Package net.imglib2.transform.integer

Class SlicingTransform

java.lang.Object
net.imglib2.transform.integer.AbstractMixedTransform
net.imglib2.transform.integer.SlicingTransform
All Implemented Interfaces:
Concatenable<Slicing>, PreConcatenable<Slicing>, BoundingBoxTransform, Mixed, Slicing, Transform
public class SlicingTransform extends AbstractMixedTransform implements Slicing, Concatenable<Slicing>, PreConcatenable<Slicing>
Map the components of the source vector to a slice of the target space, for instance transform (x,y) to (x,C,y) where C is a constant.

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

  1. component permutation
  2. project up and position (add constant components in the target vector)

The component permutation step is 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!

Author:
Tobias Pietzsch

  • Field Details

    • numSourceDimensions

      protected final int numSourceDimensions
      dimension of source vector.

    • 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).

    • translation

      protected final long[] translation
      translation is added to the target vector after applying the permutation and project-up operations. Only translation values for dimensions that have not been assigned a source vector component are used. For instance, if you project (x,y) to (x,y,z) only the translation value for z is used.

    • component

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

  • Constructor Details

    • SlicingTransform

      public SlicingTransform(int sourceDim, int targetDim)

  • Method Details

    • numSourceDimensions

      public int numSourceDimensions()
      Description copied from interface: Transform
      Returns n, the dimension of the source vector.
      Specified by:
      numSourceDimensions in interface Transform
      Overrides:
      numSourceDimensions in class AbstractMixedTransform
      Returns:
      the dimension of the source vector.

    • 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.

    • getTranslation

      public long getTranslation(int d)
      Description copied from interface: Mixed
      Get the d-th component of translation (see Mixed.getTranslation(long[])).
      Specified by:
      getTranslation in interface Mixed
      Overrides:
      getTranslation in class AbstractMixedTransform
      Parameters:
      d -

    • setTranslation

      public void setTranslation(long[] t)

    • 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.

    • getComponentZero

      public boolean getComponentZero(int d)
      Description copied from interface: Mixed
      Get the d-th component of zeroing vector (see Mixed.getComponentZero(boolean[])).
      Specified by:
      getComponentZero in interface Mixed
      Overrides:
      getComponentZero in class AbstractMixedTransform
      Parameters:
      d -

    • 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.

    • getComponentMapping

      public int getComponentMapping(int d)
      Description copied from interface: Mixed
      Get the source dimension which is mapped to the d-th target dimension (see Mixed.getComponentMapping(int[])).
      Specified by:
      getComponentMapping in interface Mixed
      Overrides:
      getComponentMapping in class AbstractMixedTransform
      Parameters:
      d -

    • 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.

    • 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.

    • apply

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

    • concatenate

      public SlicingTransform concatenate(Slicing 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<Slicing>

    • getConcatenableClass

      public Class<Slicing> getConcatenableClass()
      Specified by:
      getConcatenableClass in interface Concatenable<Slicing>

    • preConcatenate

      public SlicingTransform preConcatenate(Slicing 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<Slicing>

    • getPreConcatenableClass

      public Class<Slicing> getPreConcatenableClass()
      Specified by:
      getPreConcatenableClass in interface PreConcatenable<Slicing>

    • set

      public void set(Slicing 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.