ossimDms Class Reference

#include <ossimDms.h>

Public Member Functions
	ossimDms ()
	Default constructor. More...
	ossimDms (double someDegrees, bool latFlag=true)
	Constructor ossimDms(double, bool) More...
	ossimDms (const std::string &value)
	` Constructor. More...
ossimString	toString (const ossimString &formatString=ossimString("")) const
	You can specify a number of different formats. More...
double	getDegrees () const
bool	getLatFlag () const
bool	setDegrees (const std::string &value)
	setDegrees(char*). More...
ossimDms &	setDegrees (double degrees)
ossimDms &	setLatFlag (bool latFlag)

Static Public Attributes
static const ossim_uint8	theDegreeSign = 176

Private Member Functions
ossimString	degree_to_string (double degrees, char format[], bool lat_flag) const
	char * function degree_to_string More...
void	calc_mins_or_secs (double *dd, std::string::const_iterator &formatIter, std::string &result) const
int	calc_mins_or_secs (double *dd, const char *format, char *res) const
	integer function calc_mins_or_secs * calculates minutes from degrees, seconds from minutes, based on "format", returning the resultant string in "res". More...
void	setup_printf (int ival, char *fmt) const
	function setup_printf the C library function sprintf takes as its second argument, a format specifier. More...
void	set_default (char *fp, char *rp) const
	function set_default * assigns a default format to be used as the template for the conversion of the double precision value, degrees. More...
void	init_values (double d) const
	function init_values initializes the global values used throughout the function. More...
double	string_to_degree (const std::string &cdegrees)
	double function string_to_degree More...

Private Attributes
double	theDegrees
bool	theLatFlag
double	theDecDegs
bool	theAfterDot
bool	theDoingSeconds
int	theIntDegs
int	theSign
double	theWorking

Static Private Attributes
static const char *	DEFAULT_FORMAT = "ddd mm.mmC"
static const char *	SPACES = " "

Detailed Description

Definition at line 19 of file ossimDms.h.

Constructor & Destructor Documentation

ossimDms() [1/3]

ossimDms::ossimDms

(

)

Default constructor.

Initializes to 0.0 degrees latitude.

Definition at line 27 of file ossimDms.cpp.

   : theDegrees(0.0),
     theLatFlag(true),
     theDecDegs(0.0),
     theAfterDot(false),
     theDoingSeconds(true),
     theIntDegs(0),
     theSign(1),
     theWorking(0.0)
{
}

ossimDms() [2/3]

ossimDms::ossimDms	(	double	someDegrees,
		bool	latFlag = true
	)

Constructor ossimDms(double, bool)

You can construct a DMS class with a decimal degree and specify if its for the lat or lon.

latFlag true its for the lat false its for the lon

Definition at line 39 of file ossimDms.cpp.

   : theDegrees(someDegrees),
     theLatFlag(latFlag),
     theDecDegs(0.0),
     theAfterDot(false),
     theDoingSeconds(true),
     theIntDegs(0),
     theSign(1),
     theWorking(0.0)
{
}

ossimDms() [3/3]

ossimDms::ossimDms

(

const std::string &

value

)

` Constructor.

You can specify the value in a formated string. Example: "45N" will set the decimal degree to 45 and will set the lat flag to true

"45W" will set the internal degree to negative and set the lat flag to false.

Definition at line 51 of file ossimDms.cpp.

References string_to_degree(), and theDegrees.

   : theDegrees(0.0),
     theLatFlag(false),
     theDecDegs(0.0),
     theAfterDot(false),
     theDoingSeconds(true),
     theIntDegs(0),
     theSign(1),
     theWorking(0.0)
{
   if (value != "")
   {
      theDegrees = string_to_degree(value);
   }
   else
   {
      theDegrees = 0.0;
   }

}

Member Function Documentation

calc_mins_or_secs() [1/2]

void ossimDms::calc_mins_or_secs ( double *  dd, std::string::const_iterator &  formatIter, std::string &  result  ) const

private

Definition at line 615 of file ossimDms.cpp.

References theAfterDot.

Referenced by degree_to_string(), and toString().

{
    double du;
    int ufactor, ires, numunits;
    char unit;

    unit = *formatIter;         /* set to 'm' or 's' */

    ufactor = 1, numunits = 0;

/* count minutes (or seconds) desired in this part of format */

    while (*formatIter == unit)
        {
       numunits++;
       formatIter++, ufactor *= 10;
    }

/* different calc based on beyond decimal pt or not */

    if (theAfterDot == true)
        {
       du = *dd * (double)ufactor;
//     ires = (int)(du + 0.5);
       ires = (int)(du);
       *dd = (du - ires);
           if(*dd < 0.0) *dd = 0.0;
    }
    else
        {
       du = (*dd * 60.0) * (double)ufactor;
//     ires = (int)(du + 0.5) / ufactor;
       ires = (int)(du) / ufactor;
       *dd = (du - (ires * ufactor)) / (double)ufactor;
           if(*dd < 0.0) *dd = 0.0;
    }
        std::ostringstream out;
        
        out << std::setw(numunits)
            << std::setfill('0')
            << std::setiosflags(std::ios::right)
            << std::setprecision(numunits)
            << ires
            << std::ends;
        result+=out.str().c_str();
        

//        result += ossimString::toString(ires);
}

calc_mins_or_secs() [2/2]

int ossimDms::calc_mins_or_secs ( double *  dd, const char *  format, char *  res  ) const

private

integer function calc_mins_or_secs * calculates minutes from degrees, seconds from minutes,
based on "format", returning the resultant string in "res".

"dd" is the part of 'degrees' that provides
the value to manipulate. the integer returned as the
value of this function is the number of places in the
format that have been parsed here, to be used in the
main function to advance the format-parsing pointer.

Definition at line 679 of file ossimDms.cpp.

References setup_printf(), and theAfterDot.

{
    double du;
    int ufactor, ires, numunits;
    char unit, str_fmt[8];

    unit = *format;         /* set to 'm' or 's' */

    ufactor = 1, numunits = 0;

/* count minutes (or seconds) desired in this part of format */

    while (*format == unit) {
       numunits++;
       format++, ufactor *= 10;
    }

/* different calc based on beyond decimal pt or not */

    if (theAfterDot == true) {
       du = *dd * (double)ufactor;
//     ires = (int)(du + 0.5);
       ires = (int)(du + 0.5);
       *dd = (du - ires);
    }
    else {
       du = (*dd * 60.0) * (double)ufactor;
//     ires = (int)(du + 0.5) / ufactor;
       ires = (int)(du) / ufactor;
       *dd = (du - (ires * ufactor)) / (double)ufactor;
    }
    setup_printf(numunits, str_fmt);
    sprintf(res, str_fmt, ires);
        
    return(numunits);
}

degree_to_string()

ossimString ossimDms::degree_to_string ( double  degrees, char  format[], bool  lat_flag  ) const

private

char * function degree_to_string

requires: dts.h
input: double precision, string, integer params returns: pointer to a string

purpose: to convert a double precision number "degrees" to a character string based on the input "format" and a flag indicating whether or not the degrees are latitude. If 'lat_flag' is TRUE, then degrees are latitude, otherwise they are longitude. default format: ddd mm.mmC
returns: a pointer to a string which contains the formatted degree value.
written as part of the DIAL facility, G&G, WHOI April 1992
Christine L. Hammond

Definition at line 475 of file ossimDms.cpp.

References calc_mins_or_secs(), init_values(), set_default(), setup_printf(), theAfterDot, theDecDegs, theDegreeSign, theIntDegs, and theWorking.

{
   char cdegrees[64];
   char str_fmt[10];
   char *rptr, *fptr, *sptr;
   int i, d_s;
   
/* assign a default format if none is given */
   
   if (format[0] == '\0')
   {
      set_default(format, cdegrees);
   }
   else
   {
      memset(cdegrees, ' ', 64);
//       strcpy(cdegrees, SPACES);
   }
   
   init_values(degrees);
   
   rptr = cdegrees;
   fptr = format;
   sptr = str_fmt;
   
/* cycle through characters of the format and plug in values */
   
   while (*fptr != '\0') {
      
     switch (*fptr) {

       case '-': {
        (theWorking < 0.0) ? (*rptr = '-') : (*rptr = ' ');
        rptr++, fptr++;
        break;
       }

       case 'c':
       case 'C': {
        if (theWorking < 0.0)
           (lat_flag == true) ? (*rptr = 'S') : (*rptr = 'W');
        else
           (lat_flag == true) ? (*rptr = 'N') : (*rptr = 'E');
        
        rptr++, fptr++;
        break;
       }

       case 'd':
       case 'D': {          /* how many 'd's until not 'd' */
        d_s = 1, fptr++;
        while (*fptr == 'd') {
           d_s++, fptr++;
        }
        setup_printf(d_s, sptr);    /* printf's fmt will be %x.xd */

        if (theAfterDot == true) {      /* beyond the decimal point */
           i = d_s;
           while (i-- > 0)
            theDecDegs = theDecDegs * 10.0;
//         theIntDegs = (int)(theDecDegs + 0.5);
           theIntDegs = (int)(theDecDegs);
         }

        sprintf(rptr, str_fmt, theIntDegs);

        if (*rptr == '0' && !theAfterDot)   /* remove leading zero */
           *rptr = ' ';
        rptr += d_s;
        break;
       }

       case ' ': {          /* compress multiple spaces in format */
        *rptr = *fptr;
        while (*fptr == ' ')
            fptr++;
        rptr++;
        break;
       }

       case '.': {
        if (theAfterDot == true) {      /* a second decimal point? */
           set_default(format, cdegrees);
           fptr = format;
           rptr = cdegrees;
           init_values(degrees);
        }
        else {
           *rptr = *fptr;
           rptr++, fptr++;
           theAfterDot = true;
        }
        break;
       }

         case 'm':
         case 'M':
         case 's':
         case 'S':
         {
        i = calc_mins_or_secs(&theDecDegs, fptr, rptr);
        fptr += i, rptr += i;       /* i == num to advance format */
        break;
       }

           // This is code that I added so you can do additional
           // formatting.
           //
         case '\'':
         case '"':
         {
            *rptr = *fptr;
            rptr++;
            fptr++;
            break;
         }
         case '@':
         {
            *rptr = (char)theDegreeSign;
            rptr++;
            fptr++;
            break;
         }
       default: {
        set_default(format, cdegrees);
        fptr = format;
        rptr = cdegrees;
        init_values(degrees);
       }
     }  /* end switch statement */

    }   /* end while loop */

    *rptr = '\0';
    return(cdegrees);
}

getDegrees()

double ossimDms::getDegrees ( ) const

inline

Definition at line 71 of file ossimDms.h.

Referenced by ossimNitfBlockaTag::converLocStringToPt(), ossimStatePlaneProjectionInfo::originLat(), ossimStatePlaneProjectionInfo::originLon(), ossimStatePlaneProjectionInfo::ossimStatePlaneProjectionInfo(), and ossimNitfProjectionFactory::parseGeographicString().

{ return theDegrees; }

getLatFlag()

bool ossimDms::getLatFlag ( ) const

inline

Definition at line 72 of file ossimDms.h.

{ return theLatFlag; }

init_values()

void ossimDms::init_values ( double  d ) const

private

function init_values initializes the global values used throughout the function.

see notes in header file.

Definition at line 763 of file ossimDms.cpp.

References theAfterDot, theDecDegs, theDoingSeconds, theIntDegs, theSign, and theWorking.

Referenced by degree_to_string(), and toString().

{

   theAfterDot     = false;
   theDoingSeconds = false;
   theSign = 1;
   if (d < 0.0)
      theSign = -1;
   
   theWorking = d;
   theIntDegs = (int)theWorking * theSign;
   theDecDegs = (theWorking  * theSign) - theIntDegs;
   
   return;
}

set_default()

void ossimDms::set_default ( char *  fp, char *  rp  ) const

private

function set_default * assigns a default format to be used as the template for
the conversion of the double precision value, degrees.

either an error was detected in parsing the format that
the user entered, or no format was entered at all.
also, clears the result string of any characters which
may have been placed therein prior to the call here.

Definition at line 750 of file ossimDms.cpp.

References DEFAULT_FORMAT, and SPACES.

Referenced by degree_to_string().

{
    strcpy(fp, DEFAULT_FORMAT);     /* assign default format */
    strcpy(rp, SPACES);

}

setDegrees() [1/2]

bool ossimDms::setDegrees

(

const std::string &

value

)

setDegrees(char*).

Will allow you to set the internal paramters through a string. examples:

"45 5 6" will assume degrees minutes seconds "45" will assume degrees. "-45" "45W"

Returns

true on success, false if unhandled characters are found.

Definition at line 79 of file ossimDms.cpp.

References ossimString::c_str(), status, theAfterDot, theDegrees, theDegreeSign, theLatFlag, and theSign.

Referenced by ossimNitfBlockaTag::converLocStringToPt(), and ossimNitfProjectionFactory::parseGeographicString().

{
   bool status = true;
   
   ossimString copy = cdegrees;
   
   double degrees, factor, dividend, units;
   int i;
   bool afterdelim;
   char* cptr = const_cast<char*>(copy.c_str());
   char c;

   theAfterDot = false;
   afterdelim = false;
   degrees = 0.0;
   units = 0.0;
   factor = 1.0;
   dividend = 60.0;
   theSign = 1;

   /* get rid of leading spaces */

   while (*cptr == ' ')
   {
      cptr++;
   }

   while(*cptr != '\0') 
   {
      switch (*cptr) 
      {

         // north, west and + values will change sign of degrees to plus.

         case '+':
         {
            theSign = 1;
            cptr++;
         }
         case 'n':
         case 'N':
         {
            theSign = 1;
            theLatFlag = true;
            cptr++;
            break;
         }
         case 'e':
         case 'E':
         {
            theLatFlag = false;
            theSign = 1;
            cptr++;
            break;
         }

         // south, east and - values will change sign of degrees to minus
         
         case '-':
         {
            theSign = -1;
            cptr++;
            break;
         }
         case 's':
         case 'S':
         {
            theSign = -1;
            cptr++;
            theLatFlag = true;
            break;
         }
         case 'w':
         case 'W':
         {
            theSign = -1;
            cptr++;
            theLatFlag = false;
            break;
         }
         
         case '0':
         case '1':
         case '2':
         case '3':
         case '4':
         case '5':
         case '6':
         case '7':
         case '8':
         case '9': 
         {
            c = *cptr;
            i = (c - '0');
            
            if (afterdelim == true) 
            {
               if (theAfterDot == true) 
               {
                  units = units + (((double)i * factor) / dividend);
               }
               else
               {
                  units = (units * factor) + ((double)i / dividend);
               }
            }
            else 
            {
               if (theAfterDot == true)
               {
                  degrees = degrees + ((double)i * factor);
               }
               else
               {
                  degrees = (degrees * factor) + (double)i;
               }
            }
            if (theAfterDot == true)
            {
               factor = factor * .10;
            }
            else
            {
               factor = 10.;
            }
            
            cptr++;
            break;
         }

         //---
         // a decimal point indicates a change in the factor used
         // to calculate degrees or units (minutes or seconds)
         //---
         case '.': 
         {
            factor = .10;
            theAfterDot = true;
            cptr++;
            break;
         }

         // after a delimiter the value contains minutes, first time through
         case ' ': 
         case '\"':
         case '\'':
         {
            while (*(cptr + 1) == ' ')
            {
               cptr++;
            }
            
            degrees = degrees + units;
            units = 0.0;
            
            if (afterdelim == true)     /* must be seconds */
            {
               dividend = dividend * dividend;
            }
            else
            {
               afterdelim = true;
            }
            
            factor = 1.;
            
            cptr++;
            
            // skip any leading zeroes after delimiter */
            
            while (*cptr == '0')
            {
               cptr++;
            }
            
            break;
         }

         //---
         //  check for a delimiter that is allowable:
         // isspace allows: space, tab, cr, nl, vt, ff
         // ispunct allows: punctuation char != space or control or letter
         //---
         default: 
         {
            if(isspace(*cptr) || 
               ispunct(*cptr) || 
               ((ossim_uint8)(*cptr) == theDegreeSign))
            {
               *cptr = ' ';
            }
            else
            {
               status = false;
               ++cptr;
            }
         }
         
      } // end switch

      if (status == false)
      {
         break;
      }
      
   } //  end while loop

   // add any units that may have been calculated (minutes or seconds)
   degrees     = degrees + units;
   
   theDegrees = (degrees * (double)theSign);
   
   return status;
}

setDegrees() [2/2]

ossimDms & ossimDms::setDegrees

(

double

degrees

)

Definition at line 72 of file ossimDms.cpp.

References theDegrees.

{
   theDegrees = degrees;
   
   return *this;
}

setLatFlag()

ossimDms& ossimDms::setLatFlag ( bool  latFlag )

inline

Definition at line 89 of file ossimDms.h.

Referenced by ossimNitfProjectionFactory::parseGeographicString().

{theLatFlag = latFlag;return *this;}

setup_printf()

void ossimDms::setup_printf ( int  ival, char *  fmt  ) const

private

function setup_printf the C library function sprintf takes as its second argument, a format specifier.

this function constructs that specifier based on 'ival', an integer indicating the number of d's or m's or s's seen in the group just parsed.

Definition at line 727 of file ossimDms.cpp.

Referenced by calc_mins_or_secs(), and degree_to_string().

{
    char precis[3];
    
    strcpy(fmt, "%");
    sprintf(precis, "%d", ival);
    strcat(fmt,precis);
    strcat(fmt,".");
    strcat(fmt,precis);
    strcat(fmt,"d");
}

string_to_degree()

double ossimDms::string_to_degree ( const std::string &  cdegrees )

private

double function string_to_degree

requires: dts.h input: string variable parameter returns: double precision number

purpose: to calculate a double precision number, representing degrees latitude or longitude, given a string "cdegrees". valid input consists of the following characters:

+, -, N, n, S, s, E, e, W, w – direction indicators
any digit [0-9]
a decimal point, '.' – says decimal degrees follow an ascii delimiter, for example ' ', TAB, '/' to indicate that either minutes or seconds follow.

output is a double precision number, which will be either latitude or longitude degrees and decimal degree

written as part of the DIAL facility, G&G, WHOI April 1992 Christine L. Hammond

Definition at line 807 of file ossimDms.cpp.

References theAfterDot, theLatFlag, and theSign.

Referenced by ossimDms().

{
   if (cdegrees.size() == 0) return 0.0;

   // We must make a non-const copy of "cdegrees".
   char* copy = new char[cdegrees.size()+1];

   //---
   // Since where going to play with the "copy" pointer we must keep the
   // original pointer so we can delete it at the bottom.
   //---
   char* cptr = copy;
   
   strcpy(cptr, cdegrees.c_str());
   
   double degrees, factor, dividend, units;
   int i;
   bool afterdelim;
   char c;
   
   theAfterDot = false;
   afterdelim = false;
   degrees = 0.0;
   units = 0.0;
   factor = 1.0;
   dividend = 60.0;
   theSign = 1;
   
   /* get rid of leading spaces */
   
   while (*cptr == ' ')
      cptr++;
   
   while(*cptr != '\0')
   {
      switch (*cptr)
      {
         
         /* north, west and + values will change sign of degrees to plus */
         case '+':
         case 'n':
         case 'N':
         case 'e':
         case 'E': 
         {
            if(toupper(*cptr) == 'N')
            {
               theLatFlag = true;
            }
            else if(toupper(*cptr) == 'E')
            {
               theLatFlag = false;
            }
            theSign = 1;
            cptr++;
            break;
         }
         
         /* south, east and - values will change sign of degrees to minus */
         
         case '-':
         case 's':
         case 'S':
         case 'w':
         case 'W': 
         {
            if(toupper(*cptr) == 'S')
            {
               theLatFlag = true;
            }
            else if(toupper(*cptr) == 'W')
            {
               theLatFlag = false;
            }
            theSign = -1;
            cptr++;
            break;
         }
         
         case '0':
         case '1':
         case '2':
         case '3':
         case '4':
         case '5':
         case '6':
         case '7':
         case '8':
         case '9':
         {
            c = *cptr;
            i = (c - '0');
            
            if (afterdelim == true) {
               
               if (theAfterDot == true) 
                  units = units + (((double)i * factor) / dividend);
               else
                  units = (units * factor) + ((double)i / dividend);
            }
            else {
               
               if (theAfterDot == true)
                  degrees = degrees + ((double)i * factor);
               else
                  degrees = (degrees * factor) + (double)i;
            }
            
            if (theAfterDot == true) 
               factor = factor * .10;
            else
               factor = 10.;
            
            cptr++;
            break;
         }
            
         /* a decimal point indicates a change in the factor used */
         /* to calculate degrees or units (minutes or seconds)    */
            
         case '.':
         {
            factor = .10;
            theAfterDot = true;
            cptr++;
            break;
         }
         
         /* after a delimiter the value contains minutes, first time through */
         
         case ' ':
         {
            
            while (*(cptr + 1) == ' ') 
               cptr++;
            
            degrees = degrees + units;
            units = 0.0;
            
            if (afterdelim == true)     /* must be seconds */
               dividend = dividend * dividend;
            else 
               afterdelim = true;
            
            factor = 1.;
            
            cptr++;
            
            /* skip any leading zeroes after delimiter */
            
            while (*cptr == '0')
               cptr++;
            
            break;
         }
            
         /* check for a delimiter that is allowable:
            isspace allows: space, tab, cr, nl, vt, ff
            ispunct allows: punctuation char != space or control or letter */
         
         default:
         {
            if (isspace(*cptr) || ispunct(*cptr))
               *cptr = ' ';
         }
         
      } /* end switch */
      
   }    /* end while loop */
   
   /* add any units that may have been calculated (minutes or seconds) */
   
   degrees = degrees + units;

   //---
   // NOTE:  local variable "cptr" has been moved so do not delete "cptr"
   // delete "copy" which points to the original allocated memory...
   //---
   delete [] copy;
   copy = 0;
   
   return(degrees * (double)theSign);
}

toString()

ossimString ossimDms::toString

(

const ossimString &

formatString = ossimString("")

)

const

You can specify a number of different formats.

special characters:

@    is replaced with a degree character.
'    minutes character
"    seconds character
d    replaced with degree portion
m    replaced with minute portion
s    replaced with second portion
c or C replaces with N/S or E/W

examples for format string

Definition at line 294 of file ossimDms.cpp.

References abs, ossimString::begin(), calc_mins_or_secs(), DEFAULT_FORMAT, ossimString::end(), init_values(), ossimString::length(), theAfterDot, theDecDegs, theDegrees, theDegreeSign, theDoingSeconds, theIntDegs, theLatFlag, theWorking, and ossimString::toString().

Referenced by ossimMapCompositionSource::addMeterGridLabels(), ossimNitfCommon::encodeGeographicDms(), and ossimGpt::toDmsString().

{
   ossimString result="";
   std::string::const_iterator stringIter;
   ossimString tempFormatString = formatString;
   if(formatString == ossimString(""))
   {
      tempFormatString = ossimDms::DEFAULT_FORMAT;
   }

   stringIter = tempFormatString.begin();
   int i, d_s;
   
/* assign a default format if none is given */
      
   init_values(theDegrees);
   
   while(stringIter != tempFormatString.end())
   {
      switch(*stringIter)
      {
         case '-':
         {
            result +=(theWorking < 0.0) ? ('-') : (' ');
            stringIter++;
            break;
         }
         
         case 'c':
         case 'C':
         {
            char temp;
            if (theWorking < 0.0)
            {
               temp = (theLatFlag == true) ? ('S') : ('W');
            }
            else
            {
               temp= (theLatFlag == true) ? ('N') : ('E');
            }
            
            if(*stringIter == 'c')
            {
               temp = tolower(temp);
            }
            result += temp;
            stringIter++;
            break;
         }
         
         case 'd':
         case 'D':
         {          /* how many 'd's until not 'd' */
            d_s = 1;
            ++stringIter;
            while (*stringIter == 'd' || *stringIter == 'D')
            {
               ++d_s;
               ++stringIter;
            }
            if (theAfterDot == true)
            {       /* beyond the decimal point */
               double fractionalDegrees = std::abs(theDegrees-(int)theDegrees);
               i = d_s;
               while (i > 0)
               {
                  fractionalDegrees = fractionalDegrees * 10.0;
                  result += ossimString::toString((int)fractionalDegrees);
                  fractionalDegrees = fractionalDegrees - (int)fractionalDegrees;
                  --i;
               }
               theIntDegs = (int)(theDecDegs);
            }
            else
            {
               theIntDegs = static_cast<int>( std::abs(theDegrees) );
               ossimString temp = ossimString::toString(theIntDegs);
               ossimString prefix;
               d_s -= (int)temp.length();
               while(d_s > 0)
               {
                  prefix += '0';
                  --d_s;
               }
               temp = prefix + temp;
               result += temp;
            }
//             // fill the rest with blanks
//             ossimString temp = ossimString::toString(theIntDegs);
//             d_s -= temp.length();
//             if(d_s>0)
//             {
//                if(theAfterDot)
//                {
                  
//                   while(d_s > 0)
//                   {
//                      temp+='0';
//                      --d_s;
//                   }
//                }
//                else
//                {
//                   ossimString prefix;
//                   while(d_s > 0)
//                   {
//                      prefix += '0';
//                      --d_s;
//                   }
//                   temp = prefix + temp;
//                }
//             }
            
            break;
         }
 
         case ' ':
         {          
            result += *stringIter;
            
            while (*stringIter == ' ')
            {
               result += *stringIter;
               stringIter++;
            }
            break;
         }
         
         case '.': 
         {
            theAfterDot = true;              
            result +=  *stringIter++;
            break;
         }
         
         case 'm':
         case 'M':
         case 's':
         case 'S':
         {
            if((*stringIter == 's') ||
               (*stringIter == 'S'))
            {
               theDoingSeconds = true;
            }
            
            calc_mins_or_secs(&theDecDegs, stringIter, result);
            break;
         }
         
         // This is code that I added so you can do additional
         // formatting.
         //
         case '\'':
         case '"':
         {
            result += *stringIter++;
            break;
         }
         case '@':
         {
            result += (char)theDegreeSign;
            stringIter++;
            break;
         }
         default:
         {
            if(theDoingSeconds)
            {
               theAfterDot = true;
            }
            result += *stringIter++;
         }
      } /* end switch statement */
   }    /* end while loop */
   
   return result;   
}

Member Data Documentation

DEFAULT_FORMAT

const char * ossimDms::DEFAULT_FORMAT = "ddd mm.mmC"

staticprivate

Definition at line 93 of file ossimDms.h.

Referenced by set_default(), and toString().

SPACES

const char * ossimDms::SPACES = " "

staticprivate

Definition at line 94 of file ossimDms.h.

Referenced by set_default().

theAfterDot

bool ossimDms::theAfterDot

mutableprivate

Definition at line 103 of file ossimDms.h.

Referenced by calc_mins_or_secs(), degree_to_string(), init_values(), setDegrees(), string_to_degree(), and toString().

theDecDegs

double ossimDms::theDecDegs

mutableprivate

Definition at line 102 of file ossimDms.h.

Referenced by degree_to_string(), init_values(), and toString().

theDegrees

double ossimDms::theDegrees

private

Definition at line 96 of file ossimDms.h.

Referenced by ossimDms(), setDegrees(), and toString().

theDegreeSign

const ossim_uint8 ossimDms::theDegreeSign = 176

static

Definition at line 90 of file ossimDms.h.

Referenced by degree_to_string(), setDegrees(), and toString().

theDoingSeconds

bool ossimDms::theDoingSeconds

mutableprivate

Definition at line 104 of file ossimDms.h.

Referenced by init_values(), and toString().

theIntDegs

int ossimDms::theIntDegs

mutableprivate

Definition at line 105 of file ossimDms.h.

Referenced by degree_to_string(), init_values(), and toString().

theLatFlag

bool ossimDms::theLatFlag

private

Definition at line 97 of file ossimDms.h.

Referenced by setDegrees(), string_to_degree(), and toString().

theSign

int ossimDms::theSign

mutableprivate

Definition at line 106 of file ossimDms.h.

Referenced by init_values(), setDegrees(), and string_to_degree().

theWorking

double ossimDms::theWorking

mutableprivate

Definition at line 107 of file ossimDms.h.

Referenced by degree_to_string(), init_values(), and toString().

---

The documentation for this class was generated from the following files:

• ossimDms.h
• ossimDms.cpp