Rework GCoder to factorize preprocessing in a single function #423

printrun/gcoder.py

@@ -116,6 +116,8 @@ class GCode(object):
     current_z = 0
     # For E this is the absolute position from machine start
     current_e = 0
+    total_e = 0
+    max_e = 0
     # Current feedrate
     current_f = 0
     # Offset: current offset between the machine origin and the machine current
@@ -190,16 +192,16 @@ class GCode(object):
         return len(self.all_zs)
     layers_count = property(_get_layers_count)
 
-    def __init__(self, data = None, home_pos = None):
+    def __init__(self, data = None, home_pos = None, layer_callback = None):
         self.home_pos = home_pos
         if data:
             self.lines = [Line(l2) for l2 in
                           (l.strip() for l in data)
                           if l2]
-            self._preprocess_lines()
-            self.filament_length = self._preprocess_extrusion()
-            self._create_layers()
-            self._preprocess_layers()
+            self._preprocess(build_layers = True,
+                             layer_callback = layer_callback)
+            self.filament_length = self.max_e
+            self._compute_bounding_box()
         else:
             self.lines = []
             self.append_layer_id = 0
@@ -220,8 +222,7 @@ class GCode(object):
         if not command:
             return
         gline = Line(command)
-        self._preprocess_lines([gline])
-        self._preprocess_extrusion([gline])
+        self._preprocess([gline])
         if store:
             self.lines.append(gline)
             self.append_layer.append(gline)
@@ -229,7 +230,8 @@ class GCode(object):
             self.line_idxs.append(len(self.append_layer))
         return gline
 
-    def _preprocess_lines(self, lines = None):
+    def _preprocess(self, lines = None, build_layers = False,
+                    layer_callback = None):
         """Checks for imperial/relativeness settings and tool changes"""
         if not lines:
             lines = self.lines
@@ -244,11 +246,30 @@ class GCode(object):
         offset_y = self.offset_y
         offset_z = self.offset_z
 
+        current_e = self.current_e
+        offset_e = self.offset_e
+        total_e = self.total_e
+        max_e = self.max_e
+
+        # Initialize layers
+        if build_layers:
+            all_layers = self.all_layers = []
+            layer_idxs = self.layer_idxs = []
+            line_idxs = self.line_idxs = []
+
+            layer_id = 0
+            layer_line = 0
+
+            last_layer_z = None
+            prev_z = None
+            prev_base_z = (None, None)
+            cur_z = None
+            cur_lines = []
+
         for line in lines:
+            ## Parse line
             split_raw = split(line)
-            if not line.command:
-                continue
-
+            if line.command:
                 # Update properties
                 if line.is_move:
                     line.relative = relative
@@ -316,29 +337,9 @@ class GCode(object):
                 line.current_x = current_x
                 line.current_y = current_y
                 line.current_z = current_z
-        self.imperial = imperial
-        self.relative = relative
-        self.relative_e = relative_e
-        self.current_tool = current_tool
-        self.current_x = current_x
-        self.current_y = current_y
-        self.current_z = current_z
-        self.offset_x = offset_x
-        self.offset_y = offset_y
-        self.offset_z = offset_z
-
-    def _preprocess_extrusion(self, lines = None):
-        if not lines:
-            lines = self.lines
 
-        current_e = self.current_e
-        offset_e = self.offset_e
-        total_e = 0
-        max_e = 0
-
-        for line in lines:
-            if line.e is None:
-                continue
+                ## Process extrusion
+                if line.e is not None:
                     if line.is_move:
                         if line.relative_e:
                             line.extruding = line.e > 0
@@ -353,26 +354,10 @@ class GCode(object):
                     elif line.command == "G92":
                         offset_e = current_e - line.e
 
-        self.current_e = current_e
-        self.offset_e = offset_e
-        return max_e
-
-    # FIXME : looks like this needs to be tested with list Z on move
-    def _create_layers(self):
-        layers = {}
-        all_layers = []
-        layer_idxs = []
-        line_idxs = []
-
-        layer_id = 0
-        layer_line = 0
-
-        last_layer_z = None
-        prev_z = None
-        prev_base_z = (None, None)
-        cur_z = None
-        cur_lines = []
-        for line in self.lines:
+                ## Create layers
+                if not build_layers:
+                    continue
+                # FIXME : looks like this needs to be tested with "lift Z on move"
                 if line.command == "G92" and line.z is not None:
                     cur_z = line.z
                 elif line.is_move:
@@ -403,55 +388,55 @@ class GCode(object):
 
                     if base_z != prev_base_z:
                         all_layers.append(Layer(cur_lines, base_z))
-                    old_lines = layers.get(base_z, [])
-                    old_lines += cur_lines
-                    layers[base_z] = old_lines
                         cur_lines = []
                         layer_id += 1
                         layer_line = 0
                         last_layer_z = base_z
+                        if layer_callback is not None:
+                            layer_callback(self, len(all_layers) - 1)
 
                     prev_base_z = base_z
 
+            if build_layers:
                 cur_lines.append(line)
                 layer_idxs.append(layer_id)
                 line_idxs.append(layer_line)
                 layer_line += 1
                 prev_z = cur_z
+            ### Loop done
 
+        # Store current status
+        self.imperial = imperial
+        self.relative = relative
+        self.relative_e = relative_e
+        self.current_tool = current_tool
+        self.current_x = current_x
+        self.current_y = current_y
+        self.current_z = current_z
+        self.offset_x = offset_x
+        self.offset_y = offset_y
+        self.offset_z = offset_z
+
+        self.current_e = current_e
+        self.offset_e = offset_e
+        self.max_e = max_e
+        self.total_e = total_e
+
+        # Finalize layers
+        if build_layers:
             if cur_lines:
                 all_layers.append(Layer(cur_lines, prev_z))
-            old_lines = layers.get(prev_z, [])
-            old_lines += cur_lines
-            layers[prev_z] = old_lines
-
-        for zindex in layers.keys():
-            cur_lines = layers[zindex]
-            has_movement = False
-            for l in layers[zindex]:
-                if l.is_move and l.e is not None:
-                    has_movement = True
-                    break
-            if has_movement:
-                layers[zindex] = Layer(cur_lines, zindex)
-            else:
-                del layers[zindex]
 
             self.append_layer_id = len(all_layers)
             self.append_layer = Layer([])
             all_layers.append(self.append_layer)
-        self.all_layers = all_layers
-        self.layers = layers
             self.layer_idxs = array('I', layer_idxs)
             self.line_idxs = array('I', line_idxs)
 
     def idxs(self, i):
         return self.layer_idxs[i], self.line_idxs[i]
 
-    def num_layers(self):
-        return len(self.layers)
-
-    def _preprocess_layers(self):
+    def _compute_bounding_box(self):
         xmin = float("inf")
         ymin = float("inf")
         zmin = 0