From 998347e97f3b5d7e8de7283df437615f669a982f Mon Sep 17 00:00:00 2001 From: Markus Lampert Date: Sat, 13 Aug 2022 18:11:56 -0700 Subject: [PATCH] Started moving base classes into Path.Base module --- src/Mod/Path/CMakeLists.txt | 16 +- .../Generators/threadmilling_generator.py | 5 +- .../Base/FeedRate.py} | 12 +- .../Base/MachineState.py} | 4 +- .../PathProperty.py => Path/Base/Property.py} | 0 .../Base/PropertyBag.py} | 0 .../PathUtil.py => Path/Base/Util.py} | 2 +- src/Mod/Path/Path/Dressup/Gui/AxisMap.py | 8 +- src/Mod/Path/Path/Dressup/Gui/Dogbone.py | 42 +-- src/Mod/Path/Path/Dressup/Gui/LeadInOut.py | 3 +- src/Mod/Path/Path/Dressup/Gui/RampEntry.py | 33 +- src/Mod/Path/Path/Dressup/Gui/Tags.py | 3 +- src/Mod/Path/Path/Dressup/Gui/ZCorrect.py | 8 +- src/Mod/Path/Path/Dressup/PathBoundary.py | 25 +- src/Mod/Path/Path/Dressup/Tags.py | 125 ++++--- .../{PathScripts/PathGeom.py => Path/Geom.py} | 4 +- src/Mod/Path/Path/Op/Adaptive.py | 3 +- src/Mod/Path/Path/Op/Area.py | 5 +- src/Mod/Path/Path/Op/Base.py | 9 +- src/Mod/Path/Path/Op/Deburr.py | 5 +- src/Mod/Path/Path/Op/Drilling.py | 4 +- src/Mod/Path/Path/Op/EngraveBase.py | 9 +- src/Mod/Path/Path/Op/Gui/Base.py | 5 +- src/Mod/Path/Path/Op/Helix.py | 2 +- src/Mod/Path/Path/Op/Pocket.py | 8 +- src/Mod/Path/Path/Op/PocketShape.py | 19 +- src/Mod/Path/Path/Op/Slot.py | 3 +- src/Mod/Path/Path/Op/ThreadMilling.py | 1 - src/Mod/Path/Path/Op/Util.py | 29 +- src/Mod/Path/Path/Op/Vcarve.py | 3 +- src/Mod/Path/Path/Post/Command.py | 2 +- src/Mod/Path/Path/Post/Utils.py | 9 +- src/Mod/Path/Path/Post/scripts/dxf_post.py | 7 +- src/Mod/Path/Path/Post/scripts/grbl_post.py | 3 +- src/Mod/Path/Path/Post/scripts/marlin_post.py | 3 +- src/Mod/Path/Path/Post/scripts/opensbp_pre.py | 3 +- src/Mod/Path/Path/Post/scripts/rrf_post.py | 3 +- src/Mod/Path/Path/Tool/Bit.py | 4 +- src/Mod/Path/Path/Tool/Gui/BitEdit.py | 2 +- src/Mod/Path/Path/Tool/Gui/Controller.py | 2 +- src/Mod/Path/Path/__init__.py | 1 + .../Path/PathScripts/PathFeatureExtensions.py | 27 +- .../PathScripts/PathFeatureExtensionsGui.py | 7 +- src/Mod/Path/PathScripts/PathGui.py | 7 +- .../Path/PathScripts/PathIconViewProvider.py | 2 +- src/Mod/Path/PathScripts/PathJob.py | 2 +- src/Mod/Path/PathScripts/PathJobCmd.py | 2 +- src/Mod/Path/PathScripts/PathJobDlg.py | 2 +- src/Mod/Path/PathScripts/PathJobGui.py | 13 +- .../Path/PathScripts/PathPropertyBagGui.py | 4 +- src/Mod/Path/PathScripts/PathSanity.py | 2 +- src/Mod/Path/PathScripts/PathSetupSheet.py | 5 +- src/Mod/Path/PathScripts/PathSetupSheetGui.py | 2 +- src/Mod/Path/PathScripts/PathSimulatorGui.py | 7 +- src/Mod/Path/PathScripts/PathUtils.py | 21 +- src/Mod/Path/PathTests/PathTestUtils.py | 10 +- src/Mod/Path/PathTests/TestPathAdaptive.py | 1 - src/Mod/Path/PathTests/TestPathGeom.py | 341 +++++++++--------- src/Mod/Path/PathTests/TestPathHelpers.py | 7 +- src/Mod/Path/PathTests/TestPathOpUtil.py | 61 ++-- src/Mod/Path/PathTests/TestPathPropertyBag.py | 2 +- .../Path/PathTests/TestPathThreadMilling.py | 2 +- .../TestPathThreadMillingGenerator.py | 1 - src/Mod/Path/PathTests/TestPathUtil.py | 2 +- src/Mod/Path/PathTests/TestPathVcarve.py | 1 - src/Mod/Path/PathTests/TestPathVoronoi.py | 13 +- src/Mod/Path/Tools/toolbit-attributes.py | 4 +- 67 files changed, 474 insertions(+), 508 deletions(-) rename src/Mod/Path/{PathFeedRate.py => Path/Base/FeedRate.py} (91%) rename src/Mod/Path/{PathMachineState.py => Path/Base/MachineState.py} (97%) rename src/Mod/Path/{PathScripts/PathProperty.py => Path/Base/Property.py} (100%) rename src/Mod/Path/{PathScripts/PathPropertyBag.py => Path/Base/PropertyBag.py} (100%) rename src/Mod/Path/{PathScripts/PathUtil.py => Path/Base/Util.py} (98%) rename src/Mod/Path/{PathScripts/PathGeom.py => Path/Geom.py} (99%) diff --git a/src/Mod/Path/CMakeLists.txt b/src/Mod/Path/CMakeLists.txt index 6ac2ad6507..8aab94bb94 100644 --- a/src/Mod/Path/CMakeLists.txt +++ b/src/Mod/Path/CMakeLists.txt @@ -10,8 +10,6 @@ set(Path_Scripts Init.py PathCommands.py TestPathApp.py - PathMachineState.py - PathFeedRate.py ) if(BUILD_GUI) @@ -28,6 +26,16 @@ INSTALL( SET(PathPython_SRCS Path/__init__.py Path/Log.py + Path/Geom.py +) + +SET(PathPythonBase_SRCS + Path/Base/__init__.py + Path/Base/MachineState.py + Path/Base/FeedRate.py + Path/Base/Property.py + Path/Base/PropertyBag.py + Path/Base/Util.py ) SET(PathPythonDressup_SRCS @@ -169,7 +177,6 @@ SET(PathScripts_SRCS PathScripts/PathFeatureExtensions.py PathScripts/PathFeatureExtensionsGui.py PathScripts/PathFixture.py - PathScripts/PathGeom.py PathScripts/PathGetPoint.py PathScripts/PathGui.py PathScripts/PathGuiInit.py @@ -183,8 +190,6 @@ SET(PathScripts_SRCS PathScripts/PathPreferences.py PathScripts/PathPreferencesAdvanced.py PathScripts/PathPreferencesPathJob.py - PathScripts/PathProperty.py - PathScripts/PathPropertyBag.py PathScripts/PathPropertyBagGui.py PathScripts/PathPropertyEditor.py PathScripts/PathSanity.py @@ -197,7 +202,6 @@ SET(PathScripts_SRCS PathScripts/PathSimulatorGui.py PathScripts/PathStock.py PathScripts/PathStop.py - PathScripts/PathUtil.py PathScripts/PathUtils.py PathScripts/PathUtilsGui.py PathScripts/__init__.py diff --git a/src/Mod/Path/Generators/threadmilling_generator.py b/src/Mod/Path/Generators/threadmilling_generator.py index 83aca0e762..2fb0e7bd87 100644 --- a/src/Mod/Path/Generators/threadmilling_generator.py +++ b/src/Mod/Path/Generators/threadmilling_generator.py @@ -24,7 +24,6 @@ from __future__ import print_function import FreeCAD import Path -import PathScripts.PathGeom as PathGeom import math from PySide.QtCore import QT_TRANSLATE_NOOP @@ -152,7 +151,7 @@ def generate(center, cmd, zStart, zFinal, pitch, radius, leadInOut, elevator, st z = thread.zStart r = -radius i = 0 - while not PathGeom.isRoughly(z, thread.zFinal): + while not Path.Geom.isRoughly(z, thread.zFinal): if thread.overshoots(z): break if 0 == (i & 0x01): @@ -164,7 +163,7 @@ def generate(center, cmd, zStart, zFinal, pitch, radius, leadInOut, elevator, st i = i + 1 z = z + thread.hPitch - if PathGeom.isRoughly(z, thread.zFinal): + if Path.Geom.isRoughly(z, thread.zFinal): x = center.x y = yMin if (i & 0x01) else yMax else: diff --git a/src/Mod/Path/PathFeedRate.py b/src/Mod/Path/Path/Base/FeedRate.py similarity index 91% rename from src/Mod/Path/PathFeedRate.py rename to src/Mod/Path/Path/Base/FeedRate.py index 87f16b2eba..a95d367a37 100644 --- a/src/Mod/Path/PathFeedRate.py +++ b/src/Mod/Path/Path/Base/FeedRate.py @@ -22,10 +22,8 @@ import FreeCAD import Path -import PathMachineState -import PathScripts.PathGeom as PathGeom +import Path.Base.MachineState as PathMachineState import Part -from PathScripts.PathGeom import CmdMoveRapid, CmdMoveAll __title__ = "Feed Rate Helper Utility" __author__ = "sliptonic (Brad Collette)" @@ -69,24 +67,24 @@ def setFeedRate(commandlist, ToolController): endpoint = FreeCAD.Vector(x, y, z) if PathGeom.pointsCoincide(currentposition, endpoint): return True - return PathGeom.isVertical(Part.makeLine(currentposition, endpoint)) + return Path.Geom.isVertical(Part.makeLine(currentposition, endpoint)) machine = PathMachineState.MachineState() for command in commandlist: - if command.Name not in CmdMoveAll: + if command.Name not in Path.Geom.CmdMoveAll: continue if _isVertical(machine.getPosition(), command): rate = ( ToolController.VertRapid.Value - if command.Name in CmdMoveRapid + if command.Name in Path.Geom.CmdMoveRapid else ToolController.VertFeed.Value ) else: rate = ( ToolController.HorizRapid.Value - if command.Name in CmdMoveRapid + if command.Name in Path.Geom.CmdMoveRapid else ToolController.HorizFeed.Value ) diff --git a/src/Mod/Path/PathMachineState.py b/src/Mod/Path/Path/Base/MachineState.py similarity index 97% rename from src/Mod/Path/PathMachineState.py rename to src/Mod/Path/Path/Base/MachineState.py index 7334b1e4c7..313dce99d9 100644 --- a/src/Mod/Path/PathMachineState.py +++ b/src/Mod/Path/Path/Base/MachineState.py @@ -28,7 +28,7 @@ __contributors__ = "" import Path import FreeCAD -from PathScripts.PathGeom import CmdMoveRapid, CmdMoveAll, CmdMoveDrill +import Path if False: Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule()) @@ -92,7 +92,7 @@ class MachineState: self.WCS = command.Name return not oldstate == self.getState() - if command.Name in CmdMoveDrill: + if command.Name in Path.Geom.CmdMoveDrill: oldZ = self.Z for p in command.Parameters: self.__setattr__(p, command.Parameters[p]) diff --git a/src/Mod/Path/PathScripts/PathProperty.py b/src/Mod/Path/Path/Base/Property.py similarity index 100% rename from src/Mod/Path/PathScripts/PathProperty.py rename to src/Mod/Path/Path/Base/Property.py diff --git a/src/Mod/Path/PathScripts/PathPropertyBag.py b/src/Mod/Path/Path/Base/PropertyBag.py similarity index 100% rename from src/Mod/Path/PathScripts/PathPropertyBag.py rename to src/Mod/Path/Path/Base/PropertyBag.py diff --git a/src/Mod/Path/PathScripts/PathUtil.py b/src/Mod/Path/Path/Base/Util.py similarity index 98% rename from src/Mod/Path/PathScripts/PathUtil.py rename to src/Mod/Path/Path/Base/Util.py index 27835f4c07..291a47c340 100644 --- a/src/Mod/Path/PathScripts/PathUtil.py +++ b/src/Mod/Path/Path/Base/Util.py @@ -22,7 +22,7 @@ """ The purpose of this file is to collect some handy functions. The reason they -are not in PathUtils (and there is this confusing naming going on) is that +are not in Path.Base.Utils (and there is this confusing naming going on) is that PathUtils depends on PathJob. Which makes it impossible to use the functions and classes defined there in PathJob. diff --git a/src/Mod/Path/Path/Dressup/Gui/AxisMap.py b/src/Mod/Path/Path/Dressup/Gui/AxisMap.py index 0bded9c6e5..d2d9929f06 100644 --- a/src/Mod/Path/Path/Dressup/Gui/AxisMap.py +++ b/src/Mod/Path/Path/Dressup/Gui/AxisMap.py @@ -23,11 +23,9 @@ import FreeCAD import Path import math -import PathScripts.PathGeom as PathGeom import PathScripts.PathUtils as PathUtils import PathScripts.PathGui as PathGui from PySide.QtCore import QT_TRANSLATE_NOOP -from PathScripts.PathGeom import CmdMoveArc if False: Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule()) @@ -88,11 +86,11 @@ class ObjectDressup: currLocation = {"X": 0, "Y": 0, "Z": 0, "F": 0} for p in path: - if p.Name in CmdMoveArc: + if p.Name in Path.Geom.CmdMoveArc: curVec = FreeCAD.Vector( currLocation["X"], currLocation["Y"], currLocation["Z"] ) - arcwire = PathGeom.edgeForCmd(p, curVec) + arcwire = Path.Geom.edgeForCmd(p, curVec) pointlist = arcwire.discretize(Deflection=d) for point in pointlist: newcommand = Path.Command( @@ -117,7 +115,7 @@ class ObjectDressup: if obj.Base.Path: if obj.Base.Path.Commands: pp = obj.Base.Path.Commands - if len([i for i in pp if i.Name in CmdMoveArc]) == 0: + if len([i for i in pp if i.Name in Path.Geom.CmdMoveArc]) == 0: pathlist = pp else: pathlist = self._stripArcs(pp, d) diff --git a/src/Mod/Path/Path/Dressup/Gui/Dogbone.py b/src/Mod/Path/Path/Dressup/Gui/Dogbone.py index 1d051a5a06..8249ee6d16 100644 --- a/src/Mod/Path/Path/Dressup/Gui/Dogbone.py +++ b/src/Mod/Path/Path/Dressup/Gui/Dogbone.py @@ -26,12 +26,10 @@ from PySide import QtCore from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import Path +import Path.Base.Util as PathUtil import Path.Dressup.Utils as PathDressup -import PathScripts.PathGeom as PathGeom -import PathScripts.PathUtil as PathUtil import PathScripts.PathUtils as PathUtils import math -from PathScripts.PathGeom import CmdMoveCW, CmdMoveStraight, CmdMoveArc, CmdMoveRapid # lazily loaded modules from lazy_loader.lazy_loader import LazyLoader @@ -50,7 +48,7 @@ else: translate = FreeCAD.Qt.translate -movecommands = CmdMoveStraight + CmdMoveRapid + CmdMoveArc +movecommands = Path.Geom.CmdMoveStraight + Path.Geom.CmdMoveRapid + Path.Geom.CmdMoveArc def debugMarker(vector, label, color=None, radius=0.5): @@ -118,9 +116,9 @@ def edgesForCommands(cmds, startPt): for cmd in cmds: if cmd.Name in movecommands: pt = pointFromCommand(cmd, lastPt) - if cmd.Name in CmdMoveStraight: + if cmd.Name in Path.Geom.CmdMoveStraight: edges.append(Part.Edge(Part.LineSegment(lastPt, pt))) - elif cmd.Name in CmdMoveArc: + elif cmd.Name in Path.Geom.CmdMoveArc: center = lastPt + pointFromCommand( cmd, FreeCAD.Vector(0, 0, 0), "I", "J", "K" ) @@ -131,7 +129,7 @@ def edgesForCommands(cmds, startPt): if d == 0: # we're dealing with half a circle here angle = getAngle(A) + math.pi / 2 - if cmd.Name in CmdMoveCW: + if cmd.Name in Path.Geom.CmdMoveCW: angle -= math.pi else: C = A + B @@ -250,7 +248,7 @@ class Chord(object): A = self.asDirection() # if the 2 vectors are identical, they head in the same direction Path.Log.debug(" {}.getDirectionOfVector({})".format(A, B)) - if PathGeom.pointsCoincide(A, B): + if Path.Geom.pointsCoincide(A, B): return "Straight" d = -A.x * B.y + A.y * B.x if d < 0: @@ -306,15 +304,15 @@ class Chord(object): return self.arcCommand("G3", center, f) def isAPlungeMove(self): - return not PathGeom.isRoughly(self.End.z, self.Start.z) + return not Path.Geom.isRoughly(self.End.z, self.Start.z) def isANoopMove(self): Path.Log.debug( "{}.isANoopMove(): {}".format( - self, PathGeom.pointsCoincide(self.Start, self.End) + self, Path.Geom.pointsCoincide(self.Start, self.End) ) ) - return PathGeom.pointsCoincide(self.Start, self.End) + return Path.Geom.pointsCoincide(self.Start, self.End) def foldsBackOrTurns(self, chord, side): direction = chord.getDirectionOf(self) @@ -322,7 +320,7 @@ class Chord(object): return direction == "Back" or direction == side def connectsTo(self, chord): - return PathGeom.pointsCoincide(self.End, chord.Start) + return Path.Geom.pointsCoincide(self.End, chord.Start) class Bone(object): @@ -397,7 +395,7 @@ class Bone(object): return 0 gamma = math.asin(D) alpha = math.pi - beta - gamma - if PathGeom.isRoughly(0.0, math.sin(beta)): + if Path.Geom.isRoughly(0.0, math.sin(beta)): # it is not a good idea to divide by 0 length = 0.0 else: @@ -495,7 +493,7 @@ class ObjectDressup(object): # Answer true if a dogbone could be on either end of the chord, given its command def canAttachDogbone(self, cmd, chord): return ( - cmd.Name in CmdMoveStraight + cmd.Name in Path.Geom.CmdMoveStraight and not chord.isAPlungeMove() and not chord.isANoopMove() ) @@ -590,7 +588,7 @@ class ObjectDressup(object): % (e.Curve.Center.x, e.Curve.Center.y, e.Curve.Radius) ) for pt in DraftGeomUtils.findIntersection(edge, e, True, findAll=True): - if not PathGeom.pointsCoincide(pt, corner) and self.pointIsOnEdge( + if not Path.Geom.pointsCoincide(pt, corner) and self.pointIsOnEdge( pt, e ): # debugMarker(pt, "candidate-%d-%s" % (self.boneId, d), color, 0.05) @@ -616,7 +614,7 @@ class ObjectDressup(object): ) commands = [] - if not PathGeom.pointsCoincide(t1, inChord.Start): + if not Path.Geom.pointsCoincide(t1, inChord.Start): Path.Log.debug(" add lead in") commands.append(Chord(inChord.Start, t1).g1Command(bone.F)) if bone.obj.Side == Side.Left: @@ -628,7 +626,7 @@ class ObjectDressup(object): % (pivot.x, pivot.y, t1.x, t1.y, t2.x, t2.y) ) commands.append(Chord(t1, t2).g2Command(pivot, bone.F)) - if not PathGeom.pointsCoincide(t2, outChord.End): + if not Path.Geom.pointsCoincide(t2, outChord.End): Path.Log.debug(" add lead out") commands.append(Chord(t2, outChord.End).g1Command(bone.F)) @@ -745,7 +743,7 @@ class ObjectDressup(object): def tboneVertical(self, bone): angle = bone.angle() boneAngle = math.pi / 2 - if PathGeom.isRoughly(angle, math.pi) or angle < 0: + if Path.Geom.isRoughly(angle, math.pi) or angle < 0: boneAngle = -boneAngle return self.inOutBoneCommands(bone, boneAngle, self.toolRadius) @@ -853,9 +851,9 @@ class ObjectDressup(object): for pt in cutoff: # debugCircle(e1.Curve.Center, e1.Curve.Radius, "bone.%d-1" % (self.boneId), (1.,0.,0.)) # debugCircle(e2.Curve.Center, e2.Curve.Radius, "bone.%d-2" % (self.boneId), (0.,1.,0.)) - if PathGeom.pointsCoincide( + if Path.Geom.pointsCoincide( pt, e1.valueAt(e1.LastParameter) - ) or PathGeom.pointsCoincide(pt, e2.valueAt(e2.FirstParameter)): + ) or Path.Geom.pointsCoincide(pt, e2.valueAt(e2.FirstParameter)): continue # debugMarker(pt, "it", (0.0, 1.0, 1.0)) # 1. remove all redundant commands @@ -868,7 +866,7 @@ class ObjectDressup(object): commands.append(c1) # 3. change where c2 starts, this depends on the command itself c2 = bone2.inCommands[j] - if c2.Name in CmdMoveArc: + if c2.Name in Path.Geom.CmdMoveArc: center = e2.Curve.Center offset = center - pt c2Params = c2.Parameters @@ -1073,7 +1071,7 @@ class ObjectDressup(object): class Marker(object): def __init__(self, pt, r, h): - if PathGeom.isRoughly(h, 0): + if Path.Geom.isRoughly(h, 0): h = 0.1 self.pt = pt self.r = r diff --git a/src/Mod/Path/Path/Dressup/Gui/LeadInOut.py b/src/Mod/Path/Path/Dressup/Gui/LeadInOut.py index 5d1e181576..bdb4f2b16b 100644 --- a/src/Mod/Path/Path/Dressup/Gui/LeadInOut.py +++ b/src/Mod/Path/Path/Dressup/Gui/LeadInOut.py @@ -27,7 +27,6 @@ import FreeCAD import FreeCADGui import Path import Path.Dressup.Utils as PathDressup -import PathScripts.PathGeom as PathGeom import PathScripts.PathUtils as PathUtils import math import copy @@ -190,7 +189,7 @@ class ObjectDressup: + "\n" ) obj.Length = 0.1 - self.wire, self.rapids = PathGeom.wireForPath(obj.Base.Path) + self.wire, self.rapids = Path.Geom.wireForPath(obj.Base.Path) obj.Path = self.generateLeadInOutCurve(obj) def getDirectionOfPath(self, obj): diff --git a/src/Mod/Path/Path/Dressup/Gui/RampEntry.py b/src/Mod/Path/Path/Dressup/Gui/RampEntry.py index 80dd8a89f0..5b740bef3f 100644 --- a/src/Mod/Path/Path/Dressup/Gui/RampEntry.py +++ b/src/Mod/Path/Path/Dressup/Gui/RampEntry.py @@ -25,7 +25,6 @@ from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import Path import Path.Dressup.Utils as PathDressup -import PathScripts.PathGeom as PathGeom import math @@ -223,7 +222,7 @@ class ObjectDressup: self.angle = obj.Angle self.method = obj.Method - self.wire, self.rapids = PathGeom.wireForPath(obj.Base.Path) + self.wire, self.rapids = Path.Geom.wireForPath(obj.Base.Path) if self.method in ["RampMethod1", "RampMethod2", "RampMethod3"]: self.outedges = self.generateRamps() else: @@ -236,7 +235,7 @@ class ObjectDressup: for edge in edges: israpid = False for redge in self.rapids: - if PathGeom.edgesMatch(edge, redge): + if Path.Geom.edgesMatch(edge, redge): israpid = True if not israpid: bb = edge.BoundBox @@ -361,7 +360,7 @@ class ObjectDressup: edge = edges[i] israpid = False for redge in self.rapids: - if PathGeom.edgesMatch(edge, redge): + if Path.Geom.edgesMatch(edge, redge): israpid = True if not israpid: bb = edge.BoundBox @@ -395,7 +394,7 @@ class ObjectDressup: candidate = edges[j] cp0 = candidate.Vertexes[0].Point cp1 = candidate.Vertexes[1].Point - if PathGeom.pointsCoincide(p1, cp1): + if Path.Geom.pointsCoincide(p1, cp1): # found closed loop loopFound = True rampedges.append(candidate) @@ -413,7 +412,7 @@ class ObjectDressup: outedges.append(edge) else: outedges.extend(self.createHelix(rampedges, p0, p1)) - if not PathGeom.isRoughly(p1.z, minZ): + if not Path.Geom.isRoughly(p1.z, minZ): # the edges covered by the helix not handled again, # unless reached the bottom height i = j @@ -431,11 +430,11 @@ class ObjectDressup: p1 = edge.Vertexes[1].Point if p0.z > self.ignoreAbove and ( p1.z > self.ignoreAbove - or PathGeom.isRoughly(p1.z, self.ignoreAbove.Value) + or Path.Geom.isRoughly(p1.z, self.ignoreAbove.Value) ): Path.Log.debug("Whole plunge move above 'ignoreAbove', ignoring") return (edge, True) - elif p0.z > self.ignoreAbove and not PathGeom.isRoughly( + elif p0.z > self.ignoreAbove and not Path.Geom.isRoughly( p0.z, self.ignoreAbove.Value ): Path.Log.debug( @@ -543,7 +542,7 @@ class ObjectDressup: if redge.Length >= rampremaining: # will reach end of ramp within this edge, needs to be split p1 = self.getSplitPoint(redge, rampremaining) - splitEdge = PathGeom.splitEdgeAt(redge, p1) + splitEdge = Path.Geom.splitEdgeAt(redge, p1) Path.Log.debug("Ramp remaining: {}".format(rampremaining)) Path.Log.debug( "Got split edge (index: {}) (total len: {}) with lengths: {}, {}".format( @@ -626,7 +625,7 @@ class ObjectDressup: if redge.Length >= rampremaining: # will reach end of ramp within this edge, needs to be split p1 = self.getSplitPoint(redge, rampremaining) - splitEdge = PathGeom.splitEdgeAt(redge, p1) + splitEdge = Path.Geom.splitEdgeAt(redge, p1) Path.Log.debug( "Got split edge (index: {}) with lengths: {}, {}".format( i, splitEdge[0].Length, splitEdge[1].Length @@ -702,9 +701,9 @@ class ObjectDressup: outedges = [] rampremaining = projectionlen curPoint = p0 # start from the upper point of plunge - if PathGeom.pointsCoincide( - PathGeom.xy(p0), - PathGeom.xy(rampedges[-1].valueAt(rampedges[-1].LastParameter)), + if Path.Geom.pointsCoincide( + Path.Geom.xy(p0), + Path.Geom.xy(rampedges[-1].valueAt(rampedges[-1].LastParameter)), ): Path.Log.debug( "The ramp forms a closed wire, needless to move on original Z height" @@ -714,7 +713,7 @@ class ObjectDressup: if redge.Length >= rampremaining: # this edge needs to be split p1 = self.getSplitPoint(redge, rampremaining) - splitEdge = PathGeom.splitEdgeAt(redge, p1) + splitEdge = Path.Geom.splitEdgeAt(redge, p1) Path.Log.debug( "Got split edges with lengths: {}, {}".format( splitEdge[0].Length, splitEdge[1].Length @@ -785,13 +784,13 @@ class ObjectDressup: for edge in edges: israpid = False for redge in self.rapids: - if PathGeom.edgesMatch(edge, redge): + if Path.Geom.edgesMatch(edge, redge): israpid = True if israpid: v = edge.valueAt(edge.LastParameter) commands.append(Path.Command("G0", {"X": v.x, "Y": v.y, "Z": v.z})) else: - commands.extend(PathGeom.cmdsForEdge(edge)) + commands.extend(Path.Geom.cmdsForEdge(edge)) lastCmd = Path.Command("G0", {"X": 0.0, "Y": 0.0, "Z": 0.0}) @@ -830,7 +829,7 @@ class ObjectDressup: if cmd.Name in ["G1", "G2", "G3", "G01", "G02", "G03"]: if zVal is not None and zVal2 != zVal: - if PathGeom.isRoughly(xVal, xVal2) and PathGeom.isRoughly( + if Path.Geom.isRoughly(xVal, xVal2) and Path.Geom.isRoughly( yVal, yVal2 ): # this is a straight plunge diff --git a/src/Mod/Path/Path/Dressup/Gui/Tags.py b/src/Mod/Path/Path/Dressup/Gui/Tags.py index 284e166496..847aa0a038 100644 --- a/src/Mod/Path/Path/Dressup/Gui/Tags.py +++ b/src/Mod/Path/Path/Dressup/Gui/Tags.py @@ -28,7 +28,6 @@ import FreeCADGui import Path import Path.Dressup.Tags as PathDressupTag import PathGui as PGui # ensure Path/Gui/Resources are loaded -import PathScripts.PathGeom as PathGeom import PathScripts.PathGetPoint as PathGetPoint import PathScripts.PathPreferences as PathPreferences import PathScripts.PathUtils as PathUtils @@ -527,7 +526,7 @@ class PathDressupTagViewProvider: z = self.tags[0].point.z p = FreeCAD.Vector(x, y, z) for i, tag in enumerate(self.tags): - if PathGeom.pointsCoincide( + if Path.Geom.pointsCoincide( p, tag.point, tag.sphere.radius.getValue() * 1.3 ): return i diff --git a/src/Mod/Path/Path/Dressup/Gui/ZCorrect.py b/src/Mod/Path/Path/Dressup/Gui/ZCorrect.py index a93417fe70..15f884ecc7 100644 --- a/src/Mod/Path/Path/Dressup/Gui/ZCorrect.py +++ b/src/Mod/Path/Path/Dressup/Gui/ZCorrect.py @@ -26,12 +26,10 @@ import FreeCAD import FreeCADGui import Path -import PathScripts.PathGeom as PathGeom import PathScripts.PathUtils as PathUtils from PySide import QtGui from PySide.QtCore import QT_TRANSLATE_NOOP -from PathScripts.PathGeom import CmdMoveArc, CmdMoveStraight # lazily loaded modules from lazy_loader.lazy_loader import LazyLoader @@ -176,16 +174,16 @@ class ObjectDressup: Path.Log.debug(" curLoc:{}".format(currLocation)) newparams = dict(c.Parameters) zval = newparams.get("Z", currLocation["Z"]) - if c.Name in CmdMoveStraight + CmdMoveArc: + if c.Name in Path.Geom.CmdMoveStraight + Path.Geom.CmdMoveArc: curVec = FreeCAD.Vector( currLocation["X"], currLocation["Y"], currLocation["Z"], ) - arcwire = PathGeom.edgeForCmd(c, curVec) + arcwire = Path.Geom.edgeForCmd(c, curVec) if arcwire is None: continue - if c.Name in CmdMoveArc: + if c.Name in Path.Geom.CmdMoveArc: pointlist = arcwire.discretize(Deflection=curveD) else: disc_number = int(arcwire.Length / sampleD) diff --git a/src/Mod/Path/Path/Dressup/PathBoundary.py b/src/Mod/Path/Path/Dressup/PathBoundary.py index 00d7bb5a01..896e4a164a 100644 --- a/src/Mod/Path/Path/Dressup/PathBoundary.py +++ b/src/Mod/Path/Path/Dressup/PathBoundary.py @@ -23,10 +23,9 @@ from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import Path +import Path.Base.Util as PathUtil import Path.Dressup.Utils as PathDressup -import PathScripts.PathGeom as PathGeom import PathScripts.PathStock as PathStock -import PathScripts.PathUtil as PathUtil import PathScripts.PathUtils as PathUtils if False: @@ -127,7 +126,7 @@ class PathBoundary: def boundaryCommands(self, begin, end, verticalFeed): Path.Log.track(_vstr(begin), _vstr(end)) - if end and PathGeom.pointsCoincide(begin, end): + if end and Path.Geom.pointsCoincide(begin, end): return [] cmds = [] if begin.z < self.safeHeight: @@ -172,12 +171,12 @@ class PathBoundary: commands = [cmd] lastExit = None for cmd in self.baseOp.Path.Commands[1:]: - if cmd.Name in PathGeom.CmdMoveAll: + if cmd.Name in Path.Geom.CmdMoveAll: if bogusX: bogusX = "X" not in cmd.Parameters if bogusY: bogusY = "Y" not in cmd.Parameters - edge = PathGeom.edgeForCmd(cmd, pos) + edge = Path.Geom.edgeForCmd(cmd, pos) if edge: inside = edge.common(self.boundary).Edges outside = edge.cut(self.boundary).Edges @@ -201,25 +200,25 @@ class PathBoundary: ) lastExit = None commands.append(cmd) - pos = PathGeom.commandEndPoint(cmd, pos) + pos = Path.Geom.commandEndPoint(cmd, pos) elif 0 == len(inside) and 1 == len(outside): Path.Log.track(_vstr(pos), _vstr(lastExit), " - ", cmd) # cmd fully excluded by boundary if not lastExit: lastExit = pos - pos = PathGeom.commandEndPoint(cmd, pos) + pos = Path.Geom.commandEndPoint(cmd, pos) else: Path.Log.track( _vstr(pos), _vstr(lastExit), len(inside), len(outside), cmd ) # cmd pierces boundary while inside or outside: - ie = [e for e in inside if PathGeom.edgeConnectsTo(e, pos)] + ie = [e for e in inside if Path.Geom.edgeConnectsTo(e, pos)] Path.Log.track(ie) if ie: e = ie[0] LastPt = e.valueAt(e.LastParameter) - flip = PathGeom.pointsCoincide(pos, LastPt) + flip = Path.Geom.pointsCoincide(pos, LastPt) newPos = e.valueAt(e.FirstParameter) if flip else LastPt # inside edges are taken at this point (see swap of inside/outside # above - so we can just connect the dots ... @@ -236,7 +235,7 @@ class PathBoundary: bogusX or bogusY ): # don't insert false paths based on bogus m/c position commands.extend( - PathGeom.cmdsForEdge( + Path.Geom.cmdsForEdge( e, flip, False, @@ -252,13 +251,13 @@ class PathBoundary: oe = [ e for e in outside - if PathGeom.edgeConnectsTo(e, pos) + if Path.Geom.edgeConnectsTo(e, pos) ] Path.Log.track(oe) if oe: e = oe[0] ptL = e.valueAt(e.LastParameter) - flip = PathGeom.pointsCoincide(pos, ptL) + flip = Path.Geom.pointsCoincide(pos, ptL) newPos = ( e.valueAt(e.FirstParameter) if flip else ptL ) @@ -280,7 +279,7 @@ class PathBoundary: # Eif # Ewhile # Eif - # pos = PathGeom.commandEndPoint(cmd, pos) + # pos = Path.Geom.commandEndPoint(cmd, pos) # Eif else: Path.Log.track("no-move", cmd) diff --git a/src/Mod/Path/Path/Dressup/Tags.py b/src/Mod/Path/Path/Dressup/Tags.py index fcd1b8b1c0..bc4adec927 100644 --- a/src/Mod/Path/Path/Dressup/Tags.py +++ b/src/Mod/Path/Path/Dressup/Tags.py @@ -25,9 +25,8 @@ from PathScripts.PathUtils import waiting_effects from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import Path +import Path.Base.Util as PathUtil import Path.Dressup.Utils as PathDressup -import PathScripts.PathGeom as PathGeom -import PathScripts.PathUtil as PathUtil import PathScripts.PathUtils as PathUtils import copy import math @@ -164,7 +163,7 @@ class Tag: self.r2 = r1 height = self.height * 1.01 radius = 0 - if PathGeom.isRoughly(90, self.angle) and height > 0: + if Path.Geom.isRoughly(90, self.angle) and height > 0: # cylinder self.isSquare = True self.solid = Part.makeCylinder(r1, height) @@ -192,10 +191,10 @@ class Tag: # degenerated case - no tag Path.Log.debug("Part.makeSphere(%f / 10000)" % (r1)) self.solid = Part.makeSphere(r1 / 10000) - if not PathGeom.isRoughly( + if not Path.Geom.isRoughly( 0, R ): # testing is easier if the solid is not rotated - angle = -PathGeom.getAngle(self.originAt(0)) * 180 / math.pi + angle = -Path.Geom.getAngle(self.originAt(0)) * 180 / math.pi Path.Log.debug("solid.rotate(%f)" % angle) self.solid.rotate(FreeCAD.Vector(0, 0, 0), FreeCAD.Vector(0, 0, 1), angle) orig = self.originAt(z - 0.01 * self.actualHeight) @@ -203,7 +202,7 @@ class Tag: self.solid.translate(orig) radius = min(self.radius, radius) self.realRadius = radius - if not PathGeom.isRoughly(0, radius): + if not Path.Geom.isRoughly(0, radius): Path.Log.debug("makeFillet(%.4f)" % radius) self.solid = self.solid.makeFillet(radius, [self.solid.Edges[0]]) @@ -226,7 +225,7 @@ class Tag: pt for pt in pts if (pt - c.Center).Length <= c.Radius - or PathGeom.isRoughly((pt - c.Center).Length, c.Radius) + or Path.Geom.isRoughly((pt - c.Center).Length, c.Radius) ] ) Path.Log.error("==== we got a %s" % face.Surface) @@ -237,7 +236,7 @@ class Tag: return True if edge.LastParameter <= param <= edge.FirstParameter: return True - if PathGeom.isRoughly(edge.FirstParameter, param) or PathGeom.isRoughly( + if Path.Geom.isRoughly(edge.FirstParameter, param) or Path.Geom.isRoughly( edge.LastParameter, param ): return True @@ -265,7 +264,7 @@ class Tag: def intersects(self, edge, param): def isDefinitelySmaller(z, zRef): # Eliminate false positives of edges that just brush along the top of the tag - return z < zRef and not PathGeom.isRoughly(z, zRef, 0.01) + return z < zRef and not Path.Geom.isRoughly(z, zRef, 0.01) if self.enabled: zFirst = edge.valueAt(edge.FirstParameter).z @@ -297,20 +296,20 @@ class MapWireToTag: self.maxZ = maxZ self.hSpeed = hSpeed self.vSpeed = vSpeed - if PathGeom.pointsCoincide(edge.valueAt(edge.FirstParameter), i): + if Path.Geom.pointsCoincide(edge.valueAt(edge.FirstParameter), i): tail = edge self.commands = [] debugEdge(tail, ".........=") - elif PathGeom.pointsCoincide(edge.valueAt(edge.LastParameter), i): + elif Path.Geom.pointsCoincide(edge.valueAt(edge.LastParameter), i): debugEdge(edge, "++++++++ .") - self.commands = PathGeom.cmdsForEdge( + self.commands = Path.Geom.cmdsForEdge( edge, segm=segm, hSpeed=self.hSpeed, vSpeed=self.vSpeed ) tail = None else: - e, tail = PathGeom.splitEdgeAt(edge, i) + e, tail = Path.Geom.splitEdgeAt(edge, i) debugEdge(e, "++++++++ .") - self.commands = PathGeom.cmdsForEdge( + self.commands = Path.Geom.cmdsForEdge( e, segm=segm, hSpeed=self.hSpeed, vSpeed=self.vSpeed ) debugEdge(tail, ".........-") @@ -344,20 +343,20 @@ class MapWireToTag: self.edges.append(edge) def needToFlipEdge(self, edge, p): - if PathGeom.pointsCoincide(edge.valueAt(edge.LastParameter), p): + if Path.Geom.pointsCoincide(edge.valueAt(edge.LastParameter), p): return True, edge.valueAt(edge.FirstParameter) return False, edge.valueAt(edge.LastParameter) def isEntryOrExitStrut(self, e): p1 = e.valueAt(e.FirstParameter) p2 = e.valueAt(e.LastParameter) - if PathGeom.pointsCoincide(p1, self.entry) and p2.z >= self.entry.z: + if Path.Geom.pointsCoincide(p1, self.entry) and p2.z >= self.entry.z: return 1 - if PathGeom.pointsCoincide(p2, self.entry) and p1.z >= self.entry.z: + if Path.Geom.pointsCoincide(p2, self.entry) and p1.z >= self.entry.z: return 1 - if PathGeom.pointsCoincide(p1, self.exit) and p2.z >= self.exit.z: + if Path.Geom.pointsCoincide(p1, self.exit) and p2.z >= self.exit.z: return 2 - if PathGeom.pointsCoincide(p2, self.exit) and p1.z >= self.exit.z: + if Path.Geom.pointsCoincide(p2, self.exit) and p1.z >= self.exit.z: return 2 return 0 @@ -383,16 +382,16 @@ class MapWireToTag: self.edgePoints.append(p1) self.edgePoints.append(p2) if self.tag.solid.isInside( - p1, PathGeom.Tolerance, False - ) or self.tag.solid.isInside(p2, PathGeom.Tolerance, False): + p1, Path.Geom.Tolerance, False + ) or self.tag.solid.isInside(p2, Path.Geom.Tolerance, False): edges.remove(e) debugEdge(e, "......... X0", False) else: - if PathGeom.pointsCoincide(p1, self.entry) or PathGeom.pointsCoincide( + if Path.Geom.pointsCoincide(p1, self.entry) or Path.Geom.pointsCoincide( p2, self.entry ): self.entryEdges.append(e) - if PathGeom.pointsCoincide(p1, self.exit) or PathGeom.pointsCoincide( + if Path.Geom.pointsCoincide(p1, self.exit) or Path.Geom.pointsCoincide( p2, self.exit ): self.exitEdges.append(e) @@ -406,7 +405,7 @@ class MapWireToTag: self.edgePoints, key=lambda p: (p - self.entry).Length )[0] self.entryEdges = list( - [e for e in edges if PathGeom.edgeConnectsTo(e, self.realEntry)] + [e for e in edges if Path.Geom.edgeConnectsTo(e, self.realEntry)] ) edges.append(Part.Edge(Part.LineSegment(self.entry, self.realEntry))) else: @@ -417,7 +416,7 @@ class MapWireToTag: self.edgePoints, key=lambda p: (p - self.exit).Length )[0] self.exitEdges = list( - [e for e in edges if PathGeom.edgeConnectsTo(e, self.realExit)] + [e for e in edges if Path.Geom.edgeConnectsTo(e, self.realExit)] ) edges.append(Part.Edge(Part.LineSegment(self.realExit, self.exit))) else: @@ -471,15 +470,15 @@ class MapWireToTag: for e in copy.copy(edges): p1 = e.valueAt(e.FirstParameter) p2 = e.valueAt(e.LastParameter) - if PathGeom.pointsCoincide(p1, p0): + if Path.Geom.pointsCoincide(p1, p0): outputEdges.append((e, False)) edges.remove(e) lastP = None p0 = p2 debugEdge(e, ">>>>> no flip") break - elif PathGeom.pointsCoincide(p2, p0): - flipped = PathGeom.flipEdge(e) + elif Path.Geom.pointsCoincide(p2, p0): + flipped = Path.Geom.flipEdge(e) if not flipped is None: outputEdges.append((flipped, True)) else: @@ -526,21 +525,21 @@ class MapWireToTag: return outputEdges def isStrut(self, edge): - p1 = PathGeom.xy(edge.valueAt(edge.FirstParameter)) - p2 = PathGeom.xy(edge.valueAt(edge.LastParameter)) - return PathGeom.pointsCoincide(p1, p2) + p1 = Path.Geom.xy(edge.valueAt(edge.FirstParameter)) + p2 = Path.Geom.xy(edge.valueAt(edge.LastParameter)) + return Path.Geom.pointsCoincide(p1, p2) def shell(self): if len(self.edges) > 1: wire = Part.Wire(self.initialEdge) else: edge = self.edges[0] - if PathGeom.pointsCoincide( + if Path.Geom.pointsCoincide( edge.valueAt(edge.FirstParameter), self.finalEdge.valueAt(self.finalEdge.FirstParameter), ): wire = Part.Wire(self.finalEdge) - elif hasattr(self, "initialEdge") and PathGeom.pointsCoincide( + elif hasattr(self, "initialEdge") and Path.Geom.pointsCoincide( edge.valueAt(edge.FirstParameter), self.initialEdge.valueAt(self.initialEdge.FirstParameter), ): @@ -549,7 +548,7 @@ class MapWireToTag: wire = Part.Wire(edge) for edge in self.edges[1:]: - if PathGeom.pointsCoincide( + if Path.Geom.pointsCoincide( edge.valueAt(edge.FirstParameter), self.finalEdge.valueAt(self.finalEdge.FirstParameter), ): @@ -558,7 +557,7 @@ class MapWireToTag: wire.add(edge) shell = wire.extrude(FreeCAD.Vector(0, 0, self.tag.height + 1)) - nullFaces = list([f for f in shell.Faces if PathGeom.isRoughly(f.Area, 0)]) + nullFaces = list([f for f in shell.Faces if Path.Geom.isRoughly(f.Area, 0)]) if nullFaces: return shell.removeShape(nullFaces) return shell @@ -575,8 +574,8 @@ class MapWireToTag: p2 = e.valueAt(e.LastParameter) if ( self.tag.isSquare - and (PathGeom.isRoughly(p1.z, self.maxZ) or p1.z > self.maxZ) - and (PathGeom.isRoughly(p2.z, self.maxZ) or p2.z > self.maxZ) + and (Path.Geom.isRoughly(p1.z, self.maxZ) or p1.z > self.maxZ) + and (Path.Geom.isRoughly(p2.z, self.maxZ) or p2.z > self.maxZ) ): rapid = p1 if flip else p2 else: @@ -588,7 +587,7 @@ class MapWireToTag: ) rapid = None commands.extend( - PathGeom.cmdsForEdge( + Path.Geom.cmdsForEdge( e, False, False, @@ -612,7 +611,7 @@ class MapWireToTag: commands = [] for e in self.edges: commands.extend( - PathGeom.cmdsForEdge(e, hSpeed=self.hSpeed, vSpeed=self.vSpeed) + Path.Geom.cmdsForEdge(e, hSpeed=self.hSpeed, vSpeed=self.vSpeed) ) return commands return [] @@ -621,7 +620,7 @@ class MapWireToTag: self.tail = None self.finalEdge = edge if self.tag.solid.isInside( - edge.valueAt(edge.LastParameter), PathGeom.Tolerance, True + edge.valueAt(edge.LastParameter), Path.Geom.Tolerance, True ): Path.Log.track("solid.isInside") self.addEdge(edge) @@ -633,12 +632,12 @@ class MapWireToTag: o = self.tag.originAt(self.tag.z) Path.Log.debug("originAt: (%.2f, %.2f, %.2f)" % (o.x, o.y, o.z)) i = edge.valueAt(edge.FirstParameter) - if PathGeom.pointsCoincide(i, edge.valueAt(edge.FirstParameter)): + if Path.Geom.pointsCoincide(i, edge.valueAt(edge.FirstParameter)): Path.Log.track("tail") self.tail = edge else: Path.Log.track("split") - e, tail = PathGeom.splitEdgeAt(edge, i) + e, tail = Path.Geom.splitEdgeAt(edge, i) self.addEdge(e) self.tail = tail self.exit = i @@ -661,12 +660,12 @@ class _RapidEdges: r0 = r.Vertexes[0] r1 = r.Vertexes[1] if ( - PathGeom.isRoughly(r0.X, v0.X) - and PathGeom.isRoughly(r0.Y, v0.Y) - and PathGeom.isRoughly(r0.Z, v0.Z) - and PathGeom.isRoughly(r1.X, v1.X) - and PathGeom.isRoughly(r1.Y, v1.Y) - and PathGeom.isRoughly(r1.Z, v1.Z) + Path.Geom.isRoughly(r0.X, v0.X) + and Path.Geom.isRoughly(r0.Y, v0.Y) + and Path.Geom.isRoughly(r0.Z, v0.Z) + and Path.Geom.isRoughly(r1.X, v1.X) + and Path.Geom.isRoughly(r1.Y, v1.Y) + and Path.Geom.isRoughly(r1.Z, v1.Z) ): return True return False @@ -676,7 +675,7 @@ class PathData: def __init__(self, obj): Path.Log.track(obj.Base.Name) self.obj = obj - self.wire, rapid = PathGeom.wireForPath(obj.Base.Path) + self.wire, rapid = Path.Geom.wireForPath(obj.Base.Path) self.rapid = _RapidEdges(rapid) if self.wire: self.edges = self.wire.Edges @@ -691,8 +690,8 @@ class PathData: bottom = [ e for e in edges - if PathGeom.isRoughly(e.Vertexes[0].Point.z, minZ) - and PathGeom.isRoughly(e.Vertexes[1].Point.z, minZ) + if Path.Geom.isRoughly(e.Vertexes[0].Point.z, minZ) + and Path.Geom.isRoughly(e.Vertexes[1].Point.z, minZ) ] self.bottomEdges = bottom try: @@ -746,7 +745,7 @@ class PathData: for i in range(0, len(self.baseWire.Edges)): edge = self.baseWire.Edges[i] Path.Log.debug(" %d: %.2f" % (i, edge.Length)) - if PathGeom.isRoughly(edge.Length, longestEdge.Length): + if Path.Geom.isRoughly(edge.Length, longestEdge.Length): startIndex = i break @@ -898,7 +897,7 @@ class PathData: ts = [ t for t in tags - if PathGeom.isRoughly( + if Path.Geom.isRoughly( 0, Part.Vertex(t.originAt(self.minZ)).distToShape(edge)[0], 0.1 ) ] @@ -926,7 +925,7 @@ class PathData: for e in self.bottomEdges: indent = "{} ".format(e.distToShape(v)[0]) debugEdge(e, indent, True) - if PathGeom.isRoughly(0.0, v.distToShape(e)[0], 0.1): + if Path.Geom.isRoughly(0.0, v.distToShape(e)[0], 0.1): return True return False @@ -1059,11 +1058,11 @@ class ObjectTagDressup: return False def isValidTagStartIntersection(self, edge, i): - if PathGeom.pointsCoincide(i, edge.valueAt(edge.LastParameter)): + if Path.Geom.pointsCoincide(i, edge.valueAt(edge.LastParameter)): return False p1 = edge.valueAt(edge.FirstParameter) p2 = edge.valueAt(edge.LastParameter) - if PathGeom.pointsCoincide(PathGeom.xy(p1), PathGeom.xy(p2)): + if Path.Geom.pointsCoincide(Path.Geom.xy(p1), Path.Geom.xy(p2)): # if this vertical goes up, it can't be the start of a tag intersection if p1.z < p2.z: return False @@ -1141,9 +1140,9 @@ class ObjectTagDressup: v = edge.Vertexes[1] if ( not commands - and PathGeom.isRoughly(0, v.X) - and PathGeom.isRoughly(0, v.Y) - and not PathGeom.isRoughly(0, v.Z) + and Path.Geom.isRoughly(0, v.X) + and Path.Geom.isRoughly(0, v.Y) + and not Path.Geom.isRoughly(0, v.Z) ): # The very first move is just to move to ClearanceHeight commands.append( @@ -1157,7 +1156,7 @@ class ObjectTagDressup: ) else: commands.extend( - PathGeom.cmdsForEdge( + Path.Geom.cmdsForEdge( edge, segm=segm, hSpeed=horizFeed, vSpeed=vertFeed ) ) @@ -1203,8 +1202,8 @@ class ObjectTagDressup: p0 = e.valueAt(e.FirstParameter) p1 = e.valueAt(e.LastParameter) if tag.solid.isInside( - p0, PathGeom.Tolerance, True - ) or tag.solid.isInside(p1, PathGeom.Tolerance, True): + p0, Path.Geom.Tolerance, True + ) or tag.solid.isInside(p1, Path.Geom.Tolerance, True): Path.Log.info( "Tag #%d intersects with starting point - disabling\n" % i ) @@ -1290,7 +1289,7 @@ class ObjectTagDressup: "x=%s, y=%s, z=%s" % (tag.x, tag.y, self.pathData.minZ) ) # debugMarker(FreeCAD.Vector(tag.x, tag.y, self.pathData.minZ), "tag-%02d" % tagID , (1.0, 0.0, 1.0), 0.5) - # if not PathGeom.isRoughly(90, tag.angle): + # if not Path.Geom.isRoughly(90, tag.angle): # debugCone(tag.originAt(self.pathData.minZ), tag.r1, tag.r2, tag.actualHeight, "tag-%02d" % tagID) # else: # debugCylinder(tag.originAt(self.pathData.minZ), tag.fullWidth()/2, tag.actualHeight, "tag-%02d" % tagID) diff --git a/src/Mod/Path/PathScripts/PathGeom.py b/src/Mod/Path/Path/Geom.py similarity index 99% rename from src/Mod/Path/PathScripts/PathGeom.py rename to src/Mod/Path/Path/Geom.py index 6566cf97f1..29955f6f25 100644 --- a/src/Mod/Path/PathScripts/PathGeom.py +++ b/src/Mod/Path/Path/Geom.py @@ -33,7 +33,7 @@ from lazy_loader.lazy_loader import LazyLoader Part = LazyLoader("Part", globals(), "Part") -__title__ = "PathGeom - geometry utilities for Path" +__title__ = "Geom - geometry utilities for Path" __author__ = "sliptonic (Brad Collette)" __url__ = "https://www.freecadweb.org" __doc__ = "Functions to extract and convert between Path.Command and Part.Edge and utility functions to reason about them." @@ -709,7 +709,7 @@ def combineHorizontalFaces(faces): The Adaptive op is not concerned with which hole edges belong to which face. Attempts to do the same shape connecting failed with TechDraw.findShapeOutline() and - PathGeom.combineConnectedShapes(), so this algorithm was created. + Path.Geom.combineConnectedShapes(), so this algorithm was created. """ horizontal = list() offset = 10.0 diff --git a/src/Mod/Path/Path/Op/Adaptive.py b/src/Mod/Path/Path/Op/Adaptive.py index d456d423b3..b7a037440a 100644 --- a/src/Mod/Path/Path/Op/Adaptive.py +++ b/src/Mod/Path/Path/Op/Adaptive.py @@ -25,7 +25,6 @@ import Path import Path.Op.Base as PathOp import PathScripts.PathUtils as PathUtils -import PathScripts.PathGeom as PathGeom import FreeCAD import time import json @@ -869,7 +868,7 @@ def _get_working_edges(op, obj): all_regions.append(f) # Second face-combining method attempted - horizontal = PathGeom.combineHorizontalFaces(all_regions) + horizontal = Path.Geom.combineHorizontalFaces(all_regions) if horizontal: obj.removalshape = Part.makeCompound(horizontal) for f in horizontal: diff --git a/src/Mod/Path/Path/Op/Area.py b/src/Mod/Path/Path/Op/Area.py index 5c35188b36..094627c58e 100644 --- a/src/Mod/Path/Path/Op/Area.py +++ b/src/Mod/Path/Path/Op/Area.py @@ -32,7 +32,6 @@ from lazy_loader.lazy_loader import LazyLoader Draft = LazyLoader("Draft", globals(), "Draft") Part = LazyLoader("Part", globals(), "Part") -PathGeom = LazyLoader("PathScripts.PathGeom", globals(), "PathScripts.PathGeom") __title__ = "Base class for PathArea based operations." @@ -315,9 +314,9 @@ class ObjectOp(PathOp.ObjectOp): x = verts[idx].X y = verts[idx].Y # Zero start value adjustments for Path.fromShapes() bug - if PathGeom.isRoughly(x, 0.0): + if Path.Geom.isRoughly(x, 0.0): x = 0.00001 - if PathGeom.isRoughly(y, 0.0): + if Path.Geom.isRoughly(y, 0.0): y = 0.00001 pathParams["start"] = FreeCAD.Vector(x, y, verts[0].Z) else: diff --git a/src/Mod/Path/Path/Op/Base.py b/src/Mod/Path/Path/Op/Base.py index f1e1e036a1..04c3d25408 100644 --- a/src/Mod/Path/Path/Op/Base.py +++ b/src/Mod/Path/Path/Op/Base.py @@ -24,9 +24,8 @@ import FreeCAD from PathScripts.PathUtils import waiting_effects from PySide.QtCore import QT_TRANSLATE_NOOP import Path -import PathScripts.PathGeom as PathGeom +import Path.Base.Util as PathUtil import PathScripts.PathPreferences as PathPreferences -import PathScripts.PathUtil as PathUtil import PathScripts.PathUtils as PathUtils import math import time @@ -703,12 +702,12 @@ class ObjectOp(object): if FeatureDepths & self.opFeatures(obj): # first set update final depth, it's value is not negotiable - if not PathGeom.isRoughly(obj.OpFinalDepth.Value, zmin): + if not Path.Geom.isRoughly(obj.OpFinalDepth.Value, zmin): obj.OpFinalDepth = zmin zmin = obj.OpFinalDepth.Value def minZmax(z): - if hasattr(obj, "StepDown") and not PathGeom.isRoughly( + if hasattr(obj, "StepDown") and not Path.Geom.isRoughly( obj.StepDown.Value, 0 ): return z + obj.StepDown.Value @@ -720,7 +719,7 @@ class ObjectOp(object): zmax = minZmax(zmin) # update start depth if requested and required - if not PathGeom.isRoughly(obj.OpStartDepth.Value, zmax): + if not Path.Geom.isRoughly(obj.OpStartDepth.Value, zmax): obj.OpStartDepth = zmax else: # every obj has a StartDepth diff --git a/src/Mod/Path/Path/Op/Deburr.py b/src/Mod/Path/Path/Op/Deburr.py index d464441715..9ad1893ac9 100644 --- a/src/Mod/Path/Path/Op/Deburr.py +++ b/src/Mod/Path/Path/Op/Deburr.py @@ -26,7 +26,6 @@ import Path import Path.Op.Base as PathOp import Path.Op.EngraveBase as PathEngraveBase import Path.Op.Util as PathOpUtil -import PathScripts.PathGeom as PathGeom import math from PySide.QtCore import QT_TRANSLATE_NOOP @@ -61,7 +60,7 @@ def toolDepthAndOffset(width, extraDepth, tool, printInfo): suppressInfo = False if hasattr(tool, "CuttingEdgeAngle"): angle = float(tool.CuttingEdgeAngle) - if PathGeom.isRoughly(angle, 180) or PathGeom.isRoughly(angle, 0): + if Path.Geom.isRoughly(angle, 180) or Path.Geom.isRoughly(angle, 0): angle = 180 toolOffset = float(tool.Diameter) / 2 else: @@ -95,7 +94,7 @@ def toolDepthAndOffset(width, extraDepth, tool, printInfo): tan = math.tan(math.radians(angle / 2)) - toolDepth = 0 if PathGeom.isRoughly(tan, 0) else width / tan + toolDepth = 0 if Path.Geom.isRoughly(tan, 0) else width / tan depth = toolDepth + extraDepth extraOffset = -width if angle == 180 else (extraDepth / tan) offset = toolOffset + extraOffset diff --git a/src/Mod/Path/Path/Op/Drilling.py b/src/Mod/Path/Path/Op/Drilling.py index 0434f5f6a3..bd60e7c922 100644 --- a/src/Mod/Path/Path/Op/Drilling.py +++ b/src/Mod/Path/Path/Op/Drilling.py @@ -28,10 +28,10 @@ from Generators import drill_generator as generator import FreeCAD import Part import Path +import Path.Base.FeedRate as PathFeedRate +import Path.Base.MachineState as PathMachineState import Path.Op.Base as PathOp import Path.Op.CircularHoleBase as PathCircularHoleBase -import PathFeedRate -import PathMachineState import PathScripts.PathUtils as PathUtils from PySide.QtCore import QT_TRANSLATE_NOOP diff --git a/src/Mod/Path/Path/Op/EngraveBase.py b/src/Mod/Path/Path/Op/EngraveBase.py index 6169b12ffe..0a235bb356 100644 --- a/src/Mod/Path/Path/Op/EngraveBase.py +++ b/src/Mod/Path/Path/Op/EngraveBase.py @@ -23,7 +23,6 @@ from lazy_loader.lazy_loader import LazyLoader import Path import Path.Op.Base as PathOp -import PathScripts.PathGeom as PathGeom import Path.Op.Util as PathOpUtil import copy @@ -138,13 +137,13 @@ class ObjectOp(PathOp.ObjectOp): ) first = False - if PathGeom.pointsCoincide(last, edge.valueAt(edge.FirstParameter)): - # if PathGeom.pointsCoincide(last, edge.Vertexes[0].Point): - for cmd in PathGeom.cmdsForEdge(edge): + if Path.Geom.pointsCoincide(last, edge.valueAt(edge.FirstParameter)): + # if Path.Geom.pointsCoincide(last, edge.Vertexes[0].Point): + for cmd in Path.Geom.cmdsForEdge(edge): self.appendCommand(cmd, z, relZ, self.horizFeed) last = edge.Vertexes[-1].Point else: - for cmd in PathGeom.cmdsForEdge(edge, True): + for cmd in Path.Geom.cmdsForEdge(edge, True): self.appendCommand(cmd, z, relZ, self.horizFeed) last = edge.Vertexes[0].Point self.commandlist.append( diff --git a/src/Mod/Path/Path/Op/Gui/Base.py b/src/Mod/Path/Path/Op/Gui/Base.py index c582bd119d..7efbccb3f2 100644 --- a/src/Mod/Path/Path/Op/Gui/Base.py +++ b/src/Mod/Path/Path/Op/Gui/Base.py @@ -23,16 +23,15 @@ import FreeCAD import FreeCADGui import Path +import Path.Base.Util as PathUtil import Path.Op.Base as PathOp import PathGui as PGui # ensure Path/Gui/Resources are loaded -import PathScripts.PathGeom as PathGeom import PathScripts.PathGetPoint as PathGetPoint import PathScripts.PathGui as PathGui import PathScripts.PathJob as PathJob import PathScripts.PathPreferences as PathPreferences import PathScripts.PathSelection as PathSelection import PathScripts.PathSetupSheet as PathSetupSheet -import PathScripts.PathUtil as PathUtil import PathScripts.PathUtils as PathUtils import importlib from PySide.QtCore import QT_TRANSLATE_NOOP @@ -1000,7 +999,7 @@ class TaskPanelDepthsPage(TaskPanelPage): sub = sel[0].SubObjects[0] if "Vertex" == sub.ShapeType: return sub.Z - if PathGeom.isHorizontal(sub): + if Path.Geom.isHorizontal(sub): if "Edge" == sub.ShapeType: return sub.Vertexes[0].Z if "Face" == sub.ShapeType: diff --git a/src/Mod/Path/Path/Op/Helix.py b/src/Mod/Path/Path/Op/Helix.py index 31f5436180..c6af036821 100644 --- a/src/Mod/Path/Path/Op/Helix.py +++ b/src/Mod/Path/Path/Op/Helix.py @@ -27,9 +27,9 @@ from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import Part import Path +import Path.Base.FeedRate as PathFeedRate import Path.Op.Base as PathOp import Path.Op.CircularHoleBase as PathCircularHoleBase -import PathFeedRate __title__ = "Path Helix Drill Operation" diff --git a/src/Mod/Path/Path/Op/Pocket.py b/src/Mod/Path/Path/Op/Pocket.py index 148ea4e0dc..2453f613d0 100644 --- a/src/Mod/Path/Path/Op/Pocket.py +++ b/src/Mod/Path/Path/Op/Pocket.py @@ -31,8 +31,6 @@ import PathScripts.PathUtils as PathUtils # lazily loaded modules from lazy_loader.lazy_loader import LazyLoader -PathGeom = LazyLoader("PathScripts.PathGeom", globals(), "PathScripts.PathGeom") - __title__ = "Path 3D Pocket Operation" __author__ = "Yorik van Havre " __url__ = "https://www.freecadweb.org" @@ -254,7 +252,7 @@ class ObjectPocket(PathPocketBase.ObjectPocket): removalSolids = [ s for s in rawRemovalShape.Solids - if PathGeom.isRoughly( + if Path.Geom.isRoughly( s.BoundBox.ZMax, rawRemovalShape.BoundBox.ZMax ) ] @@ -893,7 +891,7 @@ def _extrudeBaseDown(base): Extrudes and fuses all non-vertical faces downward to a level 1.0 mm below base ZMin.""" allExtrusions = list() zMin = base.Shape.BoundBox.ZMin - bbFace = PathGeom.makeBoundBoxFace(base.Shape.BoundBox, offset=5.0) + bbFace = Path.Geom.makeBoundBoxFace(base.Shape.BoundBox, offset=5.0) bbFace.translate( FreeCAD.Vector(0.0, 0.0, float(int(base.Shape.BoundBox.ZMin - 5.0))) ) @@ -902,7 +900,7 @@ def _extrudeBaseDown(base): # Make projections of each non-vertical face and extrude it for f in base.Shape.Faces: fbb = f.BoundBox - if not PathGeom.isRoughly(f.normalAt(0, 0).z, 0.0): + if not Path.Geom.isRoughly(f.normalAt(0, 0).z, 0.0): pp = bbFace.makeParallelProjection(f.Wires[0], direction) face = Part.Face(Part.Wire(pp.Edges)) face.translate(FreeCAD.Vector(0.0, 0.0, fbb.ZMin)) diff --git a/src/Mod/Path/Path/Op/PocketShape.py b/src/Mod/Path/Path/Op/PocketShape.py index f5124908e7..62b2c6bc92 100644 --- a/src/Mod/Path/Path/Op/PocketShape.py +++ b/src/Mod/Path/Path/Op/PocketShape.py @@ -25,7 +25,6 @@ import FreeCAD import Path import Path.Op.Base as PathOp import Path.Op.PocketBase as PathPocketBase -import PathScripts.PathGeom as PathGeom # lazily loaded modules @@ -123,16 +122,16 @@ class ObjectPocket(PathPocketBase.ObjectPocket): # Check if selected vertical faces form a loop if len(self.vert) > 0: - self.vertical = PathGeom.combineConnectedShapes(self.vert) + self.vertical = Path.Geom.combineConnectedShapes(self.vert) self.vWires = [ TechDraw.findShapeOutline(shape, 1, FreeCAD.Vector(0, 0, 1)) for shape in self.vertical ] for wire in self.vWires: - w = PathGeom.removeDuplicateEdges(wire) + w = Path.Geom.removeDuplicateEdges(wire) face = Part.Face(w) # face.tessellate(0.1) - if PathGeom.isRoughly(face.Area, 0): + if Path.Geom.isRoughly(face.Area, 0): Path.Log.error("Vertical faces do not form a loop - ignoring") else: self.horiz.append(face) @@ -149,7 +148,7 @@ class ObjectPocket(PathPocketBase.ObjectPocket): self.exts.append(f) # check all faces and see if they are touching/overlapping and combine and simplify - self.horizontal = PathGeom.combineHorizontalFaces(self.horiz) + self.horizontal = Path.Geom.combineHorizontalFaces(self.horiz) # Move all faces to final depth less buffer before extrusion # Small negative buffer is applied to compensate for internal significant digits/rounding issue @@ -202,11 +201,11 @@ class ObjectPocket(PathPocketBase.ObjectPocket): # Support methods def isVerticalExtrusionFace(self, face): fBB = face.BoundBox - if PathGeom.isRoughly(fBB.ZLength, 0.0): + if Path.Geom.isRoughly(fBB.ZLength, 0.0): return False extr = face.extrude(FreeCAD.Vector(0.0, 0.0, fBB.ZLength)) if hasattr(extr, "Volume"): - if PathGeom.isRoughly(extr.Volume, 0.0): + if Path.Geom.isRoughly(extr.Volume, 0.0): return True return False @@ -219,13 +218,13 @@ class ObjectPocket(PathPocketBase.ObjectPocket): if type(face.Surface) == Part.Plane: Path.Log.debug("type() == Part.Plane") - if PathGeom.isVertical(face.Surface.Axis): + if Path.Geom.isVertical(face.Surface.Axis): Path.Log.debug(" -isVertical()") # it's a flat horizontal face self.horiz.append(face) return True - elif PathGeom.isHorizontal(face.Surface.Axis): + elif Path.Geom.isHorizontal(face.Surface.Axis): Path.Log.debug(" -isHorizontal()") self.vert.append(face) return True @@ -233,7 +232,7 @@ class ObjectPocket(PathPocketBase.ObjectPocket): else: return False - elif type(face.Surface) == Part.Cylinder and PathGeom.isVertical( + elif type(face.Surface) == Part.Cylinder and Path.Geom.isVertical( face.Surface.Axis ): Path.Log.debug("type() == Part.Cylinder") diff --git a/src/Mod/Path/Path/Op/Slot.py b/src/Mod/Path/Path/Op/Slot.py index 7d5ec7d81c..0c726bdf02 100644 --- a/src/Mod/Path/Path/Op/Slot.py +++ b/src/Mod/Path/Path/Op/Slot.py @@ -41,7 +41,6 @@ from lazy_loader.lazy_loader import LazyLoader Part = LazyLoader("Part", globals(), "Part") Arcs = LazyLoader("draftgeoutils.arcs", globals(), "draftgeoutils.arcs") -PathGeom = LazyLoader("PathScripts.PathGeom", globals(), "PathScripts.PathGeom") if FreeCAD.GuiUp: FreeCADGui = LazyLoader("FreeCADGui", globals(), "FreeCADGui") @@ -947,7 +946,7 @@ class ObjectSlot(PathOp.ObjectOp): norm = shape_1.normalAt(0.0, 0.0) Path.Log.debug("{}.normalAt(): {}".format(sub1, norm)) - if PathGeom.isRoughly(shape_1.BoundBox.ZMax, shape_1.BoundBox.ZMin): + if Path.Geom.isRoughly(shape_1.BoundBox.ZMax, shape_1.BoundBox.ZMin): # Horizontal face if norm.z == 1 or norm.z == -1: pnts = self._processSingleHorizFace(obj, shape_1) diff --git a/src/Mod/Path/Path/Op/ThreadMilling.py b/src/Mod/Path/Path/Op/ThreadMilling.py index fa56a64541..bd634d057d 100644 --- a/src/Mod/Path/Path/Op/ThreadMilling.py +++ b/src/Mod/Path/Path/Op/ThreadMilling.py @@ -26,7 +26,6 @@ import FreeCAD import Path import Path.Op.Base as PathOp import Path.Op.CircularHoleBase as PathCircularHoleBase -import PathScripts.PathGeom as PathGeom import Generators.threadmilling_generator as threadmilling import math from PySide.QtCore import QT_TRANSLATE_NOOP diff --git a/src/Mod/Path/Path/Op/Util.py b/src/Mod/Path/Path/Op/Util.py index 2f547986a3..b201b0a447 100644 --- a/src/Mod/Path/Path/Op/Util.py +++ b/src/Mod/Path/Path/Op/Util.py @@ -24,7 +24,6 @@ from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import Path -import PathScripts.PathGeom as PathGeom import math # lazily loaded modules @@ -116,19 +115,19 @@ def _orientEdges(inEdges): if 1 < len(inEdges): last = e0.valueAt(e0.LastParameter) e1 = inEdges[1] - if not PathGeom.pointsCoincide( + if not Path.Geom.pointsCoincide( last, e1.valueAt(e1.FirstParameter) - ) and not PathGeom.pointsCoincide(last, e1.valueAt(e1.LastParameter)): + ) and not Path.Geom.pointsCoincide(last, e1.valueAt(e1.LastParameter)): debugEdge("# _orientEdges - flip first", e0) - e0 = PathGeom.flipEdge(e0) + e0 = Path.Geom.flipEdge(e0) edges = [e0] last = e0.valueAt(e0.LastParameter) for e in inEdges[1:]: edge = ( e - if PathGeom.pointsCoincide(last, e.valueAt(e.FirstParameter)) - else PathGeom.flipEdge(e) + if Path.Geom.pointsCoincide(last, e.valueAt(e.FirstParameter)) + else Path.Geom.flipEdge(e) ) edges.append(edge) last = edge.valueAt(edge.LastParameter) @@ -172,7 +171,7 @@ def orientWire(w, forward=True): if forward is not None: if forward != _isWireClockwise(wire): Path.Log.track("orientWire - needs flipping") - return PathGeom.flipWire(wire) + return Path.Geom.flipWire(wire) Path.Log.track("orientWire - ok") return wire @@ -196,7 +195,7 @@ def offsetWire(wire, base, offset, forward, Side=None): curve.Radius + offset, curve.Center, FreeCAD.Vector(0, 0, z) ) if base.isInside(new_edge.Vertexes[0].Point, offset / 2, True): - if offset > curve.Radius or PathGeom.isRoughly(offset, curve.Radius): + if offset > curve.Radius or Path.Geom.isRoughly(offset, curve.Radius): # offsetting a hole by its own radius (or more) makes the hole vanish return None if Side: @@ -285,9 +284,9 @@ def offsetWire(wire, base, offset, forward, Side=None): # flip the edge if it's not on the right side of the original edge if forward is not None: v1 = edge.Vertexes[1].Point - p0 - left = PathGeom.Side.Left == PathGeom.Side.of(v0, v1) + left = Path.Geom.Side.Left == Path.Geom.Side.of(v0, v1) if left != forward: - edge = PathGeom.flipEdge(edge) + edge = Path.Geom.flipEdge(edge) return Part.Wire([edge]) # if we get to this point the assumption is that makeOffset2D can deal with the edge @@ -342,7 +341,7 @@ def offsetWire(wire, base, offset, forward, Side=None): p0 = edge.firstVertex().Point p1 = edge.lastVertex().Point for p in insideEndpoints: - if PathGeom.pointsCoincide(p, p0, 0.01) or PathGeom.pointsCoincide( + if Path.Geom.pointsCoincide(p, p0, 0.01) or Path.Geom.pointsCoincide( p, p1, 0.01 ): return True @@ -361,7 +360,7 @@ def offsetWire(wire, base, offset, forward, Side=None): def isCircleAt(edge, center): """isCircleAt(edge, center) ... helper function returns True if edge is a circle at the given center.""" if Part.Circle == type(edge.Curve) or Part.ArcOfCircle == type(edge.Curve): - return PathGeom.pointsCoincide(edge.Curve.Center, center) + return Path.Geom.pointsCoincide(edge.Curve.Center, center) return False # split offset wire into edges to the left side and edges to the right side @@ -376,7 +375,7 @@ def offsetWire(wire, base, offset, forward, Side=None): # next side, we're done for e in owire.Edges + owire.Edges: if isCircleAt(e, start): - if PathGeom.pointsCoincide(e.Curve.Axis, FreeCAD.Vector(0, 0, 1)): + if Path.Geom.pointsCoincide(e.Curve.Axis, FreeCAD.Vector(0, 0, 1)): if not collectLeft and leftSideEdges: break collectLeft = True @@ -387,7 +386,7 @@ def offsetWire(wire, base, offset, forward, Side=None): collectLeft = False collectRight = True elif isCircleAt(e, end): - if PathGeom.pointsCoincide(e.Curve.Axis, FreeCAD.Vector(0, 0, 1)): + if Path.Geom.pointsCoincide(e.Curve.Axis, FreeCAD.Vector(0, 0, 1)): if not collectRight and rightSideEdges: break collectLeft = False @@ -410,7 +409,7 @@ def offsetWire(wire, base, offset, forward, Side=None): edges = leftSideEdges for e in longestWire.Edges: for e0 in rightSideEdges: - if PathGeom.edgesMatch(e, e0): + if Path.Geom.edgesMatch(e, e0): edges = rightSideEdges Path.Log.debug("#use right side edges") if not forward: diff --git a/src/Mod/Path/Path/Op/Vcarve.py b/src/Mod/Path/Path/Op/Vcarve.py index 55f42a48f8..03e5277596 100644 --- a/src/Mod/Path/Path/Op/Vcarve.py +++ b/src/Mod/Path/Path/Op/Vcarve.py @@ -26,7 +26,6 @@ import Path import Path.Op.Base as PathOp import Path.Op.EngraveBase as PathEngraveBase import PathScripts.PathUtils as PathUtils -import PathScripts.PathGeom as PathGeom import PathScripts.PathPreferences as PathPreferences import math from PySide.QtCore import QT_TRANSLATE_NOOP @@ -285,7 +284,7 @@ class ObjectVcarve(PathEngraveBase.ObjectOp): Path.Command("G1 X{} Y{} Z{} F{}".format(p.x, p.y, p.z, vSpeed)) ) for e in edges: - path.extend(PathGeom.cmdsForEdge(e, hSpeed=hSpeed, vSpeed=vSpeed)) + path.extend(Path.Geom.cmdsForEdge(e, hSpeed=hSpeed, vSpeed=vSpeed)) return path diff --git a/src/Mod/Path/Path/Post/Command.py b/src/Mod/Path/Path/Post/Command.py index 5a1eb5f812..2e36110f04 100644 --- a/src/Mod/Path/Path/Post/Command.py +++ b/src/Mod/Path/Path/Post/Command.py @@ -27,9 +27,9 @@ from __future__ import print_function import FreeCAD import FreeCADGui import Path +import Path.Base.Util as PathUtil import PathScripts.PathJob as PathJob import PathScripts.PathPreferences as PathPreferences -import PathScripts.PathUtil as PathUtil import PathScripts.PathUtils as PathUtils import os import re diff --git a/src/Mod/Path/Path/Post/Utils.py b/src/Mod/Path/Path/Post/Utils.py index ec6b21c609..b4090afde3 100644 --- a/src/Mod/Path/Path/Post/Utils.py +++ b/src/Mod/Path/Path/Post/Utils.py @@ -34,8 +34,7 @@ import FreeCAD import Path import Part -from PathMachineState import MachineState -from PathScripts.PathGeom import CmdMoveArc, edgeForCmd, cmdsForEdge +from Path.Base.MachineState import MachineState translate = FreeCAD.Qt.translate FreeCADGui = None @@ -216,16 +215,16 @@ def splitArcs(path): machine = MachineState() for command in path.Commands: - if command.Name not in CmdMoveArc: + if command.Name not in Path.Geom.CmdMoveArc: machine.addCommand(command) results.append(command) continue - edge = edgeForCmd(command, machine.getPosition()) + edge = Path.Geom.edgeForCmd(command, machine.getPosition()) pts = edge.discretize(Deflection=deflection) edges = [Part.makeLine(v1, v2) for v1, v2 in zip(pts, pts[1:])] for edge in edges: - results.extend(cmdsForEdge(edge)) + results.extend(Path.Geom.cmdsForEdge(edge)) machine.addCommand(command) diff --git a/src/Mod/Path/Path/Post/scripts/dxf_post.py b/src/Mod/Path/Path/Post/scripts/dxf_post.py index 16e25ada60..e08d66d398 100644 --- a/src/Mod/Path/Path/Post/scripts/dxf_post.py +++ b/src/Mod/Path/Path/Post/scripts/dxf_post.py @@ -24,7 +24,6 @@ from __future__ import print_function import FreeCAD import Part import Path -import PathScripts.PathGeom as PathGeom import datetime import importDXF @@ -93,8 +92,8 @@ def dxfWrite(objlist, filename): def parse(pathobj): """accepts a Path object. Returns a list of wires""" - feedcommands = PathGeom.CmdMove - rapidcommands = PathGeom.CmdMoveRapid + feedcommands = Path.Geom.CmdMove + rapidcommands = Path.Geom.CmdMoveRapid edges = [] objlist = [] @@ -126,7 +125,7 @@ def parse(pathobj): # feeding move. Build an edge if flatcommand.Name in feedcommands: - edges.append(PathGeom.edgeForCmd(flatcommand, curPoint)) + edges.append(Path.Geom.edgeForCmd(flatcommand, curPoint)) Path.Log.debug("feeding move") # update the curpoint diff --git a/src/Mod/Path/Path/Post/scripts/grbl_post.py b/src/Mod/Path/Path/Post/scripts/grbl_post.py index ab8482fa56..5c27cd5fcf 100755 --- a/src/Mod/Path/Path/Post/scripts/grbl_post.py +++ b/src/Mod/Path/Path/Post/scripts/grbl_post.py @@ -26,11 +26,12 @@ import FreeCAD from FreeCAD import Units +import Path +import Path.Base.Util as PathUtil import Path.Post.Utils as PostUtils import argparse import datetime import shlex -import PathScripts.PathUtil as PathUtil import re diff --git a/src/Mod/Path/Path/Post/scripts/marlin_post.py b/src/Mod/Path/Path/Post/scripts/marlin_post.py index 3a3d06e518..a948ac9df5 100644 --- a/src/Mod/Path/Path/Post/scripts/marlin_post.py +++ b/src/Mod/Path/Path/Post/scripts/marlin_post.py @@ -32,7 +32,8 @@ import argparse import shlex import FreeCAD from FreeCAD import Units -import PathScripts.PathUtil as PathUtil +import Path +import Path.Base.Util as PathUtil import Path.Post.Utils as PostUtils Revised = "2020-11-03" # Revision date for this file. diff --git a/src/Mod/Path/Path/Post/scripts/opensbp_pre.py b/src/Mod/Path/Path/Post/scripts/opensbp_pre.py index 3bd4117d69..f0815d9442 100644 --- a/src/Mod/Path/Path/Post/scripts/opensbp_pre.py +++ b/src/Mod/Path/Path/Post/scripts/opensbp_pre.py @@ -49,7 +49,8 @@ Many other OpenSBP commands not handled """ from __future__ import print_function import FreeCAD -import PathScripts.PathUtil as PathUtil +import Path +import Path.Base.Util as PathUtil import os import Path diff --git a/src/Mod/Path/Path/Post/scripts/rrf_post.py b/src/Mod/Path/Path/Post/scripts/rrf_post.py index cdef35bb10..4d09d7b9ba 100644 --- a/src/Mod/Path/Path/Post/scripts/rrf_post.py +++ b/src/Mod/Path/Path/Post/scripts/rrf_post.py @@ -31,7 +31,8 @@ import argparse import shlex import FreeCAD from FreeCAD import Units -import PathScripts.PathUtil as PathUtil +import Path +import Path.Base.Util as PathUtil import Path.Post.Utils as PostUtils Revised = "2021-10-21" # Revision date for this file. diff --git a/src/Mod/Path/Path/Tool/Bit.py b/src/Mod/Path/Path/Tool/Bit.py index e59734798f..12f8469d7e 100644 --- a/src/Mod/Path/Path/Tool/Bit.py +++ b/src/Mod/Path/Path/Tool/Bit.py @@ -22,9 +22,9 @@ import FreeCAD import Path +import Path.Base.Util as PathUtil +import Path.Base.PropertyBag as PathPropertyBag import PathScripts.PathPreferences as PathPreferences -import PathScripts.PathPropertyBag as PathPropertyBag -import PathScripts.PathUtil as PathUtil import json import os import zipfile diff --git a/src/Mod/Path/Path/Tool/Gui/BitEdit.py b/src/Mod/Path/Path/Tool/Gui/BitEdit.py index 9b0a71087f..30f1a4b1ab 100644 --- a/src/Mod/Path/Path/Tool/Gui/BitEdit.py +++ b/src/Mod/Path/Path/Tool/Gui/BitEdit.py @@ -23,10 +23,10 @@ from PySide import QtCore, QtGui import FreeCADGui import Path +import Path.Base.Util as PathUtil import PathScripts.PathGui as PathGui import PathScripts.PathPreferences as PathPreferences import PathScripts.PathPropertyEditor as PathPropertyEditor -import PathScripts.PathUtil as PathUtil import os import re diff --git a/src/Mod/Path/Path/Tool/Gui/Controller.py b/src/Mod/Path/Path/Tool/Gui/Controller.py index 7f2e9f7bcc..2908b06275 100644 --- a/src/Mod/Path/Path/Tool/Gui/Controller.py +++ b/src/Mod/Path/Path/Tool/Gui/Controller.py @@ -25,11 +25,11 @@ from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import FreeCADGui import Path +import Path.Base.Util as PathUtil import Path.Tool.Controller as PathToolController import Path.Tool.Gui.Bit as PathToolBitGui import PathGui as PGui # ensure Path/Gui/Resources are loaded import PathScripts.PathGui as PathGui -import PathScripts.PathUtil as PathUtil # lazily loaded modules from lazy_loader.lazy_loader import LazyLoader diff --git a/src/Mod/Path/Path/__init__.py b/src/Mod/Path/Path/__init__.py index e633bc4d34..a1bfe7366d 100644 --- a/src/Mod/Path/Path/__init__.py +++ b/src/Mod/Path/Path/__init__.py @@ -1,3 +1,4 @@ from PathApp import * import Path.Log as Log +import Path.Geom as Geom diff --git a/src/Mod/Path/PathScripts/PathFeatureExtensions.py b/src/Mod/Path/PathScripts/PathFeatureExtensions.py index da4e0c66fc..fd14420453 100644 --- a/src/Mod/Path/PathScripts/PathFeatureExtensions.py +++ b/src/Mod/Path/PathScripts/PathFeatureExtensions.py @@ -24,7 +24,6 @@ from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import Part import Path -import PathScripts.PathGeom as PathGeom import math # lazily loaded modules @@ -56,7 +55,7 @@ def endPoints(edgeOrWire): pts.extend([e.valueAt(e.LastParameter) for e in edgeOrWire.Edges]) unique = [] for p in pts: - cnt = len([p2 for p2 in pts if PathGeom.pointsCoincide(p, p2)]) + cnt = len([p2 for p2 in pts if Path.Geom.pointsCoincide(p, p2)]) if 1 == cnt: unique.append(p) @@ -64,7 +63,7 @@ def endPoints(edgeOrWire): pfirst = edgeOrWire.valueAt(edgeOrWire.FirstParameter) plast = edgeOrWire.valueAt(edgeOrWire.LastParameter) - if PathGeom.pointsCoincide(pfirst, plast): + if Path.Geom.pointsCoincide(pfirst, plast): return None return [pfirst, plast] @@ -73,7 +72,7 @@ def endPoints(edgeOrWire): def includesPoint(p, pts): """includesPoint(p, pts) ... answer True if the collection of pts includes the point p""" for pt in pts: - if PathGeom.pointsCoincide(p, pt): + if Path.Geom.pointsCoincide(p, pt): return True return False @@ -246,7 +245,7 @@ class Extension(object): e2 = e0.copy() off = self.length.Value * direction e2.translate(off) - e2 = PathGeom.flipEdge(e2) + e2 = Path.Geom.flipEdge(e2) e1 = Part.Edge( Part.LineSegment( e0.valueAt(e0.LastParameter), e2.valueAt(e2.FirstParameter) @@ -295,7 +294,7 @@ class Extension(object): tangent = e0.tangentAt(midparam) Path.Log.track("tangent", tangent, self.feature, self.sub) normal = tangent.cross(FreeCAD.Vector(0, 0, 1)) - if PathGeom.pointsCoincide(normal, FreeCAD.Vector(0, 0, 0)): + if Path.Geom.pointsCoincide(normal, FreeCAD.Vector(0, 0, 0)): return None return self._getDirectedNormal(e0.valueAt(midparam), normal.normalize()) @@ -326,7 +325,7 @@ class Extension(object): Path.Log.track() length = self.length.Value - if PathGeom.isRoughly(0, length) or not self.sub: + if Path.Geom.isRoughly(0, length) or not self.sub: Path.Log.debug("no extension, length=%.2f, sub=%s" % (length, self.sub)) return None @@ -347,7 +346,7 @@ class Extension(object): if direction is None: return None - if PathGeom.pointsCoincide(normal, direction): + if Path.Geom.pointsCoincide(normal, direction): r = circle.Radius - length else: r = circle.Radius + length @@ -365,7 +364,7 @@ class Extension(object): # Determine if rotational alignment is necessary for new arc rotationAdjustment = arcAdjustmentAngle(edge, e3) - if not PathGeom.isRoughly(rotationAdjustment, 0.0): + if not Path.Geom.isRoughly(rotationAdjustment, 0.0): e3.rotate( edge.Curve.Center, FreeCAD.Vector(0.0, 0.0, 1.0), @@ -424,7 +423,7 @@ class Extension(object): subFace = Part.Face(sub) featFace = Part.Face(feature.Wires[0]) isOutside = True - if not PathGeom.isRoughly(featFace.Area, subFace.Area): + if not Path.Geom.isRoughly(featFace.Area, subFace.Area): length = -1.0 * length isOutside = False @@ -560,9 +559,9 @@ def getExtendOutlineFace( bbx = f.BoundBox zNorm = abs(f.normalAt(0.0, 0.0).z) if ( - PathGeom.isRoughly(zNorm, 1.0) - and PathGeom.isRoughly(bbx.ZMax - bbx.ZMin, 0.0) - and PathGeom.isRoughly(bbx.ZMin, face.BoundBox.ZMin) + Path.Geom.isRoughly(zNorm, 1.0) + and Path.Geom.isRoughly(bbx.ZMax - bbx.ZMin, 0.0) + and Path.Geom.isRoughly(bbx.ZMin, face.BoundBox.ZMin) ): if bbx.ZMin < zmin: bottom_faces.append(f) @@ -610,7 +609,7 @@ def getWaterlineFace(base_shape, face): # Get top face(s) of envelope at face height rawList = list() for f in env.Faces: - if PathGeom.isRoughly(f.BoundBox.ZMin, faceHeight): + if Path.Geom.isRoughly(f.BoundBox.ZMin, faceHeight): rawList.append(f) # make compound and extrude downward rawComp = Part.makeCompound(rawList) diff --git a/src/Mod/Path/PathScripts/PathFeatureExtensionsGui.py b/src/Mod/Path/PathScripts/PathFeatureExtensionsGui.py index 5d4f9d8e0c..e43ab53242 100644 --- a/src/Mod/Path/PathScripts/PathFeatureExtensionsGui.py +++ b/src/Mod/Path/PathScripts/PathFeatureExtensionsGui.py @@ -27,7 +27,6 @@ import FreeCADGui import Path import Path.Op.Gui.Base as PathOpGui import PathScripts.PathFeatureExtensions as FeatureExtensions -import PathScripts.PathGeom as PathGeom import PathScripts.PathGui as PathGui # lazily loaded modules @@ -361,13 +360,13 @@ class TaskPanelExtensionPage(PathOpGui.TaskPanelPage): if extendCorners: def edgesMatchShape(e0, e1): - flipped = PathGeom.flipEdge(e1) + flipped = Path.Geom.flipEdge(e1) if flipped: - return PathGeom.edgesMatch(e0, e1) or PathGeom.edgesMatch( + return Path.Geom.edgesMatch(e0, e1) or Path.Geom.edgesMatch( e0, flipped ) else: - return PathGeom.edgesMatch(e0, e1) + return Path.Geom.edgesMatch(e0, e1) self.extensionEdges = extensionEdges Path.Log.debug("extensionEdges.values(): {}".format(extensionEdges.values())) diff --git a/src/Mod/Path/PathScripts/PathGui.py b/src/Mod/Path/PathScripts/PathGui.py index d216d3fa42..320ac6092f 100644 --- a/src/Mod/Path/PathScripts/PathGui.py +++ b/src/Mod/Path/PathScripts/PathGui.py @@ -23,8 +23,7 @@ import FreeCAD import FreeCADGui import Path -import PathScripts.PathGeom as PathGeom -import PathScripts.PathUtil as PathUtil +import Path.Base.Util as PathUtil from PySide import QtGui, QtCore from PySide import QtCore, QtGui @@ -75,7 +74,7 @@ def updateInputField(obj, prop, widget, onBeforeChange=None): attrValue = attr.Value if hasattr(attr, "Value") else attr isDiff = False - if not PathGeom.isRoughly(attrValue, value): + if not Path.Geom.isRoughly(attrValue, value): isDiff = True else: if hasattr(obj, "ExpressionEngine"): @@ -85,7 +84,7 @@ def updateInputField(obj, prop, widget, onBeforeChange=None): exprSet = True Path.Log.debug('prop = "expression": {} = "{}"'.format(prp, expr)) value = FreeCAD.Units.Quantity(obj.evalExpression(expr)).Value - if not PathGeom.isRoughly(attrValue, value): + if not Path.Geom.isRoughly(attrValue, value): isDiff = True break if exprSet: diff --git a/src/Mod/Path/PathScripts/PathIconViewProvider.py b/src/Mod/Path/PathScripts/PathIconViewProvider.py index 9238454a5d..57ae10e895 100644 --- a/src/Mod/Path/PathScripts/PathIconViewProvider.py +++ b/src/Mod/Path/PathScripts/PathIconViewProvider.py @@ -22,8 +22,8 @@ import FreeCAD import Path +import Path.Base.Util as PathUtil import PathGui -import PathScripts.PathUtil as PathUtil import importlib __title__ = "Path Icon ViewProvider" diff --git a/src/Mod/Path/PathScripts/PathJob.py b/src/Mod/Path/PathScripts/PathJob.py index 3060247e23..0cda5d0c47 100644 --- a/src/Mod/Path/PathScripts/PathJob.py +++ b/src/Mod/Path/PathScripts/PathJob.py @@ -24,12 +24,12 @@ from PySide import QtCore from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import Path +import Path.Base.Util as PathUtil from Path.Post.Processor import PostProcessor import Path.Tool.Controller as PathToolController import PathScripts.PathPreferences as PathPreferences import PathScripts.PathSetupSheet as PathSetupSheet import PathScripts.PathStock as PathStock -import PathScripts.PathUtil as PathUtil import json import time import Path diff --git a/src/Mod/Path/PathScripts/PathJobCmd.py b/src/Mod/Path/PathScripts/PathJobCmd.py index c1b15de56d..e3a1adddba 100644 --- a/src/Mod/Path/PathScripts/PathJobCmd.py +++ b/src/Mod/Path/PathScripts/PathJobCmd.py @@ -25,11 +25,11 @@ from PySide.QtCore import QT_TRANSLATE_NOOP import FreeCAD import FreeCADGui import Path +import Path.Base.Util as PathUtil import PathScripts.PathJob as PathJob import PathScripts.PathJobDlg as PathJobDlg import PathScripts.PathPreferences as PathPreferences import PathScripts.PathStock as PathStock -import PathScripts.PathUtil as PathUtil import json import os diff --git a/src/Mod/Path/PathScripts/PathJobDlg.py b/src/Mod/Path/PathScripts/PathJobDlg.py index b3dd2b6721..d21b1761fe 100644 --- a/src/Mod/Path/PathScripts/PathJobDlg.py +++ b/src/Mod/Path/PathScripts/PathJobDlg.py @@ -25,10 +25,10 @@ from collections import Counter import FreeCAD import FreeCADGui import Path +import Path.Base.Util as PathUtil import PathScripts.PathJob as PathJob import PathScripts.PathPreferences as PathPreferences import PathScripts.PathStock as PathStock -import PathScripts.PathUtil as PathUtil import glob import os diff --git a/src/Mod/Path/PathScripts/PathJobGui.py b/src/Mod/Path/PathScripts/PathJobGui.py index e172646a7d..e17c30d375 100644 --- a/src/Mod/Path/PathScripts/PathJobGui.py +++ b/src/Mod/Path/PathScripts/PathJobGui.py @@ -28,9 +28,9 @@ from pivy import coin import FreeCAD import FreeCADGui import Path +import Path.Base.Util as PathUtil import Path.Tool.Gui.Bit as PathToolBitGui import Path.Tool.Gui.Controller as PathToolControllerGui -import PathScripts.PathGeom as PathGeom import PathScripts.PathGuiInit as PathGuiInit import PathScripts.PathJob as PathJob import PathScripts.PathJobCmd as PathJobCmd @@ -38,7 +38,6 @@ import PathScripts.PathJobDlg as PathJobDlg import PathScripts.PathPreferences as PathPreferences import PathScripts.PathSetupSheetGui as PathSetupSheetGui import PathScripts.PathStock as PathStock -import PathScripts.PathUtil as PathUtil import PathScripts.PathUtils as PathUtils import json import math @@ -1087,7 +1086,7 @@ class TaskPanel: if flip: v = axis.negative() - if PathGeom.pointsCoincide(abs(v), abs(normal)): + if Path.Geom.pointsCoincide(abs(v), abs(normal)): # Selection is already aligned with the axis of rotation leading # to a (0,0,0) cross product for rotation. # --> Need to flip the object around one of the "other" axis. @@ -1128,9 +1127,9 @@ class TaskPanel: % (normal.x, normal.y, normal.z, sub.Orientation) ) - if PathGeom.pointsCoincide(axis, normal): + if Path.Geom.pointsCoincide(axis, normal): alignSel(sel, normal, True) - elif PathGeom.pointsCoincide(axis, FreeCAD.Vector() - normal): + elif Path.Geom.pointsCoincide(axis, FreeCAD.Vector() - normal): alignSel(sel, FreeCAD.Vector() - normal, True) else: alignSel(sel, normal) @@ -1139,9 +1138,9 @@ class TaskPanel: normal = ( sub.Vertexes[1].Point - sub.Vertexes[0].Point ).normalize() - if PathGeom.pointsCoincide( + if Path.Geom.pointsCoincide( axis, normal - ) or PathGeom.pointsCoincide(axis, FreeCAD.Vector() - normal): + ) or Path.Geom.pointsCoincide(axis, FreeCAD.Vector() - normal): # Don't really know the orientation of an edge, so let's just flip the object # and if the user doesn't like it they can flip again alignSel(sel, normal, True) diff --git a/src/Mod/Path/PathScripts/PathPropertyBagGui.py b/src/Mod/Path/PathScripts/PathPropertyBagGui.py index bf7be075e7..9d45778cdd 100644 --- a/src/Mod/Path/PathScripts/PathPropertyBagGui.py +++ b/src/Mod/Path/PathScripts/PathPropertyBagGui.py @@ -24,10 +24,10 @@ from PySide import QtCore, QtGui import FreeCAD import FreeCADGui import Path +import Path.Base.PropertyBag as PathPropertyBag +import Path.Base.Util as PathUtil import PathScripts.PathIconViewProvider as PathIconViewProvider -import PathScripts.PathPropertyBag as PathPropertyBag import PathScripts.PathPropertyEditor as PathPropertyEditor -import PathScripts.PathUtil as PathUtil import re diff --git a/src/Mod/Path/PathScripts/PathSanity.py b/src/Mod/Path/PathScripts/PathSanity.py index fd980f86e2..02c79bdaf3 100644 --- a/src/Mod/Path/PathScripts/PathSanity.py +++ b/src/Mod/Path/PathScripts/PathSanity.py @@ -33,8 +33,8 @@ from PySide import QtCore, QtGui import FreeCAD import FreeCADGui import Path +import Path.Base.Util as PathUtil import PathScripts -import PathScripts.PathUtil as PathUtil import PathScripts.PathPreferences as PathPreferences from collections import Counter from datetime import datetime diff --git a/src/Mod/Path/PathScripts/PathSetupSheet.py b/src/Mod/Path/PathScripts/PathSetupSheet.py index 656ebac45c..483cd9dea6 100644 --- a/src/Mod/Path/PathScripts/PathSetupSheet.py +++ b/src/Mod/Path/PathScripts/PathSetupSheet.py @@ -22,9 +22,8 @@ import FreeCAD import Path -import PathScripts.PathGeom as PathGeom +import Path.Base.Util as PathUtil import PathScripts.PathSetupSheetOpPrototype as PathSetupSheetOpPrototype -import PathScripts.PathUtil as PathUtil from PySide.QtCore import QT_TRANSLATE_NOOP __title__ = "Setup Sheet for a Job." @@ -234,7 +233,7 @@ class SetupSheet: return None def hasDefaultToolRapids(self): - return PathGeom.isRoughly(self.obj.VertRapid.Value, 0) and PathGeom.isRoughly( + return Path.Geom.isRoughly(self.obj.VertRapid.Value, 0) and Path.Geom.isRoughly( self.obj.HorizRapid.Value, 0 ) diff --git a/src/Mod/Path/PathScripts/PathSetupSheetGui.py b/src/Mod/Path/PathScripts/PathSetupSheetGui.py index 949dc3fc71..3aa4ea3a65 100644 --- a/src/Mod/Path/PathScripts/PathSetupSheetGui.py +++ b/src/Mod/Path/PathScripts/PathSetupSheetGui.py @@ -23,12 +23,12 @@ import FreeCAD import FreeCADGui import Path +import Path.Base.Util as PathUtil import PathGui as PGui # ensure Path/Gui/Resources are loaded import PathScripts.PathGui as PathGui import PathScripts.PathIconViewProvider as PathIconViewProvider import PathScripts.PathSetupSheet as PathSetupSheet import PathScripts.PathSetupSheetOpPrototypeGui as PathSetupSheetOpPrototypeGui -import PathScripts.PathUtil as PathUtil from PySide import QtCore, QtGui diff --git a/src/Mod/Path/PathScripts/PathSimulatorGui.py b/src/Mod/Path/PathScripts/PathSimulatorGui.py index ab462c7d07..52aec327a1 100644 --- a/src/Mod/Path/PathScripts/PathSimulatorGui.py +++ b/src/Mod/Path/PathScripts/PathSimulatorGui.py @@ -22,10 +22,9 @@ import FreeCAD import Path +import Path.Base.Util as PathUtil import Path.Dressup.Utils as PathDressup import PathGui as PGui # ensure Path/Gui/Resources are loaded -import PathScripts.PathGeom as PathGeom -import PathScripts.PathUtil as PathUtil import PathScripts.PathJob as PathJob import PathSimulator import math @@ -399,14 +398,14 @@ class PathSimulation: self.PerformCutBoolean() def RapidMove(self, cmd, curpos): - path = PathGeom.edgeForCmd(cmd, curpos) # hack to overcome occ bug + path = Path.Geom.edgeForCmd(cmd, curpos) # hack to overcome occ bug if path is None: return curpos return path.valueAt(path.LastParameter) # get a solid representation of a tool going along path def GetPathSolid(self, tool, cmd, pos): - toolPath = PathGeom.edgeForCmd(cmd, pos) + toolPath = Path.Geom.edgeForCmd(cmd, pos) startDir = toolPath.tangentAt(0) startDir[2] = 0.0 endPos = toolPath.valueAt(toolPath.LastParameter) diff --git a/src/Mod/Path/PathScripts/PathUtils.py b/src/Mod/Path/PathScripts/PathUtils.py index 34c2f3b19e..dd06227c6a 100644 --- a/src/Mod/Path/PathScripts/PathUtils.py +++ b/src/Mod/Path/PathScripts/PathUtils.py @@ -25,7 +25,6 @@ import FreeCAD from FreeCAD import Vector from PySide import QtCore import Path -import PathScripts.PathGeom as PathGeom import PathScripts.PathJob as PathJob import math from numpy import linspace @@ -122,8 +121,8 @@ def horizontalEdgeLoop(obj, edge): loops = [ w for w in wires - if all(PathGeom.isHorizontal(e) for e in w.Edges) - and PathGeom.isHorizontal(Part.Face(w)) + if all(Path.Geom.isHorizontal(e) for e in w.Edges) + and Path.Geom.isHorizontal(Part.Face(w)) ] if len(loops) == 1: return loops[0] @@ -146,7 +145,7 @@ def horizontalFaceLoop(obj, face, faceList=None): faces = [ "Face%d" % (i + 1) for i, f in enumerate(obj.Shape.Faces) - if any(e.hashCode() in hashes for e in f.Edges) and PathGeom.isVertical(f) + if any(e.hashCode() in hashes for e in f.Edges) and Path.Geom.isVertical(f) ] if faceList and not all(f in faces for f in faceList): @@ -161,7 +160,7 @@ def horizontalFaceLoop(obj, face, faceList=None): # trace-backs single edge spikes don't contribute to the bound box uniqueEdges = [] for edge in outline.Edges: - if any(PathGeom.edgesMatch(edge, e) for e in uniqueEdges): + if any(Path.Geom.edgesMatch(edge, e) for e in uniqueEdges): continue uniqueEdges.append(edge) w = Part.Wire(uniqueEdges) @@ -172,10 +171,10 @@ def horizontalFaceLoop(obj, face, faceList=None): bb2 = w.BoundBox if ( w.isClosed() - and PathGeom.isRoughly(bb1.XMin, bb2.XMin) - and PathGeom.isRoughly(bb1.XMax, bb2.XMax) - and PathGeom.isRoughly(bb1.YMin, bb2.YMin) - and PathGeom.isRoughly(bb1.YMax, bb2.YMax) + and Path.Geom.isRoughly(bb1.XMin, bb2.XMin) + and Path.Geom.isRoughly(bb1.XMax, bb2.XMax) + and Path.Geom.isRoughly(bb1.YMin, bb2.YMin) + and Path.Geom.isRoughly(bb1.YMax, bb2.YMax) ): return faces return None @@ -721,7 +720,7 @@ class depth_params(object): def __filter_roughly_equal_depths(self, depths): """Depths arrive sorted from largest to smallest, positive to negative. - Return unique list of depths, using PathGeom.isRoughly() method to determine + Return unique list of depths, using Path.Geom.isRoughly() method to determine if the two values are equal. Only one of two consecutive equals are removed. The assumption is that there are not enough consecutively roughly-equal depths @@ -731,7 +730,7 @@ class depth_params(object): depthcopy = sorted(depths) # make a copy and sort low to high keep = [depthcopy[0]] for depth in depthcopy[1:]: - if not PathGeom.isRoughly(depth, keep[-1]): + if not Path.Geom.isRoughly(depth, keep[-1]): keep.append(depth) keep.reverse() # reverse results back high to low return keep diff --git a/src/Mod/Path/PathTests/PathTestUtils.py b/src/Mod/Path/PathTests/PathTestUtils.py index 492d44f77a..5df774fd71 100644 --- a/src/Mod/Path/PathTests/PathTestUtils.py +++ b/src/Mod/Path/PathTests/PathTestUtils.py @@ -22,7 +22,7 @@ import FreeCAD import Part -import PathScripts.PathGeom as PathGeom +import Path import math import unittest @@ -73,11 +73,11 @@ class PathTestBase(unittest.TestCase): self.assertCoincide(edge.valueAt(edge.FirstParameter), pt1) self.assertCoincide(edge.valueAt(edge.LastParameter), pt2) ptm = edge.valueAt((edge.LastParameter + edge.FirstParameter) / 2) - side = PathGeom.Side.of(pt2 - pt1, ptm - pt1) + side = Path.Geom.Side.of(pt2 - pt1, ptm - pt1) if "CW" == direction: - self.assertEqual(side, PathGeom.Side.Left) + self.assertEqual(side, Path.Geom.Side.Left) else: - self.assertEqual(side, PathGeom.Side.Right) + self.assertEqual(side, Path.Geom.Side.Right) def assertCircle(self, edge, pt, r): """Verivy that edge is a circle at given location.""" @@ -162,7 +162,7 @@ class PathTestBase(unittest.TestCase): e.FirstParameter + (e.LastParameter - e.FirstParameter) * fraction ) - if PathGeom.pointsCoincide(e1.Vertexes[0].Point, e2.Vertexes[0].Point): + if Path.Geom.pointsCoincide(e1.Vertexes[0].Point, e2.Vertexes[0].Point): self.assertCoincide(e1.Vertexes[-1].Point, e2.Vertexes[-1].Point) self.assertCoincide(valueAt(e1, 0.10), valueAt(e2, 0.10)) self.assertCoincide(valueAt(e1, 0.20), valueAt(e2, 0.20)) diff --git a/src/Mod/Path/PathTests/TestPathAdaptive.py b/src/Mod/Path/PathTests/TestPathAdaptive.py index 12fb52f546..4805ba7856 100644 --- a/src/Mod/Path/PathTests/TestPathAdaptive.py +++ b/src/Mod/Path/PathTests/TestPathAdaptive.py @@ -26,7 +26,6 @@ import FreeCAD import Part import Path.Op.Adaptive as PathAdaptive import PathScripts.PathJob as PathJob -import PathScripts.PathGeom as PathGeom from PathTests.PathTestUtils import PathTestBase if FreeCAD.GuiUp: diff --git a/src/Mod/Path/PathTests/TestPathGeom.py b/src/Mod/Path/PathTests/TestPathGeom.py index 87c93f5852..0a2fa38ef6 100644 --- a/src/Mod/Path/PathTests/TestPathGeom.py +++ b/src/Mod/Path/PathTests/TestPathGeom.py @@ -22,7 +22,6 @@ import Part import Path -import PathScripts.PathGeom as PathGeom import math from FreeCAD import Vector @@ -34,186 +33,186 @@ class TestPathGeom(PathTestBase): def test00(self): """Verify getAngle functionality.""" - self.assertRoughly(PathGeom.getAngle(Vector(1, 0, 0)), 0) - self.assertRoughly(PathGeom.getAngle(Vector(1, 1, 0)), math.pi / 4) - self.assertRoughly(PathGeom.getAngle(Vector(0, 1, 0)), math.pi / 2) - self.assertRoughly(PathGeom.getAngle(Vector(-1, 1, 0)), 3 * math.pi / 4) - self.assertRoughly(PathGeom.getAngle(Vector(-1, 0, 0)), math.pi) - self.assertRoughly(PathGeom.getAngle(Vector(-1, -1, 0)), -3 * math.pi / 4) - self.assertRoughly(PathGeom.getAngle(Vector(0, -1, 0)), -math.pi / 2) - self.assertRoughly(PathGeom.getAngle(Vector(1, -1, 0)), -math.pi / 4) + self.assertRoughly(Path.Geom.getAngle(Vector(1, 0, 0)), 0) + self.assertRoughly(Path.Geom.getAngle(Vector(1, 1, 0)), math.pi / 4) + self.assertRoughly(Path.Geom.getAngle(Vector(0, 1, 0)), math.pi / 2) + self.assertRoughly(Path.Geom.getAngle(Vector(-1, 1, 0)), 3 * math.pi / 4) + self.assertRoughly(Path.Geom.getAngle(Vector(-1, 0, 0)), math.pi) + self.assertRoughly(Path.Geom.getAngle(Vector(-1, -1, 0)), -3 * math.pi / 4) + self.assertRoughly(Path.Geom.getAngle(Vector(0, -1, 0)), -math.pi / 2) + self.assertRoughly(Path.Geom.getAngle(Vector(1, -1, 0)), -math.pi / 4) def test01(self): """Verify diffAngle functionality.""" self.assertRoughly( - PathGeom.diffAngle(0, +0 * math.pi / 4, "CW") / math.pi, 0 / 4.0 + Path.Geom.diffAngle(0, +0 * math.pi / 4, "CW") / math.pi, 0 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(0, +3 * math.pi / 4, "CW") / math.pi, 5 / 4.0 + Path.Geom.diffAngle(0, +3 * math.pi / 4, "CW") / math.pi, 5 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(0, -3 * math.pi / 4, "CW") / math.pi, 3 / 4.0 + Path.Geom.diffAngle(0, -3 * math.pi / 4, "CW") / math.pi, 3 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(0, +4 * math.pi / 4, "CW") / math.pi, 4 / 4.0 + Path.Geom.diffAngle(0, +4 * math.pi / 4, "CW") / math.pi, 4 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(0, +0 * math.pi / 4, "CCW") / math.pi, 0 / 4.0 + Path.Geom.diffAngle(0, +0 * math.pi / 4, "CCW") / math.pi, 0 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(0, +3 * math.pi / 4, "CCW") / math.pi, 3 / 4.0 + Path.Geom.diffAngle(0, +3 * math.pi / 4, "CCW") / math.pi, 3 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(0, -3 * math.pi / 4, "CCW") / math.pi, 5 / 4.0 + Path.Geom.diffAngle(0, -3 * math.pi / 4, "CCW") / math.pi, 5 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(0, +4 * math.pi / 4, "CCW") / math.pi, 4 / 4.0 + Path.Geom.diffAngle(0, +4 * math.pi / 4, "CCW") / math.pi, 4 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(+math.pi / 4, +0 * math.pi / 4, "CW") / math.pi, 1 / 4.0 + Path.Geom.diffAngle(+math.pi / 4, +0 * math.pi / 4, "CW") / math.pi, 1 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(+math.pi / 4, +3 * math.pi / 4, "CW") / math.pi, 6 / 4.0 + Path.Geom.diffAngle(+math.pi / 4, +3 * math.pi / 4, "CW") / math.pi, 6 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(+math.pi / 4, -1 * math.pi / 4, "CW") / math.pi, 2 / 4.0 + Path.Geom.diffAngle(+math.pi / 4, -1 * math.pi / 4, "CW") / math.pi, 2 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(-math.pi / 4, +0 * math.pi / 4, "CW") / math.pi, 7 / 4.0 + Path.Geom.diffAngle(-math.pi / 4, +0 * math.pi / 4, "CW") / math.pi, 7 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(-math.pi / 4, +3 * math.pi / 4, "CW") / math.pi, 4 / 4.0 + Path.Geom.diffAngle(-math.pi / 4, +3 * math.pi / 4, "CW") / math.pi, 4 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(-math.pi / 4, -1 * math.pi / 4, "CW") / math.pi, 0 / 4.0 + Path.Geom.diffAngle(-math.pi / 4, -1 * math.pi / 4, "CW") / math.pi, 0 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(+math.pi / 4, +0 * math.pi / 4, "CCW") / math.pi, 7 / 4.0 + Path.Geom.diffAngle(+math.pi / 4, +0 * math.pi / 4, "CCW") / math.pi, 7 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(+math.pi / 4, +3 * math.pi / 4, "CCW") / math.pi, 2 / 4.0 + Path.Geom.diffAngle(+math.pi / 4, +3 * math.pi / 4, "CCW") / math.pi, 2 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(+math.pi / 4, -1 * math.pi / 4, "CCW") / math.pi, 6 / 4.0 + Path.Geom.diffAngle(+math.pi / 4, -1 * math.pi / 4, "CCW") / math.pi, 6 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(-math.pi / 4, +0 * math.pi / 4, "CCW") / math.pi, 1 / 4.0 + Path.Geom.diffAngle(-math.pi / 4, +0 * math.pi / 4, "CCW") / math.pi, 1 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(-math.pi / 4, +3 * math.pi / 4, "CCW") / math.pi, 4 / 4.0 + Path.Geom.diffAngle(-math.pi / 4, +3 * math.pi / 4, "CCW") / math.pi, 4 / 4.0 ) self.assertRoughly( - PathGeom.diffAngle(-math.pi / 4, -1 * math.pi / 4, "CCW") / math.pi, 0 / 4.0 + Path.Geom.diffAngle(-math.pi / 4, -1 * math.pi / 4, "CCW") / math.pi, 0 / 4.0 ) def test02(self): """Verify isVertical/isHorizontal for Vector""" - self.assertTrue(PathGeom.isVertical(Vector(0, 0, 1))) - self.assertTrue(PathGeom.isVertical(Vector(0, 0, -1))) - self.assertFalse(PathGeom.isVertical(Vector(1, 0, 1))) - self.assertFalse(PathGeom.isVertical(Vector(1, 0, -1))) + self.assertTrue(Path.Geom.isVertical(Vector(0, 0, 1))) + self.assertTrue(Path.Geom.isVertical(Vector(0, 0, -1))) + self.assertFalse(Path.Geom.isVertical(Vector(1, 0, 1))) + self.assertFalse(Path.Geom.isVertical(Vector(1, 0, -1))) - self.assertTrue(PathGeom.isHorizontal(Vector(1, 0, 0))) - self.assertTrue(PathGeom.isHorizontal(Vector(-1, 0, 0))) - self.assertTrue(PathGeom.isHorizontal(Vector(0, 1, 0))) - self.assertTrue(PathGeom.isHorizontal(Vector(0, -1, 0))) - self.assertTrue(PathGeom.isHorizontal(Vector(1, 1, 0))) - self.assertTrue(PathGeom.isHorizontal(Vector(-1, 1, 0))) - self.assertTrue(PathGeom.isHorizontal(Vector(1, -1, 0))) - self.assertTrue(PathGeom.isHorizontal(Vector(-1, -1, 0))) + self.assertTrue(Path.Geom.isHorizontal(Vector(1, 0, 0))) + self.assertTrue(Path.Geom.isHorizontal(Vector(-1, 0, 0))) + self.assertTrue(Path.Geom.isHorizontal(Vector(0, 1, 0))) + self.assertTrue(Path.Geom.isHorizontal(Vector(0, -1, 0))) + self.assertTrue(Path.Geom.isHorizontal(Vector(1, 1, 0))) + self.assertTrue(Path.Geom.isHorizontal(Vector(-1, 1, 0))) + self.assertTrue(Path.Geom.isHorizontal(Vector(1, -1, 0))) + self.assertTrue(Path.Geom.isHorizontal(Vector(-1, -1, 0))) - self.assertFalse(PathGeom.isHorizontal(Vector(0, 1, 1))) - self.assertFalse(PathGeom.isHorizontal(Vector(0, -1, 1))) - self.assertFalse(PathGeom.isHorizontal(Vector(0, 1, -1))) - self.assertFalse(PathGeom.isHorizontal(Vector(0, -1, -1))) + self.assertFalse(Path.Geom.isHorizontal(Vector(0, 1, 1))) + self.assertFalse(Path.Geom.isHorizontal(Vector(0, -1, 1))) + self.assertFalse(Path.Geom.isHorizontal(Vector(0, 1, -1))) + self.assertFalse(Path.Geom.isHorizontal(Vector(0, -1, -1))) def test03(self): """Verify isVertical/isHorizontal for Edges""" # lines self.assertTrue( - PathGeom.isVertical( + Path.Geom.isVertical( Part.Edge(Part.LineSegment(Vector(-1, -1, -1), Vector(-1, -1, 8))) ) ) self.assertFalse( - PathGeom.isVertical( + Path.Geom.isVertical( Part.Edge(Part.LineSegment(Vector(-1, -1, -1), Vector(1, -1, 8))) ) ) self.assertFalse( - PathGeom.isVertical( + Path.Geom.isVertical( Part.Edge(Part.LineSegment(Vector(-1, -1, -1), Vector(-1, 1, 8))) ) ) self.assertTrue( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.LineSegment(Vector(1, -1, -1), Vector(-1, -1, -1))) ) ) self.assertTrue( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.LineSegment(Vector(-1, 1, -1), Vector(-1, -1, -1))) ) ) self.assertTrue( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.LineSegment(Vector(1, 1, -1), Vector(-1, -1, -1))) ) ) self.assertFalse( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.LineSegment(Vector(1, -1, -1), Vector(1, -1, 8))) ) ) self.assertFalse( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.LineSegment(Vector(-1, 1, -1), Vector(-1, 1, 8))) ) ) # circles self.assertTrue( - PathGeom.isVertical( + Path.Geom.isVertical( Part.Edge(Part.makeCircle(4, Vector(), Vector(0, 1, 0))) ) ) self.assertTrue( - PathGeom.isVertical( + Path.Geom.isVertical( Part.Edge(Part.makeCircle(4, Vector(), Vector(1, 0, 0))) ) ) self.assertTrue( - PathGeom.isVertical( + Path.Geom.isVertical( Part.Edge(Part.makeCircle(4, Vector(), Vector(1, 1, 0))) ) ) self.assertFalse( - PathGeom.isVertical( + Path.Geom.isVertical( Part.Edge(Part.makeCircle(4, Vector(), Vector(1, 1, 1))) ) ) self.assertTrue( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.makeCircle(4, Vector(), Vector(0, 0, 1))) ) ) self.assertFalse( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.makeCircle(4, Vector(), Vector(0, 1, 1))) ) ) self.assertFalse( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.makeCircle(4, Vector(), Vector(1, 0, 1))) ) ) self.assertFalse( - PathGeom.isHorizontal( + Path.Geom.isHorizontal( Part.Edge(Part.makeCircle(4, Vector(), Vector(1, 1, 1))) ) ) @@ -223,21 +222,21 @@ class TestPathGeom(PathTestBase): # and now I disable the tests because they seem to fail on OCE # bezier = Part.BezierCurve() # bezier.setPoles([Vector(), Vector(1,1,0), Vector(2,1,0), Vector(2,2,0)]) - # self.assertTrue(PathGeom.isHorizontal(Part.Edge(bezier))) - # self.assertFalse(PathGeom.isVertical(Part.Edge(bezier))) + # self.assertTrue(Path.Geom.isHorizontal(Part.Edge(bezier))) + # self.assertFalse(Path.Geom.isVertical(Part.Edge(bezier))) # bezier.setPoles([Vector(), Vector(1,1,1), Vector(2,1,0), Vector(2,2,0)]) - # self.assertFalse(PathGeom.isHorizontal(Part.Edge(bezier))) - # self.assertFalse(PathGeom.isVertical(Part.Edge(bezier))) + # self.assertFalse(Path.Geom.isHorizontal(Part.Edge(bezier))) + # self.assertFalse(Path.Geom.isVertical(Part.Edge(bezier))) # bezier.setPoles([Vector(), Vector(1,1,0), Vector(2,1,1), Vector(2,2,0)]) - # self.assertFalse(PathGeom.isHorizontal(Part.Edge(bezier))) - # self.assertFalse(PathGeom.isVertical(Part.Edge(bezier))) + # self.assertFalse(Path.Geom.isHorizontal(Part.Edge(bezier))) + # self.assertFalse(Path.Geom.isVertical(Part.Edge(bezier))) # bezier.setPoles([Vector(), Vector(1,1,0), Vector(2,1,0), Vector(2,2,1)]) - # self.assertFalse(PathGeom.isHorizontal(Part.Edge(bezier))) - # self.assertFalse(PathGeom.isVertical(Part.Edge(bezier))) + # self.assertFalse(Path.Geom.isHorizontal(Part.Edge(bezier))) + # self.assertFalse(Path.Geom.isVertical(Part.Edge(bezier))) # # bezier.setPoles([Vector(), Vector(1,1,1), Vector(2,2,2), Vector(0,0,3)]) - # self.assertFalse(PathGeom.isHorizontal(Part.Edge(bezier))) - # self.assertTrue(PathGeom.isVertical(Part.Edge(bezier))) + # self.assertFalse(Path.Geom.isHorizontal(Part.Edge(bezier))) + # self.assertTrue(Path.Geom.isVertical(Part.Edge(bezier))) def test04(self): """Verify isVertical/isHorizontal for faces""" @@ -250,19 +249,19 @@ class TestPathGeom(PathTestBase): xzPlane = Part.makePlane(100, 100, Vector(), Vector(1, 0, 1)) yzPlane = Part.makePlane(100, 100, Vector(), Vector(0, 1, 1)) - self.assertTrue(PathGeom.isVertical(xPlane)) - self.assertTrue(PathGeom.isVertical(yPlane)) - self.assertFalse(PathGeom.isVertical(zPlane)) - self.assertTrue(PathGeom.isVertical(xyPlane)) - self.assertFalse(PathGeom.isVertical(xzPlane)) - self.assertFalse(PathGeom.isVertical(yzPlane)) + self.assertTrue(Path.Geom.isVertical(xPlane)) + self.assertTrue(Path.Geom.isVertical(yPlane)) + self.assertFalse(Path.Geom.isVertical(zPlane)) + self.assertTrue(Path.Geom.isVertical(xyPlane)) + self.assertFalse(Path.Geom.isVertical(xzPlane)) + self.assertFalse(Path.Geom.isVertical(yzPlane)) - self.assertFalse(PathGeom.isHorizontal(xPlane)) - self.assertFalse(PathGeom.isHorizontal(yPlane)) - self.assertTrue(PathGeom.isHorizontal(zPlane)) - self.assertFalse(PathGeom.isHorizontal(xyPlane)) - self.assertFalse(PathGeom.isHorizontal(xzPlane)) - self.assertFalse(PathGeom.isHorizontal(yzPlane)) + self.assertFalse(Path.Geom.isHorizontal(xPlane)) + self.assertFalse(Path.Geom.isHorizontal(yPlane)) + self.assertTrue(Path.Geom.isHorizontal(zPlane)) + self.assertFalse(Path.Geom.isHorizontal(xyPlane)) + self.assertFalse(Path.Geom.isHorizontal(xzPlane)) + self.assertFalse(Path.Geom.isHorizontal(yzPlane)) # cylinders xCylinder = [ @@ -296,92 +295,92 @@ class TestPathGeom(PathTestBase): if type(f.Surface) == Part.Cylinder ][0] - self.assertTrue(PathGeom.isHorizontal(xCylinder)) - self.assertTrue(PathGeom.isHorizontal(yCylinder)) - self.assertFalse(PathGeom.isHorizontal(zCylinder)) - self.assertTrue(PathGeom.isHorizontal(xyCylinder)) - self.assertFalse(PathGeom.isHorizontal(xzCylinder)) - self.assertFalse(PathGeom.isHorizontal(yzCylinder)) + self.assertTrue(Path.Geom.isHorizontal(xCylinder)) + self.assertTrue(Path.Geom.isHorizontal(yCylinder)) + self.assertFalse(Path.Geom.isHorizontal(zCylinder)) + self.assertTrue(Path.Geom.isHorizontal(xyCylinder)) + self.assertFalse(Path.Geom.isHorizontal(xzCylinder)) + self.assertFalse(Path.Geom.isHorizontal(yzCylinder)) def test07(self): """Verify speed interpolation works for different pitches""" # horizontal self.assertRoughly( - 100, PathGeom.speedBetweenPoints(Vector(), Vector(1, 1, 0), 100, 50) + 100, Path.Geom.speedBetweenPoints(Vector(), Vector(1, 1, 0), 100, 50) ) self.assertRoughly( - 100, PathGeom.speedBetweenPoints(Vector(1, 1, 0), Vector(), 100, 50) + 100, Path.Geom.speedBetweenPoints(Vector(1, 1, 0), Vector(), 100, 50) ) # vertical self.assertRoughly( - 50, PathGeom.speedBetweenPoints(Vector(), Vector(0, 0, 1), 100, 50) + 50, Path.Geom.speedBetweenPoints(Vector(), Vector(0, 0, 1), 100, 50) ) self.assertRoughly( - 50, PathGeom.speedBetweenPoints(Vector(0, 0, 1), Vector(), 100, 50) + 50, Path.Geom.speedBetweenPoints(Vector(0, 0, 1), Vector(), 100, 50) ) # 45° self.assertRoughly( - 75, PathGeom.speedBetweenPoints(Vector(), Vector(1, 0, 1), 100, 50) + 75, Path.Geom.speedBetweenPoints(Vector(), Vector(1, 0, 1), 100, 50) ) self.assertRoughly( - 75, PathGeom.speedBetweenPoints(Vector(), Vector(0, 1, 1), 100, 50) + 75, Path.Geom.speedBetweenPoints(Vector(), Vector(0, 1, 1), 100, 50) ) self.assertRoughly( 75, - PathGeom.speedBetweenPoints(Vector(), Vector(0.707, 0.707, 1), 100, 50), + Path.Geom.speedBetweenPoints(Vector(), Vector(0.707, 0.707, 1), 100, 50), 0.01, ) self.assertRoughly( - 75, PathGeom.speedBetweenPoints(Vector(1, 0, 1), Vector(), 100, 50) + 75, Path.Geom.speedBetweenPoints(Vector(1, 0, 1), Vector(), 100, 50) ) self.assertRoughly( - 75, PathGeom.speedBetweenPoints(Vector(0, 1, 1), Vector(), 100, 50) + 75, Path.Geom.speedBetweenPoints(Vector(0, 1, 1), Vector(), 100, 50) ) self.assertRoughly( 75, - PathGeom.speedBetweenPoints(Vector(0.707, 0.707, 1), Vector(), 100, 50), + Path.Geom.speedBetweenPoints(Vector(0.707, 0.707, 1), Vector(), 100, 50), 0.01, ) # 30° self.assertRoughly( 66.66, - PathGeom.speedBetweenPoints(Vector(), Vector(0.5774, 0, 1), 100, 50), + Path.Geom.speedBetweenPoints(Vector(), Vector(0.5774, 0, 1), 100, 50), 0.01, ) self.assertRoughly( 66.66, - PathGeom.speedBetweenPoints(Vector(), Vector(0, 0.5774, 1), 100, 50), + Path.Geom.speedBetweenPoints(Vector(), Vector(0, 0.5774, 1), 100, 50), 0.01, ) self.assertRoughly( 66.66, - PathGeom.speedBetweenPoints(Vector(0.5774, 0, 1), Vector(), 100, 50), + Path.Geom.speedBetweenPoints(Vector(0.5774, 0, 1), Vector(), 100, 50), 0.01, ) self.assertRoughly( 66.66, - PathGeom.speedBetweenPoints(Vector(0, 0.5774, 1), Vector(), 100, 50), + Path.Geom.speedBetweenPoints(Vector(0, 0.5774, 1), Vector(), 100, 50), 0.01, ) # 60° self.assertRoughly( 83.33, - PathGeom.speedBetweenPoints(Vector(), Vector(1, 0, 0.5774), 100, 50), + Path.Geom.speedBetweenPoints(Vector(), Vector(1, 0, 0.5774), 100, 50), 0.01, ) self.assertRoughly( 83.33, - PathGeom.speedBetweenPoints(Vector(), Vector(0, 1, 0.5774), 100, 50), + Path.Geom.speedBetweenPoints(Vector(), Vector(0, 1, 0.5774), 100, 50), 0.01, ) self.assertRoughly( 83.33, - PathGeom.speedBetweenPoints(Vector(1, 0, 0.5774), Vector(), 100, 50), + Path.Geom.speedBetweenPoints(Vector(1, 0, 0.5774), Vector(), 100, 50), 0.01, ) self.assertRoughly( 83.33, - PathGeom.speedBetweenPoints(Vector(0, 1, 0.5774), Vector(), 100, 50), + Path.Geom.speedBetweenPoints(Vector(0, 1, 0.5774), Vector(), 100, 50), 0.01, ) @@ -389,81 +388,81 @@ class TestPathGeom(PathTestBase): """Verify speed interpolation works for different pitches if vSpeed > hSpeed""" # horizontal self.assertRoughly( - 50, PathGeom.speedBetweenPoints(Vector(), Vector(1, 1, 0), 50, 100) + 50, Path.Geom.speedBetweenPoints(Vector(), Vector(1, 1, 0), 50, 100) ) self.assertRoughly( - 50, PathGeom.speedBetweenPoints(Vector(1, 1, 0), Vector(), 50, 100) + 50, Path.Geom.speedBetweenPoints(Vector(1, 1, 0), Vector(), 50, 100) ) # vertical self.assertRoughly( - 100, PathGeom.speedBetweenPoints(Vector(), Vector(0, 0, 1), 50, 100) + 100, Path.Geom.speedBetweenPoints(Vector(), Vector(0, 0, 1), 50, 100) ) self.assertRoughly( - 100, PathGeom.speedBetweenPoints(Vector(0, 0, 1), Vector(), 50, 100) + 100, Path.Geom.speedBetweenPoints(Vector(0, 0, 1), Vector(), 50, 100) ) # 45° self.assertRoughly( - 75, PathGeom.speedBetweenPoints(Vector(), Vector(1, 0, 1), 50, 100) + 75, Path.Geom.speedBetweenPoints(Vector(), Vector(1, 0, 1), 50, 100) ) self.assertRoughly( - 75, PathGeom.speedBetweenPoints(Vector(), Vector(0, 1, 1), 50, 100) + 75, Path.Geom.speedBetweenPoints(Vector(), Vector(0, 1, 1), 50, 100) ) self.assertRoughly( 75, - PathGeom.speedBetweenPoints(Vector(), Vector(0.707, 0.707, 1), 50, 100), + Path.Geom.speedBetweenPoints(Vector(), Vector(0.707, 0.707, 1), 50, 100), 0.01, ) self.assertRoughly( - 75, PathGeom.speedBetweenPoints(Vector(1, 0, 1), Vector(), 50, 100) + 75, Path.Geom.speedBetweenPoints(Vector(1, 0, 1), Vector(), 50, 100) ) self.assertRoughly( - 75, PathGeom.speedBetweenPoints(Vector(0, 1, 1), Vector(), 50, 100) + 75, Path.Geom.speedBetweenPoints(Vector(0, 1, 1), Vector(), 50, 100) ) self.assertRoughly( 75, - PathGeom.speedBetweenPoints(Vector(0.707, 0.707, 1), Vector(), 50, 100), + Path.Geom.speedBetweenPoints(Vector(0.707, 0.707, 1), Vector(), 50, 100), 0.01, ) # 30° self.assertRoughly( 83.33, - PathGeom.speedBetweenPoints(Vector(), Vector(0.5774, 0, 1), 50, 100), + Path.Geom.speedBetweenPoints(Vector(), Vector(0.5774, 0, 1), 50, 100), 0.01, ) self.assertRoughly( 83.33, - PathGeom.speedBetweenPoints(Vector(), Vector(0, 0.5774, 1), 50, 100), + Path.Geom.speedBetweenPoints(Vector(), Vector(0, 0.5774, 1), 50, 100), 0.01, ) self.assertRoughly( 83.33, - PathGeom.speedBetweenPoints(Vector(0.5774, 0, 1), Vector(), 50, 100), + Path.Geom.speedBetweenPoints(Vector(0.5774, 0, 1), Vector(), 50, 100), 0.01, ) self.assertRoughly( 83.33, - PathGeom.speedBetweenPoints(Vector(0, 0.5774, 1), Vector(), 50, 100), + Path.Geom.speedBetweenPoints(Vector(0, 0.5774, 1), Vector(), 50, 100), 0.01, ) # 60° self.assertRoughly( 66.66, - PathGeom.speedBetweenPoints(Vector(), Vector(1, 0, 0.5774), 50, 100), + Path.Geom.speedBetweenPoints(Vector(), Vector(1, 0, 0.5774), 50, 100), 0.01, ) self.assertRoughly( 66.66, - PathGeom.speedBetweenPoints(Vector(), Vector(0, 1, 0.5774), 50, 100), + Path.Geom.speedBetweenPoints(Vector(), Vector(0, 1, 0.5774), 50, 100), 0.01, ) self.assertRoughly( 66.66, - PathGeom.speedBetweenPoints(Vector(1, 0, 0.5774), Vector(), 50, 100), + Path.Geom.speedBetweenPoints(Vector(1, 0, 0.5774), Vector(), 50, 100), 0.01, ) self.assertRoughly( 66.66, - PathGeom.speedBetweenPoints(Vector(0, 1, 0.5774), Vector(), 50, 100), + Path.Geom.speedBetweenPoints(Vector(0, 1, 0.5774), Vector(), 50, 100), 0.01, ) @@ -471,12 +470,12 @@ class TestPathGeom(PathTestBase): """Verify proper geometry objects for G1 and G01 commands are created.""" spt = Vector(1, 2, 3) self.assertLine( - PathGeom.edgeForCmd(Path.Command("G1", {"X": 7, "Y": 2, "Z": 3}), spt), + Path.Geom.edgeForCmd(Path.Command("G1", {"X": 7, "Y": 2, "Z": 3}), spt), spt, Vector(7, 2, 3), ) self.assertLine( - PathGeom.edgeForCmd(Path.Command("G01", {"X": 1, "Y": 3, "Z": 5}), spt), + Path.Geom.edgeForCmd(Path.Command("G01", {"X": 1, "Y": 3, "Z": 5}), spt), spt, Vector(1, 3, 5), ) @@ -486,7 +485,7 @@ class TestPathGeom(PathTestBase): p1 = Vector(0, -1, 2) p2 = Vector(-1, 0, 2) self.assertArc( - PathGeom.edgeForCmd( + Path.Geom.edgeForCmd( Path.Command( "G2", {"X": p2.x, "Y": p2.y, "Z": p2.z, "I": 0, "J": 1, "K": 0} ), @@ -497,7 +496,7 @@ class TestPathGeom(PathTestBase): "CW", ) self.assertArc( - PathGeom.edgeForCmd( + Path.Geom.edgeForCmd( Path.Command( "G3", {"X": p1.x, "Y": p1.y, "z": p1.z, "I": -1, "J": 0, "K": 0} ), @@ -514,7 +513,7 @@ class TestPathGeom(PathTestBase): p1 = Vector(0, 1, 0) p2 = Vector(1, 0, 2) self.assertCurve( - PathGeom.edgeForCmd( + Path.Geom.edgeForCmd( Path.Command( "G2", {"X": p2.x, "Y": p2.y, "Z": p2.z, "I": 0, "J": -1, "K": 1} ), @@ -527,7 +526,7 @@ class TestPathGeom(PathTestBase): p1 = Vector(-1, 0, 0) p2 = Vector(0, -1, 2) self.assertCurve( - PathGeom.edgeForCmd( + Path.Geom.edgeForCmd( Path.Command( "G3", {"X": p2.x, "Y": p2.y, "Z": p2.z, "I": 1, "J": 0, "K": 1} ), @@ -542,7 +541,7 @@ class TestPathGeom(PathTestBase): p1 = Vector(0, -1, 2) p2 = Vector(-1, 0, 0) self.assertCurve( - PathGeom.edgeForCmd( + Path.Geom.edgeForCmd( Path.Command( "G2", {"X": p2.x, "Y": p2.y, "Z": p2.z, "I": 0, "J": 1, "K": -1} ), @@ -555,7 +554,7 @@ class TestPathGeom(PathTestBase): p1 = Vector(-1, 0, 2) p2 = Vector(0, -1, 0) self.assertCurve( - PathGeom.edgeForCmd( + Path.Geom.edgeForCmd( Path.Command( "G3", {"X": p2.x, "Y": p2.y, "Z": p2.z, "I": 1, "J": 0, "K": -1} ), @@ -574,7 +573,7 @@ class TestPathGeom(PathTestBase): p4 = Vector(+10, 0, 0) def cmds(pa, pb, pc, flip): - return PathGeom.cmdsForEdge(Part.Edge(Part.Arc(pa, pb, pc)), flip)[0] + return Path.Geom.cmdsForEdge(Part.Edge(Part.Arc(pa, pb, pc)), flip)[0] def cmd(g, end, off): return Path.Command( @@ -608,7 +607,7 @@ class TestPathGeom(PathTestBase): def cmds(center, radius, up=True): norm = Vector(0, 0, 1) if up else Vector(0, 0, -1) - return PathGeom.cmdsForEdge(Part.Edge(Part.Circle(center, norm, radius)))[0] + return Path.Geom.cmdsForEdge(Part.Edge(Part.Circle(center, norm, radius)))[0] def cmd(g, end, off): return Path.Command( @@ -633,7 +632,7 @@ class TestPathGeom(PathTestBase): def test42(self): """Verify ellipsis results in a proper segmentation of G1 commands.""" ellipse = Part.Edge(Part.Ellipse()) - cmds = PathGeom.cmdsForEdge(ellipse) + cmds = Path.Geom.cmdsForEdge(ellipse) # let's make sure all commands are G1 and there are more than 20 of those self.assertGreater(len(cmds), 20) self.assertTrue(all([cmd.Name == "G1" for cmd in cmds])) @@ -646,16 +645,16 @@ class TestPathGeom(PathTestBase): commands.append(Path.Command("G0", {"X": 0})) commands.append(Path.Command("G1", {"Y": 0})) - wire, rapid = PathGeom.wireForPath(Path.Path(commands)) + wire, rapid = Path.Geom.wireForPath(Path.Path(commands)) self.assertEqual(len(wire.Edges), 4) self.assertLine(wire.Edges[0], Vector(0, 0, 0), Vector(1, 0, 0)) self.assertLine(wire.Edges[1], Vector(1, 0, 0), Vector(1, 1, 0)) self.assertLine(wire.Edges[2], Vector(1, 1, 0), Vector(0, 1, 0)) self.assertLine(wire.Edges[3], Vector(0, 1, 0), Vector(0, 0, 0)) self.assertEqual(len(rapid), 1) - self.assertTrue(PathGeom.edgesMatch(rapid[0], wire.Edges[2])) + self.assertTrue(Path.Geom.edgesMatch(rapid[0], wire.Edges[2])) - wires = PathGeom.wiresForPath(Path.Path(commands)) + wires = Path.Geom.wiresForPath(Path.Path(commands)) self.assertEqual(len(wires), 2) self.assertEqual(len(wires[0].Edges), 2) self.assertLine(wires[0].Edges[0], Vector(0, 0, 0), Vector(1, 0, 0)) @@ -669,15 +668,15 @@ class TestPathGeom(PathTestBase): p2 = Vector(0, 0, 0) p3 = Vector(10, 10, 0) - e = PathGeom.arcToHelix(Part.Edge(Part.Arc(p1, p2, p3)), 0, 2) + e = Path.Geom.arcToHelix(Part.Edge(Part.Arc(p1, p2, p3)), 0, 2) self.assertCurve(e, p1, p2 + Vector(0, 0, 1), p3 + Vector(0, 0, 2)) - e = PathGeom.arcToHelix(Part.Edge(Part.Arc(p1, p2, p3)), 3, 7) + e = Path.Geom.arcToHelix(Part.Edge(Part.Arc(p1, p2, p3)), 3, 7) self.assertCurve( e, p1 + Vector(0, 0, 3), p2 + Vector(0, 0, 5), p3 + Vector(0, 0, 7) ) - e = PathGeom.arcToHelix(Part.Edge(Part.Arc(p1, p2, p3)), 9, 1) + e = Path.Geom.arcToHelix(Part.Edge(Part.Arc(p1, p2, p3)), 9, 1) self.assertCurve( e, p1 + Vector(0, 0, 9), p2 + Vector(0, 0, 5), p3 + Vector(0, 0, 1) ) @@ -687,16 +686,16 @@ class TestPathGeom(PathTestBase): p12 = p2 + dz p13 = p3 + dz - e = PathGeom.arcToHelix(Part.Edge(Part.Arc(p11, p12, p13)), 0, 8) + e = Path.Geom.arcToHelix(Part.Edge(Part.Arc(p11, p12, p13)), 0, 8) self.assertCurve(e, p1, p2 + Vector(0, 0, 4), p3 + Vector(0, 0, 8)) - e = PathGeom.arcToHelix(Part.Edge(Part.Arc(p11, p12, p13)), 2, -2) + e = Path.Geom.arcToHelix(Part.Edge(Part.Arc(p11, p12, p13)), 2, -2) self.assertCurve(e, p1 + Vector(0, 0, 2), p2, p3 + Vector(0, 0, -2)) p1 = Vector(10, -10, 1) p2 = Vector(10 - 10 * math.sin(math.pi / 4), -10 * math.cos(math.pi / 4), 1) p3 = Vector(0, 0, 1) - e = PathGeom.arcToHelix(Part.Edge(Part.Arc(p1, p2, p3)), 0, 5) + e = Path.Geom.arcToHelix(Part.Edge(Part.Arc(p1, p2, p3)), 0, 5) self.assertCurve( e, Vector(10, -10, 0), Vector(p2.x, p2.y, 2.5), Vector(0, 0, 5) ) @@ -713,7 +712,7 @@ class TestPathGeom(PathTestBase): p12 = Vector(10 - o, -o, 0) p23 = Vector(10 - o, +o, 0) - e = PathGeom.splitArcAt(arc, p2) + e = Path.Geom.splitArcAt(arc, p2) self.assertCurve(e[0], p1, p12, p2) self.assertCurve(e[1], p2, p23, p3) @@ -724,7 +723,7 @@ class TestPathGeom(PathTestBase): 10 - 10 * math.sin(5 * math.pi / 8), -10 * math.cos(5 * math.pi / 8), 0 ) - e = PathGeom.splitArcAt(arc, p12) + e = Path.Geom.splitArcAt(arc, p12) self.assertCurve(e[0], p1, p34, p12) self.assertCurve(e[1], p12, p45, p3) @@ -732,7 +731,7 @@ class TestPathGeom(PathTestBase): """Verify splitEdgeAt.""" # split a line segment - e = PathGeom.splitEdgeAt( + e = Path.Geom.splitEdgeAt( Part.Edge(Part.LineSegment(Vector(), Vector(2, 4, 6))), Vector(1, 2, 3) ) self.assertLine(e[0], Vector(), Vector(1, 2, 3)) @@ -743,7 +742,7 @@ class TestPathGeom(PathTestBase): p2 = Vector(0, 0, 1) p3 = Vector(10, 10, 1) arc = Part.Edge(Part.Arc(p1, p2, p3)) - e = PathGeom.splitEdgeAt(arc, p2) + e = Path.Geom.splitEdgeAt(arc, p2) o = 10 * math.sin(math.pi / 4) p12 = Vector(10 - o, -o, 1) p23 = Vector(10 - o, +o, 1) @@ -754,10 +753,10 @@ class TestPathGeom(PathTestBase): p1 = Vector(10, -10, 0) p2 = Vector(0, 0, 5) p3 = Vector(10, 10, 10) - h = PathGeom.arcToHelix(arc, 0, 10) + h = Path.Geom.arcToHelix(arc, 0, 10) self.assertCurve(h, p1, p2, p3) - e = PathGeom.splitEdgeAt(h, p2) + e = Path.Geom.splitEdgeAt(h, p2) o = 10 * math.sin(math.pi / 4) p12 = Vector(10 - o, -o, 2.5) p23 = Vector(10 - o, +o, 7.5) @@ -774,7 +773,7 @@ class TestPathGeom(PathTestBase): ac = arc.Curve.Center s = Vector(434.54, 378.26, 1) - head, tail = PathGeom.splitEdgeAt(arc, s) + head, tail = Path.Geom.splitEdgeAt(arc, s) # make sure the arcs connect as they should self.assertCoincide( @@ -802,59 +801,59 @@ class TestPathGeom(PathTestBase): def test70(self): """Flip a line.""" edge = Part.Edge(Part.Line(Vector(0, 0, 0), Vector(3, 2, 1))) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.Edge(Part.Line(Vector(0, 0, 0), Vector(-3, -2, -1))) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) def test71(self): """Flip a line segment.""" edge = Part.Edge(Part.LineSegment(Vector(0, 0, 0), Vector(3, 2, 1))) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.Edge(Part.LineSegment(Vector(4, 2, 1), Vector(-3, -7, 9))) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.makeLine(Vector(1, 0, 3), Vector(3, 2, 1)) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) def test72(self): """Flip a circle""" edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, 1)) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, -1)) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) def test73(self): """Flip an arc""" # make sure all 4 quadrants work edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, 1), 45, 90) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, 1), 100, 170) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, 1), 200, 250) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, 1), 300, 340) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) # and the other way around too edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, -1), 45, 90) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, -1), 100, 170) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, -1), 200, 250) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, -1), 300, 340) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) def test74(self): """Flip a rotated arc""" # oh yes ... edge = Part.makeCircle(3, Vector(1, 3, 2), Vector(0, 0, 1), 45, 90) edge.rotate(edge.Curve.Center, Vector(0, 0, 1), -90) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) def test75(self): """Flip a B-spline""" @@ -863,7 +862,7 @@ class TestPathGeom(PathTestBase): [Vector(1, 2, 3), Vector(-3, 0, 7), Vector(-3, 1, 9), Vector(1, 3, 5)] ) edge = Part.Edge(spline) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) edge = Part.Edge( Part.BSplineCurve( @@ -876,7 +875,7 @@ class TestPathGeom(PathTestBase): weights=[2, 3, 5, 7], ) ) - self.assertEdgeShapesMatch(edge, PathGeom.flipEdge(edge)) + self.assertEdgeShapesMatch(edge, Path.Geom.flipEdge(edge)) def test76(self): """Flip an offset wire""" @@ -896,7 +895,7 @@ class TestPathGeom(PathTestBase): e2 = Part.Edge(Part.LineSegment(Vector(0, -7, 0), Vector(-8, 4, 0))) w0 = Part.Wire([e0, e1, e2]) w1 = w0.makeOffset2D(1) - w2 = PathGeom.flipWire(w1) + w2 = Path.Geom.flipWire(w1) # do some sanity checks self.assertTrue(w2.isValid()) self.assertTrue(w2.isClosed()) diff --git a/src/Mod/Path/PathTests/TestPathHelpers.py b/src/Mod/Path/PathTests/TestPathHelpers.py index 50835bb47d..c70b3dabfc 100644 --- a/src/Mod/Path/PathTests/TestPathHelpers.py +++ b/src/Mod/Path/PathTests/TestPathHelpers.py @@ -23,11 +23,10 @@ import FreeCAD import Part import Path +import Path.Base.FeedRate as PathFeedRate +import Path.Base.MachineState as PathMachineState import Path.Tool.Bit as PathToolBit import Path.Tool.Controller as PathToolController -import PathFeedRate -import PathMachineState -import PathScripts.PathGeom as PathGeom import PathScripts.PathUtils as PathUtils from PathTests.PathTestUtils import PathTestBase @@ -134,7 +133,7 @@ class TestPathHelpers(PathTestBase): self.assertTrue(len(results) == 2) e1 = results[0] self.assertTrue(isinstance(e1.Curve, Part.Circle)) - self.assertTrue(PathGeom.pointsCoincide(edge.Curve.Location, e1.Curve.Location)) + self.assertTrue(Path.Geom.pointsCoincide(edge.Curve.Location, e1.Curve.Location)) self.assertTrue(edge.Curve.Radius == e1.Curve.Radius) # filter a 180 degree arc diff --git a/src/Mod/Path/PathTests/TestPathOpUtil.py b/src/Mod/Path/PathTests/TestPathOpUtil.py index 28f1e88b9b..c066352745 100644 --- a/src/Mod/Path/PathTests/TestPathOpUtil.py +++ b/src/Mod/Path/PathTests/TestPathOpUtil.py @@ -24,7 +24,6 @@ import FreeCAD import Part import Path import Path.Op.Util as PathOpUtil -import PathScripts.PathGeom as PathGeom import PathTests.PathTestUtils as PathTestUtils import math @@ -208,14 +207,14 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): w for w in obj.Shape.Wires if 1 == len(w.Edges) - and PathGeom.isRoughly(0, w.Edges[0].Vertexes[0].Point.z) + and Path.Geom.isRoughly(0, w.Edges[0].Vertexes[0].Point.z) ] self.assertEqual(2, len(wires)) w = wires[1] if wires[0].BoundBox.isInside(wires[1].BoundBox) else wires[0] self.assertRoughly(10, w.Edges[0].Curve.Radius) # make sure there is a placement and I didn't mess up the model - self.assertFalse(PathGeom.pointsCoincide(Vector(), w.Edges[0].Placement.Base)) + self.assertFalse(Path.Geom.pointsCoincide(Vector(), w.Edges[0].Placement.Base)) wire = PathOpUtil.offsetWire(w, obj.Shape, 2, True) self.assertIsNotNone(wire) @@ -232,14 +231,14 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): w for w in obj.Shape.Wires if 1 == len(w.Edges) - and PathGeom.isRoughly(0, w.Edges[0].Vertexes[0].Point.z) + and Path.Geom.isRoughly(0, w.Edges[0].Vertexes[0].Point.z) ] self.assertEqual(2, len(wires)) w = wires[0] if wires[0].BoundBox.isInside(wires[1].BoundBox) else wires[1] self.assertRoughly(20, w.Edges[0].Curve.Radius) # make sure there is a placement and I didn't mess up the model - self.assertFalse(PathGeom.pointsCoincide(Vector(), w.Edges[0].Placement.Base)) + self.assertFalse(Path.Geom.pointsCoincide(Vector(), w.Edges[0].Placement.Base)) wire = PathOpUtil.offsetWire(w, obj.Shape, 2, True) self.assertIsNotNone(wire) @@ -335,16 +334,16 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): begin = e.Vertexes[0].Point end = e.Vertexes[1].Point v = end - begin - angle = PathGeom.getAngle(v) - if PathGeom.isRoughly(0, angle) or PathGeom.isRoughly( + angle = Path.Geom.getAngle(v) + if Path.Geom.isRoughly(0, angle) or Path.Geom.isRoughly( math.pi, math.fabs(angle) ): if lastAngle: self.assertRoughly(-refAngle, lastAngle) - elif PathGeom.isRoughly(+refAngle, angle): + elif Path.Geom.isRoughly(+refAngle, angle): if lastAngle: self.assertRoughly(math.pi, math.fabs(lastAngle)) - elif PathGeom.isRoughly(-refAngle, angle): + elif Path.Geom.isRoughly(-refAngle, angle): if lastAngle: self.assertRoughly(+refAngle, lastAngle) else: @@ -385,9 +384,9 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): ) for e in wire.Edges: if Part.Line == type(e.Curve): - if PathGeom.isRoughly(e.Vertexes[0].Point.x, e.Vertexes[1].Point.x): + if Path.Geom.isRoughly(e.Vertexes[0].Point.x, e.Vertexes[1].Point.x): self.assertEqual(40, e.Length) - if PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y): + if Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y): self.assertEqual(60, e.Length) if Part.Circle == type(e.Curve): self.assertRoughly(3, e.Curve.Radius) @@ -405,9 +404,9 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): ) for e in wire.Edges: if Part.Line == type(e.Curve): - if PathGeom.isRoughly(e.Vertexes[0].Point.x, e.Vertexes[1].Point.x): + if Path.Geom.isRoughly(e.Vertexes[0].Point.x, e.Vertexes[1].Point.x): self.assertEqual(40, e.Length) - if PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y): + if Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y): self.assertEqual(60, e.Length) if Part.Circle == type(e.Curve): self.assertRoughly(3, e.Curve.Radius) @@ -512,9 +511,9 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): self.assertEqual(4, len(wire.Edges)) self.assertEqual(4, len([e for e in wire.Edges if Part.Line == type(e.Curve)])) for e in wire.Edges: - if PathGeom.isRoughly(e.Vertexes[0].Point.x, e.Vertexes[1].Point.x): + if Path.Geom.isRoughly(e.Vertexes[0].Point.x, e.Vertexes[1].Point.x): self.assertRoughly(34, e.Length) - if PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y): + if Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y): self.assertRoughly(54, e.Length) self.assertFalse(PathOpUtil.isWireClockwise(wire)) @@ -525,9 +524,9 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): self.assertEqual(4, len(wire.Edges)) self.assertEqual(4, len([e for e in wire.Edges if Part.Line == type(e.Curve)])) for e in wire.Edges: - if PathGeom.isRoughly(e.Vertexes[0].Point.x, e.Vertexes[1].Point.x): + if Path.Geom.isRoughly(e.Vertexes[0].Point.x, e.Vertexes[1].Point.x): self.assertRoughly(34, e.Length) - if PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y): + if Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y): self.assertRoughly(54, e.Length) self.assertTrue(PathOpUtil.isWireClockwise(wire)) @@ -601,7 +600,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): hEdges = [ e for e in w.Edges - if PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) + if Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) ] x = length / 2 @@ -620,7 +619,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): self.assertCoincide(Vector(-x, y, 0), wire.Edges[0].Vertexes[1].Point) # make sure we get the same result even if the edge is oriented the other way - edge = PathGeom.flipEdge(edge) + edge = Path.Geom.flipEdge(edge) wire = PathOpUtil.offsetWire(Part.Wire([edge]), obj.Shape, 5, True) self.assertEqual(1, len(wire.Edges)) @@ -640,7 +639,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): hEdges = [ e for e in w.Edges - if PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) + if Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) ] x = length / 2 @@ -658,7 +657,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): self.assertCoincide(Vector(+x, y, 0), wire.Edges[0].Vertexes[1].Point) # make sure we get the same result on a reversed edge - edge = PathGeom.flipEdge(edge) + edge = Path.Geom.flipEdge(edge) wire = PathOpUtil.offsetWire(Part.Wire([edge]), obj.Shape, 5, False) self.assertEqual(1, len(wire.Edges)) @@ -678,7 +677,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): lEdges = [ e for e in w.Edges - if not PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) + if not Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) ] self.assertEqual(2, len(lEdges)) @@ -721,11 +720,11 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): lEdges = [ e for e in w.Edges - if not PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) + if not Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) ] self.assertEqual(2, len(lEdges)) - w = PathGeom.flipWire(Part.Wire(lEdges)) + w = Path.Geom.flipWire(Part.Wire(lEdges)) wire = PathOpUtil.offsetWire(w, obj.Shape, 2, True) x = length / 2 + 2 * math.cos(math.pi / 6) @@ -765,7 +764,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): hEdges = [ e for e in w.Edges - if PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) + if Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) ] x = length / 2 @@ -784,7 +783,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): self.assertCoincide(Vector(+x, y, 0), wire.Edges[0].Vertexes[1].Point) # make sure we get the same result even if the edge is oriented the other way - edge = PathGeom.flipEdge(edge) + edge = Path.Geom.flipEdge(edge) wire = PathOpUtil.offsetWire(Part.Wire([edge]), obj.Shape, 2, True) self.assertEqual(1, len(wire.Edges)) @@ -804,7 +803,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): hEdges = [ e for e in w.Edges - if PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) + if Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) ] x = length / 2 @@ -823,7 +822,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): self.assertCoincide(Vector(-x, y, 0), wire.Edges[0].Vertexes[1].Point) # make sure we get the same result even if the edge is oriented the other way - edge = PathGeom.flipEdge(edge) + edge = Path.Geom.flipEdge(edge) wire = PathOpUtil.offsetWire(Part.Wire([edge]), obj.Shape, 2, False) self.assertEqual(1, len(wire.Edges)) @@ -841,7 +840,7 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): lEdges = [ e for e in w.Edges - if not PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) + if not Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) ] self.assertEqual(2, len(lEdges)) @@ -878,11 +877,11 @@ class TestPathOpUtil(PathTestUtils.PathTestBase): lEdges = [ e for e in w.Edges - if not PathGeom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) + if not Path.Geom.isRoughly(e.Vertexes[0].Point.y, e.Vertexes[1].Point.y) ] self.assertEqual(2, len(lEdges)) - w = PathGeom.flipWire(Part.Wire(lEdges)) + w = Path.Geom.flipWire(Part.Wire(lEdges)) wire = PathOpUtil.offsetWire(w, obj.Shape, 2, True) x = length / 2 - 2 * math.cos(math.pi / 6) diff --git a/src/Mod/Path/PathTests/TestPathPropertyBag.py b/src/Mod/Path/PathTests/TestPathPropertyBag.py index 71019dfb27..ae675b71ff 100644 --- a/src/Mod/Path/PathTests/TestPathPropertyBag.py +++ b/src/Mod/Path/PathTests/TestPathPropertyBag.py @@ -21,7 +21,7 @@ # *************************************************************************** import FreeCAD -import PathScripts.PathPropertyBag as PathPropertyBag +import Path.Base.PropertyBag as PathPropertyBag import PathTests.PathTestUtils as PathTestUtils diff --git a/src/Mod/Path/PathTests/TestPathThreadMilling.py b/src/Mod/Path/PathTests/TestPathThreadMilling.py index 207cd93604..a1a29dde92 100644 --- a/src/Mod/Path/PathTests/TestPathThreadMilling.py +++ b/src/Mod/Path/PathTests/TestPathThreadMilling.py @@ -21,7 +21,7 @@ # *************************************************************************** import FreeCAD -import PathScripts.PathGeom as PathGeom +import Path import Path.Op.ThreadMilling as PathThreadMilling import math diff --git a/src/Mod/Path/PathTests/TestPathThreadMillingGenerator.py b/src/Mod/Path/PathTests/TestPathThreadMillingGenerator.py index c73e5ea592..c33368cc7d 100644 --- a/src/Mod/Path/PathTests/TestPathThreadMillingGenerator.py +++ b/src/Mod/Path/PathTests/TestPathThreadMillingGenerator.py @@ -21,7 +21,6 @@ # *************************************************************************** import FreeCAD -import PathScripts.PathGeom as PathGeom import Generators.threadmilling_generator as threadmilling import math diff --git a/src/Mod/Path/PathTests/TestPathUtil.py b/src/Mod/Path/PathTests/TestPathUtil.py index 04ae92ce58..a22c4f2876 100644 --- a/src/Mod/Path/PathTests/TestPathUtil.py +++ b/src/Mod/Path/PathTests/TestPathUtil.py @@ -21,7 +21,7 @@ # *************************************************************************** import FreeCAD -import PathScripts.PathUtil as PathUtil +import Path.Base.Util as PathUtil import TestSketcherApp from PathTests.PathTestUtils import PathTestBase diff --git a/src/Mod/Path/PathTests/TestPathVcarve.py b/src/Mod/Path/PathTests/TestPathVcarve.py index 0744fd32b8..469742b57f 100644 --- a/src/Mod/Path/PathTests/TestPathVcarve.py +++ b/src/Mod/Path/PathTests/TestPathVcarve.py @@ -23,7 +23,6 @@ import FreeCAD import Path.Op.Vcarve as PathVcarve import Path.Tool.Bit as PathToolBit -import PathScripts.PathGeom as PathGeom import math from PathTests.PathTestUtils import PathTestBase diff --git a/src/Mod/Path/PathTests/TestPathVoronoi.py b/src/Mod/Path/PathTests/TestPathVoronoi.py index a6a91bf725..169ee5e1c1 100644 --- a/src/Mod/Path/PathTests/TestPathVoronoi.py +++ b/src/Mod/Path/PathTests/TestPathVoronoi.py @@ -23,7 +23,6 @@ import FreeCAD import Part import Path -import PathScripts.PathGeom as PathGeom import PathTests.PathTestUtils as PathTestUtils vd = None @@ -110,7 +109,7 @@ class TestPathVoronoi(PathTestUtils.PathTestBase): e = e0.toShape() self.assertTrue(type(e.Curve) == Part.LineSegment or type(e.Curve) == Part.Line) self.assertFalse( - PathGeom.pointsCoincide( + Path.Geom.pointsCoincide( e.valueAt(e.FirstParameter), e.valueAt(e.LastParameter) ) ) @@ -127,7 +126,7 @@ class TestPathVoronoi(PathTestUtils.PathTestBase): e = e0.toShape(13.7) self.assertTrue(type(e.Curve) == Part.LineSegment or type(e.Curve) == Part.Line) self.assertFalse( - PathGeom.pointsCoincide( + Path.Geom.pointsCoincide( e.valueAt(e.FirstParameter), e.valueAt(e.LastParameter) ) ) @@ -144,7 +143,7 @@ class TestPathVoronoi(PathTestUtils.PathTestBase): e = e0.toShape(2.37, 5.14) self.assertTrue(type(e.Curve) == Part.LineSegment or type(e.Curve) == Part.Line) self.assertFalse( - PathGeom.pointsCoincide( + Path.Geom.pointsCoincide( e.valueAt(e.FirstParameter), e.valueAt(e.LastParameter) ) ) @@ -163,7 +162,7 @@ class TestPathVoronoi(PathTestUtils.PathTestBase): type(e.Curve) == Part.Parabola or type(e.Curve) == Part.BSplineCurve ) self.assertFalse( - PathGeom.pointsCoincide( + Path.Geom.pointsCoincide( e.valueAt(e.FirstParameter), e.valueAt(e.LastParameter) ) ) @@ -182,7 +181,7 @@ class TestPathVoronoi(PathTestUtils.PathTestBase): type(e.Curve) == Part.Parabola or type(e.Curve) == Part.BSplineCurve ) self.assertFalse( - PathGeom.pointsCoincide( + Path.Geom.pointsCoincide( e.valueAt(e.FirstParameter), e.valueAt(e.LastParameter) ) ) @@ -201,7 +200,7 @@ class TestPathVoronoi(PathTestUtils.PathTestBase): type(e.Curve) == Part.Parabola or type(e.Curve) == Part.BSplineCurve ) self.assertFalse( - PathGeom.pointsCoincide( + Path.Geom.pointsCoincide( e.valueAt(e.FirstParameter), e.valueAt(e.LastParameter) ) ) diff --git a/src/Mod/Path/Tools/toolbit-attributes.py b/src/Mod/Path/Tools/toolbit-attributes.py index 92f91d70fd..326eaa71dd 100755 --- a/src/Mod/Path/Tools/toolbit-attributes.py +++ b/src/Mod/Path/Tools/toolbit-attributes.py @@ -93,8 +93,8 @@ if args.freecad: import FreeCAD import Path -import PathScripts.PathPropertyBag as PathPropertyBag -import PathScripts.PathUtil as PathUtil +import Path.Base.PropertyBag as PathPropertyBag +import Path.Base.Util as PathUtil set_var = None set_val = None