//--------------------------------------------------------- bool CTopographic_Correction::Get_Model(void) { //----------------------------------------------------- m_pOriginal = Parameters("ORIGINAL") ->asGrid(); m_pCorrected = Parameters("CORRECTED") ->asGrid(); m_pCorrected ->Set_Name(CSG_String::Format(SG_T("%s [%s]"), m_pOriginal->Get_Name(), _TL("Topographic Correction"))); m_Method = Parameters("METHOD") ->asInt(); m_Minnaert = Parameters("MINNAERT") ->asDouble(); switch( Parameters("MAXVALUE")->asInt() ) { default: m_maxValue = 255; break; case 1: m_maxValue = 65535; break; } switch( m_Method ) { //----------------------------------------------------- case 5: // C Correction { Process_Set_Text(_TL("Regression Analysis")); CSG_Regression R; sLong n = Parameters("MAXCELLS")->asInt(); int nStep = Get_NCells() < n ? 1 : (int)(Get_NCells() / n); for(n=0; n<Get_NCells() && Set_Progress_NCells(n); n+=nStep) { R.Add_Values(m_pOriginal->asDouble(n), m_Illumination.asDouble(n)); } if( !R.Calculate() || !R.Get_Constant() ) { return( false ); } m_C = R.Get_Coefficient() / R.Get_Constant(); Message_Add(R.asString()); } break; //----------------------------------------------------- case 6: // Normalization (after Civco, modified by Law & Nichol) { m_C = 1.0; } break; } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- 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_Gaps_Spline_Fill::On_Execute(void) { //----------------------------------------------------- m_pGrid = Parameters("CLOSED") ->asGrid(); m_pMask = Parameters("MASK") ->asGrid(); m_nGapCells_Max = Parameters("MAXGAPCELLS") ->asInt(); m_nPoints_Max = Parameters("MAXPOINTS") ->asInt(); m_nPoints_Local = Parameters("LOCALPOINTS") ->asInt(); m_bExtended = Parameters("EXTENDED") ->asBool(); m_Neighbours = Parameters("NEIGHBOURS") ->asInt() == 0 ? 2 : 1; m_Radius = Parameters("RADIUS") ->asDouble(); m_Relaxation = Parameters("RELAXATION") ->asDouble(); if( m_pGrid == NULL ) { m_pGrid = Parameters("GRID")->asGrid(); Parameters("CLOSED")->Set_Value(m_pGrid); } else if( m_pGrid != Parameters("GRID")->asGrid() ) { m_pGrid->Assign(Parameters("GRID")->asGrid()); m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), Parameters("GRID")->asGrid()->Get_Name(), _TL("no gaps"))); } if( m_nGapCells_Max == 0 ) { m_nGapCells_Max = Get_NCells(); } if( m_nPoints_Local > m_nPoints_Max ) { m_nPoints_Local = m_nPoints_Max; } //----------------------------------------------------- m_Gaps.Create(*Get_System(), SG_DATATYPE_Int); m_Gaps.Assign(0.0); m_nGaps = 0; for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0; x<Get_NX(); x++) { if( is_Gap(x, y) && m_Gaps.asInt(x, y) == 0 ) { Close_Gap(x, y); } } } //----------------------------------------------------- m_Stack .Clear(); m_GapCells .Clear(); m_Gaps .Destroy(); m_Spline .Destroy(); return( true ); }
//--------------------------------------------------------- // Runs on module execution. //--------------------------------------------------------- bool CExercise_04::On_Execute(void) { CSG_Grid *grid, *result, *accumulation; grid = Parameters("GRID")->asGrid(); result = Parameters("RESULT")->asGrid(); accumulation = Parameters("ACC")->asGrid(); accumulation->Assign(1.0); for (int i = 0; i < Get_NCells() && Set_Progress_NCells(i); i++) { int x, y; if (grid->Get_Sorted(i, x, y)) { int direction = Get_Flow_Direction(grid, x, y); if (direction > -1) { result->Set_Value(x, y, direction); int destX = accumulation->Get_System().Get_xTo(direction, x); int destY = accumulation->Get_System().Get_yTo(direction, y); accumulation->Set_Value(destX, destY, accumulation->asDouble(destX, destY) + accumulation->asDouble(x, y)); } } } result->Set_Name("Flow Direction Map"); 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 CViGrA_Morphology::On_Execute(void) { bool bRescale; int Type, Radius; double Rank; CSG_Grid *pInput, *pOutput, Rescaled; pInput = Parameters("INPUT") ->asGrid(); pOutput = Parameters("OUTPUT") ->asGrid(); Type = Parameters("TYPE") ->asInt(); Radius = Parameters("RADIUS") ->asInt(); Rank = Parameters("RANK") ->asDouble(); bRescale = Parameters("RESCALE") ->asBool(); //----------------------------------------------------- if( bRescale ) { Rescaled.Create(*Get_System(), SG_DATATYPE_Byte); for(sLong i=0; i<Get_NCells() && Set_Progress_NCells(i); i++) { Rescaled.Set_Value(i, 0.5 + (pInput->asDouble(i) - pInput->Get_ZMin()) * 255.0 / pInput->Get_ZRange()); } pInput = &Rescaled; } //----------------------------------------------------- vigra::BImage Input, Output(Get_NX(), Get_NY()); Copy_Grid_SAGA_to_VIGRA(*pInput, Input, true); switch( Type ) { case 0: // Dilation discDilation (srcImageRange(Input), destImage(Output), Radius); break; case 1: // Erosion discErosion (srcImageRange(Input), destImage(Output), Radius); break; case 2: // Median discMedian (srcImageRange(Input), destImage(Output), Radius); break; case 3: // User defined rank discRankOrderFilter (srcImageRange(Input), destImage(Output), Radius, Rank); break; } //----------------------------------------------------- Copy_Grid_VIGRA_to_SAGA(*pOutput, Output, false); pOutput->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pInput->Get_Name(), Get_Name().c_str())); return( true ); }
//--------------------------------------------------------- bool CSADO_SolarRadiation::Get_Shade(double Decline, double Azimuth) { //----------------------------------------------------- m_Shade.Assign(0.0); if( !m_bBending ) { int i, x, y; double dx, dy, dz; Get_Shade_Params(Decline, Azimuth, dx, dy, dz); for(i=0; i<Get_NCells() && Set_Progress_NCells(i); i++) { if( m_pDEM->Get_Sorted(i, x, y) && !Get_Shade_Complete(x, y) ) { Set_Shade(x, y, dx, dy, dz); } } } //----------------------------------------------------- else { int i, x, y, iLock; for(i=0, iLock=1; i<Get_NCells() && Set_Progress_NCells(i); i++, iLock++) { if( m_pDEM->Get_Sorted(i, x, y) && !Get_Shade_Complete(x, y) ) { if( iLock >= 255 ) iLock = 1; if( iLock == 1 ) Lock_Create(); Set_Shade_Bended(x, y, iLock); } } } 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 CMelton_Ruggedness::On_Execute(void) { CSG_Grid *pDEM, *pArea, *pMRN, *pZMax; //----------------------------------------------------- pDEM = Parameters("DEM" )->asGrid(); pArea = Parameters("AREA")->asGrid(); pZMax = Parameters("ZMAX")->asGrid(); pMRN = Parameters("MRN" )->asGrid(); if( !pDEM->Set_Index() ) { Error_Set(_TL("index creation failed")); return( false ); } pArea->Set_NoData_Value(0.0); pArea->Assign_NoData(); pZMax->Assign_NoData(); pMRN ->Assign_NoData(); //------------------------------------------------- for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { int x, y, i, ix, iy; if( pDEM->Get_Sorted(n, x, y, true, true) ) { pArea->Add_Value(x, y, Get_Cellsize()); if( pZMax->is_NoData(x, y) ) { pZMax->Set_Value(x, y, pDEM->asDouble(x, y)); } if( (i = pDEM->Get_Gradient_NeighborDir(x, y, true)) >= 0 && Get_System().Get_Neighbor_Pos(i, x, y, ix, iy) ) { pArea->Add_Value(ix, iy, pArea->asDouble(x, y)); if( pZMax->is_NoData(ix, iy) || pZMax->asDouble(ix, iy) < pZMax->asDouble(x, y) ) { pZMax->Set_Value(ix, iy, pZMax->asDouble(x, y)); } } pMRN->Set_Value(x, y, (pZMax->asDouble(x, y) - pDEM->asDouble(x, y)) / sqrt(pArea->asDouble(x, y))); } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CFlow_by_Slope::On_Execute(void) { m_Slope_Min = Parameters("SLOPE_MIN")->asDouble() * M_DEG_TO_RAD; m_Slope_Max = Parameters("SLOPE_MAX")->asDouble() * M_DEG_TO_RAD; if( m_Slope_Max <= 0.0 ) { Error_Set(_TL("slope threshold must not be zero!")); return( false ); } if( Parameters("B_FLOW")->asBool() ) { m_Flow_Min = Parameters("T_FLOW")->asRange()->Get_LoVal() * Get_Cellarea(); m_Flow_Max = Parameters("T_FLOW")->asRange()->Get_HiVal() * Get_Cellarea(); } else { m_Flow_Min = m_Flow_Max = 0.0; } //----------------------------------------------------- m_pDEM = Parameters("DEM" )->asGrid(); m_pFlow = Parameters("FLOW" )->asGrid(); m_pFlow->Assign(Get_Cellarea()); if( Parameters("WEIGHT")->asGrid() ) { m_pFlow->Multiply(*Parameters("WEIGHT")->asGrid()); } DataObject_Set_Colors(m_pFlow, 11, SG_COLORS_WHITE_BLUE, false); //----------------------------------------------------- for(sLong i=0; i<Get_NCells() && Set_Progress_NCells(i); i++) { int x, y; if( !m_pDEM->Get_Sorted(i, x, y, true) || m_pDEM->is_NoData(x, y) ) { m_pFlow->Set_NoData(x, y); } else { Set_Area(x, y); } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CSlopeLength::On_Execute(void) { int x, y; //----------------------------------------------------- m_pDEM = Parameters("DEM" )->asGrid(); m_pLength = Parameters("LENGTH")->asGrid(); if( !m_pDEM->Set_Index() ) { Error_Set(_TL("index creation failed")); return( false ); } //----------------------------------------------------- m_Slope.Create(*Get_System()); for(y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for private(x) for(x=0; x<Get_NX(); x++) { double Slope, Aspect; if( m_pDEM->Get_Gradient(x, y, Slope, Aspect) ) { m_Slope .Set_Value(x, y, Slope); m_pLength->Set_Value(x, y, 0.0); } else { m_Slope .Set_NoData(x, y); m_pLength->Set_NoData(x, y); } } } //----------------------------------------------------- for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { if( m_pDEM->Get_Sorted(n, x, y) ) { Get_Length(x, y); } } //----------------------------------------------------- m_Slope.Destroy(); 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 CExercise_14::Find_Channels(void) { int n, x, y; for(n=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { if( m_pDTM->Get_Sorted(n, x, y, true) && m_pChnl->asInt(x, y) == SPRING ) { m_pChnl ->Set_Value(x, y, SPRING); Find_Channels(x, y); } } }
//--------------------------------------------------------- // Calculation according to Milledge et al. 2012 //--------------------------------------------------------- bool CDiffuse_Pollution_Risk::Get_Risk_Diffuse(void) { Process_Set_Text(_TL("Difuse Pollution Risk")); m_pRisk_Diffuse->Assign(0.0); //----------------------------------------------------- for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { int x, y; if( !m_pDEM->Get_Sorted(n, x, y, true) || m_pDelivery->is_NoData(x, y) || m_pRisk_Point->is_NoData(x, y) || m_RainAcc.asDouble(x, y) <= 0.0 ) { m_pRisk_Diffuse->Set_NoData(x, y); } else { double d[8], Risk; m_pRisk_Point->Mul_Value(x, y, m_pDelivery->asDouble(x, y)); // locational risk = generation risk * connection risk Risk = m_pRisk_Diffuse->asDouble(x, y) + m_pRisk_Point->asDouble(x, y); // risk load = sum of upslope locational risk m_pRisk_Diffuse->Set_Value(x, y, Risk / m_RainAcc.asDouble(x, y)); // risk concentration = risk load / sum of upslope rain if( m_bSingle ) { int i = !m_FlowDir.is_NoData(x, y) ? m_FlowDir.asInt(x, y) : -1; if( i > 0 && m_pDEM->is_InGrid(Get_xTo(i, x), Get_yTo(i, y)) ) { m_pRisk_Diffuse->Add_Value(Get_xTo(i, x), Get_yTo(i, y), Risk); } } else if( Get_Flow_Proportions(x, y, d) ) { for(int i=0; i<8; i++) { if( d[i] > 0.0 ) { m_pRisk_Diffuse->Add_Value(Get_xTo(i, x), Get_yTo(i, y), Risk * d[i]); } } } } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CTIN_From_Grid_Specific_Points::Get_FlowDirection2(CSG_Grid *pResult, CSG_Grid *pGrid, int Threshold) { CSG_Grid Grid(*pGrid), Result(*pResult); Get_FlowDirection(pResult, &Grid, -1, Threshold); Grid.Invert(); Get_FlowDirection(&Result, &Grid, -1, Threshold); for(sLong n=0; n<Get_NCells(); n++) { if( Result.asInt(n) > 0 ) { pResult->Set_Value(n, 1); } } return( true ); }
//--------------------------------------------------------- bool CWatersheds::On_Execute(void) { int x, y, nCells, nCells_Min, nBasins; sLong n; CSG_Grid *pDTM, *pSeed, *pRoute; //----------------------------------------------------- pDTM = Parameters("ELEVATION")->asGrid(); pSeed = Parameters("CHANNELS" )->asGrid(); pRoute = Parameters("SINKROUTE")->asGrid(); nCells_Min = Parameters("MINSIZE" )->asInt(); m_pBasins = Parameters("BASINS" )->asGrid(); m_pBasins->Set_NoData_Value(NO_BASIN); m_pBasins->Assign_NoData(); if( !pDTM->Set_Index() ) { Error_Set(_TL("index creation failed")); return( false ); } m_Direction.Create(m_pBasins, SG_DATATYPE_Char); for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { if( pDTM->is_NoData(x, y) ) { m_Direction.Set_NoData(x, y); } else { if( !pRoute || (n = pRoute->asChar(x, y)) <= 0 ) { n = pDTM->Get_Gradient_NeighborDir(x, y); } m_Direction.Set_Value(x, y, (int)(n < 0 ? -1 : (n + 4) % 8)); } } } //----------------------------------------------------- for(n=0, m_nBasins=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { pDTM->Get_Sorted(n, x, y, true, false); if( !pSeed->is_NoData(x, y) && pSeed->asInt(x, y) < 0 ) { m_nBasins++; if( (nCells = Get_Basin(x, y)) < nCells_Min ) { nBasins = m_nBasins - 1; m_nBasins = NO_BASIN; Get_Basin(x, y); m_nBasins = nBasins; } } } //----------------------------------------------------- m_Direction.Destroy(); return( true ); }
//--------------------------------------------------------- bool CChange_Detection::On_Execute(void) { bool bNoChange; int iInitial, iFinal; CSG_Matrix Identity; CSG_Table Initial, Final, *pChanges; CSG_Grid *pInitial, *pFinal, *pChange; //----------------------------------------------------- pInitial = Parameters("INITIAL") ->asGrid(); pFinal = Parameters("FINAL") ->asGrid(); pChange = Parameters("CHANGE") ->asGrid(); pChanges = Parameters("CHANGES") ->asTable(); bNoChange = Parameters("NOCHANGE")->asBool(); if( !Get_Classes(Initial, pInitial, true) ) { Error_Set(_TL("no class definitions for initial state")); return( false ); } if( !Get_Classes(Final, pFinal, false) ) { Error_Set(_TL("no class definitions for final state")); return( false ); } if( !Get_Changes(Initial, Final, pChanges, Identity) ) { return( false ); } //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0; x<Get_NX(); x++) { iInitial = Get_Class(Initial, pInitial->asDouble(x, y)); iFinal = Get_Class(Final , pFinal ->asDouble(x, y)); if( bNoChange || !Identity[iInitial][iFinal] ) { pChanges->Get_Record(iInitial)->Add_Value(1 + iFinal, 1); pChange->Set_Value(x, y, (pChanges->Get_Field_Count() - 1) * iInitial + iFinal); } else { pChange->Set_Value(x, y, -1); } } } //----------------------------------------------------- CSG_Parameters P; if( DataObject_Get_Parameters(pChange, P) && P("COLORS_TYPE") && P("LUT") ) { CSG_Table *pLUT = P("LUT")->asTable(); CSG_Colors cRandom(pChanges->Get_Count()); cRandom.Random(); pLUT->Del_Records(); for(iInitial=0; iInitial<pChanges->Get_Count(); iInitial++) { CSG_Colors cRamp(pChanges->Get_Field_Count() - 1); cRamp.Set_Ramp(cRandom[iInitial], cRandom[iInitial]); cRamp.Set_Ramp_Brighness(225, 50); for(iFinal=0; iFinal<pChanges->Get_Field_Count()-1; iFinal++) { if( pChanges->Get_Record(iInitial)->asInt(1 + iFinal) > 0 ) { CSG_Table_Record *pClass = pLUT->Add_Record(); pClass->Set_Value(0, cRamp.Get_Color(iFinal)); pClass->Set_Value(1, CSG_String::Format(SG_T("%s >> %s"), pChanges->Get_Record(iInitial)->asString(0), pChanges->Get_Field_Name(1 + iFinal))); pClass->Set_Value(3, (pChanges->Get_Field_Count() - 1) * iInitial + iFinal); pClass->Set_Value(4, (pChanges->Get_Field_Count() - 1) * iInitial + iFinal); } } } P("COLORS_TYPE")->Set_Value(1); // Color Classification Type: Lookup Table DataObject_Set_Parameters(pChange, P); } //----------------------------------------------------- double Factor; switch( Parameters("OUTPUT")->asInt() ) { default: Factor = 1.0; break; // cells case 1: Factor = 100.0 / Get_NCells(); break; // percent case 2: Factor = M_SQR(Get_Cellsize()); break; // area } if( Factor != 1.0 ) { for(iInitial=0; iInitial<pChanges->Get_Count(); iInitial++) { for(iFinal=0; iFinal<pChanges->Get_Field_Count()-1; iFinal++) { pChanges->Get_Record(iInitial)->Mul_Value(1 + iFinal, Factor); } } } //----------------------------------------------------- pChanges ->Set_Name(CSG_String::Format(SG_T("%s [%s >> %s]"), _TL("Changes"), pInitial->Get_Name(), pFinal->Get_Name())); pChange ->Set_Name(CSG_String::Format(SG_T("%s [%s >> %s]"), _TL("Changes"), pInitial->Get_Name(), pFinal->Get_Name())); pChange ->Set_NoData_Value(-1); return( true ); }
//--------------------------------------------------------- void CFlow::Finalize(void) { long n; double z, CellSize, Catch, Contour, dContour, G, H; //----------------------------------------------------- CellSize = Get_Cellsize() * Get_Cellsize(); Contour = 1.0; dContour = 0.02 * M_PI * sqrt(CellSize / M_PI); //----------------------------------------------------- for(n=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { if( pDTM->is_NoData(n) ) { if( pCatch ) { pCatch ->Set_NoData(n); } if( pCatch_Height ) { pCatch_Height ->Set_NoData(n); } if( pCatch_Slope ) { pCatch_Slope ->Set_NoData(n); } if( pCatch_Aspect ) { pCatch_Aspect ->Set_NoData(n); } if( pFlowPath ) { pFlowPath ->Set_NoData(n); } } else { z = pDTM->asDouble(n); //--------------------------------------------- Catch = 1.0 / pCatch->asDouble(n); if( pCatch_Height ) { pCatch_Height ->Set_Value(n, Catch * pCatch_Height->asDouble(n) - z); } if( pCatch_Slope ) { pCatch_Slope ->Mul_Value(n, Catch); } if( pFlowPath ) { pFlowPath ->Mul_Value(n, Catch); } //--------------------------------------------- Catch = CellSize / Catch; if( pCatch ) { pCatch ->Set_Value(n, Catch); } //--------------------------------------------- if( pCatch_Aspect && pCatch_AspectY ) { G = pCatch_Aspect ->asDouble(n); H = pCatch_AspectY->asDouble(n); pCatch_Aspect ->Set_Value(n, G ? fmod(M_PI_270 + atan2(H, G), M_PI_360) : (H > 0 ? M_PI_270 : (H < 0 ? M_PI_090 : -1))); } } } //----------------------------------------------------- if( pCatch_AspectY ) { delete(pCatch_AspectY); pCatch_AspectY = NULL; } }
//--------------------------------------------------------- bool CFlow::On_Execute(void) { bool bResult = false; long n; double d; //------------------------------------------------- pDTM = Parameters("ELEVATION") ->asGrid(); pRoute = Parameters("SINKROUTE") ->asGrid(); pWeight = Parameters("WEIGHT") ->asGrid(); pCatch = Parameters("CAREA") ->asGrid(); DataObject_Set_Colors(pCatch, 100, SG_COLORS_WHITE_BLUE); pCatch_Height = NULL; pCatch_Slope = NULL; pCatch_Aspect = NULL; pFlowPath = NULL; Step = Parameters("STEP") ->asInt(); //------------------------------------------------- On_Initialize(); //------------------------------------------------- if( pCatch ) { pCatch ->Assign(0.0); } if( pCatch_Height ) { pCatch_Height ->Assign(0.0); } if( pCatch_Slope ) { pCatch_Slope ->Assign(0.0); } if( pCatch_Aspect ) { pCatch_Aspect ->Assign(0.0); pCatch_AspectY = SG_Create_Grid(pCatch_Aspect); } if( pFlowPath ) { pFlowPath ->Assign(0.0); } //------------------------------------------------- if( bPoint ) { bPoint = false; if( is_InGrid(xPoint, yPoint) ) { Calculate(xPoint, yPoint); On_Finalize(); for(n=0; n<Get_NCells(); n++) { d = pCatch->asDouble(n); pCatch->Set_Value(n, 100.0 * d); } bResult = true; } } else { pCatch_Height = Parameters("CHEIGHT") ->asGrid(); pCatch_Slope = Parameters("CSLOPE") ->asGrid(); Calculate(); On_Finalize(); Finalize(); bResult = true; } //------------------------------------------------- return( bResult ); }
//--------------------------------------------------------- bool CWatershed_Segmentation::Get_Segments(void) { Process_Set_Text(_TL("Segments")); double Threshold = Parameters("THRESHOLD")->asDouble(); int Join = Threshold > 0.0 ? Parameters("JOIN")->asInt() : 0; //----------------------------------------------------- for(sLong n=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { int x, y, i, ID, iID; if( m_pGrid->Get_Sorted(n, x, y, m_bDown) && (i = m_Dir.asInt(x, y)) >= 0 ) { m_pSegments->Set_Value(x, y, ID = m_pSegments->asInt(Get_xTo(i, x), Get_yTo(i, y))); if( Join != 0 && ID >= 0 ) { double z = m_pGrid->asDouble(x, y); for(int i=0; i<8; i++) { int ix = Get_xTo(i, x); int iy = Get_yTo(i, y); if( m_pSegments->is_InGrid(ix, iy) && (iID = m_pSegments->asInt(ix, iy)) >= 0 ) // Border < 0, Segment >= 0 { if( ID != iID ) { bool bJoin; if( Join == 1 ) { bJoin = (Threshold >= fabs(m_pSeeds->Get_Shape(iID)->asDouble(SEED_Z) - z)) || (Threshold >= fabs(m_pSeeds->Get_Shape( ID)->asDouble(SEED_Z) - z)); } else { bJoin = Threshold >= fabs(m_pSeeds->Get_Shape(iID)->asDouble(SEED_Z) - m_pSeeds->Get_Shape(ID)->asDouble(SEED_Z)); } if( bJoin ) { if( (m_bDown == true && m_pSeeds->Get_Shape(iID)->asDouble(SEED_Z) < m_pSeeds->Get_Shape(ID)->asDouble(SEED_Z)) || (m_bDown == false && m_pSeeds->Get_Shape(iID)->asDouble(SEED_Z) > m_pSeeds->Get_Shape(ID)->asDouble(SEED_Z)) ) { Segment_Change(iID, ID); } else { Segment_Change(ID, iID); ID = iID; } } } } } } } } return( true ); }
//--------------------------------------------------------- bool CGrid_Cluster_Analysis::_On_Execute(void) { int i, j, *nMembers, nCluster, nElements; double *Variances, **Centroids, SP; CSG_Grid **Grids, *pCluster; CSG_Parameter_Grid_List *pGrids; //----------------------------------------------------- pGrids = Parameters("GRIDS") ->asGridList(); pCluster = Parameters("CLUSTER") ->asGrid(); nCluster = Parameters("NCLUSTER")->asInt(); if( pGrids->Get_Count() < 1 ) { return( false ); } //----------------------------------------------------- Grids = (CSG_Grid **)SG_Malloc(pGrids->Get_Count() * sizeof(CSG_Grid *)); if( Parameters("NORMALISE")->asBool() ) { for(i=0; i<pGrids->Get_Count(); i++) { Grids[i] = SG_Create_Grid(pGrids->asGrid(i), SG_DATATYPE_Float); Grids[i] ->Assign(pGrids->asGrid(i)); Grids[i] ->Standardise(); } } else { for(i=0; i<pGrids->Get_Count(); i++) { Grids[i] = pGrids->asGrid(i); } } pCluster->Set_NoData_Value(-1.0); pCluster->Assign_NoData(); nMembers = (int *)SG_Malloc(nCluster * sizeof(int)); Variances = (double *)SG_Malloc(nCluster * sizeof(double)); Centroids = (double **)SG_Malloc(nCluster * sizeof(double *)); for(i=0; i<nCluster; i++) { Centroids[i] = (double *)SG_Malloc(pGrids->Get_Count() * sizeof(double)); } //------------------------------------------------- switch( Parameters("METHOD")->asInt() ) { case 0: SP = _MinimumDistance (Grids, pGrids->Get_Count(), pCluster, nCluster, nMembers, Variances, Centroids, nElements = Get_NCells()); break; case 1: SP = _HillClimbing (Grids, pGrids->Get_Count(), pCluster, nCluster, nMembers, Variances, Centroids, nElements = Get_NCells()); break; case 2: SP = _MinimumDistance (Grids, pGrids->Get_Count(), pCluster, nCluster, nMembers, Variances, Centroids, nElements = Get_NCells()); SP = _HillClimbing (Grids, pGrids->Get_Count(), pCluster, nCluster, nMembers, Variances, Centroids, nElements = Get_NCells()); break; } //------------------------------------------------- if( Parameters("NORMALISE")->asBool() ) { for(i=0; i<pGrids->Get_Count(); i++) { delete(Grids[i]); for(j=0; j<nCluster; j++) { Centroids[j][i] = pGrids->asGrid(i)->Get_StdDev() * Centroids[j][i] + pGrids->asGrid(i)->Get_Mean(); } } } //------------------------------------------------- Save_LUT(pCluster); //------------------------------------------------- int iCluster, iFeature; CSG_String s; CSG_Table_Record *pRecord; CSG_Table *pTable; pTable = Parameters("STATISTICS")->asTable(); pTable->Destroy(); pTable->Set_Name(_TL("Cluster Analysis")); pTable->Add_Field(_TL("ClusterID") , SG_DATATYPE_Int); pTable->Add_Field(_TL("Elements") , SG_DATATYPE_Int); pTable->Add_Field(_TL("Std.Dev.") , SG_DATATYPE_Double); s.Printf(SG_T("\n%s:\t%ld \n%s:\t%d \n%s:\t%d \n%s:\t%f\n\n%s\t%s\t%s"), _TL("Number of Elements") , nElements, _TL("Number of Variables") , pGrids->Get_Count(), _TL("Number of Clusters") , nCluster, _TL("Standard Deviation") , sqrt(SP), _TL("Cluster"), _TL("Elements"), _TL("Std.Dev.") ); for(iFeature=0; iFeature<pGrids->Get_Count(); iFeature++) { s += CSG_String::Format(SG_T("\t%s"), pGrids->asGrid(iFeature)->Get_Name()); pTable->Add_Field(pGrids->asGrid(iFeature)->Get_Name(), SG_DATATYPE_Double); } Message_Add(s); for(iCluster=0; iCluster<nCluster; iCluster++) { Variances[iCluster] = nMembers[iCluster] ? Variances[iCluster] / nMembers[iCluster] : 0.0; s.Printf(SG_T("\n%d\t%d\t%f"), iCluster, nMembers[iCluster], sqrt(Variances[iCluster])); pRecord = pTable->Add_Record(); pRecord->Set_Value(0, iCluster); pRecord->Set_Value(1, nMembers[iCluster]); pRecord->Set_Value(2, sqrt(Variances[iCluster])); for(iFeature=0; iFeature<pGrids->Get_Count(); iFeature++) { double Centroid = Centroids[iCluster][iFeature]; if( Parameters("NORMALISE")->asBool() ) { Centroid = pGrids->asGrid(iFeature)->Get_Mean() + Centroid * pGrids->asGrid(iFeature)->Get_StdDev(); } s += CSG_String::Format(SG_T("\t%f"), Centroid); pRecord->Set_Value(iFeature + 3, Centroid); } Message_Add(s, false); } //------------------------------------------------- for(i=0; i<nCluster; i++) { SG_Free(Centroids[i]); } SG_Free(Centroids); SG_Free(Variances); SG_Free(nMembers); SG_Free(Grids); return( true ); }
//--------------------------------------------------------- bool CChannelNetwork::On_Execute(void) { int x, y, ID, Trace_Method, Init_Method; long n; double Init_Threshold; CSG_Grid *Trace_pRoute, *Trace_pWeight, *Init_pGrid; //----------------------------------------------------- pDTM = Parameters("ELEVATION") ->asGrid(); pConvergence = Parameters("DIV_GRID") ->asGrid(); pChannels = Parameters("CHNLNTWRK") ->asGrid(); pChannelRoute = Parameters("CHNLROUTE") ->asGrid(); pShapes = Parameters("SHAPES") ->asShapes(); minLength = Parameters("MINLEN") ->asInt(); maxDivCells = Parameters("DIV_GRID")->asGrid() ? Parameters("DIV_CELLS")->asInt() : -1; //----------------------------------------------------- // 1. Flow Direction... Process_Set_Text(_TL("Channel Network: Pass 1")); pChannels->Assign(); Trace_pRoute = Parameters("SINKROUTE") ->asGrid(); Trace_pWeight = Parameters("TRACE_WEIGHT")->asGrid(); Trace_Method = Trace_pWeight ? 1 : 0; for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { if( Trace_pRoute && (ID = Trace_pRoute->asChar(x, y)) >= 1 && ID <= 8 ) { pChannels->Set_Value(x, y, ID); } else { switch( Trace_Method ) { default: Set_Route_Standard(x, y); break; case 1: Set_Route_Weighted(x, y, Trace_pWeight, 0.0); break; } } } } //----------------------------------------------------- // 2. Initiation... Process_Set_Text(_TL("Channel Network: Pass 2")); pStart = SG_Create_Grid(pDTM, SG_DATATYPE_Char); Init_pGrid = Parameters("INIT_GRID") ->asGrid(); Init_Method = Parameters("INIT_METHOD") ->asInt(); Init_Threshold = Parameters("INIT_VALUE") ->asDouble(); for(n=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { switch( Init_Method ) { case 0: if( Init_pGrid->asDouble(n) <= Init_Threshold ) pStart->Set_Value(n, 1); break; case 1: if( Init_pGrid->asDouble(n) == Init_Threshold ) pStart->Set_Value(n, 1); break; case 2: if( Init_pGrid->asDouble(n) >= Init_Threshold ) pStart->Set_Value(n, 1); break; } } //----------------------------------------------------- // 3. Trace Channel Routes... Process_Set_Text(_TL("Channel Network: Pass 3")); pChannelRoute->Assign(); Direction = NULL; Direction_Buffer = 0; for(n=0; n<Get_NCells() && Set_Progress_NCells(n); n++) { if( pDTM->Get_Sorted(n,x,y) ) { Set_Channel_Route(x,y); } } if( Direction ) { SG_Free( Direction ); } pChannels->Assign(); delete(pStart); //----------------------------------------------------- Process_Set_Text(_TL("Channel Network: Pass 4")); for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { Set_Channel_Order(x,y); } } //----------------------------------------------------- Process_Set_Text(_TL("Channel Network: Pass 5")); for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { Set_Channel_Mouth(x,y); } } //----------------------------------------------------- if( pShapes ) { Process_Set_Text(_TL("Channel Network: Pass 6")); pShapes->Create(SHAPE_TYPE_Line, _TL("Channel Network")); pShapes->Add_Field("SegmentID" ,SG_DATATYPE_Int); pShapes->Add_Field("Order" ,SG_DATATYPE_Int); pShapes->Add_Field("Length" ,SG_DATATYPE_Double); Lock_Create(); for(y=0, ID=1; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { Set_Vector(x, y, ID++); } } Lock_Destroy(); } //----------------------------------------------------- for(n=0; n<Get_NCells(); n++) { if( pChannels->asInt(n) == 0 ) { pChannels->Set_NoData(n); pChannelRoute->Set_NoData(n); } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CGrid_Proximity::On_Execute(void) { int x, y; double z, d; TSG_Point p; CSG_Grid *pFeatures, *pDistance, *pDirection, *pAllocation; CSG_PRQuadTree Search; //----------------------------------------------------- pFeatures = Parameters("FEATURES") ->asGrid(); pDistance = Parameters("DISTANCE") ->asGrid(); pDirection = Parameters("DIRECTION") ->asGrid(); pAllocation = Parameters("ALLOCATION") ->asGrid(); //----------------------------------------------------- Process_Set_Text(_TL("preparing distance calculation...")); Search.Create(CSG_Rect(-1, -1, Get_NX(), Get_NY())); for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { if( pFeatures->is_NoData(x, y) ) { pDistance->Set_Value(x, y, -1.0); } else { pDistance->Set_Value(x, y, 0.0); if( pDirection ) { pDirection->Set_NoData(x, y); } if( pAllocation ) { pAllocation->Set_Value(x, y, pFeatures->asDouble(x, y)); } //----------------------------------------- bool bBorder = false; for(int i=0; i<8 && !bBorder; i++) { int ix = Get_xTo(i, x); int iy = Get_yTo(i, y); if( is_InGrid(ix, iy) && pFeatures->is_NoData(ix, iy) ) { bBorder = true; } } if( bBorder ) { Search.Add_Point(x, y, pFeatures->asDouble(x, y)); } } } } if( !Search.is_Okay() || Search.Get_Point_Count() <= 0 || Search.Get_Point_Count() >= Get_NCells() ) { Message_Add(_TL("no features to buffer.")); return( false ); } //----------------------------------------------------- Process_Set_Text(_TL("performing distance calculation...")); for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { if( pDistance->asDouble(x, y) < 0.0 && Search.Get_Nearest_Point(x, y, p, z, d) ) { pDistance->Set_Value(x, y, d * Get_Cellsize()); if( pDirection ) { if( d > 0.0 ) { pDirection->Set_Value(x, y, SG_Get_Angle_Of_Direction(x, y, p.x, p.y) * M_RAD_TO_DEG); } else { pDirection->Set_NoData(x, y); } } if( pAllocation ) { pAllocation->Set_Value(x, y, z); } } } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CChange_Detection::Get_Classes(CSG_Table &Classes, CSG_Grid *pGrid, bool bInitial) { CSG_Table *pClasses; Classes.Destroy(); Classes.Add_Field(_TL("NAME") , SG_DATATYPE_String); Classes.Add_Field(_TL("MIN") , SG_DATATYPE_Double); Classes.Add_Field(_TL("MAX") , SG_DATATYPE_Double); //----------------------------------------------------- if( (pClasses = Parameters(bInitial ? "INI_LUT" : "FIN_LUT")->asTable()) != NULL ) { int fNam = Parameters(bInitial ? "INI_LUT_NAM" : "FIN_LUT_NAM")->asInt(); int fMin = Parameters(bInitial ? "INI_LUT_MIN" : "FIN_LUT_MIN")->asInt(); int fMax = Parameters(bInitial ? "INI_LUT_MAX" : "FIN_LUT_MAX")->asInt(); if( fNam < 0 || fNam >= pClasses->Get_Field_Count() ) { fNam = fMin; } if( fMax < 0 || fMax >= pClasses->Get_Field_Count() ) { fMax = fMin; } for(int iClass=0; iClass<pClasses->Get_Count(); iClass++) { CSG_Table_Record *pClass = Classes.Add_Record(); pClass->Set_Value(CLASS_NAM, pClasses->Get_Record(iClass)->asString(fNam)); pClass->Set_Value(CLASS_MIN, pClasses->Get_Record(iClass)->asDouble(fMin)); pClass->Set_Value(CLASS_MAX, pClasses->Get_Record(iClass)->asDouble(fMax)); } } //----------------------------------------------------- else if( DataObject_Get_Parameter(pGrid, "LUT") ) { pClasses = DataObject_Get_Parameter(pGrid, "LUT")->asTable(); for(int iClass=0; iClass<pClasses->Get_Count(); iClass++) { CSG_Table_Record *pClass = Classes.Add_Record(); pClass->Set_Value(CLASS_NAM, pClasses->Get_Record(iClass)->asString(1)); pClass->Set_Value(CLASS_MIN, pClasses->Get_Record(iClass)->asDouble(3)); pClass->Set_Value(CLASS_MAX, pClasses->Get_Record(iClass)->asDouble(4)); } } //----------------------------------------------------- else { double z; for(sLong i=0; i<Get_NCells() && Set_Progress_NCells(i); i++) { double iz = pGrid->asDouble(pGrid->Get_Sorted(i, false, false)); if( i == 0 || iz != z ) { CSG_Table_Record *pClass = Classes.Add_Record(); pClass->Set_Value(CLASS_NAM, z = iz); pClass->Set_Value(CLASS_MIN, z); pClass->Set_Value(CLASS_MAX, z); } } } //----------------------------------------------------- return( Classes.Get_Count() > 0 ); }
//--------------------------------------------------------- bool CGrid_Aspect_Slope_Map::On_Execute(void) { CSG_Grid *pAspect, *pSlope, *pAspectSlope; CSG_Table *pLUT; int iAspectCount = 9; static const double AspectBreaks[] = {0.000, 0.393, 1.178, 1.963, 2.749, 3.534, 4.320, 5.105, 5.890, 6.283}; static const int AspectClass[] = {1, 2, 3, 4, 5, 6, 7, 8, 1}; int iSlopeCount = 4; static const double SlopeBreaks[] = {0.000, 0.087, 0.349, 0.698, 1.571}; static const int SlopeClass[] = {10, 20, 30, 40}; pAspect = Parameters("ASPECT")->asGrid(); pSlope = Parameters("SLOPE")->asGrid(); pAspectSlope = Parameters("ASPECT_SLOPE")->asGrid(); pLUT = Parameters("LUT")->asTable(); //----------------------------------------------------- if( pLUT == NULL ) pLUT = new CSG_Table(); else pLUT->Destroy(); pLUT->Set_Name(SG_T("LUT_Aspect-Slope")); pLUT->Add_Field(SG_T("COLOR"), SG_DATATYPE_Int); pLUT->Add_Field(SG_T("NAME"), SG_DATATYPE_String); pLUT->Add_Field(SG_T("DESCRIPTION"), SG_DATATYPE_String); pLUT->Add_Field(SG_T("MINIMUM"), SG_DATATYPE_Int); pLUT->Add_Field(SG_T("MAXIMUM"), SG_DATATYPE_Int); for(int i=0; i<25; i++) { CSG_Table_Record *pRecord = pLUT->Add_Record(); pRecord->Set_Value(0, LUT_COLOR[i]); pRecord->Set_Value(1, LUT_NAME[i]); pRecord->Set_Value(2, SG_T("")); pRecord->Set_Value(3, LUT_BREAK[i]); pRecord->Set_Value(4, LUT_BREAK[i+1]); } //----------------------------------------------------- #pragma omp parallel for for(sLong n=0; n<Get_NCells(); n++) { int iAspectClass, iSlopeClass; if( pAspect->is_NoData(n) || pSlope->is_NoData(n) ) { pAspectSlope->Set_NoData(n); } else { iAspectClass = Get_Class(pAspect->asDouble(n), iAspectCount, AspectBreaks, AspectClass); iSlopeClass = Get_Class(pSlope->asDouble(n), iSlopeCount, SlopeBreaks, SlopeClass); pAspectSlope->Set_Value(n, iAspectClass + iSlopeClass); } } //----------------------------------------------------- CSG_Parameters Parms; if( DataObject_Get_Parameters(pAspectSlope, Parms) && Parms("COLORS_TYPE") && Parms("LUT") ) { Parms("LUT")->asTable()->Assign(pLUT); Parms("COLORS_TYPE")->Set_Value(1); DataObject_Set_Parameters(pAspectSlope, Parms); } if( Parameters("LUT")->asTable() == NULL ) { delete pLUT; } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CGridsFromTableAndGrid::On_Execute(void) { int iField, iRecord, iAttribute, nAttributes, *Attribute; sLong iCell, jCell; CSG_Parameter_Grid_List *pGrids; CSG_Grid *pClasses; CSG_Table *pTable; //----------------------------------------------------- pClasses = Parameters("CLASSES" )->asGrid(); pGrids = Parameters("GRIDS" )->asGridList(); pTable = Parameters("TABLE" )->asTable(); iField = Parameters("ID_FIELD")->asInt(); pGrids->Del_Items(); if( !pClasses->Set_Index() ) { Error_Set(_TL("index creation failed")); return( false ); } //----------------------------------------------------- if( pTable->Get_Field_Count() == 0 || pTable->Get_Count() == 0 ) { Message_Add(_TL("selected table contains no valid records")); return( false ); } //----------------------------------------------------- if( !pTable->Set_Index(iField, TABLE_INDEX_Ascending) ) { Message_Add(_TL("failed to create index for table")); return( false ); } //----------------------------------------------------- Attribute = new int[pTable->Get_Field_Count()]; for(iAttribute=0, nAttributes=0; iAttribute<pTable->Get_Field_Count(); iAttribute++) { if( iAttribute != iField && pTable->Get_Field_Type(iAttribute) != SG_DATATYPE_String ) { Attribute[nAttributes++] = iAttribute; CSG_Grid *pGrid = SG_Create_Grid(*Get_System()); pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pClasses->Get_Name(), pTable->Get_Field_Name(iAttribute))); pGrids->Add_Item(pGrid); } } if( nAttributes == 0 ) { delete[](Attribute); Message_Add(_TL("selected table does not have numeric attributes")); return( false ); } //----------------------------------------------------- CSG_Table_Record *pRecord = pTable->Get_Record_byIndex(0); for(iCell=0, iRecord=0; iCell<Get_NCells() && pRecord && Set_Progress_NCells(iCell); iCell++) { if( pClasses->Get_Sorted(iCell, jCell, false, true) ) { double valClass = pClasses->asDouble(jCell); while( pRecord && pRecord->asDouble(iField) < valClass ) { pRecord = pTable->Get_Record_byIndex(++iRecord); } if( !pRecord || pRecord->asDouble(iField) > valClass ) { for(iAttribute=0; iAttribute<nAttributes; iAttribute++) { pGrids->asGrid(iAttribute)->Set_NoData(jCell); } } else { for(iAttribute=0; iAttribute<nAttributes; iAttribute++) { pGrids->asGrid(iAttribute)->Set_Value(jCell, pRecord->asDouble(Attribute[iAttribute])); } } } } //----------------------------------------------------- delete[](Attribute); return true; }
//--------------------------------------------------------- bool 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 CRGA_Basic::On_Execute(void) { bool bRefresh; int x, y, i, Segment; CSG_Grid *pSeeds; //----------------------------------------------------- m_pSegments = Parameters("SEGMENTS" )->asGrid(); m_pFeatures = Parameters("FEATURES" )->asGridList(); m_nFeatures = m_pFeatures->Get_Count(); pSeeds = Parameters("SEEDS" )->asGrid(); m_pSeeds = Parameters("TABLE" )->asTable(); m_pSimilarity = Parameters("SIMILARITY")->asGrid(); m_dNeighbour = Parameters("NEIGHBOUR" )->asInt() == 0 ? 2 : 1; m_Var_1 = SG_Get_Square(Parameters("SIG_1")->asDouble()); m_Var_2 = SG_Get_Square(Parameters("SIG_2")->asDouble()); m_Threshold = Parameters("THRESHOLD" )->asDouble(); m_bNormalize = Parameters("NORMALIZE" )->asBool(); m_Method = Parameters("METHOD" )->asInt(); bRefresh = Parameters("REFRESH" )->asBool(); //----------------------------------------------------- m_pSegments ->Assign(-1); m_pSegments ->Set_NoData_Value(-1); m_pSimilarity ->Assign(-1); m_pSimilarity ->Set_NoData_Value(-1); //----------------------------------------------------- m_pSeeds->Destroy(); m_pSeeds->Add_Field(_TL("ID" ), SG_DATATYPE_Int); m_pSeeds->Add_Field(_TL("AREA"), SG_DATATYPE_Double); m_pSeeds->Add_Field(_TL("X" ), SG_DATATYPE_Double); m_pSeeds->Add_Field(_TL("Y" ), SG_DATATYPE_Double); for(i=0; i<m_pFeatures->Get_Count(); i++) { m_pSeeds->Add_Field(m_pFeatures->asGrid(i)->Get_Name(), SG_DATATYPE_Double); } m_Candidates.Create(Parameters("LEAFSIZE")->asInt()); //----------------------------------------------------- for(y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { if( !pSeeds->is_NoData(x, y) ) { CSG_Table_Record *pRec = m_pSeeds->Add_Record(); pRec->Set_Value(0, m_pSeeds->Get_Count() - 1); pRec->Set_Value(SEEDFIELD_X, x); pRec->Set_Value(SEEDFIELD_Y, y); for(i=0; i<m_pFeatures->Get_Count(); i++) { pRec->Set_Value(SEEDFIELD_Z + i, Get_Feature(x, y, i)); } m_pSimilarity->Set_Value(x, y, 1.0); Add_To_Segment(x, y, m_pSeeds->Get_Count() - 1); } } } //----------------------------------------------------- if( m_pSeeds->Get_Count() > 1 ) { sLong n = 0; while( n++ < Get_NCells() && Set_Progress_NCells(n) && Get_Next_Candidate(x, y, Segment) ) { Add_To_Segment(x, y, Segment); if( bRefresh && (n % Get_NX()) == 0 ) { DataObject_Update(m_pSegments, 0, m_pSeeds->Get_Count()); Process_Set_Text(CSG_String::Format(SG_T("%.2f"), 100.0 * m_Candidates.Get_Count() / Get_NCells())); } } m_Candidates.Destroy(); return( true ); } //----------------------------------------------------- m_Candidates.Destroy(); return( false ); }
//--------------------------------------------------------- void CFlow_RecursiveUp::On_Create(void) { int x, y, Method; double *p; //----------------------------------------------------- On_Destroy(); Flow = (double ***)SG_Malloc( Get_NY () * sizeof(double **)); p = (double *)SG_Malloc(8 * Get_NCells() * sizeof(double )); for(y=0; y<Get_NY(); y++) { Flow[y] = (double **)SG_Malloc( Get_NX () * sizeof(double *)); for(x=0; x<Get_NX(); x++, p+=8) { Flow[y][x] = p; } } //----------------------------------------------------- Lock_Create(); Method = Parameters("Method")->asInt(); memset(Flow[0][0], 0, 8 * Get_NCells() * sizeof(double) ); for(y=0; y<Get_NY(); y++) { for(x=0; x<Get_NX(); x++) { if( pRoute && pRoute->asChar(x,y) > 0 ) { Flow[y][x][pRoute->asChar(x,y) % 8] = 1.0; } else { switch( Method ) { case 0: Set_D8(x,y); break; case 1: Set_Rho8(x,y); break; case 2: Set_DInf(x,y); break; case 3: Set_MFD(x,y); break; } } } } }
//--------------------------------------------------------- bool CGrid_Cluster_Analysis::On_Execute(void) { if( Parameters("OLDVERSION")->asBool() ) { return( _On_Execute() ); } //----------------------------------------------------- bool bNormalize; int iFeature; sLong iElement, nElements; CSG_Cluster_Analysis Analysis; CSG_Grid *pCluster; CSG_Parameter_Grid_List *pGrids; //----------------------------------------------------- pGrids = Parameters("GRIDS" )->asGridList(); pCluster = Parameters("CLUSTER" )->asGrid(); bNormalize = Parameters("NORMALISE")->asBool(); if( !Analysis.Create(pGrids->Get_Count()) ) { return( false ); } //----------------------------------------------------- pCluster->Set_NoData_Value(0.0); for(iElement=0, nElements=0; iElement<Get_NCells() && Set_Progress_NCells(iElement); iElement++) { bool bNoData = false; for(iFeature=0; iFeature<pGrids->Get_Count() && !bNoData; iFeature++) { if( pGrids->asGrid(iFeature)->is_NoData(iElement) ) { bNoData = true; } } if( bNoData || !Analysis.Add_Element() ) { pCluster->Set_Value(iElement, 0); } else { pCluster->Set_Value(iElement, 1); for(iFeature=0; iFeature<pGrids->Get_Count(); iFeature++) { double d = pGrids->asGrid(iFeature)->asDouble(iElement); if( bNormalize ) { d = (d - pGrids->asGrid(iFeature)->Get_Mean()) / pGrids->asGrid(iFeature)->Get_StdDev(); } Analysis.Set_Feature(nElements, iFeature, d); } nElements++; } } if( nElements <= 1 ) { return( false ); } //----------------------------------------------------- bool bResult = Analysis.Execute( Parameters("METHOD" )->asInt(), Parameters("NCLUSTER")->asInt(), Parameters("MAXITER" )->asInt() ); for(iElement=0, nElements=0; iElement<Get_NCells(); iElement++) { Set_Progress_NCells(iElement); if( !pCluster->is_NoData(iElement) ) { pCluster->Set_Value(iElement, 1 + Analysis.Get_Cluster(nElements++)); } } Save_Statistics(pGrids, bNormalize, Analysis); Save_LUT(pCluster); return( bResult ); }