//--------------------------------------------------------- bool CSG_Grid::_Assign_Interpolated(CSG_Grid *pGrid, TSG_Grid_Interpolation Interpolation) { int x, y; double xPosition, yPosition, z; Set_NoData_Value_Range(pGrid->Get_NoData_Value(), pGrid->Get_NoData_hiValue()); for(y=0, yPosition=Get_YMin(); y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++, yPosition+=Get_Cellsize()) { for(x=0, xPosition=Get_XMin(); x<Get_NX(); x++, xPosition+=Get_Cellsize()) { if( pGrid->Get_Value(xPosition, yPosition, z, Interpolation) ) { Set_Value (x, y, z); } else { Set_NoData(x, y); } } } Get_History() = pGrid->Get_History(); Get_History().Add_Child(SG_T("GRID_OPERATION"), CSG_String::Format(SG_T("%f -> %f"), pGrid->Get_Cellsize(), Get_Cellsize()))->Add_Property(SG_T("NAME"), LNG("Resampling")); SG_UI_Process_Set_Ready(); return( true ); }
//--------------------------------------------------------- bool CWatershed_Segmentation::Get_Borders(void) { Process_Set_Text(_TL("Borders")); CSG_Grid *pBorders = SG_Create_Grid(SG_DATATYPE_Byte, Get_NX() + 2, Get_NY() + 2, Get_Cellsize(), Get_XMin() - 0.5 * Get_Cellsize(), Get_YMin() - 0.5 * Get_Cellsize()); pBorders->Set_NoData_Value(0); Parameters("BORDERS")->Set_Value(pBorders); for(int y=0, yy=1; yy<Get_NY() && Set_Progress(yy); y++, yy++) { for(int x=0, xx=1; xx<Get_NX(); x++, xx++) { int id = m_pSegments->asInt(x, y); if( id != m_pSegments->asInt(xx, y) ) { pBorders->Set_Value(xx, y, 1); } if( id != m_pSegments->asInt( x, yy) ) { pBorders->Set_Value( x, yy, 1); } if( id != m_pSegments->asInt(xx, yy) ) { pBorders->Set_Value(xx, yy, 1); } } } return( true ); }
//--------------------------------------------------------- bool CViGrA_Watershed::On_Execute(void) { CSG_Grid *pInput = Parameters("INPUT" )->asGrid(); CSG_Grid *pOutput = Parameters("OUTPUT")->asGrid(); //----------------------------------------------------- if( !Parameters("RGB")->asBool() ) { vigra::FImage Input, Output(Get_NX(), Get_NY()); Copy_Grid_SAGA_to_VIGRA(*pInput, Input, true); Segmentation(Input, Output, Parameters("SCALE")->asDouble(), Parameters("EDGES")->asBool()); Copy_Grid_VIGRA_to_SAGA(*pOutput, Output, false); } //----------------------------------------------------- else // perform watershed segmentation on color image { vigra::BRGBImage Input, Output(Get_NX(), Get_NY()); Copy_RGBGrid_SAGA_to_VIGRA(*pInput, Input, true); Segmentation(Input, Output, Parameters("SCALE")->asDouble(), Parameters("EDGES")->asBool()); Copy_RGBGrid_VIGRA_to_SAGA(*pOutput, Output, false); } //----------------------------------------------------- pOutput->Fmt_Name("%s [%s]", pInput->Get_Name(), Get_Name().c_str()); return( true ); }
//--------------------------------------------------------- double CGSGrid_Variance::Get_GSGrid_Variance(int x, int y, int iRadius, int &Count) { int i, ix, iy; double d, z, Variance; Variance = 0; z = pInput->asDouble(x,y); for(i=rLength[iRadius-1], Count=0; i<rLength[iRadius]; i++, Count++) { ix = x + x_diff[i]; if( ix < 0 ) ix = 0; else if( ix >= Get_NX() ) ix = Get_NX() - 1; iy = y + y_diff[i]; if( iy < 0 ) iy = 0; else if( iy >= Get_NY() ) iy = Get_NY() - 1; d = z - pInput->asDouble(ix,iy); Variance += d * d; } return( Variance ); }
//--------------------------------------------------------- void CSG_Grid::Invert(void) { int x, y; double zMin, zMax; if( is_Valid() && Get_ZRange() > 0.0 ) { zMin = Get_ZMin(); zMax = Get_ZMax(); for(y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++) { for(x=0; x<Get_NX(); x++) { if( !is_NoData(x, y) ) { Set_Value(x, y, zMax - (asDouble(x, y) - zMin)); } } } SG_UI_Process_Set_Ready(); Get_History().Add_Child(SG_T("GRID_OPERATION"), LNG("Inversion")); } }
//--------------------------------------------------------- bool CExercise_09::On_Execute(void) { int x, y; CSG_Grid *pDTM; //----------------------------------------------------- // Get parameter settings... pDTM = Parameters("ELEVATION")->asGrid(); m_pArea = Parameters("AREA" )->asGrid(); //----------------------------------------------------- // Initialisations... m_pArea ->Assign(0.0); m_pArea ->Set_Unit(SG_T("m\xc2\xb2")); DataObject_Set_Colors(m_pArea, 100, SG_COLORS_WHITE_BLUE); //----------------------------------------------------- // Save flow directions to temporary grid... m_pDir = new CSG_Grid(pDTM, SG_DATATYPE_Char); // this object has to be deleted later... for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { m_pDir->Set_Value(x, y, pDTM->Get_Gradient_NeighborDir(x, y) % 8); } } //------------------------------------------------- // Execute calculation... for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { Get_Area(x, y); } } //----------------------------------------------------- // Finalisations... delete(m_pDir); //----------------------------------------------------- // Return 'true' if everything went okay... return( true ); }
//--------------------------------------------------------- CSG_Grid & CSG_Grid::_Operation_Arithmetic(double Value, TSG_Grid_Operation Operation) { //----------------------------------------------------- switch( Operation ) { case GRID_OPERATION_Addition: Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Addition")); break; case GRID_OPERATION_Subtraction: Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Subtraction")); Value = -Value; break; case GRID_OPERATION_Multiplication: Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Multiplication")); break; case GRID_OPERATION_Division: if( Value == 0.0 ) return( *this ); Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Division")); Value = 1.0 / Value; break; } //----------------------------------------------------- for(int y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++) { for(int x=0; x<Get_NX(); x++) { if( !is_NoData(x, y) ) { switch( Operation ) { case GRID_OPERATION_Addition: case GRID_OPERATION_Subtraction: Add_Value(x, y, Value); break; case GRID_OPERATION_Multiplication: case GRID_OPERATION_Division: Mul_Value(x, y, Value); break; } } } } SG_UI_Process_Set_Ready(); return( *this ); }
//--------------------------------------------------------- bool CGrid_Histogram_Surface::Get_Lines(bool bRows) { int i, j, n_i, n_j; CSG_Table Values; CSG_Grid *pHist; //----------------------------------------------------- Parameters("HIST")->Set_Value(pHist = SG_Create_Grid(m_pGrid)); pHist->Set_NoData_Value_Range( m_pGrid->Get_NoData_Value(), m_pGrid->Get_NoData_hiValue() ); n_i = bRows ? Get_NX() : Get_NY(); n_j = bRows ? Get_NY() : Get_NX(); Values.Add_Field(SG_T("Z"), SG_DATATYPE_Double); for(i=0; i<n_i; i++) { Values.Add_Record(); } //----------------------------------------------------- for(j=0; j<n_j && Set_Progress(j, n_j); j++) { for(i=0; i<n_i; i++) { Values.Get_Record(i)->Set_Value(0, bRows ? m_pGrid->asDouble(i, j) : m_pGrid->asDouble(j, i)); } Values.Set_Index(0, TABLE_INDEX_Ascending); for(i=0; i<n_i; i++) { int k = i % 2 ? i / 2 : n_i - 1 - i / 2; if( bRows ) { pHist->Set_Value(k, j, Values.Get_Record_byIndex(i)->asDouble(0)); } else { pHist->Set_Value(j, k, Values.Get_Record_byIndex(i)->asDouble(0)); } } } //----------------------------------------------------- return( true ); }
/////////////////////////////////////////////////////////// //--------------------------------------------------------- // This function modifies the incoming integer variables!!! //--------------------------------------------------------- bool CGrid_Polygon_Clip::Get_Extent(int &xMin, int &xCount, int &yMin, int &yCount, CSG_Grid *pMask, CSG_Parameter_Grid_List *pGrids) { bool bFound; for(yMin=0, bFound=false; yMin<Get_NY() && !bFound && Process_Get_Okay(true); yMin++) { for(int x=0; x<Get_NX() && !bFound; x++) { bFound = is_InGrid(x, yMin, pMask, pGrids); } } yMin--; //----------------------------------------------------- if( yMin < Get_NY() && Process_Get_Okay() ) { int xMax, yMax; for(yMax=Get_NY()-1, bFound=false; yMax>=yMin && !bFound && Process_Get_Okay(true); yMax--) { for(int x=0; x<Get_NX() && !bFound; x++) { bFound = is_InGrid(x, yMax, pMask, pGrids); } } for(xMin=0, bFound=false; xMin<Get_NX() && !bFound && Process_Get_Okay(true); xMin++) { for(int y=yMin; y<yMax && !bFound; y++) { bFound = is_InGrid(xMin, y, pMask, pGrids); } } xMin--; for(xMax=Get_NX()-1, bFound=false; xMax>=xMin && !bFound && Process_Get_Okay(true); xMax--) { for(int y=yMin; y<yMax && !bFound; y++) { bFound = is_InGrid(xMax, y, pMask, pGrids); } } xCount = 1 + xMax - xMin; yCount = 1 + yMax - yMin; return( xCount > 0 && yCount > 0 ); } return( false ); }
//--------------------------------------------------------- bool CSG_Grid::_Assign_ExtremeValue(CSG_Grid *pGrid, bool bMaximum) { if( Get_Cellsize() < pGrid->Get_Cellsize() || is_Intersecting(pGrid->Get_Extent()) == INTERSECTION_None ) { return( false ); } //----------------------------------------------------- int x, y, ix, iy; double px, py, ax, ay, d, z; CSG_Matrix S(Get_NY(), Get_NX()), N(Get_NY(), Get_NX()); d = pGrid->Get_Cellsize() / Get_Cellsize(); Set_NoData_Value(pGrid->Get_NoData_Value()); Assign_NoData(); //----------------------------------------------------- ax = 0.5 + (pGrid->Get_XMin() - Get_XMin()) / Get_Cellsize(); ay = 0.5 + (pGrid->Get_YMin() - Get_YMin()) / Get_Cellsize(); for(y=0, py=ay; y<pGrid->Get_NY() && SG_UI_Process_Set_Progress(y, pGrid->Get_NY()); y++, py+=d) { if( (iy = (int)floor(py)) >= 0 && iy < Get_NY() ) { for(x=0, px=ax; x<pGrid->Get_NX(); x++, px+=d) { if( !pGrid->is_NoData(x, y) && (ix = (int)floor(px)) >= 0 && ix < Get_NX() ) { z = pGrid->asDouble(x, y); if( is_NoData(ix, iy) || (bMaximum == true && z > asDouble(ix, iy)) || (bMaximum == false && z < asDouble(ix, iy)) ) { Set_Value(ix, iy, z); } } } } } //----------------------------------------------------- Get_History() = pGrid->Get_History(); Get_History().Add_Child(SG_T("GRID_OPERATION"), CSG_String::Format(SG_T("%f -> %f"), pGrid->Get_Cellsize(), Get_Cellsize()))->Add_Property(SG_T("NAME"), LNG("Resampling")); SG_UI_Process_Set_Ready(); return( true ); }
//--------------------------------------------------------- bool CGSGrid_Variance::On_Execute(void) { int x, y; //----------------------------------------------------- pInput = Parameters("INPUT" )->asGrid(); pOutput = Parameters("RESULT" )->asGrid(); maxRadius = Parameters("RADIUS" )->asInt(); Exponent = Parameters("EXPONENT" )->asDouble(); //----------------------------------------------------- Initialize(); //----------------------------------------------------- for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { pOutput->Set_Value(x,y, Get_Laenge(x,y) ); } } //----------------------------------------------------- Finalize(); //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CMRVBF::Get_MRVBF(int Level, CSG_Grid *pMRVBF, CSG_Grid *pVF, CSG_Grid *pMRRTF, CSG_Grid *pRF) { if( pMRVBF && pVF && pMRRTF && pRF ) { double d, w, t, p; t = 0.4; p = log((Level - 0.5) / 0.1) / log(1.5); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0; x<Get_NX(); x++) { if( !pMRVBF->is_NoData(x, y) && !pVF->is_NoData(x, y) ) { d = pVF->asDouble(x, y); w = 1.0 - Get_Transformation(d, t, p); pMRVBF->Set_Value(x, y, w * (Level - 1 + d) + (1.0 - w) * pMRVBF->asDouble(x, y)); } if( !pMRRTF->is_NoData(x, y) && !pRF->is_NoData(x, y) ) { d = pRF->asDouble(x, y); w = 1.0 - Get_Transformation(d, t, p); pMRRTF->Set_Value(x, y, w * (Level - 1 + d) + (1.0 - w) * pMRRTF->asDouble(x, y)); } } } return( true ); } return( false ); }
//--------------------------------------------------------- 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 CGradient_Polar_To_Cartes::On_Execute(void) { bool bDegree, bClockwise; int Method; double LEN, DIR, Zero; CSG_Grid *pDX, *pDY, *pDIR, *pLEN; //----------------------------------------------------- pDX = Parameters("DX") ->asGrid(); pDY = Parameters("DY") ->asGrid(); pDIR = Parameters("DIR") ->asGrid(); pLEN = Parameters("LEN") ->asGrid(); bDegree = Parameters("UNITS") ->asInt() == 1; Method = Parameters("SYSTEM") ->asInt(); if( Method == 0 ) // mathematic { Zero = M_PI_090; bClockwise = false; } else { Zero = Parameters("SYSTEM_ZERO")->asDouble() * M_DEG_TO_RAD; bClockwise = Parameters("SYSTEM_ORIENT")->asInt() == 0; } //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0; x<Get_NX(); x++) { if( pLEN->is_NoData(x, y) || pDIR->is_NoData(x, y) ) { pDX->Set_NoData(x, y); pDY->Set_NoData(x, y); } else { LEN = pLEN->asDouble(x, y); DIR = pDIR->asDouble(x, y); if( bDegree ) { DIR *= M_DEG_TO_RAD; } if( Method != 1 ) // not geographic { DIR = bClockwise ? DIR - Zero : Zero - DIR; } pDX->Set_Value(x, y, LEN * sin(DIR)); pDY->Set_Value(x, y, LEN * cos(DIR)); } } } 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 CFragmentation_Classify::On_Execute(void) { CSG_Grid *pDensity, *pConnectivity, *pFragmentation; pDensity = Parameters("DENSITY") ->asGrid(); pConnectivity = Parameters("CONNECTIVITY") ->asGrid(); pFragmentation = Parameters("FRAGMENTATION") ->asGrid(); m_Weight = Parameters("WEIGHT") ->asDouble(); m_Density_Min = Parameters("DENSITY_MIN") ->asDouble() / 100.0; m_Density_Interior = Parameters("DENSITY_INT") ->asDouble() / 100.0; //----------------------------------------------------- CSG_Parameters Parms; DataObject_Set_Colors(pFragmentation, 100, SG_COLORS_WHITE_GREEN, true); if( DataObject_Get_Parameters(pFragmentation, Parms) && Parms("COLORS_TYPE") && Parms("LUT") ) { Parms("LUT")->asTable()->Assign_Values(&m_LUT); // Lookup Table Parms("COLORS_TYPE")->Set_Value(1); // Color Classification Type: Lookup Table DataObject_Set_Parameters(pFragmentation, Parms); } // pFragmentation->Set_NoData_Value(CLASS_NONE); //----------------------------------------------------- if( 1 ) { for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0; x<Get_NX(); x++) { if( !pDensity->is_NoData(x, y) && !pConnectivity->is_NoData(x, y) ) { double Density = pDensity ->asDouble(x, y) / 100.0; double Connectivity = pConnectivity ->asDouble(x, y) / 100.0; // pFragmentation ->Set_Value (x, y, 100.0 * Density * Connectivity); pFragmentation ->Set_Value (x, y, Get_Classification(Density, Connectivity)); } else { pFragmentation ->Set_NoData(x, y); } } } //------------------------------------------------- if( Parameters("BORDER")->asBool() ) { Add_Border(pFragmentation); } return( true ); } return( false ); }
//--------------------------------------------------------- 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 ); }
int CEdgeContamination::getEdgeContamination(int x, int y){ int iNextX, iNextY; int iEdgeContamination; if (x <= 1 || y <= 1 || x >= Get_NX() - 2 || y >= Get_NY() - 2){ iEdgeContamination = 1; }//if else{ iEdgeContamination = 0; }//else for (int i = -1; i<2; i++){ for (int j = -1; j<2; j++){ if (!(i == 0) || !(j == 0)) { getNextCell(m_pDEM, x + i, y + j, iNextX, iNextY); if (iNextY == y && iNextX == x) { if (m_pEdgeContamination->asInt(x+i,y+j)!=NOT_VISITED){ iEdgeContamination += m_pEdgeContamination->asInt(x+i,y+j); }//if else{ iEdgeContamination += getEdgeContamination(x+i,y+j); }//else }// if }//if }//for }//for m_pEdgeContamination->Set_Value(x, y, iEdgeContamination); return iEdgeContamination; }//method
//--------------------------------------------------------- bool CSG_Grid::Assign(double Value) { if( is_Valid() ) { if( Value == 0.0 && m_Memory_Type == GRID_MEMORY_Normal ) { for(int n=0, m=_Get_nLineBytes(); n<Get_NY(); n++) { memset(m_Values[n], 0, m); } } else { for(int n=0; n<Get_NCells(); n++) { Set_Value(n, Value); } } //------------------------------------------------- Get_History().Destroy(); Get_History().Add_Child(SG_T("GRID_OPERATION"), Value)->Add_Property(SG_T("NAME"), LNG("Assign")); //------------------------------------------------- m_zStats.Invalidate(); Set_Update_Flag(false); return( true ); } return( false ); }
//--------------------------------------------------------- bool CGrid_Plotter::On_Execute(void) { pResult = Parameters("RESULT")->asGrid(); double xmin = Parameters("XMIN")->asDouble(); double ymin = Parameters("YMIN")->asDouble(); double xmax = Parameters("XMAX")->asDouble(); double ymax = Parameters("YMAX")->asDouble(); const SG_Char *formel = Parameters("FORMUL")->asString(); CSG_Formula Formel; Formel.Set_Formula(formel); CSG_String Msg; if (Formel.Get_Error(Msg)) { Message_Add(Msg); return false; } for(int y=0; y<Get_NY() && Set_Progress(y); y++) for(int x=0; x<Get_NX(); x++) { pResult->Set_Value(x,y,Formel.Get_Value(SG_T("xy"),(xmax-xmin)*((double)x/Get_NX())+xmin,(ymax-ymin)*((double)y/Get_NY())+ymin)); } return( true ); }
//--------------------------------------------------------- bool CMRVBF::Get_Classified(CSG_Grid *pMRF) { if( pMRF && pMRF->is_Valid() ) { for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0; x<Get_NX(); x++) { if( !pMRF->is_NoData(x, y) ) { double d = pMRF->asDouble(x, y); if ( d < 0.5 ) pMRF->Set_Value(x, y, 0.0); else if ( d < 1.5 ) pMRF->Set_Value(x, y, 1.0); else if ( d < 2.5 ) pMRF->Set_Value(x, y, 2.0); else if ( d < 3.5 ) pMRF->Set_Value(x, y, 3.0); else if ( d < 4.5 ) pMRF->Set_Value(x, y, 4.0); else if ( d < 5.5 ) pMRF->Set_Value(x, y, 5.0); else pMRF->Set_Value(x, y, 6.0); } } } return( true ); } return( false ); }
//--------------------------------------------------------- bool CExercise_10::On_Execute(void) { bool bAlive; int x, y, i; CSG_Colors Colors; //----------------------------------------------------- // General initialisations... m_pLife = Parameters("RESULT")->asGrid(); m_nColors = Parameters("COLORS")->asInt(); Colors.Set_Count(m_nColors + 1); Colors.Set_Ramp(SG_GET_RGB(127, 127, 127), SG_GET_RGB(0, 0, 0)); Colors.Set_Color(0, SG_GET_RGB(255, 255, 255)); DataObject_Set_Colors(m_pLife, Colors); //----------------------------------------------------- // Initialise life's world... if( Parameters("REFRESH")->asBool() ) { srand((unsigned)time(NULL)); for(y=0; y<Get_NY(); y++) { for(x=0; x<Get_NX(); x++) { m_pLife->Set_Value(x, y, rand() > RAND_MAX / 2 ? 0 : 1); } } } //----------------------------------------------------- // Execution... m_pTemp = SG_Create_Grid(m_pLife, SG_DATATYPE_Byte); for(i=1, bAlive=true; bAlive && Process_Get_Okay(true); i++) { Process_Set_Text(CSG_String::Format(SG_T("%d %s"), i, _TL("Life Cycle"))); if( (bAlive = Next_Step()) == false ) { Message_Add(CSG_String::Format(SG_T("%s %d %s\n"), _TL("Dead after"), i, _TL("Life Cycles"))); } } delete(m_pTemp); //----------------------------------------------------- // Finish... return( true ); }
//--------------------------------------------------------- void CHillslope_Evolution_FTCS::Set_Diffusion(double dFactor) { int iStep = Parameters("NEIGHBOURS")->asInt() == 1 ? 1 : 2; m_pDEM_Old->Assign(m_pDEM); #pragma omp parallel for for(int y=0; y<Get_NY(); y++) { for(int x=0; x<Get_NX(); x++) { if( !m_pDEM_Old->is_NoData(x, y) ) { double z = m_pDEM_Old->asDouble(x, y); double dz = 0.0; for(int i=0; i<8; i+=iStep) { int ix = Get_xTo(i, x); int iy = Get_yTo(i, y); if( m_pDEM_Old->is_InGrid(ix, iy) ) { dz += (m_pDEM_Old->asDouble(ix, iy) - z) / Get_UnitLength(i); } } m_pDEM->Add_Value(x, y, dFactor * dz); } } } }
//--------------------------------------------------------- bool CFilter_Resample::On_Execute(void) { double Cellsize; CSG_Grid *pGrid, *pLoPass, *pHiPass; //----------------------------------------------------- pGrid = Parameters("GRID" )->asGrid(); pLoPass = Parameters("LOPASS")->asGrid(); pHiPass = Parameters("HIPASS")->asGrid(); 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->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pGrid->Get_Name(), _TL("Low Pass"))); pHiPass->Set_Name(CSG_String::Format(SG_T("%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 CGrid_Pattern::On_Execute(void){ m_pInput = Parameters("INPUT")->asGrid(); CSG_Grid *pRelative = Parameters("RELATIVE")->asGrid(); CSG_Grid *pDominance = Parameters("DOMINANCE")->asGrid(); CSG_Grid *pDiversity = Parameters("DIVERSITY")->asGrid(); CSG_Grid *pFragmentation = Parameters("FRAGMENTATION")->asGrid(); CSG_Grid *pNDC = Parameters("NDC")->asGrid(); CSG_Grid *pCVN = Parameters("CVN")->asGrid(); m_iWinSize = Parameters("WINSIZE")->asInt()*2+3; m_iNumClasses = Parameters("MAXNUMCLASS")->asInt(); for(int y=m_iWinSize-2; y<Get_NY()-m_iWinSize+2 && Set_Progress(y); y++){ for(int x=m_iWinSize-2; x<Get_NX()-m_iWinSize+2; x++){ double dDiversity = getDiversity(x,y); int iNumClasses = getNumberOfClasses(x,y); pRelative->Set_Value(x,y,((double)iNumClasses)/((double)m_iNumClasses)*100.0); pDominance->Set_Value(x,y,log((double)iNumClasses)-dDiversity); pDiversity->Set_Value(x,y,dDiversity); pFragmentation->Set_Value(x,y,((double)(iNumClasses-1))/((double)(m_iWinSize*m_iWinSize-1))); pNDC->Set_Value(x,y,iNumClasses); pCVN->Set_Value(x,y,getCVN(x,y)); }// for }// for return true; }//method
//--------------------------------------------------------- bool CConvergence::On_Execute(void) { bool bGradient; int Neighbours; CSG_Grid *pConvergence; m_pDTM = Parameters("ELEVATION") ->asGrid(); pConvergence = Parameters("RESULT") ->asGrid(); Neighbours = Parameters("NEIGHBOURS") ->asInt(); bGradient = Parameters("METHOD") ->asInt() == 1; DataObject_Set_Colors(pConvergence, 100, SG_COLORS_RED_GREY_BLUE, true); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0; x<Get_NX(); x++) { if( m_pDTM->is_InGrid(x, y) ) { switch( Neighbours ) { case 0: default: pConvergence->Set_Value(x, y, Get_2x2(x, y, bGradient)); break; case 1: pConvergence->Set_Value(x, y, Get_9x9(x, y, bGradient)); break; } } else { pConvergence->Set_NoData(x, y); } } } return( true ); }
bool CIsochronesVar::On_Execute_Position(CSG_Point ptWorld, TSG_Module_Interactive_Mode Mode) { int iX, iY; if( Mode != MODULE_INTERACTIVE_LDOWN || !Get_Grid_Pos(iX, iY) ) { return( false ); } m_pTime->Assign((double)0); writeTimeOut(iX, iY, iX, iY); for(int y=0; y<Get_NY() && Set_Progress(y); y++){ for(int x=0; x<Get_NX(); x++){ m_pTime->Set_Value(x,y,m_pTime->asDouble(x,y)/3600.); }// for }// for ZeroToNoData(); DataObject_Update(m_pTime, true); return (true); }//method
//--------------------------------------------------------- bool CTC_Texture::On_Execute(void) { //----------------------------------------------------- CSG_Grid Noise(*Get_System(), SG_DATATYPE_Char); double Epsilon = Parameters("EPSILON")->asDouble(); m_pDEM = Parameters("DEM")->asGrid(); //----------------------------------------------------- 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) ) { Noise.Set_NoData(x, y); } else { Noise.Set_Value(x, y, Get_Noise(x, y, Epsilon)); } } } //----------------------------------------------------- return( Get_Parameter(&Noise, Parameters("TEXTURE")->asGrid()) ); }
bool CGrid_CVA::On_Execute(void){ double a1,a2,b1,b2; double dDist, dAngle; CSG_Grid* pA1 = Parameters("A1")->asGrid(); CSG_Grid* pA2 = Parameters("A2")->asGrid(); CSG_Grid* pB1 = Parameters("B1")->asGrid(); CSG_Grid* pB2 = Parameters("B2")->asGrid(); CSG_Grid* pDist = Parameters("DIST")->asGrid(); CSG_Grid* pAngle = Parameters("ANGLE")->asGrid(); pDist->Assign(0.0); pAngle->Assign(0.0); for(int y=0; y<Get_NY() && Set_Progress(y); y++){ for(int x=0; x<Get_NX(); x++){ a1 = pA1->asDouble(x,y); a2 = pA2->asDouble(x,y); b1 = pB1->asDouble(x,y); b2 = pB2->asDouble(x,y); dDist = sqrt((a1-a2)*(a1-a2)+(b1-b2)*(b1-b2)); dAngle = atan((a1-a2)/(b1-b2)); pDist->Set_Value(x,y,dDist); pAngle->Set_Value(x,y,dAngle); }// for }// for return true; }//method
//--------------------------------------------------------- bool CTC_Convexity::On_Execute(void) { //----------------------------------------------------- const double Kernels[3][2] = { { 1, 0 }, { 1, 1 }, { 1, 1 / sqrt(2.0) } }; int Kernel = Parameters("KERNEL")->asInt(); //----------------------------------------------------- CSG_Grid Laplace(*Get_System(), SG_DATATYPE_Char); double Epsilon = Parameters("EPSILON")->asDouble(); int Type = Parameters("TYPE" )->asInt (); m_pDEM = Parameters("DEM")->asGrid(); //----------------------------------------------------- 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) ) { Laplace.Set_NoData(x, y); } else { Laplace.Set_Value(x, y, Get_Laplace(x, y, Kernels[Kernel], Type, Epsilon)); } } } //----------------------------------------------------- return( Get_Parameter(&Laplace, Parameters("CONVEXITY")->asGrid()) ); }