brepjs 18.113.0 → 18.115.0

package/dist/shapeRefFns-CuepnFOm.cjs

@@ -1,283 +0,0 @@
-const require_topologyQueryFns = require("./topologyQueryFns-CoXVHuN7.cjs");
-const require_faceFns = require("./faceFns-BV0GnTlt.cjs");
-const require_shapeFns = require("./shapeFns-ybo0INGL.cjs");
-const require_measureFns = require("./measureFns-DblG0Yaz.cjs");
-//#region src/topology/shapeRef/scoring.ts
-/**
-* Default face scorer combining surface type, normal alignment, centroid proximity,
-* and area similarity.
-*
-* Scoring breakdown:
-* - Surface type match: +1.0 (mismatch when both defined: -Infinity)
-* - Normal dot product: weighted contribution (rejected if < 0.707)
-* - Centroid distance: quadratic penalty (rejected if distSq > 100)
-* - Area ratio: penalized if |log(hintArea / faceArea)| > 1.0
-*/
-function defaultScorer(hint, face) {
-	let score = 0;
-	const faceType = require_faceFns.faceGeomType(face);
-	if (hint.surfaceType !== void 0) if (faceType === hint.surfaceType) score += 1;
-	else return -Infinity;
-	if (hint.normal !== void 0) {
-		const faceNormal = require_faceFns.normalAt(face);
-		const dot = hint.normal[0] * faceNormal[0] + hint.normal[1] * faceNormal[1] + hint.normal[2] * faceNormal[2];
-		if (dot < .707) return -Infinity;
-		score += dot;
-	}
-	if (hint.centroid !== void 0) {
-		const faceCentroid = require_faceFns.faceCenter(face);
-		const dx = hint.centroid[0] - faceCentroid[0];
-		const dy = hint.centroid[1] - faceCentroid[1];
-		const dz = hint.centroid[2] - faceCentroid[2];
-		const distSq = dx * dx + dy * dy + dz * dz;
-		if (distSq > 100) return -Infinity;
-		score -= distSq / 100;
-	}
-	if (hint.area !== void 0 && hint.area > 0) {
-		const areaResult = require_measureFns.measureArea(face);
-		if (areaResult.ok && areaResult.value > 0) {
-			const logRatio = Math.abs(Math.log(hint.area / areaResult.value));
-			if (logRatio > 1) score -= logRatio;
-		}
-	}
-	return score;
-}
-//#endregion
-//#region src/topology/shapeRef/shapeRefFns.ts
-/** Snapshot the geometric properties of a face for later matching. */
-function captureHint(face) {
-	const surfaceType = require_faceFns.faceGeomType(face);
-	const normal = require_faceFns.normalAt(face);
-	const centroid = require_faceFns.faceCenter(face);
-	const areaResult = require_measureFns.measureArea(face);
-	return {
-		entityType: "face",
-		surfaceType,
-		normal,
-		centroid,
-		area: areaResult.ok ? areaResult.value : void 0
-	};
-}
-/** Threshold for dominant-axis detection (abs(component) > 0.9). */
-var AXIS_THRESHOLD = .9;
-/** Determine the cardinal role name for a box face from its outward normal. */
-function boxRoleFromNormal(n) {
-	if (n[2] > AXIS_THRESHOLD) return "box:top";
-	if (n[2] < -.9) return "box:bottom";
-	if (n[1] > AXIS_THRESHOLD) return "box:back";
-	if (n[1] < -.9) return "box:front";
-	if (n[0] > AXIS_THRESHOLD) return "box:right";
-	if (n[0] < -.9) return "box:left";
-}
-/**
-* Auto-assign role names to the faces of a shape based on operation type.
-*
-* For 'box': uses face normals to assign cardinal names
-* ('box:top', 'box:bottom', 'box:front', 'box:back', 'box:left', 'box:right').
-* **Note:** Box role detection assumes axis-aligned faces (normal within 0.9 of
-* a cardinal axis). Rotated boxes may receive fewer than 6 named roles; remaining
-* faces fall through to sequential naming.
-*
-* For other types: sequential naming ('opType:face_0', 'opType:face_1', ...).
-*
-* @returns Map from role name to its face hash codes (one at assignment time;
-*   a role accrues more hashes only later, when `updateRoles` tracks a split).
-*/
-function assignRoles(shape, operationType) {
-	const faces = require_topologyQueryFns.getFaces(shape);
-	const roles = /* @__PURE__ */ new Map();
-	if (operationType === "box") {
-		for (const face of faces) {
-			const role = boxRoleFromNormal(require_faceFns.normalAt(face));
-			if (role !== void 0 && !roles.has(role)) roles.set(role, [require_shapeFns.getHashCode(face)]);
-		}
-		return roles;
-	}
-	let index = 0;
-	for (const face of faces) {
-		roles.set(`${operationType}:face_${index}`, [require_shapeFns.getHashCode(face)]);
-		index++;
-	}
-	return roles;
-}
-/** Create a ShapeRef from an origin ID, role name, and face. */
-function createRef(origin, role, face) {
-	return {
-		origin,
-		role,
-		hint: captureHint(face)
-	};
-}
-/**
-* Advance a role's face hashes through one evolution: drop deleted faces,
-* replace a modified face with *all* its successors (a 1→many split keeps every
-* fragment), and keep unchanged faces. Deduped so a shared successor isn't
-* doubled.
-*/
-function nextHashes(hashes, evolution) {
-	const successors = [];
-	for (const hash of hashes) {
-		if (evolution.deleted.has(hash)) continue;
-		const modified = evolution.modified.get(hash);
-		const targets = modified && modified.length > 0 ? modified : [hash];
-		for (const h of targets) if (!successors.includes(h)) successors.push(h);
-	}
-	return successors;
-}
-/**
-* Propagate a role table through a ShapeEvolution record.
-* Returns a new RoleTable with hashes updated according to the evolution.
-*
-* - Deleted faces: hash dropped (role removed once all its hashes are gone).
-* - Modified faces: hash replaced by **all** successor hashes — so a 1→many
-*   split keeps every fragment, and `resolveRef` disambiguates among them.
-* - Unchanged faces: hash preserved.
-*
-* Note: `evolution.generated` is intentionally not consumed here — on the OCCT
-* kernels its hashes refer to an intermediate shape, not the final result, so
-* naming generated faces produces roles that never resolve (verified: 0 live
-* generated hashes across cut/fuse on occt-wasm). Stable names for generated
-* geometry (fillet rounds, boolean seams) need history-fidelity work tracked
-* separately.
-*/
-function updateRoles(roles, origin, evolution) {
-	const originRoles = roles.get(origin);
-	if (!originRoles) return roles;
-	const updatedOriginRoles = /* @__PURE__ */ new Map();
-	for (const [role, hashes] of originRoles) {
-		const successors = nextHashes(hashes, evolution);
-		if (successors.length > 0) updatedOriginRoles.set(role, successors);
-	}
-	const newRoles = /* @__PURE__ */ new Map();
-	for (const [key, value] of roles) newRoles.set(key, key === origin ? updatedOriginRoles : value);
-	return newRoles;
-}
-/** Ambiguity threshold: if two scores are within this range, it's ambiguous. */
-var AMBIGUITY_THRESHOLD = .1;
-/** Minimum score for geometric fallback to accept a match. */
-var MIN_SCORE = .5;
-/**
-* Score `candidates` against `hint`, returning the best match, a tie within
-* {@link AMBIGUITY_THRESHOLD}, or nothing above {@link MIN_SCORE}. Scoping the
-* candidates to a role's tracked successors (rather than every face) is what
-* makes split-face disambiguation reliable — the fragments compete only with
-* each other, not with unrelated geometry.
-*/
-function scoreFaces(hint, candidates, scoreFn) {
-	let bestScore = -Infinity;
-	let bestFace;
-	let secondBestScore = -Infinity;
-	const scored = [];
-	for (const face of candidates) {
-		const score = scoreFn(hint, face);
-		if (score > MIN_SCORE) scored.push([face, score]);
-		if (score > bestScore) {
-			secondBestScore = bestScore;
-			bestScore = score;
-			bestFace = face;
-		} else if (score > secondBestScore) secondBestScore = score;
-	}
-	if (bestFace !== void 0 && bestScore > MIN_SCORE) {
-		if (bestScore - secondBestScore < AMBIGUITY_THRESHOLD && scored.length > 1) return {
-			kind: "ambiguous",
-			candidates: scored.filter(([, s]) => s >= bestScore - AMBIGUITY_THRESHOLD).map(([f]) => f)
-		};
-		return {
-			kind: "match",
-			face: bestFace
-		};
-	}
-	return { kind: "none" };
-}
-/**
-* Resolve a ShapeRef to a face in the current shape.
-*
-* Resolution strategy:
-* 1. Exact: the role's tracked successor hashes. One survivor → exact match;
-*    several survivors (a face that split) → disambiguate among *only those*
-*    fragments; none survive → deleted.
-* 2. Geometric fallback over the whole shape when the role isn't tracked (or a
-*    scoped score turned up nothing): best-scoring face, else ambiguous /
-*    not-found.
-*/
-function resolveRef(ref, roles, currentShape, scorer) {
-	const faces = require_topologyQueryFns.getFaces(currentShape);
-	const scoreFn = scorer ?? defaultScorer;
-	const targetHashes = roles.get(ref.origin)?.get(ref.role);
-	if (targetHashes !== void 0 && targetHashes.length > 0) {
-		const survivors = faces.filter((f) => targetHashes.includes(require_shapeFns.getHashCode(f)));
-		if (survivors.length === 1) {
-			const [only] = survivors;
-			if (only !== void 0) return {
-				face: only,
-				confidence: "exact"
-			};
-		} else if (survivors.length === 0) return {
-			ref,
-			reason: "deleted"
-		};
-		else {
-			const outcome = scoreFaces(ref.hint, survivors, scoreFn);
-			if (outcome.kind === "match") return {
-				face: outcome.face,
-				confidence: "geometric-fallback"
-			};
-			if (outcome.kind === "ambiguous") return {
-				ref,
-				reason: "ambiguous",
-				candidates: outcome.candidates
-			};
-		}
-	}
-	const outcome = scoreFaces(ref.hint, faces, scoreFn);
-	if (outcome.kind === "match") return {
-		face: outcome.face,
-		confidence: "geometric-fallback"
-	};
-	if (outcome.kind === "ambiguous") return {
-		ref,
-		reason: "ambiguous",
-		candidates: outcome.candidates
-	};
-	return {
-		ref,
-		reason: "not-found"
-	};
-}
-//#endregion
-Object.defineProperty(exports, "assignRoles", {
-	enumerable: true,
-	get: function() {
-		return assignRoles;
-	}
-});
-Object.defineProperty(exports, "captureHint", {
-	enumerable: true,
-	get: function() {
-		return captureHint;
-	}
-});
-Object.defineProperty(exports, "createRef", {
-	enumerable: true,
-	get: function() {
-		return createRef;
-	}
-});
-Object.defineProperty(exports, "defaultScorer", {
-	enumerable: true,
-	get: function() {
-		return defaultScorer;
-	}
-});
-Object.defineProperty(exports, "resolveRef", {
-	enumerable: true,
-	get: function() {
-		return resolveRef;
-	}
-});
-Object.defineProperty(exports, "updateRoles", {
-	enumerable: true,
-	get: function() {
-		return updateRoles;
-	}
-});