//--------------------------------------------------------- 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 ); }
//--------------------------------------------------------- bool CGridding_Spline_Base::_Get_Grid(void) { CSG_Grid *pGrid = m_bGridPoints ? Parameters("GRIDPOINTS")->asGrid () : NULL; CSG_Shapes *pShapes = !m_bGridPoints ? Parameters("SHAPES") ->asShapes() : NULL; //----------------------------------------------------- m_pGrid = NULL; switch( Parameters("TARGET")->asInt() ) { case 0: // user defined... if( m_Grid_Target.Init_User(m_bGridPoints ? pGrid->Get_Extent() : pShapes->Get_Extent()) && Dlg_Parameters("USER") ) { m_pGrid = m_Grid_Target.Get_User(); } break; case 1: // grid... if( Dlg_Parameters("GRID") ) { m_pGrid = m_Grid_Target.Get_Grid(); } break; } //------------------------------------------------- if( m_pGrid ) { m_pGrid->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_bGridPoints ? pGrid->Get_Name() : pShapes->Get_Name(), Get_Name())); m_pGrid->Assign_NoData(); } //----------------------------------------------------- return( m_pGrid != NULL ); }
bool CGrid_Aggregate::On_Execute(void) { int x,y; int x2,y2; int i,j; int iNX, iNY; int iSize = Parameters("SIZE")->asInt(); int iMethod = Parameters("METHOD")->asInt(); double dMin,dMax; double dSum; double dValue; iNX = (int) (Get_NX() / iSize); iNY = (int) (Get_NY() / iSize); CSG_Grid *pGrid = Parameters("INPUT")->asGrid(); CSG_Grid *pOutput = SG_Create_Grid(pGrid->Get_Type(), iNX, iNY, pGrid->Get_Cellsize() * iSize, pGrid->Get_XMin(), pGrid->Get_YMin()); pOutput->Set_Name(pGrid->Get_Name()); for (y = 0, y2 = 0; y2 < iNY; y+=iSize, y2++){ for (x = 0, x2 = 0; x2 < iNX; x+=iSize, x2++){ dMax = dMin = pGrid->asDouble(x,y); dSum = 0; for (i = 0; i < iSize; i++){ for (j = 0; j < iSize; j++){ dValue = pGrid->asDouble(x+i,y+j); if (dValue > dMax){ dMax = dValue; }//if if (dValue < dMin){ dMin = dValue; }//if dSum += dValue; }//for }//for switch (iMethod){ case SUM: pOutput->Set_Value(x2,y2,dSum); break; case MIN: pOutput->Set_Value(x2,y2,dMin); break; case MAX: pOutput->Set_Value(x2,y2,dMax); break; default: break; } }//for }//for DataObject_Add(pOutput); return true; }
//--------------------------------------------------------- bool CFilter_Resample::On_Execute(void) { //----------------------------------------------------- CSG_Grid *pGrid = Parameters("GRID" )->asGrid(); CSG_Grid *pLoPass = Parameters("LOPASS")->asGrid(); CSG_Grid *pHiPass = Parameters("HIPASS")->asGrid(); double Cellsize = Parameters("SCALE" )->asDouble() * Get_Cellsize(); //----------------------------------------------------- if( Cellsize > 0.5 * SG_Get_Length(Get_System().Get_XRange(), Get_System().Get_YRange()) ) { Error_Set(_TL("resampling cell size is too large")); return( false ); } //----------------------------------------------------- CSG_Grid Grid(CSG_Grid_System(Cellsize, Get_XMin(), Get_YMin(), Get_XMax(), Get_YMax()), SG_DATATYPE_Float); Grid.Assign(pGrid, GRID_RESAMPLING_Mean_Cells); //----------------------------------------------------- pLoPass->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("Low Pass" )); pHiPass->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("High Pass")); CSG_Colors Colors; DataObject_Get_Colors(pGrid , Colors); DataObject_Set_Colors(pLoPass, Colors); DataObject_Set_Colors(pHiPass, 11, SG_COLORS_RED_GREY_BLUE); //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { double py = Get_YMin() + y * Get_Cellsize(); #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { double z, px = Get_XMin() + x * Get_Cellsize(); if( !pGrid->is_NoData(x, y) && Grid.Get_Value(px, py, z) ) { pLoPass->Set_Value(x, y, z); pHiPass->Set_Value(x, y, pGrid->asDouble(x, y) - z); } else { pLoPass->Set_NoData(x, y); pHiPass->Set_NoData(x, y); } } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CPROJ4_Grid::Set_Shapes(CSG_Parameter_Grid_List *pSources, CSG_Shapes *pTarget) { int x, y, i; double z; TSG_Point Pt_Source, Pt_Target; CSG_Grid *pSource; CSG_Shape *pShape; if( pSources && pSources->Get_Count() > 0 && pTarget ) { pSource = pSources->asGrid(0); pTarget->Create(SHAPE_TYPE_Point, CSG_String::Format(SG_T("%s [%s]"), pSource->Get_Name(), Get_Proj_Name().c_str())); for(i=0; i<pSources->Get_Count(); i++) { pTarget->Add_Field(pSources->asGrid(i)->Get_Name(), pSources->asGrid(i)->Get_Type()); } for(y=0, Pt_Source.y=pSource->Get_YMin(); y<pSource->Get_NY() && Set_Progress(y, pSource->Get_NY()); y++, Pt_Source.y+=pSource->Get_Cellsize()) { for(x=0, Pt_Source.x=pSource->Get_XMin(); x<pSource->Get_NX(); x++, Pt_Source.x+=pSource->Get_Cellsize()) { if( !pSource->is_NoData(x, y) ) { Pt_Target = Pt_Source; if( Get_Converted(Pt_Target) ) { pShape = pTarget->Add_Shape(); pShape->Add_Point(Pt_Target); for(i=0; i<pSources->Get_Count(); i++) { if( pSources->asGrid(i)->Get_Value(Pt_Source, z, m_Interpolation) ) { pShape->Set_Value(i, z); } else { pShape->Set_NoData(i); } } } } } } return( true ); } return( false ); }
//--------------------------------------------------------- bool CGrid_Mask::On_Execute(void) { CSG_Grid *pGrid = Parameters("GRID")->asGrid(); CSG_Grid *pMask = Parameters("MASK")->asGrid(); if( !pGrid->is_Intersecting(pMask->Get_Extent()) ) { Message_Add(_TL("no intersection with mask grid.")); return( false ); } //----------------------------------------------------- CSG_Grid *pMasked = Parameters("MASKED")->asGrid(); if( pMasked && pMasked != pGrid ) { pMasked->Create(*pGrid); pMasked->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("masked")); pGrid = pMasked; } //----------------------------------------------------- Process_Set_Text(_TL("masking...")); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { double py = Get_YMin() + y * Get_Cellsize(); #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { if( !pGrid->is_NoData(x, y) ) { double px = Get_XMin() + x * Get_Cellsize(); if( !pMask->is_InGrid_byPos(px, py) ) { pGrid->Set_NoData(x, y); } } } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CGrid_Normalise::On_Execute(void) { CSG_Grid *pGrid = Parameters("INPUT")->asGrid(); if( pGrid->Get_StdDev() <= 0.0 ) { return( false ); } if( pGrid != Parameters("OUTPUT")->asGrid() ) { pGrid = Parameters("OUTPUT")->asGrid(); pGrid ->Assign(Parameters("INPUT")->asGrid()); } pGrid->Fmt_Name("%s (%s)", pGrid->Get_Name(), _TL("Normalized")); //----------------------------------------------------- double Minimum, Maximum, Offset, Scale; Minimum = Parameters("RANGE")->asRange()->Get_Min(); Maximum = Parameters("RANGE")->asRange()->Get_Max(); Offset = pGrid->Get_Min(); Scale = (Maximum - Minimum) / pGrid->Get_Range(); for(int y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++) { for(int x=0; x<Get_NX(); x++) { if( !pGrid->is_NoData(x, y) ) { pGrid->Set_Value(x, y, Minimum + Scale * (pGrid->asDouble(x, y) - Offset)); } } } //----------------------------------------------------- if( pGrid == Parameters("INPUT")->asGrid() ) { DataObject_Update(pGrid); } return( true ); }
//--------------------------------------------------------- bool CGrid_Standardise::On_Execute(void) { CSG_Grid *pGrid = Parameters("INPUT")->asGrid(); if( pGrid->Get_StdDev() <= 0.0 ) { return( false ); } if( pGrid != Parameters("OUTPUT")->asGrid() ) { pGrid = Parameters("OUTPUT")->asGrid(); pGrid ->Assign(Parameters("INPUT")->asGrid()); } pGrid->Fmt_Name("%s (%s)", pGrid->Get_Name(), _TL("Standard Score")); //----------------------------------------------------- double Mean = pGrid->Get_Mean(); double Stretch = Parameters("STRETCH")->asDouble() / pGrid->Get_StdDev(); for(int y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { if( !pGrid->is_NoData(x, y) ) { pGrid->Set_Value(x, y, Stretch * (pGrid->asDouble(x, y) - Mean)); } } } //----------------------------------------------------- if( pGrid == Parameters("INPUT")->asGrid() ) { DataObject_Update(pGrid); } return( true ); }
//--------------------------------------------------------- bool CGrid_Invert::On_Execute(void) { CSG_Grid *pGrid = Parameters("INVERSE")->asGrid(); if( pGrid == NULL ) { pGrid = Parameters("GRID")->asGrid(); } else if( pGrid != Parameters("GRID")->asGrid() ) { pGrid->Create(*Parameters("GRID")->asGrid()); pGrid->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("Inverse")); } //----------------------------------------------------- double zMin = pGrid->Get_Min(); double zMax = pGrid->Get_Max(); for(int y=0; y<Get_NY() && SG_UI_Process_Set_Progress(y, Get_NY()); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { if( !pGrid->is_NoData(x, y) ) { pGrid->Set_Value(x, y, zMax - (pGrid->asDouble(x, y) - zMin)); } } } //----------------------------------------------------- if( pGrid == Parameters("GRID")->asGrid() ) { DataObject_Update(pGrid); } return( true ); }
//--------------------------------------------------------- bool CGrid_To_Points_Random::On_Execute(void) { int x, y, n; double frequency; CSG_Grid *pGrid; CSG_Shape *pShape; CSG_Shapes *pShapes; pGrid = Parameters("GRID")->asGrid(); frequency = 1.0 / Parameters("FREQ")->asDouble(); pShapes = Parameters("POINTS")->asShapes(); pShapes->Create(SHAPE_TYPE_Point, pGrid->Get_Name()); pShapes->Add_Field("ID" , SG_DATATYPE_Int); pShapes->Add_Field("VALUE" , SG_DATATYPE_Double); srand((unsigned)time(NULL)); for(n=0, y=0; y<Get_NY() && Set_Progress(y); y++) { for(x=0; x<Get_NX(); x++) { if( (double)rand() / (double)RAND_MAX <= frequency ) { pShape = pShapes->Add_Shape(); pShape->Add_Point( pGrid->Get_XMin() + x * Get_Cellsize(), pGrid->Get_YMin() + y * Get_Cellsize() ); pShape->Set_Value(0, ++n); pShape->Set_Value(1, pGrid->asDouble(x, y)); } } } return( true ); }
//--------------------------------------------------------- bool CGCS_Grid_Longitude_Range::On_Execute(void) { CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList(); CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList(); if( pInput->Get_Count() <= 0 ) { Message_Dlg(_TL("nothing to do: no data in selection")); return( false ); } pOutput->Del_Items(); //----------------------------------------------------- int xZero; CSG_Grid_System Target; //----------------------------------------------------- if( Parameters("DIRECTION")->asInt() == 0 ) // 0 - 360 >> -180 - 180 { if( Get_XMax() <= 180.0 ) { Message_Add(_TL("Nothing to do. Raster is already within target range.")); return( true ); } else if( Get_XMin() >= 180.0 ) { xZero = 0; Target.Assign(Get_Cellsize(), Get_XMin() - 360.0, Get_YMin(), Get_NX(), Get_NY()); } else if( Get_XMax() - 360.0 < Get_XMin() - Get_Cellsize() ) { Error_Set(_TL("Nothing to do be done. Raster splitting is not supported.")); return( false ); } else { xZero = (int)(0.5 + 180.0 / Get_Cellsize()); Target.Assign(Get_Cellsize(), Get_XMin() - 180.0, Get_YMin(), Get_NX(), Get_NY()); } } //----------------------------------------------------- else // -180 - 180 >> 0 - 360 { if( Get_XMin() >= 0.0 ) { Message_Add(_TL("Nothing to do. Raster is already within target range.")); return( true ); } else if( Get_XMax() <= 0.0 ) { xZero = 0; Target.Assign(Get_Cellsize(), Get_XMin() + 360.0, Get_YMin(), Get_NX(), Get_NY()); } else if( Get_XMin() + 360.0 > Get_XMax() + Get_Cellsize() ) { Error_Set(_TL("Nothing to do be done. Raster splitting is not supported.")); return( false ); } else { xZero = (int)(0.5 + 180.0 / Get_Cellsize()); Target.Assign(Get_Cellsize(), Get_XMin() - 180.0, Get_YMin(), Get_NX(), Get_NY()); } } //----------------------------------------------------- for(int i=0; i<pInput->Get_Count() && Process_Get_Okay(); i++) { CSG_Grid *pIn = pInput->asGrid(i); CSG_Grid *pOut = SG_Create_Grid(Target, pIn->Get_Type()); pOut->Set_Name(pIn->Get_Name()); pOut->Set_NoData_Value_Range(pIn->Get_NoData_Value(), pIn->Get_NoData_hiValue()); pOut->Set_ZFactor(pIn->Get_ZFactor()); pOutput->Add_Item(pOut); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0, xx=xZero; x<Get_NX(); x++, xx++) { if( xx >= Get_NX() ) { xx = 0; } pOut->Set_Value(xx, y, pIn->asDouble(x, y)); } } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CSet_Grid_Georeference::On_Execute(void) { //----------------------------------------------------- CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList(); if( pGrids->Get_Count() <= 0 ) { return( false ); } //----------------------------------------------------- double xMin, yMin, size; switch( Parameters("DEFINITION")->asInt() ) { case 0: // cellsize and lower left center coordinates size = Parameters("SIZE")->asDouble(); xMin = Parameters("XMIN")->asDouble(); yMin = Parameters("YMIN")->asDouble(); break; case 1: // cellsize and lower left corner coordinates size = Parameters("SIZE")->asDouble(); xMin = Parameters("XMIN")->asDouble() + size * 0.5; yMin = Parameters("YMIN")->asDouble() + size * 0.5; break; case 2: // cellsize and upper left center coordinates size = Parameters("SIZE")->asDouble(); xMin = Parameters("XMIN")->asDouble(); yMin = Parameters("YMAX")->asDouble() - size * Get_NY(); break; case 3: // cellsize and upper left corner coordinates size = Parameters("SIZE")->asDouble(); xMin = Parameters("XMIN")->asDouble() + size * 0.5; yMin = Parameters("YMAX")->asDouble() - size * (0.5 + Get_NY()); break; case 4: // lower left and upper right center coordinates size = (Parameters("XMAX")->asDouble() - Parameters("XMIN")->asDouble()) / Get_NX(); xMin = Parameters("XMIN")->asDouble(); yMin = Parameters("YMIN")->asDouble(); break; case 5: // lower left and upper right corner coordinates size = (Parameters("XMAX")->asDouble() - Parameters("XMIN")->asDouble()) / (Get_NX() + 1); xMin = Parameters("XMIN")->asDouble() + size * 0.5; yMin = Parameters("YMIN")->asDouble() + size * 0.5; break; } //----------------------------------------------------- CSG_Grid_System System; if( !System.Assign(size, xMin, yMin, Get_NX(), Get_NY()) ) { return( false ); } //----------------------------------------------------- Parameters("REFERENCED")->asGridList()->Del_Items(); for(int i=0; i<pGrids->Get_Count() && Process_Get_Okay(); i++) { CSG_Grid *pGrid = pGrids->asGrid(i); CSG_Grid *pReferenced = SG_Create_Grid(System, pGrid->Get_Type()); pReferenced->Set_Name(pGrid->Get_Name()); pReferenced->Set_Unit(pGrid->Get_Unit()); pReferenced->Set_Scaling(pGrid->Get_Scaling(), pGrid->Get_Offset()); pReferenced->Set_NoData_Value_Range(pGrid->Get_NoData_Value(), pGrid->Get_NoData_hiValue()); pReferenced->Get_MetaData () = pGrid->Get_MetaData (); pReferenced->Get_Projection() = pGrid->Get_Projection(); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { pReferenced->Set_Value(x, y, pGrid->asDouble(x, y)); } } Parameters("REFERENCED")->asGridList()->Add_Item(pReferenced); } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CGrid_Merge::On_Execute(void) { //----------------------------------------------------- if( !Initialize() ) { return( false ); } //----------------------------------------------------- for(int i=0; i<m_pGrids->Get_Count(); i++) { CSG_Grid *pGrid = m_pGrids->asGrid(i); Set_Weight(pGrid); Get_Match(i > 0 ? pGrid : NULL); int ax = (int)((pGrid->Get_XMin() - m_pMosaic->Get_XMin()) / m_pMosaic->Get_Cellsize()); int ay = (int)((pGrid->Get_YMin() - m_pMosaic->Get_YMin()) / m_pMosaic->Get_Cellsize()); //------------------------------------------------- if( is_Aligned(pGrid) ) { Process_Set_Text(CSG_String::Format("[%d/%d] %s: %s", i + 1, m_pGrids->Get_Count(), _TL("copying"), pGrid->Get_Name())); int nx = pGrid->Get_NX(); if( nx > m_pMosaic->Get_NX() - ax ) nx = m_pMosaic->Get_NX() - ax; int ny = pGrid->Get_NY(); if( ny > m_pMosaic->Get_NY() - ay ) ny = m_pMosaic->Get_NY() - ay; for(int y=0; y<ny && Set_Progress(y, ny); y++) { if( ay + y >= 0 ) { #pragma omp parallel for for(int x=0; x<nx; x++) { if( ax + x >= 0 && !pGrid->is_NoData(x, y) ) { Set_Value(ax + x, ay + y, pGrid->asDouble(x, y), Get_Weight(x, y)); } } } } } //------------------------------------------------- else { Process_Set_Text(CSG_String::Format("[%d/%d] %s: %s", i + 1, m_pGrids->Get_Count(), _TL("resampling"), pGrid->Get_Name())); if( ax < 0 ) ax = 0; if( ay < 0 ) ay = 0; int nx = 1 + m_pMosaic->Get_System().Get_xWorld_to_Grid(pGrid->Get_XMax()); if( nx > m_pMosaic->Get_NX() ) nx = m_pMosaic->Get_NX(); int ny = 1 + m_pMosaic->Get_System().Get_yWorld_to_Grid(pGrid->Get_YMax()); if( ny > m_pMosaic->Get_NY() ) ny = m_pMosaic->Get_NY(); for(int y=ay; y<ny && Set_Progress(y-ay, ny-ay); y++) { double py = m_pMosaic->Get_YMin() + y * m_pMosaic->Get_Cellsize(); #pragma omp parallel for for(int x=ax; x<nx; x++) { double px = m_pMosaic->Get_XMin() + x * m_pMosaic->Get_Cellsize(); Set_Value(x, y, pGrid, px, py); } } } } //----------------------------------------------------- if( m_Overlap == 4 ) // mean { for(int y=0; y<m_pMosaic->Get_NY() && Set_Progress(y, m_pMosaic->Get_NY()); y++) { #pragma omp parallel for for(int x=0; x<m_pMosaic->Get_NX(); x++) { double w = m_Weights.asDouble(x, y); if( w > 0.0 ) { m_pMosaic->Mul_Value(x, y, 1.0 / w); } } } } //----------------------------------------------------- m_Weight .Destroy(); m_Weights.Destroy(); return( true ); }
//--------------------------------------------------------- bool CCRS_Transform_Grid::Transform(CSG_Parameter_Grid_List *pSources, CSG_Parameter_Grid_List *pTargets, const CSG_Grid_System &Target_System) { if( !m_Projector.Set_Inverse(true) || !pTargets || !pSources || pSources->Get_Count() < 1 ) { return( false ); } //----------------------------------------------------- CSG_Grid *pX, *pY; if( !Parameters("CREATE_XY")->asBool() ) { pX = pY = NULL; } else { Parameters("OUT_X")->Set_Value(pX = SG_Create_Grid(Target_System, SG_DATATYPE_Float)); pX->Assign_NoData(); pX->Set_Name(_TL("X-Coordinate")); pX->Get_Projection().Create(m_Projector.Get_Target()); Parameters("OUT_Y")->Set_Value(pY = SG_Create_Grid(Target_System, SG_DATATYPE_Float)); pY->Assign_NoData(); pY->Set_Name(_TL("Y-Coordinate")); pY->Get_Projection().Create(m_Projector.Get_Target()); } //----------------------------------------------------- bool bGeogCS_Adjust = m_Projector.Get_Source().Get_Type() == SG_PROJ_TYPE_CS_Geographic && pSources->asGrid(0)->Get_System().Get_XMax() > 180.0; Set_Target_Area(pSources->asGrid(0)->Get_System(), Target_System); //----------------------------------------------------- int i, n = pTargets->Get_Count(); for(i=0; i<pSources->Get_Count(); i++) { CSG_Grid *pSource = pSources->asGrid(i); CSG_Grid *pTarget = SG_Create_Grid(Target_System, m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float); if( pTarget ) { pTarget->Set_NoData_Value_Range (pSource->Get_NoData_Value(), pSource->Get_NoData_hiValue()); pTarget->Set_ZFactor (pSource->Get_ZFactor()); pTarget->Set_Name (CSG_String::Format(SG_T("%s"), pSource->Get_Name())); pTarget->Set_Unit (pSource->Get_Unit()); pTarget->Assign_NoData(); pTarget->Get_Projection().Create(m_Projector.Get_Target()); pTargets->Add_Item(pTarget); } } //------------------------------------------------- for(int y=0; y<Target_System.Get_NY() && Set_Progress(y, Target_System.Get_NY()); y++) { double yTarget = Target_System.Get_YMin() + y * Target_System.Get_Cellsize(); #pragma omp parallel for private(i) for(int x=0; x<Target_System.Get_NX(); x++) { double z, ySource, xSource = Target_System.Get_XMin() + x * Target_System.Get_Cellsize(); if( is_In_Target_Area(x, y) && m_Projector.Get_Projection(xSource, ySource = yTarget) ) { if( pX ) pX->Set_Value(x, y, xSource); if( pY ) pY->Set_Value(x, y, ySource); if( bGeogCS_Adjust && xSource < 0.0 ) { xSource += 360.0; } for(i=0; i<pTargets->Get_Count(); i++) { if( pSources->asGrid(i)->Get_Value(xSource, ySource, z, m_Interpolation) ) { pTargets->asGrid(n + i)->Set_Value(x, y, z); } } } } } //----------------------------------------------------- m_Target_Area.Destroy(); return( true ); }
//--------------------------------------------------------- bool CGrid_Mirror::On_Execute(void) { CSG_Grid *pGrid = Parameters("MIRROR")->asGrid(); if( pGrid == NULL ) { pGrid = Parameters("GRID")->asGrid(); } else if( pGrid != Parameters("GRID")->asGrid() ) { pGrid->Create(*Parameters("GRID")->asGrid()); pGrid->Fmt_Name("%s [%s %s]", pGrid->Get_Name(), _TL("mirrored"), Parameters("METHOD")->asString()); } //----------------------------------------------------- switch( Parameters("METHOD")->asInt() ) { //----------------------------------------------------- case 0: // vertically { for(int xa=0, xb=Get_NX()-1; xa<xb && SG_UI_Process_Set_Progress(xa, Get_NX()/2); xa++, xb--) { #pragma omp parallel for for(int y=0; y<Get_NY(); y++) { double d = pGrid->asDouble(xa, y); pGrid->Set_Value(xa, y, pGrid->asDouble(xb, y)); pGrid->Set_Value(xb, y, d); } } } break; //----------------------------------------------------- case 1: // horizontally { for(int ya=0, yb=Get_NY()-1; ya<yb && SG_UI_Process_Set_Progress(ya, Get_NY()/2); ya++, yb--) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { double d = pGrid->asDouble(x, ya); pGrid->Set_Value(x, ya, pGrid->asDouble(x, yb)); pGrid->Set_Value(x, yb, d); } } } break; //----------------------------------------------------- default: // both { for(int ya=0, yb=Get_NY()-1; ya<=yb && SG_UI_Process_Set_Progress(ya, Get_NY()/2); ya++, yb--) { for(int xa=0, xb=Get_NX()-1; xa<=xb; xa++, xb--) { if( ya < yb && xa < xb ) { double d = pGrid->asDouble(xa, ya); pGrid->Set_Value(xa, ya, pGrid->asDouble(xb, yb)); pGrid->Set_Value(xb, yb, d); d = pGrid->asDouble(xa, yb); pGrid->Set_Value(xa, yb, pGrid->asDouble(xb, ya)); pGrid->Set_Value(xb, ya, d); } else if( xa < xb ) { double d = pGrid->asDouble(xa, ya); pGrid->Set_Value(xa, ya, pGrid->asDouble(xb, ya)); pGrid->Set_Value(xb, ya, d); } else if( ya < yb ) { double d = pGrid->asDouble(xa, ya); pGrid->Set_Value(xa, ya, pGrid->asDouble(xa, yb)); pGrid->Set_Value(xa, yb, d); } } } } break; } //----------------------------------------------------- if( pGrid == Parameters("GRID")->asGrid() ) { DataObject_Update(pGrid); } 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 CGrid_PCA_Focal::On_Execute(void) { int i; //----------------------------------------------------- CSG_Grid_Cell_Addressor Kernel; Kernel.Set_Radius( Parameters("KERNEL_RADIUS")->asInt(), Parameters("KERNEL_TYPE" )->asInt() == 0 ); CSG_Parameter_Grid_List *pPCA, *pGrids = Parameters("BASE")->asGridList(); pGrids->Del_Items(); for(i=0; i<Kernel.Get_Count()-1; i++) { CSG_Grid *pGrid = SG_Create_Grid(Get_System()); if( !pGrid ) { Error_Set(_TL("failed to allocate memory")); for(i=0; i<pGrids->Get_Grid_Count(); i++) { delete(pGrids->Get_Grid(i)); } pGrids->Del_Items(); return( false ); } pGrid->Fmt_Name("x(%d)-y(%d)", Kernel.Get_X(i + 1), Kernel.Get_Y(i + 1)); pGrids->Add_Item(pGrid); } //----------------------------------------------------- CSG_Grid *pGrid = Parameters("GRID")->asGrid(); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for private(i) for(int x=0; x<Get_NX(); x++) { if( pGrid->is_NoData(x, y) ) { for(i=0; i<pGrids->Get_Grid_Count(); i++) { pGrids->Get_Grid(i)->Set_NoData(x, y); } } else { double z = pGrid->asDouble(x, y); for(i=0; i<pGrids->Get_Grid_Count(); i++) { int ix = Kernel.Get_X(i + 1, x); int iy = Kernel.Get_Y(i + 1, y); pGrids->Get_Grid(i)->Set_Value(x, y, pGrid->is_InGrid(ix, iy) ? z - pGrid->asDouble(ix, iy) : 0.0); } } } } //----------------------------------------------------- bool bResult; CSG_Parameters PCA_Parms; SG_RUN_TOOL_KEEP_PARMS(bResult, "statistics_grid", 8, PCA_Parms, // pca analysis for grids SG_TOOL_PARAMETER_SET("GRIDS" , Parameters("BASE" )) && SG_TOOL_PARAMETER_SET("METHOD" , Parameters("METHOD" )) && SG_TOOL_PARAMETER_SET("EIGEN" , Parameters("EIGEN" )) && SG_TOOL_PARAMETER_SET("COMPONENTS", Parameters("COMPONENTS")->asInt()) ); if( !Parameters("BASE_OUT")->asBool() ) { for(i=0; i<pGrids->Get_Grid_Count(); i++) { delete(pGrids->Get_Grid(i)); } pGrids->Del_Items(); } //----------------------------------------------------- pGrids = Parameters("PCA")->asGridList(); pPCA = PCA_Parms ("PCA")->asGridList(); if( !Parameters("OVERWRITE")->asBool() || (pGrids->Get_Grid_Count() > 0 && !Get_System().is_Equal(pGrids->Get_Grid(0)->Get_System())) ) { pGrids->Del_Items(); } for(i=0; i<pPCA->Get_Grid_Count(); i++) { if( pGrids->Get_Grid(i) ) { pGrids->Get_Grid(i)->Assign(pPCA->Get_Grid(i)); delete(pPCA->Get_Grid(i)); } else { pGrids->Add_Item(pPCA->Get_Grid(i)); } pGrids->Get_Grid(i)->Fmt_Name("%s [PC%0*d]", pGrid->Get_Name(), pPCA->Get_Grid_Count() < 10 ? 1 : 2, i + 1); } //----------------------------------------------------- return( bResult ); }
//--------------------------------------------------------- bool CGrid_RGB_Composite::On_Execute(void) { double rMin, rRange, gMin, gRange, bMin, bRange, aMin, aRange; //----------------------------------------------------- CSG_Grid *pR = _Get_Grid(Parameters("R_GRID")->asGrid(), Parameters("R_METHOD")->asInt(), Parameters("R_RANGE")->asRange(), Parameters("R_PERCTL")->asRange(), Parameters("R_STDDEV")->asDouble(), rMin, rRange); CSG_Grid *pG = _Get_Grid(Parameters("G_GRID")->asGrid(), Parameters("G_METHOD")->asInt(), Parameters("G_RANGE")->asRange(), Parameters("G_PERCTL")->asRange(), Parameters("G_STDDEV")->asDouble(), gMin, gRange); CSG_Grid *pB = _Get_Grid(Parameters("B_GRID")->asGrid(), Parameters("B_METHOD")->asInt(), Parameters("B_RANGE")->asRange(), Parameters("B_PERCTL")->asRange(), Parameters("B_STDDEV")->asDouble(), bMin, bRange); CSG_Grid *pA = _Get_Grid(Parameters("A_GRID")->asGrid(), Parameters("A_METHOD")->asInt(), Parameters("A_RANGE")->asRange(), Parameters("A_PERCTL")->asRange(), Parameters("A_STDDEV")->asDouble(), aMin, aRange); //----------------------------------------------------- CSG_Grid *pRGB = Parameters("RGB")->asGrid(); pRGB->Create(pRGB->Get_System(), SG_DATATYPE_Int); pRGB->Set_Name(_TL("Composite")); CSG_String s; s += CSG_String(_TL("Red" )) + ": " + pR->Get_Name() + "\n"; s += CSG_String(_TL("Green")) + ": " + pG->Get_Name() + "\n"; s += CSG_String(_TL("Blue" )) + ": " + pB->Get_Name() + "\n"; if( pA ) { s += CSG_String(_TL("Alpha")) + ": " + pA->Get_Name() + "\n"; } pRGB->Set_Description(s); DataObject_Set_Colors (pRGB, 100, SG_COLORS_BLACK_WHITE); DataObject_Set_Parameter(pRGB, "COLORS_TYPE", 5); // Color Classification Type: RGB Coded Values //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { if( pR->is_NoData(x, y) || pG->is_NoData(x, y) || pB->is_NoData(x, y) || (pA && pA->is_NoData(x, y)) ) { pRGB->Set_NoData(x, y); } else { int r = (int)(rRange * (pR->asDouble(x, y) - rMin)); if( r > 255 ) r = 255; else if( r < 0 ) r = 0; int g = (int)(gRange * (pG->asDouble(x, y) - gMin)); if( g > 255 ) g = 255; else if( g < 0 ) g = 0; int b = (int)(bRange * (pB->asDouble(x, y) - bMin)); if( b > 255 ) b = 255; else if( b < 0 ) b = 0; if( pA ) { int a = (int)(aRange * (pA->asDouble(x, y) - aMin)); if( a > 255 ) a = 255; else if( a < 0 ) a = 0; pRGB->Set_Value(x, y, SG_GET_RGBA(r, g, b, a)); } else { pRGB->Set_Value(x, y, SG_GET_RGB (r, g, b)); } } } } return( true ); }
//--------------------------------------------------------- bool CGrid_Values_AddTo_Shapes::On_Execute(void) { CSG_Parameter_Grid_List *pGrids; CSG_Shapes *pShapes; //----------------------------------------------------- pShapes = Parameters("RESULT")->asShapes(); pGrids = Parameters("GRIDS" )->asGridList(); //----------------------------------------------------- if( pGrids->Get_Count() <= 0 ) { return( false ); } //----------------------------------------------------- if( pShapes == NULL ) { pShapes = Parameters("SHAPES")->asShapes(); } else if( pShapes != Parameters("SHAPES")->asShapes() ) { pShapes->Create(*Parameters("SHAPES")->asShapes()); } //----------------------------------------------------- switch( Parameters("RESAMPLING")->asInt() ) { default: m_Resampling = GRID_RESAMPLING_NearestNeighbour; break; case 1: m_Resampling = GRID_RESAMPLING_Bilinear; break; case 2: m_Resampling = GRID_RESAMPLING_BicubicSpline; break; case 3: m_Resampling = GRID_RESAMPLING_BSpline; break; } //----------------------------------------------------- for(int iGrid=0; iGrid<pGrids->Get_Count(); iGrid++) { CSG_Grid *pGrid = pGrids->asGrid(iGrid); int Field = pShapes->Get_Field_Count(); pShapes->Add_Field(pGrid->Get_Name(), SG_DATATYPE_Double); for(int iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++) { CSG_Simple_Statistics Statistics; CSG_Shape *pShape = pShapes->Get_Shape(iShape); if( pShape->Get_Extent().Intersects(pGrid->Get_Extent()) ) { switch( pShapes->Get_Type() ) { case SHAPE_TYPE_Point: default: case SHAPE_TYPE_Points: Get_Data_Point (Statistics, pShape, pGrid); break; case SHAPE_TYPE_Line: Get_Data_Line (Statistics, pShape, pGrid); break; case SHAPE_TYPE_Polygon: Get_Data_Polygon(Statistics, pShape, pGrid); break; } } if( Statistics.Get_Count() > 0 ) { pShape->Set_Value(Field, Statistics.Get_Mean()); } else { pShape->Set_NoData(Field); } } } //----------------------------------------------------- if( pShapes == Parameters("SHAPES")->asShapes() ) { DataObject_Update(pShapes); } return( true ); }
//--------------------------------------------------------- bool CFilter_3x3::On_Execute(void) { //----------------------------------------------------- CSG_Table *pFilter = Parameters("FILTER")->asTable() ? Parameters("FILTER" )->asTable() : Parameters("FILTER_3X3")->asTable(); if( pFilter->Get_Count() < 1 || pFilter->Get_Field_Count() < 1 ) { Error_Set(_TL("invalid filter matrix")); return( false ); } //----------------------------------------------------- CSG_Matrix Filter(pFilter->Get_Field_Count(), pFilter->Get_Count()); { for(int iy=0; iy<Filter.Get_NY(); iy++) { CSG_Table_Record *pRecord = pFilter->Get_Record(iy); for(int ix=0; ix<Filter.Get_NX(); ix++) { Filter[iy][ix] = pRecord->asDouble(ix); } } } int nx = (Filter.Get_NX() - 1) / 2; int ny = (Filter.Get_NY() - 1) / 2; //----------------------------------------------------- CSG_Grid *pInput = Parameters("INPUT" )->asGrid(); CSG_Grid *pResult = Parameters("RESULT")->asGrid(); if( !pResult || pResult == pInput ) { pResult = SG_Create_Grid(pInput); } else { pResult->Fmt_Name("%s [%s]", pInput->Get_Name(), _TL("Filter")); pResult->Set_NoData_Value(pInput->Get_NoData_Value()); } //----------------------------------------------------- bool bAbsolute = Parameters("ABSOLUTE")->asBool(); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { double s = 0.0; double n = 0.0; if( pInput->is_InGrid(x, y) ) { for(int iy=0, jy=y-ny; iy<Filter.Get_NY(); iy++, jy++) { for(int ix=0, jx=x-nx; ix<Filter.Get_NX(); ix++, jx++) { if( pInput->is_InGrid(jx, jy) ) { s += Filter[iy][ix] * pInput->asDouble(jx, jy); n += fabs(Filter[iy][ix]); } } } } if( n > 0.0 ) { pResult->Set_Value(x, y, bAbsolute ? s : s / n); } else { pResult->Set_NoData(x, y); } } } //----------------------------------------------------- if( !Parameters("RESULT")->asGrid() || Parameters("RESULT")->asGrid() == pInput ) { pInput->Assign(pResult); delete(pResult); DataObject_Update(pInput); } return( true ); }
//--------------------------------------------------------- CSG_Grid * CLandsat_Import::Get_Band(const CSG_String &File) { CSG_Data_Manager tmpMgr; if( !tmpMgr.Add(File) || !tmpMgr.Get_Grid_System(0) || !tmpMgr.Get_Grid_System(0)->Get(0) ) { Error_Set(CSG_String::Format(SG_T("%s: %s"), _TL("could not load file"), File.c_str())); return( NULL ); } tmpMgr.Get_Grid_System(0)->Get(0)->Set_NoData_Value(0); // landsat 8 pretends to use a value of 65535 (2^16 - 1) CSG_Grid *pBand = NULL; //----------------------------------------------------- if( !tmpMgr.Get_Grid_System(0)->Get(0)->Get_Projection().is_Okay() ) { // undefined coordinate system, nothing to do be done further... } //----------------------------------------------------- else if( Parameters("PROJECTION")->asInt() == 2 ) // Geographic Coordinates { pBand = Get_Projection((CSG_Grid *)tmpMgr.Get_Grid_System(0)->Get(0), "+proj=longlat +ellps=WGS84 +datum=WGS84"); } //----------------------------------------------------- else // UTM { CSG_Grid *pTmp = (CSG_Grid *)tmpMgr.Get_Grid_System(0)->Get(0); CSG_String Projection = pTmp->Get_Projection().Get_Proj4(); if( Projection.Find("+proj=utm") >= 0 && ( (Projection.Find("+south") >= 0 && Parameters("PROJECTION")->asInt() == 0) || (Projection.Find("+south") < 0 && Parameters("PROJECTION")->asInt() == 1)) && (pBand = SG_Create_Grid(pTmp->Get_Type(), pTmp->Get_NX(), pTmp->Get_NY(), pTmp->Get_Cellsize(), pTmp->Get_XMin(), pTmp->Get_YMin() + (Parameters("PROJECTION")->asInt() == 1 ? 10000000 : -10000000) )) != NULL ) { if( Parameters("PROJECTION")->asInt() == 1 ) Projection.Append (" +south"); else Projection.Replace(" +south", ""); pBand->Get_Projection().Create(Projection, SG_PROJ_FMT_Proj4); pBand->Set_Name (pTmp->Get_Name()); pBand->Set_Description (pTmp->Get_Description()); pBand->Set_NoData_Value_Range(pTmp->Get_NoData_Value(), pTmp->Get_NoData_hiValue()); pBand->Set_Scaling (pTmp->Get_Scaling(), pTmp->Get_Offset()); #pragma omp parallel for for(int y=0; y<pBand->Get_NY(); y++) { for(int x=0; x<pBand->Get_NX(); x++) { pBand->Set_Value(x, y, pTmp->asDouble(x, y)); } } } } //----------------------------------------------------- if( !pBand ) { pBand = (CSG_Grid *)tmpMgr.Get_Grid_System(0)->Get(0); tmpMgr.Delete(tmpMgr.Get_Grid_System(0)->Get(0), true); // make permanent, detach from temporary data manager } return( pBand ); }
//--------------------------------------------------------- bool CGSGrid_Statistics_To_Table::On_Execute(void) { //----------------------------------------------------- CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList(); if( pGrids->Get_Count() < 1 ) { Error_Set(_TL("no grids in selection")); return( false ); } //----------------------------------------------------- CSG_Table *pTable = Parameters("STATS")->asTable(); pTable->Destroy(); pTable->Set_Name(_TL("Statistics for Grids")); pTable->Add_Field(_TL("NAME"), SG_DATATYPE_String); if( Parameters("DATA_CELLS" )->asBool() ) pTable->Add_Field(_TL("DATA_CELLS" ), SG_DATATYPE_Int); if( Parameters("NODATA_CELLS")->asBool() ) pTable->Add_Field(_TL("NODATA_CELLS"), SG_DATATYPE_Int); if( Parameters("CELLSIZE" )->asBool() ) pTable->Add_Field(_TL("CELLSIZE" ), SG_DATATYPE_Double); if( Parameters("MEAN" )->asBool() ) pTable->Add_Field(_TL("MEAN" ), SG_DATATYPE_Double); if( Parameters("MIN" )->asBool() ) pTable->Add_Field(_TL("MIN" ), SG_DATATYPE_Double); if( Parameters("MAX" )->asBool() ) pTable->Add_Field(_TL("MAX" ), SG_DATATYPE_Double); if( Parameters("RANGE" )->asBool() ) pTable->Add_Field(_TL("RANGE" ), SG_DATATYPE_Double); if( Parameters("VAR" )->asBool() ) pTable->Add_Field(_TL("VAR" ), SG_DATATYPE_Double); if( Parameters("STDDEV" )->asBool() ) pTable->Add_Field(_TL("STDDEV" ), SG_DATATYPE_Double); if( Parameters("STDDEVLO" )->asBool() ) pTable->Add_Field(_TL("STDDEVLO" ), SG_DATATYPE_Double); if( Parameters("STDDEVHI" )->asBool() ) pTable->Add_Field(_TL("STDDEVHI" ), SG_DATATYPE_Double); if( Parameters("PCTL" )->asBool() ) pTable->Add_Field(_TL("PCTL" ), SG_DATATYPE_Double); if( pTable->Get_Field_Count() <= 1 ) { Error_Set(_TL("no parameter output specified")); return( false ); } double dRank = Parameters("PCTL")->asBool() ? Parameters("PCTL_VAL")->asDouble() : -1.0; //----------------------------------------------------- for(int i=0; i<pGrids->Get_Count() && Process_Get_Okay(); i++) { CSG_Grid *pGrid = pGrids->asGrid(i); CSG_Table_Record *pRecord = pTable->Add_Record(); pRecord->Set_Value("NAME" , pGrid->Get_Name()); pRecord->Set_Value("DATA_CELLS" , pGrid->Get_NCells() - pGrid->Get_NoData_Count()); pRecord->Set_Value("NODATA_CELLS", pGrid->Get_NoData_Count()); pRecord->Set_Value("CELLSIZE" , pGrid->Get_Cellsize()); pRecord->Set_Value("MEAN" , pGrid->Get_ArithMean()); pRecord->Set_Value("MIN" , pGrid->Get_ZMin()); pRecord->Set_Value("MAX" , pGrid->Get_ZMax()); pRecord->Set_Value("RANGE" , pGrid->Get_ZRange()); pRecord->Set_Value("VAR" , pGrid->Get_Variance()); pRecord->Set_Value("STDDEV" , pGrid->Get_StdDev()); pRecord->Set_Value("STDDEVLO" , pGrid->Get_ArithMean() - pGrid->Get_StdDev()); pRecord->Set_Value("STDDEVHI" , pGrid->Get_ArithMean() + pGrid->Get_StdDev()); if( dRank > 0.0 && dRank < 100.0 ) { pRecord->Set_Value("PCTL", pGrid->Get_Percentile(dRank)); // this is a time consuming operation } } if( dRank > 0.0 && dRank < 100.0 ) { pTable->Set_Field_Name(pTable->Get_Field_Count() - 1, CSG_String::Format(SG_T("%s%02d"), _TL("PCTL"), (int)dRank)); } return( true ); }
//--------------------------------------------------------- bool CGrid_Value_Type::On_Execute(void) { //----------------------------------------------------- CSG_Grid *pOutput = Parameters("OUTPUT")->asGrid(); CSG_Grid *pInput = Parameters("INPUT" )->asGrid(), Input; if( pOutput == NULL || pOutput == pInput ) { Input.Create(*pInput); pOutput = pInput; pInput = &Input; } //----------------------------------------------------- double Offset = Parameters("OFFSET")->asDouble(); double Scale = Parameters("SCALE" )->asDouble(); if( Scale == 0.0 ) { Error_Set(_TL("scale factor must not equal zero")); return( false ); } //----------------------------------------------------- switch( Parameters("TYPE")->asInt() ) { default: Error_Set(_TL("undefined data type")); return( false ); case 0: pOutput->Create(*Get_System(), SG_DATATYPE_Bit ); break; case 1: pOutput->Create(*Get_System(), SG_DATATYPE_Byte ); break; case 2: pOutput->Create(*Get_System(), SG_DATATYPE_Char ); break; case 3: pOutput->Create(*Get_System(), SG_DATATYPE_Word ); break; case 4: pOutput->Create(*Get_System(), SG_DATATYPE_Short ); break; case 5: pOutput->Create(*Get_System(), SG_DATATYPE_DWord ); break; case 6: pOutput->Create(*Get_System(), SG_DATATYPE_Int ); break; case 7: pOutput->Create(*Get_System(), SG_DATATYPE_Float ); break; case 8: pOutput->Create(*Get_System(), SG_DATATYPE_Double); break; } pOutput->Set_Name (pInput->Get_Name ()); pOutput->Set_Description(pInput->Get_Description()); pOutput->Set_Unit (pInput->Get_Unit ()); pOutput->Set_Scaling (Scale, Offset); //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { if( pInput->is_NoData(x, y) ) { pOutput->Set_NoData(x, y); } else { pOutput->Set_Value(x, y, pInput->asDouble(x, y)); } } } //----------------------------------------------------- if( pOutput == Parameters("INPUT")->asGrid() ) { DataObject_Update(pOutput); } return( true ); }
//--------------------------------------------------------- bool CCRS_Transform_Grid::Transform(CSG_Parameter_Grid_List *pSources, CSG_Parameter_Grid_List *pTargets, const CSG_Grid_System &Target_System) { if( !m_Projector.Set_Inverse(true) || !pTargets || !pSources || pSources->Get_Count() < 1 ) { return( false ); } //----------------------------------------------------- CSG_Grid *pX, *pY; if( (pX = m_Grid_Target.Get_Grid("OUT_X")) != NULL ) { pX->Assign_NoData(); pX->Set_Name(_TL("X Coordinates")); pX->Get_Projection().Create(m_Projector.Get_Target()); } if( (pY = m_Grid_Target.Get_Grid("OUT_Y")) != NULL ) { pY->Assign_NoData(); pY->Set_Name(_TL("Y Coordinates")); pY->Get_Projection().Create(m_Projector.Get_Target()); } //----------------------------------------------------- bool bGeogCS_Adjust = m_Projector.Get_Source().Get_Type() == SG_PROJ_TYPE_CS_Geographic && pSources->asGrid(0)->Get_System().Get_XMax() > 180.0; Set_Target_Area(pSources->asGrid(0)->Get_System(), Target_System); bool bKeepType = m_Resampling == GRID_RESAMPLING_NearestNeighbour || Parameters("KEEP_TYPE")->asBool(); //----------------------------------------------------- int i, n = pTargets->Get_Count(); for(i=0; i<pSources->Get_Count(); i++) { CSG_Grid *pSource = pSources->asGrid(i); CSG_Grid *pTarget = SG_Create_Grid(Target_System, bKeepType ? pSource->Get_Type() : SG_DATATYPE_Float); if( pTarget ) { pTargets->Add_Item(pTarget); pTarget->Set_NoData_Value_Range (pSource->Get_NoData_Value(), pSource->Get_NoData_hiValue()); pTarget->Set_Scaling (pSource->Get_Scaling(), pSource->Get_Offset()); pTarget->Set_Name (pSource->Get_Name()); pTarget->Set_Unit (pSource->Get_Unit()); pTarget->Get_Projection().Create(m_Projector.Get_Target()); pTarget->Assign_NoData(); CSG_Parameters Parms; if( DataObject_Get_Parameters(pSource, Parms) ) { DataObject_Add(pTarget); DataObject_Set_Parameters(pTarget, Parms); } } } //------------------------------------------------- for(int y=0; y<Target_System.Get_NY() && Set_Progress(y, Target_System.Get_NY()); y++) { double yTarget = Target_System.Get_YMin() + y * Target_System.Get_Cellsize(); // #pragma omp parallel for private(i) for(int x=0; x<Target_System.Get_NX(); x++) { double z, ySource, xSource = Target_System.Get_XMin() + x * Target_System.Get_Cellsize(); if( is_In_Target_Area(x, y) && m_Projector.Get_Projection(xSource, ySource = yTarget) ) { if( bGeogCS_Adjust ) { if( xSource < 0.0 ) { xSource += 360.0; } else if( xSource >= 360.0 ) { xSource -= 360.0; } } if( pX ) pX->Set_Value(x, y, xSource); if( pY ) pY->Set_Value(x, y, ySource); for(i=0; i<pSources->Get_Count(); i++) { if( pSources->asGrid(i)->Get_Value(xSource, ySource, z, m_Resampling, false, true) ) { pTargets->asGrid(n + i)->Set_Value(x, y, z); } } } } } //----------------------------------------------------- m_Target_Area.Destroy(); return( true ); }