StartSliceJob.py 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366
  1. # Copyright (c) 2017 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. import numpy
  4. from string import Formatter
  5. from enum import IntEnum
  6. import time
  7. from UM.Job import Job
  8. from UM.Application import Application
  9. from UM.Logger import Logger
  10. from UM.Scene.SceneNode import SceneNode
  11. from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
  12. from UM.Settings.Validator import ValidatorState
  13. from UM.Settings.SettingRelation import RelationType
  14. from cura.OneAtATimeIterator import OneAtATimeIterator
  15. from cura.Settings.ExtruderManager import ExtruderManager
  16. class StartJobResult(IntEnum):
  17. Finished = 1
  18. Error = 2
  19. SettingError = 3
  20. NothingToSlice = 4
  21. MaterialIncompatible = 5
  22. BuildPlateError = 6
  23. ## Formatter class that handles token expansion in start/end gcod
  24. class GcodeStartEndFormatter(Formatter):
  25. def get_value(self, key, args, kwargs): # [CodeStyle: get_value is an overridden function from the Formatter class]
  26. if isinstance(key, str):
  27. try:
  28. return kwargs[key]
  29. except KeyError:
  30. Logger.log("w", "Unable to replace '%s' placeholder in start/end gcode", key)
  31. return "{" + key + "}"
  32. else:
  33. Logger.log("w", "Incorrectly formatted placeholder '%s' in start/end gcode", key)
  34. return "{" + str(key) + "}"
  35. ## Job class that builds up the message of scene data to send to CuraEngine.
  36. class StartSliceJob(Job):
  37. ## Meshes that are sent to the engine regardless of being outside of the
  38. # build volume.
  39. #
  40. # If these settings are True for any mesh, the build volume is ignored.
  41. # Note that Support Mesh is not in here because it actually generates
  42. # g-code in the volume of the mesh.
  43. _not_printed_mesh_settings = {"anti_overhang_mesh", "infill_mesh", "cutting_mesh"}
  44. def __init__(self, slice_message):
  45. super().__init__()
  46. self._scene = Application.getInstance().getController().getScene()
  47. self._slice_message = slice_message
  48. self._is_cancelled = False
  49. def getSliceMessage(self):
  50. return self._slice_message
  51. ## Check if a stack has any errors.
  52. ## returns true if it has errors, false otherwise.
  53. def _checkStackForErrors(self, stack):
  54. if stack is None:
  55. return False
  56. for key in stack.getAllKeys():
  57. validation_state = stack.getProperty(key, "validationState")
  58. if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError):
  59. Logger.log("w", "Setting %s is not valid, but %s. Aborting slicing.", key, validation_state)
  60. return True
  61. Job.yieldThread()
  62. return False
  63. ## Runs the job that initiates the slicing.
  64. def run(self):
  65. stack = Application.getInstance().getGlobalContainerStack()
  66. if not stack:
  67. self.setResult(StartJobResult.Error)
  68. return
  69. # Don't slice if there is a setting with an error value.
  70. if Application.getInstance().getMachineManager().stacksHaveErrors:
  71. self.setResult(StartJobResult.SettingError)
  72. return
  73. if Application.getInstance().getBuildVolume().hasErrors():
  74. self.setResult(StartJobResult.BuildPlateError)
  75. return
  76. for extruder_stack in ExtruderManager.getInstance().getMachineExtruders(stack.getId()):
  77. material = extruder_stack.findContainer({"type": "material"})
  78. if material:
  79. if material.getMetaDataEntry("compatible") == False:
  80. self.setResult(StartJobResult.MaterialIncompatible)
  81. return
  82. # Don't slice if there is a per object setting with an error value.
  83. for node in DepthFirstIterator(self._scene.getRoot()):
  84. if type(node) is not SceneNode or not node.isSelectable():
  85. continue
  86. if self._checkStackForErrors(node.callDecoration("getStack")):
  87. self.setResult(StartJobResult.SettingError)
  88. return
  89. with self._scene.getSceneLock():
  90. # Remove old layer data.
  91. for node in DepthFirstIterator(self._scene.getRoot()):
  92. if node.callDecoration("getLayerData"):
  93. node.getParent().removeChild(node)
  94. break
  95. # Get the objects in their groups to print.
  96. object_groups = []
  97. if stack.getProperty("print_sequence", "value") == "one_at_a_time":
  98. for node in OneAtATimeIterator(self._scene.getRoot()):
  99. temp_list = []
  100. # Node can't be printed, so don't bother sending it.
  101. if getattr(node, "_outside_buildarea", False):
  102. continue
  103. children = node.getAllChildren()
  104. children.append(node)
  105. for child_node in children:
  106. if type(child_node) is SceneNode and child_node.getMeshData() and child_node.getMeshData().getVertices() is not None:
  107. temp_list.append(child_node)
  108. if temp_list:
  109. object_groups.append(temp_list)
  110. Job.yieldThread()
  111. if len(object_groups) == 0:
  112. Logger.log("w", "No objects suitable for one at a time found, or no correct order found")
  113. else:
  114. temp_list = []
  115. for node in DepthFirstIterator(self._scene.getRoot()):
  116. if type(node) is SceneNode and node.getMeshData() and node.getMeshData().getVertices() is not None:
  117. if not getattr(node, "_outside_buildarea", False)\
  118. or (node.callDecoration("getStack") and any(node.callDecoration("getStack").getProperty(setting, "value") for setting in self._not_printed_mesh_settings)):
  119. temp_list.append(node)
  120. Job.yieldThread()
  121. if temp_list:
  122. object_groups.append(temp_list)
  123. # There are cases when there is nothing to slice. This can happen due to one at a time slicing not being
  124. # able to find a possible sequence or because there are no objects on the build plate (or they are outside
  125. # the build volume)
  126. if not object_groups:
  127. self.setResult(StartJobResult.NothingToSlice)
  128. return
  129. self._buildGlobalSettingsMessage(stack)
  130. self._buildGlobalInheritsStackMessage(stack)
  131. # Only add extruder stacks if there are multiple extruders
  132. # Single extruder machines only use the global stack to store setting values
  133. if stack.getProperty("machine_extruder_count", "value") > 1:
  134. for extruder_stack in ExtruderManager.getInstance().getMachineExtruders(stack.getId()):
  135. self._buildExtruderMessage(extruder_stack)
  136. else:
  137. self._buildExtruderMessageFromGlobalStack(stack)
  138. for group in object_groups:
  139. group_message = self._slice_message.addRepeatedMessage("object_lists")
  140. if group[0].getParent().callDecoration("isGroup"):
  141. self._handlePerObjectSettings(group[0].getParent(), group_message)
  142. for object in group:
  143. mesh_data = object.getMeshData()
  144. rot_scale = object.getWorldTransformation().getTransposed().getData()[0:3, 0:3]
  145. translate = object.getWorldTransformation().getData()[:3, 3]
  146. # This effectively performs a limited form of MeshData.getTransformed that ignores normals.
  147. verts = mesh_data.getVertices()
  148. verts = verts.dot(rot_scale)
  149. verts += translate
  150. # Convert from Y up axes to Z up axes. Equals a 90 degree rotation.
  151. verts[:, [1, 2]] = verts[:, [2, 1]]
  152. verts[:, 1] *= -1
  153. obj = group_message.addRepeatedMessage("objects")
  154. obj.id = id(object)
  155. indices = mesh_data.getIndices()
  156. if indices is not None:
  157. flat_verts = numpy.take(verts, indices.flatten(), axis=0)
  158. else:
  159. flat_verts = numpy.array(verts)
  160. obj.vertices = flat_verts
  161. self._handlePerObjectSettings(object, obj)
  162. Job.yieldThread()
  163. self.setResult(StartJobResult.Finished)
  164. def cancel(self):
  165. super().cancel()
  166. self._is_cancelled = True
  167. def isCancelled(self):
  168. return self._is_cancelled
  169. def _expandGcodeTokens(self, key, value, settings):
  170. try:
  171. # any setting can be used as a token
  172. fmt = GcodeStartEndFormatter()
  173. return str(fmt.format(value, **settings)).encode("utf-8")
  174. except:
  175. Logger.logException("w", "Unable to do token replacement on start/end gcode")
  176. return str(value).encode("utf-8")
  177. ## Create extruder message from stack
  178. def _buildExtruderMessage(self, stack):
  179. message = self._slice_message.addRepeatedMessage("extruders")
  180. message.id = int(stack.getMetaDataEntry("position"))
  181. material_instance_container = stack.findContainer({"type": "material"})
  182. settings = {}
  183. for key in stack.getAllKeys():
  184. settings[key] = stack.getProperty(key, "value")
  185. Job.yieldThread()
  186. settings["print_bed_temperature"] = settings["material_bed_temperature"] #Renamed settings.
  187. settings["print_temperature"] = settings["material_print_temperature"]
  188. settings["time"] = time.strftime("%H:%M:%S") #Some extra settings.
  189. settings["date"] = time.strftime("%d-%m-%Y")
  190. settings["day"] = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][int(time.strftime("%w"))]
  191. for key, value in settings.items():
  192. # Do not send settings that are not settable_per_extruder.
  193. if not stack.getProperty(key, "settable_per_extruder"):
  194. continue
  195. setting = message.getMessage("settings").addRepeatedMessage("settings")
  196. setting.name = key
  197. if key == "material_guid" and material_instance_container:
  198. # Also send the material GUID. This is a setting in fdmprinter, but we have no interface for it.
  199. setting.value = str(material_instance_container.getMetaDataEntry("GUID", "")).encode("utf-8")
  200. elif key == "machine_extruder_start_code" or key == "machine_extruder_end_code":
  201. setting.value = self._expandGcodeTokens(key, value, settings)
  202. else:
  203. setting.value = str(stack.getProperty(key, "value")).encode("utf-8")
  204. Job.yieldThread()
  205. ## Create extruder message from global stack
  206. def _buildExtruderMessageFromGlobalStack(self, stack):
  207. message = self._slice_message.addRepeatedMessage("extruders")
  208. for key in stack.getAllKeys():
  209. # Do not send settings that are not settable_per_extruder.
  210. if not stack.getProperty(key, "settable_per_extruder"):
  211. continue
  212. setting = message.getMessage("settings").addRepeatedMessage("settings")
  213. setting.name = key
  214. setting.value = str(stack.getProperty(key, "value")).encode("utf-8")
  215. Job.yieldThread()
  216. ## Sends all global settings to the engine.
  217. #
  218. # The settings are taken from the global stack. This does not include any
  219. # per-extruder settings or per-object settings.
  220. def _buildGlobalSettingsMessage(self, stack):
  221. keys = stack.getAllKeys()
  222. settings = {}
  223. for key in keys:
  224. settings[key] = stack.getProperty(key, "value")
  225. Job.yieldThread()
  226. start_gcode = settings["machine_start_gcode"]
  227. #Pre-compute material material_bed_temp_prepend and material_print_temp_prepend
  228. bed_temperature_settings = {"material_bed_temperature", "material_bed_temperature_layer_0"}
  229. settings["material_bed_temp_prepend"] = all(("{" + setting + "}" not in start_gcode for setting in bed_temperature_settings))
  230. print_temperature_settings = {"material_print_temperature", "material_print_temperature_layer_0", "default_material_print_temperature", "material_initial_print_temperature", "material_final_print_temperature", "material_standby_temperature"}
  231. settings["material_print_temp_prepend"] = all(("{" + setting + "}" not in start_gcode for setting in print_temperature_settings))
  232. settings["print_bed_temperature"] = settings["material_bed_temperature"]
  233. settings["print_temperature"] = settings["material_print_temperature"]
  234. settings["time"] = time.strftime('%H:%M:%S')
  235. settings["date"] = time.strftime('%d-%m-%Y')
  236. settings["day"] = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][int(time.strftime('%w'))]
  237. for key, value in settings.items(): #Add all submessages for each individual setting.
  238. setting_message = self._slice_message.getMessage("global_settings").addRepeatedMessage("settings")
  239. setting_message.name = key
  240. if key == "machine_start_gcode" or key == "machine_end_gcode": #If it's a g-code message, use special formatting.
  241. setting_message.value = self._expandGcodeTokens(key, value, settings)
  242. else:
  243. setting_message.value = str(value).encode("utf-8")
  244. Job.yieldThread()
  245. ## Sends for some settings which extruder they should fallback to if not
  246. # set.
  247. #
  248. # This is only set for settings that have the limit_to_extruder
  249. # property.
  250. #
  251. # \param stack The global stack with all settings, from which to read the
  252. # limit_to_extruder property.
  253. def _buildGlobalInheritsStackMessage(self, stack):
  254. for key in stack.getAllKeys():
  255. extruder = int(round(float(stack.getProperty(key, "limit_to_extruder"))))
  256. if extruder >= 0: #Set to a specific extruder.
  257. setting_extruder = self._slice_message.addRepeatedMessage("limit_to_extruder")
  258. setting_extruder.name = key
  259. setting_extruder.extruder = extruder
  260. Job.yieldThread()
  261. ## Check if a node has per object settings and ensure that they are set correctly in the message
  262. # \param node \type{SceneNode} Node to check.
  263. # \param message object_lists message to put the per object settings in
  264. def _handlePerObjectSettings(self, node, message):
  265. stack = node.callDecoration("getStack")
  266. # Check if the node has a stack attached to it and the stack has any settings in the top container.
  267. if not stack:
  268. return
  269. # Check all settings for relations, so we can also calculate the correct values for dependent settings.
  270. top_of_stack = stack.getTop() # Cache for efficiency.
  271. changed_setting_keys = set(top_of_stack.getAllKeys())
  272. # Add all relations to changed settings as well.
  273. for key in top_of_stack.getAllKeys():
  274. instance = top_of_stack.getInstance(key)
  275. self._addRelations(changed_setting_keys, instance.definition.relations)
  276. Job.yieldThread()
  277. # Ensure that the engine is aware what the build extruder is.
  278. if stack.getProperty("machine_extruder_count", "value") > 1:
  279. changed_setting_keys.add("extruder_nr")
  280. # Get values for all changed settings
  281. for key in changed_setting_keys:
  282. setting = message.addRepeatedMessage("settings")
  283. setting.name = key
  284. extruder = int(round(float(stack.getProperty(key, "limit_to_extruder"))))
  285. # Check if limited to a specific extruder, but not overridden by per-object settings.
  286. if extruder >= 0 and key not in changed_setting_keys:
  287. limited_stack = ExtruderManager.getInstance().getActiveExtruderStacks()[extruder]
  288. else:
  289. limited_stack = stack
  290. setting.value = str(limited_stack.getProperty(key, "value")).encode("utf-8")
  291. Job.yieldThread()
  292. ## Recursive function to put all settings that require each other for value changes in a list
  293. # \param relations_set \type{set} Set of keys (strings) of settings that are influenced
  294. # \param relations list of relation objects that need to be checked.
  295. def _addRelations(self, relations_set, relations):
  296. for relation in filter(lambda r: r.role == "value" or r.role == "limit_to_extruder", relations):
  297. if relation.type == RelationType.RequiresTarget:
  298. continue
  299. relations_set.add(relation.target.key)
  300. self._addRelations(relations_set, relation.target.relations)