bool DeriveProduct::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Execute Wizard Item", "app", "58FE5CAB-E941-4E60-BA55-B29D70715FC4");
pStep->addProperty("Item", getName());
mpStep = pStep.get();
if (!extractInputArgs(pInArgList))
{
reportError("Unable to extract input arguments.", "5E158F48-6089-4A88-ABD0-55C717BD13E2");
return false;
}
View* pView = pInArgList->getPlugInArgValue<View>("View");
if (pView == NULL)
{
std::vector<Window*> windows;
Service<DesktopServices>()->getWindows(SPATIAL_DATA_WINDOW, windows);
if (!windows.empty())
{
pView = static_cast<SpatialDataWindow*>(windows.front())->getSpatialDataView();
}
}
if (pView == NULL)
{
reportError("No view provided.", "852F585B-D239-4C0A-B993-70EE68EC8DEE");
return false;
}
ProductWindow* pProductWindow = Service<DesktopServices>()->deriveProduct(pView);
if (pProductWindow == NULL)
{
reportError("Unable to derive product", "E24BB5A5-A675-4897-9C48-A4E4109379DF");
return false;
}
// Load a template if one is specified
Filename* pTemplate = pInArgList->getPlugInArgValue<Filename>("Template");
if (pTemplate != NULL)
{
if (!pProductWindow->getProductView()->loadTemplate(pTemplate->getFullPathAndName()))
{
reportError("Could not load the requested template!", "C99CE97E-3F0F-4CBB-8460-28D96D55596B");
return false;
}
}
// Set the output values
if (!pOutArgList->setPlugInArgValue("Window", pProductWindow) ||
!pOutArgList->setPlugInArgValue("View", pProductWindow->getProductView()))
{
reportError("Could not set the data set output value!", "3C53EDAE-DC70-4141-9759-ECD3EB9BE186");
return false;
}
reportComplete();
pStep->finalize(Message::Success);
return true;
}
bool WavelengthExporter::extractInputArgs(PlugInArgList* pArgList)
{
VERIFY(pArgList != NULL);
mpProgress = pArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
mpWavelengths = pArgList->getPlugInArgValue<Wavelengths>(Wavelengths::WavelengthsArg());
if (mpWavelengths == NULL)
{
string message = "The " + Wavelengths::WavelengthsArg() + " input value is invalid.";
if (mpProgress != NULL)
{
mpProgress->updateProgress(message, 0, ERRORS);
}
mpStep->finalize(Message::Failure, message);
return false;
}
Filename* pFilename = pArgList->getPlugInArgValue<Filename>(Wavelengths::WavelengthFileArg());
if (pFilename == NULL)
{
string message = "The " + Wavelengths::WavelengthFileArg() + " input value is not present.";
if (mpProgress != NULL)
{
mpProgress->updateProgress(message, 0, ERRORS);
}
mpStep->finalize(Message::Failure, message);
return false;
}
mFilename = pFilename->getFullPathAndName();
if (mFilename.empty() == true)
{
string message = "The " + Wavelengths::WavelengthFileArg() + " input value is invalid.";
if (mpProgress != NULL)
{
mpProgress->updateProgress(message, 0, ERRORS);
}
mpStep->finalize(Message::Failure, message);
return false;
}
return true;
}
bool ResamplerPlugIn::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
VERIFY(pInArgList != NULL && pOutArgList != NULL);
ProgressTracker progress(pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg()),
"Executing Spectral Resampler.", "spectral", "{88CD3E49-A522-431A-AE2A-96A6B2EB4012}");
Service<DesktopServices> pDesktop;
const DataElement* pElement(NULL);
std::string waveFilename;
// get default resampling options from user config
std::string resampleMethod = ResamplerOptions::getSettingResamplerMethod();
double dropOutWindow = ResamplerOptions::getSettingDropOutWindow();
double fwhm = ResamplerOptions::getSettingFullWidthHalfMax();
bool useFillValue = ResamplerOptions::getSettingUseFillValue();
double fillValue = ResamplerOptions::getSettingSignatureFillValue();
std::vector<Signature*> originalSignatures;
std::auto_ptr<std::vector<Signature*> > pResampledSignatures(new std::vector<Signature*>);
std::string errorMsg;
if (isBatch())
{
VERIFY(pInArgList->getPlugInArgValue("Signatures to resample", originalSignatures));
if (originalSignatures.empty())
{
Signature* pSignature = pInArgList->getPlugInArgValue<Signature>("Signature to resample");
if (pSignature != NULL)
{
originalSignatures.push_back(pSignature);
}
}
if (originalSignatures.empty())
{
progress.report("No signatures are available to be resampled.", 0, ERRORS, true);
return false;
}
pElement = pInArgList->getPlugInArgValue<DataElement>("Data element wavelength source");
Filename* pWaveFilename = pInArgList->getPlugInArgValue<Filename>("Wavelengths Filename");
if (pWaveFilename != NULL)
{
waveFilename = pWaveFilename->getFullPathAndName();
}
VERIFY(pInArgList->getPlugInArgValue("Resampling Method", resampleMethod));
VERIFY(pInArgList->getPlugInArgValue("Drop out window", dropOutWindow));
VERIFY(pInArgList->getPlugInArgValue("FWHM", fwhm));
VERIFY(pInArgList->getPlugInArgValue("Use fill value", useFillValue));
VERIFY(pInArgList->getPlugInArgValue("Fill value", fillValue));
}
else
{
ResamplerPlugInDlg dlg(pDesktop->getMainWidget());
if (dlg.exec() == QDialog::Rejected)
{
progress.report("User canceled resampling.", 0, ABORT, true);
progress.upALevel();
return false;
}
originalSignatures = dlg.getSignaturesToResample();
resampleMethod = dlg.getResamplingMethod();
dropOutWindow = dlg.getDropOutWindow();
fwhm = dlg.getFWHM();
useFillValue = dlg.getUseFillValue();
fillValue = dlg.getFillValue();
pElement = dlg.getWavelengthsElement();
waveFilename = dlg.getWavelengthsFilename();
}
std::string resampledTo;
FactoryResource<Wavelengths> pWavelengths;
if (pElement != NULL) // try loading wavelengths from user specified data element
{
if (getWavelengthsFromElement(pElement, pWavelengths.get(), errorMsg) == false)
{
progress.report(errorMsg, 0, ERRORS, true);
return false;
}
resampledTo = pElement->getName();
}
else if (waveFilename.empty() == false) // if no user provided raster, look for a wavelengths file
{
if (QFile::exists(QString::fromStdString(waveFilename)))
{
if (getWavelengthsFromFile(waveFilename, pWavelengths.get(), errorMsg) == false)
{
progress.report(errorMsg, 0, ERRORS, true);
return false;
}
}
else
{
errorMsg = "The wavelengths file \"" + waveFilename + "\" could not be found.";
progress.report(errorMsg, 0, ERRORS, true);
return false;
}
resampledTo = waveFilename;
}
else // if no wavelength source provided, look for raster in current active spatial data view
{
SpatialDataView* pView = dynamic_cast<SpatialDataView*>(pDesktop->getCurrentWorkspaceWindowView());
if (pView != NULL)
{
LayerList* pLayerList = pView->getLayerList();
if (pLayerList != NULL)
{
pElement = pLayerList->getPrimaryRasterElement();
pWavelengths->initializeFromDynamicObject(pElement->getMetadata(), false);
if (pWavelengths->isEmpty())
{
progress.report("No target wavelengths are available for resampling the signatures.", 0, ERRORS, true);
return false;
}
resampledTo = pElement->getName();
}
}
}
PlugInResource pPlugIn("Resampler");
Resampler* pResampler = dynamic_cast<Resampler*>(pPlugIn.get());
if (pResampler == NULL)
{
progress.report("The \"Resampler\" plug-in is not available so the signatures can not be resampled.",
0, ERRORS, true);
return false;
}
std::string dataName("Reflectance");
std::string wavelengthName("Wavelength");
// save user config settings - Resampler doesn't have interface to set them separately from user config
std::string configMethod = ResamplerOptions::getSettingResamplerMethod();
ResamplerOptions::setSettingResamplerMethod(resampleMethod);
double configDropout = ResamplerOptions::getSettingDropOutWindow();
ResamplerOptions::setSettingDropOutWindow(dropOutWindow);
double configFwhm = ResamplerOptions::getSettingFullWidthHalfMax();
ResamplerOptions::setSettingFullWidthHalfMax(fwhm);
std::vector<double> toWavelengths = pWavelengths->getCenterValues();
std::vector<double> toFwhm = pWavelengths->getFwhm();
if (toFwhm.size() != toWavelengths.size())
{
toFwhm.clear(); // Resampler will use the default config setting fwhm if this vector is empty
}
unsigned int numSigs = originalSignatures.size();
unsigned int numSigsResampled(0);
progress.report("Begin resampling signatures...", 0, NORMAL);
for (unsigned int index = 0; index < numSigs; ++index)
{
if (isAborted())
{
progress.report("Resampling aborted by user", 100 * index / numSigs, ABORT, true);
return false;
}
if (originalSignatures[index] == NULL)
{
continue;
}
// check if signature has target wavelength centers and doesn't need to be resampled
if (needToResample(originalSignatures[index], pWavelengths.get()) == false)
{
pResampledSignatures->push_back(originalSignatures[index]);
++numSigsResampled;
continue;
}
DataVariant var = originalSignatures[index]->getData(dataName);
if (var.isValid() == false)
{
continue;
}
std::vector<double> fromData;
if (!var.getValue(fromData))
{
continue;
}
var = originalSignatures[index]->getData(wavelengthName);
if (var.isValid() == false)
{
continue;
}
std::vector<double> fromWavelengths;
if (!var.getValue(fromWavelengths))
{
continue;
}
std::string resampledSigName = originalSignatures[index]->getName() + "_resampled";
int suffix(2);
ModelResource<Signature> pSignature(resampledSigName, NULL);
// probably not needed but just in case resampled name already used
while (pSignature.get() == NULL)
{
pSignature = ModelResource<Signature>(resampledSigName + StringUtilities::toDisplayString(suffix), NULL);
++suffix;
}
if (resampledTo.empty() == false)
{
DynamicObject* pMetaData = pSignature->getMetadata();
if (pMetaData != NULL)
{
pMetaData->setAttribute(CommonSignatureMetadataKeys::ResampledTo(), resampledTo);
}
}
std::vector<double> toData;
std::vector<int> toBands;
if (pResampler->execute(fromData, toData, fromWavelengths, toWavelengths, toFwhm, toBands, errorMsg))
{
if (toWavelengths.size() != toBands.size())
{
if (toBands.size() < 2) // no need to try if only one point
{
continue;
}
if (useFillValue)
{
std::vector<double> values(toWavelengths.size(), fillValue);
for (unsigned int i = 0; i < toBands.size(); ++i)
{
values[static_cast<unsigned int>(toBands[i])] = toData[i];
}
toData.swap(values);
DynamicObject* pMetaData = pSignature->getMetadata();
if (pMetaData != NULL)
{
pMetaData->setAttribute(CommonSignatureMetadataKeys::FillValue(), fillValue);
}
}
else
{
std::vector<double> wavelengths(toBands.size());
for (unsigned int i = 0; i < toBands.size(); ++i)
{
wavelengths[i] = toWavelengths[static_cast<unsigned int>(toBands[i])];
}
toWavelengths.swap(wavelengths);
}
}
pSignature->setData(dataName, toData);
pSignature->setData(wavelengthName, toWavelengths);
SignatureDataDescriptor* pDesc = dynamic_cast<SignatureDataDescriptor*>(pSignature->getDataDescriptor());
if (pDesc == NULL)
{
continue;
}
pDesc->setUnits(dataName, originalSignatures[index]->getUnits(dataName));
pResampledSignatures->push_back(pSignature.release());
++numSigsResampled;
}
std::string progressStr =
QString("Resampled signature %1 of %2 signatures").arg(index + 1).arg(numSigs).toStdString();
progress.report(progressStr, (index + 1) * 100 / numSigs, NORMAL);
}
// reset config options
ResamplerOptions::setSettingResamplerMethod(configMethod);
ResamplerOptions::setSettingDropOutWindow(configDropout);
ResamplerOptions::setSettingFullWidthHalfMax(configFwhm);
if (numSigsResampled == numSigs)
{
progress.report("Complete", 100, NORMAL);
progress.upALevel();
}
else
{
errorMsg = QString("Only %1 of the %2 signatures were successfully resampled.").arg(
numSigsResampled).arg(numSigs).toStdString();
progress.report(errorMsg, 100, WARNING, true);
}
VERIFY(pOutArgList->setPlugInArgValue("Resampled signatures", pResampledSignatures.release()));
return true;
}
bool WavelengthExporter::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
if (pInArgList == NULL)
{
return false;
}
StepResource pStep(string("Execute ") + getName(), "Spectral", "B6112093-AE6A-4319-85D8-B7A4C1E3DC5E");
// Extract the input args
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
DynamicObject* pWavelengthData = pInArgList->getPlugInArgValue<DynamicObject>(Wavelengths::WavelengthsArg());
if (pWavelengthData == NULL)
{
string message = "The " + Wavelengths::WavelengthsArg() + " input value is invalid.";
if (pProgress != NULL)
{
pProgress->updateProgress(message, 0, ERRORS);
}
pStep->finalize(Message::Failure, message);
return false;
}
Filename* pFilename = pInArgList->getPlugInArgValue<Filename>(Wavelengths::WavelengthFileArg());
if (pFilename == NULL)
{
string message = "The " + Wavelengths::WavelengthFileArg() + " input value is not present.";
if (pProgress != NULL)
{
pProgress->updateProgress(message, 0, ERRORS);
}
pStep->finalize(Message::Failure, message);
return false;
}
mFilename = pFilename->getFullPathAndName();
if (mFilename.empty() == true)
{
string message = "The " + Wavelengths::WavelengthFileArg() + " input value is invalid.";
if (pProgress != NULL)
{
pProgress->updateProgress(message, 0, ERRORS);
}
pStep->finalize(Message::Failure, message);
return false;
}
// Save the wavelength values
Wavelengths wavelengths(pWavelengthData);
bool bSuccess = saveWavelengths(wavelengths);
if (bSuccess == false)
{
string message = "Could not save the wavelengths to the file.";
if (pProgress != NULL)
{
pProgress->updateProgress(message, 0, ERRORS);
}
pStep->finalize(Message::Failure, message);
return false;
}
if (pProgress != NULL)
{
pProgress->updateProgress("Wavelength export completed successfully.", 100, NORMAL);
}
pStep->finalize(Message::Success);
return true;
}
bool ElmBatch::extractInputArgs(PlugInArgList* pInputArgList)
{
if (ElmCore::extractInputArgs(pInputArgList) == false)
{
return false;
}
StepResource pStep("Extract Batch Input Args", "app", "32A136BE-8531-42ca-8B22-086293B5A925");
VERIFY(pStep.get() != NULL);
// Get the Use Gains/Offsets Flag.
if (pInputArgList->getPlugInArgValue<bool>(UseGainsOffsetsArg(), mUseGainsOffsets) == false)
{
pStep->finalize(Message::Failure, "The \"" + UseGainsOffsetsArg() + "\" input arg is invalid.");
if (mpProgress != NULL)
{
mpProgress->updateProgress(pStep->getFailureMessage(), 100, ERRORS);
}
return false;
}
if (mUseGainsOffsets == true)
{
// If the Use Gains/Offsets Flag is set to true, get the Gains/Offsets Filename.
Filename* pFilename = pInputArgList->getPlugInArgValue<Filename>(GainsOffsetsFilenameArg());
if (pFilename == NULL || pFilename->getFullPathAndName().empty() == true)
{
// If the Gains/Offsets Filename is not set, use the default.
mGainsOffsetsFilename = getDefaultGainsOffsetsFilename();
}
else if (pFilename->isDirectory() == true)
{
pStep->finalize(Message::Failure, "The \"" + GainsOffsetsFilenameArg() + "\" cannot be a directory.");
if (mpProgress != NULL)
{
mpProgress->updateProgress(pStep->getFailureMessage(), 100, ERRORS);
}
return false;
}
else
{
mGainsOffsetsFilename = pFilename->getFullPathAndName();
}
}
else
{
// If the Use Gains/Offsets Flag is set to false, get the Signature Filenames and AOI Filenames.
vector<Filename*> pSignatureFilenames;
if (pInputArgList->getPlugInArgValue<vector<Filename*> >
(SignatureFilenamesArg(), pSignatureFilenames) == false)
{
pStep->finalize(Message::Failure, "The \"" + SignatureFilenamesArg() + "\" input arg is invalid.");
if (mpProgress != NULL)
{
mpProgress->updateProgress(pStep->getFailureMessage(), 100, ERRORS);
}
return false;
}
for (vector<Filename*>::iterator iter = pSignatureFilenames.begin(); iter != pSignatureFilenames.end(); ++iter)
{
bool previouslyLoaded;
Signature* pSignature = dynamic_cast<Signature*>
(getElement(*iter, "Signature", NULL, previouslyLoaded));
if (pSignature == NULL)
{
pStep->finalize(Message::Failure, "The \"" + SignatureFilenamesArg() +
"\" input arg contains an invalid value.");
if (mpProgress != NULL)
{
mpProgress->updateProgress(pStep->getFailureMessage(), 100, ERRORS);
}
return false;
}
mpSignatures.push_back(pSignature);
if (previouslyLoaded == false)
{
mpSignaturesToDestroy.push_back(pSignature);
}
}
// Get the AOI names.
vector<Filename*> pAoiFilenames;
if (pInputArgList->getPlugInArgValue<vector<Filename*> >(AoiFilenamesArg(), pAoiFilenames) == false)
{
pStep->finalize(Message::Failure, "The \"" + AoiFilenamesArg() + "\" input arg is invalid.");
if (mpProgress != NULL)
{
mpProgress->updateProgress(pStep->getFailureMessage(), 100, ERRORS);
}
return false;
}
for (vector<Filename*>::iterator iter = pAoiFilenames.begin(); iter != pAoiFilenames.end(); ++iter)
{
bool previouslyLoaded;
AoiElement* pAoiElement = dynamic_cast<AoiElement*>
(getElement(*iter, "AoiElement", mpRasterElement, previouslyLoaded));
if (pAoiElement == NULL)
{
pStep->finalize(Message::Failure, "The \"" + AoiFilenamesArg() +
"\" input arg contains an invalid value.");
if (mpProgress != NULL)
{
mpProgress->updateProgress(pStep->getFailureMessage(), 100, ERRORS);
}
return false;
}
mpAoiElements.push_back(pAoiElement);
if (previouslyLoaded == false)
{
mpAoiElementsToDestroy.push_back(pAoiElement);
}
}
}
pStep->finalize();
return true;
}