kompas-kernel 0.0.1__py3-none-any.whl

kompas_kernel/features/geometry_3d/ksapi/measurements.py

@@ -0,0 +1,368 @@
+"""Distance/neighbor/ray-pick measurements over `IMeasurement3D` and `PickModelObjectsWithLimit`.
+
+Free functions taking explicit `modules`/`app` dependencies (no adapter `self` state) —
+same shape as `component_geometry.py`. Component identifier resolution
+(`resolve_component`/`component_by_identifier`) is imported from there, not duplicated
+(E16.04a dedup step).
+"""
+
+from __future__ import annotations
+
+import math
+import time
+from typing import Any
+
+from kompas_kernel.features.geometry_3d.ksapi.component_geometry import (
+    bool_xyz_point,
+    component_by_identifier,
+    resolve_component,
+)
+from kompas_kernel.features.geometry_3d.models import DistanceMeasurement, NeighborHit, NeighborsResult, RayHit
+from kompas_kernel.kompas.errors import KompasError
+from kompas_kernel.kompas.models import Point3D
+from kompas_kernel.kompas.objects import as_document_3d, constants3d_class
+from kompas_kernel.kompas.runtime import KsApiModules
+from kompas_kernel.observability.logger import get_logger
+from kompas_kernel.observability.taxonomy import LogDomain, LogEventType, event_name
+
+logger = get_logger(__name__)
+
+_KSAPI_BOOL_XYZ_VALUE_COUNT = 4
+_POINT3D_COORDINATE_COUNT = 3
+_PART_ORIGIN_MATCH_TOLERANCE_MM = 1e-6
+_GABARIT_VALUE_COUNT = 7  # (ok, x1, y1, z1, x2, y2, z2)
+
+
+def measure_min_distance(
+    modules: KsApiModules,
+    app: Any,
+    component_identifier_1: str,
+    component_identifier_2: str,
+) -> DistanceMeasurement:
+    """Measure minimum distance between two top-level components in one call.
+
+    Transient `IMeasurement3D` (`IPart.GetMeasurement3D()`), spike 11: computes
+    `IPart <-> IPart` directly (unlike `IDistanceAngleMeasurement3D`, which spike 02
+    found only computes `IFace <-> IFace` and needed a 37-54-call face-pair perimeter
+    per component pair). `IMeasurement3D` is an `IKompasAPIObject`, not an
+    `IModelObject` — no `Add()`/`Delete()`, nothing enters a document collection.
+    The measurement object itself is cached on `IPart` (`GetMeasurement3D()` returns
+    the same reference on repeated calls), but each call here still does a
+    fresh
+    `SetObject1/2` + `Calculate()`, so the result is always freshly computed for the
+    requested pair.
+    """
+    _doc3d, top, components, component_1 = resolve_component(
+        modules, app, "measure_min_distance", component_identifier_1
+    )
+    component_2 = component_by_identifier("measure_min_distance", components, component_identifier_2)
+    constants3d = constants3d_class(modules)
+
+    measurement = top.GetMeasurement3D()
+    if not measurement:
+        raise KompasError("measure_min_distance: IPart.GetMeasurement3D() is unavailable")
+
+    measurement.SetObject1(component_1)
+    measurement.SetObject2(component_2)
+    started_at = time.perf_counter()
+    result_code = int(measurement.Calculate())
+    elapsed_s = time.perf_counter() - started_at
+
+    # ksMResUnknown=0 (constants3d.py) is the documented "not computed" result
+    # (spike 02: IPart<->IPart via IDistanceAngleMeasurement3D stuck at exactly this
+    # code when it couldn't calculate). Every other code (ksMResCalculate=-1, or one
+    # of the specific axis/surface relationship codes 1-13) means Calculate() produced
+    # a real answer — spike 11 saw -1 for part/body pairs and 2 (AxisAxisParallel) for
+    # a face-level calibration pair, both valid.
+    if result_code == int(constants3d.ksMResUnknown):
+        raise KompasError(
+            "measure_min_distance: IMeasurement3D.Calculate() could not determine a distance for "
+            f"components {component_identifier_1!r} and {component_identifier_2!r} (ksMResUnknown)"
+        )
+
+    # Spike 11 flagged result "stickiness" on a failing pair as unverified — validate
+    # Lmin/points defensively instead of trusting a non-zero result code alone.
+    distance_mm = float(measurement.GetLmin())
+    if not math.isfinite(distance_mm) or distance_mm < 0:
+        raise KompasError(
+            f"measure_min_distance: IMeasurement3D returned invalid Lmin={distance_mm!r} for "
+            f"components {component_identifier_1!r} and {component_identifier_2!r} "
+            f"(Calculate() code={result_code})"
+        )
+    point1 = bool_xyz_point(measurement.GetMinPoint1(0.0, 0.0, 0.0))
+    point2 = bool_xyz_point(measurement.GetMinPoint2(0.0, 0.0, 0.0))
+    if point1 is None or point2 is None:
+        raise KompasError(
+            "measure_min_distance: IMeasurement3D did not return valid min-distance points for "
+            f"components {component_identifier_1!r} and {component_identifier_2!r} "
+            f"(Calculate() code={result_code})"
+        )
+
+    logger.info(
+        event_name(LogDomain.BRIDGE, "ksapi_measure_min_distance", LogEventType.COMPLETED),
+        component_identifier_1=component_identifier_1,
+        component_identifier_2=component_identifier_2,
+        distance_mm=distance_mm,
+        measure_result_code=result_code,
+        elapsed_s=elapsed_s,
+    )
+    return DistanceMeasurement(
+        component_identifier_1=component_identifier_1,
+        component_identifier_2=component_identifier_2,
+        distance_mm=distance_mm,
+        point1=point1,
+        point2=point2,
+        measure_result_code=result_code,
+    )
+
+
+def _component_bbox(
+    component: Any,
+) -> tuple[float, float, float, float, float, float] | None:
+    """Axis-aligned bbox компонента (min/max по осям, мм), или `None` если габарит недоступен."""
+    raw = component.GetGabarit(True, True, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+    values = tuple(raw) if raw is not None else ()
+    if len(values) < _GABARIT_VALUE_COUNT or not bool(values[0]):
+        return None
+    x1, y1, z1, x2, y2, z2 = (float(value) for value in values[-6:])
+    return (min(x1, x2), min(y1, y2), min(z1, z2), max(x1, x2), max(y1, y2), max(z1, z2))
+
+
+def _aabb_gap_mm(
+    box_a: tuple[float, float, float, float, float, float],
+    box_b: tuple[float, float, float, float, float, float],
+) -> float:
+    """Евклидов зазор между двумя AABB (0.0 если пересекаются).
+
+    Нижняя оценка расстояния между телами — дешёвый предфильтр перед точным
+    `IMeasurement3D`: если даже коробки дальше порога, сами тела тем более дальше.
+    """
+    total = 0.0
+    for axis in range(_POINT3D_COORDINATE_COUNT):
+        axis_gap = max(box_b[axis] - box_a[axis + 3], box_a[axis] - box_b[axis + 3], 0.0)
+        total += axis_gap * axis_gap
+    return math.sqrt(total)
+
+
+def _try_measure_pair(
+    measurement: Any, constants3d: Any, object_1: Any, object_2: Any
+) -> tuple[float, Point3D, Point3D, int] | None:
+    """Non-raising ядро замера пары: `(distance_mm, point1, point2, code)` или `None`.
+
+    Та же последовательность `IMeasurement3D`, что в `measure_min_distance`, но при
+    скане соседей неизмеримая/невалидная пара — не ошибка всего запроса, а честный
+    пропуск кандидата, поэтому возвращается `None`, а не бросается `KompasError`.
+    """
+    measurement.SetObject1(object_1)
+    measurement.SetObject2(object_2)
+    result_code = int(measurement.Calculate())
+    if result_code == int(constants3d.ksMResUnknown):
+        return None
+    distance_mm = float(measurement.GetLmin())
+    if not math.isfinite(distance_mm) or distance_mm < 0:
+        return None
+    point_1 = bool_xyz_point(measurement.GetMinPoint1(0.0, 0.0, 0.0))
+    point_2 = bool_xyz_point(measurement.GetMinPoint2(0.0, 0.0, 0.0))
+    if point_1 is None or point_2 is None:
+        return None
+    return distance_mm, point_1, point_2, result_code
+
+
+def _part_name(part: Any) -> str | None:
+    raw = part.GetName()
+    name = str(raw).strip() if raw is not None else ""
+    return name or None
+
+
+def find_neighbors(modules: KsApiModules, app: Any, identifier: str, gap_mm: float) -> NeighborsResult:
+    """Компоненты в пределах `gap_mm` от компонента `identifier` — bbox-предфильтр + линейка.
+
+    Детерминированный «что рядом с компонентом»: сначала bbox-предфильтр по `GetGabarit`
+    (чистая математика, отсекает заведомо далёкие компоненты без вызова замера), затем
+    точный зазор до каждого кандидата — транзиентный `IMeasurement3D` part↔part (спайк 11:
+    тот же механизм, что `measure_min_distance`, без объекта в дереве документа). Кандидаты,
+    чей ТОЧНЫЙ зазор всё же больше `gap_mm`, отбрасываются (bbox — только нижняя оценка).
+    Результат отсортирован по возрастанию зазора; сам компонент-цель в него не входит.
+
+    Read-only: ни `GetGabarit`, ни `IMeasurement3D` не создают объектов в дереве и не
+    трогают геометрию — в отличие от `ICollision` (спайк find-neighbors в
+    `docs/recipes/ksapi-link.md`), который сюда сознательно не берётся.
+    """
+    if gap_mm <= 0:
+        raise KompasError("find_neighbors: gap_mm must be positive")
+    _doc3d, top, components, target = resolve_component(modules, app, "find_neighbors", identifier)
+    constants3d = constants3d_class(modules)
+    target_bbox = _component_bbox(target)
+    if target_bbox is None:
+        raise KompasError(f"find_neighbors: GetGabarit() failed for target component {identifier!r}")
+
+    measurement = top.GetMeasurement3D()
+    if not measurement:
+        raise KompasError("find_neighbors: IPart.GetMeasurement3D() is unavailable")
+
+    neighbors: list[NeighborHit] = []
+    bbox_candidate_count = 0
+    for index, component in enumerate(components):
+        if component is target:
+            continue
+        component_bbox = _component_bbox(component)
+        if component_bbox is None:
+            continue
+        if _aabb_gap_mm(target_bbox, component_bbox) > gap_mm:
+            continue  # предфильтр: коробки дальше порога — точный замер не нужен
+        bbox_candidate_count += 1
+        measured = _try_measure_pair(measurement, constants3d, target, component)
+        if measured is None:
+            continue
+        distance_mm, point_on_target, point_on_neighbor, result_code = measured
+        if distance_mm > gap_mm:
+            continue
+        neighbors.append(
+            NeighborHit(
+                component_identifier=str(index),
+                component_name=_part_name(component),
+                distance_mm=distance_mm,
+                point_on_target=point_on_target,
+                point_on_neighbor=point_on_neighbor,
+                measure_result_code=result_code,
+            )
+        )
+    neighbors.sort(key=lambda hit: hit.distance_mm)
+
+    logger.info(
+        event_name(LogDomain.BRIDGE, "ksapi_find_neighbors", LogEventType.COMPLETED),
+        identifier=identifier,
+        gap_mm=gap_mm,
+        bbox_candidates=bbox_candidate_count,
+        neighbors=len(neighbors),
+    )
+    return NeighborsResult(target_identifier=identifier, gap_mm=gap_mm, neighbors=neighbors)
+
+
+def _api_reference(obj: Any) -> int | None:
+    raw = getattr(obj, "reference", None)
+    if raw is None:
+        return None
+    try:
+        return int(raw)
+    except (TypeError, ValueError):
+        return None
+
+
+def _part_origin(part: Any) -> tuple[float, float, float] | None:
+    placement = part.GetPlacement()
+    if not placement:
+        return None
+    raw = placement.GetOrigin(0.0, 0.0, 0.0)
+    values = tuple(raw) if raw is not None else ()
+    if len(values) < _KSAPI_BOOL_XYZ_VALUE_COUNT or not bool(values[0]):
+        return None
+    return (float(values[1]), float(values[2]), float(values[3]))
+
+
+def _same_origin(left: tuple[float, float, float], right: tuple[float, float, float]) -> bool:
+    return all(abs(a - b) <= _PART_ORIGIN_MATCH_TOLERANCE_MM for a, b in zip(left, right, strict=True))
+
+
+def _component_index_for_part(components: list[Any], target_part: Any) -> int | None:
+    """Resolve a picked object's owning `IPart` to a top-level component index.
+
+    `IModelObject.GetPart()` returns a fresh wrapper, so object identity is not enough.
+    Prefer SWIG reference equality and fall back to placement origin, as confirmed by
+    spike 03 for picked face/edge/body hits.
+    """
+    target_reference = _api_reference(target_part)
+    if target_reference is not None and target_reference != 0:
+        for index, component in enumerate(components):
+            if _api_reference(component) == target_reference:
+                return index
+
+    target_origin = _part_origin(target_part)
+    if target_origin is None:
+        return None
+    for index, component in enumerate(components):
+        component_origin = _part_origin(component)
+        if component_origin is not None and _same_origin(component_origin, target_origin):
+            return index
+    return None
+
+
+def _document_3d_ex(modules: KsApiModules, doc: Any, doc3d: Any) -> Any:
+    """Resolve `IKompasDocument3DEx` from document or document3d handle."""
+    doc3d_ex = modules.ksapi.IKompasDocument3DEx(doc)
+    if not doc3d_ex:
+        doc3d_ex = modules.ksapi.IKompasDocument3DEx(doc3d)
+    if not doc3d_ex:
+        raise KompasError("probe_ray: IKompasDocument3DEx is unavailable")
+    return doc3d_ex
+
+
+def _ray_hit_for_object(
+    modules: KsApiModules,
+    constants3d: Any,
+    components: list[Any],
+    obj: Any,
+) -> RayHit | None:
+    """Map one pick result to a component hit, or `None` if it is not a part hit."""
+    model_object = modules.ksapi.IModelObject(obj)
+    if not model_object:
+        return None
+    type_code = int(model_object.GetModelObjectType())
+    owning_part = model_object.GetPart()
+    if not owning_part and type_code == int(constants3d.o3d_part):
+        owning_part = modules.ksapi.IPart(model_object)
+    if not owning_part:
+        return None
+    component_index = _component_index_for_part(components, owning_part)
+    if component_index is None:
+        return None
+    component = components[component_index]
+    return RayHit(
+        hit=True,
+        component_identifier=str(component_index),
+        component_name=_part_name(component),
+        model_object_type=type_code,
+    )
+
+
+def probe_ray(
+    modules: KsApiModules,
+    app: Any,
+    origin: Point3D,
+    direction: Point3D,
+    limit_mm: float,
+) -> RayHit:
+    """Pick model objects along a geometric ray and return only owning component.
+
+    `PickModelObjectsWithLimit` returns intersection points, but spike 03 found
+    placeholders at body/part levels. This method intentionally ignores them.
+    """
+    if limit_mm < 0:
+        raise KompasError("probe_ray: limit_mm must be non-negative")
+    direction_length_sq = direction.x_mm**2 + direction.y_mm**2 + direction.z_mm**2
+    if direction_length_sq == 0:
+        raise KompasError("probe_ray: direction vector must be non-zero")
+
+    doc = app.GetActiveDocument()
+    doc3d = as_document_3d(modules, doc)
+    if doc3d is None:
+        raise KompasError("probe_ray: активный документ не 3D")
+    constants3d = constants3d_class(modules)
+    components: list[Any] = list(doc3d.GetTopPart().GetPartsArray(int(constants3d.ksAllParts)))
+    doc3d_ex = _document_3d_ex(modules, doc, doc3d)
+
+    pick_ray = [
+        origin.x_mm,
+        origin.y_mm,
+        origin.z_mm,
+        direction.x_mm,
+        direction.y_mm,
+        direction.z_mm,
+    ]
+    objects, _intersection_points = doc3d_ex.PickModelObjectsWithLimit(pick_ray, float(limit_mm), None, [])
+    for obj in objects:
+        hit = _ray_hit_for_object(modules, constants3d, components, obj)
+        if hit is not None:
+            return hit
+
+    return RayHit(hit=False)

kompas_kernel/features/geometry_3d/ksapi/presentation.py

@@ -0,0 +1,204 @@
+"""Permanent dimension-line presentation: `show_distance_dimension`/`clear_dimensions`.
+
+Free functions taking explicit `modules`/`app` dependencies (no adapter `self` state) —
+same shape as `component_geometry.py`/`measurements.py`. Component identifier resolution
+(`resolve_component`/`component_by_identifier`) and face resolution (`nearest_face`) are
+imported from `component_geometry.py`, not duplicated (E16.04a dedup step).
+
+Only the generated wrapper's stable integer reference is retained between callbacks (in
+the caller's `shown_distance_measurement_references` list); the raw measurement wrapper
+stays local to this callback — no raw KsAPI handle leaves `KompasSession.run(...)`.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from kompas_kernel.features.geometry_3d.ksapi.component_geometry import (
+    bool_xyz_point,
+    component_by_identifier,
+    nearest_face,
+    resolve_component,
+)
+from kompas_kernel.features.geometry_3d.models import ShowDistanceResult
+from kompas_kernel.kompas.errors import KompasError
+from kompas_kernel.kompas.objects import as_document_3d, constants3d_class, constants_class
+from kompas_kernel.kompas.runtime import KsApiModules
+from kompas_kernel.observability.logger import get_logger
+from kompas_kernel.observability.taxonomy import LogDomain, LogEventType, event_name
+
+logger = get_logger(__name__)
+
+
+def show_distance_dimension(
+    modules: KsApiModules,
+    app: Any,
+    component_identifier_1: str,
+    component_identifier_2: str,
+    shown_distance_measurement_references: list[int],
+) -> ShowDistanceResult:
+    """Measure the fast fact, then leave a PERMANENT dimension line visible in 3D.
+
+    Fast fact: transient `IMeasurement3D` (`IPart.GetMeasurement3D()`, same mechanism
+    as `measure_min_distance`). The permanent highlight uses the OTHER measurement
+    object (`IDistanceAngleMeasurement3D` via `IMeasurementContainer`, spike 02),
+    which computes only `IFace<->IFace` — so the face pair is resolved by nearest
+    tessellated vertex to each component's min-distance point (`nearest_face`).
+
+    Not read-only: creates a real `IModelObject` in the document's
+    `IDistanceAngleMeasurements3D` collection and does NOT delete it (unlike
+    `measure_min_distance`'s transient object, which never enters a collection) — the
+    whole point is a persistent, user-visible dimension line. `IKompasDocument.
+    IsChanged()` will flip to `True` (spike 02 fact) even though geometry is untouched.
+    Do NOT save the document while a shown feature exists; call
+    `clear_dimensions()` (or delete manually in KOMPAS) when done.
+
+    Only the generated wrapper's stable integer reference is retained between
+    callbacks; the raw measurement wrapper stays local to this callback.
+    """
+    doc3d, top, components, component_1 = resolve_component(
+        modules, app, "show_distance_dimension", component_identifier_1
+    )
+    component_2 = component_by_identifier("show_distance_dimension", components, component_identifier_2)
+    constants = constants_class(modules)
+    constants3d = constants3d_class(modules)
+
+    fast_measurement = top.GetMeasurement3D()
+    if not fast_measurement:
+        raise KompasError("show_distance_dimension: IPart.GetMeasurement3D() is unavailable")
+    fast_measurement.SetObject1(component_1)
+    fast_measurement.SetObject2(component_2)
+    result_code = int(fast_measurement.Calculate())
+    if result_code == int(constants3d.ksMResUnknown):
+        raise KompasError(
+            "show_distance_dimension: fast measurement could not determine a distance for "
+            f"components {component_identifier_1!r} and {component_identifier_2!r} (ksMResUnknown)"
+        )
+    distance_mm = float(fast_measurement.GetLmin())
+    point1 = bool_xyz_point(fast_measurement.GetMinPoint1(0.0, 0.0, 0.0))
+    point2 = bool_xyz_point(fast_measurement.GetMinPoint2(0.0, 0.0, 0.0))
+    if point1 is None or point2 is None:
+        raise KompasError(
+            "show_distance_dimension: fast measurement did not return valid min-distance points for "
+            f"components {component_identifier_1!r} and {component_identifier_2!r}"
+        )
+
+    face_1 = nearest_face(modules, component_1, top, point1)
+    face_2 = nearest_face(modules, component_2, top, point2)
+    if face_1 is None or face_2 is None:
+        raise KompasError(
+            "show_distance_dimension: could not resolve a tessellated face near the min-distance point "
+            f"for components {component_identifier_1!r}/{component_identifier_2!r}"
+        )
+
+    measurement_container = modules.ksapi.IMeasurementContainer(top)
+    if not measurement_container:
+        raise KompasError("show_distance_dimension: IMeasurementContainer is unavailable")
+    distance_measurements = measurement_container.GetDistanceAngleMeasurements3D()
+    if distance_measurements is None:
+        raise KompasError("show_distance_dimension: GetDistanceAngleMeasurements3D() is unavailable")
+    permanent_measurement = distance_measurements.Add()
+    if not permanent_measurement:
+        raise KompasError("show_distance_dimension: IDistanceAngleMeasurements3D.Add() failed")
+    permanent_measurement.SetObject1(face_1)
+    permanent_measurement.SetObject2(face_2)
+    permanent_measurement.Update()
+    shown_value_mm = float(permanent_measurement.GetLmin())
+    measurement_reference = int(modules.ksapi.GetReference(permanent_measurement))
+    if measurement_reference == 0:
+        raise KompasError("show_distance_dimension: created measurement has no stable reference")
+    shown_distance_measurement_references.append(measurement_reference)
+
+    sm = doc3d.GetSelectionManager()
+    sm.UnselectAll()
+    # Try selecting the measurement feature itself first (variant 2 — see task 14
+    # brief); if KOMPAS doesn't accept it as a selectable object, fall back to
+    # zooming the second (culprit) component so the user still lands near the gap.
+    feature_selected = bool(sm.Select([permanent_measurement]))
+    selected = feature_selected or bool(sm.Select([component_2]))
+    zoomed = bool(app.ExecuteKompasCommand(int(constants.ksCMZoomSelected), True)) if selected else False
+
+    logger.info(
+        event_name(LogDomain.BRIDGE, "ksapi_show_distance_dimension", LogEventType.COMPLETED),
+        component_identifier_1=component_identifier_1,
+        component_identifier_2=component_identifier_2,
+        distance_mm=distance_mm,
+        shown_value_mm=shown_value_mm,
+        feature_selected=feature_selected,
+        zoomed=zoomed,
+    )
+    return ShowDistanceResult(
+        distance_mm=distance_mm,
+        point1=point1,
+        point2=point2,
+        zoomed=zoomed,
+        shown_value_mm=shown_value_mm,
+    )
+
+
+def clear_dimensions(
+    modules: KsApiModules,
+    app: Any,
+    shown_distance_measurement_references: list[int],
+) -> tuple[int, list[int]]:
+    """Delete ONLY the permanent measurement features created by `show_distance_dimension`.
+
+    Never touches `IDistanceAngleMeasurements3D` entries the user created themselves —
+    only the integer references the caller's list holds. Returns `(deleted, remaining)`; the
+    caller (`GeometryService`/`commands.clear_dimensions`) is the one that reassigns its own
+    tracking state to `remaining` (a plain function cannot rebind the caller's attribute —
+    see `commands.py::ShownDimensionsState`).
+
+    Two failure modes, both logged and both kept in `remaining` so a retry or manual
+    cleanup is still possible:
+    * the reference does not resolve in the ACTIVE document — the document was switched
+      after `show_distance_dimension`, so the feature is still alive in the other one;
+    * `IFeature.Delete()` returned `False` for a resolved measurement.
+    """
+    doc3d = as_document_3d(modules, app.GetActiveDocument())
+    if doc3d is None:
+        raise KompasError("clear_dimensions: активный документ не 3D")
+    measurement_container = modules.ksapi.IMeasurementContainer(doc3d.GetTopPart())
+    if not measurement_container:
+        raise KompasError("clear_dimensions: IMeasurementContainer is unavailable")
+    measurements = measurement_container.GetDistanceAngleMeasurements3D()
+    if measurements is None:
+        raise KompasError("clear_dimensions: GetDistanceAngleMeasurements3D() is unavailable")
+    by_reference: dict[int, Any] = {}
+    for index in range(int(measurements.GetCount())):
+        measurement = measurements.GetDistanceAngleMeasurement3D(index)
+        if measurement is None:
+            continue
+        reference = int(modules.ksapi.GetReference(measurement))
+        if reference != 0:
+            by_reference[reference] = measurement
+
+    remaining: list[int] = []
+    deleted = 0
+    for reference in shown_distance_measurement_references:
+        measurement = by_reference.get(reference)
+        if measurement is None:
+            remaining.append(reference)
+            logger.warning(
+                event_name(LogDomain.BRIDGE, "ksapi_clear_dimensions", LogEventType.FAILED),
+                reason="reference not found in the active document",
+                reference=reference,
+            )
+            continue
+        feature = modules.ksapi.IFeature(measurement)
+        ok = bool(feature.Delete()) if feature else False
+        if ok:
+            deleted += 1
+        else:
+            remaining.append(reference)
+            logger.warning(
+                event_name(LogDomain.BRIDGE, "ksapi_clear_dimensions", LogEventType.FAILED),
+                reason="IFeature.Delete() returned False",
+                reference=reference,
+            )
+    logger.info(
+        event_name(LogDomain.BRIDGE, "ksapi_clear_dimensions", LogEventType.COMPLETED),
+        deleted=deleted,
+        remaining=len(remaining),
+    )
+    return deleted, remaining