//---------------------------------------------------------
bool CFilter_Resample::On_Execute(void)
{
double Cellsize;
CSG_Grid *pGrid, *pLoPass, *pHiPass;
//-----------------------------------------------------
pGrid = Parameters("GRID" )->asGrid();
pLoPass = Parameters("LOPASS")->asGrid();
pHiPass = Parameters("HIPASS")->asGrid();
Cellsize = Parameters("SCALE" )->asDouble() * Get_Cellsize();
//-----------------------------------------------------
if( Cellsize > 0.5 * SG_Get_Length(Get_System()->Get_XRange(), Get_System()->Get_YRange()) )
{
Error_Set(_TL("resampling cell size is too large"));
return( false );
}
//-----------------------------------------------------
CSG_Grid Grid(CSG_Grid_System(Cellsize, Get_XMin(), Get_YMin(), Get_XMax(), Get_YMax()), SG_DATATYPE_Float);
Grid.Assign(pGrid, GRID_RESAMPLING_Mean_Cells);
//-----------------------------------------------------
pLoPass->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pGrid->Get_Name(), _TL("Low Pass")));
pHiPass->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pGrid->Get_Name(), _TL("High Pass")));
CSG_Colors Colors;
DataObject_Get_Colors(pGrid , Colors);
DataObject_Set_Colors(pLoPass, Colors);
DataObject_Set_Colors(pHiPass, 11, SG_COLORS_RED_GREY_BLUE);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
double py = Get_YMin() + y * Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double z, px = Get_XMin() + x * Get_Cellsize();
if( !pGrid->is_NoData(x, y) && Grid.Get_Value(px, py, z) )
{
pLoPass->Set_Value(x, y, z);
pHiPass->Set_Value(x, y, pGrid->asDouble(x, y) - z);
}
else
{
pLoPass->Set_NoData(x, y);
pHiPass->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CDiversity_Analysis::On_Execute(void)
{
//-----------------------------------------------------
m_pClasses = Parameters("CATEGORIES" )->asGrid();
m_pCount = Parameters("COUNT" )->asGrid();
m_pDiversity = Parameters("DIVERSITY" )->asGrid();
m_pConnectivity = Parameters("CONNECTIVITY")->asGrid();
m_pConnectedAvg = Parameters("CONNECTEDAVG")->asGrid();
m_pCount ->Set_Name(CSG_String::Format("%s [%s]", m_pClasses->Get_Name(), _TL("Count" )));
m_pDiversity ->Set_Name(CSG_String::Format("%s [%s]", m_pClasses->Get_Name(), _TL("Diversity" )));
m_pConnectivity ->Set_Name(CSG_String::Format("%s [%s]", m_pClasses->Get_Name(), _TL("Connectivity" )));
m_pConnectedAvg ->Set_Name(CSG_String::Format("%s [%s]", m_pClasses->Get_Name(), _TL("Averaged Connectivity")));
DataObject_Set_Colors(m_pCount , 11, SG_COLORS_RAINBOW, false);
DataObject_Set_Colors(m_pDiversity , 11, SG_COLORS_RAINBOW, false);
DataObject_Set_Colors(m_pConnectivity, 11, SG_COLORS_RAINBOW, true);
DataObject_Set_Colors(m_pConnectedAvg, 11, SG_COLORS_RAINBOW, true);
//-----------------------------------------------------
m_Search.Get_Weighting().Set_Parameters(&Parameters);
m_Search.Get_Weighting().Set_BandWidth(Parameters("SEARCH_RADIUS")->asDouble() * m_Search.Get_Weighting().Get_BandWidth());
m_Search.Set_Radius(m_Radius = Parameters("SEARCH_RADIUS")->asInt(), Parameters("SEARCH_MODE")->asInt() == 0);
m_NB_Step = Parameters("NB_CASE" )->asInt() == 0 ? 2 : 1;
m_Normalize = Parameters("NORMALIZE")->asInt();
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( !Get_Diversity(x, y) )
{
m_pCount ->Set_NoData(x, y);
m_pDiversity ->Set_NoData(x, y);
m_pConnectivity->Set_NoData(x, y);
m_pConnectedAvg->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
m_Search.Destroy();
return( true );
}
//---------------------------------------------------------
bool CExercise_10::On_Execute(void)
{
bool bAlive;
int x, y, i;
CSG_Colors Colors;
//-----------------------------------------------------
// General initialisations...
m_pLife = Parameters("RESULT")->asGrid();
m_nColors = Parameters("COLORS")->asInt();
Colors.Set_Count(m_nColors + 1);
Colors.Set_Ramp(SG_GET_RGB(127, 127, 127), SG_GET_RGB(0, 0, 0));
Colors.Set_Color(0, SG_GET_RGB(255, 255, 255));
DataObject_Set_Colors(m_pLife, Colors);
//-----------------------------------------------------
// Initialise life's world...
if( Parameters("REFRESH")->asBool() )
{
srand((unsigned)time(NULL));
for(y=0; y<Get_NY(); y++)
{
for(x=0; x<Get_NX(); x++)
{
m_pLife->Set_Value(x, y, rand() > RAND_MAX / 2 ? 0 : 1);
}
}
}
//-----------------------------------------------------
// Execution...
m_pTemp = SG_Create_Grid(m_pLife, SG_DATATYPE_Byte);
for(i=1, bAlive=true; bAlive && Process_Get_Okay(true); i++)
{
Process_Set_Text(CSG_String::Format(SG_T("%d %s"), i, _TL("Life Cycle")));
if( (bAlive = Next_Step()) == false )
{
Message_Add(CSG_String::Format(SG_T("%s %d %s\n"), _TL("Dead after"), i, _TL("Life Cycles")));
}
}
delete(m_pTemp);
//-----------------------------------------------------
// Finish...
return( true );
}
//---------------------------------------------------------
bool CFragmentation_Classify::On_Execute(void)
{
CSG_Grid *pDensity, *pConnectivity, *pFragmentation;
pDensity = Parameters("DENSITY") ->asGrid();
pConnectivity = Parameters("CONNECTIVITY") ->asGrid();
pFragmentation = Parameters("FRAGMENTATION") ->asGrid();
m_Weight = Parameters("WEIGHT") ->asDouble();
m_Density_Min = Parameters("DENSITY_MIN") ->asDouble() / 100.0;
m_Density_Interior = Parameters("DENSITY_INT") ->asDouble() / 100.0;
//-----------------------------------------------------
CSG_Parameters Parms;
DataObject_Set_Colors(pFragmentation, 100, SG_COLORS_WHITE_GREEN, true);
if( DataObject_Get_Parameters(pFragmentation, Parms) && Parms("COLORS_TYPE") && Parms("LUT") )
{
Parms("LUT")->asTable()->Assign_Values(&m_LUT); // Lookup Table
Parms("COLORS_TYPE")->Set_Value(1); // Color Classification Type: Lookup Table
DataObject_Set_Parameters(pFragmentation, Parms);
}
// pFragmentation->Set_NoData_Value(CLASS_NONE);
//-----------------------------------------------------
if( 1 )
{
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( !pDensity->is_NoData(x, y) && !pConnectivity->is_NoData(x, y) )
{
double Density = pDensity ->asDouble(x, y) / 100.0;
double Connectivity = pConnectivity ->asDouble(x, y) / 100.0;
// pFragmentation ->Set_Value (x, y, 100.0 * Density * Connectivity);
pFragmentation ->Set_Value (x, y, Get_Classification(Density, Connectivity));
}
else
{
pFragmentation ->Set_NoData(x, y);
}
}
}
//-------------------------------------------------
if( Parameters("BORDER")->asBool() )
{
Add_Border(pFragmentation);
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGrid_Division::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pA = Parameters("A")->asGrid();
CSG_Grid *pB = Parameters("B")->asGrid();
CSG_Grid *pC = Parameters("C")->asGrid();
DataObject_Set_Colors(pC, 11, SG_COLORS_RED_GREY_BLUE);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pA->is_NoData(x, y) || pB->is_NoData(x, y) || pB->asDouble(x, y) == 0.0 )
{
pC->Set_NoData(x, y);
}
else
{
pC->Set_Value(x, y, pA->asDouble(x, y) / pB->asDouble(x, y));
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CConvergence_Radius::On_Execute(void)
{
CSG_Grid *pDTM, *pConvergence_Radius;
pDTM = Parameters("ELEVATION") ->asGrid();
pConvergence_Radius = Parameters("RESULT") ->asGrid();
if( Initialize(pDTM, Parameters("RADIUS")->asInt()) )
{
DataObject_Set_Colors(pConvergence_Radius, 100, SG_COLORS_RED_GREY_BLUE, true);
pConvergence_Radius->Assign_NoData();
Get_Convergence_Radius(
pDTM,
pConvergence_Radius,
Parameters("SLOPE") ->asBool(),
Parameters("DIFF") ->asInt() == 0 ? true : false,
Parameters("METHOD")->asInt()
);
Finalize();
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CPC_Drop_Attribute::On_After_Execution(void)
{
CSG_PointCloud *pOutput = Parameters("OUTPUT")->asPointCloud();
if( pOutput == NULL )
{
pOutput = Parameters("INPUT")->asPointCloud();
}
DataObject_Set_Parameter(pOutput, "DISPLAY_VALUE_AGGREGATE", 3); // highest z
DataObject_Set_Parameter(pOutput, "METRIC_COLORS" , 12); // number of colors
DataObject_Set_Parameter(pOutput, "COLORS_TYPE" , 3); // graduated color
DataObject_Set_Parameter(pOutput, "METRIC_ATTRIB" , 2); // z attrib
DataObject_Set_Parameter(pOutput, "METRIC_ZRANGE",
pOutput->Get_Mean(2) - 2.0 * pOutput->Get_StdDev(2),
pOutput->Get_Mean(2) + 2.0 * pOutput->Get_StdDev(2)
);
DataObject_Set_Colors(pOutput, 11, SG_COLORS_RAINBOW);
if( pOutput == Parameters("INPUT")->asPointCloud() )
{
Parameters("OUTPUT")->Set_Value(DATAOBJECT_NOTSET);
}
return( true );
}
//---------------------------------------------------------
bool CHillslope_Evolution_FTCS::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid DEM(Get_System());
m_pDEM_Old = &DEM;
m_pDEM = Parameters("MODEL")->asGrid();
m_pDEM->Assign(Parameters("DEM")->asGrid());
DataObject_Set_Colors(Parameters("DIFF")->asGrid(), 10, SG_COLORS_RED_GREY_BLUE, true);
//-----------------------------------------------------
double k, dTime, nTime;
k = Parameters("KAPPA" )->asDouble();
nTime = Parameters("DURATION")->asDouble();
if( Parameters("TIMESTEP")->asInt() == 0 )
{
dTime = Parameters("DTIME")->asDouble();
}
else
{
dTime = 0.5 * Get_Cellarea() / (2.0 * k);
if( Parameters("NEIGHBOURS")->asInt() == 1 )
{
dTime /= sqrt(2.0);
}
}
if( dTime > nTime )
{
Message_Fmt("\n%s: %s [%f]", _TL("Warning"), _TL("Time step exceeds duration"), dTime);
dTime = nTime;
}
Message_Fmt("\n%s: %f", _TL("Time Step"), dTime);
Message_Fmt("\n%s: %d", _TL("Steps"), (int)(nTime / dTime));
//-----------------------------------------------------
for(double iTime=dTime; iTime<=nTime && Set_Progress(iTime, nTime); iTime+=dTime)
{
Process_Set_Text("%s: %.2f [%.2f]", _TL("Simulation Time"), iTime, nTime);
SG_UI_Progress_Lock(true);
Set_Diffusion(dTime * k / Get_Cellarea());
Set_Difference();
SG_UI_Progress_Lock(false);
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CConvergence::On_Execute(void)
{
bool bGradient;
int Neighbours;
CSG_Grid *pConvergence;
m_pDTM = Parameters("ELEVATION") ->asGrid();
pConvergence = Parameters("RESULT") ->asGrid();
Neighbours = Parameters("NEIGHBOURS") ->asInt();
bGradient = Parameters("METHOD") ->asInt() == 1;
DataObject_Set_Colors(pConvergence, 100, SG_COLORS_RED_GREY_BLUE, true);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( m_pDTM->is_InGrid(x, y) )
{
switch( Neighbours )
{
case 0: default: pConvergence->Set_Value(x, y, Get_2x2(x, y, bGradient)); break;
case 1: pConvergence->Set_Value(x, y, Get_9x9(x, y, bGradient)); break;
}
}
else
{
pConvergence->Set_NoData(x, y);
}
}
}
return( true );
}
void Cdodproperror::ApplyColors(CSG_Grid* from, CSG_Grid* to)
{
CSG_Colors colors;
DataObject_Get_Colors(from, colors);
DataObject_Set_Colors(to, colors);
DataObject_Update(to, false);
}
//---------------------------------------------------------
bool CDVWK_SoilMoisture::On_Execute(void)
{
int Day, x, y, i, LandUseID;
CSG_Grid *pGrid;
//-----------------------------------------------------
if( pClimate->Get_Record_Count() > 0 )
{
pFK_mm = Parameters("STA_FC") ->asGrid();
FK_mm_Def = Parameters("STA_FC_DEF") ->asDouble();
pPWP_mm = Parameters("STA_PWP") ->asGrid();
PWP_mm_Def = Parameters("STA_PWP_DEF") ->asDouble();
pWi_mm = Parameters("DYN_W") ->asGrid();
DataObject_Set_Colors(pWi_mm, 100, SG_COLORS_YELLOW_BLUE);
//-------------------------------------------------
pLandUse = SG_Create_Grid(pWi_mm, pCropCoeff->Get_Record_Count() < 127 ? SG_DATATYPE_Char : SG_DATATYPE_Int);
pLandUse->Assign(Parameters("LANDUSE_DEF")->asInt());
if( (pGrid = Parameters("LANDUSE")->asGrid()) != NULL )
{
for(y=0; y<Get_NY(); y++)
{
for(x=0; x<Get_NX(); x++)
{
LandUseID = pGrid->asInt(x, y);
for(i=0; i<pCropCoeff->Get_Record_Count(); i++)
{
if( LandUseID == pCropCoeff->Get_Record(i)->asInt(0) )
{
pLandUse->Set_Value(x, y, i);
break;
}
}
}
}
}
//-------------------------------------------------
DataObject_Update(pWi_mm, 0, pFK_mm ? pFK_mm->Get_ZMax() : FK_mm_Def, true);
for(Day=0; Day<365 && Set_Progress(Day, 365); Day++)
{
Step_Day(Day);
DataObject_Update(pWi_mm, true);
}
//-------------------------------------------------
delete(pLandUse);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CMine_Sweeper::MakeBoard(int level)
{
int i, x, y;
CSG_Colors Colors;
switch( level )
{
case 0: Mine_NX = 8; Mine_NY = 8; N_Mines=10;
break;
case 1: Mine_NX = 16; Mine_NY = 16; N_Mines=40;
break;
case 2: Mine_NX = 30; Mine_NY = 16; N_Mines=99;
break;
}
pInput = SG_Create_Grid(SG_DATATYPE_Int,SPRITE_SIZE*Mine_NX, SPRITE_SIZE*Mine_NY);
pInput->Set_Name(_TL("Mine Sweeper"));
Parameters("GRID")->Set_Value(pInput);
//-----------------------------------------------------
CSG_Parameter *pLUT = DataObject_Get_Parameter(pInput, "LUT");
if( pLUT && pLUT->asTable() )
{
pLUT->asTable()->Del_Records();
for(i=0; i<16; i++)
{
CSG_Table_Record *pRecord = pLUT->asTable()->Add_Record();
pRecord->Set_Value(0, SG_GET_RGB(mine_res_color[i*3], mine_res_color[i*3+1], mine_res_color[i*3+2]));
pRecord->Set_Value(3, i);
}
DataObject_Set_Parameter(pInput, pLUT);
DataObject_Set_Parameter(pInput, "COLORS_TYPE", 1); // Color Classification Type: Lookup Table
}
Colors.Set_Count(16);
for ( i=0;i<16; i++)
{
Colors.Set_Color(i, SG_GET_RGB(mine_res_color[i*3], mine_res_color[i*3+1], mine_res_color[i*3+2]));
}
DataObject_Set_Colors(pInput, Colors);
DataObject_Update(pInput, 0.0, 15.0, true);
//-----------------------------------------------------
for( y = 0; y < Mine_NY; y++)
for( x = 0; x < Mine_NX; x++)
{
SetSprite(x,y,SPRITE_CLOSE);
}
pInput->Set_Value(0, 0);
return true;
}
//---------------------------------------------------------
bool CErosion_LS_Fields::On_Execute(void)
{
//-----------------------------------------------------
m_Method = Parameters("METHOD" )->asInt();
m_Method_Slope = Parameters("METHOD_SLOPE" )->asInt();
m_Method_Area = Parameters("METHOD_AREA" )->asInt();
m_bStopAtEdge = Parameters("STOP_AT_EDGE" )->asBool();
m_Erosivity = Parameters("EROSIVITY" )->asDouble();
m_Stability = Parameters("STABILITY" )->asInt();
m_pDEM = Parameters("DEM" )->asGrid();
m_pUp_Area = Parameters("UPSLOPE_AREA" )->asGrid();
m_pUp_Length = Parameters("UPSLOPE_LENGTH")->asGrid();
m_pUp_Slope = Parameters("UPSLOPE_SLOPE" )->asGrid();
m_pLS = Parameters("LS_FACTOR" )->asGrid();
DataObject_Set_Colors(m_pUp_Area , 11, SG_COLORS_WHITE_BLUE , false);
DataObject_Set_Colors(m_pUp_Length, 11, SG_COLORS_YELLOW_RED , false);
DataObject_Set_Colors(m_pUp_Slope , 11, SG_COLORS_YELLOW_RED , false);
DataObject_Set_Colors(m_pLS , 11, SG_COLORS_RED_GREY_GREEN, true );
if( m_pUp_Area == NULL ) m_pUp_Area = SG_Create_Grid(*Get_System(), SG_DATATYPE_Float);
if( m_pUp_Length == NULL ) m_pUp_Length = SG_Create_Grid(*Get_System(), SG_DATATYPE_Float);
if( m_pUp_Slope == NULL ) m_pUp_Slope = SG_Create_Grid(*Get_System(), SG_DATATYPE_Float);
//-----------------------------------------------------
bool bResult = Set_Fields() && Get_Flow() && Get_LS();
if( bResult )
{
Get_Statistics();
Get_Balance();
}
//-----------------------------------------------------
if( m_pUp_Area && Parameters("UPSLOPE_AREA" )->asGrid() == NULL ) delete(m_pUp_Area );
if( m_pUp_Length && Parameters("UPSLOPE_LENGTH")->asGrid() == NULL ) delete(m_pUp_Length);
if( m_pUp_Slope && Parameters("UPSLOPE_SLOPE" )->asGrid() == NULL ) delete(m_pUp_Slope );
m_Fields.Destroy();
return( bResult );
}
//---------------------------------------------------------
bool CFilter_LoG::On_Execute(void)
{
CSG_Grid *pResult;
//-----------------------------------------------------
m_pInput = Parameters("INPUT") ->asGrid();
pResult = Parameters("RESULT") ->asGrid();
//-----------------------------------------------------
if( Initialise() )
{
if( !pResult || pResult == m_pInput )
{
pResult = SG_Create_Grid(m_pInput);
}
else
{
pResult->Set_Name(CSG_String::Format(SG_T("%s [%s]"), m_pInput->Get_Name(), _TL("Laplace Filter")));
pResult->Set_NoData_Value(m_pInput->Get_NoData_Value());
}
//-------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( m_pInput->is_InGrid(x, y) )
{
pResult->Set_Value(x, y, Get_Value(x, y));
}
else
{
pResult->Set_NoData(x, y);
}
}
}
//-------------------------------------------------
if( !Parameters("RESULT")->asGrid() || Parameters("RESULT")->asGrid() == m_pInput )
{
m_pInput->Assign(pResult);
delete(pResult);
pResult = m_pInput;
}
DataObject_Set_Colors(pResult, 100, SG_COLORS_BLACK_WHITE);
m_Kernel.Destroy();
return( true );
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CExercise_09::On_Execute(void)
{
int x, y;
CSG_Grid *pDTM;
//-----------------------------------------------------
// Get parameter settings...
pDTM = Parameters("ELEVATION")->asGrid();
m_pArea = Parameters("AREA" )->asGrid();
//-----------------------------------------------------
// Initialisations...
m_pArea ->Assign(0.0);
m_pArea ->Set_Unit(SG_T("m\xc2\xb2"));
DataObject_Set_Colors(m_pArea, 100, SG_COLORS_WHITE_BLUE);
//-----------------------------------------------------
// Save flow directions to temporary grid...
m_pDir = new CSG_Grid(pDTM, SG_DATATYPE_Char); // this object has to be deleted later...
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
m_pDir->Set_Value(x, y, pDTM->Get_Gradient_NeighborDir(x, y) % 8);
}
}
//-------------------------------------------------
// Execute calculation...
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
Get_Area(x, y);
}
}
//-----------------------------------------------------
// Finalisations...
delete(m_pDir);
//-----------------------------------------------------
// Return 'true' if everything went okay...
return( true );
}
//---------------------------------------------------------
bool CGrid_Colors_Fit::On_Execute(void)
{
int iColor;
long aC, bC;
double aZ, bZ, dColor, zMin, zRange;
CSG_Colors Colors_Old, Colors_New;
CSG_Grid *pGrid;
pGrid = Parameters("GRID")->asGrid();
Colors_New.Set_Count(Parameters("COUNT")->asInt());
switch( Parameters("SCALE")->asInt() )
{
case 0: default:
zMin = pGrid->Get_ZMin();
zRange = pGrid->Get_ZMax() - zMin;
break;
case 1:
zMin = Parameters("RANGE")->asRange()->Get_LoVal();
zRange = Parameters("RANGE")->asRange()->Get_HiVal() - zMin;
break;
}
DataObject_Get_Colors(pGrid, Colors_Old);
if( Colors_Old.Get_Count() > 1 && pGrid->Get_ZRange() > 0.0 && zRange != 0.0 )
{
dColor = 100.0 / Colors_Old.Get_Count();
aZ = 0.0;
aC = Colors_Old.Get_Color(0);
for(iColor=1; iColor<Colors_Old.Get_Count()-1; iColor++)
{
bZ = aZ;
bC = aC;
aZ = (pGrid->Get_Percentile(iColor * dColor) - zMin) / zRange;
aC = Colors_Old.Get_Color(iColor);
_Set_Colors(Colors_New, bZ, bC, aZ, aC);
}
bZ = aZ;
bC = aC;
aZ = 1.0;
aC = Colors_Old.Get_Color(Colors_Old.Get_Count() - 1);
_Set_Colors(Colors_New, bZ, bC, aZ, aC);
DataObject_Set_Colors (pGrid, Colors_New);
DataObject_Update (pGrid, zMin, zMin + zRange);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CKernel_Density::On_Execute(void)
{
int Population;
double Radius;
CSG_Shapes *pPoints;
//-----------------------------------------------------
pPoints = Parameters("POINTS" )->asShapes();
Population = Parameters("POPULATION")->asInt();
Radius = Parameters("RADIUS" )->asDouble();
m_Kernel = Parameters("KERNEL" )->asInt();
if( Population < 0 || Population >= pPoints->Get_Field_Count() || pPoints->Get_Field_Type(Population) == SG_DATATYPE_String )
{
Population = -1;
}
//-----------------------------------------------------
if( (m_pGrid = m_Grid_Target.Get_Grid()) == NULL )
{
return( false );
}
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pPoints->Get_Name(), _TL("Kernel Density")));
m_pGrid->Set_NoData_Value(0.0);
m_pGrid->Assign(0.0);
DataObject_Set_Colors(m_pGrid, 100, SG_COLORS_BLACK_WHITE, true);
m_dRadius = Radius / m_pGrid->Get_Cellsize();
m_iRadius = 1 + (int)m_dRadius;
//-----------------------------------------------------
if( pPoints->Get_Selection_Count() > 0 )
{
for(int iPoint=0; iPoint<pPoints->Get_Selection_Count() && Set_Progress(iPoint, pPoints->Get_Selection_Count()); iPoint++)
{
CSG_Shape *pPoint = pPoints->Get_Selection(iPoint);
Set_Kernel(pPoint->Get_Point(0), Population < 0 ? 1.0 : pPoint->asDouble(Population));
}
}
else
{
for(int iPoint=0; iPoint<pPoints->Get_Count() && Set_Progress(iPoint, pPoints->Get_Count()); iPoint++)
{
CSG_Shape *pPoint = pPoints->Get_Shape(iPoint);
Set_Kernel(pPoint->Get_Point(0), Population < 0 ? 1.0 : pPoint->asDouble(Population));
}
}
return( true );
}
//---------------------------------------------------------
bool CFlow_Distance::On_Execute(void)
{
bool bSeeds;
int x, y, Method;
CSG_Grid *pSeed;
//-------------------------------------------------
m_pDTM = Parameters("ELEVATION") ->asGrid();
pSeed = Parameters("SEED") ->asGrid();
m_pLength = Parameters("LENGTH") ->asGrid();
m_Converge = Parameters("CONVERGENCE") ->asDouble();
bSeeds = Parameters("SEEDS_ONLY") ->asBool();
Method = Parameters("METHOD") ->asInt();
m_pWeight = SG_Create_Grid(m_pLength, SG_DATATYPE_Float);
m_pWeight ->Assign(0.0);
m_pLength ->Assign(0.0);
//-------------------------------------------------
for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++)
{
m_pDTM->Get_Sorted(n, x, y, true, false);
if( pSeed && !pSeed->is_NoData(x, y) )
{
m_pLength->Set_Value(x, y, 0.0);
m_pWeight->Set_Value(x, y, 0.0);
}
else if( m_pWeight->asDouble(x, y) > 0.0 )
{
m_pLength->Set_Value(x, y, m_pLength->asDouble(x, y) / m_pWeight->asDouble(x, y));
}
else if( bSeeds )
{
m_pLength->Set_NoData(x, y);
continue;
}
switch( Method )
{
case 0: Set_Length_D8 (x, y); break;
case 1: Set_Length_MFD (x, y); break;
}
}
//-------------------------------------------------
delete(m_pWeight);
DataObject_Set_Colors(m_pLength, 100, SG_COLORS_WHITE_BLUE);
return( true );
}
//---------------------------------------------------------
bool CFlow_by_Slope::On_Execute(void)
{
m_Slope_Min = Parameters("SLOPE_MIN")->asDouble() * M_DEG_TO_RAD;
m_Slope_Max = Parameters("SLOPE_MAX")->asDouble() * M_DEG_TO_RAD;
if( m_Slope_Max <= 0.0 )
{
Error_Set(_TL("slope threshold must not be zero!"));
return( false );
}
if( Parameters("B_FLOW")->asBool() )
{
m_Flow_Min = Parameters("T_FLOW")->asRange()->Get_LoVal() * Get_Cellarea();
m_Flow_Max = Parameters("T_FLOW")->asRange()->Get_HiVal() * Get_Cellarea();
}
else
{
m_Flow_Min = m_Flow_Max = 0.0;
}
//-----------------------------------------------------
m_pDEM = Parameters("DEM" )->asGrid();
m_pFlow = Parameters("FLOW" )->asGrid();
m_pFlow->Assign(Get_Cellarea());
if( Parameters("WEIGHT")->asGrid() )
{
m_pFlow->Multiply(*Parameters("WEIGHT")->asGrid());
}
DataObject_Set_Colors(m_pFlow, 11, SG_COLORS_WHITE_BLUE, false);
//-----------------------------------------------------
for(sLong i=0; i<Get_NCells() && Set_Progress_NCells(i); i++)
{
int x, y;
if( !m_pDEM->Get_Sorted(i, x, y, true) || m_pDEM->is_NoData(x, y) )
{
m_pFlow->Set_NoData(x, y);
}
else
{
Set_Area(x, y);
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CLife::On_Execute(void)
{
//-----------------------------------------------------
m_pLife = m_Grid_Target.Get_Grid("LIFE", SG_DATATYPE_Byte);
if( !m_pLife )
{
Error_Set(_TL("could not create target grid"));
return( false );
}
//-----------------------------------------------------
m_nColors = Parameters("FADECOLOR")->asInt();
for(int y=0; y<m_pLife->Get_NY(); y++)
{
for(int x=0; x<m_pLife->Get_NX(); x++)
{
m_pLife->Set_Value(x, y, CSG_Random::Get_Uniform(0, 100) < 50 ? 0 : m_nColors);
}
}
//-----------------------------------------------------
m_pLife->Set_Name(_TL("Conway's Game of Life"));
m_pLife->Set_NoData_Value(-1);
DataObject_Add (m_pLife);
DataObject_Set_Colors(m_pLife, 11, SG_COLORS_WHITE_BLUE);
DataObject_Update (m_pLife, 0, m_nColors, SG_UI_DATAOBJECT_SHOW);
//-----------------------------------------------------
int i;
m_Count.Create(m_pLife->Get_System(), SG_DATATYPE_Byte);
for(i=1; Process_Get_Okay(true) && Next_Cycle(i > m_nColors); i++)
{
Process_Set_Text(CSG_String::Format("%s: %d", _TL("Life Cycle"), i));
DataObject_Update(m_pLife, 0, m_nColors);
}
m_Count.Destroy();
//-----------------------------------------------------
if( is_Progress() )
{
Message_Add(CSG_String::Format("\n%s %d %s\n", _TL("Dead after"), i, _TL("Life Cycles")), false);
}
return( true );
}
//---------------------------------------------------------
bool CDiffuse_Pollution_Risk::On_Execute(void)
{
//-----------------------------------------------------
m_pDEM = Parameters("DEM" )->asGrid();
m_pDelivery = Parameters("DELIVERY" )->asGrid();
m_pRisk_Point = Parameters("RISK_POINT" )->asGrid();
m_pRisk_Diffuse = Parameters("RISK_DIFFUSE")->asGrid();
m_bSingle = Parameters("METHOD" )->asInt() == 0;
DataObject_Set_Colors(m_pDelivery , 11, SG_COLORS_RED_GREY_GREEN, true);
DataObject_Set_Colors(m_pRisk_Point , 11, SG_COLORS_RED_GREY_GREEN, true);
DataObject_Set_Colors(m_pRisk_Diffuse, 11, SG_COLORS_RED_GREY_GREEN, true);
//-----------------------------------------------------
bool bResult = false;
if( !Set_Flow() )
{
Error_Set(_TL("initialization failed"));
}
else if( !Set_Delivery_Index() )
{
Error_Set(_TL("delivery index calculation failed"));
}
else if( !Get_Risk_Diffuse() )
{
Error_Set(_TL("diffuse pollution risk calculation failed"));
}
else
{
bResult = true;
}
//-----------------------------------------------------
m_FlowDir.Destroy();
m_RainAcc.Destroy();
m_TWI .Destroy();
return( bResult );
}
//---------------------------------------------------------
bool CKinWav_D8::Initialize(double Roughness)
{
m_Flow_Last .Create(*Get_System(), SG_DATATYPE_Float);
m_Alpha .Create(*Get_System(), SG_DATATYPE_Float);
m_Direction .Create(*Get_System(), SG_DATATYPE_Char);
m_Direction .Set_NoData_Value(-1);
m_pFlow->Assign(0.0);
DataObject_Set_Colors(m_pFlow, 100, SG_COLORS_WHITE_BLUE);
DataObject_Update(m_pFlow, 0.0, 100.0, SG_UI_DATAOBJECT_SHOW);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( !m_pDEM->is_NoData(x, y) )
{
int i, ix, iy, iMax;
double z, d, dMax;
for(i=0, iMax=-1, dMax=0.0, z=m_pDEM->asDouble(x, y); i<8; i++)
{
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
if( is_InGrid(ix, iy) && (d = (z - m_pDEM->asDouble(ix, iy)) / Get_Length(i)) > dMax )
{
dMax = d;
iMax = i;
}
}
if( iMax < 0 )
{
m_Direction .Set_NoData(x, y);
}
else
{
m_Direction .Set_Value(x, y, iMax);
m_Alpha .Set_Value(x, y, pow(Roughness / sqrt(dMax), Beta_0));
if( m_Alpha.asDouble(x, y) > 10 )
m_Alpha.Set_Value(x, y, 10);
}
}
}
}
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 CFlow_AreaUpslope_Interactive::On_Execute(void)
{
if( m_Calculator.Initialise(
Parameters("METHOD") ->asInt(),
Parameters("ELEVATION") ->asGrid(),
Parameters("SINKROUTE") ->asGrid(),
Parameters("AREA") ->asGrid(),
Parameters("CONVERGE") ->asDouble() ) )
{
DataObject_Set_Colors(Parameters("AREA")->asGrid(), 100, SG_COLORS_WHITE_BLUE);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGSGrid_Residuals::On_Execute(void)
{
m_pGrid = Parameters("GRID") ->asGrid();
m_pMean = Parameters("MEAN") ->asGrid();
m_pDiff = Parameters("DIFF") ->asGrid();
m_pStdDev = Parameters("STDDEV") ->asGrid();
m_pRange = Parameters("RANGE") ->asGrid();
m_pMin = Parameters("MIN") ->asGrid();
m_pMax = Parameters("MAX") ->asGrid();
m_pDevMean = Parameters("DEVMEAN") ->asGrid();
m_pPercent = Parameters("PERCENT") ->asGrid();
DataObject_Set_Colors(m_pDiff , 100, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(m_pStdDev , 100, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(m_pRange , 100, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(m_pMin , 100, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(m_pMax , 100, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(m_pDevMean, 100, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(m_pPercent, 100, SG_COLORS_RED_GREY_BLUE, true);
//-----------------------------------------------------
bool bSquare = Parameters("MODE")->asBool() ? false : true;
m_Cells.Get_Weighting().Set_Parameters(Parameters("WEIGHTING")->asParameters());
if( !m_Cells.Set_Radius(Parameters("RADIUS")->asInt(), bSquare) )
{
return( false );
}
bool bCenter = Parameters("BCENTER")->asBool();
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
Get_Statistics(x, y, bCenter);
}
}
//-----------------------------------------------------
m_Cells.Destroy();
return( true );
}
//---------------------------------------------------------
bool CGrid_Color_Rotate::On_Execute(void)
{
bool bDown;
int i;
long c;
CSG_Grid *pGrid;
CSG_Colors *pColors;
pGrid = Parameters("GRID")->asGrid();
pColors = Parameters("COLORS")->asColors();
bDown = Parameters("DIR")->asBool();
if( pColors->Get_Count() > 1 )
{
do
{
if( bDown )
{
for(i=0, c=pColors->Get_Color(0); i<pColors->Get_Count() - 1; i++)
{
pColors->Set_Color(i, pColors->Get_Color(i + 1));
}
pColors->Set_Color(pColors->Get_Count() - 1, c);
}
else
{
for(i=pColors->Get_Count()-1, c=pColors->Get_Color(pColors->Get_Count()-1); i>0; i--)
{
pColors->Set_Color(i, pColors->Get_Color(i - 1));
}
pColors->Set_Color(0, c);
}
DataObject_Set_Colors(pGrid, *pColors);
DataObject_Update(pGrid, true);
}
while( Process_Get_Okay(true) );
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CFlow_AreaUpslope_Area::On_Execute(void)
{
bool bResult = false;
//-----------------------------------------------------
if( m_Calculator.Initialise(
Parameters("METHOD") ->asInt(),
Parameters("ELEVATION") ->asGrid(),
Parameters("SINKROUTE") ->asGrid(),
Parameters("AREA") ->asGrid(),
Parameters("CONVERGE") ->asDouble() ) )
{
if( m_Calculator.Clr_Target() )
{
int x, y;
CSG_Grid *pTarget = Parameters("TARGET")->asGrid();
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !pTarget->is_NoData(x, y) && m_Calculator.Add_Target(x, y) )
{
bResult = true;
}
}
}
if( bResult )
{
m_Calculator.Get_Area();
DataObject_Set_Colors(Parameters("AREA")->asGrid(), 100, SG_COLORS_WHITE_BLUE);
}
}
}
//-----------------------------------------------------
m_Calculator.Finalise();
return( bResult );
}
//---------------------------------------------------------
bool CConvergence::On_Execute(void)
{
pDTM = Parameters("ELEVATION") ->asGrid();
pConvergence = Parameters("RESULT") ->asGrid();
pConvergence->Assign_NoData();
DataObject_Set_Colors(pConvergence, 100, SG_COLORS_RED_GREY_BLUE, true);
switch( Parameters("METHOD")->asInt() )
{
case 0:
Do_Aspect();
break;
case 1:
Do_Gradient();
break;
}
return( true );
}
//---------------------------------------------------------
void CGrid_3D_Image::_Set_Grid(void)
{
T3DPoint *a, *b, *c, *d, p[3];
//-----------------------------------------------------
a = (T3DPoint *)SG_Malloc(sizeof(T3DPoint) * Get_NX());
b = (T3DPoint *)SG_Malloc(sizeof(T3DPoint) * Get_NX());
c = (T3DPoint *)SG_Malloc(sizeof(T3DPoint) * (Get_NX() - 1));
//-----------------------------------------------------
_Get_Line(0, b);
for(int y=1; y<Get_NY() && Set_Progress(y); y++)
{
d = a;
a = b;
b = d;
_Get_Line(y, b);
_Get_Line(a, b, c);
for(int ax=0, bx=1; bx<Get_NX(); ax++, bx++)
{
DRAW_TRIANGLE(a[ax], a[bx], c[ax]);
DRAW_TRIANGLE(b[ax], b[bx], c[ax]);
DRAW_TRIANGLE(a[ax], b[ax], c[ax]);
DRAW_TRIANGLE(a[bx], b[bx], c[ax]);
}
}
//-----------------------------------------------------
SG_Free(a);
SG_Free(b);
SG_Free(c);
//-----------------------------------------------------
DataObject_Add(m_pRGB_Z);
DataObject_Add(m_pRGB);
DataObject_Set_Colors(m_pRGB, 100, SG_COLORS_BLACK_WHITE);
}
//---------------------------------------------------------
bool CGrid_RGB_Composite::On_Execute(void)
{
double rMin, rRange, gMin, gRange, bMin, bRange, aMin, aRange;
//-----------------------------------------------------
CSG_Grid *pR = _Get_Grid(Parameters("R_GRID")->asGrid(), Parameters("R_METHOD")->asInt(), Parameters("R_RANGE")->asRange(), Parameters("R_PERCTL")->asRange(), Parameters("R_STDDEV")->asDouble(), rMin, rRange);
CSG_Grid *pG = _Get_Grid(Parameters("G_GRID")->asGrid(), Parameters("G_METHOD")->asInt(), Parameters("G_RANGE")->asRange(), Parameters("G_PERCTL")->asRange(), Parameters("G_STDDEV")->asDouble(), gMin, gRange);
CSG_Grid *pB = _Get_Grid(Parameters("B_GRID")->asGrid(), Parameters("B_METHOD")->asInt(), Parameters("B_RANGE")->asRange(), Parameters("B_PERCTL")->asRange(), Parameters("B_STDDEV")->asDouble(), bMin, bRange);
CSG_Grid *pA = _Get_Grid(Parameters("A_GRID")->asGrid(), Parameters("A_METHOD")->asInt(), Parameters("A_RANGE")->asRange(), Parameters("A_PERCTL")->asRange(), Parameters("A_STDDEV")->asDouble(), aMin, aRange);
//-----------------------------------------------------
CSG_Grid *pRGB = Parameters("RGB")->asGrid();
pRGB->Create(pRGB->Get_System(), SG_DATATYPE_Int);
pRGB->Set_Name(_TL("Composite"));
CSG_String s;
s += CSG_String(_TL("Red" )) + ": " + pR->Get_Name() + "\n";
s += CSG_String(_TL("Green")) + ": " + pG->Get_Name() + "\n";
s += CSG_String(_TL("Blue" )) + ": " + pB->Get_Name() + "\n";
if( pA )
{
s += CSG_String(_TL("Alpha")) + ": " + pA->Get_Name() + "\n";
}
pRGB->Set_Description(s);
DataObject_Set_Colors (pRGB, 100, SG_COLORS_BLACK_WHITE);
DataObject_Set_Parameter(pRGB, "COLORS_TYPE", 5); // Color Classification Type: RGB Coded Values
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pR->is_NoData(x, y) || pG->is_NoData(x, y) || pB->is_NoData(x, y) || (pA && pA->is_NoData(x, y)) )
{
pRGB->Set_NoData(x, y);
}
else
{
int r = (int)(rRange * (pR->asDouble(x, y) - rMin)); if( r > 255 ) r = 255; else if( r < 0 ) r = 0;
int g = (int)(gRange * (pG->asDouble(x, y) - gMin)); if( g > 255 ) g = 255; else if( g < 0 ) g = 0;
int b = (int)(bRange * (pB->asDouble(x, y) - bMin)); if( b > 255 ) b = 255; else if( b < 0 ) b = 0;
if( pA )
{
int a = (int)(aRange * (pA->asDouble(x, y) - aMin)); if( a > 255 ) a = 255; else if( a < 0 ) a = 0;
pRGB->Set_Value(x, y, SG_GET_RGBA(r, g, b, a));
}
else
{
pRGB->Set_Value(x, y, SG_GET_RGB (r, g, b));
}
}
}
}
return( true );
}
