add triangulation

Author: STASYA00

dataset/blender_utils.py

@@ -91,3 +91,7 @@ def gancio(v1, v2, axis, border1=0, border2=0):
 	                                  mapping[abs(1 - border2)] * np.diff(coords1[abs(1 - axis)]) + \
 	                                  (0.5 * np.diff(coords2[abs(1-axis)]) * mapping[border2])
 
+def select(_volume):
+	_volume.select_set(True)
+	bpy.context.view_layer.objects.active = _volume
+

dataset/material.py

@@ -13,9 +13,9 @@ class Material:
 	"""
 	Class that represents a material object in Blender.
 	"""
-	def __init__(self, name, filename='material'):
+	def __init__(self, name):
 		self.name = name.lower().capitalize()  # name of the material and its texture folder
-		self.filename = filename
+		self.filename = 'material'
 		self._path = file_dir + '/Textures/{}.blend'.format(self.filename)
 		self._add = '\\Material\\'
 		self.value = self._load()  # loads material into the scene
@@ -53,7 +53,10 @@ def _load_maps(self, map_type):
 		try:
 			bpy.ops.image.open(filepath=file_dir + '/Textures/{}/{}.png'.
 			                   format(self.name, map_type.capitalize()))
-			return bpy.data.images[-2]
+			_images = [x.filepath for x in bpy.data.images]
+			return bpy.data.images[_images.index('//Textures'
+			                                     '\\{}\\{}.png'.format(self.name,
+			                                                               map_type))]
 		except Exception as e:
 			print('Failed to load {} texture of {}'.format(map_type, self.name))
 			print(repr(e))

dataset/module.py

@@ -13,19 +13,38 @@
 
 stdout = io.StringIO()
 from dataset_config import *
-from blender_utils import gancio, get_min_max
+from blender_utils import *
 from shp2obj import Collection, deselect_all
 
 
+class IdAssigner:
+	"""
+	Class that assigns an instance id based on the module type.
+	"""
+	def __init__(self):
+		self.mapping = {x: y for (x, y) in zip(MODULES, range(2, len(MODULES) + 2))}
+
+	def make(self, name: str) -> int:
+		"""
+		Function that returns an id based on the module type. Numbering starts from
+		1 since 0 is the building envelope.
+		:param name: name of the module, str
+		:return: id, int
+		"""
+		assert name in MODULES, "Expected name to be in MODULES, got {}".format(name)
+		return self.mapping[name]
+
+
 class Connector:
-	def __init__(self, module, volume, axis):
+	def __init__(self, module, volume, axis, side=0):
 		self.module = module
 		self.axis = axis
+		self.side = side
 		self.volume = volume
 		self._connect()
 
 	def _connect(self):
-		gancio(self.volume, self.module, self.axis, 0, 1)
+		gancio(self.volume, self.module, self.axis, self.side, 1)
 
 
 class Module:
@@ -37,9 +56,11 @@ def __init__(self, name='generic', scale=None, mask=(1.0, 0.0, 0.0)):
 		       or issubclass(mask.__class__, np.ndarray), "Expected mask to be an " \
 		                                            "array or a tuple, got {}".format(type(mask))
 		assert len(mask) == 3, "Expected mask to have 3 colors, got {}".format(len(mask))
-		self.mask = mask
+		# self.mask = mask
 		self.mesh = self._create()
 		self.parent = self._nest()
+		self._assign_id()
+		self._triangulate()
 
 	def __copy__(self):
 		m = self.__class__(self.name, scale=self.scale)
@@ -54,12 +75,12 @@ def apply(self, material=None):
 			_material = MaterialFactory().produce()
 		self.mesh.active_material = _material.value
 
-	def connect(self, volume, axis):
-		self._connect(volume, axis)
+	def connect(self, volume, axis, side=0):
+		self._connect(volume, axis, side)
 
-	def mask(self):
-		material = MaterialFactory().produce('mask', color=self.mask)
-		self.mesh.active_material = material.value
+	# def mask(self):
+	# 	material = MaterialFactory().produce('mask', color=self.mask)
+	# 	self.mesh.active_material = material.value
 
 	def position(self, position):
 		assert isinstance(position, list) or isinstance(position, tuple) or \
@@ -77,8 +98,12 @@ def remove(self):
 		with redirect_stdout(stdout), redirect_stderr(stdout):
 			bpy.ops.object.delete()
 
-	def _connect(self, volume, axis):
-		self.connector = self.ModuleConnector(self, volume, axis)
+	def _assign_id(self):
+		self.mesh["inst_id"] = IdAssigner().make(self.name)
+		self.mesh.pass_index = IdAssigner().make(self.name)
+
+	def _connect(self, volume, axis, side):
+		self.connector = self.ModuleConnector(self, volume, axis, side)
 
 	def _create(self):
 		# rule how connects to mesh
@@ -93,13 +118,20 @@ def _nest(self):
 		bpy.data.collections[self.name].objects.link(bpy.data.objects[self.mesh.name])
 		return bpy.data.collections[self.name]
 
+	def _triangulate(self):
+		deselect_all()
+		if self.mesh:
+			select(self.mesh)
+			bpy.ops.object.modifier_add(type='TRIANGULATE')
+			bpy.ops.object.modifier_apply()
+
 	class ModuleConnector(Connector):
-		def __init__(self, module, volume, axis):
-			Connector.__init__(self, module, volume, axis)
+		def __init__(self, module, volume, axis, side):
+			Connector.__init__(self, module, volume, axis, side)
 
 
 class Window(Module):
-	def __init__(self, name='window', scale=(1.5, 0.05, 1.5)):
+	def __init__(self, name: str='window', scale: tuple=(1.5, 0.05, 1.5)):
 		Module.__init__(self, name, scale)
 
 	def _create(self):
@@ -109,13 +141,13 @@ def _create(self):
 		return bpy.context.selected_objects[0]
 
 	class ModuleConnector(Connector):
-		def __init__(self, module, volume, axis):
-			Connector.__init__(self, module, volume, axis)
+		def __init__(self, module: Module, volume, axis: bool, side):
+			Connector.__init__(self, module, volume, axis, side)
 
 		def _connect(self):
 			if self.axis == 0:
-				self.module.mesh.rotation_euler = math.radians(90)
-			gancio(self.volume, self.module, self.axis, 0, 1)
+				self.module.mesh.rotation_euler[2] = math.radians(90)
+			gancio(self.volume, self.module, self.axis, self.side, 1)
 
 
 class ModuleFactory:
@@ -125,11 +157,10 @@ class ModuleFactory:
 	def __init__(self):
 		self.mapping = {'generic': Module,
 		                'window': Window}
-		self.mapping = {x:y for x,y in self.mapping.items() if x in MODULES or x=='generic'}
+		self.mapping = {x: y for x, y in self.mapping.items() if x in MODULES or x == 'generic'}
 		self.mask_colors = list(range(len(self.mapping)))
-		self._mask_colors()
 
-	def produce(self, name):
+	def produce(self, name: str) -> object:
 		"""
 		Function that produces a module based on its name.
 		:param name: name of the module to produce, str, should be in mapping
@@ -141,16 +172,6 @@ def produce(self, name):
 		else:
 			return self.mapping['generic']()
 
-	def _mask_colors(self):
-		if len(self.mask_colors) <= 3:
-			for i in range(len(self.mask_colors)):
-				self.mask_colors[i] = [0.0, 0.0, 0.0]
-				self.mask_colors[i][i] = 1.0
-		else:
-			# Distribute colors around the color circle
-			return NotImplementedError
-
-
 
 class ModuleApplier:
 	def __init__(self, module_type):

dataset/volume.py

@@ -8,7 +8,7 @@
 file_dir = os.path.dirname(__file__)
 sys.path.append(file_dir)
 
-from blender_utils import extrude, gancio, get_min_max
+from blender_utils import *
 from dataset_config import *
 from material import Material
 from module import *
@@ -129,7 +129,10 @@ def create(self):
 		self.mesh = bpy.data.objects[self.name]
 		self._nest()
 		self._extrude()
+		self.mesh["inst_id"] = 1  # instance id for the building envelope
+		self.mesh.pass_index = 1
 		deselect_all()
+		self._triangulate()
 
 	def _extrude(self):
 		"""
@@ -141,10 +144,19 @@ def _extrude(self):
 			extrude(self.mesh, self.height)
 
 	def _nest(self):
-		if not self.name in bpy.data.collections['Building'].objects:
+		names = [x.name for x in bpy.data.collections['Building'].objects]
+		if not self.name in names:
 			bpy.data.collections['Building'].objects.link(
 					bpy.data.objects[self.name])
 
+	def _triangulate(self):
+		deselect_all()
+		if self.mesh:
+			select(self.mesh)
+			bpy.ops.object.modifier_add(type='TRIANGULATE')
+			bpy.ops.object.modifier_apply()
+
+
 
 if __name__ == '__main__':
 	f = CollectionFactory()