brepjs 18.35.3 → 18.35.5

package/dist/{occtWasmAdapter-DUruQhFF.js → occtWasmAdapter-DNXBos24.js}

@@ -1,4 +1,255 @@
 import { n as wasmIndex } from "./vec3-Dpha8d5k.js";
+//#region src/kernel/hullGeometry.ts
+function sub(a, b) {
+	return {
+		x: a.x - b.x,
+		y: a.y - b.y,
+		z: a.z - b.z
+	};
+}
+function cross(a, b) {
+	return {
+		x: a.y * b.z - a.z * b.y,
+		y: a.z * b.x - a.x * b.z,
+		z: a.x * b.y - a.y * b.x
+	};
+}
+function dot(a, b) {
+	return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function lengthVec(v) {
+	return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function distSq(a, b) {
+	const dx = a.x - b.x;
+	const dy = a.y - b.y;
+	const dz = a.z - b.z;
+	return dx * dx + dy * dy + dz * dz;
+}
+/** Safe array access — throws on out-of-bounds instead of returning undefined. */
+function at(arr, i) {
+	const v = arr[i];
+	if (v === void 0) throw new Error(`Index ${i} out of bounds`);
+	return v;
+}
+/** Safe number array access. */
+function atN(arr, i) {
+	const v = arr[i];
+	if (v === void 0) throw new Error(`Index ${i} out of bounds`);
+	return v;
+}
+function makeFace$1(points, a, b, c) {
+	const normal = cross(sub(at(points, b), at(points, a)), sub(at(points, c), at(points, a)));
+	const len = lengthVec(normal);
+	const n = len > 1e-14 ? {
+		x: normal.x / len,
+		y: normal.y / len,
+		z: normal.z / len
+	} : normal;
+	return {
+		a,
+		b,
+		c,
+		normal: n,
+		offset: dot(n, at(points, a)),
+		alive: true,
+		outsidePoints: []
+	};
+}
+function signedDist(face, point) {
+	return dot(face.normal, point) - face.offset;
+}
+function deduplicatePoints(points, tolerance) {
+	const tolSq = tolerance * tolerance;
+	const result = [];
+	for (const p of points) {
+		let isDuplicate = false;
+		for (const q of result) if (distSq(p, q) < tolSq) {
+			isDuplicate = true;
+			break;
+		}
+		if (!isDuplicate) result.push(p);
+	}
+	return result;
+}
+function findInitialTetrahedron(points) {
+	const n = points.length;
+	if (n < 4) return null;
+	let i0 = 0;
+	let i1 = 1;
+	let maxDist = distSq(at(points, 0), at(points, 1));
+	for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+		const d = distSq(at(points, i), at(points, j));
+		if (d > maxDist) {
+			maxDist = d;
+			i0 = i;
+			i1 = j;
+		}
+	}
+	if (maxDist < 1e-20) return null;
+	const lineDir = sub(at(points, i1), at(points, i0));
+	let i2 = -1;
+	let maxLineDist = -1;
+	for (let i = 0; i < n; i++) {
+		if (i === i0 || i === i1) continue;
+		const c = cross(lineDir, sub(at(points, i), at(points, i0)));
+		const d = dot(c, c);
+		if (d > maxLineDist) {
+			maxLineDist = d;
+			i2 = i;
+		}
+	}
+	if (i2 === -1 || maxLineDist < 1e-20) return null;
+	const planeNormal = cross(sub(at(points, i1), at(points, i0)), sub(at(points, i2), at(points, i0)));
+	const planeLen = lengthVec(planeNormal);
+	if (planeLen < 1e-14) return null;
+	const pn = {
+		x: planeNormal.x / planeLen,
+		y: planeNormal.y / planeLen,
+		z: planeNormal.z / planeLen
+	};
+	const planeOffset = dot(pn, at(points, i0));
+	let i3 = -1;
+	let maxPlaneDist = -1;
+	for (let i = 0; i < n; i++) {
+		if (i === i0 || i === i1 || i === i2) continue;
+		const d = Math.abs(dot(pn, at(points, i)) - planeOffset);
+		if (d > maxPlaneDist) {
+			maxPlaneDist = d;
+			i3 = i;
+		}
+	}
+	if (i3 === -1 || maxPlaneDist < 1e-14) return null;
+	if (dot(pn, at(points, i3)) - planeOffset > 0) return [
+		i0,
+		i2,
+		i1,
+		i3
+	];
+	return [
+		i0,
+		i1,
+		i2,
+		i3
+	];
+}
+/**
+* Compute the 3D convex hull of a point set.
+*
+* @throws if fewer than 4 non-coincident, non-coplanar points are supplied.
+*/
+function quickHull(inputPoints, tolerance) {
+	const points = deduplicatePoints(inputPoints, tolerance);
+	if (points.length < 4) throw new Error(points.length === 0 ? "No points provided for convex hull" : "Fewer than 4 non-coincident points; cannot form a 3D convex hull");
+	const tet = findInitialTetrahedron(points);
+	if (tet === null) throw new Error("All points are coplanar; cannot form a 3D convex hull");
+	const [t0, t1, t2, t3] = tet;
+	const centroid = {
+		x: (at(points, t0).x + at(points, t1).x + at(points, t2).x + at(points, t3).x) / 4,
+		y: (at(points, t0).y + at(points, t1).y + at(points, t2).y + at(points, t3).y) / 4,
+		z: (at(points, t0).z + at(points, t1).z + at(points, t2).z + at(points, t3).z) / 4
+	};
+	function makeOutwardFace(a, b, c) {
+		const face = makeFace$1(points, a, b, c);
+		const toCentroid = sub(centroid, {
+			x: (at(points, a).x + at(points, b).x + at(points, c).x) / 3,
+			y: (at(points, a).y + at(points, b).y + at(points, c).y) / 3,
+			z: (at(points, a).z + at(points, b).z + at(points, c).z) / 3
+		});
+		if (dot(face.normal, toCentroid) > 0) return makeFace$1(points, a, c, b);
+		return face;
+	}
+	const faces = [
+		makeOutwardFace(t0, t1, t2),
+		makeOutwardFace(t0, t2, t3),
+		makeOutwardFace(t0, t3, t1),
+		makeOutwardFace(t1, t3, t2)
+	];
+	const tetSet = new Set([
+		t0,
+		t1,
+		t2,
+		t3
+	]);
+	const epsilon = 1e-10;
+	for (let i = 0; i < points.length; i++) {
+		if (tetSet.has(i)) continue;
+		for (const face of faces) if (signedDist(face, at(points, i)) > epsilon) {
+			face.outsidePoints.push(i);
+			break;
+		}
+	}
+	for (let iteration = 0; iteration < points.length * 4; iteration++) {
+		let currentFace = null;
+		for (const face of faces) if (face.alive && face.outsidePoints.length > 0) {
+			currentFace = face;
+			break;
+		}
+		if (currentFace === null) break;
+		let furthestIdx = atN(currentFace.outsidePoints, 0);
+		let furthestDist = signedDist(currentFace, at(points, furthestIdx));
+		for (let i = 1; i < currentFace.outsidePoints.length; i++) {
+			const idx = atN(currentFace.outsidePoints, i);
+			const d = signedDist(currentFace, at(points, idx));
+			if (d > furthestDist) {
+				furthestDist = d;
+				furthestIdx = idx;
+			}
+		}
+		const visibleFaces = [];
+		for (const face of faces) if (face.alive && signedDist(face, at(points, furthestIdx)) > epsilon) visibleFaces.push(face);
+		const edgeCount = /* @__PURE__ */ new Map();
+		for (const face of visibleFaces) {
+			const edges = [
+				[face.a, face.b],
+				[face.b, face.c],
+				[face.c, face.a]
+			];
+			for (const [ea, eb] of edges) {
+				const key = ea < eb ? `${ea}-${eb}` : `${eb}-${ea}`;
+				const entry = edgeCount.get(key);
+				if (entry) entry.count++;
+				else edgeCount.set(key, {
+					a: ea,
+					b: eb,
+					count: 1
+				});
+			}
+		}
+		const horizonEdges = [];
+		for (const entry of edgeCount.values()) if (entry.count === 1) horizonEdges.push({
+			a: entry.a,
+			b: entry.b
+		});
+		const orphanedPoints = [];
+		for (const face of visibleFaces) {
+			for (const idx of face.outsidePoints) if (idx !== furthestIdx) orphanedPoints.push(idx);
+			face.alive = false;
+			face.outsidePoints = [];
+		}
+		const newFaces = [];
+		for (const edge of horizonEdges) {
+			const newFaceObj = makeFace$1(points, edge.a, edge.b, furthestIdx);
+			newFaces.push(newFaceObj);
+			faces.push(newFaceObj);
+		}
+		for (const idx of orphanedPoints) for (const face of newFaces) if (signedDist(face, at(points, idx)) > epsilon) {
+			face.outsidePoints.push(idx);
+			break;
+		}
+	}
+	const resultFaces = [];
+	for (const face of faces) if (face.alive) resultFaces.push([
+		face.a,
+		face.b,
+		face.c
+	]);
+	return {
+		faces: resultFaces,
+		points
+	};
+}
+//#endregion
 //#region src/kernel/geometry2d.ts
 function evaluateCurve2d$1(c, t) {
 	switch (c.__bk2d) {
@@ -1115,6 +1366,12 @@ function mesh(k, Module, shape, options) {
 		for (let i = 0; i < posCount; i++) vertices[i] = Module.HEAPF32[posPtr + i] ?? 0;
 		const normals = new Float32Array(normCount);
 		if (!options.skipNormals) for (let i = 0; i < normCount; i++) normals[i] = Module.HEAPF32[normPtr + i] ?? 0;
+		const uvCount = meshData.uvCount;
+		const uvs = new Float32Array(options.includeUVs ? uvCount : 0);
+		if (options.includeUVs && uvCount > 0) {
+			const uvPtr = meshData.getUvsPtr() >> 2;
+			for (let i = 0; i < uvCount; i++) uvs[i] = Module.HEAPF32[uvPtr + i] ?? 0;
+		}
 		const triangles = new Uint32Array(idxCount);
 		for (let i = 0; i < idxCount; i++) triangles[i] = Module.HEAPU32[idxPtr + i] ?? 0;
 		const faceGroups = [];
@@ -1131,7 +1388,7 @@ function mesh(k, Module, shape, options) {
 			vertices,
 			normals: options.skipNormals ? new Float32Array(0) : normals,
 			triangles,
-			uvs: new Float32Array(0),
+			uvs,
 			faceGroups
 		};
 	} finally {
@@ -2974,10 +3231,27 @@ function makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle
 function makeBezier2d(points) {
 	return c2dWrap(makeBezier2d$1(points));
 }
-function makeBSpline2d(points) {
-	if (points.length <= 25) return c2dWrap(makeBezier2d$1(points));
-	const step = Math.max(1, Math.floor(points.length / 24));
-	return c2dWrap(makeBezier2d$1(points.filter((_, i) => i % step === 0 || i === points.length - 1)));
+function makeBSpline2d(points, options) {
+	const poles = points;
+	const n = poles.length;
+	const degree = Math.max(1, Math.min(options?.degMax ?? 3, n - 1));
+	const knots = [0];
+	const mults = [degree + 1];
+	const nInternalKnots = n - degree - 1;
+	for (let i = 1; i <= nInternalKnots; i++) {
+		knots.push(i / (nInternalKnots + 1));
+		mults.push(1);
+	}
+	knots.push(1);
+	mults.push(degree + 1);
+	return c2dWrap({
+		__bk2d: "bspline",
+		poles,
+		knots,
+		multiplicities: mults,
+		degree,
+		isPeriodic: false
+	});
 }
 function evaluateCurve2d(curve, param) {
 	return evaluateCurve2d$1(c2d(curve), param);
@@ -3222,16 +3496,53 @@ function approximateCurve2dAsBSpline(curve, maxSegments) {
 	});
 }
 function decomposeBSpline2dToBeziers(curve) {
-	const knots = c2d(curve).knots ?? [];
-	if (knots.length < 2) return [curve];
-	const result = [];
-	for (let i = 0; i < knots.length - 1; i++) {
-		const k0 = knots[i];
-		const k1 = knots[i + 1];
-		if (Math.abs(k1 - k0) < 1e-15) continue;
-		result.push(trimCurve2d(curve, k0, k1));
+	let cu = c2d(curve);
+	while (cu.__bk2d === "trimmed" && cu.basis) cu = cu.basis;
+	if (cu.__bk2d !== "bspline") return [curve];
+	const poles = cu.poles;
+	const p = cu.degree;
+	const U = [];
+	for (let i = 0; i < cu.knots.length; i++) for (let j = 0; j < cu.multiplicities[i]; j++) U.push(cu.knots[i]);
+	const m = poles.length - 1 + p + 1;
+	if (p < 1 || U.length !== m + 1) return [c2dWrap(makeBezier2d$1(poles))];
+	const clone = (pt) => [pt[0], pt[1]];
+	const segments = [];
+	let a = p;
+	let b = p + 1;
+	let segPoles = [];
+	for (let i = 0; i <= p; i++) segPoles[i] = clone(poles[i]);
+	let nextPoles = [];
+	while (b < m) {
+		const i0 = b;
+		while (b < m && U[b + 1] === U[b]) b++;
+		const mult = b - i0 + 1;
+		if (mult < p) {
+			const numer = U[b] - U[a];
+			const alphas = [];
+			for (let j = p; j > mult; j--) alphas[j - mult - 1] = numer / (U[a + j] - U[a]);
+			const r = p - mult;
+			for (let j = 1; j <= r; j++) {
+				const save = r - j;
+				const s = mult + j;
+				for (let k = p; k >= s; k--) {
+					const alpha = alphas[k - s];
+					const cur = segPoles[k];
+					const prev = segPoles[k - 1];
+					segPoles[k] = [alpha * cur[0] + (1 - alpha) * prev[0], alpha * cur[1] + (1 - alpha) * prev[1]];
+				}
+				if (b < m) nextPoles[save] = clone(segPoles[p]);
+			}
+		}
+		segments.push(segPoles);
+		if (b < m) {
+			for (let i = p - mult; i <= p; i++) nextPoles[i] = clone(poles[b - p + i]);
+			segPoles = nextPoles;
+			nextPoles = [];
+			a = b;
+			b++;
+		}
 	}
-	return result.length > 0 ? result : [curve];
+	return segments.map((sp) => c2dWrap(makeBezier2d$1(sp)));
 }
 function createBoundingBox2d() {
 	return createBBox2d();
@@ -3684,124 +3995,41 @@ function applyComposedTransformWithHistory(transformFn, iterShapesFn, hashCodeFn
 }
 //#endregion
 //#region src/kernel/occtWasm/hullOps.ts
-function findHorizonEdges(faces, visible) {
-	const visSet = new Set(visible);
-	const horizon = [];
-	for (const fi of visible) {
-		const f = faces[fi];
-		for (let ei = 0; ei < 3; ei++) {
-			const a = f[ei], b = f[(ei + 1) % 3];
-			if (faces.some((g, fj) => fj !== fi && !visSet.has(fj) && [
-				0,
-				1,
-				2
-			].some((ej) => g[ej] === b && g[(ej + 1) % 3] === a))) horizon.push([a, b]);
-		}
-	}
-	return horizon;
+function hullFromPoints(k, Module, points, tolerance) {
+	if (points.length < 4) throw new Error("hullFromPoints: need at least 4 points");
+	const { points: hullPoints, faces } = quickHull(points, tolerance);
+	if (faces.length < 4) throw new Error("hullFromPoints: degenerate hull (fewer than 4 faces)");
+	return buildSolidFromFaces(k, Module, [...hullPoints], [...faces], tolerance);
 }
-function computeConvexHullFaces(pts) {
-	const cross = (a, b) => ({
-		x: a.y * b.z - a.z * b.y,
-		y: a.z * b.x - a.x * b.z,
-		z: a.x * b.y - a.y * b.x
-	});
-	const sub = (a, b) => ({
-		x: a.x - b.x,
-		y: a.y - b.y,
-		z: a.z - b.z
-	});
-	const dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
-	const n = pts.length;
-	const faces = [];
-	const p0 = pts[0];
-	let i1 = 1;
-	while (i1 < n) {
-		const p = wasmIndex(pts, i1);
-		if (Math.hypot(p.x - p0.x, p.y - p0.y, p.z - p0.z) >= 1e-10) break;
-		i1++;
-	}
-	let i2 = i1 + 1;
-	const e01 = sub(pts[i1], p0);
-	while (i2 < n) {
-		const c = cross(e01, sub(pts[i2], p0));
-		if (Math.hypot(c.x, c.y, c.z) > 1e-10) break;
-		i2++;
-	}
-	let i3 = i2 + 1;
-	const norm = cross(e01, sub(pts[i2], p0));
-	while (i3 < n) {
-		if (Math.abs(dot(norm, sub(pts[i3], p0))) > 1e-10) break;
-		i3++;
-	}
-	if (i3 >= n) return [[
-		0,
-		1,
-		2
-	]];
-	if (dot(cross(sub(pts[i1], p0), sub(pts[i2], p0)), sub(pts[i3], p0)) > 0) faces.push([
-		0,
-		i1,
-		i2
-	], [
-		0,
-		i2,
-		i3
-	], [
-		0,
-		i3,
-		i1
-	], [
-		i1,
-		i3,
-		i2
-	]);
-	else faces.push([
-		0,
-		i2,
-		i1
-	], [
-		0,
-		i3,
-		i2
-	], [
-		0,
-		i1,
-		i3
-	], [
-		i2,
-		i3,
-		i1
-	]);
-	const used = new Set([
-		0,
-		i1,
-		i2,
-		i3
-	]);
-	for (let pi = 0; pi < n; pi++) {
-		if (used.has(pi)) continue;
-		const p = pts[pi];
-		const visible = [];
-		for (let fi = 0; fi < faces.length; fi++) {
-			const f = faces[fi];
-			if (dot(cross(sub(pts[f[1]], pts[f[0]]), sub(pts[f[2]], pts[f[0]])), sub(p, pts[f[0]])) > 1e-10) visible.push(fi);
+/**
+* Sample surface vertices of each shape via tessellation. A coarse deflection
+* keeps the point count low — the convex hull only needs extreme points, and
+* fine meshes on curved surfaces explode the hull cost.
+*/
+function extractVertices(k, Module, shapes, tolerance) {
+	const deflection = Math.max(tolerance, 1);
+	const points = [];
+	for (const shape of shapes) {
+		const meshData = k.tessellate(unwrap(shape), deflection, deflection * .5);
+		try {
+			const posCount = meshData.positionCount;
+			const posPtr = meshData.getPositionsPtr() >> 2;
+			for (let i = 0; i < posCount; i += 3) points.push({
+				x: Module.HEAPF32[posPtr + i] ?? 0,
+				y: Module.HEAPF32[posPtr + i + 1] ?? 0,
+				z: Module.HEAPF32[posPtr + i + 2] ?? 0
+			});
+		} finally {
+			meshData.delete();
 		}
-		if (visible.length === 0) continue;
-		const horizon = findHorizonEdges(faces, visible);
-		visible.sort((a2, b2) => b2 - a2);
-		for (const fi of visible) faces.splice(fi, 1);
-		for (const [a, b] of horizon) faces.push([
-			a,
-			b,
-			pi
-		]);
-	}
-	return faces;
+	}
+	return points;
 }
-function hullFromPoints(k, Module, points, tolerance) {
-	if (points.length < 4) throw new Error("hullFromPoints: need at least 4 points");
-	return buildSolidFromFaces(k, Module, points, computeConvexHullFaces(points), tolerance);
+function hull(k, Module, shapes, tolerance) {
+	if (shapes.length === 0) throw new Error("hull: no shapes provided");
+	const points = extractVertices(k, Module, shapes, tolerance);
+	if (points.length < 4) throw new Error("hull: fewer than 4 vertices extracted from input shapes");
+	return hullFromPoints(k, Module, points, tolerance);
 }
 //#endregion
 //#region src/kernel/occtWasm/occtWasmAdapter.ts
@@ -3957,8 +4185,8 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	solidFromShell(shell) {
 		return solidFromShell(this.k, shell);
 	}
-	hull(_shapes, _tolerance) {
-		notImplemented("hull");
+	hull(shapes, tolerance) {
+		return hull(this.k, this.Module, shapes, tolerance);
 	}
 	hullFromPoints(points, tolerance) {
 		return hullFromPoints(this.k, this.Module, points, tolerance);
@@ -4620,4 +4848,4 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	}
 };
 //#endregion
-export { serializeCurve2d$1 as _, curveTypeName as a, intersectCurves2dFn as c, makeEllipse2d$1 as d, makeLine2d$1 as f, scaleCurve2d$1 as g, rotateCurve2d$1 as h, curveBounds as i, makeBezier2d$1 as l, mirrorAtPoint as m, addCurveToBBox as n, deserializeCurve2d$1 as o, mirrorAcrossAxis as p, createBBox2d as r, evaluateCurve2d$1 as s, OcctWasmAdapter as t, makeCircle2d$1 as u, tangentCurve2d as v, translateCurve2d$1 as y };
+export { serializeCurve2d$1 as _, curveTypeName as a, quickHull as b, intersectCurves2dFn as c, makeEllipse2d$1 as d, makeLine2d$1 as f, scaleCurve2d$1 as g, rotateCurve2d$1 as h, curveBounds as i, makeBezier2d$1 as l, mirrorAtPoint as m, addCurveToBBox as n, deserializeCurve2d$1 as o, mirrorAcrossAxis as p, createBBox2d as r, evaluateCurve2d$1 as s, OcctWasmAdapter as t, makeCircle2d$1 as u, tangentCurve2d as v, translateCurve2d$1 as y };