java.lang.Object
- org.robwork.sdurw.Transform3Df

```
public class Transform3Df
extends java.lang.Object
```
A 4x4 homogeneous transform matrix \mathbf{T}\in SE(3)

\mathbf{T} = \left[ \begin{array}{cc} \mathbf{R} \mathbf{d} \\ \begin{array}{ccc}0 0 0\end{array} 1 \end{array} \right]

Constructor Summary

Constructors
Constructor	Description
`Transform3Df()`	Default Constructor. Initializes with 0 translation and Identity matrix as rotation
`Transform3Df(long cPtr, boolean cMemoryOwn)`
`Transform3Df(Rotation3Df R)`	A homogeneous transform with a rotation of R and a translation of zero.
`Transform3Df(Transform3Df t3d)`
`Transform3Df(Vector3Df d)`	A homogeneous transform with a rotation of zero and a translation of d.
`Transform3Df(Vector3Df d, Rotation3Df R)`	Constructs a homogeneous transform
`Transform3Df(Vector3Df d, Rotation3DVectorf r)`	Constructs a homogeneous transform Calling this constructor is equivalent to the transform Transform3D(d, r.toRotation3D()).

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`static Transform3Df`	`craigDH(float alpha, float a, float d, float theta)`	Constructs a homogeneous transform using the Craig (modified) Denavit-Hartenberg notation
`void`	`delete()`
`static Transform3Df`	`DH(float alpha, float a, float d, float theta)`	Constructs a homogeneous transform using the original Denavit-Hartenberg notation
`static Transform3Df`	`DHHGP(float alpha, float a, float beta, float b)`	Constructs a homogeneous transform using the Gordon (modified) Denavit-Hartenberg notation
`EigenMatrix4f`	`e()`	Returns a Eigen 4x4 matrix \mathbf{M}\in SE(3) that represents this homogeneous transformation
`boolean`	`equal(Transform3Df t3d)`	Compares the transformations with a given precision Performs an element wise comparison.
`boolean`	`equal(Transform3Df t3d, float precision)`	Compares the transformations with a given precision Performs an element wise comparison.
`boolean`	`equals(Transform3Df rhs)`	Comparison operator. The comparison operator makes a element wise comparison. Returns true only if all elements are equal.
`static long`	`getCPtr(Transform3Df obj)`
`static Transform3Df`	`identity()`	Constructs the identity transform
`static Transform3Df`	`invMult(Transform3Df t1, Transform3Df t2)`	computes the inverse of t1 and multiplies it with t2. The result is saved in t1.
`static Transform3Df`	`makeLookAt(Vector3Df eye, Vector3Df center, Vector3Df up)`	creates a transformation that is positioned in eye and looking toward center along -z where up indicates the upward direction along which the y-axis is placed.
`Transform3Df`	`multiply(Transform3Df bTc)`	Calculates \robabx{a}{c}{\mathbf{T}} = \robabx{a}{b}{\mathbf{T}} \robabx{b}{c}{\mathbf{T}}
`static void`	`multiply(Transform3Df a, Transform3Df b, Transform3Df result)`	Write to result the product a * b.
`Vector3Df`	`multiply(Vector3Df bP)`	Calculates \robax{a}{\mathbf{p}} = \robabx{a}{b}{\mathbf{T}} \robax{b}{\mathbf{p}} thus transforming point \mathbf{p} from frame b to frame a
`Vector3Df`	`P()`	Gets the position part \mathbf{d} from \mathbf{T}
`Rotation3Df`	`R()`	Gets the rotation part \mathbf{R} from \mathbf{T}
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Transform3Df
```
public Transform3Df(long cPtr,
                    boolean cMemoryOwn)
```
  - Transform3Df
```
public Transform3Df()
```
    Default Constructor.
    
    Initializes with 0 translation and Identity matrix as rotation
  - Transform3Df
```
public Transform3Df(Transform3Df t3d)
```
  - Transform3Df
```
public Transform3Df(Vector3Df d,
                    Rotation3Df R)
```
    Constructs a homogeneous transform
    
    Parameters:
    
    d - [in] \mathbf{d} A 3x1 translation vector
    
    R - [in] \mathbf{R} A 3x3 rotation matrix
  - Transform3Df
```
public Transform3Df(Rotation3Df R)
```
    A homogeneous transform with a rotation of R and a
    translation of zero.
  - Transform3Df
```
public Transform3Df(Vector3Df d)
```
    A homogeneous transform with a rotation of zero and a
    translation of d.
  - Transform3Df
```
public Transform3Df(Vector3Df d,
                    Rotation3DVectorf r)
```
    Constructs a homogeneous transform
    
    Calling this constructor is equivalent to the transform
    Transform3D(d, r.toRotation3D()).
    
    Parameters:
    
    d - [in] A 3x1 translation vector
    
    r - [in] A 3x1 rotation vector
- Method Detail
  - getCPtr
```
public static long getCPtr(Transform3Df obj)
```
  - delete
```
public void delete()
```
  - DH
```
public static Transform3Df DH(float alpha,
                              float a,
                              float d,
                              float theta)
```
    Constructs a homogeneous transform using the original
    Denavit-Hartenberg notation
    
    Parameters:
    
    alpha - [in] \alpha_i
    
    a - [in] a_i
    
    d - [in] d_i
    
    theta - [in] \theta_i
    
    Returns:
    
    ^{i-1}\mathbf{T}_i
    
    \robabx{i-1}{i}{\mathbf{T}}= \left[ \begin{array}{cccc} c\theta_i -s\theta_i c\alpha_i s\theta_i s\alpha_i a_i c\theta_i \\ s\theta_i c\theta_i c\alpha_i -c\theta_i s\alpha_i a_i s\theta_i \\ 0 s\alpha_i c\alpha_i d_i \\ 0 0 0 1 \end{array} \right]
  - craigDH
```
public static Transform3Df craigDH(float alpha,
                                   float a,
                                   float d,
                                   float theta)
```
    Constructs a homogeneous transform using the Craig (modified)
    Denavit-Hartenberg notation
    
    Parameters:
    
    alpha - [in] \alpha_{i-1}
    
    a - [in] a_{i-1}
    
    d - [in] d_i
    
    theta - [in] \theta_i
    
    Returns:
    
    \robabx{i-1}{i}{\mathbf{T}}
    
    Note: The Craig (modified) Denavit-Hartenberg notation differs from
    the original Denavit-Hartenberg notation and is given as
    
    \robabx{i-1}{i}{\mathbf{T}} = \left[ \begin{array}{cccc} c\theta_i -s\theta_i 0 a_{i-1} \\ s\theta_i c\alpha_{i-1} c\theta_i c\alpha_{i-1} -s\alpha_{i-1} -s\alpha_{i-1}d_i \\ s\theta_i s\alpha_{i-1} c\theta_i s\alpha_{i-1} c\alpha_{i-1} c\alpha_{i-1}d_i \\ 0 0 0 1 \end{array} \right]
  - DHHGP
```
public static Transform3Df DHHGP(float alpha,
                                 float a,
                                 float beta,
                                 float b)
```
    Constructs a homogeneous transform using the Gordon (modified)
    Denavit-Hartenberg notation
    
    Parameters:
    
    alpha - [in] \alpha_i
    
    a - [in] a_i
    
    beta - [in] \beta_i
    
    b - [in] b_i
    
    Returns:
    
    ^{i-1}\mathbf{T}_i
    
    Note: The Gordon (modified) Denavit-Hartenberg differs from
    the original Denavit-Hartenberg as it branches between parallel
    and non-parallel z-axes.
    
    z_{i-1} is close to parallel to z_i
    \robabx{i-1}{i}{\mathbf{T}}= \left[ \begin{array}{cccc} c\beta_i s\alpha_i s\beta_i c\alpha_i s\beta_i a_i c\beta_i \\ 0 c\alpha_i -s\alpha_i b_i \\ -s\beta_i s\alpha_i c\beta_i c\alpha_i c\beta_i -a_i s\beta \\ 0 0 0 1 \end{array} \right]
  - identity
```
public static Transform3Df identity()
```
    Constructs the identity transform
    
    Returns:
    
    the identity transform
    
    \mathbf{T} = \left[ \begin{array}{cccc} 1 0 0 0\\ 0 1 0 0\\ 0 0 1 0\\ 0 0 0 1 \end{array} \right]
  - equals
```
public boolean equals(Transform3Df rhs)
```
    Comparison operator.
    
    The comparison operator makes a element wise comparison.
    Returns true only if all elements are equal.
    
    Parameters:
    
    rhs - [in] Transform to compare with
    
    Returns:
    
    True if equal.
  - equal
```
public boolean equal(Transform3Df t3d,
                     float precision)
```
    Compares the transformations with a given precision
    
    Performs an element wise comparison. Two elements are considered equal if the difference
    are less than precision.
    
    Parameters:
    
    t3d - [in] Transform to compare with
    
    precision - [in] The precision to use for testing
    
    Returns:
    
    True if all elements are less than precision apart.
  - equal
```
public boolean equal(Transform3Df t3d)
```
    Compares the transformations with a given precision
    
    Performs an element wise comparison. Two elements are considered equal if the difference
    are less than precision.
    
    Parameters:
    
    t3d - [in] Transform to compare with
    
    Returns:
    
    True if all elements are less than precision apart.
  - multiply
```
public Transform3Df multiply(Transform3Df bTc)
```
    Calculates \robabx{a}{c}{\mathbf{T}} = \robabx{a}{b}{\mathbf{T}} \robabx{b}{c}{\mathbf{T}}
    
    Parameters:
    
    bTc - [in] \robabx{b}{c}{\mathbf{T}}
    
    Returns:
    
    \robabx{a}{c}{\mathbf{T}}
    
    \robabx{a}{c}{\mathbf{T}} = \left[ \begin{array}{cc} \robabx{a}{b}{\mathbf{R}}\robabx{b}{c}{\mathbf{R}} \robabx{a}{b}{\mathbf{d}} + \robabx{a}{b}{\mathbf{R}}\robabx{b}{c}{\mathbf{d}} \\ \begin{array}{ccc}0 0 0\end{array} 1 \end{array} \right]
  - multiply
```
public Vector3Df multiply(Vector3Df bP)
```
    Calculates \robax{a}{\mathbf{p}} = \robabx{a}{b}{\mathbf{T}} \robax{b}{\mathbf{p}} thus transforming point \mathbf{p} from frame b
    to frame a
    
    Parameters:
    
    bP - [in] \robax{b}{\mathbf{p}}
    
    Returns:
    
    \robax{a}{\mathbf{p}}
  - R
```
public Rotation3Df R()
```
    Gets the rotation part \mathbf{R} from \mathbf{T}
    
    Returns:
    
    \mathbf{R}
  - P
```
public Vector3Df P()
```
    Gets the position part \mathbf{d} from \mathbf{T}
    
    Returns:
    
    \mathbf{d}
  - multiply
```
public static void multiply(Transform3Df a,
                            Transform3Df b,
                            Transform3Df result)
```
    Write to result the product a * b.
  - invMult
```
public static Transform3Df invMult(Transform3Df t1,
                                   Transform3Df t2)
```
    computes the inverse of t1 and multiplies it with t2.
    The result is saved in t1. t1 = inv(t1) * t2
  - makeLookAt
```
public static Transform3Df makeLookAt(Vector3Df eye,
                                      Vector3Df center,
                                      Vector3Df up)
```
    creates a transformation that is positioned in eye and looking toward
    center along -z where up indicates the upward direction along which the y-axis
    is placed. Same convention as for gluLookAt
    and is handy for placing a cameraview.
    
    Parameters:
    
    eye - [in] position of view
    
    center - [in] point to look toward
    
    up - [in] the upward direction (the
    
    Returns:
    
    Transformation
  - e
```
public EigenMatrix4f e()
```
    Returns a Eigen 4x4 matrix \mathbf{M}\in SE(3) that represents this homogeneous transformation
    
    Returns:
    
    \mathbf{M}\in SE(3)
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class Transform3Df

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Transform3Df

Transform3Df

Transform3Df

Transform3Df

Transform3Df

Transform3Df

Transform3Df

Method Detail

getCPtr

delete

DH

craigDH

DHHGP

identity

equals

equal

equal

multiply

multiply

R

P

multiply

invMult

makeLookAt

e

toString