@faicad/faijs 0.16.1 → 0.18.0

package/dist/api/assembly/solvers/joints-kinematics.d.ts

@@ -0,0 +1,308 @@
+import type { AssemblyNode, Vec3 } from './assembly-tree.js';
+/**
+ * Drivable kinematic joints — built on the assembly tree. A joint connects a
+ * `parent` (reference) body to a `child` (moving) body and carries one or more
+ * drivable degrees of freedom (DOF), each clamped to its own range.
+ *
+ * Single-DOF joints (`revolute`, `prismatic`) are sugar over the Phase-1 mate
+ * constraints — a revolute is concentric (axis alignment) plus an angle driver;
+ * a prismatic is coincident plus a distance driver. Multi-DOF joints compose
+ * several DOFs about a shared anchor: `cylindrical` (rotation + slide on one
+ * axis, 2 DOF), `planar` (two in-plane translations + a rotation about the
+ * normal, 3 DOF), and `spherical` (three rotations about a pivot, 3 DOF).
+ *
+ * The `dofs` array is the source of truth; `value`/`min`/`max`/`axis` mirror the
+ * primary (first) DOF for single-DOF ergonomics and backward compatibility.
+ * `joint.dofs` are the stored degrees of freedom, distinct from
+ * `AssemblyNode.rotate` (a static structural transform).
+ */
+/** A joint axis: a point on the axis line plus a direction. */
+export interface JointAxis {
+    readonly origin: Vec3;
+    readonly direction: Vec3;
+}
+/** The kind of kinematic joint: revolute, prismatic, cylindrical, planar, or spherical. */
+export type JointType = 'revolute' | 'prismatic' | 'cylindrical' | 'planar' | 'spherical';
+/**
+ * A single drivable degree of freedom. A `rotation` DOF turns about the joint's
+ * anchor point along `axis` (degrees); a `translation` DOF slides along `axis`
+ * (length units). `value` is always clamped to `[min, max]`.
+ */
+export interface JointDOF {
+    readonly kind: 'rotation' | 'translation';
+    readonly axis: Vec3;
+    readonly min: number;
+    readonly max: number;
+    readonly value: number;
+}
+/**
+ * A kinematic joint connecting a parent and child body, with its drivable DOFs.
+ */
+export interface Joint {
+    readonly type: JointType;
+    /** Reference body (stays put); the child moves relative to it. */
+    readonly parent: string;
+    readonly child: string;
+    /** Primary axis; `origin` is the anchor every rotation DOF pivots about. */
+    readonly axis: JointAxis;
+    /** Primary-DOF range bounds (mirror of `dofs[0]`). */
+    readonly min: number;
+    readonly max: number;
+    /** Primary-DOF value (mirror of `dofs[0]`), always clamped to `[min, max]`. */
+    readonly value: number;
+    /** All drivable degrees of freedom, in composition order. */
+    readonly dofs: readonly JointDOF[];
+    /**
+     * Optional fixed transform applied to the child frame *after* the joint
+     * motion (`childWorld = parentWorld ∘ jointTransform ∘ offset`). Lets a single
+     * joint carry a static link offset (e.g. a Denavit-Hartenberg link geometry)
+     * without an extra body. Defaults to identity. See `jointsFromDH`.
+     */
+    readonly offset?: JointPose;
+}
+/** A rigid transform: translation + quaternion rotation `[w, x, y, z]`. */
+export interface JointPose {
+    readonly position: Vec3;
+    readonly rotation: [number, number, number, number];
+}
+/** Options for single-DOF joints: range bounds and initial value. */
+export interface JointOptions {
+    /** Range lower bound. Default: -180 (revolute) / 0 (prismatic). */
+    min?: number;
+    /** Range upper bound. Default: 180 (revolute) / 100 (prismatic). */
+    max?: number;
+    /** Initial value, clamped to the range. Default: 0. */
+    value?: number;
+}
+/** Per-DOF ranges for a cylindrical joint (rotation about + slide along one axis). */
+export interface CylindricalOptions {
+    /** Rotation DOF (degrees). Default range -180..180. */
+    rotation?: JointOptions;
+    /**
+     * Translation DOF (length). Default range 0..100, matching `prismaticJoint`
+     * (both model a slide along an axis). This is deliberately asymmetric with
+     * `planarJoint`'s in-plane translations, which default to -100..100 because
+     * an unanchored in-plane slide is naturally bidirectional.
+     */
+    translation?: JointOptions;
+}
+/** Per-DOF ranges for a planar joint (two in-plane translations + a rotation). */
+export interface PlanarOptions {
+    /** Translation along the in-plane `uDirection`. Default range -100..100. */
+    u?: JointOptions;
+    /** Translation along `normal × u`. Default range -100..100. */
+    v?: JointOptions;
+    /** Rotation about the plane normal (degrees). Default range -180..180. */
+    rotation?: JointOptions;
+    /**
+     * In-plane reference direction for the `u` translation. Projected onto the
+     * plane and normalized; defaults to an arbitrary perpendicular of the normal.
+     */
+    uDirection?: Vec3;
+}
+/** Per-DOF ranges for a spherical joint (three rotations about a pivot). */
+export interface SphericalOptions {
+    /** Rotation about local X through the pivot (degrees). Default range -180..180. */
+    x?: JointOptions;
+    /** Rotation about local Y through the pivot (degrees). Default range -180..180. */
+    y?: JointOptions;
+    /** Rotation about local Z through the pivot (degrees). Default range -180..180. */
+    z?: JointOptions;
+}
+/** A revolute (hinge) joint — the child rotates about `axis` by `value` degrees.
+ * @param parent - Name of the reference (parent) body.
+ * @param child - Name of the body moved by the joint.
+ * @param axis - Joint axis: anchor point and direction.
+ * @param opts - Optional range bounds and initial value.
+ * @returns The newly created revolute joint.
+ */
+export declare function revoluteJoint(parent: string, child: string, axis: JointAxis, opts?: JointOptions): Joint;
+/**
+ * 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`.
+ * @param parent - Name of the reference (parent) body.
+ * @param child - Name of the body moved by the joint.
+ * @param axis - Slide axis; only `direction` is used.
+ * @param opts - Optional range bounds and initial value.
+ * @returns The newly created prismatic joint.
+ */
+export declare function prismaticJoint(parent: string, child: string, axis: JointAxis, opts?: JointOptions): Joint;
+/**
+ * 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`.
+ * @param parent - Name of the reference (parent) body.
+ * @param child - Name of the body moved by the joint.
+ * @param axis - Joint axis: anchor point and direction.
+ * @param opts - Optional per-DOF ranges and initial values.
+ * @returns The newly created cylindrical joint.
+ */
+export declare function cylindricalJoint(parent: string, child: string, axis: JointAxis, opts?: CylindricalOptions): Joint;
+/**
+ * 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).
+ * @param parent - Name of the reference (parent) body.
+ * @param child - Name of the body moved by the joint.
+ * @param plane - Plane definition; `direction` is the normal, `origin` the anchor.
+ * @param opts - Optional per-DOF ranges, initial values, and in-plane axes.
+ * @returns The newly created planar joint.
+ */
+export declare function planarJoint(parent: string, child: string, plane: JointAxis, opts?: PlanarOptions): Joint;
+/**
+ * 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`.
+ * @param parent - Name of the reference (parent) body.
+ * @param child - Name of the body moved by the joint.
+ * @param pivot - Pivot point all rotations pass through.
+ * @param opts - Optional per-axis ranges and initial values.
+ * @returns The newly created spherical joint.
+ */
+export declare function sphericalJoint(parent: string, child: string, pivot: Vec3, opts?: SphericalOptions): Joint;
+/**
+ * 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]`.
+ * @param joint - The joint to update.
+ * @param values - Positional per-DOF values; omitted entries keep their value.
+ * @returns A new joint with the values set.
+ */
+export declare function setJointValues(joint: Joint, values: readonly number[]): Joint;
+/** Return a copy of `joint` with its primary DOF set (clamped to range).
+ * @param joint - The joint to update.
+ * @param value - New primary-DOF value.
+ * @returns A new joint with the primary value set.
+ */
+export declare function setJointValue(joint: Joint, value: number): Joint;
+/**
+ * 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.
+ * @param joint - The joint to evaluate.
+ * @param value - Primary-DOF override (number) or positional per-DOF overrides.
+ * @returns The child's local pose relative to the parent.
+ */
+export declare function jointTransform(joint: Joint, value?: number | readonly number[]): JointPose;
+/** Attach a joint to an assembly node. Returns a new node (immutable).
+ * @param assembly - The assembly node to attach the joint to.
+ * @param joint - The joint to attach.
+ * @returns A new node with the joint added.
+ */
+export declare function addJoint(assembly: AssemblyNode, joint: Joint): AssemblyNode;
+/**
+ * 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.
+ * @param assembly - The assembly to solve.
+ * @param jointValues - Optional value overrides keyed by child node name.
+ * @returns A world pose for every node in the assembly.
+ */
+export declare function forwardKinematics(assembly: AssemblyNode, jointValues?: Readonly<Record<string, number | readonly number[]>>): Map<string, JointPose>;
+/**
+ * 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.)
+ * @param assembly - The assembly to analyze.
+ * @returns Total number of independent degrees of freedom.
+ */
+export declare function mechanismDOF(assembly: AssemblyNode): number;
+/**
+ * Inverse kinematics and motion trajectories for joint chains.
+ *
+ * `inverseKinematics` solves for the joint values that place an end-effector at
+ * a target pose, using a damped-least-squares (Levenberg-Marquardt) update over
+ * a numerically-differentiated Jacobian. Differentiating through
+ * `forwardKinematics` keeps the solver agnostic to joint type — revolute,
+ * prismatic, and the multi-DOF cylindrical/planar/spherical joints all
+ * contribute their `dofs` uniformly — and respects each DOF's range by clamping
+ * every iterate.
+ *
+ * `jointTrajectory` samples a straight-line path in joint space between two
+ * configurations, returning the posed assembly (via forward kinematics) at each
+ * step — the building block for animation and reachable-workspace sweeps.
+ */
+type Quat = readonly [number, number, number, number];
+/** A target for the end-effector: a world position, optionally an orientation. */
+export interface IKTarget {
+    readonly position: Vec3;
+    /** Target orientation `[w, x, y, z]`. Omit for position-only IK. */
+    readonly rotation?: Quat;
+}
+/** Options for the inverse-kinematics solver (iterations, tolerance, damping, seed). */
+export interface IKOptions {
+    /** Maximum solver iterations. Default 200. */
+    maxIterations?: number;
+    /** Convergence threshold on the residual norm. Default 1e-5. */
+    tolerance?: number;
+    /** Damping factor λ for the least-squares step. Default 0.05. */
+    damping?: number;
+    /** Initial joint values, keyed by child node (number or per-DOF array). */
+    seed?: Readonly<Record<string, number | readonly number[]>>;
+    /** Local point on the end-effector node to drive to the target. Default origin. */
+    tip?: Vec3;
+}
+/** Outcome of an inverse-kinematics solve: values, convergence, and residual. */
+export interface IKResult {
+    /** Solved joint values, keyed by child node, one entry per DOF. */
+    readonly values: Record<string, number[]>;
+    readonly converged: boolean;
+    readonly iterations: number;
+    /** Final residual norm (position, plus orientation when targeted). */
+    readonly error: number;
+}
+/**
+ * Solve for the joint values that place `endEffector` (offset by `tip`) at
+ * `target`, by damped-least-squares descent on a numerical Jacobian. Joint
+ * ranges are honored: every iterate is clamped to each DOF's `[min, max]`.
+ *
+ * Returns the solved per-DOF values keyed by child node (ready to pass to
+ * `forwardKinematics`), whether it converged, the iteration count, and the final
+ * residual norm. An end-effector with no driving joints, or an unreachable
+ * target, returns `converged: false` with the best configuration found.
+ * @param assembly - The assembly containing the kinematic chain.
+ * @param endEffector - Name of the end-effector node.
+ * @param target - Target world pose for the end-effector.
+ * @param options - Optional solver settings (iterations, tolerance, damping, seed, tip).
+ * @returns The solved joint values and convergence diagnostics.
+ */
+export declare function inverseKinematics(assembly: AssemblyNode, endEffector: string, target: IKTarget, options?: IKOptions): IKResult;
+/** One sample of a joint-space trajectory: parameter, values, and world poses. */
+export interface TrajectorySample {
+    /** Normalized path parameter in `[0, 1]`. */
+    readonly t: number;
+    /** Interpolated joint values at this step, keyed by child node. */
+    readonly values: Record<string, number[]>;
+    /** Forward-kinematics world poses for every node at this step. */
+    readonly poses: Map<string, JointPose>;
+}
+/**
+ * Sample a straight-line path in joint space from `from` to `to` over `steps`
+ * segments, yielding `steps + 1` samples (inclusive of both endpoints). Each
+ * sample carries the interpolated per-DOF values (clamped to range) and the
+ * forward-kinematics poses of every node. Joints absent from `from`/`to` hold
+ * their stored value at both ends.
+ * @param assembly - The assembly to pose at each sample.
+ * @param from - Starting joint values keyed by child node name.
+ * @param to - Ending joint values keyed by child node name.
+ * @param steps - Number of path segments (samples are `steps + 1`).
+ * @returns The trajectory samples with interpolated values and poses.
+ */
+export declare function jointTrajectory(assembly: AssemblyNode, from: Readonly<Record<string, number | readonly number[]>>, to: Readonly<Record<string, number | readonly number[]>>, steps: number): TrajectorySample[];
+export {};
+//# sourceMappingURL=joints-kinematics.d.ts.map

package/dist/api/assembly/solvers/joints-kinematics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joints-kinematics.d.ts","sourceRoot":"","sources":["../../../../src/api/assembly/solvers/joints-kinematics.ts"],"names":[],"mappings":"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"}