//---------------------------------------------------------
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 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 );
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
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 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 );
}
//---------------------------------------------------------
bool CCost_Accumulated::Get_Destinations(CPoints &Points)
{
Points.Clear();
m_pAccumulated->Set_NoData_Value(-1.0); m_pAccumulated->Assign(-1.0);
m_pAllocation ->Set_NoData_Value(-1.0); m_pAllocation ->Assign( 0.0);
if( Parameters("DEST_TYPE")->asInt() == 0 ) // Point
{
CSG_Shapes *pDestinations = Parameters("DEST_POINTS")->asShapes();
for(int i=0, x, y; i<pDestinations->Get_Count(); i++)
{
if( Get_System().Get_World_to_Grid(x, y, pDestinations->Get_Shape(i)->Get_Point(0)) && !m_pCost->is_NoData(x, y) )
{
Points.Add(x, y); m_pAllocation->Set_Value(x, y, Points.Get_Count()); m_pAccumulated->Set_Value(x, y, 0.0);
}
}
}
else // Grid
{
CSG_Grid *pDestinations = Parameters("DEST_GRID")->asGrid();
for(int y=0; y<Get_NY(); y++) for(int x=0; x<Get_NX(); x++)
{
if( !pDestinations->is_NoData(x, y) && !m_pCost->is_NoData(x, y) )
{
Points.Add(x, y); m_pAllocation->Set_Value(x, y, Points.Get_Count()); m_pAccumulated->Set_Value(x, y, 0.0);
}
}
}
return( Points.Get_Count() > 0 );
}
//---------------------------------------------------------
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 CFlow_Distance::On_Execute(void)
{
bool bSeeds;
int x, y, Method;
CSG_Grid *pSeed;
//-------------------------------------------------
m_pDTM = Parameters("ELEVATION") ->asGrid();
pSeed = Parameters("SEED") ->asGrid();
m_pLength = Parameters("LENGTH") ->asGrid();
m_Converge = Parameters("CONVERGENCE") ->asDouble();
bSeeds = Parameters("SEEDS_ONLY") ->asBool();
Method = Parameters("METHOD") ->asInt();
m_pWeight = SG_Create_Grid(m_pLength, SG_DATATYPE_Float);
m_pWeight ->Assign(0.0);
m_pLength ->Assign(0.0);
//-------------------------------------------------
for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++)
{
m_pDTM->Get_Sorted(n, x, y, true, false);
if( pSeed && !pSeed->is_NoData(x, y) )
{
m_pLength->Set_Value(x, y, 0.0);
m_pWeight->Set_Value(x, y, 0.0);
}
else if( m_pWeight->asDouble(x, y) > 0.0 )
{
m_pLength->Set_Value(x, y, m_pLength->asDouble(x, y) / m_pWeight->asDouble(x, y));
}
else if( bSeeds )
{
m_pLength->Set_NoData(x, y);
continue;
}
switch( Method )
{
case 0: Set_Length_D8 (x, y); break;
case 1: Set_Length_MFD (x, y); break;
}
}
//-------------------------------------------------
delete(m_pWeight);
DataObject_Set_Colors(m_pLength, 100, SG_COLORS_WHITE_BLUE);
return( true );
}
//---------------------------------------------------------
bool CPROJ4_Grid::Set_Shapes(CSG_Parameter_Grid_List *pSources, CSG_Shapes *pTarget)
{
int x, y, i;
double z;
TSG_Point Pt_Source, Pt_Target;
CSG_Grid *pSource;
CSG_Shape *pShape;
if( pSources && pSources->Get_Count() > 0 && pTarget )
{
pSource = pSources->asGrid(0);
pTarget->Create(SHAPE_TYPE_Point, CSG_String::Format(SG_T("%s [%s]"), pSource->Get_Name(), Get_Proj_Name().c_str()));
for(i=0; i<pSources->Get_Count(); i++)
{
pTarget->Add_Field(pSources->asGrid(i)->Get_Name(), pSources->asGrid(i)->Get_Type());
}
for(y=0, Pt_Source.y=pSource->Get_YMin(); y<pSource->Get_NY() && Set_Progress(y, pSource->Get_NY()); y++, Pt_Source.y+=pSource->Get_Cellsize())
{
for(x=0, Pt_Source.x=pSource->Get_XMin(); x<pSource->Get_NX(); x++, Pt_Source.x+=pSource->Get_Cellsize())
{
if( !pSource->is_NoData(x, y) )
{
Pt_Target = Pt_Source;
if( Get_Converted(Pt_Target) )
{
pShape = pTarget->Add_Shape();
pShape->Add_Point(Pt_Target);
for(i=0; i<pSources->Get_Count(); i++)
{
if( pSources->asGrid(i)->Get_Value(Pt_Source, z, m_Interpolation) )
{
pShape->Set_Value(i, z);
}
else
{
pShape->Set_NoData(i);
}
}
}
}
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
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 CGrid_Mask::On_Execute(void)
{
CSG_Grid *pGrid = Parameters("GRID")->asGrid();
CSG_Grid *pMask = Parameters("MASK")->asGrid();
if( !pGrid->is_Intersecting(pMask->Get_Extent()) )
{
Message_Add(_TL("no intersection with mask grid."));
return( false );
}
//-----------------------------------------------------
CSG_Grid *pMasked = Parameters("MASKED")->asGrid();
if( pMasked && pMasked != pGrid )
{
pMasked->Create(*pGrid);
pMasked->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("masked"));
pGrid = pMasked;
}
//-----------------------------------------------------
Process_Set_Text(_TL("masking..."));
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++)
{
if( !pGrid->is_NoData(x, y) )
{
double px = Get_XMin() + x * Get_Cellsize();
if( !pMask->is_InGrid_byPos(px, py) )
{
pGrid->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGeoref_Grid::Get_Target_Extent(CSG_Rect &Extent, bool bEdge)
{
if( Parameters("METHOD")->asInt() == GEOREF_Triangulation ) // triangulation
{
return( m_Engine.Get_Reference_Extent(Extent) );
}
//-----------------------------------------------------
CSG_Grid *pGrid = Parameters("GRID")->asGrid();
Extent.m_rect.xMin = Extent.m_rect.yMin = 1.0;
Extent.m_rect.xMax = Extent.m_rect.yMax = 0.0;
//-----------------------------------------------------
if( bEdge )
{
for(int y=0; y<pGrid->Get_NY(); y++)
{
Add_Target_Extent(Extent, pGrid->Get_XMin(), pGrid->Get_System().Get_yGrid_to_World(y));
Add_Target_Extent(Extent, pGrid->Get_XMax(), pGrid->Get_System().Get_yGrid_to_World(y));
}
for(int x=0; x<pGrid->Get_NX(); x++)
{
Add_Target_Extent(Extent, pGrid->Get_System().Get_xGrid_to_World(x), pGrid->Get_YMin());
Add_Target_Extent(Extent, pGrid->Get_System().Get_xGrid_to_World(x), pGrid->Get_YMax());
}
}
//-----------------------------------------------------
else
{
for(int y=0; y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++)
{
for(int x=0; x<pGrid->Get_NX(); x++)
{
if( !pGrid->is_NoData(x, y) )
{
TSG_Point p = pGrid->Get_System().Get_Grid_to_World(x, y);
Add_Target_Extent(Extent, p.x, p.y);
}
}
}
}
return( is_Progress() && Extent.Get_XRange() > 0.0 && Extent.Get_YRange() > 0.0 );
}
//---------------------------------------------------------
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 CFlow_AreaUpslope_Area::On_Execute(void)
{
bool bResult = false;
//-----------------------------------------------------
if( m_Calculator.Initialise(
Parameters("METHOD") ->asInt(),
Parameters("ELEVATION") ->asGrid(),
Parameters("SINKROUTE") ->asGrid(),
Parameters("AREA") ->asGrid(),
Parameters("CONVERGE") ->asDouble() ) )
{
if( m_Calculator.Clr_Target() )
{
int x, y;
CSG_Grid *pTarget = Parameters("TARGET")->asGrid();
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !pTarget->is_NoData(x, y) && m_Calculator.Add_Target(x, y) )
{
bResult = true;
}
}
}
if( bResult )
{
m_Calculator.Get_Area();
DataObject_Set_Colors(Parameters("AREA")->asGrid(), 100, SG_COLORS_WHITE_BLUE);
}
}
}
//-----------------------------------------------------
m_Calculator.Finalise();
return( bResult );
}
//---------------------------------------------------------
bool CGrid_RGB_Split::On_Execute(void)
{
CSG_Grid *pRGB = Parameters("RGB")->asGrid();
if( SG_Data_Type_Get_Size(pRGB->Get_Type()) < 4 )
{
Message_Add(_TL("warning, input uses less than 4 bytes per value"));
}
bool bNoData = Parameters("NODATA")->asBool();
CSG_Grid *pR = Parameters("R")->asGrid(); if( bNoData && pR ) pR->Set_NoData_Value(-1);
CSG_Grid *pG = Parameters("G")->asGrid(); if( bNoData && pG ) pG->Set_NoData_Value(-1);
CSG_Grid *pB = Parameters("B")->asGrid(); if( bNoData && pB ) pB->Set_NoData_Value(-1);
CSG_Grid *pA = Parameters("A")->asGrid(); if( bNoData && pA ) pA->Set_NoData_Value(-1);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( bNoData || !pRGB->is_NoData(x, y) )
{
int RGB = pRGB->asInt(x, y);
if( pR ) pR->Set_Value(x, y, SG_GET_R(RGB));
if( pG ) pG->Set_Value(x, y, SG_GET_G(RGB));
if( pB ) pB->Set_Value(x, y, SG_GET_B(RGB));
if( pA ) pA->Set_Value(x, y, SG_GET_A(RGB));
}
else
{
if( pR ) pR->Set_NoData(x, y);
if( pG ) pG->Set_NoData(x, y);
if( pB ) pB->Set_NoData(x, y);
if( pA ) pA->Set_NoData(x, y);
}
}
}
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 CFlow_RecursiveUp::Calculate(void)
{
CSG_Grid *pTargets = Parameters("TARGETS")->asGrid();
On_Create();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( !pTargets || !pTargets->is_NoData(x, y) )
{
Get_Flow(x, y);
}
}
}
On_Destroy();
return( true );
}
bool CInvertNoData::On_Execute(void){
int x,y;
CSG_Grid* pInput = Parameters("INPUT")->asGrid();
CSG_Grid* pOutput = Parameters("OUTPUT")->asGrid();
pOutput->Set_NoData_Value_Range(-9999,0);
for(y=0; y<Get_NY() && Set_Progress(y); y++){
for(x=0; x<Get_NX(); x++){
if (pInput->is_NoData(x,y)){
pOutput->Set_Value(x, y, 1.0);
}//if
else{
pOutput->Set_Value(x, y, -9999.0);
}//else
}//if
}//for
return true;
}//method
//---------------------------------------------------------
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_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_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 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 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 CWaterRetentionCapacity::On_Execute(void)
{
CSG_Shapes *pInput = Parameters("SHAPES")->asShapes();
CSG_Shapes *pOutput = Parameters("OUTPUT")->asShapes();
if( pInput->Get_Field_Count() < 5 )
{
Error_Set(_TL("Plot hole data has to provide at the very least five attributes (horizon depth, TF, L, Ar, Mo)."));
return( false );
}
pOutput->Create(SHAPE_TYPE_Point, _TL("Water Retention Capacity"));
pOutput->Add_Field("CCC" , SG_DATATYPE_Double);
pOutput->Add_Field("CIL" , SG_DATATYPE_Double);
pOutput->Add_Field("Permeability" , SG_DATATYPE_Double);
pOutput->Add_Field("Equivalent Moisture" , SG_DATATYPE_Double);
pOutput->Add_Field("Water Retention Capacity", SG_DATATYPE_Double);
//-----------------------------------------------------
CSG_Grid *pDEM = Parameters("DEM")->asGrid();
CSG_Matrix Data(5, pInput->Get_Field_Count() / 5);
for(int iPoint=0; iPoint<pInput->Get_Count(); iPoint++)
{
CSG_Shape *pPoint = pInput->Get_Shape(iPoint);
for(int iHorizon=0, n=0; iHorizon<Data.Get_NRows(); iHorizon++, n+=5)
{
for(int i=0; i<5; i++)
{
Data[iHorizon][i] = pPoint->asDouble(n + i);
}
}
double Slope, Aspect;
if( !pDEM->Get_Gradient(pPoint->Get_Point(0), Slope, Aspect, GRID_RESAMPLING_BSpline) )
{
Slope = 0.0;
}
Get_WaterRetention(Data, 1. - tan(Slope), pOutput->Add_Shape(pPoint, SHAPE_COPY_GEOM));
}
//-----------------------------------------------------
CSG_Grid *pRetention = Parameters("RETENTION")->asGrid();
if( pRetention )
{
switch( Parameters("INTERPOL")->asInt() )
{
default: // Multlevel B-Spline Interpolation
SG_RUN_TOOL_ExitOnError("grid_spline", 4,
SG_TOOL_PARAMETER_SET("SHAPES" , pOutput)
&& SG_TOOL_PARAMETER_SET("FIELD" , pOutput->Get_Field_Count() - 1)
&& SG_TOOL_PARAMETER_SET("TARGET_DEFINITION", 1) // grid or grid system
&& SG_TOOL_PARAMETER_SET("TARGET_OUT_GRID" , pRetention)
);
break;
case 1: // Inverse Distance Weighted
SG_RUN_TOOL_ExitOnError("grid_gridding", 1,
SG_TOOL_PARAMETER_SET("SHAPES" , pOutput)
&& SG_TOOL_PARAMETER_SET("FIELD" , pOutput->Get_Field_Count() - 1)
&& SG_TOOL_PARAMETER_SET("TARGET_DEFINITION", 1) // grid or grid system
&& SG_TOOL_PARAMETER_SET("TARGET_OUT_GRID" , pRetention)
&& SG_TOOL_PARAMETER_SET("SEARCH_RANGE" , 1) // global
&& SG_TOOL_PARAMETER_SET("SEARCH_POINTS_ALL", 1) // all points within search distance
);
break;
}
if( Parameters("SLOPECORR")->asBool() )
{
#pragma omp parallel for
for(int y=0; y<Get_NY(); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( !pRetention->is_NoData(x, y) )
{
double Slope, Aspect;
if( !pDEM->Get_Gradient(x, y, Slope, Aspect) )
{
Slope = 0.0;
}
pRetention->Mul_Value(x, y, 1. - tan(Slope));
}
}
}
}
}
//-----------------------------------------------------
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 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 CChannelNetwork_Distance::On_Execute(void)
{
CSG_Grid *pChannels;
//-----------------------------------------------------
m_pDEM = Parameters("ELEVATION")->asGrid();
m_pRoute = Parameters("ROUTE" )->asGrid();
pChannels = Parameters("CHANNELS" )->asGrid();
m_pDistance = Parameters("DISTANCE" )->asGrid();
m_pDistVert = Parameters("DISTVERT" )->asGrid();
m_pDistHorz = Parameters("DISTHORZ" )->asGrid();
m_pTime = Parameters("TIME" )->asGrid();
m_pSDR = Parameters("SDR" )->asGrid();
m_Flow_B = Parameters("FLOW_B" )->asDouble();
m_Flow_K = Parameters("FLOW_K" )->asDouble();
m_Flow_R = Parameters("FLOW_R" )->asDouble();
m_pFlow_K = Parameters("FLOW_K" )->asGrid();
m_pFlow_R = Parameters("FLOW_R" )->asGrid();
int Method = Parameters("METHOD" )->asInt();
//-----------------------------------------------------
if( m_pDistance ) m_pDistance->Assign_NoData();
if( m_pDistVert ) m_pDistVert->Assign_NoData();
if( m_pDistHorz ) m_pDistHorz->Assign_NoData();
if( m_pTime ) m_pTime ->Assign_NoData();
if( m_pSDR ) m_pSDR ->Assign_NoData();
switch( Method )
{
default: Initialize_D8 (); break;
case 1: Initialize_MFD(); break;
}
m_pDEM->Set_Index(true);
//-----------------------------------------------------
for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++)
{
int x, y;
if( m_pDEM->Get_Sorted(n, x, y, false, true) && !(pChannels->is_NoData(x, y) && m_pDistance->is_NoData(x, y)) )
{
if( !pChannels->is_NoData(x, y) )
{
if( m_pDistance ) m_pDistance->Set_Value(x, y, 0.0);
if( m_pDistVert ) m_pDistVert->Set_Value(x, y, 0.0);
if( m_pDistHorz ) m_pDistHorz->Set_Value(x, y, 0.0);
if( m_pTime ) m_pTime ->Set_Value(x, y, 0.0);
if( m_pSDR ) m_pSDR ->Set_Value(x, y, 0.0);
if( m_pFields ) m_pPasses ->Set_Value(x, y, 0.0);
}
switch( Method )
{
default: Execute_D8 (x, y); break;
case 1: Execute_MFD(x, y); break;
}
}
}
//-----------------------------------------------------
m_Dir.Destroy();
for(int i=0; i<=8; i++)
{
m_Flow[i].Destroy();
}
//-----------------------------------------------------
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 );
}
