DataAccessorImpl* createDataAccessor(DataElement* pElement, DataAccessorArgs* pArgs)
{
RasterElement* pRasterElement = dynamic_cast<RasterElement*>(pElement);
if (pRasterElement == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return NULL;
}
FactoryResource<DataRequest> pRequest;
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(pRasterElement->getDataDescriptor());
if (pArgs != NULL)
{
pRequest->setRows(pDescriptor->getActiveRow(pArgs->rowStart),
pDescriptor->getActiveRow(pArgs->rowEnd),pArgs->concurrentRows);
pRequest->setColumns(pDescriptor->getActiveColumn(pArgs->columnStart),
pDescriptor->getActiveColumn(pArgs->columnEnd),pArgs->concurrentColumns);
pRequest->setBands(pDescriptor->getActiveBand(pArgs->bandStart),
pDescriptor->getActiveBand(pArgs->bandEnd),pArgs->concurrentBands);
pRequest->setInterleaveFormat(static_cast<InterleaveFormatTypeEnum>(pArgs->interleaveFormat));
pRequest->setWritable(pArgs->writable != 0);
}
DataAccessor dataAccessor(pRasterElement->getDataAccessor(pRequest.release()));
if (!dataAccessor.isValid())
{
setLastError(SIMPLE_BAD_PARAMS);
return NULL;
}
DataAccessorImpl* pRval = dataAccessor.operator->();
pRval->incrementRefCount();
setLastError(SIMPLE_NO_ERROR);
return pRval;
}
DataAccessor getAccessor(int band, bool writable = false) {
FactoryResource<DataRequest> pRequest = FactoryResource<DataRequest>();
pRequest->setRows(pDataDescriptor->getActiveRow(0), pDataDescriptor->getActiveRow(getRowCount() - 1));
pRequest->setColumns(pDataDescriptor->getActiveColumn(0), pDataDescriptor->getActiveColumn(getColumnCount() - 1));
pRequest->setBands(pDataDescriptor->getActiveBand(band), pDataDescriptor->getActiveBand(band));
pRequest->setWritable(writable);
return pRaster->getDataAccessor(pRequest.release());
}
bool EdgeDetector::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Edge Detector", "app", "37C57772-DD49-4532-8BC6-9CFB8587D0C9");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
EncodingType ResultType = INT1UBYTE;
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"_Edge_Detect_Result", pDesc->getRowCount(), pDesc->getColumnCount(), ResultType));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
Service<DesktopServices> pDesktop;
EdgeRatioThresholdDlg dlg(pDesktop->getMainWidget(), SMALL_WINDOW_THRESHOLD, MEDIAN_WINDOW_THRESHOLD, LARGE_WINDOW_THRESHOLD);
int stat = dlg.exec();
if (stat == QDialog::Accepted)
{
for (unsigned int row = 0; row < pDesc->getRowCount(); ++row)
{
if (pProgress != NULL)
{
pProgress->updateProgress("Edge detect ", row * 100 / pDesc->getRowCount(), NORMAL);
}
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
for (unsigned int col = 0; col < pDesc->getColumnCount(); ++col)
{
switchOnEncoding(ResultType, EdgeDetectSAR, pDestAcc->getColumn(), pSrcAcc, row, col,
pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType(),
dlg.getSmallThreshold(), dlg.getMedianThreshold(), dlg.getLargeThreshold());
pDestAcc->nextColumn();
}
pDestAcc->nextRow();
}
if (!isBatch())
{
//Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("Edge detect compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Edge detect result", pResultCube.release());
pStep->finalize();
}
return true;
}
bool TextureSegmentation::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("SAR image segmentation", "app", "CC430C1A-9D8C-4bb5-9254-FCF7EECAFA3C");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
EncodingType ResultType = INT1UBYTE;
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"_Segmentation_Result", pDesc->getRowCount(), pDesc->getColumnCount(), ResultType));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (NULL != pBuffer)
{
free(pBuffer);
}
pBuffer = (float *)malloc(sizeof(float)*pDesc->getRowCount()*pDesc->getColumnCount());
MakeSegmentation(pSrcAcc, pBuffer, pBuffer, pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType());
//Output the value
unsigned int nCount = 0;
for (unsigned int j = 0; j < pDesc->getColumnCount(); j++)
{
for (unsigned int i = 0; i < pDesc->getRowCount(); i++)
{
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pDestAcc->toPixel(i, j);
switchOnEncoding(ResultType, restoreSegmentationValue, pDestAcc->getColumn(), (pBuffer+nCount));
nCount++;
}
}
if (!isBatch())
{
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("Image segmentation is compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Image segmentation result", pResultCube.release());
pStep->finalize();
return true;
}
void PseudocolorLayerImp::draw()
{
RasterElement* pRasterElement = dynamic_cast<RasterElement*>(getDataElement());
if (pRasterElement != NULL)
{
if (canRenderAsImage())
{
generateImage();
VERIFYNRV(mpImage != NULL);
mpImage->draw(GL_NEAREST);
}
else
{
DataAccessor accessor(NULL, NULL);
bool usingRawData = false;
int columns = 0;
int rows = 0;
EncodingType eType;
void* pData = NULL;
const RasterDataDescriptor* pDescriptor =
dynamic_cast<const RasterDataDescriptor*>(pRasterElement->getDataDescriptor());
if (pDescriptor != NULL)
{
columns = static_cast<int>(pDescriptor->getColumnCount());
rows = static_cast<int>(pDescriptor->getRowCount());
eType = pDescriptor->getDataType();
}
// There is an optimization when the full scene can be processed at once.
// Check for if it can be done
if (pDescriptor->getBandCount() == 1 || pDescriptor->getInterleaveFormat() == BSQ)
{
usingRawData = true;
pData = pRasterElement->getRawData();
}
if (pData == NULL)
{
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
accessor = pRasterElement->getDataAccessor(pRequest.release());
}
SymbolType eSymbol = getSymbol();
int visStartColumn = 0;
int visEndColumn = columns - 1;
int visStartRow = 0;
int visEndRow = rows - 1;
DrawUtil::restrictToViewport(visStartColumn, visStartRow, visEndColumn, visEndRow);
QMap<int, PseudocolorClass*>::Iterator iter = mClasses.begin();
while (iter != mClasses.end())
{
PseudocolorClass* pClass = iter.value();
if (pClass != NULL)
{
if (pClass->isDisplayed())
{
QColor clrMarker = pClass->getColor();
if (usingRawData) // all data in memory
{
switchOnEncoding(eType, drawPseudocolorMarkers, pData, columns - 1, rows - 1, visStartColumn,
visStartRow, visEndColumn, visEndRow, eSymbol, clrMarker, pClass->getValue());
}
else
{
for (int row = 0; row < rows; ++row)
{
if (!accessor.isValid())
{
break;
}
pData = accessor->getColumn();
switchOnEncoding(eType, drawPseudocolorMarkers, pData, columns - 1, row, visStartColumn,
row, visEndColumn, row, eSymbol, clrMarker, pClass->getValue(), row);
accessor->nextRow();
}
accessor->toPixel(0, 0);
}
}
}
iter++;
}
}
}
}
bool adaptive_median::execute(PlugInArgList * pInArgList,
PlugInArgList * pOutArgList)
{
StepResource pStep("adap_median", "noise",
"5EA0CC75-9E0B-4c3d-BA23-6DB7157BBD55");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
std::string msg = "Noise Reduction by Adaptive Median Filter ";
Progress *pProgress =
pInArgList->getPlugInArgValue < Progress > (Executable::ProgressArg());
RasterElement *pCube =
pInArgList->getPlugInArgValue < RasterElement >
(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor *pDesc =
static_cast < RasterDataDescriptor * >(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
if (pDesc->getDataType() == INT4SCOMPLEX
|| pDesc->getDataType() == FLT8COMPLEX)
{
std::string msg =
"Noise Reduction cannot be performed on complex types.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource < DataRequest > pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
RasterElement *dRas =
RasterUtilities::createRasterElement(pCube->getName() +
"Noise_reduction_Median_filter",
pDesc->getRowCount(),
pDesc->getColumnCount(), 3,
pDesc->getDataType(), BSQ);
pProgress->updateProgress(msg, 50, NORMAL);
copyImage4(pCube, dRas, 0, pProgress);
pProgress->updateProgress(msg + "RED complete", 60, NORMAL);
copyImage4(pCube, dRas, 1, pProgress);
pProgress->updateProgress(msg + "GREEN complete", 70, NORMAL);
copyImage4(pCube, dRas, 2, pProgress);
pProgress->updateProgress(msg + "BLUE complete", 80, NORMAL);
// new model resource
RasterDataDescriptor *rDesc =
dynamic_cast < RasterDataDescriptor * >(dRas->getDataDescriptor());
rDesc->setDisplayMode(RGB_MODE); // enable color mode
rDesc->setDisplayBand(RED, rDesc->getActiveBand(0));
rDesc->setDisplayBand(GREEN, rDesc->getActiveBand(1));
rDesc->setDisplayBand(BLUE, rDesc->getActiveBand(2));
ModelResource < RasterElement > pResultCube(dRas);
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pProgress->updateProgress("Final", 100, NORMAL);
pProgress->updateProgress(msg, 100, NORMAL);
if (!isBatch())
{
Service < DesktopServices > pDesktop;
SpatialDataWindow *pWindow =
static_cast <
SpatialDataWindow *
>(pDesktop->
createWindow(pResultCube->getName(), SPATIAL_DATA_WINDOW));
SpatialDataView *pView =
(pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("adaptive_median is compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("adaptive_median_Result", pResultCube.release()); // saving
// data
pStep->finalize();
return true;
}
bool pagauss::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Tutorial 5", "app", "5EA0CC75-9E0B-4c3d-BA23-6DB7157BBD54");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
if (pDesc->getDataType() == INT4SCOMPLEX || pDesc->getDataType() == FLT8COMPLEX)
{
std::string msg = "Edge detection cannot be performed on complex types.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"_Edge_Detection_Result", pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType()));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
for (long signed int row = 0; row < pDesc->getRowCount(); ++row)
{
if (pProgress != NULL)
{
pProgress->updateProgress("Calculating result", row * 100 / pDesc->getRowCount(), NORMAL);
}
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
for (long signed int col = 0; col < pDesc->getColumnCount(); ++col)
{
switchOnEncoding(pDesc->getDataType(), gauss, pDestAcc->getColumn(), pSrcAcc, row, col,
pDesc->getRowCount(), pDesc->getColumnCount());
pDestAcc->nextColumn();
}
pDestAcc->nextRow();
}
if (!isBatch())
{
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("pagauss is compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("pagauss_Result", pResultCube.release());
pStep->finalize();
return true;
}
bool DataMergeGui::mergeData()
{
// Service<ModelServices> pModel;
StepResource pStep("Data Merge Begin", "app", "5E4BCD48-E662-408b-93AF-F9127CE56C66");
if (mergeList->count() == 0)
{
QMessageBox::critical(NULL, "Spectral Data Merge", "No RasterElement to merge", "OK");
pStep->finalize(Message::Failure, "No RasterElement to merge");
return false;
}
// pProgress = new Progress(this, "Progress Reporter");
// std::vector<DataElement*> cubes = pModel->getElements("RasterElement");
/* if (mergeElementList.size() == 0)
{
QMessageBox::critical(NULL, "Spectral Data Merge", "No RasterElement input found!", "OK");
pStep->finalize(Message::Failure, "No RasterElement input found!");
return false;
} */
//QListWidgetItem *tmpItem = mergeList->item(i0);
//QString tmpItemText = tmpItem->text();
RasterElement* pInitData = extractRasterElement(mergeList->item(0)->text());
// vector<RasterElement*>::iterator initIter = mergeElementList.begin();
// RasterElement* pInitData = model_cast<RasterElement*>(*initIter);
if (pInitData == NULL)
{
pStep->finalize(Message::Failure, "Cube Data error!");
QMessageBox::critical(this, "Error", "pInitData Error");
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pInitData->getDataDescriptor());
EncodingType type = pDesc->getDataType();
int rowCount = pDesc->getRowCount();
int colCount = pDesc->getColumnCount();
int bandCount = mergeList->count();
RasterElement* pDesRaster = RasterUtilities::createRasterElement("DataMergeCube", rowCount,
colCount, bandCount, type, BIP, true, NULL);
if (pDesRaster == NULL)
{
QMessageBox::critical(NULL, "Spectral Data Merge", "Create RasterElement failed, Please close the previous merge result!", "OK");
pStep->finalize(Message::Failure, "No RasterElement input found!");
return false;
}
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BIP);
DataAccessor pDesAcc = pDesRaster->getDataAccessor(pRequest.release());
if (!pDesAcc.isValid())
{
QMessageBox::critical(NULL, "Spectral Data Merge", "pDesRaster Data Accessor Error!", "OK");
pStep->finalize(Message::Failure, "pDesRaster Data Accessor Error!");
return false;
}
if (pProgress == NULL)
{
QMessageBox::critical(NULL, "Spectral Data Merge", "pProgress Initialize Error!", "OK");
pStep->finalize(Message::Failure, "pProgress Error!");
return false;
}
// progressDialog = new QProgressDialog();
// progressDialog->setRange(0, rowCount);
//int index = 0;
for (int i = 0; i < mergeList->count(); i++)
{
QListWidgetItem *tmpItem = mergeList->item(i);
QString tmpItemText = tmpItem->text();
RasterElement* pData = extractRasterElement(tmpItemText);
int band = extractMergeBand(tmpItemText);
if (pData != NULL)
{
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pData->getDataDescriptor());
if (rowCount != pDesc->getRowCount())
{
QMessageBox::critical(NULL, "Spectral Data Merge", "Merge Data Format Error!", "OK");
pStep->finalize(Message::Failure, "Merge Data Row Format Error!");
return false;
}
if (colCount != pDesc->getColumnCount())
{
QMessageBox::critical(NULL, "Spectral Data Merge", "Merge Data Format Error!", "OK");
pStep->finalize(Message::Failure, "Merge Data Column Format Error!");
return false;
}
// QMessageBox::about(this, "Test", "Here2");
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BIP);
// pRequest->setWritable(true);
DataAccessor pSrcAcc = pData->getDataAccessor(pRequest.release());
switchOnEncoding(pDesc->getDataType(), mergeElement, NULL, rowCount,
colCount, pSrcAcc, pDesAcc, i, band, pProgress, mergeList->count());
// QMessageBox::about(this, "Test", "Here5");
}
else {
QMessageBox::critical(this, "Error", "pData is NULL");
return false;
}
// mergeElementList.push_back(filenameMap[tmpItemText.toStdString()]);
}
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow("DataMergeResult",
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
pStep->finalize(Message::Failure, "SpatialDataView error!");
return false;
}
pView->setPrimaryRasterElement(pDesRaster);
pView->createLayer(RASTER, pDesRaster);
if (pDesc != NULL)
{
const RasterFileDescriptor* pFileDescriptor = dynamic_cast<const RasterFileDescriptor*>(pDesc->getFileDescriptor());
if (pFileDescriptor != NULL)
{
Service<ModelServices> pModel;
if (pModel.get() != NULL)
{
list<GcpPoint> gcps;
gcps = pFileDescriptor->getGcps();
if (gcps.empty() == true)
{
if (pInitData->isGeoreferenced())
{
GcpPoint gcp;
// Lower left
gcp.mPixel.mX = 0.0;
gcp.mPixel.mY = 0.0;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
// Lower right
gcp.mPixel.mX = colCount - 1;
gcp.mPixel.mY = 0.0;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
// Upper left
gcp.mPixel.mX = 0.0;
gcp.mPixel.mY = rowCount - 1;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
// Upper right
gcp.mPixel.mX = colCount - 1;
gcp.mPixel.mY = rowCount - 1;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
// Center
gcp.mPixel.mX = colCount / 2.0;
gcp.mPixel.mY = rowCount / 2.0;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
}
}
if (gcps.empty() == false)
{
DataDescriptor* pGcpDescriptor = pModel->createDataDescriptor("Corner Coordinates",
"GcpList", pDesRaster);
if (pGcpDescriptor != NULL)
{
GcpList* pGcpList = static_cast<GcpList*>(pModel->createElement(pGcpDescriptor));
if (pGcpList != NULL)
{
// Add the GCPs to the GCP list
pGcpList->addPoints(gcps);
// Create the GCP list layer
pView->createLayer(GCP_LAYER, pGcpList);
}
}
}
}
}
}
return true;
}
bool NefImporter::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
//setting up mpRasterElement
parseInputArgList(pInArgList);
RasterElement* pRaster = getRasterElement();
VERIFY(pRaster != NULL);
RasterDataDescriptor *pDescriptor = dynamic_cast<RasterDataDescriptor*>(pRaster->getDataDescriptor());
VERIFY(pDescriptor != NULL);
FileDescriptor *pFileDescriptor = pDescriptor->getFileDescriptor();
VERIFY(pFileDescriptor != NULL);
//data accessor
//RED
DimensionDescriptor firstBand = pDescriptor->getActiveBand(0);
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
pRequest->setBands(firstBand, firstBand);
pRequest->setWritable(true);
DataAccessor firstBandDa = pRaster->getDataAccessor(pRequest.release());
//GREEN
DimensionDescriptor secondBand = pDescriptor->getActiveBand(1);
FactoryResource<DataRequest> qRequest;
qRequest->setInterleaveFormat(BSQ);
qRequest->setBands(secondBand, secondBand);
qRequest->setWritable(true);
DataAccessor secondBandDa = pRaster->getDataAccessor(qRequest.release());
//BLUE
DimensionDescriptor thirdBand = pDescriptor->getActiveBand(2);
FactoryResource<DataRequest> rRequest;
rRequest->setInterleaveFormat(BSQ);
rRequest->setBands(thirdBand, thirdBand);
rRequest->setWritable(true);
DataAccessor thirdBandDa = pRaster->getDataAccessor(rRequest.release());
std::string filename = pRaster->getFilename();
Progress *pProgress = getProgress();
FactoryResource<Filename> pFilename;
pFilename->setFullPathAndName(filename);
LibRaw RawProcessor;
putenv ((char*)"TZ=UTC");
#define P1 RawProcessor.imgdata.idata
#define S RawProcessor.imgdata.sizes
#define C RawProcessor.imgdata.color
#define T RawProcessor.imgdata.thumbnail
#define P2 RawProcessor.imgdata.other
#define OUT RawProcessor.imgdata.params
const char *fname=filename.c_str();
RawProcessor.open_file(fname);
// Let us unpack the image
if (RawProcessor.unpack() != LIBRAW_SUCCESS)
{
return false;
}
/*
unsigned int *r=NULL;
unsigned int *g=NULL;
unsigned int *b=NULL;
unsigned int *h=NULL;
*/
unsigned int *zero=0;
int row=0,col=0,r=0,c=0;
/*
r=(unsigned int*)(&RawProcessor.imgdata.image[i][0]);
g=(unsigned int*)(&RawProcessor.imgdata.image[i][1]);
b=(unsigned int*)(&RawProcessor.imgdata.image[i][2]);
h=(unsigned int*)(&RawProcessor.imgdata.image[i][3]);
*/
//secondBandDa->toPixel(row,col);
//thirdBandDa->toPixel(row,col);
unsigned short *pData=reinterpret_cast<unsigned short*>(pRaster->getRawData());
if (pData == NULL)
{
return NULL;
}
memcpy(pData, RawProcessor.imgdata.rawdata.raw_image, sizeof(unsigned short) * RawProcessor.imgdata.sizes.raw_height * RawProcessor.imgdata.sizes.raw_width);
/*
if(i%2==0) //RG1
{memcpy(firstBandDa->getColumn(),(unsigned int*)RawProcessor.imgdata.image[i][0],sizeof(unsigned int));
memcpy(thirdBandDa->getColumn(),(unsigned int*)RawProcessor.imgdata.image[i][2],sizeof(unsigned int));
memcpy(secondBandDa->getColumn(),zero,sizeof(unsigned int));
}
else{
//G2B
memcpy(thirdBandDa->getColumn(),(unsigned int*)RawProcessor.imgdata.image[i][3],sizeof(unsigned int));
memcpy(secondBandDa->getColumn(),(unsigned int*)RawProcessor.imgdata.image[i][1],sizeof(unsigned int));
memcpy(firstBandDa->getColumn(),zero,sizeof(unsigned int));
}
*/
unsigned short *ptr=NULL;
//band 0 Red
for(row=0,r=0;row<S.iheight;row++,r++)
{
for(col=0,c=0;col<S.iwidth;col++,c++)
{
if(row%2==0) //RG row
{
if(col%2==0) //Red pixel
{
ptr=reinterpret_cast<unsigned short*>(firstBandDa->getColumn());
*ptr=pData[c+(r*S.iwidth)+(0*S.iheight*S.iwidth)];
}
else
{
*ptr=0;
c--;
}
}
else //GB row
{
*ptr=0;
}
firstBandDa->nextColumn();
}
if(row%2!=0)
r--;
firstBandDa->nextRow();
}
//band 2 Blue
for(row=0,r=0;row<S.iheight;row++,r++)
{
for(col=0,c=0;col<S.iwidth;col++,c++)
{
if(row%2!=0) //GB row
{
if(col%2!=0) //Blue pixel
{
ptr=reinterpret_cast<unsigned short*>(secondBandDa->getColumn());
*ptr=pData[c+(r*S.iwidth)+(2*S.iheight*S.iwidth)];
}
else
{
*ptr=0;
c--;
}
}
else //RG row
{
*ptr=0;
}
secondBandDa->nextColumn();
}
if(row%2==0)
r--;
secondBandDa->nextRow();
}
//band 1 Green
for(row=0,r=0;row<S.iheight;row++,r++)
{
for(col=0,c=0;col<S.iwidth;col++,c++)
{
if(row%2==0) //RG row
{
if(col%2!=0) //Green pixel
{
ptr=reinterpret_cast<unsigned short*>(thirdBandDa->getColumn());
*ptr=pData[c+(r*S.iwidth)+(1*S.iheight*S.iwidth)]; //g1
}
else
{
*ptr=0;
c--;
}
}
else //GB row
{
if(col%2==0) //Green pixel
{
ptr=reinterpret_cast<unsigned short*>(thirdBandDa->getColumn());
*ptr=pData[c+(r*S.iwidth)+(3*S.iheight*S.iwidth)]; //g2
}
else
{
*ptr=0;
c--;
}
}
thirdBandDa->nextColumn();
}
thirdBandDa->nextRow();
}
if (createView() == NULL)
{
return false;
}
RawProcessor.recycle();
return true;
}
bool WaveletKSigmaFilter::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Wavelet K-Sigma Filter", "app", "1A4BDC34-5A95-419B-8E53-C92333AFFC3E");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
EncodingType ResultType = pDesc->getDataType();
if (pDesc->getDataType() == INT4SCOMPLEX)
{
ResultType = INT4SBYTES;
}
else if (pDesc->getDataType() == FLT8COMPLEX)
{
ResultType = FLT8BYTES;
}
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"_Noise_Removal_Result", pDesc->getRowCount(), pDesc->getColumnCount(), ResultType));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
Service<DesktopServices> pDesktop;
WaveletKSigmaDlg dlg(pDesktop->getMainWidget());
int stat = dlg.exec();
if (stat != QDialog::Accepted)
{
// pProgress->updateProgress("Level 4 " + StringUtilities::toDisplayString(dlg.getLevelThreshold(3))
// + " Level5 " + StringUtilities::toDisplayString(dlg.getLevelThreshold(4)), dlg.getLevelThreshold(0), NORMAL);
return true;
}
unsigned int rowLoops;
unsigned int colLoops;
unsigned int rowIndex = 0;
unsigned int colIndex = 0;
double ScaleKValue[MAX_WAVELET_LEVELS] = {0.0};
for (int k=0; k<MAX_WAVELET_LEVELS;k++)
{
ScaleKValue[k] = dlg.getLevelThreshold(k);
}
if (0 == pDesc->getRowCount()%rowBlocks)
{
rowLoops = pDesc->getRowCount()/rowBlocks;
}
else
{
rowLoops = pDesc->getRowCount()/rowBlocks + 1;
}
if (0 == pDesc->getColumnCount()%colBlocks)
{
colLoops = pDesc->getColumnCount()/colBlocks;
}
else
{
colLoops = pDesc->getColumnCount()/colBlocks + 1;
}
for (unsigned int i = 0; i < rowLoops; i++)
{
if ( rowIndex + rowBlocks > pDesc->getRowCount())
{
rowIndex = pDesc->getRowCount() - rowBlocks;
}
colIndex = 0;
for (unsigned int j = 0; j < colLoops; j++)
{
if ( colIndex + colBlocks > pDesc->getColumnCount())
{
colIndex = pDesc->getColumnCount() - colBlocks;
}
if (pProgress != NULL)
{
pProgress->updateProgress("Remove result", (i*colLoops+j) / (rowLoops*colLoops), NORMAL);
}
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
//Process the data in current block
ProcessData(pSrcAcc, pBuffer, rowIndex, colIndex, rowBlocks, colBlocks, ScaleKValue, pDesc->getDataType());
//Output the value
for (unsigned int m = 0; m < rowBlocks; m++)
{
for (unsigned int n = 0; n < colBlocks; n++)
{
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pDestAcc->toPixel(rowIndex+m, colIndex+n);
switchOnEncoding(ResultType, speckleNoiseRemove, pDestAcc->getColumn(), (pBuffer+m*colBlocks+n));
}
}
colIndex += colBlocks;
}
rowIndex += rowBlocks;
}
if (!isBatch())
{
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("Noise removal is compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Noise removal Result", pResultCube.release());
pStep->finalize();
return true;
}
bool SamAlgorithm::processAll()
{
auto_ptr<Wavelengths> pWavelengths;
ProgressTracker progress(getProgress(), "Starting SAM", "spectral", "C4320027-6359-4F5B-8820-8BC72BF1B8F0");
progress.getCurrentStep()->addProperty("Interactive", isInteractive());
RasterElement* pElement = getRasterElement();
if (pElement == NULL)
{
progress.report(SAMERR012, 0, ERRORS, true);
return false;
}
progress.getCurrentStep()->addProperty("Cube", pElement->getName());
const RasterDataDescriptor* pDescriptor = static_cast<RasterDataDescriptor*>(pElement->getDataDescriptor());
VERIFY(pDescriptor != NULL);
BitMaskIterator iter(getPixelsToProcess(), pElement);
unsigned int numRows = iter.getNumSelectedRows();
unsigned int numColumns = iter.getNumSelectedColumns();
unsigned int numBands = pDescriptor->getBandCount();
Opticks::PixelOffset layerOffset(iter.getColumnOffset(), iter.getRowOffset());
// get cube wavelengths
DynamicObject* pMetadata = pElement->getMetadata();
if (pMetadata != NULL)
{
pWavelengths.reset(new Wavelengths(pMetadata));
if (!pWavelengths->isEmpty() && (!pWavelengths->hasEndValues() || !pWavelengths->hasStartValues()))
{
pWavelengths->calculateFwhm();
}
}
VERIFY(pWavelengths.get() != NULL);
int sig_index = 0;
bool bSuccess = true;
if (mInputs.mSignatures.empty())
{
progress.report(SAMERR005, 0, ERRORS, true);
return false;
}
int iSignatureCount = mInputs.mSignatures.size();
// Get colors for all the signatures
vector<ColorType> layerColors, excludeColors;
excludeColors.push_back(ColorType(0, 0, 0));
excludeColors.push_back(ColorType(255, 255, 255));
ColorType::getUniqueColors(iSignatureCount, layerColors, excludeColors);
// Create a vector for the signature names
vector<string> sigNames;
// Create a pseudocolor results matrix if necessary
RasterElement* pPseudocolorMatrix = NULL;
RasterElement* pLowestSAMValueMatrix = NULL;
// Check for multiple Signatures and if the user has selected
// to combined multiple results in one pseudocolor output layer
if (iSignatureCount > 1 && mInputs.mbCreatePseudocolor)
{
pPseudocolorMatrix = createResults(numRows, numColumns, mInputs.mResultsName);
pLowestSAMValueMatrix = createResults(numRows, numColumns, "LowestSAMValue");
if (pPseudocolorMatrix == NULL || pLowestSAMValueMatrix == NULL )
{
progress.report(SAMERR007, 0, ERRORS, true);
return false;
}
FactoryResource<DataRequest> pseudoRequest;
pseudoRequest->setWritable(true);
string failedDataRequestErrorMessage =
SpectralUtilities::getFailedDataRequestErrorMessage(pseudoRequest.get(), pPseudocolorMatrix);
DataAccessor pseudoAccessor = pPseudocolorMatrix->getDataAccessor(pseudoRequest.release());
if (!pseudoAccessor.isValid())
{
string msg = "Unable to access results.";
if (!failedDataRequestErrorMessage.empty())
{
msg += "\n" + failedDataRequestErrorMessage;
}
progress.report(msg, 0, ERRORS, true);
return false;
}
FactoryResource<DataRequest> lsvRequest;
lsvRequest->setWritable(true);
failedDataRequestErrorMessage =
SpectralUtilities::getFailedDataRequestErrorMessage(lsvRequest.get(), pLowestSAMValueMatrix);
DataAccessor lowestSamValueAccessor = pLowestSAMValueMatrix->getDataAccessor(lsvRequest.release());
if (!lowestSamValueAccessor.isValid())
{
string msg = "Unable to access results.";
if (!failedDataRequestErrorMessage.empty())
{
msg += "\n" + failedDataRequestErrorMessage;
}
progress.report(msg, 0, ERRORS, true);
return false;
}
//Lets zero out all the results incase we connect to an existing matrix.
float* pPseudoValue = NULL;
float* pLowestValue = NULL;
for (unsigned int row_ctr = 0; row_ctr < numRows; row_ctr++)
{
for (unsigned int col_ctr = 0; col_ctr < numColumns; col_ctr++)
{
if (!pseudoAccessor.isValid() || !lowestSamValueAccessor.isValid())
{
progress.report("Unable to access results.", 0, ERRORS, true);
return false;
}
pLowestValue = reinterpret_cast<float*>(lowestSamValueAccessor->getColumn());
pPseudoValue = reinterpret_cast<float*>(pseudoAccessor->getColumn());
//Initialize the matrices
*pPseudoValue = 0.0f;
*pLowestValue = 180.0f;
pseudoAccessor->nextColumn();
lowestSamValueAccessor->nextColumn();
}
pseudoAccessor->nextRow();
lowestSamValueAccessor->nextRow();
}
}
RasterElement* pResults = NULL;
bool resultsIsTemp = false;
// Processes each selected signature one at a time and
// accumulates results
for (sig_index = 0; bSuccess && (sig_index < iSignatureCount) && !mAbortFlag; sig_index++)
{
// Get the spectrum
Signature* pSignature = mInputs.mSignatures[sig_index];
// Create the results matrix
sigNames.push_back(pSignature->getName());
std::string rname = mInputs.mResultsName;
if (iSignatureCount > 1 && !mInputs.mbCreatePseudocolor)
{
rname += " " + sigNames.back();
}
else if (iSignatureCount > 1)
{
rname += "SamTemp";
resultsIsTemp = true;
}
pResults = createResults(numRows, numColumns, rname);
if (pResults == NULL)
{
bSuccess = false;
break;
}
//Send the message to the progress object
QString messageSigNumber = QString("Processing Signature %1 of %2 : SAM running on signature %3")
.arg(sig_index+1).arg(iSignatureCount).arg(QString::fromStdString(sigNames.back()));
string message = messageSigNumber.toStdString();
vector<double> spectrumValues;
vector<int> resampledBands;
bSuccess = resampleSpectrum(pSignature, spectrumValues, *pWavelengths.get(), resampledBands);
// Check for limited spectral coverage and warning log
if (bSuccess && pWavelengths->hasCenterValues() &&
resampledBands.size() != pWavelengths->getCenterValues().size())
{
QString buf = QString("Warning SamAlg014: The spectrum only provides spectral coverage for %1 of %2 bands.")
.arg(resampledBands.size()).arg(pWavelengths->getCenterValues().size());
progress.report(buf.toStdString(), 0, WARNING, true);
}
if (bSuccess)
{
BitMaskIterator iterChecker(getPixelsToProcess(), pElement);
SamAlgInput samInput(pElement, pResults, spectrumValues, &mAbortFlag, iterChecker, resampledBands);
//Output Structure
SamAlgOutput samOutput;
// Reports current Spectrum SAM is running on
mta::ProgressObjectReporter reporter(message, getProgress());
// Initializes all threads
mta::MultiThreadedAlgorithm<SamAlgInput, SamAlgOutput, SamThread>
mtaSam(Service<ConfigurationSettings>()->getSettingThreadCount(),
samInput,
samOutput,
&reporter);
// Calculates spectral angle for current signature
mtaSam.run();
if (samInput.mpResultsMatrix == NULL)
{
Service<ModelServices>()->destroyElement(pResults);
progress.report(SAMERR006, 0, ERRORS, true);
mAbortFlag = false;
return false;
}
if ((isInteractive() || mInputs.mbDisplayResults) && iSignatureCount > 1 && mInputs.mbCreatePseudocolor)
{
// Merges results in to one output layer if a Pseudocolor
// output layer has been selected
FactoryResource<DataRequest> pseudoRequest, currentRequest, lowestRequest;
pseudoRequest->setWritable(true);
string failedDataRequestErrorMessage =
SpectralUtilities::getFailedDataRequestErrorMessage(pseudoRequest.get(), pPseudocolorMatrix);
DataAccessor daPseudoAccessor = pPseudocolorMatrix->getDataAccessor(pseudoRequest.release());
if (!daPseudoAccessor.isValid())
{
string msg = "Unable to access data.";
if (!failedDataRequestErrorMessage.empty())
{
msg += "\n" + failedDataRequestErrorMessage;
}
progress.report(msg, 0, ERRORS, true);
return false;
}
DataAccessor daCurrentAccessor = pResults->getDataAccessor(currentRequest.release());
lowestRequest->setWritable(true);
failedDataRequestErrorMessage =
SpectralUtilities::getFailedDataRequestErrorMessage(lowestRequest.get(), pLowestSAMValueMatrix);
DataAccessor daLowestSAMValue = pLowestSAMValueMatrix->getDataAccessor(lowestRequest.release());
if (!daLowestSAMValue.isValid())
{
string msg = "Unable to access data.";
if (!failedDataRequestErrorMessage.empty())
{
msg += "\n" + failedDataRequestErrorMessage;
}
progress.report(msg, 0, ERRORS, true);
return false;
}
float* pPseudoValue = NULL;
float* pCurrentValue = NULL;
float* pLowestValue = NULL;
for (unsigned int row_ctr = 0; row_ctr < numRows; row_ctr++)
{
for (unsigned int col_ctr = 0; col_ctr < numColumns; col_ctr++)
{
if (!daPseudoAccessor.isValid() || !daCurrentAccessor.isValid())
{
Service<ModelServices>()->destroyElement(pResults);
progress.report("Unable to access data.", 0, ERRORS, true);
return false;
}
daPseudoAccessor->toPixel(row_ctr, col_ctr);
daCurrentAccessor->toPixel(row_ctr, col_ctr);
pPseudoValue = reinterpret_cast<float*>(daPseudoAccessor->getColumn());
pCurrentValue = reinterpret_cast<float*>(daCurrentAccessor->getColumn());
daLowestSAMValue->toPixel(row_ctr, col_ctr);
pLowestValue = reinterpret_cast<float*>(daLowestSAMValue->getColumn());
if (*pCurrentValue <= mInputs.mThreshold)
{
if (*pCurrentValue < *pLowestValue)
{
*pPseudoValue = sig_index+1;
*pLowestValue = *pCurrentValue;
}
}
}
}
}
else
{
ColorType color;
if (sig_index <= static_cast<int>(layerColors.size()))
{
color = layerColors[sig_index];
}
double dMaxValue = pResults->getStatistics()->getMax();
// Displays results for current signature
displayThresholdResults(pResults, color, LOWER, mInputs.mThreshold, dMaxValue, layerOffset);
}
//If we are on the last signature then destroy the lowest value Matrix
if (sig_index == iSignatureCount-1)
{
if (pLowestSAMValueMatrix != NULL)
{
Service<ModelServices>()->destroyElement(pLowestSAMValueMatrix);
pLowestSAMValueMatrix = NULL;
}
}
}
} //End of Signature Loop Counter
if (resultsIsTemp || !bSuccess)
{
Service<ModelServices>()->destroyElement(pResults);
pResults = NULL;
}
if (bSuccess)
{
// Displays final Pseudocolor output layer results
if ((isInteractive() || mInputs.mbDisplayResults) && iSignatureCount > 1 && mInputs.mbCreatePseudocolor)
{
displayPseudocolorResults(pPseudocolorMatrix, sigNames, layerOffset);
}
}
// Aborts gracefully after clean up
if (mAbortFlag)
{
progress.abort();
mAbortFlag = false;
return false;
}
if (bSuccess)
{
if (pPseudocolorMatrix != NULL)
{
mpResults = pPseudocolorMatrix;
mpResults->updateData();
}
else if (pResults != NULL)
{
mpResults = pResults;
mpResults->updateData();
}
else
{
progress.report(SAMERR016, 0, ERRORS, true);
return false;
}
progress.report(SAMNORM200, 100, NORMAL);
}
progress.getCurrentStep()->addProperty("Display Layer", mInputs.mbDisplayResults);
progress.getCurrentStep()->addProperty("Threshold", mInputs.mThreshold);
progress.upALevel();
return bSuccess;
}
bool conservative_filter::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Conservative", "Filter", "5EA0CC75-9E0B-4c3d-BA23-6DB7157BBD55"); //what is this?
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Service <DesktopServices> pDesktop;
conservative_filter_ui dialog(pDesktop->getMainWidget());
int status = dialog.exec();
if (status == QDialog::Accepted)
{
int radius = dialog.getRadiusValue();
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
if (pDesc->getDataType() == INT4SCOMPLEX || pDesc->getDataType() == FLT8COMPLEX)
{
std::string msg = "Conservative Filter cannot be performed on complex types.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() + "_Conservative_Filter_Result", pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType()));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
for (unsigned int row = 0; row < pDesc->getRowCount(); ++row)
{
if (pProgress != NULL)
{
pProgress->updateProgress("Applying Conservative Filter", row * 100 / pDesc->getRowCount(), NORMAL);
}
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
for (unsigned int col = 0; col < pDesc->getColumnCount(); ++col)
{
switchOnEncoding(pDesc->getDataType(), verifyRange, pDestAcc->getColumn(), pSrcAcc, row, col, pDesc->getRowCount(), pDesc->getColumnCount(), radius);
pDestAcc->nextColumn();
}
pDestAcc->nextRow();
}
if (!isBatch())
{
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("COnservative Filter is complete", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("conservative_filter_result", pResultCube.release());
pStep->finalize();
}
return true;
}
bool KDISTRIBUTION::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("KDISTRIBUTION", "app10", "F298D57C-D816-42F0-AE27-43DAA02C0544");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
FactoryResource<DataRequest> pRequest;
FactoryResource<DataRequest> pRequest2;
pRequest->setInterleaveFormat(BSQ);
pRequest2->setInterleaveFormat(BSQ);
DataAccessor pAcc = pCube->getDataAccessor(pRequest.release());
DataAccessor pAcc2 = pCube->getDataAccessor(pRequest2.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"Result", pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType()));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pCube->getDataDescriptor());
int tester_count = 0;
int eastCol = 0;
int northRow = 0;
int westCol = 0;
int southRow = 0;
double zstatistic = 0;
double total = 0.0;
double total_sum = 0.0;
double mean = 0.0;
double std = 0.0;
double a=0;
int rowSize=pDesc->getRowCount();
int colSize=pDesc->getColumnCount();
int prevCol = 0;
int prevRow = 0;
int nextCol = 0;
int nextRow = 0;
double long PFA = 0.0;
int DEPTH1 = 10;
int DEPTH2 = 10;
int DEPTH3 = 1;
int DEPTH4 = 1;
int count=0;
int zero=0;
double long threshold = 100000.0;
double look_table1[24][6];
for(int i=0; i<24; i++)
{
for(int j=0; j<3; j++)
{
look_table1[i][j]=0.0;
}
}
QStringList Names("0.0000001");
QString value = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input a PFA value", "Input a PFA value (0.0000001 or 0.00000001)", Names);
std::string strAoi = value.toStdString();
std::istringstream stm;
stm.str(strAoi);
//stm >> PFA;
PFA=::atof(strAoi.c_str());
if (PFA==0.0000001)
{
look_table1[0][0]=1.0;
look_table1[0][1]=5.0;
look_table1[0][2]=32.3372530103729330;
look_table1[1][0]=1.0;
look_table1[1][1]=10.0;
look_table1[1][2]=25.0723580041031010;
look_table1[2][0]=1.0;
look_table1[2][1]=15.0;
look_table1[2][2]=22.3991160013551250;
look_table1[3][0]=1.0;
look_table1[3][1]=20.0;
look_table1[3][2]=20.9821949998985920;
look_table1[4][1]=1.0;
look_table1[4][2]=40.0;
look_table1[5][3]=18.7055519975583020;
look_table1[5][1]=1.0;
look_table1[5][2]=90.0;
look_table1[5][3]=18.7055519975583020;
look_table1[6][0]=2.0;
look_table1[6][1]=5.0;
look_table1[6][2]=20.2619339991581950;
look_table1[7][0]=2.0;
look_table1[7][1]=10.0;
look_table1[7][2]=15.4860609951617470;
look_table1[8][0]=2.0;
look_table1[8][1]=15.0;
look_table1[8][2]=13.7276789964777210;
look_table1[9][0]=2.0;
look_table1[9][1]=20.0;
look_table1[9][2]=12.7942589971762930;
look_table1[10][0]=2.0;
look_table1[10][1]=40.0;
look_table1[10][2]=11.2895769983023970;
look_table1[11][0]=2.0;
look_table1[11][1]=90.0;
look_table1[11][2]=10.3695259989909640;
look_table1[12][0]=3.0;
look_table1[12][1]=5.0;
look_table1[12][2]=15.9102209948443050;
look_table1[13][0]=3.0;
look_table1[13][1]=10.0;
look_table1[13][2]=12.0443629977375150;
look_table1[14][0]=3.0;
look_table1[14][1]=15.0;
look_table1[14][2]=10.6203179988032710;
look_table1[15][0]=3.0;
look_table1[15][1]=20.0;
look_table1[15][2]=9.8635499993696367;
look_table1[16][0]=3.0;
look_table1[16][1]=40.0;
look_table1[16][2]=8.6407550002847771;
look_table1[17][0]=3.0;
look_table1[17][1]=90.0;
look_table1[17][2]=7.8893780007488568;
look_table1[18][0]=4.0;
look_table1[18][1]=5.0;
look_table1[18][2]=13.6166519965608130;
look_table1[19][0]=4.0;
look_table1[19][1]=10.0;
look_table1[19][2]=10.2336029990926890;
look_table1[20][0]=4.0;
look_table1[20][1]=15.0;
look_table1[20][2]=10.6203179988032710;
look_table1[21][0]=4.0;
look_table1[21][1]=20.0;
look_table1[21][2]=8.9868610000257512;
look_table1[22][0]=4.0;
look_table1[22][1]=40.0;
look_table1[22][2]=7.2502150006595159;
look_table1[23][0]=4.0;
look_table1[23][1]=90.0;
look_table1[23][2]=6.5879140005669408;
}
if (PFA==0.00000001)
{
look_table1[0][0]=1.0;
look_table1[0][1]=5.0;
look_table1[0][2]=20.0000019988889410;
look_table1[1][0]=1.0;
look_table1[1][1]=10.0;
look_table1[1][2]=20.0000019988889410;
look_table1[2][0]=1.0;
look_table1[2][1]=15.0;
look_table1[2][2]=20.0000019988889410;
look_table1[3][0]=1.0;
look_table1[3][1]=20.0;
look_table1[3][2]=20.0000019988889410;
look_table1[4][1]=1.0;
look_table1[4][2]=40.0;
look_table1[5][3]=20.0000019988889410;
look_table1[5][1]=1.0;
look_table1[5][2]=90.0;
look_table1[5][3]=20.0000019988889410;
look_table1[6][0]=2.0;
look_table1[6][1]=5.0;
look_table1[6][2]=18.3243529971664460;
look_table1[7][0]=2.0;
look_table1[7][1]=10.0;
look_table1[7][2]=18.3243529971664460;
look_table1[8][0]=2.0;
look_table1[8][1]=15.0;
look_table1[8][2]=16.0869139948664570;
look_table1[9][0]=2.0;
look_table1[9][1]=20.0;
look_table1[9][2]=14.8998299956004820;
look_table1[10][0]=2.0;
look_table1[10][1]=40.0;
look_table1[10][2]=12.9846719970337880;
look_table1[11][0]=2.0;
look_table1[11][1]=90.0;
look_table1[11][2]=11.8094659979133120;
look_table1[12][0]=3.0;
look_table1[12][1]=5.0;
look_table1[12][2]=18.9816659978421360;
look_table1[13][0]=3.0;
look_table1[13][1]=10.0;
look_table1[13][2]=14.1167729961865230;
look_table1[14][0]=3.0;
look_table1[14][1]=15.0;
look_table1[14][2]=12.3304539975234050;
look_table1[15][0]=3.0;
look_table1[15][1]=20.0;
look_table1[15][2]=11.3819769982332450;
look_table1[16][0]=3.0;
look_table1[16][1]=40.0;
look_table1[16][2]=9.8488249993806569;
look_table1[17][0]=3.0;
look_table1[17][1]=90.0;
look_table1[17][2]=8.9039850000877756;
look_table1[18][0]=4.0;
look_table1[18][1]=5.0;
look_table1[18][2]=16.1272319949079020;
look_table1[19][0]=4.0;
look_table1[19][1]=10.0;
look_table1[19][2]=11.9117899978367330;
look_table1[20][0]=4.0;
look_table1[20][1]=15.0;
look_table1[20][2]=10.3636999989953240;
look_table1[21][0]=4.0;
look_table1[21][1]=20.0;
look_table1[21][2]=9.5411879996108926;
look_table1[22][0]=4.0;
look_table1[22][1]=40.0;
look_table1[22][2]=8.2095870006074634;
look_table1[23][0]=4.0;
look_table1[23][1]=90.0;
look_table1[23][2]=7.3860650006785047;
}
QStringList Names1("10");
QString value1 = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input the size of the window width", "Input the size of the window width in terms of the number of pixels (eg. 10)", Names1);
std::string strAoi1 = value1.toStdString();
std::istringstream stm1;
stm1.str(strAoi1);
//stm1 >> DEPTH1;
DEPTH1=::atof(strAoi1.c_str());
QStringList Names2("10");
QString value2 = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input the size of the window height", "Input the size of the window height in terms of the number of pixels (eg. 10)", Names2);
std::string strAoi2 = value2.toStdString();
std::istringstream stm2;
stm2.str(strAoi2);
//stm2 >> DEPTH2;
DEPTH2=::atof(strAoi2.c_str());
QStringList Names3("1");
QString value3 = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input the size of the gaurd width", "Input the size of the guard width in terms of the number of pixels (eg. 1)", Names3);
std::string strAoi3 = value3.toStdString();
std::istringstream stm3;
stm3.str(strAoi3);
//stm3 >> DEPTH3;
DEPTH3=::atof(strAoi3.c_str());
QStringList Names4("1");
QString value4 = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input the size of the guard height", "Input the size of the guard height in terms of the number of pixels (eg. 1)", Names4);
std::string strAoi4 = value4.toStdString();
std::istringstream stm4;
stm4.str(strAoi4);
stm4 >> DEPTH4;
DEPTH4=::atof(strAoi4.c_str());
for (int row = 0; row < rowSize; ++row)
{
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
if (pProgress != NULL)
{
pProgress->updateProgress("Calculating statistics", row * 100 / pDesc->getRowCount(), NORMAL);
}
for (int col = 0; col < colSize; ++col)
{
//p[col]=pAcc2->getColumnAsInteger();
westCol=max(col-DEPTH1,zero);
northRow=max(row-DEPTH2,zero);
eastCol=min(colSize-1,col+DEPTH1);
southRow=min(rowSize-1,row+DEPTH2);
prevCol=max(col-DEPTH3,zero);
prevRow=max(row-DEPTH4,zero);
nextCol=min(col+DEPTH3,colSize-1);
nextRow=min(row+DEPTH4,rowSize-1);
pAcc2->toPixel(northRow,westCol);
for(int row1=northRow; row1 < southRow+1; ++row1)
{
for (int col1=westCol; col1 < eastCol+1; ++col1)
{
if((row1>=prevRow && row1<=nextRow) && (col1>=prevCol && col1<=nextCol))
{
continue;
}
else
{
updateStatistics3(pAcc2->getColumnAsDouble(), total, total_sum, count);
}
pAcc2->nextColumn();
}
pAcc2->nextRow();
}
mean = total / count;
std = sqrt(total_sum / count - mean * mean);
int ELVI = (mean/std)*(mean/std);
int v = (ELVI+1)/((ELVI*mean/(std*std))-1);
pAcc2->toPixel(row,col);
pDestAcc->toPixel(row,col);
zstatistic = (pAcc2->getColumnAsDouble()-mean)/std;
if(v<=7 && v>=0)
{ v=5;
}
if(v<=12 && v>7)
{
v=10;
}
if(v<=17 && v>12)
{
v=15;
}
if(v<=30 && v>17)
{
v=20;
}
if(v<=65 && v>30)
{
v=40;
}
if(v<=90 && v>65)
{
v=90;
}
for(int i=0; i<24; i++)
{
if((look_table1[i][0]=ELVI) && (look_table1[i][1]==v))
{
threshold=look_table1[i][2];
}
}
if(zstatistic>threshold)
{
switchOnEncoding(pDesc->getDataType(), conversion1, pDestAcc->getColumn(), 1000.0);
}
else
{
switchOnEncoding(pDesc->getDataType(), conversion1, pDestAcc->getColumn(), 0.0);
}
total = 0.0;
total_sum=0.0;
threshold=100000.0;
mean = 0.0;
std = 0.0;
count=0;
pAcc->nextColumn();
}
pAcc->nextRow();
}
// Create a GCP layer
/*
SpatialDataWindow* pWindow = dynamic_cast<SpatialDataWindow*>(Service<DesktopServices>()->createWindow(pResultCube.get()->getName(), SPATIAL_DATA_WINDOW));
SpatialDataView* pView = pWindow->getSpatialDataView();
*/
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
// Create the GCP list
if (pCube->isGeoreferenced() == true)
{
const vector<DimensionDescriptor>& rows = pDescriptor->getRows();
const vector<DimensionDescriptor>& columns = pDescriptor->getColumns();
if ((rows.empty() == false) && (columns.empty() == false))
{
// Get the geocoordinates at the chip corners
/*
VERIFYNRV(rows.front().isActiveNumberValid() == true);
VERIFYNRV(rows.back().isActiveNumberValid() == true);
VERIFYNRV(columns.front().isActiveNumberValid() == true);
VERIFYNRV(columns.back().isActiveNumberValid() == true);
*/
unsigned int startRow = rows.front().getActiveNumber();
unsigned int endRow = rows.back().getActiveNumber();
unsigned int startCol = columns.front().getActiveNumber();
unsigned int endCol = columns.back().getActiveNumber();
GcpPoint ulPoint;
ulPoint.mPixel = LocationType(startCol, startRow);
ulPoint.mCoordinate = pCube->convertPixelToGeocoord(ulPoint.mPixel);
GcpPoint urPoint;
urPoint.mPixel = LocationType(endCol, startRow);
urPoint.mCoordinate = pCube->convertPixelToGeocoord(urPoint.mPixel);
GcpPoint llPoint;
llPoint.mPixel = LocationType(startCol, endRow);
llPoint.mCoordinate = pCube->convertPixelToGeocoord(llPoint.mPixel);
GcpPoint lrPoint;
lrPoint.mPixel = LocationType(endCol, endRow);
lrPoint.mCoordinate = pCube->convertPixelToGeocoord(lrPoint.mPixel);
GcpPoint centerPoint;
centerPoint.mPixel = LocationType((startCol + endCol) / 2, (startRow + endRow) / 2);
centerPoint.mCoordinate = pCube->convertPixelToGeocoord(centerPoint.mPixel);
/*
// Reset the coordinates to be in active numbers relative to the chip
const vector<DimensionDescriptor>& chipRows = pDescriptor->getRows();
const vector<DimensionDescriptor>& chipColumns = pDescriptor->getColumns();
VERIFYNRV(chipRows.front().isActiveNumberValid() == true);
VERIFYNRV(chipRows.back().isActiveNumberValid() == true);
VERIFYNRV(chipColumns.front().isActiveNumberValid() == true);
VERIFYNRV(chipColumns.back().isActiveNumberValid() == true);
unsigned int chipStartRow = chipRows.front().getActiveNumber();
unsigned int chipEndRow = chipRows.back().getActiveNumber();
unsigned int chipStartCol = chipColumns.front().getActiveNumber();
unsigned int chipEndCol = chipColumns.back().getActiveNumber();
ulPoint.mPixel = LocationType(chipStartCol, chipStartRow);
urPoint.mPixel = LocationType(chipEndCol, chipStartRow);
llPoint.mPixel = LocationType(chipStartCol, chipEndRow);
lrPoint.mPixel = LocationType(chipEndCol, chipEndRow);
centerPoint.mPixel = LocationType((chipStartCol + chipEndCol) / 2, (chipStartRow + chipEndRow) / 2);
*/
Service<ModelServices> pModel;
GcpList* pGcpList = static_cast<GcpList*>(pModel->createElement("Corner Coordinates",
TypeConverter::toString<GcpList>(), pResultCube.get()));
if (pGcpList != NULL)
{
list<GcpPoint> gcps;
gcps.push_back(ulPoint);
gcps.push_back(urPoint);
gcps.push_back(llPoint);
gcps.push_back(lrPoint);
gcps.push_back(centerPoint);
pGcpList->addPoints(gcps);
pView->createLayer(GCP_LAYER, pGcpList);
}
}
}
if (pProgress != NULL)
{
pProgress->updateProgress("CFAR is compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Result", pResultCube.release());
pStep->finalize();
return true;
}
bool LocalSharpening::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Local Sharpening", "app", "08BB9B79-5D24-4AB0-9F35-92DE77CED8E7");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
EncodingType ResultType = pDesc->getDataType();
if (pDesc->getDataType() == INT4SCOMPLEX)
{
ResultType = INT4SBYTES;
}
else if (pDesc->getDataType() == FLT8COMPLEX)
{
ResultType = FLT8BYTES;
}
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"_Local_Sharpening_Result", pDesc->getRowCount(), pDesc->getColumnCount(), ResultType));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
Service<DesktopServices> pDesktop;
LocalSharpeningDlg dlg(pDesktop->getMainWidget());
int stat = dlg.exec();
if (stat != QDialog::Accepted)
{
return true;
}
double contrastVal = dlg.getContrastValue();
int nFilterType = dlg.getCurrentFilterType();
int windowSize = dlg.getCurrentWindowSize();
windowSize = (windowSize-1)/2;
for (unsigned int row = 0; row < pDesc->getRowCount(); ++row)
{
if (pProgress != NULL)
{
pProgress->updateProgress("Local sharpening", row * 100 / pDesc->getRowCount(), NORMAL);
}
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
for (unsigned int col = 0; col < pDesc->getColumnCount(); ++col)
{
if (nFilterType == 0)
{
switchOnEncoding(ResultType, localAdaptiveSharpening, pDestAcc->getColumn(), pSrcAcc, row, col,
pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType(), windowSize, contrastVal);
}
else
{
switchOnEncoding(ResultType, localExtremeSharpening, pDestAcc->getColumn(), pSrcAcc, row, col,
pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType(), windowSize);
}
pDestAcc->nextColumn();
}
pDestAcc->nextRow();
}
if (!isBatch())
{
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("Local sharpening is compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Local sharpening Result", pResultCube.release());
pStep->finalize();
return true;
}
bool SpectralLibraryManager::generateResampledLibrary(const RasterElement* pRaster)
{
VERIFY(pRaster != NULL);
// check that lib sigs are in same units as the raster element
const RasterDataDescriptor* pDesc = dynamic_cast<const RasterDataDescriptor*>(pRaster->getDataDescriptor());
VERIFY(pDesc != NULL);
const Units* pUnits = pDesc->getUnits();
if (pDesc->getUnits()->getUnitType() != mLibraryUnitType)
{
if (Service<DesktopServices>()->showMessageBox("Mismatched Units", "The data are not in the "
"same units as the spectral library.\n Do you want to continue anyway?", "Yes", "No") == 1)
{
return false;
}
}
FactoryResource<Wavelengths> pWavelengths;
pWavelengths->initializeFromDynamicObject(pRaster->getMetadata(), false);
// populate the library with the resampled signatures
PlugInResource pPlugIn("Resampler");
Resampler* pResampler = dynamic_cast<Resampler*>(pPlugIn.get());
VERIFY(pResampler != NULL);
if (pWavelengths->getNumWavelengths() != pDesc->getBandCount())
{
mpProgress->updateProgress("Wavelength information in metadata does not match the number of bands "
"in the raster element", 0, ERRORS);
return false;
}
// get resample suitable signatures - leave out signatures that don't cover the spectral range of the data
std::vector<std::vector<double> > resampledData;
resampledData.reserve(mSignatures.size());
std::vector<Signature*> resampledSignatures;
resampledSignatures.reserve(mSignatures.size());
std::vector<std::string> unsuitableSignatures;
std::vector<double> sigValues;
std::vector<double> sigWaves;
std::vector<double> rasterWaves = pWavelengths->getCenterValues();
std::vector<double> rasterFwhm = pWavelengths->getFwhm();
std::vector<double> resampledValues;
std::vector<int> bandIndex;
DataVariant data;
for (std::vector<Signature*>::const_iterator it = mSignatures.begin(); it != mSignatures.end(); ++it)
{
data = (*it)->getData(SpectralLibraryMatch::getNameSignatureWavelengthData());
VERIFY(data.isValid());
VERIFY(data.getValue(sigWaves));
resampledValues.clear();
data = (*it)->getData(SpectralLibraryMatch::getNameSignatureAmplitudeData());
VERIFY(data.isValid());
VERIFY(data.getValue(sigValues));
double scaleFactor = (*it)->getUnits(
SpectralLibraryMatch::getNameSignatureAmplitudeData())->getScaleFromStandard();
for (std::vector<double>::iterator sit = sigValues.begin(); sit != sigValues.end(); ++sit)
{
*sit *= scaleFactor;
}
std::string msg;
if (pResampler->execute(sigValues, resampledValues, sigWaves, rasterWaves, rasterFwhm, bandIndex, msg) == false
|| resampledValues.size() != rasterWaves.size())
{
unsuitableSignatures.push_back((*it)->getName());
continue;
}
resampledData.push_back(resampledValues);
resampledSignatures.push_back(*it);
}
if (resampledSignatures.empty())
{
std::string errMsg = "None of the signatures in the library cover the spectral range of the data.";
if (mpProgress != NULL)
{
mpProgress->updateProgress(errMsg, 0, ERRORS);
return false;
}
}
if (unsuitableSignatures.empty() == false)
{
std::string warningMsg = "The following library signatures do not cover the spectral range of the data:\n";
for (std::vector<std::string>::iterator it = unsuitableSignatures.begin();
it != unsuitableSignatures.end(); ++it)
{
warningMsg += *it + "\n";
}
warningMsg += "These signatures will not be searched for in the data.";
Service<DesktopServices>()->showMessageBox("SpectralLibraryManager", warningMsg);
StepResource pStep("Spectral LibraryManager", "spectral", "64B6C87A-A6C3-4378-9B6E-221D89D8707B");
pStep->finalize(Message::Unresolved, warningMsg);
}
std::string libName = "Resampled Spectral Library";
// Try to get the resampled lib element in case session was restored. If NULL, create a new raster element with
// num rows = num valid signatures, num cols = 1, num bands = pRaster num bands
RasterElement* pLib = dynamic_cast<RasterElement*>(Service<ModelServices>()->getElement(libName,
TypeConverter::toString<RasterElement>(), pRaster));
if (pLib != NULL)
{
// check that pLib has same number of sigs as SpectralLibraryManager
RasterDataDescriptor* pLibDesc = dynamic_cast<RasterDataDescriptor*>(pLib->getDataDescriptor());
VERIFY(pLibDesc != NULL);
if (pLibDesc->getRowCount() != mSignatures.size())
{
mpProgress->updateProgress("An error occurred during session restore and some signatures were not restored."
" Check the spectral library before using.", 0, ERRORS);
Service<ModelServices>()->destroyElement(pLib);
pLib = NULL;
}
}
bool isNewElement(false);
if (pLib == NULL)
{
pLib = RasterUtilities::createRasterElement(libName,
static_cast<unsigned int>(resampledData.size()), 1, pDesc->getBandCount(), FLT8BYTES, BIP,
true, const_cast<RasterElement*>(pRaster));
isNewElement = true;
}
if (pLib == NULL)
{
mpProgress->updateProgress("Error occurred while trying to create the resampled spectral library", 0, ERRORS);
return false;
}
RasterDataDescriptor* pLibDesc = dynamic_cast<RasterDataDescriptor*>(pLib->getDataDescriptor());
VERIFY(pLibDesc != NULL);
// copy resampled data into new element
if (isNewElement)
{
FactoryResource<DataRequest> pRequest;
pRequest->setWritable(true);
pRequest->setRows(pLibDesc->getActiveRow(0), pLibDesc->getActiveRow(pLibDesc->getRowCount()-1), 1);
DataAccessor acc = pLib->getDataAccessor(pRequest.release());
for (std::vector<std::vector<double> >::iterator sit = resampledData.begin(); sit != resampledData.end(); ++sit)
{
VERIFY(acc->isValid());
void* pData = acc->getColumn();
memcpy(acc->getColumn(), &(sit->begin()[0]), pLibDesc->getBandCount() * sizeof(double));
acc->nextRow();
}
// set wavelength info in resampled library
pWavelengths->applyToDynamicObject(pLib->getMetadata());
FactoryResource<Units> libUnits;
libUnits->setUnitType(mLibraryUnitType);
libUnits->setUnitName(StringUtilities::toDisplayString<UnitType>(mLibraryUnitType));
pLibDesc->setUnits(libUnits.get());
}
pLib->attach(SIGNAL_NAME(Subject, Deleted), Slot(this, &SpectralLibraryManager::resampledElementDeleted));
mLibraries[pRaster] = pLib;
mResampledSignatures[pLib] = resampledSignatures;
const_cast<RasterElement*>(pRaster)->attach(SIGNAL_NAME(Subject, Deleted),
Slot(this, &SpectralLibraryManager::elementDeleted));
return true;
}
bool Tutorial3::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Tutorial 3", "app", "27170298-10CE-4E6C-AD7A-97E8058C29FF");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pAcc = pCube->getDataAccessor(pRequest.release());
double min = std::numeric_limits<double>::max();
double max = -min;
double total = 0.0;
for (unsigned int row = 0; row < pDesc->getRowCount(); ++row)
{
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
if (pProgress != NULL)
{
pProgress->updateProgress("Calculating statistics", row * 100 / pDesc->getRowCount(), NORMAL);
}
for (unsigned int col = 0; col < pDesc->getColumnCount(); ++col)
{
switchOnEncoding(pDesc->getDataType(), updateStatistics, pAcc->getColumn(), min, max, total);
pAcc->nextColumn();
}
pAcc->nextRow();
}
unsigned int count = pDesc->getColumnCount() * pDesc->getRowCount();
double mean = total / count;
if (pProgress != NULL)
{
std::string msg = "Minimum value: " + StringUtilities::toDisplayString(min) + "\n"
+ "Maximum value: " + StringUtilities::toDisplayString(max) + "\n"
+ "Number of pixels: " + StringUtilities::toDisplayString(count) + "\n"
+ "Average: " + StringUtilities::toDisplayString(mean);
pProgress->updateProgress(msg, 100, NORMAL);
}
pStep->addProperty("Minimum", min);
pStep->addProperty("Maximum", max);
pStep->addProperty("Count", count);
pStep->addProperty("Mean", mean);
pOutArgList->setPlugInArgValue("Minimum", &min);
pOutArgList->setPlugInArgValue("Maximum", &max);
pOutArgList->setPlugInArgValue("Count", &count);
pOutArgList->setPlugInArgValue("Mean", &mean);
pStep->finalize();
return true;
}
bool HIGHPASS::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Tutorial 5", "app", "219F1882-A59F-4835-BE2A-E83C0C8111EB");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"DResult", pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType()));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
int rowSize= pDesc->getRowCount();
int colSize = pDesc->getColumnCount();
int zero=0;
int prevCol = 0;
int prevRow = 0;
int nextCol = 0;
int nextRow = 0;
int prevCol1 = 0;
int prevRow1= 0;
int nextCol1= 0;
int nextRow1= 0;
for (unsigned int row = 0; row < pDesc->getRowCount(); ++row)
{
if (pProgress != NULL)
{
pProgress->updateProgress("Calculating result", row * 100 / pDesc->getRowCount(), NORMAL);
}
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
for (unsigned int col = 0; col < pDesc->getColumnCount(); ++col)
{
double value=edgeDetection7(pSrcAcc, row, col, pDesc->getRowCount(), pDesc->getColumnCount());
switchOnEncoding(pDesc->getDataType(), conversion, pDestAcc->getColumn(), value);
pDestAcc->nextColumn();
}
pDestAcc->nextRow();
}
if (!isBatch())
{
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("HighPass is compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Result", pResultCube.release());
pStep->finalize();
return true;
}
bool Test_Update_TerraSAR::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Tutorial CEO", "app", "0FD3C564-041D-4f8f-BBF8-96A7A165AB61");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
FactoryResource<DataRequest> pRequest;
DataAccessor pAcc = pCube->getDataAccessor(pRequest.release());
std::string path = pCube->getFilename();
DataDescriptor* dMeta = pCube->getDataDescriptor();
DynamicObject* Metadata = dMeta->getMetadata();
// RETRIEVE & UPDATE METADATA INFORMATION //
TerraSAR_Metadata Prova_metadata;
bool control = Prova_metadata.ReadFile(path);
if (control == false)
{
std::string msg = "This is not a TerraSAR-X SLC Files, Metadata can't be updated";
pProgress->updateProgress(msg, 100, ERRORS);
return false;
}
Prova_metadata.UpdateMetadata(Metadata);
//SAR_Model ModProva(Prova_metadata,1000);
SAR_Model *ModProva;
//ModProva = new SAR_Ground_Model(Prova_metadata);
ModProva = new SAR_Slant_Model(Prova_metadata);
if(Prova_metadata.Projection == "SGF")
{
ModProva = new SAR_Ground_Model(Prova_metadata);
}
//else
//{
// ModProva = new SAR_Slant_Model(Prova_metadata);
//}
// WIDGET SELECT & RETRIEVE GCPs INFORMATION //
GcpList * GCPs = NULL;
Service<ModelServices> pModel;
std::vector<DataElement*> pGcpLists = pModel->getElements(pCube, TypeConverter::toString<GcpList>());
std::list<GcpPoint> Punti;
if (!pGcpLists.empty())
{
QStringList aoiNames("<none>");
for (std::vector<DataElement*>::iterator it = pGcpLists.begin(); it != pGcpLists.end(); ++it)
{
aoiNames << QString::fromStdString((*it)->getName());
}
QString aoi = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Select a GCP List", "Select a GCP List for validate the orientation model", aoiNames);
if (aoi != "<none>")
{
std::string strAoi = aoi.toStdString();
for (std::vector<DataElement*>::iterator it = pGcpLists.begin(); it != pGcpLists.end(); ++it)
{
if ((*it)->getName() == strAoi)
{
GCPs = static_cast<GcpList*>(*it);
break;
}
}
if (GCPs == NULL)
{
std::string msg = "Invalid GCPList.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
}
else
{
std::string msg = "A set of GCPs must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
// UPDATE GCPs HEIGHT INFORMATION AND SWITCH Lat&Lon COORDINATE FOR CORRECT VISUALIZAZION IN THE GCPs EDITOR
Punti = GCPs->getSelectedPoints();
Punti = Prova_metadata.UpdateGCP(Punti, path, pProgress);
P_COORD Punto;
int N=Punti.size();
int n=0, indexP=0;
double Lat, Lon;
accumulator_set<double, stats<tag::mean, tag::variance> > accX, accY;
list<GcpPoint>::iterator pList;
for (pList = Punti.begin(); pList != Punti.end(); pList++)
{
if(pList->mPixel.mX<Prova_metadata.Width && pList->mPixel.mY<Prova_metadata.Height)
{
Lon = pList->mCoordinate.mX;
Lat = pList->mCoordinate.mY;
Punto = ModProva->SAR_GroundToImage(pList->mCoordinate.mX,pList->mCoordinate.mY,pList->mCoordinate.mZ);
//pList->mRmsError.mX = pList->mPixel.mX -Punto.I;
//pList->mRmsError.mY = pList->mPixel.mY -Punto.J;
pList->mPixel.mX = (Prova_metadata.Grid_Range_Time/Prova_metadata.RowSpacing)*(indexP-int(indexP/Prova_metadata.Grid_N_Range)*Prova_metadata.Grid_N_Range);
pList->mRmsError.mX = (Prova_metadata.Grid_Range_Time/Prova_metadata.RowSpacing)*(indexP-int(indexP/Prova_metadata.Grid_N_Range)*Prova_metadata.Grid_N_Range) -Punto.I;
pList->mPixel.mY = (Prova_metadata.Grid_Azimuth_Time*Prova_metadata.PRF)*int(indexP/Prova_metadata.Grid_N_Range);
pList->mRmsError.mY = (Prova_metadata.Grid_Azimuth_Time*Prova_metadata.PRF)*int(indexP/Prova_metadata.Grid_N_Range) - Punto.J;
accX(pList->mRmsError.mX);
accY(pList->mRmsError.mY);
pList->mCoordinate.mX = Lat;
pList->mCoordinate.mY = Lon;
}
else
{
Lon = pList->mCoordinate.mX;
Lat = pList->mCoordinate.mY;
pList->mRmsError.mX = -9999;
pList->mRmsError.mY = -9999;
pList->mCoordinate.mX = Lat;
pList->mCoordinate.mY = Lon;
}
if (pProgress != NULL)
{
pProgress->updateProgress("Calculating statistics", int(100*n/N), NORMAL);
}
n++;
indexP++;
}
double meanX = mean(accX);
double meanY = mean(accY);
double varX = variance(accX);
double varY = variance(accY);
GCPs->clearPoints();
GCPs->addPoints(Punti);
if (pProgress != NULL)
{
std::string msg = "Number of Rows : " + StringUtilities::toDisplayString(pDesc->getRowCount()) + "\n"
"Number of Columns : " + StringUtilities::toDisplayString(pDesc->getColumnCount()) + "\n\n"
"Metadata update completed" + "\n\n"
"********** Validation Results **********" "\n\n"
"Number of GCPs: " + StringUtilities::toDisplayString(Punti.size()) + "\n\n"
"Mean I : " + StringUtilities::toDisplayString(meanX) + "\n"
"Variance I : " + StringUtilities::toDisplayString(varX) + "\n\n"
"Mean J : " + StringUtilities::toDisplayString(meanY) + "\n"
"Variance J : " + StringUtilities::toDisplayString(varY) + "\n\n" ;
pProgress->updateProgress(msg, 100, NORMAL);
}
} // End if GcpList
else
{
Punti.resize(Prova_metadata.Grid_N);
Punti = Prova_metadata.UpdateGCP(Punti, path);
}
pStep->finalize();
return true;
}
bool Deconvolution::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Deconvolution Sharpening", "app", "619F3C8A-FB70-44E0-B211-B116E604EDDA");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
EncodingType ResultType = pDesc->getDataType();
if (pDesc->getDataType() == INT4SCOMPLEX)
{
ResultType = INT4SBYTES;
}
else if (pDesc->getDataType() == FLT8COMPLEX)
{
ResultType = FLT8BYTES;
}
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"_Deconvolution_Sharpening_Result", pDesc->getRowCount(), pDesc->getColumnCount(), ResultType));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
Service<DesktopServices> pDesktop;
DeconvolutionDlg dlg(pDesktop->getMainWidget());
int stat = dlg.exec();
if (stat != QDialog::Accepted)
{
return true;
}
double minGrayValue;
double maxGrayValue;
double deltaValue = 0.0;
int nFilterType = dlg.getCurrentFilterType();
int windowSize = dlg.getCurrentWindowSize();
double sigmaVal = dlg.getSigmaValue();
double gamaVal = dlg.getGamaValue();
windowSize = (windowSize-1)/2;
if (NULL != pOriginalImage)
{
free(pOriginalImage);
}
pOriginalImage = (double *)malloc(sizeof(double)*pDesc->getRowCount()*pDesc->getColumnCount());
double *OrigData = (double *)malloc(sizeof(double)*pDesc->getRowCount()*pDesc->getColumnCount());
double *NewData = (double *)malloc(sizeof(double)*pDesc->getRowCount()*pDesc->getColumnCount());
double *ConvoData = (double *)malloc(sizeof(double)*pDesc->getRowCount()*pDesc->getColumnCount());
double *pTempData;
InitializeData(pSrcAcc, pOriginalImage, OrigData, pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType());
GetGrayScale(&minGrayValue, &maxGrayValue, pDesc->getDataType());
//Perform deconvolution iteratively
for (int num = 0; num < MAX_ITERATION_NUMBER; num++)
{
if (pProgress != NULL)
{
pProgress->updateProgress("Deconvolution process", num*100/MAX_ITERATION_NUMBER, NORMAL);
}
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
free(OrigData);
free(NewData);
free(ConvoData);
return false;
}
deltaValue = DeconvolutionFunc(OrigData, pOriginalImage, NewData, ConvoData, sigmaVal, gamaVal,
windowSize, pDesc->getRowCount(), pDesc->getColumnCount(), nFilterType, maxGrayValue, minGrayValue);
pTempData = OrigData;
OrigData = NewData;
NewData = pTempData;
double errorRate = deltaValue/(maxGrayValue-minGrayValue);
if (errorRate < CONVERGENCE_THRESHOLD)
{
break;
}
}
free(NewData);
free(ConvoData);
//Output result
unsigned int nCount = 0;
for (int i = 0; i < pDesc->getRowCount(); i++)
{
for (int j = 0; j < pDesc->getColumnCount(); j++)
{
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
free(OrigData);
return false;
}
pDestAcc->toPixel(i, j);
switchOnEncoding(ResultType, restoreImageValue, pDestAcc->getColumn(), (OrigData+nCount));
nCount++;
}
}
free(OrigData);
if (!isBatch())
{
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
if (pProgress != NULL)
{
pProgress->updateProgress("Deconvolution enhancement is complete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Deconvolution enhancement Result", pResultCube.release());
pStep->finalize();
return true;
}
bool ImageRegistration::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Image Registration", "app", "A2E0FC44-2A31-41EE-90F8-805773D01FCA");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
//RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
std::vector<Window*> windows;
Service<DesktopServices>()->getWindows(SPATIAL_DATA_WINDOW, windows);
std::vector<RasterElement*> elements;
for (unsigned int i = 0; i < windows.size(); ++i)
{
SpatialDataWindow* pWindow = dynamic_cast<SpatialDataWindow*>(windows[i]);
if (pWindow == NULL)
{
continue;
}
LayerList* pList = pWindow->getSpatialDataView()->getLayerList();
elements.push_back(pList->getPrimaryRasterElement());
}
RasterElement* pCube = elements[0];
RasterElement* pCubeRef = elements[1];
if ((pCube == NULL) || (pCubeRef == NULL))
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
EncodingType ResultType = pDesc->getDataType();
if (pDesc->getDataType() == INT4SCOMPLEX)
{
ResultType = INT4SBYTES;
}
else if (pDesc->getDataType() == FLT8COMPLEX)
{
ResultType = FLT8BYTES;
}
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BSQ);
DataAccessor pSrcAcc = pCube->getDataAccessor(pRequest.release());
FactoryResource<DataRequest> pRequestRef;
pRequestRef->setInterleaveFormat(BSQ);
DataAccessor pSrcAccRef = pCubeRef->getDataAccessor(pRequestRef.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"_Image_Registration_Result", pDesc->getRowCount(), pDesc->getColumnCount(), ResultType));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
std::vector<int> badValues = pDesc->getBadValues();
//badValues.push_back(0);
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(pResultCube->getDataDescriptor());
Statistics* pStatistics = pResultCube->getStatistics(pDescriptor->getActiveBand(0));
pStatistics->setBadValues(badValues);
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
nCountMas = 0;
nCountRef = 0;
int windowSize = 6;
double *pBuffer = (double *)calloc(pDesc->getRowCount()*pDesc->getColumnCount(), sizeof(double));
GetGrayScale(pDesc->getDataType());
for (unsigned int row = 0; row < pDesc->getRowCount(); ++row)
{
if (pProgress != NULL)
{
pProgress->updateProgress("Image registration", row * 100 / pDesc->getRowCount(), NORMAL);
}
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
for (unsigned int col = 0; col < pDesc->getColumnCount(); ++col)
{
locateAllStarPosition(pSrcAcc, pSrcAccRef, row, col, pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType(), windowSize, pBuffer);
}
}
ModifyCenter(pSrcAcc, pDesc->getDataType(), windowSize, nCountMas, nStarPositionsMas);
ModifyCenter(pSrcAccRef, pDesc->getDataType(), windowSize, nCountRef, nStarPositionsRef);
GetAllNeighborStars();
GetMatchingStars();
GetParameters(pDesc->getRowCount(), pDesc->getColumnCount());
DrawStars(pBuffer, pSrcAccRef, pDesc->getDataType(), matrixT, pDesc->getRowCount(), pDesc->getColumnCount());
//Output the value
for (unsigned int m = 0; m < pDesc->getRowCount(); m++)
{
for (unsigned int n = 0; n < pDesc->getColumnCount(); n++)
{
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
switchOnEncoding(ResultType, updatePixel, pDestAcc->getColumn(), pBuffer, m, n, pDesc->getRowCount(), pDesc->getColumnCount());
pDestAcc->nextColumn();
}
pDestAcc->nextRow();
}
free(pBuffer);
if (!isBatch())
{
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
}
double theta = std::acos(matrixT[0][0])*180.0/3.1415926;
std::string msg = "Image Registration is complete.\n Translation x = " + StringUtilities::toDisplayString(round(shiftX)) + ", y = " +
StringUtilities::toDisplayString(round(shiftY)) + ", rotation = " + StringUtilities::toDisplayString(round(theta)) + " degree";
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Image Registration Result", pResultCube.release());
pStep->finalize();
return true;
}
