@ifc-lite/clash 1.6.8 → 1.7.0

package/dist/duplicate-metric.js

@@ -0,0 +1,99 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+function aabbVolume(b) {
+    const dx = Math.max(0, b.max[0] - b.min[0]);
+    const dy = Math.max(0, b.max[1] - b.min[1]);
+    const dz = Math.max(0, b.max[2] - b.min[2]);
+    return dx * dy * dz;
+}
+/** Intersection-over-union of two AABBs (0 when disjoint). */
+function aabbIoU(a, b) {
+    const ox = Math.min(a.max[0], b.max[0]) - Math.max(a.min[0], b.min[0]);
+    const oy = Math.min(a.max[1], b.max[1]) - Math.max(a.min[1], b.min[1]);
+    const oz = Math.min(a.max[2], b.max[2]) - Math.max(a.min[2], b.min[2]);
+    if (ox <= 0 || oy <= 0 || oz <= 0)
+        return 0;
+    const inter = ox * oy * oz;
+    const union = aabbVolume(a) + aabbVolume(b) - inter;
+    return union > 0 ? inter / union : 0;
+}
+function aabbApproxEqual(a, b, tol) {
+    for (let i = 0; i < 3; i += 1) {
+        if (Math.abs(a.min[i] - b.min[i]) > tol)
+            return false;
+        if (Math.abs(a.max[i] - b.max[i]) > tol)
+            return false;
+    }
+    return true;
+}
+/**
+ * Distance (m) between two boxes as *objects*: the largest distance any corner
+ * of `a` has to travel to reach the matching corner of `b`. Because the max over
+ * the eight corners picks, independently per axis, whichever face moved further,
+ * it reduces to the Euclidean norm of the three per-axis face offsets — one
+ * square root, no corner enumeration.
+ *
+ * Two properties make it the tolerance a user can reason about:
+ * - **Pure translation gives exactly the translation length.** Every corner
+ *   moves by `d`, so the result is `|d|`, whatever the shape and whatever the
+ *   direction. That is what makes it isotropic, where IoU was not.
+ * - **A size difference counts too.** Concentric boxes whose faces differ by δ
+ *   are δ apart, so this is centre distance *and* a shape check in one number,
+ *   with no second, dimensionless knob.
+ *
+ * It is still AABB-only: two elements with the same bounds and different solids
+ * inside them are indistinguishable *to this function*. In practice that costs
+ * less than it sounds, because real nesting has clearance and clearance is what
+ * this measures. An element nested with a gap of `g` on two axes is `g·√2`
+ * away, so anything looser than 10/√2 ≈ 7 mm of annulus is rejected outright at
+ * the default tolerance — a duct in its shaft and a pipe in a standard sleeve
+ * both are. What survives is nesting tighter than that, and the shape signature
+ * then keeps it out of `major`. See `findDuplicates` for the measured
+ * envelope.
+ */
+export function boxDistance(a, b) {
+    let sum = 0;
+    for (let i = 0; i < 3; i += 1) {
+        const d = Math.max(Math.abs(a.min[i] - b.min[i]), Math.abs(a.max[i] - b.max[i]));
+        sum += d * d;
+    }
+    return Math.sqrt(sum);
+}
+/** Do the boxes touch or overlap on every axis? Two elements that are disjoint
+ *  in space are two objects, however close. Without this an element SMALLER than
+ *  the tolerance (a 5 mm fixing at a 10 mm tolerance) would pair with a
+ *  neighbour it never intersects. Touching (zero gap) counts, so coincident
+ *  planar and point geometry still qualifies.
+ *
+ *  This deliberately excludes one pair the legacy IoU fallback reported: two
+ *  zero-thickness sheets offset a few millimetres ALONG THEIR OWN NORMAL are
+ *  disjoint (any gap on that axis fails this test), where the old
+ *  `aabbApproxEqual` fallback called boxes within `positionTolerance` per axis
+ *  the same place. Same reasoning as the 5 mm fixing: geometry with clear air
+ *  between the surfaces is two objects, not one modelled twice. Pinned by the
+ *  "does not pair two disjoint sheets offset along their own normal" test. */
+export function boxesTouch(a, b) {
+    for (let i = 0; i < 3; i += 1) {
+        if (Math.min(a.max[i], b.max[i]) < Math.max(a.min[i], b.min[i]))
+            return false;
+    }
+    return true;
+}
+/** Legacy IoU similarity in `[0,1]`, falling back to box-equality for degenerate
+ *  (zero-volume / planar) elements where IoU is undefined. */
+export function similarity(a, b, tol) {
+    const iou = aabbIoU(a, b);
+    if (iou > 0)
+        return iou;
+    // Both (near) degenerate: an exact box match still means "same place".
+    if (aabbVolume(a) <= 0 || aabbVolume(b) <= 0) {
+        return aabbApproxEqual(a, b, tol) ? 1 : 0;
+    }
+    return 0;
+}
+/** Shortest dimension of a box — the depth one element is embedded in another. */
+export function minExtent(b) {
+    return Math.min(b.max[0] - b.min[0], b.max[1] - b.min[1], b.max[2] - b.min[2]);
+}
+//# sourceMappingURL=duplicate-metric.js.map

package/dist/duplicate-metric.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-metric.js","sourceRoot":"","sources":["../src/duplicate-metric.ts"],"names":[],"mappings":"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"}

package/dist/duplicate-sets.d.ts

@@ -0,0 +1,47 @@
+import type { ClashGroup, ClashResult } from './types.js';
+/**
+ * Group a duplicate result into coincident **sets** — one finding per set of
+ * objects occupying the same place, rather than one per pair.
+ *
+ * `findDuplicates` reports pairwise. N coincident copies of one object therefore
+ * produce N(N−1)/2 rows and each copy is named in N−1 of them, so three
+ * triplicated columns read as nine findings with every object mentioned twice.
+ * No row is literally repeated, but the list badly overstates the problem.
+ *
+ * The partition here is the **connected components of the pair graph**: every
+ * reported clash is an edge between two model-qualified elements, and each
+ * component is one "these N objects are coincident" finding. Unlike
+ * `groupClashes({ by: 'cluster' })` this needs no epsilon and cannot fuse two
+ * unrelated duplicate sets that merely stand within a cluster radius of each
+ * other — it uses only the pairs the detector actually reported.
+ *
+ * Two properties worth stating plainly:
+ *
+ * - **Transitivity is approximated, knowingly.** A≈B and B≈C under
+ *   `positionTolerance` (the default corner-distance gate) does not imply A≈C,
+ *   yet connected components put all three in one
+ *   set. We accept that: a chain of near-coincident objects is a single
+ *   coordination issue, and the strict alternative (maximal cliques) is
+ *   exponential and would put the same object back into several findings —
+ *   the exact complaint this grouping exists to answer.
+ * - **Sets may span models.** Identity is `(model, key, ref)`, so the same
+ *   object delivered in two files groups correctly, and two files that happen to
+ *   reuse a key for different objects do not. `ref` is in there because a key
+ *   can repeat *within* one model too — a file with duplicated GlobalIds, which
+ *   is exactly the defect a duplicate hunt is looking for; on `(model, key)`
+ *   alone those two elements collapsed into one node and the set they form
+ *   counted "1 coincident object". Adding `ref` only ever splits nodes, never
+ *   merges them.
+ *
+ * Components are computed per `rule`, so a mixed result never fuses a duplicate
+ * pair with a discipline clash — and only components of the `duplicates` rule
+ * are titled "coincident". Any other rule's component is titled as connected
+ * clashes, which is all its pair graph proves: those members intersect, they
+ * do not occupy the same place. Severity is the most severe member severity: a
+ * set containing any exact-duplicate (`major`) pair surfaces as `major`.
+ *
+ * `ClashResult` is untouched — the panel, grouping modes and BCF export keep
+ * consuming the pairwise shape; this is a reporting view over it.
+ */
+export declare function groupDuplicateSets(result: ClashResult): ClashGroup[];
+//# sourceMappingURL=duplicate-sets.d.ts.map

package/dist/duplicate-sets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-sets.d.ts","sourceRoot":"","sources":["../src/duplicate-sets.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAA0B,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,EAAE,CAqEpE"}

package/dist/duplicate-sets.js

@@ -0,0 +1,124 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Coincident-set grouping for duplicate results — the reader-facing view over
+ * the pairwise `ClashResult` that `findDuplicates` produces. Split out of
+ * `grouping.ts` (which owns the generic BCF-topic groupings) to keep both
+ * under the ~400-line module limit; re-exported through the package index.
+ */
+import { DUPLICATES_RULE } from './duplicates.js';
+import { qualifiedKey } from './exclude.js';
+import { makeGroup, sortGroups } from './grouping.js';
+import { createUnionFind } from './union-find.js';
+/**
+ * Group a duplicate result into coincident **sets** — one finding per set of
+ * objects occupying the same place, rather than one per pair.
+ *
+ * `findDuplicates` reports pairwise. N coincident copies of one object therefore
+ * produce N(N−1)/2 rows and each copy is named in N−1 of them, so three
+ * triplicated columns read as nine findings with every object mentioned twice.
+ * No row is literally repeated, but the list badly overstates the problem.
+ *
+ * The partition here is the **connected components of the pair graph**: every
+ * reported clash is an edge between two model-qualified elements, and each
+ * component is one "these N objects are coincident" finding. Unlike
+ * `groupClashes({ by: 'cluster' })` this needs no epsilon and cannot fuse two
+ * unrelated duplicate sets that merely stand within a cluster radius of each
+ * other — it uses only the pairs the detector actually reported.
+ *
+ * Two properties worth stating plainly:
+ *
+ * - **Transitivity is approximated, knowingly.** A≈B and B≈C under
+ *   `positionTolerance` (the default corner-distance gate) does not imply A≈C,
+ *   yet connected components put all three in one
+ *   set. We accept that: a chain of near-coincident objects is a single
+ *   coordination issue, and the strict alternative (maximal cliques) is
+ *   exponential and would put the same object back into several findings —
+ *   the exact complaint this grouping exists to answer.
+ * - **Sets may span models.** Identity is `(model, key, ref)`, so the same
+ *   object delivered in two files groups correctly, and two files that happen to
+ *   reuse a key for different objects do not. `ref` is in there because a key
+ *   can repeat *within* one model too — a file with duplicated GlobalIds, which
+ *   is exactly the defect a duplicate hunt is looking for; on `(model, key)`
+ *   alone those two elements collapsed into one node and the set they form
+ *   counted "1 coincident object". Adding `ref` only ever splits nodes, never
+ *   merges them.
+ *
+ * Components are computed per `rule`, so a mixed result never fuses a duplicate
+ * pair with a discipline clash — and only components of the `duplicates` rule
+ * are titled "coincident". Any other rule's component is titled as connected
+ * clashes, which is all its pair graph proves: those members intersect, they
+ * do not occupy the same place. Severity is the most severe member severity: a
+ * set containing any exact-duplicate (`major`) pair surfaces as `major`.
+ *
+ * `ClashResult` is untouched — the panel, grouping modes and BCF export keep
+ * consuming the pairwise shape; this is a reporting view over it.
+ */
+export function groupDuplicateSets(result) {
+    const byRule = new Map();
+    for (const clash of result.clashes) {
+        const bucket = byRule.get(clash.rule);
+        if (bucket) {
+            bucket.push(clash);
+        }
+        else {
+            byRule.set(clash.rule, [clash]);
+        }
+    }
+    const groups = [];
+    for (const bucket of byRule.values()) {
+        // Number the participating elements in first-seen order; every clash is one
+        // edge between two of those nodes.
+        const nodeOf = new Map();
+        const idOf = (ref) => {
+            const k = `${qualifiedKey(ref.model, ref.key)}#${ref.ref}`;
+            const existing = nodeOf.get(k);
+            if (existing !== undefined)
+                return existing;
+            const assigned = nodeOf.size;
+            nodeOf.set(k, assigned);
+            return assigned;
+        };
+        const edges = bucket.map((clash) => [idOf(clash.a), idOf(clash.b)]);
+        const { find, union } = createUnionFind(nodeOf.size);
+        for (const [a, b] of edges) {
+            union(a, b);
+        }
+        // Collect each component's member clashes and its distinct element count —
+        // the latter is what the reader cares about ("these 3 objects are the same"),
+        // and it is NOT the member count once a set grows past a pair.
+        const components = new Map();
+        for (let i = 0; i < bucket.length; i += 1) {
+            const clash = bucket[i];
+            const root = find(edges[i][0]);
+            let comp = components.get(root);
+            if (!comp) {
+                comp = { members: [], nodes: new Set(), tags: new Set() };
+                components.set(root, comp);
+            }
+            comp.members.push(clash);
+            comp.nodes.add(edges[i][0]);
+            comp.nodes.add(edges[i][1]);
+            comp.tags.add(clash.a.tag);
+            comp.tags.add(clash.b.tag);
+        }
+        for (const comp of components.values()) {
+            const count = comp.nodes.size;
+            const tag = comp.tags.size === 1 ? `${[...comp.tags][0]} ` : '';
+            const members = [...comp.members].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+            // "Coincident" is a statement the `duplicates` rule actually made. For
+            // any other rule the members of a component merely clash transitively —
+            // intersecting-but-distinct elements — so the title must not upgrade
+            // that to coincidence (#2530 review: an SDK caller passing a discipline
+            // result here would otherwise get "7 coincident IfcPipeSegment objects").
+            const rule = comp.members[0].rule;
+            const title = rule === DUPLICATES_RULE.id
+                ? `${count} coincident ${tag}objects`
+                : `${count} ${tag}objects in connected ${rule} clashes`;
+            groups.push(makeGroup(members, title, undefined, 'duplicate-set'));
+        }
+    }
+    return sortGroups(groups);
+}
+//# sourceMappingURL=duplicate-sets.js.map

package/dist/duplicate-sets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-sets.js","sourceRoot":"","sources":["../src/duplicate-sets.ts"],"names":[],"mappings":"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"}

package/dist/duplicates.d.ts

@@ -1,26 +1,105 @@
 import type { ClashElement, ClashResult, ClashRule, ExclusionSet } from './types.js';
 export interface DuplicateOptions {
     /**
-     * Minimum AABB intersection-over-union for a pair to count as overlapping.
-     * `1` = identical boxes; the default catches near-coincident objects while
-     * leaving merely-adjacent ones (a slab and its finish) alone.
+     * How far apart (m) two elements may be and still count as the same object.
+     * This is the primary control and the number reported in
+     * `ClashResult.settings.tolerance`. It bounds {@link boxDistance}: for two
+     * equally-sized boxes that is exactly the distance between their centres, and
+     * a difference in size adds to it. Default 10 mm.
+     */
+    positionTolerance?: number;
+    /** Distance (m) at/below which a same-shape pair is treated as an EXACT
+     *  duplicate (severity `major`) rather than a candidate overlap (`minor`).
+     *  Default 1 mm. */
+    exactTolerance?: number;
+    /**
+     * @deprecated Superseded by {@link positionTolerance}. Minimum AABB
+     * intersection-over-union for a pair to count as overlapping. IoU is a ratio,
+     * so it imposed no fixed physical tolerance: for two equal boxes offset by `d`
+     * along an axis of extent `e` the IoU is `(e − d) / (e + d)`, and the default
+     * 0.9 therefore allowed `d ≤ e / 19` — 5 mm across a DN100 pipe but 421 mm
+     * across an 8 m slab, from one setting. Passing this (or `exactThreshold`)
+     * restores the pre-1.7 IoU **matching gate** — which pairs are reported, and
+     * the old `settings.tolerance` reading — rather than silently reinterpreting
+     * a number that means nothing in the new metric. It does NOT restore the
+     * whole pre-1.7 behaviour: severity is still decided by the area+volume
+     * shape signature (not the old triangle count), and self-pair identity is
+     * still `(model, ref)` (not key-based), so a file with duplicated GlobalIds
+     * reports pairs the old code hid.
      */
     iouThreshold?: number;
-    /** IoU at/above which a same-triangle-count pair is treated as an EXACT
-     *  duplicate (severity `major`) rather than a candidate overlap (`minor`). */
+    /** @deprecated Only meaningful in the legacy IoU mode selected by
+     *  {@link iouThreshold}; use {@link exactTolerance}. */
     exactThreshold?: number;
-    /** Centre-distance (m) under which two degenerate (planar) elements with no
-     *  AABB volume are still considered coincident. */
-    positionTolerance?: number;
     /** Pairs whose element keys are in here are skipped (voids/hosts/assemblies). */
     exclusions?: ExclusionSet;
 }
 export declare const DUPLICATES_RULE: ClashRule;
 /**
  * Find duplicate / fully-overlapping elements. Returns a {@link ClashResult}
- * where each clash is a near-coincident pair: severity `major` for an exact
- * duplicate (same triangle count + near-identical box), `minor` for a looser
- * overlap candidate.
+ * where each clash is a near-coincident pair. `settings.tolerance` is
+ * `positionTolerance`, the value that actually decided the matches.
+ *
+ * Severity says exactly this much:
+ * - `major` — some pair of the two elements' boxes coincides within
+ *   `exactTolerance` **and** the two elements' meshes — summed over the
+ *   several parts a multi-material / CSG element emits — agree to within 5% on
+ *   both surface area and enclosed volume. Read it as "the same object, in the
+ *   same place"; it survives one copy being re-tessellated, and it does not
+ *   depend on which of a multi-part element's part pairings the sweep visited
+ *   first.
+ * - `minor` — near-coincident, but something differs: the boxes are further
+ *   apart than `exactTolerance`, the shapes disagree, or one element carries no
+ *   measurable geometry.
+ *
+ * What `major` still cannot tell you: the signature is two scalars over the
+ * surface, so two genuinely different solids that happen to agree in both area
+ * and volume to within 5% are indistinguishable here, as are an element and its
+ * mirror image.
+ *
+ * ## The nested-solids limit
+ *
+ * Matching remains AABB-only, so an element nested inside another — a pipe in a
+ * sleeve, a duct in a shaft, an assembly and the envelope drawn round it — is,
+ * in principle, something this pass cannot tell from a duplicate. Two gates
+ * already narrow that to a documented residual, and `duplicates.test.ts` pins
+ * each case:
+ *
+ * - Nesting has clearance, and {@link boxDistance} measures clearance. Anything
+ *   looser than ~7 mm of annulus is more than `positionTolerance` away and is
+ *   never reported at all: a DN100 pipe in a DN125 sleeve is 17.7 mm away, a
+ *   400×300 duct in a 500×400 shaft is 70.7 mm.
+ * - Tighter nesting *is* reported, but only ever as `minor`. Reaching `major`
+ *   additionally requires the two meshes to agree on surface area and enclosed
+ *   volume within 5%, which distinct solids sharing a box do not: a 50 mm and a
+ *   55 mm tube are 9.1% / 17.4% apart, a railing and its envelope box 73.2% /
+ *   88.4%.
+ *
+ * So the residual is exactly this: a pair nested within a few millimetres is
+ * listed as a `minor` candidate overlap. That is the intended reading of
+ * `minor` — "these two coincide, and this pass will not claim they are the same
+ * object" — and a reviewer still sees it, which for a coincidence hunt is the
+ * safe direction.
+ *
+ * Measured across five public models (duplex, AC20-FZK-Haus, Office_A_20110811,
+ * dental_clinic, Infra-Bridge), *no* reported pair was a nested one: all 33
+ * findings are same-type pairs of equal bounds, and the count of nested or
+ * cross-type pairs stays 0 even at a 250 mm tolerance, 25× the default. Note
+ * what that does not cover — none of the five carries pipe or duct segments, so
+ * the pipe-in-sleeve case is evidenced only by the constructed fixtures above.
+ *
+ * Closing the residual would need a narrow phase, which this pass deliberately
+ * does not run, and the cheap substitutes are worse rather than merely weaker.
+ * An area-weighted centroid plus surface inertia — the obvious candidate, and
+ * the same O(triangles) cost as the signature (3.6 ms vs 2.6 ms over
+ * dental_clinic's 236,795 triangles) — discriminates *less* on every nested
+ * case measured, contributes nothing at all when the nesting is concentric
+ * (identical centroids for pipe-in-sleeve and pipe-plus-insulation), and is not
+ * tessellation-invariant: it reads 39.6% apart on one box against a finer
+ * triangulation of the same box, which would break the exact-duplicate case
+ * this signature exists to keep together. A voxel occupancy sample would
+ * separate nested from coincident, but it needs a cell size — reintroducing the
+ * scale-dependent knob that replacing the IoU gate removed.
  */
 export declare function findDuplicates(elements: ClashElement[], options?: DuplicateOptions): ClashResult;
 //# sourceMappingURL=duplicates.d.ts.map

package/dist/duplicates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duplicates.d.ts","sourceRoot":"","sources":["../src/duplicates.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAEV,YAAY,EAEZ,WAAW,EACX,SAAS,EAGT,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;kFAC8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;uDACmD;IACnD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iFAAiF;IACjF,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B;AAQD,eAAO,MAAM,eAAe,EAAE,SAK7B,CAAC;AAkEF;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,OAAO,GAAE,gBAAqB,GAAG,WAAW,CAqGpG"}
+{"version":3,"file":"duplicates.d.ts","sourceRoot":"","sources":["../src/duplicates.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAEV,YAAY,EAEZ,WAAW,EACX,SAAS,EAGT,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;wBAEoB;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IAIH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;4DACwD;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iFAAiF;IACjF,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B;AAWD,eAAO,MAAM,eAAe,EAAE,SAK7B,CAAC;AAmBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,OAAO,GAAE,gBAAqB,GAAG,WAAW,CA4MpG"}