Albers Equal Area Conic Projection. More...

#include <ossimAlbersProjection.h>

Inheritance diagram for ossimAlbersProjection:

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

	ossimAlbersProjection (const ossimEllipsoid &ellipsoid, const ossimGpt &origin, double stdParallel1, double stdParallel2, double falseEasting, double falseNorthing)

ossimObject *	dup () const

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

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

virtual void	update ()

void	setStandardParallel1 (double degree)

void	setStandardParallel2 (double degree)

void	setStandardParallels (double parallel1Degree, double prallel2Degree)

void	setFalseEasting (double falseEasting)

void	setFalseNorthing (double falseNorthing)

void	setFalseEastingNorthing (double falseEasting, double falseNorthing)

void	setParameters (double parallel1, double parallel2, double falseEasting, double falseNorthing)

virtual double	getStandardParallel1 () const

virtual double	getStandardParallel2 () const

void	setDefaults ()

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

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

virtual bool	operator== (const ossimProjection &projection) const
	Returns TRUE if principal parameters are within epsilon tolerance. More...

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 void	worldToLineSample (const ossimGpt &worldPoint, ossimDpt &lineSample) const

virtual ossimGpt	lineSampleToWorld (const ossimDpt &projectedPoint) const

virtual void	lineSampleToWorld (const ossimDpt &projectedPoint, ossimGpt &gpt) 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	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	getFalseEasting () const

virtual double	getFalseNorthing () const

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 bool	isGeographic () 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	setOrigin (const ossimGpt &origin)
	Sets theOrigin to origin. 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 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

Protected Member Functions
virtual	~ossimAlbersProjection ()

long	Set_Albers_Parameters (double a, double f, double Origin_Latitude, double Central_Meridian, double Std_Parallel_1, double Std_Parallel_2, double False_Easting, double False_Northing)

void	Get_Albers_Parameters (double a, double f, double Origin_Latitude, double Central_Meridian, double Std_Parallel_1, double Std_Parallel_2, double False_Easting, double False_Northing) const

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

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

Protected Member Functions inherited from ossimMapProjection
virtual	~ossimMapProjection ()

void	updateFromTransform ()

Protected Member Functions inherited from ossimReferenced
virtual	~ossimReferenced ()

Protected Attributes
double	Albers_a

double	Albers_f

double	es

double	es2

double	C

double	rho0

double	n

double	Albers_a_OVER_n

double	one_MINUS_es2

double	two_es

double	Albers_Origin_Lat

double	Albers_Origin_Long

double	Albers_Std_Parallel_1

double	Albers_Std_Parallel_2

double	Albers_False_Easting

double	Albers_False_Northing

double	Albers_Delta_Northing

double	Albers_Delta_Easting

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

Albers Equal Area Conic Projection.

A basic conic projection developed by H.C. Albers. Classified as a conic and equal area. A graphic can be found at:
http://everest.hunter.cuny.edu/mp/pbander/albers.gif

Definition at line 25 of file ossimAlbersProjection.h.

Constructor & Destructor Documentation

◆ ossimAlbersProjection() [1/2]

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

Definition at line 46 of file ossimAlbersProjection.cpp.

References Albers_Delta_Easting, Albers_Delta_Northing, setDefaults(), and update().

Referenced by dup().

    :ossimMapProjection(ellipsoid, origin)
 {
    Albers_Delta_Northing = 40000000.0;
    Albers_Delta_Easting  = 40000000.0;
    setDefaults();
    update();
 }

◆ ossimAlbersProjection() [2/2]

ossimAlbersProjection::ossimAlbersProjection	(	const ossimEllipsoid &	ellipsoid,
		const ossimGpt &	origin,
		double	stdParallel1,
		double	stdParallel2,
		double	falseEasting,
		double	falseNorthing
	)

Parameters

ellipsoid
origin	latitude longitude in decimal degrees.
stdParallel1	First parallel in DEGREES.
stdParallel2	Second parallel in DEGREES.
falseEasting	False easting in meters.
falseNorthing	False northing in meters.

Definition at line 56 of file ossimAlbersProjection.cpp.

References Albers_Delta_Easting, Albers_Delta_Northing, Albers_False_Easting, Albers_False_Northing, Albers_Std_Parallel_1, Albers_Std_Parallel_2, RAD_PER_DEG, and update().

   :ossimMapProjection(ellipsoid, origin)
 {
    Albers_Std_Parallel_1 = stdParallel1*RAD_PER_DEG;
    Albers_Std_Parallel_2 = stdParallel2*RAD_PER_DEG;
    Albers_Delta_Northing = 40000000.0;
    Albers_Delta_Easting  = 40000000.0;
    Albers_False_Easting  = falseEasting;
    Albers_False_Northing = falseNorthing;
    
    update();
    
 }

◆ ~ossimAlbersProjection()

ossimAlbersProjection::~ossimAlbersProjection ( )

protectedvirtual

Definition at line 80 of file ossimAlbersProjection.cpp.

81 {

82 }

Member Function Documentation

◆ Convert_Albers_To_Geodetic()

long ossimAlbersProjection::Convert_Albers_To_Geodetic	(	double	Easting,
		double	Northing,
		double *	Latitude,
		double *	Longitude
	)		const

protected

The function Convert_Albers_To_Geodetic converts Albers projection (easting and northing) coordinates to geodetic (latitude and longitude) coordinates, according to the current ellipsoid and Albers projection coordinates. If any errors occur, the error code(s) are returned by the function, otherwise ALBERS_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 508 of file ossimAlbersProjection.cpp.

References Albers_a, Albers_Delta_Easting, Albers_Delta_Northing, ALBERS_EASTING_ERROR, Albers_False_Easting, Albers_False_Northing, ALBERS_NO_ERROR, ALBERS_NORTHING_ERROR, Albers_Origin_Long, C, es, ES_SIN, M_PI, n, one_MINUS_es2, ONE_MINUS_SQR, PI_OVER_2, rho0, two_es, and TWO_PI.

Referenced by inverse().

 { /* BEGIN Convert_Albers_To_Geodetic */
 /*
  * The function Convert_Albers_To_Geodetic converts Albers projection
  * (easting and northing) coordinates to geodetic (latitude and longitude)
  * coordinates, according to the current ellipsoid and Albers projection
  * coordinates.  If any errors occur, the error code(s) are returned by the
  * function, otherwise ALBERS_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 dy, dx;
   double rho0_MINUS_dy;
   double q, qconst, q_OVER_2;
   double rho, rho_n;
   double PHI, Delta_PHI = 1.0;
   double sin_phi;
   double es_sin, one_MINUS_SQRes_sin;
   double theta = 0.0;
   double tolerance = 4.85e-10;        /* approximately 1/1000th of
                               an arc second or 1/10th meter */
   long Error_Code = ALBERS_NO_ERROR; 
 
   if ((Easting < (Albers_False_Easting - Albers_Delta_Easting)) 
       || (Easting > Albers_False_Easting + Albers_Delta_Easting))
   { /* Easting out of range  */
     Error_Code |= ALBERS_EASTING_ERROR;
   }
   if ((Northing < (Albers_False_Northing - Albers_Delta_Northing)) 
       || (Northing > Albers_False_Northing + Albers_Delta_Northing))
   { /* Northing out of range */
     Error_Code |= ALBERS_NORTHING_ERROR;
   }
 
   if (!Error_Code)
   {
     dy = Northing - Albers_False_Northing;
     dx = Easting - Albers_False_Easting;
     rho0_MINUS_dy = rho0 - dy;
     rho = sqrt(dx * dx + rho0_MINUS_dy * rho0_MINUS_dy);
 
     if (n < 0)
     {
       rho *= -1.0;
       dy *= -1.0;
       dx *= -1.0;
       rho0_MINUS_dy *= -1.0;
     }
 
     if (rho != 0.0)
       theta = atan2(dx, rho0_MINUS_dy);
     rho_n = rho * n;
     q = (C - (rho_n * rho_n) / (Albers_a * Albers_a)) / n;
     qconst = 1 - ((one_MINUS_es2) / (two_es)) * log((1.0 - es) / (1.0 + es));
     if (fabs(fabs(qconst) - fabs(q)) > 1.0e-6)
     {
       q_OVER_2 = q / 2.0;
       if (q_OVER_2 > 1.0)
         *Latitude = PI_OVER_2;
       else if (q_OVER_2 < -1.0)
         *Latitude = -PI_OVER_2;
       else
       {
         PHI = asin(q_OVER_2);
         if (es < 1.0e-10)
           *Latitude = PHI;
         else
         {
           while (fabs(Delta_PHI) > tolerance)
           {
             sin_phi = sin(PHI);
             es_sin = ES_SIN(sin_phi);
             one_MINUS_SQRes_sin = ONE_MINUS_SQR(es_sin);
             Delta_PHI = (one_MINUS_SQRes_sin * one_MINUS_SQRes_sin) / (2.0 * cos(PHI)) *
                         (q / (one_MINUS_es2) - sin_phi / one_MINUS_SQRes_sin +
                          (log((1.0 - es_sin) / (1.0 + es_sin)) / (two_es)));
             PHI += Delta_PHI;
           }
           *Latitude = PHI;
         }
 
         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;
 
       }
     }
     else
     {
       if (q >= 0.0)
         *Latitude = PI_OVER_2;
       else
         *Latitude = -PI_OVER_2;
     }
     *Longitude = Albers_Origin_Long + theta / n;
 
     if (*Longitude > M_PI)
       *Longitude -= TWO_PI;
     if (*Longitude < -M_PI)
       *Longitude += TWO_PI;
 
     if (*Longitude > M_PI) /* force distorted values to 180, -180 degrees */
       *Longitude = M_PI;
     else if (*Longitude < -M_PI)
       *Longitude = -M_PI;
 
   }
   return (Error_Code);
 } /* END OF Convert_Albers_To_Geodetic */

◆ Convert_Geodetic_To_Albers()

long ossimAlbersProjection::Convert_Geodetic_To_Albers	(	double	Latitude,
		double	Longitude,
		double *	Easting,
		double *	Northing
	)		const

protected

The function Convert_Geodetic_To_Albers converts geodetic (latitude and longitude) coordinates to Albers projection (easting and northing) coordinates, according to the current ellipsoid and Albers projection parameters. If any errors occur, the error code(s) are returned by the function, otherwise ALBERS_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 438 of file ossimAlbersProjection.cpp.

References Albers_a_OVER_n, Albers_False_Easting, Albers_False_Northing, ALBERS_LAT_ERROR, ALBERS_LON_ERROR, ALBERS_NO_ERROR, Albers_Origin_Long, ALBERS_Q, C, ES_SIN, M_PI, n, ONE_MINUS_SQR, PI_OVER_2, rho0, and TWO_PI.

Referenced by forward().

 { /* BEGIN Convert_Geodetic_To_Albers */
 /*
  * The function Convert_Geodetic_To_Albers converts geodetic (latitude and
  * longitude) coordinates to Albers projection (easting and northing)
  * coordinates, according to the current ellipsoid and Albers projection
  * parameters.  If any errors occur, the error code(s) are returned by the
  * function, otherwise ALBERS_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 */
   double sin_lat;
   // double cos_lat;
   double es_sin, one_MINUS_SQRes_sin;
   double q;
   double rho;
   double theta;
   double nq;
   long Error_Code = ALBERS_NO_ERROR;
 
   if ((Latitude < -PI_OVER_2) || (Latitude > PI_OVER_2))
   {  /* Latitude out of range */
     Error_Code |= ALBERS_LAT_ERROR;
   }
   if ((Longitude < -M_PI) || (Longitude > TWO_PI))
   {  /* Longitude out of range */
     Error_Code|= ALBERS_LON_ERROR;
   }
 
   if (!Error_Code)
   { /* no errors */
 
     dlam = Longitude - Albers_Origin_Long;
     if (dlam > M_PI)
     {
       dlam -= TWO_PI;
     }
     if (dlam < -M_PI)
     {
       dlam += TWO_PI;
     }
     sin_lat = sin(Latitude);
     // cos_lat = cos(Latitude);
     es_sin = ES_SIN(sin_lat);
     one_MINUS_SQRes_sin = ONE_MINUS_SQR(es_sin);
     q = ALBERS_Q(sin_lat, one_MINUS_SQRes_sin, es_sin);
     nq = n * q;
     if (C < nq)
       rho = 0;
     else
       rho = Albers_a_OVER_n * sqrt(C - nq);
 
 
     theta = n * dlam;
     *Easting = rho * sin(theta) + Albers_False_Easting;
     *Northing = rho0 - rho * cos(theta) + Albers_False_Northing;
   }
   return (Error_Code);
 } /* END OF Convert_Geodetic_To_Albers */

◆ dup()

ossimObject * ossimAlbersProjection::dup ( ) const

virtual

Implements ossimProjection.

Definition at line 75 of file ossimAlbersProjection.cpp.

References ossimAlbersProjection().

 {
    return new ossimAlbersProjection(*this);
 }

◆ forward()

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

virtual

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

Implements ossimMapProjection.

Definition at line 115 of file ossimAlbersProjection.cpp.

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

 {
    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_Albers(gpt.latr(),
                               gpt.lonr(),
                               &easting,
                               &northing);
    
    return ossimDpt(easting, northing);
 }

◆ Get_Albers_Parameters()

void ossimAlbersProjection::Get_Albers_Parameters	(	double *	a,
		double *	f,
		double *	Origin_Latitude,
		double *	Central_Meridian,
		double *	Std_Parallel_1,
		double *	Std_Parallel_2,
		double *	False_Easting,
		double *	False_Northing
	)		const

protected

The function Get_Albers_Parameters returns the current ellipsoid parameters, and Albers projection parameters.

a : Semi-major axis of ellipsoid, in meters (output) f : Flattening of ellipsoid (output) Origin_Latitude : 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 Std_Parallel_1 : First standard parallel (output) Std_Parallel_2 : Second standard parallel (output) 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 origin latitude of the projection (output)

Definition at line 398 of file ossimAlbersProjection.cpp.

References Albers_a, Albers_f, Albers_False_Easting, Albers_False_Northing, Albers_Origin_Lat, Albers_Origin_Long, Albers_Std_Parallel_1, and Albers_Std_Parallel_2.

 { /* BEGIN Get_Albers_Parameters */
 /*
  * The function Get_Albers_Parameters returns the current ellipsoid
  * parameters, and Albers projection parameters.
  *
  *    a                 : Semi-major axis of ellipsoid, in meters   (output)
  *    f                 : Flattening of ellipsoid                                       (output)
  *    Origin_Latitude   : Latitude in radians at which the          (output)
  *                          point scale factor is 1.0
  *    Origin_Longitude  : Longitude in radians at the center of     (output)
  *                          the projection
  *    Std_Parallel_1    : First standard parallel                   (output)
  *    Std_Parallel_2    : Second standard parallel                  (output)
  *    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
  *                          origin latitude of the projection       (output)
  */
 
   *a = Albers_a;
   *f = Albers_f;
   *Origin_Latitude = Albers_Origin_Lat;
   *Std_Parallel_1 = Albers_Std_Parallel_1;
   *Std_Parallel_2 = Albers_Std_Parallel_2;
   *Central_Meridian = Albers_Origin_Long;
   *False_Easting = Albers_False_Easting;
   *False_Northing = Albers_False_Northing;
   return;
 } /* END OF Get_Albers_Parameters */

◆ getStandardParallel1()

double ossimAlbersProjection::getStandardParallel1 ( ) const

virtual

Returns: the first standard parallel in decimal degrees.

Reimplemented from ossimMapProjection.

Definition at line 191 of file ossimAlbersProjection.cpp.

References Albers_Std_Parallel_1, and RAD_PER_DEG.

 {
    return  Albers_Std_Parallel_1/RAD_PER_DEG;
 }

◆ getStandardParallel2()

double ossimAlbersProjection::getStandardParallel2 ( ) const

virtual

Returns: the second standard parallel in decimal degrees.

Reimplemented from ossimMapProjection.

Definition at line 196 of file ossimAlbersProjection.cpp.

References Albers_Std_Parallel_2, and RAD_PER_DEG.

 {
    return  Albers_Std_Parallel_2/RAD_PER_DEG;
 }

◆ inverse()

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

virtual

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

Implements ossimMapProjection.

Definition at line 102 of file ossimAlbersProjection.cpp.

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

 {
    double lat, lon;
    
    
    Convert_Albers_To_Geodetic(eastingNorthing.x,
                               eastingNorthing.y,
                               &lat,
                               &lon);
    
    return ossimGpt(lat*DEG_PER_RAD, lon*DEG_PER_RAD, 0, theDatum);
 }

◆ loadState()

bool ossimAlbersProjection::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 225 of file ossimAlbersProjection.cpp.

References Albers_False_Easting, Albers_False_Northing, Albers_Std_Parallel_1, Albers_Std_Parallel_2, ossimKeywordlist::find(), ossimMapProjection::loadState(), RAD_PER_DEG, STATIC_TYPE_NAME, ossimKeywordNames::STD_PARALLEL_1_KW, ossimKeywordNames::STD_PARALLEL_2_KW, ossimMapProjection::theFalseEastingNorthing, ossimString::toDouble(), ossimKeywordNames::TYPE_KW, update(), ossimDpt::x, and ossimDpt::y.

 {
    // Must do this first...
    bool flag = ossimMapProjection::loadState(kwl, prefix);
 
    const char* type          = kwl.find(prefix, ossimKeywordNames::TYPE_KW);
 
    const char* stdParallel1  = kwl.find(prefix, ossimKeywordNames::STD_PARALLEL_1_KW);
    const char* stdParallel2  = kwl.find(prefix, ossimKeywordNames::STD_PARALLEL_2_KW);
 
    
    if(ossimString(type) == STATIC_TYPE_NAME(ossimAlbersProjection))
    {
       Albers_False_Easting  = theFalseEastingNorthing.x;
       Albers_False_Northing = theFalseEastingNorthing.y;
 
       if(stdParallel1)
       {
          Albers_Std_Parallel_1 = ossimString(stdParallel1).toDouble()*RAD_PER_DEG;
       }
       else
       {
          Albers_Std_Parallel_1 = 29.5*RAD_PER_DEG;         
       }
       if(stdParallel2)
       {
          Albers_Std_Parallel_2 = ossimString(stdParallel2).toDouble()*RAD_PER_DEG;
       }
       else
       {
          Albers_Std_Parallel_2 = 45.5*RAD_PER_DEG;
       }
    }
 
    update();
    
    return flag;
 }

◆ operator==()

bool ossimAlbersProjection::operator== ( const ossimProjection & projection ) const

virtual

Returns TRUE if principal parameters are within epsilon tolerance.

Reimplemented from ossimMapProjection.

Definition at line 629 of file ossimAlbersProjection.cpp.

References Albers_Delta_Easting, Albers_Delta_Northing, Albers_Std_Parallel_1, Albers_Std_Parallel_2, and ossim::almostEqual().

 {
    if (!ossimMapProjection::operator==(proj)) return false;
 
    const ossimAlbersProjection* p = dynamic_cast<const ossimAlbersProjection*>(&proj);
    if (!p) return false;
 
    if (!ossim::almostEqual(Albers_Std_Parallel_1,p->Albers_Std_Parallel_1)) return false;
    if (!ossim::almostEqual(Albers_Std_Parallel_2,p->Albers_Std_Parallel_2)) return false;
    if (!ossim::almostEqual(Albers_Delta_Northing,p->Albers_Delta_Northing)) return false;
    if (!ossim::almostEqual(Albers_Delta_Easting, p->Albers_Delta_Easting) ) return false;
 
    return true;
 }

◆ saveState()

bool ossimAlbersProjection::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 210 of file ossimAlbersProjection.cpp.

References ossimKeywordlist::add(), Albers_Std_Parallel_1, Albers_Std_Parallel_2, DEG_PER_RAD, ossimMapProjection::saveState(), ossimKeywordNames::STD_PARALLEL_1_KW, and ossimKeywordNames::STD_PARALLEL_2_KW.

 {
    kwl.add(prefix,
            ossimKeywordNames::STD_PARALLEL_1_KW,
            Albers_Std_Parallel_1*DEG_PER_RAD,
            true);
 
    kwl.add(prefix,
            ossimKeywordNames::STD_PARALLEL_2_KW,
            Albers_Std_Parallel_2*DEG_PER_RAD,
            true);
    
    return ossimMapProjection::saveState(kwl, prefix);
 }

◆ Set_Albers_Parameters()

long ossimAlbersProjection::Set_Albers_Parameters	(	double	a,
		double	f,
		double	Origin_Latitude,
		double	Central_Meridian,
		double	Std_Parallel_1,
		double	Std_Parallel_2,
		double	False_Easting,
		double	False_Northing
	)

protected

The function Set_Albers_Parameters receives the ellipsoid parameters and projection parameters as inputs, and sets the corresponding state variables. If any errors occur, the error code(s) are returned by the function, otherwise ALBERS_NO_ERROR is returned.

a : Semi-major axis of ellipsoid, in meters (input) f : Flattening of ellipsoid (input) Origin_Latitude : 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 (central meridian) Std_Parallel_1 : First standard parallel (input) Std_Parallel_2 : Second standard parallel (input) 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 origin latitude of the projection (input)

Definition at line 269 of file ossimAlbersProjection.cpp.

References Albers_a, ALBERS_A_ERROR, Albers_a_OVER_n, ALBERS_CENT_MER_ERROR, Albers_f, Albers_False_Easting, Albers_False_Northing, ALBERS_FIRST_SECOND_ERROR, ALBERS_FIRST_STDP_ERROR, ALBERS_HEMISPHERE_ERROR, ALBERS_INV_F_ERROR, ALBERS_M, ALBERS_NO_ERROR, Albers_Origin_Lat, ALBERS_ORIGIN_LAT_ERROR, Albers_Origin_Long, ALBERS_Q, ALBERS_SECOND_STDP_ERROR, Albers_Std_Parallel_1, Albers_Std_Parallel_2, C, es, es2, ES_SIN, M_PI, n, one_MINUS_es2, ONE_MINUS_SQR, PI_OVER_2, rho0, two_es, and TWO_PI.

Referenced by update().

 {
 /*
  * The function Set_Albers_Parameters receives the ellipsoid parameters and
  * projection parameters as inputs, and sets the corresponding state
  * variables.  If any errors occur, the error code(s) are returned by the function, 
  * otherwise ALBERS_NO_ERROR is returned.
  *
  *    a                 : Semi-major axis of ellipsoid, in meters   (input)
  *    f                 : Flattening of ellipsoid                   (input)
  *    Origin_Latitude   : 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
  *    Std_Parallel_1    : First standard parallel                   (input)
  *    Std_Parallel_2    : Second standard parallel                  (input)
  *    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
  *                          origin latitude of the projection       (input)
  */
 
   double sin_lat, sin_lat_1, cos_lat;
   double m1, m2, SQRm1;
   double q0, q1, q2;
   double es_sin, one_MINUS_SQRes_sin;
   double nq0;
   double inv_f = 1 / f;
   long Error_Code = ALBERS_NO_ERROR;
 
   if (a <= 0.0)
   { /* Semi-major axis must be greater than zero */
     Error_Code |= ALBERS_A_ERROR;
   }
   if ((inv_f < 250) || (inv_f > 350))
   { /* Inverse flattening must be between 250 and 350 */
     Error_Code |= ALBERS_INV_F_ERROR;
   }
   if ((Origin_Latitude < -PI_OVER_2) || (Origin_Latitude > PI_OVER_2))
   { /* origin latitude out of range */
     Error_Code |= ALBERS_ORIGIN_LAT_ERROR;
   }
   if ((Central_Meridian < -M_PI) || (Central_Meridian > TWO_PI))
   { /* origin longitude out of range */
     Error_Code |= ALBERS_CENT_MER_ERROR;
   }
   if ((Std_Parallel_1 < -PI_OVER_2) || (Std_Parallel_1 > PI_OVER_2))
   { /* First Standard Parallel out of range */
     Error_Code |= ALBERS_FIRST_STDP_ERROR;
   }
   if ((Std_Parallel_2 < -PI_OVER_2) || (Std_Parallel_2 > PI_OVER_2))
   { /* Second Standard Parallel out of range */
     Error_Code |= ALBERS_SECOND_STDP_ERROR;
   }
   if ((Std_Parallel_1 == 0.0) && (Std_Parallel_2 == 0.0))
   { /* First & Second Standard Parallels equal 0 */
     Error_Code |= ALBERS_FIRST_SECOND_ERROR;
   }
   if (Std_Parallel_1 == -Std_Parallel_2)
   { /* Parallels are opposite latitudes */
     Error_Code |= ALBERS_HEMISPHERE_ERROR;
   }
 
   if (!Error_Code)
   { /* no errors */
     Albers_a = a;
     Albers_f = f;
     Albers_Origin_Lat = Origin_Latitude;
     Albers_Std_Parallel_1 = Std_Parallel_1;
     Albers_Std_Parallel_2 = Std_Parallel_2;
     if (Central_Meridian > M_PI)
       Central_Meridian -= TWO_PI;
     Albers_Origin_Long = Central_Meridian;
     Albers_False_Easting = False_Easting;
     Albers_False_Northing = False_Northing;
 
     es2 = 2 * Albers_f - Albers_f * Albers_f;
     es = sqrt(es2);
     one_MINUS_es2 = 1 - es2;
     two_es = 2 * es;
 
     sin_lat = sin(Albers_Origin_Lat);
     es_sin = ES_SIN(sin_lat);
     one_MINUS_SQRes_sin = ONE_MINUS_SQR(es_sin);
     q0 = ALBERS_Q(sin_lat, one_MINUS_SQRes_sin, es_sin);
 
     sin_lat_1 = sin(Albers_Std_Parallel_1);
     cos_lat = cos(Albers_Std_Parallel_1);
     es_sin = ES_SIN(sin_lat_1);
     one_MINUS_SQRes_sin = ONE_MINUS_SQR(es_sin);
     m1 = ALBERS_M(cos_lat, one_MINUS_SQRes_sin);
     q1 = ALBERS_Q(sin_lat_1, one_MINUS_SQRes_sin, es_sin);
 
     SQRm1 = m1 * m1;
     if (fabs(Albers_Std_Parallel_1 - Albers_Std_Parallel_2) > 1.0e-10)
     {
       sin_lat = sin(Albers_Std_Parallel_2);
       cos_lat = cos(Albers_Std_Parallel_2);
       es_sin = ES_SIN(sin_lat);
       one_MINUS_SQRes_sin = ONE_MINUS_SQR(es_sin);
       m2 = ALBERS_M(cos_lat, one_MINUS_SQRes_sin);
       q2 = ALBERS_Q(sin_lat, one_MINUS_SQRes_sin, es_sin);
       n = (SQRm1 - m2 * m2) / (q2 - q1);
     }
     else
       n = sin_lat_1;
 
     C = SQRm1 + n * q1;
     Albers_a_OVER_n = Albers_a / n;
     nq0 = n * q0;
     if (C < nq0)
       rho0 = 0;
     else
       rho0 = Albers_a_OVER_n * sqrt(C - nq0);
 
 
   } /* END OF if(!Error_Code) */
   return (Error_Code);
 } /* END OF Set_Albers_Parameters */

◆ setDefaults()

void ossimAlbersProjection::setDefaults ( )

Definition at line 201 of file ossimAlbersProjection.cpp.

References Albers_False_Easting, Albers_False_Northing, Albers_Std_Parallel_1, Albers_Std_Parallel_2, and RAD_PER_DEG.

Referenced by ossimAlbersProjection().

 {
    // initialize to some default
    Albers_Std_Parallel_1 = 29.5*RAD_PER_DEG;
    Albers_Std_Parallel_2 = 45.5*RAD_PER_DEG;
    Albers_False_Easting  = 0.0;
    Albers_False_Northing = 0.0;  
 }

◆ setFalseEasting()

void ossimAlbersProjection::setFalseEasting ( double falseEasting )

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

Definition at line 159 of file ossimAlbersProjection.cpp.

References Albers_False_Easting, and update().

 {
    Albers_False_Easting = falseEasting;
    update();
 }

◆ setFalseEastingNorthing()

void ossimAlbersProjection::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 171 of file ossimAlbersProjection.cpp.

References Albers_False_Easting, Albers_False_Northing, and update().

 {
    Albers_False_Easting = falseEasting;
    Albers_False_Northing = falseNorthing;  
    update();
 }

◆ setFalseNorthing()

void ossimAlbersProjection::setFalseNorthing ( double falseNorthing )

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

Definition at line 165 of file ossimAlbersProjection.cpp.

References Albers_False_Northing, and update().

 {
    Albers_False_Northing = falseNorthing;
    update();
 }

◆ setParameters()

void ossimAlbersProjection::setParameters	(	double	parallel1,
		double	parallel2,
		double	falseEasting,
		double	falseNorthing
	)

Allows one to set all parameters for this projections. parallels are in degrees and easting northings are in meters. Update is then called so we can pre-compute paramters.

Definition at line 179 of file ossimAlbersProjection.cpp.

References Albers_False_Easting, Albers_False_Northing, Albers_Std_Parallel_1, Albers_Std_Parallel_2, RAD_PER_DEG, and update().

 {
    Albers_False_Easting = falseEasting;
    Albers_False_Northing = falseNorthing;  
    Albers_Std_Parallel_1 = parallel1*RAD_PER_DEG;
    Albers_Std_Parallel_2 = parallel2*RAD_PER_DEG;
    update(); 
 }

◆ setStandardParallel1()

void ossimAlbersProjection::setStandardParallel1 ( double degree )

The passed in Argument is in degrees and will convert it to radians for Geotrans. Update is then called so we can pre-compute paramters.

Definition at line 138 of file ossimAlbersProjection.cpp.

References Albers_Std_Parallel_1, RAD_PER_DEG, and update().

 {
    Albers_Std_Parallel_1 = degree*RAD_PER_DEG;
    update();
 }

◆ setStandardParallel2()

void ossimAlbersProjection::setStandardParallel2 ( double degree )

The passed in Argument is in degrees and will convert it to radians for Geotrans. Update is then called so we can pre-compute paramters

Definition at line 144 of file ossimAlbersProjection.cpp.

References Albers_Std_Parallel_2, RAD_PER_DEG, and update().

 {
    Albers_Std_Parallel_2 = degree*RAD_PER_DEG;
    update();
 }

◆ setStandardParallels()

void ossimAlbersProjection::setStandardParallels	(	double	parallel1Degree,
		double	prallel2Degree
	)

Will allow you to set both parallels. both are passed in degrees.

Definition at line 150 of file ossimAlbersProjection.cpp.

References Albers_Std_Parallel_1, Albers_Std_Parallel_2, RAD_PER_DEG, and update().

 {
    Albers_Std_Parallel_1 = parallel1Degree*RAD_PER_DEG;
    Albers_Std_Parallel_2 = parallel2Degree*RAD_PER_DEG;
    update();
    
 }

◆ update()

void ossimAlbersProjection::update ( )

virtual

Reimplemented from ossimMapProjection.

Definition at line 84 of file ossimAlbersProjection.cpp.

References Albers_False_Easting, Albers_False_Northing, Albers_Std_Parallel_1, Albers_Std_Parallel_2, ossimEllipsoid::getA(), ossimEllipsoid::getFlattening(), ossimGpt::latr(), ossimGpt::lonr(), Set_Albers_Parameters(), ossimMapProjection::theEllipsoid, ossimMapProjection::theFalseEastingNorthing, ossimMapProjection::theOrigin, ossimMapProjection::update(), ossimDpt::x, and ossimDpt::y.

Referenced by loadState(), ossimAlbersProjection(), setFalseEasting(), setFalseEastingNorthing(), setFalseNorthing(), setParameters(), setStandardParallel1(), setStandardParallel2(), and setStandardParallels().

 {
    Set_Albers_Parameters(theEllipsoid.getA(),
                          theEllipsoid.getFlattening(),
                          theOrigin.latr(),
                          theOrigin.lonr(),
                          Albers_Std_Parallel_1,
                          Albers_Std_Parallel_2,
                          Albers_False_Easting,
                          Albers_False_Northing);
    
    theFalseEastingNorthing.x = Albers_False_Easting;
    theFalseEastingNorthing.y = Albers_False_Northing;
 
    ossimMapProjection::update();
 }