Merge branch '3.1' of github.com:Ultimaker/Cura into 3.1

cura/CuraApplication.py

@@ -126,8 +126,6 @@ class CuraApplication(QtApplication):
     #        Cura will always show the Add Machine Dialog upon start.
     stacksValidationFinished = pyqtSignal()  # Emitted whenever a validation is finished
 
-    projectFileLoaded = pyqtSignal(str)  # Emitted whenever a project file is loaded
-
     def __init__(self):
         # this list of dir names will be used by UM to detect an old cura directory
         for dir_name in ["extruders", "machine_instances", "materials", "plugins", "quality", "user", "variants"]:
@@ -218,7 +216,7 @@ class CuraApplication(QtApplication):
             "CuraEngineBackend",
             "UserAgreement",
             "SolidView",
-            "LayerView",
+            "SimulationView",
             "STLReader",
             "SelectionTool",
             "CameraTool",
@@ -1386,7 +1384,7 @@ class CuraApplication(QtApplication):
 
             extension = os.path.splitext(filename)[1]
             if extension.lower() in self._non_sliceable_extensions:
-                self.getController().setActiveView("LayerView")
+                self.getController().setActiveView("SimulationView")
                 view = self.getController().getActiveView()
                 view.resetLayerData()
                 view.setLayer(9999999)

cura/Layer.py

@@ -47,12 +47,12 @@ class Layer:
 
         return result
 
-    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, line_types, indices):
+    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, feedrates, extruders, line_types, indices):
         result_vertex_offset = vertex_offset
         result_index_offset = index_offset
         self._element_count = 0
         for polygon in self._polygons:
-            polygon.build(result_vertex_offset, result_index_offset, vertices, colors, line_dimensions, extruders, line_types, indices)
+            polygon.build(result_vertex_offset, result_index_offset, vertices, colors, line_dimensions, feedrates, extruders, line_types, indices)
             result_vertex_offset += polygon.lineMeshVertexCount()
             result_index_offset += polygon.lineMeshElementCount()
             self._element_count += polygon.elementCount

cura/LayerDataBuilder.py

@@ -20,11 +20,11 @@ class LayerDataBuilder(MeshBuilder):
         if layer not in self._layers:
             self._layers[layer] = Layer(layer)
 
-    def addPolygon(self, layer, polygon_type, data, line_width):
+    def addPolygon(self, layer, polygon_type, data, line_width, line_thickness, line_feedrate):
         if layer not in self._layers:
             self.addLayer(layer)
 
-        p = LayerPolygon(self, polygon_type, data, line_width)
+        p = LayerPolygon(self, polygon_type, data, line_width, line_thickness, line_feedrate)
         self._layers[layer].polygons.append(p)
 
     def getLayer(self, layer):
@@ -64,13 +64,14 @@ class LayerDataBuilder(MeshBuilder):
         line_dimensions = numpy.empty((vertex_count, 2), numpy.float32)
         colors = numpy.empty((vertex_count, 4), numpy.float32)
         indices = numpy.empty((index_count, 2), numpy.int32)
+        feedrates = numpy.empty((vertex_count), numpy.float32)
         extruders = numpy.empty((vertex_count), numpy.float32)
         line_types = numpy.empty((vertex_count), numpy.float32)
 
         vertex_offset = 0
         index_offset = 0
         for layer, data in sorted(self._layers.items()):
-            ( vertex_offset, index_offset ) = data.build( vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, line_types, indices)
+            ( vertex_offset, index_offset ) = data.build( vertex_offset, index_offset, vertices, colors, line_dimensions, feedrates, extruders, line_types, indices)
             self._element_counts[layer] = data.elementCount
 
         self.addVertices(vertices)
@@ -107,6 +108,11 @@ class LayerDataBuilder(MeshBuilder):
                 "value": line_types,
                 "opengl_name": "a_line_type",
                 "opengl_type": "float"
+                },
+            "feedrates": {
+                "value": feedrates,
+                "opengl_name": "a_feedrate",
+                "opengl_type": "float"
                 }
             }
 

cura/LayerPolygon.py

@@ -28,7 +28,8 @@ class LayerPolygon:
     #   \param data new_points
     #   \param line_widths array with line widths
     #   \param line_thicknesses: array with type as index and thickness as value
-    def __init__(self, extruder, line_types, data, line_widths, line_thicknesses):
+    #   \param line_feedrates array with line feedrates
+    def __init__(self, extruder, line_types, data, line_widths, line_thicknesses, line_feedrates):
         self._extruder = extruder
         self._types = line_types
         for i in range(len(self._types)):
@@ -37,6 +38,7 @@ class LayerPolygon:
         self._data = data
         self._line_widths = line_widths
         self._line_thicknesses = line_thicknesses
+        self._line_feedrates = line_feedrates
 
         self._vertex_begin = 0
         self._vertex_end = 0
@@ -84,10 +86,11 @@ class LayerPolygon:
     #   \param vertices : vertex numpy array to be filled
     #   \param colors : vertex numpy array to be filled
     #   \param line_dimensions : vertex numpy array to be filled
+    #   \param feedrates : vertex numpy array to be filled
     #   \param extruders : vertex numpy array to be filled
     #   \param line_types : vertex numpy array to be filled
     #   \param indices : index numpy array to be filled
-    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, line_types, indices):
+    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, feedrates, extruders, line_types, indices):
         if self._build_cache_line_mesh_mask is None or self._build_cache_needed_points is None:
             self.buildCache()
             
@@ -109,10 +112,13 @@ class LayerPolygon:
         # Create an array with colors for each vertex and remove the color data for the points that has been thrown away. 
         colors[self._vertex_begin:self._vertex_end, :] = numpy.tile(self._colors, (1, 2)).reshape((-1, 4))[needed_points_list.ravel()]
 
-        # Create an array with line widths for each vertex.
+        # Create an array with line widths and thicknesses for each vertex.
         line_dimensions[self._vertex_begin:self._vertex_end, 0] = numpy.tile(self._line_widths, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
         line_dimensions[self._vertex_begin:self._vertex_end, 1] = numpy.tile(self._line_thicknesses, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
 
+        # Create an array with feedrates for each line
+        feedrates[self._vertex_begin:self._vertex_end] = numpy.tile(self._line_feedrates, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
+
         extruders[self._vertex_begin:self._vertex_end] = self._extruder
 
         # Convert type per vertex to type per line
@@ -166,6 +172,14 @@ class LayerPolygon:
     @property
     def lineWidths(self):
         return self._line_widths
+
+    @property
+    def lineThicknesses(self):
+        return self._line_thicknesses
+
+    @property
+    def lineFeedrates(self):
+        return self._line_feedrates
     
     @property
     def jumpMask(self):

cura/PrintInformation.py

@@ -71,7 +71,7 @@ class PrintInformation(QObject):
 
         Application.getInstance().globalContainerStackChanged.connect(self._updateJobName)
         Application.getInstance().fileLoaded.connect(self.setBaseName)
-        Application.getInstance().projectFileLoaded.connect(self.setProjectName)
+        Application.getInstance().workspaceLoaded.connect(self.setProjectName)
         Preferences.getInstance().preferenceChanged.connect(self._onPreferencesChanged)
 
         self._active_material_container = None

plugins/CuraEngineBackend/Cura.proto

@@ -61,6 +61,8 @@ message Polygon {
     Type type = 1; // Type of move
     bytes points = 2; // The points of the polygon, or two points if only a line segment (Currently only line segments are used)
     float line_width = 3; // The width of the line being laid down
+    float line_thickness = 4; // The thickness of the line being laid down
+    float line_feedrate = 5; // The feedrate of the line being laid down
 }
 
 message LayerOptimized {
@@ -82,6 +84,8 @@ message PathSegment {
     bytes points = 3; // The points defining the line segments, bytes of float[2/3] array of length N+1
     bytes line_type = 4; // Type of line segment as an unsigned char array of length 1 or N, where N is the number of line segments in this path
     bytes line_width = 5; // The widths of the line segments as bytes of a float array of length 1 or N
+    bytes line_thickness = 6; // The thickness of the line segments as bytes of a float array of length 1 or N
+    bytes line_feedrate = 7; // The feedrate of the line segments as bytes of a float array of length 1 or N
 }
 
 

plugins/CuraEngineBackend/CuraEngineBackend.py

@@ -608,7 +608,7 @@ class CuraEngineBackend(QObject, Backend):
     def _onActiveViewChanged(self):
         if Application.getInstance().getController().getActiveView():
             view = Application.getInstance().getController().getActiveView()
-            if view.getPluginId() == "LayerView":  # If switching to layer view, we should process the layers if that hasn't been done yet.
+            if view.getPluginId() == "SimulationView":  # If switching to layer view, we should process the layers if that hasn't been done yet.
                 self._layer_view_active = True
                 # There is data and we're not slicing at the moment
                 # if we are slicing, there is no need to re-calculate the data as it will be invalid in a moment.

plugins/CuraEngineBackend/ProcessSlicedLayersJob.py

@@ -61,7 +61,7 @@ class ProcessSlicedLayersJob(Job):
 
     def run(self):
         start_time = time()
-        if Application.getInstance().getController().getActiveView().getPluginId() == "LayerView":
+        if Application.getInstance().getController().getActiveView().getPluginId() == "SimulationView":
             self._progress_message.show()
             Job.yieldThread()
             if self._abort_requested:
@@ -109,6 +109,7 @@ class ProcessSlicedLayersJob(Job):
             layer_data.addLayer(abs_layer_number)
             this_layer = layer_data.getLayer(abs_layer_number)
             layer_data.setLayerHeight(abs_layer_number, layer.height)
+            layer_data.setLayerThickness(abs_layer_number, layer.thickness)
 
             for p in range(layer.repeatedMessageCount("path_segment")):
                 polygon = layer.getRepeatedMessage("path_segment", p)
@@ -127,10 +128,11 @@ class ProcessSlicedLayersJob(Job):
                 line_widths = numpy.fromstring(polygon.line_width, dtype="f4")  # Convert bytearray to numpy array
                 line_widths = line_widths.reshape((-1,1))  # We get a linear list of pairs that make up the points, so make numpy interpret them correctly.
 
-                # In the future, line_thicknesses should be given by CuraEngine as well.
-                # Currently the infill layer thickness also translates to line width
-                line_thicknesses = numpy.zeros(line_widths.shape, dtype="f4")
-                line_thicknesses[:] = layer.thickness / 1000  # from micrometer to millimeter
+                line_thicknesses = numpy.fromstring(polygon.line_thickness, dtype="f4")  # Convert bytearray to numpy array
+                line_thicknesses = line_thicknesses.reshape((-1,1))  # We get a linear list of pairs that make up the points, so make numpy interpret them correctly.
+
+                line_feedrates = numpy.fromstring(polygon.line_feedrate, dtype="f4")  # Convert bytearray to numpy array
+                line_feedrates = line_feedrates.reshape((-1,1))  # We get a linear list of pairs that make up the points, so make numpy interpret them correctly.
 
                 # Create a new 3D-array, copy the 2D points over and insert the right height.
                 # This uses manual array creation + copy rather than numpy.insert since this is
@@ -145,7 +147,7 @@ class ProcessSlicedLayersJob(Job):
                     new_points[:, 1] = points[:, 2]
                     new_points[:, 2] = -points[:, 1]
 
-                this_poly = LayerPolygon.LayerPolygon(extruder, line_types, new_points, line_widths, line_thicknesses)
+                this_poly = LayerPolygon.LayerPolygon(extruder, line_types, new_points, line_widths, line_thicknesses, line_feedrates)
                 this_poly.buildCache()
 
                 this_layer.polygons.append(this_poly)
@@ -219,7 +221,7 @@ class ProcessSlicedLayersJob(Job):
             self._progress_message.setProgress(100)
 
         view = Application.getInstance().getController().getActiveView()
-        if view.getPluginId() == "LayerView":
+        if view.getPluginId() == "SimulationView":
             view.resetLayerData()
 
         if self._progress_message:
@@ -232,7 +234,7 @@ class ProcessSlicedLayersJob(Job):
 
     def _onActiveViewChanged(self):
         if self.isRunning():
-            if Application.getInstance().getController().getActiveView().getPluginId() == "LayerView":
+            if Application.getInstance().getController().getActiveView().getPluginId() == "SimulationView":
                 if not self._progress_message:
                     self._progress_message = Message(catalog.i18nc("@info:status", "Processing Layers"), 0, False, 0, catalog.i18nc("@info:title", "Information"))
                 if self._progress_message.getProgress() != 100:

plugins/GCodeReader/GCodeReader.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2016 Aleph Objects, Inc.
+# Copyright (c) 2017 Aleph Objects, Inc.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.Application import Application
@@ -40,7 +40,8 @@ class GCodeReader(MeshReader):
         self._extruder_number = 0
         self._clearValues()
         self._scene_node = None
-        self._position = namedtuple('Position', ['x', 'y', 'z', 'e'])
+        # X, Y, Z position, F feedrate and E extruder values are stored
+        self._position = namedtuple('Position', ['x', 'y', 'z', 'f', 'e'])
         self._is_layers_in_file = False  # Does the Gcode have the layers comment?
         self._extruder_offsets = {}  # Offsets for multi extruders. key is index, value is [x-offset, y-offset]
         self._current_layer_thickness = 0.2  # default
@@ -48,7 +49,9 @@ class GCodeReader(MeshReader):
         Preferences.getInstance().addPreference("gcodereader/show_caution", True)
 
     def _clearValues(self):
+        self._filament_diameter = 2.85
         self._extruder_number = 0
+        self._extrusion_length_offset = [0]
         self._layer_type = LayerPolygon.Inset0Type
         self._layer_number = 0
         self._previous_z = 0
@@ -97,7 +100,7 @@ class GCodeReader(MeshReader):
     def _createPolygon(self, layer_thickness, path, extruder_offsets):
         countvalid = 0
         for point in path:
-            if point[3] > 0:
+            if point[5] > 0:
                 countvalid += 1
                 if countvalid >= 2:
                     # we know what to do now, no need to count further
@@ -115,27 +118,56 @@ class GCodeReader(MeshReader):
         line_types = numpy.empty((count - 1, 1), numpy.int32)
         line_widths = numpy.empty((count - 1, 1), numpy.float32)
         line_thicknesses = numpy.empty((count - 1, 1), numpy.float32)
-        # TODO: need to calculate actual line width based on E values
+        line_feedrates = numpy.empty((count - 1, 1), numpy.float32)
         line_widths[:, 0] = 0.35  # Just a guess
         line_thicknesses[:, 0] = layer_thickness
         points = numpy.empty((count, 3), numpy.float32)
+        extrusion_values = numpy.empty((count, 1), numpy.float32)
         i = 0
         for point in path:
             points[i, :] = [point[0] + extruder_offsets[0], point[2], -point[1] - extruder_offsets[1]]
+            extrusion_values[i] = point[4]
             if i > 0:
-                line_types[i - 1] = point[3]
-                if point[3] in [LayerPolygon.MoveCombingType, LayerPolygon.MoveRetractionType]:
+                line_feedrates[i - 1] = point[3]
+                line_types[i - 1] = point[5]
+                if point[5] in [LayerPolygon.MoveCombingType, LayerPolygon.MoveRetractionType]:
                     line_widths[i - 1] = 0.1
+                    line_thicknesses[i - 1] = 0.0 # Travels are set as zero thickness lines
+                else:
+                    line_widths[i - 1] = self._calculateLineWidth(points[i], points[i-1], extrusion_values[i], extrusion_values[i-1], layer_thickness)
             i += 1
 
-        this_poly = LayerPolygon(self._extruder_number, line_types, points, line_widths, line_thicknesses)
+        this_poly = LayerPolygon(self._extruder_number, line_types, points, line_widths, line_thicknesses, line_feedrates)
         this_poly.buildCache()
 
         this_layer.polygons.append(this_poly)
         return True
 
+    def _calculateLineWidth(self, current_point, previous_point, current_extrusion, previous_extrusion, layer_thickness):
+        # Area of the filament
+        Af = (self._filament_diameter / 2) ** 2 * numpy.pi
+        # Length of the extruded filament
+        de = current_extrusion - previous_extrusion
+        # Volumne of the extruded filament
+        dVe = de * Af
+        # Length of the printed line
+        dX = numpy.sqrt((current_point[0] - previous_point[0])**2 + (current_point[2] - previous_point[2])**2)
+        # When the extruder recovers from a retraction, we get zero distance
+        if dX == 0:
+            return 0.1
+        # Area of the printed line. This area is a rectangle
+        Ae = dVe / dX
+        # This area is a rectangle with area equal to layer_thickness * layer_width
+        line_width = Ae / layer_thickness
+
+        # A threshold is set to avoid weird paths in the GCode
+        if line_width > 1.2:
+            return 0.35
+        return line_width
+
     def _gCode0(self, position, params, path):
-        x, y, z, e = position
+        x, y, z, f, e = position
+
         if self._is_absolute_positioning:
             x = params.x if params.x is not None else x
             y = params.y if params.y is not None else y
@@ -145,22 +177,24 @@ class GCodeReader(MeshReader):
             y += params.y if params.y is not None else 0
             z += params.z if params.z is not None else 0
 
+        f = params.f if params.f is not None else f
+
         if params.e is not None:
             new_extrusion_value = params.e if self._is_absolute_positioning else e[self._extruder_number] + params.e
             if new_extrusion_value > e[self._extruder_number]:
-                path.append([x, y, z, self._layer_type])  # extrusion
+                path.append([x, y, z, f, params.e + self._extrusion_length_offset[self._extruder_number], self._layer_type])  # extrusion
             else:
-                path.append([x, y, z, LayerPolygon.MoveRetractionType])  # retraction
+                path.append([x, y, z, f, params.e + self._extrusion_length_offset[self._extruder_number], LayerPolygon.MoveRetractionType])  # retraction
             e[self._extruder_number] = new_extrusion_value
 
             # Only when extruding we can determine the latest known "layer height" which is the difference in height between extrusions
             # Also, 1.5 is a heuristic for any priming or whatsoever, we skip those.
             if z > self._previous_z and (z - self._previous_z < 1.5):
-                self._current_layer_thickness = z - self._previous_z + 0.05  # allow a tiny overlap
+                self._current_layer_thickness = z - self._previous_z # allow a tiny overlap
                 self._previous_z = z
         else:
-            path.append([x, y, z, LayerPolygon.MoveCombingType])
-        return self._position(x, y, z, e)
+            path.append([x, y, z, f, e[self._extruder_number] + self._extrusion_length_offset[self._extruder_number], LayerPolygon.MoveCombingType])
+        return self._position(x, y, z, f, e)
 
     # G0 and G1 should be handled exactly the same.
     _gCode1 = _gCode0
@@ -171,6 +205,7 @@ class GCodeReader(MeshReader):
             params.x if params.x is not None else position.x,
             params.y if params.y is not None else position.y,
             0,
+            position.f,
             position.e)
 
     ##  Set the absolute positioning
@@ -187,11 +222,14 @@ class GCodeReader(MeshReader):
     #   For example: G92 X10 will set the X to 10 without any physical motion.
     def _gCode92(self, position, params, path):
         if params.e is not None:
+            # Sometimes a G92 E0 is introduced in the middle of the GCode so we need to keep those offsets for calculate the line_width
+            self._extrusion_length_offset[self._extruder_number] += position.e[self._extruder_number] - params.e
             position.e[self._extruder_number] = params.e
         return self._position(
             params.x if params.x is not None else position.x,
             params.y if params.y is not None else position.y,
             params.z if params.z is not None else position.z,
+            params.f if params.f is not None else position.f,
             position.e)
 
     def _processGCode(self, G, line, position, path):
@@ -199,7 +237,7 @@ class GCodeReader(MeshReader):
         line = line.split(";", 1)[0]  # Remove comments (if any)
         if func is not None:
             s = line.upper().split(" ")
-            x, y, z, e = None, None, None, None
+            x, y, z, f, e = None, None, None, None, None
             for item in s[1:]:
                 if len(item) <= 1:
                     continue
@@ -211,17 +249,20 @@ class GCodeReader(MeshReader):
                     y = float(item[1:])
                 if item[0] == "Z":
                     z = float(item[1:])
+                if item[0] == "F":
+                    f = float(item[1:]) / 60
                 if item[0] == "E":
                     e = float(item[1:])
             if self._is_absolute_positioning and ((x is not None and x < 0) or (y is not None and y < 0)):
                 self._center_is_zero = True
-            params = self._position(x, y, z, e)
+            params = self._position(x, y, z, f, e)
             return func(position, params, path)
         return position
 
     def _processTCode(self, T, line, position, path):
         self._extruder_number = T
         if self._extruder_number + 1 > len(position.e):
+            self._extrusion_length_offset.extend([0] * (self._extruder_number - len(position.e) + 1))
             position.e.extend([0] * (self._extruder_number - len(position.e) + 1))
         return position
 
@@ -240,6 +281,8 @@ class GCodeReader(MeshReader):
     def read(self, file_name):
         Logger.log("d", "Preparing to load %s" % file_name)
         self._cancelled = False
+        # We obtain the filament diameter from the selected printer to calculate line widths
+        self._filament_diameter = Application.getInstance().getGlobalContainerStack().getProperty("material_diameter", "value")
 
         scene_node = SceneNode()
         # Override getBoundingBox function of the sceneNode, as this node should return a bounding box, but there is no
@@ -277,7 +320,7 @@ class GCodeReader(MeshReader):
 
             Logger.log("d", "Parsing %s..." % file_name)
 
-            current_position = self._position(0, 0, 0, [0])
+            current_position = self._position(0, 0, 0, 0, [0])
             current_path = []
 
             for line in file:
@@ -310,6 +353,7 @@ class GCodeReader(MeshReader):
                     else:
                         Logger.log("w", "Encountered a unknown type (%s) while parsing g-code.", type)
 
+                # When the layer change is reached, the polygon is computed so we have just one layer per layer per extruder
                 if self._is_layers_in_file and line[:len(self._layer_keyword)] == self._layer_keyword:
                     try:
                         layer_number = int(line[len(self._layer_keyword):])
@@ -325,17 +369,12 @@ class GCodeReader(MeshReader):
 
                 G = self._getInt(line, "G")
                 if G is not None:
+                    # When find a movement, the new posistion is calculated and added to the current_path, but
+                    # don't need to create a polygon until the end of the layer
                     current_position = self._processGCode(G, line, current_position, current_path)
-
-                    # < 2 is a heuristic for a movement only, that should not be counted as a layer
-                    if current_position.z > last_z and abs(current_position.z - last_z) < 2:
-                        if self._createPolygon(self._current_layer_thickness, current_path, self._extruder_offsets.get(self._extruder_number, [0, 0])):
-                            current_path.clear()
-                            if not self._is_layers_in_file:
-                                self._layer_number += 1
-
                     continue
 
+                # When changing the extruder, the polygon with the stored paths is computed
                 if line.startswith("T"):
                     T = self._getInt(line, "T")
                     if T is not None:
@@ -344,8 +383,8 @@ class GCodeReader(MeshReader):
 
                         current_position = self._processTCode(T, line, current_position, current_path)
 
-            # "Flush" leftovers
-            if not self._is_layers_in_file and len(current_path) > 1:
+            # "Flush" leftovers. Last layer paths are still stored
+            if len(current_path) > 1:
                 if self._createPolygon(self._current_layer_thickness, current_path, self._extruder_offsets.get(self._extruder_number, [0, 0])):
                     self._layer_number += 1
                     current_path.clear()

plugins/LayerView/LayerPass.py

@@ -1,113 +0,0 @@
-# Copyright (c) 2016 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-
-from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
-from UM.Resources import Resources
-from UM.Scene.SceneNode import SceneNode
-from UM.Scene.ToolHandle import ToolHandle
-from UM.Application import Application
-from UM.PluginRegistry import PluginRegistry
-
-from UM.View.RenderPass import RenderPass
-from UM.View.RenderBatch import RenderBatch
-from UM.View.GL.OpenGL import OpenGL
-
-from cura.Settings.ExtruderManager import ExtruderManager
-
-
-import os.path
-
-## RenderPass used to display g-code paths.
-class LayerPass(RenderPass):
-    def __init__(self, width, height):
-        super().__init__("layerview", width, height)
-
-        self._layer_shader = None
-        self._tool_handle_shader = None
-        self._gl = OpenGL.getInstance().getBindingsObject()
-        self._scene = Application.getInstance().getController().getScene()
-        self._extruder_manager = ExtruderManager.getInstance()
-
-        self._layer_view = None
-        self._compatibility_mode = None
-
-    def setLayerView(self, layerview):
-        self._layer_view = layerview
-        self._compatibility_mode = layerview.getCompatibilityMode()
-
-    def render(self):
-        if not self._layer_shader:
-            if self._compatibility_mode:
-                shader_filename = "layers.shader"
-            else:
-                shader_filename = "layers3d.shader"
-            self._layer_shader = OpenGL.getInstance().createShaderProgram(os.path.join(PluginRegistry.getInstance().getPluginPath("LayerView"), shader_filename))
-        # Use extruder 0 if the extruder manager reports extruder index -1 (for single extrusion printers)
-        self._layer_shader.setUniformValue("u_active_extruder", float(max(0, self._extruder_manager.activeExtruderIndex)))
-        if self._layer_view:
-            self._layer_shader.setUniformValue("u_layer_view_type", self._layer_view.getLayerViewType())
-            self._layer_shader.setUniformValue("u_extruder_opacity", self._layer_view.getExtruderOpacities())
-            self._layer_shader.setUniformValue("u_show_travel_moves", self._layer_view.getShowTravelMoves())
-            self._layer_shader.setUniformValue("u_show_helpers", self._layer_view.getShowHelpers())
-            self._layer_shader.setUniformValue("u_show_skin", self._layer_view.getShowSkin())
-            self._layer_shader.setUniformValue("u_show_infill", self._layer_view.getShowInfill())
-        else:
-            #defaults
-            self._layer_shader.setUniformValue("u_layer_view_type", 1)
-            self._layer_shader.setUniformValue("u_extruder_opacity", [1, 1, 1, 1])
-            self._layer_shader.setUniformValue("u_show_travel_moves", 0)
-            self._layer_shader.setUniformValue("u_show_helpers", 1)
-            self._layer_shader.setUniformValue("u_show_skin", 1)
-            self._layer_shader.setUniformValue("u_show_infill", 1)
-
-        if not self._tool_handle_shader:
-            self._tool_handle_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "toolhandle.shader"))
-
-        self.bind()
-
-        tool_handle_batch = RenderBatch(self._tool_handle_shader, type = RenderBatch.RenderType.Overlay)
-
-        for node in DepthFirstIterator(self._scene.getRoot()):
-
-            if isinstance(node, ToolHandle):
-                tool_handle_batch.addItem(node.getWorldTransformation(), mesh = node.getSolidMesh())
-
-            elif isinstance(node, SceneNode) and (node.getMeshData() or node.callDecoration("isBlockSlicing")) and node.isVisible():
-                layer_data = node.callDecoration("getLayerData")
-                if not layer_data:
-                    continue
-
-                # Render all layers below a certain number as line mesh instead of vertices.
-                if self._layer_view._current_layer_num > -1 and ((not self._layer_view._only_show_top_layers) or (not self._layer_view.getCompatibilityMode())):
-                    start = 0
-                    end = 0
-                    element_counts = layer_data.getElementCounts()
-                    for layer in sorted(element_counts.keys()):
-                        if layer > self._layer_view._current_layer_num:
-                            break
-                        if self._layer_view._minimum_layer_num > layer:
-                            start += element_counts[layer]
-                        end += element_counts[layer]
-
-                    # This uses glDrawRangeElements internally to only draw a certain range of lines.
-                    batch = RenderBatch(self._layer_shader, type = RenderBatch.RenderType.Solid, mode = RenderBatch.RenderMode.Lines, range = (start, end))
-                    batch.addItem(node.getWorldTransformation(), layer_data)
-                    batch.render(self._scene.getActiveCamera())
-
-                # Create a new batch that is not range-limited
-                batch = RenderBatch(self._layer_shader, type = RenderBatch.RenderType.Solid)
-
-                if self._layer_view.getCurrentLayerMesh():
-                    batch.addItem(node.getWorldTransformation(), self._layer_view.getCurrentLayerMesh())
-
-                if self._layer_view.getCurrentLayerJumps():
-                    batch.addItem(node.getWorldTransformation(), self._layer_view.getCurrentLayerJumps())
-
-                if len(batch.items) > 0:
-                    batch.render(self._scene.getActiveCamera())
-
-        # Render toolhandles on top of the layerview
-        if len(tool_handle_batch.items) > 0:
-            tool_handle_batch.render(self._scene.getActiveCamera())
-
-        self.release()