From 49348908e6cbd979517fe46ac1466ee117c28443 Mon Sep 17 00:00:00 2001 From: Gorgious56 Date: Thu, 28 May 2026 16:42:42 +0200 Subject: [PATCH] Add wall-fillet helper functions + recreate_wall hook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Eleven module-level helpers in wall.py that the upcoming wall-fillet operators + gizmo groups depend on. Each is self-contained or references only helpers earlier in the file; the operators and gizmos themselves land in follow-up commits. * _wall_fillet_props / _wall_fillet_preview_active / _wall_fillet_preview_walls: thin read-side accessors over the BIMPreviewProperties.wall_fillet pointer (added with the operators commit). Safe today: get_preview_props returns None until the pointer is attached. * _walls_have_zero_slope_for_fillet: validates that input walls are vertical (x_angle ~ 0); slanted-extrusion fillets require swept-along-curve geometry the banana profile builder doesn't support. * _build_curved_corner_body_representation: builds the banana (annular sector) IfcExtrudedAreaSolid as a polyline-tessellated IfcIndexedPolyCurve. * _apply_fillet_corner_geometry: positions the corner wall at tangent_a and rebuilds its body. Shared by the creation operator and the regenerate path. * _resolve_two_walls: pulls (active, other) from a 2-wall selection, validates both as LAYER2 + straight-axis + not-already- a-fillet-corner. * _pick_dominant_wall_material: returns the thickest layer's material from an element's IfcMaterialLayerSet / Usage. * regenerate_fillet_corner_wall: re-runs the geometry build from BBIM_Wall.FilletRadius + current neighbour layer parameters. Called by tool.Model.recreate_wall when the IsFilletCorner pset is set; the FIXME(PR4) placeholder in recreate_wall is dropped. * _wall_fillet_gizmo_x_matrix: 4x4 placement matrix with local +X aligned to a world-space direction; used by the fillet preview gizmo group. Centralises the IsFilletCorner pset read as tool.Parametric.is_fillet_corner_wall — replaces 3 inline get_pset(element, "BBIM_Wall", "IsFilletCorner") sites (tool.Model.recreate_wall, tool.Model.recalculate_walls, tool.Parametric.is_path_connectable_wall) plus the new _resolve_two_walls call. Generated with the assistance of an AI coding tool. --- src/bonsai/bonsai/bim/module/model/wall.py | 328 +++++++++++++++++++++ src/bonsai/bonsai/tool/model.py | 20 +- src/bonsai/bonsai/tool/parametric.py | 7 + 3 files changed, 350 insertions(+), 5 deletions(-) diff --git a/src/bonsai/bonsai/bim/module/model/wall.py b/src/bonsai/bonsai/bim/module/model/wall.py index 63358b4eb7..bda794547c 100644 --- a/src/bonsai/bonsai/bim/module/model/wall.py +++ b/src/bonsai/bonsai/bim/module/model/wall.py @@ -54,6 +54,7 @@ import bonsai.tool as tool from bonsai.bim.ifc import IfcStore from bonsai.bim.module.drawing import gizmos as gizmo from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig +from bonsai.bim.module.model import preview_base from bonsai.bim.module.model.decorator import PolylineDecorator, ProductDecorator from bonsai.bim.module.model.polyline import PolylineOperator @@ -2557,6 +2558,333 @@ def _iter_path_connections( return out +def _wall_fillet_props(context: bpy.types.Context): + return preview_base.get_preview_props(context, "wall_fillet") + + +def _wall_fillet_preview_active(context: bpy.types.Context) -> bool: + """``True`` while a wall-fillet preview is open.""" + return preview_base.is_preview_active(context, "wall_fillet") + + +_FILLET_SLOPE_TOLERANCE_RAD = 1e-4 + + +def _walls_have_zero_slope_for_fillet(operator: bpy.types.Operator, *walls: bpy.types.Object) -> bool: + """``True`` iff every input wall is vertical (``x_angle`` ~ 0). Reports an + ERROR on the operator and returns ``False`` otherwise. Slanted-extrusion + fillets require swept-along-curve geometry that the banana profile builder + isn't designed for — block the entry points so the user sees a clear + explanation instead of malformed corner geometry.""" + for wall in walls: + if wall is None: + continue + element = tool.Ifc.get_entity(wall) + if element is None: + continue + x_angle = tool.Wall.get_x_angle(element) + if x_angle is None: + continue + if abs(x_angle) > _FILLET_SLOPE_TOLERANCE_RAD: + operator.report( + {"ERROR"}, + "Wall fillet is not supported for slanted walls (non-zero slope). " + "Reset the wall's slope to vertical and try again.", + ) + return False + return True + + +def _build_curved_corner_body_representation( + ifc_file: ifcopenshell.file, + body_context: ifcopenshell.entity_instance, + arc_center_local: tuple[float, float, float], + chord_length_si: float, + radius_si: float, + r_outer_si: float, + r_inner_si: float, + height_si: float, +) -> ifcopenshell.entity_instance: + """Build an ``IfcShapeRepresentation`` with a banana (annular sector) + ``IfcExtrudedAreaSolid``. + + Local frame: origin at ``tangent_a``, +X along the chord to ``tangent_b``, + +Z vertical. ``r_outer_si`` / ``r_inner_si`` come from wall A's + ``IfcMaterialLayerSetUsage`` so the cross-section matches A at + ``tangent_a`` rather than centring on the reference arc.""" + unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file) + + cx_si, cy_si, _ = arc_center_local + dir_a = (-cx_si / radius_si, -cy_si / radius_si) + dir_b = ((chord_length_si - cx_si) / radius_si, -cy_si / radius_si) + + # Tessellate the banana profile as an IfcIndexedPolyCurve of straight + # IfcLineIndex segments rather than analytical trimmed-circle arcs: + # IfcOpenShell's geometry kernel and tool.Model.import_profile's edit-mode + # importer both handle polyline segments unconditionally; trimmed-circle + # alternatives fall through both paths to a coarse fallback or a hard error. + # 24 chord segments per arc is visually smooth and round-trip-stable. + arc_resolution = 24 + cross_z = dir_a[0] * dir_b[1] - dir_a[1] * dir_b[0] + theta_a = math.atan2(dir_a[1], dir_a[0]) + theta_b = math.atan2(dir_b[1], dir_b[0]) + # Take the SHORT angular sweep from theta_a to theta_b. CCW (positive + # signed cross product) means walking in increasing-theta direction. + sweep = theta_b - theta_a + if cross_z >= 0: + if sweep < 0: + sweep += 2 * math.pi + else: + if sweep > 0: + sweep -= 2 * math.pi + + def _arc_points(radius: float) -> list[tuple[float, float]]: + out = [] + for i in range(arc_resolution + 1): + theta = theta_a + sweep * (i / arc_resolution) + out.append((cx_si + radius * math.cos(theta), cy_si + radius * math.sin(theta))) + return out + + # Closed loop in counter-clockwise order: outer arc, radial step to inner + # arc, inner arc walked backwards, radial step back to outer start. The + # outer-to-inner and inner-to-outer steps are pure radial lines because + # the arcs share their endpoint angles. + outer_points = _arc_points(r_outer_si) + inner_points_reversed = list(reversed(_arc_points(r_inner_si))) + raw_points = outer_points + inner_points_reversed + points_ifc = [(x / unit_scale, y / unit_scale) for x, y in raw_points] + + point_list = ifc_file.createIfcCartesianPointList2D(points_ifc) + # Indices are 1-based per IFC schema. The curve auto-closes by referencing + # the first point as the next-segment start; the explicit closing segment + # survives writers that don't honour implicit close. + n = len(points_ifc) + segments = [ifc_file.createIfcLineIndex((i + 1, ((i + 1) % n) + 1)) for i in range(n)] + curve = ifc_file.createIfcIndexedPolyCurve(point_list, segments, False) + profile = ifc_file.createIfcArbitraryClosedProfileDef("AREA", None, curve) + + extrusion = ifc_file.createIfcExtrudedAreaSolid( + profile, + ifc_file.createIfcAxis2Placement3D( + ifc_file.createIfcCartesianPoint((0.0, 0.0, 0.0)), + ifc_file.createIfcDirection((0.0, 0.0, 1.0)), + ifc_file.createIfcDirection((1.0, 0.0, 0.0)), + ), + ifc_file.createIfcDirection((0.0, 0.0, 1.0)), + height_si / unit_scale, + ) + return ifc_file.createIfcShapeRepresentation( + body_context, body_context.ContextIdentifier, "SweptSolid", [extrusion] + ) + + +def _apply_fillet_corner_geometry( + ifc_file: ifcopenshell.file, + corner_obj: bpy.types.Object, + geom: dict, + wall_a_obj: bpy.types.Object, +) -> tuple[Vector, Vector, Vector, float] | None: + """Position the corner wall at ``tangent_a`` and rebuild its banana body + from ``geom``. Shared by the creation and regenerate paths so a + neighbour-driven recalc matches creation-time output even when wall A's + layer set has been edited since. + + Returns ``(x_dir, y_dir, z_dir, chord_length_si)`` on success or ``None`` + on degenerate chord / missing Body context. All probes run before any + mutation, so failures leave the corner wall untouched.""" + tangent_a = Vector(geom["tangent_a"]) + tangent_b = Vector(geom["tangent_b"]) + chord = tangent_b - tangent_a + chord_length_si = chord.length + if chord_length_si < 1e-6: + return None + body_context = ifcopenshell.util.representation.get_context(ifc_file, "Model", "Body", "MODEL_VIEW") + if body_context is None: + return None + + x_dir = chord.normalized() + z_dir = Vector((0.0, 0.0, 1.0)) + y_dir = z_dir.cross(x_dir).normalized() + corner_obj.matrix_world = Matrix( + ( + (x_dir.x, y_dir.x, z_dir.x, tangent_a.x), + (x_dir.y, y_dir.y, z_dir.y, tangent_a.y), + (x_dir.z, y_dir.z, z_dir.z, tangent_a.z), + (0.0, 0.0, 0.0, 1.0), + ) + ) + bonsai.core.geometry.edit_object_placement( + tool.Ifc, tool.Geometry, tool.Surveyor, obj=corner_obj, apply_scale=False + ) + + arc_center_world = Vector(geom["arc_center"]) + v_world = arc_center_world - tangent_a + arc_center_local = (v_world.dot(x_dir), v_world.dot(y_dir), v_world.dot(z_dir)) + + # Banana cross-section side: ``side_sign`` picks whether the body endpoints + # extend toward the arc center (s = -1) or away from it (s = +1), so the + # cross-section at tangent_a matches wall A's body span instead of being + # centred on the reference arc. + radial_a_world = tangent_a - arc_center_world + if radial_a_world.length > 1e-6: + radial_a_world = radial_a_world.normalized() + wall_a_y_world = wall_a_obj.matrix_world.col[1].to_3d().normalized() + side_sign = 1.0 if wall_a_y_world.dot(radial_a_world) >= 0.0 else -1.0 + else: + side_sign = -1.0 + + # ``arc_radius`` is signed (negative = inverted fillet); banana radii use + # the magnitude — the sign only flips which side of A's reference line + # the arc center sits on, not the curve radii themselves. + radius_si = abs(geom["arc_radius"]) + offset_si = geom["profile_offset"] or 0.0 + thickness_si = geom["profile_thickness"] + r_endpoint_1 = abs(radius_si + side_sign * offset_si) + r_endpoint_2 = abs(radius_si + side_sign * (offset_si + thickness_si)) + r_outer_si = max(r_endpoint_1, r_endpoint_2) + r_inner_si = min(r_endpoint_1, r_endpoint_2) + + new_body = _build_curved_corner_body_representation( + ifc_file, + body_context, + arc_center_local=arc_center_local, + chord_length_si=chord_length_si, + radius_si=radius_si, + r_outer_si=r_outer_si, + r_inner_si=r_inner_si, + height_si=geom["height"] or 3.0, + ) + tool.Model.replace_object_ifc_representation(body_context, corner_obj, new_body) + return x_dir, y_dir, z_dir, chord_length_si + + +def _resolve_two_walls(context: bpy.types.Context) -> tuple[bpy.types.Object, bpy.types.Object] | None: + """``(active, other)`` from a 2-wall selection, both LAYER2 with straight axes.""" + selected = list(tool.Blender.get_selected_objects()) + if len(selected) != 2: + return None + active = context.active_object + if active is None or active not in selected: + return None + other = next((o for o in selected if o is not active), None) + if other is None: + return None + for obj in (active, other): + element = tool.Ifc.get_entity(obj) + if element is None or not element.is_a("IfcWall"): + return None + if not tool.Wall.has_layer2_usage(element): + return None + if not tool.Wall.is_straight_axis(element): + return None + if tool.Parametric.is_fillet_corner_wall(element): + # Re-filleting a curved corner would treat its chord as the + # reference line and produce nonsense geometry. + return None + return active, other + + +def _pick_dominant_wall_material( + element: ifcopenshell.entity_instance, +) -> Optional[ifcopenshell.entity_instance]: + """Return a single ``IfcMaterial`` representative of ``element``'s effective + material — the thickest layer's material when the element resolves to a + layer set / usage, the material itself when it is already plain, or + ``None`` for unsupported set kinds and elements with no material.""" + material = tool.Material.get_material(element, should_inherit=True) + if material is None: + return None + if material.is_a("IfcMaterial"): + return material + layer_set = None + if material.is_a("IfcMaterialLayerSetUsage"): + layer_set = material.ForLayerSet + elif material.is_a("IfcMaterialLayerSet"): + layer_set = material + if layer_set is None: + return None + layers_with_material = [layer for layer in (layer_set.MaterialLayers or ()) if layer.Material is not None] + if not layers_with_material: + return None + thickest = max(layers_with_material, key=lambda layer: layer.LayerThickness or 0.0) + return thickest.Material + + +def regenerate_fillet_corner_wall(element: ifcopenshell.entity_instance, obj: bpy.types.Object) -> None: + """Rebuild a fillet corner wall's banana body from ``BBIM_Wall.FilletRadius`` + and its neighbours' current layer parameters.""" + ifc_file = tool.Ifc.get() + if ifc_file is None: + return + radius_si = ifcopenshell.util.element.get_pset(element, "BBIM_Wall", "FilletRadius") + if not radius_si: + return + + # Find the two neighbor walls from IfcRelConnectsPathElements. The corner- + # side connection type is NOTDEFINED so neighbours don't miter against the + # chord-axis reference line — take the single rel on each side of the + # corner's inverse graph rather than filtering on type. + wall_a = None + for rel in getattr(element, "ConnectedFrom", []): + if rel.is_a("IfcRelConnectsPathElements"): + wall_a = rel.RelatingElement + break + wall_b = None + for rel in getattr(element, "ConnectedTo", []): + if rel.is_a("IfcRelConnectsPathElements"): + wall_b = rel.RelatedElement + break + if wall_a is None or wall_b is None: + return + wall_a_obj = tool.Ifc.get_object(wall_a) + wall_b_obj = tool.Ifc.get_object(wall_b) + if wall_a_obj is None or wall_b_obj is None: + return + + geom = tool.Wall.compute_wall_fillet_geometry(wall_a_obj, wall_b_obj, float(radius_si)) + if geom is None or not geom["valid"]: + return + + # Re-anchors the corner's ObjectPlacement at the new tangent_a and rebuilds + # the banana body. If a neighbour moved, the new placement follows; if + # neither moved, the new matrix equals the old within floating-point noise. + _apply_fillet_corner_geometry(ifc_file, obj, geom, wall_a_obj) + + +def _wall_fillet_gizmo_x_matrix(location: Vector, x_direction: Vector) -> Matrix: + """4×4 matrix placing a gizmo at ``location`` with local +X aligned to + ``x_direction`` in world space.""" + x = x_direction.normalized() + seed = Vector((0, 0, 1)) if abs(x.z) < 0.9 else Vector((1, 0, 0)) + y = (seed - x * seed.dot(x)).normalized() + z = x.cross(y) + mat = Matrix.Identity(4) + mat[0][:3] = (x.x, y.x, z.x) + mat[1][:3] = (x.y, y.y, z.y) + mat[2][:3] = (x.z, y.z, z.z) + mat.translation = location + return mat + + +def _wall_fillet_preview_walls(context: bpy.types.Context): + """``(wall_a_obj, wall_b_obj)`` pinned by the preview, or ``(None, None)`` + when inactive or stale.""" + props = _wall_fillet_props(context) + if props is None or not props.is_active: + return None, None + ifc_file = tool.Ifc.get() + if ifc_file is None: + return None, None + try: + elem_a = ifc_file.by_id(props.wall_a_id) + elem_b = ifc_file.by_id(props.wall_b_id) + except (RuntimeError, KeyError): + return None, None + wall_a_obj = tool.Ifc.get_object(elem_a) if elem_a else None + wall_b_obj = tool.Ifc.get_object(elem_b) if elem_b else None + return wall_a_obj, wall_b_obj + + class GizmoWallAddOpening(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin): """Activates when a wall (active) and one non-wall blender object are co-selected. diff --git a/src/bonsai/bonsai/tool/model.py b/src/bonsai/bonsai/tool/model.py index 33bc310c22..f059b32b6c 100644 --- a/src/bonsai/bonsai/tool/model.py +++ b/src/bonsai/bonsai/tool/model.py @@ -2871,10 +2871,20 @@ class Model(bonsai.core.tool.Model): @classmethod def recreate_wall(cls, element: ifcopenshell.entity_instance, obj: bpy.types.Object) -> None: - # FIXME(PR4): the fillet-corner branch lands with PR4's - # `regenerate_fillet_corner_wall` (bim/module/model/wall.py). On v0.8.0 - # the function doesn't exist; falling through to the straight-extrusion - # path preserves v0.8.0 behaviour for fillet walls until PR4 ships. + # Curved fillet-corner walls own a hand-built banana body that + # ``regenerate_wall_representation`` would flatten — it reads the axis + # as a 2-point reference line and builds a straight extrusion. Rebuild + # the curve in place instead: ``regenerate_fillet_corner_wall`` keeps + # radius + placement from the pset / current ``ObjectPlacement`` while + # picking up new thickness / height from the wall type, which is what + # we want when a type-property edit triggered this call. + if tool.Parametric.is_fillet_corner_wall(element): + # Lazy import: ``tool.Model`` loads before ``bim/module/model`` at + # addon enable; a module-level import would cycle. + from bonsai.bim.module.model.wall import regenerate_fillet_corner_wall + + regenerate_fillet_corner_wall(element, obj) + return rep = ifcopenshell.api.geometry.regenerate_wall_representation(tool.Ifc.get(), element) bonsai.core.geometry.switch_representation( tool.Ifc, @@ -2909,7 +2919,7 @@ class Model(bonsai.core.tool.Model): if not wall: continue is_layer2_usage = tool.Model.get_usage_type(element) == "LAYER2" - is_fillet_corner = bool(ifcopenshell.util.element.get_pset(element, "BBIM_Wall", "IsFilletCorner")) + is_fillet_corner = tool.Parametric.is_fillet_corner_wall(element) if not (is_layer2_usage or is_fillet_corner): continue if is_layer2_usage: diff --git a/src/bonsai/bonsai/tool/parametric.py b/src/bonsai/bonsai/tool/parametric.py index ad9846a18d..47a1097bdc 100644 --- a/src/bonsai/bonsai/tool/parametric.py +++ b/src/bonsai/bonsai/tool/parametric.py @@ -487,6 +487,13 @@ class Parametric(bonsai.core.tool.Parametric): return False if tool.Model.get_usage_type(element) == "LAYER2": return True + return cls.is_fillet_corner_wall(element) + + @classmethod + def is_fillet_corner_wall(cls, element: entity_instance) -> bool: + """``True`` if the wall carries the ``BBIM_Wall.IsFilletCorner`` flag, + marking it as a curved corner whose banana body is hand-built rather + than regenerated from the wall's axis + layer set.""" import ifcopenshell.util.element return bool(ifcopenshell.util.element.get_pset(element, "BBIM_Wall", "IsFilletCorner"))