Struct RobotArm 

pub struct RobotArm {
    pub name: String,
    pub links: Vec<RobotLink>,
    pub base_transform: Mat4,
}

A serial-chain robot arm described by a sequence of DH links.

Supports forward kinematics, Jacobian computation (analytical and numerical), Newton-Raphson inverse kinematics, workspace Monte-Carlo sampling, joint-limit checking, and self-collision detection.

Fields

name: String

Name of the robot.

links: Vec<RobotLink>

Ordered list of links (joint 0 is closest to base).

base_transform: Mat4

Base transform applied before all joint transforms.

Implementations

impl RobotArm

pub fn new(name: impl Into<String>, links: Vec<RobotLink>) -> Self

Creates a new robot arm.

pub fn with_base_transform(self, t: Mat4) -> Self

Sets the base transform and returns self for chaining.

pub fn dof(&self) -> usize

Number of degrees of freedom (non-Fixed joints).

pub fn forward_frames(&self, q: &[f64]) -> Vec<Mat4>

Computes all intermediate frames (base → end-effector) for a given joint configuration q. Returns one matrix per link plus the base.

pub fn end_effector(&self, q: &[f64]) -> Mat4

Returns the end-effector transform for joint configuration q.

pub fn end_effector_pos(&self, q: &[f64]) -> [f64; 3]

Returns the end-effector position [x, y, z] for joint configuration q.

pub fn jacobian_numerical(&self, q: &[f64]) -> Vec<f64>

Computes the 3×n positional Jacobian numerically (finite differences).

Returns a flat row-major array of shape 3 × dof.

pub fn jacobian_6dof_numerical(&self, q: &[f64]) -> Vec<f64>

Computes the full 6×n Jacobian (position + orientation) numerically.

Orientation rows use angle-axis approximation via the rotation part of the end-effector transform. Returns flat row-major 6 × dof.

pub fn jacobian_analytical(&self, q: &[f64]) -> Vec<f64>

Computes the 3×n analytical Jacobian using the geometric (cross-product) method.

For revolute joints: J_i = z_{i-1} × (p_e − p_{i-1}). For prismatic joints: J_i = z_{i-1}.

pub fn jacobian_pseudoinverse(j: &[f64], n: usize, lambda: f64) -> Vec<f64>

Computes the damped least-squares pseudo-inverse of a 3 × n Jacobian.

Uses the formula J^+ = J^T (J J^T + λ²I)^{-1} with closed-form inversion for the 3×3 system.

pub fn ik_newton_raphson( &self, target: [f64; 3], q_init: &[f64], max_iter: usize, tol: f64, lambda: f64, ) -> Result<Vec<f64>, Vec<f64>>

Attempts to solve inverse kinematics using Newton-Raphson iteration.

Returns Ok(q) if converged within max_iter steps, or Err with the best solution found.

pub fn workspace_monte_carlo(&self, n_samples: usize) -> Vec<[f64; 3]>

Samples n_samples random joint configurations and returns the set of reachable end-effector positions.

pub fn workspace_bounding_box( &self, n_samples: usize, ) -> Option<([f64; 3], [f64; 3])>

Estimates the reachable workspace bounding box from a Monte-Carlo sample.

Returns (min_corner, max_corner) or None if no samples.

pub fn link_capsules(&self, q: &[f64]) -> Vec<([f64; 3], [f64; 3], f64)>

Returns all link capsule endpoints in world space for configuration q.

Each entry is (p_start, p_end, radius) describing the capsule axis.

pub fn check_collision_sphere( &self, q: &[f64], sphere_center: [f64; 3], sphere_radius: f64, ) -> bool

Checks whether any robot link capsule intersects an obstacle sphere.

Returns true if any link is in collision.

pub fn check_collision_aabb( &self, q: &[f64], box_min: [f64; 3], box_max: [f64; 3], ) -> bool

Checks whether any robot link capsule intersects an axis-aligned box.

Returns true if any link is in collision.

pub fn check_self_collision(&self, q: &[f64]) -> bool

Detects self-collision between non-adjacent link capsules.

Links with indices that differ by 1 (adjacent) are always skipped. Returns true if any non-adjacent pair of capsules overlaps.

pub fn joints_within_limits(&self, q: &[f64]) -> bool

Returns true if all joint values in q satisfy the robot’s joint limits.

pub fn clamp_joints(&self, q: &[f64]) -> Vec<f64>

Clamps all joints in q to the robot’s limits and returns the result.

pub fn swept_volume_aabb( &self, q_start: &[f64], q_end: &[f64], n_steps: usize, ) -> ([f64; 3], [f64; 3])

Computes a coarse AABB for the swept volume of the end-effector as joints vary linearly from q_start to q_end using n_steps samples.

pub fn manipulability(&self, q: &[f64]) -> f64

Computes Yoshikawa’s manipulability measure sqrt(det(J J^T)).

High values indicate configurations far from singularities.

Trait Implementations

impl Clone for RobotArm

fn clone(&self) -> RobotArm

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RobotArm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.