conversion to new pycam.Toolpath.Toolpath interface (moves + filters)

pycam/Plugins/TaskTypes.py

@@ -79,9 +79,5 @@ class TaskTypeMilling(pycam.Plugins.PluginBase):
         if not moves:
             self.log.info("No valid moves found")
             return None
-        data = {}
-        for item_name in ("process", "bounds"):
-            self.core.call_chain("get_toolpath_information",
-                    environment[item_name], data)
-        return moves, data
+        return moves, tool_filters
 

pycam/Plugins/ToolpathCrop.py

@@ -169,8 +169,8 @@ class ToolpathCrop(pycam.Plugins.PluginBase):
             new_path = toolpath | Filters.Crop(polygons)
             if new_path | Filters.MovesOnly():
                 if keep_original:
-                    self.core.get("toolpaths").add_new((new_path,
-                            toolpath.get_params()))
+                    self.core.get("toolpaths").add_new(
+                            (new_path, toolpath.filters))
                 else:
                     toolpath.path = new_path
                     self.core.emit_event("toolpath-changed")

pycam/Plugins/ToolpathExport.py

@@ -23,8 +23,8 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 import os
 
 import pycam.Plugins
-from pycam.Exporters.GCodeExporter import PATH_MODES
 from pycam.Geometry.PointUtils import *
+import pycam.Exporters.GCode.LinuxCNC
 
 
 FILTER_GCODE = (("GCode files", ("*.ngc", "*.nc", "*.gc", "*.gcode")),)
@@ -33,7 +33,7 @@ FILTER_GCODE = (("GCode files", ("*.ngc", "*.nc", "*.gc", "*.gcode")),)
 class ToolpathExport(pycam.Plugins.PluginBase):
 
     UI_FILE = "toolpath_export.ui"
-    DEPENDS = ["Toolpaths", "FilenameDialog"]
+    DEPENDS = ["Toolpaths", "FilenameDialog", "ToolpathProcessors"]
     CATEGORIES = ["Toolpath", "Export"]
 
     def setup(self):
@@ -82,12 +82,16 @@ class ToolpathExport(pycam.Plugins.PluginBase):
         self._export_toolpaths(self.core.get("toolpaths").get_selected())
 
     def _export_toolpaths(self, toolpaths):
-        proc_name = self.get_selected()
-        processor = self._postprocessors[proc_name]
+        processor = self.core.get("toolpath_processors").get_selected()
         if not processor:
-            self.log.warn("Unknown postprocessor: %s" % str(name))
+            self.log.warn("No toolpath processor selected")
             return
-        generator_func = processor["func"]
+        filter_func = processor["func"]
+        filter_params = self.core.get("get_parameter_values")(
+                "toolpath_processor")
+        settings_filters = filter_func(filter_params)
+        # TODO: get "public" filters (metric, ...)
+        common_filters = []
         # we open a dialog
         if self.core.get("gcode_filename_extension"):
             filename_extension = self.core.get("gcode_filename_extension")
@@ -106,7 +110,6 @@ class ToolpathExport(pycam.Plugins.PluginBase):
             return
         try:
             destination = open(filename, "w")
-            safety_height = self.core.get("gcode_safety_height")
             # TODO: implement "get_meta_data()"
             #meta_data = self.get_meta_data()
             meta_data = ""
@@ -116,6 +119,10 @@ class ToolpathExport(pycam.Plugins.PluginBase):
                 machine_time += toolpath.get_machine_time()
             all_info = meta_data + os.linesep \
                     + "Estimated machine time: %.0f minutes" % machine_time
+            generator = pycam.Exporters.GCode.LinuxCNC.LinuxCNC(destination)
+            generator.add_filters(settings_filters)
+            generator.add_filters(common_filters)
+            """
             minimum_steps = [self.core.get("gcode_minimum_step_x"),  
                     self.core.get("gcode_minimum_step_y"),  
                     self.core.get("gcode_minimum_step_z")]
@@ -142,27 +149,22 @@ class ToolpathExport(pycam.Plugins.PluginBase):
                     touch_off_pause_execution=self.core.get("touch_off_pause_execution"))
             path_mode = self.core.get("gcode_path_mode")
             if path_mode == 0:
-                generator.set_path_mode(PATH_MODES["exact_path"])
+                generator.set_path_mode(CORNER_STYLE_EXACT_PATH)
             elif path_mode == 1:
-                generator.set_path_mode(PATH_MODES["exact_stop"])
+                generator.set_path_mode(CORNER_STYLE_EXACT_STOP)
             elif path_mode == 2:
-                generator.set_path_mode(PATH_MODES["continuous"])
+                generator.set_path_mode(CORNER_STYLE_OPTIMIZE_SPEED)
             else:
                 naive_tolerance = self.core.get("gcode_naive_tolerance")
                 if naive_tolerance == 0:
                     naive_tolerance = None
-                generator.set_path_mode(PATH_MODES["continuous"],
+                generator.set_path_mode(CORNER_STYLE_OPTIMIZE_TOLERANCE,
                         self.core.get("gcode_motion_tolerance"),
                         naive_tolerance)
+            """
             for toolpath in toolpaths:
-                params = toolpath.get_params()
-                tool_id = params.get("tool_id", 1)
-                feedrate = params.get("tool_feedrate", 300)
-                spindle_speed = params.get("spindle_speed", 1000)
-                generator.set_speed(feedrate, spindle_speed)
                 # TODO: implement toolpath.get_meta_data()
-                generator.add_moves(toolpath.get_basic_moves(),
-                        tool_id=tool_id, comment="")
+                generator.add_moves(toolpath.path, toolpath.filters)
             generator.finish()
             destination.close()
             self.log.info("GCode file successfully written: %s" % str(filename))

pycam/Plugins/ToolpathGrid.py

@@ -109,7 +109,6 @@ class ToolpathGrid(pycam.Plugins.PluginBase):
                 toolpath.path = new_path
                 self.core.emit_event("toolpath-changed")
             else:
-                self.core.get("toolpaths").add_new((new_path,
-                        toolpath.get_params()))
+                self.core.get("toolpaths").add_new((new_path, toolpath.filters))
         self.core.get("toolpaths").select(toolpaths)
 

pycam/Plugins/ToolpathProcessors.py

@@ -24,7 +24,8 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 import pycam.Plugins
 import pycam.Gui.ControlsGTK
 import pycam.Utils.log
-
+import pycam.Toolpath.Filters as Filters
+from pycam.Toolpath import CORNER_STYLE_EXACT_PATH
 
 _log = pycam.Utils.log.get_logger()
 
@@ -137,20 +138,22 @@ class ToolpathProcessors(pycam.Plugins.ListPluginBase):
                     ("toolpath-processor-list-changed", self._update_processors),
                     ("toolpath-selection-changed", self._update_visibility),
                     ("notify-initialization-finished",
-                            self._activate_first_processor),
+                            self._select_first_processor),
             )
             self.register_event_handlers(self._event_handlers)
             self._update_processors()
             self._update_visibility()
+        self.core.set("toolpath_processors", self)
         return True
 
     def teardown(self):
         if self.gui:
             self._toggle_window(False)
+        self.core.set("toolpath_processors", None)
         self.unregister_event_handlers(self._event_handlers)
         self.core.get("unregister_parameter_group")("toolpath_processor")
 
-    def _activate_first_processor(self):
+    def _select_first_processor(self):
         # run this action as soon as all processors are registered
         processors = self.core.get("get_parameter_sets")("toolpath_processor").values()
         processors.sort(key=lambda item: item["weight"])
@@ -198,6 +201,12 @@ class ToolpathProcessors(pycam.Plugins.ListPluginBase):
         return True
 
 
+def _get_processor_filters(core, parameters):
+    filters = []
+    core.call_chain("toolpath_filters", "settings", parameters, filters)
+    return filters
+
+
 class ToolpathProcessorMilling(pycam.Plugins.PluginBase):
 
     DEPENDS = ["Toolpaths", "GCodeSafetyHeight", "GCodeFilenameExtension",
@@ -210,7 +219,7 @@ class ToolpathProcessorMilling(pycam.Plugins.PluginBase):
                 "step_width_x": 0.0001,
                 "step_width_y": 0.0001,
                 "step_width_z": 0.0001,
-                "path_mode": "exact_path",
+                "path_mode": CORNER_STYLE_EXACT_PATH,
                 "motion_tolerance": 0.0,
                 "naive_tolerance": 0.0,
                 "spindle_enable": True,
@@ -218,17 +227,15 @@ class ToolpathProcessorMilling(pycam.Plugins.PluginBase):
                 "touch_off": None,
         }
         self.core.get("register_parameter_set")("toolpath_processor",
-                "milling", "Milling", self.get_filters, parameters=parameters,
-                weight=10)
+                "milling", "Milling",
+                lambda params: _get_processor_filters(self.core, params),
+                parameters=parameters, weight=10)
         return True
 
     def teardown(self):
         self.core.get("unregister_parameter_set")("toolpath_processor", 
                 "milling")
 
-    def get_filters(self):
-        return []
-
 
 class ToolpathProcessorLaser(pycam.Plugins.PluginBase):
 
@@ -246,14 +253,12 @@ class ToolpathProcessorLaser(pycam.Plugins.PluginBase):
                 "naive_tolerance": 0.0,
         }
         self.core.get("register_parameter_set")("toolpath_processor",
-                "laser", "Laser", self.get_filters, parameters=parameters,
-                weight=50)
+                "laser", "Laser",
+                lambda params: _get_processor_filters(self.core, params),
+                parameters=parameters, weight=50)
         return True
 
     def teardown(self):
         self.core.get("unregister_parameter_set")("toolpath_processor",
                 "laser")
 
-    def get_filters(self):
-        return []
-

pycam/Plugins/Toolpaths.py

@@ -154,14 +154,14 @@ class Toolpaths(pycam.Plugins.ListPluginBase):
     def add_new(self, new_tp):
         if isinstance(new_tp, pycam.Toolpath.Toolpath):
             moves = new_tp.path
-            parameters = new_tp.get_params()
+            filters = new_tp.filters
         else:
-            moves, parameters = new_tp
+            moves, filters = new_tp
         name = get_non_conflicting_name("Toolpath #%d",
                 [tp["name"] for tp in self])
         attributes= {"visible": True, "name": name}
-        new_tp = ToolpathEntity(toolpath_path=moves,
-                toolpath_parameters=parameters, attributes=attributes)
+        new_tp = ToolpathEntity(toolpath_path=moves, attributes=attributes,
+                toolpath_filters=filters)
         self.append(new_tp)