LayerPolygon.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262
  1. # Copyright (c) 2019 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. import numpy
  4. from typing import Optional, cast
  5. from UM.Qt.Bindings.Theme import Theme
  6. from UM.Qt.QtApplication import QtApplication
  7. from UM.Logger import Logger
  8. class LayerPolygon:
  9. NoneType = 0
  10. Inset0Type = 1
  11. InsetXType = 2
  12. SkinType = 3
  13. SupportType = 4
  14. SkirtType = 5
  15. InfillType = 6
  16. SupportInfillType = 7
  17. MoveCombingType = 8
  18. MoveRetractionType = 9
  19. SupportInterfaceType = 10
  20. PrimeTowerType = 11
  21. __number_of_types = 12
  22. __jump_map = numpy.logical_or(numpy.logical_or(numpy.arange(__number_of_types) == NoneType, numpy.arange(__number_of_types) == MoveCombingType), numpy.arange(__number_of_types) == MoveRetractionType)
  23. def __init__(self, extruder: int, line_types: numpy.ndarray, data: numpy.ndarray, line_widths: numpy.ndarray, line_thicknesses: numpy.ndarray, line_feedrates: numpy.ndarray) -> None:
  24. """LayerPolygon, used in ProcessSlicedLayersJob
  25. :param extruder: The position of the extruder
  26. :param line_types: array with line_types
  27. :param data: new_points
  28. :param line_widths: array with line widths
  29. :param line_thicknesses: array with type as index and thickness as value
  30. :param line_feedrates: array with line feedrates
  31. """
  32. self._extruder = extruder
  33. self._types = line_types
  34. for i in range(len(self._types)):
  35. if self._types[i] >= self.__number_of_types: # Got faulty line data from the engine.
  36. Logger.log("w", "Found an unknown line type: %s", i)
  37. self._types[i] = self.NoneType
  38. self._data = data
  39. self._line_widths = line_widths
  40. self._line_thicknesses = line_thicknesses
  41. self._line_feedrates = line_feedrates
  42. self._vertex_begin = 0
  43. self._vertex_end = 0
  44. self._index_begin = 0
  45. self._index_end = 0
  46. self._jump_mask = self.__jump_map[self._types]
  47. self._jump_count = numpy.sum(self._jump_mask)
  48. self._mesh_line_count = len(self._types) - self._jump_count
  49. self._vertex_count = self._mesh_line_count + numpy.sum(self._types[1:] == self._types[:-1])
  50. # Buffering the colors shouldn't be necessary as it is not
  51. # re-used and can save a lot of memory usage.
  52. self._color_map = LayerPolygon.getColorMap()
  53. self._colors = self._color_map[self._types] # type: numpy.ndarray
  54. # When type is used as index returns true if type == LayerPolygon.InfillType or type == LayerPolygon.SkinType or type == LayerPolygon.SupportInfillType
  55. # Should be generated in better way, not hardcoded.
  56. self._is_infill_or_skin_type_map = numpy.array([0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0], dtype = bool)
  57. self._build_cache_line_mesh_mask = None # type: Optional[numpy.ndarray]
  58. self._build_cache_needed_points = None # type: Optional[numpy.ndarray]
  59. def buildCache(self) -> None:
  60. # For the line mesh we do not draw Infill or Jumps. Therefore those lines are filtered out.
  61. self._build_cache_line_mesh_mask = numpy.ones(self._jump_mask.shape, dtype = bool)
  62. self._index_begin = 0
  63. self._index_end = cast(int, numpy.sum(self._build_cache_line_mesh_mask))
  64. self._build_cache_needed_points = numpy.ones((len(self._types), 2), dtype = bool)
  65. # Only if the type of line segment changes do we need to add an extra vertex to change colors
  66. self._build_cache_needed_points[1:, 0][:, numpy.newaxis] = self._types[1:] != self._types[:-1]
  67. # Mark points as unneeded if they are of types we don't want in the line mesh according to the calculated mask
  68. numpy.logical_and(self._build_cache_needed_points, self._build_cache_line_mesh_mask, self._build_cache_needed_points )
  69. self._vertex_begin = 0
  70. self._vertex_end = cast(int, numpy.sum(self._build_cache_needed_points))
  71. def build(self, vertex_offset: int, index_offset: int, vertices: numpy.ndarray, colors: numpy.ndarray, line_dimensions: numpy.ndarray, feedrates: numpy.ndarray, extruders: numpy.ndarray, line_types: numpy.ndarray, indices: numpy.ndarray) -> None:
  72. """Set all the arrays provided by the function caller, representing the LayerPolygon
  73. The arrays are either by vertex or by indices.
  74. :param vertex_offset: determines where to start and end filling the arrays
  75. :param index_offset: determines where to start and end filling the arrays
  76. :param vertices: vertex numpy array to be filled
  77. :param colors: vertex numpy array to be filled
  78. :param line_dimensions: vertex numpy array to be filled
  79. :param feedrates: vertex numpy array to be filled
  80. :param extruders: vertex numpy array to be filled
  81. :param line_types: vertex numpy array to be filled
  82. :param indices: index numpy array to be filled
  83. """
  84. if self._build_cache_line_mesh_mask is None or self._build_cache_needed_points is None:
  85. self.buildCache()
  86. if self._build_cache_line_mesh_mask is None or self._build_cache_needed_points is None:
  87. Logger.log("w", "Failed to build cache for layer polygon")
  88. return
  89. line_mesh_mask = self._build_cache_line_mesh_mask
  90. needed_points_list = self._build_cache_needed_points
  91. # Index to the points we need to represent the line mesh. This is constructed by generating simple
  92. # start and end points for each line. For line segment n these are points n and n+1. Row n reads [n n+1]
  93. # Then then the indices for the points we don't need are thrown away based on the pre-calculated list.
  94. index_list = ( numpy.arange(len(self._types)).reshape((-1, 1)) + numpy.array([[0, 1]]) ).reshape((-1, 1))[needed_points_list.reshape((-1, 1))]
  95. # The relative values of begin and end indices have already been set in buildCache, so we only need to offset them to the parents offset.
  96. self._vertex_begin += vertex_offset
  97. self._vertex_end += vertex_offset
  98. # Points are picked based on the index list to get the vertices needed.
  99. vertices[self._vertex_begin:self._vertex_end, :] = self._data[index_list, :]
  100. # Create an array with colors for each vertex and remove the color data for the points that has been thrown away.
  101. colors[self._vertex_begin:self._vertex_end, :] = numpy.tile(self._colors, (1, 2)).reshape((-1, 4))[needed_points_list.ravel()]
  102. # Create an array with line widths and thicknesses for each vertex.
  103. line_dimensions[self._vertex_begin:self._vertex_end, 0] = numpy.tile(self._line_widths, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
  104. line_dimensions[self._vertex_begin:self._vertex_end, 1] = numpy.tile(self._line_thicknesses, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
  105. # Create an array with feedrates for each line
  106. feedrates[self._vertex_begin:self._vertex_end] = numpy.tile(self._line_feedrates, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
  107. extruders[self._vertex_begin:self._vertex_end] = self._extruder
  108. # Convert type per vertex to type per line
  109. line_types[self._vertex_begin:self._vertex_end] = numpy.tile(self._types, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
  110. # The relative values of begin and end indices have already been set in buildCache, so we only need to offset them to the parents offset.
  111. self._index_begin += index_offset
  112. self._index_end += index_offset
  113. indices[self._index_begin:self._index_end, :] = numpy.arange(self._index_end-self._index_begin, dtype = numpy.int32).reshape((-1, 1))
  114. # When the line type changes the index needs to be increased by 2.
  115. indices[self._index_begin:self._index_end, :] += numpy.cumsum(needed_points_list[line_mesh_mask.ravel(), 0], dtype = numpy.int32).reshape((-1, 1))
  116. # Each line segment goes from it's starting point p to p+1, offset by the vertex index.
  117. # The -1 is to compensate for the necessarily True value of needed_points_list[0,0] which causes an unwanted +1 in cumsum above.
  118. indices[self._index_begin:self._index_end, :] += numpy.array([self._vertex_begin - 1, self._vertex_begin])
  119. self._build_cache_line_mesh_mask = None
  120. self._build_cache_needed_points = None
  121. def getColors(self):
  122. return self._colors
  123. def mapLineTypeToColor(self, line_types: numpy.ndarray) -> numpy.ndarray:
  124. return self._color_map[line_types]
  125. def isInfillOrSkinType(self, line_types: numpy.ndarray) -> numpy.ndarray:
  126. return self._is_infill_or_skin_type_map[line_types]
  127. def lineMeshVertexCount(self) -> int:
  128. return self._vertex_end - self._vertex_begin
  129. def lineMeshElementCount(self) -> int:
  130. return self._index_end - self._index_begin
  131. @property
  132. def extruder(self):
  133. return self._extruder
  134. @property
  135. def types(self):
  136. return self._types
  137. @property
  138. def data(self):
  139. return self._data
  140. @property
  141. def elementCount(self):
  142. return (self._index_end - self._index_begin) * 2 # The range of vertices multiplied by 2 since each vertex is used twice
  143. @property
  144. def lineWidths(self):
  145. return self._line_widths
  146. @property
  147. def lineThicknesses(self):
  148. return self._line_thicknesses
  149. @property
  150. def lineFeedrates(self):
  151. return self._line_feedrates
  152. @property
  153. def jumpMask(self):
  154. return self._jump_mask
  155. @property
  156. def meshLineCount(self):
  157. return self._mesh_line_count
  158. @property
  159. def jumpCount(self):
  160. return self._jump_count
  161. def getNormals(self) -> numpy.ndarray:
  162. """Calculate normals for the entire polygon using numpy.
  163. :return: normals for the entire polygon
  164. """
  165. normals = numpy.copy(self._data)
  166. normals[:, 1] = 0.0 # We are only interested in 2D normals
  167. # Calculate the edges between points.
  168. # The call to numpy.roll shifts the entire array by one so that
  169. # we end up subtracting each next point from the current, wrapping
  170. # around. This gives us the edges from the next point to the current
  171. # point.
  172. normals = numpy.diff(normals, 1, 0)
  173. # Calculate the length of each edge using standard Pythagoras
  174. lengths = numpy.sqrt(normals[:, 0] ** 2 + normals[:, 2] ** 2)
  175. # The normal of a 2D vector is equal to its x and y coordinates swapped
  176. # and then x inverted. This code does that.
  177. normals[:, [0, 2]] = normals[:, [2, 0]]
  178. normals[:, 0] *= -1
  179. # Normalize the normals.
  180. normals[:, 0] /= lengths
  181. normals[:, 2] /= lengths
  182. return normals
  183. __color_map = None # type: numpy.ndarray
  184. @classmethod
  185. def getColorMap(cls) -> numpy.ndarray:
  186. """Gets the instance of the VersionUpgradeManager, or creates one."""
  187. if cls.__color_map is None:
  188. theme = cast(Theme, QtApplication.getInstance().getTheme())
  189. cls.__color_map = numpy.array([
  190. theme.getColor("layerview_none").getRgbF(), # NoneType
  191. theme.getColor("layerview_inset_0").getRgbF(), # Inset0Type
  192. theme.getColor("layerview_inset_x").getRgbF(), # InsetXType
  193. theme.getColor("layerview_skin").getRgbF(), # SkinType
  194. theme.getColor("layerview_support").getRgbF(), # SupportType
  195. theme.getColor("layerview_skirt").getRgbF(), # SkirtType
  196. theme.getColor("layerview_infill").getRgbF(), # InfillType
  197. theme.getColor("layerview_support_infill").getRgbF(), # SupportInfillType
  198. theme.getColor("layerview_move_combing").getRgbF(), # MoveCombingType
  199. theme.getColor("layerview_move_retraction").getRgbF(), # MoveRetractionType
  200. theme.getColor("layerview_support_interface").getRgbF(), # SupportInterfaceType
  201. theme.getColor("layerview_prime_tower").getRgbF() # PrimeTowerType
  202. ])
  203. return cls.__color_map