//---------------------------------------------------------
double CGrid_Gaps::Tension_Change(int x, int y, int iStep)
{
int i, ix, iy;
double n, d, dz;
for(i=0, d=0.0, n=0.0; i<8; i++)
{
ix = x + iStep * Get_System()->Get_xTo(i);
iy = y + iStep * Get_System()->Get_yTo(i);
if( pResult->is_InGrid(ix, iy) )
{
dz = 1.0 / Get_System()->Get_UnitLength(i);
d += dz * pResult->asDouble(ix, iy);
n += dz;
}
}
if( n > 0.0 )
{
d /= n;
return( d );
}
return( pResult->asDouble(x, y) );
}
*/ void Init_Errors(REBVAL *errors)
/*
***********************************************************************/
{
REBSER *errs;
REBVAL *val;
// Create error objects and error type objects:
*ROOT_ERROBJ = *Get_System(SYS_STANDARD, STD_ERROR);
errs = Construct_Object(0, VAL_BLK(errors), 0);
Set_Object(Get_System(SYS_CATALOG, CAT_ERRORS), errs);
Set_Root_Series(TASK_ERR_TEMPS, Make_Block(3));
// Create objects for all error types:
for (val = BLK_SKIP(errs, 1); NOT_END(val); val++) {
errs = Construct_Object(0, VAL_BLK(val), 0);
SET_OBJECT(val, errs);
}
// Catch top level errors, to provide decent output:
PUSH_STATE(Top_State, Saved_State);
if (SET_JUMP(Top_State)) {
POP_STATE(Top_State, Saved_State);
DSP++; // Room for return value
Catch_Error(DS_TOP); // Stores error value here
Print_Value(DS_TOP, 0, FALSE);
Crash(RP_NO_CATCH);
}
SET_STATE(Top_State, Saved_State);
}
//---------------------------------------------------------
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 CSG_Module_Grid::Set_Progress_NCells(int iCell)
{
if( Get_System()->is_Valid() && (Get_System()->Get_NCells() <= 100 || !(iCell % (Get_System()->Get_NCells() / 100))) )
{
return( CSG_Module::Set_Progress(iCell, Get_System()->Get_NCells()) );
}
return( is_Progress() );
}
//---------------------------------------------------------
bool CSG_Module_Grid::Set_Progress_NCells(sLong iCell)
{
if( Get_System()->is_Valid() )
{
return( CSG_Module::Set_Progress((double)iCell, (double)Get_System()->Get_NCells()) );
}
return( is_Progress() );
}
//---------------------------------------------------------
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 CDiffuse_Pollution_Risk::Set_Flow(void)
{
Process_Set_Text(_TL("initialization"));
CSG_Grid *pWeight = Parameters("WEIGHT")->asGrid ();
double Weight = Parameters("WEIGHT")->asDouble();
CSG_Grid *pRain = Parameters("RAIN" )->asGrid ();
double Rain = Parameters("RAIN" )->asDouble();
m_FlowDir.Create(*Get_System(), SG_DATATYPE_Char);
m_RainAcc.Create(*Get_System());
m_TWI .Create(*Get_System());
for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++)
{
int x, y;
if( !m_pDEM->Get_Sorted(n, x, y, true) || (pRain && pRain->is_NoData(x, y)) || !Set_Flow(x, y, pRain ? pRain->asDouble(x, y) : Rain) )
{
m_FlowDir .Set_NoData(x, y);
m_RainAcc .Set_NoData(x, y);
m_TWI .Set_NoData(x, y);
m_pRisk_Point->Set_NoData(x, y);
}
else
{
double s, a;
m_pDEM->Get_Gradient(x, y, s, a);
s = tan(s); // tangens of slope
a = (fabs(sin(a)) + fabs(cos(a))) * Get_Cellsize(); // flow width
double SCA = m_RainAcc.asDouble(x, y) / a; // rain * specific catchment area
m_TWI.Set_Value(x, y, log(SCA / (s < M_ALMOST_ZERO ? M_ALMOST_ZERO : s)));
if( pWeight && pWeight->is_NoData(x, y) )
{
m_pRisk_Point->Set_NoData(x, y);
}
else
{
m_pRisk_Point->Set_Value(x, y, SCA * s * (pWeight ? pWeight->asDouble(x, y) : Weight)); // Point Scale Risk Calculation according to Milledge et al. 2012
}
}
}
return( true );
}
//---------------------------------------------------------
bool CTC_Texture::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid Noise(*Get_System(), SG_DATATYPE_Char);
double Epsilon = Parameters("EPSILON")->asDouble();
m_pDEM = Parameters("DEM")->asGrid();
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( m_pDEM->is_NoData(x, y) )
{
Noise.Set_NoData(x, y);
}
else
{
Noise.Set_Value(x, y, Get_Noise(x, y, Epsilon));
}
}
}
//-----------------------------------------------------
return( Get_Parameter(&Noise, Parameters("TEXTURE")->asGrid()) );
}
*/ REBVAL *Find_Last_Event (REBINT model, REBINT type)
/*
** Find the last event in the queue by the model
** Check its type, if it matches, then return the event or NULL
**
**
***********************************************************************/
{
REBVAL *port;
REBVAL *value;
REBVAL *state;
port = Get_System(SYS_PORTS, PORTS_SYSTEM);
if (!IS_PORT(port)) return NULL; // verify it is a port object
// Get queue block:
state = VAL_OBJ_VALUE(port, STD_PORT_STATE);
if (!IS_BLOCK(state)) return NULL;
for (value = VAL_BLK_TAIL(state) - 1; value >= VAL_BLK(state); -- value) {
if (VAL_EVENT_MODEL(value) == model) {
if (VAL_EVENT_TYPE(value) == type) {
return value;
} else {
return NULL;
}
}
}
return NULL;
}
*/ REBVAL *Find_Error_Info(ERROR_OBJ *error, REBINT *num)
/*
** Return the error message needed to print an error.
** Must scan the error catalog and its error lists.
** Note that the error type and id words no longer need
** to be bound to the error catalog context.
** If the message is not found, return null.
**
***********************************************************************/
{
REBSER *frame;
REBVAL *obj1;
REBVAL *obj2;
if (!IS_WORD(&error->type) || !IS_WORD(&error->id)) return 0;
// Find the correct error type object in the catalog:
frame = VAL_OBJ_FRAME(Get_System(SYS_CATALOG, CAT_ERRORS));
obj1 = Find_Word_Value(frame, VAL_WORD_SYM(&error->type));
if (!obj1) return 0;
// Now find the correct error message for that type:
frame = VAL_OBJ_FRAME(obj1);
obj2 = Find_Word_Value(frame, VAL_WORD_SYM(&error->id));
if (!obj2) return 0;
if (num) {
obj1 = Find_Word_Value(frame, SYM_CODE);
*num = VAL_INT32(obj1)
+ Find_Word_Index(frame, VAL_WORD_SYM(&error->id), FALSE)
- Find_Word_Index(frame, SYM_TYPE, FALSE) - 1;
}
return obj2;
}
*/ void Set_Error_Type(ERROR_OBJ *error)
/*
** Sets error type and id fields based on code number.
**
***********************************************************************/
{
REBSER *cats; // Error catalog object
REBSER *cat; // Error category object
REBCNT n; // Word symbol number
REBCNT code;
code = VAL_INT32(&error->code);
// Set error category:
n = code / 100 + 1;
cats = VAL_OBJ_FRAME(Get_System(SYS_CATALOG, CAT_ERRORS));
if (code >= 0 && n < SERIES_TAIL(cats) &&
NZ(cat = VAL_SERIES(BLK_SKIP(cats, n)))
) {
Set_Word(&error->type, FRM_WORD_SYM(cats, n), cats, n);
// Find word related to the error itself:
n = code % 100 + 3;
if (n < SERIES_TAIL(cat))
Set_Word(&error->id, FRM_WORD_SYM(cat, n), cat, n);
}
}
//---------------------------------------------------------
bool CGrid_Gaps_Spline_Fill::On_Execute(void)
{
//-----------------------------------------------------
m_pGrid = Parameters("CLOSED") ->asGrid();
m_pMask = Parameters("MASK") ->asGrid();
m_nGapCells_Max = Parameters("MAXGAPCELLS") ->asInt();
m_nPoints_Max = Parameters("MAXPOINTS") ->asInt();
m_nPoints_Local = Parameters("LOCALPOINTS") ->asInt();
m_bExtended = Parameters("EXTENDED") ->asBool();
m_Neighbours = Parameters("NEIGHBOURS") ->asInt() == 0 ? 2 : 1;
m_Radius = Parameters("RADIUS") ->asDouble();
m_Relaxation = Parameters("RELAXATION") ->asDouble();
if( m_pGrid == NULL )
{
m_pGrid = Parameters("GRID")->asGrid();
Parameters("CLOSED")->Set_Value(m_pGrid);
}
else if( m_pGrid != Parameters("GRID")->asGrid() )
{
m_pGrid->Assign(Parameters("GRID")->asGrid());
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), Parameters("GRID")->asGrid()->Get_Name(), _TL("no gaps")));
}
if( m_nGapCells_Max == 0 )
{
m_nGapCells_Max = Get_NCells();
}
if( m_nPoints_Local > m_nPoints_Max )
{
m_nPoints_Local = m_nPoints_Max;
}
//-----------------------------------------------------
m_Gaps.Create(*Get_System(), SG_DATATYPE_Int);
m_Gaps.Assign(0.0);
m_nGaps = 0;
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( is_Gap(x, y) && m_Gaps.asInt(x, y) == 0 )
{
Close_Gap(x, y);
}
}
}
//-----------------------------------------------------
m_Stack .Clear();
m_GapCells .Clear();
m_Gaps .Destroy();
m_Spline .Destroy();
return( true );
}
//---------------------------------------------------------
bool CDiffuse_Pollution_Risk::Set_Flow(int x, int y, double Rain)
{
//-----------------------------------------------------
if( m_pDEM->is_NoData(x, y) )
{
return( false );
}
double d[8];
m_FlowDir.Set_Value(x, y, m_pDEM->Get_Gradient_NeighborDir(x, y));
m_RainAcc.Set_Value(x, y, Rain = Rain * Get_Cellarea() + m_RainAcc.asDouble(x, y));
//-----------------------------------------------------
if( m_bSingle )
{
if( Get_System()->Get_Neighbor_Pos(m_FlowDir.asInt(x, y), x, y, x, y) && m_pDEM->is_InGrid(x, y) )
{
m_RainAcc.Add_Value(x, y, Rain);
}
}
else if( Get_Flow_Proportions(x, y, d) )
{
for(int i=0; i<8; i++)
{
if( d[i] > 0.0 )
{
m_RainAcc.Add_Value(Get_xTo(i, x), Get_yTo(i, y), Rain * d[i]);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGrid_Fill::On_Execute(void)
{
CSG_Shapes *pPoints = Parameters("POINTS")->asShapes();
if( !pPoints->is_Valid() || !pPoints->Get_Extent().Intersects(Get_System().Get_Extent()) || !Parameters_Set(Parameters) )
{
return( false );
}
//-----------------------------------------------------
int nReplaced = 0;
#define GET_NPOINTS (bSelection ? pPoints->Get_Selection_Count() : pPoints->Get_Count())
#define GET_POINT(i) (bSelection ? pPoints->Get_Selection(i)->Get_Point(0) : pPoints->Get_Shape(i)->Get_Point(0))
bool bSelection = pPoints->Get_Selection_Count() > 0;
for(int i=0; i<GET_NPOINTS && Process_Get_Okay(); i++)
{
nReplaced += Fill(GET_POINT(i));
}
Message_Fmt("\n%d %s\n", nReplaced, _TL("replacements"));
return( true );
}
*/ REBVAL *Append_Event()
/*
** Append an event to the end of the current event port queue.
** Return a pointer to the event value.
**
** Note: this function may be called from out of environment,
** so do NOT extend the event queue here. If it does not have
** space, return 0. (Should it overwrite or wrap???)
**
***********************************************************************/
{
REBVAL *port;
REBVAL *value;
REBVAL *state;
port = Get_System(SYS_PORTS, PORTS_SYSTEM);
if (!IS_PORT(port)) return 0; // verify it is a port object
// Get queue block:
state = VAL_BLK_SKIP(port, STD_PORT_STATE);
if (!IS_BLOCK(state)) return 0;
// Append to tail if room:
if (SERIES_FULL(VAL_SERIES(state))) Crash(RP_MAX_EVENTS);
VAL_TAIL(state)++;
value = VAL_BLK_TAIL(state);
SET_END(value);
value--;
SET_NONE(value);
//Dump_Series(VAL_SERIES(state), "state");
//Print("Tail: %d %d", VAL_TAIL(state), nn++);
return value;
}
//---------------------------------------------------------
bool CCost_Accumulated::Get_Destinations(CPoints &Points)
{
Points.Clear();
m_pAccumulated->Set_NoData_Value(-1.0); m_pAccumulated->Assign(-1.0);
m_pAllocation ->Set_NoData_Value(-1.0); m_pAllocation ->Assign( 0.0);
if( Parameters("DEST_TYPE")->asInt() == 0 ) // Point
{
CSG_Shapes *pDestinations = Parameters("DEST_POINTS")->asShapes();
for(int i=0, x, y; i<pDestinations->Get_Count(); i++)
{
if( Get_System().Get_World_to_Grid(x, y, pDestinations->Get_Shape(i)->Get_Point(0)) && !m_pCost->is_NoData(x, y) )
{
Points.Add(x, y); m_pAllocation->Set_Value(x, y, Points.Get_Count()); m_pAccumulated->Set_Value(x, y, 0.0);
}
}
}
else // Grid
{
CSG_Grid *pDestinations = Parameters("DEST_GRID")->asGrid();
for(int y=0; y<Get_NY(); y++) for(int x=0; x<Get_NX(); x++)
{
if( !pDestinations->is_NoData(x, y) && !m_pCost->is_NoData(x, y) )
{
Points.Add(x, y); m_pAllocation->Set_Value(x, y, Points.Get_Count()); m_pAccumulated->Set_Value(x, y, 0.0);
}
}
}
return( Points.Get_Count() > 0 );
}
//---------------------------------------------------------
bool CTC_Convexity::On_Execute(void)
{
//-----------------------------------------------------
const double Kernels[3][2] = { { 1, 0 }, { 1, 1 }, { 1, 1 / sqrt(2.0) } };
int Kernel = Parameters("KERNEL")->asInt();
//-----------------------------------------------------
CSG_Grid Laplace(*Get_System(), SG_DATATYPE_Char);
double Epsilon = Parameters("EPSILON")->asDouble();
int Type = Parameters("TYPE" )->asInt ();
m_pDEM = Parameters("DEM")->asGrid();
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( m_pDEM->is_NoData(x, y) )
{
Laplace.Set_NoData(x, y);
}
else
{
Laplace.Set_Value(x, y, Get_Laplace(x, y, Kernels[Kernel], Type, Epsilon));
}
}
}
//-----------------------------------------------------
return( Get_Parameter(&Laplace, Parameters("CONVEXITY")->asGrid()) );
}
//---------------------------------------------------------
void CAir_Flow_Height::Get_Lee(int x, int y, double &Sum_A, double &Sum_B)
{
double Weight_A = Sum_A = 0.0;
double Weight_B = Sum_B = 0.0;
if( m_pDEM->is_InGrid(x, y) )
{
double z, d, id, w;
TSG_Point p;
d = id = Get_Cellsize();
p = Get_System()->Get_Grid_to_World(x, y);
while( id <= m_maxDistance && Get_Next(p, d, true) )
{
if( Get_Z(p, d, z) )
{
Weight_A += w = d * pow(id, -m_dLuv);
Sum_A += w * z;
Weight_B += w = d * pow(id, -m_dLee);
Sum_B += w * z;
}
d *= m_Acceleration;
id += d;
}
if( Weight_A > 0.0 ) { Sum_A /= Weight_A; }
if( Weight_B > 0.0 ) { Sum_B /= Weight_B; }
}
}
*/ void Sieve_Ports(REBSER *ports)
/*
** Remove all ports not found in the WAKE list.
** ports could be NULL, in which case the WAKE list is cleared.
**
***********************************************************************/
{
REBVAL *port;
REBVAL *waked;
REBVAL *val;
REBCNT n;
port = Get_System(SYS_PORTS, PORTS_SYSTEM);
if (!IS_PORT(port)) return;
waked = VAL_OBJ_VALUE(port, STD_PORT_DATA);
if (!IS_BLOCK(waked)) return;
for (n = 0; ports && n < SERIES_TAIL(ports);) {
val = BLK_SKIP(ports, n);
if (IS_PORT(val)) {
assert(VAL_TAIL(waked) != 0);
if (VAL_TAIL(waked) == Find_Block_Simple(VAL_SERIES(waked), 0, val)) {//not found
Remove_Series(ports, n, 1);
continue;
}
}
n++;
}
//clear waked list
RESET_SERIES(VAL_SERIES(waked));
}
//---------------------------------------------------------
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 CRGA_Basic::Add_To_Segment(int x, int y, int Segment)
{
if( is_InGrid(x, y) && m_pSegments->is_NoData(x, y) ) // if the pixel is not element of any segment...
{
int i, ix, iy;
m_pSegments->Set_Value(x, y, Segment); // the candidate is added to the correspondig region
for(i=0; i<8; i+=m_dNeighbour) // update of candidate-grid - all 8-Neigbours of the added pixel are checked
{
if( Get_System()->Get_Neighbor_Pos(i, x, y, ix, iy) && m_pSegments->is_NoData(ix, iy) )
{
double Similarity = Get_Similarity(ix, iy, Segment);
if( Similarity >= m_Threshold // a neigbour-pixel is only added as candidate if its similarity is higher than the preset threshold
&& Similarity > m_pSimilarity->asDouble(ix, iy) ) // and it is not candidate for another region with a higher similarity-value yet
{
m_Candidates.Add(ix, iy, Segment, Similarity);
m_pSimilarity->Set_Value(ix, iy, Similarity);
}
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGrid_Profile::On_Execute_Position(CSG_Point ptWorld, TSG_Module_Interactive_Mode Mode)
{
switch( Mode )
{
default:
break;
case MODULE_INTERACTIVE_LDOWN:
if( !m_bAdd )
{
m_bAdd = true;
m_pLine->Create(SHAPE_TYPE_Line, CSG_String::Format(SG_T("Profile [%s]"), m_pDEM->Get_Name()));
m_pLine->Add_Field("ID" , SG_DATATYPE_Int);
m_pLine->Add_Shape()->Set_Value(0, 1);
}
m_pLine->Get_Shape(0)->Add_Point(Get_System()->Fit_to_Grid_System(ptWorld));
DataObject_Update(m_pLine);
break;
case MODULE_INTERACTIVE_RDOWN:
Set_Profile();
m_bAdd = false;
break;
}
return( true );
}
bool Cdodproperror::SaveGridsAsTIFF(CSG_Grid** grids, CSG_Strings paths)
{
TSG_Data_Type Type;
CSG_String FilePath;
CSG_Grid* Grid;
// SAVE TIFFS
for (int i = 0; i < paths.Get_Count(); i++)
{
FilePath = paths[i];
Grid = grids[i];
Type = Grid->Get_Type();
if( !GDALDataSet.Open_Write(FilePath, GDALDriver, GDALOptions, Type, 1, *Get_System(), Projection) )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for writing: "), FilePath.c_str()));
return( false );
}
GDALDataSet.Write(0, Grid);
if( !GDALDataSet.Close() )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to close file after writing: "), FilePath.c_str()));
return( false );
}
}
return true;
}
//---------------------------------------------------------
bool CTopographic_Correction::Get_Illumination(void)
{
Process_Set_Text(_TL("Illumination calculation"));
//-----------------------------------------------------
CSG_Grid DEM, *pDEM = Parameters("DEM")->asGrid();
if( !pDEM->Get_System().is_Equal(*Get_System()) )
{
DEM.Create(*Get_System());
DEM.Assign(pDEM, pDEM->Get_Cellsize() > Get_Cellsize() ? GRID_INTERPOLATION_BSpline : GRID_INTERPOLATION_Mean_Cells);
pDEM = &DEM;
}
//-----------------------------------------------------
double Azi = Parameters("AZI")->asDouble() * M_DEG_TO_RAD;
double Hgt = Parameters("HGT")->asDouble() * M_DEG_TO_RAD;
m_cosTz = cos(M_PI_090 - Hgt);
m_sinTz = sin(M_PI_090 - Hgt);
m_Slope .Create(*Get_System());
m_Illumination .Create(*Get_System());
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
double Slope, Aspect;
if( pDEM->Get_Gradient(x, y, Slope, Aspect) )
{
m_Slope .Set_Value(x, y, Slope);
m_Illumination .Set_Value(x, y, cos(Slope) * m_cosTz + sin(Slope) * m_sinTz * cos(Azi - Aspect));
}
else
{
m_Slope .Set_Value(x, y, 0.0);
m_Illumination .Set_Value(x, y, m_cosTz);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CKinWav_D8::Gauges_Initialise(void)
{
if( m_pGauges_Flow != NULL )
{
if( m_pGauges == NULL )
{
DataObject_Add(m_pGauges = SG_Create_Shapes(SHAPE_TYPE_Point, _TL("Gauges")));
Parameters("GAUGES")->Set_Value(m_pGauges);
m_pGauges->Add_Field(_TL("ID"), SG_DATATYPE_Int);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
bool bBorder = false;
bool bLowest = true;
for(int i=0; i<8; i++)
{
int ix = Get_xTo(i, x);
int iy = Get_yTo(i, y);
if( !m_pDEM->is_InGrid(ix, iy) )
{
bBorder = true;
}
else if( m_pDEM->asDouble(ix, iy) < m_pDEM->asDouble(x, y) )
{
bLowest = false;
}
}
if( bLowest && bBorder )
{
CSG_Shape *pGauge = m_pGauges->Add_Shape();
pGauge->Add_Point(Get_System()->Get_Grid_to_World(x, y));
pGauge->Set_Value(0, m_pGauges->Get_Count() + 1);
}
}
}
}
m_pGauges_Flow->Destroy();
m_pGauges_Flow->Set_Name(_TL("Outlet Hydrographs"));
m_pGauges_Flow->Add_Field("TIME", SG_DATATYPE_Double);
for(int i=0; i<m_pGauges->Get_Count(); i++)
{
m_pGauges_Flow->Add_Field(CSG_String::Format(SG_T("GAUGE_%02d"), i + 1), SG_DATATYPE_Double);
}
return( true );
}
return( false );
}
//---------------------------------------------------------
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 CViGrA_Morphology::On_Execute(void)
{
bool bRescale;
int Type, Radius;
double Rank;
CSG_Grid *pInput, *pOutput, Rescaled;
pInput = Parameters("INPUT") ->asGrid();
pOutput = Parameters("OUTPUT") ->asGrid();
Type = Parameters("TYPE") ->asInt();
Radius = Parameters("RADIUS") ->asInt();
Rank = Parameters("RANK") ->asDouble();
bRescale = Parameters("RESCALE") ->asBool();
//-----------------------------------------------------
if( bRescale )
{
Rescaled.Create(*Get_System(), SG_DATATYPE_Byte);
for(sLong i=0; i<Get_NCells() && Set_Progress_NCells(i); i++)
{
Rescaled.Set_Value(i, 0.5 + (pInput->asDouble(i) - pInput->Get_ZMin()) * 255.0 / pInput->Get_ZRange());
}
pInput = &Rescaled;
}
//-----------------------------------------------------
vigra::BImage Input, Output(Get_NX(), Get_NY());
Copy_Grid_SAGA_to_VIGRA(*pInput, Input, true);
switch( Type )
{
case 0: // Dilation
discDilation (srcImageRange(Input), destImage(Output), Radius);
break;
case 1: // Erosion
discErosion (srcImageRange(Input), destImage(Output), Radius);
break;
case 2: // Median
discMedian (srcImageRange(Input), destImage(Output), Radius);
break;
case 3: // User defined rank
discRankOrderFilter (srcImageRange(Input), destImage(Output), Radius, Rank);
break;
}
//-----------------------------------------------------
Copy_Grid_VIGRA_to_SAGA(*pOutput, Output, false);
pOutput->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pInput->Get_Name(), Get_Name().c_str()));
return( true );
}
//---------------------------------------------------------
bool CErosion_LS_Fields::Set_Fields(void)
{
CSG_Shapes *pFields = Parameters("FIELDS")->asShapes();
//-----------------------------------------------------
if( !pFields || pFields->Get_Count() <= 0 )
{
m_Fields.Create(*Get_System(), SG_DATATYPE_Char);
// m_Fields.Set_NoData_Value(1.0);
// m_Fields.Assign(0.0);
#pragma omp parallel for
for(int y=0; y<Get_NY(); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( !m_pDEM->is_InGrid(x, y) )
{
m_Fields.Set_NoData(x, y);
}
}
}
return( true );
}
//-----------------------------------------------------
Process_Set_Text(_TL("Initializing Fields"));
m_nFields = pFields->Get_Count();
m_Fields.Create(*Get_System(), m_nFields < pow(2.0, 16.0) - 1.0 ? SG_DATATYPE_Word : SG_DATATYPE_DWord);
m_Fields.Set_NoData_Value(m_nFields);
m_Fields.Assign_NoData();
//-----------------------------------------------------
for(int iField=0; iField<pFields->Get_Count() && Set_Progress(iField, pFields->Get_Count()); iField++)
{
CSG_Shape_Polygon *pField = (CSG_Shape_Polygon *)pFields->Get_Shape(iField);
int xMin = Get_System()->Get_xWorld_to_Grid(pField->Get_Extent().Get_XMin()) - 1; if( xMin < 0 ) xMin = 0;
int xMax = Get_System()->Get_xWorld_to_Grid(pField->Get_Extent().Get_XMax()) + 1; if( xMax >= Get_NX() ) xMax = Get_NX() - 1;
int yMin = Get_System()->Get_yWorld_to_Grid(pField->Get_Extent().Get_YMin()) - 1; if( yMin < 0 ) yMin = 0;
int yMax = Get_System()->Get_yWorld_to_Grid(pField->Get_Extent().Get_YMax()) + 1; if( yMax >= Get_NY() ) yMax = Get_NY() - 1;
for(int y=yMin; y<=yMax; y++)
{
for(int x=xMin; x<=xMax; x++)
{
if( m_pDEM->is_InGrid(x, y) && pField->Contains(Get_System()->Get_Grid_to_World(x, y)) )
{
m_Fields.Set_Value(x, y, iField);
}
}
}
}
//-----------------------------------------------------
return( true );
}
*/ REBINT Get_System_Int(REBCNT i1, REBCNT i2, REBINT default_int)
/*
** Get an integer from system object.
**
***********************************************************************/
{
REBVAL *val = Get_System(i1, i2);
if (IS_INTEGER(val)) return VAL_INT32(val);
return default_int;
}
//---------------------------------------------------------
CWKSP_Grid_System * CWKSP_Grid_Manager::_Get_System(const CSG_Grid_System &System)
{
CWKSP_Grid_System *pItem = NULL;
if( (pItem = Get_System(System)) == NULL )
{
Add_Item(pItem = new CWKSP_Grid_System(System));
}
return( pItem );
}