Class ProjectiveTransformBuilder

  • Direct Known Subclasses:
    AffineTransformBuilder, SimilarTransformBuilder

    public class ProjectiveTransformBuilder
    extends MathTransformBuilder
    Builds MathTransform setup as Projective transformation from a list of MappedPosition. The calculation uses least square method. The Projective transform equation: (2D). The calculation uses least square method. Projective transform equation:
      [ x']   [  m00  m01  m02  ] [ x ]
       [ y'] = [  m10  m11  m12  ] [ y ]
       [ 1 ]   [  m20  m21    1  ] [ 1 ]                           x' = m * x
     
    In the case that we have more identical points we can write it like this (in Matrix):
      [ x'1 ]      [ x1 y1 1  0  0  0 -x'x  -x'y]   [ m00 ]
      [ x'2 ]      [ x2 y2 1  0  0  0 -x'x  -x'y]   [ m01 ]
      [  .  ]      [             .              ]   [ m02 ]
      [  .  ]      [             .              ] * [ m10 ]
      [ x'n ]   =  [ xn yn 1  0  0  0 -x'x  -x'y]   [ m11 ]
      [ y'1 ]      [ 0  0  0  x1 y1 1 -y'x  -y'y]   [ m12 ]
      [ y'2 ]      [ 0  0  0  x2 y2 1  -y'x  -y'y]   [ m20 ]
      [  .  ]      [             .              ]   [ m21 ]
      [  .  ]      [             .              ]
      [ y'n ]      [ 0  0  0  xn yn 1  -y'x  -y'y]
      x' = A*m 
    Using the least square method we get this result:
    m = (ATPA)-1 ATPx'
    Since:
    2.4
    Author:
    Jan Jezek
    • Method Detail

      • getMinimumPointCount

        public int getMinimumPointCount()
        Returns the minimum number of points required by this builder, which is 4 by default. Subclasses like affine transform builders will reduce this minimum.
        Specified by:
        getMinimumPointCount in class MathTransformBuilder
        Returns:
        minimum number of points required by this builder, which is 4 by default.
      • fillAMatrix

        protected void fillAMatrix()
        Fills A matrix for m = (ATPA)-1 ATPx' equation
      • fillXMatrix

        protected void fillXMatrix()
        Fills x' matrix for m = (ATPA)-1 ATPx' equation
      • includeWeights

        public void includeWeights​(boolean include)
                            throws MissingInfoException
        Switch whether to include weights into the calculation. Weights are derived from each point accuracy. Weight p = 1 / accuracy2.
        Parameters:
        include - if true then the weights will be included onto the calculation. False is default.
        Throws:
        FactoryException - if all or some of the points does not have accuracy setup properly.
        MissingInfoException
      • calculateLSM

        protected double[] calculateLSM()
        Calculates the parameters using the least square method. The equation:
        m = (ATA)-1 ATx'
        Returns:
        m matrix.
      • getProjectiveMatrix

        protected GeneralMatrix getProjectiveMatrix()
        Returns the matrix of parameters for Projective transformation. This method should by override for the special cases like affine or similar transformation. The M matrix looks like this:
        
          [  m00  m01  m02  ]
          [  m10  m11  m12  ]
          [  m20  m21   1   ]
         
        Returns:
        Matrix M