brepjs 18.78.1 → 18.79.0

package/dist/{threadFns-a_C2wGGt.cjs → threadFns-B7a1EVpS.cjs}

@@ -255,6 +255,420 @@ function collectShapes(root) {
 	return shapes;
 }
 //#endregion
+//#region src/utils/quaternion.ts
+function dot(a, b) {
+	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross$1(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+function normalize(a) {
+	const l = Math.hypot(a[0], a[1], a[2]) || 1;
+	return [
+		a[0] / l,
+		a[1] / l,
+		a[2] / l
+	];
+}
+/** A unit vector perpendicular to `v` (for the 180°/parallel degenerate cases). */
+function anyPerpendicular$1(v) {
+	return normalize(cross$1(v, Math.abs(v[0]) < .9 ? [
+		1,
+		0,
+		0
+	] : [
+		0,
+		1,
+		0
+	]));
+}
+/** Rotate vector `v` by quaternion `q`. */
+function quatRotate(q, v) {
+	const [w, x, y, z] = q;
+	const tx = 2 * (y * v[2] - z * v[1]);
+	const ty = 2 * (z * v[0] - x * v[2]);
+	const tz = 2 * (x * v[1] - y * v[0]);
+	return [
+		v[0] + w * tx + (y * tz - z * ty),
+		v[1] + w * ty + (z * tx - x * tz),
+		v[2] + w * tz + (x * ty - y * tx)
+	];
+}
+/** Quaternion for a rotation of `angle` radians about (unit-normalized) `axis`. */
+function quatFromAxisAngle(axis, angle) {
+	const h = angle / 2;
+	const s = Math.sin(h);
+	const u = normalize(axis);
+	return [
+		Math.cos(h),
+		u[0] * s,
+		u[1] * s,
+		u[2] * s
+	];
+}
+/** Shortest-arc quaternion rotating unit vector `from` onto unit vector `to`. */
+function quatFromTo(from, to) {
+	const a = normalize(from);
+	const b = normalize(to);
+	const d = dot(a, b);
+	if (d >= .999999999) return [
+		1,
+		0,
+		0,
+		0
+	];
+	if (d <= -.999999999) return quatFromAxisAngle(anyPerpendicular$1(a), Math.PI);
+	const c = cross$1(a, b);
+	const len = Math.hypot(1 + d, c[0], c[1], c[2]) || 1;
+	return [
+		(1 + d) / len,
+		c[0] / len,
+		c[1] / len,
+		c[2] / len
+	];
+}
+/** Hamilton product `a ⊗ b` — the rotation that applies `b` first, then `a`. */
+function quatMultiply(a, b) {
+	const [aw, ax, ay, az] = a;
+	const [bw, bx, by, bz] = b;
+	return [
+		aw * bw - ax * bx - ay * by - az * bz,
+		aw * bx + ax * bw + ay * bz - az * by,
+		aw * by - ax * bz + ay * bw + az * bx,
+		aw * bz + ax * by - ay * bx + az * bw
+	];
+}
+//#endregion
+//#region src/operations/jointFns.ts
+var DEG2RAD = Math.PI / 180;
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function unit(v) {
+	const l = Math.hypot(v[0], v[1], v[2]) || 1;
+	return [
+		v[0] / l,
+		v[1] / l,
+		v[2] / l
+	];
+}
+function cross(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+/** A unit vector perpendicular to `v` (for the unspecified-reference case). */
+function anyPerpendicular(v) {
+	return unit(cross(v, Math.abs(v[0]) < .9 ? [
+		1,
+		0,
+		0
+	] : [
+		0,
+		1,
+		0
+	]));
+}
+/** Build one DOF, normalizing an inverted range and clamping the initial value. */
+function makeDof(kind, axis, opts, defMin, defMax) {
+	const a = opts.min ?? defMin;
+	const b = opts.max ?? defMax;
+	const min = Math.min(a, b);
+	const max = Math.max(a, b);
+	return {
+		kind,
+		axis: unit(axis),
+		min,
+		max,
+		value: clamp(opts.value ?? 0, min, max)
+	};
+}
+/** Assemble a Joint from its DOFs, mirroring the primary DOF into the top level. */
+function buildJoint(type, parent, child, axis, dofs) {
+	const primary = dofs[0] ?? {
+		kind: "rotation",
+		axis: [
+			0,
+			0,
+			1
+		],
+		min: 0,
+		max: 0,
+		value: 0
+	};
+	return {
+		type,
+		parent,
+		child,
+		axis: {
+			origin: axis.origin,
+			direction: unit(axis.direction)
+		},
+		min: primary.min,
+		max: primary.max,
+		value: primary.value,
+		dofs
+	};
+}
+/** A revolute (hinge) joint — the child rotates about `axis` by `value` degrees. */
+function revoluteJoint(parent, child, axis, opts = {}) {
+	return buildJoint("revolute", parent, child, axis, [makeDof("rotation", axis.direction, opts, -180, 180)]);
+}
+/**
+* A prismatic (slider) joint — the child translates along `axis` by `value`
+* units. Only `axis.direction` is used; `axis.origin` is ignored (a pure
+* translation has no anchor point), unlike a revolute joint which rotates about
+* the axis line through `origin`.
+*/
+function prismaticJoint(parent, child, axis, opts = {}) {
+	return buildJoint("prismatic", parent, child, axis, [makeDof("translation", axis.direction, opts, 0, 100)]);
+}
+/**
+* A cylindrical joint — the child both rotates about and slides along a single
+* `axis` (2 DOF). DOF order: `[rotation, translation]`. The two motions share
+* the axis, so they commute; rotation pivots about `axis.origin`.
+*/
+function cylindricalJoint(parent, child, axis, opts = {}) {
+	return buildJoint("cylindrical", parent, child, axis, [makeDof("rotation", axis.direction, opts.rotation ?? {}, -180, 180), makeDof("translation", axis.direction, opts.translation ?? {}, 0, 100)]);
+}
+/**
+* A planar joint — the child translates within a plane and rotates about its
+* normal (3 DOF). `plane.direction` is the normal; `plane.origin` the rotation
+* anchor. DOF order: `[u-translation, v-translation, rotation]`, where the
+* translations are applied in the plane frame (independent of the rotation).
+*/
+function planarJoint(parent, child, plane, opts = {}) {
+	const normal = unit(plane.direction);
+	let u;
+	if (opts.uDirection) {
+		const d = opts.uDirection;
+		const proj = d[0] * normal[0] + d[1] * normal[1] + d[2] * normal[2];
+		const inPlane = [
+			d[0] - proj * normal[0],
+			d[1] - proj * normal[1],
+			d[2] - proj * normal[2]
+		];
+		u = Math.hypot(inPlane[0], inPlane[1], inPlane[2]) < 1e-9 ? anyPerpendicular(normal) : unit(inPlane);
+	} else u = anyPerpendicular(normal);
+	const v = unit(cross(normal, u));
+	return buildJoint("planar", parent, child, {
+		origin: plane.origin,
+		direction: normal
+	}, [
+		makeDof("translation", u, opts.u ?? {}, -100, 100),
+		makeDof("translation", v, opts.v ?? {}, -100, 100),
+		makeDof("rotation", normal, opts.rotation ?? {}, -180, 180)
+	]);
+}
+/**
+* A spherical (ball) joint — the child rotates freely about a pivot point
+* (3 DOF). DOF order: `[x, y, z]` rotations about the local axes through
+* `pivot`, composed as `Rx · Ry · Rz`.
+*/
+function sphericalJoint(parent, child, pivot, opts = {}) {
+	return buildJoint("spherical", parent, child, {
+		origin: pivot,
+		direction: [
+			0,
+			0,
+			1
+		]
+	}, [
+		makeDof("rotation", [
+			1,
+			0,
+			0
+		], opts.x ?? {}, -180, 180),
+		makeDof("rotation", [
+			0,
+			1,
+			0
+		], opts.y ?? {}, -180, 180),
+		makeDof("rotation", [
+			0,
+			0,
+			1
+		], opts.z ?? {}, -180, 180)
+	]);
+}
+/**
+* Return a copy of `joint` with per-DOF values set (each clamped to its range).
+* Values are positional, matching `joint.dofs`; omitted entries keep their
+* stored value. The primary mirror (`value`) is kept in sync with `dofs[0]`.
+*/
+function setJointValues(joint, values) {
+	const dofs = joint.dofs.map((d, i) => {
+		const v = values[i];
+		return v === void 0 ? d : {
+			...d,
+			value: clamp(v, d.min, d.max)
+		};
+	});
+	const primary = dofs[0];
+	return primary ? {
+		...joint,
+		dofs,
+		value: primary.value
+	} : {
+		...joint,
+		dofs
+	};
+}
+/** Return a copy of `joint` with its primary DOF set (clamped to range). */
+function setJointValue(joint, value) {
+	return setJointValues(joint, [value]);
+}
+/** The local rigid transform contributed by a single DOF at `value`. */
+function dofPose(origin, dof, value) {
+	if (dof.kind === "translation") return {
+		position: [
+			dof.axis[0] * value,
+			dof.axis[1] * value,
+			dof.axis[2] * value
+		],
+		rotation: [
+			1,
+			0,
+			0,
+			0
+		]
+	};
+	const rotation = quatFromAxisAngle(dof.axis, value * DEG2RAD);
+	const ro = quatRotate(rotation, origin);
+	return {
+		position: [
+			origin[0] - ro[0],
+			origin[1] - ro[1],
+			origin[2] - ro[2]
+		],
+		rotation
+	};
+}
+/**
+* The child's local rigid transform (relative to the parent) for given DOF
+* values. Defaults to each DOF's stored value. A single `number` overrides only
+* the primary DOF (single-DOF ergonomics); an array overrides positionally,
+* with omitted entries keeping their stored value. Each value is clamped to its
+* DOF range.
+*
+* DOFs are folded in array order via frame composition. For same-anchor
+* rotations (e.g. spherical) this composes to a single rotation about the pivot;
+* for a cylindrical axis the rotation and slide commute.
+*/
+function jointTransform(joint, value = joint.value) {
+	const overrides = Array.isArray(value) ? value : void 0;
+	const primary = overrides ? void 0 : value;
+	const origin = joint.axis.origin;
+	let pose = IDENTITY_POSE;
+	for (let i = 0; i < joint.dofs.length; i++) {
+		const dof = joint.dofs[i];
+		if (!dof) continue;
+		const raw = overrides ? overrides[i] ?? dof.value : i === 0 ? primary ?? dof.value : dof.value;
+		pose = composePose(pose, dofPose(origin, dof, clamp(raw, dof.min, dof.max)));
+	}
+	return pose;
+}
+/** Attach a joint to an assembly node. Returns a new node (immutable). */
+function addJoint(assembly, joint) {
+	const existing = assembly.joints ?? [];
+	return {
+		...assembly,
+		joints: [...existing, joint]
+	};
+}
+var IDENTITY_POSE = {
+	position: [
+		0,
+		0,
+		0
+	],
+	rotation: [
+		1,
+		0,
+		0,
+		0
+	]
+};
+/** Compose two poses: the result applies `b` in `a`'s frame (`a ∘ b`). */
+function composePose(a, b) {
+	const rb = quatRotate(a.rotation, b.position);
+	return {
+		position: [
+			a.position[0] + rb[0],
+			a.position[1] + rb[1],
+			a.position[2] + rb[2]
+		],
+		rotation: quatMultiply(a.rotation, b.rotation)
+	};
+}
+/** Collect every joint attached anywhere in the assembly tree. */
+function collectJoints(assembly) {
+	const joints = [];
+	walkAssembly(assembly, (node) => {
+		if (node.joints) joints.push(...node.joints);
+	});
+	return joints;
+}
+/**
+* Forward kinematics: set joint values and propagate world poses down the
+* kinematic chain. Each joint's axis is interpreted in its **parent's** frame,
+* so a child's world pose is `parentWorld ∘ jointTransform(joint, value)`.
+*
+* Bodies not driven by a joint (chain roots) start at the origin. `jointValues`
+* overrides a joint's stored value, keyed by the **child** node name; omitted
+* joints use `joint.value`. Resolution is topological (reuses the Phase-0
+* ordering), so chains of any depth compose. Returns a world pose for every node.
+*/
+function forwardKinematics(assembly, jointValues = {}) {
+	const joints = [];
+	const names = /* @__PURE__ */ new Set();
+	walkAssembly(assembly, (node) => {
+		names.add(node.name);
+		if (node.joints) joints.push(...node.joints);
+	});
+	const byChild = /* @__PURE__ */ new Map();
+	for (const j of joints) {
+		byChild.set(j.child, j);
+		names.add(j.parent);
+		names.add(j.child);
+	}
+	const poses = /* @__PURE__ */ new Map();
+	for (const name of names) if (!byChild.has(name)) poses.set(name, IDENTITY_POSE);
+	const pending = [...joints];
+	let progress = true;
+	while (progress && pending.length > 0) {
+		progress = false;
+		for (let i = pending.length - 1; i >= 0; i--) {
+			const j = pending[i];
+			if (!j) continue;
+			const parentPose = poses.get(j.parent);
+			if (!parentPose) continue;
+			pending.splice(i, 1);
+			progress = true;
+			if (poses.has(j.child)) continue;
+			const value = jointValues[j.child] ?? j.value;
+			poses.set(j.child, composePose(parentPose, jointTransform(j, value)));
+		}
+	}
+	for (const j of pending) if (!poses.has(j.child)) poses.set(j.child, IDENTITY_POSE);
+	return poses;
+}
+/**
+* Open-chain mobility — the number of independent degrees of freedom, summing
+* each joint's DOF count (revolute/prismatic 1, cylindrical 2, planar/spherical
+* 3). For a serial chain this equals the total DOF. (Closed-loop
+* Grübler/Kutzbach analysis is future work.)
+*/
+function mechanismDOF(assembly) {
+	return collectJoints(assembly).reduce((sum, j) => sum + j.dofs.length, 0);
+}
+//#endregion
 //#region src/operations/historyFns.ts
 /** Create a new empty history. */
 function createHistory() {
@@ -528,6 +942,12 @@ Object.defineProperty(exports, "addChild", {
 		return addChild;
 	}
 });
+Object.defineProperty(exports, "addJoint", {
+	enumerable: true,
+	get: function() {
+		return addJoint;
+	}
+});
 Object.defineProperty(exports, "addStep", {
 	enumerable: true,
 	get: function() {
@@ -576,6 +996,12 @@ Object.defineProperty(exports, "createRegistry", {
 		return createRegistry;
 	}
 });
+Object.defineProperty(exports, "cylindricalJoint", {
+	enumerable: true,
+	get: function() {
+		return cylindricalJoint;
+	}
+});
 Object.defineProperty(exports, "deserializeHistory", {
 	enumerable: true,
 	get: function() {
@@ -600,6 +1026,12 @@ Object.defineProperty(exports, "findStep", {
 		return findStep;
 	}
 });
+Object.defineProperty(exports, "forwardKinematics", {
+	enumerable: true,
+	get: function() {
+		return forwardKinematics;
+	}
+});
 Object.defineProperty(exports, "getShape", {
 	enumerable: true,
 	get: function() {
@@ -612,18 +1044,60 @@ Object.defineProperty(exports, "gridPattern", {
 		return gridPattern;
 	}
 });
+Object.defineProperty(exports, "jointTransform", {
+	enumerable: true,
+	get: function() {
+		return jointTransform;
+	}
+});
 Object.defineProperty(exports, "linearPattern", {
 	enumerable: true,
 	get: function() {
 		return linearPattern;
 	}
 });
+Object.defineProperty(exports, "mechanismDOF", {
+	enumerable: true,
+	get: function() {
+		return mechanismDOF;
+	}
+});
 Object.defineProperty(exports, "modifyStep", {
 	enumerable: true,
 	get: function() {
 		return modifyStep;
 	}
 });
+Object.defineProperty(exports, "planarJoint", {
+	enumerable: true,
+	get: function() {
+		return planarJoint;
+	}
+});
+Object.defineProperty(exports, "prismaticJoint", {
+	enumerable: true,
+	get: function() {
+		return prismaticJoint;
+	}
+});
+Object.defineProperty(exports, "quatFromAxisAngle", {
+	enumerable: true,
+	get: function() {
+		return quatFromAxisAngle;
+	}
+});
+Object.defineProperty(exports, "quatFromTo", {
+	enumerable: true,
+	get: function() {
+		return quatFromTo;
+	}
+});
+Object.defineProperty(exports, "quatRotate", {
+	enumerable: true,
+	get: function() {
+		return quatRotate;
+	}
+});
 Object.defineProperty(exports, "registerOperation", {
 	enumerable: true,
 	get: function() {
@@ -654,12 +1128,36 @@ Object.defineProperty(exports, "replayHistory", {
 		return replayHistory;
 	}
 });
+Object.defineProperty(exports, "revoluteJoint", {
+	enumerable: true,
+	get: function() {
+		return revoluteJoint;
+	}
+});
 Object.defineProperty(exports, "serializeHistory", {
 	enumerable: true,
 	get: function() {
 		return serializeHistory;
 	}
 });
+Object.defineProperty(exports, "setJointValue", {
+	enumerable: true,
+	get: function() {
+		return setJointValue;
+	}
+});
+Object.defineProperty(exports, "setJointValues", {
+	enumerable: true,
+	get: function() {
+		return setJointValues;
+	}
+});
+Object.defineProperty(exports, "sphericalJoint", {
+	enumerable: true,
+	get: function() {
+		return sphericalJoint;
+	}
+});
 Object.defineProperty(exports, "stepCount", {
 	enumerable: true,
 	get: function() {