bool ossimBandSelector::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
ossimImageSourceFilter::loadState(kwl, prefix);
// call ossimSource method to delete the list of objects
theOutputBandList.clear();
ossimString copyPrefix = prefix;
ossimString regExpression = ossimString("^(") + copyPrefix + "band[0-9]+)";
vector<ossimString> keys = kwl.getSubstringKeyList( regExpression );
long numberOfBands = (long)keys.size();
ossim_uint32 offset = (ossim_uint32)(copyPrefix+"band").size();
std::vector<int>::size_type idx = 0;
std::vector<int> numberList(numberOfBands);
for(idx = 0; idx < keys.size();++idx)
{
ossimString numberStr(keys[idx].begin() + offset,
keys[idx].end());
numberList[idx] = numberStr.toInt();
}
std::sort(numberList.begin(), numberList.end());
for(idx=0;idx < numberList.size();++idx)
{
const char* bandValue =
kwl.find(copyPrefix,
("band"+ossimString::toString(numberList[idx])).c_str());
theOutputBandList.push_back( ossimString(bandValue).toLong()-1);
}
initialize();
return true;
}
void ossimImageChain::findInputConnectionIds(vector<ossimId>& result,
const ossimKeywordlist& kwl,
const char* prefix)
{
ossimString copyPrefix = prefix;
ossim_uint32 idx = 0;
ossimString regExpression = ossimString("^") + ossimString(prefix) + "input_connection[0-9]+";
vector<ossimString> keys =
kwl.getSubstringKeyList( regExpression );
ossim_int32 offset = (ossim_int32)(copyPrefix+"input_connection").size();
ossim_uint32 numberOfKeys = (ossim_uint32)keys.size();
std::vector<int> theNumberList(numberOfKeys);
for(idx = 0; idx < theNumberList.size();++idx)
{
ossimString numberStr(keys[idx].begin() + offset,
keys[idx].end());
theNumberList[idx] = numberStr.toInt();
}
std::sort(theNumberList.begin(), theNumberList.end());
copyPrefix += ossimString("input_connection");
for(idx=0;idx < theNumberList.size();++idx)
{
const char* lookup = kwl.find(copyPrefix,ossimString::toString(theNumberList[idx]));
if(lookup)
{
long id = ossimString(lookup).toLong();
result.push_back(ossimId(id));
}
}
}
bool rspfGeoPolyCutter::loadState(const rspfKeywordlist& kwl,
const char* prefix)
{
rspfString copyPrefix(prefix);
rspfString polygons = rspfString("^(") + copyPrefix + "geo_polygon[0-9]+.)";
vector<rspfString> keys =
kwl.getSubstringKeyList( polygons );
int offset = (int)(copyPrefix+"geo_polygon").size();
std::vector<int> numberList(keys.size());
for(int idx = 0; idx < (int)numberList.size();++idx)
{
rspfString numberStr(keys[idx].begin() + offset,
keys[idx].end());
numberList[idx] = numberStr.toInt();
}
std::sort(numberList.begin(), numberList.end());
rspfString newPrefix;
thePolygonList.clear();
for(int i = 0; i < (int)numberList.size();++i)
{
theGeoPolygonList.push_back(rspfGeoPolygon());
newPrefix = copyPrefix+"geo_polygon"+rspfString::toString(numberList[i])+".";
theGeoPolygonList[i].loadState(kwl, newPrefix.c_str());
}
const char* lookup = kwl.find(prefix,
"cut_type");
if(lookup)
{
theCutType = RSPF_POLY_NULL_INSIDE;
rspfString test = lookup;
if(test == "null_outside")
{
theCutType = RSPF_POLY_NULL_OUTSIDE;
}
}
else
{
theCutType = RSPF_POLY_NULL_OUTSIDE;
}
rspfString viewPrefix = prefix;
viewPrefix += "view.";
theViewProjection = new rspfImageGeometry();
if(theViewProjection->loadState(kwl,
viewPrefix))
{
transformVertices();
}
return rspfImageSourceFilter::loadState(kwl, prefix);
}
bool ossimVpfAnnotationCoverageInfo::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
deleteAllFeatures();
if(!theLibrary)
{
return false;
}
theName = kwl.find(prefix, "name");
ossimVpfCoverage coverage;
if(theLibrary->getCoverage(theName, coverage))
{
ossimString regExpression = ossimString("^(") + ossimString(prefix) + "feature[0-9]+.)";
vector<ossimString> keys =
kwl.getSubstringKeyList( regExpression );
std::vector<int> theNumberList(keys.size());
int offset = (int)(ossimString(prefix)+"feature").size();
int idx = 0;
for(idx = 0; idx < (int)theNumberList.size(); ++idx)
{
ossimString numberStr(keys[idx].begin() + offset,
keys[idx].end());
theNumberList[idx] = numberStr.toInt();
}
std::sort(theNumberList.begin(), theNumberList.end());
for(idx=0; idx < (int)keys.size(); ++idx)
{
ossimString newPrefix = ossimString(prefix);
newPrefix += ossimString("feature");
newPrefix += ossimString::toString(theNumberList[idx]);
newPrefix += ossimString(".");
ossimVpfAnnotationFeatureInfo* featureInfo = new ossimVpfAnnotationFeatureInfo;
featureInfo->setCoverage(coverage);
theFeatureInfoArray.push_back(featureInfo);
if(!featureInfo->loadState(kwl,
newPrefix))
{
return false;
}
}
}
else
{
return false;
}
return true;
}
bool rspfVpfAnnotationSource::loadState(const rspfKeywordlist& kwl,
const char* prefix)
{
bool result = false;
deleteAllLibraries();
const char* filename = kwl.find(prefix, rspfKeywordNames::FILENAME_KW);
if(filename)
{
if(openDatabase(filename))
{
int idx = 0;
rspfString regExpression = rspfString("^(") + rspfString(prefix) + "library[0-9]+.)";
vector<rspfString> keys =
kwl.getSubstringKeyList( regExpression );
std::vector<int> theNumberList(keys.size());
int offset = (int)(rspfString(prefix)+"library").size();
for(idx = 0; idx < (int)theNumberList.size();++idx)
{
rspfString numberStr(keys[idx].begin() + offset,
keys[idx].end());
theNumberList[idx] = numberStr.toInt();
}
std::sort(theNumberList.begin(), theNumberList.end());
for(idx=0;idx < (int)keys.size();++idx)
{
rspfString newPrefix = rspfString(prefix);
newPrefix += rspfString("library");
newPrefix += rspfString::toString(theNumberList[idx]);
newPrefix += rspfString(".");
rspfVpfAnnotationLibraryInfo* info = new rspfVpfAnnotationLibraryInfo;
theLibraryInfo.push_back(info);
info->setDatabase(&theDatabase);
info->loadState(kwl,
newPrefix);
info->getAllFeatures(theFeatureList);
}
transformObjects();
result = true;
}
}
return result;
}
bool ossimImageChain::addAllSources(map<ossimId, vector<ossimId> >& idMapping,
const ossimKeywordlist& kwl,
const char* prefix)
{
static const char* MODULE = "ossimImageChain::addAllSources";
ossimString copyPrefix = prefix;
bool result = ossimImageSource::loadState(kwl, copyPrefix.c_str());
if(!result)
{
return result;
}
long index = 0;
// ossimSource* source = NULL;
vector<ossimId> inputConnectionIds;
ossimString regExpression = ossimString("^(") + copyPrefix + "object[0-9]+.)";
vector<ossimString> keys =
kwl.getSubstringKeyList( regExpression );
long numberOfSources = (long)keys.size();//kwl.getNumberOfSubstringKeys(regExpression);
int offset = (int)(copyPrefix+"object").size();
int idx = 0;
std::vector<int> theNumberList(numberOfSources);
for(idx = 0; idx < (int)theNumberList.size();++idx)
{
ossimString numberStr(keys[idx].begin() + offset,
keys[idx].end());
theNumberList[idx] = numberStr.toInt();
}
std::sort(theNumberList.begin(), theNumberList.end());
for(idx=0;idx < (int)theNumberList.size();++idx)
{
ossimString newPrefix = copyPrefix;
newPrefix += ossimString("object");
newPrefix += ossimString::toString(theNumberList[idx]);
newPrefix += ossimString(".");
if(traceDebug())
{
CLOG << "trying to create source with prefix: " << newPrefix
<< std::endl;
}
ossimRefPtr<ossimObject> object = ossimObjectFactoryRegistry::instance()->createObject(kwl,
newPrefix.c_str());
ossimConnectableObject* source = PTR_CAST(ossimConnectableObject, object.get());
if(source)
{
// we did find a source so include it in the count
if(traceDebug())
{
CLOG << "Created source with prefix: " << newPrefix << std::endl;
}
if(PTR_CAST(ossimImageSource, source))
{
ossimId id = source->getId();
inputConnectionIds.clear();
findInputConnectionIds(inputConnectionIds,
kwl,
newPrefix);
if(inputConnectionIds.size() == 0)
{
// we will try to do a default connection
//
if(theImageChainList.size())
{
if(traceDebug())
{
CLOG << "connecting " << source->getClassName() << " to "
<< theImageChainList[0]->getClassName() << std::endl;
}
source->connectMyInputTo(0, theImageChainList[0].get());
}
}
else
{
// we remember the connection id's so we can connect this later.
// this way we make sure all sources were actually
// allocated.
//
idMapping.insert(std::make_pair(id, inputConnectionIds));
}
add(source);
}
else
{
source = 0;
}
}
else
{
object = 0;
source = 0;
}
++index;
}
if(theImageChainList.size())
{
ossimConnectableObject* obj = theImageChainList[(ossim_int32)theImageChainList.size()-1].get();
if(obj)
{
setNumberOfInputs(obj->getNumberOfInputs());
}
}
return result;
}
void ossimQtVceCanvasWidget::addAllObjects(const ossimKeywordlist& kwl,
const QPoint& location,
const char* prefix)
{
unselectItems();
QPoint locationPoint = location;
ossimString copyPrefix = prefix;
std::vector<QCanvasItem*> newItemList;
ossimString regExpression = ossimString("^(") + copyPrefix + "object[0-9]+.)";
vector<ossimString> keys =
kwl.getSubstringKeyList( regExpression );
long numberOfObjets = keys.size();//kwl.getNumberOfSubstringKeys(regExpression);
int offset = (copyPrefix+"object").size();
int idx = 0;
std::vector<int> theNumberList(numberOfObjets);
for(idx = 0; idx < (int)theNumberList.size();++idx)
{
ossimString numberStr(keys[idx].begin() + offset,
keys[idx].end());
theNumberList[idx] = numberStr.toInt();
}
std::sort(theNumberList.begin(), theNumberList.end());
for(idx=0;idx < (int)theNumberList.size();++idx)
{
ossimString newPrefix = copyPrefix;
newPrefix += ossimString("object");
newPrefix += ossimString::toString(theNumberList[idx]);
newPrefix += ossimString(".");
ossimString objType = kwl.find(newPrefix,
ossimKeywordNames::TYPE_KW);
QCanvasItem* item = NULL;
if(objType == "ossimQtImageWindow")
{
item = new ossimQtVceImageDisplayObject(canvas(),
this);
item->setX(locationPoint.x());
item->setY(locationPoint.y());
item->show();
emit itemAdded(item);
}
else if(objType == "ossimImageHandler")
{
QStringList filenames = QFileDialog::getOpenFileNames("Images (*.adf *.ccf *.dem *.DEM *.dt1 *.dt0 *.dt2 *.hdr *.hgt *.jpg *.jpeg *.img *.doqq *.fst *.FST *.nitf *.NTF *.ntf *.ras *.sid *.tif *.tiff *.toc *.TOC);;Vectors(*.shp dht *.tab);;All Files(*)",
QString::null,
this,
"open file dialog",
"Choose a file to open");
QStringList::Iterator it;
for(it = filenames.begin(); it != filenames.end(); ++it)
{
std::vector<QCanvasItem*> newItems;
openImageFile((*it).ascii(),
locationPoint,
newItems);
if(newItems.size())
{
// QRect bounds = newItems[newItems.size()-1]->boundingRect();
// locationPoint.setY(locationPoint.y() + bounds.height() + 10);
newItemList.insert(newItemList.end(),
newItems.begin(),
newItems.end());
}
}
// we will make sure that we don't adjust the location point any further
//
item = NULL;
}
else
{
ossimObject* object = ossimObjectFactoryRegistry::instance()->createObject(objType);
if(object)
{
item = addObject(object, locationPoint);
}
}
if(item)
{
newItemList.push_back(item);
QRect bounds = item->boundingRect();
locationPoint.setY(locationPoint.y() + bounds.height() + 10);
emit itemAdded(item);
}
}
if(newItemList.size() > 0)
{
for(idx = 0; idx < (int)newItemList.size(); ++idx)
{
newItemList[idx]->setSelected(true);
theSelectedItems.push_back(newItemList[idx]);
emit itemSelected(newItemList[idx]);
}
}
}
/**
* Method to the load (recreate) the state of an object from a keyword
* list. Return true if ok or false on error.
*/
bool ossimElevManager::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimElevManager::loadState: Entered..."
<< std::endl;
}
if(!ossimElevSource::loadState(kwl, prefix))
{
return false;
}
ossimString copyPrefix(prefix);
ossimString elevationOffset = kwl.find(copyPrefix, "elevation_offset");
ossimString defaultHeightAboveEllipsoid = kwl.find(copyPrefix, "default_height_above_ellipsoid");
ossimString useGeoidIfNull = kwl.find(copyPrefix, "use_geoid_if_null");
ossimString elevRndRbnSize = kwl.find(copyPrefix, "threads");
if(!elevationOffset.empty())
{
m_elevationOffset = elevationOffset.toDouble();
}
if(!defaultHeightAboveEllipsoid.empty())
{
m_defaultHeightAboveEllipsoid = defaultHeightAboveEllipsoid.toDouble();
}
if(!useGeoidIfNull.empty())
{
m_useGeoidIfNullFlag = useGeoidIfNull.toBool();
}
ossim_uint32 numThreads = 1;
if(!elevRndRbnSize.empty())
{
if (elevRndRbnSize.contains("yes") || elevRndRbnSize.contains("true"))
numThreads = ossim::getNumberOfThreads();
else if (elevRndRbnSize.contains("no") || elevRndRbnSize.contains("false"))
numThreads = 1;
else
{
numThreads = elevRndRbnSize.toUInt32();
numThreads = numThreads > 0 ? numThreads : 1;
}
}
setRoundRobinMaxSize(numThreads);
ossimString regExpression = ossimString("^(") + copyPrefix + "elevation_source[0-9]+.)";
vector<ossimString> keys = kwl.getSubstringKeyList( regExpression );
long numberOfSources = (long)keys.size();
ossim_uint32 offset = (ossim_uint32)(copyPrefix+"elevation_source").size();
ossim_uint32 idx = 0;
std::vector<int> theNumberList(numberOfSources);
for(idx = 0; idx < theNumberList.size();++idx)
{
ossimString numberStr(keys[idx].begin() + offset,
keys[idx].end());
theNumberList[idx] = numberStr.toInt();
}
std::sort(theNumberList.begin(), theNumberList.end());
for(idx=0;idx < theNumberList.size();++idx)
{
ossimString newPrefix = copyPrefix;
newPrefix += ossimString("elevation_source");
newPrefix += ossimString::toString(theNumberList[idx]);
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimElevManager::loadState:"
<< "\nLooking for key: " << newPrefix
<< std::endl;
}
//---
// Check for enabled key first. Default, if not found is true for
// legacy compatibility.
//---
bool enabled = true;
std::string key = newPrefix.string();
key += ".";
key += ossimKeywordNames::ENABLED_KW;
std::string value = kwl.findKey( key );
if ( value.size() )
{
enabled = ossimString(value).toBool();
}
if ( enabled )
{
// first check if new way is supported
ossimRefPtr<ossimElevationDatabase> database =
ossimElevationDatabaseRegistry::instance()->createDatabase(kwl, newPrefix+".");
if(database.valid())
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimElevManager::loadState:"
<< "\nadding elevation database: "
<< database->getClassName()
<< ": " << database->getConnectionString()
<< std::endl;
}
addDatabase(database.get());
}
else
{
// if not new elevation load verify the old way by
// looking at the filename
//
ossimString fileKey = newPrefix;
fileKey += ".";
fileKey += ossimKeywordNames::FILENAME_KW;
ossimString lookup = kwl.find(prefix, fileKey.c_str());
if (!lookup.empty())
{
loadElevationPath(ossimFilename(lookup));
} // end if lookup
}
}
} // end for loop
return true;
}
bool rspfApplanixEcefModel::loadState(const rspfKeywordlist& kwl,
const char* prefix)
{
if(traceDebug())
{
std::cout << "rspfApplanixEcefModel::loadState: ......... entered" << std::endl;
}
theImageClipRect = rspfDrect(0,0,4076,4091);
theRefImgPt = rspfDpt(2046.0, 2038.5);
rspfSensorModel::loadState(kwl, prefix);
if(getNumberOfAdjustableParameters() < 1)
{
initAdjustableParameters();
}
theEcefPlatformPosition = rspfGpt(0.0,0.0,1000.0);
theAdjEcefPlatformPosition = rspfGpt(0.0,0.0,1000.0);
theRoll = 0.0;
thePitch = 0.0;
theHeading = 0.0;
// bool computeGsdFlag = false;
const char* roll = kwl.find(prefix, "roll");
const char* pitch = kwl.find(prefix, "pitch");
const char* heading = kwl.find(prefix, "heading");
const char* principal_point = kwl.find(prefix, "principal_point");
const char* pixel_size = kwl.find(prefix, "pixel_size");
const char* focal_length = kwl.find(prefix, "focal_length");
const char* ecef_platform_position = kwl.find(prefix, "ecef_platform_position");
const char* latlonh_platform_position = kwl.find(prefix, "latlonh_platform_position");
const char* compute_gsd_flag = kwl.find(prefix, "compute_gsd_flag");
const char* eo_file = kwl.find(prefix, "eo_file");
const char* camera_file = kwl.find(prefix, "camera_file");
const char* eo_id = kwl.find(prefix, "eo_id");
bool result = true;
if(eo_id)
{
theImageID = eo_id;
}
if(eo_file)
{
rspfApplanixEOFile eoFile;
if(eoFile.parseFile(rspfFilename(eo_file)))
{
rspfRefPtr<rspfApplanixEORecord> record = eoFile.getRecordGivenId(theImageID);
if(record.valid())
{
rspf_int32 rollIdx = eoFile.getFieldIdx("ROLL");
rspf_int32 pitchIdx = eoFile.getFieldIdx("PITCH");
rspf_int32 headingIdx = eoFile.getFieldIdx("HEADING");
rspf_int32 xIdx = eoFile.getFieldIdx("X");
rspf_int32 yIdx = eoFile.getFieldIdx("Y");
rspf_int32 zIdx = eoFile.getFieldIdx("Z");
if((rollIdx >= 0)&&
(pitchIdx >= 0)&&
(headingIdx >= 0)&&
(xIdx >= 0)&&
(yIdx >= 0)&&
(zIdx >= 0))
{
theRoll = (*record)[rollIdx].toDouble();
thePitch = (*record)[pitchIdx].toDouble();
theHeading = (*record)[headingIdx].toDouble();
theEcefPlatformPosition = rspfEcefPoint((*record)[xIdx].toDouble(),
(*record)[yIdx].toDouble(),
(*record)[zIdx].toDouble());
theAdjEcefPlatformPosition = theEcefPlatformPosition;
}
else
{
return false;
}
}
else
{
rspfNotify(rspfNotifyLevel_WARN) << "rspfApplanixEcefModel::loadState() Image id " << theImageID << " not found in eo file " << eo_file << std::endl;
return false;
}
}
else
{
return false;
}
// computeGsdFlag = true;
}
else
{
if(roll)
{
theRoll = rspfString(roll).toDouble();
}
if(pitch)
{
thePitch = rspfString(pitch).toDouble();
}
if(heading)
{
theHeading = rspfString(heading).toDouble();
}
if(ecef_platform_position)
{
std::vector<rspfString> splitString;
rspfString tempString(ecef_platform_position);
tempString.split(splitString, rspfString(" "));
if(splitString.size() > 2)
{
theEcefPlatformPosition = rspfEcefPoint(splitString[0].toDouble(),
splitString[1].toDouble(),
splitString[2].toDouble());
}
}
else if(latlonh_platform_position)
{
std::vector<rspfString> splitString;
rspfString tempString(latlonh_platform_position);
tempString.split(splitString, rspfString(" "));
std::string datumString;
double lat=0.0, lon=0.0, h=0.0;
if(splitString.size() > 2)
{
lat = splitString[0].toDouble();
lon = splitString[1].toDouble();
h = splitString[2].toDouble();
}
theEcefPlatformPosition = rspfGpt(lat,lon,h);
}
}
if(camera_file)
{
rspfKeywordlist cameraKwl;
rspfKeywordlist lensKwl;
cameraKwl.add(camera_file);
const char* sensor = cameraKwl.find("sensor");
const char* image_size = cameraKwl.find(prefix, "image_size");
principal_point = cameraKwl.find("principal_point");
focal_length = cameraKwl.find("focal_length");
pixel_size = cameraKwl.find(prefix, "pixel_size");
focal_length = cameraKwl.find(prefix, "focal_length");
const char* distortion_units = cameraKwl.find(prefix, "distortion_units");
rspfUnitConversionTool tool;
rspfUnitType unitType = RSPF_MILLIMETERS;
if(distortion_units)
{
unitType = (rspfUnitType)rspfUnitTypeLut::instance()->getEntryNumber(distortion_units);
if(unitType == RSPF_UNIT_UNKNOWN)
{
unitType = RSPF_MILLIMETERS;
}
}
if(image_size)
{
std::vector<rspfString> splitString;
rspfString tempString(image_size);
tempString.split(splitString, rspfString(" "));
double w=1, h=1;
if(splitString.size() == 2)
{
w = splitString[0].toDouble();
h = splitString[1].toDouble();
}
theImageClipRect = rspfDrect(0,0,w-1,h-1);
theRefImgPt = rspfDpt(w/2.0, h/2.0);
}
if(sensor)
{
theSensorID = sensor;
}
if(principal_point)
{
std::vector<rspfString> splitString;
rspfString tempString(principal_point);
tempString.split(splitString, rspfString(" "));
if(splitString.size() == 2)
{
thePrincipalPoint.x = splitString[0].toDouble();
thePrincipalPoint.y = splitString[1].toDouble();
}
}
if(pixel_size)
{
std::vector<rspfString> splitString;
rspfString tempString(pixel_size);
tempString.split(splitString, rspfString(" "));
if(splitString.size() == 1)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = thePixelSize.x;
}
else if(splitString.size() == 2)
{
thePixelSize.x = splitString[0].toDouble();
thePixelSize.y = splitString[1].toDouble();
}
}
if(focal_length)
{
theFocalLength = rspfString(focal_length).toDouble();
}
cameraKwl.trimAllValues();
rspfString regExpression = rspfString("^(") + "d[0-9]+)";
vector<rspfString> keys;
cameraKwl.getSubstringKeyList( keys, regExpression );
long numberOfDistortions = (long)keys.size();
int offset = (int)rspfString("d").size();
rspf_uint32 idx = 0;
std::vector<int> numberList(numberOfDistortions);
for(idx = 0; idx < (int)numberList.size();++idx)
{
rspfString numberStr(keys[idx].begin() + offset,
keys[idx].end());
numberList[idx] = numberStr.toInt();
}
std::sort(numberList.begin(), numberList.end());
double distance=0.0, distortion=0.0;
for(idx = 0; idx < numberList.size(); ++idx)
{
rspfString value = cameraKwl.find(rspfString("d")+rspfString::toString(numberList[idx]));
if(!value.empty())
{
std::istringstream inStr(value.c_str());
inStr >> distance;
rspf::skipws(inStr);
inStr >> distortion;
#if 0
std::vector<rspfString> splitString;
rspfString tempString(value);
tempString = tempString.trim();
tempString.split(splitString, " ");
std::cout << splitString.size() << std::endl;
if(splitString.size() >= 2)
{
distance = splitString[0].toDouble();
distortion = splitString[1].toDouble();
}
#endif
tool.setValue(distortion, unitType);
lensKwl.add(rspfString("distance") + rspfString::toString(idx),
distance,
true);
lensKwl.add(rspfString("distortion") + rspfString::toString(idx),
tool.getMillimeters(),
true);
}
lensKwl.add("convergence_threshold",
.00001,
true);
if(pixel_size)
{
lensKwl.add("dxdy",
rspfString(pixel_size) + " " + rspfString(pixel_size),
true);
}
else
{
lensKwl.add("dxdy",
".009 .009",
true);
}
}
if(theLensDistortion.valid())
{
theLensDistortion->loadState(lensKwl,"");
}
}
/**
* Method to the load (recreate) the state of an object from a keyword
* list. Return true if ok or false on error.
*/
bool ossimElevManager::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimElevManager::loadState: Entered..."
<< std::endl;
}
if(!ossimElevSource::loadState(kwl, prefix))
{
return false;
}
ossimString copyPrefix(prefix);
ossimString elevationOffset = kwl.find(copyPrefix, "elevation_offset");
ossimString defaultHeightAboveEllipsoid = kwl.find(copyPrefix, "default_height_above_ellipsoid");
ossimString useGeoidIfNull = kwl.find(copyPrefix, "use_geoid_if_null");
if(!elevationOffset.empty())
{
m_elevationOffset = elevationOffset.toDouble();
}
if(!defaultHeightAboveEllipsoid.empty())
{
m_defaultHeightAboveEllipsoid = defaultHeightAboveEllipsoid.toDouble();
}
if(!useGeoidIfNull.empty())
{
m_useGeoidIfNullFlag = useGeoidIfNull.toBool();
}
ossimString regExpression = ossimString("^(") + copyPrefix + "elevation_source[0-9]+.)";
vector<ossimString> keys =
kwl.getSubstringKeyList( regExpression );
long numberOfSources = (long)keys.size();
ossim_uint32 offset = (ossim_uint32)(copyPrefix+"elevation_source").size();
ossim_uint32 idx = 0;
std::vector<int> theNumberList(numberOfSources);
for(idx = 0; idx < theNumberList.size();++idx)
{
ossimString numberStr(keys[idx].begin() + offset,
keys[idx].end());
theNumberList[idx] = numberStr.toInt();
}
std::sort(theNumberList.begin(), theNumberList.end());
for(idx=0;idx < theNumberList.size();++idx)
{
ossimString newPrefix = copyPrefix;
newPrefix += ossimString("elevation_source");
newPrefix += ossimString::toString(theNumberList[idx]);
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimElevManager::loadState:"
<< "\nLooking for key: " << newPrefix
<< std::endl;
}
// first check if new way is supported
//
ossimRefPtr<ossimElevationDatabase> database = ossimElevationDatabaseRegistry::instance()->createDatabase(kwl, newPrefix+".");
if(database.valid())
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimElevManager::loadState:"
<< "\nadding elevation database: "
<< database->getClassName()
<< ": " << database->getConnectionString()
<< std::endl;
}
addDatabase(database.get());
}
else
{
// if not new elevation load verify the old way by
// looking at the filename
//
ossimString fileKey = newPrefix;
fileKey += ".";
fileKey += ossimKeywordNames::FILENAME_KW;
ossimString lookup = kwl.find(prefix, fileKey.c_str());
if (!lookup.empty())
{
loadElevationPath(ossimFilename(lookup));
} // end if lookup
}
} // end for loop
return true;
}
