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); }