BuildVolume.py 60 KB

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