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).

Each stage is a standalone, trait-conforming component; the caller drives them. condition splits the polyline into runs, then for each run the CartesianLinearPlanner resolves a joint path and the ConstantSpeedRetimer times it:

let planner = CartesianLinearPlanner::new(fk);
let retimer = ConstantSpeedRetimer::new(fk);
// `NoopValidator` plans without obstacle checks; pass a real `Validator`
// (and its context) to route the arm around obstacles inside the planner.
for run in condition(poses, cond).unwrap() {
    let (path, _) = planner.plan::<deke_types::DekeError, _>(opts, &run, &NoopValidator::<6>, &());
    let (traj, _) = retimer.retime(cons, &path.unwrap(), &NoopValidator::<6>, &());
    let _ = traj;
}

For a symmetric welding torch, the RedundantLinearPlanner treats the free tool-axis yaw as a DOF and resolves it globally to dodge singularities — and, with a real Validator, obstacles.

Re-exports

pub use constraints::JointLimits;

pub use constraints::LinearConstraints;

pub use constraints::PathConditioning;

pub use constraints::PlannerOptions;

pub use diagnostic::LinearPlannerDiagnostic;

pub use diagnostic::LinearRetimerDiagnostic;

pub use diagnostic::RedundantDiagnostic;

pub use error::LinearError;

pub use path::CartesianRun;

pub use path::condition;

pub use planner::CartesianLinearPlanner;

pub use redundant::RedundantAxis;

pub use redundant::RedundantConfig;

pub use redundant::RedundantLinearPlanner;

pub use redundant::RedundantOptions;

pub use retimer::ConstantSpeedRetimer;

Modules

constraints

diagnostic

error

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.

Structs

NoopValidator

A validator that accepts everything — for callers that handle collision checking elsewhere (or not at all).