bool ossimDrect::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
ossimKeywordNames::TYPE_KW,
"ossimDrect",
true);
kwl.add(prefix, "rect", toString());
return true;
}
bool ossimElevationCellDatabase::saveState(ossimKeywordlist& kwl, const char* prefix)const
{
kwl.add(prefix, "memory_map_cells", m_memoryMapCellsFlag, true);
kwl.add(prefix, "min_open_cells", m_minOpenCells, true);
kwl.add(prefix, "max_open_cells", m_maxOpenCells, true);
if(m_geoid.valid())
{
kwl.add(prefix, "geoid.type", m_geoid->getShortName(), true);
}
return ossimElevationDatabase::saveState(kwl, prefix);
}
bool ossimBuckeyeSensor::saveState(ossimKeywordlist& kwl,
const char* prefix) const
{
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::saveState: entering..." << std::endl;
ossimSensorModel::saveState(kwl, prefix);
kwl.add(prefix, "type", "ossimBuckeyeSensor", true);
kwl.add(prefix, "roll", theRoll, true);
kwl.add(prefix, "pitch", thePitch, true);
kwl.add(prefix, "heading", theHeading, true);
kwl.add(prefix, "principal_point", "("+ossimString::toString(thePrincipalPoint.x) + "," + ossimString::toString(thePrincipalPoint.y)+")");
kwl.add(prefix, "pixel_size", "("+ossimString::toString(thePixelSize.x) + "," + ossimString::toString(thePixelSize.y)+")");
kwl.add(prefix, "focal_length", theFocalLength);
kwl.add(prefix, "ecef_platform_position",
ossimString::toString(theEcefPlatformPosition.x()) + " " +
ossimString::toString(theEcefPlatformPosition.y()) + " " +
ossimString::toString(theEcefPlatformPosition.z()));
if(theLensDistortion.valid())
{
ossimString lensPrefix = ossimString(prefix)+"distortion.";
theLensDistortion->saveState(kwl,
lensPrefix.c_str());
}
if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimBuckeyeSensor::saveState: returning..." << std::endl;
return true;
}
bool ossimImageGaussianFilter::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
PROPERTYNAME_GAUSSSTD,
theGaussStd,
true);
kwl.add(prefix,
PROPERTYNAME_STRICTNODATA,
isStrictNoData()?"true":"false", //use string instead of boolean
true);
return ossimImageSourceFilter::saveState(kwl, prefix);
}
bool ossimUtmProjection::saveState(ossimKeywordlist& kwl, const char* prefix) const
{
kwl.add(prefix,
ossimKeywordNames::ZONE_KW,
theZone,
true);
kwl.add(prefix,
ossimKeywordNames::HEMISPHERE_KW,
theHemisphere,
true);
return ossimMapProjection::saveState(kwl, prefix);
}
bool ossimLambertConformalConicProjection::saveState(ossimKeywordlist& kwl, const char* prefix) const
{
kwl.add(prefix,
ossimKeywordNames::STD_PARALLEL_1_KW,
Lambert_Std_Parallel_1*DEG_PER_RAD,
true);
kwl.add(prefix,
ossimKeywordNames::STD_PARALLEL_2_KW,
Lambert_Std_Parallel_2*DEG_PER_RAD,
true);
return ossimMapProjection::saveState(kwl, prefix);
}
bool ossimPolygon::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
ossimKeywordNames::TYPE_KW,
"ossimPolygon",
true);
kwl.add(prefix,
NUMBER_VERTICES_KW,
static_cast<ossim_uint32>(theVertexList.size()),
true);
int i = 0;
for(i = 0; i < (int)theVertexList.size();++i)
{
ossimString vert = "v"+ossimString::toString(i);;
ossimString value = (ossimString::toString(theVertexList[i].x) + " " +
ossimString::toString(theVertexList[i].y) );
kwl.add(prefix,
vert.c_str(),
value.c_str(),
true);
}
ossimString order = "";
switch(theOrderingType)
{
case OSSIM_VERTEX_ORDER_UNKNOWN:
{
order = "unknown";
break;
}
case OSSIM_CLOCKWISE_ORDER:
{
order = "clockwise";
break;
}
case OSSIM_COUNTERCLOCKWISE_ORDER:
{
order = "counter_clockwise";
break;
}
}
kwl.add(prefix,
VERTEX_ORDER_KW,
order,
true);
return true;
}
bool ossimWatermarkFilter::saveState(ossimKeywordlist& kwl,
const char* prefix) const
{
kwl.add(prefix,
ossimKeywordNames::FILENAME_KW,
theFilename.c_str());
kwl.add(prefix,
WATERMARK_MODE_KW,
getModeString().c_str());
kwl.add(prefix,
WEIGHT_KW,
theWatermarkWeight);
return ossimImageSourceFilter::saveState(kwl, prefix);
}
void ossimNitfImageHeader::getMetadata(ossimKeywordlist& kwl,
const char* prefix) const
{
kwl.add(prefix, "source",
getImageSource().c_str(),
false);
kwl.add(prefix,
"image_date",
getAcquisitionDateMonthDayYear().c_str(),
false);
kwl.add(prefix,
"image_title",
getTitle().c_str(),
false);
}
//*************************************************************************************************
// Saves the state of the original chain along with number of clones present.
//*************************************************************************************************
bool ossimImageChainMtAdaptor::saveState(ossimKeywordlist& kwl, const char* prefix) const
{
if (m_chainContainers.empty())
return false;
kwl.add(prefix, NUM_THREADS_KW, m_numThreads);
kwl.add(prefix, ORIGINAL_SOURCE_ID_KW, m_clones[0]->getId().getId());
bool rtn_state = m_chainContainers[0]->saveState(kwl, prefix);
if (d_debugEnabled)
kwl.write("ossimImageChainMtAdaptor.kwl");
return rtn_state;
}
bool ossimTilingPoly::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
"tile_source",
m_shpFilename.c_str(),
true);
kwl.add(prefix,
"paddding_use_mbr",
m_useMbr,
true);
return ossimTilingRect::saveState(kwl, prefix);;
}
//*******************************************************************
// Public method:
//*******************************************************************
bool ossimGeneralRasterTileSource::saveState(ossimKeywordlist& kwl,
const char* prefix) const
{
// Our stuff:
m_rasterInfo.saveState(kwl, prefix);
// Base class:
bool result = ossimImageHandler::saveState(kwl, prefix);
if ( result && isBandSelector() && m_outputBandList.size() )
{
if ( isIdentityBandList( m_outputBandList ) == false )
{
// If we're not identity output the bands.
ossimString bandsString;
ossim::toSimpleStringList(bandsString, m_outputBandList);
kwl.add(prefix,
ossimKeywordNames::BANDS_KW,
bandsString,
true);
}
}
return result;
}
bool SceneCoord::saveState(ossimKeywordlist& kwl, const char* prefix) const
{
std::string pfx("");
std::string pfx2("");
if (prefix)
{
pfx = prefix;
}
pfx += SCENE_COORD;
pfx2 = pfx;
pfx2 += ".";
kwl.add(pfx2.c_str(), NUMBER_OF_SCENE_CORNER_COORD, _numberOfSceneCoord);
std::string s = pfx + "." + SCENE_CENTER_COORD;
_centerSceneCoord.saveState(kwl, s.c_str());
std::string s2 =pfx + "." + SCENE_CORNER_COORD;
for (unsigned int i = 0; i < _tabCornersSceneCoord.size(); ++i)
{
std::string s3 = s2 + "[" + ossimString::toString(i) + "]";
_tabCornersSceneCoord[i].saveState(kwl, s3.c_str());
}
return true;
}
bool IncidenceAngles::saveState(ossimKeywordlist& kwl, const char* prefix) const
{
std::string pfx("");
std::string pfx2("");
if (prefix)
{
pfx = prefix;
}
pfx += INCIDENCE_ANGLES;
pfx2 = pfx;
pfx2 += ".";
kwl.add(pfx2.c_str(), NUMBER_OF_CORNER_INCIDENCE_ANGLES, _numberOfCornerIncidenceAngles);
std::string s = pfx + "." + CENTER_INCIDENCE_ANGLE;
_centerInfoIncidenceAngle.saveState(kwl, s.c_str());
std::string s2 =pfx + "." + CORNERS_INCIDENCE_ANGLE;
for (unsigned int i = 0; i < _tabCornersInfoIncidenceAngle.size(); ++i)
{
std::string s3 = s2 + "[" + ossimString::toString(i) + "]";
_tabCornersInfoIncidenceAngle[i].saveState(kwl, s3.c_str());
}
return true;
}
bool ossimNdfTileSource::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix, "header_filename", theHeaderFile.c_str(), true);
return ossimGeneralRasterTileSource::saveState(kwl, prefix);
}
bool ossimCFARFilter::saveState(ossimKeywordlist& kwl, const char* prefix)const
{
ossimImageSourceFilter::saveState(kwl, prefix);
kwl.add(prefix,"aperture_size",0,true);
return true;
}
bool ossimQtVceWindowController::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
if(theVceWindow)
{
kwl.add(prefix,
ossimKeywordNames::TYPE_KW,
"ossimQtVceWindow",
true);
QWidget* widget = theVceWindow->parentWidget(true);
QPoint pt(widget->pos());
kwl.add(prefix,
"position",
ossimString::toString((int)pt.x()) + " " + ossimString::toString((int)pt.y()),
true);
kwl.add(prefix,
"size",
ossimString::toString((int)theVceWindow->width()) + " " + ossimString::toString((int)theVceWindow->height()),
true);
ossimString showState = "shown";
if(theVceWindow->isMinimized())
{
showState = "minimized";
}
else if(theVceWindow->isMaximized())
{
showState = "maximized";
}
else if(theVceWindow->isHidden())
{
showState = "hidden";
}
kwl.add(prefix,
"show_state",
showState,
true);
return theVceWindow->theCanvasView->saveState(kwl, (ossimString(prefix)+"canvas_view0.").c_str());
}
return false;
}
//*****************************************************************************
// METHOD: ossimTileMapModel::saveState()
//
// Saves the model state to the KWL. This KWL also serves as a geometry file.
//
//*****************************************************************************
bool ossimTileMapModel::saveState(ossimKeywordlist& kwl,
const char* prefix) const
{
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::saveState: entering..." << std::endl;
kwl.add(prefix, ossimKeywordNames::TYPE_KW, TYPE_NAME(this));
kwl.add(prefix, "depth", qDepth);
//***
// Hand off to base class for common stuff:
//***
ossimSensorModel::saveState(kwl, prefix);
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimTileMapModel::saveState: returning..." << std::endl;
return true;
}
bool ossimNitfRpcModel::saveState(ossimKeywordlist& kwl,
const char* prefix) const
{
// Save the decimation.
kwl.add(prefix, "decimation", theDecimation);
// Call base.
return ossimRpcModel::saveState(kwl, prefix);
}
bool ossimTransCylEquAreaProjection::saveState(ossimKeywordlist& kwl, const char* prefix) const
{
kwl.add(prefix,
ossimKeywordNames::SCALE_FACTOR_KW,
Tcea_Scale_Factor,
true);
return ossimMapProjection::saveState(kwl, prefix);
}
bool ossimFftFilter::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
"fft_direction",
getDirectionTypeAsString(),
true);
return ossimImageSourceFilter::saveState(kwl, prefix);
}
bool ossimGeneralRasterWriter::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
ossimKeywordNames::BYTE_ORDER_KW,
((theOutputByteOrder==OSSIM_LITTLE_ENDIAN)?"little_endian":"big_endian"),
true);
return ossimImageFileWriter::saveState(kwl,
prefix);
}
//*****************************************************************************
// METHOD:
//*****************************************************************************
bool ossim2dTo2dTransform::saveState(ossimKeywordlist& kwl,
const char* prefix) const
{
kwl.add(prefix,
ossimKeywordNames::CONVERGENCE_THRESHOLD_KW,
theConvergenceThreshold,
true);
kwl.add(prefix,
ossimKeywordNames::MAX_ITERATIONS_KW,
theMaxIterations,
true);
kwl.add(prefix,
"dxdy",
ossimString::toString(theDxDy.x) + " " +
ossimString::toString(theDxDy.y),
true);
return ossimObject::saveState(kwl, prefix);
}
bool ossimObject::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
ossimKeywordNames::TYPE_KW,
getClassName(),
true);
return true;
}
bool ossimBumpShadeTileSource::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
ossimKeywordNames::ELEVATION_ANGLE_KW,
m_lightSourceElevationAngle,
true);
kwl.add(prefix,
ossimKeywordNames::AZIMUTH_ANGLE_KW,
m_lightSourceAzimuthAngle,
true);
kwl.add(prefix, COLOR_RED_KW, m_r, true);
kwl.add(prefix, COLOR_GREEN_KW, m_g, true);
kwl.add(prefix, COLOR_BLUE_KW, m_b, true);
return ossimImageSource::saveState(kwl, prefix);
}
bool ossimEdgeFilter::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
PROP_EDGE_FILTER,
getFilterType(),
true);
return ossimImageSourceFilter::saveState(kwl, prefix);
}
bool ossimMaskFilter::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
kwl.add(prefix,
MASK_FILTER_MASK_TYPE_KW,
getMaskTypeString().c_str(),
true);
return ossimImageCombiner::saveState(kwl, prefix);
}
bool ossimGeoPolygon::saveState(ossimKeywordlist& kwl,
const char* prefix)const
{
int i = 0;
kwl.add(prefix,
ossimKeywordNames::TYPE_KW,
"ossimGeoPolygon",
true);
kwl.add(prefix,
NUMBER_VERTICES_KW,
static_cast<ossim_uint32>(theVertexList.size()),
true);
if(theVertexList.size())
{
kwl.add(prefix,
ossimKeywordNames::DATUM_KW,
theVertexList[0].datum()->code(),
true);
}
else
{
kwl.add(prefix,
ossimKeywordNames::DATUM_KW,
"WGE",
true);
}
for(i = 0; i < (int)theVertexList.size();++i)
{
ossimString vert = "v"+ossimString::toString(i);
ossimString value = (ossimString::toString(theVertexList[i].latd()) + " " +
ossimString::toString(theVertexList[i].lond()) + " " +
( theVertexList[i].isHgtNan()?ossimString("nan"):ossimString::toString(theVertexList[i].height())));
kwl.add(prefix,
vert.c_str(),
value.c_str(),
true);
}
return true;
}
//*****************************************************************************
// METHOD: ossimRpcProjection::saveState()
//
// Saves the model state to the KWL. This KWL also serves as a geometry file.
//
//*****************************************************************************
bool ossimRpcProjection::saveState(ossimKeywordlist& kwl,
const char* prefix) const
{
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimRpcProjection::saveState(): entering..." << std::endl;
kwl.add(prefix, ossimKeywordNames::TYPE_KW, MODEL_TYPE);
//***
// Hand off to base class for common stuff:
//***
ossimProjection::saveState(kwl, prefix);
kwl.add(prefix,
POLY_TYPE_KW,
(char)thePolyType,
true);
kwl.add(prefix, LINE_SCALE_KW, theLineScale);
kwl.add(prefix, SAMP_SCALE_KW, theSampScale);
kwl.add(prefix, LAT_SCALE_KW, theLatScale);
kwl.add(prefix, LON_SCALE_KW, theLonScale);
kwl.add(prefix, HGT_SCALE_KW, theHgtScale);
kwl.add(prefix, LINE_OFFSET_KW, theLineOffset);
kwl.add(prefix, SAMP_OFFSET_KW, theSampOffset);
kwl.add(prefix, LAT_OFFSET_KW, theLatOffset);
kwl.add(prefix, LON_OFFSET_KW, theLonOffset);
kwl.add(prefix, HGT_OFFSET_KW, theHgtOffset);
for (int i=0; i<NUM_COEFFS; i++)
{
kwl.add(prefix, (LINE_NUM_COEF_KW + ossimString::toString(i)).c_str(), theLineNumCoef[i]);
kwl.add(prefix, (LINE_DEN_COEF_KW + ossimString::toString(i)).c_str(), theLineDenCoef[i]);
kwl.add(prefix, (SAMP_NUM_COEF_KW + ossimString::toString(i)).c_str(), theSampNumCoef[i]);
kwl.add(prefix, (SAMP_DEN_COEF_KW + ossimString::toString(i)).c_str(), theSampDenCoef[i]);
}
saveAdjustments(kwl, prefix);
if (traceExec()) ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimRpcProjection::saveState(): returning..." << std::endl;
return true;
}
//**************************************************************************************************
//! Method to save the state of an object to a keyword list.
//! Return true if ok or false on error.
//**************************************************************************************************
bool ossimImageHandlerMtAdaptor::saveState(ossimKeywordlist& kwl, const char* prefix)const
{
if (!m_adaptedHandler.valid())
return false;
// Skip the ossimImageHandler::saveState() since it is not necessary here:
ossimImageSource::saveState(kwl, prefix);
kwl.add(prefix, ADAPTEE_ID_KW, m_adaptedHandler->getId().getId());
return true;
}
