//---------------------------------------------------------
void CSG_Grid::Invert(void)
{
int x, y;
double zMin, zMax;
if( is_Valid() && Get_ZRange() > 0.0 )
{
zMin = Get_ZMin();
zMax = Get_ZMax();
for(y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !is_NoData(x, y) )
{
Set_Value(x, y, zMax - (asDouble(x, y) - zMin));
}
}
}
SG_UI_Process_Set_Ready();
Get_History().Add_Child(SG_T("GRID_OPERATION"), LNG("Inversion"));
}
}
//---------------------------------------------------------
void CSG_Grid::Normalise(void)
{
if( is_Valid() )
{
Update();
if( m_zStats.Get_StdDev() > 0.0 )
{
int x, y;
if( (Get_NoData_hiValue() > -NORMALISED_NODATA && Get_NoData_hiValue() < NORMALISED_NODATA)
|| (Get_NoData_Value () > -NORMALISED_NODATA && Get_NoData_Value () < NORMALISED_NODATA) )
{
for(y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( is_NoData(x, y) )
{
Set_Value(x, y, -NORMALISED_NODATA);
}
}
}
Set_NoData_Value(-NORMALISED_NODATA);
}
for(y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !is_NoData(x, y) )
{
Set_Value(x, y, (asDouble(x, y) - m_zStats.Get_Mean()) / m_zStats.Get_StdDev() );
}
}
}
SG_UI_Process_Set_Ready();
Get_History().Add_Child(SG_T("GRID_OPERATION"), LNG("Normalisation"));
}
}
}
//---------------------------------------------------------
CSG_Grid & CSG_Grid::_Operation_Arithmetic(double Value, TSG_Grid_Operation Operation)
{
//-----------------------------------------------------
switch( Operation )
{
case GRID_OPERATION_Addition:
Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Addition"));
break;
case GRID_OPERATION_Subtraction:
Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Subtraction"));
Value = -Value;
break;
case GRID_OPERATION_Multiplication:
Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Multiplication"));
break;
case GRID_OPERATION_Division:
if( Value == 0.0 )
return( *this );
Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Division"));
Value = 1.0 / Value;
break;
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( !is_NoData(x, y) )
{
switch( Operation )
{
case GRID_OPERATION_Addition:
case GRID_OPERATION_Subtraction:
Add_Value(x, y, Value);
break;
case GRID_OPERATION_Multiplication:
case GRID_OPERATION_Division:
Mul_Value(x, y, Value);
break;
}
}
}
}
SG_UI_Process_Set_Ready();
return( *this );
}
//---------------------------------------------------------
bool CSG_Grid::_Assign_ExtremeValue(CSG_Grid *pGrid, bool bMaximum)
{
if( Get_Cellsize() < pGrid->Get_Cellsize() || is_Intersecting(pGrid->Get_Extent()) == INTERSECTION_None )
{
return( false );
}
//-----------------------------------------------------
int x, y, ix, iy;
double px, py, ax, ay, d, z;
CSG_Matrix S(Get_NY(), Get_NX()), N(Get_NY(), Get_NX());
d = pGrid->Get_Cellsize() / Get_Cellsize();
Set_NoData_Value(pGrid->Get_NoData_Value());
Assign_NoData();
//-----------------------------------------------------
ax = 0.5 + (pGrid->Get_XMin() - Get_XMin()) / Get_Cellsize();
ay = 0.5 + (pGrid->Get_YMin() - Get_YMin()) / Get_Cellsize();
for(y=0, py=ay; y<pGrid->Get_NY() && SG_UI_Process_Set_Progress(y, pGrid->Get_NY()); y++, py+=d)
{
if( (iy = (int)floor(py)) >= 0 && iy < Get_NY() )
{
for(x=0, px=ax; x<pGrid->Get_NX(); x++, px+=d)
{
if( !pGrid->is_NoData(x, y) && (ix = (int)floor(px)) >= 0 && ix < Get_NX() )
{
z = pGrid->asDouble(x, y);
if( is_NoData(ix, iy)
|| (bMaximum == true && z > asDouble(ix, iy))
|| (bMaximum == false && z < asDouble(ix, iy)) )
{
Set_Value(ix, iy, z);
}
}
}
}
}
//-----------------------------------------------------
Get_History() = pGrid->Get_History();
Get_History().Add_Child(SG_T("GRID_OPERATION"), CSG_String::Format(SG_T("%f -> %f"), pGrid->Get_Cellsize(), Get_Cellsize()))->Add_Property(SG_T("NAME"), LNG("Resampling"));
SG_UI_Process_Set_Ready();
return( true );
}
//---------------------------------------------------------
void CSG_Grid::DeNormalise(double ArithMean, double Variance)
{
int x, y;
if( is_Valid() )
{
Variance = sqrt(Variance);
for(y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !is_NoData(x, y) )
{
Set_Value(x, y, Variance * asDouble(x, y) + ArithMean);
}
}
}
SG_UI_Process_Set_Ready();
Get_History().Add_Child(SG_T("GRID_OPERATION"), LNG("Denormalisation"));
}
}
//---------------------------------------------------------
bool CTable_PCA::Get_Components(CSG_Matrix &Eigen_Vectors, CSG_Vector &Eigen_Values)
{
int i, j, n, field0;
double Sum, Cum;
///////////////////////////////////////////////////////
//-----------------------------------------------------
for(i=0, Sum=0.0; i<m_nFeatures; i++)
{
Sum += Eigen_Values[i];
}
Sum = Sum > 0.0 ? 100.0 / Sum : 0.0;
Message_Add(CSG_String::Format(SG_T("\n%s, %s, %s\n"), _TL("explained variance"), _TL("explained cumulative variance"), _TL("Eigenvalue")), false);
for(j=m_nFeatures-1, Cum=0.0; j>=0; j--)
{
Cum += Eigen_Values[j] * Sum;
Message_Add(CSG_String::Format(SG_T("%6.2f\t%6.2f\t%18.5f\n"), Eigen_Values[j] * Sum, Cum, Eigen_Values[j]), false);
}
Message_Add(CSG_String::Format(SG_T("\n%s:\n"), _TL("Eigenvectors")), false);
for(j=0; j<m_nFeatures; j++)
{
for(i=0; i<m_nFeatures; i++)
{
Message_Add(CSG_String::Format(SG_T("%12.4f"), Eigen_Vectors[j][m_nFeatures - 1 - i]), false);
}
Message_Add(SG_T("\n"), false);
}
///////////////////////////////////////////////////////
//-----------------------------------------------------
n = Parameters("NFIRST")->asInt();
if( n <= 0 || n > m_nFeatures )
{
n = m_nFeatures;
}
//-----------------------------------------------------
CSG_Table *pPCA = Parameters("PCA")->asTable();
if( pPCA == NULL )
{
pPCA = m_pTable;
}
if( pPCA != m_pTable )
{
pPCA->Destroy();
pPCA->Set_Name(CSG_String::Format(SG_T("%s [%s]"), m_pTable->Get_Name(), _TL("Principal Components")));
}
//-----------------------------------------------------
field0 = pPCA->Get_Field_Count();
for(i=0; i<n; i++)
{
pPCA->Add_Field(CSG_String::Format(SG_T("%s %d"), _TL("Component"), i + 1), SG_DATATYPE_Double);
}
//-----------------------------------------------------
for(int iElement=0; iElement<m_pTable->Get_Count() && Set_Progress(iElement, m_pTable->Get_Count()); iElement++)
{
if( !is_NoData(iElement) )
{
CSG_Table_Record *pElement = pPCA == m_pTable ? pPCA->Get_Record(iElement) : pPCA->Add_Record();
for(i=0, j=m_nFeatures-1; i<n; i++, j--)
{
double d = 0.0;
for(int k=0; k<m_nFeatures; k++)
{
d += Get_Value(k, iElement) * Eigen_Vectors[k][j];
}
pElement->Set_Value(field0 + i, d);
}
}
}
//-----------------------------------------------------
if( pPCA == m_pTable )
{
DataObject_Update(m_pTable);
}
return( true );
}
//---------------------------------------------------------
bool CTable_PCA::Get_Matrix(CSG_Matrix &Matrix)
{
int i, j1, j2;
Matrix.Create(m_nFeatures, m_nFeatures);
Matrix.Set_Zero();
switch( m_Method )
{
//-----------------------------------------------------
default:
case 0: // Correlation matrix: Center and reduce the column vectors.
for(j1=0; j1<m_nFeatures; j1++)
{
Matrix[j1][j1] = 1.0;
}
for(i=0; i<m_pTable->Get_Count() && Set_Progress(i, m_pTable->Get_Count()); i++)
{
if( !is_NoData(i) )
{
for(j1=0; j1<m_nFeatures-1; j1++)
{
for(j2=j1+1; j2<m_nFeatures; j2++)
{
Matrix[j1][j2] += Get_Value(j1, i) * Get_Value(j2, i);
}
}
}
}
break;
//-----------------------------------------------------
case 1: // Variance-covariance matrix: Center the column vectors.
case 2: // Sums-of-squares-and-cross-products matrix
for(i=0; i<m_pTable->Get_Count() && Set_Progress(i, m_pTable->Get_Count()); i++)
{
if( !is_NoData(i) )
{
for(j1=0; j1<m_nFeatures; j1++)
{
for(j2=j1; j2<m_nFeatures; j2++)
{
Matrix[j1][j2] += Get_Value(j1, i) * Get_Value(j2, i);
}
}
}
}
break;
}
//-----------------------------------------------------
for(j1=0; j1<m_nFeatures; j1++)
{
for(j2=j1; j2<m_nFeatures; j2++)
{
Matrix[j2][j1] = Matrix[j1][j2];
}
}
return( true );
}
