ImageReader.py 8.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228
  1. # Copyright (c) 2020 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. import numpy
  4. import math
  5. from PyQt5.QtGui import QImage, qRed, qGreen, qBlue, qAlpha
  6. from PyQt5.QtCore import Qt
  7. from UM.Mesh.MeshReader import MeshReader
  8. from UM.Mesh.MeshBuilder import MeshBuilder
  9. from UM.Math.Vector import Vector
  10. from UM.Job import Job
  11. from UM.Logger import Logger
  12. from .ImageReaderUI import ImageReaderUI
  13. from cura.Scene.CuraSceneNode import CuraSceneNode as SceneNode
  14. class ImageReader(MeshReader):
  15. def __init__(self) -> None:
  16. super().__init__()
  17. self._supported_extensions = [".jpg", ".jpeg", ".bmp", ".gif", ".png"]
  18. self._ui = ImageReaderUI(self)
  19. def preRead(self, file_name, *args, **kwargs):
  20. img = QImage(file_name)
  21. if img.isNull():
  22. Logger.log("e", "Image is corrupt.")
  23. return MeshReader.PreReadResult.failed
  24. width = img.width()
  25. depth = img.height()
  26. largest = max(width, depth)
  27. width = width / largest * self._ui.default_width
  28. depth = depth / largest * self._ui.default_depth
  29. self._ui.setWidthAndDepth(width, depth)
  30. self._ui.showConfigUI()
  31. self._ui.waitForUIToClose()
  32. if self._ui.getCancelled():
  33. return MeshReader.PreReadResult.cancelled
  34. return MeshReader.PreReadResult.accepted
  35. def _read(self, file_name):
  36. size = max(self._ui.getWidth(), self._ui.getDepth())
  37. return self._generateSceneNode(file_name, size, self._ui.peak_height, self._ui.base_height, self._ui.smoothing, 512, self._ui.lighter_is_higher, self._ui.use_transparency_model, self._ui.transmittance_1mm)
  38. def _generateSceneNode(self, file_name, xz_size, height_from_base, base_height, blur_iterations, max_size, lighter_is_higher, use_transparency_model, transmittance_1mm):
  39. scene_node = SceneNode()
  40. mesh = MeshBuilder()
  41. img = QImage(file_name)
  42. if img.isNull():
  43. Logger.log("e", "Image is corrupt.")
  44. return None
  45. width = max(img.width(), 2)
  46. height = max(img.height(), 2)
  47. aspect = height / width
  48. if img.width() < 2 or img.height() < 2:
  49. img = img.scaled(width, height, Qt.IgnoreAspectRatio)
  50. height_from_base = max(height_from_base, 0)
  51. base_height = max(base_height, 0)
  52. xz_size = max(xz_size, 1)
  53. scale_vector = Vector(xz_size, height_from_base, xz_size)
  54. if width > height:
  55. scale_vector = scale_vector.set(z=scale_vector.z * aspect)
  56. elif height > width:
  57. scale_vector = scale_vector.set(x=scale_vector.x / aspect)
  58. if width > max_size or height > max_size:
  59. scale_factor = max_size / width
  60. if height > width:
  61. scale_factor = max_size / height
  62. width = int(max(round(width * scale_factor), 2))
  63. height = int(max(round(height * scale_factor), 2))
  64. img = img.scaled(width, height, Qt.IgnoreAspectRatio)
  65. width_minus_one = width - 1
  66. height_minus_one = height - 1
  67. Job.yieldThread()
  68. texel_width = 1.0 / (width_minus_one) * scale_vector.x
  69. texel_height = 1.0 / (height_minus_one) * scale_vector.z
  70. height_data = numpy.zeros((height, width), dtype = numpy.float32)
  71. for x in range(0, width):
  72. for y in range(0, height):
  73. qrgb = img.pixel(x, y)
  74. if use_transparency_model:
  75. height_data[y, x] = (0.299 * math.pow(qRed(qrgb) / 255.0, 2.2) + 0.587 * math.pow(qGreen(qrgb) / 255.0, 2.2) + 0.114 * math.pow(qBlue(qrgb) / 255.0, 2.2))
  76. else:
  77. height_data[y, x] = (0.212655 * qRed(qrgb) + 0.715158 * qGreen(qrgb) + 0.072187 * qBlue(qrgb)) / 255 # fast computation ignoring gamma and degamma
  78. Job.yieldThread()
  79. if lighter_is_higher == use_transparency_model:
  80. height_data = 1 - height_data
  81. for _ in range(0, blur_iterations):
  82. copy = numpy.pad(height_data, ((1, 1), (1, 1)), mode = "edge")
  83. height_data += copy[1:-1, 2:]
  84. height_data += copy[1:-1, :-2]
  85. height_data += copy[2:, 1:-1]
  86. height_data += copy[:-2, 1:-1]
  87. height_data += copy[2:, 2:]
  88. height_data += copy[:-2, 2:]
  89. height_data += copy[2:, :-2]
  90. height_data += copy[:-2, :-2]
  91. height_data /= 9
  92. Job.yieldThread()
  93. if use_transparency_model:
  94. divisor = 1.0 / math.log(transmittance_1mm / 100.0) # log-base doesn't matter here. Precompute this value for faster computation of each pixel.
  95. min_luminance = (transmittance_1mm / 100.0) ** height_from_base
  96. for (y, x) in numpy.ndindex(height_data.shape):
  97. mapped_luminance = min_luminance + (1.0 - min_luminance) * height_data[y, x]
  98. height_data[y, x] = base_height + divisor * math.log(mapped_luminance) # use same base as a couple lines above this
  99. else:
  100. height_data *= scale_vector.y
  101. height_data += base_height
  102. if img.hasAlphaChannel():
  103. for x in range(0, width):
  104. for y in range(0, height):
  105. height_data[y, x] *= qAlpha(img.pixel(x, y)) / 255.0
  106. heightmap_face_count = 2 * height_minus_one * width_minus_one
  107. total_face_count = heightmap_face_count + (width_minus_one * 2) * (height_minus_one * 2) + 2
  108. mesh.reserveFaceCount(total_face_count)
  109. # initialize to texel space vertex offsets.
  110. # 6 is for 6 vertices for each texel quad.
  111. heightmap_vertices = numpy.zeros((width_minus_one * height_minus_one, 6, 3), dtype = numpy.float32)
  112. heightmap_vertices = heightmap_vertices + numpy.array([[
  113. [0, base_height, 0],
  114. [0, base_height, texel_height],
  115. [texel_width, base_height, texel_height],
  116. [texel_width, base_height, texel_height],
  117. [texel_width, base_height, 0],
  118. [0, base_height, 0]
  119. ]], dtype = numpy.float32)
  120. offsetsz, offsetsx = numpy.mgrid[0: height_minus_one, 0: width - 1]
  121. offsetsx = numpy.array(offsetsx, numpy.float32).reshape(-1, 1) * texel_width
  122. offsetsz = numpy.array(offsetsz, numpy.float32).reshape(-1, 1) * texel_height
  123. # offsets for each texel quad
  124. heightmap_vertex_offsets = numpy.concatenate([offsetsx, numpy.zeros((offsetsx.shape[0], offsetsx.shape[1]), dtype = numpy.float32), offsetsz], 1)
  125. heightmap_vertices += heightmap_vertex_offsets.repeat(6, 0).reshape(-1, 6, 3)
  126. # apply height data to y values
  127. heightmap_vertices[:, 0, 1] = heightmap_vertices[:, 5, 1] = height_data[:-1, :-1].reshape(-1)
  128. heightmap_vertices[:, 1, 1] = height_data[1:, :-1].reshape(-1)
  129. heightmap_vertices[:, 2, 1] = heightmap_vertices[:, 3, 1] = height_data[1:, 1:].reshape(-1)
  130. heightmap_vertices[:, 4, 1] = height_data[:-1, 1:].reshape(-1)
  131. heightmap_indices = numpy.array(numpy.mgrid[0:heightmap_face_count * 3], dtype = numpy.int32).reshape(-1, 3)
  132. mesh._vertices[0:(heightmap_vertices.size // 3), :] = heightmap_vertices.reshape(-1, 3)
  133. mesh._indices[0:(heightmap_indices.size // 3), :] = heightmap_indices
  134. mesh._vertex_count = heightmap_vertices.size // 3
  135. mesh._face_count = heightmap_indices.size // 3
  136. geo_width = width_minus_one * texel_width
  137. geo_height = height_minus_one * texel_height
  138. # bottom
  139. mesh.addFaceByPoints(0, 0, 0, 0, 0, geo_height, geo_width, 0, geo_height)
  140. mesh.addFaceByPoints(geo_width, 0, geo_height, geo_width, 0, 0, 0, 0, 0)
  141. # north and south walls
  142. for n in range(0, width_minus_one):
  143. x = n * texel_width
  144. nx = (n + 1) * texel_width
  145. hn0 = height_data[0, n]
  146. hn1 = height_data[0, n + 1]
  147. hs0 = height_data[height_minus_one, n]
  148. hs1 = height_data[height_minus_one, n + 1]
  149. mesh.addFaceByPoints(x, 0, 0, nx, 0, 0, nx, hn1, 0)
  150. mesh.addFaceByPoints(nx, hn1, 0, x, hn0, 0, x, 0, 0)
  151. mesh.addFaceByPoints(x, 0, geo_height, nx, 0, geo_height, nx, hs1, geo_height)
  152. mesh.addFaceByPoints(nx, hs1, geo_height, x, hs0, geo_height, x, 0, geo_height)
  153. # west and east walls
  154. for n in range(0, height_minus_one):
  155. y = n * texel_height
  156. ny = (n + 1) * texel_height
  157. hw0 = height_data[n, 0]
  158. hw1 = height_data[n + 1, 0]
  159. he0 = height_data[n, width_minus_one]
  160. he1 = height_data[n + 1, width_minus_one]
  161. mesh.addFaceByPoints(0, 0, y, 0, 0, ny, 0, hw1, ny)
  162. mesh.addFaceByPoints(0, hw1, ny, 0, hw0, y, 0, 0, y)
  163. mesh.addFaceByPoints(geo_width, 0, y, geo_width, 0, ny, geo_width, he1, ny)
  164. mesh.addFaceByPoints(geo_width, he1, ny, geo_width, he0, y, geo_width, 0, y)
  165. mesh.calculateNormals(fast = True)
  166. scene_node.setMeshData(mesh.build())
  167. return scene_node