# *************************************************************************** # * Copyright (c) 2009, 2010 Yorik van Havre * # * Copyright (c) 2009, 2010 Ken Cline * # * Copyright (c) 2020 Eliud Cabrera Castillo * # * Copyright (c) 2022 FreeCAD Project Association * # * * # * This file is part of the FreeCAD CAx development system. * # * * # * This program is free software; you can redistribute it and/or modify * # * it under the terms of the GNU Lesser General Public License (LGPL) * # * as published by the Free Software Foundation; either version 2 of * # * the License, or (at your option) any later version. * # * for detail see the LICENCE text file. * # * * # * FreeCAD is distributed in the hope that it will be useful, * # * but WITHOUT ANY WARRANTY; without even the implied warranty of * # * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * # * GNU Library General Public License for more details. * # * * # * You should have received a copy of the GNU Library General Public * # * License along with FreeCAD; if not, write to the Free Software * # * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * # * USA * # * * # *************************************************************************** """Provides the viewprovider code for the Dimension objects. These include linear dimensions, including radius and diameter, as well as angular dimensions. They inherit their behavior from the base Annotation viewprovider. """ ## @package view_dimension # \ingroup draftviewproviders # \brief Provides the viewprovider code for the Dimension objects. import math import pivy.coin as coin import lazy_loader.lazy_loader as lz from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD as App import DraftVecUtils import draftutils.units as units import draftutils.utils as utils import draftutils.gui_utils as gui_utils from draftviewproviders.view_draft_annotation \ import ViewProviderDraftAnnotation # Delay import of module until first use because it is heavy Part = lz.LazyLoader("Part", globals(), "Part") DraftGeomUtils = lz.LazyLoader("DraftGeomUtils", globals(), "DraftGeomUtils") ## \addtogroup draftviewproviders # @{ class ViewProviderDimensionBase(ViewProviderDraftAnnotation): """The base viewprovider for the Draft Dimensions object. This class is not used directly, but inherited by dimension viewproviders like linear, radial, and angular. Dimension nomeclature --------------------- The dimension object depends on various variables to draw the lines that are drawn on 3D view. :: | txt | e ----b---------a----------------------b---- | | | | d | | c (t) (t) c From the object class * `a`, `Dimline`, point through which the dimension line goes through From the viewprovider class * `b`, `ArrowType` and `ArrowSize`, the symbol shown on the endpoints * `c`, `DimOvershoot`, extension to the dimension line going through `a` * `d`, `ExtLines`, distance to target `(t)` * `e`, `ExtOvershoot`, extension in the opposite direction to `(t)` * `txt`, text label showing the value of the measurement Coin object structure --------------------- The scenegraph is set from two main nodes. :: vobj.node_wld.linecolor .drawstyle .lineswitch_wld.coords .line .marks .marksDimOvershoot .marksExtOvershoot .label_wld.textpos .textcolor .font .text_wld vobj.node_scr.linecolor .drawstyle .lineswitch_scr.coords .line .marks .marksDimOvershoot .marksExtOvershoot .label_scr.textpos .textcolor .font .text_scr """ def set_text_properties(self, vobj, properties): """Set text properties only if they don't already exist.""" super().set_text_properties(vobj, properties) if "TextSpacing" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Spacing between text and dimension line") vobj.addProperty("App::PropertyLength", "TextSpacing", "Text", _tip) vobj.TextSpacing = utils.get_param("dimspacing", 1) if "FlipText" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Rotate the dimension text 180 degrees") vobj.addProperty("App::PropertyBool", "FlipText", "Text", _tip) vobj.FlipText = False if "TextPosition" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Text Position.\n" "Leave '(0,0,0)' for automatic position") vobj.addProperty("App::PropertyVectorDistance", "TextPosition", "Text", _tip) vobj.TextPosition = App.Vector(0, 0, 0) if "Override" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Text override.\n" "Write '$dim' so that it is replaced by " "the dimension length.") vobj.addProperty("App::PropertyString", "Override", "Text", _tip) vobj.Override = '' def set_units_properties(self, vobj, properties): """Set unit properties only if they don't already exist.""" super().set_units_properties(vobj, properties) if "Decimals" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "The number of decimals to show") vobj.addProperty("App::PropertyInteger", "Decimals", "Units", _tip) vobj.Decimals = utils.get_param("dimPrecision", 2) if "ShowUnit" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Show the unit suffix") vobj.addProperty("App::PropertyBool", "ShowUnit", "Units", _tip) vobj.ShowUnit = utils.get_param("showUnit", True) if "UnitOverride" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "A unit to express the measurement.\n" "Leave blank for system default.\n" "Use 'arch' to force US arch notation") vobj.addProperty("App::PropertyString", "UnitOverride", "Units", _tip) vobj.UnitOverride = utils.get_param("overrideUnit", '') def set_graphics_properties(self, vobj, properties): """Set graphics properties only if they don't already exist.""" super().set_graphics_properties(vobj, properties) if "ArrowSize" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Arrow size") vobj.addProperty("App::PropertyLength", "ArrowSize", "Graphics", _tip) vobj.ArrowSize = utils.get_param("arrowsize", 1) if "ArrowType" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Arrow type") vobj.addProperty("App::PropertyEnumeration", "ArrowType", "Graphics", _tip) vobj.ArrowType = utils.ARROW_TYPES vobj.ArrowType = utils.ARROW_TYPES[utils.get_param("dimsymbol", 0)] if "FlipArrows" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Rotate the dimension arrows 180 degrees") vobj.addProperty("App::PropertyBool", "FlipArrows", "Graphics", _tip) vobj.FlipArrows = False if "DimOvershoot" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "The distance the dimension line " "is extended\n" "past the extension lines") vobj.addProperty("App::PropertyDistance", "DimOvershoot", "Graphics", _tip) vobj.DimOvershoot = utils.get_param("dimovershoot", 0) if "ExtLines" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Length of the extension lines") vobj.addProperty("App::PropertyDistance", "ExtLines", "Graphics", _tip) vobj.ExtLines = utils.get_param("extlines", 0.3) if "ExtOvershoot" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Length of the extension line\n" "beyond the dimension line") vobj.addProperty("App::PropertyDistance", "ExtOvershoot", "Graphics", _tip) vobj.ExtOvershoot = utils.get_param("extovershoot", 0) if "ShowLine" not in properties: _tip = QT_TRANSLATE_NOOP("App::Property", "Shows the dimension line and arrows") vobj.addProperty("App::PropertyBool", "ShowLine", "Graphics", _tip) vobj.ShowLine = True def getDefaultDisplayMode(self): """Return the default display mode.""" return ["World", "Screen"][utils.get_param("dimstyle", 0)] def getIcon(self): """Return the path to the icon used by the viewprovider.""" return ":/icons/Draft_Dimension_Tree.svg" class ViewProviderLinearDimension(ViewProviderDimensionBase): """The viewprovider for the Linear Dimension objects. This includes straight edge measurement, as well as measurement of circular edges, and circumferences. """ def attach(self, vobj): """Set up the scene sub-graph of the viewprovider.""" self.Object = vobj.Object self.textpos = coin.SoTransform() self.textcolor = coin.SoBaseColor() self.font = coin.SoFont() self.text_wld = coin.SoAsciiText() # World orientation. Can be oriented in 3D space. self.text_scr = coin.SoText2() # Screen orientation. Always faces the camera. # The text string needs to be initialized to something, # otherwise it may cause a crash of the system self.text_wld.string = "d" self.text_scr.string = "d" self.text_wld.justification = coin.SoAsciiText.CENTER self.text_scr.justification = coin.SoAsciiText.CENTER label_wld = coin.SoSeparator() label_wld.addChild(self.textpos) label_wld.addChild(self.textcolor) label_wld.addChild(self.font) label_wld.addChild(self.text_wld) label_scr = coin.SoSeparator() label_scr.addChild(self.textpos) label_scr.addChild(self.textcolor) label_scr.addChild(self.font) label_scr.addChild(self.text_scr) self.coord1 = coin.SoCoordinate3() self.trans1 = coin.SoTransform() self.coord2 = coin.SoCoordinate3() self.trans2 = coin.SoTransform() self.transDimOvershoot1 = coin.SoTransform() self.transDimOvershoot2 = coin.SoTransform() self.transExtOvershoot1 = coin.SoTransform() self.transExtOvershoot2 = coin.SoTransform() self.linecolor = coin.SoBaseColor() self.drawstyle = coin.SoDrawStyle() self.coords = coin.SoCoordinate3() import PartGui # Required for "SoBrepEdgeSet" (because a dimension is not a Part::FeaturePython object). self.line = coin.SoType.fromName("SoBrepEdgeSet").createInstance() self.marks = coin.SoSeparator() self.marksDimOvershoot = coin.SoSeparator() self.marksExtOvershoot = coin.SoSeparator() self.node_wld = coin.SoGroup() self.node_wld.addChild(self.linecolor) self.node_wld.addChild(self.drawstyle) self.lineswitch_wld = coin.SoSwitch() self.lineswitch_wld.whichChild = -3 self.node_wld.addChild(self.lineswitch_wld) self.lineswitch_wld.addChild(self.coords) self.lineswitch_wld.addChild(self.line) self.lineswitch_wld.addChild(self.marks) self.lineswitch_wld.addChild(self.marksDimOvershoot) self.lineswitch_wld.addChild(self.marksExtOvershoot) self.node_wld.addChild(label_wld) self.node_scr = coin.SoGroup() self.node_scr.addChild(self.linecolor) self.node_scr.addChild(self.drawstyle) self.lineswitch_scr = coin.SoSwitch() self.lineswitch_scr.whichChild = -3 self.node_scr.addChild(self.lineswitch_scr) self.lineswitch_scr.addChild(self.coords) self.lineswitch_scr.addChild(self.line) self.lineswitch_scr.addChild(self.marks) self.lineswitch_scr.addChild(self.marksDimOvershoot) self.lineswitch_scr.addChild(self.marksExtOvershoot) self.node_scr.addChild(label_scr) vobj.addDisplayMode(self.node_wld, "World") vobj.addDisplayMode(self.node_scr, "Screen") self.updateData(vobj.Object, "Start") self.onChanged(vobj, "FontSize") self.onChanged(vobj, "FontName") self.onChanged(vobj, "TextColor") self.onChanged(vobj, "ArrowType") self.onChanged(vobj, "LineColor") self.onChanged(vobj, "DimOvershoot") self.onChanged(vobj, "ExtOvershoot") def updateData(self, obj, prop): """Execute when a property from the Proxy class is changed. It only runs if `Start`, `End`, `Dimline`, or `Direction` changed. """ if prop not in ("Start", "End", "Dimline", "Direction"): return if obj.Start == obj.End: return if not hasattr(self, "node_wld"): return vobj = obj.ViewObject # Calculate the 4 points # # | d | # ---p2-------------c----p3---- c # | | # | | # p1 p4 # # - `c` is the `Dimline`, a point that lies on the dimension line # or on its extension. # - The line itself between `p2` to `p3` is the `base`. # - The distance between `p2` (`base`) to `p1` is `proj`, an extension # line from the dimension to the measured object. # - If the `proj` distance is zero, `p1` and `p2` are the same point, # and same with `p3` and `p4`. # self.p1 = obj.Start self.p4 = obj.End base = None if (hasattr(obj, "Direction") and not DraftVecUtils.isNull(obj.Direction)): v2 = self.p1 - obj.Dimline v3 = self.p4 - obj.Dimline v2 = DraftVecUtils.project(v2, obj.Direction) v3 = DraftVecUtils.project(v3, obj.Direction) self.p2 = obj.Dimline + v2 self.p3 = obj.Dimline + v3 if DraftVecUtils.equals(self.p2, self.p3): base = None proj = None else: base = Part.LineSegment(self.p2, self.p3).toShape() proj = DraftGeomUtils.findDistance(self.p1, base) if proj: proj = proj.negative() if not base: if DraftVecUtils.equals(self.p1, self.p4): base = None proj = None else: base = Part.LineSegment(self.p1, self.p4).toShape() proj = DraftGeomUtils.findDistance(obj.Dimline, base) if proj: self.p2 = self.p1 + proj.negative() self.p3 = self.p4 + proj.negative() else: self.p2 = self.p1 self.p3 = self.p4 if proj: if hasattr(vobj, "ExtLines") and hasattr(vobj, "ScaleMultiplier"): # The scale multiplier also affects the value # of the extension line; this makes sure a maximum length # is used if the calculated value is larger than it. dmax = vobj.ExtLines.Value * vobj.ScaleMultiplier if dmax and proj.Length > dmax: if dmax > 0: self.p1 = self.p2 + DraftVecUtils.scaleTo(proj, dmax) self.p4 = self.p3 + DraftVecUtils.scaleTo(proj, dmax) else: rest = proj.Length + dmax self.p1 = self.p2 + DraftVecUtils.scaleTo(proj, rest) self.p4 = self.p3 + DraftVecUtils.scaleTo(proj, rest) else: proj = (self.p3 - self.p2).cross(App.Vector(0, 0, 1)) # Calculate the arrow positions p2 = (self.p2.x, self.p2.y, self.p2.z) p3 = (self.p3.x, self.p3.y, self.p3.z) self.trans1.translation.setValue(p2) self.coord1.point.setValue(p2) self.trans2.translation.setValue(p3) self.coord2.point.setValue(p3) # Calculate dimension and extension lines overshoots positions self.transDimOvershoot1.translation.setValue(p2) self.transDimOvershoot2.translation.setValue(p3) self.transExtOvershoot1.translation.setValue(p2) self.transExtOvershoot2.translation.setValue(p3) # Determine the orientation of the text by using a normal direction. # By default the value of +Z will be used, or a calculated value # from p2 and p3. So the text will lie on the XY plane # or a plane coplanar with p2 and p3. u = self.p3 - self.p2 u.normalize() if proj: _norm = u.cross(proj) norm = _norm.negative() else: norm = App.Vector(0, 0, 1) # If `Normal` exists and is different from the default `(0,0,0)`, # it will be used. if hasattr(obj, "Normal") and not DraftVecUtils.isNull(obj.Normal): norm = App.Vector(obj.Normal) if not DraftVecUtils.isNull(norm): norm.normalize() # Calculate the position of the arrows and extension lines v1 = norm.cross(u) _plane_rot = DraftVecUtils.getPlaneRotation(u, v1, norm) if _plane_rot is not None: rot1 = App.Placement(_plane_rot).Rotation.Q self.transDimOvershoot1.rotation.setValue((rot1[0], rot1[1], rot1[2], rot1[3])) self.transDimOvershoot2.rotation.setValue((rot1[0], rot1[1], rot1[2], rot1[3])) self.trot = rot1 else: self.trot = (0, 0, 0, 1) if hasattr(vobj, "FlipArrows") and vobj.FlipArrows: u = u.negative() v2 = norm.cross(u) _plane_rot = DraftVecUtils.getPlaneRotation(u, v2) if _plane_rot is not None: rot2 = App.Placement(_plane_rot).Rotation.Q self.trans1.rotation.setValue((rot2[0], rot2[1], rot2[2], rot2[3])) self.trans2.rotation.setValue((rot2[0], rot2[1], rot2[2], rot2[3])) if self.p1 != self.p2: u3 = self.p1 - self.p2 u3.normalize() v3 = norm.cross(u3) _plane_rot = DraftVecUtils.getPlaneRotation(u3, v3) if _plane_rot is not None: rot3 = App.Placement(_plane_rot).Rotation.Q self.transExtOvershoot1.rotation.setValue((rot3[0], rot3[1], rot3[2], rot3[3])) self.transExtOvershoot2.rotation.setValue((rot3[0], rot3[1], rot3[2], rot3[3])) # Offset is the distance from the dimension line to the textual # element that displays the value of the measurement if hasattr(vobj, "TextSpacing") and hasattr(vobj, "ScaleMultiplier"): ts = vobj.TextSpacing.Value * vobj.ScaleMultiplier offset = DraftVecUtils.scaleTo(v1, ts) else: offset = DraftVecUtils.scaleTo(v1, 0.05) if hasattr(vobj, "FlipText") and vobj.FlipText: _rott = App.Rotation(self.trot[0], self.trot[1], self.trot[2], self.trot[3]) self.trot = _rott.multiply(App.Rotation(App.Vector(0, 0, 1), 180)).Q offset = offset.negative() # On first run the `DisplayMode` enumeration is not set, so we trap # the exception and set the display mode using the value # in the parameter database try: m = vobj.DisplayMode except AssertionError: m = ["World", "Screen"][utils.get_param("dimstyle", 0)] if m == "Screen": offset = offset.negative() # The position of the text element in the dimension is provided # in absolute coordinates by the value of `TextPosition`, # if it is different from the default `(0,0,0)` if (hasattr(vobj, "TextPosition") and not DraftVecUtils.isNull(vobj.TextPosition)): self.tbase = vobj.TextPosition else: # Otherwise the position is calculated from the end points # of the dimension line, and the offset that depends # on `TextSpacing` center = self.p2 + (self.p3 - self.p2).multiply(0.5) self.tbase = center + offset self.textpos.translation.setValue([self.tbase.x, self.tbase.y, self.tbase.z]) self.textpos.rotation = coin.SbRotation(self.trot[0], self.trot[1], self.trot[2], self.trot[3]) show_unit = True if hasattr(vobj, "ShowUnit"): show_unit = vobj.ShowUnit # Set text element showing the value of the dimension length = (self.p3 - self.p2).Length unit = None if hasattr(vobj, "UnitOverride"): unit = vobj.UnitOverride # Special representation if we use 'Building US' scheme u_params = App.ParamGet("User parameter:BaseApp/Preferences/Units") if u_params.GetInt("UserSchema", 0) == 5: s = App.Units.Quantity(length, App.Units.Length).UserString self.string = s.replace("' ", "'- ") # feet self.string = s.replace("+", " ") elif hasattr(vobj, "Decimals"): self.string = units.display_external(length, vobj.Decimals, 'Length', show_unit, unit) else: self.string = units.display_external(length, None, 'Length', show_unit, unit) if hasattr(vobj, "Override") and vobj.Override: self.string = vobj.Override.replace("$dim", self.string) self.text_wld.string = utils.string_encode_coin(self.string) self.text_scr.string = utils.string_encode_coin(self.string) # Set the lines if m == "Screen": # Calculate the spacing of the text textsize = len(self.string) * vobj.FontSize.Value / 4.0 spacing = (self.p3 - self.p2).Length/2.0 - textsize self.p2a = self.p2 + DraftVecUtils.scaleTo(self.p3 - self.p2, spacing) self.p2b = self.p3 + DraftVecUtils.scaleTo(self.p2 - self.p3, spacing) self.coords.point.setValues([[self.p1.x, self.p1.y, self.p1.z], [self.p2.x, self.p2.y, self.p2.z], [self.p2a.x, self.p2a.y, self.p2a.z], [self.p2b.x, self.p2b.y, self.p2b.z], [self.p3.x, self.p3.y, self.p3.z], [self.p4.x, self.p4.y, self.p4.z]]) # self.line.numVertices.setValues([3, 3]) self.line.coordIndex.setValues(0, 7, (0, 1, 2, -1, 3, 4, 5)) else: self.coords.point.setValues([[self.p1.x, self.p1.y, self.p1.z], [self.p2.x, self.p2.y, self.p2.z], [self.p3.x, self.p3.y, self.p3.z], [self.p4.x, self.p4.y, self.p4.z]]) # self.line.numVertices.setValue(4) self.line.coordIndex.setValues(0, 4, (0, 1, 2, 3)) def onChanged(self, vobj, prop): """Execute when a view property is changed.""" super().onChanged(vobj, prop) obj = vobj.Object properties = vobj.PropertiesList if prop == "ScaleMultiplier" and "ScaleMultiplier" in properties: # Update all dimension values if hasattr(self, "font"): self.font.size = vobj.FontSize.Value * vobj.ScaleMultiplier if (hasattr(self, "node_wld") and hasattr(self, "p2") and "ArrowSize" in properties): self.remove_dim_arrows() self.draw_dim_arrows(vobj) if "DimOvershoot" in properties: self.remove_dim_overshoot() self.draw_dim_overshoot(vobj) if "ExtOvershoot" in properties: self.remove_ext_overshoot() self.draw_ext_overshoot(vobj) self.updateData(obj, "Start") elif (prop == "FontSize" and "FontSize" in properties and "ScaleMultiplier" in properties): if hasattr(self, "font"): self.font.size = vobj.FontSize.Value * vobj.ScaleMultiplier elif (prop == "FontName" and "FontName" in properties and hasattr(self, "font")): self.font.name = str(vobj.FontName) elif (prop == "TextColor" and "TextColor" in properties and hasattr(self, "textcolor")): col = vobj.TextColor self.textcolor.rgb.setValue(col[0], col[1], col[2]) elif (prop == "LineColor" and "LineColor" in properties and hasattr(self, "linecolor")): col = vobj.LineColor self.linecolor.rgb.setValue(col[0], col[1], col[2]) elif (prop == "LineWidth" and "LineWidth" in properties and hasattr(self, "drawstyle")): self.drawstyle.lineWidth = vobj.LineWidth elif (prop in ("ArrowSize", "ArrowType") and "ArrowSize" in properties and "ScaleMultiplier" in properties and hasattr(self, "node_wld") and hasattr(self, "p2")): self.remove_dim_arrows() self.draw_dim_arrows(vobj) elif (prop == "DimOvershoot" and "DimOvershoot" in properties and "ScaleMultiplier" in properties): self.remove_dim_overshoot() self.draw_dim_overshoot(vobj) elif (prop == "ExtOvershoot" and "ExtOvershoot" in properties and "ScaleMultiplier" in properties): self.remove_ext_overshoot() self.draw_ext_overshoot(vobj) elif prop == "ShowLine" and "ShowLine" in properties: if vobj.ShowLine: self.lineswitch_wld.whichChild = -3 self.lineswitch_scr.whichChild = -3 else: self.lineswitch_wld.whichChild = -1 self.lineswitch_scr.whichChild = -1 else: self.updateData(obj, "Start") def remove_dim_arrows(self): """Remove dimension arrows in the dimension lines. Remove the existing nodes. """ self.node_wld.removeChild(self.marks) self.node_scr.removeChild(self.marks) def draw_dim_arrows(self, vobj): """Draw dimension arrows.""" if not hasattr(vobj, "ArrowType"): return if self.p3.x < self.p2.x: inv = False else: inv = True # Set scale symbol = utils.ARROW_TYPES.index(vobj.ArrowType) s = vobj.ArrowSize.Value * vobj.ScaleMultiplier self.trans1.scaleFactor.setValue((s, s, s)) self.trans2.scaleFactor.setValue((s, s, s)) # Set new nodes self.marks = coin.SoSeparator() self.marks.addChild(self.linecolor) s1 = coin.SoSeparator() if symbol == "Circle": s1.addChild(self.coord1) else: s1.addChild(self.trans1) s1.addChild(gui_utils.dim_symbol(symbol, invert=not inv)) self.marks.addChild(s1) s2 = coin.SoSeparator() if symbol == "Circle": s2.addChild(self.coord2) else: s2.addChild(self.trans2) s2.addChild(gui_utils.dim_symbol(symbol, invert=inv)) self.marks.addChild(s2) self.node_wld.insertChild(self.marks, 2) self.node_scr.insertChild(self.marks, 2) def remove_dim_overshoot(self): """Remove the dimension overshoot lines.""" self.node_wld.removeChild(self.marksDimOvershoot) self.node_scr.removeChild(self.marksDimOvershoot) def draw_dim_overshoot(self, vobj): """Draw dimension overshoot lines.""" # Set scale s = vobj.DimOvershoot.Value * vobj.ScaleMultiplier self.transDimOvershoot1.scaleFactor.setValue((s, s, s)) self.transDimOvershoot2.scaleFactor.setValue((s, s, s)) # Remove existing nodes, and set new nodes self.marksDimOvershoot = coin.SoSeparator() if vobj.DimOvershoot.Value: self.marksDimOvershoot.addChild(self.linecolor) s1 = coin.SoSeparator() s1.addChild(self.transDimOvershoot1) s1.addChild(gui_utils.dimDash((-1, 0, 0), (0, 0, 0))) self.marksDimOvershoot.addChild(s1) s2 = coin.SoSeparator() s2.addChild(self.transDimOvershoot2) s2.addChild(gui_utils.dimDash((0, 0, 0), (1, 0, 0))) self.marksDimOvershoot.addChild(s2) self.node_wld.insertChild(self.marksDimOvershoot, 2) self.node_scr.insertChild(self.marksDimOvershoot, 2) def remove_ext_overshoot(self): """Remove dimension extension overshoot lines.""" self.node_wld.removeChild(self.marksExtOvershoot) self.node_scr.removeChild(self.marksExtOvershoot) def draw_ext_overshoot(self, vobj): """Draw dimension extension overshoot lines.""" # Set scale s = vobj.ExtOvershoot.Value * vobj.ScaleMultiplier self.transExtOvershoot1.scaleFactor.setValue((s, s, s)) self.transExtOvershoot2.scaleFactor.setValue((s, s, s)) # Set new nodes self.marksExtOvershoot = coin.SoSeparator() if vobj.ExtOvershoot.Value: self.marksExtOvershoot.addChild(self.linecolor) s1 = coin.SoSeparator() s1.addChild(self.transExtOvershoot1) s1.addChild(gui_utils.dimDash((0, 0, 0), (-1, 0, 0))) self.marksExtOvershoot.addChild(s1) s2 = coin.SoSeparator() s2.addChild(self.transExtOvershoot2) s2.addChild(gui_utils.dimDash((0, 0, 0), (-1, 0, 0))) self.marksExtOvershoot.addChild(s2) self.node_wld.insertChild(self.marksExtOvershoot, 2) self.node_scr.insertChild(self.marksExtOvershoot, 2) def is_linked_to_circle(self): """Return true if the dimension measures a circular edge.""" obj = self.Object if obj.LinkedGeometry and len(obj.LinkedGeometry) == 1: linked_obj = obj.LinkedGeometry[0][0] subelements = obj.LinkedGeometry[0][1] if len(subelements) == 1 and "Edge" in subelements[0]: sub = subelements[0] index = int(sub[4:]) - 1 edge = linked_obj.Shape.Edges[index] if DraftGeomUtils.geomType(edge) == "Circle": return True return False def getIcon(self): """Return the path to the icon used by the viewprovider.""" if self.is_linked_to_circle(): return ":/icons/Draft_DimensionRadius.svg" return ":/icons/Draft_Dimension_Tree.svg" # Alias for compatibility with v0.18 and earlier _ViewProviderDimension = ViewProviderLinearDimension class ViewProviderAngularDimension(ViewProviderDimensionBase): """Viewprovider for the Angular dimension object.""" def attach(self, vobj): """Set up the scene sub-graph of the viewprovider.""" self.Object = vobj.Object self.textpos = coin.SoTransform() self.textcolor = coin.SoBaseColor() self.font = coin.SoFont() self.text_wld = coin.SoAsciiText() # World orientation. Can be oriented in 3D space. self.text_scr = coin.SoText2() # Screen orientation. Always faces the camera. # The text string needs to be initialized to something, # otherwise it may cause a crash of the system self.text_wld.string = "d" self.text_scr.string = "d" self.text_wld.justification = coin.SoAsciiText.CENTER self.text_scr.justification = coin.SoAsciiText.CENTER label_wld = coin.SoSeparator() label_wld.addChild(self.textpos) label_wld.addChild(self.textcolor) label_wld.addChild(self.font) label_wld.addChild(self.text_wld) label_scr = coin.SoSeparator() label_scr.addChild(self.textpos) label_scr.addChild(self.textcolor) label_scr.addChild(self.font) label_scr.addChild(self.text_scr) self.coord1 = coin.SoCoordinate3() self.trans1 = coin.SoTransform() self.coord2 = coin.SoCoordinate3() self.trans2 = coin.SoTransform() self.linecolor = coin.SoBaseColor() self.drawstyle = coin.SoDrawStyle() self.coords = coin.SoCoordinate3() import PartGui # Required for "SoBrepEdgeSet" (because a dimension is not a Part::FeaturePython object). self.arc = coin.SoType.fromName("SoBrepEdgeSet").createInstance() self.marks = coin.SoSeparator() self.node_wld = coin.SoGroup() self.node_wld.addChild(self.linecolor) self.node_wld.addChild(self.drawstyle) self.node_wld.addChild(self.coords) self.node_wld.addChild(self.arc) self.node_wld.addChild(self.marks) self.node_wld.addChild(label_wld) self.node_scr = coin.SoGroup() self.node_scr.addChild(self.linecolor) self.node_scr.addChild(self.drawstyle) self.node_scr.addChild(self.coords) self.node_scr.addChild(self.arc) self.node_scr.addChild(self.marks) self.node_scr.addChild(label_scr) vobj.addDisplayMode(self.node_wld, "World") vobj.addDisplayMode(self.node_scr, "Screen") self.updateData(vobj.Object, None) self.onChanged(vobj, "FontSize") self.onChanged(vobj, "FontName") self.onChanged(vobj, "TextColor") self.onChanged(vobj, "ArrowType") self.onChanged(vobj, "LineColor") def updateData(self, obj, prop): """Execute when a property from the Proxy class is changed.""" if not hasattr(self, "arc"): return arcsegs = 24 vobj = obj.ViewObject # Determine the orientation of the text by using a normal direction. # Also calculate the arc data. if DraftVecUtils.isNull(obj.Normal): norm = App.Vector(0, 0, 1) else: norm = obj.Normal radius = (obj.Dimline - obj.Center).Length self.circle = Part.makeCircle(radius, obj.Center, norm, obj.FirstAngle.Value, obj.LastAngle.Value) self.p2 = self.circle.Vertexes[0].Point self.p3 = self.circle.Vertexes[-1].Point midp = DraftGeomUtils.findMidpoint(self.circle.Edges[0]) ray = midp - obj.Center # Set text value if obj.LastAngle.Value > obj.FirstAngle.Value: angle = obj.LastAngle.Value - obj.FirstAngle.Value else: angle = (360 - obj.FirstAngle.Value) + obj.LastAngle.Value show_unit = True if hasattr(vobj, "ShowUnit"): show_unit = vobj.ShowUnit if hasattr(vobj, "Decimals"): self.string = units.display_external(angle, vobj.Decimals, 'Angle', show_unit) else: self.string = units.display_external(angle, None, 'Angle', show_unit) if vobj.Override: self.string = vobj.Override.replace("$dim", self.string) self.text_wld.string = utils.string_encode_coin(self.string) self.text_scr.string = utils.string_encode_coin(self.string) # On first run the `DisplayMode` enumeration is not set, so we trap # the exception and set the display mode using the value # in the parameter database try: m = vobj.DisplayMode except AssertionError: m = ["World", "Screen"][utils.get_param("dimstyle", 0)] # Set the arc first = self.circle.FirstParameter last = self.circle.LastParameter if m == "Screen": # Calculate the spacing of the text spacing = len(self.string) * vobj.FontSize.Value / 8.0 pts1 = [] cut = None pts2 = [] for i in range(arcsegs + 1): p = self.circle.valueAt(first + (last - first) / arcsegs * i) if (p - midp).Length <= spacing: if cut is None: cut = i else: if cut is None: pts1.append([p.x, p.y, p.z]) else: pts2.append([p.x, p.y, p.z]) self.coords.point.setValues(pts1 + pts2) pts1_num = len(pts1) pts2_num = len(pts2) i1 = pts1_num i2 = i1 + pts2_num self.arc.coordIndex.setValues(0, pts1_num + pts2_num + 1, list(range(pts1_num)) + [-1] + list(range(i1, i2))) if pts1_num >= 3 and pts2_num >= 3: self.circle1 = Part.Arc(App.Vector(pts1[0][0], pts1[0][1], pts1[0][2]), App.Vector(pts1[1][0], pts1[1][1], pts1[1][2]), App.Vector(pts1[-1][0], pts1[-1][1], pts1[-1][2])).toShape() self.circle2 = Part.Arc(App.Vector(pts2[0][0], pts2[0][1], pts2[0][2]), App.Vector(pts2[1][0], pts2[1][1], pts2[1][2]), App.Vector(pts2[-1][0], pts2[-1][1], pts2[-1][2])).toShape() else: pts = [] for i in range(arcsegs + 1): p = self.circle.valueAt(first + (last - first) / arcsegs * i) pts.append([p.x, p.y, p.z]) self.coords.point.setValues(pts) self.arc.coordIndex.setValues(0, arcsegs + 1, list(range(arcsegs + 1))) # Set the arrow coords and rotation p2 = (self.p2.x, self.p2.y, self.p2.z) p3 = (self.p3.x, self.p3.y, self.p3.z) self.trans1.translation.setValue(p2) self.coord1.point.setValue(p2) self.trans2.translation.setValue(p3) self.coord2.point.setValue(p3) # Calculate small chords to make arrows look better if vobj.ArrowSize.Value !=0 \ and hasattr(vobj, "ScaleMultiplier") \ and vobj.ScaleMultiplier != 0 \ and hasattr(vobj, "FlipArrows"): halfarrowlength = 2 * vobj.ArrowSize.Value * vobj.ScaleMultiplier arrowangle = 2 * math.asin(min(1, halfarrowlength / radius)) if vobj.FlipArrows: arrowangle = -arrowangle u1 = (self.circle.valueAt(first + arrowangle) - self.circle.valueAt(first)).normalize() u2 = (self.circle.valueAt(last) - self.circle.valueAt(last - arrowangle)).normalize() w2 = self.circle.Curve.Axis w1 = w2.negative() v1 = w1.cross(u1) v2 = w2.cross(u2) _plane_rot_1 = DraftVecUtils.getPlaneRotation(u1, v1) _plane_rot_2 = DraftVecUtils.getPlaneRotation(u2, v2) q1 = App.Placement(_plane_rot_1).Rotation.Q q2 = App.Placement(_plane_rot_2).Rotation.Q self.trans1.rotation.setValue((q1[0], q1[1], q1[2], q1[3])) self.trans2.rotation.setValue((q2[0], q2[1], q2[2], q2[3])) # Set text position and rotation self.tbase = midp if (hasattr(vobj, "TextPosition") and not DraftVecUtils.isNull(vobj.TextPosition)): self.tbase = vobj.TextPosition u3 = ray.cross(norm).normalize() v3 = norm.cross(u3) _plane_rot_3 = DraftVecUtils.getPlaneRotation(u3, v3) r = App.Placement(_plane_rot_3).Rotation offset = r.multVec(App.Vector(0, 1, 0)) if hasattr(vobj, "TextSpacing"): offset = DraftVecUtils.scaleTo(offset, vobj.TextSpacing.Value) else: offset = DraftVecUtils.scaleTo(offset, 0.05) if m == "Screen": offset = offset.negative() self.tbase = self.tbase.add(offset) q = r.Q self.textpos.translation.setValue([self.tbase.x, self.tbase.y, self.tbase.z]) self.textpos.rotation = coin.SbRotation(q[0], q[1], q[2], q[3]) # Set the angle property _round_1 = round(obj.Angle, utils.precision()) _round_2 = round(angle, utils.precision()) if _round_1 != _round_2: obj.Angle = angle def onChanged(self, vobj, prop): """Execute when a view property is changed.""" super().onChanged(vobj, prop) obj = vobj.Object properties = vobj.PropertiesList if "ScaleMultiplier" in properties and vobj.ScaleMultiplier == 0: return if prop == "ScaleMultiplier" and "ScaleMultiplier" in properties: if hasattr(self, "font"): self.font.size = vobj.FontSize.Value * vobj.ScaleMultiplier if (hasattr(self, "node_wld") and hasattr(self, "p2") and "ArrowSize" in properties): self.remove_dim_arrows() self.draw_dim_arrows(vobj) self.updateData(obj, None) elif prop == "FontSize" and "ScaleMultiplier" in properties: if hasattr(self, "font"): self.font.size = vobj.FontSize.Value * vobj.ScaleMultiplier elif (prop == "FontName" and hasattr(self, "font")): self.font.name = str(vobj.FontName) elif (prop == "TextColor" and "TextColor" in properties and hasattr(self, "textcolor")): col = vobj.TextColor self.textcolor.rgb.setValue(col[0], col[1], col[2]) elif (prop == "LineColor" and "LineColor" in properties and hasattr(self, "linecolor")): col = vobj.LineColor self.linecolor.rgb.setValue(col[0], col[1], col[2]) elif prop == "LineWidth" and hasattr(self, "drawstyle"): self.drawstyle.lineWidth = vobj.LineWidth elif (prop in ("ArrowSize", "ArrowType") and "ScaleMultiplier" in properties and hasattr(self, "node_wld") and hasattr(self, "p2")): self.updateData(obj, None) self.remove_dim_arrows() self.draw_dim_arrows(vobj) else: self.updateData(obj, None) def remove_dim_arrows(self): """Remove dimension arrows in the dimension lines. Remove the existing nodes. """ self.node_wld.removeChild(self.marks) self.node_scr.removeChild(self.marks) def draw_dim_arrows(self, vobj): """Draw dimension arrows.""" if not hasattr(vobj, "ArrowType"): return # Set scale symbol = utils.ARROW_TYPES.index(vobj.ArrowType) s = vobj.ArrowSize.Value * vobj.ScaleMultiplier self.trans1.scaleFactor.setValue((s, s, s)) self.trans2.scaleFactor.setValue((s, s, s)) # Set new nodes self.marks = coin.SoSeparator() self.marks.addChild(self.linecolor) s1 = coin.SoSeparator() if symbol == "Circle": s1.addChild(self.coord1) else: s1.addChild(self.trans1) s1.addChild(gui_utils.dim_symbol(symbol, invert=False)) self.marks.addChild(s1) s2 = coin.SoSeparator() if symbol == "Circle": s2.addChild(self.coord2) else: s2.addChild(self.trans2) s2.addChild(gui_utils.dim_symbol(symbol, invert=True)) self.marks.addChild(s2) self.node_wld.insertChild(self.marks, 2) self.node_scr.insertChild(self.marks, 2) def getIcon(self): """Return the path to the icon used by the viewprovider.""" return ":/icons/Draft_DimensionAngular.svg" # Alias for compatibility with v0.18 and earlier _ViewProviderAngularDimension = ViewProviderAngularDimension ## @}