brepjs 18.78.1 → 18.79.0

package/dist/{threadFns-DGEyXFGP.js → threadFns-Cra0yHSF.js}

@@ -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() {
@@ -522,4 +936,4 @@ function thread(options) {
 	}
 }
 //#endregion
-export { updateNode as C, linearPattern as D, gridPattern as E, exportAssemblySTEP as O, removeChild as S, circularPattern as T, addChild as _, deserializeHistory as a, createAssemblyNode as b, modifyStep as c, replayFrom as d, replayHistory as f, undoLast as g, stepsFrom as h, createRegistry as i, createAssembly as k, registerOperation as l, stepCount as m, addStep as n, findStep as o, serializeHistory as p, createHistory as r, getShape as s, thread as t, registerShape as u, collectShapes as v, walkAssembly as w, findNode as x, countNodes as y };
+export { quatRotate as A, gridPattern as B, prismaticJoint as C, sphericalJoint as D, setJointValues as E, findNode as F, exportAssemblySTEP as H, removeChild as I, updateNode as L, collectShapes as M, countNodes as N, quatFromAxisAngle as O, createAssemblyNode as P, walkAssembly as R, planarJoint as S, setJointValue as T, createAssembly as U, linearPattern as V, addJoint as _, deserializeHistory as a, jointTransform as b, modifyStep as c, replayFrom as d, replayHistory as f, undoLast as g, stepsFrom as h, createRegistry as i, addChild as j, quatFromTo as k, registerOperation as l, stepCount as m, addStep as n, findStep as o, serializeHistory as p, createHistory as r, getShape as s, thread as t, registerShape as u, cylindricalJoint as v, revoluteJoint as w, mechanismDOF as x, forwardKinematics as y, circularPattern as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs",
-  "version": "18.78.1",
+  "version": "18.79.0",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",