Merge pull request FreeCAD#26131 from tarman3/axismap

CAM: Axismap Dressup - Invert rotary axis

Author: sliptonic

src/Mod/CAM/Gui/Resources/panels/AxisMapEdit.ui

@@ -78,6 +78,20 @@
      </item>
     </widget>
    </item>
+   <item row="2" column="0">
+     <widget class="QLabel" name="lblReverse">
+       <property name="text">
+         <string>Reverse</string>
+       </property>
+     </widget>
+   </item>
+   <item row="2" column="2" colspan="2">
+     <widget class="QComboBox" name="reverse">
+       <property name="toolTip">
+         <string>Reverse rotary axis direction</string>
+       </property>
+     </widget>
+   </item>
   <item row="3" column="2">
     <spacer name="verticalSpacer">
      <property name="orientation">

src/Mod/CAM/Path/Dressup/Gui/AxisMap.py

@@ -27,6 +27,7 @@
 import Path.Base.Gui.Util as PathGuiUtil
 import PathScripts.PathUtils as PathUtils
 import Path.Dressup.Utils as PathDressup
+import Path.Post.Utils as PostUtils
 from PySide.QtCore import QT_TRANSLATE_NOOP
 
 if False:
@@ -39,7 +40,8 @@
 if FreeCAD.GuiUp:
     import FreeCADGui
 
-__doc__ = """Axis remapping Dressup object and FreeCAD command.  This dressup remaps one axis of motion to another.
+__doc__ = """Axis remapping Dressup object and FreeCAD command.
+This dressup remaps one axis of motion to another.
 For example, you can re-map the Y axis to A to control a 4th axis rotary."""
 
 
@@ -48,7 +50,6 @@
 
 class ObjectDressup:
     def __init__(self, obj):
-        maplist = ["X->A", "Y->A", "X->B", "Y->B", "X->C", "Y->C"]
         obj.addProperty(
             "App::PropertyLink",
             "Base",
@@ -67,92 +68,85 @@ def __init__(self, obj):
             "Path",
             QT_TRANSLATE_NOOP("App::Property", "The radius of the wrapped axis"),
         )
-        obj.AxisMap = maplist
+        obj.addProperty(
+            "App::PropertyBool",
+            "Reverse",
+            "Path",
+            QT_TRANSLATE_NOOP("App::Property", "Reverse rotary axis direction"),
+        )
+        obj.AxisMap = ("X->A", "Y->A", "X->B", "Y->B", "X->C", "Y->C")
         obj.AxisMap = "Y->A"
+        obj.Radius = 45
         obj.Proxy = self
 
     def dumps(self):
-        return None
+        return
 
     def loads(self, state):
-        return None
+        return
 
-    def _linear2angular(self, radius, length):
-        """returns an angular distance in degrees to achieve a linear move of a given length"""
-        circum = 2 * math.pi * float(radius)
-        return 360 * (float(length) / circum)
+    def onChanged(self, obj, prop):
+        if "Restore" not in obj.State and prop == "Radius":
+            job = PathUtils.findParentJob(obj)
+            if job:
+                job.Proxy.setCenterOfRotation(self.center(obj))
 
-    def _stripArcs(self, path, d):
-        """converts all G2/G3 commands into G1 commands"""
-        newcommandlist = []
-        currLocation = {"X": 0, "Y": 0, "Z": 0, "F": 0}
-
-        for p in path:
-            if p.Name in Path.Geom.CmdMoveArc:
-                curVec = FreeCAD.Vector(currLocation["X"], currLocation["Y"], currLocation["Z"])
-                arcwire = Path.Geom.edgeForCmd(p, curVec)
-                pointlist = arcwire.discretize(Deflection=d)
-                for point in pointlist:
-                    newcommand = Path.Command("G1", {"X": point.x, "Y": point.y, "Z": point.z})
-                    newcommandlist.append(newcommand)
-                    currLocation.update(newcommand.Parameters)
-            else:
-                newcommandlist.append(p)
-                currLocation.update(p.Parameters)
+        if prop == "Path" and obj.ViewObject:
+            obj.ViewObject.signalChangeIcon()
 
-        return newcommandlist
+    def onDocumentRestored(self, obj):
+        if not hasattr(obj, "Reverse"):
+            obj.addProperty(
+                "App::PropertyBool",
+                "Reverse",
+                "Path",
+                QT_TRANSLATE_NOOP("App::Property", "Reverse rotary axis direction"),
+            )
 
     def execute(self, obj):
 
         inAxis = obj.AxisMap[0]
         outAxis = obj.AxisMap[3]
-        d = 0.1
-
-        if obj.Base:
-            if obj.Base.isDerivedFrom("Path::Feature"):
-                if obj.Base.Path:
-                    if obj.Base.Path.Commands:
-                        pp = PathUtils.getPathWithPlacement(obj.Base).Commands
-                        if len([i for i in pp if i.Name in Path.Geom.CmdMoveArc]) == 0:
-                            pathlist = pp
-                        else:
-                            pathlist = self._stripArcs(pp, d)
-
-                        newcommandlist = []
-                        currLocation = {"X": 0, "Y": 0, "Z": 0, "F": 0}
-
-                        for c in pathlist:
-                            newparams = dict(c.Parameters)
-                            remapvar = newparams.pop(inAxis, None)
-                            if remapvar is not None:
-                                newparams[outAxis] = self._linear2angular(obj.Radius, remapvar)
-                                locdiff = dict(set(newparams.items()) - set(currLocation.items()))
-                                if (
-                                    len(locdiff) == 1 and outAxis in locdiff
-                                ):  # pure rotation.  Calculate rotational feed rate
-                                    if "F" in c.Parameters:
-                                        feed = c.Parameters["F"]
-                                    else:
-                                        feed = currLocation["F"]
-                                    newparams.update({"F": self._linear2angular(obj.Radius, feed)})
-                                newcommand = Path.Command(c.Name, newparams)
-                                newcommandlist.append(newcommand)
-                                currLocation.update(newparams)
-                            else:
-                                newcommandlist.append(c)
-                                currLocation.update(c.Parameters)
-
-                        path = Path.Path(newcommandlist)
-                        path.Center = self.center(obj)
-                        obj.Path = path
 
-    def onChanged(self, obj, prop):
-        if "Restore" not in obj.State and prop == "Radius":
-            job = PathUtils.findParentJob(obj)
-            if job:
-                job.Proxy.setCenterOfRotation(self.center(obj))
-        if prop == "Path" and obj.ViewObject:
-            obj.ViewObject.signalChangeIcon()
+        if (
+            not obj.Base
+            or not obj.Base.isDerivedFrom("Path::Feature")
+            or not obj.Base.Path
+            or not obj.Base.Path.Commands
+        ):
+            obj.Path = Path.Path()
+            return
+
+        job = PathUtils.findParentJob(obj)
+        deflection = job.GeometryTolerance.Value
+        path = PathUtils.getPathWithPlacement(obj.Base)
+        path = PostUtils.splitArcs(path, deflection=deflection)
+
+        newcommandlist = []
+        lastPar = {"X": 0, "Y": 0, "Z": 0, "F": 0}
+
+        for cmd in path.Commands:
+            newparams = dict(cmd.Parameters)
+            remapvar = newparams.pop(inAxis, None)
+            if remapvar is not None:
+                if obj.Reverse:
+                    remapvar = -remapvar
+                newparams[outAxis] = math.degrees(remapvar / obj.Radius.Value)
+                locdiff = dict(set(newparams.items()) - set(lastPar.items()))
+                if len(locdiff) == 1 and outAxis in locdiff:
+                    # calculate rotational feed rate
+                    feed = cmd.Parameters["F"] if "F" in cmd.Parameters else lastPar["F"]
+                    newparams.update({"F": math.degrees(feed / obj.Radius.Value)})
+                newcommand = Path.Command(cmd.Name, newparams)
+                newcommandlist.append(newcommand)
+                lastPar.update(newparams)
+            else:
+                newcommandlist.append(cmd)
+                lastPar.update(cmd.Parameters)
+
+        path = Path.Path(newcommandlist)
+        path.Center = self.center(obj)
+        obj.Path = path
 
     def center(self, obj):
         return FreeCAD.Vector(0, 0, 0 - obj.Radius.Value)
@@ -163,7 +157,8 @@ def __init__(self, obj):
         self.obj = obj
         self.form = FreeCADGui.PySideUic.loadUi(":/panels/AxisMapEdit.ui")
         self.radius = PathGuiUtil.QuantitySpinBox(self.form.radius, obj, "Radius")
-        FreeCAD.ActiveDocument.openTransaction("Edit Dragknife Dress-up")
+        self.reverse = PathGuiUtil.BooleanComboBox(self.form.reverse, obj, "Reverse")
+        FreeCAD.ActiveDocument.openTransaction("Edit AxisMap Dress-up")
 
     def reject(self):
         FreeCAD.ActiveDocument.abortTransaction()
@@ -179,11 +174,13 @@ def accept(self):
 
     def getFields(self):
         self.radius.updateProperty()
+        self.reverse.updateProperty()
         self.obj.AxisMap = self.form.axisMapInput.currentText()
         self.obj.Proxy.execute(self.obj)
 
     def updateUI(self):
         self.radius.updateWidget()
+        self.reverse.updateWidget()
         self.form.axisMapInput.setCurrentText(self.obj.AxisMap)
         self.updateModel()
 
@@ -200,12 +197,14 @@ def open(self):
     def setupUi(self):
         self.setFields()
         self.form.radius.valueChanged.connect(self.updateModel)
+        self.form.reverse.currentIndexChanged.connect(self.updateModel)
         self.form.axisMapInput.currentIndexChanged.connect(self.updateModel)
 
 
 class ViewProviderDressup:
     def __init__(self, vobj):
         self.obj = vobj.Object
+        vobj.Proxy = self
 
     def attach(self, vobj):
         self.obj = vobj.Object
@@ -217,7 +216,6 @@ def attach(self, vobj):
                         if g.Name == self.obj.Base.Name:
                             group.remove(g)
                     i.Group = group
-            # FreeCADGui.ActiveDocument.getObject(obj.Base.Name).Visibility = False
         return
 
     def unsetEdit(self, vobj, mode=0):
@@ -234,10 +232,10 @@ def claimChildren(self):
         return [self.obj.Base]
 
     def dumps(self):
-        return None
+        return
 
     def loads(self, state):
-        return None
+        return
 
     def onDelete(self, arg1=None, arg2=None):
         """this makes sure that the base operation is added back to the project and visible"""
@@ -299,12 +297,9 @@ def Activated(self):
         FreeCADGui.doCommand("base = FreeCAD.ActiveDocument." + selection[0].Name)
         FreeCADGui.doCommand("job = PathScripts.PathUtils.findParentJob(base)")
         FreeCADGui.doCommand("obj.Base = base")
-        FreeCADGui.doCommand("obj.Radius = 45")
         FreeCADGui.doCommand("job.Proxy.addOperation(obj, base)")
-        FreeCADGui.doCommand(
-            "obj.ViewObject.Proxy = Path.Dressup.Gui.AxisMap.ViewProviderDressup(obj.ViewObject)"
-        )
-        FreeCADGui.doCommand("Gui.ActiveDocument.getObject(base.Name).Visibility = False")
+        FreeCADGui.doCommand("Path.Dressup.Gui.AxisMap.ViewProviderDressup(obj.ViewObject)")
+        FreeCADGui.doCommand("base.Visibility = False")
         FreeCADGui.doCommand("obj.ViewObject.Document.setEdit(obj.ViewObject, 0)")
         # FreeCAD.ActiveDocument.commitTransaction()  # Final `commitTransaction()` called via TaskPanel.accept()
         FreeCAD.ActiveDocument.recompute()