bool ossimHdfGridModel::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
bool result = false;
std::string myPrefix = ( prefix ? prefix: "" );
// Look for type key:
std::string typeKey = "type";
std::string value = kwl.findKey( myPrefix, typeKey );
if ( value == "ossimHdfGridModel" )
{
// Look for "is_hdf4" key:
std::string key = "is_hdf4";
value = kwl.findKey( myPrefix, key );
if ( value.size() )
{
m_isHdf4 = ossimString(value).toBool();
}
// Make a copy of kwl so we can change type.
ossimKeywordlist myKwl = kwl;
value = "ossimCoarseGridModel";
myKwl.addPair( myPrefix, typeKey, value, true );
// Load the state of base class.
result = ossimCoarseGridModel::loadState( myKwl, prefix );
}
return result;
}
bool ossimH5GridModel::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
bool result = false;
std::string myPrefix = ( prefix ? prefix: "" );
// Look for type key:
std::string key = "type";
std::string value = kwl.findKey( myPrefix, key );
if ( value.size() )
{
// ossimHdfGridModel included for backward compatibility.
if ( ( value == "ossimH5GridModel" ) || ( value == "ossimHdfGridModel" ) )
{
//---
// theSeedFunction: This is in the base class ossimSensorModel but is not
// in the ossimSensorModel::loadState so do it here.
//---
std::string seedPrefix = myPrefix;
seedPrefix += "seed_projection.";
value = kwl.findKey( seedPrefix, key );
if ( value.size() )
{
// Only do expensive factory call if key is found...
theSeedFunction = ossimProjectionFactoryRegistry::instance()->
createProjection(kwl, seedPrefix.c_str());
}
// m_crossesDateline:
value = kwl.findKey( myPrefix, CROSSES_DATELINE_KW );
if ( value.size() )
{
m_crossesDateline = ossimString(value).toBool();
}
// m_boundGndPolygon:
std::string polyPrefix = myPrefix;
polyPrefix += GROUND_POLYGON_KW;
polyPrefix += ".";
m_boundGndPolygon.clear();
m_boundGndPolygon.loadState( kwl, polyPrefix.c_str() );
// Make a copy of kwl so we can change type.
ossimKeywordlist myKwl = kwl;
value = "ossimCoarseGridModel";
myKwl.addPair( myPrefix, key, value, true );
// Load the state of base class.
result = ossimCoarseGridModel::loadState( myKwl, prefix );
}
}
return result;
} // End: ossimH5GridModel::loadState( ... )
bool ossimNitfRsmModel::loadState( const ossimKeywordlist& kwl,
const char* prefix )
{
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimNitfRsmModel::loadState(): entering..." << std::endl;
}
bool status = false;
// Check for type match before preceeding:
std::string myPrefix = ( prefix ? prefix : "" );
std::string type = kwl.findKey( myPrefix, std::string(ossimKeywordNames::TYPE_KW) );
if ( type == "ossimNitfRsmModel" )
{
// Pass on to the base-class for parsing first:
status = ossimRsmModel::loadState(kwl, prefix);
}
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG ossimNitfRsmModel::loadState(): exit status: "
<< ( status ? "true" : "false" ) << std::endl;
}
return status;
}
bool ossimCodecFactory::encode( const ossimKeywordlist& options,
const ossimRefPtr<ossimImageData>& in,
std::vector<ossim_uint8>& out ) const
{
bool result = false;
std::string value = options.findKey( TYPE_KW );
if ( value.size() )
{
if ( value == "jpeg" )
{
ossim_uint32 quality = (ossim_uint32)ossimCodecFactory::DEFAULT_JPEG_QUALITY;
value = options.findKey( std::string(ossimKeywordNames::COMPRESSION_QUALITY_KW) );
if ( value.size() )
{
quality = ossimString(value).toUInt32();
}
result = encodeJpeg( quality, in, out );
}
}
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
bool ossimPngReader::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
bool result = false;
if (ossimImageHandler::loadState(kwl, prefix))
{
// this was causing core dumps. Mainly because if prefix is null then
// standard string core dumps. So wrapped with OSSIM string that checks
// for this and inits with empty string if null
//
ossimString value = kwl.findKey( ossimString(prefix).c_str(), USE_ALPHA_KW );
if ( value.size() )
{
ossimString s = value;
m_useAlphaChannelFlag = s.toBool();
}
result = open();
}
return result;
}
//*******************************************************************
// Public method:
//*******************************************************************
bool ossimGeneralRasterTileSource::loadState(const ossimKeywordlist& kwl,
const char* prefix)
{
bool result = false;
m_outputBandList.clear();
if ( ossimImageHandler::loadState(kwl, prefix) )
{
// Set the band list if key is present.
std::string pfx = ( prefix ? prefix : "" );
std::string key = ossimKeywordNames::BANDS_KW;
ossimString value;
value.string() = kwl.findKey( pfx, key );
if ( value.size() )
{
ossim::toSimpleVector( m_outputBandList, value );
}
result = open();
}
return result;
}
bool ossimGeneralRasterInfo::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
static const char MODULE[] = "ossimGeneralRasterInfo::loadState";
if ( traceDebug() )
{
CLOG << "DEBUG: entered..."
<< "\nprefix: " << (prefix ? prefix : "")
<< "\nInput keyword list:\n"
<< kwl
<< std::endl;
}
bool result = false;
//---
// Look for required and option keyword. Break from loop if required
// keyword is not found.
//---
while( 1 )
{
// Check for errors in the ossimKeywordlist.
if(kwl.getErrorStatus() == ossimErrorCodes::OSSIM_ERROR)
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " ERROR:\n"
<< "Detected an error in the keywordlist: " << kwl
<< std::endl;
break;
}
std::string key;
ossimString value; // Use for keyword list lookups.
ossim_int32 lines = 0;
ossim_int32 samples = 0;
// Lines (required):
key = NUMBER_LINES;
value.string() = kwl.findKey( key ); // Required to have this.
if ( value.size() )
{
lines = value.toInt32();
if ( !lines )
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< " ERROR:\n"
<< "Required number of lines is 0!" << std::endl;
}
break;
}
}
else
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< " ERROR:\n"
<< "Required keyword not found: " << key << std::endl;
}
break;
}
// Samples (required):
key = NUMBER_SAMPLES;
value.string() = kwl.findKey( key ); // Required to have this.
if ( value.size() )
{
samples = value.toInt32();
if ( !samples )
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< " ERROR:\n"
<< "Required number of samples is 0!" << std::endl;
}
break;
}
}
else
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< " ERROR:\n"
<< "Required keyword not found: " << key << std::endl;
}
break;
}
// Bands ossimImageMetaData::loadState checks for required bands:
if(!theMetaData.loadState(kwl, prefix))
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< " Error loading meta data!\n" << std::endl;
}
break;
}
// If we get here assign the rectangles:
theRawImageRect = ossimIrect( 0, 0, samples - 1, lines - 1 );
theValidImageRect = theRawImageRect;
theImageRect = theRawImageRect;
int tmp = INTERLEAVE_TYPE_LUT.getEntryNumber(kwl);
if (tmp == ossimLookUpTable::NOT_FOUND)
{
theInterleaveType = OSSIM_BIL;
}
else
{
theInterleaveType = static_cast<ossimInterleaveType>(tmp);
}
// Get the image files.
if (theInterleaveType != OSSIM_BSQ_MULTI_FILE)
{
// Look for "filename" first, then deprecated "image_file".
key = ossimKeywordNames::FILENAME_KW;
value.string() = kwl.findKey( key );
if ( value.empty() )
{
// deprecated keyword...
key = ossimKeywordNames::IMAGE_FILE_KW;
value.string() = kwl.findKey( key );
}
if ( value.size() )
{
//---
// omd (ossim metadata) files can have just the base filename, e.g. image.ras,
// in which case open will fail if not in the image dir. So only put it in
// the list if it doesn't exits.
//---
ossimFilename f = value;
if ( f.exists() )
{
theImageFileList.clear();
theImageFileList.push_back(ossimFilename(value));
}
}
if ( theImageFileList.empty() )
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ERROR:\n"
<< "Required keyword not found: "
<< ossimKeywordNames::FILENAME_KW << std::endl;
}
break;
}
}
else
{
// multiple file names.
ossim_int32 count = 0;
// look for image file key word with no number.
// Required to have this.
key = ossimKeywordNames::FILENAME_KW;
value.string() = kwl.findKey( key );
if ( value.empty() )
{
// deprecated keyword...
key = ossimKeywordNames::IMAGE_FILE_KW;
value.string() = kwl.findKey( key );
}
if ( value.size() )
{
theImageFileList.push_back(ossimFilename(value));
++count;
}
ossim_int32 i = 0;
while ( (count < numberOfBands()) && (i < 1000) )
{
key = ossimKeywordNames::FILENAME_KW;
key += ossimString::toString(i).string();
value.string() = kwl.findKey( key );
if ( value.empty() )
{
// Lookup for deprecated keyword.
key = ossimKeywordNames::IMAGE_FILE_KW;
key += ossimString::toString(i).string();
value.string() = kwl.findKey( key );
}
if ( value.size() )
{
theImageFileList.push_back(ossimFilename(value));
++count;
}
++i;
}
if (count != numberOfBands()) // Error, count should equal bands!
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< " ERROR:\n"
<< "Required keyword not found: "
<< ossimKeywordNames::FILENAME_KW
<< "\nInterleave type is multi file; however,"
<< " not enough were pick up!" << std::endl;
}
break;
}
}
key = VALID_START_LINE;
value.string() = kwl.findKey( key ); // Default is zero.
if ( value.size() )
{
theValidImageRect.set_uly( value.toInt32() );
}
key = VALID_STOP_LINE;
value.string() = kwl.findKey( key ); // Default is last line.
if ( value.size() )
{
theValidImageRect.set_lry( value.toInt32() );
}
if (theValidImageRect.lr().y < theValidImageRect.ul().y)
{
ossimNotify(ossimNotifyLevel_WARN)
<< " ERROR:"
<< "\nValid stop line < start line."
<< "\nValid start line: " << theValidImageRect.ul().y
<< "\nValid stop line: " << theValidImageRect.lr().y
<< "\nError status has been set. Returning." << std::endl;
break;
}
key = VALID_START_SAMPLE;
value.string() = kwl.findKey( key ); // Default is zero.
if ( value.size() )
{
theValidImageRect.set_ulx( value.toInt32() );
}
key = VALID_STOP_SAMPLE;
value.string() = kwl.findKey( key ); // Default is last sample.
if ( value.size() )
{
theValidImageRect.set_lrx( value.toInt32() );
}
if (theValidImageRect.lr().x < theValidImageRect.ul().x)
{
ossimNotify(ossimNotifyLevel_WARN)
<< " ERROR:"
<< "\nValid stop samp < start samp."
<< "\nValid start samp: " << theValidImageRect.ul().x
<< "\nValid stop samp: " << theValidImageRect.lr().x
<< "\nError status has been set. Returning." << std::endl;
break;
}
theImageRect.set_lry(theValidImageRect.lr().y -
theValidImageRect.ul().y);
theImageRect.set_lrx(theValidImageRect.lr().x -
theValidImageRect.ul().x);
key = SUB_IMAGE_OFFSET_LINE;
value.string() = kwl.findKey( key ); // Default is zero.
if ( value.size() )
{
theSubImageOffset.line = value.toInt32();
}
key = SUB_IMAGE_OFFSET_SAMP;
value.string() = kwl.findKey( key ); // Default is zero.
if ( value.size() )
{
theSubImageOffset.samp = atoi(value);
}
key = HEADER_SIZE;
value.string() = kwl.findKey( key ); // Default is zero.
if ( value.size() )
{
theHeaderSize = value.toInt32();
}
key = SET_NULLS;
value.string() = kwl.findKey( key ); // Default is 2.
if ( value.size() )
{
int tmp;
tmp = atoi(value);
if ((tmp < 3) && (tmp > -1))
{
theSetNullsMode = (ossimFillMode)tmp;
}
else
{
theSetNullsMode = ZEROES_TO_NULL_EDGES_ONLY; // 2
ossimNotify(ossimNotifyLevel_WARN)
<< " WARNING:"
<< "\nset_fill_to_nulls_mode value out of range."
<< "\nDefaulted to 2" << std::endl;
}
}
key = PIXELS_TO_CHOP;
value.string() = kwl.findKey( key ); // Default is zero.
if ( value.size() )
{
thePixelsToChop = value.toInt32();
}
if (bytesPerPixel() > 1)
{
// get the byte order of the data.
key = ossimKeywordNames::BYTE_ORDER_KW;
value.string() = kwl.findKey( key );
if ( value.size() )
{
ossimString s(value);
if (s.trim() != "") // Check for empty string.
{
s.downcase();
if (s.contains("big"))
{
theImageDataByteOrder = OSSIM_BIG_ENDIAN;
}
else if(s.contains("little"))
{
theImageDataByteOrder = OSSIM_LITTLE_ENDIAN;
}
}
}
}
// End of while forever loop.
result = true;
break;
} // Matches: while (1)
if ( traceDebug() )
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< MODULE << " Exit status: " << (result?"true":"false") << std::endl;
}
return result;
} // End: bool ossimGeneralRasterInfo::loadState
/**
* 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;
}
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";
if ( wpt.hasNans() == false )
{
model->worldToLineSample( wpt, rtp );
// Get the ground truth;
key = IPT_GT_KW + ossimString::toString( i ).string();
value = kwl.findKey( key );
if ( value.size() )
{
gt.toPoint( value );
cout << "itest_gt" << std::setw(9) << i << ": " << gt << "\n";
if ( gt.isNan() == false )
{
gtd.x = wpt.lon - gt.lon;
gtd.y = wpt.lat - gt.lat;
ossimDpt mpd = wpt.metersPerDegree();
ossimDpt gtm;
gtm.x = gtd.x * mpd.x;
gtm.y = gtd.y * mpd.y;
cout << "itest_gtd_dd" << std::setw(5) << i << ": " << gtd << "\n";
cout << "itest_gtd_mtrs" << std::setw(3) << i << ": " << gtm << "\n";
}
}
else
{
gt.makeNan();
}
rtd = ipt - rtp;
cout << "itest_rtp" << std::setw(8) << i << ": " << rtp << "\n"
<< "itest_rtd" << std::setw(8) << i << ": " << rtd << "\n\n";
}
else
{
cerr << "model->worldToLineSample(...) result has nans!\n"
<< wpt << endl;
}
++foundPts;
}
++i;
if ( i > POINTS+100 )
{
break;
}
}
cout << "\ntestIpts end **********************************\n\n";
}
} // End: testIpts
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
bool ossimRsmida::loadState( const ossimKeywordlist& kwl,
const std::string& prefix )
{
static const char MODULE[] = "ossimRsmida::loadState";
std::string pfx = prefix + std::string("rsmida.");
std::string key;
std::string value;
bool result = false; // Set to true on last key.
while( 1 ) // Break out on error.
{
key = IID_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_iid = value;
}
else
{
break;
}
key = EDITION_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_edition = value;
}
else
{
break;
}
key = ISID_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_isid = value;
}
else // Not required at this time. Blank in nitf test data.
{
m_isid.clear();
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_NOTICE)
<< MODULE << " NOTICE: " << ISID_KW << "was not found or is blank.\n";
}
}
key = SID_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_sid = value;
}
else // Not required at this time. Blank in nitf test data.
{
m_sid.clear();
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_NOTICE)
<< MODULE << " NOTICE: " << ISID_KW << "was not found or is blank.\n";
}
}
key = STID_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_stid = value;
}
else
{
break;
}
key = YEAR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_year = ossimString(value).toUInt32();
}
else
{
break;
}
key = MONTH_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_month = ossimString(value).toUInt32();
}
else
{
break;
}
key = DAY_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_day = ossimString(value).toUInt32();
}
else
{
break;
}
key = HOUR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_hour = ossimString(value).toUInt32();
}
else
{
break;
}
key = MINUTE_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_minute = ossimString(value).toUInt32();
}
else
{
break;
}
key = SECOND_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_second = ossimString(value).toFloat64();
}
else
{
break;
}
key = NRG_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_nrg = ossimString(value).toInt32();
}
else
{
break;
}
key = NCG_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_ncg = ossimString(value).toInt32();
}
else
{
break;
}
key = TRG_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_trg = ossimString(value).toFloat64();
}
else
{
break;
}
key = TCG_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_tcg = ossimString(value).toFloat64();
}
else
{
break;
}
key = GRNDD_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_grndd = value[0];
}
else
{
break;
}
key = XUOR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_xuor = ossimString(value).toFloat64();
}
else
{
break;
}
key = YUOR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_yuor = ossimString(value).toFloat64();
}
else
{
break;
}
key = ZUOR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_zuor = ossimString(value).toFloat64();
}
else
{
break;
}
key = XUXR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_xuxr = ossimString(value).toFloat64();
}
else
{
break;
}
key = XUYR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_xuyr = ossimString(value).toFloat64();
}
else
{
break;
}
key = XUZR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_xuzr = ossimString(value).toFloat64();
}
else
{
break;
}
key = YUXR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_yuxr = ossimString(value).toFloat64();
}
else
{
break;
}
key = YUYR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_yuyr = ossimString(value).toFloat64();
}
else
{
break;
}
key = YUZR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_yuzr = ossimString(value).toFloat64();
}
else
{
break;
}
key = ZUXR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_zuxr = ossimString(value).toFloat64();
}
else
{
break;
}
key = ZUYR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_zuyr = ossimString(value).toFloat64();
}
else
{
break;
}
key = ZUZR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_zuzr = ossimString(value).toFloat64();
}
else
{
break;
}
key = V1X_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v1x = ossimString(value).toFloat64();
}
else
{
break;
}
key = V1Y_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v1y = ossimString(value).toFloat64();
}
else
{
break;
}
key = V1Z_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v1z = ossimString(value).toFloat64();
}
else
{
break;
}
key = V2X_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v2x = ossimString(value).toFloat64();
}
else
{
break;
}
key = V2Y_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v2y = ossimString(value).toFloat64();
}
else
{
break;
}
key = V2Z_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v2z = ossimString(value).toFloat64();
}
else
{
break;
}
key = V3X_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v3x = ossimString(value).toFloat64();
}
else
{
break;
}
key = V3Y_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v3y = ossimString(value).toFloat64();
}
else
{
break;
}
key = V3Z_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v3z = ossimString(value).toFloat64();
}
else
{
break;
}
key = V4X_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v4x = ossimString(value).toFloat64();
}
else
{
break;
}
key = V4Y_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v4y = ossimString(value).toFloat64();
}
else
{
break;
}
key = V4Z_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v4z = ossimString(value).toFloat64();
}
else
{
break;
}
key = V5X_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v5x = ossimString(value).toFloat64();
}
else
{
break;
}
key = V5Y_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v5y = ossimString(value).toFloat64();
}
else
{
break;
}
key = V5Z_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v5z = ossimString(value).toFloat64();
}
else
{
break;
}
key = V6X_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v6x = ossimString(value).toFloat64();
}
else
{
break;
}
key = V6Y_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v6y = ossimString(value).toFloat64();
}
else
{
break;
}
key = V6Z_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v6z = ossimString(value).toFloat64();
}
else
{
break;
}
key = V7X_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v7x = ossimString(value).toFloat64();
}
else
{
break;
}
key = V7Y_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v7y = ossimString(value).toFloat64();
}
else
{
break;
}
key = V7Z_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v7z = ossimString(value).toFloat64();
}
else
{
break;
}
key = V8X_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v8x = ossimString(value).toFloat64();
}
else
{
break;
}
key = V8Y_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v8y = ossimString(value).toFloat64();
}
else
{
break;
}
key = V8Z_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_v8z = ossimString(value).toFloat64();
}
else
{
break;
}
key = GRPX_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_grpx = ossimString(value).toFloat64();
}
else
{
break;
}
key = GRPY_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_grpy = ossimString(value).toFloat64();
}
else
{
break;
}
key = GRPZ_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_grpz = ossimString(value).toFloat64();
}
else
{
break;
}
key = FULLR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_fullr = ossimString(value).toFloat64();
}
else
{
break;
}
key = FULLC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_fullc = ossimString(value).toFloat64();
}
else
{
break;
}
key = MINR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_minr = ossimString(value).toFloat64();
}
else
{
break;
}
key = MAXR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_maxr = ossimString(value).toFloat64();
}
else
{
break;
}
key = MINC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_minc = ossimString(value).toFloat64();
}
else
{
break;
}
key = MAXC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_maxc = ossimString(value).toFloat64();
}
else
{
break;
}
key = IE0_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_ie0 = ossimString(value).toFloat64();
}
else
{
break;
}
key = IER_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_ier = ossimString(value).toFloat64();
}
else
{
break;
}
key = IEC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_iec = ossimString(value).toFloat64();
}
else
{
break;
}
key = IERR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_ierr = ossimString(value).toFloat64();
}
else
{
break;
}
key = IERC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_ierc = ossimString(value).toFloat64();
}
else
{
break;
}
key = IECC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_iecc = ossimString(value).toFloat64();
}
else
{
break;
}
key = IA0_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_ia0 = ossimString(value).toFloat64();
}
else
{
break;
}
key = IAR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_iar = ossimString(value).toFloat64();
}
else
{
break;
}
key = IAC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_iac = ossimString(value).toFloat64();
}
else
{
break;
}
key = IARR_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_iarr = ossimString(value).toFloat64();
}
else
{
break;
}
key = IARC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_iarc = ossimString(value).toFloat64();
}
else
{
break;
}
key = IACC_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_iacc = ossimString(value).toFloat64();
}
else
{
break;
}
key = SPX_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_spx = ossimString(value).toFloat64();
}
else
{
break;
}
key = SVX_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_svx = ossimString(value).toFloat64();
}
else
{
break;
}
key = SAX_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_sax = ossimString(value).toFloat64();
}
else
{
break;
}
key = SPY_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_spy = ossimString(value).toFloat64();
}
else
{
break;
}
key = SVY_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_svy = ossimString(value).toFloat64();
}
else
{
break;
}
key = SAY_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_say = ossimString(value).toFloat64();
}
else
{
break;
}
key = SPZ_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_spz = ossimString(value).toFloat64();
}
else
{
break;
}
key = SVZ_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_svz = ossimString(value).toFloat64();
}
else
{
break;
}
key = SAZ_KW;
value = kwl.findKey( pfx, key );
if ( value.size() )
{
m_saz = ossimString(value).toFloat64();
}
else
{
break;
}
// If we get here we're good, so set the status for downstream code.
result = true;
// Final break from while forever loop.
break;
} // Matches: while( FOREVER )
if ( result == false )
{
// Find on key failed...
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING:\n"
<< "Error encountered parsing the following required keyword: "
<< key
<< "\nCheck the keywordlist for required key:value pairs."
<< std::endl;
}
return result;
} // End: ossimRsmida::loadState( ... )
