Struct Transform3f 

pub struct Transform3f {
    pub matrix: [[f32; 4]; 4],
}

3D transformation matrix (4x4 homogeneous transformation)

Fields

matrix: [[f32; 4]; 4]

4x4 transformation matrix in row-major order

Implementations

impl Transform3f

pub fn identity() -> Self

Create an identity transformation

Examples

use fast_gicp::Transform3f;

let transform = Transform3f::identity();
assert_eq!(transform.matrix[0][0], 1.0);
assert_eq!(transform.matrix[3][3], 1.0);

pub fn from_flat(data: &[f32; 16]) -> Self

Create transformation from flat array (row-major order)

Examples

use fast_gicp::Transform3f;

let data = [
    1.0, 0.0, 0.0, 1.0,
    0.0, 1.0, 0.0, 2.0,
    0.0, 0.0, 1.0, 3.0,
    0.0, 0.0, 0.0, 1.0,
];
let transform = Transform3f::from_flat(&data);
assert_eq!(transform.matrix[0][3], 1.0); // x translation
assert_eq!(transform.matrix[1][3], 2.0); // y translation
assert_eq!(transform.matrix[2][3], 3.0); // z translation

pub fn to_flat(&self) -> [f32; 16]

Convert to flat array (row-major order)

pub fn from_translation(x: f32, y: f32, z: f32) -> Self

Create transformation from translation

pub fn from_translation_array(translation: [f32; 3]) -> Self

Creates a transformation from a translation vector.

pub fn translation(&self) -> Vector3<f32>

Get translation component

pub fn set_translation(&mut self, x: f32, y: f32, z: f32)

Set translation component

pub fn rotation(&self) -> Matrix3<f32>

Get rotation matrix (3x3 upper-left block)

pub fn set_rotation(&mut self, rotation: [[f32; 3]; 3])

Set rotation matrix (3x3 upper-left block)

pub fn from_rotation_translation( rotation: [[f32; 3]; 3], translation: [f32; 3], ) -> Self

Create transformation from rotation matrix and translation

pub fn from_parts(translation: Vector3<f32>, rotation: Matrix3<f32>) -> Self

Create transformation from nalgebra translation and rotation

pub fn from_rotation_matrix(rotation: &Matrix3<f32>) -> Self

Create transformation from a rotation matrix

pub fn multiply(&self, other: &Transform3f) -> Self

Multiply two transformations

pub fn compose(&self, other: &Transform3f) -> Transform3f

Composes this transformation with another (self * other).

pub fn inverse(&self) -> Self

Compute inverse transformation

pub fn transform_point(&self, point: &Vector3<f32>) -> Vector3<f32>

Transform a 3D point

pub fn transform_point_array(&self, point: [f32; 3]) -> [f32; 3]

Transform a 3D point array

pub fn from_isometry(isometry: &Isometry3<f32>) -> Self

Create from nalgebra Isometry3

pub fn to_isometry(&self) -> Isometry3<f32>

Convert to nalgebra Isometry3

pub fn matrix_data(&self) -> &[[f32; 4]; 4]

Get the raw 4x4 matrix in row-major order

pub fn to_matrix(&self) -> Matrix4<f32>

Convert to nalgebra Matrix4

pub fn from_matrix(matrix: &Matrix4<f32>) -> Self

Create from nalgebra Matrix4

Trait Implementations

impl Clone for Transform3f

fn clone(&self) -> Transform3f

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Transform3f

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

Formats the value using the given formatter.

impl Default for Transform3f

fn default() -> Self

Returns the “default value” for a type.

impl From<&Transform3f> for Isometry3<f32>

fn from(transform: &Transform3f) -> Self

Converts to this type from the input type.

impl From<Isometry<f32, Unit<Quaternion<f32>>, 3>> for Transform3f

fn from(isometry: Isometry3<f32>) -> Self

Converts to this type from the input type.

impl From<Matrix<f32, Const<4>, Const<4>, ArrayStorage<f32, 4, 4>>> for Transform3f

fn from(m: Matrix4<f32>) -> Self

Converts to this type from the input type.

impl From<Transform3f> for Isometry3<f32>

fn from(transform: Transform3f) -> Self

Converts to this type from the input type.

impl From<Transform3f> for Matrix4<f32>

fn from(t: Transform3f) -> Self

Converts to this type from the input type.

impl Mul for Transform3f

type Output = Transform3f

The resulting type after applying the * operator.

fn mul(self, rhs: Transform3f) -> Self::Output

Performs the * operation.

impl MulAssign for Transform3f

fn mul_assign(&mut self, rhs: Transform3f)

Performs the *= operation.

impl PartialEq for Transform3f

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Transform3f

impl StructuralPartialEq for Transform3f