bool Nitf::NitfImporterShell::validate(const DataDescriptor* pDescriptor,
const vector<const DataDescriptor*>& importedDescriptors,
string& errorMessage) const
{
if (pDescriptor == NULL)
{
return false;
}
// Get the name of the file being imported
const FileDescriptor* const pFileDescriptor = pDescriptor->getFileDescriptor();
VERIFY(pFileDescriptor != NULL);
string filename = pFileDescriptor->getFilename().getFullPathAndName();
// Get the image segment being validated
const string& datasetLocation = pFileDescriptor->getDatasetLocation();
VERIFY(datasetLocation.empty() == false);
string imageSegmentText = datasetLocation.substr(1);
ossim_uint32 imageSegment = StringUtilities::fromDisplayString<unsigned int>(imageSegmentText) - 1;
// Check for J2K compression, which can be imported without ossim
const DynamicObject* pMetadata = pDescriptor->getMetadata();
VERIFY(pMetadata != NULL);
const string attributePath[] =
{
Nitf::NITF_METADATA,
Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::COMPRESSION,
END_METADATA_NAME
};
string imageCompression = pMetadata->getAttributeByPath(attributePath).toDisplayString();
if ((imageCompression != Nitf::ImageSubheaderFieldValues::IC_C8) &&
(imageCompression != Nitf::ImageSubheaderFieldValues::IC_M8))
{
// This image segment does not have J2K compression, so check if it can be imported by ossim
Nitf::OssimImageHandlerResource pHandler(filename);
if (pHandler.get() == NULL || pHandler->canCastTo("ossimNitfTileSource") == false)
{
errorMessage = "This image segment is not supported by the " + getName() + ".";
return false;
}
vector<ossim_uint32> importableImageSegments;
pHandler->getEntryList(importableImageSegments);
vector<ossim_uint32>::iterator segmentIter = find(importableImageSegments.begin(),
importableImageSegments.end(), imageSegment);
if (segmentIter == importableImageSegments.end())
{
// This image segment cannot be imported by ossim, which is generally due to the image segment
// using an unsupported compression format
errorMessage = "This image segment is not supported by the " + getName() + ".";
return false;
}
}
// Perform the default validation checks
if (RasterElementImporterShell::validate(pDescriptor, importedDescriptors, errorMessage) == false)
{
ValidationTest errorTest = getValidationError();
if (errorTest == NO_BAND_FILES)
{
const RasterDataDescriptor* pRasterDescriptor = dynamic_cast<const RasterDataDescriptor*>(pDescriptor);
VERIFY(pRasterDescriptor != NULL);
if (pRasterDescriptor->getInterleaveFormat() == BSQ)
{
errorMessage += " Bands in multiple files are not supported with on-disk read-only processing.";
}
}
else if ((errorTest == NO_ROW_SUBSETS) || (errorTest == NO_COLUMN_SUBSETS))
{
errorMessage = errorMessage.substr(0, errorMessage.length() - 1);
errorMessage += " with on-disk read-only processing.";
}
return false;
}
// Add any previously obtained warning messages to the output message
map<ossim_uint32, string>::const_iterator messageIter = mParseMessages.find(imageSegment);
if (messageIter != mParseMessages.end() && messageIter->second.empty() == false)
{
if (errorMessage.empty() == false)
{
errorMessage += "\n";
}
errorMessage += messageIter->second;
}
// Check for file sizes too large for the current platform
const qint64 actualSize = QFile(QString::fromStdString(filename)).size();
const qint64 maxSize = numeric_limits<ossim_uint64>::max() & numeric_limits<streamoff>::max();
if (actualSize > maxSize)
{
if (errorMessage.empty() == false)
{
errorMessage += "\n";
}
errorMessage += "This file exceeds the maximum supported size for this platform. "
"Data at the end of the file may be missing or incorrect. "
"IMPORT DATA FROM THIS FILE WITH THE KNOWLEDGE THAT IT IS NOT FULLY SUPPORTED.";
}
// warn user if unsupported metadata is in the file
// NITF 2.0: ICORDS values of U and C are unsupported
const string versionPathName[] = { Nitf::NITF_METADATA, Nitf::FILE_HEADER,
Nitf::FileHeaderFieldNames::FILE_VERSION, END_METADATA_NAME };
if (pMetadata->getAttributeByPath(versionPathName).toDisplayString() == Nitf::VERSION_02_00)
{
const string iCordsPath[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::ICORDS, END_METADATA_NAME };
string iCords = pMetadata->getAttributeByPath(iCordsPath).toDisplayString();
if (iCords == Nitf::ImageSubheaderFieldValues::ICORDS_GEOCENTRIC)
{
if (errorMessage.empty() == false)
{
errorMessage += "\n";
}
errorMessage += "The ICORDS is not a supported value.";
}
}
// LUTs are unsupported
bool hasLut = false;
const string irepPathName[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::REPRESENTATION, END_METADATA_NAME };
string irep;
const DataVariant& dvIrep = pMetadata->getAttributeByPath(irepPathName);
if (dvIrep.getValue(irep) == true)
{
if (irep == Nitf::ImageSubheaderFieldValues::REPRESENTATION_LUT)
{
hasLut = true;
}
}
if (hasLut == false)
{
vector<string> irepBands;
const string irepBandsPathName[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::BAND_REPRESENTATIONS, END_METADATA_NAME };
const DataVariant& dvIrepBands = pMetadata->getAttributeByPath(irepBandsPathName);
if (dvIrepBands.getValue(irepBands) == true)
{
for (vector<string>::iterator iter = irepBands.begin(); iter != irepBands.end(); iter++)
{
if (*iter == Nitf::ImageSubheaderFieldValues::BAND_REPRESENTATIONS_LUT)
{
hasLut = true;
break;
}
}
}
}
if (hasLut == false)
{
vector<unsigned int> numLuts;
const string numLutsPathName[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::NUMBER_OF_LUTS, END_METADATA_NAME };
const DataVariant& dvNumLuts = pMetadata->getAttributeByPath(numLutsPathName);
if (dvNumLuts.getValue(numLuts) == true)
{
for (vector<unsigned int>::iterator iter = numLuts.begin(); iter != numLuts.end(); iter++)
{
if (*iter > 0)
{
hasLut = true;
break;
}
}
}
}
if (hasLut == true)
{
if (errorMessage.empty() == false)
{
errorMessage += "\n";
}
errorMessage += "The lookup table will not be applied.";
}
// Check for valid Classification markings. If any level is higher than the file header, display a warning.
FactoryResource<Classification> pClassification;
const Classification* pOverallClassification = pDescriptor->getClassification();
VERIFY(pOverallClassification != NULL);
// Look in the image subheader.
string imageClassLevel;
const string imageClassLevelPathName[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::SECURITY_LEVEL, END_METADATA_NAME };
const DataVariant& dvImageClassLevel = pMetadata->getAttributeByPath(imageClassLevelPathName);
if (dvImageClassLevel.getValue(imageClassLevel) == true)
{
pClassification->setLevel(imageClassLevel);
if (pClassification->hasGreaterLevel(pOverallClassification) == true)
{
if (errorMessage.empty() == false)
{
errorMessage += "\n";
}
errorMessage += "THIS FILE CONTAINS INVALID CLASSIFICATION INFORMATION! The image has a higher "
"classification level than the file. Update the Classification information before proceeding.";
}
}
// Look in each DES subheader.
int numDes;
const string numDesPathName[] = { Nitf::NITF_METADATA, Nitf::FILE_HEADER,
Nitf::FileHeaderFieldNames::NUM_DES, END_METADATA_NAME };
const DataVariant& dvNumDes = pMetadata->getAttributeByPath(numDesPathName);
if (dvNumDes.getValue(numDes) == true)
{
for (int i = 0; i < numDes; ++i)
{
stringstream desStr;
desStr << "DES_" << setw(3) << setfill('0') << i;
string desClassLevel;
const string desClassLevelPathName[] = { Nitf::NITF_METADATA, Nitf::DES_METADATA,
desStr.str(), Nitf::DesSubheaderFieldNames::SECURITY_LEVEL, END_METADATA_NAME };
const DataVariant& dvDesClassLevel = pMetadata->getAttributeByPath(desClassLevelPathName);
if (dvDesClassLevel.getValue(desClassLevel) == true)
{
pClassification->setLevel(desClassLevel);
if (pClassification->hasGreaterLevel(pOverallClassification) == true)
{
if (errorMessage.empty() == false)
{
errorMessage += "\n";
}
errorMessage += "THIS FILE CONTAINS INVALID CLASSIFICATION INFORMATION! " + desStr.str() +
" has a higher classification level than the file. Update the Classification information "
"before proceeding.";
}
}
}
}
return true;
}
bool Nitf::NitfImporterShell::validate(const DataDescriptor* pDescriptor, string& errorMessage) const
{
if (RasterElementImporterShell::validate(pDescriptor, errorMessage) == false)
{
ValidationTest errorTest = getValidationError();
if (errorTest == NO_BAND_FILES)
{
const RasterDataDescriptor* pRasterDescriptor = dynamic_cast<const RasterDataDescriptor*>(pDescriptor);
VERIFY(pRasterDescriptor != NULL);
if (pRasterDescriptor->getInterleaveFormat() == BSQ)
{
errorMessage += " Bands in multiple files are not supported with on-disk read-only processing.";
}
}
else if ((errorTest == NO_ROW_SUBSETS) || (errorTest == NO_COLUMN_SUBSETS))
{
errorMessage = errorMessage.substr(0, errorMessage.length() - 1);
errorMessage += " with on-disk read-only processing.";
}
return false;
}
VERIFY(pDescriptor != NULL);
const FileDescriptor* const pFileDescriptor = pDescriptor->getFileDescriptor();
VERIFY(pFileDescriptor != NULL);
map<string, string>::const_iterator iter = mParseMessages.find(pFileDescriptor->getDatasetLocation());
if (iter != mParseMessages.end() && iter->second.empty() == false)
{
errorMessage += iter->second;
}
const qint64 actualSize = QFile(QString::fromStdString(pFileDescriptor->getFilename().getFullPathAndName())).size();
const qint64 maxSize = numeric_limits<ossim_uint64>::max() & numeric_limits<std::streamoff>::max();
if (actualSize > maxSize)
{
errorMessage += "This file exceeds the maximum supported size for this platform.\n"
"Data at the end of the file may be missing or incorrect.\n"
"IMPORT DATA FROM THIS FILE WITH THE KNOWLEDGE THAT IT IS NOT FULLY SUPPORTED.\n";
}
// warn user if unsupported metadata is in the file
// NITF 2.0: ICORDS values of U and C are unsupported
const DynamicObject* pMetadata = pDescriptor->getMetadata();
VERIFY(pMetadata != NULL);
const string versionPathName[] = { Nitf::NITF_METADATA, Nitf::FILE_HEADER,
Nitf::FileHeaderFieldNames::FILE_VERSION, END_METADATA_NAME };
if (pMetadata->getAttributeByPath(versionPathName).toDisplayString() == Nitf::VERSION_02_00)
{
const string iCordsPath[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::ICORDS, END_METADATA_NAME };
string iCords = pMetadata->getAttributeByPath(iCordsPath).toDisplayString();
if (iCords == Nitf::ImageSubheaderFieldValues::ICORDS_GEOCENTRIC)
{
errorMessage += "The ICORDS is not a supported value.\n";
}
}
// LUTs are unsupported
bool hasLut = false;
const string irepPathName[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::REPRESENTATION, END_METADATA_NAME };
string irep;
const DataVariant& dvIrep = pMetadata->getAttributeByPath(irepPathName);
if (dvIrep.getValue(irep) == true)
{
if (irep == Nitf::ImageSubheaderFieldValues::REPRESENTATION_LUT)
{
hasLut = true;
}
}
if (hasLut == false)
{
vector<string> irepBands;
const string irepBandsPathName[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::BAND_REPRESENTATIONS, END_METADATA_NAME };
const DataVariant& dvIrepBands = pMetadata->getAttributeByPath(irepBandsPathName);
if (dvIrepBands.getValue(irepBands) == true)
{
for (vector<string>::iterator iter = irepBands.begin(); iter != irepBands.end(); iter++)
{
if (*iter == Nitf::ImageSubheaderFieldValues::BAND_REPRESENTATIONS_LUT)
{
hasLut = true;
break;
}
}
}
}
if (hasLut == false)
{
vector<unsigned int> numLuts;
const string numLutsPathName[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::NUMBER_OF_LUTS, END_METADATA_NAME };
const DataVariant& dvNumLuts = pMetadata->getAttributeByPath(numLutsPathName);
if (dvNumLuts.getValue(numLuts) == true)
{
for (vector<unsigned int>::iterator iter = numLuts.begin(); iter != numLuts.end(); iter++)
{
if (*iter > 0)
{
hasLut = true;
break;
}
}
}
}
if (hasLut == true)
{
errorMessage += "The lookup table will not be applied.\n";
}
// Check for valid Classification markings. If any level is higher than the file header, display a warning.
FactoryResource<Classification> pClassification;
const Classification* pOverallClassification = pDescriptor->getClassification();
VERIFY(pOverallClassification != NULL);
// Look in the image subheader.
string imageClassLevel;
const string imageClassLevelPathName[] = { Nitf::NITF_METADATA, Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::SECURITY_LEVEL, END_METADATA_NAME };
const DataVariant& dvImageClassLevel = pMetadata->getAttributeByPath(imageClassLevelPathName);
if (dvImageClassLevel.getValue(imageClassLevel) == true)
{
pClassification->setLevel(imageClassLevel);
if (pClassification->hasGreaterLevel(pOverallClassification) == true)
{
errorMessage += "THIS FILE CONTAINS INVALID CLASSIFICATION INFORMATION!\n"
"The image has a higher classification level than the file.\n"
"Update the Classification information before proceeding.\n";
}
}
// Look in each DES subheader.
int numDes;
const string numDesPathName[] = { Nitf::NITF_METADATA, Nitf::FILE_HEADER,
Nitf::FileHeaderFieldNames::NUM_DES, END_METADATA_NAME };
const DataVariant& dvNumDes = pMetadata->getAttributeByPath(numDesPathName);
if (dvNumDes.getValue(numDes) == true)
{
for (int i = 0; i < numDes; ++i)
{
stringstream desStr;
desStr << "DES_" << setw(3) << setfill('0') << i;
string desClassLevel;
const string desClassLevelPathName[] = { Nitf::NITF_METADATA, Nitf::DES_METADATA,
desStr.str(), Nitf::DesSubheaderFieldNames::SECURITY_LEVEL, END_METADATA_NAME };
const DataVariant& dvDesClassLevel = pMetadata->getAttributeByPath(desClassLevelPathName);
if (dvDesClassLevel.getValue(desClassLevel) == true)
{
pClassification->setLevel(desClassLevel);
if (pClassification->hasGreaterLevel(pOverallClassification) == true)
{
errorMessage += "THIS FILE CONTAINS INVALID CLASSIFICATION INFORMATION!\n" +
desStr.str() + " has a higher classification level than the file.\n"
"Update the Classification information before proceeding.\n";
}
}
}
}
return true;
}
