pub struct Joint<T: RealField> {
pub name: String,
pub joint_type: JointType<T>,
pub limits: Option<Range<T>>,
/* private fields */
}
Expand description
Joint with type
Fields
name: String
Name of this joint
joint_type: JointType<T>
Type of this joint
limits: Option<Range<T>>
Limits of this joint
Implementations
sourceimpl<T> Joint<T> where
T: RealField + SubsetOf<f64>,
impl<T> Joint<T> where
T: RealField + SubsetOf<f64>,
sourcepub fn new(name: &str, joint_type: JointType<T>) -> Joint<T>
pub fn new(name: &str, joint_type: JointType<T>) -> Joint<T>
Create new Joint with name and type
Examples
use nalgebra as na;
// create fixed joint
let fixed = k::Joint::<f32>::new("f0", k::JointType::Fixed);
assert!(fixed.joint_position().is_none());
// create rotational joint with Y-axis
let rot = k::Joint::<f64>::new("r0", k::JointType::Rotational { axis: na::Vector3::y_axis() });
assert_eq!(rot.joint_position().unwrap(), 0.0);
sourcepub fn set_joint_position(&mut self, position: T) -> Result<(), Error>
pub fn set_joint_position(&mut self, position: T) -> Result<(), Error>
Set the position of the joint
It returns Err if it is out of the limits, or this is fixed joint.
Examples
use nalgebra as na;
// Create fixed joint
let mut fixed = k::Joint::<f32>::new("f0", k::JointType::Fixed);
// Set position to fixed joint always fails
assert!(fixed.set_joint_position(1.0).is_err());
// Create rotational joint with Y-axis
let mut rot = k::Joint::<f64>::new("r0", k::JointType::Rotational { axis: na::Vector3::y_axis() });
// As default, it has not limit
// Initial position is 0.0
assert_eq!(rot.joint_position().unwrap(), 0.0);
// If it has no limits, set_joint_position always succeeds.
rot.set_joint_position(0.2).unwrap();
assert_eq!(rot.joint_position().unwrap(), 0.2);
sourcepub fn set_joint_position_clamped(&mut self, position: T)
pub fn set_joint_position_clamped(&mut self, position: T)
Set the clamped position of the joint
It refers to the joint limit and clamps the argument. This function does nothing if this is fixed joint.
Examples
use nalgebra as na;
// Create rotational joint with Y-axis
let mut rot = k::Joint::<f64>::new("r0", k::JointType::Rotational { axis: na::Vector3::y_axis() });
let limits = k::joint::Range::new(-1.0, 1.0);
rot.limits = Some(limits);
// Initial position is 0.0
assert_eq!(rot.joint_position().unwrap(), 0.0);
rot.set_joint_position_clamped(2.0);
assert_eq!(rot.joint_position().unwrap(), 1.0);
rot.set_joint_position_clamped(-2.0);
assert_eq!(rot.joint_position().unwrap(), -1.0);
pub fn set_joint_position_unchecked(&mut self, position: T)
sourcepub fn joint_position(&self) -> Option<T>
pub fn joint_position(&self) -> Option<T>
Returns the position (angle)
pub fn origin(&self) -> &Isometry3<T>
pub fn set_origin(&mut self, origin: Isometry3<T>)
pub fn set_joint_velocity(&mut self, velocity: T) -> Result<(), Error>
sourcepub fn joint_velocity(&self) -> Option<T>
pub fn joint_velocity(&self) -> Option<T>
Returns the velocity
sourcepub fn local_transform(&self) -> Isometry3<T>
pub fn local_transform(&self) -> Isometry3<T>
Calculate and returns the transform of the end of this joint
Examples
use nalgebra as na;
// Create linear joint with X-axis
let mut lin = k::Joint::<f64>::new("l0", k::JointType::Linear { axis: na::Vector3::x_axis() });
assert_eq!(lin.local_transform().translation.vector.x, 0.0);
lin.set_joint_position(-1.0).unwrap();
assert_eq!(lin.local_transform().translation.vector.x, -1.0);
sourcepub fn world_transform(&self) -> Option<Isometry3<T>>
pub fn world_transform(&self) -> Option<Isometry3<T>>
Get the result of forward kinematics
The value is updated by Chain::update_transforms
pub fn world_velocity(&self) -> Option<Velocity<T>>
pub fn is_movable(&self) -> bool
sourcepub fn clear_caches(&self)
pub fn clear_caches(&self)
Clear caches defined in the world coordinate
Trait Implementations
Auto Trait Implementations
impl<T> !RefUnwindSafe for Joint<T>
impl<T> Send for Joint<T>
impl<T> !Sync for Joint<T>
impl<T> Unpin for Joint<T> where
T: Unpin,
impl<T> UnwindSafe for Joint<T> where
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
sourcepub fn to_subset(&self) -> Option<SS>
pub fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
sourcepub fn is_in_subset(&self) -> bool
pub fn is_in_subset(&self) -> bool
Checks if self
is actually part of its subset T
(and can be converted to it).
sourcepub fn to_subset_unchecked(&self) -> SS
pub fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset
but without any property checks. Always succeeds.
sourcepub fn from_subset(element: &SS) -> SP
pub fn from_subset(element: &SS) -> SP
The inclusion map: converts self
to the equivalent element of its superset.
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcepub fn to_owned(&self) -> T
pub fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
sourcepub fn clone_into(&self, target: &mut T)
pub fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more