org.apache.sis.referencing.operation.projection

## Class PolarStereographic

- Object
- - FormattableObject
  - - AbstractMathTransform
    - - AbstractMathTransform2D
      - - NormalizedProjection
        - - PolarStereographic

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

      public class PolarStereographic
      extends NormalizedProjection

  Polar Stereographic projection (EPSG codes 9810, 9829, 9830). This is a special case of `ObliqueStereographic` when the projection origin is at a pole.

  EPSG defines three variants for this projection, A, B and C, which differ by the way the parameters are specified. The "Polar Stereographic (variant B)" projection includes a "Latitude of standard parallel" parameter where is effective the scale factor (normally 1). The "Polar Stereographic (variant A)" forces its "Latitude of natural origin" parameter to ±90°, depending on the hemisphere.

  Since:
    0.6
  See Also:
    `ObliqueStereographic`, Serialized Form

  Defined in the `sis-referencing` module

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class NormalizedProjection

      `NormalizedProjection​.ParameterRole`

  - ### Field Summary

    - ### Fields inherited from class NormalizedProjection

      `eccentricity, eccentricitySquared`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PolarStereographic(OperationMethod method, Parameters parameters)` Creates a Polar Stereographic projection from the given parameters.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `MathTransform` | `createMapProjection(MathTransformFactory factory)` Returns the sequence of normalization → `this` → denormalization transforms as a whole.
    `protected void` | `inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff)` Converts the specified (x,y) coordinates and stores the result in `dstPts` (angles in radians).
    `Matrix` | `transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, boolean derivate)` Converts the specified (θ,φ) coordinate (units in radians) and stores the result in `dstPts`.

    - ### Methods inherited from class NormalizedProjection

      `computeHashCode, equals, getContextualParameters, getParameterDescriptors, getParameterValues, inverse, tryConcatenate`

    - ### Methods inherited from class AbstractMathTransform2D

      `createTransformedShape, derivative, getSourceDimensions, getTargetDimensions, transform`

    - ### Methods inherited from class AbstractMathTransform

      `derivative, equals, formatTo, hashCode, isIdentity, transform, transform, transform, transform, transform`

    - ### 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

    - #### PolarStereographic

          public PolarStereographic(OperationMethod method,
                                    Parameters parameters)

      Creates a Polar Stereographic projection from the given parameters. The `method` argument can be the description of one of the following:
      - "Polar Stereographic (Variant A)".
      - "Polar Stereographic (Variant B)".
      - "Polar Stereographic (Variant C)".
      Parameters:
        `method` - description of the projection parameters.
        `parameters` - the parameter values of the projection to create.

  - ### Method Detail

    - #### createMapProjection

          public MathTransform createMapProjection(MathTransformFactory factory)
                                            throws FactoryException

      Returns the sequence of normalization → `this` → denormalization transforms as a whole. The transform returned by this method expects (longitude, latitude) coordinates in degrees and returns (x,y) coordinates in metres.

      The non-linear part of the returned transform will be `this` transform, except if the ellipsoid is spherical. In the later case, `this` transform will be replaced by a simplified implementation.

      Overrides:
        `createMapProjection` in class `NormalizedProjection`
      Parameters:
        `factory` - the factory to use for creating the transform.
      Returns:
        the map projection from (λ,φ) to (x,y) coordinates.
      Throws:
        `FactoryException` - if an error occurred while creating a transform.
      See Also:
        `ContextualParameters​.completeTransform(MathTransformFactory, MathTransform)`

    - #### transform

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

      Converts the specified (θ,φ) coordinate (units in radians) and stores the result in `dstPts`. In addition, opportunistically computes the projection derivative if `derivate` is `true`.
      Specified by:
        `transform` in class `NormalizedProjection`
      Parameters:
        `srcPts` - the array containing the source point coordinate, as (longitude, latitude) angles in radians.
        `srcOff` - the offset of the single coordinate to be converted in the source array.
        `dstPts` - the array into which the converted coordinate is returned (may be the same than `srcPts`). Ordinates will be expressed in a dimensionless unit, as a linear distance on a unit sphere or ellipse.
        `dstOff` - the offset of the location of the converted coordinate 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:
        `ProjectionException` - if the coordinate can not be converted.
      See Also:
        `AbstractMathTransform​.derivative(DirectPosition)`, `AbstractMathTransform​.transform(DirectPosition, DirectPosition)`, `MathTransforms​.derivativeAndTransform(MathTransform, double[], int, double[], int)`

    - #### inverseTransform

          protected void inverseTransform(double[] srcPts,
                                          int srcOff,
                                          double[] dstPts,
                                          int dstOff)
                                   throws ProjectionException

      Converts the specified (x,y) coordinates and stores the result in `dstPts` (angles in radians).
      Specified by:
        `inverseTransform` in class `NormalizedProjection`
      Parameters:
        `srcPts` - the array containing the source point coordinate, as linear distance on a unit sphere or ellipse.
        `srcOff` - the offset of the point to be converted in the source array.
        `dstPts` - the array into which the converted point coordinate is returned (may be the same than `srcPts`). Ordinates will be (longitude, latitude) angles in radians.
        `dstOff` - the offset of the location of the converted point that is stored in the destination array.
      Throws:
        `ProjectionException` - if the point can not be converted.

Copyright © 2010–2017 The Apache Software Foundation. All rights reserved.