xMerge branch 'master' of https://github.com/Ultimaker/PluggableCura

CuraEngineBackend.py

@@ -4,6 +4,7 @@ from UM.Scene.SceneNode import SceneNode
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Preferences import Preferences
 from UM.Math.Vector import Vector
+from UM.Signal import Signal
 
 from . import Cura_pb2
 from . import ProcessSlicedObjectListJob
@@ -17,6 +18,8 @@ class CuraEngineBackend(Backend):
     def __init__(self):
         super().__init__()
 
+        Preferences.getInstance().addPreference('backend/location', '../PinkUnicornEngine/CuraEngine')
+
         self._scene = Application.getInstance().getController().getScene()
         self._scene.sceneChanged.connect(self._onSceneChanged)
 
@@ -33,8 +36,18 @@ class CuraEngineBackend(Backend):
 
         self._center = None
 
+        self._slice_interval = 0.5
+
+        self._slicing = False
+        self._restart = False
+
+        self.changeTimerFinished.connect(self._onChangeTimerFinished)
+        self.backendConnected.connect(self._onBackendConnected)
+
     def getEngineCommand(self):
-        return [Preferences.getPreference("BackendLocation"), '--connect', "127.0.0.1:{0}".format(self._port)]
+        return [Preferences.getInstance().getValue("backend/location"), '--connect', "127.0.0.1:{0}".format(self._port)]
+
+    changeTimerFinished = Signal()
 
     def _onSceneChanged(self, source):
         if (type(source) is not SceneNode) or (source is self._scene.getRoot()):
@@ -59,6 +72,8 @@ class CuraEngineBackend(Backend):
         job.start()
 
     def _onProgressMessage(self, message):
+        if message.amount >= 0.99:
+            self._slicing = False
         self.processingProgress.emit(message.amount)
 
     def _onGCodeMessage(self, message):
@@ -83,12 +98,18 @@ class CuraEngineBackend(Backend):
             return
 
         if self._changeTimer:
-            return
+            self._changeTimer.cancel()
 
-        self._changeTimer = threading.Timer(1, self._onChangeTimerFinished)
+        self._changeTimer = threading.Timer(self._slice_interval, lambda: self.changeTimerFinished.emit())
         self._changeTimer.start()
 
     def _onChangeTimerFinished(self):
+        if self._slicing:
+            self._slicing = False
+            self._restart = True
+            self._process.terminate()
+            return
+
         objects = []
         for node in DepthFirstIterator(self._scene.getRoot()):
             if type(node) is SceneNode and node.getMeshData():
@@ -98,6 +119,9 @@ class CuraEngineBackend(Backend):
             self._changeTimer = None
             return #No point in slicing an empty build plate
 
+        self._slicing = True
+        self.processingProgress.emit(0.0)
+
         self._sendSettings()
 
         self._scene.acquireLock()
@@ -306,3 +330,8 @@ class CuraEngineBackend(Backend):
             s.value = str(value).encode('utf-8')
 
         self._socket.sendMessage(msg)
+
+    def _onBackendConnected(self):
+        if self._restart:
+            self._onChanged()
+            self._restart = False

LayerData.py

@@ -1,4 +1,5 @@
 from UM.Mesh.MeshData import MeshData
+from UM.Math.Color import Color
 
 import numpy
 import math
@@ -7,16 +8,22 @@ class LayerData(MeshData):
     def __init__(self):
         super().__init__()
         self._layers = {}
+        self._element_counts = []
 
     def addPolygon(self, layer, type, data):
         if layer not in self._layers:
             self._layers[layer] = []
 
-        self._layers[layer].append(Polygon(self, type, data))
+        p = Polygon(self, type, data)
+        self._layers[layer].append(p)
+        self._element_counts.append(p.count)
 
     def getLayers(self):
         return self._layers
 
+    def getElementCounts(self):
+        return self._element_counts
+
 class Polygon():
     NoneType = 0
     Inset0Type = 1
@@ -30,11 +37,33 @@ class Polygon():
         self._type = type
         self._begin = mesh._vertex_count
         mesh.addVertices(data)
+        self._end = self._begin + len(data) - 1
 
-        indices = [self._begin + i for i in range(len(data))]
+        color = None
+        if type == self.Inset0Type:
+            color = [1, 0, 0, 1]
+        elif type == self.InsetXType:
+            color = [0, 1, 0, 1]
+        elif type == self.SkinType:
+            color = [1, 1, 0, 1]
+        elif type == self.SupportType:
+            color = [0, 1, 1, 1]
+        elif type == self.SkirtType:
+            color = [0, 1, 1, 1]
+        else:
+            color = [1, 1, 1, 1]
 
+        colors = [color for i in range(len(data))]
+        mesh.addColors(numpy.array(colors, dtype=numpy.float32))
+
+        indices = []
+        for i in range(self._begin, self._end):
+            indices.append(i)
+            indices.append(i + 1)
+
+        indices.append(self._end)
+        indices.append(self._begin)
         mesh.addIndices(numpy.array(indices, dtype=numpy.int32))
-        self._end = mesh._vertex_count
 
     @property
     def type(self):
@@ -43,3 +72,7 @@ class Polygon():
     @property
     def data(self):
         return self._data
+
+    @property
+    def count(self):
+        return self._end - self._begin

ProcessGCodeJob.py

@@ -18,10 +18,10 @@ class ProcessGCodeJob(Job):
             if type(node) is SceneNode and node.getMeshData():
                 objectIdMap[id(node)] = node
 
-        node = objectIdMap[self._message.id]
+        if self._message.id in objectIdMap:
-        if node:
+            node = objectIdMap[self._message.id]
             with open(self._message.filename) as f:
                 data = f.read(None)
                 setattr(node.getMeshData(), 'gcode', data)
 
-            os.remove(self._message.filename)
+        os.remove(self._message.filename)

ProcessSlicedObjectListJob.py

@@ -40,3 +40,4 @@ class ProcessSlicedObjectListJob(Job):
                     layerData.addPolygon(layer.id, polygon.type, points)
 
             mesh.layerData = layerData
+            objectIdMap[object.id].meshDataChanged.emit()

__init__.py

@@ -1,8 +1,6 @@
 #Shoopdawoop
 from . import CuraEngineBackend
 
-from UM.Preferences import Preferences
-
 def getMetaData():
     return {
         'type': 'backend',
@@ -12,6 +10,5 @@ def getMetaData():
     }
 
 def register(app):
-    Preferences.addPreference("BackendLocation","../PinkUnicornEngine/CuraEngine")
     return CuraEngineBackend.CuraEngineBackend()