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; }