Changing the message used from the engine from Layer to LayerOptimized.

plugins/CuraEngineBackend/Cura.proto

@@ -44,11 +44,40 @@ message Layer {
 }
 
 message Polygon {
-    bytes line_type = 1;
-    bytes points = 2;
-    bytes line_width = 3;
+    enum Type {
+        NoneType = 0;
+        Inset0Type = 1;
+        InsetXType = 2;
+        SkinType = 3;
+        SupportType = 4;
+        SkirtType = 5;
+        InfillType = 6;
+        SupportInfillType = 7;
+        MoveCombingType = 8;
+        MoveRetractionType = 9;
+    }
+    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
 }
 
+message LayerOptimized { 
+    int32 id = 1;
+    float height = 2; // Z position
+    float thickness = 3; // height of a single layer
+
+    repeated PathSegment path_segment = 4; // layer data
+}
+
+
+message PathSegment {
+	int32 ordinal = 1; // The absolute ordinal of this line segment
+    bytes line_type = 2; // 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 points = 3; // The points defining the line segments, bytes of int64[2]? array of length N+1
+    bytes line_width = 4; // The widths of the line segments as bytes of a float?/int32? array of length 1 or N
+}
+
+
 message GCodeLayer {
     bytes data = 2;
 }

plugins/CuraEngineBackend/CuraEngineBackend.py

@@ -56,6 +56,7 @@ class CuraEngineBackend(Backend):
         Application.getInstance().getController().activeViewChanged.connect(self._onActiveViewChanged)
         self._onActiveViewChanged()
         self._stored_layer_data = []
+        self._stored_optimized_layer_data = []
 
         #Triggers for when to (re)start slicing:
         self._global_container_stack = None
@@ -76,6 +77,7 @@ class CuraEngineBackend(Backend):
 
         #Listeners for receiving messages from the back-end.
         self._message_handlers["cura.proto.Layer"] = self._onLayerMessage
+        self._message_handlers["cura.proto.LayerOptimized"] = self._onOptimizedLayerMessage
         self._message_handlers["cura.proto.Progress"] = self._onProgressMessage
         self._message_handlers["cura.proto.GCodeLayer"] = self._onGCodeLayerMessage
         self._message_handlers["cura.proto.GCodePrefix"] = self._onGCodePrefixMessage
@@ -127,6 +129,7 @@ class CuraEngineBackend(Backend):
     ##  Perform a slice of the scene.
     def slice(self):
         self._stored_layer_data = []
+        self._stored_optimized_layer_data = []
 
         if not self._enabled or not self._global_container_stack: #We shouldn't be slicing.
             return
@@ -158,6 +161,7 @@ class CuraEngineBackend(Backend):
         self._slicing = False
         self._restart = True
         self._stored_layer_data = []
+        self._stored_optimized_layer_data = []
         if self._start_slice_job is not None:
             self._start_slice_job.cancel()
 
@@ -257,6 +261,12 @@ class CuraEngineBackend(Backend):
     def _onLayerMessage(self, message):
         self._stored_layer_data.append(message)
 
+    ##  Called when an optimized sliced layer data message is received from the engine.
+    #
+    #   \param message The protobuf message containing sliced layer data.
+    def _onOptimizedLayerMessage(self, message):
+        self._stored_optimized_layer_data.append(message)
+
     ##  Called when a progress message is received from the engine.
     #
     #   \param message The protobuf message containing the slicing progress.
@@ -274,9 +284,9 @@ class CuraEngineBackend(Backend):
         self._slicing = False
 
         if self._layer_view_active and (self._process_layers_job is None or not self._process_layers_job.isRunning()):
-            self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_layer_data)
+            self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_optimized_layer_data)
             self._process_layers_job.start()
-            self._stored_layer_data = []
+            self._stored_optimized_layer_data = []
 
     ##  Called when a g-code message is received from the engine.
     #
@@ -344,10 +354,10 @@ class CuraEngineBackend(Backend):
                 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.
-                if self._stored_layer_data and not self._slicing:
-                    self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_layer_data)
+                if self._stored_optimized_layer_data and not self._slicing:
+                    self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_optimized_layer_data)
                     self._process_layers_job.start()
-                    self._stored_layer_data = []
+                    self._stored_optimized_layer_data = []
             else:
                 self._layer_view_active = False
 

plugins/CuraEngineBackend/ProcessSlicedLayersJob.py

@@ -91,8 +91,8 @@ class ProcessSlicedLayersJob(Job):
             layer_data.setLayerHeight(abs_layer_number, layer.height)
             layer_data.setLayerThickness(abs_layer_number, layer.thickness)
 
-            for p in range(layer.repeatedMessageCount("polygons")):
-                polygon = layer.getRepeatedMessage("polygons", p)
+            for p in range(layer.repeatedMessageCount("path_segment")):
+                polygon = layer.getRepeatedMessage("path_segment", p)
 
                 line_types = numpy.fromstring(polygon.line_type, dtype="u1")  # Convert bytearray to numpy array
                 line_types = line_types.reshape((-1,1))