Fix workspace.py is_manual_reference block ordering for build compatibility

Move is_manual_reference UI block to before _DIMENSION_TYPES to match the position established by PR #7965's conflict resolution already present in the build. The prior merge fix (66fcad84e3) placed it after _DIMENSION_TYPES, causing a 3-way merge conflict when the build's #7965 has it before. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Merge parametric_dimensions (PR #8083 ) to resolve build conflict
2026-08-06 07:51:47 +00:00 · 2026-05-25 08:03:58 -05:00 · 2026-05-21 17:29:14 -05:00 · 2026-05-21 15:31:19 -05:00 · 2026-05-21 13:12:56 -05:00 · 2026-05-18 11:19:05 -05:00
41 changed files with 5340 additions and 188 deletions
@@ -53,7 +53,7 @@ jobs:
          python ../nix/cache_dependencies.py unpack

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
        with:
          key: mac-${{ matrix.arch }}

@@ -29,7 +29,7 @@ jobs:
          python ../IfcOpenShell/nix/cache_dependencies.py unpack

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
        with:
          key: ubuntu-22.04-${{ runner.arch }}

@@ -10,7 +10,7 @@ jobs:

    steps:
      - name: Set up uv
-        uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57 # v8.0.0
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0

      - name: Install Python
        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
@@ -54,7 +54,7 @@ jobs:
          uv run ../nix/cache_dependencies.py unpack

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
        with:
          key: ubuntu-22.04-${{ runner.arch }}-rockylinux9

@@ -10,7 +10,7 @@ jobs:

    steps:
      - name: Set up uv
-        uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57 # v8.0.0
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0

      - name: Install Python
        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
@@ -54,7 +54,7 @@ jobs:
          uv run ../nix/cache_dependencies.py unpack

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
        with:
          key: ubuntu-22.04-${{ runner.arch }}-rockylinux9

@@ -52,7 +52,7 @@ jobs:
          }

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
        with:
          key: win-${{ matrix.arch }}
          # Windows ccache needs ~1GB
@@ -35,7 +35,7 @@ jobs:

    -
      name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.22
+      uses: hendrikmuhs/ccache-action@v1.2.23

    - 
      name: Build ifcopenshell
@@ -79,7 +79,7 @@ jobs:
          libhdf5-dev libcgal-dev libeigen3-dev
          
      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
        with:
          key: ubuntu-22.04-${{ runner.arch }}

@@ -7,9 +7,9 @@ jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

-      - uses: astral-sh/setup-uv@v3
+      - uses: astral-sh/setup-uv@v7

      - run: uv run .github/scripts/publish-bonsai-releases.py
        env:
@@ -3,6 +3,8 @@ set -ex

 PYODIDE_VERSION=0.29.3
 PYODIDE_BUILD_VERSION=0.33.0
+PYODIDE_XBUILDENV_ROOT="${HOME}/.cache/.pyodide-xbuildenv-${PYODIDE_BUILD_VERSION}"
+PYODIDE_XBUILDENV="${PYODIDE_XBUILDENV_ROOT}/${PYODIDE_VERSION}"

 # Script is assuming that it will be possible to execute it multiple times
 # therefore we're clearing venv each time and ignoring existing 'emsdk' folder.
@@ -19,10 +21,10 @@ uv pip install "pyodide-build==${PYODIDE_BUILD_VERSION}"
 uv run pyodide xbuildenv install "${PYODIDE_VERSION}"
 uv run pyodide xbuildenv install-emscripten

-EMSDK_ROOT=$(pyodide config get emscripten_dir)
-[ -f "${EMSDK_ROOT}/emsdk_env.sh" ] && source "${EMSDK_ROOT}/emsdk_env.sh"
-[ -f "${EMSDK_ROOT}/../../emsdk_env.sh" ] && source "${EMSDK_ROOT}/../../emsdk_env.sh"
+EMSDK_ROOT="${PYODIDE_XBUILDENV}/emsdk"
+source "${EMSDK_ROOT}/emsdk_env.sh"
 which emcc
+emcc --version

 mkdir -p packages/ifcopenshell
 VERSION=`cat IfcOpenShell/VERSION`
@@ -3,9 +3,9 @@ name = "IfcOpenShell"
 version = "0.0.0"
 dependencies = [
    "black==26.3.1",
-    "ruff==0.15.10",
+    "ruff==0.15.12",
    "poethepoet",
-    "ty==0.0.29",
+    "ty==0.0.32",
    "gersemi==0.26.1",
 ]

@@ -5,7 +5,7 @@ FILE_NAME('Psets_BBIM_Annotation.ifc','2020-01-01T00:00:00',$,$,'Psets_BBIM_Anno
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('3VuPUwdCD2Qx3XDDRs0R1N',$,'EPset_Annotation','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation,IfcTypeProduct',(#4,#33,#29,#32,#3,#2));
+#1=IFCPROPERTYSETTEMPLATE('3VuPUwdCD2Qx3XDDRs0R1N',$,'EPset_Annotation','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation,IfcTypeProduct',(#4,#33,#29,#32,#3,#2,#41,#42));
 #2=IFCSIMPLEPROPERTYTEMPLATE('2P7JN79n96Q9pElZ83LKe4',$,'ZIndex','',.P_SINGLEVALUE.,'IfcInteger',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1Wpx_r2xj1_9w5JpI0QRJy',$,'Symbol','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3q0oxMUKP47vZ4jnyG$dDb',$,'Classes','Classes separated by spaces that end up in classes for this element in svg. Can be used to specify the text font size: small - 1.8mm; regular - 2.5mm; large - 3.5mm; header - 5mm; title - 7mm. By default regular size is used.',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -28,7 +28,7 @@ DATA;
 #21=IFCSIMPLEPROPERTYTEMPLATE('1UDakJ5_f7kBhggNSW4$h5',$,'SymbolsPath','Default symbols SVG',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #22=IFCSIMPLEPROPERTYTEMPLATE('0d53LEtgLDQxnv__NfgH7i',$,'PatternsPath','Default patterns SVG',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #23=IFCSIMPLEPROPERTYTEMPLATE('26qFNMv7nCHgU6Jd7Anga5',$,'ShadingStylesPath','Default shading styles',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
-#24=IFCPROPERTYSETTEMPLATE('0I9merLinF5Ap$aZwaclgm',$,'BBIM_Dimension','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation/DIMENSION,IfcAnnotation/RADIUS,IfcAnnotation/DIAMETER,IfcTypeProduct',(#25,#26,#27,#28,#30));
+#24=IFCPROPERTYSETTEMPLATE('0I9merLinF5Ap$aZwaclgm',$,'BBIM_Dimension','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation/DIMENSION,IfcAnnotation/RADIUS,IfcAnnotation/DIAMETER,IfcAnnotation/ANGLE,IfcAnnotation/PLAN_LEVEL,IfcAnnotation/SECTION_LEVEL,IfcTypeProduct',(#25,#26,#35,#36,#27,#28,#30,#34,#37,#38,#39,#40));
 #25=IFCSIMPLEPROPERTYTEMPLATE('1rL2AbQsXD8RbpoWH5pYOV',$,'ShowDescriptionOnly','Hide the measurement values and show only annotation description',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 #26=IFCSIMPLEPROPERTYTEMPLATE('0SVyOfB0rC2xNfdRYf3XvY',$,'SuppressZeroInches','Suppress 0 inch values in dimension annotation text (for example: 12'' - 0" -> 12'')',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 #27=IFCSIMPLEPROPERTYTEMPLATE('2bUmj458PBqPAtUoI3MXsb',$,'TextPrefix','Text to add before annotation measurement value',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -38,5 +38,14 @@ DATA;
 #31=IFCPROPERTYENUMERATION('CustomUnit',(IFCTEXT('Feet and Inches - Fractional'),IFCTEXT('Feet - Decimal'),IFCTEXT('Inches - Fractional'),IFCTEXT('Inches - Decimal'),IFCTEXT('Meters'),IFCTEXT('Decimeters'),IFCTEXT('Centimeters'),IFCTEXT('Millimeters')),$);
 #32=IFCSIMPLEPROPERTYTEMPLATE('0gjJzDYBX8P85qn1xcAOOo',$,'Reverse_List','',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 #33=IFCSIMPLEPROPERTYTEMPLATE('22TrcxF8jFNB4buSmzjGEF',$,'List_Separator','',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
+#34=IFCSIMPLEPROPERTYTEMPLATE('1Kx4Pm9nR8vBwZqTs2uYeL',$,'Separator','Characters placed between multiple dimension values when CustomUnit has more than one unit selected (default: '' / '')',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+#35=IFCSIMPLEPROPERTYTEMPLATE('3Nf6Qs1mT0pWxBuCvDyEzA',$,'SuppressZeroFeet','Suppress 0 feet in dimension annotation text (for example: 0'' - 3 1/2" -> 3 1/2")',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#36=IFCSIMPLEPROPERTYTEMPLATE('2Rg7Hn5jK4mLpNqOsVwXtY',$,'IsOrdinate','Show accumulated distance from the first vertex instead of individual segment lengths',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#37=IFCSIMPLEPROPERTYTEMPLATE('1XpRnKoT2sGuW7vYcZaMqb',$,'Anchors','JSON array of parametric anchor descriptors — one per polyline vertex. Each entry: {"guid": str|null, "type": "FACE"|"CIRCLE_CENTER"|"WORLD", "addr": {...}, "hint": [x,y,z]|null, "pt": [x,y,z]}',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
+#38=IFCSIMPLEPROPERTYTEMPLATE('2YqSmLoU3tHvX8wZdaNrjc',$,'MeasureAxis','Axis along which distances are projected: X | Y | Z | TRUE | PERPENDICULAR',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+#39=IFCSIMPLEPROPERTYTEMPLATE('3Ny31Go6T5Z9fh8j4yQC0p',$,'ForcePerpendicularToFace','When enabled the polyline is constrained to follow the face normal of the first anchor vertex so the dimension measures straight-line distance perpendicular to that face',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#40=IFCSIMPLEPROPERTYTEMPLATE('1LoNpKqR3sTuVwXyZaBcDe',$,'LinePosition','Absolute world-space coordinate (metres) of the dimension line along the horizontal offset axis (perpendicular to the dimension direction). When set, the dimension line is held at this fixed global position even if the measured geometry moves. When absent the line sits at the anchor points.',.P_SINGLEVALUE.,'IfcLengthMeasure',$,$,$,$,$,.READWRITE.);
+#41=IFCSIMPLEPROPERTYTEMPLATE('0FauxIsAnnotFaux0001aB',$,'IsManualDrawingReference','Marks this annotation as a manually placed drawing reference, exempt from automatic drawing regeneration.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#42=IFCSIMPLEPROPERTYTEMPLATE('0FauxIsDocRefFaux001aB',$,'IsDocumentReference','Marks this annotation as pointing to an external document reference (not a Bonsai drawing camera).',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 ENDSEC;
 END-ISO-10303-21;
@@ -30,6 +30,7 @@ classes = (
    operator.ActivateModel,
    operator.AddAnnotation,
    operator.AddAnnotationType,
+    operator.AssignManualDrawingReference,
    operator.AddDrawing,
    operator.AddDrawingStyle,
    operator.AddDrawingToSheet,
@@ -107,6 +108,11 @@ classes = (
    operator.ToggleTargetView,
    operator.OpenDocumentationWebUi,
    operator.FilterSelectedObjectsIfIntersectedByCamera,
+    operator.DrawParametricDimension,
+    operator.SetDimensionAnchor,
+    operator.RegenerateDimensions,
+    operator.ClickNearestDimensionAnchor,
+    operator.DebugDimensionClicks,
    prop.Variable,
    prop.Drawing,
    prop.Document,
@@ -148,11 +154,17 @@ classes = (
    gizmos.UglyDotGizmo,
    gizmos.ExtrusionGuidesGizmo,
    gizmos.ExtrusionWidget,
+    gizmos.GizmoAnchorHandle,
+    gizmos.DimensionAnchorWidget,
+    gizmos.DimensionLinePositionWidget,
    workspace.LaunchAnnotationTypeManager,
    workspace.Hotkey,
 )


+_keymaps = []
+
+
 def menu_func(self, context):
    active_obj = context.active_object
    if active_obj:
@@ -172,9 +184,17 @@ def register():
    bpy.types.TextCurve.BIMTextProperties = bpy.props.PointerProperty(type=prop.BIMTextProperties)
    bpy.app.handlers.load_post.append(handler.load_post)
    bpy.app.handlers.depsgraph_update_pre.append(handler.depsgraph_update_pre_handler)
+    bpy.app.handlers.depsgraph_update_post.append(handler.depsgraph_update_post_handler)
    bpy.types.VIEW3D_MT_image_add.append(ui.add_object_button)
    bpy.types.VIEW3D_MT_object_context_menu.append(menu_func)

+    wm = bpy.context.window_manager
+    kc = wm.keyconfigs.addon
+    if kc:
+        km = kc.keymaps.new(name="3D View", space_type="VIEW_3D")
+        kmi = km.keymap_items.new("bim.click_nearest_dimension_anchor", "LEFTMOUSE", "PRESS")
+        _keymaps.append((km, kmi))
+

 def unregister():
    if not bpy.app.background:
@@ -187,5 +207,10 @@ def unregister():
    del bpy.types.TextCurve.BIMTextProperties
    bpy.app.handlers.load_post.remove(handler.load_post)
    bpy.app.handlers.depsgraph_update_pre.remove(handler.depsgraph_update_pre_handler)
+    bpy.app.handlers.depsgraph_update_post.remove(handler.depsgraph_update_post_handler)
+
+    for km, kmi in _keymaps:
+        km.keymap_items.remove(kmi)
+    _keymaps.clear()
    bpy.types.VIEW3D_MT_image_add.remove(ui.add_object_button)
    bpy.types.VIEW3D_MT_object_context_menu.remove(menu_func)
@@ -55,6 +55,14 @@ class ProductAssignmentsData:
        element = tool.Ifc.get_entity(bpy.context.active_object)
        if not element or not element.is_a("IfcAnnotation"):
            return
+        # Document-reference annotations link to an IfcDocumentInformation, not a product.
+        if tool.Drawing.is_document_reference(element):
+            for rel in element.HasAssociations:
+                if rel.is_a("IfcRelAssociatesDocument"):
+                    doc = rel.RelatingDocument
+                    if doc.is_a("IfcDocumentInformation"):
+                        return doc.Name or "Unnamed"
+            return None
        for rel in element.HasAssignments:
            if rel.is_a("IfcRelAssignsToProduct"):
                name = rel.RelatingProduct.Name or "Unnamed"
@@ -799,19 +807,24 @@ class DecoratorData:
        pset_data = ifcopenshell.util.element.get_pset(element, "BBIM_Dimension") or {}
        show_description_only = pset_data.get("ShowDescriptionOnly", False)
        suppress_zero_inches = pset_data.get("SuppressZeroInches", False)
+        suppress_zero_feet = pset_data.get("SuppressZeroFeet", False)
+        is_ordinate = pset_data.get("IsOrdinate", False)
        text_prefix = pset_data.get("TextPrefix", None) or ""
        text_suffix = pset_data.get("TextSuffix", None) or ""
-        custom_unit_list = pset_data.get("CustomUnit", None) or ""
-        custom_unit = custom_unit_list[0] if custom_unit_list else ""
+        custom_units = list(pset_data.get("CustomUnit", None) or [])
+        separator = pset_data.get("Separator", None) or " / "

        return {
            "dimension_style": dimension_style,
            "show_description_only": show_description_only,
            "suppress_zero_inches": suppress_zero_inches,
+            "suppress_zero_feet": suppress_zero_feet,
+            "is_ordinate": is_ordinate,
            "text_prefix": text_prefix,
            "text_suffix": text_suffix,
            "fill_bg": fill_bg,
-            "custom_unit": custom_unit,
+            "custom_units": custom_units,
+            "separator": separator,
        }

    @classmethod
@@ -490,7 +490,7 @@ class BaseDecorator:
        self.draw_label(context, text=text, line_no=line_number_start, multiline=True, **draw_label_kwargs)

    @cache
-    def format_value(self, context, value, suppress_zero_inches=False, custom_unit=None, in_unit_length=False):
+    def format_value(self, context, value, suppress_zero_inches=False, suppress_zero_feet=False, custom_unit=None, in_unit_length=False):
        drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
        precision = drawing_pset_data.get("MetricPrecision", None)
        if not precision:
@@ -502,6 +502,7 @@ class BaseDecorator:
            precision=precision,
            decimal_places=decimal_places,
            suppress_zero_inches=suppress_zero_inches,
+            suppress_zero_feet=suppress_zero_feet,
            custom_unit=custom_unit,
            in_unit_length=in_unit_length,
        )
@@ -718,11 +719,13 @@ class DimensionDecorator(BaseDecorator):
        if not dimension_data:
            return
        show_description_only = dimension_data["show_description_only"]
+        is_ordinate = dimension_data["is_ordinate"]
        text_prefix = dimension_data["text_prefix"]
        text_suffix = dimension_data["text_suffix"]
        viewportDrawingScale = self.get_viewport_drawing_scale(context)
        text_offset_value = viewportDrawingScale * 3

+        ordinate_total = 0.0
        for i0, i1 in indices:
            v0 = Vector(vertices[i0])
            v1 = Vector(vertices[i1])
@@ -741,16 +744,25 @@ class DimensionDecorator(BaseDecorator):
                "multiline": True,
                "text_dir": text_dir,
            }
-            base_pos = p0 + text_dir * 0.5
+            base_pos = p1 if is_ordinate else p0 + text_dir * 0.5

            if not show_description_only:
-                length = (v1 - v0).length
-                text = self.format_value(
-                    context,
-                    length,
-                    suppress_zero_inches=dimension_data["suppress_zero_inches"],
-                    custom_unit=dimension_data["custom_unit"],
-                )
+                segment_length = (v1 - v0).length
+                if is_ordinate:
+                    ordinate_total += segment_length
+                length = ordinate_total if is_ordinate else segment_length
+                units_to_format = dimension_data["custom_units"] if dimension_data["custom_units"] else [None]
+                parts = [
+                    self.format_value(
+                        context,
+                        length,
+                        suppress_zero_inches=dimension_data["suppress_zero_inches"],
+                        suppress_zero_feet=dimension_data["suppress_zero_feet"],
+                        custom_unit=unit,
+                    )
+                    for unit in units_to_format
+                ]
+                text = dimension_data["separator"].join(str(p) for p in parts)
                if isinstance(self, DiameterDecorator):
                    text = "D" + text
                text = text_prefix + text + text_suffix
@@ -761,15 +773,18 @@ class DimensionDecorator(BaseDecorator):

            self.draw_label(
                text=text,
-                pos=base_pos + text_offset,
-                box_alignment="bottom-middle",
+                pos=base_pos + text_offset + (Vector((0, text_offset_value)) if is_ordinate else Vector((0, 0))),
+                box_alignment="bottom-right" if is_ordinate else "bottom-middle",
                multiline_to_bottom=False,
                **common_label_attrs,
            )

            if not show_description_only and description:
                self.draw_label(
-                    text=description, pos=base_pos - text_offset, box_alignment="top-middle", **common_label_attrs
+                    text=description,
+                    pos=base_pos - text_offset + (Vector((0, text_offset_value)) if is_ordinate else Vector((0, 0))),
+                    box_alignment="top-right" if is_ordinate else "top-middle",
+                    **common_label_attrs,
                )


@@ -965,7 +980,9 @@ class RadiusDecorator(BaseDecorator):

        def get_text():
            length = (spline_points[-1] - spline_points[-2]).length
-            return "R" + self.format_value(context, length, custom_unit=dimension_data["custom_unit"])
+            units_to_format = dimension_data["custom_units"] if dimension_data["custom_units"] else [None]
+            parts = [self.format_value(context, length, suppress_zero_feet=dimension_data["suppress_zero_feet"], custom_unit=unit) for unit in units_to_format]
+            return "R" + dimension_data["separator"].join(str(p) for p in parts)

        self.draw_dimension_text(
            context, get_text, description, dimension_data, pos=pos, text_dir=Vector((1, 0)), box_alignment="center"
@@ -1497,6 +1514,20 @@ class ElevationDecorator(BaseDecorator):
            "output_edges": output_edges,
        }

+        # Determine the arrow direction in camera-image-plane (XY) space.
+        # The elevation tag's local -Z is intentionally parallel to the drawing
+        # camera's view direction, so projecting it always gives a near-zero XY
+        # delta.  Fall through to local +X (which is perpendicular to the view
+        # and rotates visibly when the user spins the tag).
+        view_mat = context.region_data.view_matrix
+        edge_dir_2d = Vector((1.0, 0.0))  # final fallback
+        for local_axis in (Vector((0, 0, -1)), Vector((1, 0, 0)), Vector((0, 1, 0))):
+            world_axis = obj.matrix_world.to_3x3() @ local_axis
+            cam_xy = (view_mat.to_3x3() @ world_axis).xy
+            if cam_xy.length > 1e-6:
+                edge_dir_2d = cam_xy.normalized()
+                break
+
        # process edges
        for edge in edges_original:
            v0, v1 = winspace_verts[edge[0]], winspace_verts[edge[1]]
@@ -1505,7 +1536,7 @@ class ElevationDecorator(BaseDecorator):
            circle_head = get_circle_head(circle_size)
            start_i = add_verts_sequence(add_offsets(v0, circle_head), start_i, **out_kwargs, closed=True)

-            edge_dir = (v1 - v0).normalized()
+            edge_dir = edge_dir_2d.to_3d()
            side = (edge_dir.yx * Vector((1, -1))).to_3d()
            triangle_head = get_triangle_head(side, edge_dir, triangle_length, triangle_width)
            start_i = add_verts_sequence(add_offsets(v0, triangle_head), start_i, **out_kwargs, closed=True)
@@ -2090,4 +2121,8 @@ class DecorationsHandler:

        object_decorators = DecoratorData.data.get("object_decorators", [])
        for obj, decorator in object_decorators:
-            decorator.decorate(context, obj)
+            try:
+                decorator.decorate(context, obj)
+            except ReferenceError:
+                DecoratorData.is_loaded = False
+                break
@@ -1789,6 +1789,19 @@ DISC = (
    (1.0, 0.0, 0),
 )

+# Anchor index currently being edited by SetDimensionAnchor (-1 = none).
+_active_anchor_idx: int = -1
+# The annotation curve object being edited (kept so the gizmo group stays
+# visible even when SetDimensionAnchor temporarily changes the active object).
+_editing_annotation_obj = None
+
+
+def set_active_anchor(idx: int, annotation_obj=None) -> None:
+    global _active_anchor_idx, _editing_annotation_obj
+    _active_anchor_idx = idx
+    _editing_annotation_obj = annotation_obj if idx >= 0 else None
+
+
 X3DISC = (
    (0.0, 0.0, 0.0),
    (1.0, 0.0, 0),
@@ -2120,6 +2133,340 @@ class ExtrusionWidget(types.GizmoGroup):
        self.handle.target_set_prop("offset", prop, "value")
        self.guides.target_set_prop("depth", prop, "value")

+
+class GizmoAnchorHandle(bpy.types.Gizmo):
+    """Visual-only dot at a parametric dimension vertex.
+
+    No draw_select/invoke — any draw_select entry puts the gizmo in Blender's
+    select buffer, which causes the gizmo system to consume the click even
+    without an explicit invoke.  All click handling is done by the
+    bim.click_nearest_dimension_anchor keymap operator.
+    """
+
+    bl_idname = "BIM_GT_anchor_handle"
+
+    __slots__ = ("anchor_index", "custom_shape")
+
+    def setup(self):
+        self.anchor_index = 0
+        self.custom_shape = self.new_custom_shape(type="TRIS", verts=X3DISC)
+
+    def draw(self, context):
+        self.draw_custom_shape(self.custom_shape)
+
+
+
+class DimensionAnchorWidget(types.GizmoGroup):
+    """Anchor handle gizmos at each vertex of the active parametric dimension.
+
+    Green dots indicate vertices that are anchored to an IFC element face;
+    orange dots are free world-point anchors.  Clicking any dot fires
+    ``bim.set_dimension_anchor`` pre-targeted at that vertex index.
+    """
+
+    bl_idname = "BIM_GGT_dimension_anchors"
+    bl_label = "Dimension Anchor Handles"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT", "SHOW_MODAL_ALL"}
+
+    _DIM_TYPES = frozenset(("DIMENSION", "RADIUS", "DIAMETER", "ANGLE", "PLAN_LEVEL", "SECTION_LEVEL"))
+    _MAX_ANCHORS = 16
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context) -> bool:
+        if not tool.Ifc.get():
+            return False
+        # Stay visible while SetDimensionAnchor is running (active obj may temporarily
+        # be an IFC element in the face-picking phase rather than the annotation).
+        if _active_anchor_idx >= 0 and _editing_annotation_obj is not None:
+            active = context.active_object
+            if active is _editing_annotation_obj:
+                return True  # annotation still active
+            if active is not None and tool.Ifc.get_entity(active) is not None:
+                return True  # face-picking phase: active obj is a target element
+            # Active object is None or a non-IFC object — the modal ended without
+            # calling set_active_anchor(-1).  Reset stale state and fall through.
+            set_active_anchor(-1)
+        obj = context.active_object
+        if not obj or obj.type != "CURVE":
+            return False
+        if not obj.select_get():
+            return False
+        element = tool.Ifc.get_entity(obj)
+        if not element or not element.is_a("IfcAnnotation"):
+            return False
+        import ifcopenshell.util.element as _ue
+        if _ue.get_predefined_type(element) not in cls._DIM_TYPES:
+            return False
+        pset = _ue.get_pset(element, "BBIM_Dimension")
+        return bool(pset and pset.get("Anchors"))
+
+    def setup(self, context: bpy.types.Context) -> None:
+        self._handles: list = []
+        for _ in range(self._MAX_ANCHORS):
+            gz = self.gizmos.new("BIM_GT_anchor_handle")
+            gz.scale_basis = 0.2
+            gz.use_draw_modal = True
+            gz.hide = True
+            self._handles.append(gz)
+
+    def refresh(self, context: bpy.types.Context) -> None:
+        import json
+        import ifcopenshell.util.element as _ue
+
+        obj = _editing_annotation_obj if _active_anchor_idx >= 0 and _editing_annotation_obj else context.active_object
+        if not obj or not obj.data or not getattr(obj.data, "splines", None):
+            for gz in self._handles:
+                gz.hide = True
+            return
+
+        element = tool.Ifc.get_entity(obj)
+        if not element:
+            for gz in self._handles:
+                gz.hide = True
+            return
+
+        pset = _ue.get_pset(element, "BBIM_Dimension")
+        if not pset or not pset.get("Anchors"):
+            for gz in self._handles:
+                gz.hide = True
+            return
+
+        try:
+            anchors = json.loads(pset["Anchors"])
+        except Exception:
+            for gz in self._handles:
+                gz.hide = True
+            return
+
+        spline = obj.data.splines[0]
+        n = min(len(spline.points), len(anchors), self._MAX_ANCHORS)
+
+        for i in range(n):
+            gz = self._handles[i]
+            raw_co = spline.points[i].co
+            world_co = obj.matrix_world @ raw_co.to_3d()
+            gz.matrix_basis = Matrix.Translation(world_co)
+            gz.anchor_index = i
+            if i == _active_anchor_idx and obj is _editing_annotation_obj:
+                gz.color = (0.2, 0.7, 1.0)
+                gz.color_highlight = (0.4, 0.85, 1.0)
+            elif anchors[i].get("guid"):
+                gz.color = (0.2, 0.85, 0.2)
+                gz.color_highlight = (0.4, 1.0, 0.4)
+            else:
+                gz.color = (0.9, 0.6, 0.1)
+                gz.color_highlight = (1.0, 0.85, 0.2)
+            gz.alpha = 0.85
+            gz.alpha_highlight = 1.0
+            gz.hide = False
+
+        for i in range(n, self._MAX_ANCHORS):
+            self._handles[i].hide = True
+
+    def draw_prepare(self, context: bpy.types.Context) -> None:
+        self.refresh(context)
+
+
+class DimensionLinePositionWidget(types.GizmoGroup):
+    """Drag handle for the LinePosition of a parametric dimension annotation.
+
+    Shows two opposing cones at the midpoint of the dimension curve, oriented
+    along the horizontal offset axis (cross(world_Z, dim_direction)).  Dragging
+    either cone updates BBIM_Dimension.LinePosition and regenerates the curve in
+    real time.  The forward cone points in +offset_dir; the reverse cone in
+    -offset_dir — both respond to mouse movement along the shared axis so the
+    user can drag in either direction from either handle.
+    """
+
+    bl_idname = "BIM_GGT_dimension_line_position"
+    bl_label = "Dimension Line Position"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT", "SHOW_MODAL_ALL"}
+
+    _DIM_TYPES = frozenset(("DIMENSION", "RADIUS", "DIAMETER", "ANGLE", "PLAN_LEVEL", "SECTION_LEVEL"))
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context) -> bool:
+        if not tool.Ifc.get():
+            return False
+        obj = context.active_object
+        if not obj or obj.type != "CURVE":
+            return False
+        element = tool.Ifc.get_entity(obj)
+        if not element or not element.is_a("IfcAnnotation"):
+            return False
+        import ifcopenshell.util.element as _ue
+        if _ue.get_predefined_type(element) not in cls._DIM_TYPES:
+            return False
+        pset = _ue.get_pset(element, "BBIM_Dimension")
+        return bool(pset and pset.get("Anchors") and pset.get("ForcePerpendicularToFace"))
+
+    # ------------------------------------------------------------------
+    # Helpers
+
+    @staticmethod
+    def _offset_dir(obj: bpy.types.Object) -> "Vector | None":
+        """World-space unit direction perpendicular to the dimension line and world_Z."""
+        if not obj.data or not hasattr(obj.data, "splines") or not obj.data.splines:
+            return None
+        spline = obj.data.splines[0]
+        if len(spline.points) < 2:
+            return None
+        a = obj.matrix_world @ spline.points[0].co.to_3d()
+        b = obj.matrix_world @ spline.points[-1].co.to_3d()
+        dim = b - a
+        if dim.length < 1e-10:
+            return None
+        dim.normalize()
+        world_z = Vector((0.0, 0.0, 1.0))
+        od = world_z.cross(dim)
+        if od.length < 1e-6:
+            od = Vector((1.0, 0.0, 0.0)).cross(dim)
+        if od.length < 1e-6:
+            return None
+        return od.normalized()
+
+    @staticmethod
+    def _midpoint(obj: bpy.types.Object) -> "Vector":
+        spline = obj.data.splines[0]
+        pts = [obj.matrix_world @ p.co.to_3d() for p in spline.points]
+        return sum(pts, Vector()) / len(pts)
+
+    @staticmethod
+    def _basis(origin: "Vector", x_axis: "Vector") -> "Matrix":
+        """4×4 matrix with translation=origin, local-X=x_axis."""
+        ref = Vector((0.0, 0.0, 1.0)) if abs(x_axis.dot(Vector((0.0, 0.0, 1.0)))) < 0.9 else Vector((1.0, 0.0, 0.0))
+        y_ax = x_axis.cross(ref).normalized()
+        z_ax = x_axis.cross(y_ax)
+        return Matrix([
+            [x_axis.x, y_ax.x, z_ax.x, origin.x],
+            [x_axis.y, y_ax.y, z_ax.y, origin.y],
+            [x_axis.z, y_ax.z, z_ax.z, origin.z],
+            [0.0,      0.0,    0.0,    1.0],
+        ])
+
+    # ------------------------------------------------------------------
+    # Value callbacks
+
+    def _get_pos(self) -> float:
+        obj = bpy.context.active_object
+        if not obj:
+            return 0.0
+        element = tool.Ifc.get_entity(obj)
+        if not element:
+            return 0.0
+        import ifcopenshell.util.element as _ue
+        pset = _ue.get_pset(element, "BBIM_Dimension")
+        if not pset:
+            return 0.0
+        stored = pset.get("LinePosition")
+        if stored is not None:
+            return float(stored)
+        # Natural position: projection of midpoint onto offset axis
+        od = self._offset_dir(obj)
+        if od is None:
+            return 0.0
+        return self._midpoint(obj).dot(od)
+
+    def _set_pos(self, value: float) -> None:
+        bpy.ops.ed.undo_push(message="Set Line Position")
+        import json
+        import numpy as np
+        import ifcopenshell.util.element as _ue
+        import ifcopenshell.api.pset as _pset_api
+        import ifcopenshell.api.drawing as drawing_api
+        from bonsai.bim.module.drawing.operator import _update_blender_curve
+
+        obj = bpy.context.active_object
+        if not obj:
+            return
+        file = tool.Ifc.get()
+        if not file:
+            return
+        element = tool.Ifc.get_entity(obj)
+        if not element:
+            return
+        pset_data = _ue.get_pset(element, "BBIM_Dimension")
+        if not pset_data:
+            return
+
+        pset_entity = file.by_id(pset_data["id"])
+        _pset_api.edit_pset(file, pset=pset_entity, properties={"LinePosition": value})
+
+        anchors = json.loads(pset_data.get("Anchors") or "[]")
+        placement_override: dict = {}
+        for a in anchors:
+            guid = a.get("guid")
+            if not guid:
+                continue
+            try:
+                elem = file.by_guid(guid)
+                elem_obj = tool.Ifc.get_object(elem)
+                if elem_obj:
+                    placement_override[elem.id()] = np.array(elem_obj.matrix_world)
+            except Exception:
+                pass
+
+        resolved_pts = drawing_api.regenerate_dimension(file, element, placement_override=placement_override)
+        if resolved_pts:
+            _update_blender_curve(element, resolved_pts)
+        tool.Blender.update_viewport()
+
+    # ------------------------------------------------------------------
+    # GizmoGroup interface
+
+    def _make_cone(self, color: tuple, highlight: tuple) -> "bpy.types.Gizmo":
+        gz = self.gizmos.new("BIM_GT_gizmo_cone")
+        gz.color = color
+        gz.alpha = 0.8
+        gz.color_highlight = highlight
+        gz.alpha_highlight = 1.0
+        gz.scale_basis = 0.15
+        gz.use_draw_modal = True
+        gz.prop_name = "Line Position"
+        gz.move_get_cb = self._get_pos
+        gz.move_set_cb = self._set_pos
+        gz.gizmo_group = self
+        gz.delta_scale = 1.0
+        return gz
+
+    def setup(self, context: bpy.types.Context) -> None:
+        color = (0.9, 0.6, 0.1)
+        highlight = (1.0, 0.9, 0.2)
+        self.gz_fwd = self._make_cone(color, highlight)
+        self.gz_rev = self._make_cone(color, highlight)
+
+    def refresh(self, context: bpy.types.Context) -> None:
+        obj = context.active_object
+        if not obj:
+            self.gz_fwd.hide = self.gz_rev.hide = True
+            return
+
+        od = self._offset_dir(obj)
+        if od is None:
+            self.gz_fwd.hide = self.gz_rev.hide = True
+            return
+
+        mid = self._midpoint(obj)
+        # Lift each cone off the dimension line so the arrow base doesn't
+        # overlap anchor dots.  0.3 m gives clear separation at typical zoom.
+        _GAP = 0.15
+        fwd_origin = mid + _GAP * od
+        rev_origin = mid - _GAP * od
+
+        self.gz_fwd.matrix_basis = self._basis(fwd_origin, od)
+        self.gz_fwd.axis = od.copy()
+        self.gz_fwd.hide = False
+
+        # Reverse cone: visually points in -od; same drag axis so both cones
+        # respond identically — drag toward either tip to move the line.
+        self.gz_rev.matrix_basis = self._basis(rev_origin, -od)
+        self.gz_rev.axis = od.copy()
+        self.gz_rev.hide = False
+
    @staticmethod
    def get_scale_value(system: str, length_unit: str) -> float:
        scale_value = 1
@@ -16,15 +16,141 @@
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.

+import json
+
 import bpy
+import numpy as np
 from bpy.app.handlers import persistent

 import bonsai.bim.module.drawing.decoration as decoration
 import bonsai.tool as tool

+# ---------------------------------------------------------------------------
+# Parametric dimension auto-regeneration state
+# ---------------------------------------------------------------------------
+
+# Maps element GUID → list of annotation STEP IDs that reference it.
+_dim_guid_index: dict = {}
+# Persistent tessellation cache for the depsgraph handler (element id → shape).
+_dim_shape_cache: dict = {}
+# Set True whenever BBIM_Dimension anchors change or a new file loads.
+_dim_index_dirty: bool = True
+# Re-entry guard so curve updates don't trigger a second handler call.
+_dim_handler_running: bool = False
+
+
+def invalidate_dim_index() -> None:
+    """Mark the GUID index as stale so it is rebuilt on the next handler call."""
+    global _dim_index_dirty, _dim_shape_cache
+    _dim_index_dirty = True
+    _dim_shape_cache.clear()
+
+
+def _rebuild_dim_guid_index(file) -> None:
+    global _dim_guid_index, _dim_index_dirty
+    import ifcopenshell.util.element
+
+    _dim_guid_index = {}
+    for annotation in file.by_type("IfcAnnotation"):
+        pset_data = ifcopenshell.util.element.get_pset(annotation, "BBIM_Dimension")
+        if not pset_data or not pset_data.get("Anchors"):
+            continue
+        try:
+            anchors = json.loads(pset_data["Anchors"])
+        except Exception:
+            continue
+        ann_id = annotation.id()
+        for anchor in anchors:
+            guid = anchor.get("guid")
+            if not guid:
+                continue
+            ids = _dim_guid_index.setdefault(guid, [])
+            if ann_id not in ids:
+                ids.append(ann_id)
+    _dim_index_dirty = False
+
+
+def regenerate_dims_for_layer(file, layer) -> None:
+    """Regenerate all parametric dimensions anchored to elements that use *layer*."""
+    global _dim_shape_cache, _dim_index_dirty, _dim_guid_index
+
+    if _dim_index_dirty:
+        _rebuild_dim_guid_index(file)
+
+    affected_guids: set = set()
+    for layer_set in file.get_inverse(layer):
+        if not layer_set.is_a("IfcMaterialLayerSet"):
+            continue
+        for inv in file.get_inverse(layer_set):
+            if inv.is_a("IfcRelAssociatesMaterial"):
+                rels = [inv]
+            elif inv.is_a("IfcMaterialLayerSetUsage"):
+                rels = [r for r in file.get_inverse(inv) if r.is_a("IfcRelAssociatesMaterial")]
+            else:
+                continue
+            for rel in rels:
+                for element in rel.RelatedObjects:
+                    if hasattr(element, "GlobalId"):
+                        affected_guids.add(element.GlobalId)
+                        _dim_shape_cache.pop(element.id(), None)
+
+    if not affected_guids:
+        return
+
+    annotation_ids: set = set()
+    for guid in affected_guids:
+        for ann_id in _dim_guid_index.get(guid, []):
+            annotation_ids.add(ann_id)
+
+    if not annotation_ids:
+        return
+
+    import ifcopenshell.util.element
+    import ifcopenshell.api.drawing as drawing_api
+    import ifcopenshell.geom
+    from bonsai.bim.module.drawing.operator import _update_blender_curve
+
+    geom_settings = ifcopenshell.geom.settings()
+    geom_settings.set("APPLY_DEFAULT_MATERIALS", False)
+
+    for ann_id in annotation_ids:
+        try:
+            annotation = file.by_id(ann_id)
+        except Exception:
+            continue
+        pset = ifcopenshell.util.element.get_pset(annotation, "BBIM_Dimension")
+        if not pset:
+            continue
+        placement_override: dict = {}
+        try:
+            anchors_raw = json.loads(pset.get("Anchors") or "[]")
+            for anchor in anchors_raw:
+                guid = anchor.get("guid")
+                if not guid:
+                    continue
+                try:
+                    elem = file.by_guid(guid)
+                    elem_obj = tool.Ifc.get_object(elem)
+                    if elem_obj:
+                        placement_override[elem.id()] = np.array(elem_obj.matrix_world)
+                except Exception:
+                    pass
+        except Exception:
+            pass
+        resolved_pts = drawing_api.regenerate_dimension(
+            file,
+            annotation,
+            settings=geom_settings,
+            shape_cache=_dim_shape_cache,
+            placement_override=placement_override,
+        )
+        if resolved_pts:
+            _update_blender_curve(annotation, resolved_pts)
+

@persistent
 def load_post(*args):
+    invalidate_dim_index()
    props = tool.Drawing.get_document_props()
    if props.should_draw_decorations:
        decoration.DecorationsHandler.install(bpy.context)
@@ -58,3 +184,177 @@ def set_active_camera_resolution(scene: bpy.types.Scene) -> None:
        raster_x, raster_y = props.update_camera_resolution()
        scene_render.resolution_x = raster_x
        scene_render.resolution_y = raster_y
+
+
+def _sync_dimension_anchors_to_curve(file, annotation, obj) -> bool:
+    """Sync BBIM_Dimension.Anchors length to match the curve's spline point count.
+
+    Called when the user adds or removes vertices from a dimension annotation in
+    Edit Mode.  New vertices get a free WORLD-type anchor at their current world
+    position; removed tail vertices simply lose their anchor entries.
+
+    Returns True if the pset was changed.
+    """
+    import ifcopenshell.util.element
+    import ifcopenshell.api.pset
+
+    if not obj.data or not getattr(obj.data, "splines", None) or not obj.data.splines:
+        return False
+
+    pset_data = ifcopenshell.util.element.get_pset(annotation, "BBIM_Dimension")
+    if not pset_data or not pset_data.get("Anchors"):
+        return False
+
+    try:
+        anchors: list = json.loads(pset_data["Anchors"])
+    except Exception:
+        return False
+
+    spline = obj.data.splines[0]
+    spline_world = [obj.matrix_world @ p.co.to_3d() for p in spline.points]
+    n_pts = len(spline_world)
+    n_anchors = len(anchors)
+
+    if n_pts == n_anchors:
+        return False
+
+    # Match each spline point to the nearest unused anchor by proximity.
+    # This handles insertions (subdivide) and deletions correctly regardless
+    # of where in the polyline the edit happened.
+    _MATCH_THRESH_SQ = 1e-4  # 1 cm² — distinguishes existing pts from new midpoints
+    used: set = set()
+    new_anchors: list = []
+
+    for pt in spline_world:
+        best_idx, best_sq = None, float("inf")
+        for i, anc in enumerate(anchors):
+            if i in used:
+                continue
+            stored = anc.get("pt")
+            if not stored:
+                continue
+            dx, dy, dz = stored[0] - pt.x, stored[1] - pt.y, stored[2] - pt.z
+            sq = dx * dx + dy * dy + dz * dz
+            if sq < best_sq:
+                best_sq, best_idx = sq, i
+        if best_idx is not None and best_sq < _MATCH_THRESH_SQ:
+            new_anchors.append(anchors[best_idx])
+            used.add(best_idx)
+        else:
+            new_anchors.append({
+                "guid": None,
+                "type": "WORLD",
+                "addr": {},
+                "hint": None,
+                "pt": [pt.x, pt.y, pt.z],
+            })
+
+
+    pset_entity = file.by_id(pset_data["id"])
+    ifcopenshell.api.pset.edit_pset(file, pset=pset_entity, properties={"Anchors": json.dumps(new_anchors)})
+    invalidate_dim_index()
+    return True
+
+
+@persistent
+def depsgraph_update_post_handler(scene, depsgraph):
+    """Auto-regenerate parametric dimensions when referenced elements are moved."""
+    global _dim_handler_running, _dim_index_dirty, _dim_guid_index, _dim_shape_cache
+
+    if _dim_handler_running:
+        return
+
+    file = tool.Ifc.get()
+    if not file:
+        return
+
+    if _dim_index_dirty:
+        _rebuild_dim_guid_index(file)
+
+    import ifcopenshell.util.element
+
+    moved_guids: set = set()
+    edited_annotation_ids: set = set()
+
+    for update in depsgraph.updates:
+        obj = update.id
+        if not isinstance(obj, bpy.types.Object):
+            continue
+        if not (update.is_updated_transform or update.is_updated_geometry):
+            continue
+        element = tool.Ifc.get_entity(obj)
+        if element is None or not hasattr(element, "GlobalId"):
+            continue
+
+
+        if update.is_updated_geometry and obj.type == "CURVE" and element.is_a("IfcAnnotation"):
+            import ifcopenshell.util.element as _ue
+            ptype = _ue.get_predefined_type(element)
+            if ptype in ("DIMENSION", "RADIUS", "DIAMETER", "ANGLE", "PLAN_LEVEL", "SECTION_LEVEL"):
+                changed = _sync_dimension_anchors_to_curve(file, element, obj)
+                if changed:
+                    edited_annotation_ids.add(element.id())
+                continue
+
+        moved_guids.add(element.GlobalId)
+        if update.is_updated_geometry:
+            _dim_shape_cache.pop(element.id(), None)
+
+    annotation_ids: set = set(edited_annotation_ids)
+    for guid in moved_guids:
+        for ann_id in _dim_guid_index.get(guid, []):
+            annotation_ids.add(ann_id)
+
+    if not annotation_ids:
+        return
+
+    import ifcopenshell.api.drawing as drawing_api
+    import ifcopenshell.geom
+    from bonsai.bim.module.drawing.operator import _update_blender_curve
+
+    geom_settings = ifcopenshell.geom.settings()
+    geom_settings.set("APPLY_DEFAULT_MATERIALS", False)
+
+    _dim_handler_running = True
+    try:
+        for ann_id in annotation_ids:
+            try:
+                annotation = file.by_id(ann_id)
+            except Exception:
+                continue
+
+            pset = ifcopenshell.util.element.get_pset(annotation, "BBIM_Dimension")
+            if not pset:
+                continue
+
+            placement_override: dict = {}
+            try:
+                anchors_raw = json.loads(pset.get("Anchors") or "[]")
+                for anchor in anchors_raw:
+                    guid = anchor.get("guid")
+                    if not guid:
+                        continue
+                    try:
+                        elem = file.by_guid(guid)
+                        elem_id = elem.id()
+                        if elem_id in placement_override:
+                            continue
+                        elem_obj = tool.Ifc.get_object(elem)
+                        if elem_obj:
+                            placement_override[elem_id] = np.array(elem_obj.matrix_world)
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+
+            resolved_pts = drawing_api.regenerate_dimension(
+                file,
+                annotation,
+                settings=geom_settings,
+                shape_cache=_dim_shape_cache,
+                placement_override=placement_override,
+            )
+            if resolved_pts:
+                _update_blender_curve(annotation, resolved_pts)
+    finally:
+        _dim_handler_running = False
@@ -170,6 +170,7 @@ def format_distance(
    precision=None,
    decimal_places=None,
    suppress_zero_inches=False,
+    suppress_zero_feet=False,
    in_unit_length=False,
    custom_unit=None,
 ):
@@ -310,10 +311,10 @@ def format_distance(
            tx_dist = ""
            if feet:
                tx_dist += str(feet) + "'"
-            if not feet and not add_inches:
+            if not feet and not add_inches and not suppress_zero_feet:
                tx_dist += str(feet) + "'"

-            if not feet and add_inches:
+            if not feet and add_inches and unit_length != "INCHES" and not suppress_zero_feet:
                if value < 0:
                    tx_dist += "-0' - "
                else:
@@ -986,6 +986,160 @@ def update_sheet_data(self, context):
    SheetsData.is_loaded = False


+def _update_force_perpendicular(self, context):
+    """Apply ForcePerpendicularToFace to all selected dimension annotations and regenerate them."""
+    import json
+    import numpy as np
+    import ifcopenshell.util.element
+    import ifcopenshell.api.pset
+    import ifcopenshell.api.drawing as drawing_api
+    import bonsai.tool as tool
+
+    file = tool.Ifc.get()
+    if not file:
+        return
+
+    new_value = self.force_perpendicular_to_face
+    _DIM_TYPES = frozenset(("DIMENSION", "RADIUS", "DIAMETER", "ANGLE", "PLAN_LEVEL", "SECTION_LEVEL"))
+
+    targets = []
+    for obj in context.selected_objects:
+        element = tool.Ifc.get_entity(obj)
+        if not element or not element.is_a("IfcAnnotation"):
+            continue
+        if ifcopenshell.util.element.get_predefined_type(element) not in _DIM_TYPES:
+            continue
+        pset_data = ifcopenshell.util.element.get_pset(element, "BBIM_Dimension")
+        if not pset_data:
+            continue
+        targets.append((obj, element, pset_data))
+
+    if not targets:
+        return
+
+    from bonsai.bim.module.drawing.operator import _update_blender_curve
+
+    for obj, element, pset_data in targets:
+        pset_entity = file.by_id(pset_data["id"])
+        ifcopenshell.api.pset.edit_pset(file, pset=pset_entity, properties={"ForcePerpendicularToFace": new_value})
+
+        anchors = json.loads(pset_data.get("Anchors") or "[]")
+        placement_override = {}
+        for a in anchors:
+            guid = a.get("guid")
+            if not guid:
+                continue
+            try:
+                elem = file.by_guid(guid)
+                elem_obj = tool.Ifc.get_object(elem)
+                if elem_obj:
+                    placement_override[elem.id()] = np.array(elem_obj.matrix_world)
+            except Exception:
+                pass
+
+        resolved_pts = drawing_api.regenerate_dimension(file, element, placement_override=placement_override)
+        if resolved_pts:
+            _update_blender_curve(element, resolved_pts)
+
+
+def _get_line_position(self) -> float:
+    """Return LinePosition from the active annotation's BBIM_Dimension pset.
+
+    Falls back to the natural anchor projection when LinePosition has not been
+    explicitly set, so the field always shows a meaningful value.
+    """
+    import math
+    import json
+    try:
+        import bpy as _bpy
+        import ifcopenshell.util.element as _ue
+        import bonsai.tool as _tool
+        obj = getattr(_bpy.context, "active_object", None)
+        if obj:
+            element = _tool.Ifc.get_entity(obj)
+            if element and element.is_a("IfcAnnotation"):
+                pset = _ue.get_pset(element, "BBIM_Dimension")
+                if pset:
+                    stored = pset.get("LinePosition")
+                    if stored is not None:
+                        return float(stored)
+                    raw = pset.get("Anchors")
+                    if raw:
+                        anchors = json.loads(raw)
+                        if len(anchors) >= 2 and anchors[0].get("pt") and anchors[1].get("pt"):
+                            a, b = anchors[0]["pt"], anchors[1]["pt"]
+                            dx, dy, dz = b[0] - a[0], b[1] - a[1], b[2] - a[2]
+                            m = math.sqrt(dx * dx + dy * dy + dz * dz)
+                            if m > 1e-10:
+                                ddx, ddy, ddz = dx / m, dy / m, dz / m
+                                # cross(world_Z=(0,0,1), dim_dir) = (-ddy, ddx, 0)
+                                ox, oy, oz = -ddy, ddx, 0.0
+                                om = math.sqrt(ox * ox + oy * oy)
+                                if om > 1e-6:
+                                    od = (ox / om, oy / om, 0.0)
+                                    pt = anchors[0]["pt"]
+                                    return float(pt[0] * od[0] + pt[1] * od[1])
+    except Exception:
+        pass
+    return 0.0
+
+
+def _set_line_position(self, value: float) -> None:
+    """Write LinePosition to all selected dimension annotations and regenerate."""
+    import json
+    import numpy as np
+    import ifcopenshell.util.element
+    import ifcopenshell.api.pset
+    import ifcopenshell.api.drawing as drawing_api
+    import bonsai.tool as tool
+
+    file = tool.Ifc.get()
+    if not file:
+        return
+
+    _DIM_TYPES = frozenset(("DIMENSION", "RADIUS", "DIAMETER", "ANGLE", "PLAN_LEVEL", "SECTION_LEVEL"))
+
+    targets = []
+    import bpy as _bpy
+    for obj in getattr(_bpy.context, "selected_objects", []):
+        element = tool.Ifc.get_entity(obj)
+        if not element or not element.is_a("IfcAnnotation"):
+            continue
+        if ifcopenshell.util.element.get_predefined_type(element) not in _DIM_TYPES:
+            continue
+        pset_data = ifcopenshell.util.element.get_pset(element, "BBIM_Dimension")
+        if not pset_data:
+            continue
+        targets.append((obj, element, pset_data))
+
+    if not targets:
+        return
+
+    from bonsai.bim.module.drawing.operator import _update_blender_curve
+
+    for obj, element, pset_data in targets:
+        pset_entity = file.by_id(pset_data["id"])
+        ifcopenshell.api.pset.edit_pset(file, pset=pset_entity, properties={"LinePosition": value})
+
+        anchors = json.loads(pset_data.get("Anchors") or "[]")
+        placement_override = {}
+        for a in anchors:
+            guid = a.get("guid")
+            if not guid:
+                continue
+            try:
+                elem = file.by_guid(guid)
+                elem_obj = tool.Ifc.get_object(elem)
+                if elem_obj:
+                    placement_override[elem.id()] = np.array(elem_obj.matrix_world)
+            except Exception:
+                pass
+
+        resolved_pts = drawing_api.regenerate_dimension(file, element, placement_override=placement_override)
+        if resolved_pts:
+            _update_blender_curve(element, resolved_pts)
+
+
 class BIMAnnotationProperties(PropertyGroup):
    object_type: bpy.props.EnumProperty(
        name="Annotation Object Type", items=annotation_classes, default="TEXT", update=update_annotation_object_type
@@ -999,6 +1153,25 @@ class BIMAnnotationProperties(PropertyGroup):
    )
    is_adding_type: bpy.props.BoolProperty(default=False)
    type_name: bpy.props.StringProperty(name="Name", default="TYPEX")
+    force_perpendicular_to_face: bpy.props.BoolProperty(
+        name="Force ⊥ to Face",
+        description="Constrain dimension vertices to the face normal of the first anchor. When dimensions are selected, toggling this updates them all.",
+        default=False,
+        update=_update_force_perpendicular,
+    )
+    line_position: bpy.props.FloatProperty(
+        name="Line Position",
+        description="Absolute world position of the dimension line along the horizontal axis perpendicular to the dimension. The line is held at this fixed global coordinate even when the measured geometry moves. Updates all selected dimensions.",
+        unit="LENGTH",
+        get=_get_line_position,
+        set=_set_line_position,
+    )
+    is_manual_reference: bpy.props.BoolProperty(
+        name="Is a Reference",
+        default=False,
+        description="Place as a manual reference tag (IsManualDrawingReference). "
+        "Exempt from automatic drawing regeneration. Optionally link to a drawing or external reference.",
+    )
    tag_rotation_mode: bpy.props.EnumProperty(
        name="Tag Rotation Mode",
        description="How to orient the tag relative to the tagged object",
@@ -1019,3 +1192,4 @@ class BIMAnnotationProperties(PropertyGroup):
        create_representation_for_type: bool
        is_adding_type: bool
        type_name: str
+        is_manual_reference: bool
@@ -872,7 +872,11 @@ class SvgWriter:

        v1 = self.project_point_onto_camera(obj.matrix_world @ Vector((0, 0, 0)))
        v2 = self.project_point_onto_camera(obj.matrix_world @ Vector((0, 0, -1)))
-        angle = -math.degrees((v2 - v1).xy.angle_signed(Vector((0, 1))))
+        delta = (v2 - v1).xy
+        if delta.length <= 1e-6:
+            v2 = self.project_point_onto_camera(obj.matrix_world @ Vector((1, 0, 0)))
+            delta = (v2 - v1).xy
+        angle = -math.degrees(delta.angle_signed(Vector((0, 1)))) if delta.length > 1e-6 else 90.0

        transform = "rotate({}, {}, {})".format(angle, *symbol_position_svg.xy)

@@ -892,9 +896,35 @@ class SvgWriter:
        )

    def get_reference_and_sheet_id_from_annotation(self, element: ifcopenshell.entity_instance) -> tuple[str, str]:
-        reference_id = "-"
-        sheet_id = "-"
+        is_ifc2x3 = tool.Ifc.get_schema() == "IFC2X3"
+
+        # Document-reference annotations link to an IfcDocumentInformation via
+        # IfcRelAssociatesDocument rather than to a drawing product.
+        if tool.Drawing.is_document_reference(element):
+            doc_info = tool.Drawing.get_annotation_reference_doc(element)
+            if not doc_info:
+                return ("-", "-")
+            ext_location = tool.Drawing.get_path_with_ext(
+                (doc_info.DocumentReferences[0].Location if is_ifc2x3 else doc_info.HasDocumentReferences[0].Location),
+                "svg",
+            ) if (doc_info.DocumentReferences if is_ifc2x3 else doc_info.HasDocumentReferences) else None
+            if not ext_location:
+                return ("-", "-")
+            for sheet_reference in tool.Ifc.get().by_type("IfcDocumentReference"):
+                if tool.Drawing.get_reference_description(sheet_reference) != "REFERENCE":
+                    continue
+                if sheet_reference.Location != ext_location:
+                    continue
+                sheet = tool.Drawing.get_reference_document(sheet_reference)
+                if sheet:
+                    if is_ifc2x3:
+                        return (sheet_reference.ItemReference or "-", sheet.DocumentId or "-")
+                    return (sheet_reference.Identification or "-", sheet.Identification or "-")
+            return ("-", "-")
+
        drawing = tool.Drawing.get_annotation_element(element)
+        if not drawing:
+            return ("-", "-")
        reference = tool.Drawing.get_drawing_reference(drawing)
        if reference:
            for sheet_reference in tool.Ifc.get().by_type("IfcDocumentReference"):
@@ -903,13 +933,9 @@ class SvgWriter:
                    continue
                sheet = tool.Drawing.get_reference_document(sheet_reference)
                if sheet:
-                    if tool.Ifc.get_schema() == "IFC2X3":
-                        reference_id = sheet_reference.ItemReference or "-"
-                        sheet_id = sheet.DocumentId or "-"
-                    else:
-                        reference_id = sheet_reference.Identification or "-"
-                        sheet_id = sheet.Identification or "-"
-                    return (reference_id, sheet_id)
+                    if is_ifc2x3:
+                        return (sheet_reference.ItemReference or "-", sheet.DocumentId or "-")
+                    return (sheet_reference.Identification or "-", sheet.Identification or "-")
                break
        return ("-", "-")

@@ -1371,14 +1397,18 @@ class SvgWriter:

            def get_text():
                radius = (points[-1].co - points[-2].co).length
-                radius = helper.format_distance(
-                    radius,
-                    precision=self.precision,
-                    decimal_places=self.decimal_places,
-                    custom_unit=dimension_data["custom_unit"],
-                )
-                text = f"R{radius}"
-                return text
+                units_to_format = dimension_data["custom_units"] if dimension_data["custom_units"] else [None]
+                parts = [
+                    helper.format_distance(
+                        radius,
+                        precision=self.precision,
+                        decimal_places=self.decimal_places,
+                        suppress_zero_feet=dimension_data["suppress_zero_feet"],
+                        custom_unit=unit,
+                    )
+                    for unit in units_to_format
+                ]
+                return "R" + dimension_data["separator"].join(str(p) for p in parts)

            self.draw_dimension_text(
                get_text, tag, dimension_data, text_position=text_position, class_str="RADIUS", box_alignment="center"
@@ -1503,10 +1533,12 @@ class SvgWriter:
                    text_format=lambda x: "D" + x,
                    show_description_only=dimension_data["show_description_only"],
                    suppress_zero_inches=dimension_data["suppress_zero_inches"],
+                    suppress_zero_feet=dimension_data["suppress_zero_feet"],
                    text_prefix=dimension_data["text_prefix"],
                    text_suffix=dimension_data["text_suffix"],
                    fill_bg=dimension_data["fill_bg"],
-                    custom_unit=dimension_data["custom_unit"],
+                    custom_units=dimension_data["custom_units"],
+                    separator=dimension_data["separator"],
                )

    def draw_dimension_annotations(self, obj: bpy.types.Object) -> None:
@@ -1517,11 +1549,15 @@ class SvgWriter:
        dimension_data = DecoratorData.get_dimension_data(obj)

        assert isinstance(obj.data, bpy.types.Curve)
+        is_ordinate = dimension_data["is_ordinate"]
        for spline in obj.data.splines:
            points = self.get_spline_points(spline)
+            ordinate_total = 0.0
            for i in range(len(points) - 1):
                v0_global = matrix_world @ points[i].co.xyz
                v1_global = matrix_world @ points[i + 1].co.xyz
+                if is_ordinate:
+                    ordinate_total += (v1_global - v0_global).length
                self.draw_dimension_annotation(
                    v0_global,
                    v1_global,
@@ -1529,10 +1565,13 @@ class SvgWriter:
                    dimension_text=dimension_text,
                    show_description_only=dimension_data["show_description_only"],
                    suppress_zero_inches=dimension_data["suppress_zero_inches"],
+                    suppress_zero_feet=dimension_data["suppress_zero_feet"],
                    text_prefix=dimension_data["text_prefix"],
                    text_suffix=dimension_data["text_suffix"],
                    fill_bg=dimension_data["fill_bg"],
-                    custom_unit=dimension_data["custom_unit"],
+                    custom_units=dimension_data["custom_units"],
+                    separator=dimension_data["separator"],
+                    distance_override=ordinate_total if is_ordinate else None,
                )

    def draw_measureit_arch_dimension_annotations(self) -> None:
@@ -1556,10 +1595,13 @@ class SvgWriter:
        text_format=lambda x: x,
        show_description_only=False,
        suppress_zero_inches=False,
+        suppress_zero_feet=False,
        text_prefix="",
        text_suffix="",
        fill_bg=False,
-        custom_unit=None,
+        custom_units=None,
+        separator=" / ",
+        distance_override=None,
    ) -> None:
        offset = Vector([self.raw_width, self.raw_height]) / 2
        v0 = self.project_point_onto_camera(v0_global)
@@ -1572,7 +1614,10 @@ class SvgWriter:
        sheet_dimension = (end - start).length

        # if annotation can't fit offset text to the right of marker
-        text_position = mid if sheet_dimension > 5 else (end + (3 * vector.normalized()))
+        if distance_override is not None:
+            text_position = end
+        else:
+            text_position = mid if sheet_dimension > 5 else (end + (3 * vector.normalized()))
        angle = math.degrees(vector.angle_signed(Vector((1, 0))))

        line = self.svg.line(start=start, end=end, class_=" ".join(classes))
@@ -1587,15 +1632,20 @@ class SvgWriter:
        }

        if not show_description_only:
-            dimension = (v1_global - v0_global).length
-            dimension = helper.format_distance(
-                dimension,
-                precision=self.precision,
-                decimal_places=self.decimal_places,
-                suppress_zero_inches=suppress_zero_inches,
-                custom_unit=custom_unit,
-            )
-            text = text_prefix + str(dimension) + text_suffix
+            dimension = distance_override if distance_override is not None else (v1_global - v0_global).length
+            units_to_format = custom_units if custom_units else [None]
+            parts = [
+                helper.format_distance(
+                    dimension,
+                    precision=self.precision,
+                    decimal_places=self.decimal_places,
+                    suppress_zero_inches=suppress_zero_inches,
+                    suppress_zero_feet=suppress_zero_feet,
+                    custom_unit=unit,
+                )
+                for unit in units_to_format
+            ]
+            text = text_prefix + separator.join(str(p) for p in parts) + text_suffix
        else:
            if not dimension_text:
                return
@@ -1603,8 +1653,8 @@ class SvgWriter:

        text_tags += self.create_text_tag(
            text,
-            text_position + perpendicular,
-            box_alignment="bottom-middle",
+            text_position + perpendicular + (Vector((0, 1.5)) if distance_override is not None else Vector((0, 0))),
+            box_alignment="bottom-right" if distance_override is not None else "bottom-middle",
            multiline_to_bottom=False,
            **text_tag_kwargs,
        )
@@ -1612,8 +1662,8 @@ class SvgWriter:
        if not show_description_only and dimension_text:
            text_tags += self.create_text_tag(
                dimension_text,
-                text_position - perpendicular,
-                box_alignment="top-middle",
+                text_position - perpendicular + (Vector((0, 1.5)) if distance_override is not None else Vector((0, 0))),
+                box_alignment="top-right" if distance_override is not None else "top-middle",
                multiline_to_bottom=True,
                **text_tag_kwargs,
            )
@@ -535,6 +535,17 @@ class BIM_PT_product_assignments(Panel):

        assert self.layout
        assert (obj := context.active_object)
+
+        element = tool.Ifc.get_entity(obj)
+        if element and tool.Drawing.is_manual_drawing_reference(element):
+            row = self.layout.row(align=True)
+            fallback = "No Reference Assigned" if element.ObjectType == "REFERENCE" else "No Drawing Assigned"
+            row.label(
+                text=ProductAssignmentsData.data["relating_product"] or fallback, icon="IMAGE_DATA"
+            )
+            row.operator("bim.assign_manual_drawing_reference", icon="GREASEPENCIL", text="")
+            return
+
        props = tool.Drawing.get_object_assigned_product_props(obj)

        if props.is_editing_product:
@@ -552,6 +563,7 @@ class BIM_PT_product_assignments(Panel):
            col.enabled = bool(ProductAssignmentsData.data["relating_product"])


+
 def get_category_icon(category_name):
    """Get appropriate icon for each category"""
    icons = {
@@ -114,7 +114,11 @@ class AnnotationTool(WorkSpaceTool):
    bl_description = "Gives you Annotation related superpowers"
    bl_icon = os.path.join(os.path.dirname(__file__), "ops.authoring.annotation")
    bl_widget = None
-    bl_keymap = tool.Blender.get_default_selection_keypmap() + (
+    bl_keymap = (
+        # Before view3d.select: tool keymaps take priority over the addon keymap
+        # where ClickNearestDimensionAnchor is also registered.
+        ("bim.click_nearest_dimension_anchor", {"type": "LEFTMOUSE", "value": "PRESS"}, None),
+    ) + tool.Blender.get_default_selection_keypmap() + (
        ("bim.annotation_hotkey", {"type": "A", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_A")]}),
        ("bim.annotation_hotkey", {"type": "C", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_C")]}),
        ("bim.annotation_hotkey", {"type": "E", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_E")]}),
@@ -221,11 +225,29 @@ class AnnotationToolUI:
        props = tool.Drawing.get_document_props()
        row.prop(props, "should_draw_decorations", text="Viewport Annotations")

+    _DIMENSION_TYPES = frozenset(("DIMENSION", "RADIUS", "DIAMETER", "ANGLE", "PLAN_LEVEL", "SECTION_LEVEL"))
+
    @classmethod
    def draw_edit_object_interface(cls, context):
-        if DecoratorData.get_text_data(bpy.context.active_object):
+        obj = bpy.context.active_object
+        if tool.Ifc.get_entity(obj) and DecoratorData.get_text_data(obj):
            add_layout_hotkey_operator(cls.layout, "Edit Text", "S_E", "")

+        obj = context.active_object
+        element = tool.Ifc.get_entity(obj) if obj else None
+        if element and element.is_a("IfcAnnotation"):
+            ptype = ifcopenshell.util.element.get_predefined_type(element)
+            if ptype in cls._DIMENSION_TYPES:
+                cls.layout.separator()
+                ann_props = tool.Drawing.get_annotation_props()
+                if ann_props.force_perpendicular_to_face:
+                    row = cls.layout.row(align=True)
+                    row.prop(ann_props, "line_position")
+                cls.layout.separator()
+                row = cls.layout.row(align=True)
+                op = row.operator("bim.regenerate_dimensions", icon="FILE_REFRESH", text="Regenerate")
+                op.active_only = True
+
    @classmethod
    def draw_type_selection_interface(cls):
        # shared by both sidebar and header
@@ -248,6 +270,15 @@ class AnnotationToolUI:

        add_layout_hotkey_operator(cls.layout, "Add", "S_A", "Create a new annotation")

+        if object_type in ("ELEVATION", "SECTION"):
+            row = cls.layout.row(align=True)
+            row.prop(cls.props, "is_manual_reference")
+
+        _DIMENSION_TYPES = {"DIMENSION", "RADIUS", "DIAMETER", "ANGLE", "PLAN_LEVEL", "SECTION_LEVEL"}
+        if object_type in _DIMENSION_TYPES:
+            row = cls.layout.row(align=True)
+            row.prop(cls.props, "force_perpendicular_to_face")
+
        if object_type in tool.Drawing.ANNOTATION_TYPES_SUPPORT_SETUP:
            row = cls.layout.row(align=True)
            row.label(text="", icon="DRIVER_ROTATIONAL_DIFFERENCE")
@@ -330,9 +361,17 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
        if created_objects:
            bpy.context.view_layer.objects.active = created_objects[-1]

+    _PARAMETRIC_DIMENSION_TYPES = frozenset(
+        ("DIMENSION", "RADIUS", "DIAMETER", "ANGLE", "PLAN_LEVEL", "SECTION_LEVEL")
+    )
+
    def hotkey_S_A(self):
-        if bpy.ops.bim.add_annotation.poll():
-            bpy.ops.bim.add_annotation()
+        props = tool.Drawing.get_annotation_props()
+        if props.object_type in self._PARAMETRIC_DIMENSION_TYPES:
+            if bpy.ops.bim.draw_parametric_dimension.poll():
+                bpy.ops.bim.draw_parametric_dimension("INVOKE_DEFAULT")
+        elif bpy.ops.bim.add_annotation.poll():
+            bpy.ops.bim.add_annotation("INVOKE_DEFAULT")

    def hotkey_S_E(self):
        if not bpy.context.active_object:
@@ -630,7 +630,7 @@ class EditAssignedMaterial(bpy.types.Operator, tool.Ifc.Operator):
                    slab.DumbSlabPlaner().regenerate_from_layer_set(layer_set)

            if material_set_usage.is_a("IfcMaterialProfileSetUsage"):
-                if "CardinalPoint" in attributes:
+                if "CardinalPoint" in attributes and attributes["CardinalPoint"] is not None:
                    attributes["CardinalPoint"] = int(attributes["CardinalPoint"])
                ifcopenshell.api.material.edit_profile_usage(
                    self.file,
@@ -804,6 +804,8 @@ class EditMaterialSetItem(bpy.types.Operator, tool.Ifc.Operator):
            )
            slab.DumbSlabPlaner().regenerate_from_layer(layer)
            wall.DumbWallPlaner().regenerate_from_layer(layer)
+            from bonsai.bim.module.drawing.handler import regenerate_dims_for_layer
+            regenerate_dims_for_layer(self.file, layer)
        elif material.is_a("IfcMaterialProfileSet"):
            profile_def = None
            if mprops.profiles:
@@ -753,6 +753,8 @@ class PolylineDecorator:
        rv3d = region.data

        polyline_props = tool.Model.get_polyline_props()
+        if not polyline_props.snap_mouse_point:
+            return
        snap_prop = polyline_props.snap_mouse_point[0]
        mouse_point = Vector((snap_prop.x, snap_prop.y, snap_prop.z))

@@ -820,6 +822,8 @@ class PolylineDecorator:
        gpu.state.point_size_set(6)

        polyline_props = tool.Model.get_polyline_props()
+        if not polyline_props.snap_mouse_point:
+            return
        snap_prop = polyline_props.snap_mouse_point[0]
        # Point related to the mouse
        mouse_point = [Vector((snap_prop.x, snap_prop.y, snap_prop.z))]
@@ -461,14 +461,26 @@ class PolylineOperator:
        self.tool_state.axis_method = None
        self.tool_state.plane_method = None
        self.tool_state.mode = "Mouse"
-        tool.Raycast.clear_snap_objs()
+        # Do not call clear_snap_objs() here — create_snap_obj() validates stale
+        # entries per-object (vertex count + position check), so the BVH cache can
+        # safely persist across invocations. Clearing it caused an 11-second stall
+        # on every Shift+A because SnapObj rebuilds a pure-Python BVH tree.
        self.visible_objs = tool.Raycast.get_visible_objects(context)
        for obj in self.visible_objs:
            if bbox_2d := tool.Raycast.get_on_screen_2d_bounding_boxes(context, obj):
                self.objs_2d_bbox.append(bbox_2d)
-        detected_snaps = tool.Snap.detect_snapping_points(context, event, self.objs_2d_bbox, self.tool_state)
-        self.snapping_points = tool.Snap.select_snapping_points(context, event, self.tool_state, detected_snaps)
+        self._init_snapping_points(context, event)
        tool.Polyline.calculate_distance_and_angle(context, self.input_ui, self.tool_state)

        tool.Blender.update_viewport()
        context.window_manager.modal_handler_add(self)
+
+    def _init_snapping_points(self, context: bpy.types.Context, event: bpy.types.Event) -> None:
+        """Populate self.snapping_points at operator start.
+
+        Override in subclasses to skip the full BVH snap detection when a cheap
+        placeholder is sufficient.  The default runs the full detection pass.
+        """
+        detected_snaps = tool.Snap.detect_snapping_points(context, event, self.objs_2d_bbox, self.tool_state)
+        self.snapping_points = tool.Snap.select_snapping_points(context, event, self.tool_state, detected_snaps)
+
@@ -468,14 +468,16 @@ class ChangeExtrusionXAngle(bpy.types.Operator, tool.Ifc.Operator):
                    existing_x_angle = 0 if tool.Cad.is_x(existing_x_angle, 0, tolerance=0.001) else existing_x_angle
                    existing_x_angle = 0 if tool.Cad.is_x(existing_x_angle, pi, tolerance=0.001) else existing_x_angle

-                    coord_list = builder.get_polyline_coords(extrusion.SweptArea.OuterCurve)
-                    coord_list = [
-                        (p[0], p[1] * abs(cos(existing_x_angle))) for p in coord_list
-                    ]  # Reset the transformation and returns to the original points with 0 degrees
-                    coord_list = [
-                        (p[0], p[1] * abs(1 / cos(x_angle))) for p in coord_list
-                    ]  # Apply the transformation for the new x_angle
-                    builder.set_polyline_coords(extrusion.SweptArea.OuterCurve, coord_list)
+                    profiles = extrusion.SweptArea.Profiles if extrusion.SweptArea.is_a("IfcCompositeProfileDef") else [extrusion.SweptArea]
+                    for profile in profiles:
+                        coord_list = builder.get_polyline_coords(profile.OuterCurve)
+                        coord_list = [
+                            (p[0], p[1] * abs(cos(existing_x_angle))) for p in coord_list
+                        ]  # Reset the transformation and returns to the original points with 0 degrees
+                        coord_list = [
+                            (p[0], p[1] * abs(1 / cos(x_angle))) for p in coord_list
+                        ]  # Apply the transformation for the new x_angle
+                        builder.set_polyline_coords(profile.OuterCurve, coord_list)

                    # The extrusion direction calculated previously default to the positive direction
                    # Here we set the extrusion direction to negative if that's the case
@@ -88,6 +88,44 @@ class DisablePsetEditing(bpy.types.Operator, tool.Ifc.Operator):
        props.active_pset_type = "-"


+def _regenerate_parametric_dimension(file, annotation):
+    """Regenerate a single parametric dimension annotation after a pset edit."""
+    try:
+        import json
+        import numpy as np
+        import ifcopenshell.util.element
+        import ifcopenshell.api.drawing as drawing_api
+        import bonsai.tool as _tool
+        from bonsai.bim.module.drawing.operator import _update_blender_curve
+
+        pset_data = ifcopenshell.util.element.get_pset(annotation, "BBIM_Dimension")
+        if not pset_data or not pset_data.get("Anchors"):
+            return
+
+        anchors = json.loads(pset_data["Anchors"])
+        placement_override = {}
+        for a in anchors:
+            guid = a.get("guid")
+            if not guid:
+                continue
+            try:
+                elem = file.by_guid(guid)
+                elem_obj = _tool.Ifc.get_object(elem)
+                if elem_obj:
+                    placement_override[elem.id()] = np.array(elem_obj.matrix_world)
+            except Exception:
+                pass
+
+        resolved_pts = drawing_api.regenerate_dimension(
+            file, annotation, placement_override=placement_override
+        )
+        if resolved_pts:
+            _update_blender_curve(annotation, resolved_pts)
+    except Exception:
+        import traceback
+        traceback.print_exc()
+
+
 class EditPset(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.edit_pset"
    bl_label = "Edit Pset"
@@ -150,7 +188,12 @@ class EditPset(bpy.types.Operator, tool.Ifc.Operator):
            )
            if tool.Cost.has_schedules():
                tool.Cost.update_cost_items(pset=pset)
+        is_bbim_dimension = props.active_pset_name == "BBIM_Dimension" and element.is_a("IfcAnnotation")
+
        bpy.ops.bim.disable_pset_editing(obj=self.obj, obj_type=self.obj_type)
+        if is_bbim_dimension:
+            _regenerate_parametric_dimension(self.file, element)
+
        tool.Blender.update_viewport()


@@ -503,6 +503,26 @@ def add_annotation(
    return obj


+def assign_manual_drawing_reference(
+    ifc: type[tool.Ifc],
+    drawing_tool: type[tool.Drawing],
+    element: ifcopenshell.entity_instance,
+    drawing: Optional[ifcopenshell.entity_instance],
+) -> None:
+    for existing in drawing_tool.get_assigned_product_workaround(element):
+        ifc.run("drawing.unassign_product", relating_product=existing, related_object=element)
+    if drawing:
+        ifc.run("drawing.assign_product", relating_product=drawing, related_object=element)
+
+
+def assign_manual_reference_document(
+    drawing_tool: type[tool.Drawing],
+    element: ifcopenshell.entity_instance,
+    document: Optional[ifcopenshell.entity_instance],
+) -> None:
+    drawing_tool.set_annotation_reference_doc(element, document)
+
+
 def build_schedule(drawing: type[tool.Drawing], schedule: ifcopenshell.entity_instance) -> None:
    drawing.create_svg_schedule(schedule)
    drawing.open_svg(drawing.get_path_with_ext(drawing.get_document_uri(schedule), "svg"))
@@ -111,6 +111,7 @@ class Drawing(bonsai.core.tool.Drawing):
        "FILL_AREA":     AnnotationObjectType("Fill Area",        "", "NODE_TEXTURE", "mesh"),
        "FALL":          AnnotationObjectType("Fall",             "", "SORT_ASC", "curve"),
        "IMAGE":         AnnotationObjectType("Image",            "Add reference image attached to the drawing", "TEXTURE", "mesh"),
+        "MANUAL_DRAWING_REFERENCE": AnnotationObjectType("Manual Drawing Reference", "Add manual elevation or section reference tag that will not be moved or deleted during drawing regeneration", "EMPTY_ARROWS", "empty"),
    }
    # fmt: on

@@ -177,6 +178,10 @@ class Drawing(bonsai.core.tool.Drawing):

    @classmethod
    def get_annotation_data_type(cls, object_type: str) -> ANNOTATION_DATA_TYPE:
+        if object_type == "ELEVATION":
+            return "empty"
+        if object_type == "SECTION":
+            return "mesh"
        return cls.ANNOTATION_TYPES_DATA[object_type].data_type

    @classmethod
@@ -207,6 +212,14 @@ class Drawing(bonsai.core.tool.Drawing):
            co_end = co1 + vec * scaled_length
            obj = annotation.Annotator.add_line_to_annotation(obj, co_end, co1)
            obj.matrix_world = obj.matrix_world @ Matrix.Rotation(math.radians(-90), 4, "Z")
+        elif object_type == "ELEVATION":
+            obj.matrix_world = Matrix.Translation(bpy.context.scene.cursor.location.copy()) @ Matrix.Rotation(
+                math.radians(90), 4, "X"
+            )
+        elif object_type == "SECTION":
+            camera = tool.Ifc.get_object(drawing)
+            obj.matrix_world = cls.get_default_annotation_matrix(camera)
+            obj = annotation.Annotator.add_line_to_annotation(obj)
        elif object_type != "TEXT":
            obj = annotation.Annotator.add_line_to_annotation(obj)

@@ -1538,9 +1551,17 @@ class Drawing(bonsai.core.tool.Drawing):
                elements.append(element)
        return elements

+    @classmethod
+    def is_manual_drawing_reference(cls, element: ifcopenshell.entity_instance) -> bool:
+        return bool(ifcopenshell.util.element.get_pset(element, "EPset_Annotation", "IsManualDrawingReference"))
+
    @classmethod
    def is_auto_annotation(cls, element: ifcopenshell.entity_instance):
-        return element.is_a("IfcAnnotation") and element.ObjectType in ("GRID", "SECTION", "ELEVATION", "SECTION_LEVEL")
+        if not (element.is_a("IfcAnnotation") and element.ObjectType in ("GRID", "SECTION", "ELEVATION", "SECTION_LEVEL")):
+            return False
+        if ifcopenshell.util.element.get_pset(element, "EPset_Annotation", "IsManualDrawingReference"):
+            return False
+        return True

    @classmethod
    def get_drawing_reference_annotation(
@@ -1756,6 +1777,10 @@ class Drawing(bonsai.core.tool.Drawing):
            # For section/elevation views, elevate the segment vertically
            if not (points := helper.elevate_segment(bounds, [v1, v2])):
                return
+        elif target_view == "MODEL_VIEW":
+            # For model views, clip to XY bounds and keep Z (3D line at true elevation)
+            if not (points := helper.clip_segment(bounds, [v1, v2])):
+                return
        else:
            return

@@ -1868,6 +1893,57 @@ class Drawing(bonsai.core.tool.Drawing):
            element.Name = elevation.Name or "Unnamed"
            return element

+    @classmethod
+    def set_manual_drawing_reference(cls, element: ifcopenshell.entity_instance) -> None:
+        ifc_file = tool.Ifc.get()
+        pset = tool.Pset.get_element_pset(element, "EPset_Annotation")
+        if not pset:
+            pset = ifcopenshell.api.pset.add_pset(ifc_file, product=element, name="EPset_Annotation")
+        ifcopenshell.api.pset.edit_pset(ifc_file, pset=pset, properties={"IsManualDrawingReference": True})
+
+    @classmethod
+    def is_document_reference(cls, element: ifcopenshell.entity_instance) -> bool:
+        """Return True if this annotation links to an external document (not a Bonsai drawing camera)."""
+        return bool(ifcopenshell.util.element.get_pset(element, "EPset_Annotation", "IsDocumentReference"))
+
+    @classmethod
+    def set_document_reference_flag(cls, element: ifcopenshell.entity_instance) -> None:
+        """Mark this annotation as pointing to an external document reference."""
+        ifc_file = tool.Ifc.get()
+        pset = tool.Pset.get_element_pset(element, "EPset_Annotation")
+        if not pset:
+            pset = ifcopenshell.api.pset.add_pset(ifc_file, product=element, name="EPset_Annotation")
+        ifcopenshell.api.pset.edit_pset(ifc_file, pset=pset, properties={"IsDocumentReference": True})
+
+    @classmethod
+    def get_annotation_reference_doc(
+        cls, element: ifcopenshell.entity_instance
+    ) -> Union[ifcopenshell.entity_instance, None]:
+        """Return the IfcDocumentInformation linked to a document-reference annotation."""
+        for rel in element.HasAssociations:
+            if rel.is_a("IfcRelAssociatesDocument"):
+                doc = rel.RelatingDocument
+                if doc.is_a("IfcDocumentInformation"):
+                    return doc
+        return None
+
+    @classmethod
+    def set_annotation_reference_doc(
+        cls,
+        element: ifcopenshell.entity_instance,
+        document: Union[ifcopenshell.entity_instance, None],
+    ) -> None:
+        """Associate (or clear) an IfcDocumentInformation on a document-reference annotation."""
+        ifc_file = tool.Ifc.get()
+        # Remove existing document associations on this annotation.
+        for rel in list(element.HasAssociations):
+            if rel.is_a("IfcRelAssociatesDocument"):
+                ifcopenshell.api.document.unassign_document(
+                    ifc_file, products=[element], document=rel.RelatingDocument
+                )
+        if document:
+            ifcopenshell.api.document.assign_document(ifc_file, products=[element], document=document)
+
    @classmethod
    def regenerate_elevation_reference_annotation(
        cls,
@@ -890,17 +890,25 @@ class Raycast(bonsai.core.tool.Raycast):
            return None
        for i, snap_obj in enumerate(cls.snap_objs):
            if obj.name == snap_obj.obj.name:
-                # Handle objects modified while a modal operator is active.
-                # Example: adding a door or window alters the wall geometry.
+                # Fast O(1) invalidation: vertex count change (mesh edit) or
+                # world matrix change (object moved/rotated).
                if len(obj.data.vertices) != len(snap_obj.verts_3d):
                    cls.snap_objs.pop(i)
                    snap_obj = SnapObj(obj)
                    cls.snap_objs.append(snap_obj)
-                for v1, v2 in zip(obj.data.vertices, snap_obj.verts_3d):
-                    if (obj.matrix_world @ v1.co) != v2:
+                    return snap_obj
+                if obj.matrix_world != snap_obj.matrix_world:
+                    cls.snap_objs.pop(i)
+                    snap_obj = SnapObj(obj)
+                    cls.snap_objs.append(snap_obj)
+                    return snap_obj
+                # Sample one vertex to catch mesh edits that preserve vertex count.
+                if obj.data.vertices and snap_obj.verts_3d:
+                    if (obj.matrix_world @ obj.data.vertices[0].co) != snap_obj.verts_3d[0]:
                        cls.snap_objs.pop(i)
                        snap_obj = SnapObj(obj)
                        cls.snap_objs.append(snap_obj)
+                        return snap_obj
                return snap_obj
        snap_obj = SnapObj(obj)
        cls.snap_objs.append(snap_obj)
@@ -940,6 +948,7 @@ class SnapObj:
        self.root.edges = [e.index for e in obj.data.edges]
        self.split_box(self.root, 0)
        self.verts_3d = [obj.matrix_world @ v.co for v in obj.data.vertices]
+        self.matrix_world = obj.matrix_world.copy()
        self.snap_points = []

    def __clear_all__():
@@ -58,7 +58,7 @@ Fields
    Class** based on the IFC Schema version.

 **Unit System**
-  Choose between metric and imperial units of measurement when creating a project.
+  Choose between metric and imperial units of measurement when creating a project. Project data is stored in this Unit System and displayed according to e.g. Length Unit, Area Unit, Volume Unit. Properly changing the Unit System after project creation requires conversion. See `Blender Manual : Scene Properties : Units <https://docs.blender.org/manual/en/latest/scene_layout/scene/properties.html#units>`_ for a description of changing the display units e.g. from Feet to Adaptive (enable Separate Units option) for Feet-and-Inches.

 **Length Unit**
  Depending on the unit system, choose the default unit to be used for all length measurements. Lengths are used for moving objects around in the 3D scene, as well as lengths, widths, height, and depth quantity take-off data.
@@ -104,14 +104,6 @@ struct gradient_fn_evaluator : public fn_evaluator {
        auto xy = horizontal_evaluator_.evaluate(u);
        auto uz = vertical_evaluator_.evaluate(u);

-        // curvature is stored in row 3 - capture it and remove it from the xy and uz matrices
-        // so the matrix operations (ie multiplication) works correct.y
-        auto horizontal_curvature = xy.row(3);
-        xy.row(3) = Eigen::Vector4d(0, 0, 0, 1);
-
-        auto vertical_curvature = uz.row(3);
-        uz.row(3) = Eigen::Vector4d(0, 0, 0, 1);
-
        uz(0, 3) = 0.0;      // x is distance along. zero it out so it doesn't add to the x from horizontal
        uz.col(1).swap(uz.col(2)); // uz is 2D in distance along - y plane, swap y and z so elevations become z
        uz.row(1).swap(uz.row(2));
@@ -119,12 +111,6 @@ struct gradient_fn_evaluator : public fn_evaluator {
        Eigen::Matrix4d m;
        m = xy * uz; // combine horizontal and vertical

-        // Put curvature back into the solution matrix
-        // curvature for vertical is in column 0, need it to be in column 1
-        // so it doesn't add to curvature for horizontal
-        std::swap(vertical_curvature(0), vertical_curvature(1));
-        m.row(3) = horizontal_curvature + vertical_curvature;
-
        return m;
    }

@@ -562,6 +562,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcMaterial* material) {
            }
            // Check if it's failed or just some unsupported case.
            if (failed_on_purpose_.find(styled_item) == failed_on_purpose_.end()) {
+                failed_on_purpose_.insert(material);
                return nullptr;
            }
            Logger::Warning("Skipping unsupported material style for material: ", material);
@@ -569,6 +570,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcMaterial* material) {
    }

    // When material does not have a representation we don't create a style from it
+    failed_on_purpose_.insert(material);
    return nullptr;

    /*
@@ -25,12 +25,24 @@ annotations may have relationships which indicate smart data being populated.
 from .. import wrap_usecases
 from .assign_product import assign_product
 from .edit_text_literal import edit_text_literal
+from .regenerate_dimension import regenerate_dimension, get_dimension_segment_lengths
+from .resolve_anchor import build_anchor_from_hit, build_anchor_from_layer_boundary, build_anchor_from_profile_vert, build_anchor_from_profile_edge, get_layer_snap_candidates, get_profile_snap_candidates, make_world_anchor, resolve_anchor
 from .unassign_product import unassign_product

 wrap_usecases(__path__, __name__)

 __all__ = [
    "assign_product",
+    "build_anchor_from_hit",
+    "build_anchor_from_layer_boundary",
+    "build_anchor_from_profile_edge",
+    "build_anchor_from_profile_vert",
    "edit_text_literal",
+    "get_dimension_segment_lengths",
+    "get_layer_snap_candidates",
+    "get_profile_snap_candidates",
+    "make_world_anchor",
+    "regenerate_dimension",
+    "resolve_anchor",
    "unassign_product",
 ]
@@ -0,0 +1,383 @@
+# IfcOpenShell - IFC toolkit and geometry engine
+# Copyright (C) 2021 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of IfcOpenShell.
+#
+# IfcOpenShell is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# IfcOpenShell is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with IfcOpenShell.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Regenerate a parametric dimension annotation from its BBIM_Dimension anchors.
+
+This module operates purely on IFC data.  It:
+  1. Reads the ``Anchors`` JSON array from the ``BBIM_Dimension`` pset on an
+     ``IfcAnnotation``.
+  2. Resolves each anchor to a world-space point (IFC project units) using
+     ``resolve_anchor``.
+  3. Computes per-segment distances and updates (or creates) the linked
+     ``IfcMetric`` + ``IfcRelAssociatesConstraint`` entities.
+  4. Returns the ordered list of resolved world-space points so that the
+     Bonsai operator layer can update the Blender curve object.
+
+Updating the Blender curve (converting IFC world coords → annotation local
+coords) is the *caller's* responsibility and does **not** happen here.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from typing import Optional
+
+import ifcopenshell
+import ifcopenshell.api.owner
+import ifcopenshell.api.pset
+import ifcopenshell.geom
+import ifcopenshell.guid
+import ifcopenshell.util.element
+
+from .resolve_anchor import resolve_anchor
+
+
+_PSET_NAME = "BBIM_Dimension"
+_METRIC_INTENT_PREFIX = "PARAMETRIC_DIMENSION_SEG_"
+
+
+def regenerate_dimension(
+    file: ifcopenshell.file,
+    annotation: ifcopenshell.entity_instance,
+    settings: Optional[ifcopenshell.geom.settings] = None,
+    shape_cache: Optional[dict] = None,
+    placement_override: Optional[dict] = None,
+) -> list[tuple[float, float, float]]:
+    """Regenerate a parametric dimension from its stored anchor references.
+
+    Resolves every anchor in ``BBIM_Dimension.Anchors``, updates the
+    per-segment ``IfcMetric`` values (creating them when absent), and returns
+    the resolved world-space points in metres.
+
+    :param file: The open IFC file.
+    :param annotation: An ``IfcAnnotation`` with a ``BBIM_Dimension`` pset.
+    :param settings: Geometry settings for tessellation (shared across calls).
+    :param shape_cache: Shape cache dict (shared across calls for performance).
+    :param placement_override: Optional dict mapping element STEP id → 4×4 numpy
+        matrix (metres, row-major).  Pass ``{elem.id(): np.array(obj.matrix_world)}``
+        for each referenced element so that viewport moves not yet synced to the
+        IFC ``ObjectPlacement`` are reflected.  See ``resolve_anchor`` for details.
+    :return: Ordered list of ``(x, y, z)`` tuples, one per anchor.
+             Empty list if the pset is missing or malformed.
+    """
+    pset_data = ifcopenshell.util.element.get_pset(annotation, _PSET_NAME)
+    if not pset_data or "Anchors" not in pset_data:
+        return []
+
+    try:
+        anchors: list[dict] = json.loads(pset_data["Anchors"])
+    except (json.JSONDecodeError, TypeError):
+        return []
+
+    if not anchors:
+        return []
+
+    if shape_cache is None:
+        shape_cache = {}
+
+    resolved: list[Optional[tuple]] = []
+    for anchor in anchors:
+        pt = resolve_anchor(file, anchor, settings, shape_cache, placement_override)
+        if pt is None:
+            pt = tuple(anchor["pt"]) if anchor.get("pt") else (0.0, 0.0, 0.0)
+        resolved.append(pt)
+        anchor["pt"] = list(pt)
+
+    # ForcePerpendicularToFace: project vertices 1…n onto the line through
+    # pt[0] in the direction of anchor[0]'s face normal, so the polyline is
+    # constrained perpendicular to the face the first vertex is anchored to.
+    if pset_data.get("ForcePerpendicularToFace") and len(resolved) >= 2 and resolved[0] is not None:
+        normal = _get_anchor_face_normal_world(file, anchors[0], placement_override)
+        if normal:
+            base = resolved[0]
+            for i in range(1, len(resolved)):
+                if resolved[i] is None:
+                    continue
+                pt = resolved[i]
+                t = ((pt[0] - base[0]) * normal[0]
+                     + (pt[1] - base[1]) * normal[1]
+                     + (pt[2] - base[2]) * normal[2])
+                resolved[i] = (base[0] + t * normal[0],
+                                base[1] + t * normal[1],
+                                base[2] + t * normal[2])
+                anchors[i]["pt"] = list(resolved[i])
+
+    pset_entity_id = pset_data.get("id")
+    if pset_entity_id:
+        pset_entity = file.by_id(pset_entity_id)
+        ifcopenshell.api.pset.edit_pset(
+            file,
+            pset=pset_entity,
+            properties={"Anchors": json.dumps(anchors)},
+        )
+
+    n_segments = len(resolved) - 1
+    if n_segments >= 1:
+        existing_metrics = _get_segment_metrics(file, annotation)
+        _sync_segment_metrics(file, annotation, resolved, existing_metrics)
+
+    # LinePosition: project all points to a fixed absolute world coordinate along the
+    # horizontal offset axis (perpendicular to the dimension direction).  Applied after
+    # the pset write so anchor["pt"] always stores the true geometry surface hit.
+    # Because it is absolute, the dimension line stays put even if the geometry moves.
+    # Only active when ForcePerpendicularToFace is also set — the two are semantically coupled.
+    line_position = pset_data.get("LinePosition")
+    if line_position is not None and pset_data.get("ForcePerpendicularToFace") and resolved:
+        face_normal = _get_anchor_face_normal_world(file, anchors[0], placement_override)
+        offset_dir = _get_line_offset_direction(face_normal, [pt for pt in resolved if pt is not None])
+        if offset_dir:
+            resolved = [
+                _project_to_line_position(pt, offset_dir, float(line_position)) if pt is not None else None
+                for pt in resolved
+            ]
+
+    return [pt for pt in resolved if pt is not None]
+
+
+def get_dimension_segment_lengths(
+    file: ifcopenshell.file,
+    annotation: ifcopenshell.entity_instance,
+) -> list[float]:
+    """Return the segment lengths for a parametric dimension from stored anchor pts.
+
+    Distances are computed from the cached ``pt`` fields in ``BBIM_Dimension.Anchors``
+    (in metres, matching ifcopenshell.geom output).  Returns an empty list if the pset
+    is absent or malformed.
+    """
+    pset_data = ifcopenshell.util.element.get_pset(annotation, _PSET_NAME)
+    if not pset_data or not pset_data.get("Anchors"):
+        return []
+    try:
+        anchors: list[dict] = json.loads(pset_data["Anchors"])
+    except Exception:
+        return []
+    lengths: list[float] = []
+    for i in range(len(anchors) - 1):
+        pt_a = anchors[i].get("pt")
+        pt_b = anchors[i + 1].get("pt")
+        if pt_a and pt_b:
+            lengths.append(_dist(tuple(pt_a), tuple(pt_b)))
+        else:
+            lengths.append(0.0)
+    return lengths
+
+
+# ---------------------------------------------------------------------------
+# IfcMetric / IfcRelAssociatesConstraint management
+# ---------------------------------------------------------------------------
+
+
+def _get_segment_metrics(
+    file: ifcopenshell.file,
+    annotation: ifcopenshell.entity_instance,
+) -> dict[int, ifcopenshell.entity_instance]:
+    """Return {segment_index: IfcMetric} for all constraint rels on the annotation."""
+    metrics: dict[int, ifcopenshell.entity_instance] = {}
+    for rel in annotation.HasAssociations:
+        if not rel.is_a("IfcRelAssociatesConstraint"):
+            continue
+        intent: str = rel.Intent or ""
+        if not intent.startswith(_METRIC_INTENT_PREFIX):
+            continue
+        try:
+            seg_idx = int(intent[len(_METRIC_INTENT_PREFIX):])
+        except ValueError:
+            continue
+        constraint = rel.RelatingConstraint
+        if constraint.is_a("IfcMetric"):
+            metrics[seg_idx] = constraint
+    return metrics
+
+
+def _sync_segment_metrics(
+    file: ifcopenshell.file,
+    annotation: ifcopenshell.entity_instance,
+    resolved_pts: list[tuple],
+    existing: dict[int, ifcopenshell.entity_instance],
+) -> None:
+    """Create missing and update existing IfcMetric entities for each segment."""
+    n_segments = len(resolved_pts) - 1
+    seen_guids: set[str] = set()
+
+    # Build a lookup of which elements are at each anchor endpoint
+    pset_data = ifcopenshell.util.element.get_pset(annotation, _PSET_NAME)
+    anchors: list[dict] = []
+    if pset_data and pset_data.get("Anchors"):
+        try:
+            anchors = json.loads(pset_data["Anchors"])
+        except Exception:
+            pass
+
+    for seg_idx in range(n_segments):
+        if seg_idx in existing:
+            pass  # metric already exists; association is still valid
+        else:
+            # Create new IfcMetric + IfcRelAssociatesConstraint
+            # DataValue is IfcMetricValueSelect (entity-only SELECT in IFC4) — omit it;
+            # the measured distance is derivable from the anchor pt fields.
+            metric = file.create_entity(
+                "IfcMetric",
+                Name=f"seg_{seg_idx}",
+                ConstraintGrade="ADVISORY",
+                Benchmark="EQUALTO",
+            )
+            # Gather related products for this segment (the two anchor elements)
+            related: list[ifcopenshell.entity_instance] = [annotation]
+            for anchor_idx in (seg_idx, seg_idx + 1):
+                if anchor_idx < len(anchors):
+                    guid = anchors[anchor_idx].get("guid")
+                    if guid and guid not in seen_guids:
+                        try:
+                            elem = file.by_guid(guid)
+                            related.append(elem)
+                            seen_guids.add(guid)
+                        except Exception:
+                            pass
+
+            file.create_entity(
+                "IfcRelAssociatesConstraint",
+                GlobalId=ifcopenshell.guid.new(),
+                OwnerHistory=ifcopenshell.api.owner.create_owner_history(file),
+                Intent=f"{_METRIC_INTENT_PREFIX}{seg_idx}",
+                RelatingConstraint=metric,
+                RelatedObjects=related,
+            )
+
+    # Remove orphaned metrics for segments that no longer exist
+    for seg_idx, metric in existing.items():
+        if seg_idx >= n_segments:
+            for rel in file.get_inverse(metric):
+                if rel.is_a("IfcRelAssociatesConstraint"):
+                    file.remove(rel)
+            file.remove(metric)
+
+
+def _dist(a: tuple, b: tuple) -> float:
+    return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2)
+
+
+def _project_to_line_position(
+    pt: tuple, offset_dir: tuple, target: float
+) -> tuple[float, float, float]:
+    """Shift *pt* along *offset_dir* so its projection onto that axis equals *target*.
+
+    Keeps every other component of the point unchanged, so only the dimension line
+    is repositioned — the measured length stays the same.
+    """
+    current = pt[0] * offset_dir[0] + pt[1] * offset_dir[1] + pt[2] * offset_dir[2]
+    delta = target - current
+    return (
+        pt[0] + delta * offset_dir[0],
+        pt[1] + delta * offset_dir[1],
+        pt[2] + delta * offset_dir[2],
+    )
+
+
+def _get_anchor_face_normal_world(
+    file: ifcopenshell.file,
+    anchor: dict,
+    placement_override: Optional[dict] = None,
+) -> Optional[tuple[float, float, float]]:
+    """Return the world-space unit face normal stored in a FACE anchor, or None.
+
+    Reads ``normal_local`` (element-local, rotation-invariant) from the anchor
+    addr and rotates it to world space via the current element placement.
+    Also accepts the legacy ``addr.fingerprint.normal_local`` format.
+    """
+    if anchor.get("type") != "FACE":
+        return None
+    guid = anchor.get("guid")
+    if not guid:
+        return None
+    try:
+        element = file.by_guid(guid)
+    except Exception:
+        return None
+
+    addr = anchor.get("addr") or {}
+    from .resolve_anchor import _rotate_local_to_world
+
+    if addr.get("method") == "LAYER_BOUNDARY":
+        import ifcopenshell.util.element as _ifc_elem
+        usage = _ifc_elem.get_material(element, should_inherit=True)
+        if not usage or not usage.is_a("IfcMaterialLayerSetUsage"):
+            return None
+        axis = (getattr(usage, "LayerSetDirection", None) or "AXIS2")
+        if axis == "AXIS1":
+            normal_local: tuple = (1.0, 0.0, 0.0)
+        elif axis == "AXIS3":
+            normal_local = (0.0, 0.0, 1.0)
+        else:
+            normal_local = (0.0, 1.0, 0.0)
+    else:
+        # FACE_NORMAL: normal_local stored in addr (new) or addr.fingerprint (legacy).
+        normal_local = addr.get("normal_local") or (addr.get("fingerprint") or {}).get("normal_local")
+        if not normal_local:
+            return None
+
+    n = _rotate_local_to_world(element, normal_local, placement_override)
+    mag = math.sqrt(n[0] ** 2 + n[1] ** 2 + n[2] ** 2)
+    return (n[0] / mag, n[1] / mag, n[2] / mag) if mag > 1e-12 else None
+
+
+def _get_line_offset_direction(
+    face_normal: Optional[tuple[float, float, float]],
+    resolved_pts: list[tuple],
+) -> Optional[tuple[float, float, float]]:
+    """Return the direction to apply LineOffset — parallel to the first face.
+
+    Uses cross(world_Z, dim_direction) to get the horizontal direction
+    perpendicular to the dimension line, which slides the line sideways
+    (parallel to the face) rather than into/out of it.
+
+    Falls back to cross(face_normal, world_Z) when the dimension line is
+    nearly vertical (e.g. elevation dimensions).
+    """
+    world_z = (0.0, 0.0, 1.0)
+
+    # Primary: use the dimension line direction (anchor[0] → anchor[1])
+    if len(resolved_pts) >= 2:
+        a, b = resolved_pts[0], resolved_pts[1]
+        dx, dy, dz = b[0] - a[0], b[1] - a[1], b[2] - a[2]
+        dim_mag = math.sqrt(dx * dx + dy * dy + dz * dz)
+        if dim_mag > 1e-10:
+            dim_dir = (dx / dim_mag, dy / dim_mag, dz / dim_mag)
+            # cross(world_Z, dim_dir) — horizontal direction perp to dimension
+            d = (
+                world_z[1] * dim_dir[2] - world_z[2] * dim_dir[1],
+                world_z[2] * dim_dir[0] - world_z[0] * dim_dir[2],
+                world_z[0] * dim_dir[1] - world_z[1] * dim_dir[0],
+            )
+            mag = math.sqrt(d[0] ** 2 + d[1] ** 2 + d[2] ** 2)
+            if mag > 1e-6:
+                return (d[0] / mag, d[1] / mag, d[2] / mag)
+
+    # Fallback for vertical dims: cross(face_normal, world_Z)
+    if face_normal:
+        n = face_normal
+        d = (
+            n[1] * world_z[2] - n[2] * world_z[1],
+            n[2] * world_z[0] - n[0] * world_z[2],
+            n[0] * world_z[1] - n[1] * world_z[0],
+        )
+        mag = math.sqrt(d[0] ** 2 + d[1] ** 2 + d[2] ** 2)
+        if mag > 1e-6:
+            return (d[0] / mag, d[1] / mag, d[2] / mag)
+
+    return None
@@ -420,7 +420,15 @@ class SchemaClass(codegen.Base):

            if isinstance(type, nodes.AggregationType):
                aggr_type = type.aggregate_type
-                make_bound = lambda b: -1 if b == "?" else int(b)
+
+                def make_bound(b):
+                    # `?` and non-literal bounds (attribute references, arithmetic expressions) collapse to -1.
+                    #
+                    try:
+                        return int(b)
+                    except (TypeError, ValueError):
+                        return -1
+
                bound1, bound2 = map(make_bound, (type.bounds.lower, type.bounds.upper))
                decl_type = get_declared_type(type.type, emitted_names)
                return x.aggregation_type(aggr_type, bound1, bound2, decl_type)
@@ -547,7 +555,16 @@ class SchemaClass(codegen.Base):
                inv_attrs = []
                for attr in type.inverse:
                    if attr.bounds:
-                        make_bound = lambda b: -1 if b == "?" else int(b)
+
+                        def make_bound(b):
+                            # `?` and non-literal bounds (attribute references, arithmetic
+                            # expressions) collapse to -1 (unbounded) — the C++ runtime has
+                            # no third state for "dynamic cardinality".
+                            try:
+                                return int(b)
+                            except (TypeError, ValueError):
+                                return -1
+
                        bound1, bound2 = map(make_bound, (attr.bounds.lower, attr.bounds.upper))
                    else:
                        bound1, bound2 = -1, -1
@@ -0,0 +1,74 @@
+import os
+import sys
+import tempfile
+import unittest
+
+import ifcopenshell.express
+
+sys.path.insert(0, os.path.dirname(ifcopenshell.express.__file__))
+
+
+def _parse(schema_text):
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".exp", delete=False) as f:
+        f.write(schema_text)
+        path = f.name
+    try:
+        return ifcopenshell.express.parse(path)
+    finally:
+        os.unlink(path)
+        cache = path + ".cache.dat"
+        if os.path.exists(cache):
+            os.unlink(cache)
+
+
+class TestAggregateBounds(unittest.TestCase):
+    def test_literal_bounds_preserved(self):
+        """After loading [1;3] -> (1, 3)?"""
+        s = _parse("SCHEMA t; ENTITY E; v : ARRAY [1:3] OF REAL; END_ENTITY; END_SCHEMA;")
+        agg = (
+            next(d for d in s.schema.declarations() if d.name() == "E")
+            .attributes()[0]
+            .type_of_attribute()
+            .as_aggregation_type()
+        )
+        self.assertEqual((agg.bound1(), agg.bound2()), (1, 3))
+        s.disown()
+
+    def test_unbounded_marker(self):
+        """[0:?] -> (0, -1)?"""
+        s = _parse("SCHEMA t; ENTITY E; v : LIST [0:?] OF REAL; END_ENTITY; END_SCHEMA;")
+        agg = (
+            next(d for d in s.schema.declarations() if d.name() == "E")
+            .attributes()[0]
+            .type_of_attribute()
+            .as_aggregation_type()
+        )
+        # import pdb; pdb.set_trace()
+        self.assertEqual((agg.bound1(), agg.bound2()), (0, -1))
+        s.disown()
+
+    def test_voxel_grid_with_dynamic_bound_loads(self):
+        """
+        Array that is an expression :  [1:dim_x*dim_y*dim_z]
+        Parsing must not crash, Bbund must be (1, -1)
+        """
+        s = _parse("""
+            SCHEMA t;
+            TYPE IfcBoolean = BOOLEAN; END_TYPE;
+
+            ENTITY IfcVoxelHolder;
+              NumberOfVoxelsX : INTEGER;
+              NumberOfVoxelsY : INTEGER;
+              NumberOfVoxelsZ : INTEGER;
+              Voxels : ARRAY [1:NumberOfVoxelsX*NumberOfVoxelsY*NumberOfVoxelsZ] OF IfcBoolean;
+            END_ENTITY;
+            END_SCHEMA;
+            """)
+        holder = next(d for d in s.schema.declarations() if d.name() == "IfcVoxelHolder")
+        voxels = holder.attributes()[-1].type_of_attribute().as_aggregation_type()
+        self.assertEqual((voxels.bound1(), voxels.bound2()), (1, -1))
+        s.disown()
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -432,6 +432,15 @@ class DebugWriter {
        }
    }

+    void write_point(const Point_2& p, const std::string& name) {
+        if (enabled_) {
+            obj << "o " << name << "\n";
+            obj << "v " << CGAL::to_double(p.x()) << " " << CGAL::to_double(p.y()) << " 0\n";
+            vi++;
+            svg << "<circle class=\"" << name << "\" cx=\"" << CGAL::to_double(p.x()) << "\" cy=\"" << -CGAL::to_double(p.y()) << "\" r=\"0.5\" />\n";
+        }
+    }
+
    void write_polygon(const Polygon_with_holes_2& polygon, const std::string& name) {
        if (enabled_) {
            write_polygon(polygon.outer_boundary(), name);
@@ -452,6 +461,20 @@ class DebugWriter {
        }
    }

+    void write_polygons(const Arrangement_2& arr, const std::string& name) {
+        if (enabled_) {
+            // Just for the automatic numbering, create a full vector
+            std::vector<Polygon_2> temp;
+            for (auto it = arr.faces_begin(); it != arr.faces_end(); ++it) {
+                if (it->is_unbounded()) {
+                    continue;
+                }
+                temp.push_back(circ_to_poly(it->outer_ccb()));
+            }
+            write_polygons(temp, name);
+        }
+    }
+
    void write_polygons(const std::vector<Polygon_with_holes_2>& polygons, const std::string& name) {
        if (enabled_) {
            size_t i = 0;
@@ -475,7 +498,14 @@ class DebugWriter {
    std::string last_segment_name_;
    
    void write_polygon_to_svg_(std::ostream& ofs, const Polygon_2& polygon, const std::string& class_name = "") {
-        ofs << "<polygon class=\"" + class_name + "\" points=\"";
+        auto class_name_ = class_name;
+        if (!polygon.is_simple()) {
+            if (!class_name_.empty()) {
+                class_name_ += " ";
+            }
+            class_name_ += "self_intersecting";
+        }
+        ofs << "<polygon class=\"" + class_name_ + "\" points=\"";
        for (auto vit = polygon.vertices_begin(); vit != polygon.vertices_end(); ++vit) {
            ofs << CGAL::to_double(vit->x()) << "," << -CGAL::to_double(vit->y()) << " ";
        }
@@ -804,6 +834,10 @@ class SegmentLookup {
        return out;
    }

+    PolygonIt end() const {
+        return polygons_ref_.end();
+    }
+
 private:
    using TreeTraits = CGAL::AABB_traits<K, CGAL::AABB_segment_primitive<K, std::list<CGAL::Segment_3<K>>::iterator>>;
    using Tree = CGAL::AABB_tree<TreeTraits>;
@@ -816,25 +850,33 @@ private:
    std::map<Point_2, std::vector<Polygon_2>::const_iterator> input_polygon_boundary_cache_;
 };

-Polygon_2 subdivide_polygon(double max_distance, const Polygon_2 & p) {
+Polygon_2 subdivide_polygon_on_same_input(SegmentLookup& segment_lookup, double max_distance, const Polygon_2& p, std::map<Point_2, SegmentLookup::PolygonIt>& point_lookup) {
    std::vector<Point_2> points;
    for (auto it = p.edges_begin(); it != p.edges_end(); ++it) {
+        auto source_poly = segment_lookup.input_polygon_boundary(it->source());
+        auto target_poly = segment_lookup.input_polygon_boundary(it->target());
        const auto& seg = *it;
-        auto num_splits = (int)std::ceil(std::sqrt(CGAL::to_double(seg.squared_length())) / max_distance) - 1;
        points.push_back(seg.source());
-        for (auto i = 0; i < num_splits; ++i) {
-            auto d = (seg.target() - seg.source()) / (num_splits + 1) * (i + 1);
-            points.push_back(seg.source() + d);
+        if (source_poly == target_poly && source_poly != segment_lookup.end()) {
+            point_lookup.emplace(seg.source(), source_poly);
+            point_lookup.emplace(seg.target(), source_poly);
+            auto num_splits = (int)std::ceil(std::sqrt(CGAL::to_double(seg.squared_length())) / max_distance) - 1;
+            for (auto i = 0; i < num_splits; ++i) {
+                auto d = (seg.target() - seg.source()) / (num_splits + 1) * (i + 1);
+                auto p = seg.source() + d;
+                point_lookup.emplace(p, source_poly);
+                points.push_back(p);
+            }
        }
    }
    return Polygon_2(points.begin(), points.end());
 };

-Polygon_with_holes_2 subdivide_polygon(double max_distance, const Polygon_with_holes_2& pwh) {
-    Polygon_2 outer = subdivide_polygon(max_distance, pwh.outer_boundary());
+Polygon_with_holes_2 subdivide_polygon_on_same_input(SegmentLookup& segment_lookup, double max_distance, const Polygon_with_holes_2& pwh, std::map<Point_2, SegmentLookup::PolygonIt>& point_lookup) {
+    Polygon_2 outer = subdivide_polygon_on_same_input(segment_lookup, max_distance, pwh.outer_boundary(), point_lookup);
    std::vector<Polygon_2> holes;
    for (auto hit = pwh.holes_begin(); hit != pwh.holes_end(); ++hit) {
-        holes.push_back(subdivide_polygon(max_distance, *hit));
+        holes.push_back(subdivide_polygon_on_same_input(segment_lookup, max_distance, *hit, point_lookup));
    }
    return Polygon_with_holes_2(outer, holes.begin(), holes.end());
 };
@@ -845,7 +887,7 @@ std::tuple<
    std::map<std::pair<Point_2, Point_2>, std::vector<const CGAL::Polygon_2<K>*>>,
    std::map<Point_2, double>
 >
-build_line_graph(const std::vector<Polygon_2>& input_polygons, SegmentLookup& segment_lookup, const std::vector<Polygon_2>& triangular_polygons)
+build_line_graph(const std::vector<Polygon_2>& input_polygons, const std::map<Point_2, SegmentLookup::PolygonIt>& point_lookup, const std::vector<Polygon_2>& triangular_polygons)
 {

    // Build maps of triangle -> edge and edge -> triangle in order to do traversal on the 'corridor mesh'
@@ -874,13 +916,17 @@ build_line_graph(const std::vector<Polygon_2>& input_polygons, SegmentLookup& se
    for (auto& p : segment_to_facet) {
        auto center = CGAL::ORIGIN + (((p.first.first - CGAL::ORIGIN) + (p.first.second - CGAL::ORIGIN)) / 2);

-        auto p1index = segment_lookup.input_polygon_boundary(p.first.first);
-        auto p2index = segment_lookup.input_polygon_boundary(p.first.second);
+        auto p1index = point_lookup.find(p.first.first);
+        auto p2index = point_lookup.find(p.first.second);

-        segment_to_input_facet[p.first].push_back(&*p1index);
-        segment_to_input_facet[p.first].push_back(&*p2index);
+        if (p1index == point_lookup.end() || p2index == point_lookup.end()) {
+            continue;
+        }

-        if (p1index != input_polygons.end() && p2index != input_polygons.end() && p1index != p2index) {
+        segment_to_input_facet[p.first].push_back(&*p1index->second);
+        segment_to_input_facet[p.first].push_back(&*p2index->second);
+
+        if (p1index->second != input_polygons.end() && p2index->second != input_polygons.end() && p1index->second != p2index->second) {
            segment_to_midpoint[p.first] = center;
            midpoint_to_segment[center] = p.first;
            midpoint_to_edge_length[center] = std::sqrt(CGAL::to_double(CGAL::squared_distance(p.first.first, p.first.second)));
@@ -1039,6 +1085,45 @@ bool aabb_overlap(const DBox& a, const DBox& b, double eps = 1.e-9) {
           a[1].y() + eps >= b[0].y();
 }

+std::pair<double, double> projected_interval_on_axis(const std::array<DPoint, 4>& points, const DDir& axis_u) {
+    auto u = unit(axis_u);
+    auto t0 = (points.front() - CGAL::ORIGIN) * u;
+    auto interval = std::make_pair(t0, t0);
+    for (auto& p : points) {
+        auto t = (p - CGAL::ORIGIN) * u;
+        interval.first = std::min(interval.first, t);
+        interval.second = std::max(interval.second, t);
+    }
+    return interval;
+}
+
+bool intervals_overlap(const std::pair<double, double>& a, const std::pair<double, double>& b, double eps = 1.e-9) {
+    return a.first <= b.second + eps && b.first <= a.second + eps;
+}
+
+bool obb_overlap(const std::array<DPoint, 4>& a, const std::array<DPoint, 4>& b, double eps = 1.e-9) {
+    auto has_separating_axis = [&](const std::array<DPoint, 4>& points) {
+        for (size_t i = 0; i < points.size(); ++i) {
+            auto edge = points[(i + 1) % points.size()] - points[i];
+            auto axis = unit(perpendicular(edge));
+            if (axis.squared_length() < 1.e-18) {
+                continue;
+            }
+            if (!intervals_overlap(projected_interval_on_axis(a, axis), projected_interval_on_axis(b, axis), eps)) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    return !has_separating_axis(a) && !has_separating_axis(b);
+}
+
+template <typename T, typename U>
+bool obb_overlap(const T& a, const U& b, double eps = 1.e-9) {
+    return obb_overlap(a.corners, b.corners, eps);
+}
+
 CenterLineGraphData make_center_line_graph_data(
    const std::map<Point_2, std::vector<Point_2>>& line_graph,
    const std::map<Point_2, double>& midpoint_to_edge_length)
@@ -1332,6 +1417,9 @@ bool clusters_can_merge(const BoxCluster& a, const BoxCluster& b, double angle_t
    if (!aabb_overlap(a.box.bbox, b.box.bbox)) {
        return false;
    }
+    if (!obb_overlap(a.box, b.box)) {
+        return false;
+    }
    if (angle_between_dirs_deg(a.box.direction, b.box.direction) > angle_tol_deg) {
        return false;
    }
@@ -1522,8 +1610,11 @@ std::map<Point_2, std::vector<Point_2>> snap_points_to_box_axes(
            return a.line_distance < b.line_distance;
        });

-        if ((snapped_points[i] - best.projection).squared_length() < (max_projection_distance * max_projection_distance)) {
+        if ((graph.points[i] - best.projection).squared_length() < (max_projection_distance * max_projection_distance)) {
            snapped_points[i] = best.projection;
+        } else {
+            snapped_points[i] = graph.points[i];
+            std::cout << "Warning: snapping distance exceeding distance: " << std::sqrt(CGAL::to_double((snapped_points[i] - best.projection).squared_length())) << " > " << max_projection_distance << std::endl;
        }
    }

@@ -2078,6 +2169,7 @@ extend_end_vertices_based_on_input_simple(
    const Polygon_list& outer_perimiter,
    const K::FT& max_projection_distance)
 {
+    auto max_intersection_distance = max_projection_distance / 4;
    std::list<std::pair<Point_2, Point_2>> constructed_segments;

        for (auto it = G.vertices_begin(); it != G.vertices_end(); ++it) {
@@ -2103,7 +2195,7 @@ extend_end_vertices_based_on_input_simple(
                            if (auto* xp = variant_get<CGAL::Point_2<K>>(&*x)) {
                                auto dist = ((*xp) - M).squared_length();
                                if (dist < sq_distance_along_ray) {
-                                    if (dist < (max_projection_distance * max_projection_distance)) {
+                                    if (dist < (max_intersection_distance * max_intersection_distance)) {
                                        closest_segment = seg;
                                        closest_intersection_point = *xp;
                                        sq_distance_along_ray = dist;
@@ -2139,6 +2231,26 @@ extend_end_vertices_based_on_input_simple(

                        if (closest_point) {
                            constructed_segments.push_front({M, *closest_point});
+                        } else {
+
+                            for (auto& poly : outer_perimiter) {
+                                for (auto it = poly.begin(); it != poly.end(); ++it) {
+                                    auto Pp = *it;
+                                    auto d = CGAL::squared_distance(Pp, M);
+                                    if (d < (max_projection_distance * max_projection_distance)) {
+                                        if (d < closest_distance) {
+                                            closest_distance = d;
+                                            closest_point = Pp;
+                                        }
+                                    }
+                                }
+                            }
+
+                            if (closest_point) {
+                                constructed_segments.push_front({M, *closest_point});
+                            } else {
+                                std::cout << "Unable to find projection or intersection point for interior boundary (" << M.x() << " " << M.y() << ")" << std::endl;
+                            }
                        }
                    }
                }
@@ -2261,9 +2373,9 @@ std::vector<K::FT> arrangement_cell_iou(DebugWriter& debug_output, Arrangement_2
            for (auto hit = it->inner_ccbs_begin(); hit != it->inner_ccbs_end(); ++hit) {
                pwh.add_hole(circ_to_poly(*hit));
            }
-            if (!pwh.outer_boundary().is_simple()) {
-                throw std::runtime_error("Polygon with holes has a non-simple outer boundary");
-            }
+            // if (!pwh.outer_boundary().is_simple()) {
+            //     throw std::runtime_error("Polygon with holes has a non-simple outer boundary");
+            // }

            CGAL::Polygon_triangulation_decomposition_2<K> decompositor;
            std::vector<Polygon_2> temp;
@@ -2312,6 +2424,8 @@ std::vector<K::FT> arrangement_cell_iou(DebugWriter& debug_output, Arrangement_2

                visited_points.insert(best_point);

+                debug_output.write_point(best_point, "representative_point representative_point_" + std::to_string(std::distance(left.faces_begin(), it)));
+
                auto res = walk_pl.locate(best_point);
                if (auto* v = variant_get<Arrangement_2::Face_const_handle>(&res)) {
                    if ((*v)->is_unbounded()) {
@@ -2321,6 +2435,7 @@ std::vector<K::FT> arrangement_cell_iou(DebugWriter& debug_output, Arrangement_2
                    if (visited_faces_on_right.count(*v) > 0) {
                        // Maybe we should be more permissive, try some other points etc.
                        return_values.push_back(0);
+                        std::cout << "Already visited face on right, skipping point\n";
                    } else {
                        // convert arr facet to polygon with holes
                        auto polygon_exterior = circ_to_poly((*v)->outer_ccb());
@@ -2328,9 +2443,9 @@ std::vector<K::FT> arrangement_cell_iou(DebugWriter& debug_output, Arrangement_2
                        for (auto hit = (*v)->inner_ccbs_begin(); hit != (*v)->inner_ccbs_end(); ++hit) {
                            pwh_right.add_hole(circ_to_poly(*hit));
                        }
-                        if (!pwh_right.outer_boundary().is_simple()) {
-                            throw std::runtime_error("Polygon with holes has a non-simple outer boundary");
-                        }
+                        // if (!pwh_right.outer_boundary().is_simple()) {
+                        //     throw std::runtime_error("Polygon with holes has a non-simple outer boundary");
+                        // }

                        // compute intersection over union of pwh and the original polygon
                        if (CGAL::do_intersect(pwh, pwh_right)) {
@@ -2358,6 +2473,7 @@ std::vector<K::FT> arrangement_cell_iou(DebugWriter& debug_output, Arrangement_2
                                max_deviation_poly_pair = {pwh.outer_boundary(), pwh_right.outer_boundary()};
                            }
                        } else {
+                            std::cout << "No intersection, skipping point\n";
                            return_values.push_back(0);
                        }
                    }
@@ -3061,6 +3177,7 @@ size_t delete_same_facet_edge_pairs(Arrangement_2& arr) {
 }

 void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std::vector<Polygon_2>& input_polygons_, std::vector<Polygon_2>& output_polygons, double polygon_offset_distance = -1.) {
+
    static const double OVERLAP_RESOLUTION_DISTANCE = 1.e-1;
    // even larger amount of inset so that outer perimeter is safely within all input polygons even when overlap resolution is applied
    // no, `1.e-2 + 1.e-5` creates issues with the outer perimeter, are there other tolerances in play?
@@ -3222,13 +3339,17 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std
    t0.stop();
    t0 = timer.start("corridor triangulation");

+    SegmentLookup segment_lookup(input_polygons);
+
    // subdivide difference_result to have better more detailed triangulation and therefore less-pronounced artefacts in midpoint network

+    // We store correspondence of subdivision points to input polygons when subdividing so that we do not need to query, which is expensive, when building the line graph later on.
+    std::map<Point_2, SegmentLookup::PolygonIt> point_lookup;
+
    auto subdivision_length = polygon_offset_distance / settings.subdivision_factor;

    for (auto& pwh : difference_result) {
-        difference_result_subdivided.push_back(subdivide_polygon(subdivision_length, pwh));
-        // difference_result_subdivided.push_back(subdivide_polygon(polygon_offset_distance / 64., pwh));
+        difference_result_subdivided.push_back(subdivide_polygon_on_same_input(segment_lookup, subdivision_length, pwh, point_lookup));
    }

    debug_output.write_polygons(difference_result_subdivided, "corridor_subdivided");
@@ -3253,9 +3374,7 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std

    debug_output.write_polygons(triangular_polygons, "triangulated_corridor");

-    SegmentLookup segment_lookup(input_polygons);
-
-    auto [line_graph, midpoint_to_segment, segment_to_input_facet, midpoint_to_edge_length] = build_line_graph(input_polygons, segment_lookup, triangular_polygons);
+    auto [line_graph, midpoint_to_segment, segment_to_input_facet, midpoint_to_edge_length] = build_line_graph(input_polygons, point_lookup, triangular_polygons);
    for (auto& p : line_graph) {
        for (auto& q : p.second) {
            debug_output.write_segment(p.first, q, "network_1");
@@ -3267,8 +3386,43 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std
    t0 = timer.start("center line cleaning");

    Graph2D<K> G;
+
+    {
+        // this is applied for both algos
+        auto eliminated_segments = eliminate_triangles(line_graph);
+        for (auto e : eliminated_segments) {
+            debug_output.write_segment(e.first, e.second, "eliminated");
+            for (int i = 0; i < 2; ++i) {
+                auto it = line_graph.find(e.first);
+                if (it == line_graph.end()) {
+                    std::cerr << "Warning: unable to locate vertex for elimination, skipping" << std::endl;
+                    continue;
+                }
+                auto& neighbours = it->second;
+                neighbours.erase(std::remove(neighbours.begin(), neighbours.end(), e.second), neighbours.end());
+                if (neighbours.empty()) {
+                    line_graph.erase(it);
+                }
+                std::swap(e.first, e.second);
+            }
+        }
+    }
+
    Graph2D<K> G_orig(line_graph);

+    auto apply_line_cleaning_algo_1 = [&]() {
+        Graph2D<K> G2(line_graph);
+        G = G2.weld_vertices();
+        for (auto it = G.edges_begin(); it != G.edges_end(); ++it) {
+            debug_output.write_segment(it->first, it->second, "network_2");
+        }
+        eliminate_colinear_vertices(G);
+        edge_slide(G);
+        for (auto it = G.edges_begin(); it != G.edges_end(); ++it) {
+            debug_output.write_segment(it->first, it->second, "network_3");
+        }
+    };
+
    if (settings.line_cleaning_algo == 0) {
        G = join_segment_runs(debug_output, line_graph, midpoint_to_edge_length, subdivision_length * 4);
        Arrangement_2 arr;
@@ -3281,27 +3435,7 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std
            debug_output.write_segment(it->first, it->second, "network_2");
        }
    } else {
-        auto eliminated_segments = eliminate_triangles(line_graph);
-
-        Graph2D<K> G2(line_graph);
-        for (auto& e : eliminated_segments) {
-            debug_output.write_segment(e.first, e.second, "eliminated");
-            G2.remove_edge(e.first, e.second);
-        }
-
-        G = G2.weld_vertices();
-
-        for (auto it = G.edges_begin(); it != G.edges_end(); ++it) {
-            debug_output.write_segment(it->first, it->second, "network_2");
-        }
-
-        eliminate_colinear_vertices(G);
-
-        edge_slide(G);
-
-        for (auto it = G.edges_begin(); it != G.edges_end(); ++it) {
-            debug_output.write_segment(it->first, it->second, "network_3");
-        }
+        apply_line_cleaning_algo_1();
    }

    t0.stop();
@@ -3309,10 +3443,11 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std
    t0 = timer.start("topology");

    std::list<std::pair<Point_2, Point_2>> segments, segments1, segments2;
+    bool fallback_to_line_cleaning_algo_1 = false;
    
    if (settings.line_cleaning_algo == 0) {
-        segments1 = extend_end_vertices_based_on_input_simple(G, outer_perimiter, subdivision_length * 4);
-        segments2 = extend_end_vertices_based_on_input_simple(G_orig, outer_perimiter, subdivision_length * 4);
+        segments1 = extend_end_vertices_based_on_input_simple(G, outer_perimiter, subdivision_length * 16);
+        segments2 = extend_end_vertices_based_on_input_simple(G_orig, outer_perimiter, subdivision_length * 16);
        
        Arrangement_2 arr_clean;
        G.to_arrangement(arr_clean);
@@ -3332,9 +3467,6 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std
            CGAL::insert(arr_orig, Segment_2(pq.first, pq.second));
        }

-        delete_same_facet_edge_pairs(arr_clean);
-        delete_same_facet_edge_pairs(arr_orig);
-
        for (auto& p : outer_perimiter) {
            for (auto it = p.edges_begin(); it != p.edges_end(); ++it) {
                auto source = it->source();
@@ -3347,6 +3479,12 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std
            }
        }

+        delete_same_facet_edge_pairs(arr_clean);
+        delete_same_facet_edge_pairs(arr_orig);
+
+        debug_output.write_polygons(arr_clean, "iou_left");
+        debug_output.write_polygons(arr_orig, "iou_right");
+
        auto ious = arrangement_cell_iou(debug_output, arr_clean, arr_orig);
        /*
        for (auto& iou : ious) {
@@ -3357,14 +3495,16 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std

        auto it = std::min_element(ious.begin(), ious.end());

-        if (it != ious.end() && (*it < 0.5)) {
+        if (it != ious.end() && (*it < 0.45)) {
            std::cerr << "Significant difference between cleaned and original arrangement, using original for topology reconstruction: " << *it << std::endl;
-            segments = segments2;
-            G = G_orig;
+            fallback_to_line_cleaning_algo_1 = true;
+            apply_line_cleaning_algo_1();
        } else {
            segments = segments1;
        }
-    } else {
+    }
+
+    if (settings.line_cleaning_algo != 0 || fallback_to_line_cleaning_algo_1) {
        segments = extend_end_vertices_based_on_input(G, midpoint_to_segment, segment_to_input_facet, outer_perimiter, segment_lookup, subdivision_length * 4);
    }   

@@ -3408,15 +3548,7 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std
        }
    }

-    // Just for the automatic numbering, create a full vector
-    std::vector<Polygon_2> temp;
-    for (auto it = arr.faces_begin(); it != arr.faces_end(); ++it) {
-        if (it->is_unbounded()) {
-            continue;
-        }
-        temp.push_back(circ_to_poly(it->outer_ccb()));
-    }
-    debug_output.write_polygons(temp, "arr_faces");
+    debug_output.write_polygons(arr, "arr_faces");


    /* {
@@ -178,6 +178,9 @@ public:
        std::vector<CGAL::Segment_2<Kernel>> segments;
        for (const auto& p : adjacency_list) {
            for (const auto& q : p.second) {
+                if (p.first == q) {
+                    return false;
+                }
                if (p.first < q) {
                    segments.emplace_back(p.first, q);
                }
@@ -198,7 +201,7 @@ public:
                any = true;
            }
        });
-        return any;
+        return !any;
    }

    // Eliminates a vertex with exactly two neighbors by connecting its neighbors
@@ -338,12 +341,21 @@ public:

    template <typename T>
    void to_arrangement(T& arr) {
-        for (auto it = edges_begin(); it != edges_end(); ++it) {
-            if (it->first == it->second) {
-                continue;
+        if (is_valid() && arr.is_empty()) {
+            std::vector<CGAL::Segment_2<Kernel>> edges;
+            
+            for (auto it = edges_begin(); it != edges_end(); ++it) {
+                edges.emplace_back(it->first, it->second);
            }
-            CGAL::insert(arr, CGAL::Segment_2<Kernel>(it->first, it->second));
-        }
+            CGAL::insert_non_intersecting_curves(arr, edges.begin(), edges.end());
+        } else {
+            for (auto it = edges_begin(); it != edges_end(); ++it) {
+                if (it->first == it->second) {
+                    continue;
+                }
+                CGAL::insert(arr, CGAL::Segment_2<Kernel>(it->first, it->second));
+            }
+        }        
    }

    template <typename T>