//---------------------------------------------------------
bool CGW_Regression::Get_Model(int x, int y, CSG_Regression_Weighted &Model)
{
//-----------------------------------------------------
TSG_Point Point = m_pIntercept->Get_System().Get_Grid_to_World(x, y);
int nPoints = m_Search.Set_Location(Point);
Model.Destroy();
for(int iPoint=0; iPoint<nPoints; iPoint++)
{
double ix, iy, iz;
CSG_Shape *pPoint = m_Search.Do_Use_All() && m_Search.Get_Point(iPoint, ix, iy, iz)
? m_pPoints->Get_Shape((int)iz)
: m_pPoints->Get_Shape(iPoint);
if( !pPoint->is_NoData(m_iDependent) && !pPoint->is_NoData(m_iPredictor) )
{
Model.Add_Sample(
m_Weighting.Get_Weight(SG_Get_Distance(Point, pPoint->Get_Point(0))),
pPoint->asDouble(m_iDependent), CSG_Vector(1, &(iz = pPoint->asDouble(m_iPredictor)))
);
}
}
//-----------------------------------------------------
return( Model.Calculate() );
}
//---------------------------------------------------------
bool CSG_Parameters_Search_Points::Get_Point(int Index, double &x, double &y, double &z)
{
if( m_pPoints ) // without search engine
{
CSG_Shape *pPoint = m_pPoints->Get_Shape(Index);
if( !pPoint || pPoint->is_NoData(m_zField) )
{
return( false );
}
x = pPoint->Get_Point(0).x;
y = pPoint->Get_Point(0).y;
z = m_zField < 0 ? Index : pPoint->asDouble(m_zField);
}
else // using search engine
{
if( !m_Search.Get_Selected_Point(Index, x, y, z) )
{
return( false );
}
}
return( true );
}
//---------------------------------------------------------
bool CSG_PRQuadTree::Create(CSG_Shapes *pShapes, int Attribute, bool bStatistics)
{
Destroy();
if( pShapes && pShapes->is_Valid() && Create(pShapes->Get_Extent(), bStatistics) )
{
for(int iShape=0; iShape<pShapes->Get_Count() && SG_UI_Process_Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
if( Attribute < 0 || !pShape->is_NoData(Attribute) )
{
double z = Attribute < 0 ? iShape : pShape->asDouble(Attribute);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
Add_Point(pShape->Get_Point(iPoint, iPart), z);
}
}
}
}
return( Get_Point_Count() > 0 );
}
return( false );
}
//---------------------------------------------------------
bool C_Kriging_Base::_Get_Points(void)
{
int iShape, iPart, iPoint;
CSG_Shape *pShape , *pPoint;
CSG_Shapes *pPoints;
m_pShapes = Parameters("SHAPES") ->asShapes();
m_zField = Parameters("FIELD") ->asInt();
if( m_pShapes->Get_Type() != SHAPE_TYPE_Point )
{
pPoints = SG_Create_Shapes(SHAPE_TYPE_Point, SG_T(""), m_pShapes);
for(iShape=0; iShape<m_pShapes->Get_Count() && Set_Progress(iShape, m_pShapes->Get_Count()); iShape++)
{
pShape = m_pShapes->Get_Shape(iShape);
if( !pShape->is_NoData(m_zField) )
{
for(iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
pPoint = pPoints->Add_Shape(pShape, SHAPE_COPY_ATTR);
pPoint->Add_Point(pShape->Get_Point(iPoint, iPart));
}
}
}
}
m_pShapes = pPoints;
}
return( m_pShapes->Get_Count() > 1 );
}
//---------------------------------------------------------
bool CPoint_Zonal_Multi_Grid_Regression::Set_Residuals(CSG_Shapes *pPoints, CSG_Grid *pRegression)
{
CSG_Shapes *pResiduals = Parameters("RESIDUALS")->asShapes();
int iAttribute = Parameters("ATTRIBUTE")->asInt ();
if( !pRegression || !pResiduals )
{
return( false );
}
//-----------------------------------------------------
pResiduals->Create(SHAPE_TYPE_Point, CSG_String::Format(SG_T("%s [%s]"), Parameters("ATTRIBUTE")->asString(), _TL("Residuals")));
pResiduals->Add_Field(pPoints->Get_Field_Name(iAttribute), SG_DATATYPE_Double);
pResiduals->Add_Field("TREND" , SG_DATATYPE_Double);
pResiduals->Add_Field("RESIDUAL", SG_DATATYPE_Double);
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline; break;
case 3: Resampling = GRID_RESAMPLING_BSpline; break;
}
//-----------------------------------------------------
for(int iShape=0; iShape<pPoints->Get_Count() && Set_Progress(iShape, pPoints->Get_Count()); iShape++)
{
CSG_Shape *pShape = pPoints->Get_Shape(iShape);
if( !pShape->is_NoData(iAttribute) )
{
double zShape = pShape->asDouble(iAttribute);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
double zGrid;
TSG_Point Point = pShape->Get_Point(iPoint, iPart);
if( pRegression->Get_Value(Point, zGrid, Resampling) )
{
CSG_Shape *pResidual = pResiduals->Add_Shape();
pResidual->Add_Point(Point);
pResidual->Set_Value(0, zShape);
pResidual->Set_Value(1, zGrid);
pResidual->Set_Value(2, zShape - zGrid);
}
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CKriging_Universal::On_Initialize(void)
{
m_pGrids = Parameters("GRIDS" )->asGridList();
m_Interpolation = Parameters("INTERPOL" )->asInt();
m_nPoints_Min = Parameters("SEARCH_POINTS_MIN")->asInt ();
m_nPoints_Max = Parameters("SEARCH_POINTS_ALL")->asInt () == 0
? Parameters("SEARCH_POINTS_MAX")->asInt () : 0;
m_Radius = Parameters("SEARCH_RANGE" )->asInt () == 0
? Parameters("SEARCH_RADIUS" )->asDouble() : 0.0;
m_Direction = Parameters("SEARCH_DIRECTION" )->asInt () == 0 ? -1 : 4;
//-----------------------------------------------------
if( m_nPoints_Max <= 0 && m_Radius <= 0 ) // global
{
return( CKriging_Universal_Global::On_Initialize() );
}
//-----------------------------------------------------
m_Search.Create(m_pPoints->Get_Extent());
for(int iPoint=0; iPoint<m_pPoints->Get_Count() && Set_Progress(iPoint, m_pPoints->Get_Count()); iPoint++)
{
CSG_Shape *pPoint = m_pPoints->Get_Shape(iPoint);
if( !pPoint->is_NoData(m_zField) )
{
bool bAdd = true;
for(int iGrid=0; iGrid<m_pGrids->Get_Count(); iGrid++)
{
if( !m_pGrids->asGrid(iGrid)->is_InGrid_byPos(pPoint->Get_Point(0)) )
{
bAdd = false;
}
}
if( bAdd )
{
m_Search.Add_Point(pPoint->Get_Point(0).x, pPoint->Get_Point(0).y, m_bLog ? log(pPoint->asDouble(m_zField)) : pPoint->asDouble(m_zField));
}
}
}
if( !m_Search.is_Okay() )
{
SG_UI_Msg_Add(_TL("could not initialize point search engine"), true);
return( false );
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGridding_Spline_Base::_Get_Points(CSG_Points_Z &Points, bool bInGridOnly)
{
Points.Clear();
if( m_bGridPoints )
{
int x, y;
TSG_Point p;
CSG_Grid *pGrid = Parameters("GRIDPOINTS") ->asGrid();
for(y=0, p.y=pGrid->Get_YMin(); y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++, p.y+=pGrid->Get_Cellsize())
{
for(x=0, p.x=pGrid->Get_XMin(); x<pGrid->Get_NX(); x++, p.x+=pGrid->Get_Cellsize())
{
if( !pGrid->is_NoData(x, y) && (!bInGridOnly || m_pGrid->is_InGrid_byPos(p)) )
{
Points.Add(p.x, p.y, pGrid->asDouble(x, y));
}
}
}
}
else
{
CSG_Shapes *pShapes = Parameters("SHAPES") ->asShapes();
int zField = Parameters("FIELD") ->asInt();
for(int iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
if( !pShape->is_NoData(zField) )
{
double zValue = pShape->asDouble(zField);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
TSG_Point p = pShape->Get_Point(iPoint, iPart);
if( !bInGridOnly || m_pGrid->is_InGrid_byPos(p) )
{
Points.Add(p.x, p.y, zValue);
}
}
}
}
}
}
return( Points.Get_Count() >= 3 );
}
//---------------------------------------------------------
bool C_Kriging_Ordinary_Global::Get_Weights(void)
{
int i, j, n;
//-----------------------------------------------------
for(int iShape=0; iShape<m_pShapes->Get_Count(); iShape++)
{
CSG_Shape *pShape = m_pShapes->Get_Shape(iShape);
if( !pShape->is_NoData(m_zField) )
{
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
m_Points.Add(
pShape->Get_Point(iPoint, iPart).x,
pShape->Get_Point(iPoint, iPart).y,
pShape->asDouble(m_zField)
);
}
}
}
}
//-----------------------------------------------------
if( (n = m_Points.Get_Count()) > 4 )
{
m_G .Create(n + 1);
m_W .Create(n + 1, n + 1);
for(i=0; i<n; i++)
{
m_W[i][i] = 0.0; // diagonal...
m_W[i][n] = m_W[n][i] = 1.0; // edge...
for(j=i+1; j<n; j++)
{
m_W[i][j] = m_W[j][i] = Get_Weight(
m_Points[i].x - m_Points[j].x,
m_Points[i].y - m_Points[j].y
);
}
}
m_W[n][n] = 0.0;
return( m_W.Set_Inverse(false) );
}
return( false );
}
//---------------------------------------------------------
int CGW_Regression::Set_Variables(int x, int y)
{
int iPoint, jPoint, nPoints;
TSG_Point Point;
CSG_Shape *pPoint;
Point = m_pIntercept->Get_System().Get_Grid_to_World(x, y);
nPoints = m_Search.is_Okay() ? m_Search.Select_Nearest_Points(Point.x, Point.y, m_nPoints_Max, m_Radius, m_Mode == 0 ? -1 : 4) : m_pPoints->Get_Count();
for(iPoint=0, jPoint=0; iPoint<nPoints; iPoint++)
{
if( m_Search.is_Okay() )
{
double ix, iy, iz;
m_Search.Get_Selected_Point(iPoint, ix, iy, iz);
pPoint = m_pPoints->Get_Shape((int)iz);
}
else
{
pPoint = m_pPoints->Get_Shape(iPoint);
}
if( !pPoint->is_NoData(m_iDependent) && !pPoint->is_NoData(m_iPredictor) )
{
m_z[jPoint] = pPoint->asDouble(m_iDependent);
m_y[jPoint] = pPoint->asDouble(m_iPredictor);
m_w[jPoint] = m_Weighting.Get_Weight(SG_Get_Distance(Point, pPoint->Get_Point(0)));
jPoint++;
}
}
return( jPoint );
}
//---------------------------------------------------------
bool CVIEW_ScatterPlot::_Initialize_Shapes(void)
{
CSG_Shapes *pPoints = m_Parameters("POINTS")->asShapes();
int Field = m_Parameters("FIELD" )->asInt();
TSG_Grid_Resampling Resampling;
switch( m_Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear ; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline ; break;
case 3: Resampling = GRID_RESAMPLING_BSpline ; break;
}
CHECK_DATA(m_pGrid);
CHECK_DATA(pPoints);
if( !m_pGrid || !pPoints || Field < 0 || Field >= pPoints->Get_Field_Count() )
{
return( false );
}
m_sTitle.Printf("%s: [%s/%s]", _TL("Scatterplot"), m_pGrid->Get_Name(), pPoints->Get_Name());
m_sX.Printf("%s", m_pGrid->Get_Name());
m_sY.Printf("%s", pPoints->Get_Field_Name(Field));
int maxSamples = m_Options("SAMPLES_MAX")->asInt();
double x, Step = maxSamples > 0 && pPoints->Get_Count() > maxSamples ? pPoints->Get_Count() / maxSamples : 1.0;
for(double i=0; i<pPoints->Get_Count() && PROGRESSBAR_Set_Position(i, pPoints->Get_Count()); i+=Step)
{
CSG_Shape *pShape = pPoints->Get_Shape((int)i);
if( !pShape->is_NoData(Field) && m_pGrid->Get_Value(pShape->Get_Point(0), x, Resampling) )
{
m_Trend.Add_Data(x, pShape->asDouble(Field));
}
}
return( true );
}
//---------------------------------------------------------
CSG_Shapes * CInterpolation::Get_Points(bool bOnlyNonPoints)
{
m_pShapes = Parameters("SHAPES") ->asShapes();
if( !bOnlyNonPoints || m_pShapes->Get_Type() != SHAPE_TYPE_Point )
{
CSG_Shapes *pPoints = SG_Create_Shapes(SHAPE_TYPE_Point);
pPoints->Set_NoData_Value_Range(m_pShapes->Get_NoData_Value(), m_pShapes->Get_NoData_hiValue());
pPoints->Add_Field(SG_T("Z"), SG_DATATYPE_Double);
for(int iShape=0; iShape<m_pShapes->Get_Count() && Set_Progress(iShape, m_pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = m_pShapes->Get_Shape(iShape);
if( !pShape->is_NoData(m_zField) )
{
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
CSG_Shape *pPoint = pPoints->Add_Shape();
pPoint->Add_Point(pShape->Get_Point(iPoint, iPart));
pPoint->Set_Value(0, pShape->asDouble(m_zField));
}
}
}
}
m_zField = 0;
m_pShapes = pPoints;
}
return( m_pShapes );
}
//---------------------------------------------------------
bool CPoint_Trend_Surface::Get_Regression(CSG_Shapes *pPoints, int iAttribute)
{
//-----------------------------------------------------
int i, j, Field;
m_Names.Clear();
m_Names += pPoints->Get_Name();
for(i=1; i<=m_xOrder; i++)
{
m_Names += Get_Power(SG_T("x"), i);
}
for(i=1; i<=m_yOrder; i++)
{
m_Names += Get_Power(SG_T("y"), i);
for(j=1; j<=m_xOrder && i<m_tOrder && j<m_tOrder; j++)
{
m_Names += Get_Power(SG_T("x"), j) + Get_Power(SG_T("y"), i);
}
}
//-----------------------------------------------------
CSG_Vector Y, xPow, yPow;
CSG_Matrix X;
Y.Create(pPoints->Get_Count());
X.Create(m_Names.Get_Count(), pPoints->Get_Count());
xPow.Create(m_xOrder + 1);
yPow.Create(m_yOrder + 1);
xPow[0] = 1.0;
yPow[0] = 1.0;
//-----------------------------------------------------
for(int iShape=0; iShape<pPoints->Get_Count() && Set_Progress(iShape, pPoints->Get_Count()); iShape++)
{
CSG_Shape *pShape = pPoints->Get_Shape(iShape);
if( !pShape->is_NoData(iAttribute) )
{
double zShape = pShape->asDouble(iAttribute);
TSG_Point Point = pShape->Get_Point(0);
Y[iShape] = zShape;
X[iShape][0] = 1.0;
for(i=1, Field=1; i<=m_xOrder; i++)
{
X[iShape][Field++] = xPow[i] = xPow[i - 1] * Point.x;
}
for(i=1; i<=m_yOrder; i++)
{
X[iShape][Field++] = yPow[i] = yPow[i - 1] * Point.y;
for(j=1; j<=m_xOrder && i<m_tOrder && j<m_tOrder; j++)
{
X[iShape][Field++] = xPow[j] * yPow[i];
}
}
}
}
//-----------------------------------------------------
CSG_Matrix Xt, XtXinv;
Xt = X;
Xt .Set_Transpose();
XtXinv = Xt * X;
XtXinv .Set_Inverse();
m_Coefficients = XtXinv * Xt * Y;
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() );
}
//---------------------------------------------------------
bool CGW_Multi_Regression_Grid::Initialize(CSG_Shapes *pPoints, int iDependent, CSG_Parameter_Grid_List *pPredictors)
{
//-----------------------------------------------------
if( (m_nPredictors = pPredictors->Get_Count()) <= 0 )
{
return( false );
}
if( !pPoints->Get_Extent().Intersects(Get_System()->Get_Extent()) )
{
return( false );
}
//-----------------------------------------------------
int iPredictor, Interpolation = GRID_INTERPOLATION_BSpline;
m_Points.Create (SHAPE_TYPE_Point);
m_Points.Set_Name (Parameters("DEPENDENT")->asString());
m_Points.Add_Field(Parameters("DEPENDENT")->asString(), SG_DATATYPE_Double);
for(iPredictor=0; iPredictor<pPredictors->Get_Count(); iPredictor++)
{
m_Points.Add_Field(pPredictors->asGrid(iPredictor)->Get_Name(), SG_DATATYPE_Double);
}
//-----------------------------------------------------
for(int iPoint=0; iPoint<pPoints->Get_Count() && Set_Progress(iPoint, pPoints->Get_Count()); iPoint++)
{
CSG_Shape *pPoint = pPoints->Get_Shape(iPoint);
if( !pPoint->is_NoData(iDependent) )
{
CSG_Vector z(1 + m_nPredictors); z[0] = pPoint->asDouble(iDependent);
TSG_Point Point = pPoint->Get_Point(0);
bool bAdd = true;
for(iPredictor=0; bAdd && iPredictor<m_nPredictors; iPredictor++)
{
if( !pPredictors->asGrid(iPredictor)->Get_Value(Point, z[iPredictor + 1], Interpolation) )
{
bAdd = false;
}
}
if( bAdd )
{
(pPoint = m_Points.Add_Shape())->Add_Point(Point);
for(iPredictor=0; iPredictor<=m_nPredictors; iPredictor++)
{
pPoint->Set_Value(iPredictor, z[iPredictor]);
}
}
}
}
//-----------------------------------------------------
m_nPoints_Min = Parameters("SEARCH_POINTS_MIN")->asInt ();
m_nPoints_Max = Parameters("SEARCH_POINTS_ALL")->asInt () == 0
? Parameters("SEARCH_POINTS_MAX")->asInt () : 0;
m_Radius = Parameters("SEARCH_RANGE" )->asInt () == 0
? Parameters("SEARCH_RADIUS" )->asDouble() : 0.0;
m_Direction = Parameters("SEARCH_DIRECTION" )->asInt () == 0 ? -1 : 4;
m_Weighting.Set_Parameters(&Parameters);
return( m_Points.Get_Count() > m_nPredictors
&& ((m_nPoints_Max <= 0 && m_Radius <= 0.0) || m_Search.Create(&m_Points, -1))
);
}
//---------------------------------------------------------
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 CShapes2Grid::On_Execute(void)
{
int iField, iShape, iType;
//-----------------------------------------------------
m_pShapes = Parameters("INPUT") ->asShapes();
m_Method_Lines = Parameters("LINE_TYPE") ->asInt();
iField = Parameters("FIELD") ->asInt();
iType = Parameters("GRID_TYPE") ->asInt();
if( iField < 0 || iField >= m_pShapes->Get_Field_Count() || m_pShapes->Get_Field_Type(iField) == SG_DATATYPE_String )
{
iField = -1;
Message_Add(_TL("WARNING: selected attribute is not numeric; generating unique identifiers instead."));
}
//-----------------------------------------------------
m_pGrid = NULL;
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pShapes->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User(Get_Grid_Type(iType));
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid(Get_Grid_Type(iType));
}
break;
}
if( m_pGrid == NULL )
{
return( false );
}
//-------------------------------------------------
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), m_pShapes->Get_Name(), iField < 0 ? _TL("ID") : m_pShapes->Get_Field_Name(iField)));
m_pGrid->Assign_NoData();
m_pLock = m_pShapes->Get_Type() == SHAPE_TYPE_Point ? NULL : SG_Create_Grid(m_pGrid, SG_DATATYPE_Byte);
//-----------------------------------------------------
for(iShape=0, m_Lock_ID=1; iShape<m_pShapes->Get_Count() && Set_Progress(iShape, m_pShapes->Get_Count()); iShape++, m_Lock_ID++)
{
CSG_Shape *pShape = m_pShapes->Get_Shape(iShape);
if( m_pShapes->Get_Selection_Count() <= 0 || pShape->is_Selected() )
{
if( iField < 0 || !pShape->is_NoData(iField) )
{
m_Value = iField < 0 ? iShape + 1 : pShape->asDouble(iField);
if( pShape->Intersects(m_pGrid->Get_Extent().m_rect) )
{
switch( m_pShapes->Get_Type() )
{
case SHAPE_TYPE_Point:
case SHAPE_TYPE_Points: Set_Points (pShape); break;
case SHAPE_TYPE_Line: Set_Line (pShape); break;
case SHAPE_TYPE_Polygon: Set_Polygon (pShape); break;
}
}
}
}
}
//-----------------------------------------------------
if( m_pLock )
{
delete(m_pLock);
}
return( true );
}
//---------------------------------------------------------
bool CPolygonStatisticsFromPoints::On_Execute(void)
{
//-----------------------------------------------------
bool bSum = Parameters("SUM")->asBool();
bool bAvg = Parameters("AVG")->asBool();
bool bVar = Parameters("VAR")->asBool();
bool bDev = Parameters("DEV")->asBool();
bool bMin = Parameters("MIN")->asBool();
bool bMax = Parameters("MAX")->asBool();
bool bNum = Parameters("NUM")->asBool();
if( !bSum && !bAvg && !bVar && !bDev && !bMin && !bMax && !bNum )
{
Error_Set(_TL("no target variable in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Table_Fields *pFields = Parameters("FIELDS")->asTableFields();
if( pFields->Get_Count() <= 0 )
{
Error_Set(_TL("no attributes in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Shapes *pPoints = Parameters("POINTS" )->asShapes();
CSG_Shapes *pPolygons = Parameters("POLYGONS")->asShapes();
if( pPolygons->Get_Count() <= 0 || pPoints->Get_Count() <= 0 )
{
Error_Set(_TL("no records in input data"));
return( false );
}
//-----------------------------------------------------
if( Parameters("STATISTICS")->asShapes() == NULL )
{
Parameters("STATISTICS")->Set_Value(pPolygons);
}
else if( pPolygons != Parameters("STATISTICS")->asShapes() )
{
Parameters("STATISTICS")->asShapes()->Assign(pPolygons);
pPolygons = Parameters("STATISTICS")->asShapes();
}
//-----------------------------------------------------
int i, n, Offset = pPolygons->Get_Field_Count();
for(i=0; i<pFields->Get_Count(); i++)
{
CSG_String sName = pPoints->Get_Field_Name(pFields->Get_Index(i));
if( bSum ) { pPolygons->Add_Field(Get_Field_Name("SUM", sName), SG_DATATYPE_Double); }
if( bAvg ) { pPolygons->Add_Field(Get_Field_Name("AVG", sName), SG_DATATYPE_Double); }
if( bVar ) { pPolygons->Add_Field(Get_Field_Name("VAR", sName), SG_DATATYPE_Double); }
if( bDev ) { pPolygons->Add_Field(Get_Field_Name("DEV", sName), SG_DATATYPE_Double); }
if( bMin ) { pPolygons->Add_Field(Get_Field_Name("MIN", sName), SG_DATATYPE_Double); }
if( bMax ) { pPolygons->Add_Field(Get_Field_Name("MAX", sName), SG_DATATYPE_Double); }
if( bNum ) { pPolygons->Add_Field(Get_Field_Name("NUM", sName), SG_DATATYPE_Long ); }
}
//-----------------------------------------------------
CSG_Simple_Statistics *Statistics = new CSG_Simple_Statistics[pFields->Get_Count()];
for(int iPolygon=0; iPolygon<pPolygons->Get_Count() && Set_Progress(iPolygon, pPolygons->Get_Count()); iPolygon++)
{
CSG_Shape_Polygon *pPolygon = (CSG_Shape_Polygon *)pPolygons->Get_Shape(iPolygon);
//-------------------------------------------------
for(i=0; i<pFields->Get_Count(); i++)
{
Statistics[i].Invalidate();
}
//-------------------------------------------------
for(int iPoint=0; iPoint<pPoints->Get_Count() && Process_Get_Okay(); iPoint++)
{
CSG_Shape *pPoint = pPoints->Get_Shape(iPoint);
if( pPolygon->Contains(pPoint->Get_Point(0)) )
{
for(i=0; i<pFields->Get_Count(); i++)
{
if( !pPoint->is_NoData(pFields->Get_Index(i)))
{
Statistics[i].Add_Value(pPoint->asDouble(pFields->Get_Index(i)));
}
}
}
}
//-------------------------------------------------
for(i=0, n=Offset; i<pFields->Get_Count(); i++)
{
if( Statistics[i].Get_Count() > 0 )
{
if( bSum ) { pPolygon->Set_Value (n++, Statistics[i].Get_Sum()); }
if( bAvg ) { pPolygon->Set_Value (n++, Statistics[i].Get_Mean()); }
if( bVar ) { pPolygon->Set_Value (n++, Statistics[i].Get_Variance()); }
if( bDev ) { pPolygon->Set_Value (n++, Statistics[i].Get_StdDev()); }
if( bMin ) { pPolygon->Set_Value (n++, Statistics[i].Get_Minimum()); }
if( bMax ) { pPolygon->Set_Value (n++, Statistics[i].Get_Maximum()); }
if( bNum ) { pPolygon->Set_Value (n++, (double)Statistics[i].Get_Count()); }
}
else
{
if( bSum ) { pPolygon->Set_NoData(n++); }
if( bAvg ) { pPolygon->Set_NoData(n++); }
if( bVar ) { pPolygon->Set_NoData(n++); }
if( bDev ) { pPolygon->Set_NoData(n++); }
if( bMin ) { pPolygon->Set_NoData(n++); }
if( bMax ) { pPolygon->Set_NoData(n++); }
if( bNum ) { pPolygon->Set_Value (n++, 0.0); }
}
}
}
//-----------------------------------------------------
delete[](Statistics);
DataObject_Update(pPolygons);
return( true );
}
//---------------------------------------------------------
bool CKriging_Universal::On_Initialise(void)
{
m_pGrids = Parameters("GRIDS") ->asGridList();
m_Interpolation = Parameters("INTERPOL") ->asInt();
m_Radius = Parameters("MAXRADIUS") ->asDouble();
m_nPoints_Min = (int)Parameters("NPOINTS")->asRange()->Get_LoVal();
m_nPoints_Max = (int)Parameters("NPOINTS")->asRange()->Get_HiVal();
m_Mode = Parameters("MODE") ->asInt();
//-----------------------------------------------------
m_Search.Create(m_pPoints->Get_Extent());
for(int iPoint=0; iPoint<m_pPoints->Get_Count() && Set_Progress(iPoint, m_pPoints->Get_Count()); iPoint++)
{
CSG_Shape *pPoint = m_pPoints->Get_Shape(iPoint);
if( !pPoint->is_NoData(m_zField) )
{
bool bAdd = true;
for(int iGrid=0; iGrid<m_pGrids->Get_Count(); iGrid++)
{
if( !m_pGrids->asGrid(iGrid)->is_InGrid_byPos(pPoint->Get_Point(0)) )
{
bAdd = false;
}
}
if( bAdd )
{
m_Search.Add_Point(pPoint->Get_Point(0).x, pPoint->Get_Point(0).y, pPoint->asDouble(m_zField));
}
}
}
if( !m_Search.is_Okay() )
{
SG_UI_Msg_Add(_TL("could not initialize point search engine"), true);
return( false );
}
//-----------------------------------------------------
int nPoints_Max;
switch( m_Mode )
{
default: nPoints_Max = m_nPoints_Max; break;
case 1: nPoints_Max = m_nPoints_Max * 4; break;
}
m_Points.Set_Count (nPoints_Max);
m_G .Create (nPoints_Max + 1 + m_pGrids->Get_Count() + (m_bCoords ? 2 : 0));
m_W .Create (nPoints_Max + 1 + m_pGrids->Get_Count() + (m_bCoords ? 2 : 0),
nPoints_Max + 1 + m_pGrids->Get_Count() + (m_bCoords ? 2 : 0));
return( true );
}
//---------------------------------------------------------
bool C_Kriging_Universal_Global::Get_Weights(void)
{
int i, j, n, iGrid, nGrids;
//-----------------------------------------------------
if( (nGrids = m_pGrids->Get_Count()) > 0 )
{
for(int iShape=0; iShape<m_pShapes->Get_Count(); iShape++)
{
CSG_Shape *pShape = m_pShapes->Get_Shape(iShape);
if( !pShape->is_NoData(m_zField) )
{
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
bool bAdd;
CSG_Point p(pShape->Get_Point(iPoint, iPart));
for(j=0, bAdd=true; j<nGrids && bAdd; j++)
{
if( !m_pGrids->asGrid(j)->is_InGrid_byPos(p) )
{
bAdd = false;
}
}
if( bAdd )
{
m_Points.Add(p.Get_X(), p.Get_Y(), pShape->asDouble(m_zField));
}
}
}
}
}
//-------------------------------------------------
if( (n = m_Points.Get_Count()) > 1 )
{
m_G.Create(n + 1 + nGrids);
m_W.Create(n + 1 + nGrids, n + 1 + nGrids);
for(i=0; i<n; i++)
{
m_W[i][i] = 0.0; // diagonal...
m_W[i][n] = m_W[n][i] = 1.0; // edge...
for(j=i+1; j<n; j++)
{
m_W[i][j] = m_W[j][i] = Get_Weight(
m_Points[i].x - m_Points[j].x,
m_Points[i].y - m_Points[j].y
);
}
for(iGrid=0, j=n+1; iGrid<nGrids; iGrid++, j++)
{
m_W[i][j] = m_W[j][i] = m_pGrids->asGrid(iGrid)->Get_Value(
m_Points[i].x, m_Points[i].y, m_Interpolation
);
}
}
for(i=n; i<=n+nGrids; i++)
{
for(j=n; j<=n+nGrids; j++)
{
m_W[i][j] = 0.0;
}
}
return( m_W.Set_Inverse() );
}
}
return( 0 );
}
//---------------------------------------------------------
bool CShapes2Grid::On_Execute(void)
{
//-----------------------------------------------------
m_pShapes = Parameters("INPUT" )->asShapes();
m_Method_Lines = Parameters("LINE_TYPE")->asInt();
m_Method_Polygon = Parameters("POLY_TYPE")->asInt();
m_Method_Multi = Parameters("MULTIPLE" )->asInt();
if( m_pShapes->Get_Type() == SHAPE_TYPE_Polygon && m_Method_Polygon == 1 ) // all cells intersected have to be marked
{
m_Method_Lines = 1; // thick, each cell crossed by polygon boundary will be marked additionally
}
//-----------------------------------------------------
int iField;
switch( Parameters("OUTPUT")->asInt() )
{
case 0: iField = -1; break;
case 1: iField = -2; break;
case 2:
if( (iField = Parameters("FIELD")->asInt()) < 0 || !SG_Data_Type_is_Numeric(m_pShapes->Get_Field_Type(iField)) )
{
iField = -2;
Message_Add(_TL("WARNING: selected attribute is not numeric; generating unique identifiers instead."));
}
break;
}
//-----------------------------------------------------
m_Grid_Target.Cmd_Update(m_pShapes); // if called from saga_cmd
if( (m_pGrid = m_Grid_Target.Get_Grid("GRID", Get_Grid_Type(Parameters("GRID_TYPE")->asInt()))) == NULL )
{
return( false );
}
if( iField < 0 )
{
m_pGrid->Set_NoData_Value(0.0);
}
m_pGrid->Set_Name(CSG_String::Format("%s [%s]", m_pShapes->Get_Name(), iField < 0 ? _TL("ID") : m_pShapes->Get_Field_Name(iField)));
m_pGrid->Assign_NoData();
//-------------------------------------------------
m_pCount = m_Grid_Target.Get_Grid("COUNT", m_pShapes->Get_Count() < 256 ? SG_DATATYPE_Byte : SG_DATATYPE_Word);
if( m_pCount == NULL )
{
m_Count.Create(m_pGrid->Get_System(), SG_DATATYPE_Word);
m_pCount = &m_Count;
}
m_pCount->Set_Name(CSG_String::Format("%s [%s]", m_pShapes->Get_Name(), _TL("Count")));
m_pCount->Set_NoData_Value(0.0);
m_pCount->Assign(0.0);
//-----------------------------------------------------
for(int iShape=0; iShape<m_pShapes->Get_Count() && Set_Progress(iShape, m_pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = m_pShapes->Get_Shape(iShape);
if( m_pShapes->Get_Selection_Count() <= 0 || pShape->is_Selected() )
{
if( iField < 0 || !pShape->is_NoData(iField) )
{
m_Value = iField >= 0 ? pShape->asDouble(iField) : iField == -2 ? iShape + 1 : 1;
if( pShape->Intersects(m_pGrid->Get_Extent()) )
{
switch( m_pShapes->Get_Type() )
{
case SHAPE_TYPE_Point: case SHAPE_TYPE_Points:
Set_Points (pShape);
break;
case SHAPE_TYPE_Line:
Set_Line (pShape);
break;
case SHAPE_TYPE_Polygon:
Set_Polygon (pShape);
if( m_Method_Polygon == 1 ) // all cells intersected have to be marked
{
Set_Line(pShape); // thick, each cell crossed by polygon boundary will be marked additionally
}
break;
}
}
}
}
}
//-----------------------------------------------------
if( m_Method_Multi == 4 ) // mean
{
for(int y=0; y<m_pGrid->Get_NY() && Set_Progress(y, m_pGrid->Get_NY()); y++)
{
for(int x=0; x<m_pGrid->Get_NX(); x++)
{
if( m_pCount->asInt(x, y) > 1 )
{
m_pGrid->Mul_Value(x, y, 1.0 / m_pCount->asDouble(x, y));
}
}
}
}
//-----------------------------------------------------
m_Count.Destroy();
return( true );
}
