assembly_handbook/ahb_cmd_view_annotate.py

import FreeCADGui as Gui
import FreeCAD as App
import numpy as np
from pickle import NONE

class AHB_View_Annotate:
    updating_balloon = False
    
    def GetResources(self):
        return {"MenuText": "View/Annotate",
                "ToolTip": "Annotates a TechDraw view with object names",
                "Pixmap": ""
                }

    def IsActive(self):
        return True

    def Activated(self):
        workbench = Gui.getWorkbench("AssemblyHandbookWorkbench")
        workbench.docObserver.onObjectTypeChanged('view_annotate_balloon_changed', 'TechDraw::DrawViewBalloon', lambda obj, prop: self.onBalloonChanged(obj, prop))
        workbench.docObserver.onObjectTypeSelected('view_annotate_balloon_selected', 'TechDraw::DrawViewBalloon', lambda operation, obj, sub, point: self.onBalloonSelected(operation, obj, sub, point))
        
        doc = App.activeDocument()

        if len(Gui.Selection.getSelection()) != 1:
            raise Exception("Please select exactly one TechDraw view")

        view = Gui.Selection.getSelection()[0]
        if view.TypeId != 'TechDraw::DrawViewPart':
            raise Exception("Selected object is not a TechDraw view")
        
        page = self.getViewPage(view)
        if page is None:
            raise Exception("Can't find page in which the selected view is located")
        
        # Remove balloons referencing missing objects
        for balloon in page.Views:
            if balloon.TypeId == 'TechDraw::DrawViewBalloon' and "AssemblyHandbook_PartName" in balloon.PropertiesList:
                if balloon.SourceView != view: continue
                partLink = doc.getObject(balloon.AssemblyHandbook_PartName)
                if partLink is None or partLink not in view.XSource:
                    print(balloon.Name + " references missing object " + balloon.AssemblyHandbook_PartName + ", removing balloon")
                    doc.removeObject(balloon.Name)
        
        for partLink in view.XSource:
            balloon = None
            
            # Search an existing balloon to update
            for obj in page.Views:
                if obj.TypeId == 'TechDraw::DrawViewBalloon' and "AssemblyHandbook_PartName" in obj.PropertiesList and obj.AssemblyHandbook_PartName == partLink.Name:
                    if obj.SourceView != view: continue
                    balloon = obj
            
            # Create a new balloon if needed
            if balloon is None:
                balloon = App.ActiveDocument.addObject("TechDraw::DrawViewBalloon", "Balloon")
                balloon.SourceView = view
                
                balloon.addProperty("App::PropertyString", "AssemblyHandbook_PartName", "AssemblyHandbook")
                balloon.AssemblyHandbook_PartName = partLink.Name
                
                page.addView(balloon)
                
                self.updateBalloon(balloon)
                
                balloon.X = int(balloon.OriginX) + 20
                balloon.Y = int(balloon.OriginY) + 20
            else:
                self.updateBalloon(balloon)
    
    def onBalloonChanged(self, obj, prop):
        # Avoid reentry
        if self.updating_balloon:
            return
        
        #print('Balloon changed: ' + obj.Name + '.' + prop)
        if prop == 'Y' and "AssemblyHandbook_PartName" in obj.PropertiesList:
            self.updating_balloon = True
            self.updateBalloon(obj)
            self.updating_balloon = False
            
    def onBalloonSelected(self, operation, balloon, sub, point):
        import time
        
        #print(operation, obj.Name, sub, point)
        if "AssemblyHandbook_PartName" in balloon.PropertiesList:
            if operation == 'added':
                print("Selected balloon of " + balloon.AssemblyHandbook_PartName)
                
                doc = balloon.Document
                view = balloon.SourceView
                page = self.getViewPage(view)
                
                partLink = doc.getObject(balloon.AssemblyHandbook_PartName)
                
                cache_edges_start_time = time.perf_counter()
                
                # create temporary view of part
                tmpView = None
                for v in page.Views:
                    if v.TypeId == 'TechDraw::DrawViewPart' and len(v.XSource) == 1 and v.XSource[0] == partLink:
                        tmpView = v
                if tmpView is None:
                    keepUpdated = page.KeepUpdated
                    page.KeepUpdated = True
                    tmpView = doc.addObject("TechDraw::DrawViewPart", "View")
                    tmpView.Direction = view.Direction
                    tmpView.XDirection = view.XDirection
                    tmpView.ScaleType = 'Custom'
                    tmpView.Scale = 1.0
                    tmpView.XSource = partLink
                    page.addView(tmpView)
                    tmpView.recompute()
                    page.KeepUpdated = keepUpdated
                    
                cache_edges_end_render_time = time.perf_counter()
                    
                #tmpView.clearCosmeticEdges()
                #tmpView.recompute()
                
                # copy edges relative to center
                # TODO: in-memory cache
                tmpCenter = self.computePartCenter(tmpView, partLink)
                #print('tmpCenter', tmpCenter)
                tmpEdges = tmpView.getVisibleEdges()
                # count lines
                numLines = 0
                for edge in tmpEdges:
                    if not hasattr(edge.Curve, 'Degree') or edge.Curve.Degree == 1: numLines += 1
                # store all lines in a packed array of floats (for each line: X1, Y1, X2, Y2)
                cachedLines = np.empty([numLines, 4])
                lineIdx = 0
                for edge in tmpEdges:
                    degree = 1
                    try:
                        degree = edge.Curve.Degree
                    except:
                        pass
                    if degree == 1:
                        #print('tmpEdge', edge.Vertexes[0].Point.x, edge.Vertexes[0].Point.y, edge.Vertexes[1].Point.x, edge.Vertexes[1].Point.y)
                        sx = 1.0
                        sy = -1.0
                        cachedLines[lineIdx] = [
                            edge.Vertexes[0].Point.x*sx - tmpCenter.x,
                            edge.Vertexes[0].Point.y*sy - tmpCenter.y,
                            edge.Vertexes[1].Point.x*sx - tmpCenter.x,
                            edge.Vertexes[1].Point.y*sy - tmpCenter.y
                        ]
                        
                        #print('tmpLine', cachedLines[lineIdx])
                        
                        lineIdx = lineIdx + 1
                        
                cache_edges_end_time = time.perf_counter()
                        
                '''tmpView.makeCosmeticLine(tmpCenter - App.Vector(0,3), tmpCenter + App.Vector(0,3))
                tmpView.makeCosmeticLine(tmpCenter - App.Vector(3,0), tmpCenter + App.Vector(3,0))
                drawCenter = tmpCenter + App.Vector(-1,0)
                for line in cachedLines:
                    p0 = drawCenter + App.Vector(line[0], line[1])
                    p1 = drawCenter + App.Vector(line[2], line[3])
                    tmpView.makeCosmeticLine(p0, p1)
                tmpView.recompute()'''
                
                # delete temporary view
                doc.removeObject(tmpView.Name)
                
                #view.clearCosmeticEdges()
                #view.recompute()
                
                update_final_edges_start_time = time.perf_counter()
                
                # iterate edges of actual view and highlight matching edges
                center = self.computePartCenter(view, partLink)
                #print('center', center)
                for edgeIdx in range(1000):
                    hasEdge = False
                    try:
                        edge = view.getEdgeByIndex(edgeIdx)
                        hasEdge = True
                    except:
                        pass
                    if not hasEdge:
                        break
                    
                    view.formatGeometricEdge(edgeIdx,1,0.25,0,True)
                    
                    degree = 1
                    try:
                        degree = edge.Curve.Degree
                    except:
                        pass
                    
                    if degree == 1:
                        #print('edge', edge.Vertexes[0].X, edge.Vertexes[0].Y, edge.Vertexes[1].X, edge.Vertexes[1].Y)
                        sx = 1
                        sy = 1
                        edgeData = [
                            (edge.Vertexes[0].X - center.x)*sx,
                            (edge.Vertexes[0].Y - center.y)*sy,
                            (edge.Vertexes[1].X - center.x)*sx,
                            (edge.Vertexes[1].Y - center.y)*sy
                        ]
                        v0 = App.Vector(edgeData[0], edgeData[1])
                        v1 = App.Vector(edgeData[2], edgeData[3])
                        #print(edgeData)
                        for line in cachedLines:
                            l0 = App.Vector(line[0], line[1])
                            l1 = App.Vector(line[2], line[3])
                            #d = abs(edgeData[0] - line[0]) + abs(edgeData[1] - line[1]) + abs(edgeData[2] - line[2]) + abs(edgeData[3] - line[3])
                            d = v0.distanceToLineSegment(l0, l1).Length + v1.distanceToLineSegment(l0, l1).Length
                            if d < 0.001:
                                view.formatGeometricEdge(edgeIdx,1,0.25,(0,0.85,0),True)
                                
                update_final_edges_end_time = time.perf_counter()
                
                print("Part render time: " + str(round((cache_edges_end_render_time - cache_edges_start_time) * 1000) / 1000) + "s")
                print("Part read time: " + str(round((cache_edges_end_time - cache_edges_end_render_time) * 1000) / 1000) + "s")
                print("Update view time: " + str(round((update_final_edges_end_time - update_final_edges_start_time) * 1000) / 1000) + "s")
                
                '''view.makeCosmeticLine(center - App.Vector(0,3), center + App.Vector(0,3))
                view.makeCosmeticLine(center - App.Vector(3,0), center + App.Vector(3,0))
                drawCenter = center + App.Vector(1,0)
                for line in cachedLines:
                    p0 = drawCenter + App.Vector(line[0], line[1])
                    p1 = drawCenter + App.Vector(line[2], line[3])
                    view.makeCosmeticLine(p0, p1)'''
                    
                #view.recompute()
                
            elif operation == 'removed':
                print("Deselected balloon of " + balloon.AssemblyHandbook_PartName)
    
    def updateBalloon(self, balloon):
        doc = App.activeDocument()
        view = balloon.SourceView
        obj = doc.getObject(balloon.AssemblyHandbook_PartName)
        
        objectCenterView = self.computePartCenter(view, obj)
        
        balloon.OriginX = objectCenterView.x
        balloon.OriginY = objectCenterView.y
        
        balloon.Text = obj.LinkedObject.Document.Name if obj.TypeId == 'App::Link' else obj.Name
        balloon.ViewObject.Font = 'DejaVu Sans'
        balloon.ViewObject.Fontsize = 4
        balloon.BubbleShape = 'Inspection'
        balloon.EndTypeScale = 4
        
    def getViewPage(self, view):
        for obj in view.InList:
            if obj.TypeId == 'TechDraw::DrawPage':
                if view in obj.Views:
                    return  obj
        return None
    
    def computePartCenter(self, view, obj):
        if obj.TypeId == 'App::Link':
            partLink = obj
            objectCenterWorld = partLink.LinkPlacement.Matrix.multiply(partLink.LinkedObject.Shape.CenterOfGravity)
        else:
            objectCenterWorld = obj.Shape.CenterOfGravity
        
        vertId = view.makeCosmeticVertex3d(objectCenterWorld)
        vert = view.getCosmeticVertex(vertId)
        objectCenterView = vert.Point
        view.removeCosmeticVertex(vertId)
        return objectCenterView

from ahb_command import AHB_CommandWrapper
AHB_CommandWrapper.addGuiCommand('AHB_view_annotate', AHB_View_Annotate())