//---------------------------------------------------------
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 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_Classify_Supervised::Set_Classification(CSG_Classifier_Supervised &Classifier)
{
//-----------------------------------------------------
CSG_Grid *pClasses = Parameters("CLASSES")->asGrid();
//-----------------------------------------------------
CSG_Parameter *pLUT = DataObject_Get_Parameter(pClasses, "LUT");
if( pLUT && pLUT->asTable() )
{
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
bool bRGB = pGrids->Get_Count() >= 3 && Parameters("RGB_COLORS")->asBool();
for(int iClass=0; iClass<Classifier.Get_Class_Count(); iClass++)
{
CSG_Table_Record *pClass = pLUT->asTable()->Get_Record(iClass);
if( !pClass )
{
(pClass = pLUT->asTable()->Add_Record())->Set_Value(0, SG_Color_Get_Random());
}
pClass->Set_Value(1, Classifier.Get_Class_ID(iClass).c_str());
pClass->Set_Value(2, "");
pClass->Set_Value(3, iClass + 1);
pClass->Set_Value(4, iClass + 1);
if( bRGB )
{
#define SET_COLOR_COMPONENT(c, i) c = (int)(127 + (Classifier.Get_Class_Mean(iClass, i) - pGrids->asGrid(i)->Get_Mean()) * 127 / pGrids->asGrid(i)->Get_StdDev()); if( c < 0 ) c = 0; else if( c > 255 ) c = 255;
int r; SET_COLOR_COMPONENT(r, 2);
int g; SET_COLOR_COMPONENT(g, 1);
int b; SET_COLOR_COMPONENT(b, 0);
pClass->Set_Value(0, SG_GET_RGB(r, g, b));
}
}
pLUT->asTable()->Set_Record_Count(Classifier.Get_Class_Count());
DataObject_Set_Parameter(pClasses, pLUT);
DataObject_Set_Parameter(pClasses, "COLORS_TYPE", 1); // Color Classification Type: Lookup Table
}
pClasses->Set_Name(CSG_String::Format("%s [%s]", _TL("Classification"), CSG_Classifier_Supervised::Get_Name_of_Method(Parameters("METHOD")->asInt()).c_str()));
//-----------------------------------------------------
CSG_Grid *pQuality = Parameters("QUALITY")->asGrid();
if( pQuality )
{
DataObject_Set_Colors(pQuality, 11, SG_COLORS_YELLOW_GREEN);
pQuality->Set_Name(CSG_String::Format("%s [%s]", _TL("Classification Quality"), CSG_Classifier_Supervised::Get_Name_of_Quality(Parameters("METHOD")->asInt()).c_str()));
}
//-----------------------------------------------------
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"), System);
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_Grid_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_Grid_Count(); i++)
{
CSG_Grid *pGrid = SG_Create_Grid(System, Type != SG_DATATYPE_Undefined ? Type : pInput->Get_Grid(i)->Get_Type());
if( !pGrid || !pGrid->is_Valid() )
{
if( pGrid )
{
delete(pGrid);
}
return( false );
}
pOutput->Add_Item(pGrid);
pGrid->Set_Name(pInput->Get_Grid(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_Grid_Count(); i++)
{
if( pInput->Get_Grid(i)->Get_Value(p.x, p.y, pz, Resampling) )
{
pOutput->Get_Grid(i)->Set_Value(x, y, pz);
}
else
{
pOutput->Get_Grid(i)->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
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 CGrid_Tiling::On_Execute(void)
{
bool bSaveTiles;
int ix, iy, nx, ny, Overlap;
double y, x, dx, dy, dCell;
CSG_String FilePath, BaseName;
TSG_Data_Type Type;
TSG_Rect Extent;
TSG_Grid_Interpolation Interpolation;
CSG_Grid *pGrid, *pTile;
CSG_Parameter_Grid_List *pTiles;
//-----------------------------------------------------
pGrid = Parameters("GRID") ->asGrid();
pTiles = Parameters("TILES") ->asGridList();
Overlap = Parameters("OVERLAP") ->asInt();
bSaveTiles = Parameters("SAVE_TILES") ->asBool();
BaseName = Parameters("TILE_BASENAME") ->asString();
FilePath = Parameters("TILE_PATH") ->asString();
switch( Parameters("METHOD")->asInt() )
{
case 0: default:
Extent.xMin = pGrid->Get_XMin();
Extent.xMax = pGrid->Get_XMax();
Extent.yMin = pGrid->Get_YMin();
Extent.yMax = pGrid->Get_YMax();
dCell = pGrid->Get_Cellsize();
nx = Parameters("NX") ->asInt();
ny = Parameters("NY") ->asInt();
dx = dCell * nx;
dy = dCell * ny;
Type = pGrid->Get_Type();
Interpolation = GRID_INTERPOLATION_NearestNeighbour;
break;
case 1:
Extent.xMin = Parameters("XRANGE") ->asRange()->Get_LoVal();
Extent.xMax = Parameters("XRANGE") ->asRange()->Get_HiVal();
Extent.yMin = Parameters("YRANGE") ->asRange()->Get_LoVal();
Extent.yMax = Parameters("YRANGE") ->asRange()->Get_HiVal();
dCell = Parameters("DCELL") ->asDouble();
dx = Parameters("DX") ->asDouble();
dy = Parameters("DY") ->asDouble();
nx = (int)(dx / dCell);
ny = (int)(dy / dCell);
Type = pGrid->Get_Type();
Interpolation = GRID_INTERPOLATION_Undefined;
break;
}
switch( Parameters("OVERLAP_SYM")->asInt() )
{
case 0: default: // symetric
nx += Overlap * 2;
ny += Overlap * 2;
break;
case 1: // bottom / left
nx += Overlap;
ny += Overlap;
break;
case 2: // top / right
nx += Overlap;
ny += Overlap;
Overlap = 0;
break;
}
pTiles->Del_Items();
//-----------------------------------------------------
if( dx <= 0.0 || dy <= 0.0 || dCell <= 0.0 )
{
Message_Add(_TL("no intersection with mask grid."));
return( false );
}
if( bSaveTiles )
{
if( !SG_STR_CMP(BaseName, SG_T("")) )
{
SG_UI_Msg_Add_Error(_TL("Please provide a valid base name for the output files!"));
return( false );
}
if( !SG_STR_CMP(FilePath, SG_T("")) )
{
SG_UI_Msg_Add_Error(_TL("Please provide a valid output directory for the output files!"));
return( false );
}
}
//-----------------------------------------------------
int iTiles = 0;
for(y=Extent.yMin, iy=1; y<Extent.yMax && Process_Get_Okay(); y+=dy, iy++)
{
for(x=Extent.xMin, ix=1; x<Extent.xMax; x+=dx, ix++)
{
pTile = SG_Create_Grid(Type, nx, ny, dCell, x - dCell * Overlap, y - dCell * Overlap);
pTile ->Assign(pGrid, Interpolation);
pTile ->Set_Name(CSG_String::Format(SG_T("%s [%d, %d]"), pGrid->Get_Name(), iy, ix));
if( pTile->Get_NoData_Count() == pTile->Get_NCells() )
{
delete(pTile);
}
else
{
if( bSaveTiles )
{
CSG_String FileName = CSG_String::Format(SG_T("%s/%s_%d_%d"), FilePath.c_str(), BaseName.c_str(), iy, ix);
pTile->Save(FileName);
delete(pTile);
}
else
{
pTiles->Add_Item(pTile);
}
iTiles++;
}
}
}
SG_UI_Msg_Add(CSG_String::Format(_TL("%d tiles created."), iTiles), true);
return( iTiles > 0 );
}
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
