2021.1.02

• All Implemented Interfaces:
ILcdCylindrical, ILcdProjection, ILcdPropertyChangeSource, java.io.Serializable, java.lang.Cloneable

```public class TLcdEllipsoidalEquidistantCylindrical
extends ALcdCylindrical```
Equidistant Cylindrical projection that uses ellipsoidal calculations. See `TLcdEquidistantCylindrical` for a version of this projection that uses spherical calculations.

### Introduction

The Equidistant Cylindrical projection is basically a linear transformation from lat-lon coordinates to XY world coordinates. If the equator is made the standard parallel this projection is also known as Plate Carree or Simple Cylindrical.

### Properties

• Neither equal-area nor conformal.
• Meridians and parallels are straight lines. They are spaced equally and intersect each other at right angles.
• Poles are projected as lines.

### Sample code

``````
ILcdProjection projection =
new TLcdEllipsoidalEquidistantCylindrical(0.0, 0.0);
``````
Since:
2015.1
Serialized Form

• ### Fields inherited from class com.luciad.projection.ALcdProjection

`fPropertyChangeDispatcher`
• ### Fields inherited from interface com.luciad.projection.ILcdProjection

`EPSILON`
• ### Constructor Summary

Constructors
Constructor and Description
`TLcdEllipsoidalEquidistantCylindrical()`
Constructs a simple rectangular projection with the central meridian at 0 and the standard parallel at 0.
`TLcdEllipsoidalEquidistantCylindrical(double aCentralMeridian)`
Constructs a simple rectangular projection with the specified central meridian and the standard parallel at 0.
```TLcdEllipsoidalEquidistantCylindrical(double aCentralMeridian, double aStandardParallel)```
Constructs a simple rectangular projection with the specified central meridian.
• ### Method Summary

All Methods
Modifier and Type Method and Description
`double[][]` `boundaryLats(double aLongitude)`
Default implementation.
`double[][]` `boundaryLons(double aLatitude)`
Default implementation.
`java.lang.Object` `clone()`
Makes a deep clone of this `ILcdProjection`.
`boolean` `equals(java.lang.Object o)`
Checks if this `ILcdProjection` equals some other Object.
`double` `getStandardParallel()`
Returns the standard parallel of the Equidistant Cylindrical projection.
`int` `hashCode()`
`boolean` `inLonLatBounds(ILcdPoint aLLHP)`
Checks if an `ILcdPoint` is inside the valid area of geodetic coordinates of the projection.
`boolean` ```inWorldBoundsOnEllipsoid(ILcdPoint aXYPoint, ILcdEllipsoid aEllipsoid)```
Default implementation calls `inWorldBoundsOnSphere` with `aEllipsoid.getAuxRadius()` as sphere radius.
`boolean` ```inWorldBoundsOnSphere(ILcdPoint aXYPoint, double aRadius)```
Checks if a `ILcdPoint` is inside the valid cartesian area of the projection.
`boolean` `isAllInBounds()`
If all geodetic coordinates (l ,j ) are projected (visible) by an `ILcdProjection` and all (x,y ) coordinates are bounded this is `true`.
`void` ```loadProperties(java.lang.String aPrefix, java.util.Properties aProperty)```
Loads the two properties of this equidistant cylindrical projection, i.e., the central meridian and the standard parallel.
`void` ```lonlatheight2worldOnEllipsoidSFCT(ILcdPoint aLLHP, ILcdEllipsoid aEllipsoid, ILcd2DEditablePoint aXYPointSFCT)```
Default implementation calls `lonlatheight2worldOnEllipsoidSFCT` with `aEllipsoid.getAuxRadius()` as sphere radius.
`void` ```lonlatheight2worldOnSphereSFCT(ILcdPoint aLLHP, double aRadius, ILcd2DEditablePoint aXYPointSFCT)```
Transforms an `ILcd2DEditablePoint` on a sphere into the cartesian coordinate system of the projection.
`void` `setCentralMeridian(double aLongitude)`
Sets the centralMeridian to the meridian with longitude `aLongitude`.
`void` `setStandardParallel(double aStandardParallel)`
Sets the standard parallel of the Equidistant Cylindrical projection.
`java.lang.String` `toString()`
String representation of this `ILcdProjection`.
`void` ```world2DEditableBoundsOnEllipsoidSFCT(ILcdEllipsoid aEllipsoid, ILcd2DEditableBounds aWorldBoundsSFCT)```
Default implementation calls `world2lonlatOnSphereSFCT` with `aEllipsoid.getAuxRadius()` as sphere radius.
`void` ```world2DEditableBoundsOnSphereSFCT(double aRadius, ILcd2DEditableBounds aWorldBounds)```
Sets the `ILcd2DEditableBounds` object to the bounds of the projection in world coordinates.
`void` ```world2lonlatOnEllipsoidSFCT(ILcdPoint aXYPoint, ILcdEllipsoid aEllipsoid, ILcd2DEditablePoint aLLPointSFCT)```
Default implementation calls `world2lonlatOnSphereSFCT` with `aEllipsoid.getAuxRadius()` as sphere radius.
`void` ```world2lonlatOnSphereSFCT(ILcdPoint aXYPoint, double aRadius, ILcd2DEditablePoint aLLPointSFCT)```
Transforms an `ILcdPoint` from the cartesian coordinate system of the projection into an `ILcd2DEditablePoint` onto a sphere.
`void` ```writePropertiesSFCT(java.lang.String aPrefix, java.util.Properties aPropertySFCT)```
Writes the two properties of this equidistant cylindrical projection, i.e., the central meridian and the standard parallel.
• ### Methods inherited from class com.luciad.projection.ALcdCylindrical

`calculateCachedValues, getCentralMeridian, getOrigin, isContinuous`
• ### Methods inherited from class com.luciad.projection.ALcdProjection

`addPropertyChangeListener, firePropertyChangeEvent, removePropertyChangeListener`
• ### Methods inherited from class java.lang.Object

`finalize, getClass, notify, notifyAll, wait, wait, wait`
• ### Methods inherited from interface com.luciad.util.ILcdPropertyChangeSource

`addPropertyChangeListener, removePropertyChangeListener`
• ### Constructor Detail

• #### TLcdEllipsoidalEquidistantCylindrical

`public TLcdEllipsoidalEquidistantCylindrical()`
Constructs a simple rectangular projection with the central meridian at 0 and the standard parallel at 0.
• #### TLcdEllipsoidalEquidistantCylindrical

`public TLcdEllipsoidalEquidistantCylindrical(double aCentralMeridian)`
Constructs a simple rectangular projection with the specified central meridian and the standard parallel at 0.
Parameters:
`aCentralMeridian` - the central meridian of the projection.
• #### TLcdEllipsoidalEquidistantCylindrical

```public TLcdEllipsoidalEquidistantCylindrical(double aCentralMeridian,
double aStandardParallel)```
Constructs a simple rectangular projection with the specified central meridian.
Parameters:
`aCentralMeridian` - the central meridian of the projection.
`aStandardParallel` - the standard parallel of the projection.
• ### Method Detail

• #### getStandardParallel

`public double getStandardParallel()`
Returns the standard parallel of the Equidistant Cylindrical projection.
Returns:
the standard parallel of the Equidistant Cylindrical projection.
`setStandardParallel(double)`
• #### setStandardParallel

`public void setStandardParallel(double aStandardParallel)`
Sets the standard parallel of the Equidistant Cylindrical projection.
Parameters:
`aStandardParallel` - the new standard parallel value.
`getStandardParallel()`
• #### setCentralMeridian

`public void setCentralMeridian(double aLongitude)`
Description copied from interface: `ILcdCylindrical`
Sets the centralMeridian to the meridian with longitude `aLongitude`.
Specified by:
`setCentralMeridian` in interface `ILcdCylindrical`
Overrides:
`setCentralMeridian` in class `ALcdCylindrical`
Parameters:
`aLongitude` - The new centralMeridian value.
`ILcdCylindrical.getCentralMeridian()`
• #### isAllInBounds

`public boolean isAllInBounds()`
Description copied from interface: `ILcdProjection`
If all geodetic coordinates (l ,j ) are projected (visible) by an `ILcdProjection` and all (x,y ) coordinates are bounded this is `true`. All `ILcdProjection` objects have bounded (x,y ) coordinates because the projection is cut off if necessary.
Returns:
`true` if all LonLatPoints are within the bounds of the projection, `false` otherwise.
• #### lonlatheight2worldOnSphereSFCT

```public void lonlatheight2worldOnSphereSFCT(ILcdPoint aLLHP,
ILcd2DEditablePoint aXYPointSFCT)
throws TLcdOutOfBoundsException```
Description copied from interface: `ILcdProjection`
Transforms an `ILcd2DEditablePoint` on a sphere into the cartesian coordinate system of the projection.
Parameters:
`aLLHP` - point to be projected.
`aRadius` - radius of the sphere (meters).
`aXYPointSFCT` - projected point as side effect.
Throws:
`TLcdOutOfBoundsException` - If the `ILcdPoint` `aLLHP` is not within the valid area of the projection (visible area), then this exception is thrown.
• #### lonlatheight2worldOnEllipsoidSFCT

```public void lonlatheight2worldOnEllipsoidSFCT(ILcdPoint aLLHP,
ILcdEllipsoid aEllipsoid,
ILcd2DEditablePoint aXYPointSFCT)
throws TLcdOutOfBoundsException```
Description copied from class: `ALcdProjection`
Default implementation calls `lonlatheight2worldOnEllipsoidSFCT` with `aEllipsoid.getAuxRadius()` as sphere radius.
Specified by:
`lonlatheight2worldOnEllipsoidSFCT` in interface `ILcdProjection`
Overrides:
`lonlatheight2worldOnEllipsoidSFCT` in class `ALcdProjection`
Parameters:
`aLLHP` - point to be projected.
`aEllipsoid` - ellipsoid on which the point is defined.
`aXYPointSFCT` - projected point as side effect.
Throws:
`TLcdOutOfBoundsException` - If the `ILcdPoint` `aLLHP` is not within the valid area of the projection (visible area), then this exception is thrown.
• #### world2lonlatOnSphereSFCT

```public void world2lonlatOnSphereSFCT(ILcdPoint aXYPoint,
ILcd2DEditablePoint aLLPointSFCT)
throws TLcdOutOfBoundsException```
Description copied from interface: `ILcdProjection`
Transforms an `ILcdPoint` from the cartesian coordinate system of the projection into an `ILcd2DEditablePoint` onto a sphere.
Parameters:
`aXYPoint` - projected point for which the corresponding geodetic point is sought.
`aRadius` - radius of the sphere (meters).
`aLLPointSFCT` - resulting geodetic coordinate as side effect.
Throws:
`TLcdOutOfBoundsException` - If the `ILcdPoint` `aXYPoint` is not within the valid area of the projection (visible area), then this exception is thrown.
• #### world2lonlatOnEllipsoidSFCT

```public void world2lonlatOnEllipsoidSFCT(ILcdPoint aXYPoint,
ILcdEllipsoid aEllipsoid,
ILcd2DEditablePoint aLLPointSFCT)
throws TLcdOutOfBoundsException```
Description copied from class: `ALcdProjection`
Default implementation calls `world2lonlatOnSphereSFCT` with `aEllipsoid.getAuxRadius()` as sphere radius.
Specified by:
`world2lonlatOnEllipsoidSFCT` in interface `ILcdProjection`
Overrides:
`world2lonlatOnEllipsoidSFCT` in class `ALcdProjection`
Parameters:
`aXYPoint` - projected point for which the corresponding geodetic point is sought.
`aEllipsoid` - ellipsoid on which the geodetic coordinate is defined.
`aLLPointSFCT` - resulting geodetic coordinate as side effect.
Throws:
`TLcdOutOfBoundsException` - If the `ILcdPoint` `aXYPoint` is not within the valid area of the projection (visible area), then this exception is thrown.
• #### inLonLatBounds

`public boolean inLonLatBounds(ILcdPoint aLLHP)`
Description copied from interface: `ILcdProjection`
Checks if an `ILcdPoint` is inside the valid area of geodetic coordinates of the projection. The valid area is determined by the LonLatPoints that are visible and for which the corresponding cartesian coordinate is within the boundaries.
Parameters:
`aLLHP` - `ILcdPoint` to be checked upon.
Returns:
`true` if valid, `false` if invalid.
• #### inWorldBoundsOnSphere

```public boolean inWorldBoundsOnSphere(ILcdPoint aXYPoint,
Description copied from interface: `ILcdProjection`
Checks if a `ILcdPoint` is inside the valid cartesian area of the projection. The valid cartesian area is determined naturally by the projection bounds or by an artificial introduced boundary limit because some cartesian points are at infinity. The shape of the valid cartesian area is in many cases rectangular or circular although it might be more complex.
Parameters:
`aXYPoint` - point to be checked upon.
`aRadius` - radius of the sphere.
Returns:
`true` if valid, `false` if invalid.
• #### world2DEditableBoundsOnEllipsoidSFCT

```public void world2DEditableBoundsOnEllipsoidSFCT(ILcdEllipsoid aEllipsoid,
ILcd2DEditableBounds aWorldBoundsSFCT)```
Description copied from class: `ALcdProjection`
Default implementation calls `world2lonlatOnSphereSFCT` with `aEllipsoid.getAuxRadius()` as sphere radius.
Specified by:
`world2DEditableBoundsOnEllipsoidSFCT` in interface `ILcdProjection`
Overrides:
`world2DEditableBoundsOnEllipsoidSFCT` in class `ALcdProjection`
Parameters:
`aEllipsoid` - ellipsoid considered.
`aWorldBoundsSFCT` - the bounds of the projection in world coordinates as side effect.
• #### inWorldBoundsOnEllipsoid

```public boolean inWorldBoundsOnEllipsoid(ILcdPoint aXYPoint,
ILcdEllipsoid aEllipsoid)```
Description copied from class: `ALcdProjection`
Default implementation calls `inWorldBoundsOnSphere` with `aEllipsoid.getAuxRadius()` as sphere radius.
Specified by:
`inWorldBoundsOnEllipsoid` in interface `ILcdProjection`
Overrides:
`inWorldBoundsOnEllipsoid` in class `ALcdProjection`
Parameters:
`aXYPoint` - point to be checked upon.
`aEllipsoid` - ellipsoid on which the geodetic coordinate is defined.
Returns:
`true` if valid, `false` if invalid.
`ILcdProjection.inWorldBoundsOnSphere(com.luciad.shape.ILcdPoint, double)`
• #### boundaryLons

`public double[][] boundaryLons(double aLatitude)`
Description copied from class: `ALcdProjection`
Default implementation. To be redefined for specific projections.
Specified by:
`boundaryLons` in interface `ILcdProjection`
Overrides:
`boundaryLons` in class `ALcdProjection`
Parameters:
`aLatitude` - latitude in decimal degrees and -90.0 <= `aLat`<= 90.0.
Returns:
the array of pairs of longitudes[0] and longitudes[1], where the closed interval longitudes[0] -> longitudes[1] is in visible area and -180.0 <= lon[i] <= 180.0.
• #### boundaryLats

`public double[][] boundaryLats(double aLongitude)`
Description copied from class: `ALcdProjection`
Default implementation. To be redefined for specific projections.
Specified by:
`boundaryLats` in interface `ILcdProjection`
Overrides:
`boundaryLats` in class `ALcdProjection`
Parameters:
`aLongitude` - longitude in decimal degrees -180.0 <= lon <= 180.0 .
Returns:
the array of pairs of latitudes lats[0] and lats[1], where the closed interval lats[0] -> lats[1] is in visible area and -90.0 <= lats[i] <= 90.0 .
• #### world2DEditableBoundsOnSphereSFCT

```public void world2DEditableBoundsOnSphereSFCT(double aRadius,
ILcd2DEditableBounds aWorldBounds)```
Description copied from interface: `ILcdProjection`
Sets the `ILcd2DEditableBounds` object to the bounds of the projection in world coordinates.
Parameters:
`aRadius` - radius of the sphere.
`aWorldBounds` - the bounds of the projection in world coordinates as side effect.

```public void loadProperties(java.lang.String aPrefix,
java.util.Properties aProperty)
throws java.lang.IllegalArgumentException```
Loads the two properties of this equidistant cylindrical projection, i.e., the central meridian and the standard parallel. This method will, given aPrefix, analyze the aProperties object to set the properties of this projection. The values of following keys are retrieved:
• <aPrefix>.centralMeridian
• <aPrefix>.standardParallel
If these factors are not available they are set to the default value 0.0.
Specified by:
`loadProperties` in interface `ILcdProjection`
Overrides:
`loadProperties` in class `ALcdCylindrical`
Parameters:
`aPrefix` - prefix of the property names.
`aProperty` - Properties object containing the serialized properties.
Throws:
`java.lang.IllegalArgumentException` - if the projection cannot be created.
• #### writePropertiesSFCT

```public void writePropertiesSFCT(java.lang.String aPrefix,
java.util.Properties aPropertySFCT)```
Writes the two properties of this equidistant cylindrical projection, i.e., the central meridian and the standard parallel. This method will, given aPrefix, store the properties of this projection into the aPropertiesSFCT object. The values of following keys are stored:
• <aPrefix>.centralMeridian
• <aPrefix>.standardParallel
Specified by:
`writePropertiesSFCT` in interface `ILcdProjection`
Overrides:
`writePropertiesSFCT` in class `ALcdCylindrical`
Parameters:
`aPrefix` - prefix for the property names.
`aPropertySFCT` - Properties object to store the serialized properties by side effect.
• #### equals

`public boolean equals(java.lang.Object o)`
Description copied from interface: `ILcdProjection`
Checks if this `ILcdProjection` equals some other Object.
Specified by:
`equals` in interface `ILcdProjection`
Overrides:
`equals` in class `ALcdCylindrical`
Parameters:
`o` - Object to compare with.
Returns:
true if the Object is an instance of the same `ILcdProjection` class and having the same projection properties, false otherwise.
• #### hashCode

`public int hashCode()`
Overrides:
`hashCode` in class `ALcdCylindrical`
• #### toString

`public java.lang.String toString()`
Description copied from interface: `ILcdProjection`
String representation of this `ILcdProjection`.
Specified by:
`toString` in interface `ILcdProjection`
Overrides:
`toString` in class `java.lang.Object`
Returns:
String representation of this `ILcdProjection`.
• #### clone

`public java.lang.Object clone()`
Description copied from interface: `ILcdProjection`
Makes a deep clone of this `ILcdProjection`.
Specified by:
`clone` in interface `ILcdProjection`
Overrides:
`clone` in class `ALcdCylindrical`
Returns:
deep clone of this `ILcdProjection`.