//---------------------------------------------------------
bool CGrids_Product::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS" )->asGridList();
if( pGrids->Get_Count() < 1 )
{
Error_Set(_TL("no grid in list"));
return( false );
}
//-----------------------------------------------------
CSG_Grid *pResult = Parameters("RESULT")->asGrid();
bool bNoData = Parameters("NODATA")->asBool();
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
int n = 0;
double d = 0.0;
for(int i=0; i<pGrids->Get_Count(); i++)
{
if( pGrids->asGrid(i)->is_InGrid(x, y) )
{
if( n++ < 1 )
{
d = pGrids->asGrid(i)->asDouble(x, y);
}
else
{
d *= pGrids->asGrid(i)->asDouble(x, y);
}
}
}
if( bNoData ? n > 0 : n == pGrids->Get_Count() )
{
pResult->Set_Value(x, y, d);
}
else
{
pResult->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CLandsat_Import::On_Execute(void)
{
CSG_Strings Files;
if( !Parameters("FILES")->asFilePath()->Get_FilePaths(Files) || Files.Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Grid_List *pBands = Parameters("BANDS")->asGridList();
pBands->Del_Items();
for(int i=0; i<Files.Get_Count(); i++)
{
Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("loading"), SG_File_Get_Name(Files[i], false).c_str()));
CSG_Grid *pBand = Get_Band(Files[i]);
if( pBand )
{
pBands->Add_Item(pBand);
DataObject_Add(pBand);
DataObject_Set_Colors(pBand, 11, SG_COLORS_BLACK_WHITE);
}
}
//-----------------------------------------------------
if( Parameters("SHOW_RGB")->is_Enabled() && Parameters("SHOW_RGB")->asBool() )
{
CSG_Grid *pR = pBands->asGrid(Parameters("SHOW_R")->asInt());
CSG_Grid *pG = pBands->asGrid(Parameters("SHOW_G")->asInt());
CSG_Grid *pB = pBands->asGrid(Parameters("SHOW_B")->asInt());
if( pR && pG && pB )
{
DataObject_Set_Parameter(pR, "COLORS_TYPE" , 5); // _TL("RGB Overlay") // CLASSIFY_OVERLAY
DataObject_Set_Parameter(pR, "OVERLAY_MODE", 0); // _TL("red=this, green=1, blue=2")
DataObject_Set_Parameter(pR, "OVERLAY_G" , pG);
DataObject_Set_Parameter(pR, "OVERLAY_B" , pB);
DataObject_Update(pR, true);
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CXYZ_Export::On_Execute(void)
{
bool bExNoData;
int x, y, i;
TSG_Point p;
CSG_File Stream;
CSG_String FileName;
CSG_Parameter_Grid_List *pGrids;
pGrids = Parameters("GRIDS") ->asGridList();
FileName = Parameters("FILENAME")->asString();
bExNoData = Parameters("EX_NODATA")->asBool();
if( pGrids->Get_Count() > 0 && Stream.Open(FileName, SG_FILE_W, false) )
{
if( Parameters("CAPTION")->asBool() )
{
Stream.Printf(SG_T("\"X\"\t\"Y\""));
for(i=0; i<pGrids->Get_Count(); i++)
{
Stream.Printf(SG_T("\t\"%s\""), pGrids->asGrid(i)->Get_Name());
}
Stream.Printf(SG_T("\n"));
}
for(y=0, p.y=Get_YMin(); y<Get_NY() && Set_Progress(y); y++, p.y+=Get_Cellsize())
{
for(x=0, p.x=Get_XMin(); x<Get_NX(); x++, p.x+=Get_Cellsize())
{
if( !bExNoData || (bExNoData && !pGrids->asGrid(0)->is_NoData(x, y)) )
{
Stream.Printf(SG_T("%f\t%f"), p.x, p.y);
for(i=0; i<pGrids->Get_Count(); i++)
{
Stream.Printf(SG_T("\t%f"), pGrids->asGrid(i)->asDouble(x, y));
}
Stream.Printf(SG_T("\n"));
}
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGDAL_Export_GeoTIFF::On_Execute(void)
{
CSG_String File_Name, Options;
CSG_Projection Projection;
CSG_Parameter_Grid_List *pGrids;
CSG_GDAL_DataSet DataSet;
//-----------------------------------------------------
pGrids = Parameters("GRIDS") ->asGridList();
File_Name = Parameters("FILE") ->asString();
Options = Parameters("OPTIONS") ->asString();
Get_Projection(Projection);
//-----------------------------------------------------
if( !DataSet.Open_Write(File_Name, SG_T("GTiff"), Options, SG_Get_Grid_Type(pGrids), pGrids->Get_Count(), *Get_System(), Projection) )
{
return( false );
}
//-----------------------------------------------------
for(int i=0; i<pGrids->Get_Count(); i++)
{
Process_Set_Text(CSG_String::Format(SG_T("%s %d"), _TL("Band"), i + 1));
DataSet.Write(i, pGrids->asGrid(i));
}
if( !DataSet.Close() )
{
return( false );
}
return( true );
}
//---------------------------------------------------------
bool CSelect_Grid_From_List::On_Execute(void)
{
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
if( pGrids->Get_Count() <= 0 )
{
Error_Set(_TL("no grids in list"));
return( false );
}
int Index = Parameters("INDEX")->asInt();
if( Index >= pGrids->Get_Count() )
{
Error_Set(_TL("index out of range"));
return( false );
}
Parameters("GRID")->Set_Value(pGrids->asGrid(Index));
return( true );
}
bool CCreateGridSystem::On_Execute(void)
{
CSG_Grid *pDummy;
CSG_Shapes *pShapes;
CSG_Rect extent;
CSG_Parameter_Shapes_List *pShapesList;
CSG_Parameter_Grid_List *pGridList;
CSG_Grid_System System;
double xMin, xMax, yMin, yMax, cellsize, offset_x, offset_y, xRange, yRange, n, initVal;
int NX, NY, m_extent, m_adjust, i;
bool useoff;
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMIN")->asDouble();
xMax = Parameters("XMAX")->asDouble();
yMax = Parameters("YMAX")->asDouble();
NX = Parameters("NX")->asInt();
NY = Parameters("NY")->asInt();
cellsize = Parameters("CELLSIZE")->asDouble();
offset_x = Parameters("XOFFSET")->asDouble();
offset_y = Parameters("YOFFSET")->asDouble();
useoff = Parameters("USEOFF")->asBool();
m_extent = Parameters("M_EXTENT")->asInt();
m_adjust = Parameters("ADJUST")->asInt();
initVal = Parameters("INIT")->asDouble();
pShapesList = Parameters("SHAPESLIST")->asShapesList();
pGridList = Parameters("GRIDLIST")->asGridList();
if( useoff )
{
xMin += offset_x;
yMin += offset_y;
xMax += offset_x;
yMax += offset_y;
}
switch( m_extent )
{
case 0: // xMin, yMin, NX, NY
System.Assign(cellsize, xMin, yMin, NX, NY);
break;
case 1: // xMin, yMin, xMax, yMax
if( xMin > xMax || yMin > yMax )
{
Message_Add(CSG_String::Format(_TL("\nError: Please verify your xMin, yMin, xMax, yMax settings!\n")));
return false;
}
xRange = xMax - xMin;
yRange = yMax - yMin;
if( m_adjust == 0 ) // extent to cellsize
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else if( m_adjust == 1) // cellsize to W-E extent
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) (xRange/cellsize);
cellsize = xRange/NX;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else // cellsize to S-N extent
{
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) (yRange/cellsize);
cellsize = yRange/NY;
}
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
}
System.Assign(cellsize, xMin, yMin, xMax, yMax);
break;
case 2: // Shape(s)
if( pShapesList == NULL || pShapesList->Get_Count() == 0)
{
Message_Add(CSG_String::Format(_TL("\nError: the method Extent by Shape(s) requires shape(s) as input!\n")));
return false;
}
for (i=0; i<pShapesList->Get_Count(); i++)
{
pShapes = pShapesList->asShapes(i);
extent = pShapes->Get_Extent();
if (i==0)
{
xMin = extent.Get_XMin();
yMin = extent.Get_YMin();
xMax = extent.Get_XMax();
yMax = extent.Get_YMax();
}
else
{
xMin = (extent.Get_XMin() < xMin) ? extent.Get_XMin() : xMin;
yMin = (extent.Get_YMin() < yMin) ? extent.Get_YMin() : yMin;
xMax = (extent.Get_XMax() > xMax) ? extent.Get_XMax() : xMax;
yMax = (extent.Get_YMax() > yMax) ? extent.Get_YMax() : yMax;
}
}
if( useoff )
{
xMin += offset_x;
xMax += offset_x;
yMin += offset_y;
yMax += offset_y;
}
xRange = xMax - xMin;
yRange = yMax - yMin;
if( m_adjust == 0 ) // extent to cellsize
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else if( m_adjust == 1) // cellsize to W-E extent
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) (xRange/cellsize);
cellsize = xRange/NX;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else // cellsize to S-N extent
{
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) (yRange/cellsize);
cellsize = yRange/NY;
}
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
}
System.Assign(cellsize, xMin, yMin, xMax, yMax);
break;
case 3: // Grid(s)
if( pGridList == NULL || pGridList->Get_Count() == 0)
{
Message_Add(CSG_String::Format(_TL("\nError: the method Extent by Grid(s) requires grid(s) as input!\n")));
return false;
}
for (i=0; i<pGridList->Get_Count(); i++)
{
pDummy = pGridList->asGrid(i);
extent = pDummy->Get_Extent();
if (i==0)
{
xMin = extent.Get_XMin();
yMin = extent.Get_YMin();
xMax = extent.Get_XMax();
yMax = extent.Get_YMax();
}
else
{
xMin = (extent.Get_XMin() < xMin) ? extent.Get_XMin() : xMin;
yMin = (extent.Get_YMin() < yMin) ? extent.Get_YMin() : yMin;
xMax = (extent.Get_XMax() > xMax) ? extent.Get_XMax() : xMax;
yMax = (extent.Get_YMax() > yMax) ? extent.Get_YMax() : yMax;
}
}
if( useoff )
{
xMin += offset_x;
xMax += offset_x;
yMin += offset_y;
yMax += offset_y;
}
xRange = xMax - xMin;
yRange = yMax - yMin;
if( m_adjust == 0 ) // extent to cellsize
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else if( m_adjust == 1) // cellsize to W-E extent
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) (xRange/cellsize);
cellsize = xRange/NX;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else // cellsize to S-N extent
{
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) (yRange/cellsize);
cellsize = yRange/NY;
}
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
}
System.Assign(cellsize, xMin, yMin, xMax, yMax);
break;
}
pDummy = SG_Create_Grid(System, SG_DATATYPE_Double);
pDummy->Assign(initVal);
pDummy->Set_Name(_TL("Dummy Grid"));
Parameters("GRID")->Set_Value(pDummy);
return (true);
}
//---------------------------------------------------------
bool CGDAL_Export::On_Execute(void)
{
char **pOptions = NULL;
int x, y, n;
double *zLine;
CSG_String File_Name;
CSG_Parameter_Grid_List *pGrids;
CSG_Grid *pGrid;
GDALDataType gdal_Type;
GDALDriver *pDriver;
GDALDataset *pDataset;
GDALRasterBand *pBand;
//-----------------------------------------------------
pGrids = Parameters("GRIDS") ->asGridList();
File_Name = Parameters("FILE") ->asString();
//-----------------------------------------------------
switch( Parameters("TYPE")->asInt() )
{
default:
case 0: gdal_Type = g_GDAL_Driver.Get_GDAL_Type(pGrids); break; // match input data
case 1: gdal_Type = GDT_Byte; break; // Eight bit unsigned integer
case 2: gdal_Type = GDT_UInt16; break; // Sixteen bit unsigned integer
case 3: gdal_Type = GDT_Int16; break; // Sixteen bit signed integer
case 4: gdal_Type = GDT_UInt32; break; // Thirty two bit unsigned integer
case 5: gdal_Type = GDT_Int32; break; // Thirty two bit signed integer
case 6: gdal_Type = GDT_Float32; break; // Thirty two bit floating point
case 7: gdal_Type = GDT_Float64; break; // Sixty four bit floating point
}
//-----------------------------------------------------
if( (pDriver = g_GDAL_Driver.Get_Driver(SG_STR_SGTOMB(m_DriverNames[Parameters("FORMAT")->asInt()]))) == NULL )
{
Message_Add(_TL("Driver not found."));
}
else if( CSLFetchBoolean(pDriver->GetMetadata(), GDAL_DCAP_CREATE, false) == false )
{
Message_Add(_TL("Driver does not support file creation."));
}
else if( (pDataset = pDriver->Create(File_Name.b_str(), Get_NX(), Get_NY(), pGrids->Get_Count(), gdal_Type, pOptions)) == NULL )
{
Message_Add(_TL("Could not create dataset."));
}
else
{
g_GDAL_Driver.Set_Transform(pDataset, Get_System());
if( pGrids->asGrid(0)->Get_Projection().Get_Type() != SG_PROJ_TYPE_CS_Undefined )
{
pDataset->SetProjection(SG_STR_SGTOMB(pGrids->asGrid(0)->Get_Projection().Get_WKT()));
}
zLine = (double *)SG_Malloc(Get_NX() * sizeof(double));
for(n=0; n<pGrids->Get_Count(); n++)
{
Process_Set_Text(CSG_String::Format(SG_T("%s %d"), _TL("Band"), n + 1));
pGrid = pGrids->asGrid(n);
pBand = pDataset->GetRasterBand(n + 1);
for(y=0; y<Get_NY() && Set_Progress(y, Get_NY()); y++)
{
for(x=0; x<Get_NX(); x++)
{
zLine[x] = pGrid->asDouble(x, Get_NY() - 1 - y);
}
pBand->RasterIO(GF_Write, 0, y, Get_NX(), 1, zLine, Get_NX(), 1, GDT_Float64, 0, 0);
}
}
//-------------------------------------------------
SG_Free(zLine);
GDALClose(pDataset);
return( true );
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CFuzzyOR::On_Execute(void)
{
int Type;
CSG_Grid *pOR;
CSG_Parameter_Grid_List *pGrids;
//-----------------------------------------------------
pGrids = Parameters("GRIDS") ->asGridList();
pOR = Parameters("OR") ->asGrid();
Type = Parameters("TYPE") ->asInt();
//-----------------------------------------------------
if( pGrids->Get_Count() < 1 )
{
return( false );
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
bool bNoData = pGrids->asGrid(0)->is_NoData(x, y);
double OR = pGrids->asGrid(0)->asDouble (x, y);
for(int i=1; i<pGrids->Get_Count() && !bNoData; i++)
{
if( !(bNoData = pGrids->asGrid(i)->is_NoData(x, y)) )
{
double iz = pGrids->asGrid(i)->asDouble(x, y);
switch( Type )
{
case 0:
if( OR < iz )
{
OR = iz;
}
break;
case 1:
OR = OR + iz - OR * iz;
break;
case 2:
if( (OR = OR + iz) > 1.0 )
{
OR = 1.0;
}
break;
}
}
}
if( bNoData )
{
pOR->Set_NoData(x, y);
}
else
{
pOR->Set_Value(x, y, OR);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPanSharp_CN::On_Execute(void)
{
//-----------------------------------------------------
TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt());
//-----------------------------------------------------
int i;
CSG_Grid *pPan = Parameters("PAN")->asGrid();
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS" )->asGridList();
CSG_Parameter_Grid_List *pSharp = Parameters("SHARPEN")->asGridList();
//-----------------------------------------------------
pSharp->Del_Items();
for(i=0; i<pGrids->Get_Count(); i++)
{
Process_Set_Text(CSG_String::Format("%s: %s ...", _TL("Resampling"), pGrids->asGrid(i)->Get_Name()));
CSG_Grid *pGrid = SG_Create_Grid(*Get_System());
pGrid->Set_Name (pGrids->asGrid(i)->Get_Name());
pGrid->Assign (pGrids->asGrid(i), Resampling);
pSharp->Add_Item(pGrid);
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for private(i)
for(int x=0; x<Get_NX(); x++)
{
double Sum = 0.0;
if( !pPan->is_NoData(x, y) )
{
for(i=0; i<pSharp->Get_Count(); i++)
{
if( !pSharp->asGrid(i)->is_NoData(x, y) )
{
Sum += pSharp->asGrid(i)->asDouble(x, y);
}
else
{
Sum = 0.0;
break;
}
}
}
if( Sum )
{
Sum = pPan->asDouble(x, y) * pSharp->Get_Count() / (Sum + pSharp->Get_Count());
for(i=0; i<pSharp->Get_Count(); i++)
{
pSharp->asGrid(i)->Mul_Value(x, y, Sum);
}
}
else
{
for(i=0; i<pSharp->Get_Count(); i++)
{
pSharp->asGrid(i)->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CTIN_From_Grid_Specific_Points::On_Execute(void)
{
bool bResult;
int x, y, i;
CSG_TIN *pTIN;
CSG_Grid *pGrid, Grid;
CSG_Parameter_Grid_List *pValues;
CSG_Shape *pPoint;
CSG_Shapes Points;
//-----------------------------------------------------
pGrid = Parameters("GRID")->asGrid();
Grid.Create(pGrid, SG_DATATYPE_Byte);
//-----------------------------------------------------
switch( Parameters("METHOD")->asInt() )
{
default:
bResult = false;
break;
case 0:
bResult = Get_MarkHighestNB (&Grid, pGrid);
break;
case 1:
bResult = Get_OppositeNB (&Grid, pGrid, Parameters("HIGH")->asInt());
break;
case 2:
bResult = Get_FlowDirection (&Grid, pGrid,
(int)Parameters("FLOW")->asRange()->Get_LoVal(),
(int)Parameters("FLOW")->asRange()->Get_HiVal()
);
break;
case 3:
bResult = Get_FlowDirection2(&Grid, pGrid,
(int)Parameters("FLOW")->asRange()->Get_HiVal()
);
break;
case 4:
bResult = Get_Peucker (&Grid, pGrid, Parameters("PEUCKER")->asDouble());
break;
}
//-----------------------------------------------------
if( bResult )
{
pValues = Parameters("VALUES")->asGridList();
Points.Create(SHAPE_TYPE_Point);
Points.Add_Field(_TL("VALUE"), SG_DATATYPE_Double);
for(i=0; i<pValues->Get_Count(); i++)
{
Points.Add_Field(pValues->asGrid(i)->Get_Name(), SG_DATATYPE_Double);
}
for(y=0; y<Get_NY() && Set_Progress(y, Get_NY()); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( Grid.asInt(x, y) != 0 )
{
pPoint = Points.Add_Shape();
pPoint->Add_Point(
Get_XMin() + Get_Cellsize() * x,
Get_YMin() + Get_Cellsize() * y
);
pPoint->Set_Value(0, pGrid->asDouble(x, y));
for(i=0; i<pValues->Get_Count(); i++)
{
pPoint->Set_Value(1 + i, pValues->asGrid(i)->asDouble(x, y));
}
}
}
}
//-------------------------------------------------
if( Points.Get_Count() >= 3 )
{
pTIN = Parameters("TIN")->asTIN();
pTIN->Create(&Points);
pTIN->Set_Name(pGrid->Get_Name());
}
}
return( bResult );
}
//---------------------------------------------------------
bool CGridsFromTableAndGrid::On_Execute(void)
{
int iField, iRecord, iAttribute, nAttributes, *Attribute;
sLong iCell, jCell;
CSG_Parameter_Grid_List *pGrids;
CSG_Grid *pClasses;
CSG_Table *pTable;
//-----------------------------------------------------
pClasses = Parameters("CLASSES" )->asGrid();
pGrids = Parameters("GRIDS" )->asGridList();
pTable = Parameters("TABLE" )->asTable();
iField = Parameters("ID_FIELD")->asInt();
pGrids->Del_Items();
if( !pClasses->Set_Index() )
{
Error_Set(_TL("index creation failed"));
return( false );
}
//-----------------------------------------------------
if( pTable->Get_Field_Count() == 0 || pTable->Get_Count() == 0 )
{
Message_Add(_TL("selected table contains no valid records"));
return( false );
}
//-----------------------------------------------------
if( !pTable->Set_Index(iField, TABLE_INDEX_Ascending) )
{
Message_Add(_TL("failed to create index for table"));
return( false );
}
//-----------------------------------------------------
Attribute = new int[pTable->Get_Field_Count()];
for(iAttribute=0, nAttributes=0; iAttribute<pTable->Get_Field_Count(); iAttribute++)
{
if( iAttribute != iField && pTable->Get_Field_Type(iAttribute) != SG_DATATYPE_String )
{
Attribute[nAttributes++] = iAttribute;
CSG_Grid *pGrid = SG_Create_Grid(*Get_System());
pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pClasses->Get_Name(), pTable->Get_Field_Name(iAttribute)));
pGrids->Add_Item(pGrid);
}
}
if( nAttributes == 0 )
{
delete[](Attribute);
Message_Add(_TL("selected table does not have numeric attributes"));
return( false );
}
//-----------------------------------------------------
CSG_Table_Record *pRecord = pTable->Get_Record_byIndex(0);
for(iCell=0, iRecord=0; iCell<Get_NCells() && pRecord && Set_Progress_NCells(iCell); iCell++)
{
if( pClasses->Get_Sorted(iCell, jCell, false, true) )
{
double valClass = pClasses->asDouble(jCell);
while( pRecord && pRecord->asDouble(iField) < valClass )
{
pRecord = pTable->Get_Record_byIndex(++iRecord);
}
if( !pRecord || pRecord->asDouble(iField) > valClass )
{
for(iAttribute=0; iAttribute<nAttributes; iAttribute++)
{
pGrids->asGrid(iAttribute)->Set_NoData(jCell);
}
}
else
{
for(iAttribute=0; iAttribute<nAttributes; iAttribute++)
{
pGrids->asGrid(iAttribute)->Set_Value(jCell, pRecord->asDouble(Attribute[iAttribute]));
}
}
}
}
//-----------------------------------------------------
delete[](Attribute);
return true;
}
//---------------------------------------------------------
bool CGSGrid_Zonal_Statistics::On_Execute(void)
{
bool bShortNames;
int x, y, nCatGrids, nStatGrids, iGrid, zoneID, catID, NDcount, catLevel, NDcountStat;
double statID;
CSG_Grid *pZones, *pGrid, *pAspect;
CSG_Parameter_Grid_List *pCatList;
CSG_Parameter_Grid_List *pStatList;
CList_Conti *newZone, *startList, *runList, *newSub, *parent, *runSub, *subList;
CList_Stat *runStats;
CSG_Table *pOutTab;
CSG_Table_Record *pRecord;
CSG_String fieldName, tmpName;
pZones = Parameters("ZONES") ->asGrid();
pCatList = Parameters("CATLIST") ->asGridList();
pStatList = Parameters("STATLIST") ->asGridList();
pAspect = Parameters("ASPECT") ->asGrid();
pOutTab = Parameters("OUTTAB") ->asTable();
bShortNames = Parameters("SHORTNAMES") ->asBool();
nCatGrids = pCatList ->Get_Count();
nStatGrids = pStatList ->Get_Count();
NDcount = 0; // NoData Counter (ZoneGrid)
NDcountStat = 0; // NoData Counter (StatGrids)
if (pOutTab != NULL)
pOutTab->Destroy();
newZone = new CList_Conti(); // create first list entry (dummy)
startList = newZone;
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
runList = startList;
zoneID = pZones->asInt(x, y); // get zone ID
while( runList->next != NULL && runList->cat < zoneID ) // search for last entry in list or insert point
{
runList = runList->next;
}
if( runList->dummy == true )
{
runList->cat = zoneID; // first list entry, write and
runList->dummy = false; // setup
}
else if( runList->cat == zoneID )
runList = runList; // zoneID found
else if( runList->next == NULL && runList->cat < zoneID ) // append zoneID
{
newZone = new CList_Conti();
newZone->previous = runList;
runList->next = newZone;
newZone->cat = zoneID; // ... and write info
newZone->dummy = false;
runList = newZone;
}
else // insert new entry
{
newZone = new CList_Conti();
newZone->next = runList;
if( runList->previous != NULL )
{
newZone->previous = runList->previous;
runList->previous->next = newZone;
}
runList->previous = newZone;
if( runList == startList )
startList = newZone; // if new entry is first element, update startList pointer
newZone->cat = zoneID; // ... and write info
newZone->dummy = false;
runList = newZone;
}
for(iGrid=0; iGrid<nCatGrids; iGrid++) // collect categories
{
parent = runList;
if( runList->sub == NULL ) // no sub class found
{
newSub = new CList_Conti();
runList->sub = newSub;
}
runList = runList->sub;
pGrid = pCatList->asGrid(iGrid);
if( !pGrid->is_NoData(x, y) )
catID = pGrid->asInt(x, y);
else
catID = (int)pGrid->Get_NoData_Value();
while( runList->next != NULL && runList->cat < catID ) // search for last entry in list or insert point
{
runList = runList->next;
}
if( runList->dummy == true )
{
runList->cat = catID; // first list entry, write and
runList->dummy = false; // setup
runList->parent = parent;
}
else if( runList->cat == catID )
runList = runList; // zoneID found, all infos already written
else if( runList->next == NULL && runList->cat < catID) // append zoneID
{
newSub = new CList_Conti();
newSub->cat = catID; // ... and write info
newSub->previous = runList;
newSub->parent = parent;
newSub->dummy = false;
runList->next = newSub;
runList = newSub;
}
else // insert new entry
{
newSub = new CList_Conti();
newSub->cat = catID; // ... and write info
newSub->next = runList;
newSub->parent = parent;
newSub->dummy = false;
if( runList->previous != NULL )
{
newSub->previous = runList->previous;
runList->previous->next = newSub;
}
else
parent->sub = newSub;
runList->previous = newSub;
runList = newSub;
}
}
for(iGrid=0; iGrid<nStatGrids; iGrid++) // collect statistics for StatGrids
{
if( iGrid == 0 )
{
if( runList->stats == NULL )
runList->stats = new CList_Stat();
runStats = runList->stats;
}
else
{
if( runStats->next == NULL )
runStats->next = new CList_Stat();
runStats = runStats->next;
}
if( !pStatList->asGrid(iGrid)->is_NoData(x, y) )
{
statID = pStatList->asGrid(iGrid)->asDouble(x, y);
if( runStats->dummy == true )
{
runStats->min = statID;
runStats->max = statID;
runStats->dummy = false;
}
if( runStats->min > statID )
runStats->min = statID;
if( runStats->max < statID )
runStats->max = statID;
runStats->sum += statID;
runStats->dev += pow(statID, 2);
}
else
NDcountStat += 1;
}
if( pAspect != NULL )
{
for( int i=0; i<2; i++ )
{
if( nStatGrids == 0 && i == 0 )
{
if( runList->stats == NULL )
runList->stats = new CList_Stat();
runStats = runList->stats;
}
else
{
if( runStats->next == NULL )
runStats->next = new CList_Stat();
runStats = runStats->next;
}
if( !pAspect->is_NoData(x, y) )
{
statID = pAspect->asDouble(x, y);
if( i == 0 )
{
if( runStats->dummy == true )
{
runStats->min = statID;
runStats->max = statID;
runStats->dummy = false;
}
if( runStats->min > statID )
runStats->min = statID;
if( runStats->max < statID )
runStats->max = statID;
statID = sin(statID);
}
else
statID = cos(statID);
runStats->sum += statID;
}
else
NDcountStat += 1;
}
}
runList->count += 1; // sum up unique condition area
}
}
// Create fields in output table (1st = Zone, 2nd = Catgrid1, 3rd = Catgrid 2, ...)
fieldName = CSG_String::Format(SG_T("%s"),pZones->Get_Name()).BeforeFirst(SG_Char('.'));
if (bShortNames && fieldName.Length() > 10)
fieldName.Remove(10, fieldName.Length()-10);
pOutTab->Add_Field(fieldName, SG_DATATYPE_Int);
for(iGrid=0; iGrid<nCatGrids; iGrid++)
{
fieldName = CSG_String::Format(SG_T("%s"),pCatList->asGrid(iGrid)->Get_Name()).BeforeFirst(SG_Char('.'));
if (bShortNames && fieldName.Length() > 10)
fieldName.Remove(10, fieldName.Length()-10);
pOutTab->Add_Field(fieldName, SG_DATATYPE_Int);
}
pOutTab->Add_Field("Count", SG_DATATYPE_Int);
for( iGrid=0; iGrid<nStatGrids; iGrid++ )
{
tmpName = CSG_String::Format(SG_T("%s"),pStatList->asGrid(iGrid)->Get_Name()).BeforeFirst(SG_Char('.'));
fieldName = tmpName;
if (bShortNames && fieldName.Length()+3 > 10)
fieldName.Remove(7, fieldName.Length()-7);
pOutTab->Add_Field(CSG_String::Format(SG_T("%sMIN") , fieldName.c_str()), SG_DATATYPE_Double);
pOutTab->Add_Field(CSG_String::Format(SG_T("%sMAX") , fieldName.c_str()), SG_DATATYPE_Double);
fieldName = tmpName;
if (bShortNames && fieldName.Length()+4 > 10)
fieldName.Remove(6, fieldName.Length()-6);
pOutTab->Add_Field(CSG_String::Format(SG_T("%sMEAN") , fieldName.c_str()), SG_DATATYPE_Double);
fieldName = tmpName;
if (bShortNames && fieldName.Length()+6 > 10)
fieldName.Remove(4, fieldName.Length()-4);
pOutTab->Add_Field(CSG_String::Format(SG_T("%sSTDDEV"), fieldName.c_str()), SG_DATATYPE_Double);
fieldName = tmpName;
if (bShortNames && fieldName.Length()+3 > 10)
fieldName.Remove(7, fieldName.Length()-7);
pOutTab->Add_Field(CSG_String::Format(SG_T("%sSUM") , fieldName.c_str()), SG_DATATYPE_Double);
}
if( pAspect != NULL )
{
tmpName = CSG_String::Format(SG_T("%s"),pAspect->Get_Name()).BeforeFirst(SG_Char('.'));
fieldName = tmpName;
if (bShortNames && fieldName.Length()+3 > 10)
fieldName.Remove(7, fieldName.Length()-7);
pOutTab->Add_Field(CSG_String::Format(SG_T("%sMIN") , fieldName.c_str()), SG_DATATYPE_Double);
pOutTab->Add_Field(CSG_String::Format(SG_T("%sMAX") , fieldName.c_str()), SG_DATATYPE_Double);
fieldName = tmpName;
if (bShortNames && fieldName.Length()+4 > 10)
fieldName.Remove(6, fieldName.Length()-6);
pOutTab->Add_Field(CSG_String::Format(SG_T("%sMEAN") , fieldName.c_str()), SG_DATATYPE_Double);
}
while( startList != NULL ) // scan zone layer list and write cat values in table
{
runList = startList;
while( runList->sub != NULL ) // fall down to lowest layer
runList = runList->sub;
subList = runList; // use pointer to scan horizontal
while( subList != NULL ) // move forward and read all categories of this layer (including the parent layers)
{
runSub = subList;
catLevel = nCatGrids;
pRecord = pOutTab->Add_Record(); // create new record in table
pRecord->Set_Value((catLevel+1), runSub->count); // read/write field count
for(iGrid=0; iGrid<nStatGrids; iGrid++) // read/write statistics
{
if( iGrid == 0 )
runStats = runSub->stats;
else
runStats = runStats->next;
pRecord->Set_Value(catLevel+2+iGrid*5, runStats->min);
pRecord->Set_Value(catLevel+3+iGrid*5, runStats->max);
pRecord->Set_Value(catLevel+4+iGrid*5, runStats->sum/runSub->count);
pRecord->Set_Value(catLevel+5+iGrid*5, sqrt((runStats->dev - runSub->count*pow(runStats->sum/runSub->count, 2)) / (runSub->count - 1))); // sample
//pRecord->Set_Value(catLevel+5+iGrid*5, sqrt((runStats->dev - pow(runStats->sum/runSub->count, 2)) / runSub->count)); // population
pRecord->Set_Value(catLevel+6+iGrid*5, runStats->sum);
}
if( pAspect != NULL )
{
iGrid = nStatGrids * 5;
if( runSub->cat == pAspect->Get_NoData_Value() )
{
for( int i=2; i<5; i++ )
pRecord->Set_Value(catLevel+i+iGrid, 0.0);
}
else
{
double min, max, sumYcomp, sumXcomp, val, valYcomp, valXcomp;
if( nStatGrids == 0 )
runStats = runSub->stats;
else
runStats = runStats->next;
min = runStats->min;
max = runStats->max;
sumXcomp = runStats->sum;
runStats = runStats->next;
sumYcomp = runStats->sum;
pRecord ->Set_Value(catLevel+2+iGrid, min*M_RAD_TO_DEG);
pRecord ->Set_Value(catLevel+3+iGrid, max*M_RAD_TO_DEG);
valXcomp = sumXcomp / runSub->count;
valYcomp = sumYcomp / runSub->count;
val = valXcomp ? fmod(M_PI_270 + atan2(valYcomp, valXcomp), M_PI_360) : (valYcomp > 0 ? M_PI_270 : (valYcomp < 0 ? M_PI_090 : -1));
val = fmod(M_PI_360 - val, M_PI_360);
pRecord ->Set_Value(catLevel+4+iGrid, val*M_RAD_TO_DEG);
}
}
while( runSub != NULL ) // read/write categories
{
pRecord->Set_Value(catLevel, runSub->cat);
runSub = runSub->parent;
catLevel -= 1;
}
subList = subList->next;
}
while( runList->parent != NULL && runList->parent->next == NULL ) // move up to next 'Caterory with -> next'
runList = runList->parent;
if( runList->parent != NULL ) // if not upper layer (zones)
{
runList = runList->parent; // move to parent of next 'Caterory with -> next'
if( runList->next != NULL && runList->parent != NULL )
runList->parent->sub = runList->next; // redirect pointer to category which is next 'Categora with -> next' next
else if (runList->parent == NULL && runList->next != NULL )
startList = runList->next; // when upper layer (zones) is reached, move to next zone
else
startList = NULL; // reading finished
if( runList->parent == NULL )
startList = runList->next; // ?? when upper layer is reached, move to next zone
else
runList->sub = runList->sub->next; // on sub layers redirect pointer to ->next
}
else
{
if( nCatGrids == 0 )
startList = NULL;
else
startList = runList->next; // ?? upper layer is reached, move to next zone
}
runList->next = NULL;
delete (runList); // delete disconneted part of the list
}
if( NDcountStat > 0 )
{
Message_Add(CSG_String::Format(SG_T("\n\n\n%s: %d %s\n\n\n"), _TL("WARNING"), NDcountStat, _TL("NoData value(s) in statistic grid(s)!")));
}
return (true);
}
//---------------------------------------------------------
bool CGCS_Grid_Longitude_Range::On_Execute(void)
{
CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList();
CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList();
if( pInput->Get_Count() <= 0 )
{
Message_Dlg(_TL("nothing to do: no data in selection"));
return( false );
}
pOutput->Del_Items();
//-----------------------------------------------------
int xZero;
CSG_Grid_System Target;
//-----------------------------------------------------
if( Parameters("DIRECTION")->asInt() == 0 ) // 0 - 360 >> -180 - 180
{
if( Get_XMax() <= 180.0 )
{
Message_Add(_TL("Nothing to do. Raster is already within target range."));
return( true );
}
else if( Get_XMin() >= 180.0 )
{
xZero = 0;
Target.Assign(Get_Cellsize(), Get_XMin() - 360.0, Get_YMin(), Get_NX(), Get_NY());
}
else if( Get_XMax() - 360.0 < Get_XMin() - Get_Cellsize() )
{
Error_Set(_TL("Nothing to do be done. Raster splitting is not supported."));
return( false );
}
else
{
xZero = (int)(0.5 + 180.0 / Get_Cellsize());
Target.Assign(Get_Cellsize(), Get_XMin() - 180.0, Get_YMin(), Get_NX(), Get_NY());
}
}
//-----------------------------------------------------
else // -180 - 180 >> 0 - 360
{
if( Get_XMin() >= 0.0 )
{
Message_Add(_TL("Nothing to do. Raster is already within target range."));
return( true );
}
else if( Get_XMax() <= 0.0 )
{
xZero = 0;
Target.Assign(Get_Cellsize(), Get_XMin() + 360.0, Get_YMin(), Get_NX(), Get_NY());
}
else if( Get_XMin() + 360.0 > Get_XMax() + Get_Cellsize() )
{
Error_Set(_TL("Nothing to do be done. Raster splitting is not supported."));
return( false );
}
else
{
xZero = (int)(0.5 + 180.0 / Get_Cellsize());
Target.Assign(Get_Cellsize(), Get_XMin() - 180.0, Get_YMin(), Get_NX(), Get_NY());
}
}
//-----------------------------------------------------
for(int i=0; i<pInput->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Grid *pIn = pInput->asGrid(i);
CSG_Grid *pOut = SG_Create_Grid(Target, pIn->Get_Type());
pOut->Set_Name(pIn->Get_Name());
pOut->Set_NoData_Value_Range(pIn->Get_NoData_Value(), pIn->Get_NoData_hiValue());
pOut->Set_ZFactor(pIn->Get_ZFactor());
pOutput->Add_Item(pOut);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0, xx=xZero; x<Get_NX(); x++, xx++)
{
if( xx >= Get_NX() )
{
xx = 0;
}
pOut->Set_Value(xx, y, pIn->asDouble(x, y));
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGrid_Cluster_Analysis::_On_Execute(void)
{
int i, j, *nMembers, nCluster, nElements;
double *Variances, **Centroids, SP;
CSG_Grid **Grids, *pCluster;
CSG_Parameter_Grid_List *pGrids;
//-----------------------------------------------------
pGrids = Parameters("GRIDS") ->asGridList();
pCluster = Parameters("CLUSTER") ->asGrid();
nCluster = Parameters("NCLUSTER")->asInt();
if( pGrids->Get_Count() < 1 )
{
return( false );
}
//-----------------------------------------------------
Grids = (CSG_Grid **)SG_Malloc(pGrids->Get_Count() * sizeof(CSG_Grid *));
if( Parameters("NORMALISE")->asBool() )
{
for(i=0; i<pGrids->Get_Count(); i++)
{
Grids[i] = SG_Create_Grid(pGrids->asGrid(i), SG_DATATYPE_Float);
Grids[i] ->Assign(pGrids->asGrid(i));
Grids[i] ->Standardise();
}
}
else
{
for(i=0; i<pGrids->Get_Count(); i++)
{
Grids[i] = pGrids->asGrid(i);
}
}
pCluster->Set_NoData_Value(-1.0);
pCluster->Assign_NoData();
nMembers = (int *)SG_Malloc(nCluster * sizeof(int));
Variances = (double *)SG_Malloc(nCluster * sizeof(double));
Centroids = (double **)SG_Malloc(nCluster * sizeof(double *));
for(i=0; i<nCluster; i++)
{
Centroids[i] = (double *)SG_Malloc(pGrids->Get_Count() * sizeof(double));
}
//-------------------------------------------------
switch( Parameters("METHOD")->asInt() )
{
case 0: SP = _MinimumDistance (Grids, pGrids->Get_Count(), pCluster, nCluster, nMembers, Variances, Centroids, nElements = Get_NCells()); break;
case 1: SP = _HillClimbing (Grids, pGrids->Get_Count(), pCluster, nCluster, nMembers, Variances, Centroids, nElements = Get_NCells()); break;
case 2: SP = _MinimumDistance (Grids, pGrids->Get_Count(), pCluster, nCluster, nMembers, Variances, Centroids, nElements = Get_NCells());
SP = _HillClimbing (Grids, pGrids->Get_Count(), pCluster, nCluster, nMembers, Variances, Centroids, nElements = Get_NCells()); break;
}
//-------------------------------------------------
if( Parameters("NORMALISE")->asBool() )
{
for(i=0; i<pGrids->Get_Count(); i++)
{
delete(Grids[i]);
for(j=0; j<nCluster; j++)
{
Centroids[j][i] = pGrids->asGrid(i)->Get_StdDev() * Centroids[j][i] + pGrids->asGrid(i)->Get_Mean();
}
}
}
//-------------------------------------------------
Save_LUT(pCluster);
//-------------------------------------------------
int iCluster, iFeature;
CSG_String s;
CSG_Table_Record *pRecord;
CSG_Table *pTable;
pTable = Parameters("STATISTICS")->asTable();
pTable->Destroy();
pTable->Set_Name(_TL("Cluster Analysis"));
pTable->Add_Field(_TL("ClusterID") , SG_DATATYPE_Int);
pTable->Add_Field(_TL("Elements") , SG_DATATYPE_Int);
pTable->Add_Field(_TL("Std.Dev.") , SG_DATATYPE_Double);
s.Printf(SG_T("\n%s:\t%ld \n%s:\t%d \n%s:\t%d \n%s:\t%f\n\n%s\t%s\t%s"),
_TL("Number of Elements") , nElements,
_TL("Number of Variables") , pGrids->Get_Count(),
_TL("Number of Clusters") , nCluster,
_TL("Standard Deviation") , sqrt(SP),
_TL("Cluster"), _TL("Elements"), _TL("Std.Dev.")
);
for(iFeature=0; iFeature<pGrids->Get_Count(); iFeature++)
{
s += CSG_String::Format(SG_T("\t%s"), pGrids->asGrid(iFeature)->Get_Name());
pTable->Add_Field(pGrids->asGrid(iFeature)->Get_Name(), SG_DATATYPE_Double);
}
Message_Add(s);
for(iCluster=0; iCluster<nCluster; iCluster++)
{
Variances[iCluster] = nMembers[iCluster] ? Variances[iCluster] / nMembers[iCluster] : 0.0;
s.Printf(SG_T("\n%d\t%d\t%f"), iCluster, nMembers[iCluster], sqrt(Variances[iCluster]));
pRecord = pTable->Add_Record();
pRecord->Set_Value(0, iCluster);
pRecord->Set_Value(1, nMembers[iCluster]);
pRecord->Set_Value(2, sqrt(Variances[iCluster]));
for(iFeature=0; iFeature<pGrids->Get_Count(); iFeature++)
{
double Centroid = Centroids[iCluster][iFeature];
if( Parameters("NORMALISE")->asBool() )
{
Centroid = pGrids->asGrid(iFeature)->Get_Mean() + Centroid * pGrids->asGrid(iFeature)->Get_StdDev();
}
s += CSG_String::Format(SG_T("\t%f"), Centroid);
pRecord->Set_Value(iFeature + 3, Centroid);
}
Message_Add(s, false);
}
//-------------------------------------------------
for(i=0; i<nCluster; i++)
{
SG_Free(Centroids[i]);
}
SG_Free(Centroids);
SG_Free(Variances);
SG_Free(nMembers);
SG_Free(Grids);
return( true );
}
//---------------------------------------------------------
bool CGrid_Cluster_Analysis::On_Execute(void)
{
if( Parameters("OLDVERSION")->asBool() ) { return( _On_Execute() ); }
//-----------------------------------------------------
bool bNormalize;
int iFeature;
sLong iElement, nElements;
CSG_Cluster_Analysis Analysis;
CSG_Grid *pCluster;
CSG_Parameter_Grid_List *pGrids;
//-----------------------------------------------------
pGrids = Parameters("GRIDS" )->asGridList();
pCluster = Parameters("CLUSTER" )->asGrid();
bNormalize = Parameters("NORMALISE")->asBool();
if( !Analysis.Create(pGrids->Get_Count()) )
{
return( false );
}
//-----------------------------------------------------
pCluster->Set_NoData_Value(0.0);
for(iElement=0, nElements=0; iElement<Get_NCells() && Set_Progress_NCells(iElement); iElement++)
{
bool bNoData = false;
for(iFeature=0; iFeature<pGrids->Get_Count() && !bNoData; iFeature++)
{
if( pGrids->asGrid(iFeature)->is_NoData(iElement) )
{
bNoData = true;
}
}
if( bNoData || !Analysis.Add_Element() )
{
pCluster->Set_Value(iElement, 0);
}
else
{
pCluster->Set_Value(iElement, 1);
for(iFeature=0; iFeature<pGrids->Get_Count(); iFeature++)
{
double d = pGrids->asGrid(iFeature)->asDouble(iElement);
if( bNormalize )
{
d = (d - pGrids->asGrid(iFeature)->Get_Mean()) / pGrids->asGrid(iFeature)->Get_StdDev();
}
Analysis.Set_Feature(nElements, iFeature, d);
}
nElements++;
}
}
if( nElements <= 1 )
{
return( false );
}
//-----------------------------------------------------
bool bResult = Analysis.Execute(
Parameters("METHOD" )->asInt(),
Parameters("NCLUSTER")->asInt(),
Parameters("MAXITER" )->asInt()
);
for(iElement=0, nElements=0; iElement<Get_NCells(); iElement++)
{
Set_Progress_NCells(iElement);
if( !pCluster->is_NoData(iElement) )
{
pCluster->Set_Value(iElement, 1 + Analysis.Get_Cluster(nElements++));
}
}
Save_Statistics(pGrids, bNormalize, Analysis);
Save_LUT(pCluster);
return( bResult );
}
//---------------------------------------------------------
bool CGrid_Values_AddTo_Shapes::On_Execute(void)
{
CSG_Parameter_Grid_List *pGrids;
CSG_Shapes *pShapes;
//-----------------------------------------------------
pShapes = Parameters("RESULT")->asShapes();
pGrids = Parameters("GRIDS" )->asGridList();
//-----------------------------------------------------
if( pGrids->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
if( pShapes == NULL )
{
pShapes = Parameters("SHAPES")->asShapes();
}
else if( pShapes != Parameters("SHAPES")->asShapes() )
{
pShapes->Create(*Parameters("SHAPES")->asShapes());
}
//-----------------------------------------------------
switch( Parameters("RESAMPLING")->asInt() )
{
default: m_Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: m_Resampling = GRID_RESAMPLING_Bilinear; break;
case 2: m_Resampling = GRID_RESAMPLING_BicubicSpline; break;
case 3: m_Resampling = GRID_RESAMPLING_BSpline; break;
}
//-----------------------------------------------------
for(int iGrid=0; iGrid<pGrids->Get_Count(); iGrid++)
{
CSG_Grid *pGrid = pGrids->asGrid(iGrid);
int Field = pShapes->Get_Field_Count();
pShapes->Add_Field(pGrid->Get_Name(), SG_DATATYPE_Double);
for(int iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
CSG_Simple_Statistics Statistics;
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
if( pShape->Get_Extent().Intersects(pGrid->Get_Extent()) )
{
switch( pShapes->Get_Type() )
{
case SHAPE_TYPE_Point: default:
case SHAPE_TYPE_Points: Get_Data_Point (Statistics, pShape, pGrid); break;
case SHAPE_TYPE_Line: Get_Data_Line (Statistics, pShape, pGrid); break;
case SHAPE_TYPE_Polygon: Get_Data_Polygon(Statistics, pShape, pGrid); break;
}
}
if( Statistics.Get_Count() > 0 )
{
pShape->Set_Value(Field, Statistics.Get_Mean());
}
else
{
pShape->Set_NoData(Field);
}
}
}
//-----------------------------------------------------
if( pShapes == Parameters("SHAPES")->asShapes() )
{
DataObject_Update(pShapes);
}
return( true );
}
//---------------------------------------------------------
bool CWRF_Export::On_Execute(void)
{
CSG_String Directory;
CSG_Parameter_Grid_List *pGrids;
//-----------------------------------------------------
Directory = Parameters("FILE") ->asString();
pGrids = Parameters("GRIDS") ->asGridList();
//-----------------------------------------------------
m_Index.Reset();
switch( Parameters("DATATYPE")->asInt() )
{
case 0: default: m_Index.m_WORDSIZE = 1; m_Index.m_SIGNED = false; break;
case 1: m_Index.m_WORDSIZE = 1; m_Index.m_SIGNED = true; break;
case 2: m_Index.m_WORDSIZE = 2; m_Index.m_SIGNED = false; break;
case 3: m_Index.m_WORDSIZE = 2; m_Index.m_SIGNED = true; break;
case 4: m_Index.m_WORDSIZE = 4; m_Index.m_SIGNED = false; break;
case 5: m_Index.m_WORDSIZE = 4; m_Index.m_SIGNED = true; break;
}
m_Index.m_TYPE = Parameters("TYPE") ->asInt();
m_Index.m_MISSING_VALUE = Parameters("MISSING") ->asDouble();
m_Index.m_SCALE_FACTOR = Parameters("SCALE") ->asDouble();
m_Index.m_UNITS = Parameters("UNITS") ->asString();
m_Index.m_DESCRIPTION = Parameters("DESCRIPTION") ->asString();
m_Index.m_MMINLU = Parameters("MMINLU") ->asString();
m_Index.m_TILE_BDR = Parameters("TILE_BDR") ->asInt();
m_Index.m_TILE_X = Get_NX() - 2 * m_Index.m_TILE_BDR;
m_Index.m_TILE_Y = Get_NY() - 2 * m_Index.m_TILE_BDR;
m_Index.m_TILE_Z = pGrids->Get_Count();
m_Index.m_TILE_Z_START = 1;
m_Index.m_TILE_Z_END = pGrids->Get_Count();
m_Index.m_DX = Get_Cellsize();
m_Index.m_DY = Get_Cellsize();
m_Index.m_ENDIAN = VAL_ENDIAN_LITTLE;
m_Index.m_ROW_ORDER = VAL_BOTTOM_TOP;
m_Index.m_PROJECTION = Parameters("PROJECTION") ->asString();
m_Index.m_STDLON = Parameters("SDTLON") ->asDouble();
m_Index.m_TRUELAT1 = Parameters("TRUELAT1") ->asDouble();
m_Index.m_TRUELAT2 = Parameters("TRUELAT2") ->asDouble();
m_Index.m_KNOWN_LAT = - 90.0 + 0.5 * m_Index.m_DY;
m_Index.m_KNOWN_LON = -180.0 + 0.5 * m_Index.m_DX;
// m_Index.m_KNOWN_X = Parameters("KNOWN_X") ->asDouble();
// m_Index.m_KNOWN_Y = Parameters("KNOWN_Y") ->asDouble();
// m_Index.m_KNOWN_LAT = Parameters("KNOWN_LAT") ->asDouble();
// m_Index.m_KNOWN_LON = Parameters("KNOWN_LON") ->asDouble();
if( m_Index.m_TILE_Z == 1 )
{
m_Index.m_CATEGORY_MIN = m_Index.m_TYPE == VAL_CATEGORICAL ? (int)pGrids->asGrid(0)->Get_ZMin() : 0;
m_Index.m_CATEGORY_MAX = m_Index.m_TYPE == VAL_CATEGORICAL ? (int)pGrids->asGrid(0)->Get_ZMax() : 0;
}
else
{
m_Index.m_CATEGORY_MIN = m_Index.m_TILE_Z_START;
m_Index.m_CATEGORY_MAX = m_Index.m_TILE_Z_END;
}
m_Index.m_ISWATER = Parameters("ISWATER") ->asInt();
m_Index.m_ISLAKE = Parameters("ISLAKE") ->asInt();
m_Index.m_ISICE = Parameters("ISICE") ->asInt();
m_Index.m_ISURBAN = Parameters("ISURBAN") ->asInt();
m_Index.m_ISOILWATER = Parameters("ISOILWATER") ->asInt();
//-----------------------------------------------------
if( !m_Index.Save(SG_File_Make_Path(Directory, SG_T("index"))) )
{
Error_Set(_TL("error saving index file"));
return( false );
}
//-----------------------------------------------------
if( !Save(Directory, pGrids) )
{
Error_Set(_TL("error saving data file"));
return( false );
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPROJ4_Grid::On_Execute_Conversion(void)
{
TSG_Data_Type Type;
TSG_Rect Extent;
CSG_Grid *pSource, *pGrid;
CSG_Shapes *pShapes;
m_Interpolation = Parameters("INTERPOLATION")->asInt();
//-----------------------------------------------------
if( m_bInputList )
{
CSG_Parameter_Grid_List *pSources = Parameters("SOURCE")->asGridList();
CSG_Parameter_Grid_List *pTargets = Parameters("TARGET")->asGridList();
if( pSources->Get_Count() < 1 )
{
return( false );
}
pSource = pSources->asGrid(0);
pGrid = NULL;
pShapes = NULL;
Type = m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create new user defined grid...
if( Get_Target_Extent(pSource, Extent) && m_Grid_Target.Init_User(Extent, pSource->Get_NY()) && Dlg_Parameters("GET_USER") )
{
pGrid = m_Grid_Target.Get_User(Type);
}
break;
case 1: // select grid system...
if( Dlg_Parameters("<") && Get_Parameters("GET_SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System()->is_Valid() )
{
pGrid = SG_Create_Grid(*Get_Parameters("GET_SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System(), Type);
}
break;
case 2: // shapes...
if( Dlg_Parameters("GET_SHAPES") )
{
pShapes = Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->asShapes();
if( pShapes == DATAOBJECT_NOTSET || pShapes == DATAOBJECT_CREATE )
{
Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->Set_Value(pShapes = SG_Create_Shapes());
}
}
break;
}
//-------------------------------------------------
if( pShapes )
{
Parameters("SHAPES")->Set_Value(pShapes);
return( Set_Shapes(pSources, pShapes) );
}
if( pGrid )
{
pTargets->Del_Items();
pTargets->Add_Item(pGrid);
Init_Target(pSource, pGrid);
for(int i=1; i<pSources->Get_Count(); i++)
{
pTargets->Add_Item(SG_Create_Grid(pGrid->Get_System(), m_Interpolation == 0 ? pSources->asGrid(i)->Get_Type() : SG_DATATYPE_Float));
Init_Target(pSources->asGrid(i), pTargets->asGrid(i));
}
return( Set_Grids(pSources, pTargets) );
}
}
//-----------------------------------------------------
else
{
pSource = Parameters("SOURCE")->asGrid();
pGrid = NULL;
pShapes = NULL;
Type = m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create new user defined grid...
if( Get_Target_Extent(pSource, Extent) && m_Grid_Target.Init_User(Extent, pSource->Get_NY()) && Dlg_Parameters("GET_USER") )
{
pGrid = m_Grid_Target.Get_User(Type);
}
break;
case 1: // select grid...
if( Dlg_Parameters("GET_GRID") )
{
pGrid = m_Grid_Target.Get_Grid(Type);
}
break;
case 2: // shapes...
if( Dlg_Parameters("GET_SHAPES") )
{
pShapes = Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->asShapes();
if( pShapes == DATAOBJECT_NOTSET || pShapes == DATAOBJECT_CREATE )
{
Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->Set_Value(pShapes = SG_Create_Shapes());
}
}
break;
}
//-------------------------------------------------
if( pShapes )
{
Parameters("SHAPES")->Set_Value(pShapes);
return( Set_Shapes(pSource, pShapes) );
}
if( pGrid )
{
return( Set_Grid(pSource, pGrid) );
}
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CGSGrid_Statistics::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
if( pGrids->Get_Count() <= 1 )
{
Error_Set(_TL("no grids in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Grid *pMean = Parameters("MEAN" )->asGrid();
CSG_Grid *pMin = Parameters("MIN" )->asGrid();
CSG_Grid *pMax = Parameters("MAX" )->asGrid();
CSG_Grid *pRange = Parameters("RANGE" )->asGrid();
CSG_Grid *pSum = Parameters("SUM" )->asGrid();
CSG_Grid *pVar = Parameters("VAR" )->asGrid();
CSG_Grid *pStdDev = Parameters("STDDEV" )->asGrid();
CSG_Grid *pStdDevLo = Parameters("STDDEVLO")->asGrid();
CSG_Grid *pStdDevHi = Parameters("STDDEVHI")->asGrid();
CSG_Grid *pPercentile = Parameters("PCTL" )->asGrid();
if( !pMean && !pMin && !pMax && !pRange && !pSum && !pVar && !pStdDev && !pStdDevLo && !pStdDevHi && !pPercentile )
{
Error_Set(_TL("no parameter output specified"));
return( false );
}
double dRank = Parameters("PCTL_VAL")->asDouble() / 100.0;
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
CSG_Table Values;
CSG_Simple_Statistics s;
for(int i=0; i<pGrids->Get_Count(); i++)
{
if( !pGrids->asGrid(i)->is_NoData(x, y) )
{
double z = pGrids->asGrid(i)->asDouble(x, y);
s.Add_Value(z);
if( pPercentile )
{
if( Values.Get_Field_Count() == 0 )
{
Values.Add_Field("Z", SG_DATATYPE_Double);
}
Values.Add_Record()->Set_Value(0, z);
}
}
}
//-----------------------------------------
if( s.Get_Count() <= 0 )
{
if( pMean ) pMean ->Set_NoData(x, y);
if( pMin ) pMin ->Set_NoData(x, y);
if( pMax ) pMax ->Set_NoData(x, y);
if( pRange ) pRange ->Set_NoData(x, y);
if( pSum ) pSum ->Set_NoData(x, y);
if( pVar ) pVar ->Set_NoData(x, y);
if( pStdDev ) pStdDev ->Set_NoData(x, y);
if( pStdDevLo ) pStdDevLo ->Set_NoData(x, y);
if( pStdDevHi ) pStdDevHi ->Set_NoData(x, y);
if( pPercentile ) pPercentile ->Set_NoData(x, y);
}
else
{
if( pMean ) pMean ->Set_Value(x, y, s.Get_Mean());
if( pMin ) pMin ->Set_Value(x, y, s.Get_Minimum());
if( pMax ) pMax ->Set_Value(x, y, s.Get_Maximum());
if( pRange ) pRange ->Set_Value(x, y, s.Get_Range());
if( pSum ) pSum ->Set_Value(x, y, s.Get_Sum());
if( pVar ) pVar ->Set_Value(x, y, s.Get_Variance());
if( pStdDev ) pStdDev ->Set_Value(x, y, s.Get_StdDev());
if( pStdDevLo ) pStdDevLo ->Set_Value(x, y, s.Get_Mean() - s.Get_StdDev());
if( pStdDevHi ) pStdDevHi ->Set_Value(x, y, s.Get_Mean() + s.Get_StdDev());
if( pPercentile )
{
Values.Set_Index(0, TABLE_INDEX_Ascending);
pPercentile->Set_Value(x, y, Values.Get_Record_byIndex((int)(dRank * s.Get_Count()))->asDouble(0));
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CCropToData::On_Execute(void)
{
CSG_Parameter_Grid_List *pGrids = Parameters("INPUT")->asGridList();
//-----------------------------------------------------
if( pGrids->Get_Count() <= 0 )
{
Error_Set(_TL("no grids in selection"));
return( false );
}
//-----------------------------------------------------
bool bCrop = false;
int xMin, yMin, xMax, yMax;
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
bool bData = false;
for(int i=0; i<pGrids->Get_Count() && !bData; i++)
{
if( !pGrids->asGrid(i)->is_NoData(x, y) )
{
bData = true;
}
}
if( bData )
{
if( bCrop == false )
{
bCrop = true;
xMin = xMax = x;
yMin = yMax = y;
}
else
{
if( xMin > x )
{
xMin = x;
}
else if( xMax < x )
{
xMax = x;
}
if( yMin > y )
{
yMin = y;
}
else if( yMax < y )
{
yMax = y;
}
}
}
}
}
//-----------------------------------------------------
if( bCrop == false )
{
Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("nothing to crop"), _TL("no valid data found in grid(s)")));
}
else if( (1 + xMax - xMin) == Get_NX() && (1 + yMax - yMin) == Get_NY() )
{
Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("nothing to crop"), _TL("valid data cells match original grid extent")));
}
else
{
CSG_Parameter_Grid_List *pCropped = Parameters("OUTPUT")->asGridList();
pCropped->Del_Items();
for(int i=0; i<pGrids->Get_Count(); i++)
{
CSG_Grid *pGrid = SG_Create_Grid(
pGrids->asGrid(i)->Get_Type(),
1 + xMax - xMin,
1 + yMax - yMin,
Get_Cellsize(),
Get_XMin() + xMin * Get_Cellsize(),
Get_YMin() + yMin * Get_Cellsize()
);
pGrid->Assign(pGrids->asGrid(i), GRID_INTERPOLATION_NearestNeighbour);
pGrid->Set_Name(pGrids->asGrid(i)->Get_Name());
pCropped->Add_Item(pGrid);
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGSGrid_Statistics_To_Table::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
if( pGrids->Get_Count() < 1 )
{
Error_Set(_TL("no grids in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Table *pTable = Parameters("STATS")->asTable();
pTable->Destroy();
pTable->Set_Name(_TL("Statistics for Grids"));
pTable->Add_Field(_TL("NAME"), SG_DATATYPE_String);
if( Parameters("DATA_CELLS" )->asBool() ) pTable->Add_Field(_TL("DATA_CELLS" ), SG_DATATYPE_Int);
if( Parameters("NODATA_CELLS")->asBool() ) pTable->Add_Field(_TL("NODATA_CELLS"), SG_DATATYPE_Int);
if( Parameters("CELLSIZE" )->asBool() ) pTable->Add_Field(_TL("CELLSIZE" ), SG_DATATYPE_Double);
if( Parameters("MEAN" )->asBool() ) pTable->Add_Field(_TL("MEAN" ), SG_DATATYPE_Double);
if( Parameters("MIN" )->asBool() ) pTable->Add_Field(_TL("MIN" ), SG_DATATYPE_Double);
if( Parameters("MAX" )->asBool() ) pTable->Add_Field(_TL("MAX" ), SG_DATATYPE_Double);
if( Parameters("RANGE" )->asBool() ) pTable->Add_Field(_TL("RANGE" ), SG_DATATYPE_Double);
if( Parameters("VAR" )->asBool() ) pTable->Add_Field(_TL("VAR" ), SG_DATATYPE_Double);
if( Parameters("STDDEV" )->asBool() ) pTable->Add_Field(_TL("STDDEV" ), SG_DATATYPE_Double);
if( Parameters("STDDEVLO" )->asBool() ) pTable->Add_Field(_TL("STDDEVLO" ), SG_DATATYPE_Double);
if( Parameters("STDDEVHI" )->asBool() ) pTable->Add_Field(_TL("STDDEVHI" ), SG_DATATYPE_Double);
if( Parameters("PCTL" )->asBool() ) pTable->Add_Field(_TL("PCTL" ), SG_DATATYPE_Double);
if( pTable->Get_Field_Count() <= 1 )
{
Error_Set(_TL("no parameter output specified"));
return( false );
}
double dRank = Parameters("PCTL")->asBool() ? Parameters("PCTL_VAL")->asDouble() : -1.0;
//-----------------------------------------------------
for(int i=0; i<pGrids->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Grid *pGrid = pGrids->asGrid(i);
CSG_Table_Record *pRecord = pTable->Add_Record();
pRecord->Set_Value("NAME" , pGrid->Get_Name());
pRecord->Set_Value("DATA_CELLS" , pGrid->Get_NCells() - pGrid->Get_NoData_Count());
pRecord->Set_Value("NODATA_CELLS", pGrid->Get_NoData_Count());
pRecord->Set_Value("CELLSIZE" , pGrid->Get_Cellsize());
pRecord->Set_Value("MEAN" , pGrid->Get_ArithMean());
pRecord->Set_Value("MIN" , pGrid->Get_ZMin());
pRecord->Set_Value("MAX" , pGrid->Get_ZMax());
pRecord->Set_Value("RANGE" , pGrid->Get_ZRange());
pRecord->Set_Value("VAR" , pGrid->Get_Variance());
pRecord->Set_Value("STDDEV" , pGrid->Get_StdDev());
pRecord->Set_Value("STDDEVLO" , pGrid->Get_ArithMean() - pGrid->Get_StdDev());
pRecord->Set_Value("STDDEVHI" , pGrid->Get_ArithMean() + pGrid->Get_StdDev());
if( dRank > 0.0 && dRank < 100.0 )
{
pRecord->Set_Value("PCTL", pGrid->Get_Percentile(dRank)); // this is a time consuming operation
}
}
if( dRank > 0.0 && dRank < 100.0 )
{
pTable->Set_Field_Name(pTable->Get_Field_Count() - 1, CSG_String::Format(SG_T("%s%02d"), _TL("PCTL"), (int)dRank));
}
return( true );
}
//---------------------------------------------------------
bool CDirect_Georeferencing::On_Execute(void)
{
//-----------------------------------------------------
if( !m_Georeferencer.Set_Transformation(Parameters, Get_NX(), Get_NY()) )
{
return( false );
}
//-----------------------------------------------------
CSG_Grid *pDEM = Parameters("DEM" )->asGrid();
double zRef = Parameters("ZREF" )->asDouble();
bool bFlip = Parameters("ROW_ORDER")->asInt() == 1;
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline; break;
case 3: Resampling = GRID_RESAMPLING_BSpline; break;
}
//-----------------------------------------------------
TSG_Point p[4];
p[0] = m_Georeferencer.Image_to_World( 0, 0, zRef);
p[1] = m_Georeferencer.Image_to_World(Get_NX(), 0, zRef);
p[2] = m_Georeferencer.Image_to_World(Get_NX(), Get_NY(), zRef);
p[3] = m_Georeferencer.Image_to_World( 0, Get_NY(), zRef);
CSG_Rect r(p[0], p[1]); r.Union(p[2]); r.Union(p[3]);
//-----------------------------------------------------
CSG_Shapes *pShapes = Parameters("EXTENT")->asShapes();
if( pShapes )
{
pShapes->Create(SHAPE_TYPE_Polygon, _TL("Extent"));
pShapes->Add_Field(_TL("OID"), SG_DATATYPE_Int);
CSG_Shape *pExtent = pShapes->Add_Shape();
pExtent->Add_Point(p[0]);
pExtent->Add_Point(p[1]);
pExtent->Add_Point(p[2]);
pExtent->Add_Point(p[3]);
}
//-----------------------------------------------------
double Cellsize = SG_Get_Distance(p[0], p[1]) / Get_NX();
CSG_Grid_System System(Cellsize, r);
m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), r, Get_NX());
if( !Dlg_Parameters("TARGET") )
{
return( false );
}
System = m_Grid_Target.Get_System();
if( !System.is_Valid() )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList();
CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList();
pOutput->Del_Items();
if( pInput->Get_Count() <= 0 )
{
return( false );
}
else
{
TSG_Data_Type Type;
switch( Parameters("DATA_TYPE")->asInt() )
{
case 0: Type = SG_DATATYPE_Byte; break;
case 1: Type = SG_DATATYPE_Char; break;
case 2: Type = SG_DATATYPE_Word; break;
case 3: Type = SG_DATATYPE_Short; break;
case 4: Type = SG_DATATYPE_DWord; break;
case 5: Type = SG_DATATYPE_Int; break;
case 6: Type = SG_DATATYPE_Float; break;
case 7: Type = SG_DATATYPE_Double; break;
default: Type = SG_DATATYPE_Undefined; break;
}
for(int i=0; i<pInput->Get_Count(); i++)
{
CSG_Grid *pGrid = SG_Create_Grid(System, Type != SG_DATATYPE_Undefined ? Type : pInput->asGrid(i)->Get_Type());
if( !pGrid || !pGrid->is_Valid() )
{
if( pGrid )
{
delete(pGrid);
}
return( false );
}
pOutput->Add_Item(pGrid);
pGrid->Set_Name(pInput->asGrid(i)->Get_Name());
}
}
//-----------------------------------------------------
for(int y=0; y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y++)
{
double py = System.Get_YMin() + y * System.Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<System.Get_NX(); x++)
{
double pz, px = System.Get_XMin() + x * System.Get_Cellsize();
if( !pDEM || !pDEM->Get_Value(px, py, pz) )
{
pz = zRef;
}
TSG_Point p = m_Georeferencer.World_to_Image(px, py, pz);
if( bFlip )
{
p.y = (Get_NY() - 1) - p.y;
}
for(int i=0; i<pInput->Get_Count(); i++)
{
if( pInput->asGrid(i)->Get_Value(p.x, p.y, pz, Resampling) )
{
pOutput->asGrid(i)->Set_Value(x, y, pz);
}
else
{
pOutput->asGrid(i)->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGWR_Grid_Downscaling::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pPredictors = Parameters("PREDICTORS")->asGridList();
if( (m_nPredictors = pPredictors->Get_Count()) <= 0 )
{
return( false );
}
m_pDependent = Parameters("DEPENDENT")->asGrid();
if( !m_pDependent->Get_Extent().Intersects(Get_System()->Get_Extent()) )
{
return( false );
}
//-----------------------------------------------------
int i;
Process_Set_Text(_TL("upscaling of predictors"));
m_pPredictors = (CSG_Grid **)SG_Calloc(m_nPredictors , sizeof(CSG_Grid *));
m_pModel = (CSG_Grid **)SG_Calloc(m_nPredictors + 1, sizeof(CSG_Grid *));
for(i=0; i<m_nPredictors; i++)
{
m_pPredictors[i] = SG_Create_Grid(m_pDependent->Get_System());
m_pPredictors[i] ->Assign(pPredictors->asGrid(i), GRID_INTERPOLATION_NearestNeighbour); // GRID_INTERPOLATION_Mean_Cells
m_pModel [i] = SG_Create_Grid(m_pDependent->Get_System());
m_pModel [i] ->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pPredictors->asGrid(i)->Get_Name(), _TL("Factor")));
}
m_pModel[m_nPredictors] = SG_Create_Grid(m_pDependent->Get_System());
m_pModel[m_nPredictors] ->Set_Name(_TL("Intercept"));
//-----------------------------------------------------
Process_Set_Text(_TL("model creation"));
bool bResult = Get_Model();
//-----------------------------------------------------
for(i=0; i<m_nPredictors; i++)
{
delete(m_pPredictors[i]);
m_pPredictors[i] = pPredictors->asGrid(i);
}
//-----------------------------------------------------
if( bResult )
{
Process_Set_Text(_TL("downscaling"));
bResult = Set_Model();
}
//-----------------------------------------------------
if( Parameters("MODEL_OUT")->asBool() )
{
CSG_Parameter_Grid_List *pModel = Parameters("MODEL")->asGridList();
pModel->Del_Items();
pModel->Add_Item(m_pModel[m_nPredictors]);
for(i=0; i<m_nPredictors; i++)
{
pModel->Add_Item(m_pModel[i]);
}
}
else
{
for(i=0; i<=m_nPredictors; i++)
{
delete(m_pModel[i]);
}
}
SG_FREE_SAFE(m_pModel);
SG_FREE_SAFE(m_pPredictors);
return( bResult );
}
//---------------------------------------------------------
bool CGrid_Values_AddTo_Points::On_Execute(void)
{
int iShape, iGrid, iField, Offset, Interpolation;
double Value;
CSG_Shapes *pShapes;
CSG_Parameter_Grid_List *pGrids;
//-----------------------------------------------------
pShapes = Parameters("RESULT") ->asShapes();
pGrids = Parameters("GRIDS" ) ->asGridList();
Interpolation = Parameters("INTERPOL") ->asInt();
//-----------------------------------------------------
if( pGrids->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
if( pShapes == NULL )
{
pShapes = Parameters("SHAPES")->asShapes();
}
else if( pShapes != Parameters("SHAPES")->asShapes() )
{
pShapes->Create(*Parameters("SHAPES")->asShapes());
}
Offset = pShapes->Get_Field_Count();
//-----------------------------------------------------
for(iGrid=0; iGrid<pGrids->Get_Count(); iGrid++)
{
pShapes->Add_Field(pGrids->asGrid(iGrid)->Get_Name(), SG_DATATYPE_Double);
}
//-----------------------------------------------------
for(iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
for(iGrid=0, iField=Offset; iGrid<pGrids->Get_Count(); iGrid++, iField++)
{
CSG_Grid *pGrid = pGrids->asGrid(iGrid);
if( pGrid->Get_Value(pShape->Get_Point(0), Value, Interpolation) )
{
pShape->Set_Value(iField, Value);
}
else
{
pShape->Set_NoData(iField);
}
}
}
//-----------------------------------------------------
if( pShapes == Parameters("SHAPES")->asShapes() )
{
DataObject_Update(pShapes);
}
return( true );
}
//---------------------------------------------------------
bool CGW_Multi_Regression_Grid::On_Execute(void)
{
int i;
//-----------------------------------------------------
CSG_Parameter_Grid_List *pPredictors = Parameters("PREDICTORS")->asGridList();
if( !Initialize(Parameters("POINTS")->asShapes(), Parameters("DEPENDENT")->asInt(), pPredictors) )
{
Finalize();
return( false );
}
//-----------------------------------------------------
CSG_Grid Quality;
m_dimModel = *Get_System();
if( Parameters("RESOLUTION")->asInt() == 1 && Parameters("RESOLUTION_VAL")->asDouble() > Get_Cellsize() )
{
CSG_Rect r(Get_System()->Get_Extent()); r.Inflate(0.5 * Parameters("RESOLUTION_VAL")->asDouble(), false);
m_dimModel.Assign(Parameters("RESOLUTION_VAL")->asDouble(), r);
Quality.Create(m_dimModel);
m_pQuality = &Quality;
}
else
{
m_pQuality = Parameters("QUALITY")->asGrid();
}
//-----------------------------------------------------
Process_Set_Text(_TL("upsetting model domain"));
m_pPredictors = (CSG_Grid **)SG_Calloc(m_nPredictors , sizeof(CSG_Grid *));
m_pModel = (CSG_Grid **)SG_Calloc(m_nPredictors + 1, sizeof(CSG_Grid *));
for(i=0; i<m_nPredictors; i++)
{
if( m_dimModel.Get_Cellsize() > Get_Cellsize() ) // scaling
{
m_pPredictors[i] = SG_Create_Grid(m_dimModel);
m_pPredictors[i] ->Assign(pPredictors->asGrid(i), GRID_INTERPOLATION_NearestNeighbour); // GRID_INTERPOLATION_Mean_Cells
}
else
{
m_pPredictors[i] = pPredictors->asGrid(i);
}
m_pModel [i] = SG_Create_Grid(m_dimModel);
m_pModel [i] ->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pPredictors->asGrid(i)->Get_Name(), _TL("Factor")));
}
m_pModel[m_nPredictors] = SG_Create_Grid(m_dimModel);
m_pModel[m_nPredictors] ->Set_Name(_TL("Intercept"));
//-----------------------------------------------------
Process_Set_Text(_TL("model creation"));
bool bResult = Get_Model();
//-----------------------------------------------------
if( m_dimModel.Get_Cellsize() > Get_Cellsize() ) // scaling
{
for(i=0; i<m_nPredictors; i++)
{
delete(m_pPredictors[i]);
m_pPredictors[i] = pPredictors->asGrid(i);
}
}
//-----------------------------------------------------
if( bResult )
{
Process_Set_Text(_TL("model application"));
bResult = Set_Model();
}
//-----------------------------------------------------
if( Parameters("MODEL_OUT")->asBool() )
{
CSG_Parameter_Grid_List *pModel = Parameters("MODEL")->asGridList();
pModel->Del_Items();
pModel->Add_Item(m_pModel[m_nPredictors]);
for(i=0; i<m_nPredictors; i++)
{
pModel->Add_Item(m_pModel[i]);
}
}
else
{
for(i=0; i<=m_nPredictors; i++)
{
delete(m_pModel[i]);
}
}
SG_FREE_SAFE(m_pModel);
SG_FREE_SAFE(m_pPredictors);
Finalize();
return( bResult );
}
//---------------------------------------------------------
bool CPanSharp_PCA::On_Execute(void)
{
//-----------------------------------------------------
bool bResult;
CSG_Parameters Tool_Parms;
CSG_Table Eigen;
//-----------------------------------------------------
// get the principle components for the low resolution bands
SG_RUN_TOOL_KEEP_PARMS(bResult, "statistics_grid", 8, Tool_Parms,
SG_TOOL_PARAMETER_SET("GRIDS" , Parameters("GRIDS" ))
&& SG_TOOL_PARAMETER_SET("METHOD" , Parameters("METHOD"))
&& SG_TOOL_PARAMETER_SET("EIGEN" , &Eigen)
&& SG_TOOL_PARAMETER_SET("COMPONENTS", 0) // get all components
);
if( !bResult )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Grid_List *pPCA = Tool_Parms.Get_Parameter("PCA")->asGridList();
int i, n = pPCA->Get_Count();
CSG_Grid *PCA = new CSG_Grid[n];
CSG_Grid *pPan = Parameters("PAN")->asGrid();
//-----------------------------------------------------
// replace first principle component with the high resolution panchromatic band
Process_Set_Text(_TL("Replace first PC with PAN"));
double Offset_Pan, Offset, Scale;
if( Parameters("PAN_MATCH")->asInt() == 0 ) // scale PAN band to fit first PC histogram
{
Offset_Pan = pPan->Get_ZMin();
Offset = pPCA->asGrid(0)->Get_ZMin();
Scale = pPCA->asGrid(0)->Get_ZRange() / pPan->Get_ZRange();
}
else
{
Offset_Pan = pPan->Get_Mean();
Offset = pPCA->asGrid(0)->Get_Mean();
Scale = pPCA->asGrid(0)->Get_StdDev() / pPan->Get_StdDev();
}
PCA[0].Create(*Get_System());
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pPan->is_NoData(x, y) )
{
PCA[0].Set_NoData(x, y);
}
else
{
PCA[0].Set_Value(x, y, Offset + Scale * (pPan->asDouble(x, y) - Offset_Pan));
}
}
}
//-----------------------------------------------------
// resample all other PCs to match the high resolution of the PAN band
TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt());
for(i=1; i<n; i++)
{
Process_Set_Text(CSG_String::Format("%s: %s ...", _TL("Resampling"), pPCA->asGrid(i)->Get_Name()));
PCA[i].Create(*Get_System());
PCA[i].Assign(pPCA->asGrid(i), Resampling);
delete(pPCA->asGrid(i)); // PCA tool was unmanaged, so we have to delete the output
}
delete(pPCA->asGrid(0));
pPCA->Del_Items();
for(i=0; i<n; i++)
{
pPCA->Add_Item(&PCA[i]);
}
//-----------------------------------------------------
// inverse principle component rotation for the high resolution bands
SG_RUN_TOOL_KEEP_PARMS(bResult, "statistics_grid", 10, Tool_Parms,
SG_TOOL_PARAMETER_SET("PCA" , Tool_Parms("PCA"))
&& SG_TOOL_PARAMETER_SET("GRIDS", Parameters("SHARPEN"))
&& SG_TOOL_PARAMETER_SET("EIGEN", &Eigen)
);
delete[](PCA);
if( !bResult )
{
return( false );
}
CSG_Parameter_Grid_List *pHiRes = Parameters("SHARPEN")->asGridList();
CSG_Parameter_Grid_List *pLoRes = Parameters("GRIDS" )->asGridList();
CSG_Parameter_Grid_List *pGrids = Tool_Parms("GRIDS" )->asGridList();
if( !Parameters("OVERWRITE")->asBool() )
{
pHiRes->Del_Items();
}
for(i=0; i<pLoRes->Get_Count() && i<pGrids->Get_Count(); i++)
{
if( pHiRes->asGrid(i) )
{
pHiRes->asGrid(i)->Assign(pGrids->asGrid(i));
delete(pGrids->asGrid(i));
}
else
{
pHiRes->Add_Item(pGrids->asGrid(i));
}
pHiRes->asGrid(i)->Set_Name(pLoRes->asGrid(i)->Get_Name());
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Calculator::On_Execute(void)
{
double Result, *Values;
CSG_Formula Formula;
CSG_Parameter_Grid_List *pGrids;
CSG_Grid *pResult;
//-----------------------------------------------------
pResult = Parameters("RESULT") ->asGrid();
pGrids = Parameters("GRIDS") ->asGridList();
//-----------------------------------------------------
if( pGrids->Get_Count() <= 0 )
{
Message_Add(_TL("No grid in list"));
return( false );
}
//-----------------------------------------------------
if( !Formula.Set_Formula(Parameters("FORMULA")->asString()) )
{
int Position;
CSG_String Message, s;
s += _TL("Error in formula");
s += SG_T("\n") + Formula.Get_Formula();
if( Formula.Get_Error(&Position, &Message) )
{
s += SG_T("\n") + Message;
s += CSG_String::Format(SG_T("\n%s: %d"), _TL("Position") , Position);
if( Position >= 0 && Position < (int)Formula.Get_Formula().Length() )
{
s += SG_T("\n")
+ Formula.Get_Formula().Left(Position - 1) + SG_T("[")
+ Formula.Get_Formula()[Position] + SG_T("]")
+ Formula.Get_Formula().Right(Formula.Get_Formula().Length() - (Position + 1));
}
}
Message_Add(s, false);
return( false );
}
//-----------------------------------------------------
pResult->Set_Name(Formula.Get_Formula());
Values = new double[pGrids->Get_Count()];
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
bool bNoData = false;
for(int i=0; i<pGrids->Get_Count() && !bNoData; i++)
{
if( pGrids->asGrid(i)->is_NoData(x, y) )
{
bNoData = true;
}
else
{
Values[i] = pGrids->asGrid(i)->asDouble(x, y);
}
}
if( bNoData || _finite(Result = Formula.Get_Value(Values, pGrids->Get_Count())) == false )
{
pResult->Set_NoData(x, y);
}
else
{
pResult->Set_Value(x, y, Result);
}
}
}
delete[](Values);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSet_Grid_Georeference::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
if( pGrids->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
double xMin, yMin, size;
switch( Parameters("DEFINITION")->asInt() )
{
case 0: // cellsize and lower left center coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMIN")->asDouble();
break;
case 1: // cellsize and lower left corner coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMIN")->asDouble() + size * 0.5;
break;
case 2: // cellsize and upper left center coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMAX")->asDouble() - size * Get_NY();
break;
case 3: // cellsize and upper left corner coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMAX")->asDouble() - size * (0.5 + Get_NY());
break;
case 4: // lower left and upper right center coordinates
size = (Parameters("XMAX")->asDouble() - Parameters("XMIN")->asDouble()) / Get_NX();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMIN")->asDouble();
break;
case 5: // lower left and upper right corner coordinates
size = (Parameters("XMAX")->asDouble() - Parameters("XMIN")->asDouble()) / (Get_NX() + 1);
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMIN")->asDouble() + size * 0.5;
break;
}
//-----------------------------------------------------
CSG_Grid_System System;
if( !System.Assign(size, xMin, yMin, Get_NX(), Get_NY()) )
{
return( false );
}
//-----------------------------------------------------
Parameters("REFERENCED")->asGridList()->Del_Items();
for(int i=0; i<pGrids->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Grid *pGrid = pGrids->asGrid(i);
CSG_Grid *pReferenced = SG_Create_Grid(System, pGrid->Get_Type());
pReferenced->Set_Name(pGrid->Get_Name());
pReferenced->Set_Unit(pGrid->Get_Unit());
pReferenced->Set_Scaling(pGrid->Get_Scaling(), pGrid->Get_Offset());
pReferenced->Set_NoData_Value_Range(pGrid->Get_NoData_Value(), pGrid->Get_NoData_hiValue());
pReferenced->Get_MetaData () = pGrid->Get_MetaData ();
pReferenced->Get_Projection() = pGrid->Get_Projection();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
pReferenced->Set_Value(x, y, pGrid->asDouble(x, y));
}
}
Parameters("REFERENCED")->asGridList()->Add_Item(pReferenced);
}
//-----------------------------------------------------
return( true );
}
bool CAHP::On_Execute(void){
int i,j;
int x,y;
float *pCoefs;
float fValue;
float **pMatrix;
float fSum;
CSG_Grid *pOutputGrid;
CSG_Grid **pGrids;
CSG_Table_Record *pRecord;
CSG_Table *pTable;
CSG_Parameter_Grid_List* pGridsList;
CSG_String sMessage;
pTable = Parameters("TABLE")->asTable();
pOutputGrid = Parameters("OUTPUT")->asGrid();
if( (pGridsList = (CSG_Parameter_Grid_List *)Parameters("GRIDS")->Get_Data()) !=
NULL && pGridsList->Get_Count() > 0 ){
if (pTable->Get_Field_Count() != pGridsList->Get_Count() ||
pTable->Get_Record_Count() < pGridsList->Get_Count()){
Message_Add(_TL("Error : Wrong table. Check table dimensions"));
return false;
}//if
pMatrix = new float*[pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
pMatrix[i] = new float[pGridsList->Get_Count()];
pRecord = pTable->Get_Record(i);
for (j = 0; j<pGridsList->Get_Count(); j++){
pMatrix[i][j] = pRecord->asFloat(j);
}//for
}//for
for (i = 0; i<pGridsList->Get_Count(); i++){
fSum = 0;
for (j = 0; j<pGridsList->Get_Count(); j++){
fSum += pMatrix[j][i];
}//for
for (j = 0; j<pGridsList->Get_Count(); j++){
pMatrix[j][i] /= fSum;
}//for
}//for
pCoefs = new float[pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
fSum = 0;
for (j = 0; j<pGridsList->Get_Count(); j++){
fSum += pMatrix[i][j];
}//for
pCoefs[i] = fSum / (float) pGridsList->Get_Count();
sMessage = _TL("Weight for grid ") + SG_Get_String(i,0) + " = " + SG_Get_String(pCoefs[i]);
Message_Add(sMessage.c_str());
}//for
pGrids = new CSG_Grid* [pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
pGrids[i] = pGridsList->asGrid(i);
}//for
for(y=0; y<Get_NY() && Set_Progress(y); y++){
for(x=0; x<Get_NX(); x++){
fValue = 0;
for (i = 0; i<pGridsList->Get_Count(); i++){
fValue = pCoefs[i] * pGrids[i]->asFloat(x,y);
}//for
pOutputGrid->Set_Value(x,y,fValue);
}//for
}//for
}//if
for (i = 0; i<pGridsList->Get_Count(); i++){
delete [] pMatrix[i];
}//for
delete []pMatrix;
delete[] pCoefs;
return true;
}//method
