bool RasterElementImporterShell::copyData(const RasterElement* pSrcElement) const
{
VERIFY(pSrcElement != NULL && mpRasterElement != NULL);
const RasterDataDescriptor* pSrcDescriptor = dynamic_cast<const RasterDataDescriptor*>(
pSrcElement->getDataDescriptor());
RasterDataDescriptor* pChipDescriptor = dynamic_cast<RasterDataDescriptor*>(
mpRasterElement->getDataDescriptor());
VERIFY(pSrcDescriptor != NULL && mpRasterElement != NULL);
vector<DimensionDescriptor> selectedRows = getSelectedDims(pSrcDescriptor->getRows(),
pChipDescriptor->getRows());
vector<DimensionDescriptor> selectedColumns = getSelectedDims(pSrcDescriptor->getColumns(),
pChipDescriptor->getColumns());
vector<DimensionDescriptor> selectedBands = getSelectedDims(pSrcDescriptor->getBands(),
pChipDescriptor->getBands());
bool success = true;
Service<SessionManager> pSessionManager;
if (pSessionManager->isSessionLoading() == false)
{
success = RasterUtilities::chipMetadata(mpRasterElement->getMetadata(), selectedRows, selectedColumns,
selectedBands);
}
success = success && pSrcElement->copyDataToChip(mpRasterElement, selectedRows,
selectedColumns, selectedBands, mAborted, mpProgress);
return success;
}
bool PropertiesWavelengths::initialize(SessionItem* pSessionItem)
{
WavelengthsWidget* pWavelengthsPage = dynamic_cast<WavelengthsWidget*>(getWidget());
if (pWavelengthsPage == NULL)
{
return false;
}
DataElement* pElement = dynamic_cast<DataElement*>(pSessionItem);
if (pElement != NULL)
{
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(pElement->getDataDescriptor());
if (pDescriptor != NULL)
{
const DynamicObject* pMetadata = pElement->getMetadata();
if (pMetadata != NULL)
{
mWavelengths.initializeFromDynamicObject(pMetadata, true);
pWavelengthsPage->setWavelengths(pDescriptor->getBands(), &mWavelengths);
return PropertiesShell::initialize(pSessionItem);
}
}
}
return false;
}
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());
}
DataElement* createRasterElement(const char* pName, RasterElementArgs args)
{
if (pName == NULL || args.location > 2)
{
setLastError(SIMPLE_BAD_PARAMS);
return NULL;
}
// Check for an existing element with the name
if (getDataElement(pName, TypeConverter::toString<RasterElement>(), 0) != NULL)
{
setLastError(SIMPLE_EXISTS);
return NULL;
}
RasterElement* pElement = RasterUtilities::createRasterElement(std::string(pName), args.numRows,
args.numColumns, args.numBands, static_cast<EncodingTypeEnum>(args.encodingType),
static_cast<InterleaveFormatTypeEnum>(args.interleaveFormat), args.location != 2, args.pParent);
if (pElement == NULL)
{
switch (args.location)
{
case 0:
pElement = RasterUtilities::createRasterElement(std::string(pName), args.numRows,
args.numColumns, args.numBands, static_cast<EncodingTypeEnum>(args.encodingType),
static_cast<InterleaveFormatTypeEnum>(args.interleaveFormat), false, args.pParent);
if (pElement == NULL)
{
setLastError(SIMPLE_OTHER_FAILURE);
return NULL;
}
break;
case 1:
setLastError(SIMPLE_NO_MEM);
return NULL;
case 2:
setLastError(SIMPLE_OTHER_FAILURE);
return NULL;
default:
setLastError(SIMPLE_BAD_PARAMS);
return NULL;
}
}
if (args.pBadValues != NULL && args.numBadValues > 0)
{
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pElement->getDataDescriptor());
if (pDesc != NULL)
{
std::vector<int> badValues;
badValues.reserve(args.numBadValues);
for (uint32_t idx = 0; idx < args.numBadValues; ++idx)
{
badValues.push_back(args.pBadValues[idx]);
}
pDesc->setBadValues(badValues);
// set on the statistics objects
const std::vector<DimensionDescriptor>& allBands = pDesc->getBands();
for (std::vector<DimensionDescriptor>::const_iterator band = allBands.begin();
band != allBands.end(); ++band)
{
if (band->isValid())
{
Statistics* pStats = pElement->getStatistics(*band);
if (pStats != NULL)
{
pStats->setBadValues(badValues);
}
}
}
pElement->updateData();
}
}
setLastError(SIMPLE_NO_ERROR);
return pElement;
}
bool RasterElementImporterShell::performImport() const
{
Progress* pProgress = getProgress();
StepResource pStep("Perform import", "app", "762EF4BB-8813-4e45-B1BD-4CD237F7C151");
FAIL_IF(mpRasterElement == NULL, "Could not find RasterElement", return false);
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(
mpRasterElement->getDataDescriptor());
FAIL_IF(pDescriptor == NULL, "Could not find RasterDataDescriptor", return false);
string message;
//#pragma message(__FILE__ "(" STRING(__LINE__) ") : warning : Re-evaluate this code when plug-ins " \
// "are being loaded into the global symbol space (tclarke)")
// This was changed from a try/catch due to a problem with the exceptions
// not being caught and propagating up to QApplication::notify on solaris.
// it is believed this is due to how we load plug-ins;
// they are loaded into a private symbol space. When this changes,
// re-evaluate the try/catch model.
if (pDescriptor->getProcessingLocation() == ON_DISK_READ_ONLY)
{
Service<SessionManager> pSessionManager;
if (pSessionManager->isSessionLoading() == false)
{
RasterFileDescriptor* pOrigFileDescriptor = dynamic_cast<RasterFileDescriptor*>(pDescriptor->getFileDescriptor());
std::vector<DimensionDescriptor> orgRows = pOrigFileDescriptor->getRows();
std::vector<DimensionDescriptor> orgColumns = pOrigFileDescriptor->getColumns();
std::vector<DimensionDescriptor> orgBands = pOrigFileDescriptor->getBands();
std::vector<DimensionDescriptor>::iterator iter;
unsigned int i = 0;
for (iter = orgRows.begin(), i = 0; iter != orgRows.end(); ++iter, ++i)
{
iter->setActiveNumber(i);
}
for (iter = orgColumns.begin(), i = 0; iter != orgColumns.end(); ++iter, ++i)
{
iter->setActiveNumber(i);
}
for (iter = orgBands.begin(), i = 0; iter != orgBands.end(); ++iter, ++i)
{
iter->setActiveNumber(i);
}
vector<DimensionDescriptor> selectedRows = getSelectedDims(orgRows,
pDescriptor->getRows());
vector<DimensionDescriptor> selectedColumns = getSelectedDims(orgColumns,
pDescriptor->getColumns());
vector<DimensionDescriptor> selectedBands = getSelectedDims(orgBands,
pDescriptor->getBands());
if (!RasterUtilities::chipMetadata(mpRasterElement->getMetadata(),
selectedRows, selectedColumns, selectedBands))
{
return checkAbortOrError("Could not chip metadata", pStep.get());
}
}
if (createRasterPager(mpRasterElement) == false)
{
return checkAbortOrError("Could not create pager for RasterElement", pStep.get());
}
}
else
{
if (mpRasterElement->createDefaultPager() == false)
{
return checkAbortOrError("Could not allocate resources for new RasterElement", pStep.get());
}
RasterDataDescriptor* pSourceDescriptor = RasterUtilities::generateUnchippedRasterDataDescriptor(mpRasterElement);
if (pSourceDescriptor == NULL)
{
return checkAbortOrError("Could not get unchipped RasterDataDescriptor", pStep.get());
}
ModelResource<RasterElement> pSourceRaster(pSourceDescriptor);
if (pSourceRaster.get() == NULL)
{
return checkAbortOrError("Could not create source RasterElement", pStep.get());
}
if (createRasterPager(pSourceRaster.get()) == false)
{
return checkAbortOrError("Could not create pager for source RasterElement", pStep.get());
}
if (copyData(pSourceRaster.get()) == false)
{
return checkAbortOrError("Could not copy data from source RasterElement", pStep.get());
}
double value = 0.0;
uint64_t badValueCount = mpRasterElement->sanitizeData(value);
if (badValueCount != 0)
{
if (mpProgress != NULL)
{
string message = StringUtilities::toDisplayString(badValueCount) + " bad value(s) found in data.\n" +
"Bad values set to " + StringUtilities::toDisplayString(value);
mpProgress->updateProgress(message, 100, WARNING);
}
}
}
pStep->finalize(Message::Success);
return true;
}
QWidget* RasterElementImporterShell::getPreview(const DataDescriptor* pDescriptor, Progress* pProgress)
{
if (pDescriptor == NULL)
{
return NULL;
}
// Create a copy of the descriptor to change the loading parameters
string previewName = string("Preview: ") + pDescriptor->getName();
RasterDataDescriptor* pLoadDescriptor = dynamic_cast<RasterDataDescriptor*>(pDescriptor->copy(previewName, NULL));
if (pLoadDescriptor == NULL)
{
return NULL;
}
// Set the active row and column numbers
vector<DimensionDescriptor> newRows = pLoadDescriptor->getRows();
for (unsigned int i = 0; i < newRows.size(); ++i)
{
newRows[i].setActiveNumber(i);
}
pLoadDescriptor->setRows(newRows);
vector<DimensionDescriptor> newColumns = pLoadDescriptor->getColumns();
for (unsigned int i = 0; i < newColumns.size(); ++i)
{
newColumns[i].setActiveNumber(i);
}
pLoadDescriptor->setColumns(newColumns);
// Set the bands to load to just the first band and display it in grayscale mode
const vector<DimensionDescriptor>& bands = pLoadDescriptor->getBands();
if (bands.empty() == false)
{
DimensionDescriptor displayBand = bands.front();
displayBand.setActiveNumber(0);
vector<DimensionDescriptor> newBands;
newBands.push_back(displayBand);
pLoadDescriptor->setBands(newBands);
pLoadDescriptor->setDisplayMode(GRAYSCALE_MODE);
pLoadDescriptor->setDisplayBand(GRAY, displayBand);
}
// Set the processing location to load on-disk read-only
pLoadDescriptor->setProcessingLocation(ON_DISK_READ_ONLY);
// Do not georeference
GeoreferenceDescriptor* pLoadGeorefDescriptor = pLoadDescriptor->getGeoreferenceDescriptor();
if (pLoadGeorefDescriptor != NULL)
{
pLoadGeorefDescriptor->setGeoreferenceOnImport(false);
}
// Validate the preview
string errorMessage;
bool bValidPreview = validate(pLoadDescriptor, vector<const DataDescriptor*>(), errorMessage);
if (bValidPreview == false)
{
// Try an in-memory preview
pLoadDescriptor->setProcessingLocation(IN_MEMORY);
bValidPreview = validate(pLoadDescriptor, vector<const DataDescriptor*>(), errorMessage);
}
QWidget* pPreviewWidget = NULL;
if (bValidPreview == true)
{
// Create the model element
RasterElement* pRasterElement = static_cast<RasterElement*>(mpModel->createElement(pLoadDescriptor));
if (pRasterElement != NULL)
{
// Add the progress and raster element to an input arg list
PlugInArgList* pInArgList = NULL;
bool bSuccess = getInputSpecification(pInArgList);
if ((bSuccess == true) && (pInArgList != NULL))
{
bSuccess = pInArgList->setPlugInArgValue(Executable::ProgressArg(), pProgress);
if (bSuccess)
{
bSuccess = pInArgList->setPlugInArgValue(Importer::ImportElementArg(), pRasterElement);
}
}
// Load the data in batch mode
bool bBatch = isBatch();
setBatch();
bSuccess = execute(pInArgList, NULL);
// Restore to interactive mode if necessary
if (bBatch == false)
{
setInteractive();
}
// Create the spatial data view
if (bSuccess == true)
{
string name = pRasterElement->getName();
SpatialDataView* pView = static_cast<SpatialDataView*>(mpDesktop->createView(name, SPATIAL_DATA_VIEW));
if (pView != NULL)
{
// Set the spatial data in the view
pView->setPrimaryRasterElement(pRasterElement);
// Add the cube layer
RasterLayer* pLayer = static_cast<RasterLayer*>(pView->createLayer(RASTER, pRasterElement));
if (pLayer != NULL)
{
// Get the widget from the view
pPreviewWidget = pView->getWidget();
}
else
{
string message = "Could not create the cube layer!";
if (pProgress != NULL)
{
pProgress->updateProgress(message, 0, ERRORS);
}
mpModel->destroyElement(pRasterElement);
}
}
else
{
string message = "Could not create the view!";
if (pProgress != NULL)
{
pProgress->updateProgress(message, 0, ERRORS);
}
mpModel->destroyElement(pRasterElement);
}
}
else
{
mpModel->destroyElement(pRasterElement);
}
}
}
// Delete the data descriptor copy
mpModel->destroyDataDescriptor(pLoadDescriptor);
return pPreviewWidget;
}
ImportDescriptor* Nitf::NitfImporterShell::getImportDescriptor(const string& filename, ossim_uint32 imageSegment,
const Nitf::OssimFileResource& pFile,
const ossimNitfFileHeaderV2_X* pFileHeader,
const ossimNitfImageHeaderV2_X* pImageSubheader)
{
if (pImageSubheader == NULL)
{
return NULL;
}
EncodingType dataType = ossimImageHeaderToEncodingType(pImageSubheader);
if (dataType.isValid() == false)
{
return NULL;
}
stringstream imageNameStream;
imageNameStream << "I" << imageSegment + 1;
string imageName = imageNameStream.str();
ImportDescriptorResource pImportDescriptor(filename + "-" + imageName,
TypeConverter::toString<RasterElement>(), NULL);
VERIFYRV(pImportDescriptor.get() != NULL, NULL);
pImportDescriptor->setImported(pImageSubheader->getRepresentation() != "NODISPLY");
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(pImportDescriptor->getDataDescriptor());
VERIFYRV(pDescriptor != NULL, NULL);
vector<DimensionDescriptor> bands = RasterUtilities::generateDimensionVector(pImageSubheader->getNumberOfBands(),
true, false, true);
pDescriptor->setBands(bands);
vector<DimensionDescriptor> rows = RasterUtilities::generateDimensionVector(pImageSubheader->getNumberOfRows(),
true, false, true);
pDescriptor->setRows(rows);
vector<DimensionDescriptor> cols = RasterUtilities::generateDimensionVector(pImageSubheader->getNumberOfCols(),
true, false, true);
pDescriptor->setColumns(cols);
if (pImageSubheader->getIMode() == "P")
{
pDescriptor->setInterleaveFormat(BIP);
}
else if (pImageSubheader->getIMode() == "R")
{
pDescriptor->setInterleaveFormat(BIL);
}
else
{
pDescriptor->setInterleaveFormat(BSQ);
}
pDescriptor->setDataType(dataType);
pDescriptor->setValidDataTypes(vector<EncodingType>(1, dataType));
pDescriptor->setProcessingLocation(IN_MEMORY);
map<string, TrePlugInResource> parsers;
string errorMessage;
// Set the file descriptor
RasterFileDescriptor* pFileDescriptor = dynamic_cast<RasterFileDescriptor*>(
RasterUtilities::generateAndSetFileDescriptor(pDescriptor, filename, imageName, LITTLE_ENDIAN_ORDER));
if (pFileDescriptor == NULL)
{
return NULL;
}
// Set the bits per element, which may be different than the data type in the data descriptor,
// using NBPP instead of ABPP as is done in ossimNitfTileSource.cpp.
unsigned int bitsPerPixel = static_cast<unsigned int>(pImageSubheader->getBitsPerPixelPerBand());
pFileDescriptor->setBitsPerElement(bitsPerPixel);
// Populate the metadata and set applicable values in the data descriptor
if (Nitf::importMetadata(imageSegment + 1, pFile, pFileHeader, pImageSubheader, pDescriptor, parsers,
errorMessage) == true)
{
// Populate specific fields in the data descriptor or file descriptor from the TREs
const DynamicObject* pMetadata = pDescriptor->getMetadata();
VERIFYRV(pMetadata, NULL);
// Pixel size - This info is contained in multiple TREs, but there is no documentation on which
// TRE contains the more precise value if multiple TREs containing the info are present. Choosing
// the order ACFTA, BANDSA, ACFTB, and BANDSB where the later "B" TREs will overwrite the values
// contained in the earlier "A" TREs. The BANDSB TRE contains GSD values for each band, which is
// currently not supported, so only set the pixel size if the values in all bands are the same.
double xGsd = 1.0;
double yGsd = 1.0;
const string acrftaPath[] =
{
Nitf::NITF_METADATA,
Nitf::TRE_METADATA,
"ACFTA",
"0",
END_METADATA_NAME
};
const DynamicObject* pAcrftA = dv_cast<DynamicObject>(&pMetadata->getAttributeByPath(acrftaPath));
if (pAcrftA != NULL)
{
// The ACFTA spec calls out specific spacing units for "SAR" and "EO-IR" data, but does not indicate how
// this is determined. It seems to be related to the ACFTB SENSOR_ID_TYPE field, but that field is not
// present in the ACFTA TRE. So just check for "SAR" data from the ICAT field in the image subheader
// and assume every other data type is "EO-IR" data.
const string imageCategory = pImageSubheader->getCategory().trim();
const DataVariant& rowSpacing = pAcrftA->getAttribute(Nitf::TRE::ACFTA::ROW_SPACING);
if (rowSpacing.isValid() == true)
{
if (imageCategory == "SAR")
{
yGsd = getGsd(rowSpacing, "f"); // Feet
}
else
{
yGsd = getGsd(rowSpacing, "r"); // Micro-radians
}
}
const DataVariant& columnSpacing = pAcrftA->getAttribute(Nitf::TRE::ACFTA::COL_SPACING);
if (columnSpacing.isValid() == true)
{
if (imageCategory == "SAR")
{
xGsd = getGsd(columnSpacing, "f"); // Feet
}
else
{
xGsd = getGsd(columnSpacing, "r"); // Micro-radians
}
}
}
const string bandsaPath[] =
{
Nitf::NITF_METADATA,
Nitf::TRE_METADATA,
"BANDSA",
"0",
END_METADATA_NAME
};
const DynamicObject* pBandsA = dv_cast<DynamicObject>(&pMetadata->getAttributeByPath(bandsaPath));
if (pBandsA != NULL)
{
const DataVariant& rowSpacing = pBandsA->getAttribute(Nitf::TRE::BANDSA::ROW_SPACING);
if (rowSpacing.isValid() == true)
{
const DataVariant& rowSpacingUnits = pBandsA->getAttribute(Nitf::TRE::BANDSA::ROW_SPACING_UNITS);
if (rowSpacingUnits.isValid() == true)
{
yGsd = getGsd(rowSpacing, rowSpacingUnits.toXmlString());
}
}
const DataVariant& columnSpacing = pBandsA->getAttribute(Nitf::TRE::BANDSA::COL_SPACING);
if (columnSpacing.isValid() == true)
{
const DataVariant& columnSpacingUnits = pBandsA->getAttribute(Nitf::TRE::BANDSA::COL_SPACING_UNITS);
if (columnSpacingUnits.isValid() == true)
{
xGsd = getGsd(columnSpacing, columnSpacingUnits.toXmlString());
}
}
}
const string acrftbPath[] =
{
Nitf::NITF_METADATA,
Nitf::TRE_METADATA,
"ACFTB",
"0",
END_METADATA_NAME
};
const DynamicObject* pAcrftB = dv_cast<DynamicObject>(&pMetadata->getAttributeByPath(acrftbPath));
if (pAcrftB != NULL)
{
const DataVariant& rowSpacing = pAcrftB->getAttribute(Nitf::TRE::ACFTB::ROW_SPACING);
if (rowSpacing.isValid() == true)
{
const DataVariant& rowSpacingUnits = pAcrftB->getAttribute(Nitf::TRE::ACFTB::ROW_SPACING_UNITS);
if (rowSpacingUnits.isValid() == true)
{
yGsd = getGsd(rowSpacing, rowSpacingUnits.toXmlString());
}
}
const DataVariant& columnSpacing = pAcrftB->getAttribute(Nitf::TRE::ACFTB::COL_SPACING);
if (columnSpacing.isValid() == true)
{
const DataVariant& columnSpacingUnits = pAcrftB->getAttribute(Nitf::TRE::ACFTB::COL_SPACING_UNITS);
if (columnSpacingUnits.isValid() == true)
{
xGsd = getGsd(columnSpacing, columnSpacingUnits.toXmlString());
}
}
}
const string bandsbPath[] =
{
Nitf::NITF_METADATA,
Nitf::TRE_METADATA,
"BANDSB",
"0",
END_METADATA_NAME
};
const DynamicObject* pBandsB = dv_cast<DynamicObject>(&pMetadata->getAttributeByPath(bandsbPath));
if (pBandsB != NULL)
{
bool validRowGsd = false;
const DataVariant& rowGsd = pBandsB->getAttribute(Nitf::TRE::BANDSB::ROW_GSD);
if (rowGsd.isValid() == true)
{
const DataVariant& rowGsdUnits = pBandsB->getAttribute(Nitf::TRE::BANDSB::ROW_GSD_UNIT);
if (rowGsdUnits.isValid() == true)
{
yGsd = getGsd(rowGsd, rowGsdUnits.toXmlString());
validRowGsd = true;
}
}
if (validRowGsd == false)
{
if (pBandsB->getAttribute(Nitf::TRE::BANDSB::ROW_GSD + "#0").isValid())
{
double commonYGsd = -1.0;
unsigned int numBands = pDescriptor->getBandCount();
for (unsigned int i = 0; i < numBands; ++i)
{
double bandYGsd = -1.0;
string bandPostfix = "#" + StringUtilities::toDisplayString(i);
const DataVariant& bandRowGsd = pBandsB->getAttribute(Nitf::TRE::BANDSB::ROW_GSD + bandPostfix);
if (bandRowGsd.isValid() == true)
{
const DataVariant& bandRowGsdUnits = pBandsB->getAttribute(Nitf::TRE::BANDSB::ROW_GSD_UNIT +
bandPostfix);
if (bandRowGsdUnits.isValid() == true)
{
bandYGsd = getGsd(bandRowGsd, bandRowGsdUnits.toXmlString());
}
}
if (bandYGsd == commonYGsd)
{
continue;
}
if (commonYGsd != -1.0)
{
commonYGsd = -1.0;
break;
}
commonYGsd = bandYGsd;
}
if (commonYGsd != 1.0)
{
yGsd = commonYGsd;
}
}
}
bool validColumnGsd = false;
const DataVariant& columnGsd = pBandsB->getAttribute(Nitf::TRE::BANDSB::COL_GSD);
if (columnGsd.isValid() == true)
{
const DataVariant& columnGsdUnits = pBandsB->getAttribute(Nitf::TRE::BANDSB::COL_GSD_UNITS);
if (columnGsdUnits.isValid() == true)
{
xGsd = getGsd(columnGsd, columnGsdUnits.toXmlString());
validColumnGsd = true;
}
}
if (validColumnGsd == false)
{
if (pBandsB->getAttribute(Nitf::TRE::BANDSB::COL_GSD + "#0").isValid())
{
double commonXGsd = -1.0;
unsigned int numBands = pDescriptor->getBandCount();
for (unsigned int i = 0; i < numBands; ++i)
{
double bandXGsd = -1.0;
string bandPostfix = "#" + StringUtilities::toDisplayString(i);
const DataVariant& bandRowGsd = pBandsB->getAttribute(Nitf::TRE::BANDSB::COL_GSD + bandPostfix);
if (bandRowGsd.isValid() == true)
{
const DataVariant& bandRowGsdUnits = pBandsB->getAttribute(Nitf::TRE::BANDSB::COL_GSD_UNIT +
bandPostfix);
if (bandRowGsdUnits.isValid() == true)
{
bandXGsd = getGsd(bandRowGsd, bandRowGsdUnits.toXmlString());
}
}
if (bandXGsd == commonXGsd)
{
continue;
}
if (commonXGsd != -1.0)
{
commonXGsd = -1.0;
break;
}
commonXGsd = bandXGsd;
}
if (commonXGsd != 1.0)
{
xGsd = commonXGsd;
}
}
}
}
double magFactor = 1.0;
ossimString imag = pImageSubheader->getImageMagnification().trim();
if (imag.empty() == false)
{
// Need to multiply the GSD values by the image magnification (IMAG) value in the image subheader
if (imag[0] == '/')
{
ossimString reciprocal = imag.substr(1);
magFactor = 1.0 / reciprocal.toDouble();
}
else
{
magFactor = imag.toDouble();
}
xGsd *= magFactor;
yGsd *= magFactor;
}
pDescriptor->setXPixelSize(xGsd);
pDescriptor->setYPixelSize(yGsd);
// Higher precision GCPs
const string blockaPath[] =
{
Nitf::NITF_METADATA,
Nitf::TRE_METADATA,
"BLOCKA",
"0",
END_METADATA_NAME
};
const DynamicObject* pBlockA = dv_cast<DynamicObject>(&pMetadata->getAttributeByPath(blockaPath));
if (pBlockA != NULL)
{
const DataVariant& blockLines = pBlockA->getAttribute(Nitf::TRE::BLOCKA::L_LINES);
if (blockLines.isValid() == true)
{
unsigned int numBlockRows = 0;
if (blockLines.getValue<unsigned int>(numBlockRows) == true)
{
// Need to multiply the number of rows by the image magnification (IMAG) value in the image subheader
numBlockRows = static_cast<unsigned int>(static_cast<double>(numBlockRows) * magFactor);
if (numBlockRows == pFileDescriptor->getRowCount())
{
list<GcpPoint> updatedGcps;
list<GcpPoint> gcps = pFileDescriptor->getGcps();
for (list<GcpPoint>::iterator iter = gcps.begin(); iter != gcps.end(); ++iter)
{
GcpPoint gcp = *iter;
string coordinateText;
list<GcpPoint>::size_type index = updatedGcps.size();
if (index == 0)
{
const DataVariant& gcp1 = pBlockA->getAttribute(Nitf::TRE::BLOCKA::FRFC_LOC);
if (gcp1.isValid() == true)
{
coordinateText = gcp1.toXmlString();
}
}
else if (index == 1)
{
const DataVariant& gcp2 = pBlockA->getAttribute(Nitf::TRE::BLOCKA::FRLC_LOC);
if (gcp2.isValid() == true)
{
coordinateText = gcp2.toXmlString();
}
}
else if (index == 2)
{
const DataVariant& gcp3 = pBlockA->getAttribute(Nitf::TRE::BLOCKA::LRLC_LOC);
if (gcp3.isValid() == true)
{
coordinateText = gcp3.toXmlString();
}
}
else if (index == 3)
{
const DataVariant& gcp4 = pBlockA->getAttribute(Nitf::TRE::BLOCKA::LRFC_LOC);
if (gcp4.isValid() == true)
{
coordinateText = gcp4.toXmlString();
}
}
if (StringUtilities::isAllBlank(coordinateText) == false)
{
coordinateText.insert(10, ", ");
LatLonPoint latLon(coordinateText);
gcp.mCoordinate = latLon.getCoordinates();
}
updatedGcps.push_back(gcp);
}
pFileDescriptor->setGcps(updatedGcps);
}
}
}
}
// This only checks the first BANDSB. It is possible to have multiple BANDSB TREs.
// If someone runs across real data where the bad band info is in another BANDSB TRE
// this code will need to be modified.
if (pBandsB != NULL && pBandsB->getAttribute(Nitf::TRE::BANDSB::BAD_BAND + "#0").isValid())
{
const vector<DimensionDescriptor>& curBands = pDescriptor->getBands();
vector<DimensionDescriptor> newBands;
for (size_t idx = 0; idx < curBands.size(); ++idx)
{
const int* pVal = dv_cast<int>(&pBandsB->getAttribute(
Nitf::TRE::BANDSB::BAD_BAND + "#" + StringUtilities::toDisplayString(idx)));
if (pVal == NULL || *pVal == 1) // 0 == invalid or suspect band, 1 = valid band
{
newBands.push_back(curBands[idx]);
}
}
pDescriptor->setBands(newBands);
}
// Bad values
if (pImageSubheader->hasTransparentCode() == true)
{
vector<int> badValues;
badValues.push_back(static_cast<int>(pImageSubheader->getTransparentCode()));
pDescriptor->setBadValues(badValues);
}
// If red, green, OR blue bands are valid, set the display mode to RGB.
if (pDescriptor->getDisplayBand(RED).isValid() == true ||
pDescriptor->getDisplayBand(GREEN).isValid() == true ||
pDescriptor->getDisplayBand(BLUE).isValid() == true)
{
pDescriptor->setDisplayMode(RGB_MODE);
}
// Otherwise, if the gray band is valid, set the display mode to GRAYSCALE.
else if (pDescriptor->getDisplayBand(GRAY).isValid() == true)
{
pDescriptor->setDisplayMode(GRAYSCALE_MODE);
}
// Otherwise, if at least 3 bands are available, set the display mode to RGB,
// and set the first three bands to red, green, and blue respectively.
else if (bands.size() >= 3)
{
pDescriptor->setDisplayBand(RED, bands[0]);
pDescriptor->setDisplayBand(GREEN, bands[1]);
pDescriptor->setDisplayBand(BLUE, bands[2]);
pDescriptor->setDisplayMode(RGB_MODE);
}
// Otherwise, if at least 1 band is available, set the display mode to GRAYSCALE,
// and set the first band to GRAY.
else if (bands.empty() == false)
{
pDescriptor->setDisplayBand(GRAY, bands[0]);
pDescriptor->setDisplayMode(GRAYSCALE_MODE);
}
else
{
return NULL;
}
// Special initialization for J2K compressed image segments
const string compressionPath[] =
{
Nitf::NITF_METADATA,
Nitf::IMAGE_SUBHEADER,
Nitf::ImageSubheaderFieldNames::COMPRESSION,
END_METADATA_NAME
};
string imageCompression = pMetadata->getAttributeByPath(compressionPath).toDisplayString();
if ((imageCompression == Nitf::ImageSubheaderFieldValues::IC_C8) ||
(imageCompression == Nitf::ImageSubheaderFieldValues::IC_M8))
{
// Per Section 8.1 of the BIIF Profile for JPEG 2000 Version 01.10 (BPJ2K01.10),
// if the values in the J2K data differ from the values in the image subheader,
// the J2K values are given precedence.
opj_image_t* pImage = getImageInfo(filename, imageSegment, OPJ_CODEC_J2K);
if (pImage == NULL)
{
pImage = getImageInfo(filename, imageSegment, OPJ_CODEC_JP2);
}
if (pImage != NULL)
{
// Bits per element
unsigned int bitsPerElement = pImage->comps->prec;
if (bitsPerElement != pFileDescriptor->getBitsPerElement())
{
pFileDescriptor->setBitsPerElement(bitsPerElement);
}
// Data type
EncodingType dataType = INT1UBYTE;
if (bitsPerElement <= 8)
{
if (pImage->comps->sgnd)
{
dataType = INT1SBYTE;
}
else
{
dataType = INT1UBYTE;
}
}
else if (bitsPerElement <= 16)
{
if (pImage->comps->sgnd)
{
dataType = INT2SBYTES;
}
else
{
dataType = INT2UBYTES;
}
}
else if (bitsPerElement <= 32)
{
if (pImage->comps->sgnd)
{
dataType = INT4SBYTES;
}
else
{
dataType = INT4UBYTES;
}
}
else if (bitsPerElement <= 64)
{
dataType = FLT8BYTES;
}
if (dataType != pDescriptor->getDataType())
{
pDescriptor->setDataType(dataType);
}
// Rows
unsigned int numRows = pImage->comps->h;
if (numRows != pFileDescriptor->getRowCount())
{
vector<DimensionDescriptor> rows = RasterUtilities::generateDimensionVector(numRows, true, false, true);
pDescriptor->setRows(rows);
pFileDescriptor->setRows(rows);
}
// Columns
unsigned int numColumns = pImage->comps->w;
if (numColumns != pFileDescriptor->getColumnCount())
{
vector<DimensionDescriptor> columns = RasterUtilities::generateDimensionVector(numColumns, true, false,
true);
pDescriptor->setColumns(columns);
pFileDescriptor->setColumns(columns);
}
// Bands
unsigned int numBands = pImage->numcomps;
if (numBands != pFileDescriptor->getBandCount())
{
vector<DimensionDescriptor> bands = RasterUtilities::generateDimensionVector(numBands, true, false,
true);
pDescriptor->setBands(bands);
pFileDescriptor->setBands(bands);
}
// Cleanup
opj_image_destroy(pImage);
}
// Set the interleave format as BIP, which is the interleave format for J2K data
pDescriptor->setInterleaveFormat(BIP);
pFileDescriptor->setInterleaveFormat(BIP);
}
mParseMessages[imageSegment] = errorMessage;
}
return pImportDescriptor.release();
}
vector<ImportDescriptor*> Nitf::NitfImporterShell::getImportDescriptors(const string &filename)
{
vector<ImportDescriptor*> retval;
if (filename.empty())
{
return retval;
}
Nitf::OssimFileResource pFile(filename);
if (pFile.get() == NULL)
{
return retval;
}
Nitf::OssimImageHandlerResource pHandler(filename);
if (pHandler.get() == NULL || pHandler->canCastTo("ossimNitfTileSource") == false)
{
return retval;
}
ossimNitfFileHeaderV2_X* pFileHeader =
PTR_CAST(ossimNitfFileHeaderV2_X, pFile->getHeader().get());
if (pFileHeader == NULL)
{
return retval;
}
// Not all segments are importable. This is generally due to the segment
// using an unsupported compression format. Only generate descriptors
// for the importable segments.
vector<ossim_uint32> importableImageSegments;
pHandler->getEntryList(importableImageSegments);
// Create map of TRE parsers.
// The sole purpose of this map is to force DLLs to stay loaded while the metadata is being imported.
std::map<std::string, TrePlugInResource> parsers;
for (vector<ossim_uint32>::iterator segmentIter = importableImageSegments.begin();
segmentIter != importableImageSegments.end(); ++segmentIter)
{
// Do not call pHandler->setCurrentEntry as it is a very expensive operation
// which causes up to a several second delay on files with many large images.
const ossim_uint32& currentIndex = *segmentIter;
ossimNitfImageHeaderV2_X* pImgHeader =
PTR_CAST(ossimNitfImageHeaderV2_X, pFile->getNewImageHeader(currentIndex));
if (pImgHeader == NULL)
{
continue;
}
EncodingType dataType = ossimImageHeaderToEncodingType(pImgHeader);
if (dataType.isValid() == false)
{
continue;
}
stringstream imageNameStream;
imageNameStream << "I" << currentIndex + 1;
string imageName = imageNameStream.str();
ImportDescriptorResource pImportDescriptor(getImportDescriptor(filename, imageName,
pFile.get(), pFileHeader, pImgHeader));
if (pImportDescriptor.get() == NULL)
{
continue;
}
RasterDataDescriptor* pDd = dynamic_cast<RasterDataDescriptor*>(pImportDescriptor->getDataDescriptor());
VERIFYRV(pDd != NULL, retval);
vector<DimensionDescriptor> bands =
RasterUtilities::generateDimensionVector(pImgHeader->getNumberOfBands(), true, false, true);
pDd->setBands(bands);
vector<DimensionDescriptor> rows =
RasterUtilities::generateDimensionVector(pImgHeader->getNumberOfRows(), true, false, true);
pDd->setRows(rows);
vector<DimensionDescriptor> cols =
RasterUtilities::generateDimensionVector(pImgHeader->getNumberOfCols(), true, false, true);
pDd->setColumns(cols);
if (pImgHeader->getIMode() == "P")
{
pDd->setInterleaveFormat(BIP);
}
else if (pImgHeader->getIMode() == "R")
{
pDd->setInterleaveFormat(BIL);
}
else
{
pDd->setInterleaveFormat(BSQ);
}
pDd->setDataType(dataType);
pDd->setValidDataTypes(vector<EncodingType>(1, dataType));
pDd->setProcessingLocation(IN_MEMORY);
RasterUtilities::generateAndSetFileDescriptor(pDd, filename, imageName, LITTLE_ENDIAN_ORDER);
string errorMessage;
if (Nitf::importMetadata(currentIndex + 1, pFile, pFileHeader, pImgHeader, pDd, parsers, errorMessage) == true)
{
const DynamicObject* pMeta = pDd->getMetadata();
VERIFYRV(pMeta, retval);
// This only checks the first BANDSB. It is possible to have multiple BANDSB TREs.
// If someone runs across real data where the bad band info is in another BANDSB TRE
// this code will need to be modified.
const std::string bandsbPath[] = { Nitf::NITF_METADATA, Nitf::TRE_METADATA,
"BANDSB", "0", END_METADATA_NAME };
const DynamicObject* pBandsB = dv_cast<DynamicObject>(&pMeta->getAttributeByPath(bandsbPath));
if (pBandsB != NULL && pBandsB->getAttribute(Nitf::TRE::BANDSB::BAD_BAND + "#0").isValid())
{
const std::vector<DimensionDescriptor>& curBands = pDd->getBands();
std::vector<DimensionDescriptor> newBands;
for (size_t idx = 0; idx < curBands.size(); ++idx)
{
const int* pVal = dv_cast<int>(&pBandsB->getAttribute(
Nitf::TRE::BANDSB::BAD_BAND + "#" + StringUtilities::toDisplayString(idx)));
if (pVal == NULL || *pVal == 1) // 0 == invalid or suspect band, 1 = valid band
{
newBands.push_back(curBands[idx]);
}
}
pDd->setBands(newBands);
}
if (pImgHeader->hasTransparentCode() == true)
{
vector<int> badValues;
badValues.push_back(static_cast<int>(pImgHeader->getTransparentCode()));
pDd->setBadValues(badValues);
}
// If red, green, OR blue bands are valid, set the display mode to RGB.
if (pDd->getDisplayBand(RED).isValid() == true ||
pDd->getDisplayBand(GREEN).isValid() == true ||
pDd->getDisplayBand(BLUE).isValid() == true)
{
pDd->setDisplayMode(RGB_MODE);
}
// Otherwise, if the gray band is valid, set the display mode to GRAYSCALE.
else if (pDd->getDisplayBand(GRAY).isValid() == true)
{
pDd->setDisplayMode(GRAYSCALE_MODE);
}
// Otherwise, if at least 3 bands are available, set the display mode to RGB,
// and set the first three bands to red, green, and blue respectively.
else if (bands.size() >= 3)
{
pDd->setDisplayBand(RED, bands[0]);
pDd->setDisplayBand(GREEN, bands[1]);
pDd->setDisplayBand(BLUE, bands[2]);
pDd->setDisplayMode(RGB_MODE);
}
// Otherwise, if at least 1 band is available, set the display mode to GRAYSCALE,
// and set the first band to GRAY.
else if (bands.empty() == false)
{
pDd->setDisplayBand(GRAY, bands[0]);
pDd->setDisplayMode(GRAYSCALE_MODE);
}
else
{
continue;
}
mParseMessages[imageName] = errorMessage;
retval.push_back(pImportDescriptor.release());
}
}
return retval;
}
void ImportOptionsDlg::setCurrentDataset(ImportDescriptor* pImportDescriptor)
{
if (pImportDescriptor == NULL)
{
return;
}
if (pImportDescriptor == mpCurrentDataset)
{
return;
}
// Apply changes to the current data set if necessary
bool bSuccess = true;
if ((mpCurrentDataset != NULL) && (mEditDataDescriptorModified == true))
{
if (mPromptForChanges == true)
{
int iReturn = QMessageBox::question(this, APP_NAME, "Apply changes to data?",
QMessageBox::Yes | QMessageBox::YesToAll | QMessageBox::No | QMessageBox::Cancel);
if ((iReturn == QMessageBox::Yes) || (iReturn == QMessageBox::YesToAll))
{
bSuccess = applyChanges();
if (iReturn == QMessageBox::YesToAll)
{
mPromptForChanges = false;
}
}
else if (iReturn == QMessageBox::No)
{
// Update the validation icon for the original data descriptor
validateDataset(mpCurrentDataset->getDataDescriptor());
}
else if (iReturn == QMessageBox::Cancel)
{
bSuccess = false;
}
}
else
{
bSuccess = applyChanges();
}
}
if (bSuccess == false)
{
// Select the tree widget item for the previously selected data set
selectCurrentDatasetItem();
return;
}
mpCurrentDataset = pImportDescriptor;
// Destroy the existing edit data descriptor if necessary
Service<ModelServices> pModel;
if (mpEditDescriptor != NULL)
{
Classification* pClassification = mpEditDescriptor->getClassification();
if (pClassification != NULL)
{
VERIFYNR(pClassification->detach(SIGNAL_NAME(Subject, Modified),
Slot(this, &ImportOptionsDlg::editClassificationModified)));
}
RasterDataDescriptor* pRasterDescriptor = dynamic_cast<RasterDataDescriptor*>(mpEditDescriptor);
if (pRasterDescriptor != NULL)
{
VERIFYNR(pRasterDescriptor->detach(SIGNAL_NAME(RasterDataDescriptor, RowsChanged),
Slot(this, &ImportOptionsDlg::editDataDescriptorRowsModified)));
VERIFYNR(pRasterDescriptor->detach(SIGNAL_NAME(RasterDataDescriptor, ColumnsChanged),
Slot(this, &ImportOptionsDlg::editDataDescriptorColumnsModified)));
VERIFYNR(pRasterDescriptor->detach(SIGNAL_NAME(RasterDataDescriptor, BandsChanged),
Slot(this, &ImportOptionsDlg::editDataDescriptorBandsModified)));
}
RasterFileDescriptor* pRasterFileDescriptor =
dynamic_cast<RasterFileDescriptor*>(mpEditDescriptor->getFileDescriptor());
if (pRasterFileDescriptor != NULL)
{
VERIFYNR(pRasterFileDescriptor->detach(SIGNAL_NAME(RasterFileDescriptor, RowsChanged),
Slot(this, &ImportOptionsDlg::editFileDescriptorRowsModified)));
VERIFYNR(pRasterFileDescriptor->detach(SIGNAL_NAME(RasterFileDescriptor, ColumnsChanged),
Slot(this, &ImportOptionsDlg::editFileDescriptorColumnsModified)));
VERIFYNR(pRasterFileDescriptor->detach(SIGNAL_NAME(RasterFileDescriptor, BandsChanged),
Slot(this, &ImportOptionsDlg::editFileDescriptorBandsModified)));
}
VERIFYNR(mpEditDescriptor->detach(SIGNAL_NAME(Subject, Modified),
Slot(this, &ImportOptionsDlg::editDataDescriptorModified)));
pModel->destroyDataDescriptor(mpEditDescriptor);
mpEditDescriptor = NULL;
mEditDataDescriptorModified = false;
}
// Create a new data descriptor to validate the user inputs
DataDescriptor* pDescriptor = mpCurrentDataset->getDataDescriptor();
if (pDescriptor != NULL)
{
mpEditDescriptor = pDescriptor->copy();
}
VERIFYNRV(mpEditDescriptor != NULL);
VERIFYNR(mpEditDescriptor->attach(SIGNAL_NAME(Subject, Modified),
Slot(this, &ImportOptionsDlg::editDataDescriptorModified)));
RasterDataDescriptor* pRasterDescriptor = dynamic_cast<RasterDataDescriptor*>(mpEditDescriptor);
FileDescriptor* pFileDescriptor = mpEditDescriptor->getFileDescriptor();
RasterFileDescriptor* pRasterFileDescriptor = dynamic_cast<RasterFileDescriptor*>(pFileDescriptor);
if (pRasterDescriptor != NULL)
{
VERIFYNR(pRasterDescriptor->attach(SIGNAL_NAME(RasterDataDescriptor, RowsChanged),
Slot(this, &ImportOptionsDlg::editDataDescriptorRowsModified)));
VERIFYNR(pRasterDescriptor->attach(SIGNAL_NAME(RasterDataDescriptor, ColumnsChanged),
Slot(this, &ImportOptionsDlg::editDataDescriptorColumnsModified)));
VERIFYNR(pRasterDescriptor->attach(SIGNAL_NAME(RasterDataDescriptor, BandsChanged),
Slot(this, &ImportOptionsDlg::editDataDescriptorBandsModified)));
}
if (pRasterFileDescriptor != NULL)
{
VERIFYNR(pRasterFileDescriptor->attach(SIGNAL_NAME(RasterFileDescriptor, RowsChanged),
Slot(this, &ImportOptionsDlg::editFileDescriptorRowsModified)));
VERIFYNR(pRasterFileDescriptor->attach(SIGNAL_NAME(RasterFileDescriptor, ColumnsChanged),
Slot(this, &ImportOptionsDlg::editFileDescriptorColumnsModified)));
VERIFYNR(pRasterFileDescriptor->attach(SIGNAL_NAME(RasterFileDescriptor, BandsChanged),
Slot(this, &ImportOptionsDlg::editFileDescriptorBandsModified)));
}
// Select the tree widget item for the current data set
selectCurrentDatasetItem();
// Disconnect pages
updateConnections(false);
// Subset page
if (pRasterFileDescriptor != NULL)
{
// Show the tab if necessary
if (mpTabWidget->indexOf(mpSubsetPage) == -1)
{
mpTabWidget->insertTab(2, mpSubsetPage, "Subset");
}
// Rows
const vector<DimensionDescriptor>& rows = pRasterFileDescriptor->getRows();
const vector<DimensionDescriptor>& loadedRows = pRasterDescriptor->getRows();
mpSubsetPage->setRows(rows, loadedRows);
// Columns
const vector<DimensionDescriptor>& columns = pRasterFileDescriptor->getColumns();
const vector<DimensionDescriptor>& loadedColumns = pRasterDescriptor->getColumns();
mpSubsetPage->setColumns(columns, loadedColumns);
// Bands
const vector<DimensionDescriptor>& bands = pRasterFileDescriptor->getBands();
const vector<DimensionDescriptor>& selectedBands = pRasterDescriptor->getBands();
setSubsetBands(bands, selectedBands);
// Initial bad band file directory
if (pFileDescriptor != NULL)
{
QString strDirectory;
string filename = pFileDescriptor->getFilename();
if (filename.empty() == false)
{
QFileInfo fileInfo(QString::fromStdString(filename));
strDirectory = fileInfo.absolutePath();
}
mpSubsetPage->setBadBandFileDirectory(strDirectory);
}
}
else
{
// Remove the subset page, since the file descriptor either isn't
// present or isn't a RasterFileDescriptor, just a FileDescriptor
int index = mpTabWidget->indexOf(mpSubsetPage);
if (index != -1)
{
mpTabWidget->removeTab(index);
}
}
// Data descriptor page - enable editing for all fields
mpDataPage->setDataDescriptor(mpEditDescriptor, true);
// File descriptor page
bool editFilePage = false;
if (pRasterFileDescriptor != NULL)
{
unsigned int numRows = pRasterFileDescriptor->getRowCount();
unsigned int numColumns = pRasterFileDescriptor->getColumnCount();
unsigned int bitsPerElement = pRasterFileDescriptor->getBitsPerElement();
unsigned int numBands = pRasterFileDescriptor->getBandCount();
if ((numRows == 0) || (numColumns == 0) || (numBands == 0) || (bitsPerElement == 0))
{
editFilePage = true;
}
}
mpFilePage->setFileDescriptor(pFileDescriptor, editFilePage);
int iIndex = mpTabWidget->indexOf(mpFilePage);
if (iIndex != -1)
{
if (pFileDescriptor == NULL)
{
mpTabWidget->removeTab(iIndex);
}
}
else
{
if (pFileDescriptor != NULL)
{
mpTabWidget->insertTab(1, mpFilePage, "File");
}
}
// Classification page
updateClassificationLabel();
Classification* pClassification = mpEditDescriptor->getClassification();
if (pClassification != NULL)
{
VERIFYNR(pClassification->attach(SIGNAL_NAME(Subject, Modified),
Slot(this, &ImportOptionsDlg::editClassificationModified)));
mpClassificationPage->setClassification(pClassification);
}
// Metadata page
mpMetadataPage->setMetadata(mpEditDescriptor->getMetadata());
// Wavelengths page
bool bWavelengthsPageActive = false;
if (mpTabWidget->currentWidget() == mpWavelengthsPage)
{
bWavelengthsPageActive = true;
}
int index = mpTabWidget->indexOf(mpWavelengthsPage);
if (index != -1)
{
mpTabWidget->removeTab(index);
}
if (pRasterFileDescriptor != NULL)
{
// Populate the wavelengths with the file descriptor bands since the metadata wavelengths
// apply to all bands in the file
mpWavelengthsPage->setWavelengths(pRasterFileDescriptor->getBands(), mpEditDescriptor->getMetadata());
if (pRasterDescriptor != NULL)
{
mpWavelengthsPage->highlightActiveBands(pRasterDescriptor->getBands());
}
mpTabWidget->addTab(mpWavelengthsPage, "Wavelengths");
if (bWavelengthsPageActive == true)
{
mpTabWidget->setCurrentWidget(mpWavelengthsPage);
}
}
// Importer page
bool bImporterPageActive = false;
if (mpImporterPage != NULL)
{
if (mpTabWidget->currentWidget() == mpImporterPage)
{
bImporterPageActive = true;
}
}
removeImporterPage();
if (mpImporter != NULL)
{
mpImporterPage = mpImporter->getImportOptionsWidget(mpEditDescriptor);
if (mpImporterPage != NULL)
{
QLayout* pLayout = mpImporterPage->layout();
if (pLayout != NULL)
{
if (pLayout->margin() <= 0)
{
pLayout->setMargin(10);
}
}
QString strCaption = mpImporterPage->windowTitle();
if (strCaption.isEmpty() == true)
{
strCaption = "Importer";
}
mpTabWidget->addTab(mpImporterPage, strCaption);
if (bImporterPageActive == true)
{
mpTabWidget->setCurrentWidget(mpImporterPage);
}
}
// Set the valid processing locations on the data page. This must be done after getting the import options
// widget from the importer so that the auto importer will correctly query the importer that is used.
// This can be changed if the importer design (and auto importer) is modified to support valid processing
// locations for a specific data set.
vector<ProcessingLocation> locations;
if (mpImporter->isProcessingLocationSupported(IN_MEMORY) == true)
{
locations.push_back(IN_MEMORY);
}
if (mpImporter->isProcessingLocationSupported(ON_DISK) == true)
{
locations.push_back(ON_DISK);
}
if (mpImporter->isProcessingLocationSupported(ON_DISK_READ_ONLY) == true)
{
locations.push_back(ON_DISK_READ_ONLY);
}
mpDataPage->setValidProcessingLocations(locations);
}
// Validate the current data descriptor
validateEditDataset();
// Reconnect the pages
updateConnections(true);
// Notify connected objects
emit currentDatasetChanged(mpCurrentDataset);
}
bool SioImporter::ensureStatisticsReadProperly(Progress *pProgress, std::ostream& failure)
{
bool success = true;
success &= setBatch();
PlugInArgList* pInList = NULL;
PlugInArgList* pOutList = NULL;
isseas(getInputSpecification(pInList) != false, failure);
isseas(getOutputSpecification(pOutList) != false, failure);
PlugInArg* pRasterElementArg = NULL;
isseas(pInList->getArg(Importer::ImportElementArg(), pRasterElementArg) != false, failure);
string testFilePath = TestUtilities::getTestDataPath() + "tipjul5bands.sio";
RasterElement* pRasterElement = NULL;
if (success)
{
vector<ImportDescriptor*> descriptors = getImportDescriptors(testFilePath);
if (descriptors.empty() == false)
{
ImportDescriptor* pImportDescriptor = descriptors.front();
if (pImportDescriptor != NULL)
{
DataDescriptor* pDescriptor = pImportDescriptor->getDataDescriptor();
if (pDescriptor != NULL)
{
Service<ModelServices> pModel;
pRasterElement = dynamic_cast<RasterElement*>(pModel->createElement(pDescriptor));
if (pRasterElement != NULL)
{
pRasterElementArg->setActualValue(pRasterElement);
}
}
}
}
}
isseas(execute(pInList, pOutList) != false, failure);
isseas(pRasterElement != NULL, failure);
if (success)
{
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(pRasterElement->getDataDescriptor());
isseas(pDescriptor != NULL, failure);
const vector<DimensionDescriptor>& loadedBands = pDescriptor->getBands();
isseas(loadedBands.size() == 5, failure);
int iNumBandsWithStats = 0;
for (int i = 0; i < 5; ++i)
{
// we don't want to do an assert yet... only when we know 4 bands have computed statistics
Statistics* pStatistics = pRasterElement->getStatistics(loadedBands[i]);
if (pStatistics != NULL)
{
if (pStatistics->areStatisticsCalculated() == true)
{
if (success)
{
iNumBandsWithStats++;
}
}
}
}
// success of the band computation is dependent on 4 bands with statistics
isseas(iNumBandsWithStats == 3, failure);
}
if (pRasterElement != NULL)
{
Service<ModelServices> pModel;
pModel->destroyElement(pRasterElement);
pRasterElement = NULL;
}
Service<PlugInManagerServices> pPim;
if (pInList)
{
pPim->destroyPlugInArgList(pInList);
}
if (pOutList)
{
pPim->destroyPlugInArgList(pOutList);
}
return success;
}
std::vector<ImportDescriptor*> NefImporter::getImportDescriptors(const std::string &filename)
{
std::vector<ImportDescriptor*> descriptors;
try
{
ImportDescriptorResource pImportDescriptor(filename, TypeConverter::toString<RasterElement>());
VERIFYRV(pImportDescriptor.get() != NULL, descriptors);
descriptors.push_back(pImportDescriptor.release());
InterleaveFormatType interleave(BSQ);
EncodingType encoding(INT4UBYTES);
//bool rgb = false;
LibRaw iProcessor;
const char *fn=filename.c_str();
iProcessor.open_file(fn);
unsigned long rows = iProcessor.imgdata.sizes.iheight, columns = iProcessor.imgdata.sizes.iwidth,frames=3;
RasterDataDescriptor *pDescriptor = RasterUtilities::generateRasterDataDescriptor(
filename, NULL, rows, columns, frames, interleave, encoding, IN_MEMORY);
if(pDescriptor != NULL)
{
pDescriptor->setDisplayBand(RED, pDescriptor->getBands()[0]);
pDescriptor->setDisplayBand(GREEN, pDescriptor->getBands()[1]);
pDescriptor->setDisplayBand(BLUE, pDescriptor->getBands()[2]);
pDescriptor->setDisplayMode(RGB_MODE);
}
pImportDescriptor->setDataDescriptor(pDescriptor);
RasterUtilities::generateAndSetFileDescriptor(pImportDescriptor->getDataDescriptor(), filename, std::string(), LITTLE_ENDIAN_ORDER);
descriptors.push_back(pImportDescriptor.release());
//return descriptors;
/*
Endian e;
DynamicObject* pMeta = NULL;
{ // scope the geotiff importer
ImporterResource geotiff("GeoTIFF Importer", filename);
if (geotiff.get() == NULL)
{
return descriptors;
}
std::vector<ImportDescriptor*> tiffDescriptors = geotiff->getImportDescriptors();
if (tiffDescriptors.size() != 1)
{
return descriptors;
}
e = Endian(tiffDescriptors.front()->getDataDescriptor()->getFileDescriptor()->getEndian());
pMeta = tiffDescriptors.front()->getDataDescriptor()->getMetadata();
}
if (dv_cast<std::string>(pMeta->getAttributeByPath("TIFF/Make")) != "NIKON CORPORATION")
{
return descriptors;
}
// Reload the file and parse the RAW IFD
FileResource pNef(filename.c_str(), "rb");
if (pNef.get() == NULL)
{
return descriptors;
}
// JpegImageOffset, RawOffset
std::vector<unsigned int> ifds = dv_cast<std::vector<unsigned int> >(pMeta->getAttributeByPath("TIFF/SubIFD"));
if (ifds.size() != 2)
{
return descriptors;
}
fseek(pNef, ifds[1], SEEK_SET);
unsigned int rows = 0;
unsigned int cols = 0;
unsigned int bpp = 0;
// parse the entries
size_t entryCount = getVal<uint16_t>(pNef, e);
while (--entryCount >= 0)
{
uint16_t tag = getVal<uint16_t>(pNef, e);
uint16_t type = getVal<uint16_t>(pNef, e);
uint16_t count = getVal<uint32_t>(pNef, e);
bool compressed = false;
switch(tag)
{
case 254: // SubfileType == 0 (full resolution)
if (type != 4 && count != 1 && getVal<uint32_t>(pNef, e) != 0)
{
return descriptors;
}
break;
case 256: // ImageWidth
if (type != 4 && count != 1)
{
return descriptors;
}
cols = getVal<uint32_t>(pNef, e);
break;
case 257: // ImageHight
if (type != 4 && count != 1)
{
return descriptors;
}
rows = getVal<uint32_t>(pNef, e);
break;
case 258: // BitsPerSample
if (type != 1 && count != 1)
{
return descriptors;
}
bpp = getVal<unsigned char>(pNef, e);
fseek(pNef, 3, SEEK_CUR);
break;
case 259: // Compression
if (type != 3 && count != 1)
{
return descriptors;
}
{
uint16_t comp = getVal<uint16_t>(pNef, e);
fseek(pNef, 2, SEEK_CUR);
if (comp == 1)
{
compressed = false;
}
else if (comp == 34713)
{
compressed = true;
}
else
{
return descriptors;
}
}
break;
default:
fseek(pNef, 4, SEEK_CUR);
break;
}
}
*/
}
catch (const std::bad_cast&)
{
// metadata not present, wrong kind of file
}
return descriptors;
}
bool EditDataDescriptor::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Execute Wizard Item", "app", "055486F4-A9DB-4FDA-9AA7-75D1917E2C87");
pStep->addProperty("Item", getName());
mpStep = pStep.get();
if (extractInputArgs(pInArgList) == false)
{
return false;
}
// Set the values in the data descriptor
VERIFY(mpDescriptor != NULL);
// File descriptor
if (mpFileDescriptor != NULL)
{
mpDescriptor->setFileDescriptor(mpFileDescriptor);
}
// Processing location
if (mpProcessingLocation != NULL)
{
mpDescriptor->setProcessingLocation(*mpProcessingLocation);
}
RasterDataDescriptor* pRasterDescriptor = dynamic_cast<RasterDataDescriptor*>(mpDescriptor);
RasterFileDescriptor* pRasterFileDescriptor = dynamic_cast<RasterFileDescriptor*>(mpFileDescriptor);
SignatureDataDescriptor* pSignatureDescriptor = dynamic_cast<SignatureDataDescriptor*>(mpDescriptor);
SignatureFileDescriptor* pSignatureFileDescriptor = dynamic_cast<SignatureFileDescriptor*>(mpFileDescriptor);
if (pRasterDescriptor != NULL)
{
if (pRasterFileDescriptor != NULL)
{
// Set the rows and columns to match the rows and columns in the file descriptor before creating the subset
const vector<DimensionDescriptor>& rows = pRasterFileDescriptor->getRows();
pRasterDescriptor->setRows(rows);
const vector<DimensionDescriptor>& columns = pRasterFileDescriptor->getColumns();
pRasterDescriptor->setColumns(columns);
const vector<DimensionDescriptor>& bands = pRasterFileDescriptor->getBands();
pRasterDescriptor->setBands(bands);
}
// Data type
if (mpDataType != NULL)
{
pRasterDescriptor->setDataType(*mpDataType);
}
// InterleaveFormat
if (mpInterleave != NULL)
{
pRasterDescriptor->setInterleaveFormat(*mpInterleave);
}
// Bad values
if (mpBadValues != NULL)
{
pRasterDescriptor->setBadValues(*mpBadValues);
}
// Rows
if ((mpStartRow != NULL) || (mpEndRow != NULL) || (mpRowSkipFactor != NULL))
{
// We need to obtain this origRows from the FileDescriptor if present since an importer
// may generate a subset by default in which case the DataDescriptor will not contain all
// the rows and subsetting will not work correctly. We
// can't just set mpFileDescriptor = pRasterDescriptor->getFileDescriptor() since we only
// want to replace the DataDescriptor's row list if one of the subset options is specified
const RasterFileDescriptor* pFileDesc(pRasterFileDescriptor);
if (pFileDesc == NULL)
{
pFileDesc = dynamic_cast<const RasterFileDescriptor*>(pRasterDescriptor->getFileDescriptor());
}
const vector<DimensionDescriptor>& origRows = (pFileDesc != NULL) ?
pFileDesc->getRows() : pRasterDescriptor->getRows();
unsigned int startRow = 0;
if (mpStartRow != NULL)
{
startRow = *mpStartRow;
}
else if (origRows.empty() == false)
{
startRow = origRows.front().getOriginalNumber() + 1;
}
unsigned int endRow = 0;
if (mpEndRow != NULL)
{
endRow = *mpEndRow;
}
else if (origRows.empty() == false)
{
endRow = origRows.back().getOriginalNumber() + 1;
}
unsigned int rowSkip = 0;
if (mpRowSkipFactor != NULL)
{
rowSkip = *mpRowSkipFactor;
}
vector<DimensionDescriptor> rows;
for (unsigned int i = 0; i < origRows.size(); ++i)
{
DimensionDescriptor rowDim = origRows[i];
unsigned int originalNumber = rowDim.getOriginalNumber() + 1;
if ((originalNumber >= startRow) && (originalNumber <= endRow))
{
rows.push_back(rowDim);
i += rowSkip;
}
}
pRasterDescriptor->setRows(rows);
}
// Columns
if ((mpStartColumn != NULL) || (mpEndColumn != NULL) || (mpColumnSkipFactor != NULL))
{
// We need to obtain this origColumns from the FileDescriptor if present since an importer
// may generate a subset by default in which case the DataDescriptor will not contain all
// the columns and subsetting will not work correctly. We
// can't just set mpFileDescriptor = pRasterDescriptor->getFileDescriptor() since we only
// want to replace the DataDescriptor's column list if one of the subset options is specified
const RasterFileDescriptor* pFileDesc(pRasterFileDescriptor);
if (pFileDesc == NULL)
{
pFileDesc = dynamic_cast<const RasterFileDescriptor*>(pRasterDescriptor->getFileDescriptor());
}
const vector<DimensionDescriptor>& origColumns = (pFileDesc != NULL) ?
pFileDesc->getColumns() : pRasterDescriptor->getColumns();
unsigned int startColumn = 0;
if (mpStartColumn != NULL)
{
startColumn = *mpStartColumn;
}
else if (origColumns.empty() == false)
{
startColumn = origColumns.front().getOriginalNumber() + 1;
}
unsigned int endColumn = 0;
if (mpEndColumn != NULL)
{
endColumn = *mpEndColumn;
}
else if (origColumns.empty() == false)
{
endColumn = origColumns.back().getOriginalNumber() + 1;
}
unsigned int columnSkip = 0;
if (mpColumnSkipFactor != NULL)
{
columnSkip = *mpColumnSkipFactor;
}
vector<DimensionDescriptor> columns;
for (unsigned int i = 0; i < origColumns.size(); ++i)
{
DimensionDescriptor columnDim = origColumns[i];
unsigned int originalNumber = columnDim.getOriginalNumber() + 1;
if ((originalNumber >= startColumn) && (originalNumber <= endColumn))
{
columns.push_back(columnDim);
i += columnSkip;
}
}
pRasterDescriptor->setColumns(columns);
}
// Bands
if ((mpStartBand != NULL) || (mpEndBand != NULL) || (mpBandSkipFactor != NULL) || (mpBadBandsFile != NULL))
{
// We need to obtain this origBands from the FileDescriptor if present since an importer
// may generate a subset by default in which case the DataDescriptor will not contain all
// the bands and subsetting (especially by bad band file) will not work correctly. We
// can't just set mpFileDescriptor = pRasterDescriptor->getFileDescriptor() since we only
// want to replace the DataDescriptor's band list if one of the subset options is specified
const RasterFileDescriptor* pFileDesc(pRasterFileDescriptor);
if (pFileDesc == NULL)
{
pFileDesc = dynamic_cast<const RasterFileDescriptor*>(pRasterDescriptor->getFileDescriptor());
}
const vector<DimensionDescriptor>& origBands = (pFileDesc != NULL) ?
pFileDesc->getBands() : pRasterDescriptor->getBands();
unsigned int startBand = 0;
if (mpStartBand != NULL)
{
startBand = *mpStartBand;
}
else if (origBands.empty() == false)
{
startBand = origBands.front().getOriginalNumber() + 1;
}
unsigned int endBand = 0;
if (mpEndBand != NULL)
{
endBand = *mpEndBand;
}
else if (origBands.empty() == false)
{
endBand = origBands.back().getOriginalNumber() + 1;
}
unsigned int bandSkip = 0;
if (mpBandSkipFactor != NULL)
{
bandSkip = *mpBandSkipFactor;
}
// Get the bad bands from the file
vector<unsigned int> badBands;
if (mpBadBandsFile != NULL)
{
string filename = *mpBadBandsFile;
if (filename.empty() == false)
{
FILE* pFile = fopen(filename.c_str(), "rb");
if (pFile != NULL)
{
char line[1024];
while (fgets(line, 1024, pFile) != NULL)
{
unsigned int bandNumber = 0;
int iValues = sscanf(line, "%u", &bandNumber);
if (iValues == 1)
{
badBands.push_back(bandNumber);
}
}
fclose(pFile);
}
}
}
vector<DimensionDescriptor> bands;
for (unsigned int i = 0; i < origBands.size(); ++i)
{
DimensionDescriptor bandDim = origBands[i];
unsigned int originalNumber = bandDim.getOriginalNumber() + 1;
if ((originalNumber >= startBand) && (originalNumber <= endBand))
{
bool bBad = false;
for (unsigned int j = 0; j < badBands.size(); ++j)
{
unsigned int badBandNumber = badBands[j];
if (originalNumber == badBandNumber)
{
bBad = true;
break;
}
}
if (bBad == false)
{
bands.push_back(bandDim);
i += bandSkip;
}
}
}
pRasterDescriptor->setBands(bands);
}
// X pixel size
if (mpPixelSizeX != NULL)
{
pRasterDescriptor->setXPixelSize(*mpPixelSizeX);
}
// Y pixel size
if (mpPixelSizeY != NULL)
{
pRasterDescriptor->setYPixelSize(*mpPixelSizeY);
}
// Units
if ((mpUnitsName != NULL) || (mpUnitsType != NULL) ||
(mpUnitsScale != NULL) || (mpUnitsRangeMin != NULL) || (mpUnitsRangeMax != NULL))
{
const Units* pOrigUnits = pRasterDescriptor->getUnits();
FactoryResource<Units> pUnits;
VERIFY(pUnits.get() != NULL);
// Name
if (mpUnitsName != NULL)
{
pUnits->setUnitName(*mpUnitsName);
}
else if (pOrigUnits != NULL)
{
pUnits->setUnitName(pOrigUnits->getUnitName());
}
// Type
if (mpUnitsType != NULL)
{
pUnits->setUnitType(*mpUnitsType);
}
else if (pOrigUnits != NULL)
{
pUnits->setUnitType(pOrigUnits->getUnitType());
}
// Scale
if (mpUnitsScale != NULL)
{
pUnits->setScaleFromStandard(*mpUnitsScale);
}
else if (pOrigUnits != NULL)
{
pUnits->setScaleFromStandard(pOrigUnits->getScaleFromStandard());
}
// Range minimum
if (mpUnitsRangeMin != NULL)
{
pUnits->setRangeMin(*mpUnitsRangeMin);
}
else if (pOrigUnits != NULL)
{
pUnits->setRangeMin(pOrigUnits->getRangeMin());
}
// Range maximum
if (mpUnitsRangeMax != NULL)
{
pUnits->setRangeMax(*mpUnitsRangeMax);
}
else if (pOrigUnits != NULL)
{
pUnits->setRangeMax(pOrigUnits->getRangeMax());
}
pRasterDescriptor->setUnits(pUnits.get());
}
// Display mode
if (mpDisplayMode != NULL)
{
pRasterDescriptor->setDisplayMode(*mpDisplayMode);
}
// Display bands
// Gray
if (mpGrayBand != NULL)
{
DimensionDescriptor band = pRasterDescriptor->getOriginalBand(*mpGrayBand - 1);
pRasterDescriptor->setDisplayBand(GRAY, band);
}
// Red
if (mpRedBand != NULL)
{
DimensionDescriptor band = pRasterDescriptor->getOriginalBand(*mpRedBand - 1);
pRasterDescriptor->setDisplayBand(RED, band);
}
// Green
if (mpGreenBand != NULL)
{
DimensionDescriptor band = pRasterDescriptor->getOriginalBand(*mpGreenBand - 1);
pRasterDescriptor->setDisplayBand(GREEN, band);
}
// Blue
if (mpBlueBand != NULL)
{
DimensionDescriptor band = pRasterDescriptor->getOriginalBand(*mpBlueBand - 1);
pRasterDescriptor->setDisplayBand(BLUE, band);
}
}
else if (pSignatureDescriptor != NULL)
{
if (mpComponentName != NULL)
{
const Units* pOrigUnits = pSignatureDescriptor->getUnits(*mpComponentName);
FactoryResource<Units> pUnits;
if (pOrigUnits != NULL)
{
*pUnits = *pOrigUnits;
}
if (mpUnitsName != NULL)
{
pUnits->setUnitName(*mpUnitsName);
}
if (mpUnitsType != NULL)
{
pUnits->setUnitType(*mpUnitsType);
}
if (mpUnitsScale != NULL)
{
pUnits->setScaleFromStandard(*mpUnitsScale);
}
if (mpUnitsRangeMin != NULL)
{
pUnits->setRangeMin(*mpUnitsRangeMin);
}
if (mpUnitsRangeMax != NULL)
{
pUnits->setRangeMax(*mpUnitsRangeMax);
}
pSignatureDescriptor->setUnits(*mpComponentName, pUnits.get());
}
}
reportComplete();
return true;
}
std::vector<ImportDescriptor*> DicomImporter::getImportDescriptors(const std::string &filename)
{
mErrors.clear();
mWarnings.clear();
std::vector<ImportDescriptor*> descriptors;
DcmFileFormat fileformat;
OFCondition status;
if((status = fileformat.loadFile(filename.c_str())).bad())
{
return descriptors;
}
ImportDescriptorResource pImportDescriptor(filename, TypeConverter::toString<RasterElement>());
VERIFYRV(pImportDescriptor.get() != NULL, descriptors);
descriptors.push_back(pImportDescriptor.release());
DicomImage img(fileformat.getDataset(), fileformat.getDataset()->getOriginalXfer());
if(img.getStatus() != EIS_Normal)
{
mErrors.push_back(std::string("Unable to decode image: ") + DicomImage::getString(img.getStatus()));
pImportDescriptor->setDataDescriptor(RasterUtilities::generateRasterDataDescriptor(filename, NULL, 0, 0, INT1UBYTE, IN_MEMORY));
return descriptors;
}
InterleaveFormatType interleave(BSQ);
EncodingType encoding(INT4UBYTES);
bool rgb = false;
unsigned long rows = img.getHeight(), columns = img.getWidth(), frames = img.getFrameCount();
int imgDepth = img.getDepth();
switch(img.getPhotometricInterpretation())
{
case EPI_Monochrome1:
case EPI_Monochrome2:
// do nothing special....this is single or multi-frame grayscale, 1 or 2 byte
break;
case EPI_RGB:
case EPI_PaletteColor:
// supported if there's only 1 frame
if(frames == 1)
{
frames = 3;
rgb = true;
}
else
{
mWarnings.push_back("RGB and palette color not supported when multiple frames are present. Converting to grayscale.");
}
break;
default:
mWarnings.push_back(std::string(DicomImage::getString(img.getPhotometricInterpretation())) +
" not supported. Attempting to convert to grayscale.");
}
if(imgDepth <= 8)
{
encoding = INT1UBYTE;
}
else if(imgDepth <= 16)
{
encoding = INT2UBYTES;
}
else if(imgDepth <= 32)
{
encoding = INT4UBYTES;
}
else
{
mWarnings.push_back("Bit depth " + StringUtilities::toDisplayString(imgDepth) + " not supported. Downgrading to 32 bits.");
encoding = INT4UBYTES;
}
RasterDataDescriptor *pDescriptor = RasterUtilities::generateRasterDataDescriptor(
filename, NULL, rows, columns, frames, interleave, encoding, IN_MEMORY);
if(pDescriptor != NULL)
{
if(rgb)
{
pDescriptor->setDisplayBand(RED, pDescriptor->getBands()[0]);
pDescriptor->setDisplayBand(GREEN, pDescriptor->getBands()[1]);
pDescriptor->setDisplayBand(BLUE, pDescriptor->getBands()[2]);
pDescriptor->setDisplayMode(RGB_MODE);
}
pImportDescriptor->setDataDescriptor(pDescriptor);
FactoryResource<DynamicObject> pMeta;
int idx = 0;
DcmElement *pElmnt;
while((pElmnt = fileformat.getDataset()->getElement(idx++)) != NULL)
{
if(pElmnt->error().bad())
{
continue;
}
const DcmTag &tag = pElmnt->getTag();
std::string name = const_cast<DcmTag&>(tag).getTagName();
if(name.empty())
{
name = QString("(%1,%2)").arg(pElmnt->getGTag(), 4, 16, QChar('0')).arg(pElmnt->getETag(), 4, 16, QChar('0')).toStdString();
}
pMeta->setAttributeByPath(std::string("DICOM/") + name, dcmElementToDataVariant(*pElmnt));
}
pImportDescriptor->getDataDescriptor()->setMetadata(pMeta.release());
}
RasterUtilities::generateAndSetFileDescriptor(pImportDescriptor->getDataDescriptor(), filename, std::string(), LITTLE_ENDIAN_ORDER);
return descriptors;
}
int getBandCount() { return pDataDescriptor->getBands().size(); }
