Class DefaultMathTransformFactory

  • All Implemented Interfaces:
    Factory, MathTransformFactory, Factory, RegistrableFactory

    public class DefaultMathTransformFactory
    extends ReferencingFactory
    implements MathTransformFactory
    Low level factory for creating math transforms. Many high level GIS applications will never need to use this factory directly; they can use a coordinate operation factory instead. However, the MathTransformFactory interface can be used directly by applications that wish to transform other types of coordinates (e.g. color coordinates, or image pixel coordinates).

    A math transform is an object that actually does the work of applying formulae to coordinate values. The math transform does not know or care how the coordinates relate to positions in the real world. This lack of semantics makes implementing MathTransformFactory significantly easier than it would be otherwise.

    For example the affine transform applies a matrix to the coordinates without knowing how what it is doing relates to the real world. So if the matrix scales Z values by a factor of 1000, then it could be converting meters into millimeters, or it could be converting kilometers into meters.

    Because math transforms have low semantic value (but high mathematical value), programmers who do not have much knowledge of how GIS applications use coordinate systems, or how those coordinate systems relate to the real world can implement MathTransformFactory. The low semantic content of math transforms also means that they will be useful in applications that have nothing to do with GIS coordinates. For example, a math transform could be used to map color coordinates between different color spaces, such as converting (red, green, blue) colors into (hue, light, saturation) colors.

    Since a math transform does not know what its source and target coordinate systems mean, it is not necessary or desirable for a math transform object to keep information on its source and target coordinate systems.

    Martin Desruisseaux (IRD)
    • Constructor Detail

      • DefaultMathTransformFactory

        public DefaultMathTransformFactory()
        Constructs a default math transform factory.
    • Method Detail

      • getVendor

        public Citation getVendor()
        Returns the vendor responsible for creating this factory implementation. Many implementations may be available for the same factory interface. The default implementation returns Geotools.
        Specified by:
        getVendor in interface Factory
        getVendor in class ReferencingFactory
        The vendor for this factory implementation.
      • getOperationMethod

        public OperationMethod getOperationMethod​(String name)
                                           throws NoSuchIdentifierException
        Returns the operation method for the specified name.
        name - The case insensitive identifier code of the operation method to search for (e.g. "Transverse_Mercator").
        The operation method.
        NoSuchIdentifierException - if there is no operation method registered for the specified name.
      • createBaseToDerived

        public MathTransform createBaseToDerived​(CoordinateReferenceSystem baseCRS,
                                                 MathTransform projection,
                                                 CoordinateSystem derivedCS)
                                          throws FactoryException
        Creates a transform from a base CRS to a derived CS. This method expects a "raw" transform without unit conversion or axis switch, typically a map projection working on (longitude, latitude) axes in degrees and (x, y) axes in metres. This method inspects the coordinate systems and prepend or append the unit conversions and axis switchs automatically.
        baseCRS - The source coordinate reference system.
        projection - The "raw" base to derived transform.
        derivedCS - the target coordinate system.
        The parameterized transform.
        FactoryException - if the object creation failed. This exception is thrown if some required parameter has not been supplied, or has illegal value.
      • createAffineTransform

        public MathTransform createAffineTransform​(Matrix matrix)
                                            throws FactoryException
        Creates an affine transform from a matrix. If the transform's input dimension is M, and output dimension is N, then the matrix will have size [N+1][M+1]. The +1 in the matrix dimensions allows the matrix to do a shift, as well as a rotation. The [M][j] element of the matrix will be the j'th ordinate of the moved origin. The [i][N] element of the matrix will be 0 for i less than M, and 1 for i equals M.
        Specified by:
        createAffineTransform in interface MathTransformFactory
        matrix - The matrix used to define the affine transform.
        The affine transform.
        FactoryException - if the object creation failed.
      • createConcatenatedTransform

        public MathTransform createConcatenatedTransform​(MathTransform transform1,
                                                         MathTransform transform2)
                                                  throws FactoryException
        Creates a transform by concatenating two existing transforms. A concatenated transform acts in the same way as applying two transforms, one after the other.

        The dimension of the output space of the first transform must match the dimension of the input space in the second transform. If you wish to concatenate more than two transforms, then you can repeatedly use this method.

        Specified by:
        createConcatenatedTransform in interface MathTransformFactory
        transform1 - The first transform to apply to points.
        transform2 - The second transform to apply to points.
        The concatenated transform.
        FactoryException - if the object creation failed.
      • createPassThroughTransform

        public MathTransform createPassThroughTransform​(int firstAffectedOrdinate,
                                                        MathTransform subTransform,
                                                        int numTrailingOrdinates)
                                                 throws FactoryException
        Creates a transform which passes through a subset of ordinates to another transform. This allows transforms to operate on a subset of ordinates. For example, if you have (Lat,Lon,Height) coordinates, then you may wish to convert the height values from meters to feet without affecting the (Lat,Lon) values.
        Specified by:
        createPassThroughTransform in interface MathTransformFactory
        firstAffectedOrdinate - The lowest index of the affected ordinates.
        subTransform - Transform to use for affected ordinates.
        numTrailingOrdinates - Number of trailing ordinates to pass through. Affected ordinates will range from firstAffectedOrdinate inclusive to dimTarget-numTrailingOrdinates exclusive.
        A pass through transform with the following dimensions:
         Source: firstAffectedOrdinate + subTransform.getSourceDimensions() + numTrailingOrdinates
         Target: firstAffectedOrdinate + subTransform.getTargetDimensions() + numTrailingOrdinates
        FactoryException - if the object creation failed.
      • createFromXML

        public MathTransform createFromXML​(String xml)
                                    throws FactoryException
        Creates a math transform object from a XML string. The default implementation always throws an exception, since this method is not yet implemented.
        Specified by:
        createFromXML in interface MathTransformFactory
        xml - Math transform encoded in XML format.
        The math transform (never null).
        FactoryException - if the object creation failed.
      • scanForPlugins

        public void scanForPlugins()
        Scans for factory plug-ins on the application class path. This method is needed because the application class path can theoretically change, or additional plug-ins may become available. Rather than re-scanning the classpath on every invocation of the API, the class path is scanned automatically only on the first invocation. Clients can call this method to prompt a re-scan. Thus this method need only be invoked by sophisticated applications which dynamically make new plug-ins available at runtime.
      • main

        public static void main​(String... args)
        Dump to the standard output stream a list of available operation methods. This method can be invoked from the command line. It provides a mean to verify which transforms were found in the classpath. The syntax is:
        java org.geotools.referencing.operation.DefaultMathTransformFactory <options> <method>

        where options are:

        -projections  List only projections
        -conversions  List only conversions
        -all  List the parameters for all transforms
        -encoding <code>  Set the character encoding
        -locale <language>  Set the language for the output (e.g. "fr" for French)

        and <method> is the optional name of an operation method (e.g. "Affine", "EPSG:9624" or just "9624" for the affine transform method).

        Note for Windows users: If the output contains strange symbols, try to supply an "-encoding" argument. Example:

        java org.geotools.referencing.operation.DefaultMathTransformFactory -encoding Cp850

        The codepage number (850 in the previous example) can be obtained from the DOS commande line using the "chcp" command with no arguments.

        args - Command line arguments.
      • cleanupThreadLocals

        public static void cleanupThreadLocals()
        Cleans up the thread local set in this thread. They can prevent web applications from proper shutdown