Struct Frame

pub struct Frame {
    pub robot: Arc<dyn Kinematics>,
    pub frame: Isometry3<f64>,
}

Defines the frame that transforms the robot working area, moving and rotating it (not stretching). The frame can be created from 3 pairs of points, one defining the points before transforming and another after, or alternatively 1 pair is enough if we assume there is no rotation.

Fields

robot: Arc<dyn Kinematics>

frame: Isometry3<f64>

The frame transform, normally computed with either Frame::translation or Frame::isometry

Implementations

impl Frame

pub fn translation(p: Point3<f64>, q: Point3<f64>) -> Isometry3<f64>

Compute the frame transform that may include only shift (but not rotation)

Examples found in repository

examples/frame.rs (lines 13-15)

fn main() {
    let robot = OPWKinematics::new(Parameters::irb2400_10());
    // Shift not too much to have values close to previous
    let frame_transform = Frame::translation(
        Point3::new(0.0, 0.0, 0.0), 
        Point3::new(0.011, 0.022, 0.033));

    let framed = Frame {
        robot: Arc::new(robot),
        frame: frame_transform,
    };
    let joints_no_frame: [f64; 6] = [0.0, 0.11, 0.22, 0.3, 0.1, 0.5]; // without frame

    println!("No frame transform:");
    dump_joints(&joints_no_frame);

    println!("Possible joint values after the frame transform:");
    let (solutions, _transformed_pose) = framed.forward_transformed(
        &joints_no_frame, &joints_no_frame);
    dump_solutions(&solutions);

    let framed = robot.forward(&solutions[0]).translation;
    let unframed = robot.forward(&joints_no_frame).translation;

    println!("Distance between framed and not framed pose {:.3} {:.3} {:.3}",
             framed.x - unframed.x, framed.y - unframed.y, framed.z - unframed.z);
}

pub fn frame( p1: Point3<f64>, p2: Point3<f64>, p3: Point3<f64>, q1: Point3<f64>, q2: Point3<f64>, q3: Point3<f64>, ) -> Result<Isometry3<f64>, Box<dyn Error>>

Compute the frame transform that may include shift and rotation (but not stretching)

pub fn forward_transformed( &self, qs: &Joints, previous: &Joints, ) -> (Solutions, Pose)

This function calculates the required joint values for a robot after applying a transformation to the tool center point (TCP) location, as defined by a specified frame. It uses the provided joint positions (qs) and the previous joint positions to compute the new positions. Depending on how the frame is defined, there can be no solutions or multiple solutions; hence, the function returns a Solutions structure to account for this variability. Additionally, this method returns the transformed tool center pose.

Arguments

• qs - A reference to the Joints structure representing the initial joint positions before the transformation.
• previous - A reference to the Joints structure representing the previous joint positions.

Returns

A tuple containing:

• Solutions - A structure containing the possible joint positions after transformation.
• Pose - The transformed tool center pose.

Example

use std::sync::Arc;
use nalgebra::Point3;
use rs_opw_kinematics::frame::Frame;
use rs_opw_kinematics::kinematics_impl::OPWKinematics;
use rs_opw_kinematics::parameters::opw_kinematics::Parameters;

let robot = OPWKinematics::new(Parameters::irb2400_10());
let frame_transform = Frame::translation(
  Point3::new(0.0, 0.0, 0.0), Point3::new(0.01, 0.00, 0.0));
let framed = rs_opw_kinematics::frame::Frame {
  robot: Arc::new(robot),
  frame: frame_transform,
};
let joints_no_frame: [f64; 6] = [0.0, 0.11, 0.22, 0.3, 0.1, 0.5]; // without frame
let (solutions, _transformed_pose) = framed.forward_transformed(
  &joints_no_frame, &joints_no_frame /* prioritize closest to this value */);
// Use solutions and transformed_pose as needed

Examples found in repository

examples/frame.rs (lines 27-28)

fn main() {
    let robot = OPWKinematics::new(Parameters::irb2400_10());
    // Shift not too much to have values close to previous
    let frame_transform = Frame::translation(
        Point3::new(0.0, 0.0, 0.0), 
        Point3::new(0.011, 0.022, 0.033));

    let framed = Frame {
        robot: Arc::new(robot),
        frame: frame_transform,
    };
    let joints_no_frame: [f64; 6] = [0.0, 0.11, 0.22, 0.3, 0.1, 0.5]; // without frame

    println!("No frame transform:");
    dump_joints(&joints_no_frame);

    println!("Possible joint values after the frame transform:");
    let (solutions, _transformed_pose) = framed.forward_transformed(
        &joints_no_frame, &joints_no_frame);
    dump_solutions(&solutions);

    let framed = robot.forward(&solutions[0]).translation;
    let unframed = robot.forward(&joints_no_frame).translation;

    println!("Distance between framed and not framed pose {:.3} {:.3} {:.3}",
             framed.x - unframed.x, framed.y - unframed.y, framed.z - unframed.z);
}

Trait Implementations

impl Kinematics for Frame

fn inverse(&self, tcp: &Pose) -> Solutions

Find inverse kinematics (joint position) for this pose This function is faster but does not handle the singularity J5 = 0 well. All returned solutions are cross-checked with forward kinematics and valid.

fn inverse_5dof(&self, tcp: &Pose, j6: f64) -> Solutions

Calculates the inverse kinematics for a robot while ignoring the rotation around joint 6. The position of the tool center point remains precise, but the rotation is approximate (rotation around the tool axis is ignored). The return value for joint 6 is set according to the provided parameter. This method is significantly faster

fn inverse_continuing_5dof(&self, tcp: &Pose, previous: &Joints) -> Solutions

Calculates the inverse kinematics for a robot while ignoring the rotation around joint 6. The position of the tool center point remains precise, but the rotation is approximate (rotation around the tool axis is ignored). The return value for joint 6 is set based on the previous joint values. This method is significantly faster

fn inverse_continuing(&self, tcp: &Pose, previous: &Joints) -> Solutions

Find inverse kinematics (joint position) for this pose This function handles the singularity J5 = 0 by keeping the previous values the values J4 and J6 from the previous solution Use CONSTRAINT_CENTERED as previous if there is no previous position but we prefer to be as close to the center of constraints (or zeroes if not set) as possible.

fn forward(&self, qs: &Joints) -> Pose

Find forward kinematics (pose from joint positions). For 5 DOF robot, the rotation of the joint 6 should normally be 0.0 but some other value can be given, meaning the tool is mounted with fixed rotation offset.

fn forward_with_joint_poses(&self, joints: &Joints) -> [Pose; 6]

Computes the forward kinematics for a 6-DOF robotic arm and returns an array of poses representing the position and orientation of each joint, including the final end-effector.

fn kinematic_singularity(&self, qs: &Joints) -> Option<Singularity>

Detect the singularity. Returns either A type singlularity or None if no singularity detected.

fn constraints(&self) -> &Option<Constraints>

Returns constraints under what the solver is operating. Constraints are remembered here and can be used for generating random joint angles needed by RRT, or say providing limits of sliders in GUI.