Struct rerun::components::Rigid3

pub struct Rigid3 {
    pub rotation: Quaternion,
    pub translation: Vec3D,
}

A proper rigid 3D transform, i.e. a rotation and a translation.

Also known as an isometric transform, or a pose.

use re_log_types::component_types::Rigid3;
use arrow2_convert::field::ArrowField;
use arrow2::datatypes::{DataType, Field};

assert_eq!(
    Rigid3::data_type(),
    DataType::Struct(vec![
        Field::new(
            "rotation",
            DataType::FixedSizeList(
                Box::new(Field::new("item", DataType::Float32, false)),
                4
            ),
            false
        ),
        Field::new(
            "translation",
            DataType::FixedSizeList(
                Box::new(Field::new("item", DataType::Float32, false)),
                3
            ),
            false
        )
    ]),
);

Fields

rotation: Quaternion

How is the child rotated?

This transforms to parent-space from child-space.

translation: Vec3D

Translation to parent from child.

You can also think of this as the position of the child.

Implementations

impl Rigid3

pub const IDENTITY: Rigid3 = Rigid3{ rotation: Quaternion{ x: 1.0, y: 0.0, z: 0.0, w: 0.0,}, translation: Vec3D([0.0, 0.0, 0.0]),}

pub fn new_parent_from_child(parent_from_child: IsoTransform) -> Rigid3

pub fn new_child_from_parent(child_from_parent: IsoTransform) -> Rigid3

pub fn parent_from_child(&self) -> IsoTransform

pub fn child_from_parent(&self) -> IsoTransform

Trait Implementations

impl ArrowDeserialize for Rigid3

type ArrayType = Rigid3Array

The arrow2::Array type corresponding to this field

fn arrow_deserialize<'a>(v: Option<Rigid3>) -> Option<Rigid3>

Deserialize this field from arrow

impl ArrowField for Rigid3

type Type = Rigid3

This should be Self except when implementing large offset and fixed placeholder types. For the later, it should refer to the actual type. For example when the placeholder type is LargeString, this should be String.

fn data_type() -> DataType

The DataType

impl ArrowSerialize for Rigid3

type MutableArrayType = MutableRigid3Array

The arrow2::array::MutableArray that holds this value

fn new_array() -> <Rigid3 as ArrowSerialize>::MutableArrayType

Create a new mutable array

fn arrow_serialize( v: &Rigid3, array: &mut <Rigid3 as ArrowSerialize>::MutableArrayType ) -> Result<(), Error>

Serialize this field to arrow

impl Clone for Rigid3

fn clone(&self) -> Rigid3

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rigid3

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Rigid3

fn default() -> Rigid3

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Rigid3

fn deserialize<__D>( __deserializer: __D ) -> Result<Rigid3, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<Rigid3> for Rigid3

fn eq(&self, other: &Rigid3) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Rigid3

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Rigid3

impl StructuralPartialEq for Rigid3