AffineTransform3D (ImgLib2 Javadocs 0-SNAPSHOT API)

java.lang.Object
- net.imglib2.realtransform.AffineTransform3D

All Implemented Interfaces:

Concatenable<AffineGet>, PreConcatenable<AffineGet>, EuclideanSpace, AffineGet, AffineSet, InvertibleRealTransform, RealTransform
```
public class AffineTransform3D
extends Object
implements AffineGet, AffineSet, Concatenable<AffineGet>, PreConcatenable<AffineGet>
```
3d-affine transformation.

Author:

Stephan Saalfeld

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class AffineTransform3D.AffineMatrix3D

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`AffineTransform3D.AffineMatrix3D`

Field Summary

Fields
Modifier and Type	Field and Description
`protected AffineTransform3D.AffineMatrix3D`	`a`
`protected RealPoint`	`d0`
`protected RealPoint`	`d1`
`protected RealPoint`	`d2`
`protected RealPoint[]`	`ds`
`protected AffineTransform3D`	`inverse`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`AffineTransform3D()`
`protected`	`AffineTransform3D(AffineTransform3D.AffineMatrix3D a)`
`protected`	`AffineTransform3D(AffineTransform3D inverse)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`apply(double[] source, double[] target)` Apply the `RealTransform` to a source vector to obtain a target vector.
`void`	`apply(float[] source, float[] target)` Apply the `RealTransform` to a source vector to obtain a target vector.
`void`	`apply(RealLocalizable source, RealPositionable target)` Apply the `RealTransform` to a source `RealLocalizable` to obtain a target `RealPositionable`.
`void`	`applyInverse(double[] source, double[] target)` Apply the inverse transform to a target vector to obtain a source vector.
`void`	`applyInverse(float[] source, float[] target)` Apply the inverse transform to a target vector to obtain a source vector.
`void`	`applyInverse(RealPositionable source, RealLocalizable target)` Apply the inverse transform to a target `RealLocalizable` to obtain a source `RealPositionable`.
`AffineTransform3D`	`concatenate(AffineGet affine)` Concatenate this object with a.
`AffineTransform3D`	`concatenate(AffineTransform3D affine)`
`AffineTransform3D`	`copy()` Create a deep copy of this `RealTransform`.
`RealLocalizable`	`d(int d)` Get the constant partial differential vector for dimension d.
`FinalRealInterval`	`estimateBounds(RealInterval interval)` Calculate the boundary interval of an interval after it has been transformed.
`double`	`get(int row, int column)` Get a field of the n×(n+1) affine transformation matrix.
`Class<AffineGet>`	`getConcatenableClass()`
`Class<AffineGet>`	`getPreConcatenableClass()`
`double[]`	`getRowPackedCopy()` Get a copy of the n×(n+1) affine transformation matrix as a row packed array similar to Jama.
`double[]`	`getTranslation()` Initialize the translation with a given vector
`void`	`identity()` Set to identity transform
`AffineTransform3D`	`inverse()` Get the inverse transform.
`protected void`	`invert()`
`boolean`	`isIdentity()` Check if the `RealTransform` is identity.
`int`	`numDimensions()` Gets the space's number of dimensions.
`int`	`numSourceDimensions()` Returns n, the minimal number of dimension of the source vector.
`int`	`numTargetDimensions()` Returns m, the minimal dimension of the target vector.
`AffineTransform3D`	`preConcatenate(AffineGet affine)` Pre-concatenate this object with a.
`AffineTransform3D`	`preConcatenate(AffineTransform3D affine)`
`void`	`rotate(int axis, double angle)` Rotate
`void`	`scale(double s)` Scale
`void`	`scale(double s0, double s1, double s2)` Scale
`void`	`set(AffineTransform3D m)`
`void`	`set(double... values)` Set the n×(n+1) affine transformation matrix with row packed double values.
`void`	`set(double[][] values)` Set the n×(n+1) affine transformation matrix with double values from a [row][column] addressed array.
`void`	`set(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23)` Set the affine matrix to:
`void`	`set(double value, int row, int column)` Set a field of the n×(n+1) affine transformation matrix.
`void`	`setTranslation(double... translationVector)` Initialize the translation with a given vector
`void`	`toArray(double[] data)`
`void`	`toMatrix(double[][] data)`
`String`	`toString()`
`void`	`translate(double... translationVector)` Translation
`protected void`	`updateDs()`

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

- Field Detail
  - a
```
protected final AffineTransform3D.AffineMatrix3D a
```
  - d0
```
protected final RealPoint d0
```
  - d1
```
protected final RealPoint d1
```
  - d2
```
protected final RealPoint d2
```
  - ds
```
protected final RealPoint[] ds
```
  - inverse
```
protected final AffineTransform3D inverse
```
- Constructor Detail
  - AffineTransform3D
```
public AffineTransform3D()
```
  - AffineTransform3D
```
protected AffineTransform3D(AffineTransform3D.AffineMatrix3D a)
```
  - AffineTransform3D
```
protected AffineTransform3D(AffineTransform3D inverse)
```
- Method Detail
  - invert
```
protected void invert()
```
  - updateDs
```
protected void updateDs()
```
  - apply
```
public final void apply(double[] source,
                        double[] target)
```
    Description copied from interface: RealTransform
    
    Apply the RealTransform to a source vector to obtain a target vector.
    
    Specified by:
    
    apply in interface RealTransform
    
    Parameters:
    
    source - source coordinates, length must be >= RealTransform.numSourceDimensions()
    
    target - set this to the target coordinates, length must be >= RealTransform.numTargetDimensions()
  - apply
```
public void apply(float[] source,
                  float[] target)
```
    Description copied from interface: RealTransform
    
    Apply the RealTransform to a source vector to obtain a target vector.
    
    Specified by:
    
    apply in interface RealTransform
    
    Parameters:
    
    source - source coordinates, length must be >= RealTransform.numSourceDimensions()
    
    target - set this to the target coordinates, length must be >= RealTransform.numTargetDimensions()
  - apply
```
public void apply(RealLocalizable source,
                  RealPositionable target)
```
    Description copied from interface: RealTransform
    
    Apply the RealTransform to a source RealLocalizable to obtain a target RealPositionable.
    
    Specified by:
    
    apply in interface RealTransform
    
    Parameters:
    
    source - source coordinates, numDimensions() must be >= RealTransform.numSourceDimensions()
    
    target - set this to the target coordinates, numDimensions() must be >= RealTransform.numTargetDimensions()
  - applyInverse
```
public final void applyInverse(double[] source,
                               double[] target)
```
    Description copied from interface: InvertibleRealTransform
    
    Apply the inverse transform to a target vector to obtain a source vector.
    
    Specified by:
    
    applyInverse in interface InvertibleRealTransform
    
    Parameters:
    
    source - set this to the source coordinates.
    
    target - target coordinates.
  - applyInverse
```
public void applyInverse(float[] source,
                         float[] target)
```
    Description copied from interface: InvertibleRealTransform
    
    Apply the inverse transform to a target vector to obtain a source vector.
    
    Specified by:
    
    applyInverse in interface InvertibleRealTransform
    
    Parameters:
    
    source - set this to the source coordinates.
    
    target - target coordinates.
  - applyInverse
```
public void applyInverse(RealPositionable source,
                         RealLocalizable target)
```
    Description copied from interface: InvertibleRealTransform
    
    Apply the inverse transform to a target RealLocalizable to obtain a source RealPositionable.
    
    Specified by:
    
    applyInverse in interface InvertibleRealTransform
    
    Parameters:
    
    source - set this to the source coordinates.
    
    target - target coordinates.
  - concatenate
```
public final AffineTransform3D concatenate(AffineTransform3D affine)
```
  - concatenate
```
public final AffineTransform3D concatenate(AffineGet affine)
```
    Description copied from interface: Concatenable
    
    Concatenate this object with a. The result will be an object that can be concatenated with another A. The conventional meaning for concatenating transformations is the following: Let ba = b.concatenate(a). Applying ba to x is equivalent to first applying a to x and then applying b to the result.
    
    Specified by:
    
    concatenate in interface Concatenable<AffineGet>
  - copy
```
public AffineTransform3D copy()
```
    Description copied from interface: RealTransform
    
    Create a deep copy of this RealTransform.
    Deep copying is required to make sure that stateful RealTransforms can be duplicated for concurrent code.
    
    Specified by:
    
    copy in interface AffineGet
    
    Specified by:
    
    copy in interface InvertibleRealTransform
    
    Specified by:
    
    copy in interface RealTransform
    
    Returns:
    
    deep copy
  - d
```
public RealLocalizable d(int d)
```
    Description copied from interface: AffineGet
    
    Get the constant partial differential vector for dimension d.
    
    Specified by:
    
    d in interface AffineGet
    
    Parameters:
    
    d - the dimension
    
    Returns:
    
    the partial differential vector
  - get
```
public double get(int row,
                  int column)
```
    Description copied from interface: AffineGet
    
    Get a field of the n×(n+1) affine transformation matrix.
    
    Specified by:
    
    get in interface AffineGet
    
    Parameters:
    
    row - the row index
    
    column - the column index
    
    Returns:
    
    the value
  - getRowPackedCopy
```
public double[] getRowPackedCopy()
```
    Description copied from interface: AffineGet
    
    Get a copy of the n×(n+1) affine transformation matrix as a row packed array similar to Jama.
    
    Specified by:
    
    getRowPackedCopy in interface AffineGet
    
    Returns:
    
    the array of values
  - getConcatenableClass
```
public Class<AffineGet> getConcatenableClass()
```
    Specified by:
    
    getConcatenableClass in interface Concatenable<AffineGet>
  - getPreConcatenableClass
```
public Class<AffineGet> getPreConcatenableClass()
```
    Specified by:
    
    getPreConcatenableClass in interface PreConcatenable<AffineGet>
  - inverse
```
public AffineTransform3D inverse()
```
    Description copied from interface: InvertibleRealTransform
    
    Get the inverse transform.
    
    Specified by:
    
    inverse in interface AffineGet
    
    Specified by:
    
    inverse in interface InvertibleRealTransform
    
    Returns:
    
    the inverse transform
  - numDimensions
```
public int numDimensions()
```
    Description copied from interface: EuclideanSpace
    
    Gets the space's number of dimensions.
    
    Specified by:
    
    numDimensions in interface EuclideanSpace
  - numSourceDimensions
```
public int numSourceDimensions()
```
    Description copied from interface: RealTransform
    
    Returns n, the minimal number of dimension of the source vector.
    
    Specified by:
    
    numSourceDimensions in interface RealTransform
    
    Returns:
    
    the dimension of the source vector.
  - numTargetDimensions
```
public int numTargetDimensions()
```
    Description copied from interface: RealTransform
    
    Returns m, the minimal dimension of the target vector.
    
    Specified by:
    
    numTargetDimensions in interface RealTransform
    
    Returns:
    
    the dimension of the target vector.
  - preConcatenate
```
public final AffineTransform3D preConcatenate(AffineTransform3D affine)
```
  - preConcatenate
```
public final AffineTransform3D preConcatenate(AffineGet affine)
```
    Description copied from interface: PreConcatenable
    
    Pre-concatenate this object with a. The result will be an object that can be pre-concatenated with another A. The conventional meaning for concatenating transformations is the following: Let ba = a.preConcatenate(b). Applying ba to x is equivalent to first applying a to x and then applying b to the result.
    
    Specified by:
    
    preConcatenate in interface PreConcatenable<AffineGet>
  - rotate
```
public void rotate(int axis,
                   double angle)
```
    Rotate
    
    Parameters:
    
    axis - 0=x, 1=y, 2=z
    
    angle - angle in radians
  - scale
```
public void scale(double s)
```
    Scale
    
    Parameters:
    
    s - scale factor
  - scale
```
public void scale(double s0,
                  double s1,
                  double s2)
```
    Scale
    
    Parameters:
    
    s0 - scale factor for dimension 0
    
    s1 - scale factor for dimension 1
    
    s2 - scale factor for dimension 2
  - translate
```
public void translate(double... translationVector)
```
    Translation
    
    Parameters:
    
    translationVector - vector describing the translation
  - getTranslation
```
public double[] getTranslation()
```
    Initialize the translation with a given vector
    
    Returns:
    
    vector with 3 elements describing the translation
  - setTranslation
```
public void setTranslation(double... translationVector)
```
    Initialize the translation with a given vector
    
    Parameters:
    
    translationVector - the translation
  - identity
```
public void identity()
```
    Set to identity transform
  - set
```
public final void set(AffineTransform3D m)
```
  - set
```
public final void set(double m00,
                      double m01,
                      double m02,
                      double m03,
                      double m10,
                      double m11,
                      double m12,
                      double m13,
                      double m20,
                      double m21,
                      double m22,
                      double m23)
```
    Set the affine matrix to:
```
 m00 m01 m02 m03
 m10 m11 m12 m13
 m20 m21 m22 m23
 
```
    Parameters:
    
    m00 - element 0,0
    
    m01 - element 0,1
    
    m02 - element 0,2
    
    m03 - element 0,3
    
    m10 - element 1,0
    
    m11 - element 1,1
    
    m12 - element 1,2
    
    m13 - element 1,3
    
    m20 - element 2,0
    
    m21 - element 2,1
    
    m22 - element 2,2
    
    m23 - element 2,3
  - toArray
```
public void toArray(double[] data)
```
  - toMatrix
```
public void toMatrix(double[][] data)
```
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object
  - set
```
public void set(double value,
                int row,
                int column)
```
    Description copied from interface: AffineSet
    
    Set a field of the n×(n+1) affine transformation matrix.
    
    Specified by:
    
    set in interface AffineSet
    
    Parameters:
    
    value - the value
    
    row - the row index
    
    column - the column index
  - set
```
public void set(double... values)
```
    Description copied from interface: AffineSet
    
    Set the n×(n+1) affine transformation matrix with row packed double values.
    
    Specified by:
    
    set in interface AffineSet
    
    Parameters:
    
    values - the lines of values
  - set
```
public void set(double[][] values)
```
    Description copied from interface: AffineSet
    
    Set the n×(n+1) affine transformation matrix with double values from a [row][column] addressed array.
    
    Specified by:
    
    set in interface AffineSet
    
    Parameters:
    
    values - a 2d array of values
  - estimateBounds
```
public FinalRealInterval estimateBounds(RealInterval interval)
```
    Calculate the boundary interval of an interval after it has been transformed.
    
    Parameters:
    
    interval - the original bounds
    
    Returns:
    
    the new bounds
  - isIdentity
```
public boolean isIdentity()
```
    Description copied from interface: RealTransform
    
    Check if the RealTransform is identity.
    
    Specified by:
    
    isIdentity in interface RealTransform
    
    Returns:
    
    true if identity

Class AffineTransform3D

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

a

d0

d1

d2

ds

inverse

Constructor Detail

AffineTransform3D

AffineTransform3D

AffineTransform3D

Method Detail

invert

updateDs

apply

apply

apply

applyInverse

applyInverse

applyInverse

concatenate

concatenate

copy

d

get

getRowPackedCopy

getConcatenableClass

getPreConcatenableClass

inverse

numDimensions

numSourceDimensions

numTargetDimensions

preConcatenate

preConcatenate

rotate

scale

scale

translate

getTranslation

setTranslation

identity

set

set

toArray

toMatrix

toString

set

set

set

estimateBounds

isIdentity