From b2bdbdd8c32641f85bf47fef8c99159c6a008d8a Mon Sep 17 00:00:00 2001 From: Andrej730 Date: Tue, 31 Jan 2023 15:10:37 +0500 Subject: [PATCH] Door modifier - basic setup Also: - refactored window modifier code - part of it is now reused building a door and can be used by other module in the future - fixed bug with window lining intersecting frame when lining_depth < panel_depth - simplified the way lining is built in ifc - previously it was using 4-6 extrusions, now it's 1-2 which is also better for 2D drawings --- .../blenderbim/bim/module/model/__init__.py | 13 + .../blenderbim/bim/module/model/data.py | 21 + .../blenderbim/bim/module/model/door.py | 504 ++++++++++++++++++ .../blenderbim/bim/module/model/prop.py | 112 +++- .../blenderbim/bim/module/model/ui.py | 86 ++- .../blenderbim/bim/module/model/window.py | 117 ++-- .../api/geometry/add_door_representation.py | 297 +++++++++++ .../api/geometry/add_window_representation.py | 321 ++++++----- 8 files changed, 1251 insertions(+), 220 deletions(-) create mode 100644 src/blenderbim/blenderbim/bim/module/model/door.py create mode 100644 src/ifcopenshell-python/ifcopenshell/api/geometry/add_door_representation.py diff --git a/src/blenderbim/blenderbim/bim/module/model/__init__.py b/src/blenderbim/blenderbim/bim/module/model/__init__.py index d11f6d6b1e..446e288e8b 100644 --- a/src/blenderbim/blenderbim/bim/module/model/__init__.py +++ b/src/blenderbim/blenderbim/bim/module/model/__init__.py @@ -33,6 +33,7 @@ from . import ( workspace, profile, sverchok_modifier, + door ) classes = ( @@ -92,11 +93,13 @@ classes = ( prop.BIMStairProperties, prop.BIMSverchokProperties, prop.BIMWindowProperties, + prop.BIMDoorProperties, ui.BIM_PT_authoring, ui.BIM_PT_array, ui.BIM_PT_stair, ui.BIM_PT_sverchok, ui.BIM_PT_window, + ui.BIM_PT_door, ui.DisplayConstrTypesUI, ui.LaunchTypeManager, ui.HelpConstrTypes, @@ -125,6 +128,12 @@ classes = ( window.FinishEditingWindow, window.EnableEditingWindow, window.RemoveWindow, + door.BIM_OT_add_door, + door.AddDoor, + door.CancelEditingDoor, + door.FinishEditingDoor, + door.EnableEditingDoor, + door.RemoveDoor, ) addon_keymaps = [] @@ -138,9 +147,11 @@ def register(): bpy.types.Object.BIMStairProperties = bpy.props.PointerProperty(type=prop.BIMStairProperties) bpy.types.Object.BIMSverchokProperties = bpy.props.PointerProperty(type=prop.BIMSverchokProperties) bpy.types.Object.BIMWindowProperties = bpy.props.PointerProperty(type=prop.BIMWindowProperties) + bpy.types.Object.BIMDoorProperties = bpy.props.PointerProperty(type=prop.BIMDoorProperties) bpy.types.VIEW3D_MT_mesh_add.append(grid.add_object_button) bpy.types.VIEW3D_MT_mesh_add.append(stair.add_object_button) bpy.types.VIEW3D_MT_mesh_add.append(window.add_object_button) + bpy.types.VIEW3D_MT_mesh_add.append(door.add_object_button) bpy.types.VIEW3D_MT_add.append(ui.add_menu) bpy.app.handlers.load_post.append(handler.load_post) wm = bpy.context.window_manager @@ -159,10 +170,12 @@ def unregister(): del bpy.types.Object.BIMStairProperties del bpy.types.Object.BIMSverchokProperties del bpy.types.Object.BIMWindowProperties + del bpy.types.Object.BIMDoorProperties bpy.app.handlers.load_post.remove(handler.load_post) bpy.types.VIEW3D_MT_mesh_add.remove(grid.add_object_button) bpy.types.VIEW3D_MT_mesh_add.remove(stair.add_object_button) bpy.types.VIEW3D_MT_mesh_add.remove(window.add_object_button) + bpy.types.VIEW3D_MT_mesh_add.remove(door.add_object_button) bpy.types.VIEW3D_MT_add.remove(ui.add_menu) wm = bpy.context.window_manager kc = wm.keyconfigs.addon diff --git a/src/blenderbim/blenderbim/bim/module/model/data.py b/src/blenderbim/blenderbim/bim/module/model/data.py index 44aefdef0b..f41b3cd068 100644 --- a/src/blenderbim/blenderbim/bim/module/model/data.py +++ b/src/blenderbim/blenderbim/bim/module/model/data.py @@ -34,6 +34,7 @@ def refresh(): StairData.is_loaded = False SverchokData.is_loaded = False WindowData.is_loaded = False + DoorData.is_loaded = False class AuthoringData: @@ -426,3 +427,23 @@ class WindowData: if parameters: parameters["data"] = json.loads(parameters.get("Data", "[]") or "[]") return parameters + + +class DoorData: + data = {} + is_loaded = False + + @classmethod + def load(cls): + cls.is_loaded = True + cls.data = {"parameters": cls.parameters()} + + @classmethod + def parameters(cls): + element = tool.Ifc.get_entity(bpy.context.active_object) + if element: + psets = ifcopenshell.util.element.get_psets(element) + parameters = psets.get("BBIM_Door", None) + if parameters: + parameters["data"] = json.loads(parameters.get("Data", "[]") or "[]") + return parameters diff --git a/src/blenderbim/blenderbim/bim/module/model/door.py b/src/blenderbim/blenderbim/bim/module/model/door.py new file mode 100644 index 0000000000..8c5fb75e8d --- /dev/null +++ b/src/blenderbim/blenderbim/bim/module/model/door.py @@ -0,0 +1,504 @@ +# BlenderBIM Add-on - OpenBIM Blender Add-on +# Copyright (C) 2023 @Andrej730 +# +# This file is part of BlenderBIM Add-on. +# +# BlenderBIM Add-on is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# BlenderBIM Add-on is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with BlenderBIM Add-on. If not, see . + + +import bpy +from bpy.types import Operator +from bpy.props import FloatProperty, IntProperty, BoolProperty +from bpy_extras.object_utils import AddObjectHelper, object_data_add +import bmesh +from bmesh.types import BMVert + +import ifcopenshell +import blenderbim +import blenderbim.tool as tool +import blenderbim.core.geometry as core +from blenderbim.bim.helper import convert_property_group_from_si +from blenderbim.bim.ifc import IfcStore +from blenderbim.bim.module.model.window import create_bm_window_frame, create_bm_window, create_bm_box + +from mathutils import Vector +from pprint import pprint + +from os.path import basename, dirname +import json +import collections + + +V = lambda *x: Vector([float(i) for i in x]) + + +def update_door_modifier_representation(context): + obj = context.active_object + props = obj.BIMDoorProperties + ifc_file = tool.Ifc.get() + representation_data = { + "partition_type": props.door_type, + "overall_height": props.overall_height, + "overall_width": props.overall_width, + "lining_properties": { + "LiningDepth": props.lining_depth, + "LiningThickness": props.lining_thickness, + "LiningOffset": props.lining_offset, + "LiningToPanelOffsetX": props.lining_to_panel_offset_x, + "LiningToPanelOffsetY": props.lining_to_panel_offset_y, + "TransomThickness": props.transom_thickness, + "TransomOffset": props.transom_offset, + "transomThickness": props.transom_thickness, + "TransomOffset": props.transom_offset, + "CasingThickness": props.casing_thickness, + "CasingDepth": props.casing_depth, + "ThresholdThickness": props.threshold_thickness, + "ThresholdDepth": props.threshold_depth, + "ThresholdOffset": props.threshold_offset, + }, + "panel_properties": { + "PanelDepth": props.panel_depth, + "PanelWidth": props.panel_width_ratio, + "FrameDepth": props.frame_depth, + "FrameThickness": props.frame_thickness, + }, + } + + # ELEVATION_VIEW representation + ifc_context = ifcopenshell.util.representation.get_context(ifc_file, "Model", "Profile", "ELEVATION_VIEW") + if not ifc_context: + model_context = ifcopenshell.util.representation.get_context(ifc_file, "Model") + ifc_context = ifcopenshell.api.run( + "context.add_context", + ifc_file, + context_type="Model", + context_identifier="Profile", + target_view="ELEVATION_VIEW", + parent=model_context, + ) + + representation_data["context"] = ifc_context + elevation_representation = ifcopenshell.api.run( + "geometry.add_door_representation", ifc_file, **representation_data + ) + replace_representation_for_object(ifc_file, ifc_context, obj, elevation_representation) + + # MODEL_VIEW representation + ifc_context = ifcopenshell.util.representation.get_context(ifc_file, "Model", "Body", "MODEL_VIEW") + representation_data["context"] = ifc_context + model_representation = ifcopenshell.api.run("geometry.add_door_representation", ifc_file, **representation_data) + replace_representation_for_object(ifc_file, ifc_context, obj, model_representation) + + +def replace_representation_for_object(ifc_file, ifc_context, obj, new_representation): + ifc_element = tool.Ifc.get_entity(obj) + old_representation = ifcopenshell.util.representation.get_representation( + ifc_element, ifc_context.ContextType, ifc_context.ContextIdentifier, ifc_context.TargetView + ) + + if old_representation: + for inverse in ifc_file.get_inverse(old_representation): + ifcopenshell.util.element.replace_attribute(inverse, old_representation, new_representation) + core.remove_representation(tool.Ifc, tool.Geometry, obj=obj, representation=old_representation) + else: + ifcopenshell.api.run( + "geometry.assign_representation", ifc_file, product=ifc_element, representation=new_representation + ) + core.switch_representation( + tool.Ifc, + tool.Geometry, + obj=obj, + representation=new_representation, + should_reload=True, + is_global=False, + should_sync_changes_first=True, + ) + + +def create_bm_door_lining(bm, size: Vector, thickness: Vector, position:Vector=V(0,0,0).freeze()): + """`thickness` of the profile is defined as list in the following order: `(SIDE, TOP)` + + `thickness` can be also defined just as 1 float value. + """ + + if not isinstance(thickness, collections.abc.Iterable): + thickness = [thickness] * 2 + + th_side, th_up = thickness + + width, depth, height = size + + verts = [ + (0, [width - th_side, 0.0, height-th_up]), + (1, [0.0, 0.0, height]), + (2, [th_side, 0.0, height-th_up]), + (3, [0.0, 0.0, 0.0]), + (4, [width - th_side, 0.0, 0.0]), + (5, [width, 0.0, height]), + (6, [th_side, 0.0, 0.0]), + (7, [width, 0.0, 0.0]) + ] + + edges = [ + (0, [5, 7]), + (1, [0, 2]), + (2, [1, 5]), + (3, [4, 0]), + (4, [2, 1]), + (5, [0, 5]), + (6, [4, 7]), + (7, [3, 1]), + (8, [3, 6]), + (9, [2, 6]), + ] + + faces = [ + (0, [5, 0, 2, 1]), + (1, [4, 0, 5, 7]), + (2, [3, 1, 2, 6]), + ] + + bm.verts.index_update() + bm.edges.index_update() + bm.faces.ensure_lookup_table() + + new_verts = [bm.verts.new(v[1]) for v in verts] + new_edges = [bm.edges.new([new_verts[vi] for vi in edge[1]]) for edge in edges] + new_faces = [bm.faces.new([new_verts[vi] for vi in face[1]]) for face in faces] + + extruded = bmesh.ops.extrude_face_region(bm, geom=new_faces) + extrusion_vector = Vector((0, 1, 0)) * depth + translate_verts = [v for v in extruded["geom"] if isinstance(v, BMVert)] + bmesh.ops.translate(bm, vec=extrusion_vector, verts=translate_verts) + + bmesh.ops.translate(bm, vec=position, verts=new_verts + translate_verts) + + return new_verts + translate_verts + +def update_door_modifier_bmesh(context): + obj = context.object + props = obj.BIMDoorProperties + si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get()) + + overall_width = props.overall_width * si_conversion + overall_height = props.overall_height * si_conversion + + # lining params + lining_depth = props.lining_depth * si_conversion + lining_thickness_default = props.lining_thickness * si_conversion + lining_offset = props.lining_offset * si_conversion + lining_to_panel_offset_x = props.lining_to_panel_offset_x * si_conversion + lining_to_panel_offset_y = props.lining_to_panel_offset_y * si_conversion + + transom_thickness = props.transom_thickness * si_conversion / 2 + transfom_offset = props.transom_offset * si_conversion + if transom_thickness == 0: + transfom_offset = 0 + + window_lining_height = overall_height - transfom_offset - transom_thickness + top_lining_thickness = transom_thickness or lining_thickness_default + panel_lining_overlap_x = max(lining_thickness_default - lining_to_panel_offset_x, 0) + panel_top_lining_overlap_x = max(top_lining_thickness - lining_to_panel_offset_x, 0) + door_opening_width = (overall_width - lining_to_panel_offset_x * 2) + + threshold_thickness = props.threshold_thickness * si_conversion + threshold_depth = props.threshold_depth * si_conversion + threshold_offset = props.threshold_offset * si_conversion + threshold_width = overall_width - lining_thickness_default * 2 + + casing_thickness = props.casing_thickness * si_conversion + casing_depth = props.casing_depth * si_conversion + + # panel params + panel_depth = props.panel_depth * si_conversion + panel_width = door_opening_width * props.panel_width_ratio + frame_depth = props.frame_depth * si_conversion + frame_thickness = props.frame_thickness * si_conversion + frame_height = window_lining_height - lining_to_panel_offset_x * 2 + glass_thickness = 0.01 * si_conversion + + if transfom_offset: + panel_height = transfom_offset + transom_thickness - lining_to_panel_offset_x - threshold_thickness + lining_height = transfom_offset + transom_thickness + else: + panel_height = overall_height - lining_to_panel_offset_x - threshold_thickness + lining_height = overall_height + + bm = bmesh.new() + + # add lining + lining_size = V(overall_width, lining_depth, lining_height) + lining_thickness = [lining_thickness_default, top_lining_thickness] + lining_verts = create_bm_door_lining(bm, lining_size, lining_thickness) + + # add threshold + if not threshold_thickness: + threshold_verts = [] + else: + threshold_size = V(threshold_width, threshold_depth, threshold_thickness) + threshold_position = V(lining_thickness_default, threshold_offset, 0) + threshold_verts = create_bm_box(bm, threshold_size, threshold_position) + + # add casings + casing_verts = [] + if not lining_offset and casing_thickness: + casing_wall_overlap = max(casing_thickness - lining_thickness_default, 0) + casing_size = V(overall_width + casing_wall_overlap*2, casing_depth, overall_height+casing_wall_overlap) + casing_position = V(-casing_wall_overlap, -casing_depth, 0) + outer_casing_verts = create_bm_door_lining(bm, casing_size, casing_thickness, casing_position) + + inner_casing_thickness = [ + casing_thickness-panel_lining_overlap_x, + casing_thickness-panel_top_lining_overlap_x + ] + inner_casing_position = V(-casing_wall_overlap, lining_depth, 0) + inner_casing_verts = create_bm_door_lining(bm, casing_size, inner_casing_thickness, inner_casing_position) + + casing_verts.extend([outer_casing_verts, inner_casing_verts]) + + # add door panel + panel_size = V( + panel_width, + panel_depth, + panel_height + ) + panel_position = V( + lining_to_panel_offset_x, + lining_to_panel_offset_y, + threshold_thickness + ) + panel_verts = create_bm_box(bm, panel_size, panel_position) + + # add on top window + if not transom_thickness: + window_lining_verts = [] + frame_verts = [] + glass_verts = [] + else: + window_lining_thickness = [lining_thickness_default] * 3 + window_lining_thickness.append(transom_thickness) + window_lining_size = V( + overall_width, + lining_depth, + window_lining_height + ) + window_position = V(0, 0, overall_height-window_lining_height) + frame_size = V( + door_opening_width, + frame_depth, + frame_height + ) + window_lining_verts, frame_verts, glass_verts = create_bm_window( + bm, + window_lining_size, + window_lining_thickness, + lining_to_panel_offset_x, + lining_to_panel_offset_y, + frame_size, + frame_thickness, + glass_thickness, + window_position + ) + + lining_offset_verts = lining_verts+panel_verts+window_lining_verts+frame_verts+glass_verts + bmesh.ops.translate(bm, vec=V(0, lining_offset, 0), verts=lining_offset_verts) + bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001) + + if bpy.context.object.mode == "EDIT": + bmesh.update_edit_mesh(obj.data) + else: + bm.to_mesh(obj.data) + bm.free() + obj.data.update() + + +class BIM_OT_add_door(Operator): + bl_idname = "mesh.add_door" + bl_label = "Door" + bl_options = {"REGISTER", "UNDO"} + + def execute(self, context): + ifc_file = tool.Ifc.get() + if not ifc_file: + self.report({"ERROR"}, "You need to start IFC project first to create a door.") + return {"CANCELLED"} + + if context.object is not None: + spawn_location = context.object.location.copy() + context.object.select_set(False) + else: + spawn_location = bpy.context.scene.cursor.location.copy() + + mesh = bpy.data.meshes.new("IfcDoor") + obj = bpy.data.objects.new("IfcDoor", mesh) + obj.location = spawn_location + body_context = ifcopenshell.util.representation.get_context(ifc_file, "Model", "Body", "MODEL_VIEW") + element = blenderbim.core.root.assign_class( + tool.Ifc, + tool.Collector, + tool.Root, + obj=obj, + ifc_class="IfcDoor", + should_add_representation=False + ) + bpy.ops.object.select_all(action="DESELECT") + bpy.context.view_layer.objects.active = None + bpy.context.view_layer.objects.active = obj + obj.select_set(True) + bpy.ops.bim.add_door() + return {"FINISHED"} + + +# UI operators +class AddDoor(bpy.types.Operator, tool.Ifc.Operator): + bl_idname = "bim.add_door" + bl_label = "Add Door" + bl_options = {"REGISTER"} + + def _execute(self, context): + obj = context.active_object + element = tool.Ifc.get_entity(obj) + props = obj.BIMDoorProperties + + if element.is_a() not in ("IfcDoor", "IfcDoorType"): + self.report({"ERROR"}, "Object has to be IfcDoor/IfcDoorType type to add a stair.") + return {"CANCELLED"} + + # need to make sure all default props will have correct units + if not props.door_added_previously: + convert_property_group_from_si(props, skip_props=("is_editing", "door_type", "door_added_previously", 'convert_property_group_from_si')) + + door_data = props.get_general_kwargs() + lining_props = props.get_lining_kwargs() + panel_props = props.get_panel_kwargs() + + door_data["lining_properties"] = lining_props + door_data["panel_properties"] = panel_props + psets = ifcopenshell.util.element.get_psets(element) + pset = psets.get("BBIM_Door", None) + + if pset: + pset = tool.Ifc.get().by_id(pset["id"]) + else: + pset = ifcopenshell.api.run("pset.add_pset", tool.Ifc.get(), product=element, name="BBIM_Door") + + ifcopenshell.api.run( + "pset.edit_pset", + tool.Ifc.get(), + pset=pset, + properties={"Data": json.dumps(door_data, default=list)}, + ) + update_door_modifier_representation(context) + return {"FINISHED"} + + +class CancelEditingDoor(bpy.types.Operator, tool.Ifc.Operator): + bl_idname = "bim.cancel_editing_door" + bl_label = "Cancel editing Door" + bl_options = {"REGISTER"} + + def _execute(self, context): + obj = context.active_object + element = tool.Ifc.get_entity(obj) + psets = ifcopenshell.util.element.get_psets(element) + data = json.loads(psets["BBIM_Door"]["Data"]) + props = obj.BIMDoorProperties + # restore previous settings since editing was canceled + for prop_name in data: + setattr(props, prop_name, data[prop_name]) + update_door_modifier_representation(context) + + props.is_editing = -1 + + return {"FINISHED"} + + +class FinishEditingDoor(bpy.types.Operator, tool.Ifc.Operator): + bl_idname = "bim.finish_editing_door" + bl_label = "Finish editing door" + bl_options = {"REGISTER"} + + def _execute(self, context): + obj = context.active_object + element = tool.Ifc.get_entity(obj) + props = obj.BIMDoorProperties + + psets = ifcopenshell.util.element.get_psets(element) + pset = psets["BBIM_Door"] + door_data = props.get_general_kwargs() + lining_props = props.get_lining_kwargs() + panel_props = props.get_panel_kwargs() + + door_data["lining_properties"] = lining_props + door_data["panel_properties"] = panel_props + + props.is_editing = -1 + + update_door_modifier_representation(context) + + pset = tool.Ifc.get().by_id(pset["id"]) + door_data = json.dumps(door_data, default=list) + ifcopenshell.api.run("pset.edit_pset", tool.Ifc.get(), pset=pset, properties={"Data": door_data}) + return {"FINISHED"} + + +class EnableEditingDoor(bpy.types.Operator, tool.Ifc.Operator): + bl_idname = "bim.enable_editing_door" + bl_label = "Enable Editing Door" + bl_options = {"REGISTER"} + + def _execute(self, context): + obj = context.active_object + props = obj.BIMDoorProperties + element = tool.Ifc.get_entity(obj) + pset = ifcopenshell.util.element.get_psets(element) + data = json.loads(pset["BBIM_Door"]["Data"]) + data.update(data.pop("lining_properties")) + data.update(data.pop("panel_properties")) + + # required since we could load pset from .ifc and BIMDoorProperties won't be set + for prop_name in data: + setattr(props, prop_name, data[prop_name]) + + # need to make sure all props that weren't used before + # will have correct units + skip_props = ("is_editing", "door_type", "door_added_previously", 'convert_property_group_from_si') + skip_props += tuple(data.keys()) + convert_property_group_from_si(props, skip_props=skip_props) + + props.is_editing = 1 + return {"FINISHED"} + + +class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator): + bl_idname = "bim.remove_door" + bl_label = "Remove Door" + bl_options = {"REGISTER"} + + def _execute(self, context): + obj = context.active_object + props = obj.BIMDoorProperties + element = tool.Ifc.get_entity(obj) + obj.BIMDoorProperties.is_editing = -1 + + pset = ifcopenshell.util.element.get_psets(element) + pset = tool.Ifc.get().by_id(pset["BBIM_Door"]["id"]) + ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), pset=pset) + props.door_added_previously = True + + return {"FINISHED"} + + +def add_object_button(self, context): + self.layout.operator(BIM_OT_add_door.bl_idname, icon="PLUGIN") diff --git a/src/blenderbim/blenderbim/bim/module/model/prop.py b/src/blenderbim/blenderbim/bim/module/model/prop.py index 9d7d19d616..0b24f0b47c 100644 --- a/src/blenderbim/blenderbim/bim/module/model/prop.py +++ b/src/blenderbim/blenderbim/bim/module/model/prop.py @@ -356,13 +356,25 @@ class BIMWindowProperties(PropertyGroup): lining_to_panel_offset_x: bpy.props.FloatProperty(name="Lining to Panel Offset X", default=0.025) lining_to_panel_offset_y: bpy.props.FloatProperty(name="Lining to Panel Offset Y", default=0.025) mullion_thickness: bpy.props.FloatProperty(name="Mullion Thickness", default=0.050) - first_mullion_offset: bpy.props.FloatProperty(name="First Mullion Offset", default=0.3) - second_mullion_offset: bpy.props.FloatProperty(name="Second Mullion Offset", default=0.45) + first_mullion_offset: bpy.props.FloatProperty( + name="First Mullion Offset", + description="Distance from the first lining to the first mullion center", + default=0.3) + second_mullion_offset: bpy.props.FloatProperty( + name="Second Mullion Offset", + description="Distance from the first lining to the second mullion center", + default=0.45) transom_thickness: bpy.props.FloatProperty(name="Transom Thickness", default=0.050) - first_transom_offset: bpy.props.FloatProperty(name="First Transom Offset", default=0.3) - second_transom_offset: bpy.props.FloatProperty(name="Second Transom Offset", default=0.6) + first_transom_offset: bpy.props.FloatProperty( + name="First Transom Offset", + description="Distance from the first lining to the first transom center", + default=0.3) + second_transom_offset: bpy.props.FloatProperty( + name="Second Transom Offset", + description="Distance from the first lining to the second transom center", + default=0.6) - # panel_properties + # panel properties frame_depth: bpy.props.FloatVectorProperty(name="Frame Depth", size=3, default=[0.035] * 3) frame_thickness: bpy.props.FloatVectorProperty(name="Frame Thickness", size=3, default=[0.035] * 3) @@ -417,3 +429,93 @@ class BIMWindowProperties(PropertyGroup): "frame_depth": self.frame_depth, "frame_thickness": self.frame_thickness, } + + +class BIMDoorProperties(PropertyGroup): + door_types = ( + ("DOUBLE_SWING_LEFT", "DOUBLE_SWING_LEFT", ""), + ("DOUBLE_SWING_RIGHT", "DOUBLE_SWING_RIGHT", ""), + ) + + door_added_previously: bpy.props.BoolProperty(default=False) + is_editing: bpy.props.IntProperty(default=-1) + door_type: bpy.props.EnumProperty( + name="Door Operation Type", items=door_types, default="DOUBLE_SWING_LEFT" + ) + overall_height: bpy.props.FloatProperty(name="Overall Height", default=1.2) + overall_width: bpy.props.FloatProperty(name="Overall Width", default=0.6) + + # lining properties + lining_depth: bpy.props.FloatProperty(name="Lining Depth", default=0.050) + lining_thickness: bpy.props.FloatProperty(name="Lining Thickness", default=0.050) + lining_offset: bpy.props.FloatProperty(name="Lining Offset", default=0.0) + lining_to_panel_offset_x: bpy.props.FloatProperty(name="Lining to Panel Offset X", default=0.025) + lining_to_panel_offset_y: bpy.props.FloatProperty(name="Lining to Panel Offset Y", default=0.025) + + transom_thickness: bpy.props.FloatProperty(name="Transom Thickness", default=0.050) + transom_offset: bpy.props.FloatProperty( + name="Transom Offset", + description="Distance from the bottom door opening " \ + "to the beginning of the transom (unlike windows)", + default=0.875) + + casing_thickness: bpy.props.FloatProperty(name="Casing Thickness", default=0.075) + casing_depth: bpy.props.FloatProperty(name="Casing Depth", default=0.005) + + threshold_thickness: bpy.props.FloatProperty(name="Threshold Thickness", default=0.025) + threshold_depth: bpy.props.FloatProperty(name="Threshold Depth", default=0.1) + threshold_offset: bpy.props.FloatProperty(name="Threshold Offset", default=0.025) + + # panel properties + panel_depth: bpy.props.FloatProperty(name="Panel Depth", default=0.035) + panel_width_ratio: bpy.props.FloatProperty( + name="Panel Width Ratio", + description="Width of this panel, given as ratio " \ + "relative to the total clear opening width of the door", + default=1.0, soft_min=0, soft_max=1) + frame_thickness: bpy.props.FloatProperty(name="Window Frame Thickness", default=0.035) + frame_depth: bpy.props.FloatProperty(name="Window Frame Depth", default=0.035) + + def get_general_kwargs(self): + return { + "door_type": self.door_type, + "overall_height": self.overall_height, + "overall_width": self.overall_width, + } + + def get_lining_kwargs(self): + kwargs = { + "lining_depth": self.lining_depth, + "lining_thickness": self.lining_thickness, + "lining_offset": self.lining_offset, + "lining_to_panel_offset_x": self.lining_to_panel_offset_x, + "lining_to_panel_offset_y": self.lining_to_panel_offset_y, + } + + kwargs['transom_thickness'] = self.transom_thickness + if self.transom_thickness: + kwargs['transom_offset'] = self.transom_offset + + if not self.lining_offset: + kwargs['casing_thickness'] = self.casing_thickness + if self.casing_thickness: + kwargs['casing_depth'] = self.casing_depth + + kwargs['threshold_thickness'] = self.threshold_thickness + if self.threshold_thickness: + kwargs['threshold_depth'] = self.threshold_depth + kwargs['threshold_offset'] = self.threshold_offset + + return kwargs + + def get_panel_kwargs(self): + kwargs = { + "panel_depth": self.panel_depth, + "panel_width_ratio": self.panel_width_ratio + } + + if self.transom_thickness: + kwargs['frame_thickness'] = self.frame_thickness + kwargs['frame_depth'] = self.frame_depth + + return kwargs diff --git a/src/blenderbim/blenderbim/bim/module/model/ui.py b/src/blenderbim/blenderbim/bim/module/model/ui.py index d06ff73381..f0dee67ca9 100644 --- a/src/blenderbim/blenderbim/bim/module/model/ui.py +++ b/src/blenderbim/blenderbim/bim/module/model/ui.py @@ -19,10 +19,11 @@ import bpy import blenderbim.tool as tool from bpy.types import Panel, Operator, Menu -from blenderbim.bim.module.model.data import AuthoringData, ArrayData, StairData, SverchokData, WindowData +from blenderbim.bim.module.model.data import AuthoringData, ArrayData, StairData, SverchokData, WindowData, DoorData from blenderbim.bim.module.model.prop import store_cursor_position from blenderbim.bim.module.model.stair import update_stair_modifier from blenderbim.bim.module.model.window import update_window_modifier_bmesh +from blenderbim.bim.module.model.door import update_door_modifier_bmesh from blenderbim.bim.helper import prop_with_search @@ -521,6 +522,89 @@ class BIM_PT_window(bpy.types.Panel): row.operator("bim.add_window", icon="ADD", text="") +class BIM_PT_door(bpy.types.Panel): + bl_label = "IFC Door" + bl_idname = "BIM_PT_door" + bl_space_type = "PROPERTIES" + bl_region_type = "WINDOW" + bl_context = "modifier" + + @classmethod + def poll(cls, context): + # always display modifier if it's IFC object + return tool.Ifc.get() and tool.Ifc.get_entity(context.active_object) + + def draw(self, context): + if not DoorData.is_loaded: + DoorData.load() + + props = context.active_object.BIMDoorProperties + + if DoorData.data["parameters"]: + row = self.layout.row(align=True) + row.label(text="Door parameters", icon="OUTLINER_OB_LATTICE") + + door_data = DoorData.data["parameters"]["data"] + + if props.is_editing != -1: + row = self.layout.row(align=True) + row.operator("bim.finish_editing_door", icon="CHECKMARK", text="Finish editing") + row.operator("bim.cancel_editing_door", icon="CANCEL", text="") + + general_props = props.get_general_kwargs() + for prop in general_props: + self.layout.prop(props, prop) + + lining_props = props.get_lining_kwargs() + self.layout.label(text="Lining properties") + for prop in lining_props: + self.layout.prop(props, prop) + + panel_props = props.get_panel_kwargs() + self.layout.label(text="Panel properties") + for prop in panel_props: + self.layout.prop(props, prop) + + update_door_modifier_bmesh(context) + + else: + row.operator("bim.enable_editing_door", icon="GREASEPENCIL", text="") + row.operator("bim.remove_door", icon="X", text="") + + box = self.layout.box() + general_props = props.get_general_kwargs() + for prop in general_props: + prop_value = door_data[prop] + prop_value = round(prop_value, 5) if type(prop_value) is float else prop_value + row = box.row(align=True) + row.label(text=f"{props.bl_rna.properties[prop].name}") + row.label(text=str(prop_value)) + + lining_props = props.get_lining_kwargs() + self.layout.label(text="Lining properties") + lining_box = self.layout.box() + for prop in lining_props: + prop_value = door_data["lining_properties"][prop] + prop_value = round(prop_value, 5) if type(prop_value) is float else prop_value + row = lining_box.row(align=True) + row.label(text=f"{props.bl_rna.properties[prop].name}") + row.label(text=str(prop_value)) + + panel_props = props.get_panel_kwargs() + self.layout.label(text="Panel properties") + panel_box = self.layout.box() + for prop in panel_props: + prop_value = door_data["panel_properties"][prop] + prop_value = round(prop_value, 5) if type(prop_value) is float else prop_value + row = panel_box.row(align=True) + row.label(text=f"{props.bl_rna.properties[prop].name}") + row.label(text=str(prop_value)) + else: + row = self.layout.row() + row.label(text="No Door Found") + row.operator("bim.add_door", icon="ADD", text="") + + class BIM_MT_model(Menu): bl_idname = "BIM_MT_model" bl_label = "IFC Objects" diff --git a/src/blenderbim/blenderbim/bim/module/model/window.py b/src/blenderbim/blenderbim/bim/module/model/window.py index 49fc130bdc..13ae289e0a 100644 --- a/src/blenderbim/blenderbim/bim/module/model/window.py +++ b/src/blenderbim/blenderbim/bim/module/model/window.py @@ -1,5 +1,5 @@ # BlenderBIM Add-on - OpenBIM Blender Add-on -# Copyright (C) 2020, 2021, 2022 Dion Moult , @Andrej730 +# Copyright (C) 2023 @Andrej730 # # This file is part of BlenderBIM Add-on. # @@ -125,10 +125,11 @@ def replace_representation_for_object(ifc_file, ifc_context, obj, new_representa ) -def create_bm_window_closed_profile(bm, size: Vector, thickness: Vector, position: Vector): - """thickness of the profile is defined as list in the following order: (LEFT, TOP, RIGHT, BOTTOM) +def create_bm_window_frame(bm, size: Vector, thickness: Vector, position: Vector = V(0,0,0)): + """`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. + `thickness` can be also defined just as 1 float value. """ if not isinstance(thickness, collections.abc.Iterable): @@ -189,6 +190,52 @@ def create_bm_window_closed_profile(bm, size: Vector, thickness: Vector, positio return new_verts + translate_verts +def create_bm_box(bm, size:Vector=V(1,1,1).freeze(), position:Vector=V(0,0,0).freeze()): + """create a box of `size`, position box first vertex at `position`""" + box_verts = bmesh.ops.create_cube(bm, size=1)['verts'] + bmesh.ops.translate(bm, vec=-box_verts[0].co, verts=box_verts) + bmesh.ops.scale(bm, vec=size, verts=box_verts) + bmesh.ops.translate(bm, vec=position, verts=box_verts) + return box_verts + + +def create_bm_window(bm, + lining_size: Vector, + lining_thickness, + lining_to_panel_offset_x, + lining_to_panel_offset_y_full, + frame_size, + frame_thickness, + glass_thickness, + position: Vector): + # window lining + window_lining_verts = create_bm_window_frame(bm, lining_size, lining_thickness) + + # window frame + frame_position = V( + lining_to_panel_offset_x, + lining_to_panel_offset_y_full, + lining_to_panel_offset_x + ) + frame_verts = create_bm_window_frame(bm, frame_size, frame_thickness, frame_position) + + # window glass + glass_size = frame_size - V(frame_thickness*2, 0, frame_thickness*2) + glass_size.y = glass_thickness + glass_position = frame_position + V( + frame_thickness, + frame_size.y / 2 - glass_thickness / 2, + frame_thickness + ) + + glass_verts = create_bm_box(bm, glass_size, glass_position) + + translated_verts = window_lining_verts + frame_verts + glass_verts + bmesh.ops.translate(bm, vec=position, verts=translated_verts) + + return (window_lining_verts, frame_verts, glass_verts) + + def update_window_modifier_bmesh(context): obj = context.object props = obj.BIMWindowProperties @@ -201,7 +248,9 @@ def update_window_modifier_bmesh(context): lining_depth = props.lining_depth * si_conversion overall_height = props.overall_height * si_conversion lining_to_panel_offset_x = props.lining_to_panel_offset_x * si_conversion + lining_to_panel_offset_y = props.lining_to_panel_offset_y * si_conversion lining_thickness = props.lining_thickness * si_conversion + lining_offset = props.lining_offset mullion_thickness = props.mullion_thickness * si_conversion / 2 first_mullion_offset = props.first_mullion_offset * si_conversion @@ -251,8 +300,8 @@ def update_window_modifier_bmesh(context): frame_depth = props.frame_depth[panel_i] * si_conversion frame_thickness = props.frame_thickness[panel_i] * si_conversion - # create lining - lining_size = V( + # add window + window_lining_size = V( panel_width, lining_depth, panel_height, @@ -260,59 +309,43 @@ def update_window_modifier_bmesh(context): # calculate lining thickness # taking into account mullions and transoms - thickness = [lining_thickness] * 4 + window_lining_thickness = [lining_thickness] * 4 # mullion thickness if unique_cols > 1: if column_i != 0: - thickness[0] = mullion_thickness # left column + window_lining_thickness[0] = mullion_thickness # left column if column_i != unique_cols - 1: - thickness[2] = mullion_thickness # right column + window_lining_thickness[2] = mullion_thickness # right column # transom thickness if unique_rows_in_col[column_i] > 1: if row_i != 0: - thickness[3] = transom_thickness # bottom row + window_lining_thickness[3] = transom_thickness # bottom row if row_i != unique_rows_in_col[column_i] - 1: - thickness[1] = transom_thickness # top row + window_lining_thickness[1] = transom_thickness # top row - lining_verts = create_bm_window_closed_profile(bm, lining_size, thickness, V(0, 0, 0)) - - # add panel - panel_size = lining_size.copy() - panel_size.y = frame_depth - panel_size = panel_size - V(lining_to_panel_offset_x * 2, 0, lining_to_panel_offset_x * 2) - - panel_position = V( - props.lining_to_panel_offset_x * si_conversion, - ((props.lining_depth - props.frame_depth[panel_i]) + props.lining_to_panel_offset_y) * si_conversion, - props.lining_to_panel_offset_x * si_conversion, - ) - thickness = props.frame_thickness[panel_i] * si_conversion - panel_verts = create_bm_window_closed_profile(bm, panel_size, thickness, panel_position) - - # add glass - glass_verts = bmesh.ops.create_cube(bm, size=1)["verts"] - bmesh.ops.translate(bm, vec=-glass_verts[0].co, verts=glass_verts) - glass_size = panel_size - glass_size.y = glass_thickness - glass_size = glass_size - V(frame_thickness * 2, 0, frame_thickness) - glass_position = panel_position + V( - frame_thickness, - frame_depth / 2 - glass_thickness / 2, + frame_size = window_lining_size.copy() + frame_size.y = frame_depth + frame_size = frame_size - V(lining_to_panel_offset_x * 2, 0, lining_to_panel_offset_x * 2) + + window_position = V(accumulated_width, 0, accumulated_height[column_i]) + lining_verts, panel_verts, glass_verts = create_bm_window( + bm, + window_lining_size, + window_lining_thickness, + lining_to_panel_offset_x, + (lining_depth - frame_depth) + lining_to_panel_offset_y, + frame_size, frame_thickness, + glass_thickness, + window_position ) - bmesh.ops.scale(bm, vec=glass_size, verts=glass_verts) - bmesh.ops.translate(bm, vec=glass_position, verts=glass_verts) - - # translate panel - accumulated_offset = V(accumulated_width, 0, accumulated_height[column_i]) - bmesh.ops.translate(bm, vec=accumulated_offset, verts=lining_verts + panel_verts + glass_verts) built_panels.append(panel_i) accumulated_height[column_i] += panel_height accumulated_width += panel_width - bmesh.ops.translate(bm, vec=V(0, props.lining_offset * si_conversion, 0), verts=bm.verts) + bmesh.ops.translate(bm, vec=V(0, lining_offset, 0), verts=bm.verts) bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001) if bpy.context.object.mode == "EDIT": diff --git a/src/ifcopenshell-python/ifcopenshell/api/geometry/add_door_representation.py b/src/ifcopenshell-python/ifcopenshell/api/geometry/add_door_representation.py new file mode 100644 index 0000000000..7e12750fe4 --- /dev/null +++ b/src/ifcopenshell-python/ifcopenshell/api/geometry/add_door_representation.py @@ -0,0 +1,297 @@ +# IfcOpenShell - IFC toolkit and geometry engine +# Copyright (C) 2023 @Andrej730 +# +# This file is part of IfcOpenShell. +# +# IfcOpenShell is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# IfcOpenShell is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with IfcOpenShell. If not, see . + +import ifcopenshell.util.unit +from ifcopenshell.util.shape_builder import ShapeBuilder, V +from ifcopenshell.api.geometry.add_window_representation import create_ifc_window +from mathutils import Vector + +import collections + + +def create_ifc_door_lining_items(builder: ShapeBuilder, size: Vector, thickness: Vector, position:Vector=V(0,0,0).freeze()): + """`thickness` of the profile is defined as list in the following order: `(SIDE, TOP)` + + `thickness` can be also defined just as 1 float value. + """ + if not isinstance(thickness, collections.abc.Iterable): + thickness = [thickness] * 2 + + th_side, th_up = thickness + + left_lining = builder.rectangle(V(th_side, 0, size.z)) + right_lining = builder.translate(left_lining, V(size.x-th_side, 0, 0), create_copy=True) + top_lining = builder.rectangle(V(size.x, 0, th_up), V(0, 0, size.z-th_up)) + items = [left_lining, right_lining, top_lining] + + items = [builder.extrude(l, size.y, extrusion_vector=V(0,1,0)) for l in items] + builder.translate(items, position) + + return items + +def create_ifc_box(builder: ShapeBuilder, size: Vector, position:Vector=V(0,0,0).freeze()): + rect = builder.rectangle(size.xy) + box = builder.extrude(rect, size.z, position=position, extrusion_vector=V(0,0,1)) + return box + + +class Usecase: + def __init__(self, file, **settings): + """units in settings expected to be in ifc project units""" + self.file = file + # http://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcDoor.htm + # http://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcDoorTypeOperationEnum.htm + # http://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcDoorLiningProperties.htm + # http://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcDoorPanelProperties.htm + self.settings = {"unit_scale": ifcopenshell.util.unit.calculate_unit_scale(self.file)} + # TODO: remove upper window from default props after tests + # TODO: check default values with blender props + self.settings.update( + { + "context": None, # IfcGeometricRepresentationContext + "overall_height": self.convert_si_to_unit(0.9), + "overall_width": self.convert_si_to_unit(0.6), + + # DOUBLE_DOOR_DOUBLE_SWING, DOUBLE_DOOR_FOLDING, DOUBLE_DOOR_LIFTING_VERTICAL, + # DOUBLE_DOOR_SINGLE_SWING, DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT, + # DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT, DOUBLE_DOOR_SLIDING, + # DOUBLE_SWING_LEFT, DOUBLE_SWING_RIGHT, FOLDING_TO_LEFT, + # FOLDING_TO_RIGHT, LIFTING_HORIZONTAL, LIFTING_VERTICAL_LEFT, + # LIFTING_VERTICAL_RIGHT, REVOLVING, REVOLVING_VERTICAL, + # ROLLINGUP, SINGLE_SWING_LEFT, SINGLE_SWING_RIGHT, SLIDING_TO_LEFT, + # SLIDING_TO_RIGHT, SWING_FIXED_LEFT, SWING_FIXED_RIGHT + # TODO: take into account door types + "operation_type": "SINGLE_SWING_LEFT", # door type + "lining_properties": { + "LiningDepth": self.convert_si_to_unit(0.050), + "LiningThickness": self.convert_si_to_unit(0.050), + + # offset from the outer side of the wall (by Y-axis) + "LiningOffset": self.convert_si_to_unit(0.050), + # offset from the wall + "LiningToPanelOffsetX": self.convert_si_to_unit(0.025), + # offset from the elevation view rectangle (unlike windows) + "LiningToPanelOffsetY": self.convert_si_to_unit(0.025), + + # Casing cover wall faces around the opening + # on the left, right and upper sides + # Casing should be either on both sides of the wall or no casing + # If `LiningOffset` is present then therefore casing is not possible on outer wall + # therefore there will be no casing on inner wall either + "CasingDepth": self.convert_si_to_unit(0.025), + "CasingThickness": self.convert_si_to_unit(0.075), # by Z-axis + + # TODO: link to wall thickness? + # Threshold covers the bottom side of the opening + "ThresholdDepth": self.convert_si_to_unit(0.025), + "ThresholdThickness": self.convert_si_to_unit(0.025), # by Z-axis + # offset to X-axis + # TODO: offset goes by Z-axis? + "ThresholdOffset": self.convert_si_to_unit(0.025), + + # transom - vertical distance between door and window panels + "TransomThickness": self.convert_si_to_unit(0.050), + # TransomOffset - distance from the bottom door opening + # to the beginning of the transom + # unlike windows TransomOffset which goes to the center of the transom + "TransomOffset": self.convert_si_to_unit(0.6), + "ShapeAspectStyle": None, # DEPRECATED + }, + "panel_properties": { + "PanelDepth": self.convert_si_to_unit(0.030), # by Y + "PanelWidth": 1.0, # as ratio to the clear door opening + "FrameDepth": self.convert_si_to_unit(0.035), # by Y + "FrameThickness": self.convert_si_to_unit(0.035), # by X + # LEFT, MIDDLE, RIGHT, NOTDEFINED + "PanelPosition": ..., # NEVER USED + # defines the basic ways to describe how door panels operate + # basically how it opens + "PanelOperation": None, # NEVER USED + "ShapeAspectStyle": None, # DEPRECATED + }, + } + ) + + for key, value in settings.items(): + self.settings[key] = value + + def execute(self): + builder = ShapeBuilder(self.file) + overall_height = self.settings["overall_height"] + overall_width = self.settings["overall_width"] + + # TODO: elevation view representation + 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 + + # TODO: implement 2d representation + + panel_props = self.settings["panel_properties"] + lining_props = self.settings["lining_properties"] + + # lining params + lining_depth = lining_props['LiningDepth'] + lining_thickness_default = lining_props['LiningThickness'] + lining_offset = lining_props['LiningOffset'] + lining_to_panel_offset_x = lining_props['LiningToPanelOffsetX'] + lining_to_panel_offset_y_full = lining_props['LiningToPanelOffsetY'] + + transom_thickness = lining_props['TransomThickness'] / 2 + transfom_offset = lining_props['TransomOffset'] + if transom_thickness == 0: + transfom_offset = 0 + + window_lining_height = overall_height - transfom_offset - transom_thickness + top_lining_thickness = transom_thickness or lining_thickness_default + panel_lining_overlap_x = max(lining_thickness_default - lining_to_panel_offset_x, 0) + panel_top_lining_overlap_x = max(top_lining_thickness - lining_to_panel_offset_x, 0) + door_opening_width = (overall_width - lining_to_panel_offset_x * 2) + + threshold_thickness = lining_props['ThresholdThickness'] + threshold_depth = lining_props['ThresholdDepth'] + threshold_offset = lining_props['ThresholdOffset'] + threshold_width = overall_width - lining_thickness_default * 2 + + casing_thickness = lining_props['CasingThickness'] + casing_depth = lining_props['CasingDepth'] + + # panel params + panel_depth = panel_props['PanelDepth'] + panel_width = door_opening_width * panel_props['PanelWidth'] + frame_depth = panel_props['FrameDepth'] + frame_thickness = panel_props['FrameThickness'] + frame_height = window_lining_height - lining_to_panel_offset_x * 2 + glass_thickness = self.convert_si_to_unit(0.01) + + if transfom_offset: + panel_height = transfom_offset + transom_thickness - lining_to_panel_offset_x - threshold_thickness + lining_height = transfom_offset + transom_thickness + else: + panel_height = overall_height - lining_to_panel_offset_x - threshold_thickness + lining_height = overall_height + + # add lining + lining_size = V(overall_width, lining_depth, lining_height) + lining_thickness = [lining_thickness_default, top_lining_thickness] + + lining_items = [] + main_lining_size = lining_size + # need to check offsets to decide whether lining should be rectangle + # or L shaped + l_shape_check = lining_to_panel_offset_y_full < lining_size.y \ + and any(lining_to_panel_offset_x < th for th in lining_thickness) + + if l_shape_check: + main_lining_size = lining_size.copy() + main_lining_size.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_position = V(0, lining_to_panel_offset_y_full, 0) + second_lining_thickness = [min(th, lining_to_panel_offset_x) for th in lining_thickness] + + second_lining = create_ifc_door_lining_items(builder, + second_lining_size, + second_lining_thickness, + second_lining_position) + lining_items.extend(second_lining) + + main_lining = create_ifc_door_lining_items(builder, main_lining_size, lining_thickness) + lining_items.extend(main_lining) + + # add threshold + if not threshold_thickness: + threshold_items = [] + else: + threshold_size = V(threshold_width, threshold_depth, threshold_thickness) + threshold_position = V(lining_thickness_default, threshold_offset, 0) + threshold_items = [create_ifc_box(builder, threshold_size, threshold_position)] + + # add casings + casing_items = [] + if not lining_offset and casing_thickness: + casing_wall_overlap = max(casing_thickness - lining_thickness_default, 0) + casing_size = V(overall_width + casing_wall_overlap*2, casing_depth, overall_height+casing_wall_overlap) + casing_position = V(-casing_wall_overlap, -casing_depth, 0) + outer_casing_items = create_ifc_door_lining_items(builder, casing_size, casing_thickness, casing_position) + casing_items.extend(outer_casing_items) + + inner_casing_thickness = [ + casing_thickness-panel_lining_overlap_x, + casing_thickness-panel_top_lining_overlap_x + ] + inner_casing_position = V(-casing_wall_overlap, lining_depth, 0) + inner_casing_items = create_ifc_door_lining_items(builder, casing_size, inner_casing_thickness, inner_casing_position) + casing_items.extend(inner_casing_items) + + # add door panel + panel_size = V( + panel_width, + panel_depth, + panel_height + ) + panel_position = V( + lining_to_panel_offset_x, + lining_to_panel_offset_y_full, + threshold_thickness + ) + panel_items = [create_ifc_box(builder, panel_size, panel_position)] + + # add on top window + if not transom_thickness: + window_lining_items = [] + frame_items = [] + glass_items = [] + else: + window_lining_thickness = [lining_thickness_default] * 3 + window_lining_thickness.append(transom_thickness) + window_lining_size = V( + overall_width, + lining_depth, + window_lining_height + ) + window_position = V(0, 0, overall_height-window_lining_height) + frame_size = V( + door_opening_width, + frame_depth, + frame_height + ) + window_lining_items, frame_items, glass_items = create_ifc_window( + builder, + window_lining_size, + window_lining_thickness, + lining_to_panel_offset_x, + lining_to_panel_offset_y_full, + frame_size, + frame_thickness, + glass_thickness, + window_position + ) + + lining_offset_items = lining_items+panel_items+window_lining_items+frame_items+glass_items + builder.translate(lining_offset_items, V(0, lining_offset, 0)) + + ouput_items = lining_offset_items + threshold_items + casing_items + print(len(ouput_items), 'items ready') + representation = builder.get_representation(self.settings["context"], ouput_items) + return representation + + def convert_si_to_unit(self, value): + return value / self.settings["unit_scale"] 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 e1ce8d673e..7ed1eeec6d 100644 --- a/src/ifcopenshell-python/ifcopenshell/api/geometry/add_window_representation.py +++ b/src/ifcopenshell-python/ifcopenshell/api/geometry/add_window_representation.py @@ -1,5 +1,5 @@ # IfcOpenShell - IFC toolkit and geometry engine -# Copyright (C) 2022 @Andrej730 +# Copyright (C) 2023 @Andrej730 # # This file is part of IfcOpenShell. # @@ -17,9 +17,10 @@ # along with IfcOpenShell. If not, see . import ifcopenshell.util.unit -from math import sin, cos from ifcopenshell.util.shape_builder import ShapeBuilder, V +from itertools import chain from mathutils import Vector +import collections # SCHEMAS describe panels setup @@ -40,6 +41,95 @@ DEFAULT_PANEL_SCHEMAS = { "TRIPLE_PANEL_VERTICAL": [[0, 1, 2]], } +def create_ifc_window_frame_simple( + builder, + size: Vector, + thickness: Vector, + position: Vector = V(0,0,0)): + """`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): + thickness = [thickness] * 4 + + th_left, th_up, th_right, th_bottom = thickness + + panel_rect = builder.rectangle(size=size*V(1,0,1)) + + inner_rect_size = size - V(th_left+th_right, 0, th_bottom+th_up) + inner_rect = builder.rectangle( + size=inner_rect_size*V(1, 0, 1), + position=V(th_left, 0, th_bottom) + ) + + panel_profile = builder.profile(panel_rect, inner_curves=inner_rect) + panel_extruded = builder.extrude( + panel_profile, + size.y, + extrusion_vector=V(0, 1, 0), + position=position + ) + return panel_extruded + +def create_ifc_window( + builder, + lining_size: Vector, + lining_thickness, + lining_to_panel_offset_x, + lining_to_panel_offset_y_full, + frame_size, + frame_thickness, + glass_thickness, + position: Vector): + + lining_items = [] + main_lining_size = lining_size + + # need to check offsets to decide whether lining should be rectangle + # or L shaped + l_shape_check = lining_to_panel_offset_y_full < lining_size.y \ + and any(lining_to_panel_offset_x < th for th in lining_thickness) + + if l_shape_check: + main_lining_size = lining_size.copy() + main_lining_size.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_position = V(0, lining_to_panel_offset_y_full, 0) + second_lining_thickness = [min(th, lining_to_panel_offset_x) for th in lining_thickness] + + second_lining = create_ifc_window_frame_simple(builder, + second_lining_size, + second_lining_thickness, + second_lining_position) + lining_items.append(second_lining) + + main_lining = create_ifc_window_frame_simple(builder, main_lining_size, lining_thickness) + lining_items.append(main_lining) + + frame_position = V( + lining_to_panel_offset_x, + lining_to_panel_offset_y_full, + lining_to_panel_offset_x + ) + + frame_extruded = 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_rect = builder.deep_copy(frame_extruded.SweptArea.InnerCurves[0]) + glass = builder.extrude( + glass_rect, glass_thickness, extrusion_vector=V(0, 1, 0), position=glass_position + ) + + output_items = [lining_items, [frame_extruded], [glass]] + builder.translate(chain(*output_items), position) + + return output_items + class Usecase: def __init__(self, file, **settings): @@ -63,7 +153,10 @@ class Usecase: "LiningDepth": self.convert_si_to_unit(0.050), "LiningThickness": self.convert_si_to_unit(0.050), "LiningOffset": self.convert_si_to_unit(0.050), # offset to the wall + # offset from the wall "LiningToPanelOffsetX": self.convert_si_to_unit(0.025), + # offset from the lining + # full offset from Y axis = (lining_depth - frame_depth) + lining_to_panel_offset_y "LiningToPanelOffsetY": self.convert_si_to_unit(0.025), # applies to DoublePanelVertical, TriplePanelBottom, TriplePanelTop, # TriplePanelLeft, TriplePanelRight @@ -72,7 +165,7 @@ class Usecase: # distance from the first lining to the mullion center "FirstMullionOffset": self.convert_si_to_unit(0.3), # applies to TriplePanelVertical - # distance from the first lining to the second mullion + # distance from the first lining to the second mullion center "SecondMullionOffset": self.convert_si_to_unit(0.45), # applies to DoublePanelHorizontal, TriplePanelBottom, TriplePanelTop, # TriplePanelLeft, TriplePanelRight @@ -118,19 +211,21 @@ class Usecase: built_panels = [] window_items = [] - lining_thickness = self.settings["lining_properties"]["LiningThickness"] - lining_depth = self.settings["lining_properties"]["LiningDepth"] - lining_offset = self.settings["lining_properties"]["LiningOffset"] - lining_panel_offset_x = self.settings["lining_properties"]["LiningToPanelOffsetX"] - lining_panel_offset_y = self.settings["lining_properties"]["LiningToPanelOffsetY"] - glass_thickness = self.convert_si_to_unit(0.01) - mullion_thickness = self.settings["lining_properties"]["MullionThickness"] / 2 - first_mullion_offset = self.settings["lining_properties"]["FirstMullionOffset"] - second_mullion_offset = self.settings["lining_properties"]["SecondMullionOffset"] - transom_thickness = self.settings["lining_properties"]["TransomThickness"] / 2 - first_transom_offset = self.settings["lining_properties"]["FirstTransomOffset"] - second_transom_offset = self.settings["lining_properties"]["SecondTransomOffset"] + 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"] + + 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) panel_schema = list(reversed(panel_schema)) @@ -146,193 +241,75 @@ class Usecase: # calculate current panel dimensions if unique_cols > 1: if column_i == 0: - panel_width = first_mullion_offset + lining_width = first_mullion_offset elif column_i == unique_cols - 1: - panel_width = overall_width - accumulated_width + lining_width = overall_width - accumulated_width else: - panel_width = second_mullion_offset - accumulated_width + lining_width = second_mullion_offset - accumulated_width else: - panel_width = overall_width + lining_width = overall_width if unique_rows_in_col[column_i] > 1: if row_i == 0: - panel_height = first_transom_offset + lining_height = first_transom_offset elif row_i == unique_rows_in_col[column_i] - 1: - panel_height = overall_height - accumulated_height[column_i] + lining_height = overall_height - accumulated_height[column_i] else: - panel_height = second_transom_offset - accumulated_height[column_i] + lining_height = second_transom_offset - accumulated_height[column_i] else: - panel_height = overall_height + lining_height = overall_height if panel_i in built_panels: - accumulated_height[column_i] += panel_height - accumulated_width += panel_width + accumulated_height[column_i] += lining_height + accumulated_width += lining_width continue cur_panel = panels[panel_i] - panel_depth = cur_panel["FrameDepth"] - panel_thickness = cur_panel["FrameThickness"] + frame_depth = cur_panel["FrameDepth"] + frame_thickness = cur_panel["FrameThickness"] current_items = [] - panel_actual_width = panel_width - lining_panel_offset_x * 2 - panel_actual_height = panel_height - lining_panel_offset_x * 2 - - glass_width = panel_actual_width - panel_thickness * 2 - glass_height = panel_actual_height - panel_thickness * 2 - - # build lining - # lining is calculated on panel level because - # panel depth is used - lining_items_vertical_left = [] - lining_items = [] + frame_width = lining_width - lining_to_panel_offset_x * 2 + frame_height = lining_height - lining_to_panel_offset_x * 2 # calculate lining thickness - # taking into account mullions and transoms - thickness = [lining_thickness] * 4 + # lining is calculated on panel level because + # panel depth is used + # also taking into account mullions and transoms + window_lining_thickness = [lining_thickness] * 4 # mullion thickness if unique_cols > 1: if column_i != 0: - thickness[0] = mullion_thickness # left column + window_lining_thickness[0] = mullion_thickness # left column if column_i != unique_cols - 1: - thickness[2] = mullion_thickness # right column + window_lining_thickness[2] = mullion_thickness # right column # transom thickness if unique_rows_in_col[column_i] > 1: if row_i != 0: - thickness[3] = transom_thickness # bottom row + window_lining_thickness[3] = transom_thickness # bottom row if row_i != unique_rows_in_col[column_i] - 1: - thickness[1] = transom_thickness # top row + window_lining_thickness[1] = transom_thickness # top row + window_lining_size = V(lining_width, lining_depth, lining_height) + frame_size = V(frame_width, frame_depth, frame_height) + window_panel_position = V(accumulated_width, 0, accumulated_height[column_i]) - def get_lining_rectangle(current_lining_thickness): - lining_rectangle = builder.rectangle(size=V(current_lining_thickness, lining_depth)) - return lining_rectangle - - def get_lining_polyline(current_lining_thickness): - # need to check offsets to decide whether lining should be rectangle - # or L shaped - if lining_panel_offset_x >= current_lining_thickness or lining_panel_offset_y >= lining_depth: - lining_polyline = get_lining_rectangle(current_lining_thickness) - else: - lining_points = [ - V(0, 0), - V(0, lining_depth), - V(lining_panel_offset_x, lining_depth), - V(lining_panel_offset_x, lining_depth - (panel_depth - lining_panel_offset_y)), - V(current_lining_thickness, lining_depth - (panel_depth - lining_panel_offset_y)), - V(current_lining_thickness, 0), - ] - lining_polyline = builder.polyline(lining_points, closed=True) - return lining_polyline - - def create_lining_vertical(current_lining_thickness): - current_vertical_lining_items = [] - lining_vertical_polyline = get_lining_polyline(current_lining_thickness) - lining_vertical_height = panel_height - lining_panel_offset_x * 2 - extrusion_position = V(0, 0, lining_panel_offset_x) - lining_vertical_extruded = builder.extrude( - lining_vertical_polyline, lining_vertical_height, position=extrusion_position - ) - current_vertical_lining_items.append(lining_vertical_extruded) - - # if lining panel X offset is present - # then we also need to add two more box shapes - # to finish the lining after the panel ends - if lining_panel_offset_x > 0: - lining_vertical_addition = builder.extrude( - get_lining_rectangle(current_lining_thickness), lining_panel_offset_x - ) - - current_vertical_lining_items.append(lining_vertical_addition) - current_vertical_lining_items.append( - builder.translate( - lining_vertical_addition, - V(0, 0, panel_height - lining_panel_offset_x), - create_copy=True, - ) - ) - - return current_vertical_lining_items - - # vertical lining - lining_items_vertical_left = create_lining_vertical(thickness[0]) - lining_items_vertical_right = create_lining_vertical(thickness[2]) - lining_items_vertical_right = builder.mirror( - lining_items_vertical_right, mirror_point=V(panel_width / 2, 0), mirror_axes=V(1, 0) + # create window panel + current_window_items = create_ifc_window( + builder, + window_lining_size, + window_lining_thickness, + lining_to_panel_offset_x, + (lining_depth - frame_depth) + lining_to_panel_offset_y, + frame_size, + frame_thickness, + glass_thickness, + window_panel_position ) - lining_items.extend(lining_items_vertical_left) - lining_items.extend(lining_items_vertical_right) - - # horizontal lining - def create_horizontal_lining(current_lining_thickness, mirror_point=None): - lining_horizontal_polyline = get_lining_polyline(current_lining_thickness) - if mirror_point: - lining_horizontal_polyline = builder.mirror( - lining_horizontal_polyline, - mirror_axes=V(1, 0), - mirror_point=mirror_point - ) - builder.translate(lining_horizontal_polyline, -mirror_point) - lining_horizontal_extruded = builder.extrude( - lining_horizontal_polyline, - magnitude=panel_width - (thickness[0] + thickness[2]), - extrusion_vector=V(0, 0, -1), - position_z_axis=V(-1, 0, 0), - position_x_axis=V(0, 0, 1), - ) - return lining_horizontal_extruded - - lining_horizontal_bottom = create_horizontal_lining(thickness[3]) - builder.translate(lining_horizontal_bottom, V(thickness[0], 0, 0)) - - lining_horizontal_top = create_horizontal_lining(thickness[1], mirror_point=V(thickness[1], 0)) - builder.translate(lining_horizontal_top, V(thickness[0], 0, panel_height - thickness[1])) - - # TODO: should implement mirror by Z for more readability - # TODO: investigate meaning of mirror axes in case of custom x/y/z space - # lining_horizontal_mirrored = builder.mirror( - # lining_horizontal_extruded, - # mirror_point=V(0, panel_height/2), - # mirror_axes=V(0,1), - # create_copy=True - # ) - - lining_items.extend([lining_horizontal_bottom, lining_horizontal_top]) - current_items.extend(lining_items) - - # PANEL - panel_items = [] - - panel_position = V( - lining_panel_offset_x, (lining_depth - panel_depth) + lining_panel_offset_y, lining_panel_offset_x - ) - panel_rect = builder.rectangle(size=V(panel_actual_width, 0, panel_actual_height)) - glass_rect = builder.rectangle( - size=V(glass_width, 0, glass_height), position=V(panel_thickness, 0, panel_thickness) - ) - panel_profile = builder.profile(panel_rect, inner_curves=glass_rect) - panel_extruded = builder.extrude( - panel_profile, panel_depth, extrusion_vector=V(0, 1, 0), position=panel_position - ) - panel_items.append(panel_extruded) - - current_items.extend(panel_items) - - # add glass - glass_position = panel_position + V(0, panel_depth / 2 - glass_thickness / 2, 0) - glass_rect = builder.deep_copy(glass_rect) - glass = builder.extrude( - glass_rect, glass_thickness, extrusion_vector=V(0, 1, 0), position=glass_position - ) - current_items.append(glass) - - # translate panel - accumulated_offset = V(accumulated_width, 0, accumulated_height[column_i]) - builder.translate(current_items, accumulated_offset) - built_panels.append(panel_i) - window_items.extend(current_items) + window_items.extend(chain(*current_window_items)) - accumulated_height[column_i] += panel_height - accumulated_width += panel_width + accumulated_height[column_i] += lining_height + accumulated_width += lining_width builder.translate(window_items, V(0, lining_offset, 0)) # wall offset representation = builder.get_representation(self.settings["context"], window_items)