Translation2D (ImgLib2 Javadocs 0-SNAPSHOT API)

java.lang.Object
- net.imglib2.realtransform.AbstractTranslation
- - net.imglib2.realtransform.Translation2D

All Implemented Interfaces:

Concatenable<TranslationGet>, PreConcatenable<TranslationGet>, EuclideanSpace, AffineGet, InvertibleRealTransform, RealTransform, ScaleAndTranslationGet, TranslationGet
```
public class Translation2D
extends AbstractTranslation
implements Concatenable<TranslationGet>, PreConcatenable<TranslationGet>
```
2-dimensional translation.

Author:

Stephan Saalfeld

Field Summary

Fields
Modifier and Type Field and Description

protected static RealPoint[] constDs

protected Translation2D inverse
- Fields inherited from class net.imglib2.realtransform.AbstractTranslation
  ds, t

Fields
Modifier and Type	Field and Description
`protected static RealPoint[]`	`constDs`
`protected Translation2D`	`inverse`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`Translation2D()`
	`Translation2D(double... t)`
`protected`	`Translation2D(double[] t, Translation2D inverse)`
	`Translation2D(double tx, double ty)`

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`.
`Translation2D`	`concatenate(TranslationGet a)` Concatenate this object with a.
`Translation2D`	`copy()` Create a deep copy of this `RealTransform`.
`Class<TranslationGet>`	`getConcatenableClass()`
`Class<TranslationGet>`	`getPreConcatenableClass()`
`double[]`	`getRowPackedCopy()` Get a copy of the n×(n+1) affine transformation matrix as a row packed array similar to Jama.
`Translation2D`	`inverse()` Get the inverse transform.
`boolean`	`isIdentity()` Check if the `RealTransform` is identity.
`Translation2D`	`preConcatenate(TranslationGet a)` Pre-concatenate this object with a.
`void`	`set(double... t)` Set the translation vector.
`void`	`set(double tx, double ty)`
`void`	`set(double t, int d)` Set one value of the translation vector.

Methods inherited from class net.imglib2.realtransform.AbstractTranslation
d, get, getScale, getScaleCopy, getTranslation, getTranslationCopy, numDimensions, numSourceDimensions, numTargetDimensions

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

- Field Detail
  - constDs
```
protected static final RealPoint[] constDs
```
  - inverse
```
protected final Translation2D inverse
```
- Constructor Detail
  - Translation2D
```
protected Translation2D(double[] t,
                        Translation2D inverse)
```
  - Translation2D
```
public Translation2D()
```
  - Translation2D
```
public Translation2D(double tx,
                     double ty)
```
  - Translation2D
```
public Translation2D(double... t)
```
- Method Detail
  - set
```
public void set(double tx,
                double ty)
```
  - set
```
public void set(double... t)
```
    Set the translation vector.
    
    Specified by:
    
    set in class AbstractTranslation
    
    Parameters:
    
    t - t.length <= the number of dimensions of this Translation2D
  - set
```
public void set(double t,
                int d)
```
    Description copied from class: AbstractTranslation
    
    Set one value of the translation vector.
    
    Specified by:
    
    set in class AbstractTranslation
    
    Parameters:
    
    t - t.length <= the number of dimensions of this AbstractTranslation
    
    d - the dimension
  - apply
```
public 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
    
    Overrides:
    
    apply in class AbstractTranslation
    
    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
    
    Overrides:
    
    apply in class AbstractTranslation
    
    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
    
    Overrides:
    
    apply in class AbstractTranslation
    
    Parameters:
    
    source - source coordinates, numDimensions() must be >= RealTransform.numSourceDimensions()
    
    target - set this to the target coordinates, numDimensions() must be >= RealTransform.numTargetDimensions()
  - applyInverse
```
public 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
    
    Overrides:
    
    applyInverse in class AbstractTranslation
    
    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
    
    Overrides:
    
    applyInverse in class AbstractTranslation
    
    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
    
    Overrides:
    
    applyInverse in class AbstractTranslation
    
    Parameters:
    
    source - set this to the source coordinates.
    
    target - target coordinates.
  - copy
```
public Translation2D 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
    
    Specified by:
    
    copy in interface ScaleAndTranslationGet
    
    Specified by:
    
    copy in interface TranslationGet
    
    Specified by:
    
    copy in class AbstractTranslation
    
    Returns:
    
    deep copy
  - 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
    
    Overrides:
    
    getRowPackedCopy in class AbstractTranslation
    
    Returns:
    
    the array of values
  - inverse
```
public Translation2D inverse()
```
    Description copied from interface: InvertibleRealTransform
    
    Get the inverse transform.
    
    Specified by:
    
    inverse in interface AffineGet
    
    Specified by:
    
    inverse in interface InvertibleRealTransform
    
    Specified by:
    
    inverse in interface ScaleAndTranslationGet
    
    Specified by:
    
    inverse in interface TranslationGet
    
    Specified by:
    
    inverse in class AbstractTranslation
    
    Returns:
    
    the inverse transform
  - preConcatenate
```
public Translation2D preConcatenate(TranslationGet a)
```
    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<TranslationGet>
  - getPreConcatenableClass
```
public Class<TranslationGet> getPreConcatenableClass()
```
    Specified by:
    
    getPreConcatenableClass in interface PreConcatenable<TranslationGet>
  - concatenate
```
public Translation2D concatenate(TranslationGet a)
```
    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<TranslationGet>
  - getConcatenableClass
```
public Class<TranslationGet> getConcatenableClass()
```
    Specified by:
    
    getConcatenableClass in interface Concatenable<TranslationGet>
  - 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 Translation2D

Field Summary

Fields inherited from class net.imglib2.realtransform.AbstractTranslation

Constructor Summary

Method Summary

Methods inherited from class net.imglib2.realtransform.AbstractTranslation

Methods inherited from class java.lang.Object

Field Detail

constDs

inverse

Constructor Detail

Translation2D

Translation2D

Translation2D

Translation2D

Method Detail

set

set

set

apply

apply

apply

applyInverse

applyInverse

applyInverse

copy

getRowPackedCopy

inverse

preConcatenate

getPreConcatenableClass

concatenate

getConcatenableClass

isIdentity