//---------------------------------------------------------
bool CGW_Multi_Regression_Grid::Get_Regression(int x, int y, double &Quality, CSG_Vector &b)
{
//-----------------------------------------------------
int i, nPoints;
double zMean, zr, rss, tss;
CSG_Vector z, w;
CSG_Matrix Y, YtW;
if( (nPoints = Get_Variables(x, y, z, w, Y)) <= m_nPredictors )
{
return( false );
}
//-----------------------------------------------------
YtW.Create(nPoints, 1 + m_nPredictors);
for(i=0, zMean=0.0; i<nPoints; i++)
{
zMean += z[i];
YtW[0][i] = w[i];
for(int j=1; j<=m_nPredictors; j++)
{
YtW[j][i] = Y[i][j] * w[i];
}
}
//-----------------------------------------------------
b = (YtW * Y).Get_Inverse() * (YtW * z);
zMean /= nPoints;
for(i=0, rss=0.0, tss=0.0; i<nPoints; i++)
{
zr = b[0];
for(int j=1; j<=m_nPredictors; j++)
{
zr += b[j] * Y[i][j];
}
rss += w[i] * SG_Get_Square(z[i] - zr);
tss += w[i] * SG_Get_Square(z[i] - zMean);
}
Quality = tss > 0.0 ? (tss - rss) / tss : 0.0;
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGW_Regression_Grid::Get_Regression(int x, int y)
{
int nPoints = Set_Variables(x, y);
if( nPoints < m_nPoints_Min )
{
return( false );
}
//-----------------------------------------------------
int i;
double zMean, rss, tss;
CSG_Vector b, z;
CSG_Matrix Y, YtW;
//-----------------------------------------------------
z .Create(nPoints);
Y .Create(2, nPoints);
YtW.Create(nPoints, 2);
for(i=0, zMean=0.0; i<nPoints; i++)
{
Y [i][0] = 1.0;
Y [i][1] = m_y[i];
YtW[0][i] = m_w[i];
YtW[1][i] = m_w[i] * m_y[i];
zMean += (z[i] = m_z[i]);
}
//-----------------------------------------------------
b = (YtW * Y).Get_Inverse() * (YtW * z);
zMean /= nPoints;
for(i=0, rss=0.0, tss=0.0; i<nPoints; i++)
{
rss += m_w[i] * SG_Get_Square(m_z[i] - (b[0] + b[1] * m_y[i]));
tss += m_w[i] * SG_Get_Square(m_z[i] - zMean);
}
GRID_SET_VALUE(m_pRegression, x, y, b[0] + b[1] * m_pPredictor->asDouble(x, y));
GRID_SET_VALUE(m_pIntercept , x, y, b[0]);
GRID_SET_VALUE(m_pSlope , x, y, b[1]);
GRID_SET_VALUE(m_pQuality , x, y, (tss - rss) / tss);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CVariogram_Dialog::Execute(CSG_Shapes *pPoints, int Attribute, bool bLog, CSG_Table *pVariogram, CSG_Trend *pModel)
{
if( m_pPoints != pPoints || m_nPoints != pPoints->Get_Count() || !m_Extent.is_Equal(pPoints->Get_Extent()) )
{
m_pPoints = pPoints;
m_nPoints = pPoints->Get_Count();
m_Extent = pPoints->Get_Extent();
m_Distance = -1;
int nSkip = 1 + m_pPoints->Get_Count() / 10000;
m_Settings("SKIP" )->Set_Value(nSkip);
m_Settings("LAGDIST")->Set_Value(CSG_Variogram::Get_Lag_Distance(m_pPoints, 0, nSkip));
m_Settings("MAXDIST")->Set_Value(0.5 * sqrt(SG_Get_Square(m_pPoints->Get_Extent().Get_XRange()) + SG_Get_Square(m_pPoints->Get_Extent().Get_YRange())));
}
m_Attribute = Attribute;
m_bLog = bLog;
m_pVariogram = pVariogram;
m_pModel = pModel;
m_pDiagram->Initialize(m_pModel, m_pVariogram);
//-----------------------------------------------------
Set_Variogram();
return( ShowModal() == wxID_OK && m_pModel && m_pModel->is_Okay() );
}
//---------------------------------------------------------
inline double CKernel_Density::Get_Kernel(double dx, double dy)
{
double d = SG_Get_Length(dx, dy);
if( d >= m_dRadius )
{
return( 0.0 );
}
d /= m_dRadius;
switch( m_Kernel )
{
default:
case 0: // quartic kernel
return( (3.0 / (M_PI * m_dRadius*m_dRadius)) * SG_Get_Square(1.0 - d*d) );
case 1: // gaussian kernel
d *= 2.0;
return( exp(-0.5 * d*d) );
case 2: // exponential
d *= 2.0;
return( exp(-d) );
case 3: // inverse distance
return( pow(1.0 + d, -1.0) );
}
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
bool CMRVBF::Get_Smoothed(CSG_Grid *pDEM, CSG_Grid *pSmoothed, int Radius, double Smoothing)
{
if( pDEM && pSmoothed )
{
int x, y, ix, iy, jx, jy, kx, ky;
double d, s;
CSG_Grid Kernel(SG_DATATYPE_Double, 1 + 2 * Radius, 1 + 2 * Radius);
for(iy=-Radius, ky=0; iy<=Radius; iy++, ky++)
{
for(ix=-Radius, kx=0; ix<=Radius; ix++, kx++)
{
Kernel.Set_Value(kx, ky, 4.3565 * exp(-SG_Get_Square(sqrt((double)ix*ix + iy*iy) / 3.0)) );
// Kernel.Set_Value(kx, ky, exp(-(ix*ix + iy*iy) / (2.0 * s)) / (2.0 * M_PI * s));
}
}
pSmoothed->Create(pDEM, SG_DATATYPE_Float);
for(y=0; y<pDEM->Get_NY() && Set_Progress(y, pDEM->Get_NY()); y++)
{
for(x=0; x<pDEM->Get_NX(); x++)
{
for(iy=-Radius, jy=y-Radius, ky=0, s=d=0.0; iy<=Radius; iy++, jy++, ky++)
{
for(ix=-Radius, jx=x-Radius, kx=0; ix<=Radius; ix++, jx++, kx++)
{
if( pDEM->is_InGrid(jx, jy) )
{
s += Kernel.asDouble(kx, ky) * pDEM->asDouble(jx, jy);
d += Kernel.asDouble(kx, ky);
}
}
}
if( d > 0.0 )
{
pSmoothed->Set_Value(x, y, s / d);
}
else
{
pSmoothed->Set_NoData(x, y);
}
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
double C_Kriging_Base::Get_Weight(double d)
{
if( d > 0.0 )
{
switch( m_Model )
{
case 0:
return( // Spherical Model
d >= m_Range
? m_Nugget + m_Sill
: m_Nugget + m_Sill * (3.0 * d / (2.0 * m_Range) - d*d*d / (2.0 * m_Range*m_Range*m_Range))
);
case 1:
return( // Exponential Model
m_Nugget + m_Sill * (1.0 - exp(-3.0 * d / m_Range))
);
case 2:
return( // Gaussian Model
m_Nugget + m_Sill * SG_Get_Square(1.0 - exp(-3.0 * d / (m_Range*m_Range)))
);
case 3: default:
return( // Linear Regression
m_Nugget + d * m_BLIN
);
case 4:
return( // Exponential Regression
m_Nugget * exp(d * m_BEXP)
);
case 5:
return( // Power Function Regression
m_Nugget + m_APOW * pow(d, m_BPOW)
);
}
}
return( m_Nugget > 0.0 ? m_Nugget : 0.00001 );
}
//---------------------------------------------------------
double SG_Get_Distance_Polar(double aLon, double aLat, double bLon, double bLat, double a, double e, bool bDegree)
{
if( bDegree )
{
aLon *= M_DEG_TO_RAD;
aLat *= M_DEG_TO_RAD;
bLon *= M_DEG_TO_RAD;
bLat *= M_DEG_TO_RAD;
}
if( e <= 0.0 )
{
return( a * acos(sin(aLat) * sin(bLat) + cos(aLat) * cos(bLat) * cos(bLon - aLon)) );
}
else
{
double F = (aLat + bLat) / 2.0;
double G = (aLat - bLat) / 2.0;
double l = (aLon - bLon) / 2.0;
double sin2_F = SG_Get_Square(sin(F));
double cos2_F = SG_Get_Square(cos(F));
double sin2_G = SG_Get_Square(sin(G));
double cos2_G = SG_Get_Square(cos(G));
double sin2_l = SG_Get_Square(sin(l));
double cos2_l = SG_Get_Square(cos(l));
double S = sin2_G * cos2_l + cos2_F * sin2_l;
double C = cos2_G * cos2_l + sin2_F * sin2_l;
double w = atan(sqrt(S / C));
double D = 2.0 * w * a;
double R = sqrt(S * C) / w;
double H1 = (3.0 * R - 1.0) / (2.0 * C);
double H2 = (3.0 * R + 1.0) / (2.0 * S);
double f = 1.0 / e;
double d = D * (1.0 + f * H1 * sin2_F * cos2_G - f * H2 * cos2_F * sin2_G);
return( d );
}
}
//---------------------------------------------------------
bool CGW_Multi_Regression::Get_Regression(int x, int y)
{
int nPoints = Set_Variables(x, y);
if( nPoints < m_nPoints_Min )
{
return( false );
}
//-----------------------------------------------------
int i;
double zMean, rss, tss;
CSG_Vector b, z;
CSG_Matrix Y, YtW;
//-----------------------------------------------------
z .Create(nPoints);
Y .Create(1 + m_nPredictors, nPoints);
YtW.Create(nPoints, 1 + m_nPredictors);
for(i=0, zMean=0.0; i<nPoints; i++)
{
Y [i][0] = 1.0;
YtW[0][i] = m_w[i];
for(int j=0; j<m_nPredictors; j++)
{
Y [i][j + 1] = m_y[i][j];
YtW[j + 1][i] = m_y[i][j] * m_w[i];
}
zMean += (z[i] = m_z[i]);
}
//-----------------------------------------------------
b = (YtW * Y).Get_Inverse() * (YtW * z);
zMean /= nPoints;
for(i=0, rss=0.0, tss=0.0; i<nPoints; i++)
{
double zr = b[0];
for(int j=0; j<m_nPredictors; j++)
{
zr += b[j + 1] * m_y[i][j];
}
rss += m_w[i] * SG_Get_Square(m_z[i] - zr);
tss += m_w[i] * SG_Get_Square(m_z[i] - zMean);
}
m_pQuality ->Set_Value(x, y, tss > 0.0 ? (tss - rss) / tss : 0.0);
m_pIntercept->Set_Value(x, y, b[0]);
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i]->Set_Value(x, y, b[i + 1]);
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CMultiBand_Variation::Get_Variation(int x, int y)
{
if( !m_Mask.is_NoData(x, y) )
{
int iBand, iCell, ix, iy;
double iDistance, iWeight, Weights, Distance;
CSG_Vector Centroid(m_pBands->Get_Count());
//-------------------------------------------------
for(iCell=0, Weights=0.0; iCell<m_Cells.Get_Count(); iCell++)
{
if( m_Cells.Get_Values(iCell, ix = x, iy = y, iDistance, iWeight, true) && m_Mask.is_InGrid(ix, iy) )
{
for(iBand=0; iBand<m_pBands->Get_Count(); iBand++)
{
Centroid[iBand] += iWeight * m_pBands->asGrid(iBand)->asDouble(ix, iy);
}
Weights += iWeight;
}
}
//-------------------------------------------------
if( Weights > 0.0 )
{
CSG_Simple_Statistics s;
Centroid *= 1.0 / Weights;
for(iCell=0; iCell<m_Cells.Get_Count(); iCell++)
{
if( m_Cells.Get_Values(iCell, ix = x, iy = y, iDistance, iWeight, true) && m_Mask.is_InGrid(ix, iy) )
{
for(iBand=0, Distance=0.0; iBand<m_pBands->Get_Count(); iBand++)
{
Distance += SG_Get_Square(Centroid[iBand] - m_pBands->asGrid(iBand)->asDouble(ix, iy));
}
s.Add_Value(sqrt(Distance), iWeight);
if( ix == x && iy == y )
{
if( m_pDiff ) m_pDiff->Set_Value(x, y, sqrt(Distance));
}
}
}
if( m_pMean ) m_pMean ->Set_Value(x, y, s.Get_Mean());
if( m_pStdDev ) m_pStdDev->Set_Value(x, y, s.Get_StdDev());
return( true );
}
}
//-----------------------------------------------------
if( m_pMean ) m_pMean ->Set_NoData(x, y);
if( m_pStdDev ) m_pStdDev ->Set_NoData(x, y);
if( m_pDiff ) m_pDiff ->Set_NoData(x, y);
return( false );
}
//---------------------------------------------------------
bool CGSPoints_Semi_Variances::On_Execute(void)
{
int i, j, k, n, nDistances, nSkip, Attribute;
double zi, zj, zMean, v, c, maxDistance, lagDistance;
TSG_Point Pt_i, Pt_j;
CSG_Vector Count, Variance, Covariance;
CSG_Table_Record *pRecord;
CSG_Table *pTable;
CSG_Shape *pPoint;
CSG_Shapes *pPoints;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asShapes();
pTable = Parameters("RESULT") ->asTable();
Attribute = Parameters("FIELD") ->asInt();
nSkip = Parameters("NSKIP") ->asInt();
maxDistance = Parameters("DISTMAX") ->asDouble();
nDistances = Parameters("DISTCOUNT") ->asInt();
if( maxDistance <= 0.0 )
{
maxDistance = SG_Get_Length(pPoints->Get_Extent().Get_XRange(), pPoints->Get_Extent().Get_YRange());
}
lagDistance = maxDistance / nDistances;
zMean = pPoints->Get_Mean(Attribute);
Count .Create(nDistances);
Variance .Create(nDistances);
Covariance .Create(nDistances);
//-----------------------------------------------------
for(i=0, n=0; i<pPoints->Get_Count() && Set_Progress(n, SG_Get_Square(pPoints->Get_Count()/nSkip)/2); i+=nSkip)
{
pPoint = pPoints->Get_Shape(i);
if( !pPoint->is_NoData(Attribute) )
{
Pt_i = pPoint->Get_Point(0);
zi = pPoint->asDouble(Attribute);
for(j=i+nSkip; j<pPoints->Get_Count(); j+=nSkip, n++)
{
pPoint = pPoints->Get_Shape(j);
if( !pPoint->is_NoData(Attribute) )
{
Pt_j = pPoint->Get_Point(0);
k = (int)(SG_Get_Distance(Pt_i, Pt_j) / lagDistance);
if( k < nDistances )
{
zj = pPoint->asDouble(Attribute);
v = SG_Get_Square(zi - zj);
c = (zi - zMean) * (zj - zMean);
Count [k] ++;
Variance [k] += v;
Covariance[k] += c;
}
}
}
}
}
//-----------------------------------------------------
pTable->Destroy();
pTable->Set_Name(CSG_String::Format(SG_T("%s [%s: %s]"), pPoints->Get_Name(), _TL("Variogram"), pPoints->Get_Field_Name(Attribute)));
pTable->Add_Field(_TL("Class") , SG_DATATYPE_Int); // FIELD_CLASSNR
pTable->Add_Field(_TL("Distance") , SG_DATATYPE_Double); // FIELD_DISTANCE
pTable->Add_Field(_TL("Count") , SG_DATATYPE_Int); // FIELD_COUNT
pTable->Add_Field(_TL("Variance") , SG_DATATYPE_Double); // FIELD_VARIANCE
pTable->Add_Field(_TL("Cum.Var.") , SG_DATATYPE_Double); // FIELD_VARCUMUL
pTable->Add_Field(_TL("Covariance") , SG_DATATYPE_Double); // FIELD_COVARIANCE
pTable->Add_Field(_TL("Cum.Covar.") , SG_DATATYPE_Double); // FIELD_COVARCUMUL
for(i=0, v=0.0, c=0.0, n=0; i<nDistances; i++)
{
if( Count[i] > 0 )
{
n += (int)Count[i];
v += Variance [i];
c += Covariance[i];
pRecord = pTable->Add_Record();
pRecord->Set_Value(FIELD_CLASSNR , (i + 1));
pRecord->Set_Value(FIELD_DISTANCE , (i + 1) * lagDistance);
pRecord->Set_Value(FIELD_COUNT , Count[i]);
pRecord->Set_Value(FIELD_VARIANCE , 0.5 * Variance [i] / Count[i]);
pRecord->Set_Value(FIELD_VARCUMUL , 0.5 * v / n);
pRecord->Set_Value(FIELD_COVARIANCE , 1.0 * Covariance[i] / Count[i]);
pRecord->Set_Value(FIELD_COVARCUMUL , 1.0 * c / n);
}
}
return( true );
}
//---------------------------------------------------------
bool CFilter_LoG::Initialise(void)
{
bool bCircle = Parameters("KERNEL_TYPE")->asInt() == 1;
double Sigma = Parameters("SIGMA")->asDouble();
switch( Parameters("METHOD")->asInt() )
{
case 0:
m_Radius = 1;
m_Kernel.Create(SG_DATATYPE_Double, 3, 3);
m_Kernel.Set_Value(0, 0, 0); m_Kernel.Set_Value(0, 1, -1); m_Kernel.Set_Value(0, 2, 0);
m_Kernel.Set_Value(1, 0, -1); m_Kernel.Set_Value(1, 1, 4); m_Kernel.Set_Value(1, 2, -1);
m_Kernel.Set_Value(2, 0, 0); m_Kernel.Set_Value(2, 1, -1); m_Kernel.Set_Value(2, 2, 0);
break;
case 1:
m_Radius = 1;
m_Kernel.Create(SG_DATATYPE_Double, 3, 3);
m_Kernel.Set_Value(0, 0, -1); m_Kernel.Set_Value(0, 1, -1); m_Kernel.Set_Value(0, 2, -1);
m_Kernel.Set_Value(1, 0, -1); m_Kernel.Set_Value(1, 1, 8); m_Kernel.Set_Value(1, 2, -1);
m_Kernel.Set_Value(2, 0, -1); m_Kernel.Set_Value(2, 1, -1); m_Kernel.Set_Value(2, 2, -1);
break;
case 2:
m_Radius = 1;
m_Kernel.Create(SG_DATATYPE_Double, 3, 3);
m_Kernel.Set_Value(0, 0, -1); m_Kernel.Set_Value(0, 1, -2); m_Kernel.Set_Value(0, 2, -1);
m_Kernel.Set_Value(1, 0, -2); m_Kernel.Set_Value(1, 1, 12); m_Kernel.Set_Value(1, 2, -2);
m_Kernel.Set_Value(2, 0, -1); m_Kernel.Set_Value(2, 1, -2); m_Kernel.Set_Value(2, 2, -1);
break;
case 3: default:
m_Radius = Parameters("KERNEL_RADIUS")->asInt();
if( Sigma <= 0.0 )
{
return( false );
}
m_Kernel.Create(SG_DATATYPE_Double, 1 + 2 * m_Radius, 1 + 2 * m_Radius);
Sigma = SG_Get_Square(m_Radius * Sigma * 0.01);
for(int y=-m_Radius, iy=0; y<=m_Radius; y++, iy++)
{
for(int x=-m_Radius, ix=0; x<=m_Radius; x++, ix++)
{
double d = x*x + y*y;
if( bCircle && d > m_Radius*m_Radius )
{
m_Kernel.Set_NoData(ix, iy);
}
else
{
m_Kernel.Set_Value(ix, iy, 1.0 / (M_PI * Sigma*Sigma) * (1.0 - d / (2.0 * Sigma)) * exp(-d / (2.0 * Sigma)));
}
}
}
m_Kernel += -m_Kernel.Get_Mean();
break;
}
return( true );
}
//---------------------------------------------------------
bool CRGA_Basic::On_Execute(void)
{
bool bRefresh;
int x, y, i, Segment;
CSG_Grid *pSeeds;
//-----------------------------------------------------
m_pSegments = Parameters("SEGMENTS" )->asGrid();
m_pFeatures = Parameters("FEATURES" )->asGridList();
m_nFeatures = m_pFeatures->Get_Count();
pSeeds = Parameters("SEEDS" )->asGrid();
m_pSeeds = Parameters("TABLE" )->asTable();
m_pSimilarity = Parameters("SIMILARITY")->asGrid();
m_dNeighbour = Parameters("NEIGHBOUR" )->asInt() == 0 ? 2 : 1;
m_Var_1 = SG_Get_Square(Parameters("SIG_1")->asDouble());
m_Var_2 = SG_Get_Square(Parameters("SIG_2")->asDouble());
m_Threshold = Parameters("THRESHOLD" )->asDouble();
m_bNormalize = Parameters("NORMALIZE" )->asBool();
m_Method = Parameters("METHOD" )->asInt();
bRefresh = Parameters("REFRESH" )->asBool();
//-----------------------------------------------------
m_pSegments ->Assign(-1);
m_pSegments ->Set_NoData_Value(-1);
m_pSimilarity ->Assign(-1);
m_pSimilarity ->Set_NoData_Value(-1);
//-----------------------------------------------------
m_pSeeds->Destroy();
m_pSeeds->Add_Field(_TL("ID" ), SG_DATATYPE_Int);
m_pSeeds->Add_Field(_TL("AREA"), SG_DATATYPE_Double);
m_pSeeds->Add_Field(_TL("X" ), SG_DATATYPE_Double);
m_pSeeds->Add_Field(_TL("Y" ), SG_DATATYPE_Double);
for(i=0; i<m_pFeatures->Get_Count(); i++)
{
m_pSeeds->Add_Field(m_pFeatures->asGrid(i)->Get_Name(), SG_DATATYPE_Double);
}
m_Candidates.Create(Parameters("LEAFSIZE")->asInt());
//-----------------------------------------------------
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !pSeeds->is_NoData(x, y) )
{
CSG_Table_Record *pRec = m_pSeeds->Add_Record();
pRec->Set_Value(0, m_pSeeds->Get_Count() - 1);
pRec->Set_Value(SEEDFIELD_X, x);
pRec->Set_Value(SEEDFIELD_Y, y);
for(i=0; i<m_pFeatures->Get_Count(); i++)
{
pRec->Set_Value(SEEDFIELD_Z + i, Get_Feature(x, y, i));
}
m_pSimilarity->Set_Value(x, y, 1.0);
Add_To_Segment(x, y, m_pSeeds->Get_Count() - 1);
}
}
}
//-----------------------------------------------------
if( m_pSeeds->Get_Count() > 1 )
{
sLong n = 0;
while( n++ < Get_NCells() && Set_Progress_NCells(n) && Get_Next_Candidate(x, y, Segment) )
{
Add_To_Segment(x, y, Segment);
if( bRefresh && (n % Get_NX()) == 0 )
{
DataObject_Update(m_pSegments, 0, m_pSeeds->Get_Count());
Process_Set_Text(CSG_String::Format(SG_T("%.2f"), 100.0 * m_Candidates.Get_Count() / Get_NCells()));
}
}
m_Candidates.Destroy();
return( true );
}
//-----------------------------------------------------
m_Candidates.Destroy();
return( false );
}
//---------------------------------------------------------
int CSG_Shapes_Search::Select_Radius(double x, double y, double Radius, bool bSort, int MaxPoints, int iQuadrant)
{
int xLeft, xRight;
double yBottom, yTop, Radius_2;
m_nSelected = 0;
Radius_2 = Radius*Radius;
switch( iQuadrant )
{
default: // all
xLeft = _Get_Index_Next(x - Radius);
xRight = _Get_Index_Next(x + Radius);
yBottom = -Radius;
yTop = Radius;
break;
case 0: // upper right
xLeft = _Get_Index_Next(x);
xRight = _Get_Index_Next(x + Radius);
yBottom = 0.0;
yTop = Radius;
break;
case 1: // lower right
xLeft = _Get_Index_Next(x);
xRight = _Get_Index_Next(x + Radius);
yBottom = -Radius;
yTop = 0.0;
break;
case 2: // upper left
xLeft = _Get_Index_Next(x - Radius);
xRight = _Get_Index_Next(x);
yBottom = 0.0;
yTop = Radius;
break;
case 3: // lower left
xLeft = _Get_Index_Next(x - Radius);
xRight = _Get_Index_Next(x);
yBottom = -Radius;
yTop = 0.0;
break;
}
for(int ix=xLeft; ix<=xRight; ix++)
{
double d = m_Pos[ix].y - y;
if( yBottom <= d && d < yTop && (d = d*d + SG_Get_Square(m_Pos[ix].x - x)) <= Radius_2 )
{
_Select_Add(m_pPoints->Get_Shape(m_Idx[ix]), d);
}
}
if( bSort || (MaxPoints > 0 && MaxPoints < m_nSelected) )
{
m_Selected_Idx.Create(m_nSelected, m_Selected_Dst, true);
}
return( MaxPoints <= 0 || MaxPoints > m_nSelected ? m_nSelected : MaxPoints );
}
//---------------------------------------------------------
bool CWatersheds_ext::Get_Basin(CSG_Grid *pBasins, CSG_Shapes *pPolygons, int xMouth, int yMouth, int Main_ID)
{
int x, y, Basin_ID = 1 + pPolygons->Get_Count();
CSG_Shape *pPolygon;
CSG_Grid_Stack Stack;
CSG_Simple_Statistics s_Height, s_Distance;
//-----------------------------------------------------
Stack.Push(x = xMouth, y = yMouth);
pBasins ->Set_Value(x, y, Basin_ID);
m_Distance .Set_Value(x, y, 0.0);
s_Height += m_pDEM->asDouble(x, y);
s_Distance += 0.0;
//-----------------------------------------------------
while( Stack.Get_Size() > 0 && Process_Get_Okay() )
{
Stack.Pop(x, y);
double d = m_Distance.asDouble(x, y);
//-------------------------------------------------
for(int i=0; i<8; i++)
{
int ix = Get_xFrom(i, x);
int iy = Get_yFrom(i, y);
if( is_InGrid(ix, iy) && pBasins->is_NoData(ix, iy) && i == m_Direction.asInt(ix, iy) )
{
Stack.Push(ix, iy);
pBasins ->Set_Value(ix, iy, Basin_ID);
m_Distance .Set_Value(ix, iy, d + Get_Length(i));
s_Height += m_pDEM->asDouble(ix, iy);
s_Distance += d + Get_Length(i);
}
}
}
//-----------------------------------------------------
if( s_Height.Get_Count() > 1 && (pPolygon = Get_Basin(pBasins, pPolygons)) != NULL )
{
double d, Area, Perimeter, Side_A, Side_B;
CSG_String Gravelius;
// Area = s_Height.Get_Count() * Get_System()->Get_Cellarea();
Area = ((CSG_Shape_Polygon*)pPolygon)->Get_Area();
Perimeter = ((CSG_Shape_Polygon*)pPolygon)->Get_Perimeter();
d = 0.28 * Perimeter / sqrt(Area);
Gravelius = d > 1.75 ? _TL("rectangular")
: d > 1.5 ? _TL("ovalooblonga-rectangularoblonga")
: d > 1.25 ? _TL("ovaloredonda-ovalooblonga")
: _TL("redonda-ovaloredonda");
d = pow(Perimeter, 2.0) - 8.0 * Area;
Side_A = d > 0.0 ? (Perimeter + sqrt(d)) / 4.0 : -1.0;
Side_B = d > 0.0 ? (Perimeter - 2.0 * Side_A) / 2.0 : -1.0;
pPolygon->Set_Value(FIELD_ID , Basin_ID);
pPolygon->Set_Value(FIELD_ID_MAIN , Main_ID);
pPolygon->Set_Value(FIELD_MOUTH_X , Get_System()->Get_xGrid_to_World(xMouth));
pPolygon->Set_Value(FIELD_MOUTH_Y , Get_System()->Get_yGrid_to_World(yMouth));
pPolygon->Set_Value(FIELD_PERIMETER , Perimeter);
pPolygon->Set_Value(FIELD_AREA , Area);
pPolygon->Set_Value(FIELD_CENTROID_X , ((CSG_Shape_Polygon*)pPolygon)->Get_Centroid().x);
pPolygon->Set_Value(FIELD_CENTROID_Y , ((CSG_Shape_Polygon*)pPolygon)->Get_Centroid().y);
pPolygon->Set_Value(FIELD_Z_MEAN , s_Height .Get_Mean());
pPolygon->Set_Value(FIELD_Z_RANGE , s_Height .Get_Range());
pPolygon->Set_Value(FIELD_DIST_MEAN , s_Distance.Get_Mean());
pPolygon->Set_Value(FIELD_DIST_MAX , s_Distance.Get_Maximum());
pPolygon->Set_Value(FIELD_CONCTIME , s_Height.Get_Range() <= 0.0 ? -1.0 :
pow(0.87 * pow(s_Distance.Get_Maximum() / 1000.0, 3.0) / s_Height.Get_Range(), 0.385)
);
pPolygon->Set_Value(FIELD_BASIN_TYPE , Gravelius);
pPolygon->Set_Value(FIELD_EQVRECT_A , Side_A);
pPolygon->Set_Value(FIELD_EQVRECT_B , Side_B);
pPolygon->Set_Value(FIELD_OROG_IDX , SG_Get_Square(s_Height.Get_Mean()) / (0.0001 * Area)); // Orographic index, defined as the mean catchment altitude times the ratio of the mean catchment altitude to the orthogonal projection of drainage area (Alcázar, Palau (2010): Establishing environmental flow regimes in a Mediterranean watershed based on a regional classification. Journal of Hydrology, V. 388
pPolygon->Set_Value(FIELD_MASS_IDX , Perimeter / (0.0001 * Area)); // Perimeter / (0.0001 * Area) ??!!
pPolygon->Set_Value(FIELD_BASINS_UP , 0.0); // Upslope Basins
pPolygon->Set_Value(FIELD_BASINS_DOWN , 0.0); // Downslope Basins
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGWR_Grid_Downscaling::Get_Regression(int x, int y)
{
//-----------------------------------------------------
int i, nPoints;
double zMean, zr, rss, tss;
CSG_Vector b, z, w;
CSG_Matrix Y, YtW;
if( (nPoints = Get_Variables(x, y, z, w, Y)) <= m_nPredictors )
{
return( false );
}
//-----------------------------------------------------
YtW.Create(nPoints, 1 + m_nPredictors);
for(i=0, zMean=0.0; i<nPoints; i++)
{
zMean += z[i];
YtW[0][i] = w[i];
for(int j=1; j<=m_nPredictors; j++)
{
YtW[j][i] = Y[i][j] * w[i];
}
}
//-----------------------------------------------------
b = (YtW * Y).Get_Inverse() * (YtW * z);
zMean /= nPoints;
for(i=0, rss=0.0, tss=0.0; i<nPoints; i++)
{
zr = b[0];
for(int j=1; j<=m_nPredictors; j++)
{
zr += b[j] * Y[i][j];
}
rss += w[i] * SG_Get_Square(z[i] - zr);
tss += w[i] * SG_Get_Square(z[i] - zMean);
}
m_pQuality->Set_Value(x, y, tss > 0.0 ? (tss - rss) / tss : 0.0);
for(i=0; i<m_nPredictors; i++)
{
m_pModel[i]->Set_Value(x, y, b[i + 1]);
}
m_pModel[m_nPredictors]->Set_Value(x, y, b[0]);
//-----------------------------------------------------
if( m_pDependent->is_NoData(x, y) )
{
m_pResiduals->Set_NoData(x, y);
}
else
{
zr = b[0];
for(i=0; i<m_nPredictors; i++)
{
if( m_pPredictors[i]->is_NoData(x, y) )
{
m_pResiduals->Set_NoData(x, y);
return( true );
}
zr += b[i + 1] * m_pPredictors[i]->asDouble(x, y);
}
m_pResiduals->Set_Value(x, y, m_pDependent->asDouble(x, y) - zr);
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSG_Variogram::Calculate(CSG_Shapes *pPoints, int Attribute, bool bLog, CSG_Table *pVariogram, int nClasses, double maxDistance, int nSkip)
{
int i, j, k, n;
double z, lagDistance;
TSG_Point p;
CSG_Vector Count, Variance;
CSG_Table_Record *pRecord;
CSG_Shape *pPoint;
//-----------------------------------------------------
if( nSkip < 1 )
{
nSkip = 1;
}
if( maxDistance <= 0.0 || maxDistance > SG_Get_Length(pPoints->Get_Extent().Get_XRange(), pPoints->Get_Extent().Get_YRange()) )
{
maxDistance = SG_Get_Length(pPoints->Get_Extent().Get_XRange(), pPoints->Get_Extent().Get_YRange()); // bounding box' diagonal
}
lagDistance = maxDistance / nClasses;
Count .Create(nClasses);
Variance .Create(nClasses);
//-----------------------------------------------------
for(i=0, n=0; i<pPoints->Get_Count()-nSkip && SG_UI_Process_Set_Progress(n, SG_Get_Square(pPoints->Get_Count()/nSkip)/2); i+=nSkip)
{
pPoint = pPoints->Get_Shape(i);
if( !pPoint->is_NoData(Attribute) )
{
p = pPoint->Get_Point(0);
z = bLog ? log(pPoint->asDouble(Attribute)) : pPoint->asDouble(Attribute);
for(j=i+nSkip; j<pPoints->Get_Count(); j+=nSkip, n++)
{
pPoint = pPoints->Get_Shape(j);
if( !pPoint->is_NoData(Attribute) )
{
k = (int)(SG_Get_Distance(p, pPoint->Get_Point(0)) / lagDistance);
if( k < nClasses )
{
Count [k] ++;
Variance[k] += SG_Get_Square((bLog ? log(pPoint->asDouble(Attribute)) : pPoint->asDouble(Attribute)) - z);
}
}
}
}
}
//-----------------------------------------------------
pVariogram->Destroy();
pVariogram->Set_Name(CSG_String::Format(SG_T("%s [%s]"), _TL("Variogram"), pPoints->Get_Name()));
pVariogram->Add_Field(_TL("Class") , SG_DATATYPE_Int); // FIELD_CLASS
pVariogram->Add_Field(_TL("Distance") , SG_DATATYPE_Double); // FIELD_DISTANCE
pVariogram->Add_Field(_TL("Count") , SG_DATATYPE_Int); // FIELD_COUNT
pVariogram->Add_Field(_TL("Variance") , SG_DATATYPE_Double); // FIELD_VAR_EXP
pVariogram->Add_Field(_TL("Var.cum.") , SG_DATATYPE_Double); // FIELD_VAR_CUM
pVariogram->Add_Field(_TL("Model") , SG_DATATYPE_Double); // FIELD_VAR_MODEL
for(i=0, z=0.0, n=0; i<nClasses; i++)
{
if( Count[i] > 0 )
{
n += (int)Count[i];
z += Variance[i];
pRecord = pVariogram->Add_Record();
pRecord->Set_Value(FIELD_CLASS , (i + 1));
pRecord->Set_Value(FIELD_DISTANCE , (i + 1) * lagDistance);
pRecord->Set_Value(FIELD_COUNT , Count[i]);
pRecord->Set_Value(FIELD_VAR_EXP , 0.5 * Variance[i] / Count[i]);
pRecord->Set_Value(FIELD_VAR_CUM , 0.5 * z / n);
}
}
//-----------------------------------------------------
return( SG_UI_Process_Get_Okay() );
}