Package net.imglib2.transform.integer

Class MixedTransform

  • All Implemented Interfaces:
    Concatenable<Mixed>, PreConcatenable<Mixed>, BoundingBoxTransform, Mixed, Transform
    public class MixedTransform
extends AbstractMixedTransform
implements Concatenable<Mixed>, PreConcatenable<Mixed>
    Mixed transform allows to express common integer view transformations such as translation, rotation, rotoinversion, and projection.

    It transform a n-dimensional source vector to a m-dimensional target vector, and can be represented as a m+1 × n+1 homogeneous matrix. The mixed transform can be decomposed as follows:

    1. project down (discard some components of the source vector)
    2. component permutation
    3. component inversion
    4. project up (add zero components in the target vector)
    5. translation

    The project down and component permutation steps are implemented by the component mapping. This is a lookup array that specifies for each target dimension from which source dimension it is taken. Note, that it is not allowed to set this array such that a source component is mapped to several target components!

    • Field Detail

      • numSourceDimensions

        protected final int numSourceDimensions
        dimension of source vector.

      • translation

        protected final long[] translation
        translation is added to the target vector after applying permutation, projection, inversion operations.

      • zero

        protected final boolean[] zero
        for each component of the target vector (before translation). should the value be taken from a source vector component (false) or should it be zero (true).

      • invert

        protected final boolean[] invert
        for each component of the target vector (before translation). should the source vector component be inverted (true).

      • component

        protected final int[] component
        for each component of the target vector (before translation). from which source vector component should it be taken.

    • Constructor Detail

      • MixedTransform

        public MixedTransform​(int sourceDim,
                      int targetDim)

    • Method Detail

      • getTranslation

        public void getTranslation​(long[] t)
        Description copied from interface: Mixed
        Get the translation. Translation is added to the target vector after applying permutation, projection, inversion operations.
        Specified by:
        getTranslation in interface Mixed
        Overrides:
        getTranslation in class AbstractMixedTransform
        Parameters:
        t - array of size at least the target dimension to store the result.

      • setTranslation

        public void setTranslation​(long[] t)

      • setInverseTranslation

        public void setInverseTranslation​(long[] tinv)

      • getComponentZero

        public void getComponentZero​(boolean[] zero)
        Description copied from interface: Mixed
        Get a boolean array indicating which target dimensions are _not_ taken from source dimensions.

        For instance, if the transform maps 2D (x,y) coordinates to the first two components of a 3D (x,y,z) coordinate, the result will be [false, false, true]

        Specified by:
        getComponentZero in interface Mixed
        Overrides:
        getComponentZero in class AbstractMixedTransform
        Parameters:
        zero - array of size at least the target dimension to store the result.

      • setComponentZero

        public void setComponentZero​(boolean[] zero)
        Set which target dimensions are _not_ taken from source dimensions.

        For instance, if the transform maps 2D (x,y) coordinates to the first two components of a 3D (x,y,z) coordinate, this will be [false, false, true]

        Parameters:
        zero - array that says for each component of the target vector (before translation) whether the value should be taken from a source vector component (false) or should be set to zero (true).

      • getComponentMapping

        public void getComponentMapping​(int[] component)
        Description copied from interface: Mixed
        Get an array indicating for each target dimensions from which source dimension it is taken.

        For instance, if the transform maps 2D (x,y) coordinates to the first two components of a 3D (x,y,z) coordinate, the result will be [0, 1, x]. Here, the value of x is undefined because the third target dimension does not correspond to any source dimension. See Mixed.getComponentZero(boolean[]).

        Specified by:
        getComponentMapping in interface Mixed
        Overrides:
        getComponentMapping in class AbstractMixedTransform
        Parameters:
        component - array of size at least the target dimension to store the result.

      • setComponentMapping

        public void setComponentMapping​(int[] component)
        Set for each target dimensions from which source dimension it is taken.

        For instance, if the transform maps 2D (x,y) coordinates to the first two components of a 3D (x,y,z) coordinate, this will be [0, 1, x]. Here, x can be any value because the third target dimension does not correspond to any source dimension, which can be realized using setComponentZero(boolean[]).

        Note, that it is not allowed to set the component array such that a source component is mapped to several target components!

        Parameters:
        component - array that says for each component of the target vector (before translation) from which source vector component it should be taken.

      • getComponentInversion

        public void getComponentInversion​(boolean[] invert)
        Description copied from interface: Mixed
        Get an array indicating for each target component, whether the source component it is taken from should be inverted.

        For instance, if rotating a 2D (x,y) coordinates by 180 degrees will map it to (-x,-y). In this case, the result will be [true, true].

        Specified by:
        getComponentInversion in interface Mixed
        Overrides:
        getComponentInversion in class AbstractMixedTransform
        Parameters:
        invert - array of size at least the target dimension to store the result.

      • setComponentInversion

        public void setComponentInversion​(boolean[] invert)
        Set for each target component, whether the source component it is taken from should be inverted.

        For instance, if rotating a 2D (x,y) coordinates by 180 degrees will map it to (-x,-y). In this case, this will be [true, true].

        Parameters:
        invert - array that says for each component of the target vector (before translation) whether the source vector component it is taken from should be inverted (true).

      • apply

        public void apply​(long[] source,
                  long[] target)
        Description copied from interface: Transform
        Apply the Transform to a source vector to obtain a target vector.
        Specified by:
        apply in interface Transform
        Parameters:
        source - source coordinates.
        target - set this to the target coordinates.

      • apply

        public void apply​(int[] source,
                  int[] target)
        Description copied from interface: Transform
        Apply the Transform to a source vector to obtain a target vector.
        Specified by:
        apply in interface Transform
        Parameters:
        source - source coordinates.
        target - set this to the target coordinates.

      • concatenate

        public MixedTransform concatenate​(Mixed t)
        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<Mixed>

      • preConcatenate

        public MixedTransform preConcatenate​(Mixed t)
        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<Mixed>

      • set

        public void set​(Mixed transform)
        set parameters to transform.
        Parameters:
        transform -

      • getMatrix

        public double[][] getMatrix()
        Get the matrix that transforms homogeneous source points to homogeneous target points. For testing purposes.
        Specified by:
        getMatrix in interface Mixed

      • hasFullSourceMapping

        public boolean hasFullSourceMapping()
        Check whether the transforms has a full mapping of source to target components (no source component is discarded).
        Returns:
        whether there is a full mapping of source to target components.

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object