kompas-kernel 0.0.1__py3-none-any.whl

kompas_kernel/features/geometry_3d/commands.py

@@ -0,0 +1,68 @@
+"""Framework-free public dimension-line commands for geometry 3D, over `KompasSession`.
+
+No Pydantic AI, no `kompas_copilot.bridge` import — raw KsAPI presentation lives in
+`ksapi/presentation.py`; this module wires it through session callbacks receiving
+`KompasContext` directly and owns the explicit `ShownDimensionsState` holder that
+`show_distance_dimension`/`clear_dimensions` share.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from kompas_kernel.features.geometry_3d.ksapi import presentation
+from kompas_kernel.features.geometry_3d.models import ShowDistanceResult
+from kompas_kernel.kompas.session import KompasContext, KompasSession
+
+
+@dataclass
+class ShownDimensionsState:
+    """Mutable holder for `IDistanceAngleMeasurement3D` references created by
+    `show_distance_dimension` in this session — owned by `GeometryService`, one per
+    `KompasSession` (mirrors the field that used to live directly on
+    `KompasKsApiAdapter`, `_shown_distance_measurement_references`).
+
+    `clear_dimensions` below reads and rewrites `.references` INSIDE the same worker
+    queue item (`KompasSession.run` callback) as the KsAPI delete calls, not after the
+    `await` returns — so two concurrent `clear_dimensions()`/`show_distance_dimension()`
+    calls on the same service can never interleave a stale read with a write (the
+    property the legacy adapter's `_clear_dimensions` docstring called "update stable
+    state in the same queue item").
+    """
+
+    references: list[int] = field(default_factory=list)
+
+
+async def show_distance_dimension(
+    session: KompasSession,
+    component_identifier_1: str,
+    component_identifier_2: str,
+    state: ShownDimensionsState,
+) -> ShowDistanceResult:
+    """Показать место зазора: создать ПОСТОЯННУЮ размерную линию между компонентами."""
+
+    def _operation(context: KompasContext) -> ShowDistanceResult:
+        return presentation.show_distance_dimension(
+            context.modules,
+            context.app,
+            component_identifier_1,
+            component_identifier_2,
+            state.references,
+        )
+
+    return await session.run(operation_name="geometry_3d.show_distance_dimension", operation=_operation)
+
+
+async def clear_dimensions(session: KompasSession, state: ShownDimensionsState) -> int:
+    """Убрать все размерные линии, созданные `show_distance_dimension` в этой сессии.
+
+    `state.references` перезаписывается ВНУТРИ того же callback, что и сам вызов
+    `IFeature.Delete()` (см. `ShownDimensionsState` докстринг) — не после `await`.
+    """
+
+    def _operation(context: KompasContext) -> int:
+        deleted, remaining = presentation.clear_dimensions(context.modules, context.app, state.references)
+        state.references = remaining
+        return deleted
+
+    return await session.run(operation_name="geometry_3d.clear_dimensions", operation=_operation)

kompas_kernel/features/geometry_3d/hex_detect.py

@@ -0,0 +1,113 @@
+"""Pure hexagonal-prism detection from exact planar-face facts — no KsAPI, no mesh.
+
+`PlanarFaces` (from `features.geometry_3d.ksapi.component_geometry.component_planar_faces`)
+already did the only KsAPI-touching work: found every planar face of a component whose
+plane is parallel to the component's own axis, with an exact radial distance and exact
+corner points (see that function's docstring — no tessellation anywhere in that path).
+This module only clusters those already-computed facts — pure math, consumes DTOs, same
+shape as `wrench_zone.py` (no pydantic-ai, no bridge port calls).
+
+A hexagonal prism (a bolt head or a nut) presents as a GROUP of side-wall faces sharing
+one radial distance from the axis (K = S/2, ГОСТ 13682-80) — a live check (2026-07-07)
+found 6 for a plain nut and 12 for a bolt head (KOMPAS split each flat in two at the
+under-head bearing chamfer, both halves at the identical radius) — hence "count is a
+multiple of 6", not "count is exactly 6".
+
+The z-zone this produces plugs directly into `measure_radial_distance`'s
+`z_min_mm`/`z_max_mm` (same axis-projection convention, `axis_math.py`) — replacing
+the LLM's hand-guessed zone that caused the false "Покемон mешает гайке" verdict this
+task originates from (see AGENTS.md §«KsAPI: точный B-rep вместо меша/тесселляции»).
+"""
+
+from __future__ import annotations
+
+from pydantic import Field
+
+from kompas_kernel.features.geometry_3d.axis_math import axial_and_radial_mm, unit_axis_direction
+from kompas_kernel.features.geometry_3d.models import AxisLine, PlanarFaces
+from kompas_kernel.utils.validation import CustomModel
+
+_HEX_FACE_COUNT_DIVISOR = 6
+_DEFAULT_RADIUS_TOLERANCE_MM = 1e-2
+
+
+class HexPrismRegion(CustomModel):
+    """One hexagonal-prism region found on a component's own axis, mm.
+
+    `z_min_mm`/`z_max_mm` — axial extent along the `AxisLine` passed to `find_hex_prisms`
+    (same convention `measure_radial_distance` expects for its own `z_min_mm`/`z_max_mm` —
+    a region's bounds plug straight in, no conversion). `across_flats_mm` — 2 × the
+    group's shared radial distance (= S per ГОСТ, measured from geometry, not looked up —
+    useful as a cross-check against `search_fastener`'s S). `face_indices` — which
+    `PlanarFaceFact.face_index` values formed this region (diagnostics/highlighting).
+    """
+
+    z_min_mm: float
+    z_max_mm: float
+    across_flats_mm: float = Field(gt=0)
+    face_indices: list[int]
+
+
+def find_hex_prisms(
+    axis: AxisLine,
+    faces: PlanarFaces,
+    *,
+    radius_tolerance_mm: float = _DEFAULT_RADIUS_TOLERANCE_MM,
+) -> list[HexPrismRegion]:
+    """Group axis-parallel planar faces into hexagonal-prism regions, sorted by `z_min_mm`.
+
+    Grouping: two faces belong to the same region if their `radial_mm` (already computed
+    exactly by `component_planar_faces` — see its docstring) match within
+    `radius_tolerance_mm`. This is exact B-rep geometry, not a tessellation fit, so the
+    default tolerance (0.01 mm) only absorbs float noise, not modeling error — a real
+    hex flat's radius does not drift between faces.
+
+    A group is kept only if its face count is a positive multiple of 6 (a hexagon has 6
+    side walls; KOMPAS may split each flat into more than one topological face at a
+    chamfer/fillet transition, always in multiples of 6 for a regular hex — see module
+    docstring). Groups that don't fit (stray coplanar faces from unrelated features
+    landing at the same radius by coincidence) are silently dropped — a false NEGATIVE
+    (missing a real hex) is safer here than a false POSITIVE feeding a wrong z-zone into
+    `measure_radial_distance`.
+
+    Each kept group's `z_min_mm`/`z_max_mm` is the union of its member faces' corner
+    points projected onto `axis` (`axis_math.axial_and_radial_mm`) — the group's full
+    axial reach, not a single face's.
+    """
+    unit = unit_axis_direction(axis)
+    axial_ranges: list[tuple[float, float]] = []
+    for fact in faces.faces:
+        axial_values = [axial_and_radial_mm(corner, axis, unit)[0] for corner in fact.corners]
+        if not axial_values:
+            axial_ranges.append((0.0, 0.0))
+            continue
+        axial_ranges.append((min(axial_values), max(axial_values)))
+
+    groups: list[list[int]] = []  # indices into faces.faces
+    for index, fact in enumerate(faces.faces):
+        placed = False
+        for group in groups:
+            if abs(faces.faces[group[0]].radial_mm - fact.radial_mm) <= radius_tolerance_mm:
+                group.append(index)
+                placed = True
+                break
+        if not placed:
+            groups.append([index])
+
+    regions: list[HexPrismRegion] = []
+    for group in groups:
+        if len(group) == 0 or len(group) % _HEX_FACE_COUNT_DIVISOR != 0:
+            continue
+        z_min_mm = min(axial_ranges[i][0] for i in group)
+        z_max_mm = max(axial_ranges[i][1] for i in group)
+        radial_mm = sum(faces.faces[i].radial_mm for i in group) / len(group)
+        regions.append(
+            HexPrismRegion(
+                z_min_mm=z_min_mm,
+                z_max_mm=z_max_mm,
+                across_flats_mm=2 * radial_mm,
+                face_indices=[faces.faces[i].face_index for i in group],
+            )
+        )
+    regions.sort(key=lambda region: region.z_min_mm)
+    return regions

kompas_kernel/features/geometry_3d/ksapi/__init__.py

@@ -0,0 +1,5 @@
+"""Raw KsAPI reads for geometry 3D: component geometry, measurements, presentation.
+
+Everything that touches raw `IPart`/`IFace`/`ksapi.py` objects lives here, inside a
+`KompasSession.run(...)` callback — no raw handle leaves this package.
+"""