#include <ossimEquDistCylProjection.h>

Inheritance diagram for ossimEquDistCylProjection:

Public Member Functions
	ossimEquDistCylProjection (const ossimEllipsoid &ellipsoid=ossimEllipsoid(), const ossimGpt &origin=ossimGpt())

	ossimEquDistCylProjection (const ossimEllipsoid &ellipsoid, const ossimGpt &origin, double falseEasting, double falseNorthing)

	ossimEquDistCylProjection (const ossimEquDistCylProjection &rhs)

	~ossimEquDistCylProjection ()

virtual ossimObject *	dup () const

virtual ossimGpt	inverse (const ossimDpt &eastingNorthing) const
	Will take a point in meters and convert it to ground. More...

virtual ossimDpt	forward (const ossimGpt &latLon) const
	All map projections will convert the world coordinate to an easting northing (Meters). More...

virtual void	update ()

virtual void	setOrigin (const ossimGpt &origin)

void	setFalseEasting (double falseEasting)

void	setFalseNorthing (double falseNorthing)

void	setFalseEastingNorthing (double falseEasting, double falseNorthing)

double	getFalseEasting () const

double	getFalseNorthing () const

virtual void	lineSampleHeightToWorld (const ossimDpt &lineSampPt, const double &heightAboveEllipsoid, ossimGpt &worldPt) const
	This is the pure virtual that projects the image point to the given elevation above ellipsoid, thereby bypassing reference to a DEM. More...

virtual void	worldToLineSample (const ossimGpt &worldPoint, ossimDpt &lineSample) const

void	worldToLineSample (const ossimGpt &worldPoint, const ossimIpt &imageSize, ossimDpt &lineSample) const
	Specialized worldToLineSample. More...

virtual bool	isGeographic () const

void	setDefaults ()

virtual bool	saveState (ossimKeywordlist &kwl, const char *prefix=0) const

virtual bool	loadState (const ossimKeywordlist &kwl, const char *prefix=0)

Public Member Functions inherited from ossimMapProjection
	ossimMapProjection (const ossimEllipsoid &ellipsoid=ossimEllipsoid(), const ossimGpt &origin=ossimGpt())

	ossimMapProjection (const ossimMapProjection &src)

virtual ossimGpt	origin () const

virtual ossimDpt	worldToLineSample (const ossimGpt &worldPoint) const

virtual ossimGpt	lineSampleToWorld (const ossimDpt &projectedPoint) const

virtual void	lineSampleToWorld (const ossimDpt &projectedPoint, ossimGpt &gpt) const

virtual void	lineSampleToEastingNorthing (const ossimDpt &liineSample, ossimDpt &eastingNorthing) const

virtual void	eastingNorthingToLineSample (const ossimDpt &eastingNorthing, ossimDpt &lineSample) const

virtual void	eastingNorthingToWorld (const ossimDpt &eastingNorthing, ossimGpt &worldPt) const

virtual double	getStandardParallel1 () const
	Derived classes should implement as needed. More...

virtual double	getStandardParallel2 () const
	Derived classes should implement as needed. More...

virtual void	setPcsCode (ossim_uint32 pcsCode)

virtual ossim_uint32	getPcsCode () const
	Returns the EPSG PCS code or 32767 if the projection is a custom (non-EPSG) projection. More...

virtual ossimString	getProjectionName () const
	Returns the projection name. More...

virtual double	getA () const
	ACCESS METHODS: More...

virtual double	getB () const

virtual double	getF () const

virtual ossimDpt	getMetersPerPixel () const

virtual const ossimDpt &	getDecimalDegreesPerPixel () const
	Returns decimal degrees per pixel as an ossimDpt with "x" representing longitude and "y" representing latitude. More...

virtual const ossimDpt &	getUlEastingNorthing () const

virtual const ossimGpt &	getUlGpt () const

virtual const ossimDatum *	getDatum () const

const ossimEllipsoid &	getEllipsoid () const

const ossimGpt &	getOrigin () const

virtual void	applyScale (const ossimDpt &scale, bool recenterTiePoint)
	Applies scale to theDeltaLonPerPixel, theDeltaLatPerPixel and theMetersPerPixel data members (eg: theDeltaLonPerPixel *= scale.x). More...

virtual void	setEllipsoid (const ossimEllipsoid &ellipsoid)
	SET METHODS: More...

virtual void	setAB (double a, double b)

virtual void	setDatum (const ossimDatum *datum)
	Sets theDatum to datum. More...

virtual void	setMetersPerPixel (const ossimDpt &gsd)

virtual void	setDecimalDegreesPerPixel (const ossimDpt &gsd)

virtual void	setUlTiePoints (const ossimGpt &gpt)

virtual void	setUlTiePoints (const ossimDpt &eastingNorthing)

virtual void	setUlEastingNorthing (const ossimDpt &ulEastingNorthing)

virtual void	setUlGpt (const ossimGpt &ulGpt)

virtual void	assign (const ossimProjection &aProjection)

virtual std::ostream &	print (std::ostream &out) const
	Prints data members to stream. More...

virtual bool	operator== (const ossimProjection &projection) const
	Compares this to arg projection and returns TRUE if the same. More...

virtual void	computeDegreesPerPixel ()
	Computes the approximate resolution in degrees/pixel. More...

virtual void	computeMetersPerPixel ()
	This will go from the ground point and give you an approximate meters per pixel. More...

void	setMatrix (double rotation, const ossimDpt &scale, const ossimDpt &translation)

void	setMatrixScale (const ossimDpt &scale)

void	setMatrixRotation (double rotation)

void	setMatrixTranslation (const ossimDpt &translation)

void	snapTiePointTo (ossim_float64 multiple, ossimUnitType unitType)
	Utility method to snap the tie point to some multiple. More...

void	snapTiePointToOrigin ()

void	setElevationLookupFlag (bool flag)

bool	getElevationLookupFlag () const

ossimUnitType	getModelTransformUnitType () const

void	setModelTransformUnitType (ossimUnitType unit)

bool	hasModelTransform () const

virtual bool	isAffectedByElevation () const
	Implementation of pure virtual ossimProjection::isAffectedByElevation method. More...

void	setProjectionUnits (ossimUnitType units)

ossimUnitType	getProjectionUnits () const
	OSSIM considers all map projection coordinates (including false eastings and northings) to be in meters. More...

virtual bool	isEqualTo (const ossimObject &obj, ossimCompareType compareType=OSSIM_COMPARE_FULL) const

Public Member Functions inherited from ossimProjection
	ossimProjection ()

virtual	~ossimProjection ()

virtual void	getRoundTripError (const ossimDpt &imagePoint, ossimDpt &errorResult) const

virtual void	getRoundTripError (const ossimGpt &groundPoint, ossimDpt &errorResult) const

virtual void	getGroundClipPoints (ossimGeoPolygon &gpts) const

virtual bool	operator!= (const ossimProjection &projection) const

Public Member Functions inherited from ossimObject
	ossimObject ()

virtual	~ossimObject ()

virtual ossimString	getShortName () const

virtual ossimString	getLongName () const

virtual ossimString	getDescription () const

virtual ossimString	getClassName () const

virtual RTTItypeid	getType () const

virtual bool	canCastTo (ossimObject *obj) const

virtual bool	canCastTo (const RTTItypeid &id) const

virtual bool	canCastTo (const ossimString &parentClassName) const

virtual void	accept (ossimVisitor &visitor)

Public Member Functions inherited from ossimReferenced
	ossimReferenced ()

	ossimReferenced (const ossimReferenced &)

ossimReferenced &	operator= (const ossimReferenced &)

void	ref () const
	increment the reference count by one, indicating that this object has another pointer which is referencing it. More...

void	unref () const
	decrement the reference count by one, indicating that a pointer to this object is referencing it. More...

void	unref_nodelete () const
	decrement the reference count by one, indicating that a pointer to this object is referencing it. More...

int	referenceCount () const

Public Member Functions inherited from ossimErrorStatusInterface
	ossimErrorStatusInterface ()

virtual	~ossimErrorStatusInterface ()

virtual ossimErrorCode	getErrorStatus () const

virtual ossimString	getErrorStatusString () const

virtual void	setErrorStatus (ossimErrorCode error_status) const

virtual void	setErrorStatus () const

virtual void	clearErrorStatus () const

bool	hasError () const

Private Member Functions
long	Set_Equidistant_Cyl_Parameters (double a, double f, double Std_Parallel, double Central_Meridian, double False_Easting, double False_Northing)

void	Get_Equidistant_Cyl_Parameters (double a, double f, double Std_Parallel, double Central_Meridian, double False_Easting, double False_Northing) const

long	Convert_Geodetic_To_Equidistant_Cyl (double Latitude, double Longitude, double Easting, double Northing) const

long	Convert_Equidistant_Cyl_To_Geodetic (double Easting, double Northing, double Latitude, double Longitude) const

Private Attributes
double	Eqcy_a

double	Eqcy_f

double	es2

double	es4

double	es6

double	Ra

double	Eqcy_Std_Parallel

double	Cos_Eqcy_Std_Parallel

double	Eqcy_Origin_Long

double	Eqcy_False_Easting

double	Eqcy_False_Northing

double	Eqcy_Delta_Northing

double	Eqcy_Max_Easting

double	Eqcy_Min_Easting

double	Ra_Cos_Eqcy_Std_Parallel

Additional Inherited Members
Protected Member Functions inherited from ossimMapProjection
virtual	~ossimMapProjection ()

void	updateFromTransform ()

Protected Member Functions inherited from ossimReferenced
virtual	~ossimReferenced ()

Protected Attributes inherited from ossimMapProjection
ossimEllipsoid	theEllipsoid
	This method verifies that the projection parameters match the current pcs code. More...

ossimGpt	theOrigin

const ossimDatum *	theDatum
	This is only set if we want to have built in datum shifting. More...

ossimDpt	theMetersPerPixel
	Holds the number of meters per pixel. More...

ossimDpt	theDegreesPerPixel
	Hold the decimal degrees per pixel. More...

ossimGpt	theUlGpt
	Hold tie point in decimal degrees. More...

ossimDpt	theUlEastingNorthing
	Hold tie point as easting northing. More...

ossimDpt	theFalseEastingNorthing
	Hold the false easting northing. More...

ossim_uint32	thePcsCode
	Projection Coordinate System(PCS) code. More...

bool	theElevationLookupFlag

ossimMatrix4x4	theModelTransform

ossimMatrix4x4	theInverseModelTransform

ossimUnitType	theModelTransformUnitType

ossimUnitType	theProjectionUnits
	Linear units of the projection as indicated in the projection's specification: More...

Protected Attributes inherited from ossimErrorStatusInterface
ossimErrorCode	theErrorStatus

Detailed Description

Definition at line 20 of file ossimEquDistCylProjection.h.

Constructor & Destructor Documentation

◆ ossimEquDistCylProjection() [1/3]

ossimEquDistCylProjection::ossimEquDistCylProjection	(	const ossimEllipsoid &	ellipsoid = `ossimEllipsoid()`,
		const ossimGpt &	origin = `ossimGpt()`
	)

Definition at line 56 of file ossimEquDistCylProjection.cpp.

References setDefaults(), and update().

   :ossimMapProjection(ellipsoid, origin)
 {
    setDefaults();
    update();
 }

◆ ossimEquDistCylProjection() [2/3]

ossimEquDistCylProjection::ossimEquDistCylProjection	(	const ossimEllipsoid &	ellipsoid,
		const ossimGpt &	origin,
		double	falseEasting,
		double	falseNorthing
	)

Definition at line 65 of file ossimEquDistCylProjection.cpp.

References Eqcy_Delta_Northing, Eqcy_False_Easting, Eqcy_False_Northing, Eqcy_Max_Easting, Eqcy_Min_Easting, and update().

   :ossimMapProjection(ellipsoid, origin)
 {
    Eqcy_False_Easting  = falseEasting;
    Eqcy_False_Northing = falseNorthing;
 
    Eqcy_Delta_Northing = 10007555.0;
    Eqcy_Max_Easting    = 20015110.0;
    Eqcy_Min_Easting    = -20015110.0;
    
    update();
 }

◆ ossimEquDistCylProjection() [3/3]

ossimEquDistCylProjection::ossimEquDistCylProjection ( const ossimEquDistCylProjection & rhs )

inline

Definition at line 30 of file ossimEquDistCylProjection.h.

      :ossimMapProjection(rhs)
      //      :ossimLlxyProjection(rhs)
       {
          *this = rhs;
       }

◆ ~ossimEquDistCylProjection()

ossimEquDistCylProjection::~ossimEquDistCylProjection ( )

inline

Definition at line 37 of file ossimEquDistCylProjection.h.

37 {}

Member Function Documentation

◆ Convert_Equidistant_Cyl_To_Geodetic()

long ossimEquDistCylProjection::Convert_Equidistant_Cyl_To_Geodetic	(	double	Easting,
		double	Northing,
		double *	Latitude,
		double *	Longitude
	)		const

private

The function Convert_Equidistant_Cyl_To_Geodetic converts Equidistant Cylindrical projection easting and northing coordinates to geodetic (latitude and longitude) coordinates, according to the current ellipsoid and Equidistant Cylindrical projection coordinates. If any errors occur, the error code(s) are returned by the function, otherwise EQCY_NO_ERROR is returned.

Easting : Easting (X) in meters (input) Northing : Northing (Y) in meters (input) Latitude : Latitude (phi) in radians (output) Longitude : Longitude (lambda) in radians (output)

Definition at line 624 of file ossimEquDistCylProjection.cpp.

References Eqcy_False_Easting, Eqcy_False_Northing, EQCY_NO_ERROR, Eqcy_Origin_Long, Ra, and Ra_Cos_Eqcy_Std_Parallel.

Referenced by inverse().

 { /* Begin Convert_Equidistant_Cyl_To_Geodetic */
 /*
  * The function Convert_Equidistant_Cyl_To_Geodetic converts Equidistant Cylindrical projection
  * (easting and northing) coordinates to geodetic (latitude and longitude)
  * coordinates, according to the current ellipsoid, spherical radius
  * and Equidistant Cylindrical projection coordinates.
  * If any errors occur, the error code(s) are returned by the
  * function, otherwise EQCY_NO_ERROR is returned.
  *
  *    Easting           : Easting (X) in meters                  (input)
  *    Northing          : Northing (Y) in meters                 (input)
  *    Latitude          : Latitude (phi) in radians              (output)
  *    Longitude         : Longitude (lambda) in radians          (output)
  */
 
   double dx, dy;
   long Error_Code = EQCY_NO_ERROR;
 
 //   if ((Easting < (Eqcy_False_Easting + Eqcy_Min_Easting))
 //       || (Easting > (Eqcy_False_Easting + Eqcy_Max_Easting)))
 //   { /* Easting out of range */
 //     Error_Code |= EQCY_EASTING_ERROR;
 //   }
 //   if ((Northing < (Eqcy_False_Northing - Eqcy_Delta_Northing))
 //       || (Northing > (Eqcy_False_Northing + Eqcy_Delta_Northing)))
 //   { /* Northing out of range */
 //     Error_Code |= EQCY_NORTHING_ERROR;
 //   }
 
   if (!Error_Code)
   {
     dy = Northing - Eqcy_False_Northing;
     dx = Easting - Eqcy_False_Easting;
     *Latitude = dy / Ra;
 
     if (Ra_Cos_Eqcy_Std_Parallel == 0)
       *Longitude = 0;
     else
       *Longitude = Eqcy_Origin_Long + dx / Ra_Cos_Eqcy_Std_Parallel;
 
 //     if (*Latitude > PI_OVER_2)  /* force distorted values to 90, -90 degrees */
 //       *Latitude = PI_OVER_2;
 //     else if (*Latitude < -PI_OVER_2)
 //       *Latitude = -PI_OVER_2;
 
 //    if (*Longitude > PI)
 //      *Longitude -= TWO_PI;
 //    if (*Longitude < -PI)
 //      *Longitude += TWO_PI;
 
 //    if (*Longitude > PI)  /* force distorted values to 180, -180 degrees */
 //      *Longitude = PI;
 //    else if (*Longitude < -PI)
 //      *Longitude = -PI;
 
   }
   return (Error_Code);
 
 } /* End Convert_Equidistant_Cyl_To_Geodetic */

◆ Convert_Geodetic_To_Equidistant_Cyl()

long ossimEquDistCylProjection::Convert_Geodetic_To_Equidistant_Cyl	(	double	Latitude,
		double	Longitude,
		double *	Easting,
		double *	Northing
	)		const

private

The function Convert_Geodetic_To_Equidistant_Cyl converts geodetic (latitude and longitude) coordinates to Equidistant Cylindrical projection easting, and northing coordinates, according to the current ellipsoid and Equidistant Cylindrical projection parameters. If any errors occur, the error code(s) are returned by the function, otherwise EQCY_NO_ERROR is returned.

Latitude : Latitude (phi) in radians (input) Longitude : Longitude (lambda) in radians (input) Easting : Easting (X) in meters (output) Northing : Northing (Y) in meters (output)

Definition at line 571 of file ossimEquDistCylProjection.cpp.

References Eqcy_False_Easting, Eqcy_False_Northing, EQCY_NO_ERROR, Eqcy_Origin_Long, Ra, and Ra_Cos_Eqcy_Std_Parallel.

Referenced by forward(), and Set_Equidistant_Cyl_Parameters().

 { /* Begin Convert_Geodetic_To_Equidistant_Cyl */
 /*
  * The function Convert_Geodetic_To_Equidistant_Cyl converts geodetic (latitude and
  * longitude) coordinates to Equidistant Cylindrical projection (easting and northing)
  * coordinates, according to the current ellipsoid, spherical radiius
  * and Equidistant Cylindrical projection parameters.
  * If any errors occur, the error code(s) are returned by the
  * function, otherwise EQCY_NO_ERROR is returned.
  *
  *    Latitude          : Latitude (phi) in radians           (input)
  *    Longitude         : Longitude (lambda) in radians       (input)
  *    Easting           : Easting (X) in meters               (output)
  *    Northing          : Northing (Y) in meters              (output)
  */
 
   double dlam;     /* Longitude - Central Meridan */
   long Error_Code = EQCY_NO_ERROR;
 
 //   if ((Latitude < -PI_OVER_2) || (Latitude > PI_OVER_2))
 //   {  /* Latitude out of range */
 //     Error_Code |= EQCY_LAT_ERROR;
 //   }
 //   if ((Longitude < -M_PI) || (Longitude > TWO_PI))
 //   {  /* Longitude out of range */
 //     Error_Code|= EQCY_LON_ERROR;
 //   }
 
   if (!Error_Code)
   { /* no errors */
     dlam = Longitude - Eqcy_Origin_Long;
     //if (dlam >= TWO_PI)
     //{
     //  dlam -= TWO_PI;
    // }
    // if (dlam <= -TWO_PI)
    // {
    //   dlam += TWO_PI;
    // }
 
     *Easting = Ra_Cos_Eqcy_Std_Parallel * dlam + Eqcy_False_Easting;
     *Northing = Ra * Latitude + Eqcy_False_Northing;
 
   }
   return (Error_Code);
 
 } /* End Convert_Geodetic_To_Equidistant_Cyl */

◆ dup()

virtual ossimObject* ossimEquDistCylProjection::dup ( ) const

inlinevirtual

Implements ossimProjection.

Definition at line 38 of file ossimEquDistCylProjection.h.

       {
          return new ossimEquDistCylProjection(*this);
       }

◆ forward()

ossimDpt ossimEquDistCylProjection::forward ( const ossimGpt & worldPoint ) const

virtual

All map projections will convert the world coordinate to an easting northing (Meters).

Implements ossimMapProjection.

Definition at line 376 of file ossimEquDistCylProjection.cpp.

References ossimGpt::changeDatum(), ossimDatum::code(), Convert_Geodetic_To_Equidistant_Cyl(), ossimGpt::datum(), ossimGpt::latr(), ossimGpt::lonr(), and ossimMapProjection::theDatum.

Referenced by worldToLineSample().

 {
    double easting  = 0.0;
    double northing = 0.0;
    ossimGpt gpt = latLon;
    
    if (theDatum)
    {
       if (theDatum->code() != latLon.datum()->code())
       {
          gpt.changeDatum(theDatum); // Shift to our datum.
       }
    }
 
    Convert_Geodetic_To_Equidistant_Cyl(gpt.latr(),
                                        gpt.lonr(),
                                        &easting,
                                        &northing);
    
    return ossimDpt(easting, northing);
 }

◆ Get_Equidistant_Cyl_Parameters()

void ossimEquDistCylProjection::Get_Equidistant_Cyl_Parameters	(	double *	a,
		double *	f,
		double *	Std_Parallel,
		double *	Central_Meridian,
		double *	False_Easting,
		double *	False_Northing
	)		const

private

The function Get_Equidistant_Cyl_Parameters returns the current ellipsoid parameters and Equidistant Cylindrical projection parameters.

a : Semi-major axis of ellipsoid, in meters (output) f : Flattening of ellipsoid (output) Std_Parallel : Latitude in radians at which the (output) point scale factor is 1.0 Central_Meridian : Longitude in radians at the center of (output) the projection False_Easting : A coordinate value in meters assigned to the central meridian of the projection. (output) False_Northing : A coordinate value in meters assigned to the standard parallel of the projection (output)

Definition at line 538 of file ossimEquDistCylProjection.cpp.

References Eqcy_a, Eqcy_f, Eqcy_False_Easting, Eqcy_False_Northing, Eqcy_Origin_Long, and Eqcy_Std_Parallel.

 { /* Begin Get_Equidistant_Cyl_Parameters */
 /*
  * The function Get_Equidistant_Cyl_Parameters returns the current ellipsoid
  * parameters and Equidistant Cylindrical projection parameters.
  *
  *    a                 : Semi-major axis of ellipsoid, in meters   (output)
  *    f                 : Flattening of ellipsoid                               (output)
  *    Std_Parallel      : Latitude in radians at which the          (output)
  *                          point scale factor is 1.0
  *    Central_Meridian  : Longitude in radians at the center of     (output)
  *                          the projection
  *    False_Easting     : A coordinate value in meters assigned to the
  *                          central meridian of the projection.     (output)
  *    False_Northing    : A coordinate value in meters assigned to the
  *                          standard parallel of the projection     (output)
  */
 
   *a = Eqcy_a;
   *f = Eqcy_f;
   *Std_Parallel = Eqcy_Std_Parallel;
   *Central_Meridian = Eqcy_Origin_Long;
   *False_Easting = Eqcy_False_Easting;
   *False_Northing = Eqcy_False_Northing;
   return;
 } /* End Get_Equidistant_Cyl_Parameters */

◆ getFalseEasting()

double ossimEquDistCylProjection::getFalseEasting ( ) const

inlinevirtual

Returns: The false easting.

Reimplemented from ossimMapProjection.

Definition at line 72 of file ossimEquDistCylProjection.h.

72 {return Eqcy_False_Easting;}

ossimEquDistCylProjection::Eqcy_False_Easting

double Eqcy_False_Easting

Definition: ossimEquDistCylProjection.h:129

◆ getFalseNorthing()

double ossimEquDistCylProjection::getFalseNorthing ( ) const

inlinevirtual

Returns: The false northing.

Reimplemented from ossimMapProjection.

Definition at line 73 of file ossimEquDistCylProjection.h.

73 {return Eqcy_False_Northing;}

ossimEquDistCylProjection::Eqcy_False_Northing

double Eqcy_False_Northing

Definition: ossimEquDistCylProjection.h:130

◆ inverse()

ossimGpt ossimEquDistCylProjection::inverse ( const ossimDpt & projectedPoint ) const

virtual

Will take a point in meters and convert it to ground.

Implements ossimMapProjection.

Definition at line 363 of file ossimEquDistCylProjection.cpp.

References Convert_Equidistant_Cyl_To_Geodetic(), DEG_PER_RAD, ossimMapProjection::theDatum, ossimDpt::x, and ossimDpt::y.

Referenced by lineSampleHeightToWorld().

 {
    double lat = 0.0;
    double lon = 0.0;
 
    Convert_Equidistant_Cyl_To_Geodetic(eastingNorthing.x,
                                        eastingNorthing.y,
                                        &lat,
                                        &lon);
 
    return ossimGpt(lat*DEG_PER_RAD, lon*DEG_PER_RAD, 0.0, theDatum);
 }

◆ isGeographic()

virtual bool ossimEquDistCylProjection::isGeographic ( ) const

inlinevirtual

Reimplemented from ossimMapProjection.

Definition at line 96 of file ossimEquDistCylProjection.h.

    {
       return true;
    }

◆ lineSampleHeightToWorld()

void ossimEquDistCylProjection::lineSampleHeightToWorld	(	const ossimDpt &	lineSampPt,
		const double &	heightAboveEllipsoid,
		ossimGpt &	worldPt
	)		const

virtual

This is the pure virtual that projects the image point to the given elevation above ellipsoid, thereby bypassing reference to a DEM.

Useful for projections that are sensitive to elevation.

Reimplemented from ossimMapProjection.

Definition at line 152 of file ossimEquDistCylProjection.cpp.

References ossimGpt::datum(), ossimElevManager::getHeightAboveEllipsoid(), ossimDpt::hasNans(), ossimGpt::hgt, ossimElevManager::instance(), inverse(), ossimGpt::isLatNan(), ossimGpt::isLonNan(), ossimMapProjection::lineSampleHeightToWorld(), ossimGpt::makeNan(), OSSIM_UNIT_UNKNOWN, ossimMapProjection::theDatum, ossimMapProjection::theElevationLookupFlag, ossimMapProjection::theMetersPerPixel, ossimMapProjection::theModelTransformUnitType, ossimMapProjection::theUlEastingNorthing, ossimDpt::x, and ossimDpt::y.

 {
    //
    // make sure that the passed in lineSample is good and
    // check to make sure our easting northing is good so
    // we can compute the line sample.
    //
    //
    if(lineSample.hasNans())
    {
       gpt.makeNan();
       return;
    }
    if(theModelTransformUnitType != OSSIM_UNIT_UNKNOWN)
    {
       ossimMapProjection::lineSampleHeightToWorld(lineSample, hgtEllipsoid, gpt);
       return;
    }
    else
    {
       if(theUlEastingNorthing.hasNans())
       {
          gpt.makeNan();
          return;
       }
       ossimDpt eastingNorthing;
       
       eastingNorthing = (theUlEastingNorthing);
       
       eastingNorthing.x += (lineSample.x*theMetersPerPixel.x);
       
       //
       // Note:  the Northing is positive up.  In image space
       // the positive axis is down so we must multiply by
       // -1
       //
       eastingNorthing.y += (-lineSample.y*theMetersPerPixel.y);
       
       //
       // now invert the meters into a ground point.
       //
       gpt = inverse(eastingNorthing);
       gpt.datum(theDatum);
       
       if(gpt.isLatNan() && gpt.isLonNan())
       {
          gpt.makeNan();
       }
       else
       {
          // Finally assign the specified height:
          gpt.hgt = hgtEllipsoid;
       }
    }
    if(theElevationLookupFlag)
    {
       gpt.hgt = ossimElevManager::instance()->getHeightAboveEllipsoid(gpt);
    }
 }

◆ loadState()

bool ossimEquDistCylProjection::loadState	(	const ossimKeywordlist &	kwl,
		const char *	prefix = `0`
	)

virtual

Method to the load (recreate) the state of an object from a keyword list. Return true if ok or false on error.

Reimplemented from ossimMapProjection.

Definition at line 405 of file ossimEquDistCylProjection.cpp.

 {
    if (traceDebug())
    {
       ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimEquDistCylProjection::loadState: Input keyword list is \n" << kwl << endl;
    }
 
    //   ossimLlxyProjection::loadState(kwl, prefix);
    ossimMapProjection::loadState(kwl, prefix);
    theProjectionUnits = OSSIM_DEGREES;
 
    // Make sure the origin.lat is defined since it is needed to relate degrees/meter:
    if (ossim::isnan(theOrigin.lat))
    {
       theOrigin.lat = theUlGpt.lat;
       if (ossim::isnan(theOrigin.lat))
          theOrigin.lat = 0.0;
    }
 
    // Make sure degrees per pixel is defined:
    if (theDegreesPerPixel.hasNans() && !theMetersPerPixel.hasNans())
       computeDegreesPerPixel();
 
    const char* type = kwl.find(prefix, ossimKeywordNames::TYPE_KW);
 
    setDefaults();
    // make sure we are of the same type.  If we are then the easting
    // northing values will make since
    //
    if(ossimString(type) == STATIC_TYPE_NAME(ossimEquDistCylProjection))
    {
       Eqcy_False_Easting  = theFalseEastingNorthing.x;
       Eqcy_False_Northing = theFalseEastingNorthing.y;
    }
    else
    {
       theUlEastingNorthing.makeNan();
    }
    // finalize the initialization.
    update();
             
    return true;
 }

◆ saveState()

bool ossimEquDistCylProjection::saveState	(	ossimKeywordlist &	kwl,
		const char *	prefix = `0`
	)		const

virtual

Method to save the state of an object to a keyword list. Return true if ok or false on error.

Reimplemented from ossimMapProjection.

Definition at line 400 of file ossimEquDistCylProjection.cpp.

References ossimMapProjection::saveState().

 {
    return ossimMapProjection::saveState(kwl, prefix);
 }

◆ Set_Equidistant_Cyl_Parameters()

long ossimEquDistCylProjection::Set_Equidistant_Cyl_Parameters	(	double	a,
		double	f,
		double	Std_Parallel,
		double	Central_Meridian,
		double	False_Easting,
		double	False_Northing
	)

private

The function Set_Equidistant_Cyl_Parameters receives the ellipsoid parameters and projection parameters as inputs, and sets the corresponding state variables. It also calculates the spherical radius of the sphere having the same area as the ellipsoid. If any errors occur, the error code(s) are returned by the function, otherwise EQCY_NO_ERROR is returned.

a : Semi-major axis of ellipsoid, in meters (input) f : Flattening of ellipsoid (input) Std_Parallel : Latitude in radians at which the (input) point scale factor is 1.0 Central_Meridian : Longitude in radians at the center of (input) the projection False_Easting : A coordinate value in meters assigned to the central meridian of the projection. (input) False_Northing : A coordinate value in meters assigned to the standard parallel of the projection (input)

Definition at line 455 of file ossimEquDistCylProjection.cpp.

References Convert_Geodetic_To_Equidistant_Cyl(), Cos_Eqcy_Std_Parallel, Eqcy_a, Eqcy_f, Eqcy_False_Easting, Eqcy_False_Northing, Eqcy_Max_Easting, Eqcy_Min_Easting, EQCY_NO_ERROR, Eqcy_Origin_Long, Eqcy_Std_Parallel, es2, es4, es6, M_PI, ONE, PI_OVER_2, Ra, and Ra_Cos_Eqcy_Std_Parallel.

Referenced by update().

 { /* Begin Set_Equidistant_Cyl_Parameters */
 /*
  * The function Set_Equidistant_Cyl_Parameters receives the ellipsoid parameters and
  * projection parameters as inputs, and sets the corresponding state
  * variables.  It also calculates the spherical radius of the sphere having 
  * the same area as the ellipsoid.  If any errors occur, the error code(s) 
  * are returned by the function, otherwise EQCY_NO_ERROR is returned.
  *
  *    a                 : Semi-major axis of ellipsoid, in meters   (input)
  *    f                 : Flattening of ellipsoid                               (input)
  *    Std_Parallel      : Latitude in radians at which the          (input)
  *                          point scale factor is 1.0
  *    Central_Meridian  : Longitude in radians at the center of     (input)
  *                          the projection
  *    False_Easting     : A coordinate value in meters assigned to the
  *                          central meridian of the projection.     (input)
  *    False_Northing    : A coordinate value in meters assigned to the
  *                          standard parallel of the projection     (input)
  */
 
   double temp;
 //  double inv_f = 1 / f;
   long Error_Code = EQCY_NO_ERROR;
 
 //   if (a <= 0.0)
 //   { /* Semi-major axis must be greater than zero */
 //     Error_Code |= EQCY_A_ERROR;
 //   }
 //   if ((inv_f < 250) || (inv_f > 350))
 //   { /* Inverse flattening must be between 250 and 350 */
 //     Error_Code |= EQCY_INV_F_ERROR;
 //   }
 //   if ((Std_Parallel < -PI_OVER_2) || (Std_Parallel > PI_OVER_2))
 //   { /* standard parallel out of range */
 //     Error_Code |= EQCY_STDP_ERROR;
 //   }
 //   if ((Central_Meridian < -PI) || (Central_Meridian > TWO_PI))
 //   { /* origin longitude out of range */
 //     Error_Code |= EQCY_CENT_MER_ERROR;
 //   }
   if (!Error_Code)
   { /* no errors */
     Eqcy_a = a;
     Eqcy_f = f;
     es2 = 2 * Eqcy_f - Eqcy_f * Eqcy_f;
     es4 = es2 * es2;
     es6 = es4 * es2;
     /* spherical radius */
     Ra = Eqcy_a * (1.0 - es2 / 6.0 - 17.0 * es4 / 360.0 - 67.0 * es6 /3024.0);
     Eqcy_Std_Parallel = Std_Parallel;
     Cos_Eqcy_Std_Parallel = cos(Eqcy_Std_Parallel);
     Ra_Cos_Eqcy_Std_Parallel = Ra * Cos_Eqcy_Std_Parallel;
 //    if (Central_Meridian > M_PI)
 //      Central_Meridian -= TWO_PI;
     Eqcy_Origin_Long = Central_Meridian;
     Eqcy_False_Easting = False_Easting;
     Eqcy_False_Northing = False_Northing;
     if (Eqcy_Origin_Long > 0)
     {
       Convert_Geodetic_To_Equidistant_Cyl(PI_OVER_2, Eqcy_Origin_Long - M_PI - ONE, &Eqcy_Max_Easting, &temp);
       Convert_Geodetic_To_Equidistant_Cyl(PI_OVER_2, Eqcy_Origin_Long - M_PI, &Eqcy_Min_Easting, &temp);
     }
     else if (Eqcy_Origin_Long < 0)
     {
       Convert_Geodetic_To_Equidistant_Cyl(PI_OVER_2, Eqcy_Origin_Long + M_PI, &Eqcy_Max_Easting, &temp);
       Convert_Geodetic_To_Equidistant_Cyl(PI_OVER_2, Eqcy_Origin_Long + M_PI + ONE, &Eqcy_Min_Easting, &temp);
     }
     else
     {
       Convert_Geodetic_To_Equidistant_Cyl(PI_OVER_2, M_PI, &Eqcy_Max_Easting, &temp);
       Eqcy_Min_Easting = -Eqcy_Max_Easting;
     }
   } /* End if(!Error_Code) */
   return (Error_Code);
 } /* End Set_Equidistant_Cyl_Parameters */

◆ setDefaults()

void ossimEquDistCylProjection::setDefaults ( )

Definition at line 142 of file ossimEquDistCylProjection.cpp.

References Eqcy_Delta_Northing, Eqcy_False_Easting, Eqcy_False_Northing, Eqcy_Max_Easting, Eqcy_Min_Easting, OSSIM_DEGREES, and ossimMapProjection::theProjectionUnits.

Referenced by ossimEquDistCylProjection().

 {
    theProjectionUnits = OSSIM_DEGREES;
    Eqcy_False_Easting  = 0.0;
    Eqcy_False_Northing = 0.0;
    Eqcy_Delta_Northing = 10007555.0;
    Eqcy_Max_Easting    = 20015110.0;
    Eqcy_Min_Easting    = -20015110.0;
 }

◆ setFalseEasting()

void ossimEquDistCylProjection::setFalseEasting ( double falseEasting )

SetFalseEasting. The value is in meters. Update is then called so we can pre-compute paramters

Definition at line 121 of file ossimEquDistCylProjection.cpp.

References Eqcy_False_Easting, and update().

 {
    Eqcy_False_Easting = falseEasting;
    update();
 }

◆ setFalseEastingNorthing()

void ossimEquDistCylProjection::setFalseEastingNorthing	(	double	falseEasting,
		double	falseNorthing
	)

Sets both false easting and northing values. The values are expected to be in meters. Update is then called so we can pre-compute paramters

Definition at line 133 of file ossimEquDistCylProjection.cpp.

References Eqcy_False_Easting, Eqcy_False_Northing, and update().

 {
    Eqcy_False_Easting  = falseEasting;
    Eqcy_False_Northing = falseNorthing;
    
    update();
 }

◆ setFalseNorthing()

void ossimEquDistCylProjection::setFalseNorthing ( double falseNorthing )

SetFalseNorthing. The value is in meters. Update is then called so we can pre-compute paramters

Definition at line 127 of file ossimEquDistCylProjection.cpp.

References Eqcy_False_Northing, and update().

 {
    Eqcy_False_Northing = falseNorthing;
    update();
 }

◆ setOrigin()

void ossimEquDistCylProjection::setOrigin ( const ossimGpt & origin )

virtual

This method needs to be overridden here because of bug that causes bad projections if the origin is set without reseting the tiepoint. (OLK Jun2015)

Reimplemented from ossimMapProjection.

Definition at line 109 of file ossimEquDistCylProjection.cpp.

References ossimMapProjection::getMetersPerPixel(), ossimMapProjection::origin(), ossimMapProjection::setMetersPerPixel(), ossimMapProjection::setOrigin(), ossimMapProjection::setUlTiePoints(), ossimMapProjection::theUlGpt, ossimDpt::x, and ossimDpt::y.

Referenced by ossimGdalOgrVectorAnnotation::computeDefaultView(), ossimKmlSuperOverlayReader::createDefaultProj(), ossimOgrVectorTileSource::createDefaultProj(), ossimEpsgProjectionFactory::createProjFromAutoCode(), ossimDtedTileSource::getImageGeometry(), and ossimNitfProjectionFactory::makeEuiDistant().

 {
    ossimMapProjection::setOrigin(origin); // breaks the projection
    setUlTiePoints(theUlGpt); // needed to reset easting northing
 
    // Changing the projection origin from the equator implies a scale change in the longitude
    // direction to maintain GSD (meters) square at origin:
    ossimDpt gsd = getMetersPerPixel();
    gsd.x = gsd.y; // reset X (longitude) direction GSD
    setMetersPerPixel(gsd);
 }

◆ update()

void ossimEquDistCylProjection::update ( )

virtual

Reimplemented from ossimMapProjection.

Definition at line 82 of file ossimEquDistCylProjection.cpp.

References ossimDatum::epsgCode(), Eqcy_False_Easting, Eqcy_False_Northing, ossimEllipsoid::getA(), ossimEllipsoid::getFlattening(), ossimGpt::latr(), ossimGpt::lonr(), ossimDpt::makeNan(), Set_Equidistant_Cyl_Parameters(), ossimMapProjection::theDatum, ossimMapProjection::theEllipsoid, ossimMapProjection::theFalseEastingNorthing, ossimMapProjection::theMetersPerPixel, ossimMapProjection::theOrigin, ossimMapProjection::thePcsCode, ossimMapProjection::update(), ossimDpt::x, and ossimDpt::y.

Referenced by ossimEpsgProjectionFactory::createProjFromAutoCode(), ossimEquDistCylProjection(), setFalseEasting(), setFalseEastingNorthing(), and setFalseNorthing().

 {
    Set_Equidistant_Cyl_Parameters(theEllipsoid.getA(),
                                   theEllipsoid.getFlattening(),
                                   theOrigin.latr(),
                                   theOrigin.lonr(),
                                   Eqcy_False_Easting,
                                   Eqcy_False_Northing);
 
    theFalseEastingNorthing.x = Eqcy_False_Easting;
    theFalseEastingNorthing.y = Eqcy_False_Northing;
 
    theMetersPerPixel.makeNan(); // force recompute by base class
 
    ossimMapProjection::update();
 
    // For geographic projection, the PCS EPSG code can be derived from the datum in most cases:
    if ((thePcsCode == 0) && (theDatum != NULL))
    {
       ossim_uint32 datum_code = theDatum->epsgCode();
       if ((datum_code >= 6000) && (datum_code < 7000))
          thePcsCode = datum_code - 2000;
    }
 
    // Workaround for bug
 }

◆ worldToLineSample() [1/2]

void ossimEquDistCylProjection::worldToLineSample	(	const ossimGpt &	worldPoint,
		ossimDpt &	lineSampPt
	)		const

virtual

METHOD: worldToLineSample() Performs the forward projection from ground point to line, sample.

Reimplemented from ossimMapProjection.

Definition at line 214 of file ossimEquDistCylProjection.cpp.

References ossimGpt::changeDatum(), forward(), ossimGpt::isLatNan(), ossimGpt::isLonNan(), ossimDpt::isNan(), ossimDpt::makeNan(), OSSIM_UNIT_UNKNOWN, ossimMapProjection::theDatum, ossimMapProjection::theMetersPerPixel, ossimMapProjection::theModelTransformUnitType, ossimMapProjection::theUlEastingNorthing, ossimMapProjection::worldToLineSample(), ossimDpt::x, and ossimDpt::y.

 {
    if(theModelTransformUnitType != OSSIM_UNIT_UNKNOWN)
    {
       ossimMapProjection::worldToLineSample(worldPoint, lineSample);
       return;
    }
    
    // make sure our tie point is good and world point is good.
    if(theUlEastingNorthing.isNan() || worldPoint.isLatNan() || worldPoint.isLonNan())
    {
       lineSample.makeNan();
       return;
    }
 
    // see if we have a datum set and if so shift the world to our datum.  If not then
    // find the easting northing value for the world point.
    ossimDpt gptEastingNorthing;
    if(theDatum)
    {
       ossimGpt gpt = worldPoint;
       gpt.changeDatum(theDatum);
       gptEastingNorthing = forward(gpt);
    }
    else
    {
       gptEastingNorthing = forward(worldPoint);
    }
 
    // check the final result to make sure there were no problems.
    if(!gptEastingNorthing.isNan())
    {
       lineSample.x = ((gptEastingNorthing.x  - theUlEastingNorthing.x)/theMetersPerPixel.x);
 
       // We must remember that the Northing is negative since the positive
       // axis for an image is assumed to go down since it's image space.
       lineSample.y = (-(gptEastingNorthing.y - theUlEastingNorthing.y)/theMetersPerPixel.y);
    }
 }

◆ worldToLineSample() [2/2]

void ossimEquDistCylProjection::worldToLineSample	(	const ossimGpt &	worldPoint,
		const ossimIpt &	imageSize,
		ossimDpt &	lineSample
	)		const

Specialized worldToLineSample.

Takes into consideration the image size and crossing the date line. Also makes local points outside of image negative or positive based on there relative closeness to left or right edge.

Parameters

worldPoint	Ground point to convert to line sample.
imageSize	Size of image in pixels.
lineSample	Initialized by this.

Definition at line 255 of file ossimEquDistCylProjection.cpp.

References ossimGpt::changeDatum(), forward(), ossimGpt::isLatNan(), ossimGpt::isLonNan(), ossimIpt::isNan(), ossimDpt::isNan(), ossimGpt::lat, ossimGpt::lon, ossimDpt::makeNan(), OSSIM_UNIT_UNKNOWN, ossimMapProjection::theDatum, ossimMapProjection::theMetersPerPixel, ossimMapProjection::theModelTransformUnitType, ossimMapProjection::theUlEastingNorthing, ossimMapProjection::worldToLineSample(), ossimIpt::x, ossimDpt::x, and ossimDpt::y.

 {
    if( theModelTransformUnitType == OSSIM_UNIT_UNKNOWN )
    {
       // Make sure our points are good.
       if( !theUlEastingNorthing.isNan() && !worldPoint.isLatNan() && !worldPoint.isLonNan() &&
           !imageSize.isNan() )
       {
          ossimGpt gpt = worldPoint;
 
          //---
          // See if we have a datum set and if so shift the world to our datum.  If not then
          // find the easting northing value for the world point.
          if(theDatum)
          {
             gpt.changeDatum(theDatum);
          }
 
          // Convert to easting northing.
          ossimDpt gptEastingNorthing = forward(gpt);
         
          if( !gptEastingNorthing.isNan() )
          {
 #if 0            
             if ( imageSize.x > 0.0 )
             {
                ossimGpt edge(gpt.lat, -180.0, 0.0);
                ossimDpt leftProjectionEdge = forward(edge);
                
                edge.lon = 180;
                ossimDpt rightProjectionEdge = forward(edge);
 
                // Right edge Easting of image from tie.
                ossim_float64 leftImageX = theUlEastingNorthing.x  - (0.5*theMetersPerPixel.x);
                ossim_float64 rightImageX = leftImageX + (imageSize.x * theMetersPerPixel.x);
 
                if ( rightImageX < rightProjectionEdge.x ) // Image edge left of date line.
                {
                   // Image does not cross the date line.
                   lineSample.x =
                      (gptEastingNorthing.x - theUlEastingNorthing.x) / theMetersPerPixel.x;
                }
                else // Crossed date line:
                {
                   // Normalize the right image point to account for wrap:
                   ossim_float64 normRightX =
                      rightImageX - rightProjectionEdge.x + leftProjectionEdge.x;
 
                   if ( ( gptEastingNorthing.x >= leftImageX ) &&
                        ( gptEastingNorthing.x <= rightProjectionEdge.x ) )
                   {
                      // Between tie and date line.
                      lineSample.x =
                         (gptEastingNorthing.x - theUlEastingNorthing.x)/theMetersPerPixel.x;
                   }
                   else if ( ( gptEastingNorthing.x >= leftProjectionEdge.x ) &&
                             ( gptEastingNorthing.x <=  normRightX ) )
                   {
                      // Between date line and right image point.
                      lineSample.x = ( rightProjectionEdge.x - theUlEastingNorthing.x +
                                      gptEastingNorthing.x - leftProjectionEdge.x )/theMetersPerPixel.x;
                   }
                   else
                   {
                      // Point in between normalized right x and tie:
                      ossim_float64 deltaToLeft  = theUlEastingNorthing.x - gptEastingNorthing.x;
                      ossim_float64 deltaToRight = gptEastingNorthing.x - normRightX;
                      
                      // Make relative to the closest edge.
                      if ( deltaToRight < deltaToLeft )
                      {
                         lineSample.x = (imageSize.x - 1) + deltaToRight/theMetersPerPixel.x;
                      }
                      else
                      {
                         lineSample.x = -(deltaToLeft/theMetersPerPixel.x );
                      }
                   }  
                }
               
             } // Matches: if ( ( imageSize.x > 0.0 ) && ( imageSize.y > 0.0 ) )
             else
             {
                lineSample.x = (gptEastingNorthing.x - theUlEastingNorthing.x)/theMetersPerPixel.x;
             }
  #endif
             lineSample.x = (gptEastingNorthing.x - theUlEastingNorthing.x)/theMetersPerPixel.x;
             // We must remember that the Northing is negative since the positive
             // axis for an image is assumed to go down since it's image space.
             lineSample.y = (theUlEastingNorthing.y - gptEastingNorthing.y) / theMetersPerPixel.y;
             
          } // Matches: if( !lineSample.isNan() )
       }
       else // Some point we need has nans...
       {
          lineSample.makeNan();
       }
    } // Matches: if( theModelTransformUnitType == OSSIM_UNIT_UNKNOWN )
    else 
    {
       // Has transform:
       ossimMapProjection::worldToLineSample(worldPoint, lineSample);
    }
 
 } // End: ossimEquDistCylProjection::worldToLineSample(worldPoint, lineSample, imageSize)