refactor: generalize layer set class and method names

Rename wall/slab-specific identifiers to layer-direction-neutral equivalents:

- DumbWallPlaner → Layer2Planer
- DumbSlabPlaner → Layer3Planer
- recalculate_walls() → recalculate_layer2_elements()
- regenerate_slab() → regenerate_layer3_element()
- wall_objs → axis2_objs (material/operator.py)

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

@@ -386,8 +386,8 @@ class AddLayer(bpy.types.Operator, tool.Ifc.Operator):
             layer_set=layer_set,
             material=tool.Ifc.get().by_id(int(omprops.material)),
         )
-        slab.DumbSlabPlaner().regenerate_from_layer_set(layer_set)
+        slab.Layer3Planer().regenerate_from_layer_set(layer_set)
-        wall.DumbWallPlaner().regenerate_from_layer_set(layer_set)
+        wall.Layer2Planer().regenerate_from_layer_set(layer_set)
 
 
 class ReorderMaterialSetItem(bpy.types.Operator, tool.Ifc.Operator):
@@ -425,8 +425,8 @@ class RemoveLayer(bpy.types.Operator, tool.Ifc.Operator):
                 return {"CANCELLED"}
         ifcopenshell.api.material.remove_layer(tool.Ifc.get(), layer=layer)
         for material_set in material_sets:
-            slab.DumbSlabPlaner().regenerate_from_layer_set(material_set)
+            slab.Layer3Planer().regenerate_from_layer_set(material_set)
-            wall.DumbWallPlaner().regenerate_from_layer_set(material_set)
+            wall.Layer2Planer().regenerate_from_layer_set(material_set)
 
 
 class DuplicateLayer(bpy.types.Operator, tool.Ifc.Operator):
@@ -615,8 +615,8 @@ class EditAssignedMaterial(bpy.types.Operator, tool.Ifc.Operator):
                     attributes=attributes,
                 )
 
-                slab_planer = slab.DumbSlabPlaner()
+                slab_planer = slab.Layer3Planer()
-                wall_objs = []
+                axis2_objs = []
 
                 for obj in objects:
                     obj_element = tool.Ifc.get_entity(obj)
@@ -634,10 +634,10 @@ class EditAssignedMaterial(bpy.types.Operator, tool.Ifc.Operator):
                         if obj_material_usage.LayerSetDirection == "AXIS3":
                             slab_planer.regenerate_from_occurence(obj_element, obj_material_usage)
                         elif obj_material_usage.LayerSetDirection == "AXIS2":
-                            wall_objs.append(obj)
+                            axis2_objs.append(obj)
 
-                if wall_objs:
+                if axis2_objs:
-                    tool.Model.recalculate_walls(wall_objs)
+                    tool.Model.recalculate_layer2_elements(axis2_objs)
 
             if material_set_usage.is_a("IfcMaterialProfileSetUsage"):
                 if "CardinalPoint" in attributes:
@@ -785,8 +785,8 @@ class EditMaterialSetItem(bpy.types.Operator, tool.Ifc.Operator):
                 attributes=attributes,
                 material=self.file.by_id(int(props.material_set_item_material)),
             )
-            slab.DumbSlabPlaner().regenerate_from_layer(layer)
+            slab.Layer3Planer().regenerate_from_layer(layer)
-            wall.DumbWallPlaner().regenerate_from_layer(layer)
+            wall.Layer2Planer().regenerate_from_layer(layer)
         elif material.is_a("IfcMaterialProfileSet"):
             profile_def = None
             if mprops.profiles:

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

@@ -948,7 +948,7 @@ class Rotate90(bpy.types.Operator, tool.Ifc.Operator):
             obj.matrix_world @= rotate_matrix
         bpy.context.view_layer.update()
         DumbProfileRecalculator().recalculate(profile_objs)
-        tool.Model.recalculate_walls(layer2_objs)
+        tool.Model.recalculate_layer2_elements(layer2_objs)
         return {"FINISHED"}
 
 

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

@@ -199,7 +199,7 @@ class DumbSlabGenerator:
         return obj
 
 
-class DumbSlabPlaner:
+class Layer3Planer:
     def regenerate_from_layer_set_usage(self, usecase_path, ifc_file, settings):
         self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
         obj = bpy.context.active_object
@@ -901,7 +901,7 @@ class DrawPolylineSlab(bpy.types.Operator, PolylineOperator, tool.Ifc.Operator):
             usage=material_set_usage,
             attributes=attributes,
         )
-        DumbSlabPlaner().regenerate_from_occurence(element, material_set_usage)
+        Layer3Planer().regenerate_from_occurence(element, material_set_usage)
 
     def modal(self, context, event):
         return IfcStore.execute_ifc_operator(self, context, event, method="MODAL")
@@ -1003,5 +1003,5 @@ class RecalculateSlab(bpy.types.Operator, tool.Ifc.Operator):
                     if rel.is_a() == "IfcRelConnectsElements" and rel.RelatedElement.is_a("IfcWall"):
                         walls.append(tool.Ifc.get_object(rel.RelatedElement))
 
-        tool.Model.recalculate_walls(walls)
+        tool.Model.recalculate_layer2_elements(walls)
         return {"FINISHED"}

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

@@ -372,7 +372,7 @@ class RecalculateWall(bpy.types.Operator, tool.Ifc.Operator):
 
     def _execute(self, context):
         objects = tool.Model.get_selected_mesh_ifc_objects()
-        tool.Model.recalculate_walls(objects)
+        tool.Model.recalculate_layer2_elements(objects)
         return {"FINISHED"}
 
 
@@ -420,7 +420,7 @@ class ChangeExtrusionDepth(bpy.types.Operator, tool.Ifc.Operator):
                 layer2_objs.append(obj)
 
         if layer2_objs:
-            tool.Model.recalculate_walls(layer2_objs)
+            tool.Model.recalculate_layer2_elements(layer2_objs)
         return {"FINISHED"}
 
 
@@ -529,7 +529,7 @@ class ChangeExtrusionXAngle(bpy.types.Operator, tool.Ifc.Operator):
                 obj.rotation_euler.z = current_z_rot
 
         if layer2_objs:
-            tool.Model.recalculate_walls(layer2_objs)
+            tool.Model.recalculate_layer2_elements(layer2_objs)
         return {"FINISHED"}
 
 
@@ -641,7 +641,7 @@ class DrawPolylineWall(bpy.types.Operator, PolylineOperator, tool.Ifc.Operator):
             # if material.is_a("IfcMaterialLayerSetUsage"):
             attributes = {"OffsetFromReferenceLine": offset, "DirectionSense": direction_sense}
             ifcopenshell.api.material.edit_layer_usage(model, usage=material_set_usage, attributes=attributes)
-            tool.Model.recalculate_walls([wall["obj"]])
+            tool.Model.recalculate_layer2_elements([wall["obj"]])
 
         if walls:
             if is_polyline_closed:
@@ -1034,7 +1034,7 @@ class DumbWallGenerator:
         return next(c for c in classes if "StandardCase" not in c)
 
 
-class DumbWallPlaner:
+class Layer2Planer:
     def regenerate_from_layer(self, layer: ifcopenshell.entity_instance) -> None:
         for layer_set in layer.ToMaterialLayerSet:
             self.regenerate_from_layer_set(layer_set)
@@ -1055,7 +1055,7 @@ class DumbWallPlaner:
             else:
                 for rel in inverse.AssociatedTo:
                     walls.extend([tool.Ifc.get_object(e) for e in rel.RelatedObjects])
-        tool.Model.recalculate_walls([w for w in set(walls) if w])
+        tool.Model.recalculate_layer2_elements([w for w in set(walls) if w])
 
 
 class DumbWallJoiner:

src/bonsai/bonsai/core/model.py

@@ -99,7 +99,7 @@ def offset_walls(ifc: type[tool.Ifc], blender: type[tool.Blender], model: type[t
     ]
     for obj in objs:
         model.offset_wall(obj, offset_type)
-    model.recalculate_walls(objs)
+    model.recalculate_layer2_elements(objs)
 
 
 def align_walls(

src/bonsai/bonsai/core/type.py

@@ -44,9 +44,9 @@ def assign_type(
     if (usage := model.get_usage_type(type)) == "PROFILE":
         model.regenerate_profile(obj)
     elif usage == "LAYER2":
-        model.recalculate_walls([obj])
+        model.recalculate_layer2_elements([obj])
     elif usage == "LAYER3":
-        model.regenerate_slab(obj)
+        model.regenerate_layer3_element(obj)
     else:
         type_data = type_tool.get_object_data(ifc.get_object(type))
         if type_data:

src/bonsai/bonsai/tool/model.py

@@ -2717,41 +2717,41 @@ class Model(bonsai.core.tool.Model):
         tool.Geometry.record_object_position(obj)
 
     @classmethod
-    def recalculate_walls(cls, walls: list[bpy.types.Object]) -> None:
+    def recalculate_layer2_elements(cls, objs: list[bpy.types.Object]) -> None:
         queue: set[tuple[ifcopenshell.entity_instance, bpy.types.Object]] = set()
-        for wall in walls:
+        for obj in objs:
-            element = tool.Ifc.get_entity(wall)
+            element = tool.Ifc.get_entity(obj)
-            if tool.Ifc.is_moved(wall):
+            if tool.Ifc.is_moved(obj):
-                bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=wall)
+                bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
-            queue.add((element, wall))
+            queue.add((element, obj))
             for rel in getattr(element, "ConnectedTo", []):
-                obj = tool.Ifc.get_object(rel.RelatedElement)
+                connected_obj = tool.Ifc.get_object(rel.RelatedElement)
-                if tool.Ifc.is_moved(obj):
+                if tool.Ifc.is_moved(connected_obj):
-                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
+                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=connected_obj)
-                queue.add((rel.RelatedElement, obj))
+                queue.add((rel.RelatedElement, connected_obj))
             for rel in getattr(element, "ConnectedFrom", []):
-                obj = tool.Ifc.get_object(rel.RelatingElement)
+                connected_obj = tool.Ifc.get_object(rel.RelatingElement)
-                if tool.Ifc.is_moved(obj):
+                if tool.Ifc.is_moved(connected_obj):
-                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
+                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=connected_obj)
-                queue.add((rel.RelatingElement, obj))
+                queue.add((rel.RelatingElement, connected_obj))
-        for element, wall in queue:
+        for element, obj in queue:
-            if tool.Model.get_usage_type(element) == "LAYER2" and wall:
+            if tool.Model.get_usage_type(element) == "LAYER2" and obj:
                 # Use layer custom offset
-                custom_offset = tool.Model.get_material_layer_custom_offset(element, wall)
+                custom_offset = tool.Model.get_material_layer_custom_offset(element, obj)
                 material = ifcopenshell.util.element.get_material(element)
                 if material.is_a("IfcMaterialLayerSetUsage") and custom_offset is not None:
                     material.OffsetFromReferenceLine = custom_offset
 
-                cls.recreate_wall(element, wall)
+                cls.recreate_wall(element, obj)
 
     @classmethod
-    def regenerate_slab(cls, obj: bpy.types.Object) -> None:
+    def regenerate_layer3_element(cls, obj: bpy.types.Object) -> None:
-        from bonsai.bim.module.model.slab import DumbSlabPlaner
+        from bonsai.bim.module.model.slab import Layer3Planer
 
         element = tool.Ifc.get_entity(obj)
         material_set = ifcopenshell.util.element.get_material(element, should_skip_usage=True)
         new_thickness = sum([l.LayerThickness for l in material_set.MaterialLayers])
-        DumbSlabPlaner().change_thickness(element, new_thickness)
+        Layer3Planer().change_thickness(element, new_thickness)
 
     @classmethod
     def regenerate_profile(cls, obj: bpy.types.Object) -> None: