ConvexHullDecorator.py 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395
  1. # Copyright (c) 2016 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. from PyQt5.QtCore import QTimer
  4. from UM.Application import Application
  5. from UM.Math.Polygon import Polygon
  6. from UM.Scene.SceneNodeDecorator import SceneNodeDecorator
  7. from UM.Settings.ContainerRegistry import ContainerRegistry
  8. from cura.Settings.ExtruderManager import ExtruderManager
  9. from cura.Scene import ConvexHullNode
  10. import numpy
  11. from typing import TYPE_CHECKING, Any, Optional
  12. if TYPE_CHECKING:
  13. from UM.Scene.SceneNode import SceneNode
  14. from cura.Settings.GlobalStack import GlobalStack
  15. from UM.Mesh.MeshData import MeshData
  16. from UM.Math.Matrix import Matrix
  17. ## The convex hull decorator is a scene node decorator that adds the convex hull functionality to a scene node.
  18. # If a scene node has a convex hull decorator, it will have a shadow in which other objects can not be printed.
  19. class ConvexHullDecorator(SceneNodeDecorator):
  20. def __init__(self) -> None:
  21. super().__init__()
  22. self._convex_hull_node = None # type: Optional["SceneNode"]
  23. self._init2DConvexHullCache()
  24. self._global_stack = None # type: Optional[GlobalStack]
  25. # Make sure the timer is created on the main thread
  26. self._recompute_convex_hull_timer = None # type: Optional[QTimer]
  27. from cura.CuraApplication import CuraApplication
  28. if CuraApplication.getInstance() is not None:
  29. CuraApplication.getInstance().callLater(self.createRecomputeConvexHullTimer)
  30. self._raft_thickness = 0.0
  31. self._build_volume = CuraApplication.getInstance().getBuildVolume()
  32. self._build_volume.raftThicknessChanged.connect(self._onChanged)
  33. CuraApplication.getInstance().globalContainerStackChanged.connect(self._onGlobalStackChanged)
  34. CuraApplication.getInstance().getController().toolOperationStarted.connect(self._onChanged)
  35. CuraApplication.getInstance().getController().toolOperationStopped.connect(self._onChanged)
  36. self._onGlobalStackChanged()
  37. def createRecomputeConvexHullTimer(self) -> None:
  38. self._recompute_convex_hull_timer = QTimer()
  39. self._recompute_convex_hull_timer.setInterval(200)
  40. self._recompute_convex_hull_timer.setSingleShot(True)
  41. self._recompute_convex_hull_timer.timeout.connect(self.recomputeConvexHull)
  42. def setNode(self, node: "SceneNode") -> None:
  43. previous_node = self._node
  44. # Disconnect from previous node signals
  45. if previous_node is not None and node is not previous_node:
  46. previous_node.transformationChanged.disconnect(self._onChanged)
  47. previous_node.parentChanged.disconnect(self._onChanged)
  48. super().setNode(node)
  49. # Mypy doesn't understand that self._node is no longer optional, so just use the node.
  50. node.transformationChanged.connect(self._onChanged)
  51. node.parentChanged.connect(self._onChanged)
  52. self._onChanged()
  53. ## Force that a new (empty) object is created upon copy.
  54. def __deepcopy__(self, memo):
  55. return ConvexHullDecorator()
  56. ## Get the unmodified 2D projected convex hull of the node (if any)
  57. def getConvexHull(self) -> Optional[Polygon]:
  58. if self._node is None:
  59. return None
  60. hull = self._compute2DConvexHull()
  61. if self._global_stack and self._node is not None and hull is not None:
  62. # Parent can be None if node is just loaded.
  63. if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and not self.hasGroupAsParent(self._node):
  64. hull = hull.getMinkowskiHull(Polygon(numpy.array(self._global_stack.getProperty("machine_head_polygon", "value"), numpy.float32)))
  65. hull = self._add2DAdhesionMargin(hull)
  66. return hull
  67. ## Get the convex hull of the node with the full head size
  68. def getConvexHullHeadFull(self) -> Optional[Polygon]:
  69. if self._node is None:
  70. return None
  71. return self._compute2DConvexHeadFull()
  72. @staticmethod
  73. def hasGroupAsParent(node: "SceneNode") -> bool:
  74. parent = node.getParent()
  75. if parent is None:
  76. return False
  77. return bool(parent.callDecoration("isGroup"))
  78. ## Get convex hull of the object + head size
  79. # In case of printing all at once this is the same as the convex hull.
  80. # For one at the time this is area with intersection of mirrored head
  81. def getConvexHullHead(self) -> Optional[Polygon]:
  82. if self._node is None:
  83. return None
  84. if self._global_stack:
  85. if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and not self.hasGroupAsParent(self._node):
  86. head_with_fans = self._compute2DConvexHeadMin()
  87. if head_with_fans is None:
  88. return None
  89. head_with_fans_with_adhesion_margin = self._add2DAdhesionMargin(head_with_fans)
  90. return head_with_fans_with_adhesion_margin
  91. return None
  92. ## Get convex hull of the node
  93. # In case of printing all at once this is the same as the convex hull.
  94. # For one at the time this is the area without the head.
  95. def getConvexHullBoundary(self) -> Optional[Polygon]:
  96. if self._node is None:
  97. return None
  98. if self._global_stack:
  99. if self._global_stack.getProperty("print_sequence", "value") == "one_at_a_time" and not self.hasGroupAsParent(self._node):
  100. # Printing one at a time and it's not an object in a group
  101. return self._compute2DConvexHull()
  102. return None
  103. ## The same as recomputeConvexHull, but using a timer if it was set.
  104. def recomputeConvexHullDelayed(self) -> None:
  105. if self._recompute_convex_hull_timer is not None:
  106. self._recompute_convex_hull_timer.start()
  107. else:
  108. self.recomputeConvexHull()
  109. def recomputeConvexHull(self) -> None:
  110. controller = Application.getInstance().getController()
  111. root = controller.getScene().getRoot()
  112. if self._node is None or controller.isToolOperationActive() or not self.__isDescendant(root, self._node):
  113. # If the tool operation is still active, we need to compute the convex hull later after the controller is
  114. # no longer active.
  115. if controller.isToolOperationActive():
  116. self.recomputeConvexHullDelayed()
  117. return
  118. if self._convex_hull_node:
  119. self._convex_hull_node.setParent(None)
  120. self._convex_hull_node = None
  121. return
  122. convex_hull = self.getConvexHull()
  123. if self._convex_hull_node:
  124. self._convex_hull_node.setParent(None)
  125. hull_node = ConvexHullNode.ConvexHullNode(self._node, convex_hull, self._raft_thickness, root)
  126. self._convex_hull_node = hull_node
  127. def _onSettingValueChanged(self, key: str, property_name: str) -> None:
  128. if property_name != "value": # Not the value that was changed.
  129. return
  130. if key in self._affected_settings:
  131. self._onChanged()
  132. if key in self._influencing_settings:
  133. self._init2DConvexHullCache() # Invalidate the cache.
  134. self._onChanged()
  135. def _init2DConvexHullCache(self) -> None:
  136. # Cache for the group code path in _compute2DConvexHull()
  137. self._2d_convex_hull_group_child_polygon = None # type: Optional[Polygon]
  138. self._2d_convex_hull_group_result = None # type: Optional[Polygon]
  139. # Cache for the mesh code path in _compute2DConvexHull()
  140. self._2d_convex_hull_mesh = None # type: Optional[MeshData]
  141. self._2d_convex_hull_mesh_world_transform = None # type: Optional[Matrix]
  142. self._2d_convex_hull_mesh_result = None # type: Optional[Polygon]
  143. def _compute2DConvexHull(self) -> Optional[Polygon]:
  144. if self._node is None:
  145. return None
  146. if self._node.callDecoration("isGroup"):
  147. points = numpy.zeros((0, 2), dtype=numpy.int32)
  148. for child in self._node.getChildren():
  149. child_hull = child.callDecoration("_compute2DConvexHull")
  150. if child_hull:
  151. points = numpy.append(points, child_hull.getPoints(), axis = 0)
  152. if points.size < 3:
  153. return None
  154. child_polygon = Polygon(points)
  155. # Check the cache
  156. if child_polygon == self._2d_convex_hull_group_child_polygon:
  157. return self._2d_convex_hull_group_result
  158. convex_hull = child_polygon.getConvexHull() #First calculate the normal convex hull around the points.
  159. offset_hull = self._offsetHull(convex_hull) #Then apply the offset from the settings.
  160. # Store the result in the cache
  161. self._2d_convex_hull_group_child_polygon = child_polygon
  162. self._2d_convex_hull_group_result = offset_hull
  163. return offset_hull
  164. else:
  165. offset_hull = Polygon([])
  166. mesh = self._node.getMeshData()
  167. if mesh is None:
  168. return Polygon([]) # Node has no mesh data, so just return an empty Polygon.
  169. world_transform = self._node.getWorldTransformation()
  170. # Check the cache
  171. if mesh is self._2d_convex_hull_mesh and world_transform == self._2d_convex_hull_mesh_world_transform:
  172. return self._2d_convex_hull_mesh_result
  173. vertex_data = mesh.getConvexHullTransformedVertices(world_transform)
  174. # Don't use data below 0.
  175. # TODO; We need a better check for this as this gives poor results for meshes with long edges.
  176. # Do not throw away vertices: the convex hull may be too small and objects can collide.
  177. # vertex_data = vertex_data[vertex_data[:,1] >= -0.01]
  178. if len(vertex_data) >= 4: # type: ignore # mypy and numpy don't play along well just yet.
  179. # Round the vertex data to 1/10th of a mm, then remove all duplicate vertices
  180. # This is done to greatly speed up further convex hull calculations as the convex hull
  181. # becomes much less complex when dealing with highly detailed models.
  182. vertex_data = numpy.round(vertex_data, 1)
  183. vertex_data = vertex_data[:, [0, 2]] # Drop the Y components to project to 2D.
  184. # Grab the set of unique points.
  185. #
  186. # This basically finds the unique rows in the array by treating them as opaque groups of bytes
  187. # which are as long as the 2 float64s in each row, and giving this view to numpy.unique() to munch.
  188. # See http://stackoverflow.com/questions/16970982/find-unique-rows-in-numpy-array
  189. vertex_byte_view = numpy.ascontiguousarray(vertex_data).view(
  190. numpy.dtype((numpy.void, vertex_data.dtype.itemsize * vertex_data.shape[1])))
  191. _, idx = numpy.unique(vertex_byte_view, return_index=True)
  192. vertex_data = vertex_data[idx] # Select the unique rows by index.
  193. hull = Polygon(vertex_data)
  194. if len(vertex_data) >= 3:
  195. convex_hull = hull.getConvexHull()
  196. offset_hull = self._offsetHull(convex_hull)
  197. # Store the result in the cache
  198. self._2d_convex_hull_mesh = mesh
  199. self._2d_convex_hull_mesh_world_transform = world_transform
  200. self._2d_convex_hull_mesh_result = offset_hull
  201. return offset_hull
  202. def _getHeadAndFans(self) -> Polygon:
  203. if self._global_stack:
  204. return Polygon(numpy.array(self._global_stack.getHeadAndFansCoordinates(), numpy.float32))
  205. return Polygon()
  206. def _compute2DConvexHeadFull(self) -> Optional[Polygon]:
  207. convex_hull = self._compute2DConvexHull()
  208. if convex_hull:
  209. return convex_hull.getMinkowskiHull(self._getHeadAndFans())
  210. return None
  211. def _compute2DConvexHeadMin(self) -> Optional[Polygon]:
  212. head_and_fans = self._getHeadAndFans()
  213. mirrored = head_and_fans.mirror([0, 0], [0, 1]).mirror([0, 0], [1, 0]) # Mirror horizontally & vertically.
  214. head_and_fans = self._getHeadAndFans().intersectionConvexHulls(mirrored)
  215. # Min head hull is used for the push free
  216. convex_hull = self._compute2DConvexHeadFull()
  217. if convex_hull:
  218. return convex_hull.getMinkowskiHull(head_and_fans)
  219. return None
  220. ## Compensate given 2D polygon with adhesion margin
  221. # \return 2D polygon with added margin
  222. def _add2DAdhesionMargin(self, poly: Polygon) -> Polygon:
  223. if not self._global_stack:
  224. return Polygon()
  225. # Compensate for raft/skirt/brim
  226. # Add extra margin depending on adhesion type
  227. adhesion_type = self._global_stack.getProperty("adhesion_type", "value")
  228. if adhesion_type == "raft":
  229. extra_margin = max(0, self._getSettingProperty("raft_margin", "value"))
  230. elif adhesion_type == "brim":
  231. extra_margin = max(0, self._getSettingProperty("brim_line_count", "value") * self._getSettingProperty("skirt_brim_line_width", "value"))
  232. elif adhesion_type == "none":
  233. extra_margin = 0
  234. elif adhesion_type == "skirt":
  235. extra_margin = max(
  236. 0, self._getSettingProperty("skirt_gap", "value") +
  237. self._getSettingProperty("skirt_line_count", "value") * self._getSettingProperty("skirt_brim_line_width", "value"))
  238. else:
  239. raise Exception("Unknown bed adhesion type. Did you forget to update the convex hull calculations for your new bed adhesion type?")
  240. # Adjust head_and_fans with extra margin
  241. if extra_margin > 0:
  242. extra_margin_polygon = Polygon.approximatedCircle(extra_margin)
  243. poly = poly.getMinkowskiHull(extra_margin_polygon)
  244. return poly
  245. ## Offset the convex hull with settings that influence the collision area.
  246. #
  247. # \param convex_hull Polygon of the original convex hull.
  248. # \return New Polygon instance that is offset with everything that
  249. # influences the collision area.
  250. def _offsetHull(self, convex_hull: Polygon) -> Polygon:
  251. horizontal_expansion = max(
  252. self._getSettingProperty("xy_offset", "value"),
  253. self._getSettingProperty("xy_offset_layer_0", "value")
  254. )
  255. mold_width = 0
  256. if self._getSettingProperty("mold_enabled", "value"):
  257. mold_width = self._getSettingProperty("mold_width", "value")
  258. hull_offset = horizontal_expansion + mold_width
  259. if hull_offset > 0: #TODO: Implement Minkowski subtraction for if the offset < 0.
  260. expansion_polygon = Polygon(numpy.array([
  261. [-hull_offset, -hull_offset],
  262. [-hull_offset, hull_offset],
  263. [hull_offset, hull_offset],
  264. [hull_offset, -hull_offset]
  265. ], numpy.float32))
  266. return convex_hull.getMinkowskiHull(expansion_polygon)
  267. else:
  268. return convex_hull
  269. def _onChanged(self, *args) -> None:
  270. self._raft_thickness = self._build_volume.getRaftThickness()
  271. if not args or args[0] == self._node:
  272. self.recomputeConvexHullDelayed()
  273. def _onGlobalStackChanged(self) -> None:
  274. if self._global_stack:
  275. self._global_stack.propertyChanged.disconnect(self._onSettingValueChanged)
  276. self._global_stack.containersChanged.disconnect(self._onChanged)
  277. extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
  278. for extruder in extruders:
  279. extruder.propertyChanged.disconnect(self._onSettingValueChanged)
  280. self._global_stack = Application.getInstance().getGlobalContainerStack()
  281. if self._global_stack:
  282. self._global_stack.propertyChanged.connect(self._onSettingValueChanged)
  283. self._global_stack.containersChanged.connect(self._onChanged)
  284. extruders = ExtruderManager.getInstance().getActiveExtruderStacks()
  285. for extruder in extruders:
  286. extruder.propertyChanged.connect(self._onSettingValueChanged)
  287. self._onChanged()
  288. ## Private convenience function to get a setting from the correct extruder (as defined by limit_to_extruder property).
  289. def _getSettingProperty(self, setting_key: str, prop: str = "value") -> Any:
  290. if self._global_stack is None or self._node is None:
  291. return None
  292. per_mesh_stack = self._node.callDecoration("getStack")
  293. if per_mesh_stack:
  294. return per_mesh_stack.getProperty(setting_key, prop)
  295. extruder_index = self._global_stack.getProperty(setting_key, "limit_to_extruder")
  296. if extruder_index == "-1":
  297. # No limit_to_extruder
  298. extruder_stack_id = self._node.callDecoration("getActiveExtruder")
  299. if not extruder_stack_id:
  300. # Decoration doesn't exist
  301. extruder_stack_id = ExtruderManager.getInstance().extruderIds["0"]
  302. extruder_stack = ContainerRegistry.getInstance().findContainerStacks(id = extruder_stack_id)[0]
  303. return extruder_stack.getProperty(setting_key, prop)
  304. else:
  305. # Limit_to_extruder is set. The global stack handles this then
  306. return self._global_stack.getProperty(setting_key, prop)
  307. ## Returns True if node is a descendant or the same as the root node.
  308. def __isDescendant(self, root: "SceneNode", node: Optional["SceneNode"]) -> bool:
  309. if node is None:
  310. return False
  311. if root is node:
  312. return True
  313. return self.__isDescendant(root, node.getParent())
  314. _affected_settings = [
  315. "adhesion_type", "raft_margin", "print_sequence",
  316. "skirt_gap", "skirt_line_count", "skirt_brim_line_width", "skirt_distance", "brim_line_count"]
  317. ## Settings that change the convex hull.
  318. #
  319. # If these settings change, the convex hull should be recalculated.
  320. _influencing_settings = {"xy_offset", "xy_offset_layer_0", "mold_enabled", "mold_width"}