vector<ImportDescriptor*> CgmImporter::getImportDescriptors(const string& filename)
{
vector<ImportDescriptor*> descriptors;
if (!filename.empty())
{
FactoryResource<Filename> pFullFilename;
pFullFilename->setFullPathAndName(filename);
ImportDescriptor* pImportDescriptor = mpModel->createImportDescriptor(filename, "AnnotationElement", NULL);
if (pImportDescriptor != NULL)
{
DataDescriptor* pDescriptor = pImportDescriptor->getDataDescriptor();
if (pDescriptor != NULL)
{
FactoryResource<FileDescriptor> pFileDescriptor;
if (pFileDescriptor.get() != NULL)
{
pFileDescriptor->setFilename(filename);
pDescriptor->setFileDescriptor(pFileDescriptor.get());
}
}
descriptors.push_back(pImportDescriptor);
}
}
return descriptors;
}
bool Nitf::Header::importDateYYMMDD(const ossimPropertyInterface *pPropertyInterface,
RasterDataDescriptor *pDescriptor,
DynamicObject *pDynObj, const string& appName,
const string& ossimName)
{
FactoryResource<DateTime> pDateTime;
VERIFY(pDateTime.get() != NULL && pDynObj != NULL);
if (pPropertyInterface == NULL)
{
return false;
}
ossimRefPtr<ossimProperty> pProperty = pPropertyInterface->getProperty(ossimName);
ossimProperty* pProp = pProperty.get();
if (pProp == NULL)
{
return false;
}
ossimString date;
pProp->valueToString(date);
// Purposely ignore the return value of DtgParseYYMMDD so that a DateTime is
// present in the metadata even if the value is invalid.
DtgParseYYMMDD(date, pDateTime.get());
return pDynObj->setAttribute(appName, *pDateTime.get());
}
vector<ImportDescriptor*> Jpeg2000Importer::getImportDescriptors(const string& filename)
{
vector<ImportDescriptor*> descriptors;
if (filename.empty() == true)
{
return descriptors;
}
vector<string>& warnings = msWarnings[filename];
warnings.clear();
vector<string>& errors = msErrors[filename];
errors.clear();
ImportDescriptor* pImportDescriptor = mpModel->createImportDescriptor(filename, "RasterElement", NULL);
if (pImportDescriptor != NULL)
{
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(pImportDescriptor->getDataDescriptor());
if (pDescriptor != NULL)
{
vector<EncodingType> validDataTypes;
validDataTypes.push_back(INT1UBYTE);
validDataTypes.push_back(INT1SBYTE);
validDataTypes.push_back(INT2UBYTES);
validDataTypes.push_back(INT2SBYTES);
validDataTypes.push_back(INT4UBYTES);
validDataTypes.push_back(INT4SBYTES);
validDataTypes.push_back(FLT4BYTES);
pDescriptor->setValidDataTypes(validDataTypes);
pDescriptor->setProcessingLocation(IN_MEMORY);
// Create and set a file descriptor in the data descriptor
FactoryResource<RasterFileDescriptor> pFileDescriptor;
pFileDescriptor->setEndian(BIG_ENDIAN_ORDER);
if (pFileDescriptor.get() != NULL)
{
pFileDescriptor->setFilename(filename);
pDescriptor->setFileDescriptor(pFileDescriptor.get());
}
// Populate the data descriptor from the file
bool bSuccess = populateDataDescriptor(pDescriptor);
if (bSuccess == true)
{
descriptors.push_back(pImportDescriptor);
}
else
{
// Delete the import descriptor
mpModel->destroyImportDescriptor(pImportDescriptor);
}
}
}
return descriptors;
}
bool LandsatEtmPlusImporter::createRasterPager(RasterElement* pRaster) const
{
string srcFile = pRaster->getFilename();
if (srcFile.empty())
{
return false;
}
{
//scoping to ensure the file is closed before creating the pager
LargeFileResource srcFileRes;
if (!srcFileRes.open(srcFile, O_RDONLY | O_BINARY, S_IREAD))
{
return false;
}
}
// create the pager
ExecutableResource pPager("BandResamplePager");
VERIFY(pPager->getPlugIn() != NULL);
bool isWritable = false;
bool useDataDescriptor = false;
FactoryResource<Filename> pFilename;
VERIFY(pFilename.get() != NULL);
pFilename->setFullPathAndName(pRaster->getFilename());
pPager->getInArgList().setPlugInArgValue("Raster Element", pRaster);
pPager->getInArgList().setPlugInArgValue("Filename", pFilename.get());
pPager->getInArgList().setPlugInArgValue("isWritable", &isWritable);
pPager->getInArgList().setPlugInArgValue("Use Data Descriptor", &useDataDescriptor);
RasterDataDescriptor* pDescriptor = static_cast<RasterDataDescriptor*>(pRaster->getDataDescriptor());
VERIFY(pDescriptor != NULL);
RasterFileDescriptor* pFileDescriptor = static_cast<RasterFileDescriptor*>(pDescriptor->getFileDescriptor());
VERIFY(pFileDescriptor != NULL);
unsigned int band = 5, rows = mB6Rows, cols = mB6Cols;
pPager->getInArgList().setPlugInArgValue("Band", &band);
pPager->getInArgList().setPlugInArgValue("Rows", &rows);
pPager->getInArgList().setPlugInArgValue("Columns", &cols);
if (!pPager->execute())
{
return false;
}
RasterPager* pRasterPager = dynamic_cast<RasterPager*>(pPager->getPlugIn());
if (pRasterPager != NULL)
{
pPager->releasePlugIn();
}
else
{
return false;
}
pRaster->setPager(pRasterPager);
return true;
}
bool AoiLogical::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
if (!extractInputArgs(pInArgList))
{
return false;
}
mProgress.report("Begin AOI set operation.", 1, NORMAL);
if (isBatch())
{
mProgress.report("Batch mode is not supported.", 0, ERRORS, true);
return false;
}
FactoryResource<BitMask> pResultMask;
if (pResultMask.get() == NULL)
{
mProgress.report("Unable to create result AOI.", 0, ERRORS, true);
return false;
}
mpResult = pResultMask.get();
if (mOperation == "Union")
{
mpResult->merge(*mpSet1);
mpResult->merge(*mpSet2);
}
else if (mOperation == "Intersection")
{
mpResult->merge(*mpSet1);
mpResult->intersect(*mpSet2);
}
else
{
mProgress.report("Invalid operation: " + mOperation, 0, ERRORS, true);
return false;
}
if (!displayResult())
{
return false;
}
mProgress.upALevel();
return true;
}
vector<ImportDescriptor*> SignatureSetImporter::getImportDescriptors(const string &filename)
{
vector<ImportDescriptor*> descriptors;
if (filename.empty())
{
return descriptors;
}
mFilename = filename;
try
{
loadDoc(filename);
if (mDoc[filename] == NULL)
{
return descriptors;
}
FactoryResource<DynamicObject> pMetadata;
VERIFYRV(pMetadata.get() != NULL, descriptors);
mDatasetNumber = 0;
ImportDescriptorFilter filter;
DOMTreeWalker* pTree = mDoc[filename]->createTreeWalker(mDoc[filename]->getDocumentElement(), DOMNodeFilter::SHOW_ELEMENT, &filter, false);
std::vector<std::string> dummy;
descriptors = createImportDescriptors(pTree, dummy);
}
catch(const DOMException &) {}
catch(const XMLException &) {}
return descriptors;
}
bool DiHdfImporter::createRasterPager(RasterElement *pRaster) const
{
VERIFY(pRaster != NULL);
DataDescriptor *pDescriptor = pRaster->getDataDescriptor();
VERIFY(pDescriptor != NULL);
FileDescriptor *pFileDescriptor = pDescriptor->getFileDescriptor();
VERIFY(pFileDescriptor != NULL);
std::string filename = pRaster->getFilename();
Progress *pProgress = getProgress();
FactoryResource<Filename> pFilename;
pFilename->setFullPathAndName(filename);
ExecutableResource pagerPlugIn("DiHdfRasterPager", std::string(), pProgress);
pagerPlugIn->getInArgList().setPlugInArgValue(CachedPager::PagedElementArg(), pRaster);
pagerPlugIn->getInArgList().setPlugInArgValue(CachedPager::PagedFilenameArg(), pFilename.get());
bool success = pagerPlugIn->execute();
RasterPager *pPager = dynamic_cast<RasterPager*>(pagerPlugIn->getPlugIn());
if(!success || pPager == NULL)
{
std::string message = "Execution of DiHdfRasterPager failed!";
if (pProgress != NULL) pProgress->updateProgress(message, 0, ERRORS);
return false;
}
pRaster->setPager(pPager);
pagerPlugIn->releasePlugIn();
return true;
}
bool Nitf::DesSubheader::importMetadata(const ossimPropertyInterface *pHeader, RasterDataDescriptor *pDescriptor)
{
VERIFY(pHeader != NULL && pDescriptor != NULL);
FactoryResource<DynamicObject> pDesSubheaderMetadata;
VERIFY(pDesSubheaderMetadata.get() != NULL);
VERIFY(Header::importMetadata(pHeader, pDescriptor, pDesSubheaderMetadata.get()));
VERIFY(pDescriptor != NULL);
DynamicObject* pMetadata = pDescriptor->getMetadata();
VERIFY(pMetadata != NULL);
pMetadata->setAttributeByPath(getMetadataPath(), *pDesSubheaderMetadata.get());
return true;
}
vector<ImportDescriptor*> SignatureSetImporter::createImportDescriptors(DOMTreeWalker* pTree, vector<string> &datasetPath)
{
vector<ImportDescriptor*> descriptors;
FactoryResource<DynamicObject> pMetadata;
VERIFYRV(pMetadata.get() != NULL, descriptors);
string datasetName = StringUtilities::toDisplayString(mDatasetNumber++);
for (DOMNode* pChld = pTree->firstChild(); pChld != NULL; pChld = pTree->nextSibling())
{
if (XMLString::equals(pChld->getNodeName(), X("metadata")))
{
DOMElement* pElmnt = static_cast<DOMElement*>(pChld);
string name = A(pElmnt->getAttribute(X("name")));
string val = A(pElmnt->getAttribute(X("value")));
pMetadata->setAttribute(name, val);
if (name == "Name")
{
datasetName = val;
}
}
else if (XMLString::equals(pChld->getNodeName(), X("signature_set")))
{
datasetPath.push_back(datasetName);
vector<ImportDescriptor*> sub = createImportDescriptors(pTree, datasetPath);
datasetPath.pop_back();
descriptors.insert(descriptors.end(), sub.begin(), sub.end());
pTree->parentNode();
}
}
ImportDescriptorResource pImportDescriptor(datasetName, "SignatureSet", datasetPath);
VERIFYRV(pImportDescriptor.get() != NULL, descriptors);
DataDescriptor* pDataDescriptor = pImportDescriptor->getDataDescriptor();
VERIFYRV(pDataDescriptor != NULL, descriptors);
FactoryResource<SignatureFileDescriptor> pFileDescriptor;
VERIFYRV(pFileDescriptor.get() != NULL, descriptors);
pFileDescriptor->setFilename(mFilename);
datasetPath.push_back(datasetName);
string loc = "/" + StringUtilities::join(datasetPath, "/");
datasetPath.pop_back();
pFileDescriptor->setDatasetLocation(loc);
pDataDescriptor->setFileDescriptor(pFileDescriptor.get());
pDataDescriptor->setMetadata(pMetadata.get());
descriptors.push_back(pImportDescriptor.release());
return descriptors;
}
bool ResamplerPlugIn::getWavelengthsFromFile(const std::string& filename,
Wavelengths* pWavelengths, std::string& errorMsg)
{
errorMsg.clear();
if (filename.empty() || pWavelengths == NULL)
{
errorMsg = "Invalid input parameters.";
return false;
}
pWavelengths->clear();
FactoryResource<Filename> pFilename;
pFilename->setFullPathAndName(filename);
std::string importerName;
std::string extension;
std::vector<std::string> extensionStrs =
StringUtilities::split(StringUtilities::toLower(pFilename->getExtension()), '.');
if (extensionStrs.empty() == false)
{
extension = extensionStrs.back();
}
if (extension == "wmd")
{
importerName = "Wavelength Metadata Importer";
}
else
{
importerName = "Wavelength Text Importer";
}
ExecutableResource pImporter(importerName, std::string());
if (pImporter->getInArgList().setPlugInArgValue(Wavelengths::WavelengthFileArg(), pFilename.get()) == false)
{
errorMsg = "Unable to set filename into plug-in \"" + importerName + "\".";
return false;
}
if (pImporter->execute() == false)
{
errorMsg = "Unable to load file \"" + filename + "\".";
return false;
}
Wavelengths* pWave = pImporter->getOutArgList().getPlugInArgValue<Wavelengths>(Wavelengths::WavelengthsArg());
if (pWave == NULL)
{
errorMsg = "Unable to extract wavelengths from plug-in \"" + importerName + "\".";
return false;
}
if (pWavelengths->initializeFromWavelengths(pWave) == false)
{
errorMsg = "Unable to retrieve the wavelengths.";
return false;
}
return true;
}
void OptionsFileLocations::applyChanges(CustomTreeWidget* pTree)
{
VERIFYNR(pTree != NULL);
Service<ConfigurationSettings> pSettings;
QTreeWidgetItemIterator iter(pTree);
while (*iter != NULL)
{
QTreeWidgetItem* pItem = *iter;
if (pItem != NULL)
{
string type = pItem->text(0).toStdString();
string confSettingsKey;
string confSettingsArgumentKey;
for (vector<FileLocationDescriptor>::iterator iter2 = mFileLocations.begin();
iter2 != mFileLocations.end();
++iter2)
{
if (iter2->getText() == type)
{
confSettingsKey = iter2->getKey();
confSettingsArgumentKey = iter2->getArgumentKey();
break;
}
}
if (!confSettingsKey.empty())
{
QString strLocation = pItem->text(1);
strLocation.replace(QRegExp("\\\\"), "/");
FactoryResource<Filename> pFilename;
string location = strLocation.toStdString();
pFilename->setFullPathAndName(location);
pSettings->setSetting(confSettingsKey, *(pFilename.get()));
if (type == "Message Log Path")
{
MessageLogMgrImp::instance()->setPath(location);
}
else if (type == "Wizard Path")
{
Service<DesktopServices> pDesktop;
ApplicationWindow* pAppWindow = static_cast<ApplicationWindow*>(pDesktop->getMainWidget());
if ((location != mWizardPath) && (pAppWindow != NULL))
{
pAppWindow->updateWizardCommands();
}
}
}
if (!confSettingsArgumentKey.empty())
{
pSettings->setSetting(confSettingsArgumentKey, pItem->text(2).toStdString());
}
}
++iter;
}
}
bool DynamicObjectImp::setAttributeByPath(QStringList pathComponents, DataVariant& value, bool swap)
{
if (!value.isValid())
{
return false;
}
QString finalName = pathComponents.back();
pathComponents.pop_back();
string loopType = "DynamicObject";
DynamicObject* pLoopObj = dynamic_cast<DynamicObject*>(this);
DynamicObject* pCurObj = pLoopObj;
for (QStringList::const_iterator iter = pathComponents.begin();
iter != pathComponents.end(); ++iter)
{
if (pLoopObj == NULL || loopType != "DynamicObject")
{
return false;
}
pCurObj = pLoopObj;
DataVariant& attrValue = pCurObj->getAttribute(iter->toStdString());
loopType = attrValue.getTypeName();
pLoopObj = attrValue.getPointerToValue<DynamicObject>();
if ((pLoopObj != NULL) && (loopType != "DynamicObject"))
{
return false;
}
if (pLoopObj == NULL)
{
FactoryResource<DynamicObject> pNewObj;
if (pCurObj != NULL)
{
pCurObj->setAttribute(iter->toStdString(), *pNewObj.get());
DataVariant& currentValue = pCurObj->getAttribute(iter->toStdString());
loopType = currentValue.getTypeName();
pLoopObj = currentValue.getPointerToValue<DynamicObject>();
}
}
}
if (pLoopObj == NULL || loopType != "DynamicObject")
{
return false;
}
pCurObj = pLoopObj;
DynamicObjectImp* const pCurObjImp = dynamic_cast<DynamicObjectImp*>(pCurObj);
VERIFY(pCurObjImp != NULL);
return pCurObjImp->setAttribute(finalName.toStdString(), value, swap);
}
bool Nitf::TrePlugInResource::exportMetadata(const RasterDataDescriptor& descriptor,
const RasterFileDescriptor& exportDescriptor, ossimNitfWriter& writer, string& errorMessage) const
{
const TreParser* pParser = dynamic_cast<const TreParser*>(get());
VERIFY(pParser != NULL);
string treErrorMessage;
FactoryResource<DynamicObject> pTre;
VERIFY(pTre.get() != NULL);
unsigned int ownerIndex = 1;
string tagType = "IXSHD";
TreExportStatus status = pParser->exportMetadata(descriptor, exportDescriptor,
*pTre.get(), ownerIndex, tagType, treErrorMessage);
if (treErrorMessage.empty() == false)
{
errorMessage = getArgs().mPlugInName + ": " + treErrorMessage;
}
string writeErrorMessage;
switch (status)
{
case REPLACE:
writeTag(*pTre.get(), ownerIndex, ossimString(tagType), writer, writeErrorMessage);
if (!writeErrorMessage.empty())
{
errorMessage += "," + writeErrorMessage;
}
return true;
case REMOVE:
return true;
default:
break;
}
return false;
}
vector<string> LandsatEtmPlusImporter::getBandFilenames(std::string strInHeaderFileName, LandsatEtmPlusImporter::BandSetType bandSet) const
{
vector<string> bandFilenames;
if (strInHeaderFileName.empty())
{
return bandFilenames;
}
FactoryResource<Filename> headerFileName;
VERIFYRV(headerFileName.get() != NULL, bandFilenames);
headerFileName->setFullPathAndName(strInHeaderFileName);
string bandFilePath = headerFileName->getPath();
// get the requested band filenames
FactoryResource<FileFinder> fileFinder;
if (bandSet == PANCHROMATIC)
{
if (!fileFinder->findFile(bandFilePath, mFieldHPN[FILENAME_1]))
{
return vector<string>();
}
fileFinder->findNextFile();
string path;
fileFinder->getFullPath(path);
bandFilenames += path;
}
else
{
vector<string> fileNames;
fileNames += mFieldHRF[FILENAME_1],
mFieldHRF[FILENAME_2],
mFieldHRF[FILENAME_3],
mFieldHRF[FILENAME_4],
mFieldHRF[FILENAME_5],
((bandSet == LOW_GAIN) ? mFieldHTM[FILENAME_1] : mFieldHTM[FILENAME_2]),
mFieldHRF[FILENAME_6];
for (vector<string>::const_iterator fileName = fileNames.begin(); fileName != fileNames.end(); ++fileName)
{
if (!fileFinder->findFile(bandFilePath, *fileName))
{
return vector<string>();
}
fileFinder->findNextFile();
string path;
fileFinder->getFullPath(path);
bandFilenames += path;
}
}
return bandFilenames;
}
RasterElement* AceAlgorithm::createResults(int numRows, int numColumns, const string& sigName)
{
RasterElement* pElement = getRasterElement();
if (pElement == NULL)
{
return NULL;
}
// Delete an existing element to ensure that the new results element is the correct size
Service<ModelServices> pModel;
RasterElement* pExistingResults = static_cast<RasterElement*>(pModel->getElement(sigName,
TypeConverter::toString<RasterElement>(), pElement));
if (pExistingResults != NULL)
{
pModel->destroyElement(pExistingResults);
}
// Create the new results element
ModelResource<RasterElement> pResults(RasterUtilities::createRasterElement(sigName, numRows, numColumns,
FLT4BYTES, true, pElement));
if (pResults.get() == NULL)
{
pResults = ModelResource<RasterElement>(RasterUtilities::createRasterElement(sigName, numRows, numColumns,
FLT4BYTES, false, pElement));
if (pResults.get() == NULL)
{
reportProgress(ERRORS, 0, ACEERR009);
MessageResource(ACEERR009, "spectral", "C89D361B-DB12-43ED-B276-6D98CA3539EE");
return NULL;
}
}
FactoryResource<Units> pUnits;
pUnits->setUnitName("degrees");
vector<int> badValues(1, 181);
RasterDataDescriptor* pResultsDescriptor = static_cast<RasterDataDescriptor*>(pResults->getDataDescriptor());
VERIFYRV(pResultsDescriptor != NULL, NULL);
pResultsDescriptor->setUnits(pUnits.get());
pResultsDescriptor->setBadValues(badValues);
Statistics* pStatistics = pResults->getStatistics();
VERIFYRV(pStatistics != NULL, NULL);
pStatistics->setBadValues(badValues);
return pResults.release();
}
DataAccessor BackgroundSuppressionShell::getCurrentFrameAccessor() const
{
if(mpRaster == NULL)
{
return DataAccessor(NULL, NULL);
}
RasterDataDescriptor *pDesc = static_cast<RasterDataDescriptor*>(mpRaster->getDataDescriptor());
VERIFYRV(pDesc != NULL, DataAccessor(NULL, NULL));
FactoryResource<DataRequest> request;
VERIFYRV(request.get() != NULL, DataAccessor(NULL, NULL));
request->setInterleaveFormat(BSQ);
DimensionDescriptor band = pDesc->getBands()[mCurrentFrame];
request->setBands(band, band, 1);
return mpRaster->getDataAccessor(request.release());
}
bool SkinsPlugIn::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
MenuBar* pMenu = Service<DesktopServices>()->getMainMenuBar();
QAction* pBefore = pMenu->getMenuItem("&View/&Status Bar");
mpSkinsMenu = pMenu->addMenu("&View/S&kins", pBefore);
mpSkinsMenu->setStatusTip("Change the current application skin.");
VERIFY(mpSkinsMenu);
VERIFY(connect(mpSkinsMenu, SIGNAL(triggered(QAction*)), this, SLOT(changeSkin(QAction*))));
QActionGroup* pActionGroup = new QActionGroup(mpSkinsMenu);
pActionGroup->setExclusive(true);
// Add default menu entries
mpDefaultAction = mpSkinsMenu->addAction("Default");
mpDefaultAction->setCheckable(true);
pActionGroup->addAction(mpDefaultAction);
// Scan the skins directory
const Filename* pPath = ConfigurationSettings::getSettingSupportFilesPath();
FactoryResource<FileFinder> pFinder;
VERIFY(pPath && pFinder.get());
pFinder->findFile(pPath->getFullPathAndName() + "/Skins", "*.css", true);
while (pFinder->findNextFile())
{
std::string title;
pFinder->getFileTitle(title);
QAction* pAction = mpSkinsMenu->addAction(QString::fromStdString(title));
pAction->setCheckable(true);
pActionGroup->addAction(pAction);
}
pFinder->findFile(pPath->getFullPathAndName() + "/Skins", "*.rcc", true);
while (pFinder->findNextFile())
{
std::string fullPath;
std::string fileTitle;
pFinder->getFullPath(fullPath);
pFinder->getFileTitle(fileTitle);
QString path = QString::fromStdString(fullPath);
QString root = "/" + QString::fromStdString(fileTitle);
if (QResource::registerResource(path, root))
{
mRegisteredResources[root] = path;
}
}
mDefaultStyleSheet = qApp->styleSheet();
mpDefaultAction->setChecked(true);
return true;
}
bool Nitf::Header::exportMetadata(const RasterDataDescriptor *pDescriptor,
ossimContainerProperty *pExportHeader)
{
VERIFY(pDescriptor != NULL);
FactoryResource<DynamicObject> pDefaults = createDefaultsDynamicObject(pDescriptor);
VERIFY(Header::exportMetadata(pDescriptor, pDefaults.get(), pExportHeader));
const DynamicObject* pMetadata = pDescriptor->getMetadata();
VERIFY(pMetadata != NULL);
const DynamicObject* pHeaderMetadata =
pMetadata->getAttributeByPath(getMetadataPath()).getPointerToValue<DynamicObject>();
VERIFY(Header::exportMetadata(pDescriptor, pHeaderMetadata, pExportHeader));
return true;
}
bool Nitf::EngrdaParser::toDynamicObject(std::istream& input,
size_t numBytes,
DynamicObject& output,
std::string &errorMessage) const
{
std::vector<char> buf;
bool success(true);
Nitf::readField<std::string>(input, output, success, ENGRDA::RESRC, 20, errorMessage, buf);
Nitf::readField<unsigned int>(input, output, success, ENGRDA::RECNT, 3, errorMessage, buf);
unsigned int recnt = QString(&buf.front()).toUInt();
for (unsigned int rec = 0; rec < recnt; ++rec)
{
std::string recId = QString::number(rec).toStdString();
{
FactoryResource<DynamicObject> record;
output.setAttribute(recId, *record.get());
}
DynamicObject& record = dv_cast<DynamicObject>(output.getAttribute(recId));
unsigned int lbln(0);
Nitf::readAndConvertFromStream(input, lbln, success, ENGRDA::ENGLN, 2, errorMessage, buf);
Nitf::readField<std::string>(input, record, success, ENGRDA::ENGLBL, lbln, errorMessage, buf);
Nitf::readField<unsigned int>(input, record, success, ENGRDA::ENGMTXC, 4, errorMessage, buf);
Nitf::readField<unsigned int>(input, record, success, ENGRDA::ENGMTXR, 4, errorMessage, buf);
Nitf::readField<std::string>(input, record, success, ENGRDA::ENGTYP, 1, errorMessage, buf);
Nitf::readField<unsigned int>(input, record, success, ENGRDA::ENGDTS, 1, errorMessage, buf);
int dts = QString(&buf.front()).toInt(); // bytes per element
Nitf::readField<std::string>(input, record, success, ENGRDA::ENGDATU, 2, errorMessage, buf);
unsigned int datc(0); // data count
Nitf::readAndConvertFromStream(input, datc, success, ENGRDA::ENGDATC, 8, errorMessage, buf);
// read the data
Nitf::readFromStream(input, buf, datc * dts, false);
record.setAttribute(ENGRDA::ENGDATA, Blob(&buf.front(), buf.size()));
}
int64_t numRead = input.tellg();
if (numRead < 0 || static_cast<uint64_t>(numRead) > std::numeric_limits<size_t>::max() ||
numRead != static_cast<int64_t>(numBytes))
{
numReadErrMsg(numRead, numBytes, errorMessage);
return false;
}
return success;
}
DynamicObject *QueryOptions::toDynamicObject() const
{
FactoryResource<DynamicObject> pDynObj;
VERIFYRV(pDynObj.get() != NULL, NULL);
pDynObj->setAttribute(QUERY_NAME, mQueryName);
pDynObj->setAttribute(QUERY_STRING, mQueryString);
pDynObj->setAttribute(SYMBOL_NAME, mSymbolName);
pDynObj->setAttribute(SYMBOL_SIZE, mSymbolSize);
pDynObj->setAttribute(LINE_STATE, mLineState);
pDynObj->setAttribute(LINE_STYLE, mLineStyle);
pDynObj->setAttribute(LINE_WIDTH, mLineWidth);
pDynObj->setAttribute(LINE_COLOR, mLineColor);
pDynObj->setAttribute(LINE_SCALED, mLineScaled);
pDynObj->setAttribute(FILL_COLOR, mFillColor);
pDynObj->setAttribute(FILL_STYLE, mFillStyle);
pDynObj->setAttribute(HATCH_STYLE, mHatchStyle);
return pDynObj.release();
}
bool Nitf::NitfImporterShell::createRasterPager(RasterElement *pRaster) const
{
VERIFY(pRaster != NULL);
DataDescriptor* pDd = pRaster->getDataDescriptor();
VERIFY(pDd != NULL);
FileDescriptor* pFd = pDd->getFileDescriptor();
VERIFY(pFd != NULL);
const string& datasetLocation = pFd->getDatasetLocation();
if (datasetLocation.empty() == true)
{
return false;
}
stringstream imageNameStream(datasetLocation.substr(1));
int imageSegment;
imageNameStream >> imageSegment;
FactoryResource<Filename> pFn;
pFn->setFullPathAndName(pFd->getFilename());
ExecutableResource pPlugIn("NitfPager");
pPlugIn->getInArgList().setPlugInArgValue("Segment Number", &imageSegment);
pPlugIn->getInArgList().setPlugInArgValue(CachedPager::PagedElementArg(), pRaster);
pPlugIn->getInArgList().setPlugInArgValue(CachedPager::PagedFilenameArg(), pFn.get());
if (pPlugIn->execute() == true)
{
RasterPager* pPager = dynamic_cast<RasterPager*>(pPlugIn->getPlugIn());
if (pPager != NULL)
{
pRaster->setPager(pPager);
pPlugIn->releasePlugIn();
return true;
}
}
return false;
}
void FeatureClassDlg::addFeatureClass()
{
// Assign a unique default name for the feature class
int featureClassNumber = 1;
QString className = "Feature Class " + QString::number(featureClassNumber);
while (mpClassList->findItems(className, Qt::MatchExactly).empty() == false)
{
className = "Feature Class " + QString::number(++featureClassNumber);
}
// Add the feature class to the member DynamicObject
FactoryResource<DynamicObject> pFields;
mpFeatureClasses->setAttribute(className.toStdString(), *(pFields.get()));
// Create a new list widget item and select it
QListWidgetItem* pItem = new QListWidgetItem(className, mpClassList);
pItem->setData(Qt::UserRole, QVariant(className));
pItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable);
mpClassList->addItem(pItem);
mpClassList->setCurrentItem(pItem);
}
vector<ImportDescriptor*> ShapeFileImporter::getImportDescriptors(const string& filename)
{
vector<ImportDescriptor*> descriptors;
if (getFileAffinity(filename) != Importer::CAN_NOT_LOAD)
{
Service<ModelServices> pModel;
ImportDescriptor* pImportDescriptor = pModel->createImportDescriptor(filename, "AnnotationElement", NULL);
VERIFYRV(pImportDescriptor != NULL, descriptors);
DataDescriptor* pDescriptor = pImportDescriptor->getDataDescriptor();
VERIFYRV(pDescriptor != NULL, descriptors);
FactoryResource<FileDescriptor> pFileDescriptor;
pFileDescriptor->setFilename(filename);
pDescriptor->setFileDescriptor(pFileDescriptor.get());
descriptors.push_back(pImportDescriptor);
}
return descriptors;
}
bool Nitf::SectgaParser::runAllTests(Progress* pProgress, ostream& failure)
{
static const string data(
"123456789012" // SEC_ID
"123456789012345" // SEC_BE
"0" // RESERVED001
);
static const string data_error4(
"123456789012" // SEC_ID
"123456789012345" // SEC_BE
" " // RESERVED001 ERROR: must == "0"
);
FactoryResource<DynamicObject> treDO;
size_t numBytes(0);
istringstream input(data);
numBytes = data.size();
string errorMessage;
bool success = toDynamicObject(input, numBytes, *treDO.get(), errorMessage);
if (!errorMessage.empty())
{
failure << errorMessage << endl;
errorMessage.clear();
}
TreState status(INVALID);
if (success)
{
status = isTreValid(*treDO.get(), failure);
}
treDO->clear();
if (status == INVALID)
{
return false;
}
// Start of test 2 - Negative test: 1 extra byte in input stream
stringstream input2(data);
input2 << "1"; // Add one more byte; valid as alphanumberic or numeric
numBytes = data.size() + 1;
success = toDynamicObject(input2, numBytes, *treDO.get(), errorMessage);
if (success == true) // negative test so success must == false.
{
failure << "Error: Negative test of 1 extra byte failed\n";
treDO->clear();
return false;
}
// start of test 3 - Negative test: 1 byte short in input stream
string negdata3(data); // data for test 3 not the 3rd data set
negdata3.resize(data.size()-1);
stringstream input3(negdata3);
numBytes = negdata3.size();
success = toDynamicObject(input3, numBytes, *treDO.get(), errorMessage);
if (success == true) // negative test so success must == false.
{
failure << "Error: Negative test of 1 byte short failed\n";
treDO->clear();
return false;
}
treDO->clear();
// Start of test 4 - SUSPECT test
stringstream input4(data_error4);
numBytes = input4.str().size();
success = toDynamicObject(input4, numBytes, *treDO.get(), errorMessage);
status = INVALID;
if (success)
{
failure << "Error: Negative test with data out of range failed: did not return false\n";
treDO->clear();
return false;
}
treDO->clear();
return true;
}
bool Nitf::RpcParser::runAllTests(Progress* pProgress, ostream& failure)
{
static const string data(
"1" // SUCCESS
"0128.03" // ERR_BIAS
"0000.50" // ERR_RAND
"002556" // LINE_OFFSET
"01827" // SAMP_OFFSET
"+33.5812" // LAT_OFFSET
"-112.0370" // LONG_OFFSET
"+0477" // HEIGHT_OFFSET
"003716" // LINE_SCALE
"06841" // SAMP_SCALE
"+00.0341" // LAT_SCALE
"+000.0734" // LONG_SCALE
"+0162" // HEIGHT_SCALE
"+6.267838E-4" // LINE_NUMERATOR_COEF_PREFIX
"+1.834668E-2" // LINE_NUMERATOR_COEF_PREFIX
"-1.018332E+0" // LINE_NUMERATOR_COEF_PREFIX
"+2.40411E-10" // LINE_NUMERATOR_COEF_PREFIX
"-7.031540E-4" // LINE_NUMERATOR_COEF_PREFIX
"+7.036708E-9" // LINE_NUMERATOR_COEF_PREFIX
"-3.905794E-7" // LINE_NUMERATOR_COEF_PREFIX
"-6.374024E-4" // LINE_NUMERATOR_COEF_PREFIX
"+3.272871E-3" // LINE_NUMERATOR_COEF_PREFIX
"-3.38456E-14" // LINE_NUMERATOR_COEF_PREFIX
"-7.23340E-11" // LINE_NUMERATOR_COEF_PREFIX
"-4.082647E-7" // LINE_NUMERATOR_COEF_PREFIX
"+2.818481E-7" // LINE_NUMERATOR_COEF_PREFIX
"-1.21567E-13" // LINE_NUMERATOR_COEF_PREFIX
"+2.192819E-6" // LINE_NUMERATOR_COEF_PREFIX
"-1.531184E-6" // LINE_NUMERATOR_COEF_PREFIX
"+3.76793E-12" // LINE_NUMERATOR_COEF_PREFIX
"-2.47717E-10" // LINE_NUMERATOR_COEF_PREFIX
"+2.83224E-10" // LINE_NUMERATOR_COEF_PREFIX
"+9.28724E-15" // LINE_NUMERATOR_COEF_PREFIX
"+1.000000E+0" // LINE_DENOMINATOR_COEF_PREFIX
"+6.416136E-4" // LINE_DENOMINATOR_COEF_PREFIX
"-3.216630E-3" // LINE_DENOMINATOR_COEF_PREFIX
"+3.835487E-7" // LINE_DENOMINATOR_COEF_PREFIX
"-2.931790E-7" // LINE_DENOMINATOR_COEF_PREFIX
"+6.94669E-11" // LINE_DENOMINATOR_COEF_PREFIX
"-2.79189E-10" // LINE_DENOMINATOR_COEF_PREFIX
"-4.228677E-7" // LINE_DENOMINATOR_COEF_PREFIX
"+1.511759E-6" // LINE_DENOMINATOR_COEF_PREFIX
"-3.68835E-12" // LINE_DENOMINATOR_COEF_PREFIX
"+2.38470E-14" // LINE_DENOMINATOR_COEF_PREFIX
"-7.25739E-11" // LINE_DENOMINATOR_COEF_PREFIX
"+5.28938E-11" // LINE_DENOMINATOR_COEF_PREFIX
"-4.96651E-15" // LINE_DENOMINATOR_COEF_PREFIX
"+5.10645E-10" // LINE_DENOMINATOR_COEF_PREFIX
"-2.11044E-12" // LINE_DENOMINATOR_COEF_PREFIX
"+5.46322E-14" // LINE_DENOMINATOR_COEF_PREFIX
"-4.30517E-14" // LINE_DENOMINATOR_COEF_PREFIX
"-3.21303E-14" // LINE_DENOMINATOR_COEF_PREFIX
"+3.33432E-14" // LINE_DENOMINATOR_COEF_PREFIX
"-4.111796E-4" // SAMPLE_NUMERATOR_COEF_PREFIX
"+9.952671E-1" // SAMPLE_NUMERATOR_COEF_PREFIX
"+5.539122E-3" // SAMPLE_NUMERATOR_COEF_PREFIX
"-1.57700E-10" // SAMPLE_NUMERATOR_COEF_PREFIX
"-3.589757E-3" // SAMPLE_NUMERATOR_COEF_PREFIX
"+3.817335E-7" // SAMPLE_NUMERATOR_COEF_PREFIX
"+2.124194E-9" // SAMPLE_NUMERATOR_COEF_PREFIX
"+6.340649E-4" // SAMPLE_NUMERATOR_COEF_PREFIX
"-1.531497E-5" // SAMPLE_NUMERATOR_COEF_PREFIX
"+1.35346E-14" // SAMPLE_NUMERATOR_COEF_PREFIX
"-4.27781E-10" // SAMPLE_NUMERATOR_COEF_PREFIX
"-3.173940E-7" // SAMPLE_NUMERATOR_COEF_PREFIX
"+2.588437E-6" // SAMPLE_NUMERATOR_COEF_PREFIX
"-3.67806E-12" // SAMPLE_NUMERATOR_COEF_PREFIX
"-5.165706E-7" // SAMPLE_NUMERATOR_COEF_PREFIX
"+1.80431E-11" // SAMPLE_NUMERATOR_COEF_PREFIX
"-1.27129E-14" // SAMPLE_NUMERATOR_COEF_PREFIX
"+6.73947E-11" // SAMPLE_NUMERATOR_COEF_PREFIX
"-6.15359E-13" // SAMPLE_NUMERATOR_COEF_PREFIX
"+4.17329E-15" // SAMPLE_NUMERATOR_COEF_PREFIX
"+1.000000E+0" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+6.416136E-4" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-3.216630E-3" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+3.835487E-7" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-2.931790E-7" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+6.94669E-11" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-2.79189E-10" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-4.228677E-7" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+1.511759E-6" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-3.68835E-12" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+2.38470E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-7.25739E-11" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+5.28938E-11" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-4.96651E-15" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+5.10645E-10" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-2.11044E-12" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+5.46322E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-4.30517E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-3.21303E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+3.33432E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
);
static const string data_error4(
"1" // SUCCESS
"0128.03" // ERR_BIAS
"0000.50" // ERR_RAND
"0255.6" // LINE_OFFSET // ERROR floating point in int field
"01827" // SAMP_OFFSET
"+33.5812" // LAT_OFFSET
"-112.0370" // LONG_OFFSET
"+0477" // HEIGHT_OFFSET
"003716" // LINE_SCALE
"06841" // SAMP_SCALE
"+00.0341" // LAT_SCALE
"+000.0734" // LONG_SCALE
"+0162" // HEIGHT_SCALE
"+6.267838E-4" // LINE_NUMERATOR_COEF_PREFIX
"+1.834668E-2" // LINE_NUMERATOR_COEF_PREFIX
"-1.018332E+0" // LINE_NUMERATOR_COEF_PREFIX
"+2.40411E-10" // LINE_NUMERATOR_COEF_PREFIX
"-7.031540E-4" // LINE_NUMERATOR_COEF_PREFIX
"+7.036708E-9" // LINE_NUMERATOR_COEF_PREFIX
"-3.905794E-7" // LINE_NUMERATOR_COEF_PREFIX
"-6.374024E-4" // LINE_NUMERATOR_COEF_PREFIX
"+3.272871E-3" // LINE_NUMERATOR_COEF_PREFIX
"-3.38456E-14" // LINE_NUMERATOR_COEF_PREFIX
"-7.23340E-11" // LINE_NUMERATOR_COEF_PREFIX
"-4.082647E-7" // LINE_NUMERATOR_COEF_PREFIX
"+2.818481E-7" // LINE_NUMERATOR_COEF_PREFIX
"-1.21567E-13" // LINE_NUMERATOR_COEF_PREFIX
"+2.192819E-6" // LINE_NUMERATOR_COEF_PREFIX
"-1.531184E-6" // LINE_NUMERATOR_COEF_PREFIX
"+3.76793E-12" // LINE_NUMERATOR_COEF_PREFIX
"-2.47717E-10" // LINE_NUMERATOR_COEF_PREFIX
"+2.83224E-10" // LINE_NUMERATOR_COEF_PREFIX
"+9.28724E-15" // LINE_NUMERATOR_COEF_PREFIX
"+1.000000E+0" // LINE_DENOMINATOR_COEF_PREFIX
"+6.416136E-4" // LINE_DENOMINATOR_COEF_PREFIX
"-3.216630E-3" // LINE_DENOMINATOR_COEF_PREFIX
"+3.835487E-7" // LINE_DENOMINATOR_COEF_PREFIX
"-2.931790E-7" // LINE_DENOMINATOR_COEF_PREFIX
"+6.94669E-11" // LINE_DENOMINATOR_COEF_PREFIX
"-2.79189E-10" // LINE_DENOMINATOR_COEF_PREFIX
"-4.228677E-7" // LINE_DENOMINATOR_COEF_PREFIX
"+1.511759E-6" // LINE_DENOMINATOR_COEF_PREFIX
"-3.68835E-12" // LINE_DENOMINATOR_COEF_PREFIX
"+2.38470E-14" // LINE_DENOMINATOR_COEF_PREFIX
"-7.25739E-11" // LINE_DENOMINATOR_COEF_PREFIX
"+5.28938E-11" // LINE_DENOMINATOR_COEF_PREFIX
"-4.96651E-15" // LINE_DENOMINATOR_COEF_PREFIX
"+5.10645E-10" // LINE_DENOMINATOR_COEF_PREFIX
"-2.11044E-12" // LINE_DENOMINATOR_COEF_PREFIX
"+5.46322E-14" // LINE_DENOMINATOR_COEF_PREFIX
"-4.30517E-14" // LINE_DENOMINATOR_COEF_PREFIX
"-3.21303E-14" // LINE_DENOMINATOR_COEF_PREFIX
"+3.33432E-14" // LINE_DENOMINATOR_COEF_PREFIX
"-4.111796E-4" // SAMPLE_NUMERATOR_COEF_PREFIX
"+9.952671E-1" // SAMPLE_NUMERATOR_COEF_PREFIX
"+5.539122E-3" // SAMPLE_NUMERATOR_COEF_PREFIX
"-1.57700E-10" // SAMPLE_NUMERATOR_COEF_PREFIX
"-3.589757E-3" // SAMPLE_NUMERATOR_COEF_PREFIX
"+3.817335E-7" // SAMPLE_NUMERATOR_COEF_PREFIX
"+2.124194E-9" // SAMPLE_NUMERATOR_COEF_PREFIX
"+6.340649E-4" // SAMPLE_NUMERATOR_COEF_PREFIX
"-1.531497E-5" // SAMPLE_NUMERATOR_COEF_PREFIX
"+1.35346E-14" // SAMPLE_NUMERATOR_COEF_PREFIX
"-4.27781E-10" // SAMPLE_NUMERATOR_COEF_PREFIX
"-3.173940E-7" // SAMPLE_NUMERATOR_COEF_PREFIX
"+2.588437E-6" // SAMPLE_NUMERATOR_COEF_PREFIX
"-3.67806E-12" // SAMPLE_NUMERATOR_COEF_PREFIX
"-5.165706E-7" // SAMPLE_NUMERATOR_COEF_PREFIX
"+1.80431E-11" // SAMPLE_NUMERATOR_COEF_PREFIX
"-1.27129E-14" // SAMPLE_NUMERATOR_COEF_PREFIX
"+6.73947E-11" // SAMPLE_NUMERATOR_COEF_PREFIX
"-6.15359E-13" // SAMPLE_NUMERATOR_COEF_PREFIX
"+4.17329E-15" // SAMPLE_NUMERATOR_COEF_PREFIX
"+1.000000E+0" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+6.416136E-4" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-3.216630E-3" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+3.835487E-7" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-2.931790E-7" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+6.94669E-11" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-2.79189E-10" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-4.228677E-7" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+1.511759E-6" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-3.68835E-12" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+2.38470E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-7.25739E-11" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+5.28938E-11" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-4.96651E-15" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+5.10645E-10" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-2.11044E-12" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+5.46322E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-4.30517E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
"-3.21303E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
"+3.33432E-14" // SAMPLE_DENOMINATOR_COEF_PREFIX
);
FactoryResource<DynamicObject> treDO;
size_t numBytes(0);
istringstream input(data);
numBytes = data.size();
string errorMessage;
bool success = toDynamicObject(input, numBytes, *treDO.get(), errorMessage);
if (!errorMessage.empty())
{
failure << errorMessage << endl;
errorMessage.clear();
}
TreState status(INVALID);
if (success)
{
status = isTreValid(*treDO.get(), failure);
}
treDO->clear();
if (status == INVALID)
{
return false;
}
// Start of test 2 - Negative test: 1 extra byte in input stream
stringstream input2(data);
input2 << "1"; // Add one more byte; valid as alphanumberic or numeric
numBytes = data.size() + 1;
success = toDynamicObject(input2, numBytes, *treDO.get(), errorMessage);
if (success == true) // negative test so success must == false.
{
failure << "Error: Negative test of 1 extra byte failed\n";
treDO->clear();
return false;
}
// start of test 3 - Negative test: 1 byte short in input stream
string negdata3(data); // data for test 3 not the 3rd data set
negdata3.resize(data.size()-1);
stringstream input3(negdata3);
numBytes = negdata3.size();
success = toDynamicObject(input3, numBytes, *treDO.get(), errorMessage);
if (success == true) // negative test so success must == false.
{
failure << "Error: Negative test of 1 byte short failed\n";
treDO->clear();
return false;
}
// Start of test 4 - false parser test
stringstream input4(data_error4);
numBytes = input4.str().size();
success = toDynamicObject(input4, numBytes, *treDO.get(), errorMessage);
if (success)
{
failure << "Error: Negative test: LINE_OFFSET floating point in int field failed: did not return false\n";
return false;
}
treDO->clear();
return (status != INVALID);
}
bool ThresholdData::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
VERIFY(pInArgList != NULL);
StepResource pStep("Execute Wizard Item", "app", "{2501975d-7cd5-49b0-a3e7-49f7106793c0}");
pStep->addProperty("Item", getName());
mpStep = pStep.get();
if (!extractInputArgs(pInArgList))
{
return false;
}
const RasterDataDescriptor* pDesc = static_cast<const RasterDataDescriptor*>(mpInputElement->getDataDescriptor());
VERIFY(pDesc);
DimensionDescriptor band;
if (mDisplayBandNumber > 0)
{
band = pDesc->getOriginalBand(mDisplayBandNumber - 1);
if (band.isValid() == false)
{
reportError("The specified band is invalid.", "{a529538b-5b82-425d-af10-385a2581beec}");
return false;
}
}
else
{
band = pDesc->getActiveBand(mDisplayBandNumber);
}
FactoryResource<DataRequest> pReq;
pReq->setInterleaveFormat(BSQ);
pReq->setBands(band, band, 1);
DataAccessor acc = mpInputElement->getDataAccessor(pReq.release());
if (!acc.isValid())
{
reportError("Unable to access data element.", "{b5f1b7dd-7cf7-4cd5-b5bc-7b747d3561b9}");
return false;
}
// If necessary, convert region units
if (mRegionUnits != RAW_VALUE)
{
Statistics* pStatistics = mpInputElement->getStatistics(band);
if (pStatistics == NULL)
{
reportError("Unable to calculate data statistics.", "{61a44ced-a4aa-4423-b379-5783137eb980}");
return false;
}
mFirstThreshold = convertToRawUnits(pStatistics, mRegionUnits, mFirstThreshold);
mSecondThreshold = convertToRawUnits(pStatistics, mRegionUnits, mSecondThreshold);
}
FactoryResource<BitMask> pBitmask;
for (unsigned int row = 0; row < pDesc->getRowCount(); ++row)
{
reportProgress("Thresholding data", 100 * row / pDesc->getRowCount(),
"{2fc3dbea-1307-471c-bba2-bf86032be518}");
for (unsigned int col = 0; col < pDesc->getColumnCount(); ++col)
{
VERIFY(acc.isValid());
double val = ModelServices::getDataValue(pDesc->getDataType(), acc->getColumn(), 0);
switch (mPassArea)
{
case UPPER:
if (val >= mFirstThreshold)
{
pBitmask->setPixel(col, row, true);
}
break;
case LOWER:
if (val <= mFirstThreshold)
{
pBitmask->setPixel(col, row, true);
}
break;
case MIDDLE:
if (val >= mFirstThreshold && val <= mSecondThreshold)
{
pBitmask->setPixel(col, row, true);
}
break;
case OUTSIDE:
if (val <= mFirstThreshold || val >= mSecondThreshold)
{
pBitmask->setPixel(col, row, true);
}
break;
default:
reportError("Unknown or invalid pass area.", "{19c92b3b-52e9-442b-a01f-b545f819f200}");
return false;
}
acc->nextColumn();
}
acc->nextRow();
}
std::string aoiName = pDesc->getName() + "_aoi";
ModelResource<AoiElement> pAoi(aoiName, mpInputElement);
if (pAoi.get() == NULL)
{
reportWarning("Overwriting existing AOI.", "{d953a030-dd63-43a1-98db-b0f491dee123}");
Service<ModelServices>()->destroyElement(
Service<ModelServices>()->getElement(aoiName, TypeConverter::toString<AoiElement>(), mpInputElement));
pAoi = ModelResource<AoiElement>(aoiName, mpInputElement);
}
if (pAoi.get() == NULL)
{
reportError("Unable to create output AOI.", "{f76c2f4d-9a7f-4055-9383-022116cdcadb}");
return false;
}
pAoi->addPoints(pBitmask.get());
AoiLayer* pLayer = NULL;
if (mpView != NULL)
{
if ((pLayer = static_cast<AoiLayer*>(mpView->createLayer(AOI_LAYER, pAoi.get()))) == NULL)
{
reportWarning("Unable to create AOI layer, continuing thresholding.",
"{5eca6ea0-33c1-4b1a-b777-c8e1b86fd2fb}");
}
}
if (pOutArgList != NULL)
{
pOutArgList->setPlugInArgValue("Result", pAoi.get());
if (pLayer != NULL)
{
pOutArgList->setPlugInArgValue("Result Layer", pLayer);
}
}
pAoi.release();
reportComplete();
return true;
}
bool ResamplerPlugIn::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
VERIFY(pInArgList != NULL && pOutArgList != NULL);
ProgressTracker progress(pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg()),
"Executing Spectral Resampler.", "spectral", "{88CD3E49-A522-431A-AE2A-96A6B2EB4012}");
Service<DesktopServices> pDesktop;
const DataElement* pElement(NULL);
std::string waveFilename;
// get default resampling options from user config
std::string resampleMethod = ResamplerOptions::getSettingResamplerMethod();
double dropOutWindow = ResamplerOptions::getSettingDropOutWindow();
double fwhm = ResamplerOptions::getSettingFullWidthHalfMax();
bool useFillValue = ResamplerOptions::getSettingUseFillValue();
double fillValue = ResamplerOptions::getSettingSignatureFillValue();
std::vector<Signature*> originalSignatures;
std::auto_ptr<std::vector<Signature*> > pResampledSignatures(new std::vector<Signature*>);
std::string errorMsg;
if (isBatch())
{
VERIFY(pInArgList->getPlugInArgValue("Signatures to resample", originalSignatures));
if (originalSignatures.empty())
{
Signature* pSignature = pInArgList->getPlugInArgValue<Signature>("Signature to resample");
if (pSignature != NULL)
{
originalSignatures.push_back(pSignature);
}
}
if (originalSignatures.empty())
{
progress.report("No signatures are available to be resampled.", 0, ERRORS, true);
return false;
}
pElement = pInArgList->getPlugInArgValue<DataElement>("Data element wavelength source");
Filename* pWaveFilename = pInArgList->getPlugInArgValue<Filename>("Wavelengths Filename");
if (pWaveFilename != NULL)
{
waveFilename = pWaveFilename->getFullPathAndName();
}
VERIFY(pInArgList->getPlugInArgValue("Resampling Method", resampleMethod));
VERIFY(pInArgList->getPlugInArgValue("Drop out window", dropOutWindow));
VERIFY(pInArgList->getPlugInArgValue("FWHM", fwhm));
VERIFY(pInArgList->getPlugInArgValue("Use fill value", useFillValue));
VERIFY(pInArgList->getPlugInArgValue("Fill value", fillValue));
}
else
{
ResamplerPlugInDlg dlg(pDesktop->getMainWidget());
if (dlg.exec() == QDialog::Rejected)
{
progress.report("User canceled resampling.", 0, ABORT, true);
progress.upALevel();
return false;
}
originalSignatures = dlg.getSignaturesToResample();
resampleMethod = dlg.getResamplingMethod();
dropOutWindow = dlg.getDropOutWindow();
fwhm = dlg.getFWHM();
useFillValue = dlg.getUseFillValue();
fillValue = dlg.getFillValue();
pElement = dlg.getWavelengthsElement();
waveFilename = dlg.getWavelengthsFilename();
}
std::string resampledTo;
FactoryResource<Wavelengths> pWavelengths;
if (pElement != NULL) // try loading wavelengths from user specified data element
{
if (getWavelengthsFromElement(pElement, pWavelengths.get(), errorMsg) == false)
{
progress.report(errorMsg, 0, ERRORS, true);
return false;
}
resampledTo = pElement->getName();
}
else if (waveFilename.empty() == false) // if no user provided raster, look for a wavelengths file
{
if (QFile::exists(QString::fromStdString(waveFilename)))
{
if (getWavelengthsFromFile(waveFilename, pWavelengths.get(), errorMsg) == false)
{
progress.report(errorMsg, 0, ERRORS, true);
return false;
}
}
else
{
errorMsg = "The wavelengths file \"" + waveFilename + "\" could not be found.";
progress.report(errorMsg, 0, ERRORS, true);
return false;
}
resampledTo = waveFilename;
}
else // if no wavelength source provided, look for raster in current active spatial data view
{
SpatialDataView* pView = dynamic_cast<SpatialDataView*>(pDesktop->getCurrentWorkspaceWindowView());
if (pView != NULL)
{
LayerList* pLayerList = pView->getLayerList();
if (pLayerList != NULL)
{
pElement = pLayerList->getPrimaryRasterElement();
pWavelengths->initializeFromDynamicObject(pElement->getMetadata(), false);
if (pWavelengths->isEmpty())
{
progress.report("No target wavelengths are available for resampling the signatures.", 0, ERRORS, true);
return false;
}
resampledTo = pElement->getName();
}
}
}
PlugInResource pPlugIn("Resampler");
Resampler* pResampler = dynamic_cast<Resampler*>(pPlugIn.get());
if (pResampler == NULL)
{
progress.report("The \"Resampler\" plug-in is not available so the signatures can not be resampled.",
0, ERRORS, true);
return false;
}
std::string dataName("Reflectance");
std::string wavelengthName("Wavelength");
// save user config settings - Resampler doesn't have interface to set them separately from user config
std::string configMethod = ResamplerOptions::getSettingResamplerMethod();
ResamplerOptions::setSettingResamplerMethod(resampleMethod);
double configDropout = ResamplerOptions::getSettingDropOutWindow();
ResamplerOptions::setSettingDropOutWindow(dropOutWindow);
double configFwhm = ResamplerOptions::getSettingFullWidthHalfMax();
ResamplerOptions::setSettingFullWidthHalfMax(fwhm);
std::vector<double> toWavelengths = pWavelengths->getCenterValues();
std::vector<double> toFwhm = pWavelengths->getFwhm();
if (toFwhm.size() != toWavelengths.size())
{
toFwhm.clear(); // Resampler will use the default config setting fwhm if this vector is empty
}
unsigned int numSigs = originalSignatures.size();
unsigned int numSigsResampled(0);
progress.report("Begin resampling signatures...", 0, NORMAL);
for (unsigned int index = 0; index < numSigs; ++index)
{
if (isAborted())
{
progress.report("Resampling aborted by user", 100 * index / numSigs, ABORT, true);
return false;
}
if (originalSignatures[index] == NULL)
{
continue;
}
// check if signature has target wavelength centers and doesn't need to be resampled
if (needToResample(originalSignatures[index], pWavelengths.get()) == false)
{
pResampledSignatures->push_back(originalSignatures[index]);
++numSigsResampled;
continue;
}
DataVariant var = originalSignatures[index]->getData(dataName);
if (var.isValid() == false)
{
continue;
}
std::vector<double> fromData;
if (!var.getValue(fromData))
{
continue;
}
var = originalSignatures[index]->getData(wavelengthName);
if (var.isValid() == false)
{
continue;
}
std::vector<double> fromWavelengths;
if (!var.getValue(fromWavelengths))
{
continue;
}
std::string resampledSigName = originalSignatures[index]->getName() + "_resampled";
int suffix(2);
ModelResource<Signature> pSignature(resampledSigName, NULL);
// probably not needed but just in case resampled name already used
while (pSignature.get() == NULL)
{
pSignature = ModelResource<Signature>(resampledSigName + StringUtilities::toDisplayString(suffix), NULL);
++suffix;
}
if (resampledTo.empty() == false)
{
DynamicObject* pMetaData = pSignature->getMetadata();
if (pMetaData != NULL)
{
pMetaData->setAttribute(CommonSignatureMetadataKeys::ResampledTo(), resampledTo);
}
}
std::vector<double> toData;
std::vector<int> toBands;
if (pResampler->execute(fromData, toData, fromWavelengths, toWavelengths, toFwhm, toBands, errorMsg))
{
if (toWavelengths.size() != toBands.size())
{
if (toBands.size() < 2) // no need to try if only one point
{
continue;
}
if (useFillValue)
{
std::vector<double> values(toWavelengths.size(), fillValue);
for (unsigned int i = 0; i < toBands.size(); ++i)
{
values[static_cast<unsigned int>(toBands[i])] = toData[i];
}
toData.swap(values);
DynamicObject* pMetaData = pSignature->getMetadata();
if (pMetaData != NULL)
{
pMetaData->setAttribute(CommonSignatureMetadataKeys::FillValue(), fillValue);
}
}
else
{
std::vector<double> wavelengths(toBands.size());
for (unsigned int i = 0; i < toBands.size(); ++i)
{
wavelengths[i] = toWavelengths[static_cast<unsigned int>(toBands[i])];
}
toWavelengths.swap(wavelengths);
}
}
pSignature->setData(dataName, toData);
pSignature->setData(wavelengthName, toWavelengths);
SignatureDataDescriptor* pDesc = dynamic_cast<SignatureDataDescriptor*>(pSignature->getDataDescriptor());
if (pDesc == NULL)
{
continue;
}
pDesc->setUnits(dataName, originalSignatures[index]->getUnits(dataName));
pResampledSignatures->push_back(pSignature.release());
++numSigsResampled;
}
std::string progressStr =
QString("Resampled signature %1 of %2 signatures").arg(index + 1).arg(numSigs).toStdString();
progress.report(progressStr, (index + 1) * 100 / numSigs, NORMAL);
}
// reset config options
ResamplerOptions::setSettingResamplerMethod(configMethod);
ResamplerOptions::setSettingDropOutWindow(configDropout);
ResamplerOptions::setSettingFullWidthHalfMax(configFwhm);
if (numSigsResampled == numSigs)
{
progress.report("Complete", 100, NORMAL);
progress.upALevel();
}
else
{
errorMsg = QString("Only %1 of the %2 signatures were successfully resampled.").arg(
numSigsResampled).arg(numSigs).toStdString();
progress.report(errorMsg, 100, WARNING, true);
}
VERIFY(pOutArgList->setPlugInArgValue("Resampled signatures", pResampledSignatures.release()));
return true;
}
bool Nitf::StdidcParser::runAllTests(Progress* pProgress, ostream& failure)
{
static const string data(
"20000108180902" // ACQUISITION_DATE
"ABCXYZ_0123456" // MISSION
"01" // PASS
"528" // OP_NUM
"AA" // START_SEGMENT
"00" // REPRO_NUM
"000" // REPLAY_REGEN
" " // BLANK_FILL
"001" // START_COLUMN
"00001" // START_ROW
"AA" // END_SEGMENT
"012" // END_COLUMN
"00027" // END_ROW
"US" // COUNTRY
"0404" // WAC
"3251N11715W" // LOCATION
" " // RESERVED2
" " // RESERVED3
);
static const string data_error4(
"20000108180902" // ACQUISITION_DATE
"ABCXYZ_0123456" // MISSION
"01" // PASS
"528" // OP_NUM
"AA" // START_SEGMENT
"00" // REPRO_NUM
"000" // REPLAY_REGEN
" " // BLANK_FILL
"001" // START_COLUMN
"00001" // START_ROW
"AA" // END_SEGMENT
"012" // END_COLUMN
"00027" // END_ROW
"US" // COUNTRY
"1867" // WAC - max == 1866
"3251N11715W" // LOCATION
" " // RESERVED2
" " // RESERVED3
);
static const string data5(
"20000108180902" // ACQUISITION_DATE
"ABCXYZ_0123456" // MISSION
"01" // PASS
"528" // OP_NUM
"AA" // START_SEGMENT
"00" // REPRO_NUM
"000" // REPLAY_REGEN
" " // BLANK_FILL
"001" // START_COLUMN
"00001" // START_ROW
"AA" // END_SEGMENT
"012" // END_COLUMN
"00027" // END_ROW
"US" // COUNTRY
" " // WAC - set to spaces
"3251N11715W" // LOCATION
" " // RESERVED2
" " // RESERVED3
);
FactoryResource<DynamicObject> treDO;
size_t numBytes(0);
istringstream input(data);
numBytes = data.size();
string errorMessage;
bool success = toDynamicObject(input, numBytes, *treDO.get(), errorMessage);
if (!errorMessage.empty())
{
failure << errorMessage << endl;
errorMessage.clear();
}
TreState status(INVALID);
if (success)
{
status = isTreValid(*treDO.get(), failure);
}
treDO->clear();
if (status == INVALID)
{
return false;
}
// Start of test 2 - Negative test: 1 extra byte in input stream
stringstream input2(data);
input2 << "1"; // Add one more byte; valid as alphanumberic or numeric
numBytes = data.size() + 1;
success = toDynamicObject(input2, numBytes, *treDO.get(), errorMessage);
if (success == true) // negative test so success must == false.
{
failure << "Error: Negative test of 1 extra byte failed\n";
treDO->clear();
return false;
}
// start of test 3 - Negative test: 1 byte short in input stream
string negdata3(data); // data for test 3 not the 3rd data set
negdata3.resize(data.size()-1);
stringstream input3(negdata3);
numBytes = negdata3.size();
success = toDynamicObject(input3, numBytes, *treDO.get(), errorMessage);
if (success == true) // negative test so success must == false.
{
failure << "Error: Negative test of 1 byte short failed\n";
treDO->clear();
return false;
}
treDO->clear();
// Start of test 4 - SUSPECT test
stringstream input4(data_error4);
numBytes = input4.str().size();
success = toDynamicObject(input4, numBytes, *treDO.get(), errorMessage);
status = INVALID;
if (success)
{
stringstream tmpStream;
status = isTreValid(*treDO.get(), tmpStream);
if (status != SUSPECT)
{
failure << "Error: Negative test with data out of range failed: did not return SUSPECT\n";
failure << tmpStream.str();
treDO->clear();
return false;
}
status = VALID;
}
treDO->clear();
// Start of test 5 - blanks in optional fields
errorMessage.clear();
stringstream input5(data5);
success = toDynamicObject(input5, input5.str().size(), *treDO.get(), errorMessage);
if (success == false)
{
failure << errorMessage;
return false;
}
else
{
stringstream tmpStream;
status = isTreValid(*treDO.get(), tmpStream);
if (status != VALID)
{
failure << "Error: Test with blank data failed: did not return VALID\n";
failure << tmpStream.str();
return false;
}
tmpStream.str(string());
success = fromDynamicObject(*treDO.get(), tmpStream, numBytes, errorMessage);
if (success == false)
{
failure << errorMessage;
return false;
}
if (input5.str() != tmpStream.str())
{
failure << "Error: Test with blank data failed: fromDynamicObject returned an unexpected value\n";
return false;
}
}
treDO->clear();
return true;
}
bool Nitf::StdidcParser::toDynamicObject(istream& input, size_t numBytes, DynamicObject& output,
string &errorMessage) const
{
vector<char> buf;
bool ok(true);
bool success(true);
success = readFromStream(input, buf, 14); // CCYYMMDDHHMMSS
FactoryResource<DateTime> appDTG;
string dtg;
dtg.resize(15);
memcpy(&dtg[0], &buf[0], 15);
bool dateValid(false);
bool timeValid(false);
unsigned short year(0);
unsigned short month(0);
unsigned short day(0);
unsigned short hour;
unsigned short min;
unsigned short sec;
if (success)
{
success = DtgParseCCYYMMDDhhmmss(dtg, year, month, day, hour, min, sec, &dateValid, &timeValid);
}
if (success)
{
success = appDTG->set(year, month, day, hour, min, sec);
if (success)
{
success = output.setAttribute(STDIDC::ACQUISITION_DATE, *appDTG.get());
}
}
if (!success)
{
errorMessage += "Parsing " + STDIDC::ACQUISITION_DATE + " failed\n";
}
readField<string>(input, output, success, STDIDC::MISSION, 14, errorMessage, buf);
readField<string>(input, output, success, STDIDC::PASS, 2, errorMessage, buf);
readField<unsigned int>(input, output, success, STDIDC::OP_NUM, 3, errorMessage, buf);
readField<string>(input, output, success, STDIDC::START_SEGMENT, 2, errorMessage, buf);
readField<unsigned int>(input, output, success, STDIDC::REPRO_NUM, 2, errorMessage, buf);
readField<string>(input, output, success, STDIDC::REPLAY_REGEN, 3, errorMessage, buf);
readField<string>(input, output, success, STDIDC::BLANK_FILL, 1, errorMessage, buf, true);
readField<unsigned int>(input, output, success, STDIDC::START_COLUMN, 3, errorMessage, buf);
readField<unsigned int>(input, output, success, STDIDC::START_ROW, 5, errorMessage, buf);
readField<string>(input, output, success, STDIDC::END_SEGMENT, 2, errorMessage, buf);
readField<unsigned int>(input, output, success, STDIDC::END_COLUMN, 3, errorMessage, buf);
readField<unsigned int>(input, output, success, STDIDC::END_ROW, 5, errorMessage, buf);
readField<string>(input, output, success, STDIDC::COUNTRY, 2, errorMessage, buf, true);
readField<unsigned int>(input, output, success, STDIDC::WAC, 4, errorMessage, buf, true);
readField<string>(input, output, success, STDIDC::LOCATION, 11, errorMessage, buf);
readField<string>(input, output, success, STDIDC::RESERVED2, 5, errorMessage, buf, true);
readField<string>(input, output, success, STDIDC::RESERVED3, 8, errorMessage, buf, true);
size_t numRead = input.tellg();
if (numRead != numBytes)
{
numReadErrMsg(numRead, numBytes, errorMessage);
return false;
}
return success;
}
void LandsatEtmPlusImporter::populateMetaData(DynamicObject* pMetadata, RasterFileDescriptor* pFileDescriptor, BandSetType bandSet)
{
vector<string> &field = (bandSet == PANCHROMATIC) ? mFieldHPN : mFieldHRF;
if (bandSet != PANCHROMATIC)
{
vector<double> startWavelengths;
startWavelengths += 0.45, 0.525, 0.63, 0.75, 1.55, 10.4, 2.09;
pMetadata->setAttributeByPath(START_WAVELENGTHS_METADATA_PATH, startWavelengths);
vector<double> centerWavelengths;
centerWavelengths += 0.483, 0.565, 0.66, 0.825, 1.65, 11.45, 2.22;
pMetadata->setAttributeByPath(CENTER_WAVELENGTHS_METADATA_PATH, centerWavelengths);
vector<double> endWavelengths;
endWavelengths += 0.515, 0.605, 0.69, 0.9, 1.75, 12.5, 2.35;
pMetadata->setAttributeByPath(END_WAVELENGTHS_METADATA_PATH, endWavelengths);
}
pMetadata->setAttribute("Product", field[PRODUCT]);
pMetadata->setAttribute("LOC", field[LOC]);
pMetadata->setAttribute("Satellite", field[SATELLITE]);
pMetadata->setAttribute("Sensor", field[INSTRUMENT]);
pMetadata->setAttribute("Sensor Mode", field[SENSOR_MODE]);
pMetadata->setAttribute("Orientation Angle", StringUtilities::fromDisplayString<double>(field[LOOK_ANGLE]));
pMetadata->setAttribute("Location", field[LOCATION]);
pMetadata->setAttribute("Product Type", field[PRODUCT_TYPE]);
pMetadata->setAttribute("Product Size", field[PRODUCT_SIZE]);
pMetadata->setAttribute("Geodetic Processing", field[TYPE_OF_PROCESSING]);
pMetadata->setAttribute("Resampling", field[RESAMPLING]);
pMetadata->setAttribute("Volume Number/Number in Set", field[VOLUME_NUMBER]);
pMetadata->setAttribute("Start Line", StringUtilities::fromDisplayString<unsigned int>(field[START_LINE]));
pMetadata->setAttribute("Blocking Factor", StringUtilities::fromDisplayString<unsigned int>(field[BLOCKING_FACTOR]));
pMetadata->setAttribute("Record Length", StringUtilities::fromDisplayString<unsigned int>(field[REC_SIZE]));
pMetadata->setAttribute("Output Bits per Pixel", StringUtilities::fromDisplayString<unsigned int>(field[OUTPUT_BITS_PER_PIXEL]));
pMetadata->setAttribute("Acquired Bits per Pixel", StringUtilities::fromDisplayString<unsigned int>(field[ACQUIRED_BITS_PER_PIXEL]));
vector<double> gain;
vector<double> bias;
gain += StringUtilities::fromDisplayString<double>(field[GAIN_1]);
bias += StringUtilities::fromDisplayString<double>(field[BIAS_1]);
if (bandSet != PANCHROMATIC)
{
gain += StringUtilities::fromDisplayString<double>(field[GAIN_2]),
StringUtilities::fromDisplayString<double>(field[GAIN_3]),
StringUtilities::fromDisplayString<double>(field[GAIN_4]),
StringUtilities::fromDisplayString<double>(field[GAIN_5]),
StringUtilities::fromDisplayString<double>(mFieldHTM[(bandSet == LOW_GAIN) ? GAIN_1 : GAIN_2]),
StringUtilities::fromDisplayString<double>(field[GAIN_6]);
bias += StringUtilities::fromDisplayString<double>(field[BIAS_2]),
StringUtilities::fromDisplayString<double>(field[BIAS_3]),
StringUtilities::fromDisplayString<double>(field[BIAS_4]),
StringUtilities::fromDisplayString<double>(field[BIAS_5]),
StringUtilities::fromDisplayString<double>(mFieldHTM[(bandSet == LOW_GAIN) ? BIAS_1 : BIAS_2]),
StringUtilities::fromDisplayString<double>(field[BIAS_6]);
}
pMetadata->setAttributeByPath("Radiance Adjust/Gain", gain);
pMetadata->setAttributeByPath("Radiance Adjust/Bias", bias);
pMetadata->setAttribute("Geometric Data Map Projection", field[GEOMETRIC_MAP_PROJECTION]);
pMetadata->setAttribute("Earth Ellipsoid", field[ELLIPSOID]);
pMetadata->setAttribute("Datum", field[DATUM]);
vector<double> projParam;
projParam += StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_1]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_2]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_3]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_4]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_5]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_6]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_7]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_8]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_9]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_10]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_11]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_12]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_13]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_14]),
StringUtilities::fromDisplayString<double>(field[USGS_PROJECTION_PARAMETER_15]);
pMetadata->setAttribute("USGS Projection Parameters", projParam);
pMetadata->setAttribute("USGS Map Zone", StringUtilities::fromDisplayString<int>(field[USGS_MAP_ZONE]));
pMetadata->setAttribute("UL Easting", StringUtilities::fromDisplayString<double>(field[UL_EASTING]));
pMetadata->setAttribute("UL Northing", StringUtilities::fromDisplayString<double>(field[UL_NORTHING]));
pMetadata->setAttribute("UR Easting", StringUtilities::fromDisplayString<double>(field[UR_EASTING]));
pMetadata->setAttribute("UR Northing", StringUtilities::fromDisplayString<double>(field[UR_NORTHING]));
pMetadata->setAttribute("LR Easting", StringUtilities::fromDisplayString<double>(field[LR_EASTING]));
pMetadata->setAttribute("LR Northing", StringUtilities::fromDisplayString<double>(field[LR_NORTHING]));
pMetadata->setAttribute("LL Easting", StringUtilities::fromDisplayString<double>(field[LL_EASTING]));
pMetadata->setAttribute("LL Northing", StringUtilities::fromDisplayString<double>(field[LL_NORTHING]));
pMetadata->setAttribute("Center Easting", StringUtilities::fromDisplayString<double>(field[CENTER_EASTING]));
pMetadata->setAttribute("Center Northing", StringUtilities::fromDisplayString<double>(field[CENTER_NORTHING]));
pMetadata->setAttribute("Scene Center Pixel Number", StringUtilities::fromDisplayString<int>(field[SCENE_CENTER_PIXEL_NUMBER]));
pMetadata->setAttribute("Scene Center Line Number", StringUtilities::fromDisplayString<int>(field[SCENE_CENTER_LINE_NUMBER]));
pMetadata->setAttribute("Offset", StringUtilities::fromDisplayString<int>(field[OFFSET]));
pMetadata->setAttribute("Orientation Angle", StringUtilities::fromDisplayString<double>(field[ORIENTATION]));
if (field[INSTRUMENT].substr(0, 2) == "TM")
{
pMetadata->setAttribute("Sensor Name", string("LandSat ETM+"));
pMetadata->setAttribute("Change Detection Format", string("ETM"));
}
int yyyy = StringUtilities::fromDisplayString<int>(field[ACQUISITION_DATE].substr(0, 4));
int mm = StringUtilities::fromDisplayString<int>(field[ACQUISITION_DATE].substr(4, 2));
int dd = StringUtilities::fromDisplayString<int>(field[ACQUISITION_DATE].substr(6));
FactoryResource<DateTime> collectionDate;
VERIFYNRV(collectionDate.get() != NULL);
collectionDate->set(yyyy, mm, dd);
pMetadata->setAttributeByPath(COLLECTION_DATE_TIME_METADATA_PATH, *collectionDate.get());
pMetadata->setAttribute("Sun Elevation", StringUtilities::fromDisplayString<double>(field[SUN_ELEVATION]));
pMetadata->setAttribute("Sun Azimuth", StringUtilities::fromDisplayString<double>(field[SUN_AZIMUTH]));
GcpPoint ul;
ul.mPixel = LocationType(0,0);
ul.mCoordinate = LocationType(Landsat::LatLongConvert(field[UL_LATITUDE]), Landsat::LatLongConvert(field[UL_LONGITUDE]));
GcpPoint ur;
ur.mPixel = LocationType(mNumCols-1,0);
ur.mCoordinate = LocationType(Landsat::LatLongConvert(field[UR_LATITUDE]), Landsat::LatLongConvert(field[UR_LONGITUDE]));
GcpPoint lr;
lr.mPixel = LocationType(mNumCols-1,mNumRows-1);
lr.mCoordinate = LocationType(Landsat::LatLongConvert(field[LR_LATITUDE]), Landsat::LatLongConvert(field[LR_LONGITUDE]));
GcpPoint ll;
ll.mPixel = LocationType(0,mNumRows-1);
ll.mCoordinate = LocationType(Landsat::LatLongConvert(field[LL_LATITUDE]), Landsat::LatLongConvert(field[LL_LONGITUDE]));
GcpPoint center;
center.mPixel = LocationType(mNumCols/2,mNumRows/2);
center.mCoordinate = LocationType(Landsat::LatLongConvert(field[CENTER_LATITUDE]), Landsat::LatLongConvert(field[CENTER_LONGITUDE]));
list<GcpPoint> gcps;
gcps += ul,ur,lr,ll,center;
pFileDescriptor->setGcps(gcps);
}
