forked from youen/assembly_handbook
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
271 lines
12 KiB
271 lines
12 KiB
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())
|
|
|