//---------------------------------------------------------
CSG_Shapes * COGR_DataSource::Read_Shapes(int iLayer)
{
OGRLayer *pLayer = Get_Layer(iLayer);
//-----------------------------------------------------
if( pLayer && Get_Type(iLayer) != SHAPE_TYPE_Undefined )
{
int iField;
OGRFeature *pFeature;
OGRFeatureDefn *pDef = pLayer->GetLayerDefn();
CSG_Shapes *pShapes = SG_Create_Shapes(Get_Type(iLayer), CSG_String(pDef->GetName()));
for(iField=0; iField<pDef->GetFieldCount(); iField++)
{
OGRFieldDefn *pDefField = pDef->GetFieldDefn(iField);
pShapes->Add_Field(pDefField->GetNameRef(), COGR_Driver::Get_Type(pDefField->GetType()));
}
pLayer->ResetReading();
//-------------------------------------------------
while( (pFeature = pLayer->GetNextFeature()) != NULL && SG_UI_Process_Get_Okay(false) )
{
OGRGeometry *pGeometry = pFeature->GetGeometryRef();
if( pGeometry != NULL )
{
CSG_Shape *pShape = pShapes->Add_Shape();
for(iField=0; iField<pDef->GetFieldCount(); iField++)
{
OGRFieldDefn *pDefField = pDef->GetFieldDefn(iField);
switch( pDefField->GetType() )
{
default: pShape->Set_Value(iField, SG_STR_MBTOSG(pFeature->GetFieldAsString (iField))); break;
case OFTString: pShape->Set_Value(iField, SG_STR_MBTOSG(pFeature->GetFieldAsString (iField))); break;
case OFTInteger: pShape->Set_Value(iField, pFeature->GetFieldAsInteger(iField)); break;
case OFTReal: pShape->Set_Value(iField, pFeature->GetFieldAsDouble (iField)); break;
}
}
//-----------------------------------------
if( _Read_Geometry(pShape, pGeometry) == false )
{
pShapes->Del_Shape(pShape);
}
}
OGRFeature::DestroyFeature(pFeature);
}
return( pShapes );
}
//-----------------------------------------------------
return( NULL );
}
bool g_Set_Progress (int i, int n)
{
return( g_bProgress ? SG_UI_Process_Set_Progress(i, n) : SG_UI_Process_Get_Okay() );
}
//---------------------------------------------------------
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 SG_Matrix_LU_Decomposition(int n, int *Permutation, double **Matrix, bool bSilent)
{
int i, j, k, iMax;
double dMax, d, Sum;
CSG_Vector Vector;
Vector.Create(n);
for(i=0, iMax=0; i<n && (bSilent || SG_UI_Process_Set_Progress(i, n)); i++)
{
dMax = 0.0;
for(j=0; j<n; j++)
{
if( (d = fabs(Matrix[i][j])) > dMax )
{
dMax = d;
}
}
if( dMax <= 0.0 ) // singular matrix !!!...
{
return( false );
}
Vector[i] = 1.0 / dMax;
}
for(j=0; j<n && (bSilent || SG_UI_Process_Set_Progress(j, n)); j++)
{
for(i=0; i<j; i++)
{
Sum = Matrix[i][j];
for(k=0; k<i; k++)
{
Sum -= Matrix[i][k] * Matrix[k][j];
}
Matrix[i][j] = Sum;
}
for(i=j, dMax=0.0; i<n; i++)
{
Sum = Matrix[i][j];
for(k=0; k<j; k++)
{
Sum -= Matrix[i][k] * Matrix[k][j];
}
Matrix[i][j] = Sum;
if( (d = Vector[i] * fabs(Sum)) >= dMax )
{
dMax = d;
iMax = i;
}
}
if( j != iMax )
{
for(k=0; k<n; k++)
{
d = Matrix[iMax][k];
Matrix[iMax][k] = Matrix[j ][k];
Matrix[j ][k] = d;
}
Vector[iMax] = Vector[j];
}
Permutation[j] = iMax;
if( Matrix[j][j] == 0.0 )
{
Matrix[j][j] = M_TINY;
}
if( j != n )
{
d = 1.0 / (Matrix[j][j]);
for(i=j+1; i<n; i++)
{
Matrix[i][j] *= d;
}
}
}
return( bSilent || SG_UI_Process_Get_Okay(false) );
}
