//--------------------------------------------------------- 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 ); }