Enum rerun::components::Transform

pub enum Transform {
    Unknown,
    Rigid3(Rigid3),
    Pinhole(Pinhole),
}

A transform between two spaces.

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

assert_eq!(
    Transform::data_type(),
    DataType::Union(
       vec![
           Field::new("Unknown", DataType::Boolean, false),
           Field::new(
               "Rigid3",
               Rigid3::data_type(),
               false
           ),
           Field::new(
               "Pinhole",
               Pinhole::data_type(),
               false
           )
       ],
       None,
       UnionMode::Dense
    )
);

Variants

Unknown

We don’t know the transform, but it is likely/potentially non-identity. Maybe the user intend to set the transform later.

Rigid3(Rigid3)

For example: the parent is a 3D world space, the child a camera space.

Pinhole(Pinhole)

The parent is some local camera space, the child an image space.

Trait Implementations

impl ArrowDeserialize for Transform

type ArrayType = TransformArray

The arrow2::Array type corresponding to this field

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

Deserialize this field from arrow

impl ArrowField for Transform

type Type = Transform

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 Transform

type MutableArrayType = MutableTransformArray

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

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

Create a new mutable array

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

Serialize this field to arrow

impl Clone for Transform

fn clone(&self) -> Transform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Transform

fn name() -> ComponentName

The name of the component.

fn field() -> Field

Create a Field for this Component.

impl Debug for Transform

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transform

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<Transform> for Transform

fn eq(&self, other: &Transform) -> 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 Transform

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 StructuralPartialEq for Transform