uint32_t getRasterLayerFilterName(Layer* pLayer, uint32_t index, int enabled, char* pName, uint32_t nameSize)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL || pName == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
std::vector<std::string> filters =
(enabled != 0) ? pRaster->getEnabledFilterNames() : pRaster->getSupportedFilters();
if (index >= filters.size())
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
std::string name = filters[index];
if (nameSize == 0)
{
return name.size() + 1;
}
else if (name.size() > nameSize - 1) // extra char for the null
{
setLastError(SIMPLE_BUFFER_SIZE);
return 0;
}
memcpy(pName, name.c_str(), name.size());
pName[name.size()] = '\0';
setLastError(SIMPLE_NO_ERROR);
return name.size();
}
int getRasterLayerStatistics(Layer* pLayer, uint32_t channel,
uint32_t component, struct RasterStatistics* pStatistics)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
RasterChannelType chan(static_cast<RasterChannelTypeEnum>(channel));
ComplexComponent comp(static_cast<ComplexComponentEnum>(component));
if (pRaster == NULL || pStatistics == NULL || !chan.isValid() || !comp.isValid())
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
Statistics* pStats = pRaster->getStatistics(chan);
if (pStats == NULL || !pStats->areStatisticsCalculated(comp))
{
setLastError(SIMPLE_OTHER_FAILURE);
return 1;
}
pStatistics->min = pStats->getMin(comp);
pStatistics->max = pStats->getMax(comp);
pStatistics->mean = pStats->getAverage(comp);
pStatistics->stddev = pStats->getStandardDeviation(comp);
const double* pTmp = NULL;
const unsigned int* pTmp2 = NULL;
pStats->getHistogram(pTmp, pTmp2, comp);
pStatistics->pHistogramCenters = const_cast<double*>(pTmp);
pStatistics->pHistogramCounts = const_cast<unsigned int*>(pTmp2);
pStatistics->pPercentiles = const_cast<double*>(pStats->getPercentiles(comp));
pStatistics->resolution = pStats->getStatisticsResolution();
setLastError(SIMPLE_NO_ERROR);
return 0;
}
int setRasterLayerColormapValues(Layer* pLayer, const char* pName, uint32_t* pColormap)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL || pColormap == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
std::vector<ColorType> colormap;
colormap.reserve(256);
for (size_t idx = 0; idx < 256; ++idx)
{
colormap.push_back(decodeColor(pColormap[idx]));
}
try
{
pRaster->setColorMap(ColorMap(std::string((pName == NULL) ? "" : pName), colormap));
}
catch (const std::exception&)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
setLastError(SIMPLE_NO_ERROR);
return 0;
}
void Timeline::AddRasterLayer(int index)
{
if (!mScene)
{
return;
}
if (index < 0 || index > mLayers.size())
{
index = mLayers.size();
}
int width = mScene->GetWidth();
int height = mScene->GetHeight();
QString name;
name.sprintf("layer%d", mLayers.size());
RasterLayerModel* layerModel = mScene->AddRasterLayer(index, name, width, height);
if (layerModel)
{
RasterLayer* layer = new RasterLayer(this, layerModel);
layer->SetUndoStack(mUndoStack);
std::vector<Layer*>::iterator it = mLayers.begin();
it += index;
mLayers.insert(it, layer);
UpdateLayersUi();
}
}
uint32_t getRasterLayerFilterCount(Layer* pLayer, int enabled)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
setLastError(SIMPLE_NO_ERROR);
return (enabled != 0) ? pRaster->getEnabledFilterNames().size() : pRaster->getSupportedFilters().size();
}
int getRasterLayerGpuEnabled(Layer* pLayer)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
setLastError(SIMPLE_NO_ERROR);
return static_cast<int>(pRaster->isGpuImageEnabled());
}
uint32_t getRasterLayerComplexComponent(Layer* pLayer)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
setLastError(SIMPLE_NO_ERROR);
return pRaster->getComplexComponent();
}
int isRasterLayerRgbDisplayed(Layer* pLayer)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
setLastError(SIMPLE_NO_ERROR);
return static_cast<int>(pRaster->getDisplayMode() == RGB_MODE);
}
int setRasterLayerRgbDisplayed(Layer* pLayer, int rgb)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
pRaster->setDisplayMode(rgb == 0 ? GRAYSCALE_MODE : RGB_MODE);
setLastError(SIMPLE_NO_ERROR);
return 0;
}
int setRasterLayerComplexComponent(Layer* pLayer, uint32_t component)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
ComplexComponent comp(static_cast<ComplexComponentEnum>(component));
if (pRaster == NULL || !comp.isValid())
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
pRaster->setComplexComponent(comp);
setLastError(SIMPLE_NO_ERROR);
return 0;
}
int setRasterLayerFilterFrozen(Layer* pLayer, const char* pFilterName, int freeze)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL || pFilterName == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
pRaster->freezeFilter(std::string(pFilterName), freeze != 0);
pRaster->getView()->refresh();
setLastError(SIMPLE_NO_ERROR);
return 0;
}
void Timeline::Render(QPainter& painter)
{
std::vector<QImage*> onions;
for (size_t i = 0; i < mLayers.size(); ++i)
{
Layer* layer = mLayers[i];
if (!layer->IsEnabled())
{
continue;
}
if (layer->GetType() == LayerTypeRaster)
{
QImage* img = mLayers[i]->GetImage(mFrameIndex);
if (img)
{
if (mEditor->IsOnionEnabled() && mLayerIndex == (int)i)
{
if (layer->GetType() == LayerTypeRaster && layer->IsOnionEnabled())
{
RasterLayer* l = (RasterLayer*)mLayers[i];
QImage* prev = l->GetImage(l->GetPrevImageIndex(mFrameIndex));
if(prev && prev != img)
{
onions.push_back(prev);
}
QImage* next = l->GetImage(l->GetNextImageIndex(mFrameIndex));
if(next && next != img)
{
onions.push_back(next);
}
}
}
painter.setOpacity(layer->GetOpacity() / 255.0f);
painter.drawImage(0, 0, *img);
}
}
else if (layer->GetType() == LayerTypeTrace)
{
TraceLayer* tl = (TraceLayer*)layer;
tl->Render(painter);
}
}
painter.setOpacity(0.25f);
for (size_t i = 0; i < onions.size(); ++i)
{
painter.drawImage(0, 0, *onions[i]);
}
}
int setRasterLayerColormapName(Layer* pLayer, const char* pName)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
std::string name(pName);
ColorMap map;
if (!map.loadFromFile(name))
{
// see if name is a colormap name
const Filename* pSupportFiles = Service<ConfigurationSettings>()->getSettingSupportFilesPath();
if (pSupportFiles == NULL)
{
setLastError(SIMPLE_OTHER_FAILURE);
return 1;
}
std::string mapDir = pSupportFiles->getFullPathAndName() + SLASH + "ColorTables" + SLASH;
if (!map.loadFromFile(mapDir + name) && !map.loadFromFile(mapDir + name + ".clu")
&& !map.loadFromFile(mapDir + name + ".cgr"))
{
// scan all the default files and check for a valid name
bool located = false;
FactoryResource<FileFinder> pFinder;
pFinder->findFile(mapDir, "*.c??");
while (pFinder->findNextFile())
{
std::string filePath;
pFinder->getFullPath(filePath);
if (map.loadFromFile(filePath) && map.getName() == name)
{
located = true;
break;
}
}
if (!located)
{
setLastError(SIMPLE_NOT_FOUND);
return 1;
}
}
}
pRaster->setColorMap(map);
setLastError(SIMPLE_NO_ERROR);
return 0;
}
uint32_t getRasterLayerDisplayedBand(Layer* pLayer, uint32_t channel, DataElement** pElement)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
RasterChannelType chan(static_cast<RasterChannelTypeEnum>(channel));
if (pRaster == NULL || !chan.isValid())
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
if (pElement != NULL)
{
*pElement = pRaster->getDisplayedRasterElement(chan);
}
setLastError(SIMPLE_NO_ERROR);
return pRaster->getDisplayedBand(chan).getActiveNumber();
}
int setRasterLayerStretchInfo(Layer* pLayer, uint32_t channel, struct RasterLayerStretchInfo* pInfo)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
RasterChannelType chan(static_cast<RasterChannelTypeEnum>(channel));
if (pRaster == NULL || pInfo == NULL || !chan.isValid())
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
DisplayMode mode(chan == GRAY ? GRAYSCALE_MODE : RGB_MODE);
pRaster->setStretchValues(chan, pInfo->lowerStretch, pInfo->upperStretch);
pRaster->setStretchType(mode, static_cast<StretchTypeEnum>(pInfo->stretchType));
pRaster->setStretchUnits(chan, static_cast<RegionUnitsEnum>(pInfo->stretchUnits));
setLastError(SIMPLE_NO_ERROR);
return 0;
}
int setRasterLayerGpuEnabled(Layer* pLayer, int gpu)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
if (!pRaster->isGpuImageSupported())
{
setLastError(SIMPLE_OTHER_FAILURE);
return 1;
}
setLastError(SIMPLE_NO_ERROR);
pRaster->enableGpuImage(gpu != 0);
return 0;
}
SpatialDataView* VideoImporter::createView() const
{
if ((isBatch()) || (mpRasterElement == NULL))
{
return NULL;
}
mProgress.report("Creating view...", 85, NORMAL);
// Get the data set name
std::string name = mpRasterElement->getName();
if (name.empty())
{
mProgress.report("The data set name is invalid! A view cannot be created.", 0, ERRORS, true);
return NULL;
}
// Create the spatial data window
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(Service<DesktopServices>()->createWindow(name, SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
mProgress.report("Could not create the view window!", 0, ERRORS, true);
return NULL;
}
// Set the spatial data in the view
pView->setPrimaryRasterElement(mpRasterElement);
// Block undo actions when creating the layers
UndoLock lock(pView);
// Add the cube layer
RasterLayer* pLayer = static_cast<RasterLayer*>(pView->createLayer(RASTER, mpRasterElement));
if (pLayer == NULL)
{
mProgress.report("Could not create the cube layer!", 0, ERRORS, true);
return NULL;
}
pLayer->setStretchUnits(RED, RAW_VALUE);
pLayer->setStretchUnits(GREEN, RAW_VALUE);
pLayer->setStretchUnits(BLUE, RAW_VALUE);
pLayer->setStretchValues(RED, 0, 255);
pLayer->setStretchValues(GREEN, 0, 255);
pLayer->setStretchValues(BLUE, 0, 255);
if (pLayer->isGpuImageSupported())
{
pLayer->enableGpuImage(true);
}
return pView;
}
void FrameLabelObjectImp::setAnimations(View* pView)
{
if (getLocked() == false)
{
reset();
vector<Animation*> pAnimations;
if (pView != NULL)
{
SpatialDataView* pSpatialDataView = dynamic_cast<SpatialDataView*>(pView);
if (pSpatialDataView == NULL)
{
mpView.reset(pView);
mpAnimationController.reset(mpView->getAnimationController());
if (mpAnimationController.get() != NULL)
{
pAnimations = mpAnimationController->getAnimations();
}
}
else
{
mpLayerList.reset(pSpatialDataView->getLayerList());
VERIFYNRV(mpLayerList.get() != NULL);
vector<Layer*> pLayers;
mpLayerList->getLayers(RASTER, pLayers);
for (vector<Layer*>::iterator iter = pLayers.begin(); iter != pLayers.end(); ++iter)
{
RasterLayer* pRasterLayer = dynamic_cast<RasterLayer*>(*iter);
VERIFYNRV(pRasterLayer != NULL);
pRasterLayer->attach(SIGNAL_NAME(RasterLayer, AnimationChanged),
Slot(this, &FrameLabelObjectImp::updateAnimations));
pRasterLayer->attach(SIGNAL_NAME(Subject, Deleted),
Slot(this, &FrameLabelObjectImp::layerDeleted));
mLayers.push_back(pRasterLayer);
if (pRasterLayer->getAnimation() != NULL)
{
pAnimations.push_back(pRasterLayer->getAnimation());
}
}
}
}
insertAnimations(pAnimations);
}
}
int getRasterLayerColormapValues(Layer* pLayer, uint32_t* pColormap)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL || pColormap == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
const std::vector<ColorType>& colormap = pRaster->getColorMap().getTable();
if (colormap.size() != 256)
{
setLastError(SIMPLE_NO_MEM);
return 1;
}
for (size_t idx = 0; idx < colormap.size(); ++idx)
{
pColormap[idx] = encodeColor(colormap[idx]);
}
setLastError(SIMPLE_NO_ERROR);
return 0;
}
PlotWidget* HistogramWindowImp::getPlot(Layer* pLayer) const
{
if (pLayer == NULL)
{
return NULL;
}
RasterLayer* pRasterLayer = dynamic_cast<RasterLayer*>(pLayer);
if (pRasterLayer != NULL)
{
RasterChannelType channel = GRAY;
if (pRasterLayer->getDisplayMode() == RGB_MODE)
{
channel = RED;
}
return getPlot(pRasterLayer, channel);
}
// Iterate over all histogram plots on all plot sets to find the plot
vector<PlotWidget*> plots = mpPlotSetGroup->getPlots(HISTOGRAM_PLOT);
for (vector<PlotWidget*>::iterator iter = plots.begin(); iter != plots.end(); ++iter)
{
PlotWidget* pPlot = *iter;
if (pPlot != NULL)
{
HistogramPlotImp* pHistogramPlot = dynamic_cast<HistogramPlotImp*>(pPlot->getPlot());
if (pHistogramPlot != NULL)
{
Layer* pCurrentLayer = pHistogramPlot->getLayer();
if (pCurrentLayer == pLayer)
{
return pPlot;
}
}
}
}
return NULL;
}
void Timeline::UpdateCanvas()
{
std::vector<QImage*> layerImages;
std::vector<QImage*> onions;
QImage* editImage = NULL;
for (size_t i = 0; i < mLayers.size(); ++i)
{
if (!mLayers[i]->IsEnabled())
{
continue;
}
QImage* img = mLayers[i]->GetImage(mFrameIndex);
if (img)
{
if (mLayerIndex == i)
{
if (mLayers[i]->GetType() == LayerTypeRaster)
{
RasterLayer* l = (RasterLayer*)mLayers[i];
QImage* prev = l->GetImage(l->GetPrevImageIndex(mFrameIndex));
if(prev && prev != img)
{
onions.push_back(prev);
}
QImage* next = l->GetImage(l->GetNextImageIndex(mFrameIndex));
if(next && next != img)
{
onions.push_back(next);
}
}
editImage = img;
}
layerImages.push_back(img);
}
}
mEditor->Load(editImage);
update();
}
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;
}
uint32_t getRasterLayerColormapName(Layer* pLayer, char* pName, uint32_t nameSize)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
std::string name = pRaster->getColorMap().getName();
if (nameSize == 0)
{
return name.size() + 1;
}
else if (name.size() > nameSize - 1) // extra char for the null
{
setLastError(SIMPLE_BUFFER_SIZE);
return 0;
}
memcpy(pName, name.c_str(), name.size());
pName[name.size()] = '\0';
setLastError(SIMPLE_NO_ERROR);
return name.size();
}
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;
}
int setRasterLayerFilters(Layer* pLayer, uint32_t count, const char** pFilters)
{
RasterLayer* pRaster = dynamic_cast<RasterLayer*>(pLayer);
if (pRaster == NULL || (count > 0 && pFilters == NULL))
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
std::vector<std::string> filters;
filters.reserve(count);
for (size_t idx = 0; idx < count; ++idx)
{
if (pFilters[idx] == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 1;
}
filters.push_back(std::string(pFilters[idx]));
}
pRaster->enableFilters(filters);
pRaster->getView()->refresh();
setLastError(SIMPLE_NO_ERROR);
return 0;
}
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.");
}
}
}
}
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;
}
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 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 SampleGeoref::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
// Do any kind of setup we need before converting coordinates.
// In this case, get our X and Y factors.
StepResource pStep("Run Sample Georef", "app", "CFCB8AA9-D504-42e9-86F0-547DF9B4798A");
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
FAIL_IF(!isBatch(), "Interactive mode is not supported.", return false);
// Default values
bool animated = false;
// get factors from pInArgList
pInArgList->getPlugInArgValue("XSize", mXSize);
pInArgList->getPlugInArgValue("YSize", mYSize);
pInArgList->getPlugInArgValue("Extrapolate", mExtrapolate);
pInArgList->getPlugInArgValue("Animated", animated);
pInArgList->getPlugInArgValue("Rotate", mRotate);
View* pView = pInArgList->getPlugInArgValue<View>(Executable::ViewArg());
mpRaster = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
FAIL_IF(mpRaster == NULL, "Could not find raster element", return false);
if (mpGui != NULL)
{
mXSize = mpGui->getXSize();
mYSize = mpGui->getYSize();
animated = mpGui->getAnimated();
mRotate = mpGui->getRotate();
mExtrapolate = mpGui->getExtrapolate();
}
if (animated)
{
SpatialDataView* pSpatialView = dynamic_cast<SpatialDataView*>(pView);
FAIL_IF(pSpatialView == NULL, "Could not find spatial data view.", return false);
LayerList* pLayerList = pSpatialView->getLayerList();
FAIL_IF(pLayerList == NULL, "Could not find layer list.", return false);
RasterLayer* pLayer = dynamic_cast<RasterLayer*>(pLayerList->getLayer(RASTER, mpRaster));
FAIL_IF(pLayer == NULL, "Could not find raster layer", return false);
Animation* pAnim = pLayer->getAnimation();
FAIL_IF(pAnim == NULL, "Could not find animation", return false);
const std::vector<AnimationFrame>& frames = pAnim->getFrames();
FAIL_IF(frames.empty(), "No frames in animation.", return false);
mpAnimation.reset(pAnim);
mFrames = frames.size();
mCurrentFrame = 0;
}
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>(mpRaster->getDataDescriptor());
FAIL_IF(pDescriptor == NULL, "Could not get data descriptor.", return false);
unsigned int rows = pDescriptor->getRowCount();
unsigned int cols = pDescriptor->getColumnCount();
unsigned int bands = pDescriptor->getBandCount();
mXScale = static_cast<double>(mXSize) / rows;
mYScale = static_cast<double>(mYSize) / cols;
mpRaster->setGeoreferencePlugin(this);
mpGui = NULL; // Pointer not guaranteed to be valid after execute() is called
return true;
}
