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 RasterElementImporterShell::createRasterPager(RasterElement* pRaster) const { string srcFile = pRaster->getFilename(); if (srcFile.empty()) { return false; } { //scoping to ensure the file is closed before calling createMemoryMappedPager LargeFileResource srcFileRes; if (!srcFileRes.open(srcFile, O_RDONLY | O_BINARY, S_IREAD)) { return false; } } mUsingMemoryMappedPager = pRaster->createMemoryMappedPager(); return mUsingMemoryMappedPager; }
bool LandsatEtmPlusImporter::readHeader(const string& strInFstHeaderFileName) { if (strInFstHeaderFileName.empty()) { return false; } //The HTM header file contains information for Band 6 Channel 1 and 2. //This set extracts the info needed to process HTM(band 6) header mFieldHTM.clear(); string baseFileName = strInFstHeaderFileName.substr(0, strInFstHeaderFileName.length() - 7); FactoryResource<Filename> filename; filename->setFullPathAndName(baseFileName); FactoryResource<FileFinder> fileFinder; string htmFileName = filename->getFileName() + "HTM.FST"; if (fileFinder->findFile(filename->getPath(), htmFileName)) { fileFinder->findNextFile(); fileFinder->getFullPath(htmFileName); } LargeFileResource htmFile; if (htmFile.open(htmFileName, O_RDONLY, S_IREAD)) { //process HTM header vector<char> buf(5120); size_t count = static_cast<size_t>(htmFile.read(&buf.front(), 5120)); VERIFY(htmFile.eof()); string htmHeaderFull(&buf.front(), count); vector<string> htmHeaderLines = StringUtilities::split(htmHeaderFull, '\n'); if (!parseHeader(htmHeaderLines, mFieldHTM)) //parse band 6 header { mFieldHTM.clear(); } } htmFile.close(); // The HRF Header file contains the parameters for Bands 1-5 and 7. mFieldHRF.clear(); string hrfFileName = filename->getFileName() + "HRF.FST"; if (fileFinder->findFile(filename->getPath(), hrfFileName)) { fileFinder->findNextFile(); fileFinder->getFullPath(hrfFileName); } LargeFileResource hrfFile; if (hrfFile.open(hrfFileName, O_RDONLY, S_IREAD)) { //process HRF header vector<char> buf(5120); size_t count = static_cast<size_t>(hrfFile.read(&buf.front(), 5120)); VERIFY(hrfFile.eof()); string hrfHeaderFull(&buf.front(), count); vector<string> hrfHeaderLines = StringUtilities::split(hrfHeaderFull, '\n'); if (!parseHeader(hrfHeaderLines, mFieldHRF)) //parse bands 1-5 and 7 header { mFieldHRF.clear(); } } hrfFile.close(); // The HPN Header file contains the parameters for Band 8. mFieldHPN.clear(); string hpnFileName = filename->getFileName() + "HPN.FST"; if (fileFinder->findFile(filename->getPath(), hpnFileName)) { fileFinder->findNextFile(); fileFinder->getFullPath(hpnFileName); } LargeFileResource hpnFile; if (hpnFile.open(hpnFileName, O_RDONLY, S_IREAD)) { //process HPN header vector<char> buf(5120); size_t count = static_cast<size_t>(hpnFile.read(&buf.front(), 5120)); VERIFY(hpnFile.eof()); string hpnHeaderFull(&buf.front(), count); vector<string> hpnHeaderLines = StringUtilities::split(hpnHeaderFull, '\n'); if (!parseHeader(hpnHeaderLines, mFieldHPN)) //parse band 8 header { mFieldHPN.clear(); } } hpnFile.close(); return (!mFieldHRF.empty() || !mFieldHTM.empty() || !mFieldHPN.empty()); }
vector<ImportDescriptor*> SignatureImporter::getImportDescriptors(const string& filename) { vector<ImportDescriptor*> descriptors; if (filename.empty()) { return descriptors; } LargeFileResource pSigFile; if (!pSigFile.open(filename, O_RDONLY | O_BINARY, S_IREAD)) { return descriptors; } // load the data FactoryResource<DynamicObject> pMetadata; VERIFYRV(pMetadata.get() != NULL, descriptors); bool readError = false; string line; string unitName("Reflectance"); UnitType unitType(REFLECTANCE); double unitScale(1.0); // parse the metadata for (line = pSigFile.readLine(&readError); (readError == false) && (line.find('=') != string::npos); line = pSigFile.readLine(&readError)) { vector<string> metadataEntry; trim(line); split(metadataEntry, line, is_any_of("=")); if (metadataEntry.size() == 2) { string key = metadataEntry[0]; string value = metadataEntry[1]; trim(key); trim(value); if (ends_with(key, "Bands") || key == "Pixels") { pMetadata->setAttribute(key, StringUtilities::fromXmlString<unsigned long>(value)); } else if (key == "UnitName") { unitName = value; } else if (key == "UnitType") { unitType = StringUtilities::fromXmlString<UnitType>(value); } else if (key == "UnitScale") { unitScale = StringUtilities::fromXmlString<double>(value); } else { pMetadata->setAttribute(key, value); } } } if ((readError == true) && (pSigFile.eof() != 1)) { return descriptors; } // Verify that the next line contains float float pairs vector<string> dataEntry; trim(line); split(dataEntry, line, is_space()); if (dataEntry.size() != 2) { return descriptors; } bool error = false; StringUtilities::fromXmlString<float>(dataEntry[0], &error); !error && StringUtilities::fromXmlString<float>(dataEntry[1], &error); if (error) { return descriptors; } string datasetName = dv_cast<string>(pMetadata->getAttribute("Name"), filename); ImportDescriptorResource pImportDescriptor(datasetName, "Signature"); VERIFYRV(pImportDescriptor.get() != NULL, descriptors); SignatureDataDescriptor* pDataDescriptor = dynamic_cast<SignatureDataDescriptor*>(pImportDescriptor->getDataDescriptor()); VERIFYRV(pDataDescriptor != NULL, descriptors); FactoryResource<SignatureFileDescriptor> pFileDescriptor; VERIFYRV(pFileDescriptor.get() != NULL, descriptors); pFileDescriptor->setFilename(filename); FactoryResource<Units> pReflectanceUnits; VERIFYRV(pReflectanceUnits.get() != NULL, descriptors); pReflectanceUnits->setUnitName(unitName); pReflectanceUnits->setUnitType(unitType); if (unitScale != 0.0) { pReflectanceUnits->setScaleFromStandard(1.0 / unitScale); } pDataDescriptor->setUnits("Reflectance", pReflectanceUnits.get()); pFileDescriptor->setUnits("Reflectance", pReflectanceUnits.get()); pDataDescriptor->setFileDescriptor(pFileDescriptor.get()); pDataDescriptor->setMetadata(pMetadata.get()); descriptors.push_back(pImportDescriptor.release()); return descriptors; }
bool SignatureImporter::execute(PlugInArgList* pInArgList, PlugInArgList* OutArgList) { VERIFY(pInArgList != NULL); ProgressTracker progress(pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg()), "Loading spectral signature", "spectral", "5A9F8379-7D7D-4575-B78B-305AE0DFC66D"); Signature* pSignature = pInArgList->getPlugInArgValue<Signature>(Importer::ImportElementArg()); VERIFY(pSignature != NULL); DataDescriptor* pDataDescriptor = pSignature->getDataDescriptor(); VERIFY(pDataDescriptor != NULL); FileDescriptor* pFileDescriptor = pDataDescriptor->getFileDescriptor(); VERIFY(pFileDescriptor != NULL); progress.getCurrentStep()->addProperty("filename", pFileDescriptor->getFilename().getFullPathAndName()); DynamicObject* pMetadata = pSignature->getMetadata(); VERIFY(pMetadata != NULL); string warningMsg; LargeFileResource pSigFile; VERIFY(pSigFile.open(pFileDescriptor->getFilename().getFullPathAndName(), O_RDONLY | O_BINARY, S_IREAD)); const Units* pUnits = pSignature->getUnits("Reflectance"); VERIFY(pUnits != NULL); // Read the signature data vector<double> wavelengthData, reflectanceData; int64_t fileSize = pSigFile.fileLength(); bool readError = false; size_t largeValueCount(0); for (string line = pSigFile.readLine(&readError); readError == false; line = pSigFile.readLine(&readError)) { if (isAborted()) { progress.report("Importer aborted", 0, ABORT, true); return false; } int64_t fileLocation = pSigFile.tell(); progress.report("Loading signature data", static_cast<int>(fileLocation * 100.0 / fileSize), NORMAL); trim(line); if (line.empty()) { continue; } if (line.find('=') == string::npos) { double wavelength = 0.0, reflectance = 0.0; vector<string> dataEntry; split(dataEntry, line, is_space()); bool error = true; if (dataEntry.size() >= 1) { wavelength = StringUtilities::fromXmlString<double>(dataEntry[0], &error); if (wavelength > 50.0) { // Assume wavelength values are in nanometers and convert to microns wavelength = Wavelengths::convertValue(wavelength, NANOMETERS, MICRONS); } } if (!error && dataEntry.size() == 2) { reflectance = StringUtilities::fromXmlString<double>(dataEntry[1], &error); // Since the signature file may not have contained info on units and unitScale (defaults to values of // "REFLECTANCE" and "1.0"), we need to check that the reflectance value is properly scaled. // In theory, a valid reflectance value should be between 0 and 1, but real data may extend beyond these // limits due to errors that occurred in collection, calibration, conversion, etc. We're assuming that a // value greater than 2.0 indicates that the value was scaled by a factor other than 1.0 - a common data // collection practice is to store a data value as an integer value equal to the actual value multiplied // by a scaling factor. This saves storage space while preserving precision. 10000 is a very common // scaling factor and the one we will assume was used. Right now we'll just count the number of large values. // If more than half the values are large, we will assume they were scaled and divide all the values by 10000. if (pUnits->getUnitType() == REFLECTANCE && pUnits->getScaleFromStandard() == 1.0 && fabs(reflectance) > 2.0) { ++largeValueCount; } } if (error) { progress.report("Error parsing signature data", 0, ERRORS, true); } wavelengthData.push_back(wavelength); reflectanceData.push_back(reflectance); } } if ((readError == true) && (pSigFile.eof() != 1)) { progress.report("Unable to read signature file", 0, ERRORS, true); return false; } // check for need to scale the values, i.e., at least half the values are large if (reflectanceData.empty() == false && largeValueCount > 0 && largeValueCount >= (reflectanceData.size() / 2)) { warningMsg += (warningMsg.empty() ? "" : "\n"); warningMsg += "Values appear to have been scaled - values have been divided by 10000"; for (vector<double>::iterator it = reflectanceData.begin(); it != reflectanceData.end(); ++it) { *it *= 0.0001; // divide by 10000 } } pSignature->setData("Wavelength", wavelengthData); pSignature->setData("Reflectance", reflectanceData); if (warningMsg.empty()) { progress.report("Spectral signature loaded", 100, NORMAL); } else { progress.report(warningMsg, 100, WARNING); progress.getCurrentStep()->addMessage(warningMsg, "spectral", "770EB61A-71CD-4f83-8C7B-E0FEF3D7EB8D"); } progress.upALevel(); return true; }
bool DicomImporter::validateDefaultOnDiskReadOnly(const DataDescriptor *pDescriptor, std::string &errorMessage) const { const RasterDataDescriptor *pRasterDescriptor = dynamic_cast<const RasterDataDescriptor*>(pDescriptor); if(pRasterDescriptor == NULL) { errorMessage = "The data descriptor is invalid."; return false; } const RasterFileDescriptor *pFileDescriptor = dynamic_cast<const RasterFileDescriptor*>(pRasterDescriptor->getFileDescriptor()); if(pFileDescriptor == NULL) { errorMessage = "The file descriptor is invalid."; return false; } ProcessingLocation loc = pDescriptor->getProcessingLocation(); if (loc == ON_DISK_READ_ONLY) { // Invalid filename const Filename &filename = pFileDescriptor->getFilename(); if(filename.getFullPathAndName().empty()) { errorMessage = "The filename is invalid."; return false; } // Existing file LargeFileResource file; if(!file.open(filename.getFullPathAndName(), O_RDONLY | O_BINARY, S_IREAD)) { errorMessage = "The file: " + std::string(filename) + " does not exist."; return false; } // Data can be decoded DicomImage img(filename.getFullPathAndName().c_str()); if(img.getStatus() != EIS_Normal) { errorMessage = std::string("Unable to decode dataset: ") + DicomImage::getString(img.getStatus()); return false; } // Interleave conversions InterleaveFormatType dataInterleave = pRasterDescriptor->getInterleaveFormat(); InterleaveFormatType fileInterleave = pFileDescriptor->getInterleaveFormat(); if(dataInterleave != fileInterleave) { errorMessage = "Interleave format conversions are not supported with on-disk read-only processing."; return false; } //Subset unsigned int loadedBands = pRasterDescriptor->getBandCount(); unsigned int fileBands = pFileDescriptor->getBandCount(); unsigned int skipFactor = 0; if(!RasterUtilities::determineSkipFactor(pRasterDescriptor->getRows(), skipFactor) || skipFactor != 0) { errorMessage = "Skip factors are not supported for rows or columns with on-disk read-only processing."; return false; } if(!RasterUtilities::determineSkipFactor(pRasterDescriptor->getColumns(), skipFactor) || skipFactor != 0) { errorMessage = "Skip factors are not supported for rows or columns with on-disk read-only processing."; return false; } } return true; }
bool ImporterShell::validate(const DataDescriptor* pDescriptor, string& errorMessage) const { mValidationError = ValidationTest(); // Check for no validation int validationTest = getValidationTest(pDescriptor); if (validationTest == NO_VALIDATION) { return true; } // Always validate the data descriptor and file descriptor if (pDescriptor == NULL) { errorMessage = "The data set information is invalid."; return false; } const FileDescriptor* pFileDescriptor = pDescriptor->getFileDescriptor(); if (pFileDescriptor == NULL) { errorMessage = "The data set does not contain valid file information."; return false; } // Existing file const string& filename = pFileDescriptor->getFilename(); if (validationTest & EXISTING_FILE) { // Valid filename if (filename.empty() == true) { errorMessage = "The filename is invalid."; mValidationError = EXISTING_FILE; return false; } // Existing file LargeFileResource file(true); if (!file.open(filename.c_str(), O_RDONLY | O_BINARY, S_IREAD)) { errorMessage = "The file: " + filename + " does not exist."; mValidationError = EXISTING_FILE; return false; } } // Existing data element if (validationTest & NO_EXISTING_DATA_ELEMENT) { const string& name = pDescriptor->getName(); const string& type = pDescriptor->getType(); DataElement* pParent = pDescriptor->getParent(); Service<ModelServices> pModel; if (pModel->getElement(name, type, pParent) != NULL) { errorMessage = "The data set currently exists. It may have already been imported."; mValidationError = NO_EXISTING_DATA_ELEMENT; return false; } } // Valid classification Service<UtilityServices> pUtilities; if (validationTest & VALID_CLASSIFICATION) { // Existing Classification object const Classification* pClassification = pDescriptor->getClassification(); if (pClassification == NULL) { errorMessage = "The required classification does not exist."; mValidationError = VALID_CLASSIFICATION; return false; } // Unauthorized classification level on the system - warn the user, but continue to load the file FactoryResource<Classification> pSystemClassification; pSystemClassification->setLevel(pUtilities->getDefaultClassification()); if (pClassification->hasGreaterLevel(pSystemClassification.get()) == true) { errorMessage = "THIS FILE CONTAINS CLASSIFIED INFORMATION WHICH SHOULD NOT BE PROCESSED ON THIS SYSTEM!\n" "THIS MAY CONSTITUTE A SECURITY VIOLATION WHICH SHOULD BE REPORTED TO YOUR SECURITY OFFICER!\n"; StepResource pStep("Validate", "app", "1A881267-6A96-4eb2-A9D3-7D30334B0A0B", errorMessage); } } // Valid metadata if (validationTest & VALID_METADATA) { if (pDescriptor->getMetadata() == NULL) { errorMessage = "The required metadata does not exist."; mValidationError = VALID_METADATA; return false; } } // Processing location if (validationTest & VALID_PROCESSING_LOCATION) { if (isProcessingLocationSupported(pDescriptor->getProcessingLocation()) == false) { errorMessage = "The specified processing location is not supported."; mValidationError = VALID_PROCESSING_LOCATION; return false; } } // If no RasterDataDescriptor or RasterFileDescriptor tests are performed, end here if (validationTest < RASTER_SIZE) { return true; } // Since raster tests have been specified, always validate the raster data descriptor and raster file descriptor const RasterDataDescriptor* pRasterDescriptor = dynamic_cast<const RasterDataDescriptor*>(pDescriptor); if (pRasterDescriptor == NULL) { errorMessage = "The data set does not contain raster information."; return false; } const RasterFileDescriptor* pRasterFileDescriptor = dynamic_cast<const RasterFileDescriptor*>(pRasterDescriptor->getFileDescriptor()); if (pRasterFileDescriptor == NULL) { errorMessage = "The file does not contain valid raster data."; return false; } // Raster size if (validationTest & RASTER_SIZE) { // Data set size unsigned int loadedRows = pRasterDescriptor->getRowCount(); unsigned int loadedColumns = pRasterDescriptor->getColumnCount(); unsigned int loadedBands = pRasterDescriptor->getBandCount(); if ((loadedRows == 0) || (loadedColumns == 0) || (loadedBands == 0)) { errorMessage = "The data set is empty. Check the size of the rows, columns, and bands."; mValidationError = RASTER_SIZE; return false; } // Pixel size if (pRasterFileDescriptor->getBitsPerElement() == 0) { errorMessage = "The number of bits per element is invalid."; mValidationError = RASTER_SIZE; return false; } } // Data type if (validationTest & VALID_DATA_TYPE) { const std::vector<EncodingType>& dataTypes = pRasterDescriptor->getValidDataTypes(); if (std::find(dataTypes.begin(), dataTypes.end(), pRasterDescriptor->getDataType()) == dataTypes.end()) { errorMessage = "The data type is not valid for this data set."; mValidationError = VALID_DATA_TYPE; return false; } } // Header bytes if (validationTest & NO_HEADER_BYTES) { if (pRasterFileDescriptor->getHeaderBytes() > 0) { errorMessage = "The file has an invalid number of header bytes."; mValidationError = NO_HEADER_BYTES; return false; } } // Preline and postline bytes if (validationTest & NO_PRE_POST_LINE_BYTES) { if ((pRasterFileDescriptor->getPrelineBytes() > 0) || (pRasterFileDescriptor->getPostlineBytes() > 0)) { errorMessage = "The file has an invalid number of preline and/or postline bytes."; mValidationError = NO_PRE_POST_LINE_BYTES; return false; } } // Preband and postband bytes if (validationTest & NO_PRE_POST_BAND_BYTES) { if ((pRasterFileDescriptor->getPrebandBytes() > 0) || (pRasterFileDescriptor->getPostbandBytes() > 0)) { errorMessage = "The file has an invalid number of preband and/or postband bytes."; mValidationError = NO_PRE_POST_BAND_BYTES; return false; } } // Trailer bytes if (validationTest & NO_TRAILER_BYTES) { if (pRasterFileDescriptor->getTrailerBytes() > 0) { errorMessage = "The file has an invalid number of trailer bytes."; mValidationError = NO_TRAILER_BYTES; return false; } } // File size int64_t requiredSize = RasterUtilities::calculateFileSize(pRasterFileDescriptor); if ((validationTest & FILE_SIZE) == FILE_SIZE) { // Existing file LargeFileResource file; VERIFY(file.open(filename, O_RDONLY | O_BINARY, S_IREAD) == true); // File size if (requiredSize < 0) { errorMessage = "Unable to determine the required file size."; mValidationError = FILE_SIZE; return false; } if (file.fileLength() < requiredSize) { errorMessage = "The size of the file does not match the current parameters."; mValidationError = FILE_SIZE; return false; } } // Band files const vector<const Filename*>& bandFiles = pRasterFileDescriptor->getBandFiles(); if (validationTest & NO_BAND_FILES) { if (bandFiles.empty() == false) { errorMessage = "This data set cannot have band data in multiple files."; mValidationError = NO_BAND_FILES; return false; } } // Existing band files and band file sizes if (validationTest & EXISTING_BAND_FILES) { // Enough band files for all bands unsigned int numBands = pRasterFileDescriptor->getBandCount(); if (bandFiles.size() < numBands) { errorMessage = "The number of band files specified is less than the total number of bands to be loaded."; mValidationError = EXISTING_BAND_FILES; return false; } // Invalid file for imported bands for (vector<const Filename*>::size_type i = 0; i < bandFiles.size(); ++i) { const Filename* pFilename = bandFiles[i]; if (pFilename == NULL) { stringstream streamMessage; streamMessage << "Band filename " << i + 1 << " is missing."; errorMessage = streamMessage.str(); mValidationError = EXISTING_BAND_FILES; return false; } // Invalid filename string bandFilename = pFilename->getFullPathAndName(); if (bandFilename.empty() == true) { stringstream streamMessage; streamMessage << "Band filename " << i + 1 << " is invalid."; errorMessage = streamMessage.str(); mValidationError = EXISTING_BAND_FILES; return false; } // Existing file LargeFileResource bandFile; if (!bandFile.open(bandFilename, O_RDONLY | O_BINARY, S_IREAD)) { stringstream streamMessage; streamMessage << "Band file " << i + 1 << " does not exist."; errorMessage = streamMessage.str(); mValidationError = EXISTING_BAND_FILES; return false; } // File size if ((validationTest & BAND_FILE_SIZES) == BAND_FILE_SIZES) { if (requiredSize < 0) { errorMessage = "Unable to determine the required band file size."; mValidationError = BAND_FILE_SIZES; return false; } if (bandFile.fileLength() < requiredSize) { stringstream streamMessage; streamMessage << "The size of band file " << i + 1 << " does not match the required size " "for the current parameters."; errorMessage = streamMessage.str(); mValidationError = BAND_FILE_SIZES; return false; } } } } // Band names const DynamicObject* pMetadata = pRasterDescriptor->getMetadata(); if ((validationTest & VALID_BAND_NAMES) == VALID_BAND_NAMES) { VERIFY(pMetadata != NULL); string namesPath[] = { SPECIAL_METADATA_NAME, BAND_METADATA_NAME, NAMES_METADATA_NAME, END_METADATA_NAME }; // If band names are present in the metadata, check the number of names against the number of bands // If band names are not present in the metadata, then succeed const vector<string>* pBandNames = dv_cast<vector<string> >(&pMetadata->getAttributeByPath(namesPath)); if (pBandNames != NULL) { if (pBandNames->size() != pRasterFileDescriptor->getBandCount()) { errorMessage = "The number of band names in the metadata does not match the number of bands."; mValidationError = VALID_BAND_NAMES; return false; } } } // Wavelengths if ((validationTest & VALID_WAVELENGTHS) == VALID_WAVELENGTHS) { VERIFY(pMetadata != NULL); // If wavelengths are present in the metadata, check the number of wavelengths against the number of bands // If wavelengths are not present in the metadata, then succeed FactoryResource<Wavelengths> pWavelengths; if (pWavelengths->initializeFromDynamicObject(pMetadata, false) == true) { if (pWavelengths->getNumWavelengths() != pRasterFileDescriptor->getBandCount()) { errorMessage = "The number of wavelengths in the metadata does not match the number of bands."; mValidationError = VALID_WAVELENGTHS; return false; } } } // Interleave conversions if (validationTest & NO_INTERLEAVE_CONVERSIONS) { InterleaveFormatType dataInterleave = pRasterDescriptor->getInterleaveFormat(); InterleaveFormatType fileInterleave = pRasterFileDescriptor->getInterleaveFormat(); if ((pRasterFileDescriptor->getBandCount() > 1) && (dataInterleave != fileInterleave)) { errorMessage = "Interleave format conversions are not supported."; mValidationError = NO_INTERLEAVE_CONVERSIONS; return false; } } // Skip factors if (validationTest & NO_ROW_SKIP_FACTOR) { if (pRasterDescriptor->getRowSkipFactor() > 0) { errorMessage = "Row skip factors are not supported."; mValidationError = NO_ROW_SKIP_FACTOR; return false; } } if (validationTest & NO_COLUMN_SKIP_FACTOR) { if (pRasterDescriptor->getColumnSkipFactor() > 0) { errorMessage = "Column skip factors are not supported."; mValidationError = NO_COLUMN_SKIP_FACTOR; return false; } } // Subsets if (validationTest & NO_ROW_SUBSETS) { if (pRasterDescriptor->getRowCount() != pRasterFileDescriptor->getRowCount()) { errorMessage = "Row subsets are not supported."; mValidationError = NO_ROW_SUBSETS; return false; } } if (validationTest & NO_COLUMN_SUBSETS) { if (pRasterDescriptor->getColumnCount() != pRasterFileDescriptor->getColumnCount()) { errorMessage = "Column subsets are not supported."; mValidationError = NO_COLUMN_SUBSETS; return false; } } if (validationTest & NO_BAND_SUBSETS) { if (pRasterDescriptor->getBandCount() != pRasterFileDescriptor->getBandCount()) { errorMessage = "Band subsets are not supported."; mValidationError = NO_BAND_SUBSETS; return false; } } // Available memory if (validationTest & AVAILABLE_MEMORY) { unsigned int loadedRows = pRasterDescriptor->getRowCount(); unsigned int loadedColumns = pRasterDescriptor->getColumnCount(); unsigned int loadedBands = pRasterDescriptor->getBandCount(); unsigned int bytesPerElement = pRasterDescriptor->getBytesPerElement(); uint64_t dataSize = loadedRows * loadedColumns * loadedBands * bytesPerElement; uint64_t maxMemoryAvail = pUtilities->getMaxMemoryBlockSize(); #if PTR_SIZE > 4 uint64_t totalRam = pUtilities->getTotalPhysicalMemory(); if (totalRam < maxMemoryAvail) { maxMemoryAvail = totalRam; } #endif if (dataSize > maxMemoryAvail) { errorMessage = "The data set cannot be loaded into memory. Use a different " "processing location or specify a subset."; mValidationError = AVAILABLE_MEMORY; return false; } } return true; }