BuildVolume.py 63 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217
  1. # Copyright (c) 2021 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. import numpy
  4. import math
  5. from typing import List, Optional, TYPE_CHECKING, Any, Set, cast, Iterable, Dict
  6. from UM.Logger import Logger
  7. from UM.Mesh.MeshData import MeshData
  8. from UM.Mesh.MeshBuilder import MeshBuilder
  9. from UM.Application import Application #To modify the maximum zoom level.
  10. from UM.i18n import i18nCatalog
  11. from UM.Scene.Platform import Platform
  12. from UM.Scene.Iterator.BreadthFirstIterator import BreadthFirstIterator
  13. from UM.Scene.SceneNode import SceneNode
  14. from UM.Resources import Resources
  15. from UM.Math.Vector import Vector
  16. from UM.Math.Matrix import Matrix
  17. from UM.Math.Color import Color
  18. from UM.Math.AxisAlignedBox import AxisAlignedBox
  19. from UM.Math.Polygon import Polygon
  20. from UM.Message import Message
  21. from UM.Signal import Signal
  22. from UM.View.RenderBatch import RenderBatch
  23. from UM.View.GL.OpenGL import OpenGL
  24. from cura.Settings.GlobalStack import GlobalStack
  25. from cura.Scene.CuraSceneNode import CuraSceneNode
  26. from cura.Settings.ExtruderManager import ExtruderManager
  27. from PyQt6.QtCore import QTimer
  28. if TYPE_CHECKING:
  29. from cura.CuraApplication import CuraApplication
  30. from cura.Settings.ExtruderStack import ExtruderStack
  31. from UM.Settings.ContainerStack import ContainerStack
  32. catalog = i18nCatalog("cura")
  33. # Radius of disallowed area in mm around prime. I.e. how much distance to keep from prime position.
  34. PRIME_CLEARANCE = 6.5
  35. class BuildVolume(SceneNode):
  36. """Build volume is a special kind of node that is responsible for rendering the printable area & disallowed areas."""
  37. raftThicknessChanged = Signal()
  38. def __init__(self, application: "CuraApplication", parent: Optional[SceneNode] = None) -> None:
  39. super().__init__(parent)
  40. self._application = application
  41. self._machine_manager = self._application.getMachineManager()
  42. self._volume_outline_color = None # type: Optional[Color]
  43. self._x_axis_color = None # type: Optional[Color]
  44. self._y_axis_color = None # type: Optional[Color]
  45. self._z_axis_color = None # type: Optional[Color]
  46. self._disallowed_area_color = None # type: Optional[Color]
  47. self._error_area_color = None # type: Optional[Color]
  48. self._width = 0 # type: float
  49. self._height = 0 # type: float
  50. self._depth = 0 # type: float
  51. self._shape = "" # type: str
  52. self._scale_vector = Vector(1.0, 1.0, 1.0)
  53. self._shader = None
  54. self._origin_mesh = None # type: Optional[MeshData]
  55. self._origin_line_length = 20
  56. self._origin_line_width = 1
  57. self._enabled = False
  58. self._grid_mesh = None # type: Optional[MeshData]
  59. self._grid_shader = None
  60. self._disallowed_areas = [] # type: List[Polygon]
  61. self._disallowed_areas_no_brim = [] # type: List[Polygon]
  62. self._disallowed_area_mesh = None # type: Optional[MeshData]
  63. self._disallowed_area_size = 0.
  64. self._error_areas = [] # type: List[Polygon]
  65. self._error_mesh = None # type: Optional[MeshData]
  66. self.setCalculateBoundingBox(False)
  67. self._volume_aabb = None # type: Optional[AxisAlignedBox]
  68. self._raft_thickness = 0.0
  69. self._extra_z_clearance = 0.0
  70. self._adhesion_type = None # type: Any
  71. self._platform = Platform(self)
  72. self._edge_disallowed_size = None
  73. self._build_volume_message = Message(catalog.i18nc("@info:status",
  74. "The build volume height has been reduced due to the value of the"
  75. " \"Print Sequence\" setting to prevent the gantry from colliding"
  76. " with printed models."),
  77. title = catalog.i18nc("@info:title", "Build Volume"),
  78. message_type = Message.MessageType.WARNING)
  79. self._global_container_stack = None # type: Optional[GlobalStack]
  80. self._stack_change_timer = QTimer()
  81. self._stack_change_timer.setInterval(100)
  82. self._stack_change_timer.setSingleShot(True)
  83. self._stack_change_timer.timeout.connect(self._onStackChangeTimerFinished)
  84. self._application.globalContainerStackChanged.connect(self._onStackChanged)
  85. self._engine_ready = False
  86. self._application.engineCreatedSignal.connect(self._onEngineCreated)
  87. self._has_errors = False
  88. self._application.getController().getScene().sceneChanged.connect(self._onSceneChanged)
  89. # Objects loaded at the moment. We are connected to the property changed events of these objects.
  90. self._scene_objects = set() # type: Set[SceneNode]
  91. # Number of toplevel printable meshes. If there is more than one, the build volume needs to take account of the gantry height in One at a Time printing.
  92. self._root_printable_object_count = 0
  93. self._scene_change_timer = QTimer()
  94. self._scene_change_timer.setInterval(200)
  95. self._scene_change_timer.setSingleShot(True)
  96. self._scene_change_timer.timeout.connect(self._onSceneChangeTimerFinished)
  97. self._setting_change_timer = QTimer()
  98. self._setting_change_timer.setInterval(150)
  99. self._setting_change_timer.setSingleShot(True)
  100. self._setting_change_timer.timeout.connect(self._onSettingChangeTimerFinished)
  101. # Must be after setting _build_volume_message, apparently that is used in getMachineManager.
  102. # activeQualityChanged is always emitted after setActiveVariant, setActiveMaterial and setActiveQuality.
  103. # Therefore this works.
  104. self._machine_manager.activeQualityChanged.connect(self._onStackChanged)
  105. # Enable and disable extruder
  106. self._machine_manager.extruderChanged.connect(self.updateNodeBoundaryCheck)
  107. # List of settings which were updated
  108. self._changed_settings_since_last_rebuild = [] # type: List[str]
  109. def _onSceneChanged(self, source):
  110. if self._global_container_stack:
  111. # Ignore anything that is not something we can slice in the first place!
  112. if source.callDecoration("isSliceable"):
  113. self._scene_change_timer.start()
  114. def _onSceneChangeTimerFinished(self):
  115. root = self._application.getController().getScene().getRoot()
  116. new_scene_objects = set(node for node in BreadthFirstIterator(root) if node.callDecoration("isSliceable"))
  117. if new_scene_objects != self._scene_objects:
  118. for node in new_scene_objects - self._scene_objects: #Nodes that were added to the scene.
  119. self._updateNodeListeners(node)
  120. node.decoratorsChanged.connect(self._updateNodeListeners) # Make sure that decoration changes afterwards also receive the same treatment
  121. for node in self._scene_objects - new_scene_objects: #Nodes that were removed from the scene.
  122. per_mesh_stack = node.callDecoration("getStack")
  123. if per_mesh_stack:
  124. per_mesh_stack.propertyChanged.disconnect(self._onSettingPropertyChanged)
  125. active_extruder_changed = node.callDecoration("getActiveExtruderChangedSignal")
  126. if active_extruder_changed is not None:
  127. node.callDecoration("getActiveExtruderChangedSignal").disconnect(self._updateDisallowedAreasAndRebuild)
  128. node.decoratorsChanged.disconnect(self._updateNodeListeners)
  129. self.rebuild()
  130. self._scene_objects = new_scene_objects
  131. # This also needs to be called when objects are grouped/ungrouped,
  132. # which is not reflected in a change in self._scene_objects
  133. self._updateRootPrintableObjectCount()
  134. def _updateRootPrintableObjectCount(self):
  135. # Get the number of models in the scene root, excluding modifier meshes and counting grouped models as 1
  136. root = self._application.getController().getScene().getRoot()
  137. scene_objects = set(node for node in BreadthFirstIterator(root) if node.callDecoration("isSliceable") or node.callDecoration("isGroup"))
  138. new_root_printable_object_count = len(list(node for node in scene_objects if node.getParent() == root and not (
  139. node_stack := node.callDecoration("getStack") and (
  140. node.callDecoration("getStack").getProperty("anti_overhang_mesh", "value") or
  141. node.callDecoration("getStack").getProperty("support_mesh", "value") or
  142. node.callDecoration("getStack").getProperty("cutting_mesh", "value") or
  143. node.callDecoration("getStack").getProperty("infill_mesh", "value")
  144. ))
  145. ))
  146. if new_root_printable_object_count != self._root_printable_object_count:
  147. self._root_printable_object_count = new_root_printable_object_count
  148. self._onSettingPropertyChanged("print_sequence", "value") # Create fake event, so right settings are triggered.
  149. def _updateNodeListeners(self, node: SceneNode):
  150. """Updates the listeners that listen for changes in per-mesh stacks.
  151. :param node: The node for which the decorators changed.
  152. """
  153. per_mesh_stack = node.callDecoration("getStack")
  154. if per_mesh_stack:
  155. per_mesh_stack.propertyChanged.connect(self._onSettingPropertyChanged)
  156. active_extruder_changed = node.callDecoration("getActiveExtruderChangedSignal")
  157. if active_extruder_changed is not None:
  158. active_extruder_changed.connect(self._updateDisallowedAreasAndRebuild)
  159. def setWidth(self, width: float) -> None:
  160. self._width = width
  161. def getWidth(self) -> float:
  162. return self._width
  163. def setHeight(self, height: float) -> None:
  164. self._height = height
  165. def getHeight(self) -> float:
  166. return self._height
  167. def setDepth(self, depth: float) -> None:
  168. self._depth = depth
  169. def getDepth(self) -> float:
  170. return self._depth
  171. def setShape(self, shape: str) -> None:
  172. if shape:
  173. self._shape = shape
  174. def getShape(self) -> str:
  175. return self._shape
  176. def getDiagonalSize(self) -> float:
  177. """Get the length of the 3D diagonal through the build volume.
  178. This gives a sense of the scale of the build volume in general.
  179. :return: length of the 3D diagonal through the build volume
  180. """
  181. return math.sqrt(self._width * self._width + self._height * self._height + self._depth * self._depth)
  182. def getDisallowedAreas(self) -> List[Polygon]:
  183. return self._disallowed_areas
  184. def getDisallowedAreasNoBrim(self) -> List[Polygon]:
  185. return self._disallowed_areas_no_brim
  186. def setDisallowedAreas(self, areas: List[Polygon]):
  187. self._disallowed_areas = areas
  188. def render(self, renderer):
  189. if not self.getMeshData() or not self.isVisible():
  190. return True
  191. if not self._shader:
  192. self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader"))
  193. self._grid_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "grid.shader"))
  194. theme = self._application.getTheme()
  195. self._grid_shader.setUniformValue("u_plateColor", Color(*theme.getColor("buildplate").getRgb()))
  196. self._grid_shader.setUniformValue("u_gridColor0", Color(*theme.getColor("buildplate_grid").getRgb()))
  197. self._grid_shader.setUniformValue("u_gridColor1", Color(*theme.getColor("buildplate_grid_minor").getRgb()))
  198. renderer.queueNode(self, mode = RenderBatch.RenderMode.Lines)
  199. renderer.queueNode(self, mesh = self._origin_mesh, backface_cull = True)
  200. renderer.queueNode(self, mesh = self._grid_mesh, shader = self._grid_shader, backface_cull = True)
  201. if self._disallowed_area_mesh:
  202. renderer.queueNode(self, mesh = self._disallowed_area_mesh, shader = self._shader, transparent = True, backface_cull = True, sort = -9)
  203. if self._error_mesh:
  204. renderer.queueNode(self, mesh=self._error_mesh, shader=self._shader, transparent=True,
  205. backface_cull=True, sort=-8)
  206. return True
  207. def updateNodeBoundaryCheck(self):
  208. """For every sliceable node, update node._outside_buildarea"""
  209. if not self._global_container_stack:
  210. return
  211. root = self._application.getController().getScene().getRoot()
  212. nodes = cast(List[SceneNode], list(cast(Iterable, BreadthFirstIterator(root))))
  213. group_nodes = [] # type: List[SceneNode]
  214. build_volume_bounding_box = self.getBoundingBox()
  215. if build_volume_bounding_box:
  216. # It's over 9000!
  217. # We set this to a very low number, as we do allow models to intersect the build plate.
  218. # This means the model gets cut off at the build plate.
  219. build_volume_bounding_box = build_volume_bounding_box.set(bottom=-9001)
  220. else:
  221. # No bounding box. This is triggered when running Cura from command line with a model for the first time
  222. # In that situation there is a model, but no machine (and therefore no build volume.
  223. return
  224. for node in nodes:
  225. # Need to check group nodes later
  226. if node.callDecoration("isGroup"):
  227. group_nodes.append(node) # Keep list of affected group_nodes
  228. if node.callDecoration("isSliceable") or node.callDecoration("isGroup"):
  229. if not isinstance(node, CuraSceneNode):
  230. continue
  231. if node.collidesWithBbox(build_volume_bounding_box):
  232. node.setOutsideBuildArea(True)
  233. continue
  234. if node.collidesWithAreas(self.getDisallowedAreas()):
  235. node.setOutsideBuildArea(True)
  236. continue
  237. # If the entire node is below the build plate, still mark it as outside.
  238. node_bounding_box = node.getBoundingBox()
  239. if node_bounding_box and node_bounding_box.top < 0 and not node.getParent().callDecoration("isGroup"):
  240. node.setOutsideBuildArea(True)
  241. continue
  242. # Mark the node as outside build volume if the set extruder is disabled
  243. extruder_position = node.callDecoration("getActiveExtruderPosition")
  244. try:
  245. if not self._global_container_stack.extruderList[int(extruder_position)].isEnabled and not node.callDecoration("isGroup"):
  246. node.setOutsideBuildArea(True)
  247. continue
  248. except IndexError: # Happens when the extruder list is too short. We're not done building the printer in memory yet.
  249. continue
  250. except TypeError: # Happens when extruder_position is None. This object has no extruder decoration.
  251. continue
  252. node.setOutsideBuildArea(False)
  253. # Group nodes should override the _outside_buildarea property of their children.
  254. for group_node in group_nodes:
  255. children = group_node.getAllChildren()
  256. # Check if one or more children are non-printable and if so, set the parent as non-printable:
  257. for child_node in children:
  258. if child_node.isOutsideBuildArea():
  259. group_node.setOutsideBuildArea(True)
  260. break
  261. # Apply results of the check to all children of the group:
  262. for child_node in children:
  263. child_node.setOutsideBuildArea(group_node.isOutsideBuildArea())
  264. def checkBoundsAndUpdate(self, node: CuraSceneNode, bounds: Optional[AxisAlignedBox] = None) -> None:
  265. """Update the outsideBuildArea of a single node, given bounds or current build volume
  266. :param node: single node
  267. :param bounds: bounds or current build volume
  268. """
  269. if not isinstance(node, CuraSceneNode) or self._global_container_stack is None:
  270. return
  271. if bounds is None:
  272. build_volume_bounding_box = self.getBoundingBox()
  273. if build_volume_bounding_box:
  274. # It's over 9000!
  275. build_volume_bounding_box = build_volume_bounding_box.set(bottom=-9001)
  276. else:
  277. # No bounding box. This is triggered when running Cura from command line with a model for the first time
  278. # In that situation there is a model, but no machine (and therefore no build volume.
  279. return
  280. else:
  281. build_volume_bounding_box = bounds
  282. if node.callDecoration("isSliceable") or node.callDecoration("isGroup"):
  283. if node.collidesWithBbox(build_volume_bounding_box):
  284. node.setOutsideBuildArea(True)
  285. return
  286. if node.collidesWithAreas(self.getDisallowedAreas()):
  287. node.setOutsideBuildArea(True)
  288. return
  289. # Mark the node as outside build volume if the set extruder is disabled
  290. extruder_position = node.callDecoration("getActiveExtruderPosition")
  291. try:
  292. if not self._global_container_stack.extruderList[int(extruder_position)].isEnabled:
  293. node.setOutsideBuildArea(True)
  294. return
  295. except IndexError:
  296. # If the extruder doesn't exist, also mark it as unprintable.
  297. node.setOutsideBuildArea(True)
  298. return
  299. node.setOutsideBuildArea(False)
  300. def _buildGridMesh(self, min_w: float, max_w: float, min_h: float, max_h: float, min_d: float, max_d:float, z_fight_distance: float) -> MeshData:
  301. mb = MeshBuilder()
  302. if self._shape != "elliptic":
  303. # Build plate grid mesh
  304. mb.addQuad(
  305. Vector(min_w, min_h - z_fight_distance, min_d),
  306. Vector(max_w, min_h - z_fight_distance, min_d),
  307. Vector(max_w, min_h - z_fight_distance, max_d),
  308. Vector(min_w, min_h - z_fight_distance, max_d)
  309. )
  310. for n in range(0, 6):
  311. v = mb.getVertex(n)
  312. mb.setVertexUVCoordinates(n, v[0], v[2])
  313. return mb.build()
  314. else:
  315. aspect = 1.0
  316. scale_matrix = Matrix()
  317. if self._width != 0:
  318. # Scale circular meshes by aspect ratio if width != height
  319. aspect = self._depth / self._width
  320. scale_matrix.compose(scale=Vector(1, 1, aspect))
  321. mb.addVertex(0, min_h - z_fight_distance, 0)
  322. mb.addArc(max_w, Vector.Unit_Y, center=Vector(0, min_h - z_fight_distance, 0))
  323. sections = mb.getVertexCount() - 1 # Center point is not an arc section
  324. indices = []
  325. for n in range(0, sections - 1):
  326. indices.append([0, n + 2, n + 1])
  327. mb.addIndices(numpy.asarray(indices, dtype=numpy.int32))
  328. mb.calculateNormals()
  329. for n in range(0, mb.getVertexCount()):
  330. v = mb.getVertex(n)
  331. mb.setVertexUVCoordinates(n, v[0], v[2] * aspect)
  332. return mb.build().getTransformed(scale_matrix)
  333. def _buildMesh(self, min_w: float, max_w: float, min_h: float, max_h: float, min_d: float, max_d:float, z_fight_distance: float) -> MeshData:
  334. if self._shape != "elliptic":
  335. # Outline 'cube' of the build volume
  336. mb = MeshBuilder()
  337. mb.addLine(Vector(min_w, min_h, min_d), Vector(max_w, min_h, min_d), color = self._volume_outline_color)
  338. mb.addLine(Vector(min_w, min_h, min_d), Vector(min_w, max_h, min_d), color = self._volume_outline_color)
  339. mb.addLine(Vector(min_w, max_h, min_d), Vector(max_w, max_h, min_d), color = self._volume_outline_color)
  340. mb.addLine(Vector(max_w, min_h, min_d), Vector(max_w, max_h, min_d), color = self._volume_outline_color)
  341. mb.addLine(Vector(min_w, min_h, max_d), Vector(max_w, min_h, max_d), color = self._volume_outline_color)
  342. mb.addLine(Vector(min_w, min_h, max_d), Vector(min_w, max_h, max_d), color = self._volume_outline_color)
  343. mb.addLine(Vector(min_w, max_h, max_d), Vector(max_w, max_h, max_d), color = self._volume_outline_color)
  344. mb.addLine(Vector(max_w, min_h, max_d), Vector(max_w, max_h, max_d), color = self._volume_outline_color)
  345. mb.addLine(Vector(min_w, min_h, min_d), Vector(min_w, min_h, max_d), color = self._volume_outline_color)
  346. mb.addLine(Vector(max_w, min_h, min_d), Vector(max_w, min_h, max_d), color = self._volume_outline_color)
  347. mb.addLine(Vector(min_w, max_h, min_d), Vector(min_w, max_h, max_d), color = self._volume_outline_color)
  348. mb.addLine(Vector(max_w, max_h, min_d), Vector(max_w, max_h, max_d), color = self._volume_outline_color)
  349. return mb.build()
  350. else:
  351. # Bottom and top 'ellipse' of the build volume
  352. scale_matrix = Matrix()
  353. if self._width != 0:
  354. # Scale circular meshes by aspect ratio if width != height
  355. aspect = self._depth / self._width
  356. scale_matrix.compose(scale = Vector(1, 1, aspect))
  357. mb = MeshBuilder()
  358. mb.addArc(max_w, Vector.Unit_Y, center = (0, min_h - z_fight_distance, 0), color = self._volume_outline_color)
  359. mb.addArc(max_w, Vector.Unit_Y, center = (0, max_h, 0), color = self._volume_outline_color)
  360. return mb.build().getTransformed(scale_matrix)
  361. def _buildOriginMesh(self, origin: Vector) -> MeshData:
  362. mb = MeshBuilder()
  363. mb.addCube(
  364. width=self._origin_line_length,
  365. height=self._origin_line_width,
  366. depth=self._origin_line_width,
  367. center=origin + Vector(self._origin_line_length / 2, 0, 0),
  368. color=self._x_axis_color
  369. )
  370. mb.addCube(
  371. width=self._origin_line_width,
  372. height=self._origin_line_length,
  373. depth=self._origin_line_width,
  374. center=origin + Vector(0, self._origin_line_length / 2, 0),
  375. color=self._y_axis_color
  376. )
  377. mb.addCube(
  378. width=self._origin_line_width,
  379. height=self._origin_line_width,
  380. depth=self._origin_line_length,
  381. center=origin - Vector(0, 0, self._origin_line_length / 2),
  382. color=self._z_axis_color
  383. )
  384. return mb.build()
  385. def _updateColors(self):
  386. theme = self._application.getTheme()
  387. if theme is None:
  388. return
  389. self._volume_outline_color = Color(*theme.getColor("volume_outline").getRgb())
  390. self._x_axis_color = Color(*theme.getColor("x_axis").getRgb())
  391. self._y_axis_color = Color(*theme.getColor("y_axis").getRgb())
  392. self._z_axis_color = Color(*theme.getColor("z_axis").getRgb())
  393. self._disallowed_area_color = Color(*theme.getColor("disallowed_area").getRgb())
  394. self._error_area_color = Color(*theme.getColor("error_area").getRgb())
  395. def _buildErrorMesh(self, min_w: float, max_w: float, min_h: float, max_h: float, min_d: float, max_d: float, disallowed_area_height: float) -> Optional[MeshData]:
  396. if not self._error_areas:
  397. return None
  398. mb = MeshBuilder()
  399. for error_area in self._error_areas:
  400. color = self._error_area_color
  401. points = error_area.getPoints()
  402. first = Vector(self._clamp(points[0][0], min_w, max_w), disallowed_area_height,
  403. self._clamp(points[0][1], min_d, max_d))
  404. previous_point = Vector(self._clamp(points[0][0], min_w, max_w), disallowed_area_height,
  405. self._clamp(points[0][1], min_d, max_d))
  406. for point in points:
  407. new_point = Vector(self._clamp(point[0], min_w, max_w), disallowed_area_height,
  408. self._clamp(point[1], min_d, max_d))
  409. mb.addFace(first, previous_point, new_point, color=color)
  410. previous_point = new_point
  411. return mb.build()
  412. def _buildDisallowedAreaMesh(self, min_w: float, max_w: float, min_h: float, max_h: float, min_d: float, max_d: float, disallowed_area_height: float) -> Optional[MeshData]:
  413. if not self._disallowed_areas:
  414. return None
  415. bounding_box = Polygon(numpy.array([[min_w, min_d], [min_w, max_d], [max_w, max_d], [max_w, min_d]], numpy.float32))
  416. mb = MeshBuilder()
  417. color = self._disallowed_area_color
  418. for polygon in self._disallowed_areas:
  419. intersection = polygon.intersectionConvexHulls(bounding_box)
  420. points = numpy.flipud(intersection.getPoints())
  421. if len(points) < 3:
  422. continue
  423. first = Vector(points[0][0], disallowed_area_height, points[0][1])
  424. previous_point = Vector(points[1][0], disallowed_area_height, points[1][1])
  425. for point in points[2:]:
  426. new_point = Vector(point[0], disallowed_area_height, point[1])
  427. mb.addFace(first, previous_point, new_point, color=color)
  428. previous_point = new_point
  429. # Find the largest disallowed area to exclude it from the maximum scale bounds.
  430. # This is a very nasty hack. This pretty much only works for UM machines.
  431. # This disallowed area_size needs a -lot- of rework at some point in the future: TODO
  432. if numpy.min(points[:,
  433. 1]) >= 0: # This filters out all areas that have points to the left of the centre. This is done to filter the skirt area.
  434. size = abs(numpy.max(points[:, 1]) - numpy.min(points[:, 1]))
  435. else:
  436. size = 0
  437. self._disallowed_area_size = max(size, self._disallowed_area_size)
  438. return mb.build()
  439. def _updateScaleFactor(self) -> None:
  440. if not self._global_container_stack:
  441. return
  442. scale_xy = 100.0 / max(100.0, self._global_container_stack.getProperty("material_shrinkage_percentage_xy", "value"))
  443. scale_z = 100.0 / max(100.0, self._global_container_stack.getProperty("material_shrinkage_percentage_z" , "value"))
  444. self._scale_vector = Vector(scale_xy, scale_xy, scale_z)
  445. def rebuild(self) -> None:
  446. """Recalculates the build volume & disallowed areas."""
  447. if not self._width or not self._height or not self._depth:
  448. return
  449. if not self._engine_ready:
  450. return
  451. if not self._global_container_stack:
  452. return
  453. if not self._volume_outline_color:
  454. self._updateColors()
  455. min_w = -self._width / 2
  456. max_w = self._width / 2
  457. min_h = 0.0
  458. max_h = self._height
  459. min_d = -self._depth / 2
  460. max_d = self._depth / 2
  461. z_fight_distance = 0.2 # Distance between buildplate and disallowed area meshes to prevent z-fighting
  462. self._grid_mesh = self._buildGridMesh(min_w, max_w, min_h, max_h, min_d, max_d, z_fight_distance)
  463. self.setMeshData(self._buildMesh(min_w, max_w, min_h, max_h, min_d, max_d, z_fight_distance))
  464. # Indication of the machine origin
  465. if self._global_container_stack.getProperty("machine_center_is_zero", "value"):
  466. origin = (Vector(min_w, min_h, min_d) + Vector(max_w, min_h, max_d)) / 2
  467. else:
  468. origin = Vector(min_w, min_h, max_d)
  469. self._origin_mesh = self._buildOriginMesh(origin)
  470. disallowed_area_height = 0.1
  471. self._disallowed_area_size = 0.
  472. self._disallowed_area_mesh = self._buildDisallowedAreaMesh(min_w, max_w, min_h, max_h, min_d, max_d, disallowed_area_height)
  473. self._error_mesh = self._buildErrorMesh(min_w, max_w, min_h, max_h, min_d, max_d, disallowed_area_height)
  474. self._updateScaleFactor()
  475. self._volume_aabb = AxisAlignedBox(
  476. minimum = Vector(min_w, min_h - 1.0, min_d),
  477. maximum = Vector(max_w, max_h - self._raft_thickness - self._extra_z_clearance, max_d)
  478. )
  479. bed_adhesion_size = self.getEdgeDisallowedSize()
  480. # As this works better for UM machines, we only add the disallowed_area_size for the z direction.
  481. # This is probably wrong in all other cases. TODO!
  482. # The +1 and -1 is added as there is always a bit of extra room required to work properly.
  483. scale_to_max_bounds = AxisAlignedBox(
  484. minimum = Vector(min_w + bed_adhesion_size + 1, min_h, min_d + self._disallowed_area_size - bed_adhesion_size + 1),
  485. maximum = Vector(max_w - bed_adhesion_size - 1, max_h - self._raft_thickness - self._extra_z_clearance, max_d - self._disallowed_area_size + bed_adhesion_size - 1)
  486. )
  487. self._application.getController().getScene()._maximum_bounds = scale_to_max_bounds # type: ignore
  488. self.updateNodeBoundaryCheck()
  489. def getBoundingBox(self) -> Optional[AxisAlignedBox]:
  490. return self._volume_aabb
  491. def getRaftThickness(self) -> float:
  492. return self._raft_thickness
  493. def _updateRaftThickness(self) -> None:
  494. if not self._global_container_stack:
  495. return
  496. old_raft_thickness = self._raft_thickness
  497. if self._global_container_stack.extruderList:
  498. # This might be called before the extruder stacks have initialised, in which case getting the adhesion_type fails
  499. self._adhesion_type = self._global_container_stack.getProperty("adhesion_type", "value")
  500. self._raft_thickness = 0.0
  501. if self._adhesion_type == "raft":
  502. self._raft_thickness = (
  503. self._global_container_stack.getProperty("raft_base_thickness", "value") +
  504. self._global_container_stack.getProperty("raft_interface_layers", "value") *
  505. self._global_container_stack.getProperty("raft_interface_thickness", "value") +
  506. self._global_container_stack.getProperty("raft_surface_layers", "value") *
  507. self._global_container_stack.getProperty("raft_surface_thickness", "value") +
  508. self._global_container_stack.getProperty("raft_airgap", "value") -
  509. self._global_container_stack.getProperty("layer_0_z_overlap", "value"))
  510. # Rounding errors do not matter, we check if raft_thickness has changed at all
  511. if old_raft_thickness != self._raft_thickness:
  512. self.setPosition(Vector(0, -self._raft_thickness, 0), SceneNode.TransformSpace.World)
  513. self.raftThicknessChanged.emit()
  514. def _calculateExtraZClearance(self, extruders: List["ContainerStack"]) -> float:
  515. if not self._global_container_stack:
  516. return 0
  517. extra_z = 0.0
  518. for extruder in extruders:
  519. if extruder.getProperty("retraction_hop_enabled", "value"):
  520. retraction_hop = extruder.getProperty("retraction_hop", "value")
  521. if extra_z is None or retraction_hop > extra_z:
  522. extra_z = retraction_hop
  523. return extra_z
  524. def _onStackChanged(self):
  525. self._stack_change_timer.start()
  526. def _onStackChangeTimerFinished(self) -> None:
  527. """Update the build volume visualization"""
  528. if self._global_container_stack:
  529. self._global_container_stack.propertyChanged.disconnect(self._onSettingPropertyChanged)
  530. extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
  531. for extruder in extruders:
  532. extruder.propertyChanged.disconnect(self._onSettingPropertyChanged)
  533. self._global_container_stack = self._application.getGlobalContainerStack()
  534. if self._global_container_stack:
  535. self._global_container_stack.propertyChanged.connect(self._onSettingPropertyChanged)
  536. extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
  537. for extruder in extruders:
  538. extruder.propertyChanged.connect(self._onSettingPropertyChanged)
  539. self._width = self._global_container_stack.getProperty("machine_width", "value")
  540. machine_height = self._global_container_stack.getProperty("machine_height", "value")
  541. if self._global_container_stack.getProperty("print_sequence", "value") == "one_at_a_time" and self._root_printable_object_count > 1:
  542. new_height = min(self._global_container_stack.getProperty("gantry_height", "value") * self._scale_vector.z, machine_height)
  543. if self._height > new_height:
  544. self._build_volume_message.show()
  545. elif self._height < new_height:
  546. self._build_volume_message.hide()
  547. self._height = new_height
  548. else:
  549. self._height = self._global_container_stack.getProperty("machine_height", "value")
  550. self._build_volume_message.hide()
  551. self._depth = self._global_container_stack.getProperty("machine_depth", "value")
  552. self._shape = self._global_container_stack.getProperty("machine_shape", "value")
  553. self._updateDisallowedAreas()
  554. self._updateRaftThickness()
  555. self._extra_z_clearance = self._calculateExtraZClearance(ExtruderManager.getInstance().getUsedExtruderStacks())
  556. if self._engine_ready:
  557. self.rebuild()
  558. camera = Application.getInstance().getController().getCameraTool()
  559. if camera:
  560. diagonal = self.getDiagonalSize()
  561. if diagonal > 1:
  562. # You can zoom out up to 5 times the diagonal. This gives some space around the volume.
  563. camera.setZoomRange(min = 0.1, max = diagonal * 5) # type: ignore
  564. def _onEngineCreated(self) -> None:
  565. self._engine_ready = True
  566. self.rebuild()
  567. def _onSettingChangeTimerFinished(self) -> None:
  568. if not self._global_container_stack:
  569. return
  570. rebuild_me = False
  571. update_disallowed_areas = False
  572. update_raft_thickness = False
  573. update_extra_z_clearance = True
  574. for setting_key in self._changed_settings_since_last_rebuild:
  575. if setting_key in ["print_sequence", "support_mesh", "infill_mesh", "cutting_mesh", "anti_overhang_mesh"]:
  576. self._updateRootPrintableObjectCount()
  577. if setting_key == "print_sequence":
  578. machine_height = self._global_container_stack.getProperty("machine_height", "value")
  579. if self._application.getGlobalContainerStack().getProperty("print_sequence", "value") == "one_at_a_time" and self._root_printable_object_count > 1:
  580. new_height = min(
  581. self._global_container_stack.getProperty("gantry_height", "value") * self._scale_vector.z,
  582. machine_height)
  583. if self._height > new_height:
  584. self._build_volume_message.show()
  585. elif self._height < new_height:
  586. self._build_volume_message.hide()
  587. self._height = new_height
  588. else:
  589. self._height = self._global_container_stack.getProperty("machine_height", "value") * self._scale_vector.z
  590. self._build_volume_message.hide()
  591. update_disallowed_areas = True
  592. # sometimes the machine size or shape settings are adjusted on the active machine, we should reflect this
  593. if setting_key in self._machine_settings or setting_key in self._material_size_settings:
  594. self._updateMachineSizeProperties()
  595. update_extra_z_clearance = True
  596. update_disallowed_areas = True
  597. if setting_key in self._disallowed_area_settings:
  598. update_disallowed_areas = True
  599. if setting_key in self._raft_settings:
  600. update_raft_thickness = True
  601. if setting_key in self._extra_z_settings:
  602. update_extra_z_clearance = True
  603. if setting_key in self._limit_to_extruder_settings:
  604. update_disallowed_areas = True
  605. rebuild_me = update_extra_z_clearance or update_disallowed_areas or update_raft_thickness
  606. # We only want to update all of them once.
  607. if update_disallowed_areas:
  608. self._updateDisallowedAreas()
  609. if update_raft_thickness:
  610. self._updateRaftThickness()
  611. if update_extra_z_clearance:
  612. self._extra_z_clearance = self._calculateExtraZClearance(ExtruderManager.getInstance().getUsedExtruderStacks())
  613. if rebuild_me:
  614. self.rebuild()
  615. # We just did a rebuild, reset the list.
  616. self._changed_settings_since_last_rebuild = []
  617. def _onSettingPropertyChanged(self, setting_key: str, property_name: str) -> None:
  618. if property_name != "value":
  619. return
  620. if setting_key not in self._changed_settings_since_last_rebuild:
  621. self._changed_settings_since_last_rebuild.append(setting_key)
  622. self._setting_change_timer.start()
  623. def hasErrors(self) -> bool:
  624. return self._has_errors
  625. def _updateMachineSizeProperties(self) -> None:
  626. if not self._global_container_stack:
  627. return
  628. self._updateScaleFactor()
  629. self._height = self._global_container_stack.getProperty("machine_height", "value") * self._scale_vector.z
  630. self._width = self._global_container_stack.getProperty("machine_width", "value")
  631. self._depth = self._global_container_stack.getProperty("machine_depth", "value")
  632. self._shape = self._global_container_stack.getProperty("machine_shape", "value")
  633. def _updateDisallowedAreasAndRebuild(self):
  634. """Calls :py:meth:`cura.BuildVolume._updateDisallowedAreas` and makes sure the changes appear in the scene.
  635. This is required for a signal to trigger the update in one go. The
  636. :py:meth:`cura.BuildVolume._updateDisallowedAreas` method itself shouldn't call
  637. :py:meth:`cura.BuildVolume.rebuild`, since there may be other changes before it needs to be rebuilt,
  638. which would hit performance.
  639. """
  640. self._updateDisallowedAreas()
  641. self._updateRaftThickness()
  642. self._extra_z_clearance = self._calculateExtraZClearance(ExtruderManager.getInstance().getUsedExtruderStacks())
  643. self.rebuild()
  644. def _updateDisallowedAreas(self) -> None:
  645. if not self._global_container_stack:
  646. return
  647. self._error_areas = []
  648. used_extruders = ExtruderManager.getInstance().getUsedExtruderStacks()
  649. self._edge_disallowed_size = None # Force a recalculation
  650. disallowed_border_size = self.getEdgeDisallowedSize()
  651. result_areas = self._computeDisallowedAreasStatic(disallowed_border_size, used_extruders) # Normal machine disallowed areas can always be added.
  652. prime_areas = self._computeDisallowedAreasPrimeBlob(disallowed_border_size, used_extruders)
  653. result_areas_no_brim = self._computeDisallowedAreasStatic(0, used_extruders) # Where the priming is not allowed to happen. This is not added to the result, just for collision checking.
  654. # Check if prime positions intersect with disallowed areas.
  655. for extruder in used_extruders:
  656. extruder_id = extruder.getId()
  657. result_areas[extruder_id].extend(prime_areas[extruder_id])
  658. result_areas_no_brim[extruder_id].extend(prime_areas[extruder_id])
  659. nozzle_disallowed_areas = extruder.getProperty("nozzle_disallowed_areas", "value")
  660. for area in nozzle_disallowed_areas:
  661. polygon = Polygon(numpy.array(area, numpy.float32))
  662. polygon_disallowed_border = polygon.getMinkowskiHull(Polygon.approximatedCircle(disallowed_border_size))
  663. result_areas[extruder_id].append(polygon_disallowed_border) # Don't perform the offset on these.
  664. result_areas_no_brim[extruder_id].append(polygon) # No brim
  665. # Add prime tower location as disallowed area.
  666. if len([x for x in used_extruders if x.isEnabled]) > 1: # No prime tower if only one extruder is enabled
  667. prime_tower_collision = False
  668. prime_tower_areas = self._computeDisallowedAreasPrinted(used_extruders)
  669. for extruder_id in prime_tower_areas:
  670. for area_index, prime_tower_area in enumerate(prime_tower_areas[extruder_id]):
  671. for area in result_areas_no_brim[extruder_id]:
  672. if prime_tower_area.intersectsPolygon(area) is not None:
  673. prime_tower_collision = True
  674. break
  675. if prime_tower_collision: # Already found a collision.
  676. break
  677. if not prime_tower_collision:
  678. result_areas[extruder_id].extend(prime_tower_areas[extruder_id])
  679. result_areas_no_brim[extruder_id].extend(prime_tower_areas[extruder_id])
  680. else:
  681. self._error_areas.extend(prime_tower_areas[extruder_id])
  682. self._has_errors = len(self._error_areas) > 0
  683. self._disallowed_areas = []
  684. for extruder_id in result_areas:
  685. self._disallowed_areas.extend(result_areas[extruder_id])
  686. self._disallowed_areas_no_brim = []
  687. for extruder_id in result_areas_no_brim:
  688. self._disallowed_areas_no_brim.extend(result_areas_no_brim[extruder_id])
  689. def _computeDisallowedAreasPrinted(self, used_extruders):
  690. """Computes the disallowed areas for objects that are printed with print features.
  691. This means that the brim, travel avoidance and such will be applied to these features.
  692. :return: A dictionary with for each used extruder ID the disallowed areas where that extruder may not print.
  693. """
  694. result = {}
  695. skirt_brim_extruder: ExtruderStack = None
  696. skirt_brim_extruder_nr = self._global_container_stack.getProperty("skirt_brim_extruder_nr", "value")
  697. for extruder in used_extruders:
  698. if skirt_brim_extruder_nr == -1:
  699. skirt_brim_extruder = used_extruders[0] # The prime tower brim is always printed with the first extruder
  700. elif int(extruder.getProperty("extruder_nr", "value")) == int(skirt_brim_extruder_nr):
  701. skirt_brim_extruder = extruder
  702. result[extruder.getId()] = []
  703. # Currently, the only normally printed object is the prime tower.
  704. if self._global_container_stack.getProperty("prime_tower_mode", "value") != 'none':
  705. prime_tower_size = self._global_container_stack.getProperty("prime_tower_size", "value")
  706. machine_width = self._global_container_stack.getProperty("machine_width", "value")
  707. machine_depth = self._global_container_stack.getProperty("machine_depth", "value")
  708. prime_tower_x = self._global_container_stack.getProperty("prime_tower_position_x", "value")
  709. prime_tower_y = - self._global_container_stack.getProperty("prime_tower_position_y", "value")
  710. prime_tower_brim_enable = self._global_container_stack.getProperty("prime_tower_brim_enable", "value")
  711. prime_tower_base_size = self._global_container_stack.getProperty("prime_tower_base_size", "value")
  712. prime_tower_base_height = self._global_container_stack.getProperty("prime_tower_base_height", "value")
  713. adhesion_type = self._global_container_stack.getProperty("adhesion_type", "value")
  714. if not self._global_container_stack.getProperty("machine_center_is_zero", "value"):
  715. prime_tower_x = prime_tower_x - machine_width / 2 #Offset by half machine_width and _depth to put the origin in the front-left.
  716. prime_tower_y = prime_tower_y + machine_depth / 2
  717. radius = prime_tower_size / 2
  718. delta_x = -radius
  719. delta_y = -radius
  720. if prime_tower_base_size > 0 and ((prime_tower_brim_enable and prime_tower_base_height > 0) or adhesion_type == "raft"):
  721. radius += prime_tower_base_size
  722. prime_tower_area = Polygon.approximatedCircle(radius, num_segments = 32)
  723. prime_tower_area = prime_tower_area.translate(prime_tower_x + delta_x, prime_tower_y + delta_y)
  724. prime_tower_area = prime_tower_area.getMinkowskiHull(Polygon.approximatedCircle(0))
  725. for extruder in used_extruders:
  726. result[extruder.getId()].append(prime_tower_area) #The prime tower location is the same for each extruder, regardless of offset.
  727. return result
  728. def _computeDisallowedAreasPrimeBlob(self, border_size: float, used_extruders: List["ExtruderStack"]) -> Dict[str, List[Polygon]]:
  729. """Computes the disallowed areas for the prime blobs.
  730. These are special because they are not subject to things like brim or travel avoidance. They do get a dilute
  731. with the border size though because they may not intersect with brims and such of other objects.
  732. :param border_size: The size with which to offset the disallowed areas due to skirt, brim, travel avoid distance
  733. , etc.
  734. :param used_extruders: The extruder stacks to generate disallowed areas for.
  735. :return: A dictionary with for each used extruder ID the prime areas.
  736. """
  737. result = {} # type: Dict[str, List[Polygon]]
  738. if not self._global_container_stack:
  739. return result
  740. machine_width = self._global_container_stack.getProperty("machine_width", "value")
  741. machine_depth = self._global_container_stack.getProperty("machine_depth", "value")
  742. for extruder in used_extruders:
  743. prime_blob_enabled = extruder.getProperty("prime_blob_enable", "value")
  744. prime_x = extruder.getProperty("extruder_prime_pos_x", "value")
  745. prime_y = -extruder.getProperty("extruder_prime_pos_y", "value")
  746. # Ignore extruder prime position if it is not set or if blob is disabled
  747. if (prime_x == 0 and prime_y == 0) or not prime_blob_enabled:
  748. result[extruder.getId()] = []
  749. continue
  750. if not self._global_container_stack.getProperty("machine_center_is_zero", "value"):
  751. prime_x = prime_x - machine_width / 2 # Offset by half machine_width and _depth to put the origin in the front-left.
  752. prime_y = prime_y + machine_depth / 2
  753. prime_polygon = Polygon.approximatedCircle(PRIME_CLEARANCE)
  754. prime_polygon = prime_polygon.getMinkowskiHull(Polygon.approximatedCircle(border_size))
  755. prime_polygon = prime_polygon.translate(prime_x, prime_y)
  756. result[extruder.getId()] = [prime_polygon]
  757. return result
  758. def _computeDisallowedAreasStatic(self, border_size:float, used_extruders: List["ExtruderStack"]) -> Dict[str, List[Polygon]]:
  759. """Computes the disallowed areas that are statically placed in the machine.
  760. It computes different disallowed areas depending on the offset of the extruder. The resulting dictionary will
  761. therefore have an entry for each extruder that is used.
  762. :param border_size: The size with which to offset the disallowed areas due to skirt, brim, travel avoid distance
  763. , etc.
  764. :param used_extruders: The extruder stacks to generate disallowed areas for.
  765. :return: A dictionary with for each used extruder ID the disallowed areas where that extruder may not print.
  766. """
  767. # Convert disallowed areas to polygons and dilate them.
  768. machine_disallowed_polygons = []
  769. if self._global_container_stack is None:
  770. return {}
  771. for area in self._global_container_stack.getProperty("machine_disallowed_areas", "value"):
  772. if len(area) == 0:
  773. continue # Numpy doesn't deal well with 0-length arrays, since it can't determine the dimensionality of them.
  774. polygon = Polygon(numpy.array(area, numpy.float32))
  775. polygon = polygon.getMinkowskiHull(Polygon.approximatedCircle(border_size))
  776. machine_disallowed_polygons.append(polygon)
  777. # For certain machines we don't need to compute disallowed areas for each nozzle.
  778. # So we check here and only do the nozzle offsetting if needed.
  779. nozzle_offsetting_for_disallowed_areas = self._global_container_stack.getMetaDataEntry(
  780. "nozzle_offsetting_for_disallowed_areas", True)
  781. result = {} # type: Dict[str, List[Polygon]]
  782. for extruder in used_extruders:
  783. extruder_id = extruder.getId()
  784. offset_x = extruder.getProperty("machine_nozzle_offset_x", "value")
  785. if offset_x is None:
  786. offset_x = 0
  787. offset_y = extruder.getProperty("machine_nozzle_offset_y", "value")
  788. if offset_y is None:
  789. offset_y = 0
  790. offset_y = -offset_y # Y direction of g-code is the inverse of Y direction of Cura's scene space.
  791. result[extruder_id] = []
  792. for polygon in machine_disallowed_polygons:
  793. result[extruder_id].append(polygon.translate(offset_x, offset_y)) # Compensate for the nozzle offset of this extruder.
  794. # Add the border around the edge of the build volume.
  795. left_unreachable_border = 0
  796. right_unreachable_border = 0
  797. top_unreachable_border = 0
  798. bottom_unreachable_border = 0
  799. # Only do nozzle offsetting if needed
  800. if nozzle_offsetting_for_disallowed_areas:
  801. # The build volume is defined as the union of the area that all extruders can reach, so we need to know
  802. # the relative offset to all extruders.
  803. for other_extruder in ExtruderManager.getInstance().getActiveExtruderStacks():
  804. other_offset_x = other_extruder.getProperty("machine_nozzle_offset_x", "value")
  805. if other_offset_x is None:
  806. other_offset_x = 0
  807. other_offset_y = other_extruder.getProperty("machine_nozzle_offset_y", "value")
  808. if other_offset_y is None:
  809. other_offset_y = 0
  810. other_offset_y = -other_offset_y
  811. left_unreachable_border = min(left_unreachable_border, other_offset_x - offset_x)
  812. right_unreachable_border = max(right_unreachable_border, other_offset_x - offset_x)
  813. top_unreachable_border = min(top_unreachable_border, other_offset_y - offset_y)
  814. bottom_unreachable_border = max(bottom_unreachable_border, other_offset_y - offset_y)
  815. half_machine_width = self._global_container_stack.getProperty("machine_width", "value") / 2
  816. half_machine_depth = self._global_container_stack.getProperty("machine_depth", "value") / 2
  817. # We need at a minimum a very small border around the edge so that models can't go off the build plate
  818. border_size = max(border_size, 0.1)
  819. if self._shape != "elliptic":
  820. if border_size - left_unreachable_border > 0:
  821. result[extruder_id].append(Polygon(numpy.array([
  822. [-half_machine_width, -half_machine_depth],
  823. [-half_machine_width, half_machine_depth],
  824. [-half_machine_width + border_size - left_unreachable_border, half_machine_depth - border_size - bottom_unreachable_border],
  825. [-half_machine_width + border_size - left_unreachable_border, -half_machine_depth + border_size - top_unreachable_border]
  826. ], numpy.float32)))
  827. if border_size + right_unreachable_border > 0:
  828. result[extruder_id].append(Polygon(numpy.array([
  829. [half_machine_width, half_machine_depth],
  830. [half_machine_width, -half_machine_depth],
  831. [half_machine_width - border_size - right_unreachable_border, -half_machine_depth + border_size - top_unreachable_border],
  832. [half_machine_width - border_size - right_unreachable_border, half_machine_depth - border_size - bottom_unreachable_border]
  833. ], numpy.float32)))
  834. if border_size + bottom_unreachable_border > 0:
  835. result[extruder_id].append(Polygon(numpy.array([
  836. [-half_machine_width, half_machine_depth],
  837. [half_machine_width, half_machine_depth],
  838. [half_machine_width - border_size - right_unreachable_border, half_machine_depth - border_size - bottom_unreachable_border],
  839. [-half_machine_width + border_size - left_unreachable_border, half_machine_depth - border_size - bottom_unreachable_border]
  840. ], numpy.float32)))
  841. if border_size - top_unreachable_border > 0:
  842. result[extruder_id].append(Polygon(numpy.array([
  843. [half_machine_width, -half_machine_depth],
  844. [-half_machine_width, -half_machine_depth],
  845. [-half_machine_width + border_size - left_unreachable_border, -half_machine_depth + border_size - top_unreachable_border],
  846. [half_machine_width - border_size - right_unreachable_border, -half_machine_depth + border_size - top_unreachable_border]
  847. ], numpy.float32)))
  848. else:
  849. sections = 32
  850. arc_vertex = [0, half_machine_depth - border_size]
  851. for i in range(0, sections):
  852. quadrant = math.floor(4 * i / sections)
  853. vertices = []
  854. if quadrant == 0:
  855. vertices.append([-half_machine_width, half_machine_depth])
  856. elif quadrant == 1:
  857. vertices.append([-half_machine_width, -half_machine_depth])
  858. elif quadrant == 2:
  859. vertices.append([half_machine_width, -half_machine_depth])
  860. elif quadrant == 3:
  861. vertices.append([half_machine_width, half_machine_depth])
  862. vertices.append(arc_vertex)
  863. angle = 2 * math.pi * (i + 1) / sections
  864. arc_vertex = [-(half_machine_width - border_size) * math.sin(angle), (half_machine_depth - border_size) * math.cos(angle)]
  865. vertices.append(arc_vertex)
  866. result[extruder_id].append(Polygon(numpy.array(vertices, numpy.float32)))
  867. if border_size > 0:
  868. result[extruder_id].append(Polygon(numpy.array([
  869. [-half_machine_width, -half_machine_depth],
  870. [-half_machine_width, half_machine_depth],
  871. [-half_machine_width + border_size, 0]
  872. ], numpy.float32)))
  873. result[extruder_id].append(Polygon(numpy.array([
  874. [-half_machine_width, half_machine_depth],
  875. [ half_machine_width, half_machine_depth],
  876. [ 0, half_machine_depth - border_size]
  877. ], numpy.float32)))
  878. result[extruder_id].append(Polygon(numpy.array([
  879. [ half_machine_width, half_machine_depth],
  880. [ half_machine_width, -half_machine_depth],
  881. [ half_machine_width - border_size, 0]
  882. ], numpy.float32)))
  883. result[extruder_id].append(Polygon(numpy.array([
  884. [ half_machine_width, -half_machine_depth],
  885. [-half_machine_width, -half_machine_depth],
  886. [ 0, -half_machine_depth + border_size]
  887. ], numpy.float32)))
  888. return result
  889. def _getSettingFromAllExtruders(self, setting_key: str) -> List[Any]:
  890. """Private convenience function to get a setting from every extruder.
  891. For single extrusion machines, this gets the setting from the global stack.
  892. :return: A sequence of setting values, one for each extruder.
  893. """
  894. all_values = ExtruderManager.getInstance().getAllExtruderSettings(setting_key, "value")
  895. all_types = ExtruderManager.getInstance().getAllExtruderSettings(setting_key, "type")
  896. for i, (setting_value, setting_type) in enumerate(zip(all_values, all_types)):
  897. if not setting_value and setting_type in ["int", "float"]:
  898. all_values[i] = 0
  899. return all_values
  900. def _calculateBedAdhesionSize(self, used_extruders):
  901. """Get the bed adhesion size for the global container stack and used extruders
  902. :param adhesion_override: override adhesion type.
  903. Use None to use the global stack default, "none" for no adhesion, "brim" for brim etc.
  904. """
  905. if self._global_container_stack is None:
  906. return None
  907. container_stack = self._global_container_stack
  908. adhesion_type = container_stack.getProperty("adhesion_type", "value")
  909. if adhesion_type == "raft":
  910. bed_adhesion_size = self._global_container_stack.getProperty("raft_margin", "value") # Should refer to the raft extruder if set.
  911. else: # raft, brim or skirt. Those last two are handled by CuraEngine.
  912. bed_adhesion_size = 0
  913. max_length_available = 0.5 * min(
  914. self._global_container_stack.getProperty("machine_width", "value"),
  915. self._global_container_stack.getProperty("machine_depth", "value")
  916. )
  917. bed_adhesion_size = min(bed_adhesion_size, max_length_available)
  918. return bed_adhesion_size
  919. def _calculateFarthestShieldDistance(self, container_stack):
  920. farthest_shield_distance = 0
  921. if container_stack.getProperty("draft_shield_enabled", "value"):
  922. farthest_shield_distance = max(farthest_shield_distance, container_stack.getProperty("draft_shield_dist", "value"))
  923. if container_stack.getProperty("ooze_shield_enabled", "value"):
  924. farthest_shield_distance = max(farthest_shield_distance,container_stack.getProperty("ooze_shield_dist", "value"))
  925. return farthest_shield_distance
  926. def _calculateSupportExpansion(self, container_stack):
  927. support_expansion = 0
  928. support_enabled = self._global_container_stack.getProperty("support_enable", "value")
  929. support_offset = self._global_container_stack.getProperty("support_offset", "value")
  930. if support_enabled and support_offset:
  931. support_expansion += support_offset
  932. return support_expansion
  933. def _calculateMoveFromWallRadius(self, used_extruders):
  934. move_from_wall_radius = 0 # Moves that start from outer wall.
  935. for stack in used_extruders:
  936. if stack.getProperty("travel_avoid_other_parts", "value"):
  937. move_from_wall_radius = max(move_from_wall_radius, stack.getProperty("travel_avoid_distance", "value"))
  938. infill_wipe_distance = stack.getProperty("infill_wipe_dist", "value")
  939. num_walls = stack.getProperty("wall_line_count", "value")
  940. if num_walls >= 1: # Infill wipes start from the infill, so subtract the total wall thickness from this.
  941. infill_wipe_distance -= stack.getProperty("wall_line_width_0", "value")
  942. if num_walls >= 2:
  943. infill_wipe_distance -= stack.getProperty("wall_line_width_x", "value") * (num_walls - 1)
  944. move_from_wall_radius = max(move_from_wall_radius, infill_wipe_distance)
  945. return move_from_wall_radius
  946. def getEdgeDisallowedSize(self):
  947. """Calculate the disallowed radius around the edge.
  948. This disallowed radius is to allow for space around the models that is not part of the collision radius,
  949. such as bed adhesion (skirt/brim/raft) and travel avoid distance.
  950. """
  951. if not self._global_container_stack or not self._global_container_stack.extruderList:
  952. return 0
  953. if self._edge_disallowed_size is not None:
  954. return self._edge_disallowed_size
  955. container_stack = self._global_container_stack
  956. used_extruders = ExtruderManager.getInstance().getUsedExtruderStacks()
  957. # If we are printing one at a time, we need to add the bed adhesion size to the disallowed areas of the objects
  958. if container_stack.getProperty("print_sequence", "value") == "one_at_a_time":
  959. return 0.1
  960. bed_adhesion_size = self._calculateBedAdhesionSize(used_extruders)
  961. support_expansion = self._calculateSupportExpansion(self._global_container_stack)
  962. farthest_shield_distance = self._calculateFarthestShieldDistance(self._global_container_stack)
  963. move_from_wall_radius = self._calculateMoveFromWallRadius(used_extruders)
  964. # Now combine our different pieces of data to get the final border size.
  965. # Support expansion is added to the bed adhesion, since the bed adhesion goes around support.
  966. # Support expansion is added to farthest shield distance, since the shields go around support.
  967. self._edge_disallowed_size = max(move_from_wall_radius, support_expansion + farthest_shield_distance, support_expansion + bed_adhesion_size)
  968. return self._edge_disallowed_size
  969. def _clamp(self, value, min_value, max_value):
  970. return max(min(value, max_value), min_value)
  971. _machine_settings = ["machine_width", "machine_depth", "machine_height", "machine_shape", "machine_center_is_zero"]
  972. _skirt_settings = ["adhesion_type", "skirt_gap", "skirt_line_count", "skirt_brim_line_width", "brim_gap", "brim_width", "brim_line_count", "raft_margin", "draft_shield_enabled", "draft_shield_dist", "initial_layer_line_width_factor"]
  973. _raft_settings = ["adhesion_type", "raft_base_thickness", "raft_interface_layers", "raft_interface_thickness", "raft_surface_layers", "raft_surface_thickness", "raft_airgap", "layer_0_z_overlap"]
  974. _extra_z_settings = ["retraction_hop_enabled", "retraction_hop"]
  975. _prime_settings = ["extruder_prime_pos_x", "extruder_prime_pos_y", "prime_blob_enable"]
  976. _tower_settings = ["prime_tower_mode", "prime_tower_size", "prime_tower_position_x", "prime_tower_position_y", "prime_tower_brim_enable", "prime_tower_base_size", "prime_tower_base_height"]
  977. _ooze_shield_settings = ["ooze_shield_enabled", "ooze_shield_dist"]
  978. _distance_settings = ["infill_wipe_dist", "travel_avoid_distance", "support_offset", "support_enable", "travel_avoid_other_parts", "travel_avoid_supports", "wall_line_count", "wall_line_width_0", "wall_line_width_x"]
  979. _extruder_settings = ["support_enable", "support_bottom_enable", "support_roof_enable", "support_infill_extruder_nr", "support_extruder_nr_layer_0", "support_bottom_extruder_nr", "support_roof_extruder_nr", "brim_line_count", "skirt_brim_extruder_nr", "raft_base_extruder_nr", "raft_interface_extruder_nr", "raft_surface_extruder_nr", "adhesion_type"] #Settings that can affect which extruders are used.
  980. _limit_to_extruder_settings = ["wall_extruder_nr", "wall_0_extruder_nr", "wall_x_extruder_nr", "top_bottom_extruder_nr", "infill_extruder_nr", "support_infill_extruder_nr", "support_extruder_nr_layer_0", "support_bottom_extruder_nr", "support_roof_extruder_nr", "skirt_brim_extruder_nr", "raft_base_extruder_nr", "raft_interface_extruder_nr", "raft_surface_extruder_nr"]
  981. _material_size_settings = ["material_shrinkage_percentage", "material_shrinkage_percentage_xy", "material_shrinkage_percentage_z"]
  982. _disallowed_area_settings = _skirt_settings + _prime_settings + _tower_settings + _ooze_shield_settings + _distance_settings + _extruder_settings + _material_size_settings