brepjs 13.2.0 → 14.1.2

package/dist/shapeRefFns-CVdS6jWS.cjs

@@ -0,0 +1,229 @@
+const require_faceFns = require("./faceFns-cE2WxY6I.cjs");
+const require_shapeFns = require("./shapeFns-aEeSHNqX.cjs");
+const require_measureFns = require("./measureFns-D_QKZ5yg.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] < -AXIS_THRESHOLD) return "box:bottom";
+	if (n[1] > AXIS_THRESHOLD) return "box:back";
+	if (n[1] < -AXIS_THRESHOLD) return "box:front";
+	if (n[0] > AXIS_THRESHOLD) return "box:right";
+	if (n[0] < -AXIS_THRESHOLD) 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 face hash code
+*/
+function assignRoles(shape, operationType) {
+	const faces = require_shapeFns.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)
+	};
+}
+/**
+* Propagate a role table through a ShapeEvolution record.
+* Returns a new RoleTable with hashes updated according to the evolution.
+*
+* - Deleted faces: role removed
+* - Modified faces: hash updated to first result hash
+* - Unchanged faces: hash preserved
+*
+* **Limitation:** When a face splits (1→many in `evolution.modified`), only the
+* first successor hash is tracked. The geometric fallback in `resolveRef` handles
+* cases where this picks the "wrong" successor. A future version may return
+* multi-hash mappings for split-aware resolution.
+*/
+function updateRoles(roles, origin, evolution) {
+	const originRoles = roles.get(origin);
+	if (!originRoles) return roles;
+	const updatedOriginRoles = /* @__PURE__ */ new Map();
+	for (const [role, hash] of originRoles) {
+		if (evolution.deleted.has(hash)) continue;
+		const modifiedHashes = evolution.modified.get(hash);
+		if (modifiedHashes && modifiedHashes.length > 0) updatedOriginRoles.set(role, modifiedHashes[0]);
+		else updatedOriginRoles.set(role, hash);
+	}
+	const newRoles = /* @__PURE__ */ new Map();
+	for (const [key, value] of roles) if (key === origin) newRoles.set(key, updatedOriginRoles);
+	else newRoles.set(key, 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;
+/**
+* Resolve a ShapeRef to a face in the current shape.
+*
+* Resolution strategy:
+* 1. Exact lookup via role table hash match
+* 2. Geometric fallback using scorer against all faces
+* 3. Ambiguous if multiple faces score within threshold
+* 4. Not-found if no match above minimum score
+*/
+function resolveRef(ref, roles, currentShape, scorer) {
+	const faces = require_shapeFns.getFaces(currentShape);
+	const scoreFn = scorer ?? defaultScorer;
+	const targetHash = roles.get(ref.origin)?.get(ref.role);
+	if (targetHash !== void 0) {
+		for (const face of faces) if (require_shapeFns.getHashCode(face) === targetHash) return {
+			face,
+			confidence: "exact"
+		};
+		return {
+			ref,
+			reason: "deleted"
+		};
+	}
+	let bestScore = -Infinity;
+	let bestFace;
+	let secondBestScore = -Infinity;
+	const scored = [];
+	for (const face of faces) {
+		const score = scoreFn(ref.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 {
+			ref,
+			reason: "ambiguous",
+			candidates: scored.filter(([, s]) => s >= bestScore - AMBIGUITY_THRESHOLD).map(([f]) => f)
+		};
+		return {
+			face: bestFace,
+			confidence: "geometric-fallback"
+		};
+	}
+	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;
+	}
+});