//---------------------------------------------------------
void CFlow::Add_Portion(int x, int y, int ix, int iy)
{
if( is_InGrid(x, y) && is_InGrid(ix, iy) )
{
if( pCatch )
{
pCatch ->Add_Value(ix, iy, pCatch ->asDouble(x, y));
}
if( pCatch_Height )
{
pCatch_Height ->Add_Value(ix, iy, pCatch_Height ->asDouble(x, y));
}
if( pCatch_Slope )
{
pCatch_Slope ->Add_Value(ix, iy, pCatch_Slope ->asDouble(x, y));
}
if( pFlowPath )
{
pFlowPath ->Add_Value(ix, iy, pFlowPath ->asDouble(x, y));
}
if( pCatch_Aspect && pCatch_AspectY )
{
pCatch_Aspect ->Add_Value(ix, iy, pCatch_Aspect ->asDouble(x, y));
pCatch_AspectY ->Add_Value(ix, iy, pCatch_AspectY ->asDouble(x, y));
}
}
}
//---------------------------------------------------------
bool CSG_Grid::Get_Gradient(int x, int y, double &Decline, double &Azimuth) const
{
int i, ix, iy, iDir;
double z, zm[4], G, H;
if( is_InGrid(x, y) )
{
z = asDouble(x, y);
for(i=0, iDir=0; i<4; i++, iDir+=2)
{
ix = m_System.Get_xTo(iDir, x);
iy = m_System.Get_yTo(iDir, y);
if( is_InGrid(ix, iy) )
{
zm[i] = asDouble(ix, iy) - z;
}
else
{
ix = m_System.Get_xFrom(iDir, x);
iy = m_System.Get_yFrom(iDir, y);
if( is_InGrid(ix, iy) )
{
zm[i] = z - asDouble(ix, iy);
}
else
{
zm[i] = 0.0;
}
}
}
G = (zm[0] - zm[2]) / (2.0 * Get_Cellsize());
H = (zm[1] - zm[3]) / (2.0 * Get_Cellsize());
Decline = atan(sqrt(G*G + H*H));
if( G != 0.0 )
Azimuth = M_PI_180 + atan2(H, G);
else
Azimuth = H > 0.0 ? M_PI_270 : (H < 0.0 ? M_PI_090 : -1.0);
return( true );
}
Decline = 0.0;
Azimuth = -1.0;
return( false );
}
///////////////////////////////////////////////////////////
//---------------------------------------------------------
// This function modifies the incoming integer variables!!!
//---------------------------------------------------------
bool CGrid_Polygon_Clip::Get_Extent(int &xMin, int &xCount, int &yMin, int &yCount, CSG_Grid *pMask, CSG_Parameter_Grid_List *pGrids)
{
bool bFound;
for(yMin=0, bFound=false; yMin<Get_NY() && !bFound && Process_Get_Okay(true); yMin++)
{
for(int x=0; x<Get_NX() && !bFound; x++)
{
bFound = is_InGrid(x, yMin, pMask, pGrids);
}
}
yMin--;
//-----------------------------------------------------
if( yMin < Get_NY() && Process_Get_Okay() )
{
int xMax, yMax;
for(yMax=Get_NY()-1, bFound=false; yMax>=yMin && !bFound && Process_Get_Okay(true); yMax--)
{
for(int x=0; x<Get_NX() && !bFound; x++)
{
bFound = is_InGrid(x, yMax, pMask, pGrids);
}
}
for(xMin=0, bFound=false; xMin<Get_NX() && !bFound && Process_Get_Okay(true); xMin++)
{
for(int y=yMin; y<yMax && !bFound; y++)
{
bFound = is_InGrid(xMin, y, pMask, pGrids);
}
}
xMin--;
for(xMax=Get_NX()-1, bFound=false; xMax>=xMin && !bFound && Process_Get_Okay(true); xMax--)
{
for(int y=yMin; y<yMax && !bFound; y++)
{
bFound = is_InGrid(xMax, y, pMask, pGrids);
}
}
xCount = 1 + xMax - xMin;
yCount = 1 + yMax - yMin;
return( xCount > 0 && yCount > 0 );
}
return( false );
}
//---------------------------------------------------------
void CPit_Eliminator::Dig_Channel(int x, int y)
{
bool bContinue;
int goDir;
double z;
z = pDTM->asDouble(x, y);
bContinue = true;
do
{
z -= M_ALMOST_ZERO;
goDir = goRoute->asChar(x, y);
if( goDir < 0 )
{
bContinue = false;
}
else
{
x = Get_xTo(goDir, x);
y = Get_yTo(goDir, y);
if( !is_InGrid(x, y) || z > pDTM->asDouble(x, y) )
{
bContinue = false;
}
else
{
pDTM->Set_Value(x, y, z);
}
}
}
while( bContinue );
}
//---------------------------------------------------------
bool CPit_Eliminator::Dig_Channels(void)
{
bool bPit;
int x, y, i, ix, iy;
double z;
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
z = pDTM->asDouble(x, y);
for(i=0, bPit=true; i<8 && bPit; i++)
{
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
if( !is_InGrid(ix, iy) || z > pDTM->asDouble(ix, iy) )
{
bPit = false;
}
}
if( bPit )
{
Dig_Channel(x, y);
}
}
}
return( is_Progress() );
}
//---------------------------------------------------------
void CFlow_RecursiveUp::Set_MFD(int x, int y)
{
int i, ix, iy;
double z, d, *dz, dzSum;
z = pDTM->asDouble(x,y);
dz = Flow[y][x];
dzSum = 0;
for(i=0; i<8; i++)
{
ix = Get_xTo(i,x);
iy = Get_yTo(i,y);
if( is_InGrid(ix,iy) )
{
d = z - pDTM->asDouble(ix,iy);
if( d > 0 )
dzSum += dz[i] = pow(d / Get_Length(i), MFD_Converge);
}
}
if( dzSum )
{
for(i=0; i<8; i++)
if( dz[i] > 0 )
dz[i] /= dzSum;
}
}
//---------------------------------------------------------
void CFlow_Parallel::Set_BRM( int x, int y )
{
int Dir, QBinaer,
ix[3], iy[3],
nexp[6];
double QLinks, QMitte, QRecht,
nnei[6];
//-----------------------------------------------------
if( is_InGrid(x, y, 1) ) // Rand !!!
{
Dir = BRM_InitRZ(x,y,ix,iy);
if( Dir >= 0 )
{
if( Dir % 2 )
{
BRM_GetDiago(Dir,x,y,ix,iy,nnei,nexp);
BRM_QStreuung(4,1,nnei,nexp,QBinaer,QLinks,QMitte,QRecht);
}
else
{
BRM_GetOrtho(Dir,x,y,ix,iy,nnei,nexp);
BRM_QStreuung(6,0,nnei,nexp,QBinaer,QLinks,QMitte,QRecht);
}
Add_Fraction(x,y,(Dir+1)%8,BRM_BitMtrx[0][QBinaer] ? QLinks : 0);
Add_Fraction(x,y,(Dir+0)%8,BRM_BitMtrx[1][QBinaer] ? QMitte : 0);
Add_Fraction(x,y,(Dir+7)%8,BRM_BitMtrx[2][QBinaer] ? QRecht : 0);
}
}
}
//---------------------------------------------------------
void CChannelNetwork_Distance::Initialize_D8(int x, int y)
{
int i, iMax, iRoute;
double z, dz, dzMax, dzRoute;
for(i=0, iMax=-1, dzMax=0.0, iRoute=-1, dzRoute=0.0, z=m_pDEM->asDouble(x, y); i<8; i++)
{
int ix = Get_xTo(i, x);
int iy = Get_yTo(i, y);
if( is_InGrid(ix, iy) && (dz = (z - m_pDEM->asDouble(ix, iy)) / Get_Length(i)) > 0.0 )
{
if( dz > dzMax )
{
iMax = i;
dzMax = dz;
}
if( m_pRoute && !m_pRoute->is_NoData(ix, iy) && dz > dzRoute )
{
iRoute = i;
dzRoute = dz;
}
}
}
m_Dir.Set_Value(x, y, iRoute >= 0 ? iRoute : iMax);
}
//---------------------------------------------------------
void CSADO_SolarRadiation::Set_Shade_Bended(int x, int y, char iLock)
{
double dx, dy, dz;
Get_Shade_Params(m_Decline.asDouble(x, y), m_Azimuth.asDouble(x, y), dx, dy, dz);
for(double ix=x+0.5, iy=y+0.5, iz=m_pDEM->asDouble(x, y); ; )
{
x = (int)(ix += dx);
y = (int)(iy += dy);
iz -= dz;
if( !is_InGrid(x, y) || m_pDEM->asDouble(x, y) > iz || Lock_Get(x, y) == iLock )
{
return;
}
m_Shade.Set_Value(x, y, 1);
//---------------------------------------------
Lock_Set(x, y, iLock);
Get_Shade_Params(m_Decline.asDouble(x, y), m_Azimuth.asDouble(x, y), dx, dy, dz);
}
}
//---------------------------------------------------------
void CPit_Eliminator::Create_goRoute(void)
{
int x, y;
goRoute = SG_Create_Grid(pRoute);
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !is_InGrid(x,y) )
{
goRoute->Set_NoData(x, y);
}
else if( pRoute->asChar(x, y) > 0 )
{
goRoute->Set_Value(x, y, pRoute->asChar(x, y) % 8 );
}
else
{
goRoute->Set_Value(x, y, pDTM->Get_Gradient_NeighborDir(x, y));
}
}
}
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
void CFlow_RecursiveUp::Get_Flow(int x, int y)
{
int i, ix, iy, j;
double jFlow;
if( !is_Locked(x,y) )
{
Lock_Set(x,y);
Init_Cell(x,y);
for(i=0, j=4; i<8; i++, j=(j+1)%8)
{
ix = Get_xTo(i,x);
iy = Get_yTo(i,y);
if( is_InGrid(ix,iy) )
{
jFlow = Flow[iy][ix][j];
if( jFlow > 0 )
{
Get_Flow(ix,iy);
Add_Fraction(ix,iy,j,jFlow);
}
}
}
}
}
//---------------------------------------------------------
double CExercise_09::Get_Area(int x, int y)
{
int i, ix, iy;
double area;
//-----------------------------------------------------
area = m_pArea->asDouble(x, y);
if( area <= 0.0 ) // cell has not been processed yet...
{
m_pArea->Set_Value(x, y, 1.0); // Very important: mark this cell as processed to prevent endless loops...
area = Get_Cellsize() * Get_Cellsize(); // initialize the cell's area with its own cell size...
for(i=0; i<8; i++)
{
ix = Get_xFrom(i, x);
iy = Get_yFrom(i, y);
if( is_InGrid(ix, iy) && i == m_pDir->asInt(ix, iy) ) // drains ith neigbour into this cell ???...
{
area += Get_Area(ix, iy); // ...then add its area (recursive call of this function!)...
}
}
m_pArea->Set_Value(x, y, area);
}
//-----------------------------------------------------
return( area );
}
//---------------------------------------------------------
int CSG_Grid::Get_Gradient_NeighborDir(int x, int y, bool bMustBeLower) const
{
int i, ix, iy, Direction;
double z, dz, dzMax;
Direction = -1;
if( is_InGrid(x, y) )
{
z = asDouble(x, y);
dzMax = 0.0;
for(i=0; i<8; i++)
{
ix = m_System.Get_xTo(i, x);
iy = m_System.Get_yTo(i, y);
if( !is_InGrid(ix, iy) )
{
if( 1 ) // flag 'bStopOnNoData'
{
return( -1 );
}
}
else
{
dz = (z - asDouble(ix, iy)) / m_System.Get_Length(i);
if( (bMustBeLower && dz > 0.0) || !bMustBeLower )
{
if( Direction < 0 || (dz > dzMax) )
{
Direction = i;
dzMax = dz;
}
}
}
}
}
return( Direction );
}
//---------------------------------------------------------
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);
}
}
}
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
void CFlow::Add_Fraction(int x, int y, int Direction, double Fraction)
{
int ix, iy;
if( is_InGrid(x, y) )
{
ix = Get_xTo(Direction, x);
iy = Get_yTo(Direction, y);
if( is_InGrid(ix, iy) )
{
if( pCatch )
{
pCatch ->Add_Value(ix, iy, Fraction * pCatch ->asDouble(x, y));
}
if( pCatch_Height )
{
pCatch_Height ->Add_Value(ix, iy, Fraction * pCatch_Height ->asDouble(x, y));
}
if( pCatch_Slope )
{
pCatch_Slope ->Add_Value(ix, iy, Fraction * pCatch_Slope ->asDouble(x, y));
}
if( pFlowPath )
{
pFlowPath ->Add_Value(ix, iy, Fraction * (pFlowPath ->asDouble(x, y) + Get_Length(Direction)));
}
if( pCatch_Aspect && pCatch_AspectY )
{
pCatch_Aspect ->Add_Value(ix, iy, Fraction * pCatch_Aspect ->asDouble(x, y));
pCatch_AspectY ->Add_Value(ix, iy, Fraction * pCatch_AspectY ->asDouble(x, y));
}
}
}
}
//---------------------------------------------------------
void CCellBalance::Set_D8(int x, int y, double Weight)
{
int Dir;
if( (Dir = m_pDEM->Get_Gradient_NeighborDir(x, y)) >= 0 )
{
x += Get_xTo(Dir);
y += Get_yTo(Dir);
if( is_InGrid(x, y) )
{
m_pBalance->Add_Value(x, y, Weight);
}
}
}
//---------------------------------------------------------
void CSADO_SolarRadiation::Set_Shade(int x, int y, double dx, double dy, double dz)
{
for(double ix=x+0.5, iy=y+0.5, iz=m_pDEM->asDouble(x, y); ; )
{
x = (int)(ix += dx);
y = (int)(iy += dy);
iz -= dz;
if( !is_InGrid(x, y) || m_pDEM->asDouble(x, y) > iz )
{
return;
}
m_Shade.Set_Value(x, y, 1);
}
}
//---------------------------------------------------------
void CAir_Flow_Height::Get_Luv_Old(int x, int y, double dx, double dy, double &Sum_A)
{
double Weight_A = Sum_A = 0.0;
double w, d = Get_Cellsize() * sqrt(dx*dx + dy*dy);
for(double ix=x+dx+0.5, iy=y+dy+0.5, id=d; is_InGrid(x = (int)ix, y = (int)iy) && id<=m_maxDistance; ix+=dx, iy+=dy, id+=d)
{
if( !m_pDEM->is_NoData(x, y) )
{
Weight_A += w = pow(id, -m_dLuv);
Sum_A += w * m_pDEM->asDouble(x, y);
}
}
if( Weight_A > 0.0 ) { Sum_A /= Weight_A; }
}
//---------------------------------------------------------
bool CTopographic_Openness::Get_Angle_Sectoral(int x, int y, int i, double &Max, double &Min)
{
double iDistance, dDistance, dx, dy, ix, iy, d, z;
z = m_pDEM->asDouble(x, y);
dx = m_Direction[i].x;
dy = m_Direction[i].y;
ix = x;
iy = y;
iDistance = 0.0;
dDistance = Get_Cellsize() * M_GET_LENGTH(dx, dy);
Max = 0.0;
Min = 0.0;
bool bOkay = false;
while( is_InGrid(x, y) && iDistance <= m_Radius )
{
ix += dx; x = (int)(0.5 + ix);
iy += dy; y = (int)(0.5 + iy);
iDistance += dDistance;
if( m_pDEM->is_InGrid(x, y) )
{
d = (m_pDEM->asDouble(x, y) - z) / iDistance;
if( bOkay == false )
{
bOkay = true;
Max = Min = d;
}
else if( Max < d )
{
Max = d;
}
else if( Min > d )
{
Min = d;
}
}
}
return( bOkay );
}
//---------------------------------------------------------
double CRGA_Basic::Get_Similarity(int x, int y, int Segment)
{
CSG_Table_Record *pSeed;
if( is_InGrid(x, y) && (pSeed = m_pSeeds->Get_Record(Segment)) != NULL )
{
int i;
double a, b, Result;
switch( m_Method )
{
//-------------------------------------------------
case 0: // feature space and position
for(i=0, a=0.0; i<m_nFeatures; i++)
{
a += SG_Get_Square(Get_Feature(x, y, i) - pSeed->asDouble(SEEDFIELD_Z + i));
}
b = SG_Get_Square(x - pSeed->asDouble(SEEDFIELD_X))
+ SG_Get_Square(y - pSeed->asDouble(SEEDFIELD_Y));
Result = a / m_Var_1 + b / m_Var_2;
break;
//-------------------------------------------------
case 1: // feature space
for(i=0, a=0.0; i<m_nFeatures; i++)
{
a += SG_Get_Square(Get_Feature(x, y, i) - pSeed->asDouble(SEEDFIELD_Z + i));
}
Result = a / m_Var_1;
break;
}
return( 1.0 / (1.0 + Result) ); // from 'distance' to 'similarity' !!!
// return( exp(-0.5 * Result) );
}
return( -1.0 );
}
//---------------------------------------------------------
inline bool CSADO_SolarRadiation::Get_Shade_Complete(int x, int y)
{
if( m_Shade.asInt(x, y) == 1 )
{
for(int iy=y-1; iy<=y+1; iy++)
{
for(int ix=x-1; ix<x+1; ix++)
{
if( is_InGrid(ix, iy) && m_Shade.asInt(ix, iy) == 0 )
{
return( false );
}
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
void CGrid_Gaps_Spline_Fill::Set_Gap_Cell(int x, int y)
{
if( is_InGrid(x, y) && (!m_pMask || !m_pMask->is_NoData(x, y)) && m_Gaps.asInt(x, y) != m_nGaps )
{
m_Gaps.Set_Value(x, y, m_nGaps);
if( !is_Gap(x, y) )
{
m_Spline.Add_Point(x, y, m_pGrid->asDouble(x, y));
for(int i=0; m_bExtended && i<8; i+=m_Neighbours)
{
int ix = Get_xTo(i, x), iy = Get_yTo(i, y);
if( m_pGrid->is_InGrid(ix, iy) && m_Gaps.asInt(ix, iy) != m_nGaps )
{
m_Gaps.Set_Value(ix, iy, m_nGaps);
m_Spline.Add_Point(ix, iy, m_pGrid->asDouble(ix, iy));
}
}
}
else
{
if( m_nGapCells >= m_GapCells.Get_Count() )
{
m_GapCells.Set_Count(m_GapCells.Get_Count() + 1024);
}
m_GapCells[m_nGapCells].x = x;
m_GapCells[m_nGapCells].y = y;
m_nGapCells++;
Push(x, y);
}
}
}
//---------------------------------------------------------
void CPit_Eliminator::Fill_Sink(int x, int y, int j, double z)
{
int i, ix, iy;
if( is_InGrid(x, y) && !is_Locked(x, y) && goRoute->asChar(x, y) == j )
{
Lock_Set(x, y);
z += M_ALMOST_ZERO * Get_UnitLength(j);
if( pDTM->asDouble(x, y) < z )
{
pDTM->Set_Value(x, y, z);
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);
}
}
}
}
//---------------------------------------------------------
int CWatersheds::Get_Basin(int x, int y)
{
int i, ix, iy, nCells;
if( m_pBasins->is_NoData(x, y) && !m_Direction.is_NoData(x, y) )
{
m_pBasins->Set_Value(x, y, m_nBasins);
for(i=0, nCells=1; i<8; i++)
{
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
if( is_InGrid(ix,iy) && m_Direction.asInt(ix, iy) == i )
{
nCells += Get_Basin(ix, iy);
}
}
return( nCells );
}
return( -1 );
}
//---------------------------------------------------------
bool CTIN_From_Grid_Specific_Points::Get_FlowDirection(CSG_Grid *pResult, CSG_Grid *pGrid, int Min, int Max)
{
bool bLower;
int x, y, i, ix, iy, xLow, yLow;
double z, iz, zLow;
pResult->Assign();
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
z = pGrid->asDouble(x,y);
bLower = false;
for(i=0; i<8; i++)
{
ix = Get_xTo(i,x);
iy = Get_yTo(i,y);
if( is_InGrid(ix,iy) )
{
iz = pGrid->asDouble(ix,iy);
if(iz<z)
{
if(!bLower)
{
bLower = true;
zLow = iz;
xLow = ix;
yLow = iy;
}
else if(iz<zLow)
{
zLow = iz;
xLow = ix;
yLow = iy;
}
}
}
}
if(bLower)
{
pResult->Add_Value(xLow, yLow, 1);
}
}
}
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
i = pResult->asInt(x, y);
if( i <= Min )
{
pResult->Set_Value(x, y, -1);
}
else if( i >= Max )
{
pResult->Set_Value(x, y, 1);
}
else
{
pResult->Set_Value(x, y, 0);
}
}
}
return( true );
}
//---------------------------------------------------------
bool CLakeFloodInteractive::On_Execute_Position(CSG_Point ptWorld, TSG_Tool_Interactive_Mode Mode)
{
//-----------------------------------------------------
if( Mode == TOOL_INTERACTIVE_LDOWN )
{
int x, y, ix, iy, i;
double level;
x = Get_System()->Get_xWorld_to_Grid(ptWorld.Get_X());
y = Get_System()->Get_yWorld_to_Grid(ptWorld.Get_Y());
if( pElev->is_InGrid(x, y, true) )
{
if( !m_bLevel )
level = m_water + pElev->asDouble(x, y);
else
level = m_water;
if( level <= pOlevel->asDouble(x, y) )
return (true);
newCell = new CTraceOrder();
newCell->x = x;
newCell->y = y;
firstCell = newCell;
pOdepth->Set_Value(x, y, level - pElev->asDouble(x, y));
pOlevel->Set_Value(x, y, level);
iterCell = firstCell;
lastCell = firstCell;
while( iterCell != NULL )
{
x = iterCell->x;
y = iterCell->y;
for( i=0; i<8; i++ )
{
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
if( is_InGrid(ix, iy) && !pElev->is_NoData(ix, iy) && pOlevel->asDouble(ix, iy) < level )
{
pOdepth->Set_Value(ix, iy, level - pElev->asDouble(ix, iy));
pOlevel->Set_Value(ix, iy, level);
newCell = new CTraceOrder();
newCell->x = ix;
newCell->y = iy;
newCell->prev = lastCell;
lastCell->next = newCell;
lastCell = newCell;
}
}
newCell = firstCell;
if( newCell->next == NULL )
{
firstCell = lastCell = NULL;
delete (newCell);
newCell = NULL;
}
else
{
newCell->next->prev = NULL;
firstCell = newCell->next;
newCell->next = NULL;
delete (newCell);
newCell = NULL;
}
iterCell = firstCell;
}
SG_UI_Msg_Add(_TL("ready ..."), true);
DataObject_Update(pOdepth, pOdepth->Get_ZMin(), pOdepth->Get_ZMax());
DataObject_Update(pOlevel, pOlevel->Get_ZMin(), pOlevel->Get_ZMax());
return( true );
}
}
return( false );
}
//---------------------------------------------------------
bool CExercise_14::Initialise(int Threshold)
{
int x, y, i, ix, iy, Dir;
double z, dz, dzMax;
CSG_Colors Colors;
//-----------------------------------------------------
m_pDir = new CSG_Grid(m_pDTM, SG_DATATYPE_Char);
m_pChnl->Assign();
Colors.Set_Count(4);
Colors.Set_Color(0, 192, 192, 192); // NOCHANNEL
Colors.Set_Color(1, 0, 255, 0); // SPRING
Colors.Set_Color(2, 0, 0, 255); // CHANNEL
Colors.Set_Color(3, 255, 0, 0); // MOUTH
DataObject_Set_Colors(m_pChnl, Colors);
//-----------------------------------------------------
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
Dir = -1;
if( is_InGrid(x, y) && !m_pDTM->is_NoData(x, y) )
{
z = m_pDTM->asDouble(x, y);
dzMax = 0.0;
for(i=0; i<8; i++)
{
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
if( is_InGrid(ix, iy) && !m_pDTM->is_NoData(ix, iy) )
{
dz = (z - m_pDTM->asDouble(ix, iy)) / Get_Length(i);
if( dz > dzMax )
{
dzMax = dz;
Dir = i;
}
}
}
}
//---------------------------------------------
m_pDir->Set_Value(x, y, Dir);
if( Dir >= 0 )
{
m_pChnl->Add_Value(Get_xTo(Dir, x), Get_yTo(Dir, y), 1);
}
}
}
//-----------------------------------------------------
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
m_pChnl->Set_Value(x, y, m_pChnl->asInt(x, y) >= Threshold ? SPRING : NOCHANNEL);
}
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Proximity::On_Execute(void)
{
int x, y;
double z, d;
TSG_Point p;
CSG_Grid *pFeatures, *pDistance, *pDirection, *pAllocation;
CSG_PRQuadTree Search;
//-----------------------------------------------------
pFeatures = Parameters("FEATURES") ->asGrid();
pDistance = Parameters("DISTANCE") ->asGrid();
pDirection = Parameters("DIRECTION") ->asGrid();
pAllocation = Parameters("ALLOCATION") ->asGrid();
//-----------------------------------------------------
Process_Set_Text(_TL("preparing distance calculation..."));
Search.Create(CSG_Rect(-1, -1, Get_NX(), Get_NY()));
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( pFeatures->is_NoData(x, y) )
{
pDistance->Set_Value(x, y, -1.0);
}
else
{
pDistance->Set_Value(x, y, 0.0);
if( pDirection )
{
pDirection->Set_NoData(x, y);
}
if( pAllocation )
{
pAllocation->Set_Value(x, y, pFeatures->asDouble(x, y));
}
//-----------------------------------------
bool bBorder = false;
for(int i=0; i<8 && !bBorder; i++)
{
int ix = Get_xTo(i, x);
int iy = Get_yTo(i, y);
if( is_InGrid(ix, iy) && pFeatures->is_NoData(ix, iy) )
{
bBorder = true;
}
}
if( bBorder )
{
Search.Add_Point(x, y, pFeatures->asDouble(x, y));
}
}
}
}
if( !Search.is_Okay() || Search.Get_Point_Count() <= 0 || Search.Get_Point_Count() >= Get_NCells() )
{
Message_Add(_TL("no features to buffer."));
return( false );
}
//-----------------------------------------------------
Process_Set_Text(_TL("performing distance calculation..."));
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( pDistance->asDouble(x, y) < 0.0 && Search.Get_Nearest_Point(x, y, p, z, d) )
{
pDistance->Set_Value(x, y, d * Get_Cellsize());
if( pDirection )
{
if( d > 0.0 )
{
pDirection->Set_Value(x, y, SG_Get_Angle_Of_Direction(x, y, p.x, p.y) * M_RAD_TO_DEG);
}
else
{
pDirection->Set_NoData(x, y);
}
}
if( pAllocation )
{
pAllocation->Set_Value(x, y, z);
}
}
}
}
//-----------------------------------------------------
return( true );
}
