uint32_t setGcpPoints(DataElement* pList, uint32_t count, struct Gcp* pPoints)
{
GcpList* pGcpList = dynamic_cast<GcpList*>(pList);
if (pGcpList == NULL || (count > 0 && pPoints == NULL))
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
pGcpList->clearPoints();
if (count == 0)
{
setLastError(SIMPLE_NO_ERROR);
return 0;
}
std::list<GcpPoint> points;
for (uint32_t index = 0; index < count; ++index)
{
GcpPoint point;
memcpy(&point, &pPoints[index], sizeof(struct Gcp));
points.push_back(point);
}
pGcpList->addPoints(points);
setLastError(SIMPLE_NO_ERROR);
return pGcpList->getCount();
}
void RemoveGcpPoint::executeUndo()
{
GcpList* pGcpList = dynamic_cast<GcpList*>(getSessionItem());
if (pGcpList != NULL)
{
pGcpList->addPoint(mPoint);
}
}
uint32_t getGcpCount(DataElement* pList)
{
GcpList* pGcpList = dynamic_cast<GcpList*>(pList);
if (pGcpList == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
setLastError(SIMPLE_NO_ERROR);
return pGcpList->getCount();
}
void SetGcpPoints::executeRedo()
{
GcpList* pGcpList = dynamic_cast<GcpList*>(getSessionItem());
if (pGcpList != NULL)
{
if (pGcpList->getSelectedPoints() != mNewPoints)
{
pGcpList->clearPoints();
pGcpList->addPoints(mNewPoints);
}
}
}
struct Gcp getGcpPoint(DataElement* pList, uint32_t index)
{
GcpList* pGcpList = dynamic_cast<GcpList*>(pList);
if (pGcpList == NULL || index >= static_cast<uint32_t>(pGcpList->getCount()))
{
setLastError(SIMPLE_BAD_PARAMS);
return Gcp();
}
const std::list<GcpPoint>& points = pGcpList->getSelectedPoints();
std::list<GcpPoint>::const_iterator point = points.begin();
while (index-- > 0) ++point;
struct Gcp rval;
memcpy(&rval, &*point, sizeof(struct Gcp));
setLastError(SIMPLE_NO_ERROR);
return rval;
}
uint32_t getGcpPoints(DataElement* pList, struct Gcp* pPoints)
{
GcpList* pGcpList = dynamic_cast<GcpList*>(pList);
if (pGcpList == NULL || pPoints == NULL)
{
setLastError(SIMPLE_BAD_PARAMS);
return 0;
}
const std::list<GcpPoint>& points = pGcpList->getSelectedPoints();
uint32_t index = 0;
for (std::list<GcpPoint>::const_iterator point = points.begin(); point != points.end(); ++point)
{
memcpy(&pPoints[index++], &*point, sizeof(struct Gcp));
}
setLastError(SIMPLE_NO_ERROR);
return points.size();
}
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 Orthorectification::process(int type, RasterElement *pDSM, GRID DSMGrid, double Geoid_Offset, int DSM_resampling)
{
StepResource pStep("Orthorectification Process", "app", "B4D426EC-E06D-11E1-83C8-42E56088709B");
pStep->addStep("Start","app", "B4D426EC-E06D-11E1-83C8-42E56088709B");
boxsize=0;
res_type = type;
if (res_type == 0)
{
boxsize=0;
}
else if (res_type == 1)
{
boxsize=1;
}
else if (res_type == 2)
{
boxsize=2;
}
else if (res_type == 3)
{
boxsize=3;
}
ProgressResource pResource("ProgressBar");
Progress *pProgress=pResource.get();
pProgress->setSettingAutoClose(false);
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(Image->getDataDescriptor());
FactoryResource<DataRequest> pRequest;
DataAccessor pSrcAcc = Image->getDataAccessor(pRequest.release());
RasterDataDescriptor* pDescDSM = static_cast<RasterDataDescriptor*>(pDSM->getDataDescriptor());
FactoryResource<DataRequest> pRequestDSM;
DataAccessor pDSMAcc = pDSM->getDataAccessor(pRequestDSM.release());
unsigned int N_Row = int(OrthoGrid.Y_Dim)+1;
unsigned int N_Col = int(OrthoGrid.X_Dim)+1;
// Check name of raster element //
Service<ModelServices> pModel;
vector<string> mCubeNames = pModel->getElementNames("RasterElement");
int NameIndex = 0, control=0;
stringstream out;
string OutputName=Image->getName();
string OutputName1 = OutputName.substr(0,OutputName.find_last_of("."));
while (control == 0)
{
control = 1;
OutputName = OutputName1+"_ortho_";
out << NameIndex;
OutputName.append(out.str()+".tiff");
for (unsigned int k=0; k<mCubeNames.size(); k++)
{
if (OutputName.compare(mCubeNames[k]) == 0) control = 0;
}
NameIndex++;
out.str("");
out.clear();
}
// Create output raster element and assoiciated descriptor and accessor //
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(OutputName,N_Row ,N_Col, FLT4BYTES));
RasterDataDescriptor* pResultDesc = static_cast<RasterDataDescriptor*> (pResultCube->getDataDescriptor());
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
double NodeLat, NodeLon, H_IJ=0;
//int DSM_I, DSM_J;
for (unsigned int row = 0; row < N_Row; ++row)
{
if (pProgress != NULL)
{
pProgress->updateProgress("Calculating result", row * 100 / N_Row, NORMAL);
}
if (!pDestAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pProgress->updateProgress(msg, 0, ERRORS);
pStep->finalize(Message::Failure, msg);
return false;
}
for (unsigned int col = 0; col < N_Col; ++col)
{
NodeLat = OrthoGrid.Lat_Min+row*OrthoGrid.Lat_Step;
NodeLon = OrthoGrid.Lon_Min+col*OrthoGrid.Lon_Step;
// RETRIEVE HEIGHT VALUE FROM DSM
if (DSM_resampling == 0)
{
int DSM_I = int((NodeLon - DSMGrid.Lon_Min)/DSMGrid.Lon_Step);
int DSM_J = pDescDSM->getRowCount() - int((NodeLat - DSMGrid.Lat_Min)/DSMGrid.Lat_Step);
pDSMAcc->toPixel(DSM_J,DSM_I);
VERIFY(pDSMAcc.isValid());
H_IJ = (pDSMAcc->getColumnAsDouble());
}
else
{
double DSM_I = ((NodeLon - DSMGrid.Lon_Min)/DSMGrid.Lon_Step);
double DSM_J = pDescDSM->getRowCount() - ((NodeLat - DSMGrid.Lat_Min)/DSMGrid.Lat_Step);
H_IJ = bilinear_height(pDSMAcc,DSM_I,DSM_J);
}
P_COORD NodeImage = Model->SAR_GroundToImage(NodeLon,NodeLat,H_IJ+Geoid_Offset);
if ((NodeImage.I>1 && NodeImage.I< Model->Metadata.Width-1) && (NodeImage.J>1 && NodeImage.J< Model->Metadata.Height-1))
{
switchOnEncoding(pResultDesc->getDataType(), copypixel3, pDestAcc->getColumn(), pSrcAcc, int(NodeImage.I), int(NodeImage.J),boxsize, H_IJ);
}
pDestAcc->nextColumn();
}
pDestAcc->nextRow();
}
Service<DesktopServices> pDesktop;
Service<ModelServices> pMod;
GcpList* GcpL = static_cast<GcpList*>(pMod->createElement("corner coordinate","GcpList",pResultCube.get()));
// Update GCPs Information: to account for Opticks reading gcp lat&lon values the opposite way around,
// here it is necessary to switch the value to assign lat to gcp.mCoordinate.mX and lon to gcp.mCoordinate.mY
GcpPoint Punto;
Punto.mCoordinate.mX = OrthoGrid.Lat_Min;
Punto.mCoordinate.mY = OrthoGrid.Lon_Min;
Punto.mCoordinate.mZ = 0.0;
Punto.mPixel.mX = 0.0;
Punto.mPixel.mY = 0.0;
GcpL->addPoint(Punto);
Punto.mCoordinate.mX = OrthoGrid.Lat_Max;
Punto.mCoordinate.mY = OrthoGrid.Lon_Min;
Punto.mCoordinate.mZ = 0.0;
Punto.mPixel.mX = 0.0;
Punto.mPixel.mY = OrthoGrid.Y_Dim;
GcpL->addPoint(Punto);
Punto.mCoordinate.mX = OrthoGrid.Lat_Min;
Punto.mCoordinate.mY = OrthoGrid.Lon_Max;
Punto.mCoordinate.mZ = 0.0;
Punto.mPixel.mX = OrthoGrid.X_Dim;
Punto.mPixel.mY = 0.0;
GcpL->addPoint(Punto);
Punto.mCoordinate.mX = OrthoGrid.Lat_Max;
Punto.mCoordinate.mY = OrthoGrid.Lon_Max;
Punto.mCoordinate.mZ = 0.0;
Punto.mPixel.mX = OrthoGrid.X_Dim;
Punto.mPixel.mY = OrthoGrid.Y_Dim;
GcpL->addPoint(Punto);
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
pView->createLayer(GCP_LAYER,GcpL,"GCP");
pView->setDataOrigin(LOWER_LEFT);
pResultCube.release();
pProgress->updateProgress("Orthorectification is complete.", 100, NORMAL);
pStep->addStep("End","app", "B4D426EC-E06D-11E1-83C8-42E56088709B");
pStep->finalize();
return true;
}
GcpList* RasterElementImporterShell::createGcpList() const
{
if (mpRasterElement == NULL)
{
return NULL;
}
const RasterDataDescriptor* pDescriptor =
dynamic_cast<const RasterDataDescriptor*>(mpRasterElement->getDataDescriptor());
if (pDescriptor == NULL)
{
return NULL;
}
const RasterFileDescriptor* pFileDescriptor =
dynamic_cast<const RasterFileDescriptor*>(pDescriptor->getFileDescriptor());
if (pFileDescriptor == NULL)
{
return NULL;
}
const list<GcpPoint>& gcps = pFileDescriptor->getGcps();
if (gcps.empty() == true)
{
return NULL;
}
// Create the GCP list
GcpList* pGcpList = static_cast<GcpList*>(mpModel->createElement("Corner Coordinates", "GcpList", mpRasterElement));
if (pGcpList != NULL)
{
unsigned int onDiskStartRow = 0;
unsigned int onDiskStartColumn = 0;
unsigned int numActiveRows = pDescriptor->getRowCount();
unsigned int numActiveColumns = pDescriptor->getColumnCount();
unsigned int numOnDiskRows = pFileDescriptor->getRowCount();
unsigned int numOnDiskColumns = pFileDescriptor->getColumnCount();
if ((numActiveRows != numOnDiskRows) || (numActiveColumns != numOnDiskColumns))
{
const vector<DimensionDescriptor>& activeRows = pDescriptor->getRows();
if (activeRows.empty() == false)
{
DimensionDescriptor rowDim = activeRows.front();
if (rowDim.isOnDiskNumberValid())
{
onDiskStartRow = rowDim.getOnDiskNumber();
}
}
const vector<DimensionDescriptor>& activeColumns = pDescriptor->getColumns();
if (activeColumns.empty() == false)
{
DimensionDescriptor columnDim = activeColumns.front();
if (columnDim.isOnDiskNumberValid())
{
onDiskStartColumn = columnDim.getOnDiskNumber();
}
}
}
// Add the GCPs to the GCP list
list<GcpPoint> adjustedGcps;
list<GcpPoint>::const_iterator iter;
for (iter = gcps.begin(); iter != gcps.end(); ++iter)
{
GcpPoint gcp = *iter;
gcp.mPixel.mX = gcp.mPixel.mX - onDiskStartColumn;
gcp.mPixel.mY = gcp.mPixel.mY - onDiskStartRow;
adjustedGcps.push_back(gcp);
}
pGcpList->addPoints(adjustedGcps);
}
return pGcpList;
}
bool BandMath::createReturnValue(string partialResultsName)
{
// Set the short and long result names
FactoryResource<Filename> pFilename;
string shortResultsName;
string longResultsName;
if (pFilename.get() != NULL)
{
pFilename->setFullPathAndName(mpCube->getFilename());
shortResultsName = pFilename->getTitle() + " = " + partialResultsName;
longResultsName = pFilename->getPath() + "/" + pFilename->getTitle() + " = " + partialResultsName;
}
mResultsName = longResultsName;
const RasterDataDescriptor* pOrigDescriptor = dynamic_cast<RasterDataDescriptor*>(mpCube->getDataDescriptor());
const vector<DimensionDescriptor>& origRows = pOrigDescriptor->getRows();
const vector<DimensionDescriptor>& origColumns = pOrigDescriptor->getColumns();
mpResultData = NULL;
unsigned int bandCount = mCubeBands;
if (mbCubeMath == false)
{
bandCount = 1;
}
RasterElement* pParent = NULL;
if (mbAsLayerOnExistingView)
{
pParent = mpCube;
}
RasterElement* pRaster = RasterUtilities::createRasterElement(mResultsName, origRows.size(),
origColumns.size(), bandCount, FLT4BYTES, BIP, pOrigDescriptor->getProcessingLocation() == IN_MEMORY, pParent);
if (pRaster == NULL)
{
mstrProgressString = "Error creating result raster element";
meGabbiness = ERRORS;
displayErrorMessage();
mbError = true;
return false;
}
if (!mbAsLayerOnExistingView)
{
// need to copy classification since parent was NULL in call to createRasterElement
pRaster->copyClassification(mpCube);
// make copies of existing GcpLists only if going into a new view
vector<DataElement*> gcps = mpDataModel->getElements(mpCube, "GcpList");
if (!gcps.empty())
{
vector<DataElement*>::iterator iter;
for (iter = gcps.begin(); iter != gcps.end(); ++iter)
{
GcpList* theGcp = dynamic_cast<GcpList*>(*iter);
theGcp->copy(theGcp->getName(), pRaster);
}
}
}
mpResultData = pRaster;
RasterDataDescriptor* pDescriptor = dynamic_cast<RasterDataDescriptor*>
(mpResultData->getDataDescriptor());
if (pDescriptor != NULL)
{
// Rows
vector<DimensionDescriptor> rows = pDescriptor->getRows();
for (unsigned int i = 0; i < origRows.size(); ++i)
{
// Original number
DimensionDescriptor origRow = origRows[i];
if (origRow.isOriginalNumberValid() == true)
{
rows[i].setOriginalNumber(origRow.getOriginalNumber());
}
}
pDescriptor->setRows(rows);
// Columns
vector<DimensionDescriptor> columns = pDescriptor->getColumns();
for (unsigned int i = 0; i < origColumns.size(); ++i)
{
// Original number
DimensionDescriptor origColumn = origColumns[i];
if (origColumn.isOriginalNumberValid() == true)
{
columns[i].setOriginalNumber(origColumn.getOriginalNumber());
}
}
pDescriptor->setColumns(columns);
}
return true;
}
void Simulation_GUI::CheckModel()
{
ProgressResource pProgress("ProgressBar");
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
FactoryResource<DataRequest> pRequest;
DataAccessor pAcc = pCube->getDataAccessor(pRequest.release());
DataDescriptor* dMeta = pCube->getDataDescriptor();
DynamicObject* oMetadata = dMeta->getMetadata();
// RETRIEVE & UPDATE METADATA INFORMATION //
bool control = Metadata->ReadFile(image_path);
Metadata->UpdateMetadata(oMetadata);
// WIDGET SELECT & RETRIEVE GCPs INFORMATION //
GcpList * GCPs = NULL;
Service<ModelServices> pModel;
std::vector<DataElement*> pGcpLists = pModel->getElements(pCube, TypeConverter::toString<GcpList>());
if (!pGcpLists.empty())
{
QStringList aoiNames("<none>");
for (std::vector<DataElement*>::iterator it = pGcpLists.begin(); it != pGcpLists.end(); ++it)
{
aoiNames << QString::fromStdString((*it)->getName());
}
QString aoi = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Select a GCP List", "Select a GCP List for validate the orientation model", aoiNames);
if (aoi != "<none>")
{
std::string strAoi = aoi.toStdString();
for (std::vector<DataElement*>::iterator it = pGcpLists.begin(); it != pGcpLists.end(); ++it)
{
if ((*it)->getName() == strAoi)
{
GCPs = static_cast<GcpList*>(*it);
break;
}
}
if (GCPs == NULL)
{
std::string msg = "Invalid GCPList.";
pProgress->updateProgress(msg, 0, ERRORS);
return;
}
}
else
{
std::string msg = "A set of GCPs must be specified.";
if (pProgress.get() != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return;
}
} // End if GcpList
// UPDATE GCPs HEIGHT INFORMATION AND SWITCH Lat&Lon COORDINATE FOR CORRECT VISUALIZAZION IN THE GCPs EDITOR
std::list<GcpPoint> Punti = GCPs->getSelectedPoints();
Punti = Metadata->UpdateGCP(Punti, image_path);
//SAR_Model ModProva(*Metadata);
SAR_Model *ModProva;
//ModProva = new SAR_Ground_Model(Prova_metadata);
ModProva = new SAR_Slant_Model(*Metadata);
if(Metadata->Projection == "SGF")
{
ModProva = new SAR_Ground_Model(*Metadata);
}
P_COORD Punto;
int N=Punti.size();
int n=0;
double Lat, Lon;
accumulator_set<double, stats<tag::mean, tag::variance> > accX, accY;
list<GcpPoint>::iterator pList;
for (pList = Punti.begin(); pList != Punti.end(); pList++)
{
if(pList->mPixel.mX<Metadata->Width && pList->mPixel.mY<Metadata->Height)
{
Lon = pList->mCoordinate.mX;
Lat = pList->mCoordinate.mY;
Punto = ModProva->SAR_GroundToImage(pList->mCoordinate.mX,pList->mCoordinate.mY,pList->mCoordinate.mZ);
pList->mRmsError.mX = pList->mPixel.mX -Punto.I;
pList->mRmsError.mY = pList->mPixel.mY -Punto.J;
accX(pList->mRmsError.mX);
accY(pList->mRmsError.mY);
pList->mCoordinate.mX = Lat;
pList->mCoordinate.mY = Lon;
}
else
{
Lon = pList->mCoordinate.mX;
Lat = pList->mCoordinate.mY;
pList->mRmsError.mX = -9999;
pList->mRmsError.mY = -9999;
pList->mCoordinate.mX = Lat;
pList->mCoordinate.mY = Lon;
}
pProgress->updateProgress("Calculating statistics", int(100*n/N), NORMAL);
n++;
}
double meanX = mean(accX);
double meanY = mean(accY);
double varX = variance(accX);
double varY = variance(accY);
GCPs->clearPoints();
GCPs->addPoints(Punti);
std::string msg = "Number of Rows : " + StringUtilities::toDisplayString(pDesc->getRowCount()) + "\n"
"Number of Columns : " + StringUtilities::toDisplayString(pDesc->getColumnCount()) + "\n\n"
"Metadata update completed" + "\n\n"
"********** Validation Results **********" "\n\n"
"Number of GCPs: " + StringUtilities::toDisplayString(Punti.size()) + "\n\n"
"Mean I : " + StringUtilities::toDisplayString(meanX) + "\n"
"Variance I : " + StringUtilities::toDisplayString(varX) + "\n\n"
"Mean J : " + StringUtilities::toDisplayString(meanY) + "\n"
"Variance J : " + StringUtilities::toDisplayString(varY) + "\n\n" ;
pProgress->updateProgress(msg, 100, NORMAL);
// pStep->finalize();
}
bool Test_Update_TerraSAR::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Tutorial CEO", "app", "0FD3C564-041D-4f8f-BBF8-96A7A165AB61");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
FactoryResource<DataRequest> pRequest;
DataAccessor pAcc = pCube->getDataAccessor(pRequest.release());
std::string path = pCube->getFilename();
DataDescriptor* dMeta = pCube->getDataDescriptor();
DynamicObject* Metadata = dMeta->getMetadata();
// RETRIEVE & UPDATE METADATA INFORMATION //
TerraSAR_Metadata Prova_metadata;
bool control = Prova_metadata.ReadFile(path);
if (control == false)
{
std::string msg = "This is not a TerraSAR-X SLC Files, Metadata can't be updated";
pProgress->updateProgress(msg, 100, ERRORS);
return false;
}
Prova_metadata.UpdateMetadata(Metadata);
//SAR_Model ModProva(Prova_metadata,1000);
SAR_Model *ModProva;
//ModProva = new SAR_Ground_Model(Prova_metadata);
ModProva = new SAR_Slant_Model(Prova_metadata);
if(Prova_metadata.Projection == "SGF")
{
ModProva = new SAR_Ground_Model(Prova_metadata);
}
//else
//{
// ModProva = new SAR_Slant_Model(Prova_metadata);
//}
// WIDGET SELECT & RETRIEVE GCPs INFORMATION //
GcpList * GCPs = NULL;
Service<ModelServices> pModel;
std::vector<DataElement*> pGcpLists = pModel->getElements(pCube, TypeConverter::toString<GcpList>());
std::list<GcpPoint> Punti;
if (!pGcpLists.empty())
{
QStringList aoiNames("<none>");
for (std::vector<DataElement*>::iterator it = pGcpLists.begin(); it != pGcpLists.end(); ++it)
{
aoiNames << QString::fromStdString((*it)->getName());
}
QString aoi = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Select a GCP List", "Select a GCP List for validate the orientation model", aoiNames);
if (aoi != "<none>")
{
std::string strAoi = aoi.toStdString();
for (std::vector<DataElement*>::iterator it = pGcpLists.begin(); it != pGcpLists.end(); ++it)
{
if ((*it)->getName() == strAoi)
{
GCPs = static_cast<GcpList*>(*it);
break;
}
}
if (GCPs == NULL)
{
std::string msg = "Invalid GCPList.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
}
else
{
std::string msg = "A set of GCPs must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
// UPDATE GCPs HEIGHT INFORMATION AND SWITCH Lat&Lon COORDINATE FOR CORRECT VISUALIZAZION IN THE GCPs EDITOR
Punti = GCPs->getSelectedPoints();
Punti = Prova_metadata.UpdateGCP(Punti, path, pProgress);
P_COORD Punto;
int N=Punti.size();
int n=0, indexP=0;
double Lat, Lon;
accumulator_set<double, stats<tag::mean, tag::variance> > accX, accY;
list<GcpPoint>::iterator pList;
for (pList = Punti.begin(); pList != Punti.end(); pList++)
{
if(pList->mPixel.mX<Prova_metadata.Width && pList->mPixel.mY<Prova_metadata.Height)
{
Lon = pList->mCoordinate.mX;
Lat = pList->mCoordinate.mY;
Punto = ModProva->SAR_GroundToImage(pList->mCoordinate.mX,pList->mCoordinate.mY,pList->mCoordinate.mZ);
//pList->mRmsError.mX = pList->mPixel.mX -Punto.I;
//pList->mRmsError.mY = pList->mPixel.mY -Punto.J;
pList->mPixel.mX = (Prova_metadata.Grid_Range_Time/Prova_metadata.RowSpacing)*(indexP-int(indexP/Prova_metadata.Grid_N_Range)*Prova_metadata.Grid_N_Range);
pList->mRmsError.mX = (Prova_metadata.Grid_Range_Time/Prova_metadata.RowSpacing)*(indexP-int(indexP/Prova_metadata.Grid_N_Range)*Prova_metadata.Grid_N_Range) -Punto.I;
pList->mPixel.mY = (Prova_metadata.Grid_Azimuth_Time*Prova_metadata.PRF)*int(indexP/Prova_metadata.Grid_N_Range);
pList->mRmsError.mY = (Prova_metadata.Grid_Azimuth_Time*Prova_metadata.PRF)*int(indexP/Prova_metadata.Grid_N_Range) - Punto.J;
accX(pList->mRmsError.mX);
accY(pList->mRmsError.mY);
pList->mCoordinate.mX = Lat;
pList->mCoordinate.mY = Lon;
}
else
{
Lon = pList->mCoordinate.mX;
Lat = pList->mCoordinate.mY;
pList->mRmsError.mX = -9999;
pList->mRmsError.mY = -9999;
pList->mCoordinate.mX = Lat;
pList->mCoordinate.mY = Lon;
}
if (pProgress != NULL)
{
pProgress->updateProgress("Calculating statistics", int(100*n/N), NORMAL);
}
n++;
indexP++;
}
double meanX = mean(accX);
double meanY = mean(accY);
double varX = variance(accX);
double varY = variance(accY);
GCPs->clearPoints();
GCPs->addPoints(Punti);
if (pProgress != NULL)
{
std::string msg = "Number of Rows : " + StringUtilities::toDisplayString(pDesc->getRowCount()) + "\n"
"Number of Columns : " + StringUtilities::toDisplayString(pDesc->getColumnCount()) + "\n\n"
"Metadata update completed" + "\n\n"
"********** Validation Results **********" "\n\n"
"Number of GCPs: " + StringUtilities::toDisplayString(Punti.size()) + "\n\n"
"Mean I : " + StringUtilities::toDisplayString(meanX) + "\n"
"Variance I : " + StringUtilities::toDisplayString(varX) + "\n\n"
"Mean J : " + StringUtilities::toDisplayString(meanY) + "\n"
"Variance J : " + StringUtilities::toDisplayString(varY) + "\n\n" ;
pProgress->updateProgress(msg, 100, NORMAL);
}
} // End if GcpList
else
{
Punti.resize(Prova_metadata.Grid_N);
Punti = Prova_metadata.UpdateGCP(Punti, path);
}
pStep->finalize();
return true;
}
bool GcpGeoreference::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("Run GCP Georeference", "app", "296120A0-1CD5-467E-A501-934BCA7775EA");
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
mpProgress = pProgress;
FAIL_IF(!isBatch(), "Interactive mode is not supported.", return false);
int numPoints;
PlugInArg* pArg = NULL;
mpRaster = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
FAIL_IF(mpRaster == NULL, "Unable to find raster element input", return false);
GcpList* pGcpList = NULL;
if (mpGui != NULL)
{
mOrder = mpGui->getOrder();
string gcpListName = mpGui->getGcpListName();
if (gcpListName.empty() == false)
{
pGcpList = static_cast<GcpList*>(mpDataModel->getElement(gcpListName,
TypeConverter::toString<GcpList>(), mpRaster));
}
}
else
{
pInArgList->getPlugInArgValue<int>("Order", mOrder);
pGcpList = pInArgList->getPlugInArgValue<GcpList>(Georeference::GcpListArg());
}
if (pGcpList != NULL)
{
pStep->addProperty("gcpList", pGcpList->getName());
}
pStep->addProperty("polynomialOrder", mOrder);
FAIL_IF(pGcpList == NULL, "Unable to find GCP list.", return false);
if ((mOrder <= 0) || (mOrder > MAX_ORDER))
{
if (mpProgress)
{
stringstream buffer;
buffer << "Invalid polynomial order: " << mOrder << "\nThe order must be between 1 and " <<
MAX_ORDER << " (inclusive)";
mpProgress->updateProgress(buffer.str(), 0, ERRORS);
}
pStep->addProperty("Max Polynomial Order", MAX_ORDER);
pStep->finalize(Message::Failure, "Invalid polynomial order");
return false;
}
mReverseOrder = min(MAX_ORDER, mOrder+1);
int numCoeffs = COEFFS_FOR_ORDER(mOrder);
numPoints = pGcpList->getSelectedPoints().size();
if (numPoints < numCoeffs)
{
if (mpProgress)
{
stringstream buffer;
buffer << "Too few ground control points.\n" << "A polynomial fit of order " << mOrder <<
"\nrequires at least " << numCoeffs << " GCPs.";
mpProgress->updateProgress(buffer.str(), 0, ERRORS);
}
pStep->addProperty("Required GCPs", numCoeffs);
pStep->finalize(Message::Failure, "Too few ground control points");
return false;
}
int numReverseCoeffs = COEFFS_FOR_ORDER(mReverseOrder);
vector<double> latCoeffs(numCoeffs);
vector<double> lonCoeffs(numCoeffs);
vector<double> pXCoeffs(numReverseCoeffs);
vector<double> pYCoeffs(numReverseCoeffs);
vector<LocationType> latlonValues(numPoints);
vector<LocationType> pixelValues(numPoints);
double maxLonSeparation(0.0);
list<GcpPoint>::const_iterator it;
unsigned int i;
unsigned int j;
for (i = 0, it = pGcpList->getSelectedPoints().begin();
it != pGcpList->getSelectedPoints().end();
++it, ++i)
{
pixelValues[i] = it->mPixel;
latlonValues[i] = it->mCoordinate;
}
// Find the maximum separation to determine if it is the antimeridian or the poles
for (i = 0; i < pGcpList->getSelectedPoints().size(); ++i)
{
for (j = i + 1; j < pGcpList->getSelectedPoints().size(); ++j)
{
if (fabs(latlonValues[i].mY - latlonValues[j].mY) > maxLonSeparation)
{
maxLonSeparation = fabs(latlonValues[i].mY - latlonValues[j].mY);
}
}
}
bool badValues = true;
bool badPixelValues = true;
for (i = 0; i < pGcpList->getSelectedPoints().size(); ++i)
{
for (j = i + 1; j < pGcpList->getSelectedPoints().size(); ++j)
{
if (fabs(latlonValues[i].mX - latlonValues[j].mX) > 1e-20)
{
badValues = false;
break;
}
if (fabs(latlonValues[i].mY - latlonValues[j].mY) > 1e-20)
{
badValues = false;
break;
}
}
}
#pragma message(__FILE__ "(" STRING(__LINE__) ") : warning : This is a short term solution " \
"the draw method in LatLonLayer needs to be changed! (mconsidi)")
// Special lon cases of the Antimeridian and poles
// A value of more than 180.0 in maxLonSeparation indicates a special condition
if (maxLonSeparation > 180.0)
{
for (i = 0; i < pGcpList->getSelectedPoints().size(); ++i)
{
if (latlonValues[i].mY < 0.0)
{
latlonValues[i].mY = 360.0 + latlonValues[i].mY;
}
}
}
if (badValues)
{
mMessageText = "All GCPs have the same value.";
if (mpProgress)
{
mpProgress->updateProgress(mMessageText, 0, ERRORS);
}
pStep->finalize(Message::Failure, mMessageText);
return false;
}
for (i = 0; i < pGcpList->getSelectedPoints().size(); ++i)
{
for (j = i + 1; j < pGcpList->getSelectedPoints().size(); ++j)
{
if (fabs(pixelValues[i].mX - pixelValues[j].mX) > 1e-20)
{
badPixelValues = false;
break;
}
if (fabs(pixelValues[i].mY - pixelValues[j].mY) > 1e-20)
{
badPixelValues = false;
break;
}
}
}
if (badPixelValues)
{
mMessageText = "All GCPs have the same pixel location value.";
if (mpProgress)
{
mpProgress->updateProgress(mMessageText, 0, ERRORS);
}
pStep->finalize(Message::Failure, mMessageText);
return false;
}
mMessageText = "GcpGeoreference started.";
if (mpProgress)
{
mpProgress->updateProgress(mMessageText, 0, NORMAL);
}
bool success = computeFit(pixelValues, latlonValues, 0, latCoeffs);
if (success)
{
success = computeFit(pixelValues, latlonValues, 1, lonCoeffs);
}
const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(mpRaster->getDataDescriptor());
if (pDescriptor != NULL)
{
setCubeSize(pDescriptor->getRowCount(), pDescriptor->getColumnCount());
}
copy(latCoeffs.begin(), latCoeffs.end(), mLatCoefficients);
copy(lonCoeffs.begin(), lonCoeffs.end(), mLonCoefficients);
// Generate a gridSize x gridSize grid of GCPs calculated from the
// frontwards (pixel-to-lat/lon) polynomial. Then generate the reverse
// (lat/lon-to-pixel) polynomial from this grid of GCPs.
const int gridSize = 30;
pixelValues.clear();
latlonValues.clear();
for (i = 0; i < gridSize; ++i)
{
for (j = 0; j < gridSize; ++j)
{
LocationType pixel;
LocationType latlon;
pixel.mX = i * mNumColumns / gridSize;
pixel.mY = j * mNumRows / gridSize;
latlon.mX = computePolynomial(pixel, mOrder, latCoeffs);
latlon.mY = computePolynomial(pixel, mOrder, lonCoeffs);
pixelValues.push_back(pixel);
latlonValues.push_back(latlon);
}
}
if (success)
{
success = computeFit(latlonValues, pixelValues, 0, pXCoeffs);
}
if (success)
{
success = computeFit(latlonValues, pixelValues, 1, pYCoeffs);
}
copy(pXCoeffs.begin(), pXCoeffs.end(), mXCoefficients);
copy(pYCoeffs.begin(), pYCoeffs.end(), mYCoefficients);
list<GcpPoint> newPoints;
list<GcpPoint>::iterator npIter;
for (i = 0, it = pGcpList->getSelectedPoints().begin(); it != pGcpList->getSelectedPoints().end(); ++it, ++i)
{
GcpPoint newPoint;
newPoint.mPixel.mX = it->mPixel.mX;
newPoint.mPixel.mY = it->mPixel.mY;
newPoint.mCoordinate.mX = it->mCoordinate.mX;
newPoint.mCoordinate.mY = it->mCoordinate.mY;
// If maxLonSeparation > 180.0 then this is a special case
if (maxLonSeparation > 180.0 && newPoint.mCoordinate.mY < 0.0)
{
newPoint.mCoordinate.mY = newPoint.mCoordinate.mY + 360.0;
}
LocationType newPixel = geoToPixel(newPoint.mCoordinate);
newPoint.mRmsError.mX = fabs(newPixel.mX - newPoint.mPixel.mX);
newPoint.mRmsError.mY = fabs(newPixel.mY - newPoint.mPixel.mY);
newPoints.push_back(newPoint);
}
pGcpList->clearPoints();
pGcpList->addPoints(newPoints);
mpGui = NULL;
if (mpRaster != NULL)
{
mpRaster->setGeoreferencePlugin(this);
}
pStep->finalize(Message::Success);
if (mpProgress)
{
mpProgress->updateProgress("GcpGeoreference finished.", 0, NORMAL);
}
return true;
}
bool KDISTRIBUTION::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList)
{
StepResource pStep("KDISTRIBUTION", "app10", "F298D57C-D816-42F0-AE27-43DAA02C0544");
if (pInArgList == NULL || pOutArgList == NULL)
{
return false;
}
Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
RasterElement* pCube = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg());
if (pCube == NULL)
{
std::string msg = "A raster cube must be specified.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pCube->getDataDescriptor());
VERIFY(pDesc != NULL);
FactoryResource<DataRequest> pRequest;
FactoryResource<DataRequest> pRequest2;
pRequest->setInterleaveFormat(BSQ);
pRequest2->setInterleaveFormat(BSQ);
DataAccessor pAcc = pCube->getDataAccessor(pRequest.release());
DataAccessor pAcc2 = pCube->getDataAccessor(pRequest2.release());
ModelResource<RasterElement> pResultCube(RasterUtilities::createRasterElement(pCube->getName() +
"Result", pDesc->getRowCount(), pDesc->getColumnCount(), pDesc->getDataType()));
if (pResultCube.get() == NULL)
{
std::string msg = "A raster cube could not be created.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
FactoryResource<DataRequest> pResultRequest;
pResultRequest->setWritable(true);
DataAccessor pDestAcc = pResultCube->getDataAccessor(pResultRequest.release());
const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pCube->getDataDescriptor());
int tester_count = 0;
int eastCol = 0;
int northRow = 0;
int westCol = 0;
int southRow = 0;
double zstatistic = 0;
double total = 0.0;
double total_sum = 0.0;
double mean = 0.0;
double std = 0.0;
double a=0;
int rowSize=pDesc->getRowCount();
int colSize=pDesc->getColumnCount();
int prevCol = 0;
int prevRow = 0;
int nextCol = 0;
int nextRow = 0;
double long PFA = 0.0;
int DEPTH1 = 10;
int DEPTH2 = 10;
int DEPTH3 = 1;
int DEPTH4 = 1;
int count=0;
int zero=0;
double long threshold = 100000.0;
double look_table1[24][6];
for(int i=0; i<24; i++)
{
for(int j=0; j<3; j++)
{
look_table1[i][j]=0.0;
}
}
QStringList Names("0.0000001");
QString value = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input a PFA value", "Input a PFA value (0.0000001 or 0.00000001)", Names);
std::string strAoi = value.toStdString();
std::istringstream stm;
stm.str(strAoi);
//stm >> PFA;
PFA=::atof(strAoi.c_str());
if (PFA==0.0000001)
{
look_table1[0][0]=1.0;
look_table1[0][1]=5.0;
look_table1[0][2]=32.3372530103729330;
look_table1[1][0]=1.0;
look_table1[1][1]=10.0;
look_table1[1][2]=25.0723580041031010;
look_table1[2][0]=1.0;
look_table1[2][1]=15.0;
look_table1[2][2]=22.3991160013551250;
look_table1[3][0]=1.0;
look_table1[3][1]=20.0;
look_table1[3][2]=20.9821949998985920;
look_table1[4][1]=1.0;
look_table1[4][2]=40.0;
look_table1[5][3]=18.7055519975583020;
look_table1[5][1]=1.0;
look_table1[5][2]=90.0;
look_table1[5][3]=18.7055519975583020;
look_table1[6][0]=2.0;
look_table1[6][1]=5.0;
look_table1[6][2]=20.2619339991581950;
look_table1[7][0]=2.0;
look_table1[7][1]=10.0;
look_table1[7][2]=15.4860609951617470;
look_table1[8][0]=2.0;
look_table1[8][1]=15.0;
look_table1[8][2]=13.7276789964777210;
look_table1[9][0]=2.0;
look_table1[9][1]=20.0;
look_table1[9][2]=12.7942589971762930;
look_table1[10][0]=2.0;
look_table1[10][1]=40.0;
look_table1[10][2]=11.2895769983023970;
look_table1[11][0]=2.0;
look_table1[11][1]=90.0;
look_table1[11][2]=10.3695259989909640;
look_table1[12][0]=3.0;
look_table1[12][1]=5.0;
look_table1[12][2]=15.9102209948443050;
look_table1[13][0]=3.0;
look_table1[13][1]=10.0;
look_table1[13][2]=12.0443629977375150;
look_table1[14][0]=3.0;
look_table1[14][1]=15.0;
look_table1[14][2]=10.6203179988032710;
look_table1[15][0]=3.0;
look_table1[15][1]=20.0;
look_table1[15][2]=9.8635499993696367;
look_table1[16][0]=3.0;
look_table1[16][1]=40.0;
look_table1[16][2]=8.6407550002847771;
look_table1[17][0]=3.0;
look_table1[17][1]=90.0;
look_table1[17][2]=7.8893780007488568;
look_table1[18][0]=4.0;
look_table1[18][1]=5.0;
look_table1[18][2]=13.6166519965608130;
look_table1[19][0]=4.0;
look_table1[19][1]=10.0;
look_table1[19][2]=10.2336029990926890;
look_table1[20][0]=4.0;
look_table1[20][1]=15.0;
look_table1[20][2]=10.6203179988032710;
look_table1[21][0]=4.0;
look_table1[21][1]=20.0;
look_table1[21][2]=8.9868610000257512;
look_table1[22][0]=4.0;
look_table1[22][1]=40.0;
look_table1[22][2]=7.2502150006595159;
look_table1[23][0]=4.0;
look_table1[23][1]=90.0;
look_table1[23][2]=6.5879140005669408;
}
if (PFA==0.00000001)
{
look_table1[0][0]=1.0;
look_table1[0][1]=5.0;
look_table1[0][2]=20.0000019988889410;
look_table1[1][0]=1.0;
look_table1[1][1]=10.0;
look_table1[1][2]=20.0000019988889410;
look_table1[2][0]=1.0;
look_table1[2][1]=15.0;
look_table1[2][2]=20.0000019988889410;
look_table1[3][0]=1.0;
look_table1[3][1]=20.0;
look_table1[3][2]=20.0000019988889410;
look_table1[4][1]=1.0;
look_table1[4][2]=40.0;
look_table1[5][3]=20.0000019988889410;
look_table1[5][1]=1.0;
look_table1[5][2]=90.0;
look_table1[5][3]=20.0000019988889410;
look_table1[6][0]=2.0;
look_table1[6][1]=5.0;
look_table1[6][2]=18.3243529971664460;
look_table1[7][0]=2.0;
look_table1[7][1]=10.0;
look_table1[7][2]=18.3243529971664460;
look_table1[8][0]=2.0;
look_table1[8][1]=15.0;
look_table1[8][2]=16.0869139948664570;
look_table1[9][0]=2.0;
look_table1[9][1]=20.0;
look_table1[9][2]=14.8998299956004820;
look_table1[10][0]=2.0;
look_table1[10][1]=40.0;
look_table1[10][2]=12.9846719970337880;
look_table1[11][0]=2.0;
look_table1[11][1]=90.0;
look_table1[11][2]=11.8094659979133120;
look_table1[12][0]=3.0;
look_table1[12][1]=5.0;
look_table1[12][2]=18.9816659978421360;
look_table1[13][0]=3.0;
look_table1[13][1]=10.0;
look_table1[13][2]=14.1167729961865230;
look_table1[14][0]=3.0;
look_table1[14][1]=15.0;
look_table1[14][2]=12.3304539975234050;
look_table1[15][0]=3.0;
look_table1[15][1]=20.0;
look_table1[15][2]=11.3819769982332450;
look_table1[16][0]=3.0;
look_table1[16][1]=40.0;
look_table1[16][2]=9.8488249993806569;
look_table1[17][0]=3.0;
look_table1[17][1]=90.0;
look_table1[17][2]=8.9039850000877756;
look_table1[18][0]=4.0;
look_table1[18][1]=5.0;
look_table1[18][2]=16.1272319949079020;
look_table1[19][0]=4.0;
look_table1[19][1]=10.0;
look_table1[19][2]=11.9117899978367330;
look_table1[20][0]=4.0;
look_table1[20][1]=15.0;
look_table1[20][2]=10.3636999989953240;
look_table1[21][0]=4.0;
look_table1[21][1]=20.0;
look_table1[21][2]=9.5411879996108926;
look_table1[22][0]=4.0;
look_table1[22][1]=40.0;
look_table1[22][2]=8.2095870006074634;
look_table1[23][0]=4.0;
look_table1[23][1]=90.0;
look_table1[23][2]=7.3860650006785047;
}
QStringList Names1("10");
QString value1 = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input the size of the window width", "Input the size of the window width in terms of the number of pixels (eg. 10)", Names1);
std::string strAoi1 = value1.toStdString();
std::istringstream stm1;
stm1.str(strAoi1);
//stm1 >> DEPTH1;
DEPTH1=::atof(strAoi1.c_str());
QStringList Names2("10");
QString value2 = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input the size of the window height", "Input the size of the window height in terms of the number of pixels (eg. 10)", Names2);
std::string strAoi2 = value2.toStdString();
std::istringstream stm2;
stm2.str(strAoi2);
//stm2 >> DEPTH2;
DEPTH2=::atof(strAoi2.c_str());
QStringList Names3("1");
QString value3 = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input the size of the gaurd width", "Input the size of the guard width in terms of the number of pixels (eg. 1)", Names3);
std::string strAoi3 = value3.toStdString();
std::istringstream stm3;
stm3.str(strAoi3);
//stm3 >> DEPTH3;
DEPTH3=::atof(strAoi3.c_str());
QStringList Names4("1");
QString value4 = QInputDialog::getItem(Service<DesktopServices>()->getMainWidget(),
"Input the size of the guard height", "Input the size of the guard height in terms of the number of pixels (eg. 1)", Names4);
std::string strAoi4 = value4.toStdString();
std::istringstream stm4;
stm4.str(strAoi4);
stm4 >> DEPTH4;
DEPTH4=::atof(strAoi4.c_str());
for (int row = 0; row < rowSize; ++row)
{
if (isAborted())
{
std::string msg = getName() + " has been aborted.";
pStep->finalize(Message::Abort, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ABORT);
}
return false;
}
if (!pAcc.isValid())
{
std::string msg = "Unable to access the cube data.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
if (pProgress != NULL)
{
pProgress->updateProgress("Calculating statistics", row * 100 / pDesc->getRowCount(), NORMAL);
}
for (int col = 0; col < colSize; ++col)
{
//p[col]=pAcc2->getColumnAsInteger();
westCol=max(col-DEPTH1,zero);
northRow=max(row-DEPTH2,zero);
eastCol=min(colSize-1,col+DEPTH1);
southRow=min(rowSize-1,row+DEPTH2);
prevCol=max(col-DEPTH3,zero);
prevRow=max(row-DEPTH4,zero);
nextCol=min(col+DEPTH3,colSize-1);
nextRow=min(row+DEPTH4,rowSize-1);
pAcc2->toPixel(northRow,westCol);
for(int row1=northRow; row1 < southRow+1; ++row1)
{
for (int col1=westCol; col1 < eastCol+1; ++col1)
{
if((row1>=prevRow && row1<=nextRow) && (col1>=prevCol && col1<=nextCol))
{
continue;
}
else
{
updateStatistics3(pAcc2->getColumnAsDouble(), total, total_sum, count);
}
pAcc2->nextColumn();
}
pAcc2->nextRow();
}
mean = total / count;
std = sqrt(total_sum / count - mean * mean);
int ELVI = (mean/std)*(mean/std);
int v = (ELVI+1)/((ELVI*mean/(std*std))-1);
pAcc2->toPixel(row,col);
pDestAcc->toPixel(row,col);
zstatistic = (pAcc2->getColumnAsDouble()-mean)/std;
if(v<=7 && v>=0)
{ v=5;
}
if(v<=12 && v>7)
{
v=10;
}
if(v<=17 && v>12)
{
v=15;
}
if(v<=30 && v>17)
{
v=20;
}
if(v<=65 && v>30)
{
v=40;
}
if(v<=90 && v>65)
{
v=90;
}
for(int i=0; i<24; i++)
{
if((look_table1[i][0]=ELVI) && (look_table1[i][1]==v))
{
threshold=look_table1[i][2];
}
}
if(zstatistic>threshold)
{
switchOnEncoding(pDesc->getDataType(), conversion1, pDestAcc->getColumn(), 1000.0);
}
else
{
switchOnEncoding(pDesc->getDataType(), conversion1, pDestAcc->getColumn(), 0.0);
}
total = 0.0;
total_sum=0.0;
threshold=100000.0;
mean = 0.0;
std = 0.0;
count=0;
pAcc->nextColumn();
}
pAcc->nextRow();
}
// Create a GCP layer
/*
SpatialDataWindow* pWindow = dynamic_cast<SpatialDataWindow*>(Service<DesktopServices>()->createWindow(pResultCube.get()->getName(), SPATIAL_DATA_WINDOW));
SpatialDataView* pView = pWindow->getSpatialDataView();
*/
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow(pResultCube->getName(),
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
std::string msg = "Unable to create view.";
pStep->finalize(Message::Failure, msg);
if (pProgress != NULL)
{
pProgress->updateProgress(msg, 0, ERRORS);
}
return false;
}
pView->setPrimaryRasterElement(pResultCube.get());
pView->createLayer(RASTER, pResultCube.get());
// Create the GCP list
if (pCube->isGeoreferenced() == true)
{
const vector<DimensionDescriptor>& rows = pDescriptor->getRows();
const vector<DimensionDescriptor>& columns = pDescriptor->getColumns();
if ((rows.empty() == false) && (columns.empty() == false))
{
// Get the geocoordinates at the chip corners
/*
VERIFYNRV(rows.front().isActiveNumberValid() == true);
VERIFYNRV(rows.back().isActiveNumberValid() == true);
VERIFYNRV(columns.front().isActiveNumberValid() == true);
VERIFYNRV(columns.back().isActiveNumberValid() == true);
*/
unsigned int startRow = rows.front().getActiveNumber();
unsigned int endRow = rows.back().getActiveNumber();
unsigned int startCol = columns.front().getActiveNumber();
unsigned int endCol = columns.back().getActiveNumber();
GcpPoint ulPoint;
ulPoint.mPixel = LocationType(startCol, startRow);
ulPoint.mCoordinate = pCube->convertPixelToGeocoord(ulPoint.mPixel);
GcpPoint urPoint;
urPoint.mPixel = LocationType(endCol, startRow);
urPoint.mCoordinate = pCube->convertPixelToGeocoord(urPoint.mPixel);
GcpPoint llPoint;
llPoint.mPixel = LocationType(startCol, endRow);
llPoint.mCoordinate = pCube->convertPixelToGeocoord(llPoint.mPixel);
GcpPoint lrPoint;
lrPoint.mPixel = LocationType(endCol, endRow);
lrPoint.mCoordinate = pCube->convertPixelToGeocoord(lrPoint.mPixel);
GcpPoint centerPoint;
centerPoint.mPixel = LocationType((startCol + endCol) / 2, (startRow + endRow) / 2);
centerPoint.mCoordinate = pCube->convertPixelToGeocoord(centerPoint.mPixel);
/*
// Reset the coordinates to be in active numbers relative to the chip
const vector<DimensionDescriptor>& chipRows = pDescriptor->getRows();
const vector<DimensionDescriptor>& chipColumns = pDescriptor->getColumns();
VERIFYNRV(chipRows.front().isActiveNumberValid() == true);
VERIFYNRV(chipRows.back().isActiveNumberValid() == true);
VERIFYNRV(chipColumns.front().isActiveNumberValid() == true);
VERIFYNRV(chipColumns.back().isActiveNumberValid() == true);
unsigned int chipStartRow = chipRows.front().getActiveNumber();
unsigned int chipEndRow = chipRows.back().getActiveNumber();
unsigned int chipStartCol = chipColumns.front().getActiveNumber();
unsigned int chipEndCol = chipColumns.back().getActiveNumber();
ulPoint.mPixel = LocationType(chipStartCol, chipStartRow);
urPoint.mPixel = LocationType(chipEndCol, chipStartRow);
llPoint.mPixel = LocationType(chipStartCol, chipEndRow);
lrPoint.mPixel = LocationType(chipEndCol, chipEndRow);
centerPoint.mPixel = LocationType((chipStartCol + chipEndCol) / 2, (chipStartRow + chipEndRow) / 2);
*/
Service<ModelServices> pModel;
GcpList* pGcpList = static_cast<GcpList*>(pModel->createElement("Corner Coordinates",
TypeConverter::toString<GcpList>(), pResultCube.get()));
if (pGcpList != NULL)
{
list<GcpPoint> gcps;
gcps.push_back(ulPoint);
gcps.push_back(urPoint);
gcps.push_back(llPoint);
gcps.push_back(lrPoint);
gcps.push_back(centerPoint);
pGcpList->addPoints(gcps);
pView->createLayer(GCP_LAYER, pGcpList);
}
}
}
if (pProgress != NULL)
{
pProgress->updateProgress("CFAR is compete.", 100, NORMAL);
}
pOutArgList->setPlugInArgValue("Result", pResultCube.release());
pStep->finalize();
return true;
}
bool DataMergeGui::mergeData()
{
// Service<ModelServices> pModel;
StepResource pStep("Data Merge Begin", "app", "5E4BCD48-E662-408b-93AF-F9127CE56C66");
if (mergeList->count() == 0)
{
QMessageBox::critical(NULL, "Spectral Data Merge", "No RasterElement to merge", "OK");
pStep->finalize(Message::Failure, "No RasterElement to merge");
return false;
}
// pProgress = new Progress(this, "Progress Reporter");
// std::vector<DataElement*> cubes = pModel->getElements("RasterElement");
/* if (mergeElementList.size() == 0)
{
QMessageBox::critical(NULL, "Spectral Data Merge", "No RasterElement input found!", "OK");
pStep->finalize(Message::Failure, "No RasterElement input found!");
return false;
} */
//QListWidgetItem *tmpItem = mergeList->item(i0);
//QString tmpItemText = tmpItem->text();
RasterElement* pInitData = extractRasterElement(mergeList->item(0)->text());
// vector<RasterElement*>::iterator initIter = mergeElementList.begin();
// RasterElement* pInitData = model_cast<RasterElement*>(*initIter);
if (pInitData == NULL)
{
pStep->finalize(Message::Failure, "Cube Data error!");
QMessageBox::critical(this, "Error", "pInitData Error");
return false;
}
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pInitData->getDataDescriptor());
EncodingType type = pDesc->getDataType();
int rowCount = pDesc->getRowCount();
int colCount = pDesc->getColumnCount();
int bandCount = mergeList->count();
RasterElement* pDesRaster = RasterUtilities::createRasterElement("DataMergeCube", rowCount,
colCount, bandCount, type, BIP, true, NULL);
if (pDesRaster == NULL)
{
QMessageBox::critical(NULL, "Spectral Data Merge", "Create RasterElement failed, Please close the previous merge result!", "OK");
pStep->finalize(Message::Failure, "No RasterElement input found!");
return false;
}
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BIP);
DataAccessor pDesAcc = pDesRaster->getDataAccessor(pRequest.release());
if (!pDesAcc.isValid())
{
QMessageBox::critical(NULL, "Spectral Data Merge", "pDesRaster Data Accessor Error!", "OK");
pStep->finalize(Message::Failure, "pDesRaster Data Accessor Error!");
return false;
}
if (pProgress == NULL)
{
QMessageBox::critical(NULL, "Spectral Data Merge", "pProgress Initialize Error!", "OK");
pStep->finalize(Message::Failure, "pProgress Error!");
return false;
}
// progressDialog = new QProgressDialog();
// progressDialog->setRange(0, rowCount);
//int index = 0;
for (int i = 0; i < mergeList->count(); i++)
{
QListWidgetItem *tmpItem = mergeList->item(i);
QString tmpItemText = tmpItem->text();
RasterElement* pData = extractRasterElement(tmpItemText);
int band = extractMergeBand(tmpItemText);
if (pData != NULL)
{
RasterDataDescriptor* pDesc = static_cast<RasterDataDescriptor*>(pData->getDataDescriptor());
if (rowCount != pDesc->getRowCount())
{
QMessageBox::critical(NULL, "Spectral Data Merge", "Merge Data Format Error!", "OK");
pStep->finalize(Message::Failure, "Merge Data Row Format Error!");
return false;
}
if (colCount != pDesc->getColumnCount())
{
QMessageBox::critical(NULL, "Spectral Data Merge", "Merge Data Format Error!", "OK");
pStep->finalize(Message::Failure, "Merge Data Column Format Error!");
return false;
}
// QMessageBox::about(this, "Test", "Here2");
FactoryResource<DataRequest> pRequest;
pRequest->setInterleaveFormat(BIP);
// pRequest->setWritable(true);
DataAccessor pSrcAcc = pData->getDataAccessor(pRequest.release());
switchOnEncoding(pDesc->getDataType(), mergeElement, NULL, rowCount,
colCount, pSrcAcc, pDesAcc, i, band, pProgress, mergeList->count());
// QMessageBox::about(this, "Test", "Here5");
}
else {
QMessageBox::critical(this, "Error", "pData is NULL");
return false;
}
// mergeElementList.push_back(filenameMap[tmpItemText.toStdString()]);
}
Service<DesktopServices> pDesktop;
SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>(pDesktop->createWindow("DataMergeResult",
SPATIAL_DATA_WINDOW));
SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView();
if (pView == NULL)
{
pStep->finalize(Message::Failure, "SpatialDataView error!");
return false;
}
pView->setPrimaryRasterElement(pDesRaster);
pView->createLayer(RASTER, pDesRaster);
if (pDesc != NULL)
{
const RasterFileDescriptor* pFileDescriptor = dynamic_cast<const RasterFileDescriptor*>(pDesc->getFileDescriptor());
if (pFileDescriptor != NULL)
{
Service<ModelServices> pModel;
if (pModel.get() != NULL)
{
list<GcpPoint> gcps;
gcps = pFileDescriptor->getGcps();
if (gcps.empty() == true)
{
if (pInitData->isGeoreferenced())
{
GcpPoint gcp;
// Lower left
gcp.mPixel.mX = 0.0;
gcp.mPixel.mY = 0.0;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
// Lower right
gcp.mPixel.mX = colCount - 1;
gcp.mPixel.mY = 0.0;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
// Upper left
gcp.mPixel.mX = 0.0;
gcp.mPixel.mY = rowCount - 1;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
// Upper right
gcp.mPixel.mX = colCount - 1;
gcp.mPixel.mY = rowCount - 1;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
// Center
gcp.mPixel.mX = colCount / 2.0;
gcp.mPixel.mY = rowCount / 2.0;
gcp.mCoordinate = pInitData->convertPixelToGeocoord(gcp.mPixel);
gcps.push_back(gcp);
}
}
if (gcps.empty() == false)
{
DataDescriptor* pGcpDescriptor = pModel->createDataDescriptor("Corner Coordinates",
"GcpList", pDesRaster);
if (pGcpDescriptor != NULL)
{
GcpList* pGcpList = static_cast<GcpList*>(pModel->createElement(pGcpDescriptor));
if (pGcpList != NULL)
{
// Add the GCPs to the GCP list
pGcpList->addPoints(gcps);
// Create the GCP list layer
pView->createLayer(GCP_LAYER, pGcpList);
}
}
}
}
}
}
return true;
}