void ReplaceBandInputWizard::addSourcePage() { QWizardPage* pPage = new QWizardPage(this); pPage->setTitle("Select source data element"); QLabel* pPageLabel = new QLabel("Select the source data element.", pPage); pPageLabel->setWordWrap(true); mpSource = new QComboBox(pPage); mpSource->setEditable(false); const RasterDataDescriptor* pDestDesc = static_cast<const RasterDataDescriptor*>(mpDest->getDataDescriptor()); std::vector<DataElement*> rasters = Service<ModelServices>()->getElements(TypeConverter::toString<RasterElement>()); for(std::vector<DataElement*>::iterator raster = rasters.begin(); raster != rasters.end(); ++raster) { RasterElement* pRaster = static_cast<RasterElement*>(*raster); if (pRaster == mpDest) { continue; } const RasterDataDescriptor* pDesc = static_cast<const RasterDataDescriptor*>(pRaster->getDataDescriptor()); if (pDesc->getRowCount() == pDestDesc->getRowCount() && pDesc->getColumnCount() == pDestDesc->getColumnCount() && pDesc->getDataType() == pDestDesc->getDataType()) { mpSource->addItem(QString::fromStdString(pRaster->getName()), reinterpret_cast<qulonglong>(pRaster)); } } QVBoxLayout* pLayout = new QVBoxLayout(); pLayout->addWidget(pPageLabel); pLayout->addWidget(mpSource); pPage->setLayout(pLayout); addPage(pPage); }
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; }
Image(SpatialDataView* iPView) : pView(iPView) { LayerList* pLayerList = pView->getLayerList(); VERIFYNRV(pLayerList != NULL); pRaster = dynamic_cast<RasterElement*>(pLayerList->getPrimaryRasterElement()); VERIFYNRV(pRaster != NULL); pDataDescriptor = dynamic_cast<const RasterDataDescriptor*>(pRaster->getDataDescriptor()); VERIFYNR(pDataDescriptor != NULL); /* Service<DesktopServices> pDesktop; VERIFYNRV(pDesktop.get() != NULL); SpatialDataWindow* pWindow = dynamic_cast<SpatialDataWindow*>(pDesktop->getWindow(pRaster->getName(), SPATIAL_DATA_WINDOW)); VERIFYNRV(pWindow != NULL); VERIFYNRV(pDesktop->setCurrentWorkspaceWindow(pWindow));*/ }
int copyDataToRasterElement(DataElement* pElement, DataPointerArgs* pArgs, void* pData) { RasterElement* pRaster = dynamic_cast<RasterElement*>(pElement); if (pRaster == NULL || pData == NULL) { setLastError(SIMPLE_BAD_PARAMS); return 1; } const RasterDataDescriptor* pDesc = static_cast<const RasterDataDescriptor*>(pRaster->getDataDescriptor()); void* pRawData = pRaster->getRawData(); if (pArgs == NULL && pRawData != NULL) { size_t len = pDesc->getRowCount() * pDesc->getColumnCount() * pDesc->getBandCount() * pDesc->getBytesPerElement(); memcpy(pRawData, pData, len); setLastError(SIMPLE_NO_ERROR); return 0; } DataPointerArgs args = { 0, pDesc->getRowCount() - 1, 0, pDesc->getColumnCount() - 1, 0, pDesc->getBandCount() - 1, 0 }; switch (pDesc->getInterleaveFormat()) { case BSQ: args.interleaveFormat = 0; break; case BIP: args.interleaveFormat = 1; break; case BIL: args.interleaveFormat = 2; break; } if (pArgs == NULL) { pArgs = &args; } bool success = true; switchOnComplexEncoding(pDesc->getDataType(), copySubcube, pData, pRaster, pArgs->rowStart, pArgs->rowEnd, pArgs->columnStart, pArgs->columnEnd, pArgs->bandStart, pArgs->bandEnd, true, success); if (!success) { setLastError(SIMPLE_OTHER_FAILURE); return 1; } setLastError(SIMPLE_NO_ERROR); return 0; }
bool PseudocolorLayerImp::getExtents(double& x1, double& y1, double& x4, double& y4) { RasterElement* pRasterElement = dynamic_cast<RasterElement*>(getDataElement()); VERIFY(pRasterElement != NULL); const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pRasterElement->getDataDescriptor()); VERIFY(pDescriptor != NULL); translateDataToWorld(0, 0, x1, y1); translateDataToWorld(pDescriptor->getColumnCount(), pDescriptor->getRowCount(), x4, y4); return true; }
void PropertiesRasterLayer::setDisplayBands(QAction* pAction) { if (mpRasterLayer == NULL) { return; } RasterElement* pRasterElement = dynamic_cast<RasterElement*>(mpRasterLayer->getDataElement()); if (pRasterElement == NULL) { return; } const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pRasterElement->getDataDescriptor()); if (pDescriptor == NULL) { return; } const std::string name = pAction->text().toStdString(); DimensionDescriptor redBand; DimensionDescriptor greenBand; DimensionDescriptor blueBand; if (RasterUtilities::findColorCompositeDimensionDescriptors( pDescriptor, name, redBand, greenBand, blueBand) == false) { Service<DesktopServices>()->showSuppressibleMsgDlg("Error", "Unable to display " + name + ": required wavelengths do not exist for all bands. " "Broaden the wavelength region or specify band numbers in the Raster Layers section of the Options dialog.", MESSAGE_ERROR, PropertiesRasterLayer::getDisplayAsWarningDialogId()); } // If at least one of red, green, or blue is valid set display mode to RGB and update the combo boxes appropriately if (redBand.isActiveNumberValid() || greenBand.isActiveNumberValid() || blueBand.isActiveNumberValid()) { mpDisplayModeCombo->setCurrentIndex(1); mpRedBandCombo->setCurrentIndex(redBand.isActiveNumberValid() ? redBand.getActiveNumber() : -1); mpGreenBandCombo->setCurrentIndex(greenBand.isActiveNumberValid() ? greenBand.getActiveNumber() : -1); mpBlueBandCombo->setCurrentIndex(blueBand.isActiveNumberValid() ? blueBand.getActiveNumber() : -1); } }
int setRasterLayerDisplayedBand(Layer* pLayer, uint32_t channel, uint32_t band, DataElement* pElement) { RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer); RasterChannelType chan(static_cast<RasterChannelTypeEnum>(channel)); if (pRaster == NULL || !chan.isValid()) { setLastError(SIMPLE_BAD_PARAMS); return 1; } RasterElement* pRasterElement = (pElement == NULL) ? pRaster->getDisplayedRasterElement(chan) : dynamic_cast<RasterElement*>(pElement); if (pRasterElement == NULL) { setLastError(SIMPLE_BAD_PARAMS); return 1; } DimensionDescriptor bandDD(static_cast<const RasterDataDescriptor*>( pRasterElement->getDataDescriptor())->getActiveBand(band)); pRaster->setDisplayedBand(chan, bandDD, pRasterElement); setLastError(SIMPLE_NO_ERROR); return 0; }
DataInfo* createDataInfo(DataElement* pElement) { RasterElement* pRasterElement = dynamic_cast<RasterElement*>(pElement); if (pRasterElement == NULL) { setLastError(SIMPLE_BAD_PARAMS); return NULL; } RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(pRasterElement->getDataDescriptor()); if (pDescriptor == NULL) { setLastError(SIMPLE_OTHER_FAILURE); return NULL; } DataInfo* pDataInfo = new DataInfo; pDataInfo->numRows = pDescriptor->getRowCount(); pDataInfo->numColumns = pDescriptor->getColumnCount(); pDataInfo->numBands = pDescriptor->getBandCount(); pDataInfo->encodingType = static_cast<uint32_t>(pDescriptor->getDataType()); pDataInfo->encodingTypeSize = RasterUtilities::bytesInEncoding(pDescriptor->getDataType()); pDataInfo->interleaveFormat = static_cast<uint32_t>(pDescriptor->getInterleaveFormat()); const std::vector<int>& badValues = pDescriptor->getBadValues(); pDataInfo->numBadValues = badValues.size(); if (pDataInfo->numBadValues == 0) { pDataInfo->pBadValues = NULL; } else { pDataInfo->pBadValues = new int32_t[pDataInfo->numBadValues]; memcpy(pDataInfo->pBadValues, &badValues[0], pDataInfo->numBadValues * sizeof(int32_t)); } setLastError(SIMPLE_NO_ERROR); return pDataInfo; }
bool TimelineWidget::saveAnimationTimes(Animation *pAnim) { if(pAnim == NULL) { return false; } bool success = false; const std::vector<AnimationFrame> frames = pAnim->getFrames(); std::vector<double> times(frames.size(), 0.0); for(unsigned int idx = 0; idx < frames.size(); idx++) { times[idx] = frames[idx].mTime; } std::vector<Window*> windows; Service<DesktopServices>()->getWindows(SPATIAL_DATA_WINDOW, windows); for(std::vector<Window*>::iterator window = windows.begin(); window != windows.end(); ++window) { SpatialDataView *pView = static_cast<SpatialDataWindow*>(*window)->getSpatialDataView(); std::vector<Layer*> layers; pView->getLayerList()->getLayers(RASTER, layers); for(std::vector<Layer*>::iterator layer = layers.begin(); layer != layers.end(); ++layer) { RasterLayer *pLayer = static_cast<RasterLayer*>(*layer); if(pLayer->getAnimation() == pAnim) { RasterElement *pElement = static_cast<RasterElement*>(pLayer->getDataElement()); DynamicObject *pMetadata = static_cast<RasterDataDescriptor*>(pElement->getDataDescriptor())->getMetadata(); if(pMetadata != NULL) { success = success || pMetadata->setAttributeByPath(FRAME_TIMES_METADATA_PATH, times); } } } } return success; }
QWidget* ResultsExporter::getExportOptionsWidget(const PlugInArgList *pInArgList) { const DataDescriptor* pDescriptor = NULL; if (pInArgList != NULL) { RasterElement* pElement = pInArgList->getPlugInArgValue<RasterElement>(Exporter::ExportItemArg()); if (pElement != NULL) { pDescriptor = pElement->getDataDescriptor(); } } if (mpOptionsWidget == NULL) { Service<DesktopServices> pDesktop; VERIFY(pDesktop.get() != NULL); mpOptionsWidget = new ResultsOptionsWidget(pDesktop->getMainWidget()); } if (mpOptionsWidget != NULL) { const string& name = pDescriptor->getName(); const string& type = pDescriptor->getType(); DataElement* pParent = pDescriptor->getParent(); RasterElement* pResults = dynamic_cast<RasterElement*>(mpModel->getElement(name, type, pParent)); if (pResults != NULL) { PassArea passArea = MIDDLE; double dFirstThreshold = 0.0; double dSecondThreshold = 0.0; SpatialDataWindow* pWindow = dynamic_cast<SpatialDataWindow*>(mpDesktop->getCurrentWorkspaceWindow()); if (pWindow != NULL) { SpatialDataView* pView = pWindow->getSpatialDataView(); if (pView != NULL) { LayerList* pLayerList = pView->getLayerList(); if (pLayerList != NULL) { ThresholdLayer* pThresholdLayer = static_cast<ThresholdLayer*>(pLayerList->getLayer(THRESHOLD, pResults)); if (pThresholdLayer != NULL) { passArea = pThresholdLayer->getPassArea(); dFirstThreshold = pThresholdLayer->getFirstThreshold(); dSecondThreshold = pThresholdLayer->getSecondThreshold(); } else { Statistics* pStatistics = pResults->getStatistics(); if (pStatistics != NULL) { dFirstThreshold = pStatistics->getMin(); dSecondThreshold = pStatistics->getMax(); } } } LatLonLayer* pLatLonLayer = static_cast<LatLonLayer*>(pView->getTopMostLayer(LAT_LONG)); if (pLatLonLayer != NULL) { GeocoordType geocoordType = pLatLonLayer->getGeocoordType(); mpOptionsWidget->setGeocoordType(geocoordType); } } } mpOptionsWidget->setPassArea(passArea); mpOptionsWidget->setFirstThreshold(dFirstThreshold); mpOptionsWidget->setSecondThreshold(dSecondThreshold); } } return mpOptionsWidget; }
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; }
void ChippingWindow::createView() { if (mpChippingWidget == NULL) { return; } RasterElement* pRaster = getRasterElement(); if (pRaster == NULL) { return; } // Create the new raster element from the primary element of the source. // Note that this does not chip displayed elements if they differ from the primary element. // This causes a special case below where the stretch values are being applied to the chipped layer. RasterElement* pRasterChip = pRaster->createChip(pRaster->getParent(), "_chip", mpChippingWidget->getChipRows(), mpChippingWidget->getChipColumns(), mpChippingWidget->getChipBands()); if (pRasterChip == NULL) { QMessageBox::critical(this, windowTitle(), "Unable to create a new cube!"); return; } const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pRasterChip->getDataDescriptor()); VERIFYNRV(pDescriptor != NULL); // Create a view for the new chip SpatialDataWindow* pWindow = dynamic_cast<SpatialDataWindow*>( Service<DesktopServices>()->createWindow(pRasterChip->getName(), SPATIAL_DATA_WINDOW)); if (pWindow == NULL) { return; } SpatialDataView* pView = pWindow->getSpatialDataView(); if (pView == NULL) { Service<DesktopServices>()->deleteWindow(pWindow); return; } UndoLock lock(pView); if (pView->setPrimaryRasterElement(pRasterChip) == false) { Service<DesktopServices>()->deleteWindow(pWindow); return; } // RasterLayerImp is needed for the call to setCurrentStretchAsOriginalStretch(). RasterLayerImp* pLayer = dynamic_cast<RasterLayerImp*>(pView->createLayer(RASTER, pRasterChip)); if (pLayer == NULL) { Service<DesktopServices>()->deleteWindow(pWindow); return; } string origName = pRaster->getName(); SpatialDataWindow* pOrigWindow = dynamic_cast<SpatialDataWindow*>( Service<DesktopServices>()->getWindow(origName, SPATIAL_DATA_WINDOW)); if (pOrigWindow != NULL) { SpatialDataView* pOrigView = pOrigWindow->getSpatialDataView(); if (pOrigView != NULL) { LayerList* pLayerList = pOrigView->getLayerList(); if (pLayerList != NULL) { RasterLayer* pOrigLayer = static_cast<RasterLayer*>(pLayerList->getLayer(RASTER, pRaster)); if (pOrigLayer != NULL) { // Set the stretch type first so that stretch values are interpreted correctly. pLayer->setStretchType(GRAYSCALE_MODE, pOrigLayer->getStretchType(GRAYSCALE_MODE)); pLayer->setStretchType(RGB_MODE, pOrigLayer->getStretchType(RGB_MODE)); pLayer->setDisplayMode(pOrigLayer->getDisplayMode()); // Set the properties of the cube layer in the new view. // For each channel, display the first band if the previously displayed band was chipped. vector<RasterChannelType> channels = StringUtilities::getAllEnumValues<RasterChannelType>(); for (vector<RasterChannelType>::const_iterator iter = channels.begin(); iter != channels.end(); ++iter) { bool bandCopied = true; DimensionDescriptor newBand; DimensionDescriptor oldBand = pOrigLayer->getDisplayedBand(*iter); if (oldBand.isOriginalNumberValid() == true) { newBand = pDescriptor->getOriginalBand(oldBand.getOriginalNumber()); } if (newBand.isValid() == false) { bandCopied = false; newBand = pDescriptor->getBands().front(); } // No need to explicitly set the RasterElement here since the new view only has one RasterElement. pLayer->setDisplayedBand(*iter, newBand); // Use the default stretch properties if the displayed band was removed from the view or // if the non-primary raster element was displayed. Otherwise, copy the stretch properties. if (bandCopied && pRaster == pOrigLayer->getDisplayedRasterElement(*iter)) { // Set the stretch units first so that stretch values are interpreted correctly. pLayer->setStretchUnits(*iter, pOrigLayer->getStretchUnits(*iter)); double lower; double upper; pOrigLayer->getStretchValues(*iter, lower, upper); pLayer->setStretchValues(*iter, lower, upper); } } pLayer->setCurrentStretchAsOriginalStretch(); pView->refresh(); } } } } // Create a GCP layer if (pRaster->isGeoreferenced() == true) { const vector<DimensionDescriptor>& rows = mpChippingWidget->getChipRows(); const vector<DimensionDescriptor>& columns = mpChippingWidget->getChipColumns(); 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 = pRaster->convertPixelToGeocoord(ulPoint.mPixel); GcpPoint urPoint; urPoint.mPixel = LocationType(endCol, startRow); urPoint.mCoordinate = pRaster->convertPixelToGeocoord(urPoint.mPixel); GcpPoint llPoint; llPoint.mPixel = LocationType(startCol, endRow); llPoint.mCoordinate = pRaster->convertPixelToGeocoord(llPoint.mPixel); GcpPoint lrPoint; lrPoint.mPixel = LocationType(endCol, endRow); lrPoint.mCoordinate = pRaster->convertPixelToGeocoord(lrPoint.mPixel); GcpPoint centerPoint; centerPoint.mPixel = LocationType((startCol + endCol) / 2, (startRow + endRow) / 2); centerPoint.mCoordinate = pRaster->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); // Create the GCP list Service<ModelServices> pModel; GcpList* pGcpList = static_cast<GcpList*>(pModel->createElement("Corner Coordinates", TypeConverter::toString<GcpList>(), pRasterChip)); 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); // Create the layer if (pView->createLayer(GCP_LAYER, pGcpList) == NULL) { QMessageBox::warning(this, windowTitle(), "Could not create a GCP layer."); } } else { QMessageBox::warning(this, windowTitle(), "Could not create a GCP list."); } } } }
ExportOptionsDlg::ExportOptionsDlg(ExporterResource& pExporter, QWidget* pParent) : QDialog(pParent), mpExporter(pExporter), mpTabWidget(NULL), mpSubsetPage(NULL), mpExporterPage(NULL) { // Options widget QStackedWidget* pStack = new QStackedWidget(this); // Subset page RasterElement* pRasterElement = dynamic_cast<RasterElement*>(mpExporter->getItem()); RasterFileDescriptor* pRasterWholeCubeFileDescriptor = NULL; RasterDataDescriptor* pRasterOrgDataDescriptor = NULL; if (pRasterElement != NULL) { pRasterOrgDataDescriptor = dynamic_cast<RasterDataDescriptor*>(pRasterElement->getDataDescriptor()); if (pRasterOrgDataDescriptor != NULL) { // we are creating a file descriptor for export from the original cube, because the SubsetWidget // uses DimensionDescriptor::operator= compare's to determine selection which dictate that on-disk, // original and active numbers need to be identical, this guarantees that DimensionDescriptors will // compare correctly. pRasterWholeCubeFileDescriptor = dynamic_cast<RasterFileDescriptor*>( RasterUtilities::generateFileDescriptorForExport(pRasterOrgDataDescriptor, "foobar")); } } RasterFileDescriptor* pRasterFileDescriptor = dynamic_cast<RasterFileDescriptor*>(mpExporter->getFileDescriptor()); if ((pRasterFileDescriptor != NULL) && (pRasterWholeCubeFileDescriptor != NULL) && (pRasterOrgDataDescriptor != NULL)) { mpSubsetPage = new SubsetWidget(); mpSubsetPage->setExportMode(true); // Rows const vector<DimensionDescriptor>& orgRows = pRasterWholeCubeFileDescriptor->getRows(); const vector<DimensionDescriptor>& selectedRows = pRasterFileDescriptor->getRows(); mpSubsetPage->setRows(orgRows, selectedRows); // Columns const vector<DimensionDescriptor>& orgColumns = pRasterWholeCubeFileDescriptor->getColumns(); const vector<DimensionDescriptor>& selectedColumns = pRasterFileDescriptor->getColumns(); mpSubsetPage->setColumns(orgColumns, selectedColumns); // Bands const vector<DimensionDescriptor>& orgBands = pRasterWholeCubeFileDescriptor->getBands(); const vector<DimensionDescriptor>& selectedBands = pRasterFileDescriptor->getBands(); vector<string> bandNames = RasterUtilities::getBandNames(pRasterOrgDataDescriptor); mpSubsetPage->setBands(orgBands, bandNames, selectedBands); // Initial bad band file directory QString strDirectory; string filename = pRasterFileDescriptor->getFilename(); if (filename.empty() == false) { QFileInfo fileInfo(QString::fromStdString(filename)); strDirectory = fileInfo.absolutePath(); } mpSubsetPage->setBadBandFileDirectory(strDirectory); } // Exporter page if (mpExporter->getPlugIn() != NULL) { mpExporterPage = mpExporter->getExportOptionsWidget(); } // Horizontal line QFrame* pLine = new QFrame(this); pLine->setFrameStyle(QFrame::HLine | QFrame::Sunken); // Buttons QDialogButtonBox* pButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this); // Layout QVBoxLayout* pLayout = new QVBoxLayout(this); pLayout->setMargin(10); pLayout->setSpacing(10); pLayout->addWidget(pStack, 10); pLayout->addWidget(pLine); pLayout->addWidget(pButtonBox); // Initialization QString strWindowTitle = "Export Options"; SessionItem* pSessionItem = mpExporter->getItem(); if (pSessionItem != NULL) { string name = pSessionItem->getDisplayName(); if (name.empty() == true) { name = pSessionItem->getName(); } if (name.empty() == false) { strWindowTitle += ": " + QString::fromStdString(name); } } setWindowTitle(strWindowTitle); setModal(true); if ((mpSubsetPage != NULL) || (mpExporterPage != NULL)) { QWidget* pSubsetWidget = NULL; if (mpSubsetPage != NULL) { pSubsetWidget = new QWidget(); mpSubsetPage->setParent(pSubsetWidget); QVBoxLayout* pSubsetLayout = new QVBoxLayout(pSubsetWidget); if (mpExporterPage != NULL) { pSubsetLayout->setMargin(10); } else { pSubsetLayout->setMargin(0); } pSubsetLayout->setSpacing(10); pSubsetLayout->addWidget(mpSubsetPage); } QWidget* pExporterWidget = NULL; if (mpExporterPage != NULL) { pExporterWidget = new QWidget(); mpExporterPage->setParent(pExporterWidget); QVBoxLayout* pExporterLayout = new QVBoxLayout(pExporterWidget); if (mpSubsetPage != NULL) { pExporterLayout->setMargin(10); } else { pExporterLayout->setMargin(0); } pExporterLayout->setSpacing(10); pExporterLayout->addWidget(mpExporterPage); } if ((pSubsetWidget != NULL) && (pExporterWidget != NULL)) { QString strExporterCaption = mpExporterPage->windowTitle(); if (strExporterCaption.isEmpty() == true) { PlugIn* pPlugIn = mpExporter->getPlugIn(); if (pPlugIn != NULL) { strExporterCaption = QString::fromStdString(pPlugIn->getName()); } if (strExporterCaption.isEmpty() == true) { strExporterCaption = "Exporter"; } } mpTabWidget = new QTabWidget(this); mpTabWidget->setTabPosition(QTabWidget::North); mpTabWidget->addTab(pSubsetWidget, "Subset"); mpTabWidget->addTab(pExporterWidget, strExporterCaption); pStack->addWidget(mpTabWidget); } else if (pSubsetWidget != NULL) { pStack->addWidget(pSubsetWidget); pButtonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel); } else if (pExporterWidget != NULL) { pStack->addWidget(pExporterWidget); } } if (pStack->count() == 0) { QLabel* pNoOptionsLabel = new QLabel("No options are available", this); pNoOptionsLabel->setAlignment(Qt::AlignCenter); pNoOptionsLabel->setMinimumSize(250, 100); pStack->addWidget(pNoOptionsLabel); } // Connections VERIFYNR(connect(pButtonBox, SIGNAL(accepted()), this, SLOT(accept()))); VERIFYNR(connect(pButtonBox, SIGNAL(rejected()), this, SLOT(reject()))); }
bool Kml::addLayer(Layer* pLayer, const Layer* pGeoLayer, const SpatialDataView* pView, int totalLayers) { if (pLayer == NULL) { return false; } switch (pLayer->getLayerType()) { case ANNOTATION: case AOI_LAYER: case GRAPHIC_LAYER: // These are polygonal layers generatePolygonalLayer(dynamic_cast<GraphicLayer*>(pLayer), pView->isLayerDisplayed(pLayer), totalLayers - pView->getLayerDisplayIndex(pLayer), pGeoLayer); break; case RASTER: { RasterLayer* pRasterLayer = dynamic_cast<RasterLayer*>(pLayer); RasterElement* pRasterElement = pRasterLayer->getDisplayedRasterElement(GRAY); if (pRasterElement != NULL) { bool layerIsDisplayed = pView->isLayerDisplayed(pLayer); int order = totalLayers - pView->getLayerDisplayIndex(pLayer) - 1; if (pView->getAnimationController() == NULL) { generateGroundOverlayLayer(pLayer, layerIsDisplayed, order, pGeoLayer, -1); } else { mXml.pushAddPoint(mXml.addElement("Folder")); mXml.addText("Frame Data", mXml.addElement("name")); vector<DimensionDescriptor> frames = static_cast<RasterDataDescriptor*>(pRasterElement->getDataDescriptor())->getBands(); for (vector<DimensionDescriptor>::const_iterator frame = frames.begin(); frame != frames.end(); ++frame) { generateGroundOverlayLayer(pLayer, layerIsDisplayed, order, pGeoLayer, frame->getActiveNumber()); } mXml.popAddPoint(); } break; } // fall through...if there is no displayed raster element, export the flattened layer } case PSEUDOCOLOR: case THRESHOLD: // These are image layers generateGroundOverlayLayer(pLayer, pView->isLayerDisplayed(pLayer), totalLayers - pView->getLayerDisplayIndex(pLayer), pGeoLayer); break; case CONTOUR_MAP: case LAT_LONG: case TIEPOINT_LAYER: default: // These are unsupported layers if (mpProgress != NULL) { mpProgress->updateProgress("Unable to export unsupported layer " + pLayer->getName(), 0, WARNING); } return false; } return true; }
void ChippingWindow::createFile() { if (mpChippingWidget == NULL) { return; } RasterElement* pRaster = getRasterElement(); if (pRaster == NULL) { return; } const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pRaster->getDataDescriptor()); if (pDescriptor == NULL) { return; } // Rows const vector<DimensionDescriptor>& rows = mpChippingWidget->getChipRows(); const DimensionDescriptor startRow = rows.front(); const DimensionDescriptor stopRow = rows.back(); // Columns const vector<DimensionDescriptor>& columns = mpChippingWidget->getChipColumns(); const DimensionDescriptor startCol = columns.front(); const DimensionDescriptor stopCol = columns.back(); // Create a file descriptor based on the data with the chip rows and columns FactoryResource<FileDescriptor> fileDescriptor(RasterUtilities::generateFileDescriptorForExport(pDescriptor, string(), startRow, stopRow, 0, startCol, stopCol, 0, mpChippingWidget->getChipBands())); Service<DesktopServices>()->exportSessionItem(pRaster, fileDescriptor.get()); }
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 ImageHandler::getSessionItemImage(SessionItem* pItem, QBuffer& buffer, const QString& format, int band, int* pBbox) { if (format.isEmpty()) { return false; } bool success = true; QImage image; Layer* pLayer = dynamic_cast<Layer*>(pItem); View* pView = dynamic_cast<View*>(pItem); if (pLayer != NULL) { SpatialDataView* pSDView = dynamic_cast<SpatialDataView*>(pLayer->getView()); if (pSDView != NULL) { UndoLock ulock(pSDView); DimensionDescriptor cur; DisplayMode mode; RasterLayer* pRasterLayer = dynamic_cast<RasterLayer*>(pLayer); if (band >= 0 && pRasterLayer != NULL) { RasterElement* pRaster = pRasterLayer->getDisplayedRasterElement(GRAY); DimensionDescriptor bandDesc = static_cast<RasterDataDescriptor*>(pRaster->getDataDescriptor())->getActiveBand(band); cur = pRasterLayer->getDisplayedBand(GRAY); mode = pRasterLayer->getDisplayMode(); pRasterLayer->setDisplayedBand(GRAY, bandDesc); pRasterLayer->setDisplayMode(GRAYSCALE_MODE); } int bbox[4] = {0, 0, 0, 0}; ColorType transparent(255, 255, 254); success = pSDView->getLayerImage(pLayer, image, transparent, bbox); if (pBbox != NULL) { memcpy(pBbox, bbox, sizeof(bbox)); } QImage alphaChannel(image.size(), QImage::Format_Indexed8); if (image.hasAlphaChannel()) { alphaChannel = image.alphaChannel(); } else { alphaChannel.fill(0xff); } QRgb transColor = COLORTYPE_TO_QCOLOR(transparent).rgb(); for (int y = 0; y < image.height(); y++) { for (int x = 0; x < image.width(); x++) { if (image.pixel(x, y) == transColor) { alphaChannel.setPixel(x, y, 0x00); } } } image.setAlphaChannel(alphaChannel); if (mode.isValid()) { pRasterLayer->setDisplayedBand(GRAY, cur); pRasterLayer->setDisplayMode(mode); } } } else if (pView != NULL) { success = pView->getCurrentImage(image); } else { success = false; } if (success) { buffer.open(QIODevice::WriteOnly); QImageWriter writer(&buffer, format.toAscii()); success = writer.write(image); } return success; }
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* createDataPointer(DataElement* pElement, DataPointerArgs* pArgs, int* pOwn) { RasterElement* pRaster = dynamic_cast<RasterElement*>(pElement); if (pRaster == NULL || pOwn == NULL) { setLastError(SIMPLE_BAD_PARAMS); return NULL; } void* pRawData = pRaster->getRawData(); if (pArgs == NULL && pRawData != NULL) { *pOwn = 0; setLastError(SIMPLE_NO_ERROR); return pRawData; } *pOwn = 1; const RasterDataDescriptor* pDesc = static_cast<const RasterDataDescriptor*>(pRaster->getDataDescriptor()); DataPointerArgs args = { 0, pDesc->getRowCount() - 1, 0, pDesc->getColumnCount() - 1, 0, pDesc->getBandCount() - 1, 0 }; switch (pDesc->getInterleaveFormat()) { case BSQ: args.interleaveFormat = 0; break; case BIP: args.interleaveFormat = 1; break; case BIL: args.interleaveFormat = 2; break; } if (pArgs == NULL) { pArgs = &args; } unsigned int rowCount = pArgs->rowEnd - pArgs->rowStart + 1; unsigned int columnCount = pArgs->columnEnd - pArgs->columnStart + 1; unsigned int bandCount = pArgs->bandEnd - pArgs->bandStart + 1; pRawData = new (std::nothrow) char[rowCount * columnCount * bandCount * pDesc->getBytesPerElement()]; if (pRawData == NULL) { setLastError(SIMPLE_NO_MEM); return NULL; } bool success = true; switchOnComplexEncoding(pDesc->getDataType(), copySubcube, pRawData, pRaster, pArgs->rowStart, pArgs->rowEnd, pArgs->columnStart, pArgs->columnEnd, pArgs->bandStart, pArgs->bandEnd, false, success); if (!success) { delete [] pRawData; setLastError(SIMPLE_OTHER_FAILURE); return NULL; } setLastError(SIMPLE_NO_ERROR); return pRawData; }
bool IceImporterShell::performImport() const { Progress* pProgress = getProgress(); if (Hdf5ImporterShell::performImport() == false) { if (pProgress != NULL) { pProgress->updateProgress("Unable to perform import.", 100, ERRORS); } return false; } hid_t fileHandle = -1; Hdf5FileResource fileResource; if (getFileHandle(fileHandle, fileResource) == false) { if (pProgress != NULL) { pProgress->updateProgress("Unable to get the file handle.", 100, ERRORS); } return NULL; } RasterElement* pElement = getRasterElement(); if (pElement == NULL) { if (pProgress != NULL) { pProgress->updateProgress("Unable to get the RasterElement.", 100, ERRORS); } return false; } Hdf5File file(pElement->getFilename(), fileHandle); if (file.readFileData() == false) { if (pProgress != NULL) { pProgress->updateProgress("Unable to read statistics from file.", 100, WARNING); } } else { const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pElement->getDataDescriptor()); IceReader reader(file); if (pDescriptor != NULL && RasterUtilities::isSubcube(pDescriptor, false) == false && Service<SessionManager>()->isSessionLoading() == false) { if (reader.loadCubeStatistics(pElement) == false) { if (pProgress != NULL) { pProgress->updateProgress("Unable to load statistics.", 100, WARNING); } } } } return true; }
bool bilinear_bayer::execute(PlugInArgList * pInArgList, PlugInArgList * pOutArgList) { StepResource pStep("bilinear_bayer", "pratik", "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()); // pCube 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; } pProgress->updateProgress("Starting calculations", 10, NORMAL); RasterDataDescriptor *pDesc = static_cast < RasterDataDescriptor * >(pCube->getDataDescriptor()); VERIFY(pDesc != NULL); std::string msg = "De-bayerize by bilinear interpolation \n"; pProgress->updateProgress(msg, 20, NORMAL); // show initial R,G and B // values RasterElement *dRas = RasterUtilities::createRasterElement(pCube->getName() + "RGB", pDesc->getRowCount(), pDesc->getColumnCount(), 3, pDesc->getDataType(), BSQ); // request pProgress->updateProgress(msg, 50, NORMAL); copyImage(pCube, dRas, 0, pProgress); pProgress->updateProgress(msg + "RED complete", 60, NORMAL); copyImage(pCube, dRas, 1, pProgress); pProgress->updateProgress(msg + "GREEN complete", 70, NORMAL); copyImage(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); pProgress->updateProgress("Final", 100, NORMAL); // create window 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()); } pOutArgList->setPlugInArgValue("bilinear_bayer_Result", pResultCube.release()); // for // saving // data pStep->finalize(); return true; }
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 RasterTimingTest::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList) { if (isBatch()) { VERIFY(pOutArgList != NULL); } Service<DesktopServices> pDesktop; SpatialDataView* pView = dynamic_cast<SpatialDataView*>(pDesktop->getCurrentWorkspaceWindowView()); if (pView) { UndoLock lock(pView); RasterElement* pElement = pView->getLayerList()->getPrimaryRasterElement(); RasterDataDescriptor* pDesc = dynamic_cast<RasterDataDescriptor*>(pElement->getDataDescriptor()); int bands = pDesc->getBandCount(); int frameNumber = 0; RasterLayer* pLayer = NULL; vector<Layer*> layers; pView->getLayerList()->getLayers(RASTER, layers); for (vector<Layer*>::iterator iter = layers.begin(); iter != layers.end(); ++iter) { RasterLayer* pRasterLayer = static_cast<RasterLayer*>(*iter); if (pRasterLayer != NULL) { RasterElement* pCurrentRasterElement = dynamic_cast<RasterElement*>(pRasterLayer->getDataElement()); if (pCurrentRasterElement == pElement) { pLayer = pRasterLayer; break; } } } for (int i = 0; i < bands; ++i) { pElement->getStatistics(pDesc->getActiveBand(i))->getMin(); } // set grayscale display mode DisplayMode initialDisplayMode = pLayer->getDisplayMode(); pLayer->setDisplayMode(GRAYSCALE_MODE); const int frameiterations = 10000; clock_t startTime = clock(); QWidget* pWidget = pView->getWidget(); int i = 0; for (i = 0; i < frameiterations; ++i, ++frameNumber) { if (frameNumber >= bands) { frameNumber = 0; } pLayer->setDisplayedBand(GRAY, pDesc->getActiveBand(frameNumber)); if (pWidget) { pWidget->repaint(); } if ((i + 1) % (frameiterations / 100) == 0) { QString message = QString("Frame ") + QString::number(i+1) + QString(" of ") + QString::number(frameiterations); pDesktop->setStatusBarMessage(message.toStdString()); } if ((i + 1) % 20 == 0) { clock_t stopTime = clock(); double elapsedTime = static_cast<double>(stopTime - startTime) / CLOCKS_PER_SEC; if (elapsedTime > 30) { ++i; break; } } } clock_t stopTime = clock(); double framesPerSec = i / (static_cast<double>(stopTime - startTime) / CLOCKS_PER_SEC); // restore display mode pLayer->setDisplayMode(initialDisplayMode); if (isBatch()) { pOutArgList->setPlugInArgValue<double>("Framerate", &framesPerSec); } else { QMessageBox::information(pDesktop->getMainWidget(), "Frame Rate", QString("The number of frames per second was: %1\nGPU Acceleration was%2 enabled\n").arg(framesPerSec) .arg(pLayer->isGpuImageEnabled() ? "" : " not")); } return true; } return false; }
bool AceAlgorithm::processAll() { auto_ptr<Wavelengths> pWavelengths; ProgressTracker progress(getProgress(), "Starting Ace", "spectral", "C4320027-6359-4F5B-8820-8BC72BF1B8F0"); RasterElement* pElement = getRasterElement(); if (pElement == NULL) { progress.report(ACEERR012, 0, ERRORS, true); return false; } 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(ACEERR005, 0, ERRORS, true); return false; } int iSignatureCount = mInputs.mSignatures.size(); // Create a vector for the signature names vector<string> sigNames; RasterElement* pResults = NULL; bool resultsIsTemp = false; Signature* pSignature = mInputs.mSignatures[sig_index]; sigNames.push_back(pSignature->getName()); std::string rname = mInputs.mResultsName; if (iSignatureCount > 1 && !mInputs.mbCreatePseudocolor) { rname += " " + sigNames.back(); } else if (iSignatureCount > 1) { rname += "AceTemp"; resultsIsTemp = true; } pResults = createResults(numRows, numColumns, rname); if (pResults == NULL) { return false; } 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 AceAlg014: 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); } BitMaskIterator iterChecker(getPixelsToProcess(), pElement); EncodingType type = pDescriptor->getDataType(); switchOnEncoding(type, aceAlg, NULL, pElement, pResults, spectrumValues, mpProgress); ///////////////////////////////////////////////////// vector<ColorType> layerColors, excludeColors; excludeColors.push_back(ColorType(0, 0, 0)); excludeColors.push_back(ColorType(255, 255, 255)); ColorType::getUniqueColors(iSignatureCount, layerColors, excludeColors); ColorType color; if (0 <= static_cast<int>(layerColors.size())) { color = layerColors[0]; } double dMaxValue = pResults->getStatistics()->getMax(); // Displays results for current signature displayThresholdResults(pResults, color, UPPER, mInputs.mThreshold, dMaxValue, layerOffset); // displayThresholdResults(pResults, color, UPPER, 0.6, dMaxValue, layerOffset); ////////////////////////////////////////////////////// /* Service<DesktopServices> pDesktop; SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(rname, SPATIAL_DATA_WINDOW)); SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView(); if (pView == NULL) { std::string msg = "Unable to create view."; progress.report(msg, 0, ERRORS, true); return false; } pView->setPrimaryRasterElement(pResults); pView->createLayer(RASTER, pResults); */ return true; }
DataElement* createRasterElement(const char* pName, RasterElementArgs args) { if (pName == NULL || args.location > 2) { setLastError(SIMPLE_BAD_PARAMS); return NULL; } // Check for an existing element with the name if (getDataElement(pName, TypeConverter::toString<RasterElement>(), 0) != NULL) { setLastError(SIMPLE_EXISTS); return NULL; } RasterElement* pElement = RasterUtilities::createRasterElement(std::string(pName), args.numRows, args.numColumns, args.numBands, static_cast<EncodingTypeEnum>(args.encodingType), static_cast<InterleaveFormatTypeEnum>(args.interleaveFormat), args.location != 2, args.pParent); if (pElement == NULL) { switch (args.location) { case 0: pElement = RasterUtilities::createRasterElement(std::string(pName), args.numRows, args.numColumns, args.numBands, static_cast<EncodingTypeEnum>(args.encodingType), static_cast<InterleaveFormatTypeEnum>(args.interleaveFormat), false, args.pParent); if (pElement == NULL) { setLastError(SIMPLE_OTHER_FAILURE); return NULL; } break; case 1: setLastError(SIMPLE_NO_MEM); return NULL; case 2: setLastError(SIMPLE_OTHER_FAILURE); return NULL; default: setLastError(SIMPLE_BAD_PARAMS); return NULL; } } if (args.pBadValues != NULL && args.numBadValues > 0) { RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pElement->getDataDescriptor()); if (pDesc != NULL) { std::vector<int> badValues; badValues.reserve(args.numBadValues); for (uint32_t idx = 0; idx < args.numBadValues; ++idx) { badValues.push_back(args.pBadValues[idx]); } pDesc->setBadValues(badValues); // set on the statistics objects const std::vector<DimensionDescriptor>& allBands = pDesc->getBands(); for (std::vector<DimensionDescriptor>::const_iterator band = allBands.begin(); band != allBands.end(); ++band) { if (band->isValid()) { Statistics* pStats = pElement->getStatistics(*band); if (pStats != NULL) { pStats->setBadValues(badValues); } } } pElement->updateData(); } } setLastError(SIMPLE_NO_ERROR); return pElement; }
bool 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 PropertiesRasterLayer::initialize(SessionItem* pSessionItem) { mpRasterLayer = dynamic_cast<RasterLayer*>(pSessionItem); if (mpRasterLayer == NULL) { return false; } mInitializing = true; // Populate the raster element combos with raster elements of the same size as the layer element mRasterElements.clear(); QStringList elementNames; RasterElement* pRasterElement = dynamic_cast<RasterElement*>(mpRasterLayer->getDataElement()); if (pRasterElement != NULL) { const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pRasterElement->getDataDescriptor()); if (pDescriptor != NULL) { unsigned int rows = pDescriptor->getRowCount(); unsigned int columns = pDescriptor->getColumnCount(); Service<ModelServices> pModel; vector<DataElement*> rasterElements = pModel->getElements("RasterElement"); for (unsigned int i = 0; i < rasterElements.size(); ++i) { RasterElement* pCurrentRasterElement = dynamic_cast<RasterElement*>(rasterElements[i]); if (pCurrentRasterElement != NULL) { unsigned int currentRows = 0; unsigned int currentColumns = 0; const RasterDataDescriptor* pCurrentDescriptor = dynamic_cast<const RasterDataDescriptor*>(pCurrentRasterElement->getDataDescriptor()); if (pCurrentDescriptor != NULL) { currentRows = pCurrentDescriptor->getRowCount(); currentColumns = pCurrentDescriptor->getColumnCount(); } if ((currentRows == rows) && (currentColumns == columns)) { mRasterElements.push_back(pCurrentRasterElement); string displayName = pCurrentRasterElement->getDisplayName(); if (displayName.empty() == true) { displayName = pCurrentRasterElement->getName(); } if (displayName.empty() == false) { elementNames.append(QString::fromStdString(displayName)); } } } } } } mpGrayElementCombo->clear(); mpGrayElementCombo->addItems(elementNames); mpRedElementCombo->clear(); mpRedElementCombo->addItems(elementNames); mpGreenElementCombo->clear(); mpGreenElementCombo->addItems(elementNames); mpBlueElementCombo->clear(); mpBlueElementCombo->addItems(elementNames); // Display configuration DisplayMode displayMode = mpRasterLayer->getDisplayMode(); if (displayMode == GRAYSCALE_MODE) { mpDisplayModeCombo->setCurrentIndex(0); } else if (displayMode == RGB_MODE) { mpDisplayModeCombo->setCurrentIndex(1); } mpComplexComponentCombo->setCurrentValue(mpRasterLayer->getComplexComponent()); mpOpacitySpin->setValue(static_cast<int>(mpRasterLayer->getAlpha())); // Grayscale int grayIndex = getElementIndex(mpRasterLayer->getDisplayedRasterElement(GRAY)); mpGrayElementCombo->setCurrentIndex(grayIndex); double dGrayLower = 0.0; double dGrayUpper = 0.0; mpRasterLayer->getStretchValues(GRAY, dGrayLower, dGrayUpper); mpGrayLowerSpin->setValue(dGrayLower); mpGrayUpperSpin->setValue(dGrayUpper); mGrayUnits = mpRasterLayer->getStretchUnits(GRAY); mpGrayUnitsCombo->setCurrentValue(mGrayUnits); mpGrayStretchTypeCombo->setCurrentValue(mpRasterLayer->getStretchType(GRAYSCALE_MODE)); // RGB int redIndex = getElementIndex(mpRasterLayer->getDisplayedRasterElement(RED)); mpRedElementCombo->setCurrentIndex(redIndex); int greenIndex = getElementIndex(mpRasterLayer->getDisplayedRasterElement(GREEN)); mpGreenElementCombo->setCurrentIndex(greenIndex); int blueIndex = getElementIndex(mpRasterLayer->getDisplayedRasterElement(BLUE)); mpBlueElementCombo->setCurrentIndex(blueIndex); double dRedLower = 0.0; double dRedUpper = 0.0; double dGreenLower = 0.0; double dGreenUpper = 0.0; double dBlueLower = 0.0; double dBlueUpper = 0.0; mpRasterLayer->getStretchValues(RED, dRedLower, dRedUpper); mpRasterLayer->getStretchValues(GREEN, dGreenLower, dGreenUpper); mpRasterLayer->getStretchValues(BLUE, dBlueLower, dBlueUpper); mpRedLowerSpin->setValue(dRedLower); mpRedUpperSpin->setValue(dRedUpper); mpGreenLowerSpin->setValue(dGreenLower); mpGreenUpperSpin->setValue(dGreenUpper); mpBlueLowerSpin->setValue(dBlueLower); mpBlueUpperSpin->setValue(dBlueUpper); mRedUnits = mpRasterLayer->getStretchUnits(RED); mGreenUnits = mpRasterLayer->getStretchUnits(GREEN); mBlueUnits = mpRasterLayer->getStretchUnits(BLUE); mpRedUnitsCombo->setCurrentValue(mRedUnits); mpGreenUnitsCombo->setCurrentValue(mGreenUnits); mpBlueUnitsCombo->setCurrentValue(mBlueUnits); mpRgbStretchTypeCombo->setCurrentValue(mpRasterLayer->getStretchType(RGB_MODE)); // Graphics acceleration mpAccelerationCheck->setChecked(mpRasterLayer->isGpuImageEnabled()); mpFilterCheck->setEnabled(mpRasterLayer->isGpuImageEnabled()); mpFilterList->setEnabled(false); mpFilterList->clearSelection(); if (mpFilterCheck->isEnabled()) { vector<string> filters = mpRasterLayer->getEnabledFilterNames(); mpFilterCheck->setChecked(!(filters.empty())); mpFilterList->setEnabled(!(filters.empty())); for (vector<string>::iterator iter = filters.begin(); iter != filters.end(); ++iter) { QString filterName = QString::fromStdString(*iter); if (filterName.isEmpty() == false) { QList<QListWidgetItem*> filterItems = mpFilterList->findItems(filterName, Qt::MatchExactly); for (int i = 0; i < filterItems.count(); ++i) { QListWidgetItem* pItem = filterItems[i]; if (pItem != NULL) { pItem->setSelected(true); } } } } } resetModifiers(); mInitializing = false; return true; }
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 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; }
void PropertiesRasterLayer::updateDisplayedBandCombo(int index) { // Get the selected raster element RasterElement* pElement = NULL; if ((index > -1) && (static_cast<int>(mRasterElements.size()) > index)) { pElement = mRasterElements[index]; } // Get the band names from the element QStringList strBandNames; if (pElement != NULL) { RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(pElement->getDataDescriptor()); if (pDescriptor != NULL) { vector<string> bandNames = RasterUtilities::getBandNames(pDescriptor); for (vector<string>::iterator iter = bandNames.begin(); iter != bandNames.end(); ++iter) { strBandNames.append(QString::fromStdString(*iter)); } } } // Update the display band combo QComboBox* pCombo = dynamic_cast<QComboBox*>(sender()); if (pCombo == mpGrayElementCombo) { mpGrayBandCombo->clear(); mpGrayBandCombo->addItems(strBandNames); if (strBandNames.isEmpty() == false) { mpGrayBandCombo->setCurrentIndex(0); if ((mpRasterLayer != NULL) && (mpRasterLayer->getDataElement() == pElement)) { DimensionDescriptor displayedBand = mpRasterLayer->getDisplayedBand(GRAY); if (displayedBand.isActiveNumberValid() == true) { mpGrayBandCombo->setCurrentIndex(displayedBand.getActiveNumber()); } } } } else if (pCombo == mpRedElementCombo) { mpRedBandCombo->clear(); mpRedBandCombo->addItems(strBandNames); if (strBandNames.isEmpty() == false) { mpRedBandCombo->setCurrentIndex(0); if ((mpRasterLayer != NULL) && (mpRasterLayer->getDataElement() == pElement)) { DimensionDescriptor displayedBand = mpRasterLayer->getDisplayedBand(RED); if (displayedBand.isActiveNumberValid() == true) { mpRedBandCombo->setCurrentIndex(displayedBand.getActiveNumber()); } } } } else if (pCombo == mpGreenElementCombo) { mpGreenBandCombo->clear(); mpGreenBandCombo->addItems(strBandNames); if (strBandNames.isEmpty() == false) { mpGreenBandCombo->setCurrentIndex(0); if ((mpRasterLayer != NULL) && (mpRasterLayer->getDataElement() == pElement)) { DimensionDescriptor displayedBand = mpRasterLayer->getDisplayedBand(GREEN); if (displayedBand.isActiveNumberValid() == true) { mpGreenBandCombo->setCurrentIndex(displayedBand.getActiveNumber()); } } } } else if (pCombo == mpBlueElementCombo) { mpBlueBandCombo->clear(); mpBlueBandCombo->addItems(strBandNames); if (strBandNames.isEmpty() == false) { mpBlueBandCombo->setCurrentIndex(0); if ((mpRasterLayer != NULL) && (mpRasterLayer->getDataElement() == pElement)) { DimensionDescriptor displayedBand = mpRasterLayer->getDisplayedBand(BLUE); if (displayedBand.isActiveNumberValid() == true) { mpBlueBandCombo->setCurrentIndex(displayedBand.getActiveNumber()); } } } } }