Class ProjectiveTransformBuilder

Object
MathTransformBuilder
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
  • Field Details

  • Constructor Details

  • Method Details

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

      public Class<? extends CartesianCS> getCoordinateSystemType()
      Returns the required coordinate system type, which is cartesian CS.
      Overrides:
      getCoordinateSystemType in class MathTransformBuilder
      Returns:
      required coordinate system type
    • fillPMatrix

      protected void fillPMatrix() throws MissingInfoException
      Fills P matrix for m = (ATPA)-1 ATPx' equation
      Throws:
      MissingInfoException - if accuracy is not defined.
    • 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:
      MissingInfoException - if all or some of the points does not have accuracy setup properly.
    • 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
    • computeMathTransform

      protected MathTransform computeMathTransform()
      Description copied from class: MathTransformBuilder
      Calculates the math transform immediately.
      Specified by:
      computeMathTransform in class MathTransformBuilder
      Returns:
      Math transform from MappedPosition.