C++ ossimKeywordlist::numberOf方法代码示例

bool ossimOpjCompressor::loadState(const ossimKeywordlist& kwl,
                                      const char* prefix)
{
   const char* value = 0;

   value = kwl.find(prefix, ossimKeywordNames::COMPRESSION_QUALITY_KW);
   if(value)
   {
      setQualityTypeString( ossimString(value) );
   }
   
   value = kwl.find(prefix, LEVELS_KW);
   if(value)
   {
      m_levels = ossimString(value).toInt32();
   }
   
   value = kwl.find(prefix, REVERSIBLE_KW);
   if(value)
   {
      setReversibleFlag(ossimString(value).toBool());
   }

   value = kwl.find(prefix, ADD_ALPHA_CHANNEL_KW);
   if(value)
   {
      m_alpha = ossimString(value).toBool();
   }
   
   value = kwl.find(prefix, THREADS_KW);
   if(value)
   {
      m_threads = ossimString(value).toInt32();
   }

   ossimString searchKey;
   if (prefix)
   {
      searchKey = prefix;
   }
   searchKey += "option";
   ossim_uint32 nOptions = kwl.numberOf(searchKey);
   for (ossim_uint32 i = 0; i < nOptions; ++i)
   {
      ossimString key = searchKey;
      key += ossimString::toString(i);
      
      const char* lookup = kwl.find(key.c_str());
      if (lookup)
      {
         m_options.push_back(ossimString(lookup));
      }
   }
   
   return true;
}

//*****************************************************************************
//  METHOD: ossimImageViewProjectionTransform::loadState
//*****************************************************************************
bool ossimImageViewProjectionTransform::loadState(const ossimKeywordlist& kwl,
                                                  const char* prefix)
{
   bool result = ossimImageViewTransform::loadState(kwl, prefix);
   if(result)
   {
      ossimString imagePrefix = ossimString(prefix)+"image_geometry.";
      ossimString viewPrefix  = ossimString(prefix)+"view_geometry.";
      if(kwl.numberOf(imagePrefix.c_str())>0)
      {
         m_imageGeometry = new ossimImageGeometry();
         m_imageGeometry->loadState(kwl, imagePrefix.c_str());
      }
      if(kwl.numberOf(viewPrefix.c_str())>0)
      {
         m_viewGeometry = new ossimImageGeometry();
         m_viewGeometry->loadState(kwl, viewPrefix.c_str());
      }
      
   }
   
   return result;
}

void ossimPiecewiseRemapper::ossimBandRemap::loadState( const ossimKeywordlist& kwl,
                                                        const std::string& prefix,
                                                        ossim_uint32 band )
{
   //---
   // Band Remap set example:
   // band0.remap0:((0, 127, 0, 127), (128, 255, 128, 382))
   // band0.remap1:((0, 382, 0, 255))
   //---

   // Clear the sets:
   m_remap.clear();
   
   // Get the number of remaps for this band.
   std::string keyBase = "band";
   keyBase += ossimString::toString(band).string();
   keyBase += ".";
   keyBase += REMAP_KW;
   
   ossim_uint32 NUMBER_REMAPS = kwl.numberOf(prefix.c_str(), keyBase.c_str());
   ossim_uint32 found = 0;
   ossim_uint32 index = 0;
   
   // Loop to find band remaps.  This allows for skipping indexes. 
   while ( found < NUMBER_REMAPS )
   {
      std::string key = keyBase + ossimString::toString(index).string();
      std::string value = kwl.findKey( prefix, key );
      if ( value.size() )
      {
         ossimPiecewiseRemapper::ossimRemapSet set;
         if ( initRemapSetFromString( value, set ) )
         {
            m_remap.push_back( set );
         }
         ++found;
      }
      
      ++index;
      if ( index > (NUMBER_REMAPS+100) )
      {
         break;
      }
   }
   
} // End: ossimPiecewiseRemapper::ossimBandRemap::loadState

void testIpts( ossimRefPtr<ossimNitfRsmModel>& model, const ossimKeywordlist& kwl )
{
   if ( model.valid() )
   {
      cout << std::setfill(' ') << setiosflags(ios::left);

      const std::string  ID_KW      = "itest_id";
      const std::string  IPT_KW     = "itest_ipt";
      const std::string  IPT_GT_KW  = "itest_gt"; // ground truth      
      const std::string  IPT_HGT_KW = "itest_hgt";
      const ossim_uint32 POINTS     = kwl.numberOf( ID_KW.c_str() );
   
      // Test data height values can be in feet.
      ossimUnitType heightUnits = OSSIM_METERS;
      std::string key = "itest_height_units";
      std::string value = kwl.findKey( key );
      if ( value.size() )
      {
         cout << key << ": " << value << "\n";
         if ( value == "feet" )
         {
            heightUnits = OSSIM_FEET;
         }
      }

      // Test the pixel type.
      ossim_float64 iptShift = 0.0;
      key = "pixel_type";
      value = kwl.findKey( key );
      if ( value.size() )
      {
         if ( value == "area" )
         {
            iptShift = -0.5;
            cout << key << ": " << value << "\n";
            cout << "input_line_sample_shift: " << iptShift << "\n";
         }
      }     
      
      cout << "\nitest begin ********************************\n\n"
           << "number_of_line_sample_points: " << POINTS << "\n";
      
      ossim_uint32 foundPts = 0;
      ossim_uint32 i = 0;

      while ( foundPts < POINTS )
      {
         // ID:
         key = ID_KW + ossimString::toString( i ).string();
         value = kwl.findKey( key );
         if ( value.size() )
         {
            cout << "itest_id" << std::setw(9) << i << ":  " << value << "\n";
         }
      
         // Image point, sample, line:
         key = IPT_KW + ossimString::toString( i ).string();
         value = kwl.findKey( key );
      
         if ( value.size() )
         {
            ossimDpt ipt; // image point
            ossimGpt wpt; // world point
            ossimGpt gt;  // ground truth
            ossimDpt gtd; // wpt to gt delta
            ossimDpt rtp; // round trip point
            ossimDpt rtd; // round trip delta;
         
            ipt.toPoint( value );
            ipt.x += iptShift;
            ipt.y += iptShift;
         
            cout << "itest_ipt" << std::setw(8) << i << ":  " << value << "\n";
         
            // Get the height above ellipsoid:
            ossim_float64 hgt = 0.0;
            key = IPT_HGT_KW + ossimString::toString( i ).string();
            value = kwl.findKey( key );
            if ( value.size() )
            {
               ossimString os ( value );
               hgt = os.toFloat64();
            
               if ( heightUnits == OSSIM_FEET )
               {
                  hgt *= MTRS_PER_FT;
               }
            }
            else
            {
               cerr << "missing height above ellipsoid for point!  Using 0.0."
                    << endl;
            }
         
            cout << "itest_hgt" << std::setw(8) << i << ":  " << value << "\n";
         
            model->lineSampleHeightToWorld( ipt, hgt, wpt );

            cout << "itest_wpt" << std::setw(8) << i << ":  " << wpt << "\n";
            
//.........这里部分代码省略.........

void testGpts( ossimRefPtr<ossimNitfRsmModel>& model, const ossimKeywordlist& kwl )
{
   if ( model.valid() )
   {
      cout << std::setfill(' ') << setiosflags(ios::left);
      
      const std::string  ID_KW  = "gtest_id";
      const std::string  GPT_KW = "gtest_gpt";
      const ossim_uint32 POINTS = kwl.numberOf( ID_KW.c_str() );
      
      cout << "\ngtest begin ********************************\n\n"
           << "number_of_points_world_points: " << POINTS << "\n";
      
      ossim_uint32 foundPts = 0;
      ossim_uint32 i = 0;
      
      std::string key;
      std::string value;
      
      while ( foundPts < POINTS )
      {
         // ID:
         key = ID_KW + ossimString::toString( i ).string();
         value = kwl.findKey( key );
         if ( value.size() )
         {
            cout << "gtest_id" << std::setw(6) << i << ":  " << value << "\n";
         }
      
         // World point :
         key = GPT_KW + ossimString::toString( i ).string();
         value = kwl.findKey( key );
      
         if ( value.size() )
         {
            ossimDpt ipt; // image point
            ossimGpt wpt; // world point
            ossimGpt rtp; // round trip point
            ossimDpt rtd; // round trip delta;
         
            wpt.toPoint( value );

            cout << "gtest_gpt" << std::setw(5) << i << ":  " << wpt << "\n";

            model->worldToLineSample( wpt, ipt );

            if ( wpt.hasNans() == false )
            {
               model->lineSampleHeightToWorld( ipt, wpt.hgt, rtp );
            
               rtd.x = wpt.lon - rtp.lon;
               rtd.y = wpt.lat - rtp.lat;
            
               cout << "gtest_ipt" << std::setw(5) << i << ":  " << ipt << "\n"
                    << "gtest_rtp" << std::setw(5) << i << ":  " << rtp << "\n"
                    << "gtest_rtd" << std::setw(5) << i << ":  " << rtd << "\n\n";  
            }
            else
            {
               cerr << "model->worldToLineSample(...) result has nans!\n"
                    << wpt << endl;
            }
         
            ++foundPts;
         }
      
         ++i;
      
         if ( i > POINTS+100 )
         {
            break;
         }
      }

      cout << "\ngtest end **********************************\n\n";
   }
   
} // End: testGpts