D5: Refactoring

cura/CuraApplication.py

@@ -546,6 +546,10 @@ class CuraApplication(QtApplication):
 
     def changeToLayerView(self):
         self.getController().setActiveView("LayerView")
+        view = self.getController().getActiveView()
+        view.resetLayerData()
+        view.setLayer(999999)
+        view.calculateMaxLayers()
 
     @pyqtSlot(QUrl)
     def loadFile(self, file):

plugins/CuraEngineBackend/ProcessSlicedLayersJob.py

@@ -60,7 +60,6 @@ class ProcessSlicedLayersJob(Job):
         for node in DepthFirstIterator(self._scene.getRoot()):
             if node.callDecoration("getLayerData"):
                 node.getParent().removeChild(node)
-                break
             if self._abort_requested:
                 if self._progress:
                     self._progress.hide()

plugins/GCodeReader/GCodeReader.py

@@ -18,7 +18,7 @@ catalog = i18nCatalog("cura")
 
 from cura import LayerDataBuilder
 from cura import LayerDataDecorator
-from cura import LayerPolygon
+from cura.LayerPolygon import LayerPolygon
 
 import numpy
 import math
@@ -28,66 +28,66 @@ class GCodeReader(MeshReader):
     def __init__(self):
         super(GCodeReader, self).__init__()
         self._supported_extensions = [".gcode", ".g"]
-        Application.getInstance().hideMessageSignal.connect(self.onHideMessage)
-        self.cancelled = False
-        self.message = None
+        Application.getInstance().hideMessageSignal.connect(self._onHideMessage)
+        self._cancelled = False
+        self._message = None
 
-        self.scene_node = None
+        self._scene_node = None
 
     @staticmethod
-    def getInt(line, code):
-        n = line.find(code) + 1
+    def _getValue(line, code):
+        n = line.find(code) + len(code)
         if n < 1:
             return None
         m = line.find(' ', n)
         try:
             if m < 0:
-                return int(line[n:])
-            return int(line[n:m])
+                return line[n:]
+            return line[n:m]
         except:
             return None
 
-    @staticmethod
-    def getFloat(line, code):
-        n = line.find(code) + 1
-        if n < 1:
+    def _getInt(self, line, code):
+        value = self._getValue(line, code)
+        try:
+            return int(value)
+        except:
             return None
-        m = line.find(' ', n)
+
+    def _getFloat(self, line, code):
+        value = self._getValue(line, code)
         try:
-            if m < 0:
-                return float(line[n:])
-            return float(line[n:m])
+            return float(value)
         except:
             return None
 
-    def onHideMessage(self, m):
-        if m == self.message:
-            self.cancelled = True
+    def _onHideMessage(self, message):
+        if message == self._message:
+            self._cancelled = True
 
-    def onParentChanged(self, node):
+    def _onParentChanged(self, node):
         backend = Application.getInstance().getBackend()
-        if self.scene_node is not None and self.scene_node.getParent() is None:
-            self.scene_node = None
+        if self._scene_node is not None and self._scene_node.getParent() is None:
+            self._scene_node = None
             backend.backendStateChange.emit(BackendState.NotStarted)
             Application.getInstance().setHideSettings(False)
             Application.getInstance().getPrintInformation().setPreSliced(False)
-        else:
-            backend.backendStateChange.emit(BackendState.SlicingDisabled)
-            Application.getInstance().getPrintInformation().setPreSliced(True)
-            Application.getInstance().setHideSettings(True)
+        # else:
+        #     backend.backendStateChange.emit(BackendState.SlicingDisabled)
+        #     Application.getInstance().getPrintInformation().setPreSliced(True)
+        #     Application.getInstance().setHideSettings(True)
 
     @staticmethod
-    def getNullBoundingBox():
+    def _getNullBoundingBox():
         return AxisAlignedBox(minimum=Vector(0, 0, 0), maximum=Vector(10, 10, 10))
 
     @staticmethod
-    def createPolygon(layer_data, path, layer_id, extruder):
+    def _createPolygon(layer_data, path, layer_id, extruder):
         countvalid = 0
         for point in path:
             if point[3] > 0:
                 countvalid += 1
         if countvalid < 2:
-            path.clear()
             return False
         try:
             layer_data.addLayer(layer_id)
@@ -95,57 +95,51 @@ class GCodeReader(MeshReader):
             layer_data.setLayerThickness(layer_id, 0.25)
             this_layer = layer_data.getLayer(layer_id)
         except ValueError:
-            path.clear()
             return False
         count = len(path)
         line_types = numpy.empty((count - 1, 1), numpy.int32)
-        line_types[:, 0] = 1
         line_widths = numpy.empty((count - 1, 1), numpy.float32)
         line_widths[:, 0] = 0.5
         points = numpy.empty((count, 3), numpy.float32)
         i = 0
         for point in path:
             points[i, 0] = point[0]
-            points[i, 1] = point[1]
-            points[i, 2] = point[2]
+            points[i, 1] = point[2]
+            points[i, 2] = -point[1]
             if i > 0:
-                if point[3] == 1:
+                if point[3] == LayerPolygon.Inset0Type:
                     line_types[i - 1] = extruder + 1
                 else:
                     line_types[i - 1] = point[3]
             i += 1
 
-        this_poly = LayerPolygon.LayerPolygon(layer_data, extruder, line_types, points, line_widths)
+        this_poly = LayerPolygon(layer_data, extruder, line_types, points, line_widths)
         this_poly.buildCache()
 
         this_layer.polygons.append(this_poly)
-
-        path.clear()
         return True
 
     def read(self, file_name):
-        extension = os.path.splitext(file_name)[1]
-        if extension.lower() in self._supported_extensions:
-            Logger.log("d", "Preparing to load %s" % file_name)
-            self.cancelled = False
-            Application.getInstance().deleteAll()
+        Logger.log("d", "Preparing to load %s" % file_name)
+        self._cancelled = False
 
-            self.scene_node = SceneNode()
-            self.scene_node.getBoundingBox = self.getNullBoundingBox
-            self.scene_node.gcode = True
-            self.scene_node.parentChanged.connect(self.onParentChanged)
+        self._scene_node = SceneNode()
+        self._scene_node.getBoundingBox = self._getNullBoundingBox  # Manually set bounding box, because mesh doesn't have mesh data
+        self._scene_node.gcode = True
+        self._scene_node.parentChanged.connect(self._onParentChanged)
 
-            backend = Application.getInstance().getBackend()
-            backend.close()
-            backend.backendStateChange.emit(BackendState.SlicingDisabled)
+        backend = Application.getInstance().getBackend()
+        backend.close()
+        backend.backendStateChange.emit(BackendState.SlicingDisabled)
 
-            glist = getattr(Application.getInstance().getController().getScene(), "gcode_list")
-            glist.clear()
+        glist = []
+        Application.getInstance().getController().getScene().gcode_list = glist
 
-            Logger.log("d", "Opening file %s" % file_name)
+        Logger.log("d", "Opening file %s" % file_name)
 
-            file = open(file_name, "r")
+        layer_data_builder = LayerDataBuilder.LayerDataBuilder()
 
+        with open(file_name, "r") as file:
             file_lines = 0
             current_line = 0
             for line in file:
@@ -153,7 +147,6 @@ class GCodeReader(MeshReader):
             file.seek(0)
 
             file_step = max(math.floor(file_lines / 100), 1)
-            layer_data = LayerDataBuilder.LayerDataBuilder()
 
             current_extruder = 0
             current_path = []
@@ -163,30 +156,30 @@ class GCodeReader(MeshReader):
             current_e = 0
             current_layer = 0
 
-            self.message = Message(catalog.i18nc("@info:status", "Parsing GCODE"), lifetime=0)
-            self.message.setProgress(0)
-            self.message.show()
+            self._message = Message(catalog.i18nc("@info:status", "Parsing GCODE"), lifetime=0)
+            self._message.setProgress(0)
+            self._message.show()
 
             Logger.log("d", "Parsing %s" % file_name)
 
             for line in file:
-                if self.cancelled:
+                if self._cancelled:
                     Logger.log("w", "Parsing %s cancelled" % file_name)
                     return None
                 current_line += 1
                 if current_line % file_step == 0:
-                    self.message.setProgress(math.floor(current_line/file_lines*100))
+                    self._message.setProgress(math.floor(current_line / file_lines * 100))
                 if len(line) == 0:
                     continue
                 if line[0] == ";":
                     continue
-                G = self.getInt(line, "G")
+                G = self._getInt(line, "G")
                 if G is not None:
                     if G == 0 or G == 1:
-                        x = self.getFloat(line, "X")
-                        y = self.getFloat(line, "Y")
-                        z = self.getFloat(line, "Z")
-                        e = self.getFloat(line, "E")
+                        x = self._getFloat(line, "X")
+                        y = self._getFloat(line, "Y")
+                        z = self._getFloat(line, "Z")
+                        e = self._getFloat(line, "E")
                         z_changed = False
                         if x is not None:
                             current_x = x
@@ -198,78 +191,79 @@ class GCodeReader(MeshReader):
                             current_z = z
                         if e is not None:
                             if e > current_e:
-                                current_path.append([current_x, current_z, -current_y, 1])  # extrusion
+                                current_path.append([current_x, current_y, current_z, LayerPolygon.Inset0Type])  # extrusion
                             else:
-                                current_path.append([current_x, current_z, -current_y, 2])  # retraction
+                                current_path.append([current_x, current_y, current_z, LayerPolygon.MoveRetractionType])  # retraction
                             current_e = e
                         else:
-                            current_path.append([current_x, current_z, -current_y, 0])
+                            current_path.append([current_x, current_y, current_z, LayerPolygon.NoneType])
                         if z_changed:
                             if len(current_path) > 1 and current_z > 0:
-                                if self.createPolygon(layer_data, current_path, current_layer, current_extruder):
+                                if self._createPolygon(layer_data_builder, current_path, current_layer, current_extruder):
                                     current_layer += 1
+                                current_path.clear()
                             else:
                                 current_path.clear()
 
                     elif G == 28:
-                        x = self.getFloat(line, "X")
-                        y = self.getFloat(line, "Y")
+                        x = self._getFloat(line, "X")
+                        y = self._getFloat(line, "Y")
                         if x is not None:
                             current_x = x
                         if y is not None:
                             current_y = y
                         current_z = 0
                     elif G == 92:
-                        x = self.getFloat(line, "X")
-                        y = self.getFloat(line, "Y")
-                        z = self.getFloat(line, "Z")
+                        x = self._getFloat(line, "X")
+                        y = self._getFloat(line, "Y")
+                        z = self._getFloat(line, "Z")
+                        e = self._getFloat(line, "E")
                         if x is not None:
-                            current_x += x
+                            current_x = x
                         if y is not None:
-                            current_y += y
+                            current_y = y
                         if z is not None:
-                            current_z += z
+                            current_z = z
+                        if e is not None:
+                            current_e = e
 
-                T = self.getInt(line, "T")
+                T = self._getInt(line, "T")
                 if T is not None:
                     current_extruder = T
                     if len(current_path) > 1 and current_z > 0:
-                        if self.createPolygon(layer_data, current_path, current_layer, current_extruder):
+                        if self._createPolygon(layer_data_builder, current_path, current_layer, current_extruder):
                             current_layer += 1
+                        current_path.clear()
                     else:
                         current_path.clear()
 
-            if len(current_path) > 1:
-                if self.createPolygon(layer_data, current_path, current_layer, current_extruder):
+            if len(current_path) > 1 and current_z > 0:
+                if self._createPolygon(layer_data_builder, current_path, current_layer, current_extruder):
                     current_layer += 1
+                current_path.clear()
 
-            layer_mesh = layer_data.build()
-            decorator = LayerDataDecorator.LayerDataDecorator()
-            decorator.setLayerData(layer_mesh)
-
-            self.scene_node.removeDecorator("LayerDataDecorator")
-            self.scene_node.addDecorator(decorator)
+        layer_mesh = layer_data_builder.build()
+        decorator = LayerDataDecorator.LayerDataDecorator()
+        decorator.setLayerData(layer_mesh)
 
-            Logger.log("d", "Finished parsing %s" % file_name)
-            self.message.hide()
+        self._scene_node.removeDecorator("LayerDataDecorator")
+        self._scene_node.addDecorator(decorator)
 
-            if current_layer == 0:
-                Logger.log("w", "File %s doesn't contain any valid layers" % file_name)
+        Logger.log("d", "Finished parsing %s" % file_name)
+        self._message.hide()
 
-            Application.getInstance().getPrintInformation().setPreSliced(True)
+        if current_layer == 0:
+            Logger.log("w", "File %s doesn't contain any valid layers" % file_name)
 
-            settings = Application.getInstance().getGlobalContainerStack()
-            machine_width = settings.getProperty("machine_width", "value")
-            machine_depth = settings.getProperty("machine_depth", "value")
+        Application.getInstance().getPrintInformation().setPreSliced(True)
+        Application.getInstance().setHideSettings(True)
 
-            self.scene_node.setPosition(Vector(-machine_width / 2, 0, machine_depth / 2))
+        settings = Application.getInstance().getGlobalContainerStack()
+        machine_width = settings.getProperty("machine_width", "value")
+        machine_depth = settings.getProperty("machine_depth", "value")
 
-            view = Application.getInstance().getController().getActiveView()
-            if view.getPluginId() == "LayerView":
-                view.resetLayerData()
-                view.setLayer(999999)
-                view.calculateMaxLayers()
+        self._scene_node.setPosition(Vector(-machine_width / 2, 0, machine_depth / 2))
 
-            Logger.log("d", "Loaded %s" % file_name)
+        Logger.log("d", "Loaded %s" % file_name)
 
-        return self.scene_node
+        return self._scene_node