ifctrano 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

ifctrano/base.py

@@ -3,11 +3,15 @@ from typing import Tuple, Literal, List, Annotated, Sequence
 import ifcopenshell.geom
 import numpy as np
 from numpy import ndarray
-from pydantic import BaseModel, BeforeValidator, ConfigDict
+from pydantic import BaseModel, BeforeValidator, ConfigDict, model_validator
+
+from ifctrano.exceptions import VectorWithNansError
 
 settings = ifcopenshell.geom.settings()  # type: ignore
 Coordinate = Literal["x", "y", "z"]
 AREA_TOLERANCE = 0.5
+ROUNDING_FACTOR = 5
+CLASH_CLEARANCE = 0.5
 
 
 class BaseModelConfig(BaseModel):
@@ -60,6 +64,13 @@ class Sign(BaseModel):
 
 
 class Vector(BasePoint):
+
+    @model_validator(mode="after")
+    def _validator(self) -> "Vector":
+        if any(np.isnan(v) for v in self.to_list()):
+            raise VectorWithNansError("Vector cannot have NaN values")
+        return self
+
     def __mul__(self, other: "Vector") -> "Vector":
 
         array = np.cross(self.to_array(), other.to_array())
@@ -68,6 +79,15 @@ class Vector(BasePoint):
     def dot(self, other: "Vector") -> float:
         return np.dot(self.to_array(), other.to_array())  # type: ignore
 
+    def angle(self, other: "Vector") -> int:
+        dot_product = np.dot(self.to_xy(), other.to_xy())
+        cross_product = np.cross(self.to_xy(), other.to_xy())
+        angle_rad = np.arctan2(cross_product, dot_product)
+        angle_deg = np.degrees(angle_rad)
+        if angle_deg < 0:
+            angle_deg += 360
+        return int(angle_deg)
+
     def project(self, other: "Vector") -> "Vector":
         a = self.dot(other) / other.dot(other)
         return Vector(x=a * other.x, y=a * other.y, z=a * other.z)
@@ -81,6 +101,9 @@ class Vector(BasePoint):
     def to_array(self) -> np.ndarray:  # type: ignore
         return np.array([self.x, self.y, self.z])
 
+    def to_xy(self) -> np.ndarray:  # type: ignore
+        return np.array([self.x, self.y])
+
     def get_normal_index(self) -> int:
         normal_index_list = [abs(v) for v in self.to_list()]
         return normal_index_list.index(max(normal_index_list))

ifctrano/bounding_box.py

@@ -1,5 +1,5 @@
 from logging import getLogger
-from typing import List, Optional, Any, Tuple
+from typing import List, Optional, Any, Tuple, cast
 
 import ifcopenshell
 import numpy as np
@@ -23,8 +23,9 @@ from ifctrano.base import (
     settings,
     CommonSurface,
     AREA_TOLERANCE,
+    ROUNDING_FACTOR,
 )
-from ifctrano.exceptions import BoundingBoxFaceError
+from ifctrano.exceptions import BoundingBoxFaceError, VectorWithNansError
 
 logger = getLogger(__name__)
 
@@ -77,7 +78,12 @@ class BoundingBoxFace(BaseModelConfig):
             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 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())
@@ -152,6 +158,8 @@ class OrientedBoundingBox(BaseModel):
     faces: BoundingBoxFaces
     centroid: Point
     area_tolerance: float = Field(default=AREA_TOLERANCE)
+    volume: float
+    height: float
 
     def intersect_faces(self, other: "OrientedBoundingBox") -> Optional[CommonSurface]:
         extend_surfaces = []
@@ -160,16 +168,21 @@ 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 intersection.area > self.area_tolerance:
                         distance = abs(polygon_1.length - polygon_2.length)
                         area = intersection.area
                         direction_vector = (other.centroid - self.centroid).norm()
-                        orientation = direction_vector.project(face.normal).norm()
+                        try:
+                            orientation = direction_vector.project(face.normal).norm()
+                        except VectorWithNansError as e:
+                            logger.error(
+                                "Orientation vector was not properly computed when computing the intersection between"
+                                f"two elements. Error: {e}"
+                            )
+                            continue
                         extend_surfaces.append(
                             ExtendCommonSurface(
                                 distance=distance, area=area, orientation=orientation
@@ -194,8 +207,8 @@ class OrientedBoundingBox(BaseModel):
     ) -> "OrientedBoundingBox":
         vertices_np = np.array(vertices)
         points = np.asarray(vertices_np)
-        cov = np.cov(points, y=None, rowvar=0, bias=1)  # type: ignore
-        v, vect = np.linalg.eig(cov)
+        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))
 
@@ -206,9 +219,12 @@ class OrientedBoundingBox(BaseModel):
         ymin, ymax = co_min[1], co_max[1]
         zmin, zmax = co_min[2], co_max[2]
 
-        xdif = (xmax - xmin) * 0.5
-        ydif = (ymax - ymin) * 0.5
-        zdif = (zmax - zmin) * 0.5
+        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
@@ -225,7 +241,11 @@ class OrientedBoundingBox(BaseModel):
                 [cx + xdif, cy - ydif, cz - zdif],
             ]
         )
-        corners = np.dot(corners, tvect)
+        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)
@@ -233,6 +253,8 @@ class OrientedBoundingBox(BaseModel):
         return cls(
             faces=faces,
             centroid=Point.from_array(coordinate_system.project(c.to_array())),
+            volume=x_size * y_size * z_size,
+            height=z_size,
         )
 
     @classmethod

ifctrano/building.py

@@ -1,30 +1,84 @@
+import re
 from pathlib import Path
-from typing import List
+from typing import List, Tuple, Any, Optional
 
 import ifcopenshell
 from ifcopenshell import file, entity_instance
-from pydantic import validate_call
+from pydantic import validate_call, Field, model_validator, field_validator
+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 ifctrano.base import BaseModelConfig, Libraries
-from ifctrano.exceptions import IfcFileNotFoundError
-from ifctrano.space_boundary import SpaceBoundaries, initialize_tree
+from ifctrano.base import BaseModelConfig, Libraries, Vector
+from ifctrano.exceptions import IfcFileNotFoundError, NoIfcSpaceFoundError
+from ifctrano.space_boundary import (
+    SpaceBoundaries,
+    initialize_tree,
+    Space,
+    construction,
+)
 
 
 def get_spaces(ifcopenshell_file: file) -> List[entity_instance]:
     return ifcopenshell_file.by_type("IfcSpace")
 
 
+class IfcInternalElement(BaseModelConfig):
+    spaces: List[Space]
+    element: entity_instance
+    area: float
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                *sorted([space.global_id for space in self.spaces]),
+                self.element.GlobalId,
+                self.area,
+            )
+        )
+
+    def __eq__(self, other: "IfcInternalElement") -> bool:  # type: ignore
+        return hash(self) == hash(other)
+
+    def description(self) -> Tuple[Any, Any, str, float]:
+        return (
+            *sorted([space.global_id for space in self.spaces]),
+            self.element.GlobalId,
+            self.element.is_a(),
+            self.area,
+        )
+
+
+class InternalElements(BaseModelConfig):
+    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])
+
+
 class Building(BaseModelConfig):
     name: str
     space_boundaries: List[SpaceBoundaries]
     ifc_file: file
     parent_folder: Path
+    internal_elements: InternalElements = Field(default_factory=InternalElements)
+
+    @field_validator("name")
+    @classmethod
+    def _name_validator(cls, name: str) -> str:
+        name = name.replace(" ", "_")
+        name = re.sub(r"[^a-zA-Z0-9_]", "", name)
+        return name.lower()
 
     @classmethod
-    def from_ifc(cls, ifc_file_path: Path) -> "Building":
+    def from_ifc(
+        cls, ifc_file_path: Path, selected_spaces_global_id: Optional[List[str]] = None
+    ) -> "Building":
+        selected_spaces_global_id = selected_spaces_global_id or []
         if not ifc_file_path.exists():
             raise IfcFileNotFoundError(
                 f"File specified {ifc_file_path} does not exist."
@@ -32,6 +86,12 @@ class Building(BaseModelConfig):
         ifc_file = ifcopenshell.open(str(ifc_file_path))
         tree = initialize_tree(ifc_file)
         spaces = get_spaces(ifc_file)
+        if selected_spaces_global_id:
+            spaces = [
+                space for space in spaces if space.GlobalId in selected_spaces_global_id
+            ]
+        if not spaces:
+            raise NoIfcSpaceFoundError("No IfcSpace found in the file.")
         space_boundaries = [
             SpaceBoundaries.from_space_entity(ifc_file, tree, space) for space in spaces
         ]
@@ -42,12 +102,82 @@ class Building(BaseModelConfig):
             name=ifc_file_path.stem,
         )
 
+    @model_validator(mode="after")
+    def _validator(self) -> "Building":
+        self.internal_elements = self.get_adjacency()
+        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)))
+
     @validate_call
-    def create_model(self, library: Libraries = "Buildings") -> str:
+    def create_model(
+        self,
+        library: Libraries = "Buildings",
+        north_axis: Optional[Vector] = None,
+    ) -> str:
+        north_axis = north_axis or Vector(x=0, y=1, z=0)
         network = Network(name=self.name, library=Library.from_configuration(library))
-        network.add_boiler_plate_spaces(
-            [space_boundary.model() for space_boundary in self.space_boundaries]
-        )
+        spaces = {
+            space_boundary.space.global_id: space_boundary.model(
+                self.internal_elements.internal_element_ids(), north_axis
+            )
+            for space_boundary in self.space_boundaries
+        }
+        spaces = {k: v for k, v in spaces.items() if v}
+        network.add_boiler_plate_spaces(list(spaces.values()), create_internal=False)
+        for internal_element in self.internal_elements.elements:
+            space_1 = internal_element.spaces[0]
+            space_2 = internal_element.spaces[1]
+            network.connect_spaces(
+                spaces[space_1.global_id],
+                spaces[space_2.global_id],
+                InternalElement(
+                    azimuth=10,
+                    construction=construction,
+                    surface=internal_element.area,
+                    tilt=Tilt.wall,
+                ),
+            )
         return network.model()  # type: ignore
 
     def save_model(self, library: Libraries = "Buildings") -> None: