diff --git a/src/ifcopenshell-python/ifcopenshell/api/geometry/add_window_representation.py b/src/ifcopenshell-python/ifcopenshell/api/geometry/add_window_representation.py index 73a9c255a2..424d90da23 100644 --- a/src/ifcopenshell-python/ifcopenshell/api/geometry/add_window_representation.py +++ b/src/ifcopenshell-python/ifcopenshell/api/geometry/add_window_representation.py @@ -17,13 +17,12 @@ # along with IfcOpenShell. If not, see . from __future__ import annotations -import collections.abc -import ifcopenshell.util.unit -from ifcopenshell.util.shape_builder import ShapeBuilder, V -from itertools import chain -from mathutils import Vector +import numpy as np import dataclasses -from typing import Any, Optional, Literal, Union +import ifcopenshell.util.unit +from itertools import chain +from ifcopenshell.util.shape_builder import ShapeBuilder, V +from typing import Any, Optional, Literal, Union, overload # SCHEMAS describe panels setup @@ -32,6 +31,18 @@ from typing import Any, Optional, Literal, Union # - schema columns represent window Y axis # - order of rows is from top of the window to bottom +WINDOW_TYPE = Literal[ + "SINGLE_PANEL", + "DOUBLE_PANEL_HORIZONTAL", + "DOUBLE_PANEL_VERTICAL", + "TRIPLE_PANEL_BOTTOM", + "TRIPLE_PANEL_HORIZONTAL", + "TRIPLE_PANEL_LEFT", + "TRIPLE_PANEL_RIGHT", + "TRIPLE_PANEL_TOP", + "TRIPLE_PANEL_VERTICAL", +] + DEFAULT_PANEL_SCHEMAS = { "SINGLE_PANEL": [[0]], "DOUBLE_PANEL_HORIZONTAL": [[0], [1]], @@ -51,28 +62,32 @@ def mm(x: float) -> float: def create_ifc_window_frame_simple( - builder: ShapeBuilder, size: Vector, thickness: list, position: Vector = V(0, 0, 0).freeze() -): + builder: ShapeBuilder, size: np.ndarray, thickness: Union[list[float], float], position: Optional[np.ndarray] = None +) -> list[ifcopenshell.entity_instance]: """`thickness` of the profile is defined as list in the following order: `(LEFT, TOP, RIGHT, BOTTOM)` `thickness` can be also defined just as 1 float value. """ - if not isinstance(thickness, collections.abc.Iterable): + if not isinstance(thickness, list): thickness = [thickness] * 4 + if position is None: + position = np.zeros(3) + np_X, np_Y, np_Z = 0, 1, 2 + np_XZ = [0, 2] th_left, th_up, th_right, th_bottom = thickness - def get_extruded_profile(profile): - return builder.extrude(profile, size.y, position=position, **builder.extrude_kwargs("Y")) + def get_extruded_profile(profile: ifcopenshell.entity_instance): + return builder.extrude(profile, size[np_Y], position=position, **builder.extrude_kwargs("Y")) # if all lining sides are present then we can just use two rectangles # as inner and outer curves of the profile if thickness.count(0) == 0: - panel_rect = builder.rectangle(size=size.xz) + panel_rect = builder.rectangle(size=size[np_XZ]) - inner_rect_size = size - V(th_left + th_right, 0, th_bottom + th_up) - inner_rect = builder.rectangle(size=inner_rect_size.xz, position=V(th_left, th_bottom)) + inner_rect_size = size - (th_left + th_right, 0, th_bottom + th_up) + inner_rect = builder.rectangle(size=inner_rect_size[np_XZ], position=(th_left, th_bottom)) panel_profile = builder.profile(panel_rect, inner_curves=inner_rect) return [get_extruded_profile(panel_profile)] @@ -81,12 +96,12 @@ def create_ifc_window_frame_simple( # and need to generate L/U shape or just separate rectangles else: - def get_segments_from_thickness(): + def get_segments_from_thickness() -> list[tuple[float, ...]]: nonlocal thickness segments = [] cur_segment = [] - for i, thickness in enumerate(thickness): - if thickness == 0: + for i, thickness_ in enumerate(thickness): + if thickness_ == 0: if cur_segment: segments.append(tuple(cur_segment)) cur_segment = [] @@ -103,20 +118,20 @@ def create_ifc_window_frame_simple( # prepare coords to build a lining # fmt: off outer_coords = [ - (V(0, 0), V(0, size.z)), - (V(0, size.z), V(size.x, size.z)), - (V(size.x, size.z), V(size.x, 0)), - (V(size.x, 0), V(0, 0)), + ((0, 0), (0, size[np_Z])), + ((0, size[np_Z]), (size[np_X], size[np_Z])), + ((size[np_X], size[np_Z]), (size[np_X], 0)), + ((size[np_X], 0), (0, 0)), ] inner_coords = [ - (V(th_left, th_bottom), V(th_left, size.z - th_up)), - (V(th_left, size.z - th_up), V(size.x - th_right, size.z - th_up)), - (V(size.x - th_right, size.z - th_up), V(size.x - th_right, th_bottom)), - (V(size.x - th_right, th_bottom), V(th_left, th_bottom)), + ((th_left, th_bottom), (th_left, size[np_Z] - th_up)), + ((th_left, size[np_Z] - th_up), (size[np_X] - th_right, size[np_Z] - th_up)), + ((size[np_X] - th_right, size[np_Z] - th_up), (size[np_X] - th_right, th_bottom)), + ((size[np_X] - th_right, th_bottom), (th_left, th_bottom)), ] # fmt: on - def get_points(segment): + def get_points(segment: tuple[float, ...]) -> list[tuple[float, float]]: points = [] for side in segment: outer = outer_coords[side] @@ -132,7 +147,7 @@ def create_ifc_window_frame_simple( return points segments = get_segments_from_thickness() - segments_items = [] + segments_items: list[ifcopenshell.entity_instance] = [] for seg in segments: polyline = builder.polyline(points=get_points(seg), closed=True) panel_profile = builder.profile(polyline) @@ -142,11 +157,11 @@ def create_ifc_window_frame_simple( def window_l_shape_check( - lining_to_panel_offset_y_full, - lining_depth, - lining_to_panel_offset_x: list, - lining_thickness: list, -): + lining_to_panel_offset_y_full: float, + lining_depth: float, + lining_to_panel_offset_x: list[float], + lining_thickness: list[float], +) -> bool: """`lining_thickness` and `lining_to_panel_offset_x` expected to be defined as a list, similarly to `create_ifc_window_frame_simple` `thickness` argument""" l_shape_check = lining_to_panel_offset_y_full < lining_depth and any( @@ -156,39 +171,41 @@ def window_l_shape_check( def create_ifc_window( - builder, - lining_size: Vector, - lining_thickness: list, - lining_to_panel_offset_x, - lining_to_panel_offset_y_full, - frame_size: Vector, - frame_thickness, - glass_thickness, - position: Vector, - x_offsets: list = None, -): + builder: ShapeBuilder, + lining_size: np.ndarray, + lining_thickness: list[float], + lining_to_panel_offset_x: float, + lining_to_panel_offset_y_full: float, + frame_size: np.ndarray, + frame_thickness: float, + glass_thickness: float, + position: np.ndarray, + x_offsets: Optional[list[float]] = None, +) -> tuple[list[ifcopenshell.entity_instance], list[ifcopenshell.entity_instance], list[ifcopenshell.entity_instance]]: """`lining_thickness` and `x_offsets` are expected to be defined as a list, similarly to `create_ifc_window_frame_simple` `thickness` argument""" - lining_items = [] + lining_items: list[ifcopenshell.entity_instance] = [] main_lining_size = lining_size + np_Y = 1 + if x_offsets is None: x_offsets = [lining_to_panel_offset_x] * 4 # need to check offsets to decide whether lining should be rectangle # or L shaped l_shape_check = window_l_shape_check( lining_to_panel_offset_y_full, - lining_size.y, + lining_size[np_Y], x_offsets, lining_thickness, ) if l_shape_check: main_lining_size = lining_size.copy() - main_lining_size.y = lining_to_panel_offset_y_full + main_lining_size[np_Y] = lining_to_panel_offset_y_full second_lining_size = lining_size.copy() - second_lining_size.y = lining_size.y - lining_to_panel_offset_y_full + second_lining_size[np_Y] = lining_size[np_Y] - lining_to_panel_offset_y_full second_lining_position = V(0, lining_to_panel_offset_y_full, 0) second_lining_thickness = [min(th, x_offset) for th, x_offset in zip(lining_thickness, x_offsets, strict=True)] @@ -208,11 +225,11 @@ def create_ifc_window( frame_extruded_items = create_ifc_window_frame_simple(builder, frame_size, frame_thickness, frame_position) - glass_position = frame_position + V(0, frame_size.y / 2 - glass_thickness / 2, 0) + glass_position = frame_position + V(0, frame_size[np_Y] / 2 - glass_thickness / 2, 0) glass_rect = builder.deep_copy(frame_extruded_items[0].SweptArea.InnerCurves[0]) glass = builder.extrude(glass_rect, glass_thickness, position=glass_position, **builder.extrude_kwargs("Y")) - output_items = [lining_items, frame_extruded_items, [glass]] + output_items = (lining_items, frame_extruded_items, [glass]) builder.translate(chain(*output_items), position) return output_items @@ -343,17 +360,7 @@ def add_window_representation( context: ifcopenshell.entity_instance, overall_height: Optional[float] = None, overall_width: Optional[float] = None, - partition_type: Literal[ - "SINGLE_PANEL", - "DOUBLE_PANEL_HORIZONTAL", - "DOUBLE_PANEL_VERTICAL", - "TRIPLE_PANEL_BOTTOM", - "TRIPLE_PANEL_HORIZONTAL", - "TRIPLE_PANEL_LEFT", - "TRIPLE_PANEL_RIGHT", - "TRIPLE_PANEL_TOP", - "TRIPLE_PANEL_VERTICAL", - ] = "SINGLE_PANEL", + partition_type: WINDOW_TYPE = "SINGLE_PANEL", lining_properties: Optional[Union[WindowLiningProperties, dict[str, Any]]] = None, panel_properties: Optional[list[Union[WindowPanelProperties, dict[str, Any]]]] = None, unit_scale: Optional[float] = None, @@ -361,26 +368,17 @@ def add_window_representation( """units in usecase_settings expected to be in ifc project units :param context: IfcGeometricRepresentationContext for the representation. - :type context: ifcopenshell.entity_instance :param overall_height: Overall window height. Defaults to 0.9m. - :type overall_height: float, optional :param overall_width: Overall window width. Defaults to 0.6m. - :type overall_width: float, optional :param partition_type: Type of the window. Defaults to SINGLE_PANEL. - :type partition_type: str, optional :param lining_properties: WindowLiningProperties or a dictionary to create one. See WindowLiningProperties description for details. - :type lining_properties: Union[WindowLiningProperties, dict[str, Any]]] :param panel_properties: A list of WindowPanelProperties or dictionaries to create one. See WindowPanelProperties description for details. - :type panel_properties: list[Union[WindowPanelProperties, dict[str, Any]]]] :param unit_scale: The unit scale as calculated by ifcopenshell.util.unit.calculate_unit_scale. If not provided, it will be automatically calculated for you. - :type unit_scale: float, optional :return: IfcShapeRepresentation for a window. - :rtype: ifcopenshell.entity_instance - """ usecase = Usecase() usecase.file = file @@ -428,49 +426,50 @@ def add_window_representation( class Usecase: def execute(self): builder = ShapeBuilder(self.file) - overall_height = self.settings["overall_height"] - overall_width = self.settings["overall_width"] + np_X, np_Y, np_Z = 0, 1, 2 + overall_height: float = self.settings["overall_height"] + overall_width: float = self.settings["overall_width"] if self.settings["context"].TargetView == "ELEVATION_VIEW": rect = builder.rectangle(V(overall_width, 0, overall_height)) representation_evelevation = builder.get_representation(self.settings["context"], rect) return representation_evelevation - panel_schema = self.settings["panel_schema"] - panels = self.settings["panel_properties"] + panel_schema: list[list[int]] = self.settings["panel_schema"] + panels: list[dict[str, Any]] = self.settings["panel_properties"] accumulated_height = [0] * len(panel_schema[0]) - built_panels = [] - window_items = [] + built_panels: list[int] = [] + window_items: list[ifcopenshell.entity_instance] = [] - lining_props = self.settings["lining_properties"] - lining_thickness = lining_props["LiningThickness"] - lining_depth = lining_props["LiningDepth"] - lining_offset = lining_props["LiningOffset"] - lining_to_panel_offset_x = lining_props["LiningToPanelOffsetX"] - lining_to_panel_offset_y = lining_props["LiningToPanelOffsetY"] - overall_depth = lining_depth + lining_to_panel_offset_y + lining_props: dict[str, Any] = self.settings["lining_properties"] + lining_thickness: float = lining_props["LiningThickness"] + lining_depth: float = lining_props["LiningDepth"] + lining_offset: float = lining_props["LiningOffset"] + lining_to_panel_offset_x: float = lining_props["LiningToPanelOffsetX"] + lining_to_panel_offset_y: float = lining_props["LiningToPanelOffsetY"] + overall_depth: float = lining_depth + lining_to_panel_offset_y - mullion_thickness = lining_props["MullionThickness"] / 2 - first_mullion_offset = lining_props["FirstMullionOffset"] - second_mullion_offset = lining_props["SecondMullionOffset"] - transom_thickness = lining_props["TransomThickness"] / 2 - first_transom_offset = lining_props["FirstTransomOffset"] - second_transom_offset = lining_props["SecondTransomOffset"] - glass_thickness = self.convert_si_to_unit(0.01) + mullion_thickness: float = lining_props["MullionThickness"] / 2 + first_mullion_offset: float = lining_props["FirstMullionOffset"] + second_mullion_offset: flaot = lining_props["SecondMullionOffset"] + transom_thickness: float = lining_props["TransomThickness"] / 2 + first_transom_offset: float = lining_props["FirstTransomOffset"] + second_transom_offset: float = lining_props["SecondTransomOffset"] + glass_thickness: float = self.convert_si_to_unit(0.01) panel_schema = list(reversed(panel_schema)) # create 2d representation - def create_ifc_window_2d_representation(): - items_2d = [] + def create_ifc_window_2d_representation() -> ifcopenshell.entity_instance: + items_2d: list[ifcopenshell.entity_instance] = [] top_row = panel_schema[-1] unique_cols = len(set(top_row)) - built_panels = [] - accumulated_width = 0 + built_panels: list[int] = [] + accumulated_width: float = 0 for column_i, panel_i in enumerate(top_row): - cur_panel_items = [] + cur_panel_items: list[ifcopenshell.entity_instance] = [] # lists represent left and right linings window_lining_thickness = [lining_thickness] * 2 @@ -504,8 +503,8 @@ class Usecase: else: panel_width = overall_width - frame_depth = panels[panel_i]["FrameDepth"] - frame_thickness = panels[panel_i]["FrameThickness"] + frame_depth: float = panels[panel_i]["FrameDepth"] + frame_thickness: float = panels[panel_i]["FrameThickness"] lining_to_panel_offset_y_full = (lining_depth - frame_depth) + lining_to_panel_offset_y base_frame_clear = lining_to_panel_offset_x + frame_thickness - lining_thickness current_offset_x = base_frame_clear - frame_thickness + mullion_thickness @@ -514,13 +513,15 @@ class Usecase: cur_panel_items.append( builder.polyline( [ - V(window_lining_thickness[0], 0), - V(panel_width - window_lining_thickness[1], 0), + (window_lining_thickness[0], 0), + (panel_width - window_lining_thickness[1], 0), ] ) ) - def get_lining_shape(lining_thickness, closed=True, mirror=False, x_offset=None): + def get_lining_shape( + lining_thickness: float, closed: bool = True, mirror: bool = False, x_offset: Optional[float] = None + ) -> ifcopenshell.entity_instance: if x_offset is None: x_offset = lining_to_panel_offset_x l_shape_check = window_l_shape_check( @@ -532,25 +533,22 @@ class Usecase: if l_shape_check: lining_shape = builder.polyline( [ - V(0, lining_depth), - V(x_offset, lining_depth), - V( - x_offset, - lining_to_panel_offset_y_full, - ), - V(lining_thickness, lining_to_panel_offset_y_full), - V(lining_thickness, 0), - V(0, 0), + (0, lining_depth), + (x_offset, lining_depth), + (x_offset, lining_to_panel_offset_y_full), + (lining_thickness, lining_to_panel_offset_y_full), + (lining_thickness, 0), + (0, 0), ], closed=closed, ) else: lining_shape = builder.polyline( [ - V(0, lining_depth), - V(lining_thickness, lining_depth), - V(lining_thickness, 0), - V(0, 0), + (0, lining_depth), + (lining_thickness, lining_depth), + (lining_thickness, 0), + (0, 0), ], closed=closed, ) @@ -558,8 +556,8 @@ class Usecase: if mirror: builder.mirror( lining_shape, - mirror_axes=V(1, 0), - mirror_point=V(panel_width / 2, 0), + mirror_axes=(1, 0), + mirror_point=(panel_width / 2, 0), ) return lining_shape @@ -581,9 +579,9 @@ class Usecase: ) # add frame - frame_items = [] + frame_items: list[ifcopenshell.entity_instance] = [] - frame_position = V( + frame_position = ( current_offset_x if right_to_mullion else lining_to_panel_offset_x, lining_to_panel_offset_y_full, ) @@ -592,39 +590,39 @@ class Usecase: frame_width -= current_offset_x if left_to_mullion else lining_to_panel_offset_x frame_width -= current_offset_x if right_to_mullion else lining_to_panel_offset_x - frame_vertical = builder.rectangle(size=V(frame_thickness, frame_depth)) + frame_vertical = builder.rectangle(size=(frame_thickness, frame_depth)) frame_items.extend( [ frame_vertical, builder.mirror( frame_vertical, - mirror_axes=V(1, 0), - mirror_point=V(frame_width / 2, 0), + mirror_axes=(1, 0), + mirror_point=(frame_width / 2, 0), create_copy=True, ), ] ) - frame_horizontal = builder.polyline([V(frame_thickness, 0), V(frame_width - frame_thickness, 0)]) + frame_horizontal = builder.polyline([(frame_thickness, 0), (frame_width - frame_thickness, 0)]) frame_items.extend( [ frame_horizontal, - builder.translate(frame_horizontal, V(0, frame_depth), create_copy=True), + builder.translate(frame_horizontal, (0, frame_depth), create_copy=True), ] ) # glass - frame_items.append(builder.translate(frame_horizontal, V(0, frame_depth / 2), create_copy=True)) + frame_items.append(builder.translate(frame_horizontal, (0, frame_depth / 2), create_copy=True)) builder.translate(frame_items, frame_position) cur_panel_items.extend(frame_items) - builder.translate(cur_panel_items, V(accumulated_width, 0)) + builder.translate(cur_panel_items, (accumulated_width, 0)) accumulated_width += panel_width built_panels.append(panel_i) items_2d.extend(cur_panel_items) - builder.translate(items_2d, V(0, lining_offset)) + builder.translate(items_2d, (0, lining_offset)) representation_2d = builder.get_representation(self.settings["context"], items_2d) return representation_2d @@ -711,9 +709,8 @@ class Usecase: window_lining_size = V(panel_width, lining_depth, panel_height) frame_size = window_lining_size.copy() - frame_size.y = frame_depth - frame_size.x -= x_offsets[0] + x_offsets[2] - frame_size.z -= x_offsets[1] + x_offsets[3] + frame_size[np_Y] = frame_depth + frame_size[np_X] -= x_offsets[0] + x_offsets[2] window_panel_position = V(accumulated_width, 0, accumulated_height[column_i]) # create window panel @@ -735,9 +732,14 @@ class Usecase: accumulated_height[column_i] += panel_height accumulated_width += panel_width - builder.translate(window_items, V(0, lining_offset, 0)) # wall offset + builder.translate(window_items, (0, lining_offset, 0)) # wall offset representation = builder.get_representation(self.settings["context"], window_items) return representation - def convert_si_to_unit(self, value): - return value / self.settings["unit_scale"] + @overload + def convert_si_to_unit(self, value: float) -> float: ... + @overload + def convert_si_to_unit(self, value: np.ndarray) -> np.ndarray: ... + def convert_si_to_unit(self, value: Union[float, np.ndarray]) -> Union[float, np.ndarray]: + si_conversion = 1 / self.settings["unit_scale"] + return value * si_conversion