//---------------------------------------------------------
bool CSADO_SolarRadiation::Get_Shade(double Decline, double Azimuth)
{
//-----------------------------------------------------
m_Shade.Assign(0.0);
if( !m_bBending )
{
int i, x, y;
double dx, dy, dz;
Get_Shade_Params(Decline, Azimuth, dx, dy, dz);
for(i=0; i<Get_NCells() && Set_Progress_NCells(i); i++)
{
if( m_pDEM->Get_Sorted(i, x, y) && !Get_Shade_Complete(x, y) )
{
Set_Shade(x, y, dx, dy, dz);
}
}
}
//-----------------------------------------------------
else
{
int i, x, y, iLock;
for(i=0, iLock=1; i<Get_NCells() && Set_Progress_NCells(i); i++, iLock++)
{
if( m_pDEM->Get_Sorted(i, x, y) && !Get_Shade_Complete(x, y) )
{
if( iLock >= 255 )
iLock = 1;
if( iLock == 1 )
Lock_Create();
Set_Shade_Bended(x, y, iLock);
}
}
}
return( true );
}
//---------------------------------------------------------
void CChannelNetwork::Set_Channel_Order(int x, int y)
{
int i, ix, iy, j, n;
//-----------------------------------------------------
if( pChannelRoute->asChar(x,y) > 0 )
{
for(i=n=0, j=4; i<8; i++, j=(j+1)%8)
{
ix = Get_xTo(i,x);
iy = Get_yTo(i,y);
if( pDTM->is_InGrid(ix,iy) && pChannelRoute->asChar(ix,iy) && j == pChannelRoute->asChar(ix,iy) % 8 )
{
n++;
}
}
//-----------------------------------------------------
if( n == 0 )
{
Lock_Create();
do
{
Lock_Set(x,y);
pChannels->Add_Value(x,y, 1 );
i = pChannelRoute->asChar(x,y);
if( i > 0 )
{
x = Get_xTo(i,x);
y = Get_yTo(i,y);
}
}
while( pDTM->is_InGrid(x,y) && i > 0 && !is_Locked(x,y) );
}
}
}
//---------------------------------------------------------
void CPit_Eliminator::Fill_Check(int x, int y)
{
bool bOutlet;
int i, ix, iy, j;
double z;
z = pDTM ->asDouble (x, y);
i = goRoute ->asChar (x, y);
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
if( !is_InGrid(ix, iy) || z > pDTM->asDouble(ix, iy) )
{
for(i=0, j=4, bOutlet=false; i<8 && !bOutlet; i++, j=(j+1)%8)
{
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
if( is_InGrid(ix, iy) && goRoute->asChar(ix, iy) == j && z > pDTM->asDouble(ix, iy) )
{
bOutlet = true;
}
}
if( bOutlet )
{
Lock_Create();
Lock_Set(x, y);
for(i=0, j=4; i<8; i++, j=(j+1)%8)
{
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
Fill_Sink(ix, iy, j, z);
}
}
}
}
//---------------------------------------------------------
void CFlow_RecursiveUp::On_Create(void)
{
int x, y, Method;
double *p;
//-----------------------------------------------------
On_Destroy();
Flow = (double ***)SG_Malloc( Get_NY () * sizeof(double **));
p = (double *)SG_Malloc(8 * Get_NCells() * sizeof(double ));
for(y=0; y<Get_NY(); y++)
{
Flow[y] = (double **)SG_Malloc( Get_NX () * sizeof(double *));
for(x=0; x<Get_NX(); x++, p+=8)
{
Flow[y][x] = p;
}
}
//-----------------------------------------------------
Lock_Create();
Method = Parameters("Method")->asInt();
memset(Flow[0][0], 0, 8 * Get_NCells() * sizeof(double) );
for(y=0; y<Get_NY(); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( pRoute && pRoute->asChar(x,y) > 0 )
{
Flow[y][x][pRoute->asChar(x,y) % 8] = 1.0;
}
else
{
switch( Method )
{
case 0:
Set_D8(x,y);
break;
case 1:
Set_Rho8(x,y);
break;
case 2:
Set_DInf(x,y);
break;
case 3:
Set_MFD(x,y);
break;
}
}
}
}
}
//---------------------------------------------------------
void CChannelNetwork::Set_Channel_Route(int x, int y)
{
const int BUFFER_GROWSIZE = 256;
int xStart, yStart, i, ix, iy, goDir, m, n, nDiv;
double z, dz, dzMin, Length;
//-----------------------------------------------------
if( pStart->asChar(x,y) && !pChannelRoute->asChar(x,y) )
{
Lock_Create();
n = 0;
nDiv = 0;
Length = 0;
xStart = x;
yStart = y;
do
{
//---------------------------------------------
// 1. Divergence ?!...
if( pConvergence )
{
if( pConvergence->asDouble(x,y) > -1.0 )
{
nDiv++;
}
else
{
nDiv = 0;
}
}
if( pConvergence && nDiv > maxDivCells )
{
goDir = -1;
}
else
{
//-----------------------------------------
// 2. Is there any channel around ?!...
goDir = 0;
z = pDTM->asDouble(x,y);
for(i=1; i<=8; i++)
{
ix = Get_xTo(i,x);
iy = Get_yTo(i,y);
if( pDTM->is_InGrid(ix,iy) && !is_Locked(ix,iy) && pChannelRoute->asChar(ix,iy) )
{
dz = (z - pDTM->asDouble(ix,iy)) / Get_Length(i);
if( goDir <= 0 || dzMin < dz )
{
goDir = i;
dzMin = dz;
}
}
}
if( goDir <= 0 ) // ...if not then go as usual...
{
goDir = pChannels->asInt(x,y);
}
//-----------------------------------------
// 3. Go to Drainage Direction !...
if( goDir > 0 )
{
Lock_Set(x,y);
x = Get_xTo(goDir,x);
y = Get_yTo(goDir,y);
Length += Get_UnitLength(goDir);
if( n >= Direction_Buffer )
{
Direction_Buffer += BUFFER_GROWSIZE;
Direction = (int *)SG_Realloc(Direction, Direction_Buffer * sizeof(int));
}
Direction[n++] = goDir;
}
}
}
while( goDir > 0 && pDTM->is_InGrid(x,y) && !is_Locked(x,y) && !pChannelRoute->asChar(x,y) );
//-------------------------------------------------
if( Length >= minLength )
{
x = xStart;
y = yStart;
if( goDir < 0 )
{
n -= nDiv;
}
for(m=0; m<n; m++)
{
goDir = Direction[m];
pChannelRoute->Set_Value(x,y,goDir);
for(i=0; i<8; i++) // Don't start new channels beside existing ones...
{
ix = Get_xTo(i,x);
iy = Get_yTo(i,y);
if( pDTM->is_InGrid(ix,iy) )
{
pStart->Set_Value(ix,iy,0);
}
}
x = Get_xTo(goDir,x);
y = Get_yTo(goDir,y);
}
}
}
}
//---------------------------------------------------------
bool CChannelNetwork::On_Execute(void)
{
int x, y, ID, Trace_Method, Init_Method;
long n;
double Init_Threshold;
CSG_Grid *Trace_pRoute, *Trace_pWeight, *Init_pGrid;
//-----------------------------------------------------
pDTM = Parameters("ELEVATION") ->asGrid();
pConvergence = Parameters("DIV_GRID") ->asGrid();
pChannels = Parameters("CHNLNTWRK") ->asGrid();
pChannelRoute = Parameters("CHNLROUTE") ->asGrid();
pShapes = Parameters("SHAPES") ->asShapes();
minLength = Parameters("MINLEN") ->asInt();
maxDivCells = Parameters("DIV_GRID")->asGrid() ? Parameters("DIV_CELLS")->asInt() : -1;
//-----------------------------------------------------
// 1. Flow Direction...
Process_Set_Text(_TL("Channel Network: Pass 1"));
pChannels->Assign();
Trace_pRoute = Parameters("SINKROUTE") ->asGrid();
Trace_pWeight = Parameters("TRACE_WEIGHT")->asGrid();
Trace_Method = Trace_pWeight ? 1 : 0;
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( Trace_pRoute && (ID = Trace_pRoute->asChar(x, y)) >= 1 && ID <= 8 )
{
pChannels->Set_Value(x, y, ID);
}
else
{
switch( Trace_Method )
{
default:
Set_Route_Standard(x, y);
break;
case 1:
Set_Route_Weighted(x, y, Trace_pWeight, 0.0);
break;
}
}
}
}
//-----------------------------------------------------
// 2. Initiation...
Process_Set_Text(_TL("Channel Network: Pass 2"));
pStart = SG_Create_Grid(pDTM, SG_DATATYPE_Char);
Init_pGrid = Parameters("INIT_GRID") ->asGrid();
Init_Method = Parameters("INIT_METHOD") ->asInt();
Init_Threshold = Parameters("INIT_VALUE") ->asDouble();
for(n=0; n<Get_NCells() && Set_Progress_NCells(n); n++)
{
switch( Init_Method )
{
case 0:
if( Init_pGrid->asDouble(n) <= Init_Threshold )
pStart->Set_Value(n, 1);
break;
case 1:
if( Init_pGrid->asDouble(n) == Init_Threshold )
pStart->Set_Value(n, 1);
break;
case 2:
if( Init_pGrid->asDouble(n) >= Init_Threshold )
pStart->Set_Value(n, 1);
break;
}
}
//-----------------------------------------------------
// 3. Trace Channel Routes...
Process_Set_Text(_TL("Channel Network: Pass 3"));
pChannelRoute->Assign();
Direction = NULL;
Direction_Buffer = 0;
for(n=0; n<Get_NCells() && Set_Progress_NCells(n); n++)
{
if( pDTM->Get_Sorted(n,x,y) )
{
Set_Channel_Route(x,y);
}
}
if( Direction )
{
SG_Free( Direction );
}
pChannels->Assign();
delete(pStart);
//-----------------------------------------------------
Process_Set_Text(_TL("Channel Network: Pass 4"));
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
Set_Channel_Order(x,y);
}
}
//-----------------------------------------------------
Process_Set_Text(_TL("Channel Network: Pass 5"));
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
Set_Channel_Mouth(x,y);
}
}
//-----------------------------------------------------
if( pShapes )
{
Process_Set_Text(_TL("Channel Network: Pass 6"));
pShapes->Create(SHAPE_TYPE_Line, _TL("Channel Network"));
pShapes->Add_Field("SegmentID" ,SG_DATATYPE_Int);
pShapes->Add_Field("Order" ,SG_DATATYPE_Int);
pShapes->Add_Field("Length" ,SG_DATATYPE_Double);
Lock_Create();
for(y=0, ID=1; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
Set_Vector(x, y, ID++);
}
}
Lock_Destroy();
}
//-----------------------------------------------------
for(n=0; n<Get_NCells(); n++)
{
if( pChannels->asInt(n) == 0 )
{
pChannels->Set_NoData(n);
pChannelRoute->Set_NoData(n);
}
}
//-----------------------------------------------------
return( true );
}
