ifctrano 0.1.12__py3-none-any.whl → 0.3.0__py3-none-any.whl

ifctrano/bounding_box.py

@@ -1,105 +1,47 @@
+from itertools import combinations
 from logging import getLogger
-from typing import List, Optional, Any, Tuple, cast
+from typing import List, Optional, Any, Tuple
 
 import ifcopenshell
-import numpy as np
-from ifcopenshell import entity_instance
 import ifcopenshell.geom
+import ifcopenshell.util.placement
 import ifcopenshell.util.shape
+import numpy as np
+import open3d  # type: ignore
+from ifcopenshell import entity_instance
 from pydantic import (
     BaseModel,
     Field,
+    ConfigDict,
 )
-from shapely import Polygon  # type: ignore
+from scipy.spatial import ConvexHull  # type: ignore
+from vedo import Line  # type: ignore
 
 from ifctrano.base import (
     Point,
     Vector,
-    P,
-    Sign,
-    CoordinateSystem,
     Vertices,
     BaseModelConfig,
     settings,
     CommonSurface,
     AREA_TOLERANCE,
-    ROUNDING_FACTOR,
+    FaceVertices,
+    BaseShow,
 )
-from ifctrano.exceptions import BoundingBoxFaceError, VectorWithNansError
+from ifctrano.exceptions import VectorWithNansError
 
 logger = getLogger(__name__)
 
 
-def get_normal(
-    centroid: Point,
-    difference: Point,
-    face_signs: List[Sign],
-    coordinate_system: CoordinateSystem,
-) -> Vector:
-    point_0 = centroid + difference.s(face_signs[0])
-    point_1 = centroid + difference.s(face_signs[1])
-    point_2 = centroid + difference.s(face_signs[2])
-    vector_1 = coordinate_system.project((point_1 - point_0).to_array())
-    vector_2 = coordinate_system.project((point_2 - point_0).to_array())
-    array = (
-        (Vector.from_array(vector_1) * Vector.from_array(vector_2)).norm().to_array()
-    )
-    return Vector.from_array(array)
-
-
-class Polygon2D(BaseModelConfig):
-    polygon: Polygon
-    normal: Vector
-    length: float
-
-
 class BoundingBoxFace(BaseModelConfig):
-    vertices: Vertices
+    vertices: FaceVertices
     normal: Vector
-    coordinate_system: CoordinateSystem
 
     @classmethod
-    def build(
-        cls,
-        centroid: Point,
-        difference: Point,
-        face_signs: List[Sign],
-        coordinate_system: CoordinateSystem,
-    ) -> "BoundingBoxFace":
-        if len(face_signs) != len(set(face_signs)):
-            raise BoundingBoxFaceError("Face signs must be unique")
-        normal = get_normal(centroid, difference, face_signs, coordinate_system)
-        vertices_ = [(centroid + difference.s(s)).to_list() for s in face_signs]
-        vertices_ = [*vertices_, vertices_[0]]
-        vertices__ = [coordinate_system.project(v) for v in vertices_]
-        vertices = Vertices.from_arrays(vertices__)
-
-        return cls(
-            vertices=vertices, normal=normal, coordinate_system=coordinate_system
-        )
-
-    def get_face_area(self) -> float:
-        polygon_2d = self.get_2d_polygon(self.coordinate_system)
-        return cast(float, round(polygon_2d.polygon.area, ROUNDING_FACTOR))
+    def build(cls, vertices: Vertices) -> "BoundingBoxFace":
+        face_vertices = vertices.to_face_vertices()
 
-    def get_2d_polygon(self, coordinate_system: CoordinateSystem) -> Polygon2D:
-
-        projected_vertices = coordinate_system.inverse(self.vertices.to_array())
-        projected_normal_index = Vector.from_array(
-            coordinate_system.inverse(self.normal.to_array())
-        ).get_normal_index()
-        polygon = Polygon(
-            [
-                [v_ for i, v_ in enumerate(v) if i != projected_normal_index]
-                for v in projected_vertices.tolist()
-            ]
-        )
-
-        return Polygon2D(
-            polygon=polygon,
-            normal=self.normal,
-            length=projected_vertices.tolist()[0][projected_normal_index],
-        )
+        return cls(vertices=face_vertices, normal=face_vertices.get_normal())
 
 
 class BoundingBoxFaces(BaseModel):
@@ -110,56 +52,51 @@ class BoundingBoxFaces(BaseModel):
 
     @classmethod
     def build(
-        cls, centroid: Point, difference: Point, coordinate_system: CoordinateSystem
+        cls, box_points: np.ndarray[tuple[int, ...], np.dtype[np.float64]]
     ) -> "BoundingBoxFaces":
-        face_signs = [
-            [Sign(x=-1, y=-1, z=-1), Sign(y=-1, z=-1), Sign(z=-1), Sign(x=-1, z=-1)],
-            [Sign(x=-1, y=-1), Sign(y=-1), Sign(), Sign(x=-1)],
-            [
-                Sign(x=-1, y=-1, z=-1),
-                Sign(x=-1, y=1, z=-1),
-                Sign(x=-1, y=1, z=1),
-                Sign(x=-1, y=-1, z=1),
-            ],
-            [
-                Sign(x=1, y=-1, z=-1),
-                Sign(x=1, y=1, z=-1),
-                Sign(x=1, y=1, z=1),
-                Sign(x=1, y=-1, z=1),
-            ],
-            [
-                Sign(x=-1, y=-1, z=-1),
-                Sign(x=1, y=-1, z=-1),
-                Sign(x=1, y=-1, z=1),
-                Sign(x=-1, y=-1, z=1),
-            ],
-            [
-                Sign(x=-1, y=1, z=-1),
-                Sign(x=1, y=1, z=-1),
-                Sign(x=1, y=1, z=1),
-                Sign(x=-1, y=1, z=1),
-            ],
-        ]
         faces = [
-            BoundingBoxFace.build(centroid, difference, face_sign, coordinate_system)
-            for face_sign in face_signs
+            [0, 1, 6, 3],
+            [2, 5, 4, 7],
+            [0, 3, 5, 2],
+            [1, 7, 4, 6],
+            [0, 2, 7, 1],
+            [3, 6, 4, 5],
+        ]
+        faces_ = [
+            BoundingBoxFace.build(Vertices.from_arrays(np.array(box_points)[face]))
+            for face in faces
         ]
-        return cls(faces=faces)
+        return cls(faces=faces_)
 
 
 class ExtendCommonSurface(CommonSurface):
     distance: float
 
     def to_common_surface(self) -> CommonSurface:
-        return CommonSurface(area=self.area, orientation=self.orientation)
+        return CommonSurface(
+            area=self.area,
+            orientation=self.orientation,
+            main_vertices=self.main_vertices,
+            common_vertices=self.common_vertices,
+        )
 
 
-class OrientedBoundingBox(BaseModel):
+class OrientedBoundingBox(BaseShow):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
     faces: BoundingBoxFaces
     centroid: Point
     area_tolerance: float = Field(default=AREA_TOLERANCE)
     volume: float
     height: float
+    entity: Optional[entity_instance] = None
+
+    def lines(self) -> List[Line]:
+        lines = []
+        for f in self.faces.faces:
+            face = f.vertices.to_list()
+            for a, b in combinations(face, 2):
+                lines.append(Line(a, b))
+        return lines
 
     def intersect_faces(self, other: "OrientedBoundingBox") -> Optional[CommonSurface]:
         extend_surfaces = []
@@ -167,27 +104,42 @@ class OrientedBoundingBox(BaseModel):
 
             for other_face in other.faces.faces:
                 vector = face.normal * other_face.normal
-                if vector.is_a_zero():
-                    polygon_1 = other_face.get_2d_polygon(face.coordinate_system)
-                    polygon_2 = face.get_2d_polygon(face.coordinate_system)
-                    intersection = polygon_2.polygon.intersection(polygon_1.polygon)
+                if vector.is_null():
+                    projected_face_1 = face.vertices.project(face.vertices)
+                    projected_face_2 = face.vertices.project(other_face.vertices)
+                    polygon_1 = projected_face_1.to_polygon()
+                    polygon_2 = projected_face_2.to_polygon()
+                    intersection = polygon_2.intersection(polygon_1)
                     if intersection.area > self.area_tolerance:
-                        distance = abs(polygon_1.length - polygon_2.length)
+                        distance = projected_face_1.get_distance(projected_face_2)
                         area = intersection.area
-                        direction_vector = (other.centroid - self.centroid).norm()
                         try:
-                            orientation = direction_vector.project(face.normal).norm()
+                            direction_vector = (
+                                other.centroid - self.centroid
+                            ).normalize()
+                            orientation = direction_vector.project(
+                                face.normal
+                            ).normalize()
                         except VectorWithNansError as e:
-                            logger.error(
-                                "Orientation vector was not properly computed when computing the intersection between"
-                                f"two elements. Error: {e}"
+                            logger.warning(
+                                "Orientation vector was not properly computed when computing the intersection between "
+                                f"two elements "
+                                f"({(self.entity.GlobalId, self.entity.is_a(), self.entity.Name) if self.entity else None}"  # noqa: E501
+                                f", {(other.entity.GlobalId, other.entity.is_a(), other.entity.Name)if other.entity else None}). Error: {e}"  # noqa: E501
                             )
                             continue
                         extend_surfaces.append(
                             ExtendCommonSurface(
-                                distance=distance, area=area, orientation=orientation
+                                distance=distance,
+                                area=area,
+                                orientation=orientation,
+                                main_vertices=face.vertices,
+                                common_vertices=projected_face_1.common_vertices(
+                                    intersection
+                                ),
                             )
                         )
+
         if extend_surfaces:
             if not all(
                 e.orientation == extend_surfaces[0].orientation for e in extend_surfaces
@@ -199,69 +151,47 @@ class OrientedBoundingBox(BaseModel):
                 extend_surfaces, key=lambda x: x.distance, reverse=True
             )[-1]
             return extend_surface.to_common_surface()
+        else:
+            logger.warning(
+                "No common surfaces found between between "
+                f"two elements "
+                f"({(self.entity.GlobalId, self.entity.is_a(), self.entity.Name) if self.entity else None}, "
+                f"{(other.entity.GlobalId, other.entity.is_a(), other.entity.Name) if other.entity else None})."
+            )
         return None
 
     @classmethod
     def from_vertices(
-        cls, vertices: np.ndarray[tuple[int, ...], np.dtype[np.float64]]
+        cls,
+        vertices: np.ndarray[tuple[int, ...], np.dtype[np.float64]],
+        entity: Optional[entity_instance] = None,
     ) -> "OrientedBoundingBox":
-        vertices_np = np.array(vertices)
-        points = np.asarray(vertices_np)
-        cov = np.cov(points, y=None, rowvar=0, bias=0)  # type: ignore
-        v, vect = np.linalg.eig(np.round(cov, ROUNDING_FACTOR))
-        tvect = np.transpose(vect)
-        points_r = np.dot(points, np.linalg.inv(tvect))
-
-        co_min = np.min(points_r, axis=0)
-        co_max = np.max(points_r, axis=0)
-
-        xmin, xmax = co_min[0], co_max[0]
-        ymin, ymax = co_min[1], co_max[1]
-        zmin, zmax = co_min[2], co_max[2]
-
-        x_len = xmax - xmin
-        y_len = ymax - ymin
-        z_len = zmax - zmin
-        xdif = x_len * 0.5
-        ydif = y_len * 0.5
-        zdif = z_len * 0.5
-
-        cx = xmin + xdif
-        cy = ymin + ydif
-        cz = zmin + zdif
-        corners = np.array(
-            [
-                [cx - xdif, cy - ydif, cz - zdif],
-                [cx - xdif, cy + ydif, cz - zdif],
-                [cx - xdif, cy + ydif, cz + zdif],
-                [cx - xdif, cy - ydif, cz + zdif],
-                [cx + xdif, cy + ydif, cz + zdif],
-                [cx + xdif, cy + ydif, cz - zdif],
-                [cx + xdif, cy - ydif, cz + zdif],
-                [cx + xdif, cy - ydif, cz - zdif],
-            ]
+        points_ = open3d.utility.Vector3dVector(vertices)
+        mobb = open3d.geometry.OrientedBoundingBox.create_from_points_minimal(
+            points_, robust=True
         )
-        corners_ = np.dot(corners, tvect)
-        dims = np.transpose(corners_)
-        x_size = np.max(dims[0]) - np.min(dims[0])
-        y_size = np.max(dims[1]) - np.min(dims[1])
-        z_size = np.max(dims[2]) - np.min(dims[2])
-        coordinate_system = CoordinateSystem.from_array(tvect)
-        c = P(x=cx, y=cy, z=cz)
-        d = P(x=xdif, y=ydif, z=zdif)
-        faces = BoundingBoxFaces.build(c, d, coordinate_system)
+        height = (mobb.get_max_bound() - mobb.get_min_bound())[
+            2
+        ]  # assuming that height is the z axis
+        centroid = Point.from_array(mobb.get_center())
+        faces = BoundingBoxFaces.build(np.array(mobb.get_box_points()))
         return cls(
             faces=faces,
-            centroid=Point.from_array(coordinate_system.project(c.to_array())),
-            volume=x_size * y_size * z_size,
-            height=z_size,
+            centroid=centroid,
+            volume=mobb.volume(),
+            height=height,
+            entity=entity,
         )
 
     @classmethod
     def from_entity(cls, entity: entity_instance) -> "OrientedBoundingBox":
         entity_shape = ifcopenshell.geom.create_shape(settings, entity)
-
         vertices = ifcopenshell.util.shape.get_shape_vertices(
             entity_shape, entity_shape.geometry  # type: ignore
         )
-        return cls.from_vertices(vertices)
+        vertices_ = Vertices.from_arrays(np.asarray(vertices))
+        hull = ConvexHull(vertices_.to_array())
+        vertices_ = Vertices.from_arrays(vertices_.to_array()[hull.vertices])
+        points_ = open3d.utility.Vector3dVector(vertices_.to_array())
+        aab = open3d.geometry.AxisAlignedBoundingBox.create_from_points(points_)
+        return cls.from_vertices(aab.get_box_points(), entity)

ifctrano/building.py

@@ -1,6 +1,6 @@
 import re
 from pathlib import Path
-from typing import List, Tuple, Any, Optional
+from typing import List, Tuple, Any, Optional, Set
 
 import ifcopenshell
 from ifcopenshell import file, entity_instance
@@ -9,15 +9,16 @@ from trano.elements import InternalElement  # type: ignore
 from trano.elements.library.library import Library  # type: ignore
 from trano.elements.types import Tilt  # type: ignore
 from trano.topology import Network  # type: ignore
+from vedo import Line  # type: ignore
 
-from ifctrano.base import BaseModelConfig, Libraries, Vector
+from ifctrano.base import BaseModelConfig, Libraries, Vector, BaseShow, CommonSurface
 from ifctrano.exceptions import IfcFileNotFoundError, NoIfcSpaceFoundError
 from ifctrano.space_boundary import (
     SpaceBoundaries,
     initialize_tree,
     Space,
-    construction,
 )
+from ifctrano.construction import Constructions, default_construction
 
 
 def get_spaces(ifcopenshell_file: file) -> List[entity_instance]:
@@ -28,6 +29,7 @@ class IfcInternalElement(BaseModelConfig):
     spaces: List[Space]
     element: entity_instance
     area: float
+    common_surface: CommonSurface
 
     def __hash__(self) -> int:
         return hash(
@@ -49,23 +51,108 @@ class IfcInternalElement(BaseModelConfig):
             self.area,
         )
 
+    def lines(self) -> List[Line]:
+        lines = []
+        if self.common_surface:
+            lines += self.common_surface.lines()
+        return lines
 
-class InternalElements(BaseModelConfig):
+
+class InternalElements(BaseShow):
     elements: List[IfcInternalElement] = Field(default_factory=list)
 
     def internal_element_ids(self) -> List[str]:
         return list({e.element.GlobalId for e in self.elements})
 
-    def description(self) -> List[Tuple[Any, Any, str, float]]:
-        return sorted([element.description() for element in self.elements])
+    def description(self) -> Set[Tuple[Any, Any, str, float]]:
+        return set(  # noqa: C414
+            sorted([element.description() for element in self.elements])
+        )
+
+
+def get_internal_elements(space1_boundaries: List[SpaceBoundaries]) -> InternalElements:
+    elements = []
+    seen = set()
+    common_boundaries = []
+    for space_boundaries_ in space1_boundaries:
+        for space_boundaries__ in space1_boundaries:
+            space_1 = space_boundaries_.space
+            space_2 = space_boundaries__.space
+
+            if (
+                space_1.global_id == space_2.global_id
+                and (space_1.global_id, space_2.global_id) in seen
+            ):
+                continue
+            seen.update(
+                {
+                    (space_1.global_id, space_2.global_id),
+                    (space_2.global_id, space_1.global_id),
+                }
+            )
+            common_surface = space_1.bounding_box.intersect_faces(space_2.bounding_box)
+
+            for boundary in space_boundaries_.boundaries:
+                for boundary_ in space_boundaries__.boundaries:
+                    if (
+                        boundary.entity.GlobalId == boundary_.entity.GlobalId
+                        and boundary.common_surface
+                        and boundary_.common_surface
+                        and common_surface
+                        and (
+                            boundary.common_surface.orientation
+                            * common_surface.orientation
+                        ).is_null()
+                        and (
+                            boundary_.common_surface.orientation
+                            * common_surface.orientation
+                        ).is_null()
+                    ) and boundary.common_surface.orientation.dot(
+                        boundary_.common_surface.orientation
+                    ) < 0:
+                        common_boundaries.extend([boundary, boundary_])
+                        common_surface = sorted(
+                            [boundary.common_surface, boundary_.common_surface],
+                            key=lambda s: s.area,
+                        )[0]
+                        common_surface.exterior = False
+                        elements.append(
+                            IfcInternalElement(
+                                spaces=[space_1, space_2],
+                                element=boundary_.entity,
+                                area=common_surface.area,
+                                common_surface=common_surface,
+                            )
+                        )
+    for space_boundaries_ in space1_boundaries:
+        space_boundaries_.remove(common_boundaries)
+    return InternalElements(elements=list(set(elements)))
 
 
-class Building(BaseModelConfig):
+class Building(BaseShow):
     name: str
     space_boundaries: List[SpaceBoundaries]
     ifc_file: file
     parent_folder: Path
     internal_elements: InternalElements = Field(default_factory=InternalElements)
+    constructions: Constructions
+
+    def get_boundaries(self, space_id: str) -> SpaceBoundaries:
+        return next(
+            sb for sb in self.space_boundaries if sb.space.global_id == space_id
+        )
+
+    def description(self) -> list[list[tuple[float, tuple[float, ...], Any, str]]]:
+        return sorted([sorted(b.description()) for b in self.space_boundaries])
+
+    def lines(self) -> List[Line]:
+        lines = []
+        for space_boundaries_ in [
+            *self.space_boundaries,
+            *self.internal_elements.elements,
+        ]:
+            lines += space_boundaries_.lines()  # type: ignore
+        return lines
 
     @field_validator("name")
     @classmethod
@@ -86,6 +173,7 @@ class Building(BaseModelConfig):
         ifc_file = ifcopenshell.open(str(ifc_file_path))
         tree = initialize_tree(ifc_file)
         spaces = get_spaces(ifc_file)
+        constructions = Constructions.from_ifc(ifc_file)
         if selected_spaces_global_id:
             spaces = [
                 space for space in spaces if space.GlobalId in selected_spaces_global_id
@@ -100,6 +188,7 @@ class Building(BaseModelConfig):
             ifc_file=ifc_file,
             parent_folder=ifc_file_path.parent,
             name=ifc_file_path.stem,
+            constructions=constructions,
         )
 
     @model_validator(mode="after")
@@ -108,58 +197,21 @@ class Building(BaseModelConfig):
         return self
 
     def get_adjacency(self) -> InternalElements:
-        elements = []
-        for space_boundaries_ in self.space_boundaries:
-            for space_boundaries__ in self.space_boundaries:
-                space_1 = space_boundaries_.space
-                space_2 = space_boundaries__.space
-                if space_1.global_id == space_2.global_id:
-                    continue
-                common_surface = space_1.bounding_box.intersect_faces(
-                    space_2.bounding_box
-                )
-                for boundary in space_boundaries_.boundaries:
-                    for boundary_ in space_boundaries__.boundaries:
-                        if (
-                            boundary.entity.GlobalId == boundary_.entity.GlobalId
-                            and boundary.common_surface
-                            and boundary_.common_surface
-                            and common_surface
-                            and (
-                                boundary.common_surface.orientation
-                                * common_surface.orientation
-                            ).is_a_zero()
-                            and (
-                                boundary_.common_surface.orientation
-                                * common_surface.orientation
-                            ).is_a_zero()
-                        ) and boundary.common_surface.orientation.dot(
-                            boundary_.common_surface.orientation
-                        ) < 0:
-                            elements.append(  # noqa: PERF401
-                                IfcInternalElement(
-                                    spaces=[space_1, space_2],
-                                    element=boundary_.entity,
-                                    area=min(
-                                        common_surface.area,
-                                        boundary.common_surface.area,
-                                        boundary_.common_surface.area,
-                                    ),
-                                )
-                            )
-        return InternalElements(elements=list(set(elements)))
+        return get_internal_elements(self.space_boundaries)
 
     @validate_call
-    def create_model(
+    def create_network(
         self,
         library: Libraries = "Buildings",
         north_axis: Optional[Vector] = None,
-    ) -> str:
+    ) -> Network:
         north_axis = north_axis or Vector(x=0, y=1, z=0)
         network = Network(name=self.name, library=Library.from_configuration(library))
         spaces = {
             space_boundary.space.global_id: space_boundary.model(
-                self.internal_elements.internal_element_ids(), north_axis
+                self.internal_elements.internal_element_ids(),
+                north_axis,
+                self.constructions,
             )
             for space_boundary in self.space_boundaries
         }
@@ -173,13 +225,16 @@ class Building(BaseModelConfig):
                 spaces[space_2.global_id],
                 InternalElement(
                     azimuth=10,
-                    construction=construction,
+                    construction=default_construction,
                     surface=internal_element.area,
                     tilt=Tilt.wall,
                 ),
             )
-        return network.model()  # type: ignore
+        return network
+
+    def get_model(self) -> str:
+        return str(self.create_network().model())
 
     def save_model(self, library: Libraries = "Buildings") -> None:
-        model_ = self.create_model(library)
-        Path(self.parent_folder.joinpath(f"{self.name}.mo")).write_text(model_)
+        model_ = self.create_network(library)
+        Path(self.parent_folder.joinpath(f"{self.name}.mo")).write_text(model_.model())