//--------------------------------------------------------- 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 ); }
//--------------------------------------------------------- inline double CKernel_Density::Get_Kernel(double dx, double dy) { double d = SG_Get_Length(dx, dy); if( d >= m_dRadius ) { return( 0.0 ); } d /= m_dRadius; switch( m_Kernel ) { default: case 0: // quartic kernel return( (3.0 / (M_PI * m_dRadius*m_dRadius)) * SG_Get_Square(1.0 - d*d) ); case 1: // gaussian kernel d *= 2.0; return( exp(-0.5 * d*d) ); case 2: // exponential d *= 2.0; return( exp(-d) ); case 3: // inverse distance return( pow(1.0 + d, -1.0) ); } }
//--------------------------------------------------------- void CVariogram_Dialog::Set_Variogram(void) { double lagDist = m_Settings("LAGDIST")->asDouble(); double maxDist = m_Settings("MAXDIST")->asDouble(); if( lagDist > 0.0 ) { double Diagonal = SG_Get_Length(m_pPoints->Get_Extent().Get_XRange(), m_pPoints->Get_Extent().Get_YRange()); // bounding box's diagonal if( maxDist <= 0.0 || maxDist > Diagonal ) { m_Settings("MAXDIST")->Set_Value(maxDist = Diagonal); } CSG_Variogram::Calculate(m_pPoints, m_Attribute, m_bLog, m_pVariogram, 1 + (int)(0.5 + maxDist / lagDist), maxDist, m_Settings("SKIP")->asInt() ); m_pDistance->Set_Range(0.0, m_pVariogram->Get_Maximum(CSG_Variogram::FIELD_DISTANCE)); m_pDistance->Set_Value(m_pVariogram->Get_Maximum(CSG_Variogram::FIELD_DISTANCE)); m_pDiagram->Set_Variogram(); Set_Model(); } }
//--------------------------------------------------------- bool CGWR_Grid_Downscaling::Get_Model(void) { //----------------------------------------------------- m_pQuality = Parameters("QUALITY" )->asGrid(); m_pQuality ->Set_Name(CSG_String::Format(SG_T("%s [%s, %s]"), m_pDependent->Get_Name(), _TL("GWR"), _TL("Quality"))); m_pResiduals = Parameters("RESIDUALS")->asGrid(); m_pResiduals ->Set_Name(CSG_String::Format(SG_T("%s [%s, %s]"), m_pDependent->Get_Name(), _TL("GWR"), _TL("Residuals"))); //----------------------------------------------------- m_Search.Get_Weighting().Set_Parameters(&Parameters); m_Search.Set_Radius(Parameters("SEARCH_RANGE")->asInt() == 0 ? Parameters("SEARCH_RADIUS")->asInt() : 1 + (int)(SG_Get_Length(m_pDependent->Get_NX(), m_pDependent->Get_NY())) ); //----------------------------------------------------- CSG_Grid_System System(m_pDependent->Get_System()); for(int y=0; y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y++) { #pragma omp parallel for for(int x=0; x<System.Get_NX(); x++) { if( !Get_Regression(x, y) ) { m_pQuality ->Set_NoData(x, y); m_pResiduals->Set_NoData(x, y); for(int i=0; i<=m_nPredictors; i++) { m_pModel[i]->Set_NoData(x, y); } } } } //----------------------------------------------------- m_Search.Destroy(); return( true ); }
//--------------------------------------------------------- // find_weight() Function to find the weightings matrix for the // observed cell values. // Uses an inverse distance function that can be // calibrated with an exponent (0= no decay, // 1=linear decay, 2=squared distance decay etc.) // V.1.1, Jo Wood, 11th May, 1995. //--------------------------------------------------------- bool CParam_Scale::Get_Weights(void) { if( (m_Radius = Parameters("SIZE")->asInt()) < 1 || !m_Weights.Create(1 + 2 * m_Radius, 1 + 2 * m_Radius) ) { return( false ); } double Exponent = Parameters("EXPONENT")->asDouble(); // Find inverse distance of all cells to centre. for(int y=0; y<m_Weights.Get_NY(); y++) { for(int x=0; x<m_Weights.Get_NX(); x++) { m_Weights[y][x] = 1.0 / pow(1.0 + SG_Get_Length(m_Radius - x, m_Radius - y), Exponent); } } return( true ); }
//--------------------------------------------------------- bool CWKSP_Shapes::_Edit_Move(bool bToggle) { if( m_Edit_pShape ) { if( bToggle ) { switch( m_Edit_Mode ) { default: break; //--------------------------------------------- case EDIT_SHAPE_MODE_Normal: m_Edit_Mode = EDIT_SHAPE_MODE_Move; if( m_Edit_Shapes.Get_Count() > 1 ) { m_Edit_Shapes.Get_Shape(1)->Del_Parts(); } else { m_Edit_Shapes.Add_Shape(); } return( true ); //--------------------------------------------- case EDIT_SHAPE_MODE_Move: m_Edit_Mode = EDIT_SHAPE_MODE_Normal; m_Edit_Shapes.Del_Shape(1); return( true ); } } //------------------------------------------------- else // if( !bToggle ) { if( m_Edit_Shapes.Get_Count() > 1 && m_Edit_Shapes.Get_Shape(1)->Get_Point_Count() > 1 ) { CSG_Point Move = CSG_Point(m_Edit_Shapes.Get_Shape(1)->Get_Point(1)) - CSG_Point(m_Edit_Shapes.Get_Shape(1)->Get_Point(0)); m_Edit_Shapes.Get_Shape(1)->Del_Parts(); if( SG_Get_Length(Move.Get_X(), Move.Get_Y()) > 0.0 ) { for(int iPart=0; iPart<m_Edit_pShape->Get_Part_Count(); iPart++) { for(int iPoint=0; iPoint<m_Edit_pShape->Get_Point_Count(iPart); iPoint++) { m_Edit_pShape->Set_Point(Move + m_Edit_pShape->Get_Point(iPoint, iPart), iPoint, iPart); } } Update_Views(false); return( true ); } } } } return( false ); }
//--------------------------------------------------------- bool CGSPoints_Semi_Variances::On_Execute(void) { int i, j, k, n, nDistances, nSkip, Attribute; double zi, zj, zMean, v, c, maxDistance, lagDistance; TSG_Point Pt_i, Pt_j; CSG_Vector Count, Variance, Covariance; CSG_Table_Record *pRecord; CSG_Table *pTable; CSG_Shape *pPoint; CSG_Shapes *pPoints; //----------------------------------------------------- pPoints = Parameters("POINTS") ->asShapes(); pTable = Parameters("RESULT") ->asTable(); Attribute = Parameters("FIELD") ->asInt(); nSkip = Parameters("NSKIP") ->asInt(); maxDistance = Parameters("DISTMAX") ->asDouble(); nDistances = Parameters("DISTCOUNT") ->asInt(); if( maxDistance <= 0.0 ) { maxDistance = SG_Get_Length(pPoints->Get_Extent().Get_XRange(), pPoints->Get_Extent().Get_YRange()); } lagDistance = maxDistance / nDistances; zMean = pPoints->Get_Mean(Attribute); Count .Create(nDistances); Variance .Create(nDistances); Covariance .Create(nDistances); //----------------------------------------------------- for(i=0, n=0; i<pPoints->Get_Count() && Set_Progress(n, SG_Get_Square(pPoints->Get_Count()/nSkip)/2); i+=nSkip) { pPoint = pPoints->Get_Shape(i); if( !pPoint->is_NoData(Attribute) ) { Pt_i = pPoint->Get_Point(0); zi = pPoint->asDouble(Attribute); for(j=i+nSkip; j<pPoints->Get_Count(); j+=nSkip, n++) { pPoint = pPoints->Get_Shape(j); if( !pPoint->is_NoData(Attribute) ) { Pt_j = pPoint->Get_Point(0); k = (int)(SG_Get_Distance(Pt_i, Pt_j) / lagDistance); if( k < nDistances ) { zj = pPoint->asDouble(Attribute); v = SG_Get_Square(zi - zj); c = (zi - zMean) * (zj - zMean); Count [k] ++; Variance [k] += v; Covariance[k] += c; } } } } } //----------------------------------------------------- pTable->Destroy(); pTable->Set_Name(CSG_String::Format(SG_T("%s [%s: %s]"), pPoints->Get_Name(), _TL("Variogram"), pPoints->Get_Field_Name(Attribute))); pTable->Add_Field(_TL("Class") , SG_DATATYPE_Int); // FIELD_CLASSNR pTable->Add_Field(_TL("Distance") , SG_DATATYPE_Double); // FIELD_DISTANCE pTable->Add_Field(_TL("Count") , SG_DATATYPE_Int); // FIELD_COUNT pTable->Add_Field(_TL("Variance") , SG_DATATYPE_Double); // FIELD_VARIANCE pTable->Add_Field(_TL("Cum.Var.") , SG_DATATYPE_Double); // FIELD_VARCUMUL pTable->Add_Field(_TL("Covariance") , SG_DATATYPE_Double); // FIELD_COVARIANCE pTable->Add_Field(_TL("Cum.Covar.") , SG_DATATYPE_Double); // FIELD_COVARCUMUL for(i=0, v=0.0, c=0.0, n=0; i<nDistances; i++) { if( Count[i] > 0 ) { n += (int)Count[i]; v += Variance [i]; c += Covariance[i]; pRecord = pTable->Add_Record(); pRecord->Set_Value(FIELD_CLASSNR , (i + 1)); pRecord->Set_Value(FIELD_DISTANCE , (i + 1) * lagDistance); pRecord->Set_Value(FIELD_COUNT , Count[i]); pRecord->Set_Value(FIELD_VARIANCE , 0.5 * Variance [i] / Count[i]); pRecord->Set_Value(FIELD_VARCUMUL , 0.5 * v / n); pRecord->Set_Value(FIELD_COVARIANCE , 1.0 * Covariance[i] / Count[i]); pRecord->Set_Value(FIELD_COVARCUMUL , 1.0 * c / n); } } return( true ); }
//--------------------------------------------------------- bool CMRVBF::On_Execute(void) { bool bUpdate; int Level; double T_Slope, Resolution, max_Resolution; CSG_Grid *pDEM, *pMRVBF, *pMRRTF, CF, VF, RF, DEM, Slope, Pctl; //----------------------------------------------------- pDEM = Parameters("DEM") ->asGrid(); pMRVBF = Parameters("MRVBF") ->asGrid(); pMRRTF = Parameters("MRRTF") ->asGrid(); T_Slope = Parameters("T_SLOPE") ->asDouble(); m_T_Pctl_V = Parameters("T_PCTL_V") ->asDouble(); m_T_Pctl_R = Parameters("T_PCTL_R") ->asDouble(); m_P_Slope = Parameters("P_SLOPE") ->asDouble(); m_P_Pctl = Parameters("P_PCTL") ->asDouble(); bUpdate = Parameters("UPDATE") ->asBool(); max_Resolution = Parameters("MAX_RES") ->asDouble() / 100.0; Resolution = SG_Get_Length(Get_System()->Get_XRange(), Get_System()->Get_YRange()); max_Resolution = max_Resolution * Resolution; //----------------------------------------------------- if( 1 ) { // DataObject_Set_Colors(pMRVBF, 100, SG_COLORS_WHITE_BLUE , false); DataObject_Set_Colors(pMRVBF, 100, SG_COLORS_RED_GREY_BLUE , false); // DataObject_Set_Colors(pMRRTF, 100, SG_COLORS_RED_GREY_BLUE , true); DataObject_Set_Colors(pMRRTF, 100, SG_COLORS_WHITE_RED , false); CSG_Grid CF, VF, RF, DEM, Slopes, Percentiles; VF.Create(*Get_System(), SG_DATATYPE_Float); RF.Create(*Get_System(), SG_DATATYPE_Float); CF.Create(*Get_System(), SG_DATATYPE_Float); CF.Assign(1.0); DEM.Create(*pDEM); //------------------------------------------------- Level = 1; Resolution = Get_Cellsize(); Process_Set_Text(CSG_String::Format(SG_T("%d. %s"), Level, _TL("step"))); Message_Add(CSG_String::Format(SG_T("%s: %d, %s: %.2f, %s %.2f"), _TL("step"), Level, _TL("resolution"), Resolution, _TL("threshold slope"), T_Slope)); Get_Slopes (&DEM, &Slopes); Get_Percentiles (&DEM, &Percentiles, 3); Get_Flatness (&Slopes, &Percentiles, &CF, pMRVBF, pMRRTF, T_Slope); UPDATE_VIEWS (true); //------------------------------------------------- T_Slope /= 2.0; Level++; Process_Set_Text(CSG_String::Format(SG_T("%d. %s"), Level, _TL("step"))); Message_Add(CSG_String::Format(SG_T("%s: %d, %s: %.2f, %s %.2f"), _TL("step"), Level, _TL("resolution"), Resolution, _TL("threshold slope"), T_Slope)); Get_Percentiles (&DEM, &Percentiles, 6); Get_Flatness (&Slopes, &Percentiles, &CF, &VF, &RF, T_Slope); Get_MRVBF (Level, pMRVBF, &VF, pMRRTF, &RF); UPDATE_VIEWS (false); //------------------------------------------------- while( Process_Get_Okay(false) && Resolution < max_Resolution ) { Resolution *= 3.0; T_Slope /= 2.0; Level++; Process_Set_Text(CSG_String::Format(SG_T("%d. %s"), Level, _TL("step"))); Message_Add(CSG_String::Format(SG_T("%s: %d, %s: %.2f, %s %.2f"), _TL("step"), Level, _TL("resolution"), Resolution, _TL("threshold slope"), T_Slope)); Get_Values (&DEM, &Slopes, &Percentiles, Resolution); Get_Flatness (&Slopes, &Percentiles, &CF, &VF, &RF, T_Slope); Get_MRVBF (Level, pMRVBF, &VF, pMRRTF, &RF); UPDATE_VIEWS (false); } if( Parameters("CLASSIFY")->asBool() ) { Get_Classified(pMRVBF); Get_Classified(pMRRTF); } return( true ); } return( false ); }
//--------------------------------------------------------- bool CSG_Variogram::Calculate(CSG_Shapes *pPoints, int Attribute, bool bLog, CSG_Table *pVariogram, int nClasses, double maxDistance, int nSkip) { int i, j, k, n; double z, lagDistance; TSG_Point p; CSG_Vector Count, Variance; CSG_Table_Record *pRecord; CSG_Shape *pPoint; //----------------------------------------------------- if( nSkip < 1 ) { nSkip = 1; } if( maxDistance <= 0.0 || maxDistance > SG_Get_Length(pPoints->Get_Extent().Get_XRange(), pPoints->Get_Extent().Get_YRange()) ) { maxDistance = SG_Get_Length(pPoints->Get_Extent().Get_XRange(), pPoints->Get_Extent().Get_YRange()); // bounding box' diagonal } lagDistance = maxDistance / nClasses; Count .Create(nClasses); Variance .Create(nClasses); //----------------------------------------------------- for(i=0, n=0; i<pPoints->Get_Count()-nSkip && SG_UI_Process_Set_Progress(n, SG_Get_Square(pPoints->Get_Count()/nSkip)/2); i+=nSkip) { pPoint = pPoints->Get_Shape(i); if( !pPoint->is_NoData(Attribute) ) { p = pPoint->Get_Point(0); z = bLog ? log(pPoint->asDouble(Attribute)) : pPoint->asDouble(Attribute); for(j=i+nSkip; j<pPoints->Get_Count(); j+=nSkip, n++) { pPoint = pPoints->Get_Shape(j); if( !pPoint->is_NoData(Attribute) ) { k = (int)(SG_Get_Distance(p, pPoint->Get_Point(0)) / lagDistance); if( k < nClasses ) { Count [k] ++; Variance[k] += SG_Get_Square((bLog ? log(pPoint->asDouble(Attribute)) : pPoint->asDouble(Attribute)) - z); } } } } } //----------------------------------------------------- pVariogram->Destroy(); pVariogram->Set_Name(CSG_String::Format(SG_T("%s [%s]"), _TL("Variogram"), pPoints->Get_Name())); pVariogram->Add_Field(_TL("Class") , SG_DATATYPE_Int); // FIELD_CLASS pVariogram->Add_Field(_TL("Distance") , SG_DATATYPE_Double); // FIELD_DISTANCE pVariogram->Add_Field(_TL("Count") , SG_DATATYPE_Int); // FIELD_COUNT pVariogram->Add_Field(_TL("Variance") , SG_DATATYPE_Double); // FIELD_VAR_EXP pVariogram->Add_Field(_TL("Var.cum.") , SG_DATATYPE_Double); // FIELD_VAR_CUM pVariogram->Add_Field(_TL("Model") , SG_DATATYPE_Double); // FIELD_VAR_MODEL for(i=0, z=0.0, n=0; i<nClasses; i++) { if( Count[i] > 0 ) { n += (int)Count[i]; z += Variance[i]; pRecord = pVariogram->Add_Record(); pRecord->Set_Value(FIELD_CLASS , (i + 1)); pRecord->Set_Value(FIELD_DISTANCE , (i + 1) * lagDistance); pRecord->Set_Value(FIELD_COUNT , Count[i]); pRecord->Set_Value(FIELD_VAR_EXP , 0.5 * Variance[i] / Count[i]); pRecord->Set_Value(FIELD_VAR_CUM , 0.5 * z / n); } } //----------------------------------------------------- return( SG_UI_Process_Get_Okay() ); }
//--------------------------------------------------------- bool CTC_Parameter_Base::Get_Parameter(CSG_Grid *pValues, CSG_Grid *pParameter) { DataObject_Set_Colors(pParameter, 10, SG_COLORS_RED_GREY_BLUE, true); //----------------------------------------------------- if( Parameters("METHOD")->asInt() == 0 ) { m_Kernel.Get_Weighting().Set_Parameters(&Parameters); m_Kernel.Get_Weighting().Set_BandWidth(Parameters("SCALE")->asDouble() * m_Kernel.Get_Weighting().Get_BandWidth()); m_Kernel.Set_Radius(Parameters("SCALE")->asDouble()); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { if( pValues->is_NoData(x, y) ) { pParameter->Set_NoData(x, y); } else { double d, w, nTotal = 0.0, nValid = 0.0; for(int i=0, ix, iy; i<m_Kernel.Get_Count(); i++) { if( m_Kernel.Get_Values(i, ix = x, iy = y, d, w, true) && pValues->is_InGrid(ix, iy) ) { nTotal += w; if( pValues->asInt(ix, iy) != 0 ) { nValid += w; } } } pParameter->Set_Value(x, y, nTotal > 0.0 ? 100.0 * nValid / nTotal : 0.0); // make percentage } } } m_Kernel.Destroy(); } //----------------------------------------------------- else { double Cellsize = Parameters("SCALE")->asInt() * 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 Values(CSG_Grid_System(Cellsize, Get_XMin(), Get_YMin(), Get_XMax(), Get_YMax()), SG_DATATYPE_Float); Values.Assign(pValues, GRID_RESAMPLING_Mean_Cells); 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( pValues->is_NoData(x, y) || !Values.Get_Value(px, py, z, GRID_RESAMPLING_BSpline) ) { pParameter->Set_NoData(x, y); } else { pParameter->Set_Value(x, y, 100.0 * z); // make percentage } } } } //----------------------------------------------------- return( true ); }