## 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
• ### Field Summary

Fields
Modifier and Type Field Description
`protected GeneralMatrix` `A`
Matrix of derivations
`protected GeneralMatrix` `P`
Matrix of wights
`protected GeneralMatrix` `X`
Matrix of target values
• ### Fields inherited from class MathTransformBuilder

`mtFactory`
• ### Constructor Summary

Constructors
Modifier Constructor Description
`protected ` `ProjectiveTransformBuilder()`
` ` `ProjectiveTransformBuilder​(List<MappedPosition> vectors)`
Creates ProjectiveTransformBuilder for the set of properties.
• ### Method Summary

All Methods
Modifier and Type Method Description
`protected double[]` `calculateLSM()`
Calculates the parameters using the least square method.
`protected MathTransform` `computeMathTransform()`
Calculates the math transform immediately.
`protected void` `fillAMatrix()`
Fills A matrix for m = (ATPA)-1 ATPx' equation
`protected void` `fillPMatrix()`
Fills P matrix for m = (ATPA)-1 ATPx' equation
`protected void` `fillXMatrix()`
Fills x' matrix for m = (ATPA)-1 ATPx' equation
`Class<? extends CartesianCS>` `getCoordinateSystemType()`
Returns the required coordinate system type, which is cartesian CS.
`int` `getMinimumPointCount()`
Returns the minimum number of points required by this builder, which is 4 by default.
`protected GeneralMatrix` `getProjectiveMatrix()`
Returns the matrix of parameters for Projective transformation.
`void` `includeWeights​(boolean include)`
Switch whether to include weights into the calculation.
• ### Methods inherited from class MathTransformBuilder

`getDimension, getErrorStatistics, getMappedPositions, getMathTransform, getName, getSourceCRS, getSourcePoints, getTargetCRS, getTargetPoints, getTransformation, printPoints, setMappedPositions, setSourcePoints, setTargetPoints, toString`
• ### Methods inherited from class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`
• ### Field Detail

• #### A

`protected GeneralMatrix A`
Matrix of derivations
• #### P

`protected GeneralMatrix P`
Matrix of wights
• #### X

`protected GeneralMatrix X`
Matrix of target values
• ### Constructor Detail

• #### ProjectiveTransformBuilder

`protected ProjectiveTransformBuilder()`
• #### ProjectiveTransformBuilder

```public ProjectiveTransformBuilder​(List<MappedPosition> vectors)
throws IllegalArgumentException,
MismatchedDimensionException,
MismatchedReferenceSystemException```
Creates ProjectiveTransformBuilder for the set of properties.
Parameters:
`vectors` - list of MappedPosition
Throws:
`MismatchedSizeException` - if the number of properties is not set properly.
`MismatchedDimensionException` - if the dimension of properties is not set properly.
`MismatchedReferenceSystemException` - -if there is mismatch in coordinate system in MappedPosition
`IllegalArgumentException`
• ### 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.
• #### 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:
`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
• #### 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`.