Glassvision/IfcOpenShell
1
0
Fork 0
mirror of https://github.com/IfcOpenShell/IfcOpenShell.git synced 2026-08-09 09:21:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

add_window_representation - remove mathutils dependency #5192

Browse Source
This commit is contained in:
Andrej730
2024-12-18 16:25:53 +05:00
parent eae92b55bb
commit f22636d880
1 changed files with 132 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ifcopenshell-python/ifcopenshell/api/geometry/add_window_representation.py
+132 -130
View File
@@ -17,13 +17,12 @@
# along with IfcOpenShell. If not, see <http://www.gnu.org/licenses/>.
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