CuraEngineBackend.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299
  1. # Copyright (c) 2015 Ultimaker B.V.
  2. # Cura is released under the terms of the AGPLv3 or higher.
  3. from UM.Backend.Backend import Backend
  4. from UM.Application import Application
  5. from UM.Scene.SceneNode import SceneNode
  6. from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
  7. from UM.Preferences import Preferences
  8. from UM.Math.Vector import Vector
  9. from UM.Signal import Signal
  10. from UM.Logger import Logger
  11. from UM.Qt.Bindings.BackendProxy import BackendState #To determine the state of the slicing job.
  12. from UM.Resources import Resources
  13. from UM.Settings.SettingOverrideDecorator import SettingOverrideDecorator
  14. from UM.Message import Message
  15. from UM.PluginRegistry import PluginRegistry
  16. from cura.OneAtATimeIterator import OneAtATimeIterator
  17. from . import ProcessSlicedLayersJob
  18. from . import ProcessGCodeJob
  19. from . import StartSliceJob
  20. import os
  21. import sys
  22. import numpy
  23. from PyQt5.QtCore import QTimer
  24. import Arcus
  25. from UM.i18n import i18nCatalog
  26. catalog = i18nCatalog("cura")
  27. class CuraEngineBackend(Backend):
  28. def __init__(self):
  29. super().__init__()
  30. # Find out where the engine is located, and how it is called. This depends on how Cura is packaged and which OS we are running on.
  31. default_engine_location = os.path.join(Application.getInstallPrefix(), "bin", "CuraEngine")
  32. if hasattr(sys, "frozen"):
  33. default_engine_location = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "CuraEngine")
  34. if sys.platform == "win32":
  35. default_engine_location += ".exe"
  36. default_engine_location = os.path.abspath(default_engine_location)
  37. Preferences.getInstance().addPreference("backend/location", default_engine_location)
  38. self._scene = Application.getInstance().getController().getScene()
  39. self._scene.sceneChanged.connect(self._onSceneChanged)
  40. # Workaround to disable layer view processing if layer view is not active.
  41. self._layer_view_active = False
  42. Application.getInstance().getController().activeViewChanged.connect(self._onActiveViewChanged)
  43. self._onActiveViewChanged()
  44. self._stored_layer_data = []
  45. # When there are current settings and machine instance is changed, there is no profile changed event. We should
  46. # pretend there is though.
  47. Application.getInstance().getMachineManager().activeMachineInstanceChanged.connect(self._onActiveProfileChanged)
  48. self._profile = None
  49. Application.getInstance().getMachineManager().activeProfileChanged.connect(self._onActiveProfileChanged)
  50. self._onActiveProfileChanged()
  51. self._change_timer = QTimer()
  52. self._change_timer.setInterval(500)
  53. self._change_timer.setSingleShot(True)
  54. self._change_timer.timeout.connect(self.slice)
  55. self._message_handlers["cura.proto.Layer"] = self._onLayerMessage
  56. self._message_handlers["cura.proto.Progress"] = self._onProgressMessage
  57. self._message_handlers["cura.proto.GCodeLayer"] = self._onGCodeLayerMessage
  58. self._message_handlers["cura.proto.GCodePrefix"] = self._onGCodePrefixMessage
  59. self._message_handlers["cura.proto.ObjectPrintTime"] = self._onObjectPrintTimeMessage
  60. self._message_handlers["cura.proto.SlicingFinished"] = self._onSlicingFinishedMessage
  61. self._slicing = False
  62. self._restart = False
  63. self._enabled = True
  64. self._always_restart = True
  65. self._process_layers_job = None #The currently active job to process layers, or None if it is not processing layers.
  66. self._message = None
  67. self.backendQuit.connect(self._onBackendQuit)
  68. self.backendConnected.connect(self._onBackendConnected)
  69. Application.getInstance().getController().toolOperationStarted.connect(self._onToolOperationStarted)
  70. Application.getInstance().getController().toolOperationStopped.connect(self._onToolOperationStopped)
  71. Application.getInstance().getMachineManager().activeMachineInstanceChanged.connect(self._onInstanceChanged)
  72. ## Get the command that is used to call the engine.
  73. # This is usefull for debugging and used to actually start the engine
  74. # \return list of commands and args / parameters.
  75. def getEngineCommand(self):
  76. active_machine = Application.getInstance().getMachineManager().getActiveMachineInstance()
  77. if not active_machine:
  78. return None
  79. return [Preferences.getInstance().getValue("backend/location"), "connect", "127.0.0.1:{0}".format(self._port), "-j", active_machine.getMachineDefinition().getPath(), "-vv"]
  80. ## Emitted when we get a message containing print duration and material amount. This also implies the slicing has finished.
  81. # \param time The amount of time the print will take.
  82. # \param material_amount The amount of material the print will use.
  83. printDurationMessage = Signal()
  84. ## Emitted when the slicing process starts.
  85. slicingStarted = Signal()
  86. ## Emitted whne the slicing process is aborted forcefully.
  87. slicingCancelled = Signal()
  88. ## Perform a slice of the scene.
  89. def slice(self):
  90. if not self._enabled:
  91. return
  92. if self._slicing:
  93. self._terminate()
  94. if self._message:
  95. self._message.hide()
  96. self._message = None
  97. return
  98. if self._process_layers_job:
  99. self._process_layers_job.abort()
  100. self._process_layers_job = None
  101. if self._profile.hasErrorValue():
  102. Logger.log("w", "Profile has error values. Aborting slicing")
  103. if self._message:
  104. self._message.hide()
  105. self._message = None
  106. self._message = Message(catalog.i18nc("@info:status", "Unable to slice. Please check your setting values for errors."))
  107. self._message.show()
  108. return #No slicing if we have error values since those are by definition illegal values.
  109. self.processingProgress.emit(0.0)
  110. self.backendStateChange.emit(BackendState.NOT_STARTED)
  111. if self._message:
  112. self._message.setProgress(-1)
  113. #else:
  114. # self._message = Message(catalog.i18nc("@info:status", "Slicing..."), 0, False, -1)
  115. # self._message.show()
  116. self._scene.gcode_list = []
  117. self._slicing = True
  118. self.slicingStarted.emit()
  119. job = StartSliceJob.StartSliceJob(self._profile, self._socket)
  120. job.start()
  121. job.finished.connect(self._onStartSliceCompleted)
  122. def _terminate(self):
  123. self._slicing = False
  124. self._restart = True
  125. self._stored_layer_data = []
  126. self.slicingCancelled.emit()
  127. self.processingProgress.emit(0)
  128. Logger.log("d", "Attempting to kill the engine process")
  129. if self._process is not None:
  130. Logger.log("d", "Killing engine process")
  131. try:
  132. self._process.terminate()
  133. Logger.log("d", "Engine process is killed. Recieved return code %s", self._process.wait())
  134. self._process = None
  135. #self._createSocket() # Re create the socket
  136. except Exception as e: # terminating a process that is already terminating causes an exception, silently ignore this.
  137. Logger.log("d", "Exception occured while trying to kill the engine %s", str(e))
  138. def _onStartSliceCompleted(self, job):
  139. if job.getError() or job.getResult() != True:
  140. if self._message:
  141. self._message.hide()
  142. self._message = None
  143. return
  144. def _onSceneChanged(self, source):
  145. if type(source) is not SceneNode:
  146. return
  147. if source is self._scene.getRoot():
  148. return
  149. if source.getMeshData() is None:
  150. return
  151. if source.getMeshData().getVertices() is None:
  152. return
  153. self._onChanged()
  154. def _onSocketError(self, error):
  155. super()._onSocketError(error)
  156. self._terminate()
  157. if error.getErrorCode() not in [Arcus.ErrorCode.BindFailedError, Arcus.ErrorCode.ConnectionResetError, Arcus.ErrorCode.Debug]:
  158. Logger.log("e", "A socket error caused the connection to be reset")
  159. def _onActiveProfileChanged(self):
  160. if self._profile:
  161. self._profile.settingValueChanged.disconnect(self._onSettingChanged)
  162. self._profile = Application.getInstance().getMachineManager().getWorkingProfile()
  163. if self._profile:
  164. self._profile.settingValueChanged.connect(self._onSettingChanged)
  165. self._onChanged()
  166. def _onSettingChanged(self, setting):
  167. self._onChanged()
  168. def _onLayerMessage(self, message):
  169. self._stored_layer_data.append(message)
  170. def _onProgressMessage(self, message):
  171. if self._message:
  172. self._message.setProgress(round(message.amount * 100))
  173. self.processingProgress.emit(message.amount)
  174. self.backendStateChange.emit(BackendState.PROCESSING)
  175. def _onSlicingFinishedMessage(self, message):
  176. self.backendStateChange.emit(BackendState.DONE)
  177. self.processingProgress.emit(1.0)
  178. self._slicing = False
  179. if self._message:
  180. self._message.setProgress(100)
  181. self._message.hide()
  182. self._message = None
  183. if self._layer_view_active and (self._process_layers_job is None or not self._process_layers_job.isRunning()):
  184. self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_layer_data)
  185. self._process_layers_job.start()
  186. self._stored_layer_data = []
  187. def _onGCodeLayerMessage(self, message):
  188. self._scene.gcode_list.append(message.data.decode("utf-8", "replace"))
  189. def _onGCodePrefixMessage(self, message):
  190. self._scene.gcode_list.insert(0, message.data.decode("utf-8", "replace"))
  191. def _onObjectPrintTimeMessage(self, message):
  192. self.printDurationMessage.emit(message.time, message.material_amount)
  193. def _createSocket(self):
  194. super()._createSocket(os.path.abspath(os.path.join(PluginRegistry.getInstance().getPluginPath(self.getPluginId()), "Cura.proto")))
  195. ## Manually triggers a reslice
  196. def forceSlice(self):
  197. self._change_timer.start()
  198. def _onChanged(self):
  199. if not self._profile:
  200. return
  201. self._change_timer.start()
  202. def _onBackendConnected(self):
  203. if self._restart:
  204. self._onChanged()
  205. self._restart = False
  206. def _onToolOperationStarted(self, tool):
  207. self._terminate() # Do not continue slicing once a tool has started
  208. self._enabled = False # Do not reslice when a tool is doing it's 'thing'
  209. def _onToolOperationStopped(self, tool):
  210. self._enabled = True # Tool stop, start listening for changes again.
  211. def _onActiveViewChanged(self):
  212. if Application.getInstance().getController().getActiveView():
  213. view = Application.getInstance().getController().getActiveView()
  214. if view.getPluginId() == "LayerView":
  215. self._layer_view_active = True
  216. # There is data and we're not slicing at the moment
  217. # if we are slicing, there is no need to re-calculate the data as it will be invalid in a moment.
  218. if self._stored_layer_data and not self._slicing:
  219. self._process_layers_job = ProcessSlicedLayersJob.ProcessSlicedLayersJob(self._stored_layer_data)
  220. self._process_layers_job.start()
  221. self._stored_layer_data = []
  222. else:
  223. self._layer_view_active = False
  224. def _onInstanceChanged(self):
  225. self._terminate()
  226. def _onBackendQuit(self):
  227. if not self._restart and self._process:
  228. Logger.log("d", "Backend quit with return code %s. Resetting process and socket.", self._process.wait())
  229. self._process = None
  230. self._createSocket()