Package elki.math.linearalgebra

Class AffineTransformation

  • public class AffineTransformation
extends java.lang.Object
    Affine transformations implemented using homogeneous coordinates.

    The use of homogeneous coordinates allows the combination of multiple affine transformations (rotations, translations, scaling) into a single matrix operation (of dimensionality dim+1), and also the construction of an inverse transformation.

    Since:
    0.2
    Author:
    Erich Schubert

    • Field Summary

      Fields 
      Modifier and Type Field Description
      private int dim
      the dimensionality of the transformation
      private double[][] inv
      the inverse transformation
      private double[][] trans
      the transformation matrix of dim+1 x dim+1 for homogeneous coordinates

    • Constructor Summary

      Constructors 
      Constructor Description
      AffineTransformation​(int dim)
      Constructor for an identity transformation.
      AffineTransformation​(int dim, double[][] trans, double[][] inv)
      Trivial constructor with all fields, mostly for cloning

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void addAxisReflection​(int axis)
      Add a reflection along the given axis.
      void addMatrix​(double[][] m)
      Add a matrix operation to the matrix.
      void addRotation​(int axis1, int axis2, double angle)
      Convenience function to apply a rotation in 2 dimensions.
      void addScaling​(double scale)
      Simple linear (symmetric) scaling.
      void addTranslation​(double[] v)
      Add a translation operation to the matrix
      double[] apply​(double[] v)
      Apply the transformation onto a vector
      double[] applyInverse​(double[] v)
      Apply the inverse transformation onto a vector
      double[] applyRelative​(double[] v)
      Apply the transformation onto a vector
      double[] applyRelativeInverse​(double[] v)
      Apply the inverse transformation onto a vector
      int getDimensionality()
      Query dimensionality of the transformation.
      double[][] getInverse()
      Get a the inverse matrix
      double[][] getTransformation()
      Get the transformation matrix
      double[] homogeneRelativeVector​(double[] v)
      Transform a relative vector into homogeneous coordinates.
      double[] homogeneVector​(double[] v)
      Transform an absolute vector into homogeneous coordinates.
      static AffineTransformation reorderAxesTransformation​(int dim, int... axes)
      Generate a transformation that reorders axes in the given way.
      double[] unhomogeneRelativeVector​(double[] v)
      Project an homogeneous vector back into the original space.
      double[] unhomogeneVector​(double[] v)
      Project an homogeneous vector back into the original space.
      private void updateInverse()
      Compute the inverse transformation matrix

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Field Detail

      • dim

        private final int dim
        the dimensionality of the transformation

      • trans

        private double[][] trans
        the transformation matrix of dim+1 x dim+1 for homogeneous coordinates

      • inv

        private double[][] inv
        the inverse transformation

    • Constructor Detail

      • AffineTransformation

        public AffineTransformation​(int dim)
        Constructor for an identity transformation.
        Parameters:
        dim - dimensionality

      • AffineTransformation

        public AffineTransformation​(int dim,
                            double[][] trans,
                            double[][] inv)
        Trivial constructor with all fields, mostly for cloning
        Parameters:
        dim - dimensionality
        trans - transformation matrix (will NOT be copied!)
        inv - inverse matrix (will NOT be copied!)

    • Method Detail

      • reorderAxesTransformation

        public static AffineTransformation reorderAxesTransformation​(int dim,
                                                             int... axes)
        Generate a transformation that reorders axes in the given way.

        The list of axes to be used should not contain duplicates, or the resulting matrix will not be invertible. It does not have to be complete however, in particular an empty list will result in the identity transform: unmentioned axes will be appended in their original order.

        Parameters:
        dim - Dimensionality of vector space (resulting Matrix will be dim+1 x dim+1)
        axes - (Partial) list of axes
        Returns:
        new transformation to do the requested reordering

      • getDimensionality

        public int getDimensionality()
        Query dimensionality of the transformation.
        Returns:
        dimensionality

      • addTranslation

        public void addTranslation​(double[] v)
        Add a translation operation to the matrix
        Parameters:
        v - translation vector

      • addMatrix

        public void addMatrix​(double[][] m)
        Add a matrix operation to the matrix.

        Be careful to use only invertible matrices if you want an invertible affine transformation.

        Parameters:
        m - matrix (should be invertible)

      • addRotation

        public void addRotation​(int axis1,
                        int axis2,
                        double angle)
        Convenience function to apply a rotation in 2 dimensions.
        Parameters:
        axis1 - first dimension
        axis2 - second dimension
        angle - rotation angle in radians.

      • addAxisReflection

        public void addAxisReflection​(int axis)
        Add a reflection along the given axis.
        Parameters:
        axis - Axis number to do the reflection at.

      • addScaling

        public void addScaling​(double scale)
        Simple linear (symmetric) scaling.
        Parameters:
        scale - Scaling factor

      • getTransformation

        public double[][] getTransformation()
        Get the transformation matrix
        Returns:
        the transformation matrix

      • getInverse

        public double[][] getInverse()
        Get a the inverse matrix
        Returns:
        the inverse transformation matrix

      • updateInverse

        private void updateInverse()
        Compute the inverse transformation matrix

      • homogeneVector

        public double[] homogeneVector​(double[] v)
        Transform an absolute vector into homogeneous coordinates.
        Parameters:
        v - initial vector
        Returns:
        vector of dim+1, with new column having the value 1.0

      • homogeneRelativeVector

        public double[] homogeneRelativeVector​(double[] v)
        Transform a relative vector into homogeneous coordinates.
        Parameters:
        v - initial vector
        Returns:
        vector of dim+1, with new column having the value 0.0

      • unhomogeneVector

        public double[] unhomogeneVector​(double[] v)
        Project an homogeneous vector back into the original space.
        Parameters:
        v - Matrix of 1 x dim+1 containing the homogeneous vector
        Returns:
        vector of dimension dim

      • unhomogeneRelativeVector

        public double[] unhomogeneRelativeVector​(double[] v)
        Project an homogeneous vector back into the original space.
        Parameters:
        v - Matrix of 1 x dim+1 containing the homogeneous vector
        Returns:
        vector of dimension dim

      • apply

        public double[] apply​(double[] v)
        Apply the transformation onto a vector
        Parameters:
        v - vector of dimensionality dim
        Returns:
        transformed vector of dimensionality dim

      • applyInverse

        public double[] applyInverse​(double[] v)
        Apply the inverse transformation onto a vector
        Parameters:
        v - vector of dimensionality dim
        Returns:
        transformed vector of dimensionality dim

      • applyRelative

        public double[] applyRelative​(double[] v)
        Apply the transformation onto a vector
        Parameters:
        v - vector of dimensionality dim
        Returns:
        transformed vector of dimensionality dim

      • applyRelativeInverse

        public double[] applyRelativeInverse​(double[] v)
        Apply the inverse transformation onto a vector
        Parameters:
        v - vector of dimensionality dim
        Returns:
        transformed vector of dimensionality dim