Stereographic (Referencing core 3.18-geoapi-3.0 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.geotoolkit.referencing.operation.projection
Class Stereographic

Object
  FormattableObject
      AbstractMathTransform
          AbstractMathTransform2D
              UnitaryProjection
                  Stereographic

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

Direct Known Subclasses:: EquatorialStereographic, ObliqueStereographic, PolarStereographic

@Immutable public class Stereographic
extends UnitaryProjection
extends UnitaryProjection

Stereographic Projection. See the Stereographic projection on MathWorld for an overview. See any of the following providers for a list of programmatic parameters:

Description
The directions starting from the central point are true, but the areas and the lengths become increasingly deformed as one moves away from the center. This projection is used to represent polar areas. It can be adapted for other areas having a circular form.

This implementation, and its subclasses, provides transforms for six cases of the stereographic projection:

"Oblique_Stereographic" (EPSG code 9809), alias "Double_Stereographic" in ESRI software
"Stereographic" in ESRI software (NOT EPSG code 9809)
"Polar_Stereographic" (EPSG code 9810, uses a series calculation for the inverse)
"Polar_Stereographic (variant B)" (EPSG code 9829, uses a series calculation for the inverse)
"Stereographic_North_Pole" in ESRI software (uses iteration for the inverse)
"Stereographic_South_Pole" in ESRI software (uses iteration for the inverse)

Both the "Oblique_Stereographic" and "Stereographic" projections are "double" projections involving two parts: 1) a conformal transformation of the geographic coordinates to a sphere and 2) a spherical Stereographic projection. The EPSG considers both methods to be valid, but considers them to be a different coordinate operation methods.

The "Stereographic" case uses the USGS equations of Snyder. This employs a simplified conversion to the conformal sphere that computes the conformal latitude of each point on the sphere.

The "Oblique_Stereographic" case uses equations from the EPSG. This uses a more generalized form of the conversion to the conformal sphere; using only a single conformal sphere at the origin point. Since this is a "double" projection, it is sometimes called the "Double Stereographic". The "Oblique_Stereographic" is used in New Brunswick (Canada) and the Netherlands.

The "Stereographic" and "Double_Stereographic" names are used in ESRI's ArcGIS 8.x product. The "Oblique_Stereographic" name is the EPSG name for the later only.

Note: Tests points calculated with ArcGIS's "Double_Stereographic" are not always equal to points calculated with the "Oblique_Stereographic". However, where there are differences, two different implementations of these equations (EPSG guidence note 7 and libproj) calculate the same values as we do. Until these differences are resolved, please be careful when using this projection.

If a "latitude_of_origin" parameter is supplied and is not consistent with the projection classification (for example a latitude different from ±90° for the polar case), then the oblique or polar case will be automatically inferred from the latitude. In other words, the latitude of origin has precedence on the projection classification. If omitted, then the default value is 90°N for "Polar_Stereographic" and 0° for "Oblique_Stereographic".

Polar projections that use the series equations for the inverse calculation will be little bit faster, but may be a little bit less accurate. If a polar "latitude_of_origin" is used for the "Oblique_Stereographic" or "Stereographic", the iterative equations will be used for inverse polar calculations.

The "Polar Stereographic (variant B)", "Stereographic_North_Pole", and "Stereographic_South_Pole" cases include a "standard_parallel_1" parameter. This parameter sets the latitude with a scale factor equal to the supplied scale factor. The "Polar Stereographic (variant A)" forces its "latitude_of_origin" parameter to ±90°, depending on the hemisphere.

References

John P. Snyder (Map Projections - A Working Manual,
U.S. Geological Survey Professional Paper 1395, 1987)
"Coordinate Conversions and Transformations including Formulas",
EPSG Guidence Note Number 7, Version 19.
Gerald Evenden. "Supplementary PROJ.4 Notes - Oblique Stereographic Alternative"
Krakiwsky, E.J., D.B. Thomson, and R.R. Steeves. 1977.
A Manual for Geodetic Coordinate Transformations in the Maritimes.
Geodesy and Geomatics Engineering, UNB. Technical Report No. 48.
Thomson, D.B., M.P. Mepham and R.R. Steeves. 1977.
The Stereographic Double Projection.
Geodesy and Geomatics Engineereng, UNB. Technical Report No. 46.

Since:

1.0

Version:

3.18

Author:

Gerald Evenden (USGS), André Gosselin (MPO), Martin Desruisseaux (MPO, IRD, Geomatys), Rueben Schulz (UBC)

Module:

referencing/geotk-referencing (download)

View source code for this class

Nested Class Summary

Nested classes/interfaces inherited from class UnitaryProjection
`UnitaryProjection.Parameters`

Field Summary

Fields inherited from class UnitaryProjection
`excentricity, excentricitySquared`

Fields inherited from class FormattableObject
`EPSG, GEOTIFF, INTERNAL, OGC, SINGLE_LINE`

Constructor Summary
`protected`	`Stereographic(UnitaryProjection.Parameters parameters)` Constructs an oblique stereographic projection (USGS equations).

Method Summary
`static MathTransform2D`	`create(ParameterDescriptorGroup descriptor, ParameterValueGroup values)` Creates a Stereographic projection from the given parameters.
`boolean`	`equals(Object object, ComparisonMode mode)` Compares the given object with this transform for equivalence.
`protected void`	`inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff)` Transforms the specified (`x`,`y`) coordinates and stores the result in `dstPts` (angles in radians).
`protected void`	`transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff)` Transforms the specified (`λ`,`φ`) coordinates (units in radians) and stores the result in `dstPts` (linear distance on a unit sphere).

Methods inherited from class UnitaryProjection
`computeHashCode, finish, getParameterValues, getUnmarshalledParameters, inverse, resetWarnings, rollLongitude, transform, unrollLongitude`

Methods inherited from class AbstractMathTransform2D
`getParameterDescriptors, getSourceDimensions, getTargetDimensions, transform`

Methods inherited from class AbstractMathTransform
`createTransformedShape, derivative, derivative, ensureNonNull, equals, formatWKT, getName, hashCode, isIdentity, rollLongitude, transform, transform, transform, transform`

Methods inherited from class FormattableObject
`getDefaultIndentation, print, setDefaultIndentation, toString, toWKT, toWKT, toWKT`

Methods inherited from class Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface MathTransform2D
`createTransformedShape, derivative`

Methods inherited from interface MathTransform
`derivative, isIdentity, toWKT, transform, transform, transform, transform`

Constructor Detail

Stereographic

protected Stereographic(UnitaryProjection.Parameters parameters)

Constructs an oblique stereographic projection (USGS equations).

Parameters:: parameters - The parameters of the projection to be created.

Method Detail

create

public static MathTransform2D create(ParameterDescriptorGroup descriptor,
                                     ParameterValueGroup values)

Creates a Stereographic projection from the given parameters. The descriptor argument is usually Stereographic.PARAMETERS, but is not restricted to. If a different descriptor is supplied, it is user's responsibility to ensure that it is suitable to a Stereographic projection.

Parameters:: descriptor - Typically Stereographic.PARAMETERS.; values - The parameter values of the projection to create.
Returns:: The map projection.
Since:: 3.00

transform

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

Transforms the specified (λ,φ) coordinates (units in radians) and stores the result in dstPts (linear distance on a unit sphere).

Specified by:: transform in class UnitaryProjection

Parameters:: srcPts - The array containing the source point coordinate, as (longitude, latitude) angles in radians.; 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 in a dimensionless unit, as a linear distance on a unit sphere or ellipse.; dstOff - The offset of the location of the converted point that is stored in the destination array.
Throws:: ProjectionException - if the point can't be converted.

inverseTransform

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

Transforms the specified (x,y) coordinates and stores the result in dstPts (angles in radians).

Specified by:: inverseTransform in class UnitaryProjection

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't be converted.

equals

public boolean equals(Object object,
                      ComparisonMode mode)

Compares the given object with this transform for equivalence.

Specified by:: equals in interface LenientComparable
Overrides:: equals in class UnitaryProjection

Parameters:: object - The object to compare with this unitary projection for equivalence.; mode - The strictness level of the comparison. Default to STRICT.
Returns:: true if the given object is equivalent to this unitary projection.