Struct RobotBody

pub struct RobotBody {
    pub joint_meshes: [TriMesh; 6],
    pub tool: Option<TriMesh>,
    pub base: Option<BaseBody>,
    pub collision_environment: Vec<CollisionBody>,
    pub safety: SafetyDistances,
}

Struct representing the geometry of a robot, which is composed of exactly 6 joints.

Fields

joint_meshes: [TriMesh; 6]

Joint meshes, one per joint

tool: Option<TriMesh>

Tool meshes, optional if the robot has no tool

base: Option<BaseBody>

Robot base specification

collision_environment: Vec<CollisionBody>

Environment objects arround the robot.

safety: SafetyDistances

Defines distances, how far the robot must stay from collision objects. Also specifies if we are interested in first collision only (like for path planning) or we need a detailed overview (like for diagnostics or visualization)

Implementations

impl RobotBody

pub fn collision_details( &self, qs: &Joints, kinematics: &dyn Kinematics, ) -> Vec<(usize, usize)>

Returns detailed information about all collisions detected in the robot’s configuration. This method uses default distance limits specified at creation. Use near if you need to change limits frequently as the part of your algorithm.

pub fn collides(&self, qs: &Joints, kinematics: &dyn Kinematics) -> bool

Returns true if any collision is detected in the robot’s configuration. This method uses default distance limits specified at creation. Use near if you need to change limits frequently as the part of your algorithm.

pub fn near( &self, qs: &Joints, kinematics: &dyn Kinematics, safety_distances: &SafetyDistances, ) -> Vec<(usize, usize)>

Returns detailed information about all collisions detected in the robot’s configuration. This method only checks for literally touching objects that limits its application. Use near to check if there are no objects closer than the given distance.

pub fn non_colliding_offsets( &self, initial: &Joints, from: &Joints, to: &Joints, kinematics: &dyn Kinematics, ) -> Solutions

Return non colliding offsets, tweaking each joint plus minus either side, either into ‘to’ or into ‘from’. This is required for planning algorithms like A*. We can do less collision checks as we only need to check the joint branch of the robot we moved. Offset generation is accelerated via Rayon.