double CProtectionIndex::getProtectionIndex(int x, int y){
int i,j;
int iDifX[] = {0,1,1,1,0,-1,-1,-1};
int iDifY[] = {1,1,0,-1,-1,-1,0,1};
double dDifHeight;
double dDist;
double dAngle;
double dProtectionIndex = 0;
double aAngle[8];
for (i = 0; i < 8; i++){
j = 1;
aAngle[i] = 0;
dDist = M_GET_LENGTH(iDifX[i], iDifY[i]) * j * m_pDEM->Get_Cellsize();
while (dDist < m_dRadius){
if (m_pDEM->is_InGrid(x + iDifX[i] * j, y + iDifY[i] * j)){
dDifHeight = m_pDEM->asDouble(x,y);
}//if
else{
return NO_DATA;
}
dDifHeight = m_pDEM->asDouble(x + iDifX[i] * j, y + iDifY[i] * j)
- m_pDEM->asDouble(x,y);
dAngle = atan (dDifHeight / dDist);
if (dAngle > aAngle[i]){
aAngle[i] = dAngle;
}//if
j++;
dDist = M_GET_LENGTH(iDifX[i], iDifY[i]) * j * m_pDEM->Get_Cellsize();
}//while
dProtectionIndex+=aAngle[i];
}//while
return (dProtectionIndex / 8.);
}//method
//---------------------------------------------------------
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 );
}
bool CFlowDepth::getWetAreaAndPerimeter(int iX,
int iY,
double fH,
double &fArea,
double &fPerim){
int iWidth = 0;
int iX2, iY2;
int iX3, iY3;
int i = 0;
int iStepX, iStepY;
int pStepX[4] = {1,1,0,1};
int pStepY[4] = {0,-1,1,1};
int iDir = (m_pAspect->asInt(iX, iY,true) / 45) % 4;
double fDist;
double fLocalDist;
double fBaseHeight = m_pDEM->asFloat(iX, iY);
double fPerimLeft = 0;
double fAreaLeft = 0;
double fPerimRight = 0;
double fAreaRight = 0;
double fHeightDif;
double fLocalHeightDif;
iStepY = pStepX[iDir];
iStepX = pStepY[iDir];
fDist = M_GET_LENGTH(iStepX, iStepY) * m_pDEM->Get_Cellsize();
do{
iX2 = iX + iStepX * i;
iY2 = iY + iStepY * i;
iX3 = iX + iStepX * (i+1);
iY3 = iY + iStepY * (i+1);
if (m_pDEM->is_InGrid(iX2,iY2) && m_pDEM->is_InGrid(iX3,iY3)){
fHeightDif = m_pDEM->asFloat(iX3,iY3) - m_pDEM->asFloat(iX,iY);
if (fHeightDif >= fH){
fLocalHeightDif = fabs(m_pDEM->asFloat(iX,iY) + fH - m_pDEM->asFloat(iX2,iY2));
fLocalDist = fabs(fDist * fLocalHeightDif
/ (m_pDEM->asFloat(iX3,iY3) - m_pDEM->asFloat(iX2,iY2)));
}//if
else{
fLocalHeightDif = fabs(m_pDEM->asFloat(iX3,iY3) - m_pDEM->asFloat(iX2,iY2));
fLocalDist = fDist;
}//else
fPerimLeft += sqrt(fLocalDist * fLocalDist + fLocalHeightDif * fLocalHeightDif);
fAreaLeft += (i * fLocalHeightDif + fLocalHeightDif * fLocalDist / 2.);
}//if
else{
return false;
}//else
i++;
}while(fHeightDif < fH);
i = 0;
do{
iX2 = iX - iStepX * i;
iY2 = iY - iStepY * i;
iX3 = iX - iStepX * (i+1);
iY3 = iY - iStepY * (i+1);
if (m_pDEM->is_InGrid(iX2,iY2) && m_pDEM->is_InGrid(iX3,iY3)){
fHeightDif = m_pDEM->asFloat(iX3,iY3) - m_pDEM->asFloat(iX,iY);
if (fHeightDif >= fH){
fLocalHeightDif = fabs(m_pDEM->asFloat(iX,iY) + fH - m_pDEM->asFloat(iX2,iY2));
fLocalDist = fabs(fDist * fLocalHeightDif
/ (m_pDEM->asFloat(iX3,iY3) - m_pDEM->asFloat(iX2,iY2)));
}//if
else{
fLocalHeightDif = fabs(m_pDEM->asFloat(iX3,iY3) - m_pDEM->asFloat(iX2,iY2));
fLocalDist = fDist;
}//else
fPerimLeft += sqrt(fLocalDist * fLocalDist + fLocalHeightDif * fLocalHeightDif);
fAreaLeft += (i * fLocalHeightDif + fLocalHeightDif * fLocalDist / 2.);
}//if
else{
return false;
}//else
i++;
}while(fHeightDif < fH);
fArea = fAreaLeft + fAreaRight;
fPerim = fPerimLeft +fPerimRight;
return true;
}//method
//---------------------------------------------------------
bool CConvergence_Radius::Initialize(CSG_Grid *pDTM, int Radius)
{
int x, y, ix, iy;
double Slope, Aspect, d;
if( Radius > 0 )
{
//-------------------------------------------------
m_Radius = Radius;
m_Diameter = 1 + 2 * Radius;
m_Dir.Create(SG_DATATYPE_Double, m_Diameter, m_Diameter);
m_Dst.Create(SG_DATATYPE_Double, m_Diameter, m_Diameter);
for(iy=0, y=-m_Radius; iy<m_Diameter; iy++, y++)
{
for(ix=0, x=-m_Radius; ix<m_Diameter; ix++, x++)
{
d = M_GET_LENGTH(x, y);
if( d < 1 || d > m_Radius )
{
m_Dir.Set_NoData(ix, iy);
m_Dst.Set_Value (ix, iy, 0);
}
else
{
m_Dir.Set_Value (ix, iy, y != 0.0 ? M_PI_180 + atan2((double)x, (double)y) : (x > 0.0 ? M_PI_270 : M_PI_090));
m_Dst.Set_Value (ix, iy, d - 1);
}
}
}
//-------------------------------------------------
m_Slope .Create(pDTM, SG_DATATYPE_Float);
m_Aspect.Create(pDTM, SG_DATATYPE_Float);
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( pDTM->is_InGrid(x, y) && pDTM->Get_Gradient(x, y, Slope, Aspect) && Aspect >= 0.0 )
{
m_Slope .Set_Value(x, y, Slope);
m_Aspect.Set_Value(x, y, Aspect);
}
else
{
m_Slope .Set_NoData(x, y);
m_Aspect.Set_NoData(x, y);
}
}
}
//-------------------------------------------------
m_iSum = (double *)malloc(m_Radius * sizeof(double));
m_iCnt = (int *)malloc(m_Radius * sizeof(int ));
return( true );
}
return( false );
}
bool CProfileFromPoints::On_Execute(void){
CSG_Table* pTable;
CSG_Table* pProfileTable;
CSG_Table_Record* pRecord;
CSG_Grid* pGrid;
int iXField, iYField;
int i;
int x1,x2,y1,y2;
float fPartialDist;
float fDist = 0;
pGrid = Parameters("GRID")->asGrid();
pTable = Parameters("TABLE")->asTable();
pProfileTable = Parameters("RESULT")->asTable();
iXField = Parameters("X")->asInt();
iYField = Parameters("Y")->asInt();
pProfileTable->Create((CSG_Table*)NULL);
pProfileTable->Set_Name(_TL("Profile"));
pProfileTable->Add_Field(_TL("Distance"), SG_DATATYPE_Double);
pProfileTable->Add_Field("Z", SG_DATATYPE_Double);
for (i = 0; i < pTable->Get_Record_Count()-1; i++){
x1=(int)(0.5 + (pTable->Get_Record(i )->asDouble(iXField) - pGrid->Get_XMin()) / pGrid->Get_Cellsize());
x2=(int)(0.5 + (pTable->Get_Record(i+1)->asDouble(iXField) - pGrid->Get_XMin()) / pGrid->Get_Cellsize());
y1=(int)(0.5 + (pTable->Get_Record(i )->asDouble(iYField) - pGrid->Get_YMin()) / pGrid->Get_Cellsize());
y2=(int)(0.5 + (pTable->Get_Record(i+1)->asDouble(iYField) - pGrid->Get_YMin()) / pGrid->Get_Cellsize());
int x = x1, y = y1, D = 0, HX = x2 - x1, HY = y2 - y1,
c, M, xInc = 1, yInc = 1, iLastX = x1, iLastY = y1;
if (HX < 0) {
xInc = -1;
HX = -HX;
}//if
if (HY < 0) {
yInc = -1;
HY = -HY;
}//if
if (HY <= HX) {
c = 2 * HX;
M = 2 * HY;
for (;;) {
fPartialDist = (float)(M_GET_LENGTH(x-iLastX, y-iLastY) * pGrid->Get_Cellsize());
if (pGrid->is_InGrid(x,y) && fPartialDist){
fDist+=fPartialDist;
pRecord = pProfileTable->Add_Record();
pRecord->Set_Value(0, fDist);
pRecord->Set_Value(1, pGrid->asFloat(x,y));
}//if
iLastX = x;
iLastY = y;
if (x == x2) {
break;
}// if
x += xInc;
D += M;
if (D > HX) {
y += yInc;
D -= c;
}// if
}// for
}// if
else {
c = 2 * HY;
M = 2 * HX;
for (;;) {
fPartialDist = (float)(M_GET_LENGTH(x-iLastX, y-iLastY) * pGrid->Get_Cellsize());
if (pGrid->is_InGrid(x,y) && fPartialDist){
fDist+=fPartialDist;
pRecord = pProfileTable->Add_Record();
pRecord->Set_Value(0, fDist);
pRecord->Set_Value(1, pGrid->asFloat(x,y));
}//if
iLastX = x;
iLastY = y;
if (y == y2) {
break;
}// if
y += yInc;
D += M;
if (D > HY) {
x += xInc;
D -= c;
}// if
}// for
}// else
}//for
return true;
}// method
//---------------------------------------------------------
bool CTopographic_Openness::On_Execute(void)
{
CSG_Grid *pPos, *pNeg;
m_pDEM = Parameters("DEM" )->asGrid();
pPos = Parameters("POS" )->asGrid();
pNeg = Parameters("NEG" )->asGrid();
m_Radius = Parameters("RADIUS")->asDouble();
m_Method = Parameters("METHOD")->asInt();
DataObject_Set_Colors(pPos, 100, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(pNeg, 100, SG_COLORS_RED_GREY_BLUE, false);
//-----------------------------------------------------
if( m_Method == 0 ) // multi scale
{
if( !m_Pyramid.Create(m_pDEM, Parameters("DLEVEL")->asDouble(), GRID_PYRAMID_Mean) )
{
return( false );
}
m_nLevels = m_Pyramid.Get_Count();
if( m_Radius > 0.0 )
{
while( m_nLevels > 0 && m_Pyramid.Get_Grid(m_nLevels - 1)->Get_Cellsize() > m_Radius )
{
m_nLevels--;
}
}
}
//-----------------------------------------------------
bool bResult = Initialise(Parameters("NDIRS")->asInt());
if( bResult )
{
if( m_Method != 0 && m_Radius <= 0.0 )
{
m_Radius = Get_Cellsize() * M_GET_LENGTH(Get_NX(), Get_NY());
}
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double Pos, Neg;
if( Get_Openness(x, y, Pos, Neg) )
{
if( pPos ) pPos->Set_Value(x, y, Pos);
if( pNeg ) pNeg->Set_Value(x, y, Neg);
}
else
{
if( pPos ) pPos->Set_NoData(x, y);
if( pNeg ) pNeg->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
m_Pyramid .Destroy();
m_Direction .Clear();
return( bResult );
}
//---------------------------------------------------------
bool CSG_Grid_Radius::Create(int maxRadius)
{
Destroy();
//-----------------------------------------------------
if( maxRadius > 0 && maxRadius != m_maxRadius )
{
int x, y, i, n;
double d;
m_maxRadius = maxRadius;
m_nPoints_R = (int *)SG_Calloc(m_maxRadius + 1, sizeof(int));
for(y=-m_maxRadius; y<=m_maxRadius; y++)
{
for(x=-m_maxRadius; x<=m_maxRadius; x++)
{
if( (d = M_GET_LENGTH(x, y)) <= m_maxRadius )
{
m_nPoints++;
m_nPoints_R[(int)d]++;
}
}
}
//-------------------------------------------------
if( m_nPoints > 0 )
{
m_Points = (TSG_Grid_Radius *)SG_Calloc(m_nPoints , sizeof(TSG_Grid_Radius ));
m_Points_R = (TSG_Grid_Radius **)SG_Calloc(m_maxRadius + 1, sizeof(TSG_Grid_Radius *));
for(i=0, n=0; i<=m_maxRadius; i++)
{
m_Points_R [i] = m_Points + n;
n += m_nPoints_R[i];
m_nPoints_R[i] = 0;
}
//---------------------------------------------
for(y=-m_maxRadius; y<=m_maxRadius; y++)
{
for(x=-m_maxRadius; x<=m_maxRadius; x++)
{
if( (d = M_GET_LENGTH(x, y)) <= m_maxRadius )
{
i = (int)d;
n = m_nPoints_R[i]++;
m_Points_R[i][n].x = x;
m_Points_R[i][n].y = y;
m_Points_R[i][n].d = d;
}
}
}
return( true );
}
}
//-----------------------------------------------------
Destroy();
return( false );
}
