C++ ossimKeywordlist类代码示例

bool ossimAdjustmentInfo::saveState(ossimKeywordlist& kwl,
                                    const ossimString& prefix)const
{
   kwl.add(prefix,
           ossimKeywordNames::DESCRIPTION_KW,
           getDescription(),
           true);
   kwl.add(prefix.c_str(),
           NUMBER_OF_PARAMS_KW,
           static_cast<ossim_uint32>(theParameterList.size()),
           true);

   kwl.add(prefix,
           DIRTY_FLAG_KW,
           (short)theDirtyFlag,
           true);

   ossimString value;
   for(ossim_uint32 idx = 0; idx < theParameterList.size();++idx)
   {
      ossimString newPrefix = ossimString(prefix) + (ossimString(PARAM_PREFIX) + ossimString::toString(idx)+".");
      theParameterList[idx].saveState(kwl, newPrefix.c_str());
   }

   return true;
}

bool ossimAdjustmentInfo::loadState(const ossimKeywordlist& kwl,
                                    const ossimString& prefix)
{
   setDescription(kwl.find(prefix, ossimKeywordNames::DESCRIPTION_KW));
   setNumberOfAdjustableParameters(ossimString(kwl.find(prefix, NUMBER_OF_PARAMS_KW)).toUInt32());
   const char *dirtyFlag = kwl.find(prefix, DIRTY_FLAG_KW);
   ossimString value;

   if(dirtyFlag)
   {
      theDirtyFlag = ossimString(dirtyFlag).toBool();
   }
   else
   {
      theDirtyFlag = false;
   }

   for(ossim_uint32 idx = 0; idx < theParameterList.size();++idx)
   {
      ossimString newPrefix = ossimString(prefix) + (ossimString(PARAM_PREFIX) + ossimString::toString(idx)+".");
      if(!theParameterList[idx].loadState(kwl, newPrefix.c_str()))
      {
         return false;
      }
   }

   return true;
}

bool ossimImageToPlaneNormalFilter::saveState(ossimKeywordlist& kwl,
                                              const char* prefix)const
{
   kwl.add(prefix,
           ossimKeywordNames::SCALE_PER_PIXEL_X_KW,
           theXScale,
           true);

   kwl.add(prefix,
           ossimKeywordNames::SCALE_PER_PIXEL_Y_KW,
           theXScale,
           true);

   kwl.add(prefix,
           "track_scale_flag",
           (ossim_uint32)theTrackScaleFlag,
           true);

   kwl.add(prefix,
           SMOOTHNESS_FACTOR_KW,
           theSmoothnessFactor,
           true);

   return ossimImageSourceFilter::saveState(kwl, prefix);
}

bool ossimBlendMosaic::loadState(const ossimKeywordlist& kwl,
                                 const char* prefix)
{
   bool result = ossimImageMosaic::loadState(kwl, prefix);
   ossim_uint32 count = 0;
   theWeights.clear();
   if(result)
   {
      ossimString copyPrefix    = prefix;
      ossimString regExpression =  ossimString("^(") + copyPrefix + "weight[0-9]+)";
      ossim_uint32 result = kwl.getNumberOfSubstringKeys(regExpression);
            
      ossim_uint32 numberOfMatches = 0;
      while(numberOfMatches < result)
      {
         ossimString value = ossimString("weight") + ossimString::toString(count);

         const char* lookup = kwl.find(copyPrefix.c_str(),
                                       value.c_str());
         
         if(lookup)
         {
            ++numberOfMatches;
            theWeights.push_back(ossimString(lookup).toDouble());
         }

         ++count;
      }
   }
   
   return result;
}

bool ossimMemoryImageSource::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
   bool returnResult =  ossimImageSource::loadState(kwl, prefix);
   m_geometry = 0;
   if(returnResult)
   {
      ossimString imagePrefix = ossimString(prefix) + "image.";
      ossimString geomPrefix = ossimString(prefix) + "geom.";
      
      ossimString type = kwl.find(imagePrefix, "type");
      if(!type.empty())
      {
         m_image = new ossimImageData();
         returnResult = m_image->loadState(kwl, imagePrefix.c_str());
         m_image->initialize();
         m_boundingRect = m_image->getImageRectangle();
      }
      
      if(returnResult)
      {
         type = kwl.find(geomPrefix, "type");
         if(!type.empty())
         {
            m_geometry = new ossimImageGeometry();
            returnResult = m_geometry->loadState(kwl, geomPrefix.c_str());
         }
      }
   }
   m_result = 0;
   return returnResult;
}

bool ossimTilingPoly::loadState(const ossimKeywordlist& kwl,
                            const char* prefix)
{
   bool result = ossimTilingRect::loadState(kwl, prefix);
   
   //Get the shp file if any
   m_shpFilename = kwl.find(prefix, "tile_source");

   // Get the mask if any.
   if (!m_shpFilename.empty())
   {
      if (theTileNameMask.contains("%r%_%c%"))
      {
         theTileNameMask = theTileNameMask.substitute("%r%_%c%", "%f%", true);
      }
      result = true;
   }
 
   const char* useMbr = kwl.find(prefix, "padding_use_mbr");
   if (useMbr)
   {
      if (!ossimString(useMbr).toBool())
      {
         m_useMbr = false;
         m_bufferDistance = thePaddingSizeInPixels.x;
      }
   }

   return result;
}

/***************************************************************
* This method saves the filter state between property box edits
***************************************************************/
bool ossimCFARFilter::saveState(ossimKeywordlist& kwl,
                                          const char* prefix)const
{   
   kwl.add(prefix,
           "rows",
           5,
           true);
   
   kwl.add(prefix,
           "cols",
           5,
           true);
   
   for(ossim_int32 row = 0; row < 5; ++row)
   {
      for(ossim_int32 col =0; col < 5; ++col)
      {
         ossimString newPrefix = "m" +
                                 ossimString::toString(row+1) + "_" +
                                 ossimString::toString(col+1);
         kwl.add(prefix,
                 newPrefix,
                 theKernel[row][col],
                 true);          
      }
   }   
   
	kwl.add(prefix,
           "threshold",
           theThreshold,
           true);
   
   return ossimImageSourceFilter::saveState(kwl, prefix);
}

bool buildChains(const ossimKeywordlist& kwl,
                 ossimConnectableObject::ConnectableObjectList& chains)
{
   ossim_int32 index = 0;
   ossim_int32 result = kwl.getNumberOfSubstringKeys("file[0-9]+\\.filename");
   const char* lookup = NULL;
   ossim_int32 numberOfMatches = 0;
   vector<ossimFilename> fileList;
   
   while(numberOfMatches < result)
   {
      ossimString searchValue = "file" + ossimString::toString(index);
      
      ossimString filename = searchValue + ".filename";
      lookup = kwl.find(filename.c_str());
      if(lookup)
      {
         fileList.push_back(ossimFilename(lookup));
         ++numberOfMatches;
      }
      ++index;
   }
      
   return buildChains(fileList,
                      chains);
}

bool ossimCosmoSkymedModel::InitSRGR(const ossimKeywordlist &kwl, const char *prefix)
{
  const char* rangeProjectionType_str = kwl.find(prefix,"rangeProjectionType");
  std::string rangeProjectionType(rangeProjectionType_str);

  const char* pixel_spacing_str = kwl.find(prefix,"pixel_spacing");
  _pixel_spacing= atof(pixel_spacing_str);

  _isProductGeoreferenced = (rangeProjectionType=="GROUNDRANGE") ;

  // Number of columns
  const char* nbCol_str = kwl.find(prefix,"nbCol");
  _nbCol = atoi(nbCol_str);

  // SRGR polynomial reference
  const char* SrGr_R0_str = kwl.find(prefix,"SrGr_R0");
  _SrGr_R0 = atof(SrGr_R0_str);

  // SRGR coefficients
  char name[64];
  double coeff ;
  for(int i=0;i<6;i++)
  {
    sprintf(name,"SrToGr_coeffs_%i",i);
    const char* coeff_str = kwl.find(prefix,name);
    coeff = atof(coeff_str);
    _SrGr_coeffs.push_back(coeff);
  }

  return true;
}

bool ImageNoise::saveState(ossimKeywordlist& kwl, const char* prefix) const
{
   std::string pfx;
   std::string pfx2;
   if (prefix)
   {
      pfx = prefix;
   }
  pfx += PREFIX;
  kwl.add(pfx.c_str(), TIME_UTC,  _timeUTC);

  pfx2 = pfx + NOISE_ESTIMATE;
  kwl.add(pfx2.c_str(), VALIDITY_RANGE_MIN,  _validityRangeMin);
  kwl.add(pfx2.c_str(), VALIDITY_RANGE_MAX,  _validityRangeMax);
  kwl.add(pfx2.c_str(), REFERENCE_POINT,  _referencePoint);
  kwl.add(pfx2.c_str(), POLYNOMIAL_DEGREE,  _polynomialDegree);

  for(unsigned int i=0 ; i<_polynomialCoefficients.size();i++)
  {
         ossimString iStr = ossimString::toString(i);
         ossimString kw = ossimString(COEFFICIENT) + "["+iStr+ "]";
         kwl.add(pfx2.c_str(), kw.c_str(), _polynomialCoefficients[i]);
  }

   return true;
}

bool ossimQtVceShape::loadState(const ossimKeywordlist& kwl,
                                const char* prefix)
{
   const char* id = kwl.find(prefix, ossimKeywordNames::ID_KW);
   const char* selectionSize = kwl.find(prefix, "selection_box_size");
   const char* position = kwl.find(prefix, "position");

   if(id)
   {
      theId = ossimString(id).toInt();
   }
   if(selectionSize)
   {
      std::stringstream s(selectionSize);
      int w, h;
      s >> w >> h;
      theSelectionBoxSize = QSize(w, h);
   }
   
   if(position)
   {
      std::stringstream s(position);
      int x, y;
      s >> x >> y;

      setX(x);
      setY(y);
   }
   
   return true;
}

bool ossimQtVceShape::saveState(ossimKeywordlist& kwl,
                                const char* prefix)const
{
   kwl.add(prefix,
           ossimKeywordNames::TYPE_KW,
           "ossimQtVceShape",
           true);
   kwl.add(prefix,
           ossimKeywordNames::ID_KW,
           theId,
           true);
   kwl.add(prefix,
           "selection_box_size",
           ossimString::toString(theSelectionBoxSize.width())+" "+
           ossimString::toString(theSelectionBoxSize.height()),
           true);
   kwl.add(prefix,
           "position",
           ossimString::toString((int)x())+" "+
           ossimString::toString((int)y()),
           true);

   QRect b = boundingVceShapeRect();

   return true;
}

bool ossimLambertConformalConicProjection::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
   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);

   setDefaults();
   
   if(ossimString(type) == STATIC_TYPE_NAME(ossimLambertConformalConicProjection))
   {
      Lambert_False_Easting  = theFalseEastingNorthing.x;
      Lambert_False_Northing = theFalseEastingNorthing.y;

      if(stdParallel1)
      {
         Lambert_Std_Parallel_1 = ossimString(stdParallel1).toDouble()*RAD_PER_DEG;
      }
      if(stdParallel2)
      {
         Lambert_Std_Parallel_2 = ossimString(stdParallel2).toDouble()*RAD_PER_DEG;
      }
   }
   update();
   return flag;
}

bool RefPoint::saveState(ossimKeywordlist& kwl, const char* prefix) const
{
   bool result = true;

   std::string pfx;
   if (prefix)
   {
      pfx = prefix;
   }
   pfx += PREFIX;

   if (_ephemeris)
   {
      result = _ephemeris->saveState(kwl, pfx.c_str());
   }
   else
   {
      result = false;
   }

   kwl.add(pfx.c_str(), DISTANCE_KW, _distance);
   kwl.add(pfx.c_str(), LINE_KW,     _pix_line);
   kwl.add(pfx.c_str(), COL_KW,      _pix_col);

   return result;
}

/***************************************************************
* This method loads the filter state between property box edits
***************************************************************/
bool ossimCFARFilter::loadState(const ossimKeywordlist& kwl,
                                          const char* prefix)
{
   ossimString newPrefix = prefix;
   newPrefix += ossimString("m");
   
   for(ossim_int32 r = 0; r < 5; r++)
   {
      for(ossim_int32 c = 0; c < 5; c++)
      {
         theKernel[r][c] = 0.0;
         
         ossimString value = ossimString::toString(r+1);
         value += "_";
         value += ossimString::toString(c+1);
         
         const char* v = kwl.find(newPrefix.c_str(),
                                  value.c_str());
         if(v)
         {
            theKernel[r][c] = ossimString(v).toDouble();
         }
      }
   }
   const char* threshold = kwl.find(prefix, "threshold");
   if(threshold)
   {
      theThreshold = ossimString(threshold).toDouble();
   }
   
   return ossimImageSourceFilter::loadState(kwl, prefix);
}