system_assignation/city_model_structure/polyhedron.py

"""
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 helpers.geometry_helper import GeometryHelper
from trimesh import Trimesh


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._geometry = GeometryHelper()

  def _position_of(self, point):
    vertices = self.vertices
    for i in range(len(vertices)):
      if self._geometry.almost_equal(vertices[i], point):
        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 self._geometry.almost_equal(vertex_1, vertex_2):
            found = True
            break
        if not found:
          self._vertices.append(vertex_1)
      self._vertices = np.asarray(self._vertices)
    return self._vertices

  @property
  def faces(self) -> np.ndarray:
    """
    Polyhedron faces
    :return: np.ndarray([int])
    """
    if self._faces is None:
      self._faces = []
      for surface in self._surfaces:
        face = []
        points = surface.points
        for point in points:
          face.append(self._position_of(point))
        self._faces.append(face)
      self._faces = np.asarray(self._faces)
    return self._faces

  @property
  def _polyhedron_mesh(self):
    if self._mesh is None:
      self._mesh = Trimesh(vertices=np.asarray(self.vertices), faces=np.asarray(self.faces))
      if not self._mesh.is_volume:
        print('The geometry is not a closed volume')
        return None
    return self._mesh

  @property
  def volume(self):
    """
    Polyhedron volume in cubic meters
    :return: float
    """
    if self._volume is None:
      self._volume = self._polyhedron_mesh.volume
    return self._volume

  @property
  def max_z(self):
    """
    Polyhedron maximal z value
    :return: float
    """
    bounds = self._polyhedron_mesh.bounds
    z_max = max(bounds[:, 2])
    print(z_max)
    return z_max

  def save(self, full_path):
    """
    Export the polyhedron to stl given file
    :param full_path: str
    :return: None
    """
    self._polyhedron_mesh.save(full_path)