Merge branch 'v0.7.0' into fix-normal-duplication-of-linked-aggregate

src/blenderbim/Makefile

@@ -137,7 +137,7 @@ endif
 	cp -r blenderbim/* dist/blenderbim/
 
 	# Provides IfcOpenShell Python functionality
-	cd dist/working && wget https://s3.amazonaws.com/ifcopenshell-builds/ifcopenshell-python-$(PYNUMBER)-v0.7.0-eaa2aa0-$(PLATFORM)64.zip
+	cd dist/working && wget https://s3.amazonaws.com/ifcopenshell-builds/ifcopenshell-python-$(PYNUMBER)-v0.7.0-f7c03db-$(PLATFORM)64.zip
 	cd dist/working && unzip ifcopenshell-python*
 	cp -r dist/working/ifcopenshell dist/blenderbim/libs/site/packages/
 
@@ -362,7 +362,9 @@ endif
 	# Provides express rule validation for ifcopenshell.validate
 	cd dist/working && . env/bin/activate && $(PIP) install pytest --target=./site-packages
 	# Provides Brickschema functionality
-	cd dist/working && . env/bin/activate && $(PIP) install brickschema[persistence] --target=./site-packages
+	cd dist/working && . env/bin/activate && $(PIP) install "brickschema[persistence]==0.7.6a2" --target=./site-packages
+	# Required for SVG to DXF conversion
+	cd dist/working && . env/bin/activate && $(PIP) install "ezdxf" --target=./site-packages
 	cp -r dist/working/site-packages/* dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
 
@@ -430,7 +432,7 @@ endif
 	# Required by brickschema
 	# This is a bit of a dodgy one, it should be provided by setuptools which Blender doesn't ship.
 	mkdir dist/working
-	cd dist/working && wget https://blenderbim.org/builds/pkg_resources.tar.gz
+	cd dist/working && wget https://github.com/IfcOpenShell/IfcOpenShell/raw/v0.7.0/src/blenderbim/scripts/pkg_resources.tar.gz
 	cd dist/working && tar -xzvf pkg_resources*
 	cd dist/working/ && cp -r pkg_resources ../blenderbim/libs/site/packages/
 	rm -rf dist/working

src/blenderbim/blenderbim/__init__.py

@@ -27,7 +27,7 @@ bl_info = {
     "blender": (3, 1, 0),
     "version": (0, 0, 999999),
     "location": "File Menu, Scene Properties Tab. See documentation for more.",
-    "doc_url": "https://blenderbim.org/docs",
+    "doc_url": "https://docs.blenderbim.org/",
     "tracker_url": "https://github.com/IfcOpenShell/IfcOpenShell/issues",
     "category": "System",
 }

src/blenderbim/blenderbim/bim/__init__.py

@@ -23,6 +23,7 @@ import bpy.utils.previews
 import blenderbim
 import importlib
 from . import handler, ui, prop, operator, helper
+from typing import Callable, Union
 
 try:
     from blenderbim.translations import translations_dict
@@ -96,8 +97,10 @@ for name in modules.keys():
 classes = [
     operator.AddIfcFile,
     operator.BIM_OT_add_section_plane,
+    operator.BIM_OT_delete_object,
     operator.BIM_OT_open_webbrowser,
     operator.BIM_OT_remove_section_plane,
+    operator.BIM_OT_select_object,
     operator.BIM_OT_show_description,
     operator.ClippingPlaneCutWithCappings,
     operator.EditBlenderCollection,
@@ -130,6 +133,7 @@ classes = [
     prop.BIMMeshProperties,
     prop.BIMFacet,
     prop.BIMFilterGroup,
+    ui.BIM_UL_clipping_plane,
     ui.BIM_UL_generic,
     ui.BIM_UL_topics,
     ui.BIM_ADDON_preferences,
@@ -187,7 +191,7 @@ addon_keymaps = []
 icons = None
 is_registering = False
 last_commit_hash = "8888888"
-overridden_scene_panels = dict()
+original_scene_panels_polls: dict[bpy.types.Panel, Union[Callable, None]] = dict()
 
 
 def on_register(scene):
@@ -295,10 +299,10 @@ def unregister():
             km.keymap_items.remove(kmi)
     addon_keymaps.clear()
 
-    for panel in tuple(overridden_scene_panels.keys()):
-        original_panel, override_panel = overridden_scene_panels[panel]
-        bpy.utils.unregister_class(override_panel)
-        bpy.utils.register_class(original_panel)
-        del overridden_scene_panels[panel]
+    import blenderbim.tool as tool
+
+    # use tuple() as method will be removing keys from dict
+    for panel in tuple(original_scene_panels_polls.keys()):
+        tool.Blender.remove_scene_panel_override(panel)
 
     bpy.app.translations.unregister("blenderbim")

src/blenderbim/blenderbim/bim/data/assets/default.css

@@ -10,7 +10,7 @@
  * (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
+ * 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.
  *

src/blenderbim/blenderbim/bim/data/assets/sample.css

@@ -10,7 +10,7 @@
  * (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
+ * 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.
  *

src/blenderbim/blenderbim/bim/data/pset/EPset_Drawing.ifc

@@ -5,7 +5,7 @@ FILE_NAME('EPset_Drawing.ifc','2020-01-01T00:00:00',(),(),'EPset_Drawing','EPset
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11,#12,#13,#14,#15,#16,#17,#18,#19,#20,#21,#22));
+#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11,#12,#13,#14,#15,#16,#17,#18,#19,#20,#21,#22,#23));
 #2=IFCSIMPLEPROPERTYTEMPLATE('23JavTMk98ZxXhrUEnjAcf',$,'TargetView','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1yVWUt5H9DAOuu0OaMMLpe',$,'Scale','The scale of this drawing represented as a numerator and denominator, such as 1/100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3gsuPBtU93b8f0gg1pjkq6',$,'HumanScale','The scale of this drawing in human readable format, such as 1:100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -27,5 +27,6 @@ DATA;
 #20=IFCSIMPLEPROPERTYTEMPLATE('0joEq0Rd10cxweEh0NeHT6',$,'JoinCriteria','Comma separated selection keys which determine what cut objects are to be joined.',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
 #21=IFCSIMPLEPROPERTYTEMPLATE('0nYMT3OSj5gArVniCWZRtv',$,'ShadingStyles','',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
 #22=IFCSIMPLEPROPERTYTEMPLATE('3VWG22eZXBdQwdKlzMeVQH',$,'CurrentShadingStyle','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+#23=IFCSIMPLEPROPERTYTEMPLATE('28mJ$GDxb7kBbKFH_rACMQ',$,'AngleDecimalPlaces','',.P_SINGLEVALUE.,'IfcInteger',$,$,$,$,$,.READWRITE.);
 ENDSEC;
 END-ISO-10303-21;

src/blenderbim/blenderbim/bim/export_ifc.py

@@ -27,6 +27,7 @@ import addon_utils
 import ifcopenshell
 import ifcopenshell.api
 import ifcopenshell.util.placement
+import ifcopenshell.util.unit
 import blenderbim.tool as tool
 import blenderbim.core.geometry
 import blenderbim.core.aggregate
@@ -34,6 +35,7 @@ import blenderbim.core.spatial
 import blenderbim.core.style
 from blenderbim.bim.ifc import IfcStore
 from mathutils import Vector
+from typing import Union
 
 
 class IfcExporter:
@@ -85,8 +87,8 @@ class IfcExporter:
             self.get_application_name(), tool.Blender.get_blenderbim_version()
         )
 
-    def sync_all_objects(self):
-        results = []
+    def sync_all_objects(self, skip_unlinking=False) -> list[ifcopenshell.entity_instance]:
+        results: list[ifcopenshell.entity_instance] = []
         self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(self.file)
         for ifc_definition_id in list(IfcStore.id_map.keys()):
             obj = IfcStore.id_map[ifc_definition_id]
@@ -95,19 +97,21 @@ class IfcExporter:
                     continue
                 if obj.library:
                     continue
-                tool.Collector.sync(obj)
+                tool.Collector.sync(obj, skip_unlinking)
                 result = self.sync_object_placement(obj)
                 if result:
                     results.append(result)
                 result = self.sync_object_material(obj)
+                # TODO: sync_object_material always returns None
+                # so it's never really appended
                 if result:
                     results.append(result)
             except ReferenceError:
                 pass  # The object is likely deleted
         return results
 
-    def sync_edited_objects(self):
-        results = []
+    def sync_edited_objects(self) -> list[ifcopenshell.entity_instance]:
+        results: list[ifcopenshell.entity_instance] = []
         for obj in IfcStore.edited_objs.copy():
             if not obj:
                 continue
@@ -125,7 +129,7 @@ class IfcExporter:
         IfcStore.edited_objs.clear()
         return results
 
-    def sync_object_material(self, obj):
+    def sync_object_material(self, obj: bpy.types.Object) -> None:
         if not obj.data or not isinstance(obj.data, bpy.types.Mesh):
             return
         if not self.has_changed_materials(obj):
@@ -136,11 +140,10 @@ class IfcExporter:
         checksum = obj.data.BIMMeshProperties.material_checksum
         return checksum != str([s.id() for s in tool.Geometry.get_styles(obj) if s])
 
-    def sync_object_placement(self, obj):
+    def sync_object_placement(self, obj: bpy.types.Object) -> Union[ifcopenshell.entity_instance, None]:
         element = self.file.by_id(obj.BIMObjectProperties.ifc_definition_id)
         if not tool.Ifc.is_moved(obj):
             return
-        blender_matrix = np.array(obj.matrix_world)
         if (obj.scale - Vector((1.0, 1.0, 1.0))).length > 1e-4:
             bpy.ops.bim.update_representation(obj=obj.name)
             return element
@@ -151,7 +154,7 @@ class IfcExporter:
         blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
         return element
 
-    def sync_grid_axis_object_placement(self, obj, element):
+    def sync_grid_axis_object_placement(self, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
         grid = (element.PartOfU or element.PartOfV or element.PartOfW)[0]
         grid_obj = tool.Ifc.get_object(grid)
         if grid_obj:

src/blenderbim/blenderbim/bim/handler.py

@@ -31,6 +31,7 @@ from blenderbim.bim.module.model.data import AuthoringData
 from blenderbim.bim.module.model.workspace import LIST_OF_TOOLS, TOOLS_TO_CLASSES_MAP
 from mathutils import Vector
 from math import cos, degrees
+from typing import Union
 
 
 cwd = os.path.dirname(os.path.realpath(__file__))
@@ -191,6 +192,8 @@ def refresh_ui_data():
     if isinstance(tool.Ifc.get(), ifcopenshell.sqlite):
         tool.Ifc.get().clear_cache()
 
+    bpy.context.scene.DocProperties.should_draw_decorations = bpy.context.scene.DocProperties.should_draw_decorations
+
 
 @persistent
 def loadIfcStore(scene):
@@ -254,60 +257,6 @@ def viewport_shading_changed_callback(area):
         bpy.context.scene.BIMStylesProperties.active_style_type = "External"
 
 
-@classmethod
-def poll_check_blender_tab(cls, context):
-    return tool.Blender.is_tab(context, "BLENDER")
-
-
-def get_override_scene_panel(panel_name):
-    original_panel = getattr(bpy.types, panel_name)
-
-    override_panel = type(f"Override_{panel_name}", (original_panel,), {})
-    override_panel.bl_idname = f"{panel_name}_override"
-
-    # some blender panel depend on other and register_class will throw an error
-    # if we won't override their `bl_parent_id`
-    bl_parent_id = getattr(override_panel, "bl_parent_id", None)
-    if bl_parent_id is not None:
-        override_panel.bl_parent_id = f"{bl_parent_id}_override"
-
-    # override poll method
-    poll = getattr(override_panel, "poll", None)
-    if poll is None:
-        override_panel.poll = poll_check_blender_tab
-    else:
-
-        @classmethod
-        def wrapped_poll(cls, context):
-            return super(override_panel, cls).poll(context) and poll_check_blender_tab.__func__(cls, context)
-
-        override_panel.poll = wrapped_poll
-
-    return override_panel
-
-
-# TODO: possibly override scene panels from other addons too?
-# list can be updated from
-# https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_ui/properties_scene.py#L421
-OVERRIDE_SCENE_PANELS = (
-    "SCENE_PT_scene",
-    "SCENE_PT_unit",
-    "SCENE_PT_physics",
-    "SCENE_PT_rigid_body_world",
-    "SCENE_PT_rigid_body_world_settings",
-    "SCENE_PT_rigid_body_cache",
-    "SCENE_PT_rigid_body_field_weights",
-    "SCENE_PT_audio",
-    "SCENE_PT_keying_sets",
-    "SCENE_PT_custom_props",
-    # after SCENE_PT_keying_sets
-    "SCENE_PT_keying_set_paths",
-    "SCENE_PT_keyframing_settings",
-)
-if bpy.app.version >= (4, 0):
-    OVERRIDE_SCENE_PANELS += ("SCENE_PT_simulation",)
-
-
 @persistent
 def load_post(scene):
     global global_subscription_owner
@@ -343,15 +292,11 @@ def load_post(scene):
         else:
             bpy.ops.workspace.append_activate(idname="BIM", filepath=os.path.join(cwd, "data", "workspace.blend"))
 
-        # To improve usability for new users, we hijack the scene properties
-        # tab. We override default scene properties panels with our own poll
-        # to hide them unless the user has chosen to view Blender properties.
-        for panel in OVERRIDE_SCENE_PANELS:
-            if panel in blenderbim.bim.overridden_scene_panels:
-                continue
-            override_panel = get_override_scene_panel(panel)
-            original_panel = getattr(bpy.types, panel)
-            bpy.utils.register_class(override_panel)
-            bpy.utils.unregister_class(original_panel)
-            blenderbim.bim.overridden_scene_panels[panel] = (original_panel, override_panel)
+    # To improve usability for new users, we hijack the scene properties
+    # tab. We override default scene properties panels with our own poll
+    # to hide them unless the user has chosen to view Blender properties.
+    for panel in tool.Blender.get_scene_panels_list():
+        if panel in blenderbim.bim.original_scene_panels_polls:
+            continue
+        tool.Blender.override_scene_panel(panel)
     tool.Blender.setup_tabs()

src/blenderbim/blenderbim/bim/helper.py

@@ -29,6 +29,7 @@ from mathutils import geometry
 from mathutils import Vector
 import blenderbim.tool as tool
 from blenderbim.bim.ifc import IfcStore
+from typing import Optional, Callable, Any
 
 
 def draw_attributes(props, layout, copy_operator=None, popup_active_attribute=None):
@@ -75,6 +76,10 @@ def draw_attribute(attribute, layout, copy_operator=None):
         op.data_path = attribute.path_from_id("string_value")
     if attribute.is_optional:
         layout.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
+
+    if attribute.name == "GlobalId":
+        layout.operator("bim.generate_global_id", icon="FILE_REFRESH", text="")
+
     if copy_operator:
         op = layout.operator(f"{copy_operator}", text="", icon="COPYDOWN")
         op.name = attribute.name
@@ -116,7 +121,7 @@ def import_attribute(attribute, props, data, callback=None):
     elif is_handled_by_callback is False:
         props.remove(len(props) - 1)
     elif data_type == "string":
-        new.string_value = "" if new.is_null else str(data[attribute.name()])
+        new.string_value = "" if new.is_null else str(data[attribute.name()]).replace("\n", "\\n")
         if attribute.type_of_attribute().declared_type().name() == "IfcURIReference":
             new.is_uri = True
     elif data_type == "boolean":
@@ -178,7 +183,7 @@ def add_attribute_description(attribute_blender, attribute_ifc=None):
         attribute_blender.description = description
 
 
-def export_attributes(props, callback=None):
+def export_attributes(props, callback: Optional[Callable] = None) -> dict[str, Any]:
     attributes = {}
     for prop in props:
         is_handled_by_callback = callback(attributes, prop) if callback else False
@@ -216,39 +221,6 @@ def get_enum_items(data, prop_name, context=None):
     return items
 
 
-def get_obj_ifc_definition_id(context, obj, obj_type):
-    if obj_type == "Object":
-        return bpy.data.objects.get(obj).BIMObjectProperties.ifc_definition_id
-    elif obj_type == "Material":
-        return bpy.data.materials.get(obj).BIMObjectProperties.ifc_definition_id
-    elif obj_type == "MaterialSet":
-        return ifcopenshell.util.element.get_material(
-            tool.Ifc.get_entity(bpy.data.objects.get(obj)), should_skip_usage=True
-        ).id()
-    elif obj_type == "MaterialSetItem":
-        return bpy.data.objects.get(obj).BIMObjectMaterialProperties.active_material_set_item_id
-    elif obj_type == "Task":
-        return context.scene.BIMTaskTreeProperties.tasks[
-            context.scene.BIMWorkScheduleProperties.active_task_index
-        ].ifc_definition_id
-    elif obj_type == "Cost":
-        return context.scene.BIMCostProperties.cost_items[
-            context.scene.BIMCostProperties.active_cost_item_index
-        ].ifc_definition_id
-    elif obj_type == "Resource":
-        return context.scene.BIMResourceTreeProperties.resources[
-            context.scene.BIMResourceProperties.active_resource_index
-        ].ifc_definition_id
-    elif obj_type == "Profile":
-        return context.scene.BIMProfileProperties.profiles[
-            context.scene.BIMProfileProperties.active_profile_index
-        ].ifc_definition_id
-    elif obj_type == "WorkSchedule":
-        return context.scene.BIMWorkScheduleProperties.active_work_schedule_id
-    elif obj_type == "Group":
-        prop = context.scene.BIMGroupProperties
-        return prop.groups[prop.active_group_index].ifc_definition_id
-
 # hack to close popup
 # https://blender.stackexchange.com/a/202576/130742
 def close_operator_panel(event):
@@ -304,6 +276,9 @@ def draw_filter(layout, filter_groups, data, module):
         op.type = sprops.facet
         op.index = i
         op.module = module
+        op = row.operator("bim.remove_filter_group", text="", icon="X")
+        op.index = i
+        op.module = module
 
         for j, ifc_filter in enumerate(filter_group.filters):
             if ifc_filter.type == "entity":
@@ -350,11 +325,6 @@ def draw_filter(layout, filter_groups, data, module):
             op.index = j
             op.module = module
 
-        row = box.row()
-        op = row.operator("bim.remove_filter_group", icon="X")
-        op.index = i
-        op.module = module
-
 
 # TODO this should move into ifcopenshell.util
 

src/blenderbim/blenderbim/bim/ifc.py

@@ -23,33 +23,39 @@ import hashlib
 import zipfile
 import tempfile
 import ifcopenshell
+import ifcopenshell.geom
+import ifcopenshell.ifcopenshell_wrapper
 import blenderbim.bim.handler
 import blenderbim.tool as tool
 from pathlib import Path
 from blenderbim.tool.brick import BrickStore
+from typing import Set, Union, Optional
+
+
+IFC_CONNECTED_TYPE = Union[bpy.types.Material, bpy.types.Object]
 
 
 class IfcStore:
-    path = ""
-    file = None
-    schema = None
-    cache = None
-    cache_path = None
-    id_map = {}
-    guid_map = {}
-    edited_objs = set()
-    pset_template_path = ""
-    pset_template_file = None
-    classification_path = ""
-    classification_file = None
-    library_path = ""
-    library_file = None
+    path: str = ""
+    file: ifcopenshell.file = None
+    schema: ifcopenshell.ifcopenshell_wrapper.schema_definition = None
+    cache: ifcopenshell.ifcopenshell_wrapper.HdfSerializer = None
+    cache_path: str = None
+    id_map: dict[int, IFC_CONNECTED_TYPE] = {}
+    guid_map: dict[str, IFC_CONNECTED_TYPE] = {}
+    edited_objs: Set[bpy.types.Object] = set()
+    pset_template_path: str = ""
+    pset_template_file: ifcopenshell.file = None
+    classification_path: str = ""
+    classification_file: ifcopenshell.file = None
+    library_path: str = ""
+    library_file: ifcopenshell.file = None
     current_transaction = ""
     last_transaction = ""
     history = []
     future = []
     schema_identifiers = ["IFC4", "IFC2X3", "IFC4X3"]
-    session_files = {}
+    session_files: dict[str, ifcopenshell.file] = {}
 
     @staticmethod
     def purge():
@@ -117,7 +123,7 @@ class IfcStore:
         IfcStore.get_cache()
 
     @staticmethod
-    def load_file(path):
+    def load_file(path) -> None:
         if not os.path.isfile(path):
             return
         extension = path.split(".")[-1]
@@ -146,7 +152,7 @@ class IfcStore:
         return IfcStore.schema
 
     @staticmethod
-    def get_element(id_or_guid):
+    def get_element(id_or_guid: Union[int, str]) -> IFC_CONNECTED_TYPE:
         if isinstance(id_or_guid, int):
             map_object = IfcStore.id_map
         else:
@@ -159,7 +165,7 @@ class IfcStore:
         return obj
 
     @staticmethod
-    def relink_all_objects():
+    def relink_all_objects() -> None:
         if not IfcStore.get_file():
             return
         for obj in bpy.data.objects:
@@ -172,7 +178,7 @@ class IfcStore:
             IfcStore.relink_object(obj)
 
     @staticmethod
-    def relink_object(obj):
+    def relink_object(obj: IFC_CONNECTED_TYPE) -> None:
         if not obj:
             return
         if obj.BIMObjectProperties.ifc_definition_id:
@@ -193,7 +199,7 @@ class IfcStore:
             IfcStore.commit_link_element(data)
 
     @staticmethod
-    def link_element(element, obj):
+    def link_element(element: ifcopenshell.entity_instance, obj: IFC_CONNECTED_TYPE) -> None:
         # Please use tool.Ifc.link() instead of this method. We want to
         # refactor this class and deprecate usage of IfcStore in favour of
         # tools.
@@ -259,7 +265,7 @@ class IfcStore:
         # TODO We're handling id_map and guid_map, but what about edited_objs? This might cause big problems.
 
     @staticmethod
-    def rollback_unlink_element(data):
+    def rollback_unlink_element(data) -> None:
         if "id" not in data or "obj" not in data:
             return
         obj = bpy.data.objects.get(data["obj"])
@@ -268,13 +274,15 @@ class IfcStore:
             IfcStore.guid_map[data["guid"]] = obj
 
     @staticmethod
-    def commit_unlink_element(data):
+    def commit_unlink_element(data) -> None:
         del IfcStore.id_map[data["id"]]
         if data["guid"]:
             del IfcStore.guid_map[data["guid"]]
 
     @staticmethod
-    def unlink_element(element=None, obj=None):
+    def unlink_element(
+        element: Optional[ifcopenshell.entity_instance] = None, obj: Optional[IFC_CONNECTED_TYPE] = None
+    ) -> None:
         if element is None:
             try:
                 element = tool.Ifc.get_entity(obj)
@@ -320,7 +328,7 @@ class IfcStore:
             )
 
     @staticmethod
-    def execute_ifc_operator(operator, context, is_invoke=False):
+    def execute_ifc_operator(operator: bpy.types.Operator, context: bpy.types.Context, is_invoke=False):
         bpy.context.scene.BIMProperties.is_dirty = True
         is_top_level_operator = not bool(IfcStore.current_transaction)
 
@@ -354,17 +362,17 @@ class IfcStore:
         return result
 
     @staticmethod
-    def begin_transaction(operator):
+    def begin_transaction(operator: bpy.types.Operator) -> None:
         IfcStore.current_transaction = str(uuid.uuid4())
         operator.transaction_key = IfcStore.current_transaction
 
     @staticmethod
-    def end_transaction(operator):
+    def end_transaction(operator: bpy.types.Operator) -> None:
         IfcStore.current_transaction = ""
         operator.transaction_key = ""
 
     @staticmethod
-    def add_transaction_operation(operator, rollback=None, commit=None):
+    def add_transaction_operation(operator: bpy.types.Operator, rollback=None, commit=None) -> None:
         key = getattr(operator, "transaction_key", None)
         data = getattr(operator, "transaction_data", None)
         bpy.context.scene.BIMProperties.last_transaction = key
@@ -380,7 +388,7 @@ class IfcStore:
         IfcStore.future = []
 
     @staticmethod
-    def undo(until_key=None):
+    def undo(until_key=None) -> None:
         BrickStore.undo()
         if not IfcStore.history:
             return
@@ -395,7 +403,7 @@ class IfcStore:
             IfcStore.future.append(event)
 
     @staticmethod
-    def redo(until_key=None):
+    def redo(until_key=None) -> None:
         BrickStore.redo()
 
         if not IfcStore.future:

src/blenderbim/blenderbim/bim/import_ifc.py

@@ -32,24 +32,28 @@ import ifcopenshell.geom
 import ifcopenshell.util.unit
 import ifcopenshell.util.element
 import ifcopenshell.util.geolocation
+import ifcopenshell.util.placement
+import ifcopenshell.util.representation
 import blenderbim.tool as tool
+import ifcopenshell.ifcopenshell_wrapper as ifcopenshell_wrapper
 from itertools import chain, accumulate
-from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.ifc import IfcStore, IFC_CONNECTED_TYPE
+from blenderbim.tool.loader import OBJECT_DATA_TYPE
 from blenderbim.bim.module.drawing.prop import ANNOTATION_TYPES_DATA
-from typing import Dict
+from typing import Dict, Union, Optional, Any
 
 
 class MaterialCreator:
     def __init__(self, ifc_import_settings: IfcImportSettings, ifc_importer: IfcImporter):
-        self.mesh = None
-        self.obj = None
+        self.mesh: bpy.types.Mesh = None
+        self.obj: bpy.types.Object = None
         self.materials: Dict[int, bpy.types.Material] = {}
         self.styles: Dict[int, bpy.types.Material] = {}
-        self.parsed_meshes = set()
+        self.parsed_meshes: set[str] = set()
         self.ifc_import_settings = ifc_import_settings
         self.ifc_importer = ifc_importer
 
-    def create(self, element, obj, mesh):
+    def create(self, element: ifcopenshell.entity_instance, obj: bpy.types.Object, mesh: bpy.types.Mesh) -> None:
         self.mesh = mesh
         # as ifcopenshell triangulates the mesh, we need to merge it to quads again
         self.obj = obj
@@ -65,7 +69,7 @@ class MaterialCreator:
             self.assign_material_slots_to_faces()
         tool.Geometry.record_object_materials(obj)
 
-    def add_default_material(self, element):
+    def add_default_material(self, element: ifcopenshell.entity_instance) -> None:
         element_material = ifcopenshell.util.element.get_material(element)
         if not element_material:
             return
@@ -83,14 +87,17 @@ class MaterialCreator:
             self.mesh.materials.append(self.materials[material.id()])
             return
 
-    def load_existing_materials(self):
+    def load_existing_materials(self) -> None:
         for material in bpy.data.materials:
             if material.BIMObjectProperties.ifc_definition_id:
                 self.materials[material.BIMObjectProperties.ifc_definition_id] = material
             if material.BIMMaterialProperties.ifc_style_id:
                 self.styles[material.BIMMaterialProperties.ifc_style_id] = material
 
-    def parse_representations(self, element):
+    def parse_representations(self, element: ifcopenshell.entity_instance) -> bool:
+        """Search for styles in in all `element`'s representation items
+        and adds them to `self.mesh.materials`.\n
+        Returns `True` if any styles were found and added, returns `False` otherwise."""
         has_parsed = False
         if hasattr(element, "Representation"):
             for representation in element.Representation.Representations:
@@ -104,7 +111,7 @@ class MaterialCreator:
                     has_parsed = True
         return has_parsed
 
-    def parse_representation(self, representation):
+    def parse_representation(self, representation: ifcopenshell.entity_instance) -> bool:
         has_parsed = False
         representation_items = self.resolve_all_stylable_representation_items(representation)
         for item in representation_items:
@@ -112,9 +119,9 @@ class MaterialCreator:
                 has_parsed = True
         return has_parsed
 
-    def parse_representation_item(self, item):
+    def parse_representation_item(self, item: ifcopenshell.entity_instance) -> bool:
         if not item.StyledByItem:
-            return
+            return False
         style_ids = []
         styles = list(item.StyledByItem[0].Styles)
         while styles:
@@ -124,11 +131,12 @@ class MaterialCreator:
             elif style.is_a("IfcPresentationStyleAssignment"):
                 styles.extend(style.Styles)
         if not style_ids:
-            return
+            return False
         for style_id in style_ids:
             material = self.styles[style_id]
 
-            def get_ifc_coordinate(material):
+            def get_ifc_coordinate(material: ifcopenshell.entity_instance) -> Union[ifcopenshell.entity_instance, None]:
+                """returns IfcTextureCoordinate"""
                 texture_style = tool.Style.get_texture_style(material)
                 if not texture_style:
                     return
@@ -149,7 +157,7 @@ class MaterialCreator:
                 self.mesh.materials.append(material)
         return True
 
-    def assign_material_slots_to_faces(self):
+    def assign_material_slots_to_faces(self) -> None:
         if "ios_materials" not in self.mesh or not self.mesh["ios_materials"]:
             return
         if len(self.mesh.materials) == 1:
@@ -157,8 +165,12 @@ class MaterialCreator:
         material_to_slot = {}
 
         if len(self.mesh.polygons) == len(self.mesh["ios_material_ids"]):
-            for i, style_id in enumerate(self.mesh["ios_materials"]):
-                slot_index = self.mesh.materials.find(self.styles[style_id].name)
+            for i, style_or_material_id in enumerate(self.mesh["ios_materials"]):
+                if style_or_material_id in self.styles:
+                    blender_material = self.styles[style_or_material_id]
+                else:
+                    blender_material = self.materials[style_or_material_id]
+                slot_index = self.mesh.materials.find(blender_material.name)
                 material_to_slot[i] = slot_index
 
             material_index = [
@@ -166,7 +178,10 @@ class MaterialCreator:
             ]
             self.mesh.polygons.foreach_set("material_index", material_index)
 
-    def resolve_all_stylable_representation_items(self, representation):
+    def resolve_all_stylable_representation_items(
+        self, representation: ifcopenshell.entity_instance
+    ) -> list[ifcopenshell.entity_instance]:
+        """returns list of resolved IfcRepresentationItems"""
         items = []
         for item in representation.Items:
             if item.is_a("IfcMappedItem"):
@@ -187,21 +202,27 @@ class IfcImporter:
     def __init__(self, ifc_import_settings):
         self.ifc_import_settings = ifc_import_settings
         self.diff = None
-        self.file = None
-        self.context_settings = []
-        self.gross_context_settings = []
+        self.file: ifcopenshell.file = None
+        self.context_settings: list[ifcopenshell.geom.main.settings] = []
+        self.gross_context_settings: list[ifcopenshell.geom.main.settings] = []
         self.contexts = []
         self.project = None
         self.has_existing_project = False
-        self.collections = {}
-        self.elements = set()
-        self.type_collection = None
+        # element guids to blender collections mapping
+        self.collections: dict[str, bpy.types.Collection] = {}
+        self.elements: set[ifcopenshell.entity_instance] = set()
+        self.annotations: set[ifcopenshell.entity_instance] = set()
+        self.gross_elements: set[ifcopenshell.entity_instance] = set()
+        self.element_types: set[ifcopenshell.entity_instance] = set()
+        self.spatial_elements: set[ifcopenshell.entity_instance] = set()
+        self.type_collection: bpy.types.Collection = None
         self.type_products = {}
         self.meshes = {}
         self.mesh_shapes = {}
         self.time = 0
         self.unit_scale = 1
-        self.added_data = {}
+        # ifc definition ids to blender elements mapping
+        self.added_data: dict[int, IFC_CONNECTED_TYPE] = {}
         self.native_elements = set()
         self.native_data = {}
         self.progress = 0
@@ -440,7 +461,9 @@ class IfcImporter:
             for element in self.gross_elements:
                 print(element)
 
-    def get_spatial_elements_filtered_by_elements(self, elements):
+    def get_spatial_elements_filtered_by_elements(
+        self, elements: set[ifcopenshell.entity_instance]
+    ) -> set[ifcopenshell.entity_instance]:
         leaf_spatial_elements = set([ifcopenshell.util.element.get_container(e) for e in elements])
         results = set()
         for spatial_element in leaf_spatial_elements:
@@ -776,7 +799,7 @@ class IfcImporter:
                 continue
             self.create_element_type(element_type)
 
-    def create_element_type(self, element):
+    def create_element_type(self, element: ifcopenshell.entity_instance) -> None:
         self.ifc_import_settings.logger.info("Creating object %s", element)
         mesh = None
         if self.ifc_import_settings.should_load_geometry:
@@ -833,17 +856,23 @@ class IfcImporter:
             self.create_product(element, mesh=mesh)
         print("Done creating geometry")
 
-    def create_spatial_elements(self):
-        self.create_generic_elements(self.spatial_elements)
+    def create_spatial_elements(self) -> None:
+        if bpy.context.preferences.addons["blenderbim"].preferences.spatial_elements_unselectable:
+            self.create_generic_elements(self.spatial_elements, unselectable=True)
+        else:
+            self.create_generic_elements(self.spatial_elements, unselectable=False)
 
-    def create_elements(self):
+
+    def create_elements(self) -> None:
         self.create_generic_elements(self.elements)
         tmp = self.context_settings
         self.context_settings = self.gross_context_settings
         self.create_generic_elements(self.gross_elements)
         self.context_settings = tmp
 
-    def create_generic_shape(self, element):
+    def create_generic_shape(
+        self, element: ifcopenshell.entity_instance
+    ) -> Union[ifcopenshell_wrapper.TriangulationElement, None]:
         for settings in self.context_settings:
             try:
                 result = ifcopenshell.geom.create_shape(settings, element)
@@ -852,7 +881,7 @@ class IfcImporter:
             except:
                 pass
 
-    def create_generic_elements(self, elements):
+    def create_generic_elements(self, elements: set[ifcopenshell.entity_instance], unselectable=False) -> None:
         if isinstance(self.file, ifcopenshell.sqlite):
             return self.create_generic_sqlite_elements(elements)
 
@@ -866,12 +895,17 @@ class IfcImporter:
             elements -= products
 
         total = len(elements)
+        objects = set()
         for i, element in enumerate(elements):
             if i % 250 == 0:
                 print("{} / {} elements processed ...".format(i, total))
-            self.create_product(element)
+            objects.add(self.create_product(element))
 
-    def create_generic_sqlite_elements(self, elements):
+        if unselectable:
+            for obj in objects:
+                obj.hide_select = True
+
+    def create_generic_sqlite_elements(self, elements: set[ifcopenshell.entity_instance]) -> None:
         self.geometry_cache = self.file.get_geometry([e.id() for e in elements])
         for geometry_id, geometry in self.geometry_cache["geometry"].items():
             mesh_name = tool.Loader.get_mesh_name(type("Geometry", (), {"id": geometry_id}))
@@ -918,7 +952,9 @@ class IfcImporter:
                 mesh = self.meshes.get(mesh_name)
             self.create_product(element, mesh=mesh)
 
-    def create_products(self, products, settings=None):
+    def create_products(
+        self, products, settings: Optional[ifcopenshell.geom.main.settings] = None
+    ) -> set[ifcopenshell.entity_instance]:
         results = set()
         if not products:
             return results
@@ -1041,7 +1077,7 @@ class IfcImporter:
                         return mapped_representation
         return None
 
-    def create_pointclouds(self, products):
+    def create_pointclouds(self, products: set[ifcopenshell.entity_instance]) -> set[ifcopenshell.entity_instance]:
         result = set()
         for product in products:
             representation = self.get_pointcloud_representation(product)
@@ -1052,7 +1088,9 @@ class IfcImporter:
 
         return result
 
-    def create_pointcloud(self, product, representation):
+    def create_pointcloud(
+        self, product: ifcopenshell.entity_instance, representation: ifcopenshell.entity_instance
+    ) -> Union[ifcopenshell.entity_instance, None]:
         placement_matrix = self.get_element_matrix(product)
         vertex_list = []
         for item in representation.Items:
@@ -1080,7 +1118,12 @@ class IfcImporter:
         self.link_element(product, obj)
         return product
 
-    def create_product(self, element, shape=None, mesh=None):
+    def create_product(
+        self,
+        element: ifcopenshell.entity_instance,
+        shape: Optional[Any] = None,
+        mesh: Optional[OBJECT_DATA_TYPE] = None,
+    ) -> Union[bpy.types.Object, None]:
         if element is None:
             return
 
@@ -1125,6 +1168,9 @@ class IfcImporter:
 
         return obj
 
+    def load_existing_meshes(self) -> None:
+        self.meshes.update({m.name: m for m in bpy.data.meshes})
+
     def get_representation_item_material_name(self, item):
         if not item.StyledByItem:
             return
@@ -1531,18 +1577,19 @@ class IfcImporter:
             "{}/{}".format(self.project["ifc"].is_a(), self.project["ifc"].Name)
         )
         obj = self.create_product(self.project["ifc"])
+        obj.hide_select = True
         self.project["blender"].objects.link(obj)
         self.project["blender"].BIMCollectionProperties.obj = obj
         obj.BIMObjectProperties.collection = self.collections[project.GlobalId] = self.project["blender"]
 
-    def create_collections(self):
+    def create_collections(self) -> None:
         self.create_spatial_decomposition_collections()
         if self.ifc_import_settings.collection_mode == "DECOMPOSITION":
             self.create_aggregate_and_nest_collections()
         elif self.ifc_import_settings.collection_mode == "SPATIAL_DECOMPOSITION":
             pass
 
-    def create_spatial_decomposition_collections(self):
+    def create_spatial_decomposition_collections(self) -> None:
         for rel_aggregate in self.project["ifc"].IsDecomposedBy or []:
             self.create_spatial_decomposition_collection(self.project["blender"], rel_aggregate.RelatedObjects)
 
@@ -1555,7 +1602,9 @@ class IfcImporter:
         tool.Loader.create_project_collection("Views")
         self.type_collection = tool.Loader.create_project_collection("Types")
 
-    def create_spatial_decomposition_collection(self, parent, related_objects):
+    def create_spatial_decomposition_collection(
+        self, parent: Union[bpy.types.Collection, bpy.types.Object], related_objects: list[ifcopenshell.entity_instance]
+    ) -> None:
         for element in related_objects:
             if element not in self.spatial_elements:
                 continue
@@ -1595,7 +1644,11 @@ class IfcImporter:
             ] + [
                 r
                 for r in self.file.by_type("IfcRelNests")
-                if (r.RelatingObject.is_a("IfcElement") or r.RelatingObject.is_a("IfcElementType"))
+                if (
+                    r.RelatingObject.is_a("IfcElement")
+                    or r.RelatingObject.is_a("IfcElementType")
+                    or (r.RelatingObject.is_a("IfcPositioningElement") and not r.RelatingObject.is_a("IfcGrid"))
+                )
                 and [e for e in r.RelatedObjects if not e.is_a("IfcPort")]
             ]
 
@@ -1605,9 +1658,9 @@ class IfcImporter:
             self.ifc_import_settings.collection_mode = "SPATIAL_DECOMPOSITION"
             return
 
-        aggregates = {}
+        aggregates: dict[str, dict] = {}
         for rel_aggregate in rel_aggregates:
-            element = rel_aggregate.RelatingObject
+            element: ifcopenshell.entity_instance = rel_aggregate.RelatingObject
             collection = bpy.data.collections.new(tool.Loader.get_name(element))
             aggregates[element.GlobalId] = {"element": element, "collection": collection}
             self.collections[element.GlobalId] = collection
@@ -1659,7 +1712,9 @@ class IfcImporter:
                 continue
             self.create_style(style)
 
-    def create_style(self, style, blender_material=None):
+    def create_style(
+        self, style: ifcopenshell.entity_instance, blender_material: Optional[bpy.types.Material] = None
+    ) -> None:
         if not blender_material:
             name = style.Name or str(style.id())
             blender_material = bpy.data.materials.new(name)
@@ -1676,18 +1731,20 @@ class IfcImporter:
         else:
             blender_material.BIMStyleProperties.active_style_type = "Shading"
 
-    def place_objects_in_collections(self):
+    def place_objects_in_collections(self) -> None:
         for ifc_definition_id, obj in self.added_data.items():
             if isinstance(obj, bpy.types.Object):
                 self.place_object_in_collection(self.file.by_id(ifc_definition_id), obj)
 
-    def place_object_in_collection(self, element, obj):
+    def place_object_in_collection(self, element: ifcopenshell.entity_instance, obj: bpy.types.Object) -> None:
         if self.ifc_import_settings.collection_mode == "DECOMPOSITION":
             self.place_object_in_decomposition_collection(element, obj)
         elif self.ifc_import_settings.collection_mode == "SPATIAL_DECOMPOSITION":
             self.place_object_in_spatial_decomposition_collection(element, obj)
 
-    def place_object_in_decomposition_collection(self, element, obj):
+    def place_object_in_decomposition_collection(
+        self, element: ifcopenshell.entity_instance, obj: bpy.types.Object
+    ) -> None:
         if element.is_a("IfcProject"):
             return
         elif element.is_a("IfcGridAxis"):
@@ -1704,10 +1761,12 @@ class IfcImporter:
         elif getattr(element, "Nests", None) and not element.is_a("IfcPort"):
             nest = ifcopenshell.util.element.get_nest(element)
             return self.collections[nest.GlobalId].objects.link(obj)
-        else:
-            return self.place_object_in_spatial_decomposition_collection(element, obj)
 
-    def place_object_in_spatial_decomposition_collection(self, element, obj):
+        return self.place_object_in_spatial_decomposition_collection(element, obj)
+
+    def place_object_in_spatial_decomposition_collection(
+        self, element: ifcopenshell.entity_instance, obj: bpy.types.Object
+    ) -> None:
         if element.is_a("IfcProject"):
             return
         elif element.is_a("IfcGridAxis"):
@@ -1751,7 +1810,7 @@ class IfcImporter:
             if rel.is_a("IfcRelAssignsToGroup") and rel.RelatingGroup.ObjectType == "DRAWING":
                 return rel.RelatingGroup
 
-    def get_element_matrix(self, element):
+    def get_element_matrix(self, element: ifcopenshell.entity_instance) -> np.array:
         if isinstance(element, ifcopenshell.sqlite_entity):
             result = self.geometry_cache["shapes"][element.id()]["matrix"]
         else:
@@ -1761,7 +1820,7 @@ class IfcImporter:
         result[2][3] *= self.unit_scale
         return result
 
-    def scale_matrix(self, matrix):
+    def scale_matrix(self, matrix: np.array) -> np.array:
         matrix[0][3] *= self.unit_scale
         matrix[1][3] *= self.unit_scale
         matrix[2][3] *= self.unit_scale
@@ -1793,7 +1852,7 @@ class IfcImporter:
             ):
                 return representation.Items[0].MappingTarget
 
-    def create_curve(self, element, shape):
+    def create_curve(self, element: ifcopenshell.entity_instance, shape) -> bpy.types.Curve:
         if hasattr(shape, "geometry"):
             geometry = shape.geometry
         else:
@@ -1818,12 +1877,13 @@ class IfcImporter:
             polyline.points[-1].co = mathutils.Vector(v2)
         return curve
 
-    def create_mesh(self, element, shape):
+    def create_mesh(self, element: ifcopenshell.entity_instance, shape) -> bpy.types.Mesh:
         try:
             if hasattr(shape, "geometry"):
-                geometry = shape.geometry
+                # shape is ifcopenshell_wrapper.TriangulationElement
+                geometry: ifcopenshell_wrapper.Triangulation = shape.geometry
             else:
-                geometry = shape
+                geometry: ifcopenshell_wrapper.Triangulation = shape
 
             mesh = bpy.data.meshes.new(tool.Loader.get_mesh_name(geometry))
 
@@ -1989,7 +2049,7 @@ class IfcImportSettings:
         self.has_filter = None
         self.should_filter_spatial_elements = True
         self.should_setup_viewport_camera = True
-        self.elements = set()
+        self.elements: set[ifcopenshell.entity_instance] = set()
         self.collection_mode = "DECOMPOSITION"
 
     @staticmethod

src/blenderbim/blenderbim/bim/module/aggregate/operator.py

@@ -44,7 +44,12 @@ class BIM_OT_aggregate_assign_object(bpy.types.Operator, Operator):
     def _execute(self, context):
         relating_obj = None
         if self.relating_object:
-            relating_obj = tool.Ifc.get_object(tool.Ifc.get().by_id(self.relating_object))
+            element = tool.Ifc.get().by_id(self.relating_object)
+            if element.IsDecomposedBy:
+                relating_obj = tool.Ifc.get_object(element)
+            else:
+                assembly = element.Decomposes[0].RelatingObject
+                relating_obj = tool.Ifc.get_object(assembly)
         elif context.active_object:
             relating_obj = context.active_object
         if not relating_obj:
@@ -89,7 +94,7 @@ class BIM_OT_aggregate_unassign_object(bpy.types.Operator, Operator):
                 relating_obj=tool.Ifc.get_object(aggregate),
                 related_obj=tool.Ifc.get_object(element),
             )
-            
+
             # Removes Pset related to Linked Aggregates
             if not element.is_a('IfcElementAssembly'):
                 pset = ifcopenshell.util.element.get_pset(element, 'BBIM_Linked_Aggregate')
@@ -97,7 +102,7 @@ class BIM_OT_aggregate_unassign_object(bpy.types.Operator, Operator):
                     pset = tool.Ifc.get().by_id(pset["id"])
                     ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), pset=pset)
 
-
+              
 class BIM_OT_enable_editing_aggregate(bpy.types.Operator, Operator):
     """Enable editing aggregation relationship"""
 
@@ -202,15 +207,29 @@ class BIM_OT_select_aggregate(bpy.types.Operator):
     bl_label = "Select Aggregate"
     bl_options = {"REGISTER", "UNDO"}
     obj: bpy.props.StringProperty()
+    select_parts: bpy.props.BoolProperty(default=False)
+
+    @classmethod
+    def description(cls, context, properties):
+        if properties.select_parts:
+            return "Select Aggregate and Parts"
+        else:
+            return "Select Aggregate"
 
     def execute(self, context):
         self.file = IfcStore.get_file()
         obj = bpy.data.objects.get(self.obj) or context.active_object
         aggregate = ifcopenshell.util.element.get_aggregate(tool.Ifc.get_entity(obj))
         aggregate_obj = tool.Ifc.get_object(aggregate)
+        if self.select_parts:
+            bpy.ops.bim.select_parts(obj=aggregate_obj.name)
         if aggregate_obj in context.selectable_objects:
-            aggregate_obj.select_set(True)
-            bpy.context.view_layer.objects.active = aggregate_obj
+            tool.Blender.set_objects_selection(
+                context,
+                aggregate_obj,
+                [aggregate_obj],
+                clear_previous_selection=not self.select_parts,
+            )
         return {"FINISHED"}
 
 
@@ -238,6 +257,7 @@ class BIM_OT_add_part_to_object(bpy.types.Operator, Operator):
             part_name=self.part_name,
         )
 
+
 class BIM_OT_break_link_to_other_aggregates(bpy.types.Operator, Operator):
     bl_idname = "bim.break_link_to_other_aggregates"
     bl_label = "Break link to other aggregates"
@@ -252,22 +272,23 @@ class BIM_OT_break_link_to_other_aggregates(bpy.types.Operator, Operator):
             return []
 
         parts = ifcopenshell.util.element.get_parts(aggregate)
-        
+
         for part in parts:
-            pset = ifcopenshell.util.element.get_pset(part, 'BBIM_Linked_Aggregate')
+            pset = ifcopenshell.util.element.get_pset(part, "BBIM_Linked_Aggregate")
             pset = tool.Ifc.get().by_id(pset["id"])
             ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), pset=pset)
-        
+
         linked_aggregate_group = [
             r.RelatingGroup
             for r in getattr(aggregate, "HasAssignments", []) or []
             if r.is_a("IfcRelAssignsToGroup")
             if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
         ]
-        tool.Ifc.run("group.unassign_group", group=linked_aggregate_group[0], product=aggregate)
-        
+        tool.Ifc.run("group.unassign_group", group=linked_aggregate_group[0], products=[aggregate])
+
         return {"FINISHED"}
 
+
 class BIM_OT_select_linked_aggregates(bpy.types.Operator, Operator):
     bl_idname = "bim.select_linked_aggregates"
     bl_label = "Select linked aggregates"
@@ -280,17 +301,17 @@ class BIM_OT_select_linked_aggregates(bpy.types.Operator, Operator):
             return []
         if not element:
             return []
-        
+
         linked_aggregate_group = [
             r.RelatingGroup
             for r in getattr(aggregate, "HasAssignments", []) or []
             if r.is_a("IfcRelAssignsToGroup")
             if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
         ]
-        
+
         for obj in context.selected_objects:
             obj.select_set(False)
-            
+
         for rel in linked_aggregate_group[0].IsGroupedBy or []:
             for element in rel.RelatedObjects:
                 obj = tool.Ifc.get_object(element)

src/blenderbim/blenderbim/bim/module/aggregate/ui.py

@@ -62,8 +62,12 @@ class BIM_PT_aggregate(Panel):
             row = layout.row(align=True)
             if AggregateData.data["has_relating_object"]:
                 row.label(text=AggregateData.data["relating_object_label"], icon="TRIA_UP")
+                op = row.operator("bim.select_aggregate", icon="OBJECT_DATA", text="")
+                op.obj = context.active_object.name
+                op.select_parts = False
                 op = row.operator("bim.select_aggregate", icon="RESTRICT_SELECT_OFF", text="")
                 op.obj = context.active_object.name
+                op.select_parts = True
                 row.operator("bim.enable_editing_aggregate", icon="GREASEPENCIL", text="")
                 row.operator("bim.add_aggregate", icon="ADD", text="")
                 op = row.operator("bim.aggregate_unassign_object", icon="X", text="")

src/blenderbim/blenderbim/bim/module/attribute/operator.py

@@ -47,10 +47,18 @@ class EnableEditingAttributes(bpy.types.Operator):
             obj = bpy.data.objects.get(self.obj)
         elif self.obj_type == "Material":
             obj = bpy.data.materials.get(self.obj)
-        oprops = obj.BIMObjectProperties
         props = obj.BIMAttributeProperties
         props.attributes.clear()
 
+        element = tool.Ifc.get_entity(obj)
+        has_inherited_predefined_type = False
+        if not element.is_a("IfcTypeObject") and (element_type := ifcopenshell.util.element.get_type(element)):
+            # Allow for None due to https://github.com/buildingSMART/IFC4.3.x-development/issues/818
+            has_inherited_predefined_type = ifcopenshell.util.element.get_predefined_type(element_type) not in (
+                "NOTDEFINED",
+                None,
+            )
+
         def callback(name, prop, data):
             if name in ("RefLatitude", "RefLongitude"):
                 new = props.attributes.add()
@@ -62,10 +70,11 @@ class EnableEditingAttributes(bpy.types.Operator):
                 new.string_value = "" if new.is_null else json.dumps(data[name])
                 blenderbim.bim.helper.add_attribute_description(new)
                 new.description += " The degrees, minutes and seconds should follow this format : [12,34,56]"
+            if name in ("PredefinedType", "ObjectType") and has_inherited_predefined_type:
+                props.attributes.remove(len(props.attributes) - 1)
+                return True
 
-        blenderbim.bim.helper.import_attributes2(
-            tool.Ifc.get().by_id(oprops.ifc_definition_id), props.attributes, callback=callback
-        )
+        blenderbim.bim.helper.import_attributes2(element, props.attributes, callback=callback)
         props.is_editing_attributes = True
         return {"FINISHED"}
 
@@ -120,20 +129,46 @@ class EditAttributes(bpy.types.Operator, Operator):
         return {"FINISHED"}
 
 
-class GenerateGlobalId(bpy.types.Operator):
+class GenerateGlobalId(bpy.types.Operator, Operator):
     bl_idname = "bim.generate_global_id"
     bl_label = "Regenerate GlobalId"
+    bl_description = "Regenerate GlobalId\n\nSHIFT+CLICK to regenerate GlobalIds for all selected objects"
     bl_options = {"REGISTER", "UNDO"}
 
-    def execute(self, context):
-        index = context.active_object.BIMAttributeProperties.attributes.find("GlobalId")
-        if index >= 0:
-            global_id = context.active_object.BIMAttributeProperties.attributes[index]
+    use_selected: bpy.props.BoolProperty(name="Use All Selected Objects", default=False, options={"SKIP_SAVE"})
+
+    def invoke(self, context, event):
+        # using all selected objects on shift+click
+        # make sure to use SKIP_SAVE on property, otherwise it might get stuck
+        if event.type == "LEFTMOUSE" and event.shift:
+            self.use_selected = True
+        return self.execute(context)
+
+    def _execute(self, context):
+        if self.use_selected:
+            for obj in context.selected_objects:
+                element = tool.Ifc.get_entity(obj)
+                if not element or not element.is_a("IfcRoot"):
+                    continue
+                element.GlobalId = ifcopenshell.guid.new()
+
+        obj = context.active_object
+        if not obj or not obj.BIMAttributeProperties.is_editing_attributes:
+            return {"FINISHED"}
+
+        props = obj.BIMAttributeProperties
+        element = tool.Ifc.get_entity(obj)
+
+        if not element.is_a("IfcRoot"):
+            return {"FINISHED"}
+
+        if self.use_selected and obj in context.selected_objects:
+            # guid value was already regenerated, just update the ui prop
+            guid_value = element.GlobalId
         else:
-            global_id = context.active_object.BIMAttributeProperties.attributes.add()
-        global_id.name = "GlobalId"
-        global_id.data_type = "string"
-        global_id.string_value = ifcopenshell.guid.new()
+            guid_value = ifcopenshell.guid.new()
+
+        props.attributes["GlobalId"].string_value = guid_value
         return {"FINISHED"}
 
 

src/blenderbim/blenderbim/bim/module/boundary/__init__.py

@@ -22,6 +22,7 @@ from . import ui, operator, prop
 classes = (
     operator.AddBoundary,
     operator.ColourByRelatedBuildingElement,
+    operator.DecorateBoundaries,
     operator.DisableEditingBoundary,
     operator.DisableEditingBoundaryGeometry,
     operator.EditBoundaryAttributes,

src/blenderbim/blenderbim/bim/module/boundary/operator.py

@@ -24,6 +24,7 @@ import mathutils
 import numpy as np
 import multiprocessing
 import ifcopenshell.api
+import ifcopenshell.geom
 import ifcopenshell.util.unit
 import ifcopenshell.util.shape
 import ifcopenshell.util.element
@@ -37,6 +38,7 @@ from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.model.decorator import ProfileDecorator
 from blenderbim.bim.module.boundary.decorator import BoundaryDecorator
 import blenderbim.core
+import blenderbim.core.geometry
 
 
 def get_boundaries_collection(blender_space):
@@ -147,7 +149,9 @@ class Loader:
         self.ifc_importer = import_ifc.IfcImporter(ifc_import_settings)
         self.ifc_importer.file = self.ifc_file
 
-    def load_boundary(self, boundary, blender_space=None):
+    def load_boundary(
+        self, boundary: ifcopenshell.entity_instance, blender_space: bpy.types.Object = None
+    ) -> bpy.types.Object:
         if not blender_space:
             if not boundary.RelatingSpace:
                 self.operator.report(
@@ -509,10 +513,10 @@ class DisableEditingBoundaryGeometry(bpy.types.Operator, tool.Ifc.Operator):
 class ShowBoundaries(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.show_boundaries"
     bl_label = "Show Boundaries"
+    bl_description = "Load selected objects boundaries if they are not loaded"
     bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context):
-        props = bpy.context.scene.BIMBoundaryProperties
         loader = Loader(self)
         for obj in context.selected_objects:
             element = tool.Ifc.get_entity(obj)
@@ -524,7 +528,7 @@ class ShowBoundaries(bpy.types.Operator, tool.Ifc.Operator):
             for rel in element.BoundedBy or []:
                 boundary_obj = loader.load_boundary(rel, obj)
                 tool.Boundary.decorate_boundary(boundary_obj)
-        BoundaryDecorator.install(bpy.context)
+        BoundaryDecorator.install(context)
         return {"FINISHED"}
 
 
@@ -557,6 +561,36 @@ class HideBoundaries(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
+class DecorateBoundaries(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.decorate_boundaries"
+    bl_label = "Toggle Boundaries Decorations"
+    bl_description = "Add special decorations for all boundaries in the scene or hide them if they are already added"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        props = context.scene.BIMBoundaryProperties
+        # filter not decorated boundaries and add decorations for them
+        decorated_boundaries = set([i.obj for i in props.boundaries])
+        active_boundaries = set()
+        for element in tool.Ifc.get().by_type("IfcRelSpaceBoundary"):
+            obj = tool.Ifc.get_object(element)
+            if obj is not None:
+                active_boundaries.add(obj)
+
+        boundaries_to_decorate = active_boundaries - decorated_boundaries
+        if boundaries_to_decorate:
+            for obj in boundaries_to_decorate:
+                tool.Boundary.decorate_boundary(obj)
+            BoundaryDecorator.install(context)
+        else:
+            for obj in decorated_boundaries:
+                tool.Boundary.undecorate_boundary(obj)
+            props.boundaries.clear()
+            BoundaryDecorator.uninstall()
+            tool.Blender.update_viewport()
+        return {"FINISHED"}
+
+
 class AddBoundary(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.add_boundary"
     bl_label = "Add Boundary"

src/blenderbim/blenderbim/bim/module/cad/prop.py

@@ -24,10 +24,10 @@ from math import pi
 
 class BIMCadProperties(PropertyGroup):
     resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
-    radius: bpy.props.FloatProperty(name="Radius", default=0.1)
-    distance: bpy.props.FloatProperty(name="Distance", default=0.1)
-    x: bpy.props.FloatProperty(name="X", default=0.2)
-    y: bpy.props.FloatProperty(name="Y", default=0.1)
+    radius: bpy.props.FloatProperty(name="Radius", default=0.1, subtype="DISTANCE")
+    distance: bpy.props.FloatProperty(name="Distance", default=0.1, subtype="DISTANCE")
+    x: bpy.props.FloatProperty(name="X", default=0.2, subtype="DISTANCE")
+    y: bpy.props.FloatProperty(name="Y", default=0.1, subtype="DISTANCE")
     gable_roof_edge_angle: bpy.props.FloatProperty(
         name="Gable Roof Edge Angle", default=pi / 2, soft_min=0, soft_max=pi / 2, subtype="ANGLE"
     )

src/blenderbim/blenderbim/bim/module/cad/workspace.py

@@ -20,6 +20,7 @@ import os
 import bpy
 import blenderbim.tool as tool
 import blenderbim.bim.module.type.prop as type_prop
+import ifcopenshell.util.unit
 from bpy.types import WorkSpaceTool
 from blenderbim.bim.module.model.data import AuthoringData, RailingData, RoofData
 
@@ -239,8 +240,9 @@ class CadHotkey(bpy.types.Operator):
                 row.prop(props, "resolution")
 
     def hotkey_S_C(self):
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         if self.is_profile():
-            bpy.ops.bim.add_ifccircle(radius=self.props.radius)
+            bpy.ops.bim.add_ifccircle(radius=self.props.radius / si_conversion)
         else:
             bpy.ops.bim.cad_arc_from_2_points()
 
@@ -248,13 +250,15 @@ class CadHotkey(bpy.types.Operator):
         bpy.ops.bim.cad_trim_extend()
 
     def hotkey_S_F(self):
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         if self.is_profile():
-            bpy.ops.bim.add_ifcarcindex_fillet(radius=self.props.radius)
+            bpy.ops.bim.add_ifcarcindex_fillet(radius=self.props.radius / si_conversion)
         else:
-            bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius)
+            bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius / si_conversion)
 
     def hotkey_S_O(self):
-        bpy.ops.bim.cad_offset(distance=self.props.distance)
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        bpy.ops.bim.cad_offset(distance=self.props.distance / si_conversion)
 
     def hotkey_S_Q(self):
         element = tool.Ifc.get_entity(bpy.context.active_object)
@@ -270,7 +274,8 @@ class CadHotkey(bpy.types.Operator):
 
     def hotkey_S_R(self):
         if self.is_profile():
-            bpy.ops.bim.add_rectangle(x=self.props.x, y=self.props.y)
+            si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+            bpy.ops.bim.add_rectangle(x=self.props.x / si_conversion, y=self.props.y / si_conversion)
         elif (
             (RoofData.is_loaded or not RoofData.load())
             and RoofData.data["pset_data"]

src/blenderbim/blenderbim/bim/module/clash/__init__.py

@@ -25,15 +25,12 @@ classes = (
     operator.ExecuteIfcClash,
     operator.ExportClashSets,
     operator.ImportClashSets,
-    operator.LoadIfcClashes,
-    operator.SaveIfcClashes,
     operator.LoadSmartGroupsForActiveClashSet,
     operator.RemoveClashSet,
     operator.RemoveClashSource,
     operator.SelectClash,
     operator.SelectClashResults,
     operator.SelectClashSource,
-    operator.SelectIfcClashResults,
     operator.SelectSmartGroup,
     operator.SelectSmartGroupedClashesPath,
     operator.SmartClashGroup,
@@ -44,7 +41,6 @@ classes = (
     prop.BIMClashProperties,
     ui.BIM_PT_ifcclash,
     ui.BIM_PT_clash_manager,
-    ui.BIM_PT_dumb_clash_manager,
     ui.BIM_PT_smart_clash_manager,
     ui.BIM_UL_clashes,
     ui.BIM_UL_clash_sets,

src/blenderbim/blenderbim/bim/module/clash/data.py

@@ -0,0 +1,52 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2024 Dion Moult <dion@thinkmoult.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+import bpy
+import json
+import ifcopenshell.util.element
+import blenderbim.tool as tool
+
+
+def refresh():
+    ClashData.is_loaded = False
+
+
+class ClashData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data = {}
+        cls.data["saved_searches"] = cls.saved_searches()
+
+    @classmethod
+    def saved_searches(cls):
+        if not tool.Ifc.get():
+            return []
+        groups = tool.Ifc.get().by_type("IfcGroup")
+        results = []
+        for group in groups:
+            try:
+                data = json.loads(group.Description)
+                if isinstance(data, dict) and data.get("type", None) == "BBIM_Search" and data.get("query", None):
+                    results.append(group)
+            except:
+                pass
+        return [(str(g.id()), g.Name or "Unnamed", "") for g in sorted(results, key=lambda x: x.Name or "Unnamed")]

src/blenderbim/blenderbim/bim/module/clash/decorator.py

@@ -0,0 +1,102 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2024 Dion Moult <dion@thinkmoult.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+import blf
+import gpu
+import bmesh
+import blenderbim.tool as tool
+from bpy.types import SpaceView3D
+from mathutils import Vector
+from gpu_extras.batch import batch_for_shader
+from bpy_extras.view3d_utils import location_3d_to_region_2d
+
+
+class ClashDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
+
+    def draw_text(self, context):
+        self.addon_prefs = context.preferences.addons["blenderbim"].preferences
+        selected_elements_color = self.addon_prefs.decorator_color_selected
+        unselected_elements_color = self.addon_prefs.decorator_color_unselected
+        special_elements_color = self.addon_prefs.decorator_color_special
+
+        text = context.scene.BIMClashProperties.active_clash_text
+        p = context.scene.BIMClashProperties.p1.lerp(context.scene.BIMClashProperties.p2, 0.5)
+
+        font_id = 0
+        blf.size(font_id, 12)
+        coords_2d = location_3d_to_region_2d(context.region, context.region_data, p)
+        color = self.addon_prefs.decorations_colour
+        blf.color(font_id, *color)
+        if coords_2d:
+            w, h = blf.dimensions(font_id, text)
+            coords_2d -= Vector((w * .5, 0))
+            blf.position(font_id, coords_2d[0], coords_2d[1], 0)
+            blf.draw(font_id, text)  # Set your text here
+
+    def draw_geometry(self, context):
+        self.addon_prefs = context.preferences.addons["blenderbim"].preferences
+        selected_elements_color = self.addon_prefs.decorator_color_selected
+        unselected_elements_color = self.addon_prefs.decorator_color_unselected
+        special_elements_color = self.addon_prefs.decorator_color_special
+
+        gpu.state.point_size_set(6)
+        gpu.state.blend_set("ALPHA")
+
+        self.line_shader = gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
+        self.line_shader.bind()  # required to be able to change uniforms of the shader
+        # POLYLINE_UNIFORM_COLOR specific uniforms
+        self.line_shader.uniform_float("viewportSize", (context.region.width, context.region.height))
+        self.line_shader.uniform_float("lineWidth", 2.0)
+
+        # general shader
+        self.shader = gpu.shader.from_builtin("UNIFORM_COLOR")
+
+        selected_vertices = [context.scene.BIMClashProperties.p1, context.scene.BIMClashProperties.p2]
+        selected_edges = []
+        if selected_vertices[0] != selected_vertices[1]:
+            selected_edges = [[0, 1]]
+
+        self.draw_batch("POINTS", selected_vertices, special_elements_color)
+        if selected_edges:
+            self.draw_batch("LINES", selected_vertices, special_elements_color, selected_edges)

src/blenderbim/blenderbim/bim/module/clash/operator.py

@@ -23,10 +23,11 @@ import bmesh
 import logging
 import numpy as np
 import ifcopenshell
-from mathutils import Matrix, Vector
-from math import radians
-from blenderbim.bim.ifc import IfcStore
 import blenderbim.tool as tool
+from math import radians
+from mathutils import Matrix, Vector
+from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.module.clash.decorator import ClashDecorator
 
 
 class ExportClashSets(bpy.types.Operator):
@@ -45,18 +46,7 @@ class ExportClashSets(bpy.types.Operator):
 
     def execute(self, context):
         self.filepath = bpy.path.ensure_ext(self.filepath, ".json")
-        clash_sets = []
-        for clash_set in context.scene.BIMClashProperties.clash_sets:
-            self.a = []
-            self.b = []
-            for ab in ["a", "b"]:
-                for data in getattr(clash_set, ab):
-                    clash_source = {"file": data.name}
-                    if data.selector:
-                        clash_source["selector"] = data.selector
-                        clash_source["mode"] = data.mode
-                    getattr(self, ab).append(clash_source)
-            clash_sets.append({"name": clash_set.name, "tolerance": clash_set.tolerance, "a": self.a, "b": self.b})
+        clash_sets = tool.Clash.export_clash_sets()
         with open(self.filepath, "w") as destination:
             destination.write(json.dumps(clash_sets, indent=4))
         return {"FINISHED"}
@@ -78,25 +68,34 @@ class ImportClashSets(bpy.types.Operator):
         return {"RUNNING_MODAL"}
 
     def execute(self, context):
-        with open(self.filepath) as f:
-            clash_sets = json.load(f)
-        for clash_set in clash_sets:
+        tool.Clash.load_clash_sets(self.filepath)
+        context.scene.BIMClashProperties.clash_sets.clear()
+        for clash_set in tool.Clash.get_clash_sets():
             new = context.scene.BIMClashProperties.clash_sets.add()
             new.name = clash_set["name"]
-            new.tolerance = clash_set["tolerance"]
+            new.mode = clash_set["mode"]
+            if new.mode == "intersection":
+                new.tolerance = clash_set["tolerance"]
+                new.check_all = clash_set["check_all"]
+            elif new.mode == "collision":
+                new.allow_touching = clash_set["allow_touching"]
+            elif new.mode == "clearance":
+                new.clearance = clash_set["clearance"]
+                new.check_all = clash_set["check_all"]
             for clash_source in clash_set["a"]:
                 new_source = new.a.add()
                 new_source.name = clash_source["file"]
                 if "selector" in clash_source:
-                    new_source.selector = clash_source["selector"]
+                    tool.Search.import_filter_query(clash_source["selector"], new_source.filter_groups)
                     new_source.mode = clash_source["mode"]
-            if clash_set["b"]:
+            if "b" in clash_set and clash_set["b"]:
                 for clash_source in clash_set["b"]:
                     new_source = new.b.add()
                     new_source.name = clash_source["file"]
                     if "selector" in clash_source:
-                        new_source.selector = clash_source["selector"]
+                        tool.Search.import_filter_query(clash_source["selector"], new_source.filter_groups)
                         new_source.mode = clash_source["mode"]
+        tool.Clash.import_active_clashes()
         return {"FINISHED"}
 
 
@@ -109,7 +108,6 @@ class AddClashSet(bpy.types.Operator):
     def execute(self, context):
         new = context.scene.BIMClashProperties.clash_sets.add()
         new.name = "New Clash Set"
-        new.tolerance = 0.01
         return {"FINISHED"}
 
 
@@ -211,8 +209,11 @@ class ExecuteIfcClash(bpy.types.Operator):
 
     def invoke(self, context, event):
         _, extension = os.path.splitext(self.filepath)
-        if extension != ".json":
-            self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".bcf")
+        if extension != ".bcf":
+            self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".json")
+        # TODO Temporarily until BCF support comes back
+        # if extension != ".json":
+        #     self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".bcf")
         WindowManager = context.window_manager
         WindowManager.fileselect_add(self)
         return {"RUNNING_MODAL"}
@@ -220,7 +221,12 @@ class ExecuteIfcClash(bpy.types.Operator):
     def execute(self, context):
         from ifcclash import ifcclash
 
+        self.props = context.scene.BIMClashProperties
+
         _, extension = os.path.splitext(self.filepath)
+        if extension != ".bcf":
+            self.filepath = bpy.path.ensure_ext(self.filepath, ".json")
+        # TODO Temporarily until BCF support comes back
         if extension != ".json":
             self.filepath = bpy.path.ensure_ext(self.filepath, ".bcf")
 
@@ -230,7 +236,7 @@ class ExecuteIfcClash(bpy.types.Operator):
         settings.logger.setLevel(logging.DEBUG)
         clasher = ifcclash.Clasher(settings)
 
-        if context.scene.BIMClashProperties.should_create_clash_snapshots:
+        if self.props.should_create_clash_snapshots:
 
             def get_viewpoint_snapshot(viewpoint):
                 camera = bpy.data.objects.get("IFC Clash Camera")
@@ -271,23 +277,13 @@ class ExecuteIfcClash(bpy.types.Operator):
 
             clasher.get_viewpoint_snapshot = get_viewpoint_snapshot
 
-        clasher.clash_sets = []
-        for clash_set in context.scene.BIMClashProperties.clash_sets:
-            self.a = []
-            self.b = []
-            for ab in ["a", "b"]:
-                for data in getattr(clash_set, ab):
-                    clash_source = {"file": data.name}
-                    if data.selector:
-                        clash_source["selector"] = data.selector
-                        clash_source["mode"] = data.mode
-                    getattr(self, ab).append(clash_source)
-            clash_set_data = {"name": clash_set.name, "tolerance": clash_set.tolerance, "a": self.a}
-            if self.b:
-                clash_set_data["b"] = self.b
-            clasher.clash_sets.append(clash_set_data)
+        clasher.clash_sets = tool.Clash.export_clash_sets()
         clasher.clash()
         clasher.export()
+
+        if extension == ".json":
+            tool.Clash.load_clash_sets(self.filepath)
+            tool.Clash.import_active_clashes()
         return {"FINISHED"}
 
 
@@ -306,6 +302,7 @@ class SelectIfcClashResults(bpy.types.Operator):
         return {"RUNNING_MODAL"}
 
     def execute(self, context):
+        # TODO refactor into new clash results system
         self.file = IfcStore.get_file()
         self.filepath = bpy.path.ensure_ext(self.filepath, ".json")
         with open(self.filepath) as f:
@@ -352,83 +349,6 @@ class SelectIfcClashResults(bpy.types.Operator):
         return {"FINISHED"}
 
 
-class LoadIfcClashes(bpy.types.Operator):
-    bl_idname = "bim.load_ifc_clashes"
-    bl_label = "Load IFC Clashes"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Load the clashing IFC geometry stored in a file"
-    filename_ext = ".json"
-    filepath: bpy.props.StringProperty(subtype="FILE_PATH")
-
-    def invoke(self, context, event):
-        self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".json")
-        WindowManager = context.window_manager
-        WindowManager.fileselect_add(self)
-        return {"RUNNING_MODAL"}
-
-    def execute(self, context):
-        self.file = IfcStore.get_file()
-        self.filepath = bpy.path.ensure_ext(self.filepath, ".json")
-        with open(self.filepath) as f:
-            clash_sets_json = json.load(f)
-        active_clash_set = context.scene.BIMClashProperties.active_clash_set
-
-        for clash_set in clash_sets_json:
-            if not "clashes" in clash_set.keys():
-                self.report({"WARNING"}, "No clashes found for the selected Clash Set.")
-                return {"CANCELLED"}
-            active_clash_set.clashes.clear()
-            for clash in clash_set["clashes"].values():
-                blender_clash = active_clash_set.clashes.add()
-                blender_clash.a_global_id = clash["a_global_id"]
-                blender_clash.b_global_id = clash["b_global_id"]
-                blender_clash.a_name = "{}/{}".format(clash["a_ifc_class"], clash["a_name"])
-                blender_clash.b_name = "{}/{}".format(clash["b_ifc_class"], clash["b_name"])
-                blender_clash.status = False if not "status" in clash.keys() else clash["status"]
-        return {"FINISHED"}
-
-
-class SaveIfcClashes(bpy.types.Operator):
-    bl_idname = "bim.save_ifc_clashes"
-    bl_label = "Save IFC Clashes"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Save the clashing IFC geometry stored in a file"
-    filename_ext = ".json"
-    filepath: bpy.props.StringProperty(subtype="FILE_PATH")
-
-    def invoke(self, context, event):
-        self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".json")
-        WindowManager = context.window_manager
-        WindowManager.fileselect_add(self)
-        return {"RUNNING_MODAL"}
-
-    def execute(self, context):
-        self.file = IfcStore.get_file()
-        self.filepath = bpy.path.ensure_ext(self.filepath, ".json")
-        clash_sets_json = self.load_json()
-        active_clash_set = context.scene.BIMClashProperties.active_clash_set
-        self.update_clash_sets(clash_sets_json, active_clash_set)
-        self.save_json(clash_sets_json)
-        return {"FINISHED"}
-
-    def load_json(self):
-        with open(self.filepath) as f:
-            return json.load(f)
-
-    def update_clash_sets(self, clash_sets_json, active_clash_set):
-        for clash_set in clash_sets_json:
-            if clash_set["name"] != active_clash_set.name or "clashes" not in clash_set.keys():
-                continue
-            for clash in active_clash_set.clashes:
-                clash_key = clash.a_global_id + "-" + clash.b_global_id
-                if clash_set.get("clashes", {}).get(clash_key, None) is not None:
-                    clash_set["clashes"][clash_key]["status"] = clash.status
-
-    def save_json(self, clash_sets_json):
-        with open(self.filepath, "w") as destination:
-            json.dump(clash_sets_json, destination, indent=4)
-
-
 class SelectClash(bpy.types.Operator):
     bl_idname = "bim.select_clash"
     bl_label = "Select Clash"
@@ -437,31 +357,29 @@ class SelectClash(bpy.types.Operator):
     index: bpy.props.IntProperty()
 
     def execute(self, context):
-        clash = context.scene.BIMClashProperties.active_clash
+        self.props = context.scene.BIMClashProperties
+        clash_set = tool.Clash.get_clash_set(self.props.active_clash_set.name)
+        active_clash = self.props.active_clash
+        clash = tool.Clash.get_clash(clash_set, active_clash.a_global_id, active_clash.b_global_id)
+
+        if not clash:
+            return {"FINISHED"}
 
         products = []
-        linked_objects = []
-        try:
-            products.append(tool.Ifc.get().by_guid(clash.a_global_id))
-        except:
-            linked_objects.append(clash.a_name)
-        try:
-            products.append(tool.Ifc.get().by_guid(clash.b_global_id))
-        except:
-            linked_objects.append(clash.b_name)
+
+        for global_id in (clash["a_global_id"], clash["b_global_id"]):
+            try:
+                products.append(tool.Ifc.get().by_guid(global_id))
+            except:
+                pass
 
         tool.Spatial.select_products(products, unhide=True)
-        print(linked_objects)
-        for obj_name in linked_objects:
-            obj = bpy.data.objects.get(obj_name)
-            if obj:
-                obj.select_set(True)
-            else:
-                print("Object not found:", obj_name)
-        if context.scene.BIMClashProperties.sould_focus_on_clash:
-            context_override = tool.Blender.get_viewport_context()
-            with bpy.context.temp_override(**context_override):
-                bpy.ops.view3d.view_selected()
+        ClashDecorator.install(bpy.context)
+        target = Vector(clash["p1"])
+        tool.Clash.look_at(target, target + Vector((5, 5, 5)))
+        self.props.p1 = clash["p1"]
+        self.props.p2 = clash["p2"]
+        self.props.active_clash_text = clash["type"].title() + " " + str(round(clash["distance"] * 1000)) + "mm"
         return {"FINISHED"}
 
 

src/blenderbim/blenderbim/bim/module/clash/prop.py

@@ -17,7 +17,7 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
-from blenderbim.bim.prop import StrProperty, Attribute
+from blenderbim.bim.prop import StrProperty, Attribute, BIMFilterGroup
 from bpy.types import PropertyGroup
 from bpy.props import (
     PointerProperty,
@@ -33,11 +33,12 @@ from bpy.props import (
 
 class ClashSource(PropertyGroup):
     name: StringProperty(name="File")
-    selector: StringProperty(name="Selector")
+    filter_groups: CollectionProperty(type=BIMFilterGroup, name="Filter Groups")
     mode: EnumProperty(
         items=[
-            ("i", "Include", "Only the selected objects are included for clashing"),
-            ("e", "Exclude", "All objects except the selected objects are included for clashing"),
+            ("a", "All Elements", "All elements will be used for clashing"),
+            ("i", "Include", "Only the selected elements are included for clashing"),
+            ("e", "Exclude", "All elements except the selected elements are included for clashing"),
         ],
         name="Mode",
     )
@@ -53,7 +54,24 @@ class Clash(PropertyGroup):
 
 class ClashSet(PropertyGroup):
     name: StringProperty(name="Name")
-    tolerance: FloatProperty(name="Tolerance")
+    mode: EnumProperty(
+        items=[
+            (
+                "intersection",
+                "Intersection",
+                "Detect objects that protrude or pierce another object",
+                "PIVOT_MEDIAN",
+                1,
+            ),
+            ("collision", "Collision", "Detect touching objects with any surface collision", "PIVOT_INDIVIDUAL", 2),
+            ("clearance", "Clearance", "Detect objects within a proximity threshold", "PIVOT_ACTIVE", 3),
+        ],
+        name="Mode",
+    )
+    tolerance: FloatProperty(name="Tolerance", default=0.002)
+    clearance: FloatProperty(name="Clearance", default=0.01)
+    allow_touching: BoolProperty(name="Allow Touching", default=False)
+    check_all: BoolProperty(name="Check All", default=False)
     a: CollectionProperty(name="Group A", type=ClashSource)
     b: CollectionProperty(name="Group B", type=ClashSource)
     clashes: CollectionProperty(name="Clashes", type=Clash)
@@ -78,22 +96,21 @@ class BIMClashProperties(PropertyGroup):
     smart_clash_grouping_max_distance: IntProperty(
         name="Smart Clash Grouping Max Distance", default=3, soft_min=1, soft_max=10
     )
-    sould_focus_on_clash: BoolProperty(name="Show Focus Clash", default=False)
+    p1: FloatVectorProperty(name="P1", default=(0.0, 0.0, 0.0), subtype="XYZ")
+    p2: FloatVectorProperty(name="P2", default=(0.0, 0.0, 0.0), subtype="XYZ")
+    active_clash_text: StringProperty(name="Active Clash Text")
 
     @property
     def active_clash_set(self):
-        if not self.clash_sets:
-            return None
-        return self.clash_sets[self.active_clash_set_index]
+        if self.active_clash_set_index < len(self.clash_sets):
+            return self.clash_sets[self.active_clash_set_index]
 
     @property
     def active_smart_group(self):
-        if not self.smart_clash_groups:
-            return None
-        return self.smart_clash_groups[self.active_smart_group_index]
+        if self.active_smart_group_index < len(self.smart_clash_groups):
+            return self.smart_clash_groups[self.active_smart_group_index]
 
     @property
     def active_clash(self):
-        if not self.active_clash_set:
-            return None
-        return self.active_clash_set.clashes[self.active_clash_index]
+        if self.active_clash_index < len(self.active_clash_set.clashes):
+            return self.active_clash_set.clashes[self.active_clash_index]

src/blenderbim/blenderbim/bim/module/clash/ui.py

@@ -17,7 +17,9 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
+import blenderbim.bim.helper
 from bpy.types import Panel
+from blenderbim.bim.module.clash.data import ClashData
 
 
 class BIM_PT_ifcclash(Panel):
@@ -30,6 +32,9 @@ class BIM_PT_ifcclash(Panel):
     bl_parent_id = "BIM_PT_tab_clash_detection"
 
     def draw(self, context):
+        if not ClashData.is_loaded:
+            ClashData.load()
+
         layout = self.layout
 
         scene = context.scene
@@ -45,57 +50,83 @@ class BIM_PT_ifcclash(Panel):
 
         layout.template_list("BIM_UL_clash_sets", "", props, "clash_sets", props, "active_clash_set_index")
 
-        if props.active_clash_set_index < len(props.clash_sets):
-            clash_set = props.active_clash_set
+        if not props.active_clash_set:
+            return
 
-            row = layout.row(align=True)
-            row.prop(clash_set, "name")
-            row.operator("bim.remove_clash_set", icon="X", text="").index = props.active_clash_set_index
+        clash_set = props.active_clash_set
 
-            row = layout.row(align=True)
+        row = layout.row(align=True)
+        row.prop(clash_set, "name")
+        row.operator("bim.remove_clash_set", icon="X", text="").index = props.active_clash_set_index
+
+        row = layout.row()
+        row.prop(clash_set, "mode")
+
+        if clash_set.mode == "intersection":
+            row = layout.row()
             row.prop(clash_set, "tolerance")
-
-            layout.label(text="Group A:")
             row = layout.row()
-            row.operator("bim.add_clash_source").group = "a"
-
-            for index, source in enumerate(clash_set.a):
-                row = layout.row(align=True)
-                row.prop(source, "name", text="")
-                op = row.operator("bim.select_clash_source", icon="FILE_FOLDER", text="")
-                op.index = index
-                op.group = "a"
-                op = row.operator("bim.remove_clash_source", icon="X", text="")
-                op.index = index
-                op.group = "a"
-
-                row = layout.row(align=True)
-                row.prop(source, "mode", text="")
-                row.prop(source, "selector", text="")
-
-            layout.label(text="Group B:")
+            row.prop(clash_set, "check_all")
+        elif clash_set.mode == "collision":
             row = layout.row()
-            row.operator("bim.add_clash_source").group = "b"
-
-            for index, source in enumerate(clash_set.b):
-                row = layout.row(align=True)
-                row.prop(source, "name", text="")
-                op = row.operator("bim.select_clash_source", icon="FILE_FOLDER", text="")
-                op.index = index
-                op.group = "b"
-                op = row.operator("bim.remove_clash_source", icon="X", text="")
-                op.index = index
-                op.group = "b"
-
-                row = layout.row(align=True)
-                row.prop(source, "mode", text="")
-                row.prop(source, "selector", text="")
-
+            row.prop(clash_set, "allow_touching")
+        elif clash_set.mode == "clearance":
             row = layout.row()
-            row.prop(props, "should_create_clash_snapshots")
+            row.prop(clash_set, "clearance")
+            row = layout.row()
+            row.prop(clash_set, "check_all")
+
+        row = layout.row(align=True)
+        row.label(text="Group A:", icon="OUTLINER_OB_POINTCLOUD")
+        row.operator("bim.add_clash_source", icon="ADD", text="").group = "a"
+
+        for index, source in enumerate(clash_set.a):
             row = layout.row(align=True)
-            row.operator("bim.execute_ifc_clash")
-            row.operator("bim.select_ifc_clash_results")
+            row.prop(source, "name", text="")
+            row.prop(source, "mode", text="")
+            op = row.operator("bim.select_clash_source", icon="FILE_FOLDER", text="")
+            op.index = index
+            op.group = "a"
+            op = row.operator("bim.remove_clash_source", icon="X", text="")
+            op.index = index
+            op.group = "a"
+
+            if source.mode != "a":
+                blenderbim.bim.helper.draw_filter(
+                    layout, source.filter_groups, ClashData, f"clash_{props.active_clash_set_index}_a_{index}"
+                )
+
+        row = layout.row(align=True)
+        row.label(text="Group B:", icon="OUTLINER_OB_POINTCLOUD")
+        row.operator("bim.add_clash_source", icon="ADD", text="").group = "b"
+
+        for index, source in enumerate(clash_set.b):
+            row = layout.row(align=True)
+            row.prop(source, "name", text="")
+            row.prop(source, "mode", text="")
+            op = row.operator("bim.select_clash_source", icon="FILE_FOLDER", text="")
+            op.index = index
+            op.group = "b"
+            op = row.operator("bim.remove_clash_source", icon="X", text="")
+            op.index = index
+            op.group = "b"
+
+            if source.mode != "a":
+                blenderbim.bim.helper.draw_filter(
+                    layout, source.filter_groups, ClashData, f"clash_{props.active_clash_set_index}_b_{index}"
+                )
+
+        row = layout.row()
+        row.prop(props, "should_create_clash_snapshots")
+        row = layout.row()
+        row.operator("bim.execute_ifc_clash")
+
+        row = layout.row()
+        row.label(text=f"{len(clash_set.clashes)} Clashes Found", icon="PIVOT_CURSOR")
+
+        layout.template_list("BIM_UL_clashes", "", props.active_clash_set, "clashes", props, "active_clash_index")
+        row = layout.row()
+        row.operator("bim.select_clash")
 
 
 class BIM_PT_clash_manager(Panel):
@@ -111,29 +142,6 @@ class BIM_PT_clash_manager(Panel):
         pass
 
 
-class BIM_PT_dumb_clash_manager(Panel):
-    bl_idname = "BIM_PT_dumb_clash_manager"
-    bl_label = "Dumb Manager"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_clash_manager"
-
-    def draw(self, context):
-        layout = self.layout
-        props = context.scene.BIMClashProperties
-
-        row = layout.row(align=True)
-        row.operator("bim.load_ifc_clashes", text="LOAD IFC CLASHES", icon="IMPORT")
-        row.operator("bim.save_ifc_clashes", text="SAVE CLASH RESULTS", icon="EXPORT")
-        layout.template_list("BIM_UL_clashes", "", props.active_clash_set, "clashes", props, "active_clash_index")
-        # bim.select_clash
-        row = layout.row(align=True)
-        row.operator("bim.select_clash", text="SELECT CLASH", icon="IMPORT")
-        row.prop(props, "sould_focus_on_clash", icon="RESTRICT_VIEW_OFF")
-
-
 class BIM_PT_smart_clash_manager(Panel):
     bl_idname = "BIM_PT_smart_clash_manager"
     bl_label = "Smart Clash Manager"

src/blenderbim/blenderbim/bim/module/classification/operator.py

@@ -20,6 +20,8 @@ import bpy
 import json
 import ifcopenshell
 import ifcopenshell.api
+import ifcopenshell.util.classification
+import ifcopenshell.util.element
 import blenderbim.tool as tool
 import blenderbim.bim.helper
 from blenderbim.bim.ifc import IfcStore
@@ -87,7 +89,7 @@ class AddManualClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
         reference = ifcopenshell.api.run(
             "classification.add_reference",
             tool.Ifc.get(),
-            product=product,
+            products=[product],
             classification=classification,
             identification="X",
             name="Unnamed",
@@ -292,20 +294,25 @@ class RemoveClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
         active_reference = tool.Ifc.get().by_id(self.reference)
         identification = active_reference[1]
 
+        elements_by_references: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]] = {}
         for obj in objects:
-            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, obj, self.obj_type)
+            ifc_definition_id = tool.Blender.get_obj_ifc_definition_id(obj, self.obj_type, context)
             element = tool.Ifc.get().by_id(ifc_definition_id)
             references = ifcopenshell.util.classification.get_references(element, should_inherit=False)
             for reference in references:
                 if (identification and reference[1] == identification) or (
                     not identification and reference == active_reference
                 ):
-                    ifcopenshell.api.run(
-                        "classification.remove_reference",
-                        tool.Ifc.get(),
-                        reference=reference,
-                        product=element,
-                    )
+                    elements_by_references.setdefault(reference, []).append(element)
+
+        if elements_by_references:
+            for reference, products in elements_by_references.items():
+                ifcopenshell.api.run(
+                    "classification.remove_reference",
+                    tool.Ifc.get(),
+                    reference=reference,
+                    products=products,
+                )
 
 
 class EditClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
@@ -357,15 +364,18 @@ class AddClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
                 classification = element
                 break
 
-        for obj in objects:
-            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, obj, self.obj_type)
-            if not ifc_definition_id:
-                continue
+        ifc_file = tool.Ifc.get()
+        products = [
+            ifc_file.by_id(ifc_definition_id)
+            for obj in objects
+            if (ifc_definition_id := tool.Blender.get_obj_ifc_definition_id(obj, self.obj_type, context))
+        ]
+        if products:
             ifcopenshell.api.run(
                 "classification.add_reference",
                 tool.Ifc.get(),
                 reference=IfcStore.classification_file.by_id(self.reference),
-                product=tool.Ifc.get().by_id(ifc_definition_id),
+                products=products,
                 classification=classification,
             )
 
@@ -406,14 +416,14 @@ class AddClassificationReferenceFromBSDD(bpy.types.Operator, tool.Ifc.Operator):
             classification.Location = bsdd_classification.domain_namespace_uri
 
         for obj in objects:
-            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, obj, self.obj_type)
+            ifc_definition_id = tool.Blender.get_obj_ifc_definition_id(obj, self.obj_type, context)
             if not ifc_definition_id:
                 continue
             element = tool.Ifc.get().by_id(ifc_definition_id)
             reference = ifcopenshell.api.run(
                 "classification.add_reference",
                 tool.Ifc.get(),
-                product=element,
+                products=[element],
                 classification=classification,
                 identification=bsdd_classification.reference_code,
                 name=bsdd_classification.name,

src/blenderbim/blenderbim/bim/module/constraint/operator.py

@@ -114,7 +114,7 @@ class EditObjective(bpy.types.Operator):
         ifcopenshell.api.run(
             "constraint.edit_objective",
             self.file,
-            **{"objective": self.file.by_id(props.active_constraint_id), "attributes": attributes}
+            **{"objective": self.file.by_id(props.active_constraint_id), "attributes": attributes},
         )
         bpy.ops.bim.load_objectives()
         return {"FINISHED"}
@@ -179,19 +179,17 @@ class AssignConstraint(bpy.types.Operator):
         return IfcStore.execute_ifc_operator(self, context)
 
     def _execute(self, context):
-        self.file = IfcStore.get_file()
+        self.file = tool.Ifc.get()
         objs = [bpy.data.objects.get(self.obj)] if self.obj else context.selected_objects
-        for obj in objs:
-            obj_id = obj.BIMObjectProperties.ifc_definition_id
-            if not obj_id:
-                continue
+        products = [self.file.by_id(obj_id) for obj in objs if (obj_id := obj.BIMObjectProperties.ifc_definition_id)]
+        if products:
             ifcopenshell.api.run(
                 "constraint.assign_constraint",
                 self.file,
                 **{
-                    "product": self.file.by_id(obj_id),
+                    "products": products,
                     "constraint": self.file.by_id(self.constraint),
-                }
+                },
             )
         return {"FINISHED"}
 
@@ -207,18 +205,16 @@ class UnassignConstraint(bpy.types.Operator):
         return IfcStore.execute_ifc_operator(self, context)
 
     def _execute(self, context):
-        self.file = IfcStore.get_file()
+        self.file = tool.Ifc.get()
         objs = [bpy.data.objects.get(self.obj)] if self.obj else context.selected_objects
-        for obj in objs:
-            obj_id = obj.BIMObjectProperties.ifc_definition_id
-            if not obj_id:
-                continue
+        products = [self.file.by_id(obj_id) for obj in objs if (obj_id := obj.BIMObjectProperties.ifc_definition_id)]
+        if products:
             ifcopenshell.api.run(
                 "constraint.unassign_constraint",
                 self.file,
                 **{
-                    "product": self.file.by_id(obj_id),
+                    "products": products,
                     "constraint": self.file.by_id(self.constraint),
-                }
+                },
             )
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/covering/workspace.py

@@ -191,11 +191,11 @@ class CoveringToolUI:
             row = cls.layout.row(align=True)
             row.label(text="", icon="FILE_3D")
             prop_with_search(row, cls.props, "relating_type_id", text="")
-            row.operator("bim.launch_type_manager", icon="LIGHTPROBE_GRID", text="")
+            row.operator("bim.launch_type_manager", icon=tool.Blender.TYPE_MANAGER_ICON, text="")
         else:
             row.label(text=f"No {AuthoringData.data['ifc_element_type']} Found", icon="ERROR")
             row = cls.layout.row()
-            row.operator("bim.launch_type_manager", icon="LIGHTPROBE_GRID", text="Launch Type Manager")
+            row.operator("bim.launch_type_manager", icon=tool.Blender.TYPE_MANAGER_ICON, text="Launch Type Manager")
 
     @classmethod
     def draw_basic_bim_tool_interface(cls):

src/blenderbim/blenderbim/bim/module/debug/__init__.py

@@ -24,6 +24,7 @@ classes = (
     operator.CopyDebugInformation,
     operator.CreateAllShapes,
     operator.CreateShapeFromStepId,
+    operator.DebugActiveDrawing,
     operator.InspectFromObject,
     operator.InspectFromStepId,
     operator.OverrideDisplayType,

src/blenderbim/blenderbim/bim/module/debug/operator.py

@@ -20,11 +20,14 @@ import os
 import sys
 import bpy
 import time
+import random
 import logging
 import platform
 import subprocess
 import addon_utils
 import ifcopenshell
+import ifcopenshell.api
+import ifcopenshell.util.element
 import ifcopenshell.util.placement
 import ifcopenshell.util.representation
 import blenderbim.tool as tool
@@ -660,3 +663,104 @@ class PipInstall(bpy.types.Operator):
             ]
         )
         return {"FINISHED"}
+
+
+class DebugActiveDrawing(bpy.types.Operator):
+    bl_idname = "bim.debug_active_drawing"
+    bl_label = "Search Active Drawing For Failing Elements"
+    bl_description = (
+        "Will iterate over all visible drawing's objects, trying to narrow down the list of possible failing objects"
+    )
+
+    def execute(self, context: bpy.types.Context):
+        props = context.scene.DocProperties
+        drawing_item = props.drawings[props.active_drawing_index]
+        drawing = tool.Ifc.get().by_id(drawing_item.ifc_definition_id)
+
+        GREEN = "\033[92m"
+        CYAN = "\033[96m"
+        END = "\033[0m"
+        ATTEMPS = 10
+
+        # run create drawing with sync for once
+        # to make sure everything is actually in sync
+        try:
+            bpy.ops.bim.create_drawing(sync=True)
+        except:
+            pass
+        else:
+            self.report({"INFO"}, "No errors creating drawing, nothing to investigate.")
+            return {"FINISHED"}
+
+        all_elements = [e for obj in context.visible_objects if (e := tool.Ifc.get_entity(obj))]
+        all_elements = set(all_elements)
+
+        original_exclude = ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing", "Exclude")
+        pset = tool.Pset.get_element_pset(drawing, "EPset_Drawing")
+
+        def drawing_fails_to_load(chunk_to_include: set) -> bool:
+            current_elements = all_elements - chunk_to_include
+            excluded_guids = ", ".join([e.GlobalId for e in current_elements if hasattr(e, "GlobalId")])
+            tool.Ifc.run("pset.edit_pset", pset=pset, properties={"Exclude": f"{original_exclude}, {excluded_guids}"})
+
+            try:
+                bpy.ops.bim.create_drawing(sync=False)
+                result = False
+            except Exception as e:
+                # print(e)
+                result = True
+
+            tool.Ifc.run("pset.edit_pset", pset=pset, properties={"Exclude": original_exclude})
+            return result
+
+        def test_elements(elements: list[ifcopenshell.entity_instance], attempts: int = ATTEMPS) -> None:
+            print(f"{CYAN}processing {len(elements)} elements{END}")
+            if not elements:
+                print(f"Empty list of elements, will stop...")
+                return
+
+            n_elements = len(elements)
+            middle = int(n_elements / 2)
+            chunk1, chunk2 = elements[:middle], elements[middle:]
+            test_chunk_1 = drawing_fails_to_load(set(chunk1))
+            test_chunk_2 = drawing_fails_to_load(set(chunk2))
+
+            if (
+                # both chunks do not fail anymore
+                (not test_chunk_1 and not test_chunk_2)
+                # or we have 1 element chunk that is still failing
+                or (test_chunk_1 and not chunk2)
+                or (test_chunk_2 and not chunk1)
+            ):
+                if attempts == 0 or n_elements in (1, 2):
+                    print(f"{GREEN}Couldn't narrow it down any further.{END}")
+                    print(f"It's some of the {n_elements} elements:")
+                    print(elements)
+
+                    print("Let's test excluding them...")
+                    for element in elements:
+                        test = drawing_fails_to_load(all_elements - {element})
+                        if test:
+                            print(f"{CYAN}Excluding element didn't fixed the drawing: {END}")
+                            print(element)
+                        else:
+                            print(f"{GREEN}Excluding element fixed the drawing: {END}")
+                            print(element)
+                else:
+                    print(f"{CYAN}Will try to reshuffle elements and try again, attempt {ATTEMPS-attempts+1}/{ATTEMPS}")
+                    attempts -= 1
+                    random.shuffle(elements)
+                    test_elements(elements, attempts)
+                return
+
+            # if chunk fails we need to investigate it further
+            if test_chunk_1:
+                test_elements(chunk1)
+
+            if test_chunk_2:
+                test_elements(chunk2)
+
+        test_elements(list(all_elements))
+
+        self.report({"INFO"}, "See system console for the results")
+        return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/debug/ui.py

@@ -75,6 +75,9 @@ class BIM_PT_debug(Panel):
         row = layout.row()
         row.operator("bim.profile_import_ifc")
 
+        row = layout.row()
+        row.operator("bim.debug_active_drawing")
+
         row = layout.split(factor=0.5, align=True)
         row.operator("bim.create_shape_from_step_id").should_include_curves = False
         row.operator("bim.create_shape_from_step_id", text="", icon="IPO_ELASTIC").should_include_curves = True

src/blenderbim/blenderbim/bim/module/diff/data.py

@@ -38,6 +38,7 @@ class DiffData:
         cls.data["total_deleted"] = cls.total_deleted()
         cls.data["total_changed"] = cls.total_changed()
         cls.data["changes"] = cls.changes()
+        cls.data["saved_searches"] = cls.saved_searches()
         cls.is_loaded = True
 
     @classmethod
@@ -84,3 +85,18 @@ class DiffData:
         elif element.GlobalId in diff["deleted"]:
             changes["Deleted"] = True
         return changes
+
+    @classmethod
+    def saved_searches(cls):
+        if not tool.Ifc.get():
+            return []
+        groups = tool.Ifc.get().by_type("IfcGroup")
+        results = []
+        for group in groups:
+            try:
+                data = json.loads(group.Description)
+                if isinstance(data, dict) and data.get("type", None) == "BBIM_Search" and data.get("query", None):
+                    results.append(group)
+            except:
+                pass
+        return [(str(g.id()), g.Name or "Unnamed", "") for g in sorted(results, key=lambda x: x.Name or "Unnamed")]

src/blenderbim/blenderbim/bim/module/diff/operator.py

@@ -135,6 +135,7 @@ class ExecuteIfcDiff(bpy.types.Operator):
     bl_label = "Execute IFC Diff"
     filename_ext = ".json"
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
+    filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})
 
     def invoke(self, context, event):
         self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".json")
@@ -162,7 +163,7 @@ class ExecuteIfcDiff(bpy.types.Operator):
             new = ifcopenshell.open(self.props.new_file)
 
         relationships = [r.relationship for r in self.props.diff_relationships]
-        query = self.props.diff_filter_elements
+        query = tool.Search.export_filter_query(self.props.filter_groups) or None
 
         ifc_diff = ifcdiff.IfcDiff(old, new, relationships=relationships, filter_elements=query)
         ifc_diff.diff()

src/blenderbim/blenderbim/bim/module/diff/prop.py

@@ -17,7 +17,7 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
-from blenderbim.bim.prop import StrProperty
+from blenderbim.bim.prop import StrProperty, BIMFilterGroup
 from blenderbim.bim.module.diff.data import DiffData
 from bpy.types import PropertyGroup
 from bpy.props import (
@@ -48,7 +48,7 @@ class DiffProperties(PropertyGroup):
     old_file: StringProperty(default="", name="Old IFC File")
     new_file: StringProperty(default="", name="New IFC File")
     diff_relationships: CollectionProperty(type=Relationships, name="Relationships")
-    diff_filter_elements: StringProperty(default="", name="Filter")
+    filter_groups: CollectionProperty(type=BIMFilterGroup, name="Filter Groups")
     should_load_changed_elements: BoolProperty(name="Load Changed Elements", default=True)
     active_file: EnumProperty(
         items=[

src/blenderbim/blenderbim/bim/module/diff/ui.py

@@ -19,8 +19,8 @@
 from bpy.types import Panel
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.diff.data import DiffData
+import blenderbim.bim.helper
 import blenderbim.tool as tool
-import json
 
 
 class BIM_PT_diff(Panel):
@@ -93,9 +93,7 @@ class BIM_PT_diff(Panel):
             remove.collection = "diff_relationships"
             remove.index = index
 
-        row = layout.row(align=True)
-        row.prop(props, "diff_filter_elements")
-        row.operator("bim.ifc_selector", icon="FILTER", text="")
+        blenderbim.bim.helper.draw_filter(self.layout, props.filter_groups, DiffData, "diff")
 
         row = layout.row()
         row.operator("bim.execute_ifc_diff")

src/blenderbim/blenderbim/bim/module/drawing/__init__.py

@@ -41,6 +41,7 @@ classes = (
     operator.CleanWireframes,
     operator.ContractSheet,
     operator.ContractTargetView,
+    operator.ConvertSVGToDXF,
     operator.CreateDrawing,
     operator.CreateSheets,
     operator.DisableAddAnnotationType,
@@ -126,7 +127,7 @@ def register():
     bpy.types.Object.BIMAssignedProductProperties = bpy.props.PointerProperty(type=prop.BIMAssignedProductProperties)
     bpy.types.Object.BIMTextProperties = bpy.props.PointerProperty(type=prop.BIMTextProperties)
     bpy.types.TextCurve.BIMTextProperties = bpy.props.PointerProperty(type=prop.BIMTextProperties)
-    bpy.app.handlers.load_post.append(handler.toggleDecorationsOnLoad)
+    bpy.app.handlers.load_post.append(handler.load_post)
     bpy.app.handlers.depsgraph_update_pre.append(handler.depsgraph_update_pre_handler)
     bpy.types.VIEW3D_MT_image_add.append(ui.add_object_button)
 
@@ -140,6 +141,6 @@ def unregister():
     del bpy.types.Object.BIMAssignedProductProperties
     del bpy.types.Object.BIMTextProperties
     del bpy.types.TextCurve.BIMTextProperties
-    bpy.app.handlers.load_post.remove(handler.toggleDecorationsOnLoad)
+    bpy.app.handlers.load_post.remove(handler.load_post)
     bpy.app.handlers.depsgraph_update_pre.remove(handler.depsgraph_update_pre_handler)
     bpy.types.VIEW3D_MT_image_add.remove(ui.add_object_button)

src/blenderbim/blenderbim/bim/module/drawing/data.py

@@ -23,6 +23,7 @@ import ifcopenshell.util.element
 import ifcopenshell.util.representation
 import blenderbim.tool as tool
 from pathlib import Path
+from typing import Any, Union
 
 
 def refresh():
@@ -234,9 +235,9 @@ class DecoratorData:
     cut_cache = {}
     layerset_cache = {}
 
-    # used by Ifc Annotations with ObjectType = "BATTING"
     @classmethod
     def get_batting_thickness(cls, obj):
+        """used by IfcAnnotations with ObjectType = "BATTING" """
         result = cls.data.get(obj.name, None)
         if result is not None:
             return result
@@ -248,9 +249,9 @@ class DecoratorData:
             cls.data[obj.name] = thickness
             return thickness
 
-    # used by Ifc Annotations with ObjectType = "SECTION"
     @classmethod
     def get_section_markers_display_data(cls, obj):
+        """used by IfcAnnotations with ObjectType = "SECTION" """
         result = cls.data.get(obj.name, None)
         if result is not None:
             return result
@@ -290,10 +291,10 @@ class DecoratorData:
         cls.data[obj.name] = display_data
         return display_data
 
-    # used by Ifc Annotations with ObjectType = "TEXT" / "TEXT_LEADER"
     @classmethod
-    def get_ifc_text_data(cls, obj):
-        """returns font size in mm for current ifc text object"""
+    def get_ifc_text_data(cls, obj: bpy.types.Object) -> dict[str, Any]:
+        """used by Ifc Annotations with ObjectType = "TEXT" / "TEXT_LEADER"\n
+        returns font size in mm for current ifc text object"""
         result = cls.data.get(obj.name, None)
         if result is not None:
             return result
@@ -317,7 +318,7 @@ class DecoratorData:
         font_size = FONT_SIZES[font_size_type]
 
         # get symbol
-        symbol = pset_data.get("Symbol", None)
+        symbol = tool.Drawing.get_annotation_symbol(element)
 
         # other attributes
         props_literals = props.literals
@@ -340,6 +341,11 @@ class DecoratorData:
         cls.data[obj.name] = text_data
         return text_data
 
+    @classmethod
+    def get_symbol(cls, obj: bpy.types.Object) -> Union[str, None]:
+        """used by IfcAnnotations with ObjectType MULTI_SYMBOL"""
+        return tool.Drawing.get_annotation_symbol(tool.Ifc.get_entity(obj))
+
     @classmethod
     def get_dimension_data(cls, obj):
         """used by Ifc Annotations with ObjectType:
@@ -412,10 +418,12 @@ class AnnotationData:
         relating_types = []
         for relating_type in tool.Ifc.get().by_type("IfcTypeProduct"):
             if tool.Drawing.is_annotation_object_type(relating_type, object_type):
-                relating_types.append({
-                    "id": relating_type.id(),
-                    "name": relating_type.Name or "Unnamed",
-                    "description": relating_type.Description or "No Description",
-                })
+                relating_types.append(
+                    {
+                        "id": relating_type.id(),
+                        "name": relating_type.Name or "Unnamed",
+                        "description": relating_type.Description or "No Description",
+                    }
+                )
 
         return sorted(relating_types, key=lambda x: x["name"])

src/blenderbim/blenderbim/bim/module/drawing/decoration.py

@@ -37,6 +37,7 @@ from blenderbim.bim.module.drawing.shaders import add_verts_sequence, add_offset
 from blenderbim.bim.module.drawing.helper import format_distance
 from timeit import default_timer as timer
 from functools import lru_cache
+from typing import Optional, Iterator, Type, Union
 
 UNSPECIAL_ELEMENT_COLOR = (0.2, 0.2, 0.2, 1)  # GREY
 
@@ -69,7 +70,7 @@ class profile_consequential:
         cls.lines = []
 
 
-def worldspace_to_winspace(verts, context):
+def worldspace_to_winspace(verts: list[Vector], context: bpy.types.Context) -> list[Vector]:
     """Convert world space verts to window space"""
     region = context.region
     region3d = context.region_data
@@ -80,7 +81,7 @@ def worldspace_to_winspace(verts, context):
     return winspace_verts
 
 
-def winspace_to_worldspace(verts, context):
+def winspace_to_worldspace(verts: list[Vector], context: bpy.types.Context) -> list[Vector]:
     """Convert winspace verts to world space"""
     region = context.region
     region3d = context.region_data
@@ -121,17 +122,18 @@ def get_callout_head(edge_dir, edge_side, callout_size, callout_gap):
     return head
 
 
-def get_circle_head(size, segments=20):
+def get_circle_head(size: float, segments: int = 20, rotation: float = 0.0) -> list[Vector]:
+    """`rotation` value in radians"""
     angle_d = 2 * pi / segments
     head = []
     for i in range(segments):
-        angle = angle_d * i
+        angle = angle_d * i + rotation
         head.append(Vector([cos(angle), sin(angle), 0]) * size)
     return head
 
 
-def get_circle_head_asterisk(size, segments=6):
-    circle_head = get_circle_head(size, segments)
+def get_circle_head_asterisk(size: float, segments: int = 6, rotation: float = 0.0) -> Iterator[tuple[Vector, Vector]]:
+    circle_head = get_circle_head(size, segments, rotation)
     middle = segments // 2
     return zip(circle_head[:middle], circle_head[middle:])
 
@@ -264,7 +266,7 @@ class BaseDecorator:
         vertices = [obj.matrix_world @ v.co for v in bm.verts]
         return vertices, indices
 
-    def decorate(self, context, obj):
+    def decorate(self, context: bpy.types.Context, obj: bpy.types.Object):
         """perform actual drawing stuff"""
         raise NotImplementedError()
 
@@ -310,13 +312,28 @@ class BaseDecorator:
 
         self.draw_lines(context, obj, output_verts, output_edges)
 
-    def draw_batch(self, shader_type, content_pos, color, indices=None):
+    def draw_batch(
+        self,
+        shader_type: str,
+        content_pos: list[Vector],
+        color: tuple[float, float, float, float],
+        indices: Optional[list[tuple[int, int]]] = None,
+    ) -> None:
         shader = self.line_shader if shader_type == "LINES" else self.base_shader
         batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
         shader.uniform_float("color", color)
         batch.draw(shader)
 
-    def draw_lines(self, context, obj, vertices, indices, color=None, line_width=1.0):
+    def draw_lines(
+        self,
+        context: bpy.types.Context,
+        obj: Optional[bpy.types.Object],
+        vertices: list[Vector],
+        indices: list[tuple[int, int]],
+        color: Optional[tuple[float, float, float, float]] = None,
+        line_width: float = 1.0,
+    ) -> None:
+        # TODO: `obj` is actually never used, need to remove it
         """`verts` should be in winspace with `(0,0,0)` in the screen left bottom corner, not in the center"""
         region = context.region
         if not color:
@@ -329,7 +346,7 @@ class BaseDecorator:
         gpu.state.blend_set("ALPHA")
         self.draw_batch("LINES", vertices, color, indices)
 
-    def get_viewport_drawing_scale(self, context):
+    def get_viewport_drawing_scale(self, context: bpy.types.Context) -> float:
         # Horrific prototype code
         factor = self.camera_zoom_to_factor(context.space_data.region_3d.view_camera_zoom)
         camera_width_px = factor * context.region.width
@@ -485,14 +502,16 @@ class BaseDecorator:
         decimal_places = drawing_pset_data.get("DecimalPlaces", None)
         return format_distance(value, precision=precision, decimal_places=decimal_places)
 
-    def draw_asterisk(self, context, obj):
+    def draw_asterisk(self, context: bpy.types.Context, pos: Vector, rotation: float = 0.0, scale: float = 1.0) -> None:
+        """`pos` is a world space position\n
+        `rotation` value in radians"""
         # gather geometry data and convert to winspace
-        verts = [obj.location]
+        verts = [pos]
         viewportDrawingScale = self.get_viewport_drawing_scale(context)
         winspace_verts = worldspace_to_winspace(verts, context)
 
         # setup geometry parameters
-        circle_size = viewportDrawingScale * 4
+        circle_size = viewportDrawingScale * 4 * scale
 
         output_verts = []
         output_edges = []
@@ -502,20 +521,13 @@ class BaseDecorator:
         }
 
         v0 = winspace_verts[0]
-        asterisk_head = get_circle_head_asterisk(circle_size)
+        asterisk_head = get_circle_head_asterisk(circle_size, rotation=rotation)
         start_i = 0
         for segment in asterisk_head:
             start_i = add_verts_sequence(add_offsets(v0, segment), start_i, **out_kwargs)
-        self.draw_lines(context, obj, output_verts, output_edges)
+        self.draw_lines(context, None, output_verts, output_edges)
 
-    def draw_text(self, context, obj, text_world_position=None, reverse_lines_order=False):
-        """if `text_world_position` is not provided, the object's location will be used"""
-
-        if not text_world_position:
-            text_world_position = obj.location
-
-        region = context.region
-        region3d = context.region_data
+    def get_annotation_direction(self, context: bpy.types.Context, obj: bpy.types.Object) -> Vector:
         camera = context.scene.camera
 
         def get_basis_vector(matrix, i=0):
@@ -523,10 +535,57 @@ class BaseDecorator:
             return matrix.inverted()[i].to_3d().normalized()
 
         text_dir_world_x_axis = get_basis_vector(obj.matrix_world)
-
         camera_matrix = tool.Drawing.get_camera_matrix(camera)
-
         text_dir = (camera_matrix.inverted().to_quaternion() @ text_dir_world_x_axis).to_2d().normalized()
+        return text_dir
+
+    def draw_symbol(self, context: bpy.types.Context, obj: bpy.types.Object, annotation_dir: Vector) -> None:
+        if obj.type not in ("MESH", "EMPTY"):
+            return
+
+        if obj.type == "MESH":
+            mesh: bpy.types.Mesh = obj.data
+
+            if len(mesh.vertices) == 0:
+                return
+
+            if mesh.edges:
+                MiscDecorator.decorate(self, context, obj)
+                return
+
+            symbol = DecoratorData.get_symbol(obj)
+            if not symbol:
+                return
+
+            for vert in mesh.vertices:
+                self.draw_asterisk(context, obj.matrix_world @ vert.co)
+
+            return
+
+        # EMPTY objects
+        symbol = DecoratorData.get_symbol(obj)
+        if not symbol:
+            return
+
+        rotation = -Vector((1, 0)).angle_signed(annotation_dir)
+        # NOTE: for now we assume that scale is uniform
+        self.draw_asterisk(context, obj.location, rotation, obj.scale.x)
+
+    def draw_text(
+        self,
+        context: bpy.types.Context,
+        obj: bpy.types.Object,
+        text_world_position: Optional[Vector] = None,
+        reverse_lines_order=False,
+    ) -> None:
+        """if `text_world_position` is not provided, the object's location will be used"""
+
+        if not text_world_position:
+            text_world_position = obj.location
+
+        region = context.region
+        region3d = context.region_data
+        text_dir = self.get_annotation_direction(context, obj)
 
         pos = location_3d_to_region_2d(region, region3d, text_world_position)
         props = obj.BIMTextProperties
@@ -539,8 +598,7 @@ class BaseDecorator:
 
         # draw asterisk symbol to indicate that there is some symbol that's not shown in viewport
         if symbol:
-            self.draw_asterisk(context, obj)
-            # NOTE: for now we assume that scale is uniform
+            self.draw_symbol(context, obj, text_dir)
             text_scale = obj.scale.x
 
         line_i = 0
@@ -548,7 +606,7 @@ class BaseDecorator:
         for literal_data in literals_data:
             box_alignment = literal_data["BoxAlignment"]
 
-            for line in literal_data["CurrentValue"].split("\\n"):
+            for line in literal_data["CurrentValue"].split("\n"):
                 self.draw_label(
                     context,
                     line,
@@ -812,8 +870,9 @@ class AngleDecorator(BaseDecorator):
             base_edge = edge0 if tool.Cad.is_counter_clockwise_order(p0, p1, p2) else edge1
             text_offset = (Matrix.Rotation(-angle_rad / 2, 2) @ base_edge).normalized() * (radius + ANGLE_LABEL_OFFSET)
             label_position = p1 + text_offset
-
-            text = f"{int(angle)}deg"
+            drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
+            decimal_places = drawing_pset_data.get("AngleDecimalPlaces", None)
+            text = f"{round(angle, decimal_places)}°"
             label_dir = Vector((1, 0))
             self.draw_label(context, text, label_position, label_dir, box_alignment="center")
 
@@ -1003,7 +1062,7 @@ class StairDecorator(BaseDecorator):
 class MiscDecorator(BaseDecorator):
     objecttype = "MISC"
 
-    def decorate(self, context, obj):
+    def decorate(self, context: bpy.types.Context, obj: bpy.types.Object):
         if obj.data.is_editmode:
             verts, idxs = self.get_editmesh_geom(obj)
         else:
@@ -1505,6 +1564,14 @@ class TextDecorator(BaseDecorator):
         self.draw_text(context, obj)
 
 
+class SymbolDecorator(BaseDecorator):
+    objecttype = "SYMBOL"
+
+    def decorate(self, context: bpy.types.Context, obj: bpy.types.Object) -> None:
+        annotation_dir = self.get_annotation_direction(context, obj)
+        self.draw_symbol(context, obj, annotation_dir)
+
+
 class CutDecorator:
     installed = None
     cache = {}
@@ -1901,7 +1968,7 @@ class CutDecorator:
 
 
 class DecorationsHandler:
-    decorators_classes = [
+    decorators_classes: list[Type[BaseDecorator]] = [
         DimensionDecorator,
         AngleDecorator,
         GridDecorator,
@@ -1918,6 +1985,7 @@ class DecorationsHandler:
         SectionDecorator,
         ElevationDecorator,
         TextDecorator,
+        SymbolDecorator,
         BattingDecorator,
         FallDecorator,
     ]
@@ -1945,6 +2013,7 @@ class DecorationsHandler:
         self.decorators = {cls.objecttype: cls() for cls in self.decorators_classes}
         for object_type in ("SLOPE_ANGLE", "SLOPE_FRACTION", "SLOPE_PERCENT"):
             self.decorators[object_type] = self.decorators["FALL"]
+        self.decorators["MULTI_SYMBOL"] = self.decorators["SYMBOL"]
 
     def get_objects_and_decorators(self, collection):
         # TODO: do it in data instead of the handler for performance?
@@ -1962,7 +2031,7 @@ class DecorationsHandler:
             if not element.is_a("IfcAnnotation"):
                 continue
 
-            object_type = element.ObjectType
+            object_type: Union[str, None] = element.ObjectType
             if object_type == "DRAWING":
                 continue
 

src/blenderbim/blenderbim/bim/module/drawing/handler.py

@@ -23,7 +23,7 @@ from bpy.app.handlers import persistent
 
 
 @persistent
-def toggleDecorationsOnLoad(*args):
+def load_post(*args):
     if bpy.context.scene.DocProperties.should_draw_decorations:
         decoration.DecorationsHandler.install(bpy.context)
     else:

src/blenderbim/blenderbim/bim/module/drawing/helper.py

@@ -188,7 +188,6 @@ def format_distance(
                 feet += 1
                 inches = 0
 
-
         if not isArea:
             add_inches = bool(inches) or not suppress_zero_inches
             tx_dist = ""
@@ -299,7 +298,9 @@ def parse_diagram_scale(camera):
     return float(numerator) / float(denominator)
 
 
-def ortho_view_frame(camera, margin=0.015):
+def ortho_view_frame(
+    camera: bpy.types.Camera, margin: float = 0.015
+) -> tuple[float, float, float, float, float, float]:
     """Calculates 2d bounding box of camera view area.
 
     Similar to `bpy.types.Camera.view_frame`

src/blenderbim/blenderbim/bim/module/drawing/operator.py

@@ -44,7 +44,7 @@ import blenderbim.bim.module.drawing.helper as helper
 import blenderbim.bim.export_ifc
 from blenderbim.bim.module.drawing.decoration import CutDecorator
 from blenderbim.bim.module.drawing.data import DecoratorData, DrawingsData
-from typing import NamedTuple, List
+from typing import NamedTuple, List, Union, Optional
 from lxml import etree
 from mathutils import Vector, Color, Matrix
 from timeit import default_timer as timer
@@ -199,6 +199,11 @@ class CreateDrawing(bpy.types.Operator):
         + "SHIFT+CLICK to print all selected drawings"
     )
     print_all: bpy.props.BoolProperty(name="Print All", default=False, options={"SKIP_SAVE"})
+    sync: bpy.props.BoolProperty(
+        name="Sync Before Creating Drawing",
+        description="Could save some time if you're sure IFC and current Blender session are already in sync",
+        default=True,
+    )
 
     @classmethod
     def poll(cls, context):
@@ -220,7 +225,8 @@ class CreateDrawing(bpy.types.Operator):
         else:
             drawings_to_print = [self.props.active_drawing_id]
 
-        for drawing_id in drawings_to_print:
+        for drawing_i, drawing_id in enumerate(drawings_to_print):
+            self.drawing_index = drawing_i
             if self.print_all:
                 bpy.ops.bim.activate_drawing(drawing=drawing_id, camera_view_point=False)
 
@@ -335,6 +341,13 @@ class CreateDrawing(bpy.types.Operator):
         if not ifcopenshell.util.element.get_pset(self.drawing, "EPset_Drawing", "HasUnderlay"):
             return
         svg_path = self.get_svg_path(cache_type="underlay")
+        if os.path.isfile(svg_path) and self.props.should_use_underlay_cache:
+            return svg_path
+
+        visible_object_names = {obj.name for obj in bpy.context.visible_objects}
+        for obj in bpy.context.view_layer.objects:
+            obj.hide_render = obj.name not in visible_object_names
+
         context.scene.render.filepath = svg_path[0:-4] + ".png"
         drawing_style = context.scene.DocProperties.drawing_styles[self.cprops.active_drawing_style_index]
 
@@ -445,8 +458,14 @@ class CreateDrawing(bpy.types.Operator):
         return LineworkContexts(body_contexts, annotation_contexts)
 
     def serialize_contexts_elements(
-        self, ifc, tree: ifcopenshell.geom.tree, contexts: LineworkContexts, context_type, drawing_elements, target_view
-    ):
+        self,
+        ifc: ifcopenshell.file,
+        tree: ifcopenshell.geom.tree,
+        contexts: LineworkContexts,
+        context_type: str,
+        drawing_elements: set[ifcopenshell.entity_instance],
+        target_view: str,
+    ) -> None:
         drawing_elements = drawing_elements.copy()
         contexts = getattr(contexts, context_type)
         for context in contexts:
@@ -472,20 +491,24 @@ class CreateDrawing(bpy.types.Operator):
                     tree.add_element(elem)
                 drawing_elements -= processed
 
-    def generate_linework(self, context):
+    def generate_linework(self, context: bpy.types.Context) -> Union[str, None]:
         if not ifcopenshell.util.element.get_pset(self.drawing, "EPset_Drawing", "HasLinework"):
             return
         svg_path = self.get_svg_path(cache_type="linework")
         if os.path.isfile(svg_path) and self.props.should_use_linework_cache:
             return svg_path
 
-        with profile("sync"):
-            # All very hackish whilst prototyping
-            exporter = blenderbim.bim.export_ifc.IfcExporter(None)
-            exporter.file = tool.Ifc.get()
-            invalidated_elements = exporter.sync_all_objects()
-            invalidated_elements += exporter.sync_edited_objects()
-            invalidated_guids = [e.GlobalId for e in invalidated_elements if hasattr(e, "GlobalId")]
+        # in case of printing multiple drawings we need to sync just once
+        if self.sync and self.drawing_index == 0:
+            with profile("sync"):
+                # All very hackish whilst prototyping
+                exporter = blenderbim.bim.export_ifc.IfcExporter(None)
+                exporter.file = tool.Ifc.get()
+                invalidated_elements = exporter.sync_all_objects(skip_unlinking=True)
+                invalidated_elements += exporter.sync_edited_objects()
+                invalidated_guids = [e.GlobalId for e in invalidated_elements if hasattr(e, "GlobalId")]
+                cache = IfcStore.get_cache()
+                [cache.remove(guid) for guid in invalidated_guids]
 
         # If we have already calculated it in the SVG in the past, don't recalculate
         edited_guids = set()
@@ -506,6 +529,7 @@ class CreateDrawing(bpy.types.Operator):
 
         for ifc_path, ifc in files.items():
             # Don't use draw.main() just whilst we're prototyping and experimenting
+            # TODO: hash paths are never used
             ifc_hash = hashlib.md5(ifc_path.encode("utf-8")).hexdigest()
             ifc_cache_path = os.path.join(context.scene.BIMProperties.data_dir, "cache", f"{ifc_hash}.h5")
 
@@ -518,8 +542,6 @@ class CreateDrawing(bpy.types.Operator):
             drawing_elements = tool.Drawing.get_drawing_elements(self.camera_element)
 
             self.setup_serialiser(ifc, target_view)
-            cache = IfcStore.get_cache()
-            [cache.remove(guid) for guid in invalidated_guids]
             tree = ifcopenshell.geom.tree()
             tree.enable_face_styles(True)
 
@@ -1115,14 +1137,14 @@ class CreateDrawing(bpy.types.Operator):
                     continue
                 return space
 
-    def get_material_name(self, element):
+    def get_material_name(self, element: ifcopenshell.entity_instance) -> str:
         if hasattr(element, "Name") and element.Name:
             return element.Name
         elif hasattr(element, "LayerSetName") and element.LayerSetName:
             return element.LayerSetName
         return "mat-" + str(element.id())
 
-    def get_svg_path(self, cache_type=None):
+    def get_svg_path(self, cache_type: Optional[str] = None) -> str:
         drawing_path = tool.Drawing.get_document_uri(self.camera_document)
         drawings_dir = os.path.dirname(drawing_path)
 
@@ -1345,7 +1367,7 @@ class SelectAllDrawings(bpy.types.Operator):
     bl_label = "Select All Drawings"
     view: bpy.props.StringProperty()
     bl_description = "Select all drawings in the drawing list.\n\n" + "SHIFT+CLICK to deselect all drawings"
-    select_all: bpy.props.BoolProperty(name="Open All", default=False, options={"SKIP_SAVE"})
+    select_all: bpy.props.BoolProperty(name="Open All", default=True, options={"SKIP_SAVE"})
 
     def invoke(self, context, event):
         # deselect all drawings on shift+click
@@ -1451,10 +1473,6 @@ class ActivateModel(bpy.types.Operator):
 
 
 class ActivateDrawing(bpy.types.Operator):
-    """
-    Activates the selected drawing view
-    """
-
     bl_idname = "bim.activate_drawing"
     bl_label = "Activate Drawing"
     bl_options = {"REGISTER", "UNDO"}
@@ -1600,8 +1618,14 @@ class ReloadDrawingStyles(bpy.types.Operator):
 
         json_path = Path(tool.Ifc.resolve_uri(rel_path))
         if not json_path.exists():
-            self.report({"ERROR"}, "Shading styles file not found: {}".format(json_path))
-            return {"CANCELLED"}
+            ootb_resource = Path(context.scene.BIMProperties.data_dir) / "assets" / "shading_styles.json"
+            print(
+                f"WARNING. Couldn't find shading_styles for the drawing by the path: {json_path}. "
+                f"Default BBIM resource will be copied from {ootb_resource}"
+            )
+            if ootb_resource.exists():
+                os.makedirs(json_path.parent, exist_ok=True)
+                shutil.copy(ootb_resource, json_path)
 
         with open(json_path, "r") as fi:
             shading_styles_json = json.load(fi)
@@ -2546,8 +2570,16 @@ class EnableEditingElementFilter(bpy.types.Operator, Operator):
 
     def _execute(self, context):
         obj = bpy.context.scene.camera
-        if obj:
-            obj.data.BIMCameraProperties.filter_mode = self.filter_mode
+        if not obj:
+            return
+        obj.data.BIMCameraProperties.filter_mode = self.filter_mode
+        element = tool.Ifc.get_entity(obj)
+        if query := ifcopenshell.util.element.get_pset(element, "EPset_Drawing", self.filter_mode.title()):
+            filter_groups = tool.Search.get_filter_groups(f"drawing_{self.filter_mode.lower()}")
+            try:
+                tool.Search.import_filter_query(query, filter_groups)
+            except:
+                pass
 
 
 class EditElementFilter(bpy.types.Operator, Operator):
@@ -2689,3 +2721,50 @@ class AddReferenceImage(bpy.types.Operator, Operator):
         )
         tool.Style.reload_material_from_ifc(material)
         tool.Geometry.record_object_materials(obj)
+
+
+class ConvertSVGToDXF(bpy.types.Operator):
+    bl_idname = "bim.convert_svg_to_dxf"
+    bl_label = "Convert SVG to DXF"
+    bl_options = {"REGISTER", "UNDO"}
+    view: bpy.props.StringProperty()
+    bl_description = "Convert current drawing's .svg to .dxf.\n\nSHIFT+CLICK to convert all selected drawings"
+    convert_all: bpy.props.BoolProperty(name="Convert All", default=False, options={"SKIP_SAVE"})
+
+    def invoke(self, context, event):
+        # convert all drawings on shift+click
+        # make sure to use SKIP_SAVE on property, otherwise it might get stuck
+        if event.type == "LEFTMOUSE" and event.shift:
+            self.open_all = True
+        return self.execute(context)
+
+    def execute(self, context):
+        if self.convert_all:
+            drawings = [
+                tool.Ifc.get().by_id(d.ifc_definition_id) for d in context.scene.DocProperties.drawings if d.is_selected
+            ]
+        else:
+            drawings = [tool.Ifc.get().by_id(context.scene.DocProperties.drawings.get(self.view).ifc_definition_id)]
+
+        drawing_uris: list[Path] = []
+        drawings_not_found: list[str] = []
+
+        for drawing in drawings:
+            drawing_uri = tool.Drawing.get_document_uri(tool.Drawing.get_drawing_document(drawing))
+            if drawing_uri is None or not os.path.exists(drawing_uri):
+                drawings_not_found.append(drawing.Name)
+            else:
+                drawing_uris.append(Path(drawing_uri))
+
+        if drawings_not_found:
+            msg = "Some drawings .svg files were not found, need to print them first: \n{}.".format(
+                "\n".join(drawings_not_found)
+            )
+            self.report({"ERROR"}, msg)
+            return {"CANCELLED"}
+
+        for drawing_uri in drawing_uris:
+            tool.Drawing.convert_svg_to_dxf(drawing_uri, drawing_uri.with_suffix(".dxf"))
+
+        self.report({"INFO"}, f"{len(drawing_uris)} drawings were converted to .dxf.")
+        return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/drawing/prop.py

@@ -66,6 +66,11 @@ def get_location_hint(self, context):
 
 
 def update_diagram_scale(self, context):
+    if not context.scene.camera or context.scene.camera.data != self.id_data:
+        return
+    element = tool.Ifc.get_entity(context.scene.camera)
+    if not element:
+        return
     try:
         element = (
             tool.Ifc.get()
@@ -87,6 +92,11 @@ def update_diagram_scale(self, context):
 
 
 def update_is_nts(self, context):
+    if not context.scene.camera or context.scene.camera.data != self.id_data:
+        return
+    element = tool.Ifc.get_entity(context.scene.camera)
+    if not element:
+        return
     try:
         element = (
             tool.Ifc.get()
@@ -194,7 +204,7 @@ def update_document_name(self, context):
 def update_has_underlay(self, context):
     update_layer(self, context, "HasUnderlay", self.has_underlay)
     # making sure that camera is active
-    if self.has_underlay and (context.active_object and context.active_object.data == self.id_data):
+    if self.has_underlay and (context.scene.camera and context.scene.camera.data == self.id_data):
         bpy.ops.bim.reload_drawing_styles()
         bpy.ops.bim.activate_drawing_style()
 
@@ -208,10 +218,12 @@ def update_has_annotation(self, context):
 
 
 def update_layer(self, context, name, value):
-    element = tool.Ifc.get_entity(context.active_object)
+    if not context.scene.camera or context.scene.camera.data != self.id_data:
+        return
+    element = tool.Ifc.get_entity(context.scene.camera)
     if not element:
         return
-    pset = ifcopenshell.util.element.get_psets(element).get("EPset_Drawing")
+    pset = ifcopenshell.util.element.get_pset(element, "EPset_Drawing")
     if pset:
         pset = tool.Ifc.get().by_id(pset["id"])
     else:
@@ -229,9 +241,8 @@ def update_titleblocks(self, context):
     SheetsData.data["titleblocks"] = SheetsData.titleblocks()
 
 
-def toggleDecorations(self, context):
-    toggle = self.should_draw_decorations
-    if toggle:
+def update_should_draw_decorations(self, context):
+    if self.should_draw_decorations:
         # TODO: design a proper text variable templating renderer
         collection = context.scene.camera.BIMObjectProperties.collection
         for obj in collection.objects:
@@ -343,7 +354,7 @@ class DocProperties(PropertyGroup):
     active_sheet_index: IntProperty(name="Active Sheet Index")
     ifc_files: CollectionProperty(name="IFCs", type=StrProperty)
     drawing_styles: CollectionProperty(name="Drawing Styles", type=DrawingStyle)
-    should_draw_decorations: BoolProperty(name="Should Draw Decorations", update=toggleDecorations)
+    should_draw_decorations: BoolProperty(name="Should Draw Decorations", update=update_should_draw_decorations)
     sheets_dir: StringProperty(default=os.path.join("sheets") + os.path.sep, name="Default Sheets Directory")
     layouts_dir: StringProperty(default=os.path.join("layouts") + os.path.sep, name="Default Layouts Directory")
     titleblocks_dir: StringProperty(

src/blenderbim/blenderbim/bim/module/drawing/svgwriter.py

@@ -29,9 +29,11 @@ import svgwrite
 import ifcopenshell
 import ifcopenshell.util.element
 import ifcopenshell.util.representation
+import ifcopenshell.util.selector
 import blenderbim.tool as tool
 import blenderbim.bim.module.drawing.helper as helper
 import blenderbim.bim.module.drawing.annotation as annotation
+from blenderbim.bim.module.drawing.data import DrawingsData
 
 from blenderbim.bim.module.drawing.data import DecoratorData
 from blenderbim.bim.ifc import IfcStore
@@ -39,6 +41,7 @@ from blenderbim.bim.ifc import IfcStore
 from math import pi, ceil, atan, degrees, acos
 from mathutils import geometry, Vector
 from bpy_extras import view3d_utils
+from typing import Optional
 
 
 class External(svgwrite.container.Group):
@@ -322,7 +325,7 @@ class SvgWriter:
                 )
             )
 
-    def draw_misc_annotation(self, obj):
+    def draw_misc_annotation(self, obj: bpy.types.Object) -> None:
         # We have to decide whether this should come from Blender or from IFC.
         # For the moment, for convenience of experimenting with ideas, it comes
         # from Blender. In the future, it should probably come from IFC.
@@ -356,14 +359,14 @@ class SvgWriter:
             d = "M{}".format(d[1:])
             path = self.svg.add(self.svg.path(d=d, class_=" ".join(classes)))
 
-    def get_attribute_classes(self, obj):
+    def get_attribute_classes(self, obj: bpy.types.Object) -> list[str]:
         element = tool.Ifc.get_entity(obj)
         global_id = "GlobalId-{}".format(element.GlobalId)
         predefined_type = "PredefinedType-" + tool.Drawing.canonicalise_class_name(
             str(ifcopenshell.util.element.get_predefined_type(element))
         )
         classes = [global_id, element.is_a(), predefined_type]
-        custom_classes = ifcopenshell.util.element.get_pset(element, "EPset_Annotation", "Classes")
+        custom_classes: str = ifcopenshell.util.element.get_pset(element, "EPset_Annotation", "Classes")
         if custom_classes:
             classes.extend(custom_classes.split())
         for key in self.metadata:
@@ -787,7 +790,7 @@ class SvgWriter:
         attrib["filter"] = "url(#fill-background)"
         return element
 
-    def draw_text_annotation(self, text_obj, position):
+    def draw_text_annotation(self, text_obj: bpy.types.Object, position: Vector) -> None:
         x_offset = self.raw_width / 2
         y_offset = self.raw_height / 2
         element = tool.Ifc.get_entity(text_obj)
@@ -799,17 +802,7 @@ class SvgWriter:
         text_position_svg = text_position * self.svg_scale
         text_position_svg_str = ", ".join(map(str, text_position_svg))
 
-        def get_basis_vector(matrix, i=0):
-            """returns basis vector for i in world space, unaffected by object scale"""
-            return matrix.inverted()[i].to_3d().normalized()
-
-        text_dir_world_x_axis = get_basis_vector(text_obj.matrix_world)
-
-        # RCP cameras may be scaled, so reset scales.
-        camera_matrix = tool.Drawing.get_camera_matrix(self.camera)
-        text_dir = (camera_matrix.inverted().to_quaternion() @ text_dir_world_x_axis).to_2d().normalized()
-        angle = math.degrees(-text_dir.angle_signed(Vector((1, 0))))
-
+        angle = self.get_empty_object_angle(text_obj)
         classes = self.get_attribute_classes(text_obj)
         classes_str = " ".join(classes)
         fill_bg = "fill-bg" in classes
@@ -817,8 +810,7 @@ class SvgWriter:
         symbol = tool.Drawing.get_annotation_symbol(element)
         template_text_fields = []
         if symbol:
-            # NOTE: for now we assume that scale is uniform
-            symbol_transform = f"translate({text_position_svg_str}) rotate({angle}) scale({text_obj.scale.x})"
+            symbol_transform = self.get_symbol_transform(text_position_svg_str, angle, text_obj)
 
             symbol_svg = self.find_xml_symbol_by_id(symbol)
             if symbol_svg:
@@ -847,7 +839,7 @@ class SvgWriter:
                     return None
 
             if not symbol_svg or not template_text_fields:
-                self.svg.add(self.svg.use(f"#{symbol}", transform=symbol_transform))
+                self.draw_symbol(symbol, symbol_transform)
 
         line_number = 0
         for text_literal in text_literals:
@@ -865,17 +857,14 @@ class SvgWriter:
                 self.svg.add(tag)
             line_number += len(tag.elements)
 
-    def draw_empty_annotation(self, obj, classes):
+    def draw_empty_annotation(self, obj: bpy.types.Object, classes: list[str]) -> None:
         x_offset = self.raw_width / 2
         y_offset = self.raw_height / 2
 
         point = self.project_point_onto_camera(obj.matrix_world.translation)
 
         element = tool.Ifc.get_entity(obj)
-        svg_id = ifcopenshell.util.element.get_pset(element, "EPset_Annotation", "Symbol")
-        if not svg_id:
-            # EPset_AnnotationSurveyArea is not standard! See bSI-4.3 proposal #660.
-            svg_id = ifcopenshell.util.element.get_pset(element, "EPset_AnnotationSurveyArea", "PointType")
+        svg_id = tool.Drawing.get_annotation_symbol(element)
         if not svg_id:
             svg_id = str(ifcopenshell.util.element.get_predefined_type(element))
         if not svg_id:
@@ -883,9 +872,37 @@ class SvgWriter:
 
         point = Vector(((x_offset + point.x), (y_offset - point.y)))
         symbol_position_svg = point * self.svg_scale
-        self.svg.add(self.svg.use(f"#{svg_id}", insert=symbol_position_svg))
+        svg_position_str = ", ".join(map(str, symbol_position_svg))
 
-    def draw_point_annotation(self, obj, classes):
+        angle = self.get_empty_object_angle(obj)
+        symbol_transform = self.get_symbol_transform(svg_position_str, angle, obj)
+        self.draw_symbol(svg_id, symbol_transform)
+
+    def get_empty_object_angle(self, obj: bpy.types.Object) -> float:
+        def get_basis_vector(matrix: bpy.types.Object, i: int = 0) -> Vector:
+            """returns basis vector for i in world space, unaffected by object scale"""
+            return matrix.inverted()[i].to_3d().normalized()
+
+        text_dir_world_x_axis = get_basis_vector(obj.matrix_world)
+
+        # RCP cameras may be scaled, so reset scales.
+        camera_matrix = tool.Drawing.get_camera_matrix(self.camera)
+        text_dir = (camera_matrix.inverted().to_quaternion() @ text_dir_world_x_axis).to_2d().normalized()
+        return math.degrees(-text_dir.angle_signed(Vector((1, 0))))
+
+    def get_symbol_transform(
+        self, svg_position_str: str, angle: float = 0.0, obj: Optional[bpy.types.Object] = None
+    ) -> str:
+        """`obj` will be used to identify symbol scale,
+        ignore it if object scale doesn't match the symbol scale"""
+        # NOTE: for now we assume that scale is uniform
+        scale = 1.0 if not obj else obj.scale.x
+        return f"translate({svg_position_str}) rotate({angle}) scale({scale})"
+
+    def draw_symbol(self, symbol_id: str, symbol_transform: str) -> None:
+        self.svg.add(self.svg.use(f"#{symbol_id}", transform=symbol_transform))
+
+    def draw_point_annotation(self, obj: bpy.types.Object, classes: list[str]) -> None:
         x_offset = self.raw_width / 2
         y_offset = self.raw_height / 2
 
@@ -893,10 +910,7 @@ class SvgWriter:
         projected_points = [self.project_point_onto_camera(matrix_world @ v.co) for v in obj.data.vertices]
 
         element = tool.Ifc.get_entity(obj)
-        svg_id = ifcopenshell.util.element.get_pset(element, "EPset_Annotation", "Symbol")
-        if not svg_id:
-            # EPset_AnnotationSurveyArea is not standard! See bSI-4.3 proposal #660.
-            svg_id = ifcopenshell.util.element.get_pset(element, "EPset_AnnotationSurveyArea", "PointType")
+        svg_id = tool.Drawing.get_annotation_symbol(element)
         if not svg_id:
             svg_id = str(ifcopenshell.util.element.get_predefined_type(element))
         if not svg_id:
@@ -905,7 +919,10 @@ class SvgWriter:
         for symbol_position in projected_points:
             symbol_position = Vector(((x_offset + symbol_position.x), (y_offset - symbol_position.y)))
             symbol_position_svg = symbol_position * self.svg_scale
-            self.svg.add(self.svg.use(f"#{svg_id}", insert=symbol_position_svg))
+            svg_position_str = ", ".join(map(str, symbol_position_svg))
+
+            symbol_transform = self.get_symbol_transform(svg_position_str)
+            self.draw_symbol(svg_id, symbol_transform)
 
     def draw_break_annotations(self, obj):
         x_offset = self.raw_width / 2
@@ -1066,7 +1083,9 @@ class SvgWriter:
         # calculating text parameters and adding text
         text_position = arc_mid_point + arc_mid_dir * 5
         text_style = SvgWriter.get_box_alignment_parameters("center")
-        angle_text = f"{int(angle)}deg"
+        drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
+        decimal_places = drawing_pset_data.get("AngleDecimalPlaces", None)
+        angle_text = f"{round(angle, decimal_places)}°"
         self.svg.add(self.svg.text(angle_text, insert=text_position, class_="ANGLE", **text_style))
 
         # Draw SVG arc, see for details: http://xahlee.info/js/svg_circle_arc.html
@@ -1402,7 +1421,7 @@ class SvgWriter:
 
         return text_tags
 
-    def project_point_onto_camera(self, point):
+    def project_point_onto_camera(self, point: Vector) -> Vector:
         # TODO is this needlessly complex?
         return self.camera.matrix_world.inverted() @ geometry.intersect_line_plane(
             point.xyz,

src/blenderbim/blenderbim/bim/module/drawing/ui.py

@@ -268,6 +268,11 @@ class BIM_PT_drawings(Panel):
                 col = row.column()
                 col.alignment = "RIGHT"
 
+                convert_to_dxf = row.row(align=True)
+                op = convert_to_dxf.operator("bim.convert_svg_to_dxf", text="", icon="IMAGE_DATA")
+                op.view = active_drawing.name
+                convert_to_dxf.enabled = active_drawing.ifc_definition_id > 0
+
                 op = row.operator("bim.select_all_drawings", icon="SELECT_SUBTRACT", text="")
 
                 open_drawing_button = row.row(align=True)

src/blenderbim/blenderbim/bim/module/drawing/workspace.py

@@ -250,7 +250,7 @@ class AnnotationToolUI:
         row = cls.layout.row(align=True)
         row.label(text="", icon="FILE_3D")
         prop_with_search(row, cls.props, "relating_type_id", text="")
-        row.operator("bim.launch_annotation_type_manager", icon="LIGHTPROBE_GRID", text="")
+        row.operator("bim.launch_annotation_type_manager", icon=tool.Blender.TYPE_MANAGER_ICON, text="")
 
         add_layout_hotkey_operator(cls.layout, "Add", "S_A", "Create a new annotation")
 

src/blenderbim/blenderbim/bim/module/geometry/helper.py

@@ -21,12 +21,14 @@ import bmesh
 import mathutils
 import ifcopenshell
 import ifcopenshell.util.unit
+import blenderbim.tool as tool
 from math import pi, pow
 from mathutils import Vector, Matrix, geometry
+from typing import Union
 
 
 class Helper:
-    def __init__(self, file):
+    def __init__(self, file: ifcopenshell.file):
         self.file = file
         self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(self.file)
 
@@ -34,7 +36,7 @@ class Helper:
     # edge that shares a single vertex only with that face to find the extrusion
     # edge. A face with the normal facing down is prioritised. A limited
     # dissolve ensure that faces are quads and not tris.
-    def auto_detect_rectangle_profile_extruded_area_solid(self, mesh):
+    def auto_detect_rectangle_profile_extruded_area_solid(self, mesh: bpy.types.Mesh) -> dict:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 1, verts=bm.verts, edges=bm.edges)
@@ -115,7 +117,9 @@ class Helper:
 
         return {"profile": profile, "extrusion": extrusion}
 
-    def auto_detect_arbitrary_profile_with_voids(self, obj, mesh):
+    def auto_detect_arbitrary_profile_with_voids(
+        self, obj: bpy.types.Object, mesh: bpy.types.Mesh
+    ) -> Union[tuple, dict]:
         groups = {"IFCARCINDEX": [], "IFCCIRCLE": []}
         for i, group in enumerate(obj.vertex_groups):
             if "IFCARCINDEX" in group.name:
@@ -138,28 +142,31 @@ class Helper:
             total_groups = 0
             is_circle = False
             for group_type, group_indices in groups.items():
-                for group_index in group_indices:
-                    if group_index in vert[deform_layer]:
-                        if group_type == "IFCCIRCLE":
-                            is_circle = True
-                        group_verts[group_type].setdefault(group_index, 0)
-                        group_verts[group_type][group_index] += 1
-                        total_groups += 0
+                if not group_indices:
+                    continue
+                is_special, group_index = tool.Blender.bmesh_check_vertex_in_groups(vert, deform_layer, group_indices)
+                if not is_special:
+                    continue
+                if group_type == "IFCCIRCLE":
+                    is_circle = True
+                group_verts[group_type].setdefault(group_index, 0)
+                group_verts[group_type][group_index] += 1
+                total_groups += 0
             if total_groups > 1:  # A vert can only belong to one group
                 return (False, "AMBIGUOUS_SPECIAL_VERTEX")
             elif is_circle:
-                pass # Circles are allowed to be unclosed
+                pass  # Circles are allowed to be unclosed
             elif total_groups == 0 and len(vert.link_edges) != 2:  # Unclosed loop or forked loop
                 return (False, "UNCLOSED_LOOP")
 
         for group_type, group_counts in group_verts.items():
             if group_type == "IFCARCINDEX":
                 for group_count in group_counts.values():
-                    if group_count != 3: # Each arc needs 3 verts
+                    if group_count != 3:  # Each arc needs 3 verts
                         return (False, "3POINT_ARC")
             elif group_type == "IFCCIRCLE":
                 for group_count in group_counts.values():
-                    if group_count != 2: # Each circle needs 2 verts
+                    if group_count != 2:  # Each circle needs 2 verts
                         return (False, "CIRCLE")
 
         loop_edges = set(bm.edges)
@@ -269,7 +276,7 @@ class Helper:
         inner_loops.remove(outer_loop)
 
         # Copy vectors to prevent random data mangling after bmesh is freed.
-        points = [Vector(list(v.co)) for v in bm.verts]
+        points = [v.co.copy() for v in bm.verts]
 
         bm.to_mesh(mesh)
         mesh.update()

src/blenderbim/blenderbim/bim/module/geometry/operator.py

@@ -324,8 +324,8 @@ class UpdateRepresentation(bpy.types.Operator, Operator):
                 # We are explicitly casting to a tessellation, so remove all parametric materials.
                 element_type = ifcopenshell.util.element.get_type(product)
                 if element_type:  # Some invalid IFCs use material sets without a type.
-                    ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), product=element_type)
-                ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), product=product)
+                    ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), products=[element_type])
+                ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), products=[product])
             else:
                 # These objects are parametrically based on an axis and should not be modified as a mesh
                 return
@@ -972,7 +972,7 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
             if parts:
                 index = get_max_index(parts)
                 add_linked_aggregate_pset(element, index)
-                index +=1
+                index += 1
                 for part in parts:
                     if part.is_a("IfcElementAssembly"):
                         select_objects_and_add_data(part)
@@ -982,16 +982,13 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                         
                     obj = tool.Ifc.get_object(part)
                     obj.select_set(True)
-                    
-                    
+
         def add_linked_aggregate_pset(part, index):
             pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
-        
+
             if not pset:
-                pset = ifcopenshell.api.run(
-                    "pset.add_pset", tool.Ifc.get(), product=part, name=self.pset_name
-                )
-            
+                pset = ifcopenshell.api.run("pset.add_pset", tool.Ifc.get(), product=part, name=self.pset_name)
+
                 ifcopenshell.api.run(
                     "pset.edit_pset",
                     tool.Ifc.get(),
@@ -1016,7 +1013,9 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                 return
 
             linked_aggregate_group = ifcopenshell.api.run("group.add_group", tool.Ifc.get(), Name=self.group_name)
-            ifcopenshell.api.run("group.assign_group", tool.Ifc.get(), products=[element], group=linked_aggregate_group)
+            ifcopenshell.api.run(
+                "group.assign_group", tool.Ifc.get(), products=[element], group=linked_aggregate_group
+            )
 
         def custom_incremental_naming_for_element_assembly(old_to_new):
             for new in old_to_new.values():
@@ -1027,16 +1026,16 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                         if r.is_a("IfcRelAssignsToGroup")
                         if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
                     ][0]
-                
+
                     number = len(group_elements) - 1
                     number = f"{number:02d}"
                     new_obj = tool.Ifc.get_object(new[0])
-                    pattern1 = r'_\d'
+                    pattern1 = r"_\d"
                     if re.findall(pattern1, new_obj.name):
                         split_name = new_obj.name.split("_")
                         new_obj.name = split_name[0] + "_" + number
                         continue
-                    pattern2 = r'\.\d{3}'
+                    pattern2 = r"\.\d{3}"
                     if re.findall(pattern2, new_obj.name):
                         split_name = new_obj.name.split(".")
                         new_obj.name = split_name[0] + "_" + number
@@ -1074,6 +1073,7 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                     ]
                     tool.Ifc.run("group.assign_group", group=linked_aggregate_group[0], products=new)
              
+
         if len(context.selected_objects) != 1:
             return {"FINISHED"}
 
@@ -1099,14 +1099,11 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
         copy_linked_aggregate_data(old_to_new)
 
         custom_incremental_naming_for_element_assembly(old_to_new)
-        
+
         blenderbim.bim.handler.refresh_ui_data()
 
         return old_to_new
 
-    
-        
-
 
 class RefreshLinkedAggregate(bpy.types.Operator):
     bl_idname = "bim.refresh_linked_aggregate"
@@ -1154,9 +1151,9 @@ class RefreshLinkedAggregate(bpy.types.Operator):
             original_names[group] = {}
 
             pset = ifcopenshell.util.element.get_pset(element, self.pset_name)
-            index = pset['Index']                    
+            index = pset["Index"]
             original_names[group][index] = tool.Ifc.get_object(element).name
-            
+
             parts = ifcopenshell.util.element.get_parts(element)
             if parts:
                 for part in parts:
@@ -1164,20 +1161,22 @@ class RefreshLinkedAggregate(bpy.types.Operator):
                         original_names | get_original_names(part)
                     else:
                         try:
-                          pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
+                            pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
                         except:
-                          continue
-                        index = pset['Index']                    
+                            continue
+                        index = pset["Index"]
                         original_names[group][index] = tool.Ifc.get_object(part).name
-                    
+
             return original_names
 
         def set_original_name(obj, original_names):
             element = tool.Ifc.get_entity(obj)
             aggregate = ifcopenshell.util.element.get_aggregate(element)
-            if ifcopenshell.util.element.get_parts(element): # if element has parts it means it is the base of and aggregate or sub-aggregate
+            if ifcopenshell.util.element.get_parts(
+                element
+            ):  # if element has parts it means it is the base of and aggregate or sub-aggregate
                 aggregate = element
-                
+
             group = [
                 r.RelatingGroup
                 for r in getattr(aggregate, "HasAssignments", []) or []
@@ -1186,12 +1185,12 @@ class RefreshLinkedAggregate(bpy.types.Operator):
             ]
             if not group:
                 return
-            
+
             group = group[0].id()
-                
+
             pset = ifcopenshell.util.element.get_pset(element, self.pset_name)
-            index = pset['Index']
-            
+            index = pset["Index"]
+
             try:
                 obj.name = original_names[group][index]
             except:
@@ -1295,9 +1294,9 @@ class RefreshLinkedAggregate(bpy.types.Operator):
                 element_aggregate = ifcopenshell.util.element.get_aggregate(element)
 
                 selected_matrix, duplicate_matrix = get_original_matrix(element, base_instance)
-                
+
                 original_names = get_original_names(element)
-                
+
                 delete_objects(element)
 
                 for obj in context.selected_objects:
@@ -1308,24 +1307,24 @@ class RefreshLinkedAggregate(bpy.types.Operator):
                 old_to_new = DuplicateMoveLinkedAggregate.execute_ifc_duplicate_linked_aggregate_operator(self, context)
 
                 set_new_matrix(selected_matrix, duplicate_matrix, old_to_new)
-                    
+
                 for old, new in old_to_new.items():
                     if element_aggregate and new[0].is_a("IfcElementAssembly"):
                         new_aggregate = ifcopenshell.util.element.get_aggregate(new[0])
 
                         if not new_aggregate:
                             blenderbim.core.aggregate.assign_object(
-                                                        tool.Ifc,
-                                                        tool.Aggregate,
-                                                        tool.Collector,
-                                                        relating_obj=tool.Ifc.get_object(element_aggregate),
-                                                        related_obj=tool.Ifc.get_object(new[0]),
-                                                    )
-                
+                                tool.Ifc,
+                                tool.Aggregate,
+                                tool.Collector,
+                                relating_obj=tool.Ifc.get_object(element_aggregate),
+                                related_obj=tool.Ifc.get_object(new[0]),
+                            )
+
                 for old, new in old_to_new.items():
                     new_obj = tool.Ifc.get_object(new[0])
                     set_original_name(new_obj, original_names)
-                        
+
         blenderbim.bim.handler.refresh_ui_data()
 
         operator_time = time() - refresh_start_time
@@ -1473,7 +1472,9 @@ class OverrideModeSetEdit(bpy.types.Operator):
         for obj in selected_objs:
             if not obj:
                 continue
-            if not obj.data:
+            obj_supports_edit_mode, message = tool.Blender.object_supports_edit_mode(obj)
+            if not obj_supports_edit_mode:
+                self.report({"INFO"}, message)
                 obj.select_set(False)
                 continue
             element = tool.Ifc.get_entity(obj)

src/blenderbim/blenderbim/bim/module/geometry/ui.py

@@ -212,7 +212,7 @@ class BIM_PT_representation_items(Panel):
         if props.is_editing_item_style:
             # NOTE: we currently support 1 item having just 1 style
             # when IfcStyledItem can actually have multiple styles
-            row.prop(props, "representation_item_style", icon="SHADING_RENDERED", text="")
+            prop_with_search(row, props, "representation_item_style", icon="SHADING_RENDERED", text="")
             row.operator("bim.edit_representation_item_style", icon="CHECKMARK", text="")
             row.operator("bim.disable_editing_representation_item_style", icon="CANCEL", text="")
         else:

src/blenderbim/blenderbim/bim/module/group/operator.py

@@ -212,7 +212,7 @@ class UnassignGroup(bpy.types.Operator, tool.Ifc.Operator):
                 "group.unassign_group",
                 self.file,
                 **{
-                    "product": self.file.by_id(product.BIMObjectProperties.ifc_definition_id),
+                    "products": [self.file.by_id(product.BIMObjectProperties.ifc_definition_id)],
                     "group": self.file.by_id(self.group),
                 }
             )

src/blenderbim/blenderbim/bim/module/layer/operator.py

@@ -151,7 +151,10 @@ class AssignPresentationLayer(bpy.types.Operator):
         ifcopenshell.api.run(
             "layer.assign_layer",
             self.file,
-            **{"item": self.file.by_id(item.BIMMeshProperties.ifc_definition_id), "layer": self.file.by_id(self.layer)}
+            **{
+                "items": [self.file.by_id(item.BIMMeshProperties.ifc_definition_id)],
+                "layer": self.file.by_id(self.layer),
+            }
         )
         return {"FINISHED"}
 
@@ -173,7 +176,10 @@ class UnassignPresentationLayer(bpy.types.Operator):
         ifcopenshell.api.run(
             "layer.unassign_layer",
             self.file,
-            **{"item": self.file.by_id(item.BIMMeshProperties.ifc_definition_id), "layer": self.file.by_id(self.layer)}
+            **{
+                "items": [self.file.by_id(item.BIMMeshProperties.ifc_definition_id)],
+                "layer": self.file.by_id(self.layer),
+            }
         )
         return {"FINISHED"}
 

src/blenderbim/blenderbim/bim/module/material/data.py

@@ -19,6 +19,7 @@
 import os
 import bpy
 import ifcopenshell
+import ifcopenshell.util.doc
 import ifcopenshell.util.schema
 import blenderbim.tool as tool
 
@@ -109,29 +110,41 @@ class MaterialsData:
     def active_styles(cls):
         props = bpy.context.scene.BIMMaterialProperties
         results = []
-        if props.materials and props.active_material_index < len(props.materials):
-            material = props.materials[props.active_material_index].ifc_definition_id
-            if not material:
-                return results
-            material = tool.Ifc.get().by_id(material)
-            for definition in material.HasRepresentation:
-                for representation in definition.Representations:
-                    if not representation.is_a("IfcStyledRepresentation"):
+        if not props.materials or props.active_material_index >= len(props.materials):
+            return results
+
+        material = props.materials[props.active_material_index].ifc_definition_id
+        if not material:
+            return results
+
+        material = tool.Ifc.get_entity_by_id(material)
+
+        # NOTE: it's possible that data will be refreshed during material removal
+        # (when it will try to fetch active material type and will reach for material_types)
+        # and props.materials[i].ifc_definition_id will contain already removed id
+        if not material or not material.is_a("IfcMaterial"):
+            return results
+
+        for definition in material.HasRepresentation:
+            for representation in definition.Representations:
+                if not representation.is_a("IfcStyledRepresentation"):
+                    continue
+                context = representation.ContextOfItems
+                for item in representation.Items:
+                    if not item.is_a("IfcStyledItem"):
                         continue
-                    context = representation.ContextOfItems
-                    for item in representation.Items:
-                        if not item.is_a("IfcStyledItem"):
-                            continue
-                        for style in item.Styles:
-                            if style.is_a("IfcSurfaceStyle"):
-                                results.append({
+                    for style in item.Styles:
+                        if style.is_a("IfcSurfaceStyle"):
+                            results.append(
+                                {
                                     "context_type": context.ContextType,
                                     "context_identifier": getattr(context, "ContextIdentifier", ""),
                                     "target_view": getattr(context, "TargetView", ""),
                                     "name": style.Name or "Unnamed",
                                     "id": style.id(),
                                     "context_id": context.id(),
-                                })
+                                }
+                            )
         return results
 
 

src/blenderbim/blenderbim/bim/module/material/operator.py

@@ -34,6 +34,7 @@ from blenderbim.bim.ifc import IfcStore
 class LoadMaterials(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.load_materials"
     bl_label = "Load Materials"
+    bl_description = "Display list of named materials"
     bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context):
@@ -117,7 +118,7 @@ class AddMaterial(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.add_material"
     bl_label = "Add Material"
     bl_options = {"REGISTER", "UNDO"}
-    obj: bpy.props.StringProperty()
+    obj: bpy.props.StringProperty(name="Material Name")
     name: bpy.props.StringProperty(default="Default")
 
     def invoke(self, context, event):
@@ -762,6 +763,11 @@ class EditMaterialStyle(bpy.types.Operator, tool.Ifc.Operator):
         ifcopenshell.api.run("style.assign_material_style", ifc_file, material=material, style=style, context=context)
         tool.Material.disable_editing_material()
         core.load_materials(tool.Material, props.material_type)
+        # NOTE: Update all elements that has this material and
+        # not just the ones that are using it in IfcMaterialConstituent,
+        # to handle cases where Style is connected to geometry implicitly:
+        # e.g. RepItem->IfcElement->IfcMaterial->Style
+        # instead of RepItem->ShapeAspect->Constituent->Style.
         tool.Material.update_elements_using_material(material)
 
 

src/blenderbim/blenderbim/bim/module/material/ui.py

@@ -175,7 +175,7 @@ class BIM_PT_object_material(Panel):
 
         if ObjectMaterialData.data["type_material"]:
             row = self.layout.row(align=True)
-            row.label(text="Inherited Material: " + ObjectMaterialData.data["type_material"], icon="FILE_PARENT")
+            row.label(text="Inherited Material: " + ObjectMaterialData.data["type_material"], icon="CON_CHILDOF")
 
         if ObjectMaterialData.data["material_class"]:
             return self.draw_material_ui()

src/blenderbim/blenderbim/bim/module/model/decorator.py

@@ -23,6 +23,7 @@ from math import sin, cos, radians
 from bpy.types import SpaceView3D
 from mathutils import Vector, Matrix
 from gpu_extras.batch import batch_for_shader
+from typing import Union
 
 
 ERROR_ELEMENTS_COLOR = (1, 0.2, 0.322, 1)  # RED
@@ -35,15 +36,6 @@ def transparent_color(color, alpha=0.1):
     return color
 
 
-def bm_check_vertex_in_groups(vertex, deform_layer, groups):
-    """returns tuple boolean (whether vertex is in any of the groups)
-    and related group index"""
-    for group_index in vertex[deform_layer].keys():
-        if group_index in groups:
-            return True, group_index
-    return False, None
-
-
 class ProfileDecorator:
     installed = None
 
@@ -148,12 +140,12 @@ class ProfileDecorator:
             # deform_layer is None if there are no verts assigned to vertex groups
             # even if there are vertex groups in the obj.vertex_groups
             if deform_layer:
-                is_arc, group_index = bm_check_vertex_in_groups(vertex, deform_layer, arc_groups)
+                is_arc, group_index = tool.Blender.bmesh_check_vertex_in_groups(vertex, deform_layer, arc_groups)
                 if is_arc:
                     arcs.setdefault(group_index, []).append(vertex)
                     special_vertex_indices[vertex.index] = group_index
 
-                is_circle, group_index = bm_check_vertex_in_groups(vertex, deform_layer, circle_groups)
+                is_circle, group_index = tool.Blender.bmesh_check_vertex_in_groups(vertex, deform_layer, circle_groups)
                 if is_circle:
                     circles.setdefault(group_index, []).append(vertex)
                     special_vertex_indices[vertex.index] = group_index

src/blenderbim/blenderbim/bim/module/model/mep.py

@@ -542,7 +542,7 @@ class MEPGenerator:
             ifc_representation_class=None,
         )
 
-        rel = ifcopenshell.api.run("material.assign_material", ifc_file, product=element, type="IfcMaterialProfileSet")
+        rel = ifcopenshell.api.run("material.assign_material", ifc_file, products=[element], type="IfcMaterialProfileSet")
         profile_set = rel.RelatingMaterial
         material_profile = ifcopenshell.api.run(
             "material.add_profile", ifc_file, profile_set=profile_set, material=material

src/blenderbim/blenderbim/bim/module/model/opening.py

@@ -24,10 +24,14 @@ import shapely
 import logging
 import numpy as np
 import ifcopenshell
+import ifcopenshell.api
+import ifcopenshell.geom
 import ifcopenshell.util.shape
 import ifcopenshell.util.element
 import ifcopenshell.util.shape_builder
+import ifcopenshell.util.placement
 import ifcopenshell.util.representation
+import ifcopenshell.util.unit
 import blenderbim.tool as tool
 import blenderbim.core.geometry
 import blenderbim.bim.import_ifc as import_ifc
@@ -107,7 +111,7 @@ class FilledOpeningGenerator:
                 # Equivalent to "side Z" for a wall axis, so that stuff like skylights appear on the top.
                 local_position_on_voided_obj.z = layers["offset"] + layers["thickness"]
                 new_matrix.translation.xyz = voided_obj.matrix_world @ local_position_on_voided_obj
-                rotation_matrix = Matrix.Rotation(radians(-90), 4, 'X')
+                rotation_matrix = Matrix.Rotation(radians(-90), 4, "X")
                 new_matrix @= rotation_matrix
 
             filling_obj.matrix_world = new_matrix
@@ -184,7 +188,13 @@ class FilledOpeningGenerator:
                 )
 
     def regenerate_from_type(self, usecase_path, ifc_file, settings):
-        filling = settings["related_object"]
+        relating_type = settings["relating_type"]
+
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object)
+
+    def _regenerate_from_type(self, related_object: ifcopenshell.entity_instance) -> None:
+        filling = related_object
         if not getattr(filling, "FillsVoids", None):
             return
 

src/blenderbim/blenderbim/bim/module/model/product.py

@@ -25,9 +25,13 @@ import ifcopenshell.util.system
 import ifcopenshell.util.element
 import ifcopenshell.util.placement
 import ifcopenshell.util.representation
+import ifcopenshell.util.type
+import ifcopenshell.util.unit
 import blenderbim.tool as tool
+import blenderbim.core.aggregate
 import blenderbim.core.type
 import blenderbim.core.geometry
+import blenderbim.core.spatial
 from . import wall, slab, profile, mep
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.model.data import AuthoringData
@@ -273,7 +277,7 @@ class AddConstrTypeInstance(bpy.types.Operator):
             obj.location[2] = collection_obj.location[2] + bpy.context.scene.BIMModelProperties.rl2
 
     @staticmethod
-    def generate_layered_element(ifc_class, relating_type):
+    def generate_layered_element(ifc_class: str, relating_type: ifcopenshell.entity_instance) -> bool:
         layer_set_direction = None
 
         parametric = ifcopenshell.util.element.get_psets(relating_type).get("EPset_Parametric")
@@ -297,6 +301,7 @@ class AddConstrTypeInstance(bpy.types.Operator):
             material = ifcopenshell.util.element.get_material(tool.Ifc.get_entity(obj))
             material.LayerSetDirection = layer_set_direction
             return True
+        return False
 
 
 class ChangeTypePage(bpy.types.Operator, tool.Ifc.Operator):
@@ -510,7 +515,7 @@ def ensure_material_assigned(usecase_path, ifc_file, settings):
     if usecase_path == "material.assign_material":
         if not settings.get("material", None):
             return
-        elements = [settings["product"]]
+        elements = settings["products"]
     else:
         elements = []
         for rel in ifc_file.by_type("IfcRelAssociatesMaterial"):
@@ -546,7 +551,7 @@ def ensure_material_assigned(usecase_path, ifc_file, settings):
 
 
 def ensure_material_unassigned(usecase_path, ifc_file, settings):
-    elements = [settings["product"]]
+    elements = settings["products"]
     if elements[0].is_a("IfcElementType"):
         elements.extend(ifcopenshell.util.element.get_types(elements[0]))
     for element in elements:

src/blenderbim/blenderbim/bim/module/model/profile.py

@@ -21,14 +21,18 @@ import copy
 import bmesh
 import mathutils.geometry
 import ifcopenshell
+import ifcopenshell.api
 import ifcopenshell.util.type
 import ifcopenshell.util.unit
 import ifcopenshell.util.element
+import ifcopenshell.util.placement
+import ifcopenshell.util.representation
 import blenderbim.bim.handler
 import blenderbim.tool as tool
 import blenderbim.core.type
 import blenderbim.core.geometry
 import blenderbim.core.material
+import blenderbim.core.root
 from math import pi, degrees, inf
 from mathutils import Vector, Matrix, Quaternion
 from blenderbim.bim.module.geometry.helper import Helper
@@ -92,7 +96,7 @@ class DumbProfileGenerator:
             should_add_representation=False,
             context=self.body_context,
         )
-        ifcopenshell.api.run("type.assign_type", self.file, related_object=element, relating_type=self.relating_type)
+        ifcopenshell.api.run("type.assign_type", self.file, related_objects=[element], relating_type=self.relating_type)
 
         material = ifcopenshell.util.element.get_material(element)
         material.CardinalPoint = self.cardinal_point
@@ -207,12 +211,19 @@ class DumbProfileRegenerator:
         return results
 
     def regenerate_from_type(self, usecase_path, ifc_file, settings):
-        obj = tool.Ifc.get_object(settings["related_object"])
-        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
-            return
-        new_material = ifcopenshell.util.element.get_material(settings["relating_type"])
+        relating_type = settings["relating_type"]
+
+        new_material = ifcopenshell.util.element.get_material(relating_type)
         if not new_material or not new_material.is_a("IfcMaterialProfileSet"):
             return
+
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object)
+
+    def _regenerate_from_type(self, related_object: ifcopenshell.entity_instance) -> None:
+        obj = tool.Ifc.get_object(related_object)
+        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
+            return
         DumbProfileRecalculator().recalculate([obj])
 
 

src/blenderbim/blenderbim/bim/module/model/slab.py

@@ -20,17 +20,22 @@ import bpy
 import json
 import bmesh
 import ifcopenshell
-import ifcopenshell.util.type
-import ifcopenshell.util.unit
+import ifcopenshell.api
 import ifcopenshell.util.element
+import ifcopenshell.util.placement
+import ifcopenshell.util.representation
+import ifcopenshell.util.unit
+import ifcopenshell.util.type
 import blenderbim.bim.handler
 import blenderbim.core.type
 import blenderbim.core.geometry
+import blenderbim.core.root
 import blenderbim.tool as tool
 from math import radians
 from mathutils import Vector, Matrix
 from blenderbim.bim.module.geometry.helper import Helper
 from blenderbim.bim.module.model.decorator import ProfileDecorator
+from typing import Optional
 
 
 def calculate_quantities(usecase_path, ifc_file, settings):
@@ -110,7 +115,7 @@ def calculate_quantities(usecase_path, ifc_file, settings):
 
 
 class DumbSlabGenerator:
-    def __init__(self, relating_type):
+    def __init__(self, relating_type: ifcopenshell.entity_instance):
         self.relating_type = relating_type
 
     def generate(self):
@@ -173,7 +178,7 @@ class DumbSlabGenerator:
             should_add_representation=False,
             context=self.body_context,
         )
-        ifcopenshell.api.run("type.assign_type", self.file, related_object=element, relating_type=self.relating_type)
+        ifcopenshell.api.run("type.assign_type", self.file, related_objects=[element], relating_type=self.relating_type)
 
         blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
         representation = ifcopenshell.api.run(
@@ -246,27 +251,38 @@ class DumbSlabPlaner:
                             self.change_thickness(element, total_thickness)
 
     def regenerate_from_type(self, usecase_path, ifc_file, settings):
-        obj = tool.Ifc.get_object(settings["related_object"])
-        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
-            return
-        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
-        new_material = ifcopenshell.util.element.get_material(settings["relating_type"])
+        relating_type = settings["relating_type"]
+
+        new_material = ifcopenshell.util.element.get_material(relating_type)
         if not new_material or not new_material.is_a("IfcMaterialLayerSet"):
             return
+
         parametric = ifcopenshell.util.element.get_psets(settings["relating_type"]).get("EPset_Parametric")
         layer_set_direction = None
         if parametric:
             layer_set_direction = parametric.get("LayerSetDirection", layer_set_direction)
         new_thickness = sum([l.LayerThickness for l in new_material.MaterialLayers])
-        material = ifcopenshell.util.element.get_material(settings["related_object"])
+
+        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object, layer_set_direction, new_thickness)
+
+    def _regenerate_from_type(
+        self, related_object: ifcopenshell.entity_instance, layer_set_direction: Optional[str], new_thickness: float
+    ) -> None:
+        obj = tool.Ifc.get_object(related_object)
+        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
+            return
+
+        material = ifcopenshell.util.element.get_material(related_object)
         if not material or not material.is_a("IfcMaterialLayerSetUsage"):
             return
         if layer_set_direction:
             material.LayerSetDirection = layer_set_direction
         if material.LayerSetDirection == "AXIS3":
-            self.change_thickness(settings["related_object"], new_thickness)
+            self.change_thickness(related_object, new_thickness)
 
-    def change_thickness(self, element, thickness):
+    def change_thickness(self, element: ifcopenshell.entity_instance, thickness: float) -> None:
         body_context = ifcopenshell.util.representation.get_context(tool.Ifc.get(), "Model", "Body", "MODEL_VIEW")
         obj = tool.Ifc.get_object(element)
         if not obj:
@@ -698,9 +714,7 @@ class EditExtrusionProfile(bpy.types.Operator, tool.Ifc.Operator):
         new_footprint = ifcopenshell.api.run(
             "geometry.add_footprint_representation", tool.Ifc.get(), context=footprint_context, curves=curves
         )
-        old_footprint = ifcopenshell.util.representation.get_representation(
-            element, "Plan", "FootPrint", "SKETCH_VIEW"
-        )
+        old_footprint = ifcopenshell.util.representation.get_representation(element, "Plan", "FootPrint", "SKETCH_VIEW")
         if old_footprint:
             for inverse in tool.Ifc.get().get_inverse(old_footprint):
                 ifcopenshell.util.element.replace_attribute(inverse, old_footprint, new_footprint)

src/blenderbim/blenderbim/bim/module/model/space.py

@@ -29,13 +29,17 @@ class GenerateSpace(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.generate_space"
     bl_label = "Generate Space"
     bl_options = {"REGISTER"}
-    bl_description = "Create a space from the cursor position. Move the cursor position into the desired position, select the right space collection and run the operator"
+    bl_description = (
+        "Create a space from the cursor position. "
+        "Move the cursor position into the desired position, "
+        "select the right space collection and run the operator"
+    )
 
     @classmethod
     def poll(cls, context):
         collection = context.view_layer.active_layer_collection.collection
         collection_obj = collection.BIMCollectionProperties.obj
-        active_obj = bpy.context.active_object
+        active_obj = context.active_object
         element = tool.Ifc.get_entity(active_obj)
         return tool.Ifc.get_entity(collection_obj) and not element.is_a("IfcWall")
 
@@ -47,16 +51,14 @@ class GenerateSpace(bpy.types.Operator, tool.Ifc.Operator):
         def msg(self, context):
             self.layout.label(text="NO ACTIVE STOREY")
 
-#        props = context.scene.BIMModelProperties
-
         collection = context.view_layer.active_layer_collection.collection
         collection_obj = collection.BIMCollectionProperties.obj
         if not collection_obj:
-            bpy.context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
+            context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
             return
         spatial_element = tool.Ifc.get_entity(collection_obj)
         if not spatial_element:
-            bpy.context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
+            context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
             return
 
         core.generate_space(tool.Ifc, tool.Spatial, tool.Model, tool.Type)
@@ -70,7 +72,7 @@ class GenerateSpacesFromWalls(bpy.types.Operator, tool.Ifc.Operator):
 
     @classmethod
     def poll(cls, context):
-        active_obj = bpy.context.active_object
+        active_obj = context.active_object
         element = tool.Ifc.get_entity(active_obj)
         if element:
             return context.selected_objects and element.is_a("IfcWall")
@@ -81,7 +83,7 @@ class GenerateSpacesFromWalls(bpy.types.Operator, tool.Ifc.Operator):
         # In order to run, the active object must be a wall and
         # there must be selected walls
 
-        active_obj = bpy.context.active_object
+        active_obj = context.active_object
         element = tool.Ifc.get_entity(active_obj)
         container = tool.Spatial.get_container(element)
 
@@ -96,28 +98,30 @@ class GenerateSpacesFromWalls(bpy.types.Operator, tool.Ifc.Operator):
         if not container:
             self.report({"ERROR"}, "The wall is not contained.")
 
-        if not bpy.context.selected_objects:
+        if not context.selected_objects:
             self.report({"ERROR"}, "No selected objects found. Please select walls.")
             return
 
         core.generate_spaces_from_walls(tool.Ifc, tool.Spatial, tool.Collector)
 
+
 class ToggleSpaceVisibility(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.toggle_space_visibility"
     bl_label = "Toggle Space Visibility"
     bl_options = {"REGISTER"}
     bl_description = "Change the space visibility"
 
-    def execute(cls, context):
+    def execute(self, context):
         core.toggle_space_visibility(tool.Ifc, tool.Spatial)
         return {"FINISHED"}
 
+
 class ToggleHideSpaces(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.toggle_hide_spaces"
     bl_label = "Toggle Hide Spaces"
     bl_options = {"REGISTER"}
     bl_description = "Hide or Unhide all spaces"
 
-    def execute(cls, context):
+    def execute(self, context):
         core.toggle_hide_spaces(tool.Ifc, tool.Spatial)
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/model/ui.py

@@ -54,8 +54,10 @@ class LaunchTypeManager(bpy.types.Operator):
         props.type_page = 1
         if get_ifc_class(None, context):
             ifc_class = props.ifc_class or AuthoringData.data["ifc_element_type"]
-            props.type_class = ifc_class
-            bpy.ops.bim.load_type_thumbnails(ifc_class=ifc_class, offset=0, limit=9)
+        else:
+            ifc_class = AuthoringData.data["ifc_element_type"]
+        props.type_class = ifc_class
+        bpy.ops.bim.load_type_thumbnails(ifc_class=ifc_class, offset=0, limit=9)
         return context.window_manager.invoke_popup(self, width=550)
 
     def draw(self, context):

src/blenderbim/blenderbim/bim/module/model/wall.py

@@ -24,7 +24,9 @@ import ifcopenshell
 import ifcopenshell.api
 import ifcopenshell.util.unit
 import ifcopenshell.util.element
+import ifcopenshell.util.placement
 import ifcopenshell.util.representation
+import ifcopenshell.util.type
 import mathutils.geometry
 import blenderbim.bim.handler
 import blenderbim.core.type
@@ -35,6 +37,7 @@ from blenderbim.bim.ifc import IfcStore
 from math import pi, sin, cos, degrees, radians
 from mathutils import Vector, Matrix
 from blenderbim.bim.module.model.opening import FilledOpeningGenerator
+from typing import Optional
 
 
 class JoinWall(bpy.types.Operator, tool.Ifc.Operator):
@@ -555,7 +558,10 @@ class DumbWallGenerator:
                 for face in sibling_obj.data.polygons:
                     normal = (sibling_obj.matrix_world.to_quaternion() @ face.normal).normalized()
                     face_center = sibling_obj.matrix_world @ face.center
-                    if normal.z != 0 or abs(mathutils.geometry.distance_point_to_plane(self.location, face_center, normal)) > 0.01:
+                    if (
+                        normal.z != 0
+                        or abs(mathutils.geometry.distance_point_to_plane(self.location, face_center, normal)) > 0.01
+                    ):
                         continue
 
                     rotation = math.atan2(normal[1], normal[0])
@@ -603,7 +609,7 @@ class DumbWallGenerator:
             should_add_representation=False,
             context=self.body_context,
         )
-        ifcopenshell.api.run("type.assign_type", self.file, related_object=element, relating_type=self.relating_type)
+        ifcopenshell.api.run("type.assign_type", self.file, related_objects=[element], relating_type=self.relating_type)
         if self.axis_context:
             representation = ifcopenshell.api.run(
                 "geometry.add_axis_representation",
@@ -724,18 +730,29 @@ class DumbWallPlaner:
         DumbWallRecalculator().recalculate([w for w in set(walls) if w])
 
     def regenerate_from_type(self, usecase_path, ifc_file, settings):
-        obj = tool.Ifc.get_object(settings["related_object"])
-        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
-            return
-        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
-        new_material = ifcopenshell.util.element.get_material(settings["relating_type"])
+        relating_type = settings["relating_type"]
+
+        new_material = ifcopenshell.util.element.get_material(relating_type)
         if not new_material or not new_material.is_a("IfcMaterialLayerSet"):
             return
-        parametric = ifcopenshell.util.element.get_psets(settings["relating_type"]).get("EPset_Parametric")
+
+        parametric = ifcopenshell.util.element.get_psets(relating_type).get("EPset_Parametric")
         layer_set_direction = None
         if parametric:
             layer_set_direction = parametric.get("LayerSetDirection", layer_set_direction)
-        material = ifcopenshell.util.element.get_material(settings["related_object"])
+
+        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object, layer_set_direction)
+
+    def _regenerate_from_type(
+        self, related_object: ifcopenshell.entity_instance, layer_set_direction: Optional[str]
+    ) -> None:
+        obj = tool.Ifc.get_object(related_object)
+        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
+            return
+
+        material = ifcopenshell.util.element.get_material(related_object)
         if not material or not material.is_a("IfcMaterialLayerSetUsage"):
             return
         if layer_set_direction:
@@ -854,11 +871,11 @@ class DumbWallJoiner:
             if (location_on_base - location).length < (location_on_side - location).length:
                 axis_offset = location_on_side - location_on_base
                 offset_from_axis = location_on_base - location
-                opening_matrix.translation = (location_on_base - axis_offset - offset_from_axis)
+                opening_matrix.translation = location_on_base - axis_offset - offset_from_axis
             else:
                 axis_offset = location_on_side - location_on_base
                 offset_from_axis = location_on_side - location
-                opening_matrix.translation = (location_on_side - axis_offset - offset_from_axis)
+                opening_matrix.translation = location_on_side - axis_offset - offset_from_axis
             opening_matrixes[opening] = opening_matrix
 
             for filling in [r.RelatedBuildingElement for r in opening.HasFillings]:
@@ -871,11 +888,11 @@ class DumbWallJoiner:
                 if (location_on_base - location).length < (location_on_side - location).length:
                     axis_offset = location_on_side - location_on_base
                     offset_from_axis = location_on_base - location
-                    filling_matrix.translation = (location_on_base - axis_offset - offset_from_axis)
+                    filling_matrix.translation = location_on_base - axis_offset - offset_from_axis
                 else:
                     axis_offset = location_on_side - location_on_base
                     offset_from_axis = location_on_side - location
-                    filling_matrix.translation = (location_on_side - axis_offset - offset_from_axis)
+                    filling_matrix.translation = location_on_side - axis_offset - offset_from_axis
                 filling_matrixes[filling] = filling_matrix
 
         self.recreate_wall(element1, wall1, axis1["reference"], axis1["reference"])
@@ -1120,13 +1137,8 @@ class DumbWallJoiner:
                 other = tool.Ifc.get_object(rel.RelatedElement)
                 if connection not in ["ATPATH", "NOTDEFINED"]:
                     self.join(
-                        obj,
-                        other,
-                        connection,
-                        rel.RelatedConnectionType,
-                        is_relating=True,
-                        description=rel.Description
-                  )
+                        obj, other, connection, rel.RelatedConnectionType, is_relating=True, description=rel.Description
+                    )
         for rel in element.ConnectedFrom:
             if rel.is_a("IfcRelConnectsPathElements"):
                 connection = rel.RelatedConnectionType

src/blenderbim/blenderbim/bim/module/model/workspace.py

@@ -516,20 +516,21 @@ class BimToolUI:
                 prop_with_search(row, cls.props, "relating_type_id", text="")
             else:
                 row.label(text="No Construction Type", icon="FILE_3D")
-            row.operator("bim.launch_type_manager", icon="LIGHTPROBE_GRID", text="")
+            row.operator("bim.launch_type_manager", icon=tool.Blender.TYPE_MANAGER_ICON, text="")
         else:
             if AuthoringData.data["ifc_element_type"]:
                 row.label(text=f"No {AuthoringData.data['ifc_element_type']} Found", icon="ERROR")
                 row = cls.layout.row()
                 row.prop(cls.props, "type_name")
-                row = cls.layout.row()
+                row = cls.layout.row(align=True)
                 op = row.operator(
                     "bim.add_default_type", icon="ADD", text=f"Add {AuthoringData.data['ifc_element_type']}"
                 )
                 op.ifc_element_type = AuthoringData.data["ifc_element_type"]
+                row.operator("bim.launch_type_manager", icon=tool.Blender.TYPE_MANAGER_ICON, text="")
             else:
                 row.label(text="No Element Types Found", icon="ERROR")
-                row.operator("bim.launch_type_manager", icon="LIGHTPROBE_GRID", text="Launch Type Manager")
+                row.operator("bim.launch_type_manager", icon=tool.Blender.TYPE_MANAGER_ICON, text="Launch Type Manager")
 
     @classmethod
     def draw_basic_bim_tool_interface(cls):

src/blenderbim/blenderbim/bim/module/patch/prop.py

@@ -18,6 +18,7 @@
 
 import bpy
 import importlib
+import importlib.util
 from pathlib import Path
 import ifcpatch
 from blenderbim.bim.prop import StrProperty, Attribute

src/blenderbim/blenderbim/bim/module/project/__init__.py

@@ -21,9 +21,12 @@ from . import ui, prop, operator, workspace, gizmo, decorator
 
 classes = (
     operator.AppendEntireLibrary,
+    operator.AppendInspectedLinkedElement,
     operator.AppendLibraryElement,
     operator.AppendLibraryElementByQuery,
     operator.AssignLibraryDeclaration,
+    operator.BIM_OT_load_clipping_planes,
+    operator.BIM_OT_save_clipping_planes,
     operator.ChangeLibraryElement,
     operator.CreateClippingPlane,
     operator.CreateProject,

src/blenderbim/blenderbim/bim/module/project/operator.py

@@ -28,6 +28,7 @@ import ifcopenshell.api
 import ifcopenshell.util.selector
 import ifcopenshell.util.geolocation
 import ifcopenshell.util.representation
+import ifcopenshell.util.element
 import blenderbim.bim.handler
 import blenderbim.bim.schema
 import blenderbim.tool as tool
@@ -38,6 +39,8 @@ from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.ui import IFCFileSelector
 from blenderbim.bim import import_ifc
 from blenderbim.bim import export_ifc
+from collections import defaultdict
+import json
 from math import radians
 from pathlib import Path
 from mathutils import Vector, Matrix
@@ -112,6 +115,10 @@ class CreateProject(bpy.types.Operator):
         if tool.Blender.is_default_scene():
             for obj in bpy.data.objects:
                 bpy.data.objects.remove(obj)
+            for mesh in bpy.data.meshes:
+                bpy.data.meshes.remove(mesh)
+            for mat in bpy.data.materials:
+                bpy.data.materials.remove(mat)
         core.create_project(tool.Ifc, tool.Project, schema=props.export_schema, template=template)
         tool.Blender.register_toolbar()
 
@@ -185,7 +192,9 @@ class RefreshLibrary(bpy.types.Operator):
         self.props.active_library_element = ""
 
         types = IfcStore.library_file.wrapped_data.types_with_super()
-        for importable_type in sorted(["IfcTypeProduct", "IfcMaterial", "IfcCostSchedule", "IfcProfileDef"]):
+
+        element_classes = ["IfcTypeProduct", "IfcMaterial", "IfcCostSchedule", "IfcProfileDef"]
+        for importable_type in sorted(element_classes):
             if importable_type in types:
                 new = self.props.library_elements.add()
                 new.name = importable_type
@@ -204,11 +213,15 @@ class ChangeLibraryElement(bpy.types.Operator):
         self.library_file = IfcStore.library_file
         ifc_classes = set()
         self.props.active_library_element = self.element_name
+
         crumb = self.props.library_breadcrumb.add()
         crumb.name = self.element_name
+
         elements = self.library_file.by_type(self.element_name)
         [ifc_classes.add(e.is_a()) for e in elements]
+
         self.props.library_elements.clear()
+
         if len(ifc_classes) == 1 and list(ifc_classes)[0] == self.element_name:
             for name, ifc_definition_id in sorted([(self.get_name(e), e.id()) for e in elements]):
                 self.add_library_asset(name, ifc_definition_id)
@@ -429,7 +442,13 @@ class AppendLibraryElement(bpy.types.Operator):
         if element.is_a("IfcTypeProduct"):
             self.import_type_from_ifc(element, context)
         elif element.is_a("IfcProduct"):
+            # NOTE: not used as UI doesn't allow appending non-types
             self.import_product_from_ifc(element, context)
+            element_type = ifcopenshell.util.element.get_type(element)
+            obj = tool.Ifc.get_object(element_type)
+            if obj is None:
+                self.import_type_from_ifc(element_type, context)
+
         elif element.is_a("IfcMaterial"):
             self.import_material_from_ifc(element, context)
         try:
@@ -440,7 +459,7 @@ class AppendLibraryElement(bpy.types.Operator):
         blenderbim.bim.handler.refresh_ui_data()
         return {"FINISHED"}
 
-    def import_material_from_ifc(self, element, context):
+    def import_material_from_ifc(self, element: ifcopenshell.entity_instance, context: bpy.types.Context) -> None:
         self.file = IfcStore.get_file()
         logger = logging.getLogger("ImportIFC")
         ifc_import_settings = import_ifc.IfcImportSettings.factory(context, IfcStore.path, logger)
@@ -449,7 +468,7 @@ class AppendLibraryElement(bpy.types.Operator):
         blender_material = ifc_importer.create_material(element)
         self.import_material_styles(blender_material, element, ifc_importer)
 
-    def import_product_from_ifc(self, element, context):
+    def import_product_from_ifc(self, element: ifcopenshell.entity_instance, context: bpy.types.Context) -> None:
         self.file = IfcStore.get_file()
         logger = logging.getLogger("ImportIFC")
         ifc_import_settings = import_ifc.IfcImportSettings.factory(context, IfcStore.path, logger)
@@ -462,7 +481,7 @@ class AppendLibraryElement(bpy.types.Operator):
         ifc_importer.create_generic_elements({element})
         ifc_importer.place_objects_in_collections()
 
-    def import_type_from_ifc(self, element, context):
+    def import_type_from_ifc(self, element: ifcopenshell.entity_instance, context: bpy.types.Context) -> None:
         self.file = IfcStore.get_file()
         logger = logging.getLogger("ImportIFC")
         ifc_import_settings = import_ifc.IfcImportSettings.factory(context, IfcStore.path, logger)
@@ -487,14 +506,14 @@ class AppendLibraryElement(bpy.types.Operator):
         ifc_importer.create_element_type(element)
         ifc_importer.place_objects_in_collections()
 
-    def import_materials(self, element, ifc_importer):
+    def import_materials(self, element: ifcopenshell.entity_instance, ifc_importer: import_ifc.IfcImporter) -> None:
         for material in ifcopenshell.util.element.get_materials(element):
             if IfcStore.get_element(material.id()):
                 continue
             blender_material = ifc_importer.create_material(material)
             self.import_material_styles(blender_material, material, ifc_importer)
 
-    def import_styles(self, element, ifc_importer):
+    def import_styles(self, element: ifcopenshell.entity_instance, ifc_importer: import_ifc.IfcImporter) -> None:
         if element.is_a("IfcTypeProduct"):
             representations = element.RepresentationMaps or []
         elif element.is_a("IfcProduct"):
@@ -507,7 +526,12 @@ class AppendLibraryElement(bpy.types.Operator):
                     if element2.is_a("IfcSurfaceStyle") and not IfcStore.get_element(element2.id()):
                         ifc_importer.create_style(element2)
 
-    def import_material_styles(self, blender_material, material, ifc_importer):
+    def import_material_styles(
+        self,
+        blender_material: bpy.types.Material,
+        material: ifcopenshell.entity_instance,
+        ifc_importer: import_ifc.IfcImporter,
+    ) -> None:
         if not material.HasRepresentation:
             return
         for element in self.file.traverse(material.HasRepresentation[0]):
@@ -838,7 +862,10 @@ class LinkIfc(bpy.types.Operator):
                 continue
             new = context.scene.BIMProjectProperties.links.add()
             if self.use_relative_path:
-                filepath = os.path.relpath(filepath, bpy.path.abspath("//")).replace("\\", "/")
+                try:
+                    filepath = os.path.relpath(filepath, bpy.path.abspath("//")).replace("\\", "/")
+                except:
+                    pass  # Perhaps on another drive or something
             new.name = filepath
             bpy.ops.bim.load_link(filepath=filepath, false_origin=self.false_origin)
         print(f"Finished linking {len(files)} IFCs", time.time() - start)
@@ -876,15 +903,30 @@ class UnloadLink(bpy.types.Operator):
         self.filepath = self.filepath.replace("\\", "/")
         filepath = self.filepath
         if not os.path.isabs(filepath):
-            filepath = os.path.abspath(os.path.join(bpy.path.abspath("//"), filepath)).replace("\\", "/")
-        for collection in context.scene.collection.children:
-            if collection.library and collection.library.filepath.replace("\\", "/") == filepath:
-                context.scene.collection.children.unlink(collection)
-        for scene in bpy.data.scenes:
-            if scene.library and scene.library.filepath.replace("\\", "/") == filepath:
+            filepath = os.path.abspath(os.path.join(bpy.path.abspath("//"), filepath))
+        filepath = Path(filepath)
+        if filepath.suffix.lower() == ".ifc":
+            filepath = filepath.with_suffix(".ifc.cache.blend")
+
+        for collection in context.scene.collection.children[:]:
+            if collection.library and Path(collection.library.filepath) == filepath:
+                bpy.data.collections.remove(collection)
+
+        for scene in bpy.data.scenes[:]:
+            if scene.library and Path(scene.library.filepath) == filepath:
                 bpy.data.scenes.remove(scene)
-        link = context.scene.BIMProjectProperties.links.get(self.filepath)
-        link.is_loaded = False
+
+        links = context.scene.BIMProjectProperties.links
+        links.get(self.filepath).is_loaded = False
+
+        if not any([l.is_loaded for l in links]):
+            ProjectDecorator.uninstall()
+        # we make sure we don't draw queried object from the file that was just unlinked
+        elif queried_obj := context.scene.BIMProjectProperties.queried_obj:
+            queried_filepath = Path(queried_obj["ifc_filepath"])
+            if queried_filepath == filepath:
+                ProjectDecorator.uninstall()
+
         return {"FINISHED"}
 
 
@@ -975,24 +1017,24 @@ class ToggleLinkSelectability(bpy.types.Operator):
     bl_label = "Toggle Link Selectability"
     bl_options = {"REGISTER", "UNDO"}
     bl_description = "Toggle selectability"
-    link: bpy.props.StringProperty()
+    link: bpy.props.StringProperty(name="Linked IFC Filepath")
 
     def execute(self, context):
         props = context.scene.BIMProjectProperties
         link = props.links.get(self.link)
-        self.filepath = self.link
-        if not os.path.isabs(self.filepath):
-            self.filepath = os.path.abspath(os.path.join(bpy.path.abspath("//"), self.filepath)).replace("\\", "/")
+        if not os.path.isabs(self.link):
+            self.link = os.path.abspath(os.path.join(bpy.path.abspath("//"), self.link))
+        self.library_filepath = Path(self.link).with_suffix(".ifc.cache.blend")
         for collection in self.get_linked_collections():
             collection.hide_select = not collection.hide_select
             link.is_selectable = not collection.hide_select
         return {"FINISHED"}
 
-    def get_linked_collections(self):
+    def get_linked_collections(self) -> list[bpy.types.Collection]:
         return [
             c
             for c in bpy.data.collections
-            if "IfcProject" in c.name and c.library and c.library.filepath.replace("\\", "/") == self.filepath
+            if "IfcProject" in c.name and c.library and Path(c.library.filepath) == self.library_filepath
         ]
 
 
@@ -1001,15 +1043,15 @@ class ToggleLinkVisibility(bpy.types.Operator):
     bl_label = "Toggle Link Visibility"
     bl_options = {"REGISTER", "UNDO"}
     bl_description = "Toggle visibility between SOLID and WIREFRAME"
-    link: bpy.props.StringProperty()
-    mode: bpy.props.StringProperty()
+    link: bpy.props.StringProperty(name="Linked IFC Filepath")
+    mode: bpy.props.EnumProperty(name="Visibility Mode", items=((i, i, "") for i in ("WIREFRAME", "VISIBLE")))
 
     def execute(self, context):
         props = context.scene.BIMProjectProperties
         link = props.links.get(self.link)
-        self.filepath = self.link
-        if not os.path.isabs(self.filepath):
-            self.filepath = os.path.abspath(os.path.join(bpy.path.abspath("//"), self.filepath)).replace("\\", "/")
+        if not os.path.isabs(self.link):
+            self.link = os.path.abspath(os.path.join(bpy.path.abspath("//"), self.link))
+        self.library_filepath = Path(self.link).with_suffix(".ifc.cache.blend")
         if self.mode == "WIREFRAME":
             self.toggle_wireframe(link)
         elif self.mode == "VISIBLE":
@@ -1030,25 +1072,17 @@ class ToggleLinkVisibility(bpy.types.Operator):
 
     def toggle_visibility(self, link):
         linked_collections = self.get_linked_collections()
-        queue = [bpy.context.view_layer.layer_collection]
-        layer_collection = None
 
-        while queue:
-            layer = queue.pop()
-            if layer.collection in linked_collections:
-                layer_collection = layer
-                break
-            queue.extend(list(layer.children))
-
-        if layer_collection:
+        layer_collections = tool.Blender.get_layer_collections_mapping(linked_collections)
+        for layer_collection in layer_collections.values():
             layer_collection.exclude = not layer_collection.exclude
             link.is_hidden = layer_collection.exclude
 
-    def get_linked_collections(self):
+    def get_linked_collections(self) -> list[bpy.types.Collection]:
         return [
             c
             for c in bpy.data.collections
-            if "IfcProject" in c.name and c.library and c.library.filepath.replace("\\", "/") == self.filepath
+            if "IfcProject" in c.name and c.library and Path(c.library.filepath) == self.library_filepath
         ]
 
 
@@ -1262,6 +1296,8 @@ class LoadLinkedProject(bpy.types.Operator):
                     if len(shape.geometry.faces) > 1000 and self.is_local(shape):  # 333 tris
                         self.process_occurrence(shape)
                         if not iterator.next():
+                            if not chunked_verts:
+                                break
                             mats = np.concatenate(chunked_materials)
                             midx = np.concatenate(chunked_material_ids)
                             mats, mapping = np.unique(mats, axis=0, return_inverse=True)
@@ -1297,6 +1333,9 @@ class LoadLinkedProject(bpy.types.Operator):
 
                     ms = np.vstack([default_mat, np.frombuffer(shape.geometry.colors_buffer).reshape((-1, 4))])
                     mi = np.frombuffer(shape.geometry.material_ids_buffer, dtype=np.int32)
+                    for geom_material_idx, geom_material in enumerate(shape.geometry.materials):
+                        if not geom_material.has_diffuse:
+                            ms[geom_material_idx + 1] = (0.8, 0.8, 0.8, 1)
                     chunked_materials.append(ms)
                     chunked_material_ids.append(mi + material_offset + 1)
                     material_offset += len(ms)
@@ -1417,7 +1456,10 @@ class LoadLinkedProject(bpy.types.Operator):
                 alpha = 1.0
                 if material.has_transparency and material.transparency > 0:
                     alpha = 1.0 - material.transparency
-                diffuse = material.diffuse + (alpha,)
+                if material.has_diffuse:
+                    diffuse = material.diffuse + (alpha,)
+                else:
+                    diffuse = (0.8, 0.8, 0.8, 1)  # Blender's default material
                 material_name = f"{diffuse[0]}-{diffuse[1]}-{diffuse[2]}-{diffuse[3]}"
                 blender_mat = self.blender_mats.get(material_name, None)
                 if not blender_mat:
@@ -1495,6 +1537,7 @@ class LoadLinkedProject(bpy.types.Operator):
         obj["guids"] = list(guids)
         obj["guid_ids"] = list(guid_ids)
         obj["db"] = self.db_filepath
+        obj["ifc_filepath"] = self.filepath
 
         self.collection.objects.link(obj)
 
@@ -1626,6 +1669,42 @@ class QueryLinkedElement(bpy.types.Operator):
         return self.execute(context)
 
 
+class AppendInspectedLinkedElement(AppendLibraryElement):
+    bl_idname = "bim.append_inspected_linked_element"
+    bl_label = "Append Inspected Linked Element"
+    bl_description = "Append inspected linked element"
+    bl_options = {"REGISTER"}
+
+    def _execute(self, context):
+        from blenderbim.bim.module.project.data import LinksData
+
+        if not LinksData.linked_data:
+            self.report({"INFO"}, "No linked element found.")
+            return {"CANCELLED"}
+
+        guid = LinksData.linked_data["attributes"].get("GlobalId")
+        if guid is None:
+            self.report({"INFO"}, "Cannot find Global Id for element.")
+            return {"CANCELLED"}
+
+        queried_obj = context.scene.BIMProjectProperties.queried_obj
+        ifc_file = ifcopenshell.open(queried_obj["ifc_filepath"])
+        element_to_append = ifc_file.by_guid(guid)
+        element = ifcopenshell.api.run(
+            "project.append_asset",
+            tool.Ifc.get(),
+            library=ifc_file,
+            element=element_to_append,
+        )
+        self.import_product_from_ifc(element, context)
+        element_type = ifcopenshell.util.element.get_type(element)
+        obj = tool.Ifc.get_object(element_type)
+        if obj is None:
+            self.import_type_from_ifc(element_type, context)
+
+        return {"FINISHED"}
+
+
 class EnableCulling(bpy.types.Operator):
     bl_idname = "bim.enable_culling"
     bl_label = "Enable Culling"
@@ -1843,32 +1922,32 @@ class CreateClippingPlane(bpy.types.Operator):
     bl_label = "Create Clipping Plane"
     bl_options = {"REGISTER", "UNDO"}
 
-    @classmethod
-    def poll(cls, context):
-        return context.area.type == "VIEW_3D"
-
     def execute(self, context):
         from bpy_extras.view3d_utils import region_2d_to_vector_3d, region_2d_to_origin_3d
 
         # Clean up deleted planes
 
-        if len(bpy.context.scene.BIMProjectProperties.clipping_planes) > 5:
+        if len(context.scene.BIMProjectProperties.clipping_planes) > 5:
             self.report({"INFO"}, "Maximum of six clipping planes allowed.")
             return {"FINISHED"}
 
-        for area in bpy.context.screen.areas:
+        for area in context.screen.areas:
             if area.type == "VIEW_3D":
                 area.tag_redraw()
 
         region = context.region
         rv3d = context.region_data
-        coord = (self.mouse_x, self.mouse_y)
-        origin = region_2d_to_origin_3d(region, rv3d, coord)
-        direction = region_2d_to_vector_3d(region, rv3d, coord)
-        hit, location, normal, face_index, obj, matrix = self.ray_cast(context, origin, direction)
-        if not hit:
-            self.report({"INFO"}, "No object found.")
-            return {"FINISHED"}
+        if rv3d:  # Called from a 3D viewport
+            coord = (self.mouse_x, self.mouse_y)
+            origin = region_2d_to_origin_3d(region, rv3d, coord)
+            direction = region_2d_to_vector_3d(region, rv3d, coord)
+            hit, location, normal, face_index, obj, matrix = self.ray_cast(context, origin, direction)
+            if not hit:
+                self.report({"INFO"}, "No object found.")
+                return {"FINISHED"}
+        else:  # Not Called from a 3D viewport
+            location = (0, 0, 1)
+            normal = (0, 0, 1)
 
         vertices = [(-0.5, -0.5, 0), (0.5, -0.5, 0), (0.5, 0.5, 0), (-0.5, 0.5, 0)]
 
@@ -1879,20 +1958,20 @@ class CreateClippingPlane(bpy.types.Operator):
         mesh.update()
 
         plane_obj = bpy.data.objects.new("ClippingPlane", mesh)
-        bpy.context.collection.objects.link(plane_obj)
+        context.collection.objects.link(plane_obj)
         z_axis = Vector((0, 0, 1))
         rotation_matrix = z_axis.rotation_difference(normal).to_matrix().to_4x4()
         plane_obj.matrix_world = rotation_matrix
         plane_obj.matrix_world.translation = location
 
-        bpy.context.scene.cursor.location = location
+        context.scene.cursor.location = location
 
-        new = bpy.context.scene.BIMProjectProperties.clipping_planes.add()
+        new = context.scene.BIMProjectProperties.clipping_planes.add()
         new.obj = plane_obj
 
         tool.Blender.set_active_object(plane_obj)
 
-        ClippingPlaneDecorator.install(bpy.context)
+        ClippingPlaneDecorator.install(context)
         bpy.ops.bim.refresh_clipping_planes("INVOKE_DEFAULT")
         return {"FINISHED"}
 
@@ -1914,11 +1993,69 @@ class FlipClippingPlane(bpy.types.Operator):
 
     @classmethod
     def poll(cls, context):
-        return context.area.type == "VIEW_3D"
+        return context.active_object
 
     def execute(self, context):
-        obj = bpy.context.active_object
-        if obj in [cp.obj for cp in bpy.context.scene.BIMProjectProperties.clipping_planes]:
+        obj = context.active_object
+        if obj in context.scene.BIMProjectProperties.clipping_planes_objs:
             obj.rotation_euler[0] += radians(180)
-            bpy.context.view_layer.update()
+            context.view_layer.update()
+        return {"FINISHED"}
+
+
+CLIPPING_PLANES_FILE_NAME = "ClippingPlanes.json"  # TODO un-hardcode :=
+
+
+class BIM_OT_save_clipping_planes(bpy.types.Operator):
+    bl_idname = "bim.save_clipping_planes"
+    bl_label = "Save Clipping Planes"
+    bl_description = "Save Clipping Planes to Disk"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if IfcStore.path:
+            return context.scene.BIMProjectProperties.clipping_planes
+        cls.poll_message_set("Please Save The IFC File")
+
+    def execute(self, context):
+        clipping_planes_to_serialize = defaultdict(dict)
+        clipping_planes = context.scene.BIMProjectProperties.clipping_planes
+        for clipping_plane in clipping_planes:
+            obj = clipping_plane.obj
+            name = obj.name
+            clipping_planes_to_serialize[name]["location"] = obj.location[0:3]
+            clipping_planes_to_serialize[name]["rotation"] = obj.rotation_euler[0:3]
+        with open(Path(IfcStore.path).with_name(CLIPPING_PLANES_FILE_NAME), "w") as file:
+            json.dump(clipping_planes_to_serialize, file, indent=4)
+        return {"FINISHED"}
+
+
+class BIM_OT_load_clipping_planes(bpy.types.Operator):
+    bl_idname = "bim.load_clipping_planes"
+    bl_label = "Load Clipping Planes"
+    bl_description = "Load Clipping Planes from Disk"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if filepath := IfcStore.path:
+            if Path(filepath).with_name(CLIPPING_PLANES_FILE_NAME).exists():
+                return True
+            else:
+                cls.poll_message_set(f"No Clipping Planes File in Folder {filepath}")
+        else:
+            cls.poll_message_set("Please Save The IFC File")
+
+    def execute(self, context):
+        bpy.data.batch_remove(context.scene.BIMProjectProperties.clipping_planes_objs)
+        context.scene.BIMProjectProperties.clipping_planes.clear()
+        with open(Path(IfcStore.path).with_name(CLIPPING_PLANES_FILE_NAME), "r") as file:
+            clipping_planes_dict = json.load(file)
+        for name, values in clipping_planes_dict.items():
+            bpy.ops.bim.create_clipping_plane()
+            obj = context.scene.BIMProjectProperties.clipping_planes_objs[-1]
+            obj.name = name
+            obj.location = values["location"]
+            obj.rotation_euler = values["rotation"]
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/project/prop.py

@@ -187,6 +187,11 @@ class BIMProjectProperties(PropertyGroup):
     use_relative_project_path: BoolProperty(name="Use Relative Project Path", default=False)
     queried_obj: bpy.props.PointerProperty(type=bpy.types.Object)
     clipping_planes: bpy.props.CollectionProperty(type=ObjProperty)
+    clipping_planes_active: bpy.props.IntProperty(min=0, default=0, max=5)
+
+    @property
+    def clipping_planes_objs(self):
+        return list({cp.obj for cp in self.clipping_planes if cp.obj})
 
     def get_library_element_index(self, lib_element):
         return next((i for i in range(len(self.library_elements)) if self.library_elements[i] == lib_element))

src/blenderbim/blenderbim/bim/module/project/ui.py

@@ -267,10 +267,9 @@ class BIM_PT_project_library(Panel):
             )
             row.operator("bim.append_library_element_by_query", text="", icon="APPEND_BLEND")
             row.operator("bim.save_library_file", text="", icon="EXPORT")
+            self.draw_library_ul()
         else:
             row.label(text="No Library Loaded", icon="ASSET_MANAGER")
-        if IfcStore.library_file:
-            self.draw_library_ul()
 
     def draw_library_ul(self):
         if not self.props.library_elements:
@@ -319,11 +318,16 @@ class BIM_PT_links(Panel):
             row = self.layout.row(align=True)
             row.label(text="Object Culling Enabled", icon="MOD_TRIANGULATE")
 
-        if not LinksData.linked_data:
-            row = self.layout.row(align=True)
-            row.label(text="No Object Selected", icon="QUESTION")
+        if not LinksData.linked_data or not self.props.links:
+            if self.props.links:
+                row = self.layout.row(align=True)
+                row.label(text="No Object Selected", icon="QUESTION")
             return
 
+        row = self.layout.row(align=True)
+        row.label(text="")
+        row.operator("bim.append_inspected_linked_element", icon="APPEND_BLEND", text="")
+
         for name, value in LinksData.linked_data["attributes"].items():
             row = self.layout.row(align=True)
             row.label(text=name)

src/blenderbim/blenderbim/bim/module/pset/data.py

@@ -69,6 +69,7 @@ class ObjectPsetsData(Data):
     @classmethod
     def load(cls):
         cls.data = {
+            "is_occurrence": cls.is_occurrence(),
             "psets": cls.psetqtos(tool.Ifc.get_entity(bpy.context.active_object), psets_only=True),
             "inherited_psets": cls.inherited_psets(),
             "pset_name": cls.pset_name(),
@@ -76,14 +77,18 @@ class ObjectPsetsData(Data):
         }
         cls.is_loaded = True
 
+    @classmethod
+    def is_occurrence(cls):
+        return not tool.Ifc.get_entity(bpy.context.active_object).is_a("IfcTypeObject")
+
     @classmethod
     def inherited_psets(cls):
         element = tool.Ifc.get_entity(bpy.context.active_object)
         if element.is_a("IfcTypeObject"):
-            return
+            return []
         element_type = ifcopenshell.util.element.get_type(element)
         if element_type:
-            return cls.psetqtos(element_type)
+            return cls.psetqtos(element_type, psets_only=True)
 
     @classmethod
     def pset_name(cls):
@@ -125,9 +130,26 @@ class ObjectQtosData(Data):
 
     @classmethod
     def load(cls):
-        cls.data = {"qtos": cls.psetqtos(tool.Ifc.get_entity(bpy.context.active_object), qtos_only=True)}
+        cls.data = {
+            "is_occurrence": cls.is_occurrence(),
+            "qtos": cls.psetqtos(tool.Ifc.get_entity(bpy.context.active_object), qtos_only=True),
+            "inherited_qsets": cls.inherited_qsets(),
+        }
         cls.is_loaded = True
 
+    @classmethod
+    def is_occurrence(cls):
+        return not tool.Ifc.get_entity(bpy.context.active_object).is_a("IfcTypeObject")
+
+    @classmethod
+    def inherited_qsets(cls):
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if element.is_a("IfcTypeObject"):
+            return []
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type:
+            return cls.psetqtos(element_type, qtos_only=True)
+
 
 class MaterialPsetsData(Data):
     data = {}

src/blenderbim/blenderbim/bim/module/pset/operator.py

@@ -85,7 +85,6 @@ class EnablePsetEditing(bpy.types.Operator):
     def execute(self, context):
         self.props = get_pset_props(context, self.obj, self.obj_type)
         self.props.properties.clear()
-        ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, self.obj, self.obj_type)
 
         if self.pset_id:
             pset = tool.Ifc.get().by_id(self.pset_id)
@@ -250,7 +249,7 @@ class DisablePsetEditing(bpy.types.Operator, Operator):
         props = get_pset_props(context, self.obj, self.obj_type)
         if props.active_pset_id:
             pset = tool.Ifc.get().by_id(props.active_pset_id)
-            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, self.obj, self.obj_type)
+            ifc_definition_id = tool.Blender.get_obj_ifc_definition_id(self.obj, self.obj_type, context)
             if tool.Pset.is_pset_empty(pset):
                 ifcopenshell.api.run(
                     "pset.remove_pset", tool.Ifc.get(), product=tool.Ifc.get().by_id(ifc_definition_id), pset=pset
@@ -272,7 +271,7 @@ class EditPset(bpy.types.Operator, Operator):
     def _execute(self, context):
         self.file = IfcStore.get_file()
         props = get_pset_props(context, self.obj, self.obj_type)
-        ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, self.obj, self.obj_type)
+        ifc_definition_id = tool.Blender.get_obj_ifc_definition_id(self.obj, self.obj_type, context)
         element = tool.Ifc.get().by_id(ifc_definition_id)
         properties = {}
 
@@ -343,7 +342,7 @@ class RemovePset(bpy.types.Operator, Operator):
         pset_name = tool.Ifc.get().by_id(self.pset_id).Name
         for obj in objects:
             props = get_pset_props(context, obj, self.obj_type)
-            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, obj, self.obj_type)
+            ifc_definition_id = tool.Blender.get_obj_ifc_definition_id(obj, self.obj_type, context)
             element = tool.Ifc.get().by_id(ifc_definition_id)
             pset = ifcopenshell.util.element.get_psets(element, should_inherit=False).get(pset_name, None)
             if pset:
@@ -374,7 +373,7 @@ class AddQto(bpy.types.Operator, Operator):
     def _execute(self, context):
         self.file = IfcStore.get_file()
         props = get_pset_props(context, self.obj, self.obj_type)
-        ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, self.obj, self.obj_type)
+        ifc_definition_id = tool.Blender.get_obj_ifc_definition_id(self.obj, self.obj_type, context)
         element = tool.Ifc.get().by_id(ifc_definition_id)
         bpy.ops.bim.enable_pset_editing(
             pset_id=0, pset_name=props.qto_name, pset_type="QTO", obj=self.obj, obj_type=self.obj_type

src/blenderbim/blenderbim/bim/module/pset/qto_calculator.py

@@ -25,8 +25,16 @@ from shapely.geometry import Polygon
 from shapely.ops import unary_union
 import blenderbim.tool as tool
 import ifcopenshell
+import ifcopenshell.geom
+import ifcopenshell.util.element
 from blenderbim.bim.module.pset.calc_quantity_function_mapper import mapper
 import blenderbim.bim
+from typing import Literal, Union, Optional
+
+
+AxisType = Literal["x", "y", "z"]
+VectorTuple = tuple[float, float, float]
+QuanityTypes = Literal["Q_LENGTH", "Q_AREA", "Q_VOLUME"]
 
 
 class QtoCalculator:
@@ -45,7 +53,7 @@ class QtoCalculator:
                 else:
                     self.mapping_dict[key][item] = None
 
-    def calculate_quantity(self, qto_name, quantity_name, obj):
+    def calculate_quantity(self, qto_name: str, quantity_name: str, obj: bpy.types.Object) -> float:
         """calculates the value of the quantity in the project units"""
         string = "self.mapping_dict[qto_name][quantity_name](obj"
         if isinstance(mapper[qto_name][quantity_name], dict):
@@ -54,11 +62,13 @@ class QtoCalculator:
             args = ""
         string += args
         string += ")"
-        value = eval(string)
+        value: float = eval(string)
 
         return tool.Qto.convert_to_project_units(value, qto_name, quantity_name) or value
 
-    def guess_quantity(self, prop_name, alternative_prop_names, obj):
+    def guess_quantity(
+        self, prop_name: str, alternative_prop_names: list[str], obj: bpy.types.Object
+    ) -> Union[float, None]:
         """guess the value of the quantity by name, returns the value in the project units"""
         prop_name = prop_name.lower()
         alternative_prop_names = [p.lower() for p in alternative_prop_names]
@@ -89,7 +99,7 @@ class QtoCalculator:
         if value is None:
             return
 
-        unit_type_keywords = {
+        unit_type_keywords: dict[str, QuanityTypes] = {
             "length": "Q_LENGTH",
             "width": "Q_LENGTH",
             "height": "Q_LENGTH",
@@ -102,10 +112,10 @@ class QtoCalculator:
         unit_type = next(unit_type_keywords[k] for k in unit_type_keywords if k in prop_name)
         return tool.Qto.convert_to_project_units(value, quantity_type=unit_type) or value
 
-    def get_units(self, o, vg_index):
+    def get_units(self, o: bpy.types.Object, vg_index: int) -> int:
         return len([v for v in o.data.vertices if vg_index in [g.group for g in v.groups]])
 
-    def get_linear_length(self, o):
+    def get_linear_length(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the length of the longest edge of the object bounding box
 
         :param blender-object o: Blender Object
@@ -116,7 +126,7 @@ class QtoCalculator:
         z = (Vector(o.bound_box[1]) - Vector(o.bound_box[0])).length
         return max(x, y, z)
 
-    def get_length(self, o, vg_index=None, main_axis: str = ""):
+    def get_length(self, o: bpy.types.Object, vg_index: Optional[int] = None, main_axis: str = "") -> float:
         if vg_index is None:
             x = (Vector(o.bound_box[4]) - Vector(o.bound_box[0])).length
             y = (Vector(o.bound_box[3]) - Vector(o.bound_box[0])).length
@@ -141,23 +151,23 @@ class QtoCalculator:
             length += self.get_edge_distance(o, e)
         return length
 
-    def get_stair_length(self, obj):
+    def get_stair_length(self, obj: bpy.types.Object) -> float:
         length = self.get_length(obj)
         height = self.get_height(obj)
         stair_length = math.sqrt(pow(length, 2) + pow(height, 2))
         return stair_length
 
-    def get_net_stair_area(self, obj):
+    def get_net_stair_area(self, obj: bpy.types.Object) -> float:
         OBB_obj = self.get_OBB_object(obj)
         OBB_net_footprint_area = self.get_net_footprint_area(OBB_obj)
         return OBB_net_footprint_area
 
-    def get_gross_stair_area(self, obj):
+    def get_gross_stair_area(self, obj: bpy.types.Object) -> float:
         OBB_obj = self.get_OBB_object(obj)
         OBB_gross_footprint_area = self.get_gross_footprint_area(OBB_obj)
         return OBB_gross_footprint_area
 
-    def get_parametric_axis(self, obj):
+    def get_parametric_axis(self, obj: bpy.types.Object) -> Literal["AXIS2", "AXIS3", None]:
         relating_type = ifcopenshell.util.element.get_type(tool.Ifc.get_entity(obj))
         if relating_type:
             parametric = ifcopenshell.util.element.get_psets(relating_type).get("EPset_Parametric")
@@ -172,7 +182,7 @@ class QtoCalculator:
                     return None
         return None
 
-    def get_covering_gross_area(self, obj):
+    def get_covering_gross_area(self, obj: bpy.types.Object) -> float:
         get_parametric_axis = self.get_parametric_axis(obj)
         if not get_parametric_axis:
             return self.get_gross_footprint_area(obj)
@@ -181,7 +191,7 @@ class QtoCalculator:
         elif get_parametric_axis == "AXIS3":
             return self.get_gross_footprint_area(obj)
 
-    def get_covering_net_area(self, obj):
+    def get_covering_net_area(self, obj: bpy.types.Object) -> float:
         get_parametric_axis = self.get_parametric_axis(obj)
         if not get_parametric_axis:
             return self.get_net_footprint_area(obj)
@@ -190,7 +200,7 @@ class QtoCalculator:
         elif get_parametric_axis == "AXIS3":
             return self.get_net_footprint_area(obj)
 
-    def get_covering_width(self, obj):
+    def get_covering_width(self, obj: bpy.types.Object) -> float:
         get_parametric_axis = self.get_parametric_axis(obj)
         if not get_parametric_axis:
             return self.get_height(obj)
@@ -199,7 +209,7 @@ class QtoCalculator:
         elif get_parametric_axis == "AXIS3":
             return self.get_height(obj)
 
-    def get_width(self, o):
+    def get_width(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the width of the object bounding box
 
         :param blender-object o: blender object
@@ -209,7 +219,7 @@ class QtoCalculator:
         y = (Vector(o.bound_box[3]) - Vector(o.bound_box[0])).length
         return min(x, y)
 
-    def get_height(self, o):
+    def get_height(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the height of the object bounding box
 
         :param blender-object o: blender object
@@ -217,64 +227,77 @@ class QtoCalculator:
         """
         return (Vector(o.bound_box[1]) - Vector(o.bound_box[0])).length
 
-    def get_opening_height(self, obj):
+    def get_opening_height(self, obj: bpy.types.Object) -> float:
         if self.is_opening_horizontal(obj):
             return self.get_width(obj)
         else:
             return self.get_height(obj)
 
-    def get_opening_depth(self, obj):
+    def get_opening_depth(self, obj: bpy.types.Object) -> float:
         if self.is_opening_horizontal(obj):
             return self.get_height(obj)
         else:
             return self.get_width(obj)
 
-    def get_opening_mapping_area(self, obj):
+    def get_opening_mapping_area(self, obj: bpy.types.Object) -> float:
         if self.is_opening_horizontal(obj):
             return self.get_net_footprint_area(obj)
         else:
             return self.get_net_side_area(obj)
 
-    def get_finish_ceiling_height(self, obj):
-        space_height = self.get_height(obj)
+    def get_finish_ceiling_height(self, obj: bpy.types.Object) -> float:
         floor_height = self.get_finish_floor_height(obj)
         ceiling_height = self.get_ceiling_height(obj)
-        finish_ceiling_height = space_height - floor_height - ceiling_height
+        finish_ceiling_height = ceiling_height - floor_height
         return finish_ceiling_height
 
-    def get_finish_floor_height(self, obj):
+    def get_max_global_z(self, obj: bpy.types.Object) -> float:
+        z_values = [(obj.matrix_world @ Vector(co))[2] for co in obj.bound_box]
+        return max(z_values)
+
+    def get_min_global_z(self, obj: bpy.types.Object) -> float:
+        z_values = [(obj.matrix_world @ Vector(co))[2] for co in obj.bound_box]
+        return min(z_values)
+
+    def get_finish_floor_height(self, obj: bpy.types.Object) -> float:
+        space_min_z_value = self.get_min_global_z(obj)
+        space_max_z_value = self.get_max_global_z(obj)
+
         element = tool.Ifc.get_entity(obj)
         decompositions = ifcopenshell.util.element.get_decomposition(element)
-        finish_floor_height = 0
+        flooring_max_z_value = space_min_z_value
         for decomposition in decompositions:
             if (
-                decomposition.get_info()["PredefinedType"] == "FLOORING"
-                and decomposition.get_info()["type"] == "IfcCovering"
+                decomposition.is_a() == "IfcCovering"
+                and ifcopenshell.util.element.get_predefined_type(decomposition) == "FLOORING"
             ):
-                floor_obj = tool.Ifc.get_object(decomposition)
-                new_finish_floor_height = self.get_height(floor_obj)
-                if new_finish_floor_height > finish_floor_height:
-                    finish_floor_height = new_finish_floor_height
+                flooring_obj = tool.Ifc.get_object(decomposition)
+                flooring_z_value = self.get_max_global_z(flooring_obj)
+                if flooring_z_value > space_min_z_value:
+                    flooring_max_z_value = flooring_z_value
 
-        return finish_floor_height
+        return flooring_max_z_value - space_min_z_value
+
+    def get_ceiling_height(self, obj: bpy.types.Object) -> float:
+        space_min_z_value = self.get_min_global_z(obj)
+        space_max_z_value = self.get_max_global_z(obj)
 
-    def get_ceiling_height(self, obj):
         element = tool.Ifc.get_entity(obj)
         decompositions = ifcopenshell.util.element.get_decomposition(element)
-        finish_ceiling_height = 0
+        ceiling_min_z_value = space_max_z_value
         for decomposition in decompositions:
             if (
-                decomposition.get_info()["PredefinedType"] == "CEILING"
-                and decomposition.get_info()["type"] == "IfcCovering"
+                decomposition.is_a() == "IfcCovering"
+                and ifcopenshell.util.element.get_predefined_type(decomposition) == "CEILING"
             ):
                 ceiling_obj = tool.Ifc.get_object(decomposition)
-                new_finish_ceiling_height = self.get_height(ceiling_obj)
-                if new_finish_ceiling_height > finish_ceiling_height:
-                    finish_ceiling_height = new_finish_ceiling_height
+                ceiling_z_value = self.get_min_global_z(ceiling_obj)
+                if ceiling_z_value < space_max_z_value:
+                    ceiling_min_z_value = ceiling_z_value
 
-        return finish_ceiling_height
+        return ceiling_min_z_value - space_min_z_value
 
-    def get_net_perimeter(self, o):
+    def get_net_perimeter(self, o: bpy.types.Object) -> float:
         parsed_edges = []
         shared_edges = []
         perimeter = 0
@@ -289,7 +312,7 @@ class QtoCalculator:
             perimeter -= self.get_edge_key_distance(o, edge_key)
         return perimeter
 
-    def get_gross_perimeter(self, o):
+    def get_gross_perimeter(self, o: bpy.types.Object) -> float:
         element = tool.Ifc.get_entity(o)
         mesh = self.get_gross_element_mesh(element)
         gross_obj = bpy.data.objects.new("GrossObj", mesh)
@@ -297,15 +320,15 @@ class QtoCalculator:
         self.delete_obj(gross_obj)
         return gross_perimeter
 
-    def get_space_net_perimeter(self, obj):
+    def get_space_net_perimeter(self, obj: bpy.types.Object) -> float:
         pass
 
-    def get_rectangular_perimeter(self, obj):
+    def get_rectangular_perimeter(self, obj: bpy.types.Object) -> float:
         length = self.get_length(obj, main_axis="x")
         height = self.get_height(obj)
         return (length + height) * 2
 
-    def get_lowest_polygons(self, o):
+    def get_lowest_polygons(self, o: bpy.types.Object) -> list[bpy.types.MeshPolygon]:
         lowest_polygons = []
         lowest_z = None
         for polygon in o.data.polygons:
@@ -321,7 +344,7 @@ class QtoCalculator:
                 lowest_z = z
         return lowest_polygons
 
-    def get_highest_polygons(self, o):
+    def get_highest_polygons(self, o: bpy.types.Object) -> list[bpy.types.MeshPolygon]:
         highest_polygons = []
         highest_z = None
         for polygon in o.data.polygons:
@@ -337,13 +360,13 @@ class QtoCalculator:
                 highest_z = z
         return highest_polygons
 
-    def get_edge_key_distance(self, obj, edge_key):
+    def get_edge_key_distance(self, obj: bpy.types.Object, edge_key: tuple[int, int]) -> float:
         return (obj.data.vertices[edge_key[1]].co - obj.data.vertices[edge_key[0]].co).length
 
-    def get_edge_distance(self, obj, edge):
+    def get_edge_distance(self, obj: bpy.types.Object, edge: bpy.types.MeshEdge) -> float:
         return (obj.data.vertices[edge.vertices[1]].co - obj.data.vertices[edge.vertices[0]].co).length
 
-    def get_net_floor_area(self, obj):
+    def get_net_floor_area(self, obj: bpy.types.Object) -> float:
         decompositions = self.get_obj_decompositions(obj)
         if not decompositions:
             return self.get_gross_footprint_area(obj)
@@ -359,7 +382,7 @@ class QtoCalculator:
 
         return total_net_floor_area
 
-    def get_gross_ceiling_area(self, obj):
+    def get_gross_ceiling_area(self, obj: bpy.types.Object) -> float:
         decompositions = self.get_obj_decompositions(obj)
         if not decompositions:
             return self.get_gross_top_area(obj)
@@ -367,15 +390,15 @@ class QtoCalculator:
         total_gross_ceiling_area = 0
 
         for decomposition in decompositions:
-            decomposition_type = decomposition.get_info()["type"]
-            decomposition_predefined_type = decomposition.get_info()["PredefinedType"]
-            if decomposition_type == "IfcCovering" and decomposition_predefined_type == "CEILING":
+            decomposition_class = decomposition.is_a()
+            decomposition_predefined_type = ifcopenshell.util.element.get_predefined_type(decomposition)
+            if decomposition_class == "IfcCovering" and decomposition_predefined_type == "CEILING":
                 decomposition_obj = tool.Ifc.get_object(decomposition)
                 total_gross_ceiling_area += self.get_gross_footprint_area(decomposition_obj)
 
         return total_gross_ceiling_area
 
-    def get_net_ceiling_area(self, obj):
+    def get_net_ceiling_area(self, obj: bpy.types.Object) -> float:
         decompositions = self.get_obj_decompositions(obj)
         if not decompositions:
             return self.get_net_top_area(obj)
@@ -383,19 +406,19 @@ class QtoCalculator:
         total_net_ceiling_area = 0
 
         for decomposition in decompositions:
-            decomposition_type = decomposition.get_info()["type"]
-            decomposition_predefined_type = decomposition.get_info()["PredefinedType"]
-            if decomposition_type == "IfcCovering" and decomposition_predefined_type == "CEILING":
+            decomposition_class = decomposition.is_a()
+            decomposition_predefined_type = ifcopenshell.util.element.get_predefined_type(decomposition)
+            if decomposition_class == "IfcCovering" and decomposition_predefined_type == "CEILING":
                 decomposition_obj = tool.Ifc.get_object(decomposition)
                 total_net_ceiling_area += self.get_net_footprint_area(decomposition_obj)
 
-            if decomposition_type == "IfcWall" or decomposition_type == "IfcColumn":
+            if decomposition_class == "IfcWall" or decomposition_class == "IfcColumn":
                 decomposition_obj = tool.Ifc.get_object(decomposition)
                 total_net_ceiling_area -= self.get_net_roofprint_area(decomposition_obj)
 
         return total_net_ceiling_area
 
-    def get_space_net_volume(self, obj):
+    def get_space_net_volume(self, obj: bpy.types.Object) -> float:
         decompositions = self.get_obj_decompositions(obj)
         if not decompositions:
             return self.get_gross_volume(obj)
@@ -410,7 +433,7 @@ class QtoCalculator:
 
         return total_space_net_volume
 
-    def get_net_footprint_area(self, o):
+    def get_net_footprint_area(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the area of the footprint of the object, excluding any holes
 
         :param blender-object o: blender object
@@ -421,7 +444,7 @@ class QtoCalculator:
             area += polygon.area
         return area
 
-    def get_gross_footprint_area(self, o):
+    def get_gross_footprint_area(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the area of the footprint of the object, without related opening and excluding any holes
 
         :param blender-object o: blender object
@@ -437,7 +460,7 @@ class QtoCalculator:
         self.delete_mesh(mesh)
         return gross_footprint_area
 
-    def get_net_roofprint_area(self, o):
+    def get_net_roofprint_area(self, o: bpy.types.Object) -> float:
         # Is roofprint the right word? Couldn't think of anything better - vulevukusej
         """_summary_: Returns the area of the net roofprint of the object, excluding any holes
 
@@ -449,7 +472,7 @@ class QtoCalculator:
             area += polygon.area
         return area
 
-    def get_side_area(self, o):
+    def get_side_area(self, o: bpy.types.Object) -> float:
         # There are a few dumb options for this, but this seems the dumbest
         # until I get more practical experience on what works best.
         x = (Vector(o.bound_box[4]) - Vector(o.bound_box[0])).length
@@ -457,8 +480,7 @@ class QtoCalculator:
         z = (Vector(o.bound_box[1]) - Vector(o.bound_box[0])).length
         return max(x * z, y * z)
 
-    def get_cross_section_area(self, obj):
-        element = tool.Ifc.get_entity(obj)
+    def get_cross_section_area(self, obj: bpy.types.Object) -> float:
         representation = tool.Ifc.get().by_id(obj.data.BIMMeshProperties.ifc_definition_id)
         item = representation.Items[0]
         while True:
@@ -474,7 +496,7 @@ class QtoCalculator:
                 return area
         # TODO handle other types of sections, and then fall back to mesh parsing
 
-    def get_gross_surface_area(self, o, vg_index=None):
+    def get_gross_surface_area(self, o: bpy.types.Object, vg_index: Optional[int] = None) -> float:
         if vg_index is None:
             if not self.has_openings(o):
                 return self.get_net_surface_area(o)
@@ -492,29 +514,29 @@ class QtoCalculator:
                 area += polygon.area
         return area
 
-    def get_net_surface_area(self, obj):
+    def get_net_surface_area(self, obj: bpy.types.Object) -> float:
         return self.get_mesh_area(obj.data)
 
-    def get_mesh_area(self, mesh):
+    def get_mesh_area(self, mesh: bpy.types.Mesh) -> float:
         area = 0
         for polygon in mesh.polygons:
             area += polygon.area
         return area
 
-    def is_polygon_in_vg(self, polygon, vertices_in_vg):
+    def is_polygon_in_vg(self, polygon: bpy.types.MeshPolygon, vertices_in_vg: list[bpy.types.MeshVertex]) -> bool:
         for v in polygon.vertices:
             if v not in vertices_in_vg:
                 return False
         return True
 
-    def get_net_volume(self, o):
+    def get_net_volume(self, o: bpy.types.Object) -> float:
         o_mesh = bmesh.new()
         o_mesh.from_mesh(o.data)
         volume = o_mesh.calc_volume()
         o_mesh.free()
         return volume
 
-    def get_gross_volume(self, o):
+    def get_gross_volume(self, o: bpy.types.Object) -> float:
         if not self.has_openings(o):
             return self.get_net_volume(o)
 
@@ -529,16 +551,18 @@ class QtoCalculator:
 
         return gross_volume
 
-    def has_openings(self, obj):
+    def has_openings(
+        self, obj: bpy.types.Object
+    ) -> Union[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]]:
         element = tool.Ifc.get_entity(obj)
         return element and getattr(element, "HasOpenings", [])
 
-    def get_obj_decompositions(self, obj):
+    def get_obj_decompositions(self, obj: bpy.types.Object) -> list[ifcopenshell.entity_instance]:
         element = tool.Ifc.get_entity(obj)
         decompositions = ifcopenshell.util.element.get_decomposition(element)
         return decompositions
 
-    def get_gross_weight(self, obj):
+    def get_gross_weight(self, obj: bpy.types.Object) -> Union[float, None]:
         obj_mass_density = self.get_obj_mass_density(obj)
         if not obj_mass_density:
             return
@@ -546,7 +570,7 @@ class QtoCalculator:
         gross_weight = obj_mass_density * gross_volume
         return gross_weight
 
-    def get_net_weight(self, obj):
+    def get_net_weight(self, obj: bpy.types.Object) -> Union[float, None]:
         obj_mass_density = self.get_obj_mass_density(obj)
         if not obj_mass_density:
             return
@@ -554,7 +578,7 @@ class QtoCalculator:
         net_weight = obj_mass_density * net_volume
         return net_weight
 
-    def get_obj_mass_density(self, obj):
+    def get_obj_mass_density(self, obj: bpy.types.Object) -> Union[float, None]:
         entity = tool.Ifc.get_entity(obj)
         material = ifcopenshell.util.element.get_material(entity)
         if material is None:
@@ -629,7 +653,7 @@ class QtoCalculator:
     #         volume += v1.dot(v2.cross(v3)) / 6.0
     # return volume
 
-    def get_opening_type(self, opening, obj):
+    def get_opening_type(self, opening: bpy.types.Object, obj: bpy.types.Object) -> Literal["OPENING", "RECESS"]:
         """_summary_: Returns the opening type - OPENING / RECESS
 
         :param blender-object opening: blender opening object
@@ -649,14 +673,22 @@ class QtoCalculator:
         return "OPENING" if ray_intersections % 2 == 0 else "RECESS"
 
     def get_opening_area(
-        self, obj, angle_z1: int = 45, angle_z2: int = 135, min_area: int = 0, ignore_recesses: bool = False
-    ):
+        self,
+        obj: bpy.types.Object,
+        angle_z1: int = 45,
+        angle_z2: int = 135,
+        min_area: int = 0,
+        ignore_recesses: bool = False,
+    ) -> float:
         """_summary_: Returns the lateral area of the openings in the object.
 
         :param obj: blender object
-        :param int angle_z1: Angle measured from the positive z-axis to the normal-vector of the opening area. Openings with a normal_vector lower than this value will be ignored, defaults to 45
-        :param int angle_z2: Angle measured from the positive z-axis to the normal-vector of the opening area. Openings with a normal_vector greater than this value will be ignored,defaults to 135
-        :param float min_area: Minimum opening area to consider.  Values lower than this will be ignored, defaults to 0
+        :param int angle_z1: Angle measured from the positive z-axis to the normal-vector of the opening area.
+            Openings with a normal_vector lower than this value will be ignored, defaults to 45
+        :param int angle_z2: Angle measured from the positive z-axis to the normal-vector of the opening area.
+            Openings with a normal_vector greater than this value will be ignored,defaults to 135
+        :param float min_area: Minimum opening area to consider.  Values lower than this will be ignored,
+            defaults to 0
         :param bool ignore_recesses: Toggle whether recess areas should be considered, defaults to False
         :return float: Opening Area
         """
@@ -702,14 +734,14 @@ class QtoCalculator:
 
     def get_lateral_area(
         self,
-        obj,
+        obj: bpy.types.Object,
         subtract_openings: bool = True,
         exclude_end_areas: bool = False,
         exclude_side_areas: bool = False,
         angle_z1: int = 45,
         angle_z2: int = 135,
         main_axis: str = "",
-    ):
+    ) -> float:
         """_summary_
 
         :param blender-object obj: blender object, bpy.types.Object
@@ -760,7 +792,7 @@ class QtoCalculator:
             area += polygon.area
         return area + total_opening_area
 
-    def get_gross_side_area(self, obj):
+    def get_gross_side_area(self, obj: bpy.types.Object) -> float:
         if not self.has_openings(obj):
             return self.get_net_side_area(obj)
 
@@ -768,15 +800,15 @@ class QtoCalculator:
 
         return gross_side_area
 
-    def get_net_side_area(self, obj):
+    def get_net_side_area(self, obj: bpy.types.Object) -> float:
         net_side_area = self.get_lateral_area(obj, exclude_end_areas=True, main_axis="x") / 2
         return net_side_area
 
-    def get_outer_surface_area(self, obj):
+    def get_outer_surface_area(self, obj: bpy.types.Object) -> float:
         outer_surface_area = self.get_lateral_area(obj, exclude_end_areas=True, angle_z1=0, angle_z2=360)
         return outer_surface_area
 
-    def get_end_area(self, obj):
+    def get_end_area(self, obj: bpy.types.Object) -> float:
         element = tool.Ifc.get_entity(obj)
         gross_mesh = self.get_gross_element_mesh(element)
         gross_obj = bpy.data.objects.new("MyObject", gross_mesh)
@@ -790,7 +822,7 @@ class QtoCalculator:
 
         return end_area
 
-    def get_gross_top_area(self, obj, angle: int = 45):
+    def get_gross_top_area(self, obj: bpy.types.Object, angle: int = 45) -> float:
         """_summary_: Returns the gross top area of the object.
 
         :param blender-object obj: blender object
@@ -827,12 +859,14 @@ class QtoCalculator:
         return area + opening_area
 
     # curently net top area is larger then projected area, because its taking into account internal polygons, or window sills
-    def get_net_top_area(self, obj, angle: int = 45, ignore_internal: bool = True):
+    def get_net_top_area(self, obj: bpy.types.Object, angle: int = 45, ignore_internal: bool = True) -> float:
         """_summary_: Returns the net top area of the object.
 
         :param blender-object obj: blender object
-        :param int angle: Angle measured from the positive z-axis to the normal-vector of the area. Values lower than this will be ignored, defaults to 45
-        :param bool ignore_internal: Toggle whether internal areas should be subtracted (Like window sills), defaults to True
+        :param int angle: Angle measured from the positive z-axis to the normal-vector of the area.
+            Values lower than this will be ignored, defaults to 45
+        :param bool ignore_internal: Toggle whether internal areas should be subtracted (Like window sills),
+            defaults to True
         :return float: Net Top Area
         """
         z_axis = (0, 0, 1)
@@ -852,11 +886,11 @@ class QtoCalculator:
 
         return area
 
-    def get_projected_area(self, obj, projection_axis: str = "z", is_gross: bool = True):
+    def get_projected_area(self, obj, projection_axis: AxisType = "z", is_gross: bool = True) -> float:
         """_summary_: Returns the projected area of the object.
 
         :param blender-object obj: blender object
-        :param str projection_axis: Axis to project the area onto. Can be "X", "Y" or "Z"
+        :param str projection_axis: Axis to project the area onto. Can be "x", "y" or "z"
         :param bool is_gross: if True, the projected area will include openings, if False, the projected area will exclude openings
         :return float: Projected Area
         """
@@ -891,7 +925,7 @@ class QtoCalculator:
             return projected_polygon.area + void_area
         return projected_polygon.area
 
-    def get_OBB_object(self, obj):
+    def get_OBB_object(self, obj: bpy.types.Object) -> bpy.types.Object:
         """_summary_: Returns the Oriented-Bounding-Box (OBB) of the object.
 
         :param blender-object obj: Blender Object
@@ -932,7 +966,7 @@ class QtoCalculator:
 
         return new_OBB_object
 
-    def get_AABB_object(self, obj):
+    def get_AABB_object(self, obj: bpy.types.Object) -> bpy.types.Object:
         """_summary_: Returns the Axis-Aligned-Bounding-Box (AABB) of the object.
 
         :param blender-object obj: Blender Object
@@ -988,12 +1022,12 @@ class QtoCalculator:
 
     def get_bisected_obj(
         self,
-        obj,
-        plane_co_pos,
-        plane_no_pos,
-        plane_co_neg,
-        plane_no_neg,
-    ):
+        obj: bpy.types.Object,
+        plane_co_pos: VectorTuple,
+        plane_no_pos: VectorTuple,
+        plane_co_neg: VectorTuple,
+        plane_no_neg: VectorTuple,
+    ) -> bpy.types.Object:
         """_summary_: Returns the object bisected by two planes.
 
         :param blender-object obj: Blender Object
@@ -1031,11 +1065,12 @@ class QtoCalculator:
 
         return bis_obj
 
-    def get_total_contact_area(self, obj, class_filter: str = ["IfcElement"]):
+    def get_total_contact_area(self, obj: bpy.types.Object, class_filter: list[str] = ["IfcElement"]) -> float:
         """_summary_: Returns the total contact area of the object with other objects.
 
         :param blender-object obj: Blender Object
-        :param list [] class_filter: A list of classes used to filter the objects to be considered for the calculation. Example: ["IfcWall"] or ["IfcWall", "IfcSlab"]
+        :param list [] class_filter: A list of classes used to filter the objects
+            to be considered for the calculation. Example: ["IfcWall"] or ["IfcWall", "IfcSlab"]
         :return float: Total contact area of the object with other objects.
         """
         total_contact_area = 0
@@ -1046,11 +1081,12 @@ class QtoCalculator:
 
         return total_contact_area
 
-    def get_touching_objects(self, obj, class_filter):
+    def get_touching_objects(self, obj: bpy.types.Object, class_filter: list[str]) -> list[bpy.types.Object]:
         """_summary_: Returns a list of objects that are touching the object.
 
         :param blender-object obj: Blender Object
-        :param list [] class_filter: A list of classes used to filter the objects to be considered for the calculation. Example: ["IfcWall"] or ["IfcWall", "IfcSlab"]
+        :param list [] class_filter: A list of classes used to filter the objects
+            to be considered for the calculation. Example: ["IfcWall"] or ["IfcWall", "IfcSlab"]
         :return list: List of touching objects
         """
         # rotate the object ever so slightly, otherwise bvhtree.overlap won't work properly.  https://blender.stackexchange.com/a/275244/130742
@@ -1094,7 +1130,7 @@ class QtoCalculator:
 
         return touching_objects
 
-    def get_contact_area(self, object1, object2):
+    def get_contact_area(self, object1: bpy.types.Object, object2: bpy.types.Object) -> float:
         """_summary_: Returns the contact area between two objects.
 
         :param blender-object obj: Blender Object
@@ -1109,7 +1145,13 @@ class QtoCalculator:
                 total_area += self.get_intersection_between_polygons(object1, poly1, object2, poly2)
         return total_area
 
-    def get_intersection_between_polygons(self, object1, poly1, object2, poly2):
+    def get_intersection_between_polygons(
+        self,
+        object1: bpy.types.Object,
+        poly1: bpy.types.MeshPolygon,
+        object2: bpy.types.Object,
+        poly2: bpy.types.MeshPolygon,
+    ) -> float:
         """_summary_: Returns the intersection between two polygons.
 
         :param blender-object object1: Blender Object
@@ -1152,7 +1194,9 @@ class QtoCalculator:
             # TopologicalError - Generated Geometry might be invalid
             return 0
 
-    def create_shapely_polygon(self, obj, polygon, trans_matrix):
+    def create_shapely_polygon(
+        self, obj: bpy.types.Object, polygon: bpy.types.MeshPolygon, trans_matrix: Matrix
+    ) -> Polygon:
         """_summary_: Create a shapely polygon
 
         :param blender-object obj: Blender Object
@@ -1171,12 +1215,14 @@ class QtoCalculator:
             polygon_tuples.append((x, y))
         return Polygon(polygon_tuples)
 
-    def get_gross_element_mesh(self, element):
+    def get_gross_element_mesh(self, element: ifcopenshell.entity_instance) -> bpy.types.Mesh:
         settings = ifcopenshell.geom.settings()
         settings.set(settings.DISABLE_OPENING_SUBTRACTIONS, True)
         return self.create_mesh_from_shape(element, settings)
 
-    def create_mesh_from_shape(self, element, settings=None):
+    def create_mesh_from_shape(
+        self, element: ifcopenshell.entity_instance, settings: Optional[ifcopenshell.geom.settings] = None
+    ) -> bpy.types.Mesh:
         if settings is None:
             settings = ifcopenshell.geom.settings()
         shape = ifcopenshell.geom.create_shape(settings, element)
@@ -1203,12 +1249,12 @@ class QtoCalculator:
         mesh.update()
         return mesh
 
-    def get_bmesh_from_mesh(self, mesh):
+    def get_bmesh_from_mesh(self, mesh: bpy.types.Mesh) -> bmesh.types.BMesh:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         return bm
 
-    def get_object_main_axis(self, o):
+    def get_object_main_axis(self, o: bpy.types.Object) -> AxisType:
         """_summary_: Returns the main object axis. Useful for profile-defined objects.
 
         :param blender-object o: Blender Object
@@ -1227,18 +1273,18 @@ class QtoCalculator:
         else:
             return "x"
 
-    def is_opening_horizontal(self, o):
+    def is_opening_horizontal(self, o: bpy.types.Object) -> bool:
         x = (Vector(o.bound_box[4]) - Vector(o.bound_box[0])).length
         y = (Vector(o.bound_box[3]) - Vector(o.bound_box[0])).length
         z = (Vector(o.bound_box[1]) - Vector(o.bound_box[0])).length
 
         return z < x and z < y
 
-    def delete_mesh(self, mesh):
+    def delete_mesh(self, mesh: bpy.types.Mesh) -> None:
         mesh.user_clear()
         bpy.data.meshes.remove(mesh)
 
-    def delete_obj(self, obj):
+    def delete_obj(self, obj: bpy.types.Object) -> None:
         bpy.data.objects.remove(obj, do_unlink=True)
 
 

src/blenderbim/blenderbim/bim/module/pset/ui.py

@@ -33,7 +33,6 @@ from blenderbim.bim.module.pset.data import (
     GroupPsetData,
     ProfilePsetsData,
     WorkSchedulePsetsData,
-
 )
 
 
@@ -91,7 +90,7 @@ def get_active_pset_obj_name(context, obj_type):
     return ""
 
 
-def draw_psetqto_ui(context, pset_id, pset, props, layout, obj_type):
+def draw_psetqto_ui(context, pset_id, pset, props, layout, obj_type, allow_removing=True):
     box = layout.box()
     row = box.row(align=True)
     if "is_expanded" not in pset:
@@ -115,16 +114,20 @@ def draw_psetqto_ui(context, pset_id, pset, props, layout, obj_type):
         op.pset_id = pset_id
         op.obj = obj_name
         op.obj_type = obj_type
-        op = row.operator("bim.remove_pset", icon="X", text="")
+        remove_pset_row = row.row(align=True)
+        op = remove_pset_row.operator("bim.remove_pset", icon="X", text="")
         op.pset_id = pset_id
         op.obj = obj_name
         op.obj_type = obj_type
+        remove_pset_row.enabled = allow_removing
     elif props.active_pset_id != pset_id:
         row.label(text=pset["Name"], icon="COPY_ID")
-        op = row.operator("bim.remove_pset", icon="X", text="")
+        remove_pset_row = row.row(align=True)
+        op = remove_pset_row.operator("bim.remove_pset", icon="X", text="")
         op.pset_id = pset_id
         op.obj = obj_name
         op.obj_type = obj_type
+        remove_pset_row.enabled = allow_removing
     if pset["is_expanded"]:
         if props.active_pset_id == pset_id:
             for prop in props.properties:
@@ -172,7 +175,7 @@ def draw_psetqto_editable_ui(box, props, prop):
 
 
 class BIM_PT_object_psets(Panel):
-    bl_label = "Object Property Sets"
+    bl_label = "Property Sets"
     bl_idname = "BIM_PT_object_psets"
     bl_space_type = "PROPERTIES"
     bl_region_type = "WINDOW"
@@ -204,17 +207,22 @@ class BIM_PT_object_psets(Panel):
         if not props.active_pset_id and props.active_pset_name and props.active_pset_type == "PSET":
             draw_psetqto_ui(context, 0, {}, props, self.layout, "Object")
 
-        for pset in ObjectPsetsData.data["psets"]:
-            draw_psetqto_ui(context, pset["id"], pset, props, self.layout, "Object")
+        if ObjectPsetsData.data["psets"]:
+            if ObjectPsetsData.data["is_occurrence"]:
+                self.layout.label(text="Occurrence Properties:")
+            else:
+                self.layout.label(text="Type Properties:")
+            for pset in ObjectPsetsData.data["psets"]:
+                draw_psetqto_ui(context, pset["id"], pset, props, self.layout, "Object")
 
         if ObjectPsetsData.data["inherited_psets"]:
-            self.layout.label(text="Inherited Psets:", icon="FILE_PARENT")
+            self.layout.label(text="Inherited Type Properties:", icon="CON_CHILDOF")
             for pset in ObjectPsetsData.data["inherited_psets"]:
-                draw_psetqto_ui(context, pset["id"], pset, props, self.layout, "Object")
+                draw_psetqto_ui(context, pset["id"], pset, props, self.layout, "Object", allow_removing=False)
 
 
 class BIM_PT_object_qtos(Panel):
-    bl_label = "Object Quantity Sets"
+    bl_label = "Quantity Sets"
     bl_idname = "BIM_PT_object_qtos"
     bl_space_type = "PROPERTIES"
     bl_region_type = "WINDOW"
@@ -246,8 +254,18 @@ class BIM_PT_object_qtos(Panel):
         if not props.active_pset_id and props.active_pset_name and props.active_pset_type == "QTO":
             draw_psetqto_ui(context, 0, {}, props, self.layout, "Object")
 
-        for qto in ObjectQtosData.data["qtos"]:
-            draw_psetqto_ui(context, qto["id"], qto, props, self.layout, "Object")
+        if ObjectQtosData.data["qtos"]:
+            if ObjectQtosData.data["is_occurrence"]:
+                self.layout.label(text="Occurrence Quantities:")
+            else:
+                self.layout.label(text="Type Quantities:")
+            for qto in ObjectQtosData.data["qtos"]:
+                draw_psetqto_ui(context, qto["id"], qto, props, self.layout, "Object")
+
+        if ObjectQtosData.data["inherited_qsets"]:
+            self.layout.label(text="Inherited Type Quantities:", icon="CON_CHILDOF")
+            for qset in ObjectQtosData.data["inherited_qsets"]:
+                draw_psetqto_ui(context, qset["id"], qset, props, self.layout, "Object", allow_removing=False)
 
 
 class BIM_PT_material_psets(Panel):
@@ -541,8 +559,6 @@ class BIM_PT_group_psets(Panel):
             draw_psetqto_ui(context, pset["id"], pset, props, self.layout, "Group")
 
 
-
-
 class BIM_PT_profile_psets(Panel):
     bl_label = "Profile Property Sets"
     bl_idname = "BIM_PT_profile_psets"

src/blenderbim/blenderbim/bim/module/pset_template/__init__.py

@@ -34,6 +34,7 @@ classes = (
     operator.RemovePropTemplate,
     operator.RemovePsetTemplate,
     operator.RemovePsetTemplateFile,
+    operator.SavePsetTemplateFile,
     prop.PsetTemplate,
     prop.EnumerationValues,
     prop.PropTemplate,

src/blenderbim/blenderbim/bim/module/root/data.py

@@ -42,6 +42,7 @@ class IfcClassData:
         cls.data["contexts"] = cls.contexts()
         cls.data["has_entity"] = cls.has_entity()
         cls.data["name"] = cls.name()
+        cls.data["has_inherited_predefined_type"] = cls.has_inherited_predefined_type()
         cls.data["ifc_class"] = cls.ifc_class()
         cls.data["ifc_predefined_types"] = cls.ifc_predefined_types()
         cls.data["can_reassign_class"] = cls.can_reassign_class()
@@ -162,6 +163,16 @@ class IfcClassData:
             name += f"[{predefined_type}]"
         return name
 
+    @classmethod
+    def has_inherited_predefined_type(cls):
+        element = tool.Ifc.get_entity(bpy.context.view_layer.objects.active)
+        if not element:
+            return
+        if element_type := ifcopenshell.util.element.get_type(element):
+            # Allow for None due to https://github.com/buildingSMART/IFC4.3.x-development/issues/818
+            return ifcopenshell.util.element.get_predefined_type(element_type) not in ("NOTDEFINED", None)
+        return False
+
     @classmethod
     def ifc_class(cls):
         element = tool.Ifc.get_entity(bpy.context.view_layer.objects.active)

src/blenderbim/blenderbim/bim/module/root/operator.py

@@ -215,7 +215,7 @@ class UnlinkObject(bpy.types.Operator):
     bl_idname = "bim.unlink_object"
     bl_label = "Unlink Object"
     bl_options = {"REGISTER", "UNDO"}
-    obj: bpy.props.StringProperty()
+    obj: bpy.props.StringProperty(name="Object Name")
     should_delete: bpy.props.BoolProperty(name="Delete IFC Element", default=True)
 
     def execute(self, context):
@@ -227,6 +227,7 @@ class UnlinkObject(bpy.types.Operator):
         else:
             objects = context.selected_objects
 
+        objects: list[bpy.types.Object]
         for obj in objects:
             was_active_object = obj == context.active_object
 
@@ -242,6 +243,27 @@ class UnlinkObject(bpy.types.Operator):
                 if obj.data:
                     obj_copy.data = obj.data.copy()
 
+                    # prevent unlinking materials that might be used elsewhere
+                    replacements: dict[bpy.types.Material, bpy.types.Material] = dict()
+                    for material_slot in obj_copy.material_slots:
+                        material = material_slot.material
+                        if material is None:
+                            continue
+
+                        if material in replacements:
+                            material_replacement = replacements[material]
+
+                        # no need to copy non-ifc materials as unlinking won't do anything to them
+                        elif tool.Ifc.get_entity(material) is None and tool.Style.get_style(material) is None:
+                            replacements[material] = material
+                            continue
+
+                        else:
+                            material_replacement = material.copy()
+                            replacements[material] = material_replacement
+
+                        material_slot.material = material_replacement
+
                 tool.Geometry.delete_ifc_object(obj)
 
                 obj = obj_copy

src/blenderbim/blenderbim/bim/module/root/ui.py

@@ -61,7 +61,10 @@ class BIM_PT_class(Panel):
                 self.layout.prop(context.scene.BIMRootProperties, "relating_class_object", icon="COPYDOWN")
             else:
                 row = self.layout.row(align=True)
-                row.label(text=IfcClassData.data["name"])
+                row.label(
+                    text=IfcClassData.data["name"],
+                    icon="CON_CHILDOF" if IfcClassData.data["has_inherited_predefined_type"] else "NONE",
+                )
                 row.operator("bim.select_ifc_class", text="", icon="RESTRICT_SELECT_OFF")
                 row.operator("bim.unlink_object", icon="UNLINKED", text="")
                 if IfcClassData.data["can_reassign_class"]:

src/blenderbim/blenderbim/bim/module/search/__init__.py

@@ -24,21 +24,15 @@ classes = (
     operator.ActivateIfcClassFilter,
     operator.AddFilter,
     operator.AddFilterGroup,
-    operator.AddToIfcGroup,
     operator.ColourByProperty,
     operator.EditFilterQuery,
-    operator.FilterModelElements,
-    operator.IfcSelector,
     operator.LoadColourscheme,
-    operator.LoadQuery,
     operator.LoadSearch,
-    operator.OpenQueryLibrary,
     operator.RemoveFilter,
     operator.RemoveFilterGroup,
     operator.ResetObjectColours,
     operator.SaveColourscheme,
     operator.SaveSearch,
-    operator.SaveSelectorQuery,
     operator.Search,
     operator.SelectByProperty,
     operator.SelectFilterElements,
@@ -51,11 +45,6 @@ classes = (
     prop.BIMFilterClasses,
     prop.BIMFilterBuildingStoreys,
     prop.BIMSearchProperties,
-    prop.SearchCollection,
-    prop.SearchQueryFilter,
-    prop.SearchQuery,
-    prop.SearchQueryGroup,
-    prop.IfcSelectorProperties,
     ui.BIM_PT_search,
     ui.BIM_PT_filter,
     ui.BIM_PT_colour_by_property,
@@ -63,15 +52,12 @@ classes = (
     ui.BIM_UL_colourscheme,
     ui.BIM_UL_ifc_class_filter,
     ui.BIM_UL_ifc_building_storey_filter,
-    ui.BIM_PT_IFCSelector,
 )
 
 
 def register():
     bpy.types.Scene.BIMSearchProperties = bpy.props.PointerProperty(type=prop.BIMSearchProperties)
-    bpy.types.Scene.IfcSelectorProperties = bpy.props.PointerProperty(type=prop.IfcSelectorProperties)
 
 
 def unregister():
     del bpy.types.Scene.BIMSearchProperties
-    del bpy.types.Scene.IfcSelectorProperties

src/blenderbim/blenderbim/bim/module/search/operator.py

@@ -131,6 +131,7 @@ class SelectFilterElements(bpy.types.Operator):
             text_data = bpy.data.texts.new(name)
             text_data.from_string(",".join(global_ids))
             filter_groups[self.group_index].filters[self.index].value = f"bpy.data.texts['{name}']"
+            self.report({"INFO"}, f'List of Global Ids was saved to the text file "{name}" in the current .blend file')
         else:
             filter_groups[self.group_index].filters[self.index].value = ",".join(global_ids)
         return {"FINISHED"}
@@ -234,7 +235,7 @@ class LoadSearch(Operator, tool.Ifc.Operator):
     def _execute(self, context):
         filter_groups = tool.Search.get_filter_groups(self.module)
         group = tool.Ifc.get().by_id(int(context.scene.BIMSearchProperties.saved_searches))
-        query = tool.Search.import_filter_query(tool.Search.get_group_query(group), filter_groups)
+        tool.Search.import_filter_query(tool.Search.get_group_query(group), filter_groups)
 
     def draw(self, context):
         props = context.scene.BIMSearchProperties
@@ -270,25 +271,29 @@ class ColourByProperty(Operator):
         colourscheme = {}
 
         if len(props.colourscheme):
-            colourscheme = {cs.name: cs.colour[0:3] for cs in props.colourscheme}
+            colourscheme = {cs.name: {"colour": cs.colour[0:3], "total": 0} for cs in props.colourscheme}
 
         for obj in context.visible_objects:
             element = tool.Ifc.get_entity(obj)
             if not element:
                 continue
             value = str(ifcopenshell.util.selector.get_element_value(element, query))
-            if value not in colourscheme:
-                colourscheme[value] = next(colours)[0:3]
-            obj.color = (*colourscheme[value], 1)
+            if value in colourscheme:
+                colourscheme[value]["total"] += 1
+            else:
+                colourscheme[value] = {"colour": next(colours)[0:3], "total": 1}
+            obj.color = (*colourscheme[value]["colour"], 1)
         areas = [a for a in context.screen.areas if a.type == "VIEW_3D"]
         if areas:
             areas[0].spaces[0].shading.color_type = "OBJECT"
 
         props.colourscheme.clear()
-        for value, colour in colourscheme.items():
+        for value in sorted(colourscheme.keys()):
+            data = colourscheme[value]
             new = props.colourscheme.add()
             new.name = str(value)
-            new.colour = colour[0:3]
+            new.total = data["total"]
+            new.colour = data["colour"][0:3]
         return {"FINISHED"}
 
     def store_state(self, context):
@@ -350,16 +355,16 @@ class SaveColourscheme(Operator, tool.Ifc.Operator):
         query = props.colourscheme_query
 
         group = [g for g in tool.Ifc.get().by_type("IfcGroup") if g.Name == self.name]
-        coulour_scheme = {cs.name: cs.colour[0:3] for cs in props.colourscheme}
+        colourscheme = {cs.name: {"colour": cs.colour[0:3], "total": cs.total} for cs in props.colourscheme}
         if group:
             group = group[0]
             description = json.loads(group.Description)
-            description["colourscheme"] = coulour_scheme
+            description["colourscheme"] = colourscheme
             description["colourscheme_query"] = query
             group.Description = json.dumps(description)
         else:
             description = json.dumps(
-                {"type": "BBIM_Search", "colourscheme": coulour_scheme, "colourscheme_query": query}
+                {"type": "BBIM_Search", "colourscheme": colourscheme, "colourscheme_query": query}
             )
             group = ifcopenshell.api.run("group.add_group", tool.Ifc.get(), Name=self.name, Description=description)
 
@@ -379,10 +384,11 @@ class LoadColourscheme(Operator, tool.Ifc.Operator):
         description = json.loads(group.Description)
         props.colourscheme_query = description.get("colourscheme_query")
         props.colourscheme.clear()
-        for name, colour in description.get("colourscheme", {}).items():
+        for name, data in description.get("colourscheme", {}).items():
             new = props.colourscheme.add()
             new.name = name
-            new.colour = colour
+            new.total = data["total"]
+            new.colour = data["colour"]
 
     def draw(self, context):
         props = context.scene.BIMSearchProperties
@@ -538,9 +544,11 @@ class ActivateIfcClassFilter(Operator):
             "filter_classes",
             context.scene.BIMSearchProperties,
             "filter_classes_index",
-            rows=20
-            if len(bpy.context.scene.BIMSearchProperties.filter_classes) > 20
-            else len(bpy.context.scene.BIMSearchProperties.filter_classes),
+            rows=(
+                20
+                if len(bpy.context.scene.BIMSearchProperties.filter_classes) > 20
+                else len(bpy.context.scene.BIMSearchProperties.filter_classes)
+            ),
         )
         row = self.layout.row(align=True)
         row.operator("bim.toggle_filter_selection", text="Select All").action = "SELECT"
@@ -595,9 +603,11 @@ class ActivateContainerFilter(Operator):
             "filter_container",
             context.scene.BIMSearchProperties,
             "filter_container_index",
-            rows=20
-            if len(bpy.context.scene.BIMSearchProperties.filter_container) > 20
-            else len(bpy.context.scene.BIMSearchProperties.filter_container),
+            rows=(
+                20
+                if len(bpy.context.scene.BIMSearchProperties.filter_container) > 20
+                else len(bpy.context.scene.BIMSearchProperties.filter_container)
+            ),
         )
         row = self.layout.row(align=True)
         row.operator("bim.toggle_filter_selection", text="Select All").action = "SELECT"
@@ -618,223 +628,6 @@ class ShowAllElements(Operator):
         return {"FINISHED"}
 
 
-class FilterModelElements(Operator):
-    """Filter model elements based on selection"""
-
-    bl_idname = "bim.filter_model_elements"
-    bl_label = "Filter Model Elements"
-    option: StringProperty("select|isolate|hide")
-
-    def execute(self, context):
-        selection_props = context.scene.IfcSelectorProperties
-        selection = (
-            selection_props.selector_query_syntax
-            if selection_props.manual_override
-            else self.add_groups(selection_props)
-        )
-        selection_props.selector_query_syntax = selection
-        r = core.search(tool.Search, tool.Spatial, query=selection, action=self.option)
-        if isinstance(r, str):
-            self.report({"WARNING"}, r)
-        return {"FINISHED"}
-
-    def add_groups(self, selector: str) -> str:
-        selection = ""
-        for group_index, group in enumerate(selector.groups):
-            if group_index != 0:
-                selection += " | "
-            selection += "(" if len(selector.groups) > 1 else ""
-            selection = self.add_queries(selection, group)
-
-            selection += ")" if len(selector.groups) > 1 else ""
-        return selection
-
-    def add_queries(self, selection: str, group: str) -> str:
-        for query_index, query in enumerate(group.queries):
-            if query_index != 0:
-                selection += " & " if query.and_or == "and" else " | "
-
-            if query.selector == "IFC Class":
-                active_option = query.active_option.split(": ")[1]
-                selection += f".{active_option}"
-                selection = self.add_filters(selection, query)
-
-            elif query.selector == "GlobalId":
-                selection += f"#{query.value}"
-
-            elif query.selector == "IfcElementType":
-                index = int(query.active_sub_option.split(":")[0])
-                selection += f"* #{query.sub_options[index].global_id}"
-
-            elif query.selector == "IfcSpatialElement":
-                index = int(query.active_sub_option.split(":")[0])
-                selection += f"@ #{query.sub_options[index].global_id}"
-        return selection
-
-    def add_filters(self, selection: str, query: str) -> str:
-        for f_index, f in enumerate(query.filters):
-            if f_index != 0:
-                selection += " & " if f.and_or == "and" else " | "
-                selection += f".{query.active_option}"
-
-            if f.value in ("True", "False"):
-                value = f.value
-            elif f.value.isnumeric() and str(float(f.value))[0] == f.value[0]:
-                value = f.value
-            else:
-                value = f'"{f.value}"'
-
-            selection += "["
-
-            if f.selector == "IfcPropertySet":
-                selection += f'{f.active_option.split(": ")[1]}.{f.active_sub_option.split(": ")[1]} {"!" if f.negation else ""}{f.comparison} {value}'
-            elif f.selector == "Attribute":
-                # we're using the prop_search functionality in blender which returns the index of the option.  Sometimes the user can override this and enter a value that doesn't exist in the list.  In this case there is no index and we need to handle it. @vulevukusej
-                pattern = re.compile(r"^[0-9]+:")
-                match = pattern.search(f.active_option)
-                selection += f'{f.active_option.split(": ")[1] if match else f.active_option} {"!" if f.negation else ""}{f.comparison} {value}'
-            selection += "]"
-        return selection
-
-
-# This needs to be moved into ui code, I know ;) - vulevukusej
-class IfcSelector(Operator):
-    """Select elements in model with IFC Selector"""
-
-    bl_idname = "bim.ifc_selector"
-    bl_label = "Select elements with IFC Selector"
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self, width=800)
-
-    @classmethod
-    def poll(cls, context):
-        return IfcStore.get_file()
-
-    def execute(self, context):
-        return {"FINISHED"}
-
-    def draw(self, context):
-        from . import ui
-
-        ui.IfcSelectorUI.draw(context, self.layout)
-
-
-class SaveSelectorQuery(Operator):
-    bl_idname = "bim.save_selector_query"
-    bl_label = "Save Selector Query"
-    save_name: StringProperty()
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self, width=400)
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "save_name")
-
-    def execute(self, context):
-        ifc_selector = context.scene.IfcSelectorProperties
-        new = ifc_selector.query_library.add()
-        new.name = self.save_name
-        new.query = ifc_selector.selector_query_syntax
-        return {"FINISHED"}
-
-
-class OpenQueryLibrary(Operator):
-    """Open Query Library"""
-
-    bl_idname = "bim.open_query_library"
-    bl_label = "Open Query Library"
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_popup(self, width=400)
-
-    def draw(self, context):
-        layout = self.layout
-        ifc_selector = context.scene.IfcSelectorProperties
-
-        for index, query in enumerate(ifc_selector.query_library):
-            row = layout.row(align=True)
-            row.prop(query, "query", text=query.name)
-            op = row.operator("bim.load_query", icon="SORT_ASC", text="")
-            op.index = index
-
-            row.context_pointer_set(name="bim_prop_group", data=ifc_selector)
-            op = row.operator("bim.edit_blender_collection", icon="REMOVE", text="")
-            op.option = "remove"
-            op.collection = "query_library"
-            op.index = index
-
-    def execute(self, context):
-        return {"FINISHED"}
-
-
-class LoadQuery(Operator):
-    bl_idname = "bim.load_query"
-    bl_label = "Load Query"
-    index: IntProperty()
-
-    def invoke(self, context, event):
-        close_operator_panel(event)
-        return self.execute(context)
-
-    def execute(self, context):
-        ifc_selector = context.scene.IfcSelectorProperties
-        ifc_selector.selector_query_syntax = ifc_selector.query_library[self.index].query
-        return {"FINISHED"}
-
-
-class AddToIfcGroup(Operator):
-    bl_idname = "bim.add_to_ifc_group"
-    bl_label = "Add to IFC Group"
-    group_name: StringProperty(name="Group Name")
-
-    def invoke(self, context, event):
-        bpy.ops.bim.load_groups()
-        return context.window_manager.invoke_props_dialog(self, width=400)
-
-    def draw(self, context):
-        self.props = context.scene.BIMGroupProperties
-        row = self.layout.row()
-        row.operator("bim.add_group")
-
-        self.layout.template_list(
-            "BIM_UL_groups",
-            "",
-            self.props,
-            "groups",
-            self.props,
-            "active_group_index",
-        )
-
-        if self.props.active_group_id:
-            for attribute in self.props.group_attributes:
-                if attribute.name in ["Name", "Description"]:
-                    row = self.layout.row(align=True)
-                    row.prop(attribute, "string_value", text=attribute.name)
-
-    def execute(self, context):
-        active_group_index = self.props.active_group_index
-        ifc_definition_id = self.props.groups[active_group_index].ifc_definition_id
-
-        bpy.ops.bim.enable_editing_group(group=ifc_definition_id)
-
-        selector_query_syntax = context.scene.IfcSelectorProperties.selector_query_syntax
-
-        for attribute in self.props.group_attributes:
-            if attribute.name == "Description":
-                if "*selector*" not in attribute.string_value:
-                    attribute.string_value += f" *selector*{selector_query_syntax}*selector*"
-                else:
-                    new_description = attribute.string_value.split("*selector*")
-                    new_description[1] = selector_query_syntax
-                    attribute.string_value = "*selector*".join(new_description)
-
-        bpy.ops.bim.edit_group()
-        bpy.ops.bim.disable_group_editing_ui()
-        return {"FINISHED"}
-
-
 class SelectSimilar(Operator, tool.Ifc.Operator):
     bl_idname = "bim.select_similar"
     bl_label = "Select Similar"

src/blenderbim/blenderbim/bim/module/search/prop.py

@@ -78,7 +78,7 @@ def update_is_container_selected(self, context):
     else:
         for obj in context.selected_objects:
             container = tool.Spatial.get_container(tool.Ifc.get_entity(obj))
-            if (container and container.Name == self.name) or (not container and self.name== "None"):
+            if (container and container.Name == self.name) or (not container and self.name == "None"):
                 obj.select_set(False)
                 new = self.unselected_objects.add()
                 new.obj = obj
@@ -100,6 +100,7 @@ class BIMFilterBuildingStoreys(PropertyGroup):
 
 class BIMColour(PropertyGroup):
     name: StringProperty(name="Name")
+    total: IntProperty(name="Total")
     colour: FloatVectorProperty(name="Colour", subtype="COLOR", default=(1, 0, 0), min=0.0, max=1.0)
 
 
@@ -138,139 +139,3 @@ def get_classes(self, ifc_product):
     declarations = util.schema.get_subtypes(declaration)
     names = [d.name() for d in declarations]
     return [(c, c, "") for c in sorted(names)]
-
-
-def load_sub_options(self, context):
-    if self.selector not in ["IfcClass"]:
-        self.load_option = "sub_options"
-        load_selection_options(self, context)
-
-
-def load_selection_options(self, context):
-    ifc = IfcStore.file
-    load_option = self.load_option
-    op = getattr(self, load_option)
-    op.clear()
-    options = []
-
-    if load_option == "options":
-        self.sub_options.clear()
-        if self.selector == "IFC Class":
-            options = get_classes(self, "IfcElement")
-            options.append(("IfcSpace", "IfcSpace", ""))
-        elif self.selector == "IfcSpatialElement":
-            options = get_classes(self, "IfcSpatialElement")
-        elif self.selector == "IfcElementType":
-            options = get_classes(self, "IfcElementType")
-        elif self.selector == "GlobalId":
-            return
-        elif self.selector == "IfcPropertySet":
-            psets = Selector.parse(ifc, ".IfcPropertySet")
-            options = set([o.Name for o in psets])
-        elif self.selector == "Attribute":
-            attributes = ["GlobalId", "Name", "Description", "ObjectType", "Tag", "PredefinedType"]
-            for a in attributes:
-                options.append((a, a, ""))
-
-    elif load_option == "sub_options":
-        if self.selector in ["IfcSpatialElement", "IfcElementType"]:
-            active_option = self.active_option.split(": ")[1]
-            options = Selector.parse(ifc, f".{active_option}")
-
-        elif self.selector == "IfcPropertySet":
-            options = set()
-            active_pset = self.active_option.split(": ")[1]
-            psets_in_file = Selector.parse(ifc, f'.IfcPropertySet[Name="{active_pset}"]')
-            for pset in psets_in_file:
-                for prop in pset.HasProperties:
-                    options.add(prop.Name)
-
-    for index, option in enumerate(options):
-        new = op.add()
-        if self.selector in ["IfcSpatialElement", "IfcElementType"]:
-            if self.load_option == "sub_options":
-                new.name = f"{index}: {option.Name}"
-                new.global_id = option.GlobalId
-            else:
-                new.name = f"{index}: {option[0]}"
-        elif self.selector == "IfcPropertySet":
-            new.name = f"{index}: {option}"
-        else:
-            new.name = f"{index}: {option[0]}"
-    self.load_option = "options"
-
-
-def load_spatial_elements(self, context):
-    ifc = IfcStore.file
-    col_items = Selector.parse(ifc, f".{self.selected_spatial_element}")
-    collection = getattr(self, "sub_spatial_elements", None)
-    collection.clear()
-    for index, c in enumerate(col_items):
-        new = collection.add()
-        new.name = f"{index}-{c.Name}"
-
-
-class SearchCollection(PropertyGroup):
-    name: StringProperty()
-    long_name: StringProperty()
-    global_id: StringProperty()
-    query: StringProperty()
-
-
-class IfcSelector:
-    and_or: EnumProperty(
-        items=[(i, i, i) for i in ["and", "or"]],
-    )
-    negation: BoolProperty(name="not")
-    comparison: EnumProperty(
-        items=[
-            ("=", "equal to", ""),
-            ("*=", "contains", ""),
-            (">=", "greater than or equal to", ""),
-            ("<=", "lesser than or equal to", ""),
-            (">", "greater than", ""),
-            ("<", "less than", ""),
-        ],
-    )
-    load_option: StringProperty(
-        default="options", description="controls whether or not options or sub_options are loaded"
-    )
-    options: CollectionProperty(type=SearchCollection)
-    active_option: StringProperty(update=load_sub_options)
-    sub_options: CollectionProperty(type=SearchCollection)
-    active_sub_option: StringProperty()
-    value: StringProperty(description="generic 'value' that can be used in multiple scenarios")
-
-
-class SearchQueryFilter(PropertyGroup, IfcSelector):
-    selector: EnumProperty(
-        items=[(i, i, i) for i in ["-", "IfcPropertySet", "Attribute"]],
-        name="Filter selection by",
-        update=load_selection_options,
-        default="-",
-    )
-
-
-class SearchQuery(PropertyGroup, IfcSelector):
-    filters: CollectionProperty(type=SearchQueryFilter)
-    selector: EnumProperty(
-        items=[(i, i, i) for i in ["-", "IFC Class", "IfcSpatialElement", "IfcElementType", "GlobalId"]],
-        name="Selector type",
-        update=load_selection_options,
-        default="-",
-    )
-
-
-class SearchQueryGroup(PropertyGroup, IfcSelector):
-    queries: CollectionProperty(type=SearchQuery)
-
-
-class IfcSelectorProperties(PropertyGroup, IfcSelector):
-    groups: CollectionProperty(type=SearchQueryGroup)
-    selector_query_syntax: StringProperty()
-
-    query_library: CollectionProperty(type=SearchCollection)
-    active_query: StringProperty()
-
-    active_query: StringProperty()
-    manual_override: BoolProperty(default=False, description="Toggle to allow manual typing of query-syntax")

src/blenderbim/blenderbim/bim/module/search/ui.py

@@ -125,7 +125,7 @@ class BIM_UL_colourscheme(bpy.types.UIList):
         if not item:
             return
         row = layout.row(align=True)
-        row.label(text=item.name)
+        row.label(text=f"{item.name} ({item.total})")
         row.prop(item, "colour", text="")
 
 
@@ -159,153 +159,3 @@ class BIM_UL_ifc_building_storey_filter(bpy.types.UIList):
         split = split.column()
         split.scale_x = 0.5
         split.label(text=str(item.total))
-
-
-class BIM_PT_IFCSelector(Panel):
-    bl_label = "Selector"
-    bl_idname = "BIM_PT_ifc_selector"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_tab_sandbox"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator("bim.ifc_selector")
-
-
-# this doesn't inherit from Panel since it's just a class to abstract away UI code from the IfcSelector Operator
-class IfcSelectorUI:
-    @classmethod
-    def draw(self, context, layout):
-        ifc_selector = context.scene.IfcSelectorProperties
-        row = layout.row()
-
-        row.context_pointer_set(name="bim_prop_group", data=ifc_selector)
-        op = row.operator("bim.edit_blender_collection", text="Add selection group")
-        op.option = "add"
-        op.collection = "groups"
-        layout.separator()
-
-        self.draw_query_group_ui(self, ifc_selector, layout)
-
-        if len(ifc_selector.groups) != 0:
-            row = layout.row(align=True)
-            row.prop(ifc_selector, "selector_query_syntax", text="Query Syntax")
-            row.prop(ifc_selector, "manual_override", text="")
-
-            select = row.operator("bim.filter_model_elements", text="", icon="RESTRICT_SELECT_OFF")
-            select.option = "select"
-            isolate = row.operator("bim.filter_model_elements", text="", icon="ZOOM_SELECTED")
-            isolate.option = "isolate"
-            hide = row.operator("bim.filter_model_elements", text="", icon="HIDE_ON")
-            hide.option = "hide"
-            unhide = row.operator("bim.filter_model_elements", text="", icon="HIDE_OFF")
-            unhide.option = "unhide"
-
-            row = layout.row(align=True)
-            row.alignment = "CENTER"
-            row.operator("bim.save_selector_query", text="Save Query")
-            op = row.operator("bim.open_query_library", text="Load Query")
-            row.operator("bim.add_to_ifc_group", text="Add to IFC Group")
-
-            row = layout.row(align=True)
-            row.operator("bim.show_scene_elements", text="Show All Elements", icon="HIDE_OFF")
-
-    def draw_query_group_ui(self, ifc_selector, layout):
-        for index, group in enumerate(ifc_selector.groups):
-            row = layout.row()
-            row.alignment = "CENTER"
-            row.label(text="or") if index != 0 else None
-
-            box = layout.box()
-            row = box.row(align=True)
-            row.alignment = "CENTER"
-            row.label(text=f"Group #{str(index+1)}")
-            row.context_pointer_set(name="bim_prop_group", data=group)
-            op = row.operator("bim.edit_blender_collection", text="Add query", icon="PLUS")
-            op.option = "add"
-            op.collection = "queries"
-
-            row.context_pointer_set(name="bim_prop_group", data=ifc_selector)
-            op = row.operator("bim.edit_blender_collection", text="Remove selection group")
-            op.option = "remove"
-            op.collection = "groups"
-            op.index = index
-
-            self.draw_query_ui(self, group, box)
-
-    def draw_query_ui(self, group, box):
-        for index, query in enumerate(group.queries):
-            row = box.row()
-            row.alignment = "LEFT"
-
-            row.prop(query, "and_or", text="") if index != 0 else None
-            if query.and_or == "or":
-                row = box.row()
-                row.alignment = "LEFT"
-            row.prop(query, "selector", text="")
-
-            if query.selector in ["IFC Class", "IfcSpatialElement", "IfcElementType"]:
-                row.label(text="Equals")
-                row.prop_search(query, "active_option", query, "options", text="")
-                row.prop_search(query, "active_sub_option", query, "sub_options", text="") if len(
-                    query.sub_options
-                ) != 0 else None
-                self.draw_filter_ui(self, box, query)
-
-            elif query.selector in ["GlobalId", "Attribute"]:
-                row.prop(query, "negation", text="")
-                row.prop(query, "comparison", text="")
-                row.prop(query, "value", text="")
-
-            row.context_pointer_set(name="bim_prop_group", data=group)
-            op = row.operator("bim.edit_blender_collection", icon="REMOVE", text="")
-            op.option = "remove"
-            op.collection = "queries"
-            op.index = index
-
-            row.context_pointer_set(name="bim_prop_group", data=query)
-            op = (
-                row.operator("bim.edit_blender_collection", text="Add filter")
-                if query.selector == "IFC Class"
-                else None
-            )
-            if op:
-                op.option = "add"
-                op.collection = "filters"
-
-    def draw_filter_ui(self, box, query):
-        for filter_index, f in enumerate(query.filters):
-            row = box.row()
-            row.alignment = "LEFT"
-            row.label(text="  ↪")
-            row.prop(f, "and_or", text="") if filter_index != 0 else None
-            if f.and_or == "or":
-                row = box.row()
-                row.alignment = "LEFT"
-                row.label(text="  ↪")
-            row.prop(f, "selector", text="")
-
-            if f.selector == "Attribute":
-                row.prop_search(f, "active_option", f, "options", text="", results_are_suggestions=True)
-                row.prop(
-                    f,
-                    "negation",
-                )
-                row.prop(f, "comparison", text="")
-                row.prop(f, "value", text="")
-
-            elif f.selector == "IfcPropertySet":
-                row.prop_search(f, "active_option", f, "options", text="")
-                row.prop_search(f, "active_sub_option", f, "sub_options", text="")
-                row.prop(f, "negation")
-                row.prop(f, "comparison", text="")
-                row.prop(f, "value", text="")
-
-            row.context_pointer_set(name="bim_prop_group", data=query)
-            op = row.operator("bim.edit_blender_collection", icon="REMOVE", text="")
-            op.option = "remove"
-            op.collection = "filters"
-            op.index = filter_index

src/blenderbim/blenderbim/bim/module/spatial/workspace.py

@@ -48,6 +48,7 @@ class SpatialTool(WorkSpaceTool):
         ("bim.spatial_hotkey", {"type": "B", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_B")]}),
         ("bim.spatial_hotkey", {"type": "A", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_A")]}),
         ("bim.spatial_hotkey", {"type": "B", "value": "PRESS", "alt": True}, {"properties": [("hotkey", "A_B")]}),
+        ("bim.spatial_hotkey", {"type": "V", "value": "PRESS", "alt": True}, {"properties": [("hotkey", "A_V")]}),
         ("bim.spatial_hotkey", {"type": "T", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_T")]}),
         ("bim.spatial_hotkey", {"type": "G", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_G")]}),
         ("bim.spatial_hotkey", {"type": "H", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_H")]}),
@@ -92,36 +93,34 @@ class SpatialToolUI:
         if context.active_object and context.selected_objects:
             cls.draw_selected_object_interface(context)
 
+        add_layout_hotkey(cls.layout, "Decorate Boundaries", "A_V", bpy.ops.bim.decorate_boundaries.__doc__)
+
     @classmethod
     def draw_default_interface(cls, context):
         row = cls.layout.row(align=True)
         row.prop(data=cls.model_props, property="rl3", text="RL")
         row = cls.layout.row(align=True)
-        row.label(text="", icon="EVENT_SHIFT")
-        row.label(text="", icon="EVENT_A")
-        row.operator("bim.generate_spaces_from_walls")
-        row = cls.layout.row(align=True)
-        row.label(text="", icon="EVENT_SHIFT")
-        row.label(text="", icon="EVENT_A")
-        row.operator("bim.generate_space")
-        row = cls.layout.row(align=True)
-        row.label(text="", icon="EVENT_SHIFT")
-        row.label(text="", icon="EVENT_T")
-        row.operator("bim.toggle_space_visibility")
-        row = cls.layout.row(align=True)
-        row.label(text="", icon="EVENT_SHIFT")
-        row.label(text="", icon="EVENT_H")
-        row.operator("bim.toggle_hide_spaces")
+        op_name = lambda op: op.get_rna_type().name
+        add_layout_hotkey(
+            cls.layout,
+            op_name(bpy.ops.bim.generate_spaces_from_walls),
+            "S_A",
+            bpy.ops.bim.generate_spaces_from_walls.__doc__,
+        )
+        add_layout_hotkey(cls.layout, op_name(bpy.ops.bim.generate_space), "S_A", bpy.ops.bim.generate_space.__doc__)
+        add_layout_hotkey(
+            cls.layout, op_name(bpy.ops.bim.toggle_space_visibility), "S_T", bpy.ops.bim.toggle_space_visibility.__doc__
+        )
+        add_layout_hotkey(
+            cls.layout, op_name(bpy.ops.bim.toggle_hide_spaces), "S_H", bpy.ops.bim.toggle_hide_spaces.__doc__
+        )
 
     @classmethod
     def draw_selected_object_interface(cls, context):
         active_obj = bpy.context.active_object
         element = tool.Ifc.get_entity(active_obj)
         if element and bpy.context.selected_objects and element.is_a("IfcSpace"):
-            row = cls.layout.row(align=True)
-            row.label(text="", icon="EVENT_SHIFT")
-            row.label(text="", icon="EVENT_G")
-            row.operator("bim.generate_space", text="Regen")
+            add_layout_hotkey(cls.layout, "Regen", "S_G", bpy.ops.bim.generate_space.__doc__)
 
         row = cls.layout.row(align=True)
         row.label(text="", icon="EVENT_SHIFT")
@@ -129,7 +128,7 @@ class SpatialToolUI:
         row.prop(cls.model_props, "boundary_class", text="")
         row.operator("bim.add_boundary", text="Add Boundary")
 
-        add_layout_hotkey(cls.layout, "Boundaries", "A_B", "Toggle boundaries")
+        add_layout_hotkey(cls.layout, "Boundaries", "A_B", "Load/unload boundaries on selected objects")
 
     @classmethod
     def draw_type_selection_interface(cls, context):
@@ -175,6 +174,8 @@ class Hotkey(bpy.types.Operator, Operator):
         bpy.ops.bim.add_boundary()
 
     def hotkey_A_B(self):
+        if not AuthoringData.is_loaded:
+            AuthoringData.load()
         if not bpy.context.selected_objects:
             return
         if AuthoringData.data["has_visible_boundaries"]:
@@ -182,6 +183,9 @@ class Hotkey(bpy.types.Operator, Operator):
         else:
             bpy.ops.bim.show_boundaries()
 
+    def hotkey_A_V(self):
+        bpy.ops.bim.decorate_boundaries()
+
     def hotkey_S_T(self):
         bpy.ops.bim.toggle_space_visibility()
 

src/blenderbim/blenderbim/bim/module/structural/operator.py

@@ -473,7 +473,7 @@ class AssignStructuralLoadCase(bpy.types.Operator, tool.Ifc.Operator):
             self.file,
             **{
                 "relating_object": self.file.by_id(self.work_plan),
-                "product": self.file.by_id(self.load_case),
+                "products": [self.file.by_id(self.load_case)],
             },
         )
         return {"FINISHED"}
@@ -492,7 +492,7 @@ class UnassignStructuralLoadCase(bpy.types.Operator, tool.Ifc.Operator):
             self.file,
             **{
                 "relating_object": self.file.by_id(self.work_plan),
-                "product": self.file.by_id(self.load_case),
+                "products": [self.file.by_id(self.load_case)],
             },
         )
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/style/operator.py

@@ -330,16 +330,21 @@ class ActivateExternalStyle(bpy.types.Operator, tool.Ifc.Operator):
         style_path = Path(tool.Ifc.resolve_uri(external_style.Location))
 
         if style_path.suffix != ".blend":
-            self.report({"ERROR"}, f"Error loading external style - only Blender external styles are supported")
+            self.report(
+                {"ERROR"},
+                f"Error loading external style for \"{material.name}\" - only Blender external styles are supported",
+            )
             return {"CANCELLED"}
 
         if not style_path.exists():
-            self.report({"ERROR"}, f"Error loading external style - cannot find file: '{style_path}'")
+            self.report(
+                {"ERROR"}, f"Error loading external style for \"{material.name}\" - cannot find file: '{style_path}'"
+            )
             return {"CANCELLED"}
 
         db = tool.Blender.append_data_block(str(style_path), data_block_type, data_block)
         if not db["data_block"]:
-            self.report({"ERROR"}, f"Error loading external style - {db['msg']}")
+            self.report({"ERROR"}, f"Error loading external style for \"{material.name}\" - {db['msg']}")
             return {"CANCELLED"}
 
         self.copy_material_attributes(db["data_block"], material)

src/blenderbim/blenderbim/bim/module/style/prop.py

@@ -259,7 +259,7 @@ def update_shading_style(self, context):
             try:
                 bpy.ops.bim.activate_external_style(material_name=blender_material.name)
             except RuntimeError as error:
-                if str(error).startswith("Error: Error loading external style - "):
+                if str(error).startswith("Error: Error loading external style for "):
                     return
                 raise error
 

src/blenderbim/blenderbim/bim/module/tester/operator.py

@@ -27,7 +27,7 @@ import ifctester.reporter
 import ifcopenshell
 import blenderbim.tool as tool
 import blenderbim.bim.handler
-from blenderbim.bim.module.tester.data import TesterData
+from pathlib import Path
 
 
 class ExecuteIfcTester(bpy.types.Operator, tool.Ifc.Operator):
@@ -44,7 +44,7 @@ class ExecuteIfcTester(bpy.types.Operator, tool.Ifc.Operator):
 
         with tempfile.TemporaryDirectory() as dirpath:
             start = time.time()
-            output = os.path.join(dirpath, "{}.html".format(props.specs))
+            output = Path(os.path.join(dirpath, "{}.html".format(props.specs)))
 
             filepath = None
             if props.should_load_from_memory and tool.Ifc.get():
@@ -65,8 +65,15 @@ class ExecuteIfcTester(bpy.types.Operator, tool.Ifc.Operator):
             if props.generate_html_report:
                 engine = ifctester.reporter.Html(specs)
                 engine.report()
-                engine.to_file(output)
-                webbrowser.open("file://" + output)
+                output_path = output.as_posix()
+                engine.to_file(output_path)
+                webbrowser.open(f"file://{output_path}")
+
+            if props.generate_ods_report:
+                engine = ifctester.reporter.Ods(specs)
+                engine.report()
+                output_path = output.with_suffix(".ods").as_posix()
+                engine.to_file(output_path)
 
             report = None
             report = ifctester.reporter.Json(specs).report()["specifications"]

src/blenderbim/blenderbim/bim/module/tester/prop.py

@@ -52,6 +52,7 @@ class IfcTesterProperties(PropertyGroup):
     ifc_file: StringProperty(default="", name="IFC File")
     should_load_from_memory: BoolProperty(default=False, name="Load from Memory")
     generate_html_report: BoolProperty(default=False, name="Generate HTML report")
+    generate_ods_report: BoolProperty(default=False, name="Generate ODS report")
     flag: BoolProperty(default=False, name="Flag Failed Entities")
     active_specification_index: IntProperty(name="Active Specification Index", update=update_active_specification_index)
     old_index: IntProperty(name="", default=0)

src/blenderbim/blenderbim/bim/module/tester/ui.py

@@ -44,6 +44,8 @@ class BIM_PT_tester(Panel):
         row = self.layout.row()
         row.prop(props, "generate_html_report")
         row = self.layout.row()
+        row.prop(props, "generate_ods_report")
+        row = self.layout.row()
         row.prop(props, "flag")
 
         if not tool.Ifc.get() or not props.should_load_from_memory:

src/blenderbim/blenderbim/bim/module/type/operator.py

@@ -18,7 +18,9 @@
 
 import bpy
 import bmesh
+import ifcopenshell.util.element
 import ifcopenshell.util.schema
+import ifcopenshell.util.representation
 import ifcopenshell.util.type
 import ifcopenshell.api
 import blenderbim.tool as tool
@@ -76,7 +78,7 @@ class UnassignType(bpy.types.Operator):
             element = tool.Ifc.get_entity(obj)
             if not element or element.is_a("IfcElementType"):
                 continue
-            ifcopenshell.api.run("type.unassign_type", self.file, related_object=element)
+            ifcopenshell.api.run("type.unassign_type", self.file, related_objects=[element])
 
             active_representation = tool.Geometry.get_active_representation(obj)
             active_context = active_representation.ContextOfItems
@@ -171,15 +173,22 @@ class SelectSimilarType(bpy.types.Operator):
     def execute(self, context):
         self.file = IfcStore.get_file()
         objects = bpy.context.selected_objects
+
+        # store relating types to avoid selecting same elements multiple times
+        relating_types = set()
+
         for related_object in objects:
             relating_type = ifcopenshell.util.element.get_type(tool.Ifc.get_entity(related_object))
             if not relating_type:
                 related_object.select_set(False)
                 continue
+            relating_types.add(relating_type)
+
+        for relating_type in relating_types:
             related_objects = ifcopenshell.util.element.get_types(relating_type)
-            for obj in context.visible_objects:
-                element = tool.Ifc.get_entity(obj)
-                if element and element in related_objects:
+            for element in related_objects:
+                obj = tool.Ifc.get_object(element)
+                if obj and obj in context.visible_objects:
                     obj.select_set(True)
         return {"FINISHED"}
 
@@ -274,7 +283,7 @@ class AddType(bpy.types.Operator, tool.Ifc.Operator):
             else:
                 material = self.add_default_material()
             rel = ifcopenshell.api.run(
-                "material.assign_material", ifc_file, product=element, type="IfcMaterialLayerSet"
+                "material.assign_material", ifc_file, products=[element], type="IfcMaterialLayerSet"
             )
             layer_set = rel.RelatingMaterial
             layer = ifcopenshell.api.run("material.add_layer", ifc_file, layer_set=layer_set, material=material)
@@ -352,7 +361,7 @@ class AddType(bpy.types.Operator, tool.Ifc.Operator):
                     )
 
             rel = ifcopenshell.api.run(
-                "material.assign_material", ifc_file, product=element, type="IfcMaterialProfileSet"
+                "material.assign_material", ifc_file, products=[element], type="IfcMaterialProfileSet"
             )
             profile_set = rel.RelatingMaterial
             material_profile = ifcopenshell.api.run(

src/blenderbim/blenderbim/bim/operator.py

@@ -357,7 +357,7 @@ class OpenUpstream(bpy.types.Operator):
         if self.page == "home":
             webbrowser.open("https://blenderbim.org/")
         elif self.page == "docs":
-            webbrowser.open("https://blenderbim.org/docs/")
+            webbrowser.open("https://docs.blenderbim.org/")
         elif self.page == "wiki":
             webbrowser.open("https://wiki.osarch.org/index.php?title=Category:BlenderBIM_Add-on")
         elif self.page == "community":
@@ -936,6 +936,31 @@ class BIM_OT_enum_property_search(bpy.types.Operator):
                         )
 
 
+class BIM_OT_select_object(bpy.types.Operator):
+    bl_idname = "bim.select_object"
+    bl_label = "Select Object"
+    bl_options = {"REGISTER", "UNDO"}
+    obj_name: bpy.props.StringProperty(description="Object Name To Select")
+
+    def execute(self, context):
+        obj = bpy.data.objects[self.obj_name]
+        tool.Blender.set_objects_selection(context, obj, [obj], clear_previous_selection=True)
+        return {"FINISHED"}
+
+
+class BIM_OT_delete_object(bpy.types.Operator):
+    bl_idname = "bim.delete_object"
+    bl_label = "Delete Object"
+    bl_options = {"REGISTER", "UNDO"}
+    obj_name: bpy.props.StringProperty(description="Object Name To Delete")
+
+    def execute(self, context):
+        obj = bpy.data.objects[self.obj_name]
+        with context.temp_override(selected_objects=[obj], active_object=obj):
+            bpy.ops.bim.override_object_delete(is_batch=False)
+        return {"FINISHED"}
+
+
 class EditBlenderCollection(bpy.types.Operator):
     bl_idname = "bim.edit_blender_collection"
     bl_label = "Add or Remove Blender Collection Item"

src/blenderbim/blenderbim/bim/prop.py

@@ -273,6 +273,8 @@ class Attribute(PropertyGroup):
     def get_value(self):
         if self.is_optional and self.is_null:
             return None
+        if self.data_type == "string":
+            return self.string_value.replace("\\n", "\n")
         return getattr(self, str(self.get_value_name()), None)
 
     def get_value_default(self):

src/blenderbim/blenderbim/bim/ui.py

@@ -127,6 +127,42 @@ class BIM_PT_section_with_cappings(Panel):
         row.operator("bim.clipping_plane_cut_with_cappings", icon="XRAY", text="Cut")
         row.operator("bim.revert_clipping_plane_cut", icon="FILE_REFRESH", text="Revert Cut")
 
+        props = context.scene.BIMProjectProperties
+        box = layout.box()
+        header = box.row(align=True)
+        header.label(text="Clipping Planes")
+        header.operator("bim.save_clipping_planes", text="", icon="EXPORT")
+        header.operator("bim.load_clipping_planes", text="", icon="IMPORT")
+        header.operator("bim.create_clipping_plane", text="", icon="ADD")
+
+        box.template_list(
+            "BIM_UL_clipping_plane",
+            "",
+            props,
+            "clipping_planes",
+            props,
+            "clipping_planes_active",
+        )
+
+        if props.clipping_planes_active < len(props.clipping_planes):
+            active_clipping_plane_obj = props.clipping_planes[props.clipping_planes_active].obj
+            box.prop(active_clipping_plane_obj, "location")
+            box.prop(active_clipping_plane_obj, "rotation_euler")
+
+
+class BIM_UL_clipping_plane(bpy.types.UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
+        if item and item.obj:
+            obj = item.obj
+            row = layout.row(align=True)
+            row.prop(obj, "name", text="", emboss=False)
+            row.operator("bim.select_object", text="", icon="RESTRICT_SELECT_OFF").obj_name = obj.name
+            row.context_pointer_set("active_object", obj)
+            row.operator("bim.flip_clipping_plane", text="", icon="PASTEFLIPDOWN")
+            row.operator("bim.delete_object", text="", icon="TRASH").obj_name = obj.name
+        else:
+            layout.label(text="", translate=False)
+
 
 class BIM_UL_generic(bpy.types.UIList):
     def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
@@ -168,6 +204,7 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         name="Should Make A Cha-Ching Sound When Project Costs Updates", default=False
     )
     lock_grids_on_import: BoolProperty(name="Should Lock Grids By Default", default=True)
+    spatial_elements_unselectable: BoolProperty(name="Should Make Spatial Elements Unselectable By Default", default=True)
     decorations_colour: bpy.props.FloatVectorProperty(
         name="Decorations Colour", subtype="COLOR", default=(1, 1, 1, 1), min=0.0, max=1.0, size=4
     )
@@ -249,6 +286,10 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         row.prop(self, "should_play_chaching_sound")
         row = layout.row()
         row.prop(self, "lock_grids_on_import")
+        row = layout.row()
+        row.prop(self, "spatial_elements_unselectable")
+
+
 
         row = layout.row()
         row.prop(context.scene.BIMProjectProperties, "should_disable_undo_on_save")
@@ -432,7 +473,7 @@ class BIM_PT_tab_grouping_and_filtering(Panel):
     bl_space_type = "PROPERTIES"
     bl_region_type = "WINDOW"
     bl_context = "scene"
-    bl_options = {"DEFAULT_CLOSED"}
+    bl_options = {"DEFAULT_CLOSED","HEADER_LAYOUT_EXPAND"}
 
     @classmethod
     def poll(cls, context):
@@ -441,6 +482,13 @@ class BIM_PT_tab_grouping_and_filtering(Panel):
     def draw(self, context):
         pass
 
+    def draw_header(self, context):
+        # Draws help button on the right
+        row = self.layout.row(align=True)
+        row.label(text="")  # empty text occupies the left of the row
+        row.operator("bim.open_uri", text="", icon="HELP").uri = \
+            "https://docs.ifcopenshell.org/ifcopenshell-python/selector_syntax.html"
+
 
 class BIM_PT_tab_geometry(Panel):
     bl_label = "Geometry"

src/blenderbim/blenderbim/core/aggregate.py

@@ -29,7 +29,7 @@ def assign_object(ifc, aggregator, collector, relating_obj=None, related_obj=Non
     if not aggregator.can_aggregate(relating_obj, related_obj):
         return
     rel = ifc.run(
-        "aggregate.assign_object", product=ifc.get_entity(related_obj), relating_object=ifc.get_entity(relating_obj)
+        "aggregate.assign_object", products=[ifc.get_entity(related_obj)], relating_object=ifc.get_entity(relating_obj)
     )
     collector.assign(relating_obj)
     collector.assign(related_obj)
@@ -45,9 +45,9 @@ def unassign_object(ifc, aggregate, collector, relating_obj=None, related_obj=No
         if related_element:
             relating_obj = ifc.get_object(relating_element)
     if relating_obj:
-        ifc.run("aggregate.unassign_object", product=related_element)
+        ifc.run("aggregate.unassign_object", products=[related_element])
         if container:
-            ifc.run("spatial.assign_container", product=related_element, relating_structure=container)
+            ifc.run("spatial.assign_container", products=[related_element], relating_structure=container)
         collector.assign(relating_obj)
         collector.assign(related_obj)
 

src/blenderbim/blenderbim/core/brick.py

@@ -74,7 +74,7 @@ def assign_brick_reference(ifc, brick, element=None, library=None, brick_uri=Non
     if not reference:
         reference = ifc.run("library.add_reference", library=library)
         ifc.run("library.edit_reference", reference=reference, attributes=brick.export_brick_attributes(brick_uri))
-    ifc.run("library.assign_reference", product=element, reference=reference)
+    ifc.run("library.assign_reference", products=[element], reference=reference)
     project = brick.get_brickifc_project()
     if not project:
         project = brick.add_brickifc_project(brick.get_namespace(brick_uri))

src/blenderbim/blenderbim/core/covering.py

@@ -47,7 +47,6 @@ def add_instance_flooring_covering_from_cursor(ifc, spatial, model, Type, geomet
     obj = spatial.get_named_obj_from_mesh(name, mesh)
 
     spatial.set_obj_origin_to_cursor_position(obj)
-#    spatial.traslate_obj_to_z_location(obj, z)
     spatial.link_obj_to_active_collection(obj)
     points = spatial.get_2d_vertices_from_obj(obj)
     points = spatial.get_scaled_2d_vertices(points)
@@ -153,7 +152,7 @@ def add_instance_flooring_coverings_from_walls(ifc, spatial, collector, geometry
         spatial.regen_obj_representation(ifc, geometry, obj, body)
 
 def add_instance_ceiling_coverings_from_walls(ifc, spatial, collector, geometry, covering):
-    z = covering.get_z_from_ceiling_height()
+    z = covering.get_z_from_ceiling_height() + spatial.get_active_obj_z()
     union = spatial.get_union_shape_from_selected_objects()
     for i, linear_ring in enumerate(union.interiors):
         poly = spatial.get_buffered_poly_from_linear_ring(linear_ring)

src/blenderbim/blenderbim/core/document.py

@@ -109,8 +109,8 @@ def remove_document(ifc, document_tool, document=None):
 
 
 def assign_document(ifc, product=None, document=None):
-    ifc.run("document.assign_document", product=product, document=document)
+    ifc.run("document.assign_document", products=[product], document=document)
 
 
 def unassign_document(ifc, product=None, document=None):
-    ifc.run("document.unassign_document", product=product, document=document)
+    ifc.run("document.unassign_document", products=[product], document=document)

src/blenderbim/blenderbim/core/drawing.py

@@ -241,7 +241,7 @@ def add_drawing(ifc, collector, drawing, target_view=None, location_hint=None):
         attributes = {"Identification": "X", "Name": drawing_name, "Scope": "DRAWING"}
     ifc.run("document.edit_information", information=information, attributes=attributes)
     ifc.run("document.edit_reference", reference=reference, attributes={"Location": uri})
-    ifc.run("document.assign_document", product=element, document=reference)
+    ifc.run("document.assign_document", products=[element], document=reference)
     drawing.import_drawings()
 
 
@@ -251,7 +251,7 @@ def duplicate_drawing(ifc, drawing_tool, drawing=None, should_duplicate_annotati
     drawing_tool.copy_representation(drawing, new_drawing)
     drawing_tool.set_name(new_drawing, drawing_name)
     group = drawing_tool.get_drawing_group(new_drawing)
-    ifc.run("group.unassign_group", group=group, product=new_drawing)
+    ifc.run("group.unassign_group", group=group, products=[new_drawing])
     new_group = ifc.run("group.add_group")
     ifc.run("group.edit_group", group=new_group, attributes={"Name": drawing_name, "ObjectType": "DRAWING"})
     ifc.run("group.assign_group", group=new_group, products=[new_drawing])
@@ -261,11 +261,11 @@ def duplicate_drawing(ifc, drawing_tool, drawing=None, should_duplicate_annotati
                 continue
             new_annotation = ifc.run("root.copy_class", product=annotation)
             drawing_tool.copy_representation(annotation, new_annotation)
-            ifc.run("group.unassign_group", group=group, product=new_annotation)
+            ifc.run("group.unassign_group", group=group, products=[new_annotation])
             ifc.run("group.assign_group", group=new_group, products=[new_annotation])
 
     old_reference = drawing_tool.get_drawing_document(new_drawing)
-    ifc.run("document.unassign_document", product=new_drawing, document=old_reference)
+    ifc.run("document.unassign_document", products=[new_drawing], document=old_reference)
 
     information = ifc.run("document.add_information")
     uri = drawing_tool.get_default_drawing_path(drawing_name)
@@ -276,7 +276,7 @@ def duplicate_drawing(ifc, drawing_tool, drawing=None, should_duplicate_annotati
         attributes = {"Identification": "X", "Name": drawing_name, "Scope": "DRAWING"}
     ifc.run("document.edit_information", information=information, attributes=attributes)
     ifc.run("document.edit_reference", reference=reference, attributes={"Location": uri})
-    ifc.run("document.assign_document", product=new_drawing, document=reference)
+    ifc.run("document.assign_document", products=[new_drawing], document=reference)
 
     drawing_tool.import_drawings()
     return new_drawing
@@ -388,13 +388,13 @@ def sync_references(ifc, collector, drawing_tool, drawing=None):
         should_delete_existing_annotation = False
         should_create_annotation = False
 
+        # remove annotation only if the reference object was changed
+        # otherwise we rely on the existing annotation
         if annotation:
             if reference_obj and (ifc.is_moved(reference_obj) or ifc.is_edited(reference_obj)):
                 should_delete_existing_annotation = True
-            elif not reference_obj:
-                should_delete_existing_annotation = True
 
-        if reference_obj and (should_delete_existing_annotation or not annotation):
+        if should_delete_existing_annotation or not annotation:
             should_create_annotation = True
 
         if should_delete_existing_annotation:

src/blenderbim/blenderbim/core/geometry.py

@@ -16,10 +16,17 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
-import blenderbim.core.style
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+import blenderbim.core.tool as tool
+
+if TYPE_CHECKING:
+    import bpy
 
 
-def edit_object_placement(ifc, geometry, surveyor, obj=None):
+def edit_object_placement(
+    ifc: tool.Ifc, geometry: tool.Geometry, surveyor: tool.Surveyor, obj: Optional[bpy.types.Object] = None
+) -> None:
     element = ifc.get_entity(obj)
     if not element:
         return
@@ -192,23 +199,25 @@ def select_connection(geometry, connection=None):
 def remove_connection(geometry, connection=None):
     geometry.remove_connection(connection)
 
+
 def get_similar_openings(ifc, opening):
     model = ifc.get()
     all_openings = model.by_type("IfcOpeningElement")
     similar_openings = [o for o in all_openings if o.ObjectPlacement == opening.ObjectPlacement and o != opening]
     return similar_openings
 
+
 def get_similar_openings_building_objs(ifc, similar_openings):
     building_objs = []
     for similar_opening in similar_openings:
         building_objs.append(ifc.get_object(similar_opening.VoidsElements[0].RelatingBuildingElement))
     return building_objs
 
-def edit_similar_opening_placement(geometry, opening = None, similar_openings = None):
+
+def edit_similar_opening_placement(geometry, opening=None, similar_openings=None):
     if not opening or not similar_openings:
         return
     for similar_opening in similar_openings:
         old_placement = similar_opening.ObjectPlacement
         similar_opening.ObjectPlacement = opening.ObjectPlacement
         geometry.delete_opening_object_placement(old_placement)
-

src/blenderbim/blenderbim/core/library.py

@@ -83,8 +83,8 @@ def edit_library_reference(ifc, library):
 
 
 def assign_library_reference(ifc, obj=None, reference=None):
-    ifc.run("library.assign_reference", product=ifc.get_entity(obj), reference=reference)
+    ifc.run("library.assign_reference", products=[ifc.get_entity(obj)], reference=reference)
 
 
 def unassign_library_reference(ifc, obj=None, reference=None):
-    ifc.run("library.unassign_reference", product=ifc.get_entity(obj), reference=reference)
+    ifc.run("library.unassign_reference", products=[ifc.get_entity(obj)], reference=reference)

src/blenderbim/blenderbim/core/material.py

@@ -102,7 +102,7 @@ def assign_material(ifc, material_tool, material_type, objects):
         element = ifc.get_entity(obj)
         if not element:
             continue
-        ifc.run("material.assign_material", product=element, type=material_type, material=material)
+        ifc.run("material.assign_material", products=[element], type=material_type, material=material)
         assigned_material = material_tool.get_material(element)
         if material_tool.is_a_material_set(assigned_material):
             material_tool.add_material_to_set(material_set=assigned_material, material=material)
@@ -116,12 +116,12 @@ def unassign_material(ifc, material_tool, objects):
             inherited_material = material_tool.get_material(element, should_inherit=True)
             if material and "Usage" in material.is_a():
                 element_type = material_tool.get_type(element)
-                ifc.run("material.unassign_material", product=element_type)
+                ifc.run("material.unassign_material", products=[element_type])
             elif not material and inherited_material:
                 element_type = material_tool.get_type(element)
-                ifc.run("material.unassign_material", product=element_type)
+                ifc.run("material.unassign_material", products=[element_type])
             elif material:
-                ifc.run("material.unassign_material", product=element)
+                ifc.run("material.unassign_material", products=[element])
 
 
 def patch_non_parametric_mep_segment(ifc, material_tool, profile_tool, obj):