Package org.apache.sis.referencing.operation.projection

## Class ZonedGridSystem

- Object
- - FormattableObject
  - - AbstractMathTransform
    - - AbstractMathTransform2D
      - - ZonedGridSystem

- All Implemented Interfaces:
    `Serializable`, `Parameterized`, `LenientComparable`, `MathTransform`, `MathTransform2D`

      public class ZonedGridSystem
      extends AbstractMathTransform2D
      implements Serializable

  Transverse Mercator Zoned Grid System projection (EPSG codes 9824). This projection is valid for all the world in a given hemisphere, except the poles. The Earth is divided into zones, usually 6° width. The zone number is determined automatically from the longitude and is prefixed to the Easting value.

  This map projection is not suitable for geometric calculations like distances and angles, since there is discontinuities (gaps) between zones. Actually this operation is not handled as a map projection by Apache SIS, as can been seen from the different class hierarchy.

  Note: current implementation can only be backed by the Transverse Mercator projection, but future versions could apply to some other projections if needed.

  Examples of CRS using this projection are WGS 84 / UTM grid system EPSG:32600 (northern hemisphere) and EPSG:32700 (southern hemisphere).

  Since:
    0.8
  See Also:
    Serialized Form

  Defined in the `sis-referencing` module

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ZonedGridSystem​(OperationMethod method, Parameters parameters, MathTransformFactory factory)` | Creates a Zoned Grid System from the given parameters.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `protected int` | `computeHashCode()` | Computes a hash code value for this `ZonedGridSystem`.
    `boolean` | `equals​(Object object, ComparisonMode mode)` | Compares the given object with this transform for equivalence.
    `ParameterValueGroup` | `getParameterValues()` | Returns the parameter values of this zoned grid system projection.
    `MathTransform2D` | `inverse()` | Returns the inverse of this map projection.
    `Matrix` | `transform​(double[] srcPts, int srcOff, double[] dstPts, int dstOff, boolean derivate)` | Converts the specified (λ,φ) coordinate and stores the result in `dstPts`.

    - ### Methods inherited from class AbstractMathTransform2D

      `createTransformedShape, derivative, getSourceDimensions, getTargetDimensions, transform`

    - ### Methods inherited from class AbstractMathTransform

      `derivative, equals, formatTo, getContextualParameters, getParameterDescriptors, hashCode, isIdentity, transform, transform, transform, transform, transform, tryConcatenate`

    - ### Methods inherited from class FormattableObject

      `print, toString, toString, toWKT`

    - ### Methods inherited from class Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface MathTransform

      `derivative, isIdentity, toWKT, transform, transform, transform, transform, transform`

- - ### Constructor Detail

    - #### ZonedGridSystem

          public ZonedGridSystem​(OperationMethod method,
                                 Parameters parameters,
                                 MathTransformFactory factory)
                          throws FactoryException

      Creates a Zoned Grid System from the given parameters. The `method` argument can be the description of one of the following:
      - "Transverse Mercator Zoned Grid System".
      Contrarily to other map projections in this package, there is no `createMapProjection(MathTransformFactory)` method in this class. Instead, the factory must be specified at this `ZonedGridSystem` construction time.
      Parameters:
        `method` - description of the projection parameters.
        `parameters` - the parameter values of the projection to create.
        `factory` - the factory to use for creating the transform.
      Throws:
        `FactoryException` - if an error occurred while creating a transform.

  - ### Method Detail

    - #### getParameterValues

          public ParameterValueGroup getParameterValues()

      Returns the parameter values of this zoned grid system projection.
      Specified by:
        `getParameterValues` in interface `Parameterized`
      Overrides:
        `getParameterValues` in class `AbstractMathTransform`
      Returns:
        the internal parameter values for this zoned grid system projection.
      See Also:
        `AbstractMathTransform​.getContextualParameters()`, `SingleOperation​.getParameterValues()`

    - #### transform

          public Matrix transform​(double[] srcPts,
                                  int srcOff,
                                  double[] dstPts,
                                  int dstOff,
                                  boolean derivate)
                           throws TransformException

      Converts the specified (λ,φ) coordinate and stores the result in `dstPts`. In addition, opportunistically computes the projection derivative if `derivate` is `true`. Note that the derivative does not contain zone prefix.
      Specified by:
        `transform` in class `AbstractMathTransform`
      Parameters:
        `srcPts` - the array containing the source coordinate (can not be `null`).
        `srcOff` - the offset to the point to be transformed in the source array.
        `dstPts` - the array into which the transformed coordinate is returned. May be the same than `srcPts`. May be `null` if only the derivative matrix is desired.
        `dstOff` - the offset to the location of the transformed point that is stored in the destination array.
        `derivate` - `true` for computing the derivative, or `false` if not needed.
      Returns:
        the matrix of the projection derivative at the given source position, or `null` if the `derivate` argument is `false`.
      Throws:
        `TransformException` - if the coordinate can not be converted.
      See Also:
        `AbstractMathTransform​.derivative(DirectPosition)`, `AbstractMathTransform​.transform(DirectPosition, DirectPosition)`, `MathTransforms​.derivativeAndTransform(MathTransform, double[], int, double[], int)`

    - #### inverse

          public MathTransform2D inverse()

      Returns the inverse of this map projection.
      Specified by:
        `inverse` in interface `MathTransform`
      Specified by:
        `inverse` in interface `MathTransform2D`
      Overrides:
        `inverse` in class `AbstractMathTransform2D`
      Returns:
        the inverse of this map projection.

    - #### computeHashCode

          protected int computeHashCode()

      Computes a hash code value for this `ZonedGridSystem`.
      Overrides:
        `computeHashCode` in class `AbstractMathTransform`
      Returns:
        the hash code value.

    - #### equals

          public boolean equals​(Object object,
                                ComparisonMode mode)

      Compares the given object with this transform for equivalence. If this method returns `true`, then for any given identical source position, the two compared map projections shall compute the same target position.
      Specified by:
        `equals` in interface `LenientComparable`
      Overrides:
        `equals` in class `AbstractMathTransform`
      Parameters:
        `object` - the object to compare with this map projection for equivalence.
        `mode` - the strictness level of the comparison. Default to `ComparisonMode​.STRICT`.
      Returns:
        `true` if the given object is equivalent to this map projection.
      See Also:
        `Utilities​.deepEquals(Object, Object, ComparisonMode)`