AffineTransform2D (ImgLib2 Javadocs 0-SNAPSHOT API)

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

All Implemented Interfaces:

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

Author:

Stephan Saalfeld

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class AffineTransform2D.AffineMatrix2D

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`AffineTransform2D.AffineMatrix2D`

Field Summary

Fields
Modifier and Type	Field and Description
`protected AffineTransform2D.AffineMatrix2D`	`a`
`protected RealPoint`	`d0`
`protected RealPoint`	`d1`
`protected RealPoint[]`	`ds`
`protected AffineTransform2D`	`inverse`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`AffineTransform2D()`
`protected`	`AffineTransform2D(AffineTransform2D.AffineMatrix2D a)`
`protected`	`AffineTransform2D(AffineTransform2D 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`.
`AffineTransform2D`	`concatenate(AffineGet affine)` Concatenate this object with a.
`AffineTransform2D`	`concatenate(AffineTransform2D model)`
`AffineTransform2D`	`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.
`AffineTransform2D`	`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.
`AffineTransform2D`	`preConcatenate(AffineGet affine)` Pre-concatenate this object with a.
`AffineTransform2D`	`preConcatenate(AffineTransform2D affine)`
`void`	`rotate(double d)` Rotate
`void`	`scale(double d)` Scale
`void`	`scale(double s0, double s1)` Scale
`void`	`set(AffineTransform2D 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 value, int row, int column)` Set a field of the n×(n+1) affine transformation matrix.
`void`	`toArray(double[] data)`
`void`	`toMatrix(double[][] data)`
`String`	`toString()`
`void`	`translate(double... t)` Translate
`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 AffineTransform2D.AffineMatrix2D a
```
  - d0
```
protected final RealPoint d0
```
  - d1
```
protected final RealPoint d1
```
  - ds
```
protected final RealPoint[] ds
```
  - inverse
```
protected final AffineTransform2D inverse
```
- Constructor Detail
  - AffineTransform2D
```
public AffineTransform2D()
```
  - AffineTransform2D
```
protected AffineTransform2D(AffineTransform2D.AffineMatrix2D a)
```
  - AffineTransform2D
```
protected AffineTransform2D(AffineTransform2D 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 AffineTransform2D 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>
  - concatenate
```
public final AffineTransform2D concatenate(AffineTransform2D model)
```
  - copy
```
public AffineTransform2D 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 AffineTransform2D 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 AffineTransform2D 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>
  - preConcatenate
```
public final AffineTransform2D preConcatenate(AffineTransform2D affine)
```
  - rotate
```
public void rotate(double d)
```
    Rotate
    
    Parameters:
    
    d - angle in radians
  - translate
```
public void translate(double... t)
```
    Translate
    
    Parameters:
    
    t - 2d translation vector
  - scale
```
public void scale(double d)
```
    Scale
    
    Parameters:
    
    d - scale factor
  - scale
```
public void scale(double s0,
                  double s1)
```
    Scale
    
    Parameters:
    
    s0 - scale factor for dimension 0
    
    s1 - scale factor for dimension 1
  - set
```
public final void set(AffineTransform2D m)
```
  - 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
  - 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
  - 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

Class AffineTransform2D

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

a

d0

d1

ds

inverse

Constructor Detail

AffineTransform2D

AffineTransform2D

AffineTransform2D

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

translate

scale

scale

set

toArray

toMatrix

toString

set

set

set

isIdentity

estimateBounds