Crate deke_linear 

Constant-TCP-speed Cartesian polyline following for serial manipulators.

Where the deke-topp* retimers are time-optimal (maximise speed under caps), deke-linear holds a constant TCP travel speed — the requirement for welding and similar process motions — and degrades gracefully near singularities. It is a CNC-style constant-feedrate interpolator in three stages:

• Stage A (path) conditions the raw polyline into smooth, arc-length parameterised CartesianRuns, splitting at sharp corners.
• Stage B (planner) resolves each run to a continuous joint path by analytic-IK branch tracking, steering away from singularities (CartesianLinearPlanner, implements deke_types::Planner).
• Stage C (retimer) holds the commanded speed wherever the joint v/a/j limits allow and dips smoothly where they don’t (ConstantSpeedRetimer, implements deke_types::Retimer).

LinearFollower runs all three and stitches the per-run trajectories.

let follower = LinearFollower::new(fk);
// `NoopValidator` plans without obstacle checks; pass a real `Validator`
// (and its context) to route the arm around obstacles inside the planner.
let (traj, diag) = follower.follow(poses, cfg, &NoopValidator::<6>, &()).unwrap();

For a symmetric welding torch, declare the free tool-axis on FollowConfig::redundant and the RedundantLinearPlanner resolves the yaw globally to dodge singularities — and, with a real Validator, obstacles.

Re-exports

pub use constraints::FollowConfig;

pub use constraints::JointLimits;

pub use constraints::LinearConstraints;

pub use constraints::PathConditioning;

pub use constraints::PlannerOptions;

pub use diagnostic::LinearFollowDiagnostic;

pub use diagnostic::LinearPlannerDiagnostic;

pub use diagnostic::LinearRetimerDiagnostic;

pub use diagnostic::RedundantDiagnostic;

pub use error::LinearError;

pub use follower::LinearFollower;

pub use follower::NoopValidator;

pub use path::CartesianRun;

pub use path::condition;

pub use planner::CartesianLinearPlanner;

pub use redundant::RedundantAxis;

pub use redundant::RedundantLinearPlanner;

pub use redundant::RedundantOptions;

pub use retimer::ConstantSpeedRetimer;

Modules

constraints

diagnostic

error

follower

Stage A→B→C orchestration plus the deke-types Planner/Retimer trait wiring.

path

Stage A — condition a raw Cartesian polyline into smooth, arc-length parameterised runs.

planner

Stage B — resolve a conditioned CartesianRun into a continuous joint-space path by analytic-IK branch tracking.

redundant

Redundancy-resolving planner for a tool that is rotationally symmetric about one of its axes (a welding torch, spray head, …).

retimer

Stage C — time-parameterise a joint path at constant TCP speed.