ossimUsgsQuad Class Reference

#include <ossimUsgsQuad.h>

Public Member Functions
	ossimUsgsQuad (const ossimGpt &lrGpt)
	ossimUsgsQuad (const ossimString &name, const ossimDatum *datum)
void	setQuadName (const ossimString &name)
ossimGrect	quarterQuadSegRect (char seg)
ossimString	quarterQuadSegKwRect (char seg)
ossimGrect	quarterQuadRect () const
ossimString	quarterQuadKwRect () const
ossimGrect	quadRect () const
ossimString	quadKwRect () const
ossimString	quarterQuadName () const
ossimString	quarterQuadSegName () const
ossimGpt	lrQuadCorner () const
ossimGpt	lrQuarterQuadCorner () const

Static Public Member Functions
static void	getQuadList (std::vector< ossimUsgsQuad > &result, const ossimGrect &rect)

Protected Attributes
ossimString	theName
ossimGpt	theQuadLowerRightCorner
ossimGpt	theQuarterQuadLowerRightCorner
char	theQuarterQuadSegment

Detailed Description

Definition at line 20 of file ossimUsgsQuad.h.

Constructor & Destructor Documentation

ossimUsgsQuad() [1/2]

ossimUsgsQuad::ossimUsgsQuad

(

const ossimGpt &

lrGpt

)

Definition at line 34 of file ossimUsgsQuad.cpp.

Referenced by getQuadList().

   :
      theQuadLowerRightCorner(0.0, 0.0, 0.0, lrGpt.datum()),
      theQuarterQuadLowerRightCorner(0.0, 0.0, 0.0, lrGpt.datum())
//      thePaddingInDegrees(0.0, 0.0),

{
   const char* MODULE = "ImgOutput::quadBasename";

   //***
   // NOTE:
   // This method computes a file name from the lower right corner of the
   // image.  The format is derived from USGS Digital Raster Graphic(DRG)
   // program for standardized data set names for DRG products.  Due to
   // customer  requirements there is one deviation:  The first digit of the
   // name is converted to a letter with 1 being = A, 2 being = B,
   // 3 being = C, ....
   // This was done to allow the name to be used on a pc.
   //***

   const double QUAD_SIZE_IN_DEGREES = 0.125;

   ossimString          baseString;
   int                  tmpInt;
   double               tmpDbl;
   char quadChar        = 'A';
   char quadNum         = '1';

   ostringstream           os;
   os << setiosflags(ios::right)
      << setiosflags(ios::fixed)
      << setfill('0');

   tmpInt = static_cast<int>(abs(lrGpt.lat)); // Cast away the fractional part.
   os << tmpInt; // latitude

   //***
   // Get the quadrant charactor in the latitude direction. (A - H)
   //***
   tmpDbl = fabs(lrGpt.lat) - (double)tmpInt;
   quadChar += static_cast<int>(tmpDbl / QUAD_SIZE_IN_DEGREES);

   tmpInt = static_cast<int>(abs(lrGpt.lon)); // longitude
   os << setw(3) << tmpInt;

   tmpDbl = fabs(lrGpt.lon) - (double)tmpInt;

   quadNum += static_cast<char>(tmpDbl / QUAD_SIZE_IN_DEGREES);

   os << quadChar << quadNum;

   double latFraction = (lrGpt.lat / QUAD_SIZE_IN_DEGREES) -
                        ossim::round<int>((lrGpt.lat) / QUAD_SIZE_IN_DEGREES);
   double lonFraction = (lrGpt.lon / QUAD_SIZE_IN_DEGREES) -
                        ossim::round<int>((lrGpt.lon) / QUAD_SIZE_IN_DEGREES);

   // Black & White
//   if(theRectsStandardFlag && 
//      theChipSource->radiometry().numberOfBands() == 1)
//   {
//       char quarterQuadChar = '4';
//       if (latFraction && lonFraction)
//       {
//          quarterQuadChar = '1';
//       }
//       else if (latFraction && !lonFraction)
//       {
//          quarterQuadChar = '2';
//       }
//       else if (!latFraction && lonFraction)
//       {
//          quarterQuadChar = '3';
//       }   
//       os << quarterQuadChar << ends;
//    }
//    // Color 
//    else if(theRectsStandardFlag &&
//            theChipSource->radiometry().numberOfBands() > 1)
//    {
//       char quarterQuadChar = '8';
//       if (latFraction && lonFraction)
//       {
//          quarterQuadChar = '5';
//       }
//       else if (latFraction && !lonFraction)
//       {
//          quarterQuadChar = '6';
//       }
//       else if (!latFraction && lonFraction)
//       {
//          quarterQuadChar = '7';
//       }   
//       os << quarterQuadChar << ends;
//    }
//    else
//    {
      char quarterQuadChar = 'D';
      if (latFraction && lonFraction)
      {
         quarterQuadChar = 'A';
      }
      else if (latFraction && !lonFraction)
      {
         quarterQuadChar = 'B';
      }
      else if (!latFraction && lonFraction)
      {
         quarterQuadChar = 'C';
      }   
      os << quarterQuadChar << ends;
//   }

   
   baseString = os.str().c_str();

   if (traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << " DEBUG: " << MODULE  
         << "\nbaseString:  " << baseString << std::endl;
   }
   
   setQuadName(baseString);
}

ossimUsgsQuad() [2/2]

ossimUsgsQuad::ossimUsgsQuad	(	const ossimString &	name,
		const ossimDatum *	datum
	)

Definition at line 163 of file ossimUsgsQuad.cpp.

References setQuadName().

   :
      theQuadLowerRightCorner(0.0, 0.0, 0.0, datum),
      theQuarterQuadLowerRightCorner(0.0, 0.0, 0.0, datum)
//      thePaddingInDegrees(0.0, 0.0),
{
   static const char MODULE[] = "ossimUsgsQuad::ossimUsgsQuad";

   setQuadName(name);
   if (!datum)
   {
      if (traceDebug())
      {
         ossimNotify(ossimNotifyLevel_FATAL)
            << "FATAL: " << MODULE << "\n"
            << "ossimDatum pointer passed in is null. Returning...\n";
      }
      return;
   }


   //***
   // Initialize the padding.
   //***
//    ossimGpt metersPerDegree = theQuadLowerRightCorner.metersPerDegree();

//    thePaddingInDegrees.u = paddingInMeters / metersPerDegree.u;
//    thePaddingInDegrees.v = paddingInMeters / metersPerDegree.v;

}

Member Function Documentation

getQuadList()

void ossimUsgsQuad::getQuadList ( std::vector< ossimUsgsQuad > &  result, const ossimGrect &  rect  )

static

Definition at line 441 of file ossimUsgsQuad.cpp.

References ossimGpt::lond(), ossimUsgsQuad(), ossimGrect::pointWithin(), and ossimGrect::ul().

{
   result.clear();
//   QUAD_SIZE_IN_DEGREES;

   ossimGpt point = rect.ul();

   while(rect.pointWithin(point))
   {
      while(rect.pointWithin(point))
      {
         result.push_back(ossimUsgsQuad(point));

         point.lond(point.lond()+QUAD_SIZE_IN_DEGREES);
      }
      point.lond(rect.ul().lond());
      point.latd(point.latd()-QUAD_SIZE_IN_DEGREES);
   }
}

lrQuadCorner()

ossimGpt ossimUsgsQuad::lrQuadCorner ( ) const

inline

Returns the lower right hand corner of quad with no padding.

Definition at line 85 of file ossimUsgsQuad.h.

{ return theQuadLowerRightCorner ; }

lrQuarterQuadCorner()

ossimGpt ossimUsgsQuad::lrQuarterQuadCorner ( ) const

inline

Returns the lower right hand corner of quarter quad with no padding.

Definition at line 90 of file ossimUsgsQuad.h.

      { return theQuarterQuadLowerRightCorner; }

quadKwRect()

ossimString ossimUsgsQuad::quadKwRect

(

)

const

Returns the bounding rectangle of the quarter quad (7.5 minutes) in the "area.lat_lon" keyword format: start_lat, start_lon, stop_lat, stop_lon NOTE: padding is added in.

Definition at line 739 of file ossimUsgsQuad.cpp.

References ossimString::c_str(), ossimGpt::lat, ossimGrect::ll(), ossimGpt::lon, quadRect(), ossimGrect::ul(), and ossimGrect::ur().

{
//   static const char MODULE[] = "ossimUsgsQuad::quadKwRect";

   ossimGrect rect = quadRect();

   ostringstream os;

   os << setprecision(12)
      << rect.ll().lat  << " "
      << rect.ul().lon << " "
      << rect.ul().lat << " "
      << rect.ur().lon  << ends;
//    os << setprecision(12)
//       << rect.stop.lat  << " "
//       << rect.start.lon << " "
//       << rect.start.lat << " "
//       << rect.stop.lon  << ends;

   ossimString tmp = os.str().c_str();

   return tmp;
}

quadRect()

ossimGrect ossimUsgsQuad::quadRect

(

)

const

Returns the bounding rectangle of the quarter quad (7.5 minutes).
NOTE: padding is added in.

Definition at line 626 of file ossimUsgsQuad.cpp.

References ossimGpt::lat, ossimGpt::lon, and theQuadLowerRightCorner.

Referenced by quadKwRect().

{
   static const char MODULE[] = "ossimUsgsQuad::quadRect";

   double startLat = theQuadLowerRightCorner.lat;// -
//                     thePaddingInDegrees.u;  // SouthWest corner lat.

   double startLon = theQuadLowerRightCorner.lon -
                     QUAD_SIZE_IN_DEGREES;// -
//                     thePaddingInDegrees.v; // SouthWest corner lon.
   
   double stopLat = theQuadLowerRightCorner.lat +
                     QUAD_SIZE_IN_DEGREES;// +
//                    thePaddingInDegrees.u; // NorthEast corner lat.
   
   double stopLon  = theQuadLowerRightCorner.lon;// +
//                     thePaddingInDegrees.v; // NorthEast corner lon.

   ossimGrect
      rect(ossimGpt(startLat,
                    startLon,
                    theQuarterQuadLowerRightCorner.height(),
                    theQuarterQuadLowerRightCorner.datum()),
           ossimGpt(stopLat,
                    stopLon,
                    theQuarterQuadLowerRightCorner.height(),
                    theQuarterQuadLowerRightCorner.datum()));

   if (traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "DEBUG: " << MODULE
         << "\nQuarter quad rect:  " << rect << "\n";
   }

   return rect;
}

quarterQuadKwRect()

ossimString ossimUsgsQuad::quarterQuadKwRect

(

)

const

Returns the bounding rectangle of the quarter quad (3.75 minutes)
in the "area.lat_lon" keyword format: start_lat, start_lon, stop_lat, stop_lon NOTE: padding is added in.

Definition at line 710 of file ossimUsgsQuad.cpp.

References ossimString::c_str(), ossimGpt::lat, ossimGrect::ll(), ossimGpt::lon, quarterQuadRect(), ossimGrect::ul(), and ossimGrect::ur().

{
//   static const char MODULE[] = "ossimUsgsQuad::quarterQuadKwRect";

   ossimGrect rect = quarterQuadRect();

   ostringstream os;

   os << setprecision(12)
      << rect.ll().lat  << " "
      << rect.ul().lon << " "
      << rect.ul().lat << " "
      << rect.ur().lon  << ends;
//    os << setprecision(12)
//       << rect.stop.lat  << " "
//       << rect.start.lon << " "
//       << rect.start.lat << " "
//       << rect.stop.lon  << ends;

   ossimString tmp = os.str().c_str();



   return tmp;
}

quarterQuadName()

ossimString ossimUsgsQuad::quarterQuadName ( ) const

inline

Returns the USGS quarter quad name.

Definition at line 70 of file ossimUsgsQuad.h.

Referenced by ossimIgenGenerator::generateGeoTiledSpecList().

      {
         return ossimString(theName.begin(),
                            theName.begin()+7);
      }

quarterQuadRect()

ossimGrect ossimUsgsQuad::quarterQuadRect

(

)

const

Returns the bounding rectangle of the quarter quad (3.75 minutes).
NOTE: padding is added in.

Definition at line 584 of file ossimUsgsQuad.cpp.

References ossimGpt::lat, ossimGpt::lon, and theQuarterQuadLowerRightCorner.

Referenced by quarterQuadKwRect().

{
   static const char MODULE[] = "ossimUsgsQuad::quarterQuadRect";

   double startLat = theQuarterQuadLowerRightCorner.lat;// -
//                     thePaddingInDegrees.u;  // SouthWest corner lat.

   double startLon = theQuarterQuadLowerRightCorner.lon -
                     QUARTER_QUAD_SIZE_IN_DEGREES;// -
//                     thePaddingInDegrees.v; // SouthWest corner lon.
   
   double stopLat = theQuarterQuadLowerRightCorner.lat +
                     QUARTER_QUAD_SIZE_IN_DEGREES;// +
//                    thePaddingInDegrees.u; // NorthEast corner lat.
   
   double stopLon  = theQuarterQuadLowerRightCorner.lon;// +
//                     thePaddingInDegrees.v; // NorthEast corner lon.

   ossimGrect
      rect(ossimGpt(startLat,
                    startLon,
                    theQuarterQuadLowerRightCorner.height(),
                    theQuarterQuadLowerRightCorner.datum()),
           ossimGpt(stopLat,
                    stopLon,
                    theQuarterQuadLowerRightCorner.height(),
                    theQuarterQuadLowerRightCorner.datum()));

   if (traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "DEBUG: " << MODULE
         << "\nQuarter quad rect:  " << rect <<"\n";
   }


   return rect;
}

quarterQuadSegKwRect()

ossimString ossimUsgsQuad::quarterQuadSegKwRect

(

char

seg

)

Returns the bounding rectangle of the quarter quad segment in the "area.lat_lon" keyword format: start_lat, start_lon, stop_lat, stop_lon NOTE: padding is added in.

Definition at line 667 of file ossimUsgsQuad.cpp.

{
   static const char MODULE[] = "ossimUsgsQuad::quarterQuadSegKwRect";

   ossimString tmp;

   //***
   // Check the range of the segment, must be A, B, C or D.
   //***
   if ( (seg < 65) || (seg > 68) )
   {
      if (traceDebug())
      {
         ossimNotify(ossimNotifyLevel_FATAL)
            << "FATAL:" << MODULE << "\n"
            << seg << " out of range!\n"
            << "Possible values:  A, B, C, or D\n";
      }
      return tmp;
   }

   ossimGrect rect = quarterQuadSegRect(seg);

   ostringstream os;

   os << setprecision(12)
      << rect.ll().lat  << " "
      << rect.ul().lon << " "
      << rect.ul().lat << " "
      << rect.ur().lon  << ends;
//      << rect.stop.lat  << " "
//      << rect.start.lon << " "
//      << rect.start.lat << " "
//      << rect.stop.lon  << ends;

   tmp = os.str().c_str();

   return tmp;
}

quarterQuadSegName()

ossimString ossimUsgsQuad::quarterQuadSegName ( ) const

inline

Definition at line 76 of file ossimUsgsQuad.h.

Referenced by ossimIgenGenerator::generateGeoTiledSpecList().

      {
         return theName;
      }

quarterQuadSegRect()

ossimGrect ossimUsgsQuad::quarterQuadSegRect

(

char

seg

)

Returns the bounding rectangle of the quarter quad segment. A segment is 1/4 of a quarter quad. Segment assingments: upper_left=A, upper_right=B, lower_left=C, lower_right=D NOTE: padding is added in.

Definition at line 466 of file ossimUsgsQuad.cpp.

References ossimGpt::lat, and theQuarterQuadLowerRightCorner.

{
   static const char MODULE[] = "ossimUsgsQuad::quarterQuadSegRect";

   double startLat=0.0;
   double startLon=0.0;
   double stopLat=0.0;
   double stopLon=0.0;

   //***
   // Get the segment and add to "lat" and "lon".
   //***
   switch (seg)
   {
   case 'A':  // Upper left segment of quarter quad.
      startLat = theQuarterQuadLowerRightCorner.lat +
                 QUARTER_QUAD_SEG_SIZE_IN_DEGREES;// -
//                 thePaddingInDegrees.u;

      startLon = theQuarterQuadLowerRightCorner.lon -
                 QUARTER_QUAD_SIZE_IN_DEGREES;// -
                 //thePaddingInDegrees.v;
                 
      stopLat = theQuarterQuadLowerRightCorner.lat +
                QUARTER_QUAD_SIZE_IN_DEGREES;// +
                                             //thePaddingInDegrees.u;

      stopLon =  theQuarterQuadLowerRightCorner.lon -
                 QUARTER_QUAD_SEG_SIZE_IN_DEGREES; // +
                                                  //thePaddingInDegrees.v;
      break;

   case 'B': // Upper right segment of the quarter quad.
      startLat = theQuarterQuadLowerRightCorner.lat +
                 QUARTER_QUAD_SEG_SIZE_IN_DEGREES; //-
//                 thePaddingInDegrees.u;

      startLon = theQuarterQuadLowerRightCorner.lon -
                 QUARTER_QUAD_SEG_SIZE_IN_DEGREES;// -
//                 thePaddingInDegrees.v;
                 
      stopLat = theQuarterQuadLowerRightCorner.lat +
                QUARTER_QUAD_SIZE_IN_DEGREES;// +
//                thePaddingInDegrees.u;

      stopLon =  theQuarterQuadLowerRightCorner.lon;// +
//                 thePaddingInDegrees.v;
      break;

   case 'C': // Lower left segment of the quarter quad.
      startLat = theQuarterQuadLowerRightCorner.lat;// -
//                 thePaddingInDegrees.u;

      startLon = theQuarterQuadLowerRightCorner.lon -
                 QUARTER_QUAD_SIZE_IN_DEGREES;// -
//                 thePaddingInDegrees.v;
                 
      stopLat = theQuarterQuadLowerRightCorner.lat +
                QUARTER_QUAD_SEG_SIZE_IN_DEGREES;// +
//                thePaddingInDegrees.u;

      stopLon =  theQuarterQuadLowerRightCorner.lon -
                 QUARTER_QUAD_SEG_SIZE_IN_DEGREES;// +
//                 thePaddingInDegrees.v;

      break;

   case 'D':
      startLat = theQuarterQuadLowerRightCorner.lat;// -
//                 thePaddingInDegrees.u;

      startLon = theQuarterQuadLowerRightCorner.lon -
                 QUARTER_QUAD_SEG_SIZE_IN_DEGREES;// -
//                 thePaddingInDegrees.v;
                 
      stopLat = theQuarterQuadLowerRightCorner.lat +
                QUARTER_QUAD_SEG_SIZE_IN_DEGREES;// +
//                thePaddingInDegrees.u;

      stopLon =  theQuarterQuadLowerRightCorner.lon;// +
//                 thePaddingInDegrees.v;
      break; // At the corner of a quad so nothing to do here.

   default:
      if (traceDebug())
      {
         ossimNotify(ossimNotifyLevel_FATAL)
            << "FATAL:" << MODULE << "\n"
            << "Quarter quad segment range error.\n"
            << "Quarter quad segment extracted:  " << seg
            << "Range:  A to D\n";
      }
      break;
   }

   ossimGrect
      rect(ossimGpt(startLat,
                    startLon,
                    theQuarterQuadLowerRightCorner.height(),
                    theQuarterQuadLowerRightCorner.datum()),
           ossimGpt(stopLat,
                    stopLon,
                    theQuarterQuadLowerRightCorner.height(),
                    theQuarterQuadLowerRightCorner.datum()));

   if (traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "DEBUG: " << MODULE
         << "\nQuarter quad segment " << seg << " rect:  " << rect << "\n";
   }

   return rect;
}

setQuadName()

void ossimUsgsQuad::setQuadName

(

const ossimString &

name

)

Definition at line 196 of file ossimUsgsQuad.cpp.

References ossimString::length().

Referenced by ossimUsgsQuad().

{
   const char* MODULE = "ossimUsgsQuad::setQuadName";
   ossimString qqName = name;

   //***
   // Check the length of "name" to see if it's correct.  
   //***
   if (name.length() < 7)
   {
      if (traceDebug())
      {
         ossimNotify(ossimNotifyLevel_FATAL)
            << "FATAL: " << MODULE << "\n"
            << "Quarder quad name length incorrect.\n"
            << "Name:  " << name << "\n"
            << "Expected length:  7 or 8  Name length:  " << name.length()
            << "\nExample of valid quad:  30089C6B\n"
            << "Represents lower right corner of "
            << "30 deg. 15 min. N., 89 deg. 37.5 min. W.\n"
            << "Breakdown:\n"
            << "30  = latitude on even degree boundary "
            << "(Northern Hemisphere implied)\n"
            << "089 = longitude on even degree boundary "
            << "(Western Hemisphere implied)\n"
            << "C   = Third quad section in latitude direction\n"
            << "6   = Sixth quad section in longitude direction\n"
            << "B   = Quarter quad segment within the quad\n"
            << "  (A=upper left, B=upper right, C=lower left, D=lower right)\n"
            << "Quad size 7.5 minute square,  quarter quad size 3.75 "
            << "minute square.\n";
      }
      
      return;
   }

   qqName.upcase();

   char latChars[3];
   char lonChars[4];
   char latQuad;
   char lonQuad;
//   char segment;

   //***
   // Get the latitude.
   //***
   latChars[0] = qqName.c_str()[0];
   latChars[1] = qqName.c_str()[1];
   latChars[2] = '\0';

   //***
   // Get the longitude.
   //***
   lonChars[0] = qqName.c_str()[2];
   lonChars[1] = qqName.c_str()[3];
   lonChars[2] = qqName.c_str()[4];
   lonChars[3] = '\0';

   //***
   // Get the latitude quad.
   //***
   latQuad = qqName.c_str()[5];

   //***
   // Get the longitude quad.
   //***
   lonQuad = qqName.c_str()[6];

   //***
   // Get the segment within the quad.
   //***
   if (name.length() == 8)
   {
      theQuarterQuadSegment = qqName.c_str()[7];
   }
   else
   {
      theQuarterQuadSegment = 'D';
      if (traceDebug())
      {
         ossimNotify(ossimNotifyLevel_NOTICE)
            << MODULE << ":\n"
            << "No quarter quad segment entered.  Defaulting to D segment."
            << std::endl;
      }
   }

   //***
   // Build up the lower right corner from the extracted parts.
   //***

   //***
   // Get the latitude and check the range.
   //***
   double lat = atof(latChars);
   if ( (lat < 0.0) || (lat > 90.0) )
   {
      if (traceDebug())
      {
         ossimNotify(ossimNotifyLevel_FATAL)
            << "FATAL: " << MODULE << "\n"
            << "Latitude range error.  Latitude extracted:  " << lat
            << "\nRange:  0 to 90\n";
      }
      return;
   }

   //***
   // Get the longitude and check the range.
   //***
   double lon = atof(lonChars);
   if ( (lon  < 0.0) || (lon > 180) )
   {
      if (traceDebug())
      {
         ossimNotify(ossimNotifyLevel_FATAL)
            << "FATAL: " << MODULE << "\n"
            << "Longitud range error.  Longitude extracted:  " << lon
            << "\nRange:  0 to 180\n";
      }
      return;
   }

   //***
   // Get the latitude quad and add this to "lat".  The quad are letters from
   // A - H with A being on an even degree boundary, B being 7.5 minute up
   // and so on.
   //***
   double tmp = latQuad - 65;  // Ascii decimal value for A = 65.

   if (tmp)
   {
      //***
      // Check the range.  The are eight quads within one degree.
      //***
      if (tmp > 7.0)
      {
         if (traceDebug())
         {
            ossimNotify(ossimNotifyLevel_FATAL)
               << "FATAL:" << MODULE << "\n"
               << "Latitude quad range error.  Quad extracted:  " << latQuad
               << "\nRange:  A to H\n";
         }
         return;
      }

      tmp *= 7.5;  // Convert the quad to minutes.

      lat += tmp/60.0; // Conver minutes to degrees and add to "lat".
   }
   
   //***
   // Get the longitude quad and add this to "lat".  The quad are letters from
   // A - H with A being on an even degree boundary, B being 7.5 minute up
   // and so on.
   //***
   tmp = lonQuad - 49; // Ascii decimal value for 1 = 49.

   if (tmp)
   {
      //***
      // Check the range.  The are eight quads within one degree.
      //***
      if (tmp > 7.0)
      {
         if (traceDebug())
         {
            ossimNotify(ossimNotifyLevel_FATAL)
               << "FATAL:" << MODULE << "\n"
               << "Longitude quad range error.  Quad extracted:  " << latQuad
               << "\nRange:  1 to 8\n";
         }
         return;
      }

      tmp *= 7.5;  // Convert the quad to minutes.

      lon += tmp/60.0; // Conver minutes to degrees and add to "lon".
   }
   
   //***
   // Currently this naming convention assumes Northern and Western hemisphere.
   //***
   lon = -lon;  // Make negative for Western hemisphere.

   //***
   // Initialize "theQuadLowerRightCorner".
   //***
   theQuadLowerRightCorner.lat = lat;
   theQuadLowerRightCorner.lon = lon;

   //***
   // Get the segment and add to "lat" and "lon".
   //***
   switch (theQuarterQuadSegment)
   {
   case 'A':
      lat += QUARTER_QUAD_SIZE_IN_DEGREES;
      lon -= QUARTER_QUAD_SIZE_IN_DEGREES;
      break;

   case 'B':
      lat += QUARTER_QUAD_SIZE_IN_DEGREES;
      break;

   case 'C':
      lon -= QUARTER_QUAD_SIZE_IN_DEGREES;
      break;

   case 'D':
      break; // At the corner of a quad so nothing to do here.

   default:
      if (traceDebug())
      {
         ossimNotify(ossimNotifyLevel_FATAL)
            << "FATAL:" << MODULE << "\n"
            << "Quarter quad segment range error.\n"
            << "Quarter quad segment extracted:  " << theQuarterQuadSegment
            << "Range:  A to D\n";
      }
      return;
   }

   //***
   // Initialize "theQuarterQuadLowerRightCorner".
   //***
   theQuarterQuadLowerRightCorner.lat = lat;
   theQuarterQuadLowerRightCorner.lon = lon;

   if (traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "DEBUG: " << MODULE << ", "
         << qqName << " lower right quad corner:  "
         << theQuadLowerRightCorner << "\n"
         << "Quarter quad segment:  " << theQuarterQuadSegment << "\n"
         << qqName << " lower right quarter quad corner:  "
         << theQuarterQuadLowerRightCorner << "\n";
   }   
   theName = qqName;
}

Member Data Documentation

theName

ossimString ossimUsgsQuad::theName

protected

Definition at line 97 of file ossimUsgsQuad.h.

theQuadLowerRightCorner

ossimGpt ossimUsgsQuad::theQuadLowerRightCorner

protected

Definition at line 98 of file ossimUsgsQuad.h.

Referenced by quadRect().

theQuarterQuadLowerRightCorner

ossimGpt ossimUsgsQuad::theQuarterQuadLowerRightCorner

protected

Definition at line 99 of file ossimUsgsQuad.h.

Referenced by quarterQuadRect(), and quarterQuadSegRect().

theQuarterQuadSegment

char ossimUsgsQuad::theQuarterQuadSegment

protected

Definition at line 101 of file ossimUsgsQuad.h.

---

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

• ossimUsgsQuad.h
• ossimUsgsQuad.cpp