284 lines
7.7 KiB
Python
284 lines
7.7 KiB
Python
"""
|
|
Polyhedron module
|
|
SPDX - License - Identifier: LGPL - 3.0 - or -later
|
|
Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
|
|
"""
|
|
import numpy as np
|
|
from trimesh import Trimesh
|
|
from helpers.geometry_helper import GeometryHelper
|
|
from helpers.configuration_helper import ConfigurationHelper
|
|
from city_model_structure.attributes.surface import Surface
|
|
|
|
|
|
class Polyhedron:
|
|
"""
|
|
Polyhedron class
|
|
"""
|
|
|
|
def __init__(self, surfaces):
|
|
self._surfaces = list(surfaces)
|
|
self._polygons = [s.polygon for s in surfaces]
|
|
self._polyhedron = None
|
|
self._volume = None
|
|
self._faces = None
|
|
self._vertices = None
|
|
self._mesh = None
|
|
self._centroid = None
|
|
self._max_z = None
|
|
self._max_y = None
|
|
self._max_x = None
|
|
self._min_z = None
|
|
self._min_y = None
|
|
self._min_x = None
|
|
self._geometry = GeometryHelper()
|
|
|
|
def _position_of(self, point, face):
|
|
vertices = self.vertices
|
|
for i in range(len(vertices)):
|
|
# ensure not duplicated vertex
|
|
if i not in face and GeometryHelper.distance_between_points(vertices[i], point) == 0:
|
|
return i
|
|
return -1
|
|
|
|
@property
|
|
def vertices(self) -> np.ndarray:
|
|
"""
|
|
Polyhedron vertices
|
|
:return: np.ndarray(int)
|
|
"""
|
|
if self._vertices is None:
|
|
vertices, self._vertices = [], []
|
|
_ = [vertices.extend(s.points) for s in self._surfaces]
|
|
for vertex_1 in vertices:
|
|
found = False
|
|
for vertex_2 in self._vertices:
|
|
found = False
|
|
if GeometryHelper.distance_between_points(vertex_1, vertex_2) == 0:
|
|
found = True
|
|
break
|
|
if not found:
|
|
self._vertices.append(vertex_1)
|
|
self._vertices = np.asarray(self._vertices)
|
|
return self._vertices
|
|
|
|
@staticmethod
|
|
def _point(coordinates):
|
|
return coordinates[0], coordinates[1], coordinates[2]
|
|
|
|
def _triangulate(self, surface):
|
|
print(surface.type)
|
|
triangles = []
|
|
triangles_count = len(surface.points) - 2
|
|
points_list = surface.points_list
|
|
normal = surface.normal
|
|
concave_points = []
|
|
convex_points = []
|
|
# case 1: first point as center ear
|
|
points = ' '.join(str(e) for e in [*points_list[len(points_list) - 3:], *points_list[0:6]])
|
|
triangle = Surface(points, remove_last=False)
|
|
if self._point_is_concave(normal, triangle):
|
|
concave_points.append(points_list[0:3])
|
|
else:
|
|
convex_points.append(points_list[0:3])
|
|
# case 2: all points except first and last
|
|
for i in range(0, int((len(points_list)-6)/3)):
|
|
points = ' '.join(str(e) for e in [*points_list[i*3:(i+3)*3]])
|
|
triangle = Surface(points, remove_last=False)
|
|
if self._point_is_concave(normal, triangle):
|
|
concave_points.append(points_list[(i+1)*3:(i+2)*3])
|
|
else:
|
|
convex_points.append(points_list[(i+1)*3:(i+2)*3])
|
|
# case 3: last point as center ear
|
|
points = ' '.join(str(e) for e in [*points_list[len(points_list) - 6:], *points_list[0:3]])
|
|
triangle = Surface(points, remove_last=False)
|
|
if self._point_is_concave(normal, triangle):
|
|
concave_points.append(points_list[len(points_list) - 3:])
|
|
else:
|
|
convex_points.append(points_list[len(points_list) - 3:])
|
|
# print('point list', points_list)
|
|
print('concave', concave_points)
|
|
print('convex', convex_points)
|
|
|
|
# todo: recursive function, not good solution
|
|
# for point in concave_points:
|
|
# is_ear_point = self._is_ear_point(point)
|
|
# if is_ear_point:
|
|
# ear = self._extract_ear()
|
|
# triangles.append(ear)
|
|
# self._remove_point()
|
|
# continue
|
|
return triangles
|
|
|
|
def _point_is_concave(self, normal, triangle) -> bool:
|
|
is_concave = False
|
|
accepted_error = 0.1
|
|
error_sum = 0
|
|
print('normal', normal)
|
|
print('normal triangle', triangle.normal)
|
|
for i in range(0, len(normal)):
|
|
error_sum += triangle.normal[i] - normal[i]
|
|
if np.abs(error_sum) < accepted_error:
|
|
is_concave = True
|
|
return is_concave
|
|
|
|
@property
|
|
def faces(self) -> [[int]]:
|
|
|
|
"""
|
|
Polyhedron faces
|
|
:return: [[int]]
|
|
"""
|
|
|
|
if self._faces is None:
|
|
self._faces = []
|
|
|
|
for surface in self._surfaces:
|
|
|
|
face = []
|
|
points = surface.points
|
|
if len(points) != 3:
|
|
sub_surfaces = self._triangulate(surface)
|
|
for sub_surface in sub_surfaces:
|
|
face = []
|
|
points = sub_surface.points
|
|
for point in points:
|
|
face.append(self._position_of(point, face))
|
|
self._faces.append(face)
|
|
else:
|
|
for point in points:
|
|
face.append(self._position_of(point, face))
|
|
self._faces.append(face)
|
|
return self._faces
|
|
|
|
@property
|
|
def _polyhedron_mesh(self):
|
|
if self._mesh is None:
|
|
self._mesh = Trimesh(vertices=self.vertices, faces=self.faces)
|
|
return self._mesh
|
|
|
|
@property
|
|
def volume(self):
|
|
"""
|
|
Polyhedron volume in cubic meters
|
|
:return: float
|
|
"""
|
|
if self._volume is None:
|
|
if not self._polyhedron_mesh.is_volume:
|
|
self._volume = np.inf
|
|
else:
|
|
self._volume = self._polyhedron_mesh.volume
|
|
return self._volume
|
|
|
|
@property
|
|
def max_z(self):
|
|
"""
|
|
Polyhedron maximal z value
|
|
:return: float
|
|
"""
|
|
if self._max_z is None:
|
|
self._max_z = ConfigurationHelper().min_coordinate
|
|
for surface in self._surfaces:
|
|
for point in surface.points:
|
|
if self._max_z < point[2]:
|
|
self._max_z = point[2]
|
|
return self._max_z
|
|
|
|
@property
|
|
def max_y(self):
|
|
"""
|
|
Polyhedron maximal y value
|
|
:return: float
|
|
"""
|
|
if self._max_y is None:
|
|
self._max_y = ConfigurationHelper().min_coordinate
|
|
for surface in self._surfaces:
|
|
for point in surface.points:
|
|
if self._max_y < point[1]:
|
|
self._max_y = point[1]
|
|
return self._max_y
|
|
|
|
@property
|
|
def max_x(self):
|
|
"""
|
|
Polyhedron maximal x value
|
|
:return: float
|
|
"""
|
|
if self._max_x is None:
|
|
self._max_x = ConfigurationHelper().min_coordinate
|
|
for surface in self._surfaces:
|
|
for point in surface.points:
|
|
self._max_x = max(self._max_x, point[0])
|
|
return self._max_x
|
|
|
|
@property
|
|
def min_z(self):
|
|
"""
|
|
Polyhedron minimal z value
|
|
:return: float
|
|
"""
|
|
if self._min_z is None:
|
|
self._min_z = self.max_z
|
|
for surface in self._surfaces:
|
|
for point in surface.points:
|
|
if self._min_z > point[2]:
|
|
self._min_z = point[2]
|
|
return self._min_z
|
|
|
|
@property
|
|
def min_y(self):
|
|
"""
|
|
Polyhedron minimal y value
|
|
:return: float
|
|
"""
|
|
if self._min_y is None:
|
|
self._min_y = self.max_y
|
|
for surface in self._surfaces:
|
|
for point in surface.points:
|
|
if self._min_y > point[1]:
|
|
self._min_y = point[1]
|
|
return self._min_y
|
|
|
|
@property
|
|
def min_x(self):
|
|
"""
|
|
Polyhedron minimal x value
|
|
:return: float
|
|
"""
|
|
if self._min_x is None:
|
|
self._min_x = self.max_x
|
|
for surface in self._surfaces:
|
|
for point in surface.points:
|
|
if self._min_x > point[0]:
|
|
self._min_x = point[0]
|
|
return self._min_x
|
|
|
|
@property
|
|
def center(self):
|
|
"""
|
|
Polyhedron centroid
|
|
:return: [x,y,z]
|
|
"""
|
|
x = (self.max_x + self.min_x) / 2
|
|
y = (self.max_y + self.min_y) / 2
|
|
z = (self.max_z + self.min_z) / 2
|
|
return [x, y, z]
|
|
|
|
def stl_export(self, full_path):
|
|
"""
|
|
Export the polyhedron to stl given file
|
|
:param full_path: str
|
|
:return: None
|
|
"""
|
|
self._polyhedron_mesh.export(full_path, 'stl_ascii')
|
|
|
|
def obj_export(self, full_path):
|
|
"""
|
|
Export the polyhedron to obj given file
|
|
:param full_path: str
|
|
:return: None
|
|
"""
|
|
self._polyhedron_mesh.export(full_path, 'obj')
|
|
|
|
def show(self):
|
|
self._polyhedron_mesh.show()
|