//---------------------------------------------------------
bool CGrid_Division::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pA = Parameters("A")->asGrid();
CSG_Grid *pB = Parameters("B")->asGrid();
CSG_Grid *pC = Parameters("C")->asGrid();
DataObject_Set_Colors(pC, 11, SG_COLORS_RED_GREY_BLUE);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pA->is_NoData(x, y) || pB->is_NoData(x, y) || pB->asDouble(x, y) == 0.0 )
{
pC->Set_NoData(x, y);
}
else
{
pC->Set_Value(x, y, pA->asDouble(x, y) / pB->asDouble(x, y));
}
}
}
//-----------------------------------------------------
return( true );
}
bool CGrid_Aggregate::On_Execute(void)
{
int x,y;
int x2,y2;
int i,j;
int iNX, iNY;
int iSize = Parameters("SIZE")->asInt();
int iMethod = Parameters("METHOD")->asInt();
double dMin,dMax;
double dSum;
double dValue;
iNX = (int) (Get_NX() / iSize);
iNY = (int) (Get_NY() / iSize);
CSG_Grid *pGrid = Parameters("INPUT")->asGrid();
CSG_Grid *pOutput = SG_Create_Grid(pGrid->Get_Type(), iNX, iNY, pGrid->Get_Cellsize() * iSize,
pGrid->Get_XMin(), pGrid->Get_YMin());
pOutput->Set_Name(pGrid->Get_Name());
for (y = 0, y2 = 0; y2 < iNY; y+=iSize, y2++){
for (x = 0, x2 = 0; x2 < iNX; x+=iSize, x2++){
dMax = dMin = pGrid->asDouble(x,y);
dSum = 0;
for (i = 0; i < iSize; i++){
for (j = 0; j < iSize; j++){
dValue = pGrid->asDouble(x+i,y+j);
if (dValue > dMax){
dMax = dValue;
}//if
if (dValue < dMin){
dMin = dValue;
}//if
dSum += dValue;
}//for
}//for
switch (iMethod){
case SUM:
pOutput->Set_Value(x2,y2,dSum);
break;
case MIN:
pOutput->Set_Value(x2,y2,dMin);
break;
case MAX:
pOutput->Set_Value(x2,y2,dMax);
break;
default:
break;
}
}//for
}//for
DataObject_Add(pOutput);
return true;
}
//---------------------------------------------------------
bool CPanSharp_Brovey::On_Execute(void)
{
//-----------------------------------------------------
TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt());
//-----------------------------------------------------
CSG_Grid *pPan = Parameters("PAN")->asGrid();
//-----------------------------------------------------
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("R")->asGrid()->Get_Name());
CSG_Grid *pR = Parameters("R_SHARP")->asGrid();
pR->Assign (Parameters("R")->asGrid(), Resampling);
pR->Set_Name(Parameters("R")->asGrid()->Get_Name());
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("G")->asGrid()->Get_Name());
CSG_Grid *pG = Parameters("G_SHARP")->asGrid();
pG->Assign (Parameters("G")->asGrid(), Resampling);
pG->Set_Name(Parameters("G")->asGrid()->Get_Name());
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("B")->asGrid()->Get_Name());
CSG_Grid *pB = Parameters("B_SHARP")->asGrid();
pB->Assign (Parameters("B")->asGrid(), Resampling);
pB->Set_Name(Parameters("B")->asGrid()->Get_Name());
//-----------------------------------------------------
Process_Set_Text(_TL("Sharpening"));
for(int y=0; y<pPan->Get_NY() && Set_Progress(y, pPan->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<pPan->Get_NX(); x++)
{
if( !pPan->is_NoData(x, y) && !pR->is_NoData(x, y) && !pG->is_NoData(x, y) && !pB->is_NoData(x, y) )
{
double k = (pR->asDouble(x, y) + pG->asDouble(x, y) + pB->asDouble(x, y));
if( k != 0.0 )
{
k = pPan->asDouble(x, y) / k;
}
pR->Mul_Value(x, y, k);
pG->Mul_Value(x, y, k);
pB->Mul_Value(x, y, k);
}
else
{
pR->Set_NoData(x, y);
pG->Set_NoData(x, y);
pB->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
CSG_String CPresence_Prediction::Get_Feature(int x, int y, int i)
{
CSG_Grid *pFeature = m_Features[i].pGrid;
if( m_nNumClasses > 1 && m_Features[i].bNumeric )
{
return( CSG_String::Format("%d", (int)(m_nNumClasses * (pFeature->asDouble(x, y) - pFeature->Get_Min()) / pFeature->Get_Range())) );
}
return( SG_Get_String(pFeature->asDouble(x, y), -2) );
}
//---------------------------------------------------------
bool CGrid_Volume::On_Execute(void)
{
int x, y, Method;
double Level, Volume, z;
CSG_Grid *pGrid;
CSG_String s;
//-----------------------------------------------------
pGrid = Parameters("GRID") ->asGrid();
Level = Parameters("LEVEL") ->asDouble();
Method = Parameters("METHOD") ->asInt();
//-----------------------------------------------------
for(y=0, Volume=0.0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !pGrid->is_NoData(x, y) )
{
z = pGrid->asDouble(x, y) - Level;
switch( Method )
{
case 0: // Count Only Above Base Level
if( z > 0.0 )
{
Volume += z;
}
break;
case 1: // Count Only Below Base Level
if( z < 0.0 )
{
Volume -= z;
}
break;
case 2: // Subtract Volumes Below Base Level
Volume += z;
break;
case 3: // Add Volumes Below Base Level
Volume += fabs(z);
break;
}
}
}
}
//-----------------------------------------------------
Volume *= pGrid->Get_Cellarea();
s.Printf(_TL("Volume: %f"), Volume);
Message_Add(s);
Message_Dlg(s, _TL("Grid Volume"));
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
double CGridding_Spline_MBA::BA_Get_Value(double x, double y, CSG_Grid &Phi)
{
int _x, _y, ix, iy;
double z = 0.0, bx[4], by;
if( (_x = (int)x) >= 0 && _x < Phi.Get_NX() - 3
&& (_y = (int)y) >= 0 && _y < Phi.Get_NY() - 3 )
{
x -= _x;
y -= _y;
for(ix=0; ix<4; ix++)
{
bx[ix] = BA_Get_B(ix, x);
}
for(iy=0; iy<4; iy++)
{
by = BA_Get_B(iy, y);
for(ix=0; ix<4; ix++)
{
z += by * bx[ix] * Phi.asDouble(_x + ix, _y + iy);
}
}
}
return( z );
}
//---------------------------------------------------------
void CHillslope_Evolution_FTCS::Set_Difference(void)
{
CSG_Grid *pDiff = Parameters("DIFF")->asGrid();
if( pDiff )
{
CSG_Grid *pDEM = Parameters("DEM")->asGrid();
#pragma omp parallel for
for(int i=0; i<Get_NCells(); i++)
{
if( pDEM->is_NoData(i) )
{
pDiff->Set_NoData(i);
}
else
{
pDiff->Set_Value(i, m_pDEM->asDouble(i) - pDEM->asDouble(i));
}
}
if( Parameters("UPDATE")->asBool() )
{
DataObject_Update(pDiff, SG_UI_DATAOBJECT_SHOW);
}
}
}
//---------------------------------------------------------
bool CFilter_Resample::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pGrid = Parameters("GRID" )->asGrid();
CSG_Grid *pLoPass = Parameters("LOPASS")->asGrid();
CSG_Grid *pHiPass = Parameters("HIPASS")->asGrid();
double Cellsize = Parameters("SCALE" )->asDouble() * Get_Cellsize();
//-----------------------------------------------------
if( Cellsize > 0.5 * SG_Get_Length(Get_System().Get_XRange(), Get_System().Get_YRange()) )
{
Error_Set(_TL("resampling cell size is too large"));
return( false );
}
//-----------------------------------------------------
CSG_Grid Grid(CSG_Grid_System(Cellsize, Get_XMin(), Get_YMin(), Get_XMax(), Get_YMax()), SG_DATATYPE_Float);
Grid.Assign(pGrid, GRID_RESAMPLING_Mean_Cells);
//-----------------------------------------------------
pLoPass->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("Low Pass" ));
pHiPass->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("High Pass"));
CSG_Colors Colors;
DataObject_Get_Colors(pGrid , Colors);
DataObject_Set_Colors(pLoPass, Colors);
DataObject_Set_Colors(pHiPass, 11, SG_COLORS_RED_GREY_BLUE);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
double py = Get_YMin() + y * Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double z, px = Get_XMin() + x * Get_Cellsize();
if( !pGrid->is_NoData(x, y) && Grid.Get_Value(px, py, z) )
{
pLoPass->Set_Value(x, y, z);
pHiPass->Set_Value(x, y, pGrid->asDouble(x, y) - z);
}
else
{
pLoPass->Set_NoData(x, y);
pHiPass->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
return( true );
}
bool CImage_VI_Slope::On_Execute(void){
double dRed, dNIR;
CSG_Grid* pNIR = Parameters("NIR")->asGrid();
CSG_Grid* pRed = Parameters("RED")->asGrid();
CSG_Grid* pNDVI = Parameters("NDVI")->asGrid();
CSG_Grid* pRatio = Parameters("RATIO")->asGrid();
CSG_Grid* pTVI = Parameters("TVI")->asGrid();
CSG_Grid* pTTVI = Parameters("TTVI")->asGrid();
CSG_Grid* pCTVI = Parameters("CTVI")->asGrid();
CSG_Grid* pNRatio = Parameters("NRATIO")->asGrid();
for(int y=0; y<Get_NY() && Set_Progress(y); y++){
for(int x=0; x<Get_NX(); x++){
dNIR = pNIR->asDouble(x,y);
dRed = pRed->asDouble(x,y);
pNDVI->Set_Value(x,y,getNDVI(dRed, dNIR));
if (pRatio){
if (dRed!=0){
pRatio->Set_Value(x,y,getRatio(dRed,dNIR));
}//if
else{
pRatio->Set_Value(x,y,pRatio->Get_NoData_Value());
}//else
}//if
if (pTVI){
pTVI->Set_Value(x,y,getTVI(dRed,dNIR,pTVI));
}//if
if (pCTVI){
pCTVI->Set_Value(x,y,getCTVI(dRed,dNIR));
}//if
if (pTTVI){
pTTVI->Set_Value(x,y,getTTVI(dRed,dNIR));
}//if
if (pNRatio){
pNRatio->Set_Value(x,y,getNRatio(dRed,dNIR));
}//if
}// for
}// for
return true;
}//method
//---------------------------------------------------------
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 CDiffuse_Pollution_Risk::Set_Flow(void)
{
Process_Set_Text(_TL("initialization"));
CSG_Grid *pWeight = Parameters("WEIGHT")->asGrid ();
double Weight = Parameters("WEIGHT")->asDouble();
CSG_Grid *pRain = Parameters("RAIN" )->asGrid ();
double Rain = Parameters("RAIN" )->asDouble();
m_FlowDir.Create(*Get_System(), SG_DATATYPE_Char);
m_RainAcc.Create(*Get_System());
m_TWI .Create(*Get_System());
for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++)
{
int x, y;
if( !m_pDEM->Get_Sorted(n, x, y, true) || (pRain && pRain->is_NoData(x, y)) || !Set_Flow(x, y, pRain ? pRain->asDouble(x, y) : Rain) )
{
m_FlowDir .Set_NoData(x, y);
m_RainAcc .Set_NoData(x, y);
m_TWI .Set_NoData(x, y);
m_pRisk_Point->Set_NoData(x, y);
}
else
{
double s, a;
m_pDEM->Get_Gradient(x, y, s, a);
s = tan(s); // tangens of slope
a = (fabs(sin(a)) + fabs(cos(a))) * Get_Cellsize(); // flow width
double SCA = m_RainAcc.asDouble(x, y) / a; // rain * specific catchment area
m_TWI.Set_Value(x, y, log(SCA / (s < M_ALMOST_ZERO ? M_ALMOST_ZERO : s)));
if( pWeight && pWeight->is_NoData(x, y) )
{
m_pRisk_Point->Set_NoData(x, y);
}
else
{
m_pRisk_Point->Set_Value(x, y, SCA * s * (pWeight ? pWeight->asDouble(x, y) : Weight)); // Point Scale Risk Calculation according to Milledge et al. 2012
}
}
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Classify_Supervised::Get_Features(int x, int y, CSG_Vector &Features)
{
for(int i=0; i<m_pFeatures->Get_Count(); i++)
{
CSG_Grid *pGrid = m_pFeatures->asGrid(i);
if( pGrid->is_NoData(x, y) )
{
return( false );
}
Features[i] = m_bNormalise ? (pGrid->asDouble(x, y) - pGrid->Get_Mean()) / pGrid->Get_StdDev() : pGrid->asDouble(x, y);
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Normalise::On_Execute(void)
{
CSG_Grid *pGrid = Parameters("INPUT")->asGrid();
if( pGrid->Get_StdDev() <= 0.0 )
{
return( false );
}
if( pGrid != Parameters("OUTPUT")->asGrid() )
{
pGrid = Parameters("OUTPUT")->asGrid();
pGrid ->Assign(Parameters("INPUT")->asGrid());
}
pGrid->Fmt_Name("%s (%s)", pGrid->Get_Name(), _TL("Normalized"));
//-----------------------------------------------------
double Minimum, Maximum, Offset, Scale;
Minimum = Parameters("RANGE")->asRange()->Get_Min();
Maximum = Parameters("RANGE")->asRange()->Get_Max();
Offset = pGrid->Get_Min();
Scale = (Maximum - Minimum) / pGrid->Get_Range();
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( !pGrid->is_NoData(x, y) )
{
pGrid->Set_Value(x, y, Minimum + Scale * (pGrid->asDouble(x, y) - Offset));
}
}
}
//-----------------------------------------------------
if( pGrid == Parameters("INPUT")->asGrid() )
{
DataObject_Update(pGrid);
}
return( true );
}
//---------------------------------------------------------
bool CCellBalance::On_Execute(void)
{
int x, y, Method;
double Weight;
CSG_Grid *pWeights;
m_pDEM = Parameters("DEM") ->asGrid();
pWeights = Parameters("WEIGHTS") ->asGrid();
m_pBalance = Parameters("BALANCE") ->asGrid();
Weight = Parameters("WEIGHT") ->asDouble();
Method = Parameters("METHOD") ->asInt();
m_pBalance->Assign(0.0);
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( m_pDEM->is_NoData(x, y) )
{
m_pBalance->Set_NoData (x, y);
}
else
{
if( pWeights )
{
Weight = pWeights->is_NoData(x, y) ? 0.0 : pWeights->asDouble(x, y);
}
m_pBalance->Add_Value (x, y, -Weight);
switch( Method )
{
case 0: Set_D8 (x, y, Weight); break;
case 1: Set_MFD (x, y, Weight); break;
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Standardise::On_Execute(void)
{
CSG_Grid *pGrid = Parameters("INPUT")->asGrid();
if( pGrid->Get_StdDev() <= 0.0 )
{
return( false );
}
if( pGrid != Parameters("OUTPUT")->asGrid() )
{
pGrid = Parameters("OUTPUT")->asGrid();
pGrid ->Assign(Parameters("INPUT")->asGrid());
}
pGrid->Fmt_Name("%s (%s)", pGrid->Get_Name(), _TL("Standard Score"));
//-----------------------------------------------------
double Mean = pGrid->Get_Mean();
double Stretch = Parameters("STRETCH")->asDouble() / pGrid->Get_StdDev();
for(int y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( !pGrid->is_NoData(x, y) )
{
pGrid->Set_Value(x, y, Stretch * (pGrid->asDouble(x, y) - Mean));
}
}
}
//-----------------------------------------------------
if( pGrid == Parameters("INPUT")->asGrid() )
{
DataObject_Update(pGrid);
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Invert::On_Execute(void)
{
CSG_Grid *pGrid = Parameters("INVERSE")->asGrid();
if( pGrid == NULL )
{
pGrid = Parameters("GRID")->asGrid();
}
else if( pGrid != Parameters("GRID")->asGrid() )
{
pGrid->Create(*Parameters("GRID")->asGrid());
pGrid->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("Inverse"));
}
//-----------------------------------------------------
double zMin = pGrid->Get_Min();
double zMax = pGrid->Get_Max();
for(int y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( !pGrid->is_NoData(x, y) )
{
pGrid->Set_Value(x, y, zMax - (pGrid->asDouble(x, y) - zMin));
}
}
}
//-----------------------------------------------------
if( pGrid == Parameters("GRID")->asGrid() )
{
DataObject_Update(pGrid);
}
return( true );
}
//---------------------------------------------------------
bool CGrid_To_Points_Random::On_Execute(void)
{
int x, y, n;
double frequency;
CSG_Grid *pGrid;
CSG_Shape *pShape;
CSG_Shapes *pShapes;
pGrid = Parameters("GRID")->asGrid();
frequency = 1.0 / Parameters("FREQ")->asDouble();
pShapes = Parameters("POINTS")->asShapes();
pShapes->Create(SHAPE_TYPE_Point, pGrid->Get_Name());
pShapes->Add_Field("ID" , SG_DATATYPE_Int);
pShapes->Add_Field("VALUE" , SG_DATATYPE_Double);
srand((unsigned)time(NULL));
for(n=0, y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( (double)rand() / (double)RAND_MAX <= frequency )
{
pShape = pShapes->Add_Shape();
pShape->Add_Point(
pGrid->Get_XMin() + x * Get_Cellsize(),
pGrid->Get_YMin() + y * Get_Cellsize()
);
pShape->Set_Value(0, ++n);
pShape->Set_Value(1, pGrid->asDouble(x, y));
}
}
}
return( true );
}
//---------------------------------------------------------
bool CPanSharp_CN::On_Execute(void)
{
//-----------------------------------------------------
TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt());
//-----------------------------------------------------
int i;
CSG_Grid *pPan = Parameters("PAN")->asGrid();
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS" )->asGridList();
CSG_Parameter_Grid_List *pSharp = Parameters("SHARPEN")->asGridList();
//-----------------------------------------------------
pSharp->Del_Items();
for(i=0; i<pGrids->Get_Grid_Count(); i++)
{
Process_Set_Text("%s: %s ...", _TL("Resampling"), pGrids->Get_Grid(i)->Get_Name());
CSG_Grid *pGrid = SG_Create_Grid(Get_System());
pGrid->Set_Name (pGrids->Get_Grid(i)->Get_Name());
pGrid->Assign (pGrids->Get_Grid(i), Resampling);
pSharp->Add_Item(pGrid);
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for private(i)
for(int x=0; x<Get_NX(); x++)
{
double Sum = 0.0;
if( !pPan->is_NoData(x, y) )
{
for(i=0; i<pSharp->Get_Grid_Count(); i++)
{
if( !pSharp->Get_Grid(i)->is_NoData(x, y) )
{
Sum += pSharp->Get_Grid(i)->asDouble(x, y);
}
else
{
Sum = 0.0;
break;
}
}
}
if( Sum )
{
Sum = pPan->asDouble(x, y) * pSharp->Get_Grid_Count() / (Sum + pSharp->Get_Grid_Count());
for(i=0; i<pSharp->Get_Grid_Count(); i++)
{
pSharp->Get_Grid(i)->Mul_Value(x, y, Sum);
}
}
else
{
for(i=0; i<pSharp->Get_Grid_Count(); i++)
{
pSharp->Get_Grid(i)->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPanSharp_IHS::On_Execute(void)
{
//-----------------------------------------------------
TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt());
//-----------------------------------------------------
int y;
CSG_Grid *pPan = Parameters("PAN")->asGrid();
//-----------------------------------------------------
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("R")->asGrid()->Get_Name());
CSG_Grid *pR = Parameters("R_SHARP")->asGrid();
pR->Assign (Parameters("R")->asGrid(), Resampling);
pR->Set_Name(Parameters("R")->asGrid()->Get_Name());
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("G")->asGrid()->Get_Name());
CSG_Grid *pG = Parameters("G_SHARP")->asGrid();
pG->Assign (Parameters("G")->asGrid(), Resampling);
pG->Set_Name(Parameters("G")->asGrid()->Get_Name());
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("B")->asGrid()->Get_Name());
CSG_Grid *pB = Parameters("B_SHARP")->asGrid();
pB->Assign (Parameters("B")->asGrid(), Resampling);
pB->Set_Name(Parameters("B")->asGrid()->Get_Name());
//-----------------------------------------------------
Process_Set_Text(_TL("RGB to IHS"));
double rMin = pR->Get_Min(), rRange = pR->Get_Range();
double gMin = pG->Get_Min(), gRange = pG->Get_Range();
double bMin = pB->Get_Min(), bRange = pB->Get_Range();
for(y=0; y<pPan->Get_NY() && Set_Progress(y, pPan->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<pPan->Get_NX(); x++)
{
bool bNoData = true;
if( pPan->is_NoData(x, y) || pR->is_NoData(x, y) || pG->is_NoData(x, y) || pB->is_NoData(x, y) )
{
pR->Set_NoData(x, y);
pG->Set_NoData(x, y);
pB->Set_NoData(x, y);
}
else
{
double r = (pR->asDouble(x, y) - rMin) / rRange; if( r < 0.0 ) r = 0.0; else if( r > 1.0 ) r = 1.0;
double g = (pG->asDouble(x, y) - gMin) / gRange; if( g < 0.0 ) g = 0.0; else if( g > 1.0 ) g = 1.0;
double b = (pB->asDouble(x, y) - bMin) / bRange; if( b < 0.0 ) b = 0.0; else if( b > 1.0 ) b = 1.0;
double h, s, i = r + g + b;
if( i <= 0.0 )
{
h = 0.0;
s = 0.0;
}
else
{
if( r == g && g == b ) { h = 0.0; }
else if( b < r && b < g ) { h = (g - b) / (i - 3 * b) ; }
else if( r < g && r < b ) { h = (b - r) / (i - 3 * r) + 1; }
else { h = (r - g) / (i - 3 * g) + 2; }
if ( 0.0 <= h && h < 1.0 ) { s = (i - 3 * b) / i; }
else if( 1.0 <= h && h < 2.0 ) { s = (i - 3 * r) / i; }
else { s = (i - 3 * g) / i; }
}
pR->Set_Value(x, y, i);
pG->Set_Value(x, y, s);
pB->Set_Value(x, y, h);
}
}
}
//-----------------------------------------------------
double Offset_Pan, Offset, Scale;
if( Parameters("PAN_MATCH")->asInt() == 0 )
{
Offset_Pan = pPan->Get_Min();
Offset = pR->Get_Min();
Scale = pR->Get_Range() / pPan->Get_Range();
}
else
{
Offset_Pan = pPan->Get_Mean();
Offset = pR->Get_Mean();
Scale = pR->Get_StdDev() / pPan->Get_StdDev();
}
//-----------------------------------------------------
Process_Set_Text(_TL("IHS to RGB"));
for(y=0; y<pPan->Get_NY() && Set_Progress(y, pPan->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<pPan->Get_NX(); x++)
{
if( !pR->is_NoData(x, y) )
{
double i = Offset + Scale * (pPan->asDouble(x, y) - Offset_Pan);
double s = pG ->asDouble(x, y);
double h = pB ->asDouble(x, y);
double r, g, b;
if ( 0.0 <= h && h < 1.0 )
{
r = i * (1 + 2 * s - 3 * s * h) / 3;
g = i * (1 - s + 3 * s * h) / 3;
b = i * (1 - s ) / 3;
}
else if( 1.0 <= h && h < 2.0 )
{
r = i * (1 - s ) / 3;
g = i * (1 + 2 * s - 3 * s * (h - 1)) / 3;
b = i * (1 - s + 3 * s * (h - 1)) / 3;
}
else
{
r = i * (1 - s + 3 * s * (h - 2)) / 3;
g = i * (1 - s ) / 3;
b = i * (1 + 2 * s - 3 * s * (h - 2)) / 3;
}
pR->Set_Value(x, y, rMin + r * rRange);
pG->Set_Value(x, y, gMin + g * gRange);
pB->Set_Value(x, y, bMin + b * bRange);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSet_Grid_Georeference::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
if( pGrids->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
double xMin, yMin, size;
switch( Parameters("DEFINITION")->asInt() )
{
case 0: // cellsize and lower left center coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMIN")->asDouble();
break;
case 1: // cellsize and lower left corner coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMIN")->asDouble() + size * 0.5;
break;
case 2: // cellsize and upper left center coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMAX")->asDouble() - size * Get_NY();
break;
case 3: // cellsize and upper left corner coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMAX")->asDouble() - size * (0.5 + Get_NY());
break;
case 4: // lower left and upper right center coordinates
size = (Parameters("XMAX")->asDouble() - Parameters("XMIN")->asDouble()) / Get_NX();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMIN")->asDouble();
break;
case 5: // lower left and upper right corner coordinates
size = (Parameters("XMAX")->asDouble() - Parameters("XMIN")->asDouble()) / (Get_NX() + 1);
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMIN")->asDouble() + size * 0.5;
break;
}
//-----------------------------------------------------
CSG_Grid_System System;
if( !System.Assign(size, xMin, yMin, Get_NX(), Get_NY()) )
{
return( false );
}
//-----------------------------------------------------
Parameters("REFERENCED")->asGridList()->Del_Items();
for(int i=0; i<pGrids->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Grid *pGrid = pGrids->asGrid(i);
CSG_Grid *pReferenced = SG_Create_Grid(System, pGrid->Get_Type());
pReferenced->Set_Name(pGrid->Get_Name());
pReferenced->Set_Unit(pGrid->Get_Unit());
pReferenced->Set_Scaling(pGrid->Get_Scaling(), pGrid->Get_Offset());
pReferenced->Set_NoData_Value_Range(pGrid->Get_NoData_Value(), pGrid->Get_NoData_hiValue());
pReferenced->Get_MetaData () = pGrid->Get_MetaData ();
pReferenced->Get_Projection() = pGrid->Get_Projection();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
pReferenced->Set_Value(x, y, pGrid->asDouble(x, y));
}
}
Parameters("REFERENCED")->asGridList()->Add_Item(pReferenced);
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGrid_Merge::On_Execute(void)
{
//-----------------------------------------------------
if( !Initialize() )
{
return( false );
}
//-----------------------------------------------------
for(int i=0; i<m_pGrids->Get_Count(); i++)
{
CSG_Grid *pGrid = m_pGrids->asGrid(i);
Set_Weight(pGrid);
Get_Match(i > 0 ? pGrid : NULL);
int ax = (int)((pGrid->Get_XMin() - m_pMosaic->Get_XMin()) / m_pMosaic->Get_Cellsize());
int ay = (int)((pGrid->Get_YMin() - m_pMosaic->Get_YMin()) / m_pMosaic->Get_Cellsize());
//-------------------------------------------------
if( is_Aligned(pGrid) )
{
Process_Set_Text(CSG_String::Format("[%d/%d] %s: %s", i + 1, m_pGrids->Get_Count(), _TL("copying"), pGrid->Get_Name()));
int nx = pGrid->Get_NX(); if( nx > m_pMosaic->Get_NX() - ax ) nx = m_pMosaic->Get_NX() - ax;
int ny = pGrid->Get_NY(); if( ny > m_pMosaic->Get_NY() - ay ) ny = m_pMosaic->Get_NY() - ay;
for(int y=0; y<ny && Set_Progress(y, ny); y++)
{
if( ay + y >= 0 )
{
#pragma omp parallel for
for(int x=0; x<nx; x++)
{
if( ax + x >= 0 && !pGrid->is_NoData(x, y) )
{
Set_Value(ax + x, ay + y, pGrid->asDouble(x, y), Get_Weight(x, y));
}
}
}
}
}
//-------------------------------------------------
else
{
Process_Set_Text(CSG_String::Format("[%d/%d] %s: %s", i + 1, m_pGrids->Get_Count(), _TL("resampling"), pGrid->Get_Name()));
if( ax < 0 ) ax = 0;
if( ay < 0 ) ay = 0;
int nx = 1 + m_pMosaic->Get_System().Get_xWorld_to_Grid(pGrid->Get_XMax()); if( nx > m_pMosaic->Get_NX() ) nx = m_pMosaic->Get_NX();
int ny = 1 + m_pMosaic->Get_System().Get_yWorld_to_Grid(pGrid->Get_YMax()); if( ny > m_pMosaic->Get_NY() ) ny = m_pMosaic->Get_NY();
for(int y=ay; y<ny && Set_Progress(y-ay, ny-ay); y++)
{
double py = m_pMosaic->Get_YMin() + y * m_pMosaic->Get_Cellsize();
#pragma omp parallel for
for(int x=ax; x<nx; x++)
{
double px = m_pMosaic->Get_XMin() + x * m_pMosaic->Get_Cellsize();
Set_Value(x, y, pGrid, px, py);
}
}
}
}
//-----------------------------------------------------
if( m_Overlap == 4 ) // mean
{
for(int y=0; y<m_pMosaic->Get_NY() && Set_Progress(y, m_pMosaic->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<m_pMosaic->Get_NX(); x++)
{
double w = m_Weights.asDouble(x, y);
if( w > 0.0 )
{
m_pMosaic->Mul_Value(x, y, 1.0 / w);
}
}
}
}
//-----------------------------------------------------
m_Weight .Destroy();
m_Weights.Destroy();
return( true );
}
//---------------------------------------------------------
bool CGridsFromTableAndGrid::On_Execute(void)
{
int iField, iRecord, iAttribute, nAttributes, *Attribute;
sLong iCell, jCell;
CSG_Parameter_Grid_List *pGrids;
CSG_Grid *pClasses;
CSG_Table *pTable;
//-----------------------------------------------------
pClasses = Parameters("CLASSES" )->asGrid();
pGrids = Parameters("GRIDS" )->asGridList();
pTable = Parameters("TABLE" )->asTable();
iField = Parameters("ID_FIELD")->asInt();
pGrids->Del_Items();
if( !pClasses->Set_Index() )
{
Error_Set(_TL("index creation failed"));
return( false );
}
//-----------------------------------------------------
if( pTable->Get_Field_Count() == 0 || pTable->Get_Count() == 0 )
{
Message_Add(_TL("selected table contains no valid records"));
return( false );
}
//-----------------------------------------------------
if( !pTable->Set_Index(iField, TABLE_INDEX_Ascending) )
{
Message_Add(_TL("failed to create index for table"));
return( false );
}
//-----------------------------------------------------
Attribute = new int[pTable->Get_Field_Count()];
for(iAttribute=0, nAttributes=0; iAttribute<pTable->Get_Field_Count(); iAttribute++)
{
if( iAttribute != iField && pTable->Get_Field_Type(iAttribute) != SG_DATATYPE_String )
{
Attribute[nAttributes++] = iAttribute;
CSG_Grid *pGrid = SG_Create_Grid(*Get_System());
pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pClasses->Get_Name(), pTable->Get_Field_Name(iAttribute)));
pGrids->Add_Item(pGrid);
}
}
if( nAttributes == 0 )
{
delete[](Attribute);
Message_Add(_TL("selected table does not have numeric attributes"));
return( false );
}
//-----------------------------------------------------
CSG_Table_Record *pRecord = pTable->Get_Record_byIndex(0);
for(iCell=0, iRecord=0; iCell<Get_NCells() && pRecord && Set_Progress_NCells(iCell); iCell++)
{
if( pClasses->Get_Sorted(iCell, jCell, false, true) )
{
double valClass = pClasses->asDouble(jCell);
while( pRecord && pRecord->asDouble(iField) < valClass )
{
pRecord = pTable->Get_Record_byIndex(++iRecord);
}
if( !pRecord || pRecord->asDouble(iField) > valClass )
{
for(iAttribute=0; iAttribute<nAttributes; iAttribute++)
{
pGrids->asGrid(iAttribute)->Set_NoData(jCell);
}
}
else
{
for(iAttribute=0; iAttribute<nAttributes; iAttribute++)
{
pGrids->asGrid(iAttribute)->Set_Value(jCell, pRecord->asDouble(Attribute[iAttribute]));
}
}
}
}
//-----------------------------------------------------
delete[](Attribute);
return true;
}
//---------------------------------------------------------
bool CGrid_Mirror::On_Execute(void)
{
CSG_Grid *pGrid = Parameters("MIRROR")->asGrid();
if( pGrid == NULL )
{
pGrid = Parameters("GRID")->asGrid();
}
else if( pGrid != Parameters("GRID")->asGrid() )
{
pGrid->Create(*Parameters("GRID")->asGrid());
pGrid->Fmt_Name("%s [%s %s]", pGrid->Get_Name(), _TL("mirrored"), Parameters("METHOD")->asString());
}
//-----------------------------------------------------
switch( Parameters("METHOD")->asInt() )
{
//-----------------------------------------------------
case 0: // vertically
{
for(int xa=0, xb=Get_NX()-1; xa<xb && SG_UI_Process_Set_Progress(xa, Get_NX()/2); xa++, xb--)
{
#pragma omp parallel for
for(int y=0; y<Get_NY(); y++)
{
double d = pGrid->asDouble(xa, y);
pGrid->Set_Value(xa, y, pGrid->asDouble(xb, y));
pGrid->Set_Value(xb, y, d);
}
}
}
break;
//-----------------------------------------------------
case 1: // horizontally
{
for(int ya=0, yb=Get_NY()-1; ya<yb && SG_UI_Process_Set_Progress(ya, Get_NY()/2); ya++, yb--)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double d = pGrid->asDouble(x, ya);
pGrid->Set_Value(x, ya, pGrid->asDouble(x, yb));
pGrid->Set_Value(x, yb, d);
}
}
}
break;
//-----------------------------------------------------
default: // both
{
for(int ya=0, yb=Get_NY()-1; ya<=yb && SG_UI_Process_Set_Progress(ya, Get_NY()/2); ya++, yb--)
{
for(int xa=0, xb=Get_NX()-1; xa<=xb; xa++, xb--)
{
if( ya < yb && xa < xb )
{
double d = pGrid->asDouble(xa, ya);
pGrid->Set_Value(xa, ya, pGrid->asDouble(xb, yb));
pGrid->Set_Value(xb, yb, d);
d = pGrid->asDouble(xa, yb);
pGrid->Set_Value(xa, yb, pGrid->asDouble(xb, ya));
pGrid->Set_Value(xb, ya, d);
}
else if( xa < xb )
{
double d = pGrid->asDouble(xa, ya);
pGrid->Set_Value(xa, ya, pGrid->asDouble(xb, ya));
pGrid->Set_Value(xb, ya, d);
}
else if( ya < yb )
{
double d = pGrid->asDouble(xa, ya);
pGrid->Set_Value(xa, ya, pGrid->asDouble(xa, yb));
pGrid->Set_Value(xa, yb, d);
}
}
}
}
break;
}
//-----------------------------------------------------
if( pGrid == Parameters("GRID")->asGrid() )
{
DataObject_Update(pGrid);
}
return( true );
}
//---------------------------------------------------------
bool CGrid_RGB_Composite::On_Execute(void)
{
double rMin, rRange, gMin, gRange, bMin, bRange, aMin, aRange;
//-----------------------------------------------------
CSG_Grid *pR = _Get_Grid(Parameters("R_GRID")->asGrid(), Parameters("R_METHOD")->asInt(), Parameters("R_RANGE")->asRange(), Parameters("R_PERCTL")->asRange(), Parameters("R_STDDEV")->asDouble(), rMin, rRange);
CSG_Grid *pG = _Get_Grid(Parameters("G_GRID")->asGrid(), Parameters("G_METHOD")->asInt(), Parameters("G_RANGE")->asRange(), Parameters("G_PERCTL")->asRange(), Parameters("G_STDDEV")->asDouble(), gMin, gRange);
CSG_Grid *pB = _Get_Grid(Parameters("B_GRID")->asGrid(), Parameters("B_METHOD")->asInt(), Parameters("B_RANGE")->asRange(), Parameters("B_PERCTL")->asRange(), Parameters("B_STDDEV")->asDouble(), bMin, bRange);
CSG_Grid *pA = _Get_Grid(Parameters("A_GRID")->asGrid(), Parameters("A_METHOD")->asInt(), Parameters("A_RANGE")->asRange(), Parameters("A_PERCTL")->asRange(), Parameters("A_STDDEV")->asDouble(), aMin, aRange);
//-----------------------------------------------------
CSG_Grid *pRGB = Parameters("RGB")->asGrid();
pRGB->Create(pRGB->Get_System(), SG_DATATYPE_Int);
pRGB->Set_Name(_TL("Composite"));
CSG_String s;
s += CSG_String(_TL("Red" )) + ": " + pR->Get_Name() + "\n";
s += CSG_String(_TL("Green")) + ": " + pG->Get_Name() + "\n";
s += CSG_String(_TL("Blue" )) + ": " + pB->Get_Name() + "\n";
if( pA )
{
s += CSG_String(_TL("Alpha")) + ": " + pA->Get_Name() + "\n";
}
pRGB->Set_Description(s);
DataObject_Set_Colors (pRGB, 100, SG_COLORS_BLACK_WHITE);
DataObject_Set_Parameter(pRGB, "COLORS_TYPE", 5); // Color Classification Type: RGB Coded Values
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pR->is_NoData(x, y) || pG->is_NoData(x, y) || pB->is_NoData(x, y) || (pA && pA->is_NoData(x, y)) )
{
pRGB->Set_NoData(x, y);
}
else
{
int r = (int)(rRange * (pR->asDouble(x, y) - rMin)); if( r > 255 ) r = 255; else if( r < 0 ) r = 0;
int g = (int)(gRange * (pG->asDouble(x, y) - gMin)); if( g > 255 ) g = 255; else if( g < 0 ) g = 0;
int b = (int)(bRange * (pB->asDouble(x, y) - bMin)); if( b > 255 ) b = 255; else if( b < 0 ) b = 0;
if( pA )
{
int a = (int)(aRange * (pA->asDouble(x, y) - aMin)); if( a > 255 ) a = 255; else if( a < 0 ) a = 0;
pRGB->Set_Value(x, y, SG_GET_RGBA(r, g, b, a));
}
else
{
pRGB->Set_Value(x, y, SG_GET_RGB (r, g, b));
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CGCS_Grid_Longitude_Range::On_Execute(void)
{
CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList();
CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList();
if( pInput->Get_Count() <= 0 )
{
Message_Dlg(_TL("nothing to do: no data in selection"));
return( false );
}
pOutput->Del_Items();
//-----------------------------------------------------
int xZero;
CSG_Grid_System Target;
//-----------------------------------------------------
if( Parameters("DIRECTION")->asInt() == 0 ) // 0 - 360 >> -180 - 180
{
if( Get_XMax() <= 180.0 )
{
Message_Add(_TL("Nothing to do. Raster is already within target range."));
return( true );
}
else if( Get_XMin() >= 180.0 )
{
xZero = 0;
Target.Assign(Get_Cellsize(), Get_XMin() - 360.0, Get_YMin(), Get_NX(), Get_NY());
}
else if( Get_XMax() - 360.0 < Get_XMin() - Get_Cellsize() )
{
Error_Set(_TL("Nothing to do be done. Raster splitting is not supported."));
return( false );
}
else
{
xZero = (int)(0.5 + 180.0 / Get_Cellsize());
Target.Assign(Get_Cellsize(), Get_XMin() - 180.0, Get_YMin(), Get_NX(), Get_NY());
}
}
//-----------------------------------------------------
else // -180 - 180 >> 0 - 360
{
if( Get_XMin() >= 0.0 )
{
Message_Add(_TL("Nothing to do. Raster is already within target range."));
return( true );
}
else if( Get_XMax() <= 0.0 )
{
xZero = 0;
Target.Assign(Get_Cellsize(), Get_XMin() + 360.0, Get_YMin(), Get_NX(), Get_NY());
}
else if( Get_XMin() + 360.0 > Get_XMax() + Get_Cellsize() )
{
Error_Set(_TL("Nothing to do be done. Raster splitting is not supported."));
return( false );
}
else
{
xZero = (int)(0.5 + 180.0 / Get_Cellsize());
Target.Assign(Get_Cellsize(), Get_XMin() - 180.0, Get_YMin(), Get_NX(), Get_NY());
}
}
//-----------------------------------------------------
for(int i=0; i<pInput->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Grid *pIn = pInput->asGrid(i);
CSG_Grid *pOut = SG_Create_Grid(Target, pIn->Get_Type());
pOut->Set_Name(pIn->Get_Name());
pOut->Set_NoData_Value_Range(pIn->Get_NoData_Value(), pIn->Get_NoData_hiValue());
pOut->Set_ZFactor(pIn->Get_ZFactor());
pOutput->Add_Item(pOut);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0, xx=xZero; x<Get_NX(); x++, xx++)
{
if( xx >= Get_NX() )
{
xx = 0;
}
pOut->Set_Value(xx, y, pIn->asDouble(x, y));
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPanSharp_PCA::On_Execute(void)
{
//-----------------------------------------------------
bool bResult;
CSG_Parameters Tool_Parms;
CSG_Table Eigen;
//-----------------------------------------------------
// get the principal components for the low resolution bands
SG_RUN_TOOL_KEEP_PARMS(bResult, "statistics_grid", 8, Tool_Parms,
SG_TOOL_PARAMETER_SET("GRIDS" , Parameters("GRIDS" ))
&& SG_TOOL_PARAMETER_SET("METHOD" , Parameters("METHOD"))
&& SG_TOOL_PARAMETER_SET("EIGEN" , &Eigen)
&& SG_TOOL_PARAMETER_SET("COMPONENTS", 0) // get all components
);
if( !bResult )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Grid_List *pPCA = Tool_Parms.Get_Parameter("PCA")->asGridList();
int i, n = pPCA->Get_Grid_Count();
CSG_Grid *PCA = new CSG_Grid[n];
CSG_Grid *pPan = Parameters("PAN")->asGrid();
//-----------------------------------------------------
// replace first principal component with the high resolution panchromatic band
Process_Set_Text(_TL("Replace first PC with PAN"));
double Offset_Pan, Offset, Scale;
if( Parameters("PAN_MATCH")->asInt() == 0 ) // scale PAN band to fit first PC histogram
{
Offset_Pan = pPan->Get_Min();
Offset = pPCA->Get_Grid(0)->Get_Min();
Scale = pPCA->Get_Grid(0)->Get_Range() / pPan->Get_Range();
}
else
{
Offset_Pan = pPan->Get_Mean();
Offset = pPCA->Get_Grid(0)->Get_Mean();
Scale = pPCA->Get_Grid(0)->Get_StdDev() / pPan->Get_StdDev();
}
PCA[0].Create(Get_System());
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pPan->is_NoData(x, y) )
{
PCA[0].Set_NoData(x, y);
}
else
{
PCA[0].Set_Value(x, y, Offset + Scale * (pPan->asDouble(x, y) - Offset_Pan));
}
}
}
//-----------------------------------------------------
// resample all other PCs to match the high resolution of the PAN band
TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt());
for(i=1; i<n; i++)
{
Process_Set_Text("%s: %s ...", _TL("Resampling"), pPCA->Get_Grid(i)->Get_Name());
PCA[i].Create(Get_System());
PCA[i].Assign(pPCA->Get_Grid(i), Resampling);
delete(pPCA->Get_Grid(i)); // PCA tool was unmanaged, so we have to delete the output
}
delete(pPCA->Get_Grid(0));
pPCA->Del_Items();
for(i=0; i<n; i++)
{
pPCA->Add_Item(&PCA[i]);
}
//-----------------------------------------------------
// inverse principal component rotation for the high resolution bands
SG_RUN_TOOL_KEEP_PARMS(bResult, "statistics_grid", 10, Tool_Parms,
SG_TOOL_PARAMETER_SET("PCA" , Tool_Parms("PCA"))
&& SG_TOOL_PARAMETER_SET("GRIDS", Parameters("SHARPEN"))
&& SG_TOOL_PARAMETER_SET("EIGEN", &Eigen)
);
delete[](PCA);
if( !bResult )
{
return( false );
}
CSG_Parameter_Grid_List *pHiRes = Parameters("SHARPEN")->asGridList();
CSG_Parameter_Grid_List *pLoRes = Parameters("GRIDS" )->asGridList();
CSG_Parameter_Grid_List *pGrids = Tool_Parms("GRIDS" )->asGridList();
if( !Parameters("OVERWRITE")->asBool() )
{
pHiRes->Del_Items();
}
for(i=0; i<pLoRes->Get_Grid_Count() && i<pGrids->Get_Grid_Count(); i++)
{
if( pHiRes->Get_Grid(i) )
{
pHiRes->Get_Grid(i)->Assign(pGrids->Get_Grid(i));
delete(pGrids->Get_Grid(i));
}
else
{
pHiRes->Add_Item(pGrids->Get_Grid(i));
}
pHiRes->Get_Grid(i)->Set_Name(pLoRes->Get_Grid(i)->Get_Name());
}
return( true );
}
//---------------------------------------------------------
bool CAir_Flow_Height::On_Execute(void)
{
CSG_Grid *pAFH;
//-----------------------------------------------------
m_pDEM = Parameters("DEM" )->asGrid();
pAFH = Parameters("AFH" )->asGrid();
m_maxDistance = Parameters("MAXDIST")->asDouble() * 1000.0;
m_Acceleration = Parameters("ACCEL" )->asDouble();
m_dLee = Parameters("LEE" )->asDouble();
m_dLuv = Parameters("LUV" )->asDouble();
// m_bTrace = Parameters("TRACE" )->asBool();
//-----------------------------------------------------
CSG_Colors Colors(5);
Colors.Set_Color(0, 255, 127, 63);
Colors.Set_Color(1, 255, 255, 127);
Colors.Set_Color(2, 255, 255, 255);
Colors.Set_Color(3, 127, 127, 175);
Colors.Set_Color(4, 0, 0, 100);
DataObject_Set_Colors(pAFH, Colors);
//-----------------------------------------------------
bool bOldVer = false;
if( Parameters("DIR")->asGrid() == NULL )
{
bOldVer = Parameters("OLDVER")->asBool();
m_Dir_Const.x = sin(Parameters("DIR_CONST")->asDouble() * M_DEG_TO_RAD);
m_Dir_Const.y = cos(Parameters("DIR_CONST")->asDouble() * M_DEG_TO_RAD);
if( fabs(m_Dir_Const.x) > fabs(m_Dir_Const.y) )
{
m_Dir_Const.y /= fabs(m_Dir_Const.x);
m_Dir_Const.x = m_Dir_Const.x < 0 ? -1 : 1;
}
else
{
m_Dir_Const.x /= fabs(m_Dir_Const.y);
m_Dir_Const.y = m_Dir_Const.y < 0 ? -1 : 1;
}
}
else
{
if( !m_DX.Create(*Get_System()) || !m_DY.Create(*Get_System()) )
{
Error_Set(_TL("could not allocate sufficient memory"));
return( false );
}
CSG_Grid *pDir = Parameters("DIR")->asGrid();
CSG_Grid *pLen = Parameters("LEN")->asGrid();
double dRadians = Parameters("DIR_UNITS")->asInt() == 0 ? 1.0 : M_DEG_TO_RAD;
double dScale = Parameters("LEN_SCALE")->asDouble();
#pragma omp parallel for
for(int y=0; y<Get_NY(); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( pDir->is_NoData(x, y) )
{
m_DX.Set_NoData(x, y);
}
else
{
double d = pLen ? (!pLen->is_NoData(x, y) ? dScale * pLen->asDouble(x, y) : 0.0) : 1.0;
m_DX.Set_Value(x, y, d * sin(pDir->asDouble(x, y) * dRadians));
m_DY.Set_Value(x, y, d * cos(pDir->asDouble(x, y) * dRadians));
}
}
}
}
if( Parameters("PYRAMIDS")->asBool() && !bOldVer )
{
m_DEM.Create(m_pDEM, 2.0);
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( m_pDEM->is_NoData(x, y) )
{
pAFH->Set_NoData(x, y);
}
else
{
double Luv, Luv_Lee, Lee;
if( bOldVer )
{
Get_Luv_Old(x, y, m_Dir_Const.x, m_Dir_Const.y, Luv);
Get_Lee_Old(x, y, -m_Dir_Const.x, -m_Dir_Const.y, Luv_Lee, Lee);
}
else
{
Get_Luv(x, y, Luv);
Get_Lee(x, y, Luv_Lee, Lee);
}
//-----------------------------------------
double d, z = m_pDEM->asDouble(x, y);
d = 1.0 + (z + Lee != 0.0 ? (z - Lee) / (z + Lee) : 0.0);
d = (Luv > Luv_Lee ? Luv - Luv_Lee : 0.0) + z * d*d / 2.0;
pAFH->Set_Value(x, y, d < 0.0 ? 0.0 : d);
}
}
}
//-----------------------------------------------------
m_DX .Destroy();
m_DY .Destroy();
m_DEM.Destroy();
return( true );
}
//---------------------------------------------------------
bool CGridding_Spline_MBA::BA_Get_Phi(CSG_Grid &Phi)
{
int iPoint, _x, _y, ix, iy;
double x, y, z, dx, dy, wxy, wy, SW2, W[4][4];
CSG_Grid Delta;
//-----------------------------------------------------
Phi .Assign(0.0);
Delta .Create(Phi.Get_System());
//-----------------------------------------------------
for(iPoint=0; iPoint<m_Points.Get_Count() && Set_Progress(iPoint, m_Points.Get_Count()); iPoint++)
{
x = (m_Points[iPoint].x - Phi.Get_XMin()) / Phi.Get_Cellsize();
y = (m_Points[iPoint].y - Phi.Get_YMin()) / Phi.Get_Cellsize();
z = m_Points[iPoint].z;
if( (_x = (int)x) >= 0 && _x < Phi.Get_NX() - 3
&& (_y = (int)y) >= 0 && _y < Phi.Get_NY() - 3 )
{
dx = x - _x;
dy = y - _y;
for(iy=0, SW2=0.0; iy<4; iy++) // compute W[k,l] and Sum[a=0-3, b=0-3](W²[a,b])
{
wy = BA_Get_B(iy, dy);
for(ix=0; ix<4; ix++)
{
wxy = W[iy][ix] = wy * BA_Get_B(ix, dx);
SW2 += wxy*wxy;
}
}
for(iy=0; iy<4; iy++)
{
for(ix=0; ix<4; ix++)
{
wxy = W[iy][ix];
Delta.Add_Value(_x + ix, _y + iy, wxy*wxy * ((wxy * z) / SW2)); // Numerator
Phi .Add_Value(_x + ix, _y + iy, wxy*wxy); // Denominator
}
}
}
}
//-----------------------------------------------------
for(iy=0; iy<Phi.Get_NY(); iy++)
{
for(ix=0; ix<Phi.Get_NX(); ix++)
{
if( (z = Phi.asDouble(ix, iy)) != 0.0 )
{
Phi.Set_Value(ix, iy, Delta.asDouble(ix, iy) / z);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGrid_Value_Type::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pOutput = Parameters("OUTPUT")->asGrid();
CSG_Grid *pInput = Parameters("INPUT" )->asGrid(), Input;
if( pOutput == NULL || pOutput == pInput )
{
Input.Create(*pInput);
pOutput = pInput;
pInput = &Input;
}
//-----------------------------------------------------
double Offset = Parameters("OFFSET")->asDouble();
double Scale = Parameters("SCALE" )->asDouble();
if( Scale == 0.0 )
{
Error_Set(_TL("scale factor must not equal zero"));
return( false );
}
//-----------------------------------------------------
switch( Parameters("TYPE")->asInt() )
{
default:
Error_Set(_TL("undefined data type"));
return( false );
case 0: pOutput->Create(*Get_System(), SG_DATATYPE_Bit ); break;
case 1: pOutput->Create(*Get_System(), SG_DATATYPE_Byte ); break;
case 2: pOutput->Create(*Get_System(), SG_DATATYPE_Char ); break;
case 3: pOutput->Create(*Get_System(), SG_DATATYPE_Word ); break;
case 4: pOutput->Create(*Get_System(), SG_DATATYPE_Short ); break;
case 5: pOutput->Create(*Get_System(), SG_DATATYPE_DWord ); break;
case 6: pOutput->Create(*Get_System(), SG_DATATYPE_Int ); break;
case 7: pOutput->Create(*Get_System(), SG_DATATYPE_Float ); break;
case 8: pOutput->Create(*Get_System(), SG_DATATYPE_Double); break;
}
pOutput->Set_Name (pInput->Get_Name ());
pOutput->Set_Description(pInput->Get_Description());
pOutput->Set_Unit (pInput->Get_Unit ());
pOutput->Set_Scaling (Scale, Offset);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pInput->is_NoData(x, y) )
{
pOutput->Set_NoData(x, y);
}
else
{
pOutput->Set_Value(x, y, pInput->asDouble(x, y));
}
}
}
//-----------------------------------------------------
if( pOutput == Parameters("INPUT")->asGrid() )
{
DataObject_Update(pOutput);
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Value_Replace::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pGrid = Parameters("OUTPUT")->asGrid();
if( !pGrid || pGrid == Parameters("INPUT")->asGrid() )
{
pGrid = Parameters("INPUT")->asGrid();
}
else
{
pGrid->Assign(Parameters("INPUT")->asGrid());
DataObject_Set_Parameters(pGrid, Parameters("INPUT")->asGrid());
pGrid->Fmt_Name("%s [%s]", Parameters("INPUT")->asGrid()->Get_Name(), _TL("Changed"));
}
//-----------------------------------------------------
int Method = Parameters("METHOD")->asInt();
CSG_Table LUT;
switch( Method )
{
default: LUT.Create(*Parameters("IDENTITY")->asTable()); break;
case 1: LUT.Create(*Parameters("RANGE" )->asTable()); break;
case 2: LUT.Create( Parameters("RANGE" )->asTable());
if( SG_UI_Get_Window_Main() // gui only
&& DataObject_Get_Parameter(Parameters("GRID" )->asGrid(), "LUT")
&& DataObject_Get_Parameter(Parameters("INPUT")->asGrid(), "LUT") )
{
CSG_Table LUTs[2];
LUTs[0].Create(*DataObject_Get_Parameter(Parameters("GRID" )->asGrid(), "LUT")->asTable());
LUTs[1].Create(*DataObject_Get_Parameter(Parameters("INPUT")->asGrid(), "LUT")->asTable());
for(int i=0; i<LUTs[0].Get_Count(); i++)
{
CSG_String Name = LUTs[0][i].asString(1);
for(int j=LUTs[1].Get_Count()-1; j>=0; j--)
{
if( !Name.Cmp(LUTs[1][j].asString(1)) )
{
CSG_Table_Record *pReplace = LUT.Add_Record();
pReplace->Set_Value(0, LUTs[0][i].asDouble(3));
pReplace->Set_Value(1, LUTs[1][j].asDouble(3));
pReplace->Set_Value(2, LUTs[1][j].asDouble(4));
LUTs[1].Del_Record(j);
break;
}
}
}
for(int j=0; j<LUTs[1].Get_Count(); j++)
{
LUTs[0].Add_Record(LUTs[1].Get_Record(j));
}
DataObject_Add(pGrid);
CSG_Parameter *pLUT = DataObject_Get_Parameter(pGrid, "LUT");
pLUT->asTable()->Assign_Values(&LUTs[0]);
DataObject_Set_Parameter(pGrid, pLUT);
}
break;
}
//-----------------------------------------------------
if( LUT.Get_Count() == 0 )
{
Error_Set(_TL("empty look-up table, nothing to replace"));
return( false );
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#ifndef _DEBUG
#pragma omp parallel for
#endif
for(int x=0; x<Get_NX(); x++)
{
double Value = pGrid->asDouble(x, y);
for(int i=0; i<LUT.Get_Count(); i++)
{
if( Method == 0 )
{
if( LUT[i].asDouble(1) == Value )
{
pGrid->Set_Value(x, y, LUT[i].asDouble(0));
break;
}
}
else
{
if( LUT[i].asDouble(1) <= Value && Value <= LUT[i].asDouble(2) )
{
pGrid->Set_Value(x, y, LUT[i].asDouble(0));
break;
}
}
}
}
}
//-----------------------------------------------------
if( pGrid == Parameters("INPUT")->asGrid() )
{
DataObject_Update(pGrid);
}
return( true );
}
