//--------------------------------------------------------- // Returns the flow direction for a cell at x and y. //--------------------------------------------------------- int CExercise_04::Get_Flow_Direction(CSG_Grid *grid, int x, int y) { int result = -1; double resultAngle = 0; CSG_Grid_System system = grid->Get_System(); double myElevation = grid->asDouble(x, y); for (int direction = 0; direction < 8; direction++) { int nx, ny; double length, nElevation, dz, angle; length = system.Get_Length(direction); // Get neighbor position nx = system.Get_xTo(direction, x); ny = system.Get_yTo(direction, y); if (grid->is_InGrid(nx, ny)) { nElevation = grid->asDouble(nx, ny); dz = myElevation - nElevation; angle = atan(dz / length); if (angle > resultAngle) { result = direction; resultAngle = angle; } } } return result; }
int SG_Grid_Cache_Check(CSG_Grid_System &m_System, int nValueBytes) { if( SG_Grid_Cache_Get_Automatic() && m_System.Get_NCells() * nValueBytes > SG_Grid_Cache_Get_Threshold() ) { switch( SG_Grid_Cache_Get_Confirm() ) { default: break; case 1: { CSG_String s; s.Printf(SG_T("%s\n%s\n%s: %.2fMB"), LNG("Shall I activate file caching for new grid."), m_System.Get_Name(), LNG("Total memory size"), (m_System.Get_NCells() * nValueBytes) / (double)N_MEGABYTE_BYTES ); if( SG_UI_Dlg_Continue(s, LNG("Activate Grid File Cache?")) ) { // Memory_Type = GRID_MEMORY_Cache; return( SG_Grid_Cache_Get_Threshold() ); } } break; case 2: { CSG_Parameters p(NULL, LNG("Activate Grid File Cache?"), SG_T("")); p.Add_Value( NULL , SG_T("BUFFERSIZE") , LNG("Buffer Size [MB]"), SG_T(""), PARAMETER_TYPE_Double, SG_Grid_Cache_Get_Threshold_MB(), 0.0, true ); if( SG_UI_Dlg_Parameters(&p, LNG("Activate Grid File Cache?")) ) { // Memory_Type = GRID_MEMORY_Cache; // Set_Buffer_Size((int)(p(SG_T("BUFFERSIZE"))->asDouble() * N_MEGABYTE_BYTES)); return( (int)(p(SG_T("BUFFERSIZE"))->asDouble() * N_MEGABYTE_BYTES) ); } } break; } } return( 0 ); }
//--------------------------------------------------------- bool CPROJ4_Grid::Set_Grids(CSG_Parameter_Grid_List *pSources, CSG_Parameter_Grid_List *pTargets) { if( !pSources || pSources->Get_Count() < 1 || !pTargets || pTargets->Get_Count() != pSources->Get_Count() || !Set_Inverse() ) { return( false ); } //------------------------------------------------- int x, y, i; double z; TSG_Point Pt_Source, Pt_Target; CSG_Grid_System System; CSG_Grid *pX, *pY; System = pTargets->asGrid(0)->Get_System(); Init_XY(System, &pX, &pY); //------------------------------------------------- for(y=0, Pt_Target.y=System.Get_YMin(); y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y++, Pt_Target.y+=System.Get_Cellsize()) { for(x=0, Pt_Target.x=System.Get_XMin(); x<System.Get_NX(); x++, Pt_Target.x+=System.Get_Cellsize()) { Pt_Source = Pt_Target; if( Get_Converted(Pt_Source) ) { if( pX ) pX->Set_Value(x, y, Pt_Source.x); if( pY ) pY->Set_Value(x, y, Pt_Source.y); for(i=0; i<pSources->Get_Count(); i++) { if( pSources->asGrid(i)->Get_Value(Pt_Source, z, m_Interpolation) ) { pTargets->asGrid(i)->Set_Value(x, y, z); } } } } } 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 CCRS_Transform_Grid::Set_Target_Area(const CSG_Grid_System &Source, const CSG_Grid_System &Target) { if( Parameters("TARGET_AREA")->asBool() == false ) { m_Target_Area.Destroy(); return( true ); } //----------------------------------------------------- CSG_Rect r(Source.Get_Extent()); if( m_Projector.Get_Source().Get_Type() == SG_PROJ_TYPE_CS_Geographic ) { if( r.Get_XMax() > 180.0 ) r.Move(-180.0, 0.0); if( r.Get_YMin() < -90.0 ) r.m_rect.yMin = -90.0; if( r.Get_YMax() < 90.0 ) r.m_rect.yMax = 90.0; } //----------------------------------------------------- CSG_Shapes Area(SHAPE_TYPE_Polygon); CSG_Shape_Polygon *pArea = (CSG_Shape_Polygon *)Area.Add_Shape(); TSG_Point p, q; double dx = Source.Get_XRange() / 100.0; double dy = Source.Get_YRange() / 100.0; m_Projector.Set_Inverse(false); for(p.x=r.Get_XMin(), p.y=r.Get_YMin(); p.y<r.Get_YMax(); p.y+=dy) { m_Projector.Get_Projection(q = p); pArea->Add_Point(q); } for(p.x=r.Get_XMin(), p.y=r.Get_YMax(); p.x<r.Get_XMax(); p.x+=dx) { m_Projector.Get_Projection(q = p); pArea->Add_Point(q); } for(p.x=r.Get_XMax(), p.y=r.Get_YMax(); p.y>r.Get_YMin(); p.y-=dy) { m_Projector.Get_Projection(q = p); pArea->Add_Point(q); } for(p.x=r.Get_XMax(), p.y=r.Get_YMin(); p.x>r.Get_XMin(); p.x-=dx) { m_Projector.Get_Projection(q = p); pArea->Add_Point(q); } m_Projector.Set_Inverse(true); //----------------------------------------------------- m_Target_Area.Create(Target, SG_DATATYPE_Char); m_Target_Area.Set_NoData_Value(0); for(int y=0; y<m_Target_Area.Get_NY() && Set_Progress(y, m_Target_Area.Get_NY()); y++) { double yWorld = Target.Get_yGrid_to_World(y); #pragma omp parallel for for(int x=0; x<m_Target_Area.Get_NX(); x++) { m_Target_Area.Set_Value(x, y, pArea->Contains(Target.Get_xGrid_to_World(x), yWorld) ? 1 : 0); } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CCRS_Transform_Grid::Get_Target_System(const CSG_Grid_System &System, bool bEdge) { int x, y, Resolution; TSG_Rect Extent; Extent.xMin = Extent.yMin = 1.0; Extent.xMax = Extent.yMax = 0.0; Get_MinMax(Extent, System.Get_XMin(), System.Get_YMin()); Get_MinMax(Extent, System.Get_XMax(), System.Get_YMin()); Get_MinMax(Extent, System.Get_XMin(), System.Get_YMax()); Get_MinMax(Extent, System.Get_XMax(), System.Get_YMax()); Resolution = 256; switch( 1 ) { case 1: // edges { double d; int yStep = 1 + System.Get_NY() / Resolution; for(y=0, d=System.Get_YMin(); y<System.Get_NY(); y+=yStep, d+=yStep*System.Get_Cellsize()) { Get_MinMax(Extent, System.Get_XMin(), d); Get_MinMax(Extent, System.Get_XMax(), d); } int xStep = 1 + System.Get_NX() / Resolution; for(x=0, d=System.Get_XMin(); x<System.Get_NX(); x+=xStep, d+=xStep*System.Get_Cellsize()) { Get_MinMax(Extent, d, System.Get_YMin()); Get_MinMax(Extent, d, System.Get_YMax()); } } break; case 2: // all cells { TSG_Point p; int xStep = 1 + System.Get_NX() / Resolution; int yStep = 1 + System.Get_NY() / Resolution; for(y=0, p.y=System.Get_YMin(); y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y+=yStep, p.y+=yStep*System.Get_Cellsize()) { for(x=0, p.x=System.Get_XMin(); x<System.Get_NX(); x+=xStep, p.x+=xStep*System.Get_Cellsize()) { Get_MinMax(Extent, p.x, p.y); } } } break; } return( is_Progress() && Extent.xMin < Extent.xMax && Extent.yMin < Extent.yMax && m_Grid_Target.Init_User(Extent, System.Get_NY()) && Dlg_Parameters("GET_USER") ); }
//--------------------------------------------------------- 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 CImport_Clip_Resample::Load_Grid(CSG_Grid *pImport) { CSG_Grid_System System = pImport->Get_System(); //----------------------------------------------------- const CSG_Rect *pClip = Parameters("CLIP")->asShapes() ? &Parameters("CLIP")->asShapes()->Get_Extent() : NULL; if( pClip ) { if( !pClip->Intersects(System.Get_Extent()) ) { return( false ); } TSG_Rect Extent = System.Get_Extent(); if( pClip->Get_XMin() > System.Get_XMin() ) Extent.xMin = System.Fit_xto_Grid_System(pClip->Get_XMin()); if( pClip->Get_XMax() < System.Get_XMax() ) Extent.xMax = System.Fit_xto_Grid_System(pClip->Get_XMax()); if( pClip->Get_YMin() > System.Get_YMin() ) Extent.yMin = System.Fit_yto_Grid_System(pClip->Get_YMin()); if( pClip->Get_YMax() < System.Get_YMax() ) Extent.yMax = System.Fit_yto_Grid_System(pClip->Get_YMax()); System.Assign(System.Get_Cellsize(), Extent); } //----------------------------------------------------- if( Parameters("RESAMPLE")->asBool() ) { double Cellsize = Parameters("CELLSIZE")->asDouble(); if( Cellsize > 0.0 && Cellsize != System.Get_Cellsize() ) { System.Assign(Cellsize, System.Get_Extent()); } } //----------------------------------------------------- if( Parameters("NODATA")->asBool() ) { pImport->Set_NoData_Value(Parameters("NODATA_VAL")->asDouble()); } //----------------------------------------------------- CSG_Grid *pGrid = SG_Create_Grid(System, Parameters("KEEP_TYPE")->asBool() ? pImport->Get_Type() : SG_DATATYPE_Float); if( pGrid ) { pGrid->Assign (pImport); pGrid->Set_Name(pImport->Get_Name()); m_pGrids->Add_Item(pGrid); return( true ); } return( false ); }
//--------------------------------------------------------- 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 CCreateGridSystem::On_Execute(void) { CSG_Grid *pDummy; CSG_Shapes *pShapes; CSG_Rect extent; CSG_Parameter_Shapes_List *pShapesList; CSG_Parameter_Grid_List *pGridList; CSG_Grid_System System; double xMin, xMax, yMin, yMax, cellsize, offset_x, offset_y, xRange, yRange, n, initVal; int NX, NY, m_extent, m_adjust, i; bool useoff; xMin = Parameters("XMIN")->asDouble(); yMin = Parameters("YMIN")->asDouble(); xMax = Parameters("XMAX")->asDouble(); yMax = Parameters("YMAX")->asDouble(); NX = Parameters("NX")->asInt(); NY = Parameters("NY")->asInt(); cellsize = Parameters("CELLSIZE")->asDouble(); offset_x = Parameters("XOFFSET")->asDouble(); offset_y = Parameters("YOFFSET")->asDouble(); useoff = Parameters("USEOFF")->asBool(); m_extent = Parameters("M_EXTENT")->asInt(); m_adjust = Parameters("ADJUST")->asInt(); initVal = Parameters("INIT")->asDouble(); pShapesList = Parameters("SHAPESLIST")->asShapesList(); pGridList = Parameters("GRIDLIST")->asGridList(); if( useoff ) { xMin += offset_x; yMin += offset_y; xMax += offset_x; yMax += offset_y; } switch( m_extent ) { case 0: // xMin, yMin, NX, NY System.Assign(cellsize, xMin, yMin, NX, NY); break; case 1: // xMin, yMin, xMax, yMax if( xMin > xMax || yMin > yMax ) { Message_Add(CSG_String::Format(_TL("\nError: Please verify your xMin, yMin, xMax, yMax settings!\n"))); return false; } xRange = xMax - xMin; yRange = yMax - yMin; if( m_adjust == 0 ) // extent to cellsize { if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) floor(xRange / cellsize + 0.5); xMax = xMin + NX * cellsize; } if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) floor(yRange / cellsize + 0.5); yMax = yMin + NY * cellsize; } } else if( m_adjust == 1) // cellsize to W-E extent { if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) (xRange/cellsize); cellsize = xRange/NX; } if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) floor(yRange / cellsize + 0.5); yMax = yMin + NY * cellsize; } } else // cellsize to S-N extent { if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) (yRange/cellsize); cellsize = yRange/NY; } if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) floor(xRange / cellsize + 0.5); xMax = xMin + NX * cellsize; } } System.Assign(cellsize, xMin, yMin, xMax, yMax); break; case 2: // Shape(s) if( pShapesList == NULL || pShapesList->Get_Count() == 0) { Message_Add(CSG_String::Format(_TL("\nError: the method Extent by Shape(s) requires shape(s) as input!\n"))); return false; } for (i=0; i<pShapesList->Get_Count(); i++) { pShapes = pShapesList->asShapes(i); extent = pShapes->Get_Extent(); if (i==0) { xMin = extent.Get_XMin(); yMin = extent.Get_YMin(); xMax = extent.Get_XMax(); yMax = extent.Get_YMax(); } else { xMin = (extent.Get_XMin() < xMin) ? extent.Get_XMin() : xMin; yMin = (extent.Get_YMin() < yMin) ? extent.Get_YMin() : yMin; xMax = (extent.Get_XMax() > xMax) ? extent.Get_XMax() : xMax; yMax = (extent.Get_YMax() > yMax) ? extent.Get_YMax() : yMax; } } if( useoff ) { xMin += offset_x; xMax += offset_x; yMin += offset_y; yMax += offset_y; } xRange = xMax - xMin; yRange = yMax - yMin; if( m_adjust == 0 ) // extent to cellsize { if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) floor(xRange / cellsize + 0.5); xMax = xMin + NX * cellsize; } if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) floor(yRange / cellsize + 0.5); yMax = yMin + NY * cellsize; } } else if( m_adjust == 1) // cellsize to W-E extent { if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) (xRange/cellsize); cellsize = xRange/NX; } if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) floor(yRange / cellsize + 0.5); yMax = yMin + NY * cellsize; } } else // cellsize to S-N extent { if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) (yRange/cellsize); cellsize = yRange/NY; } if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) floor(xRange / cellsize + 0.5); xMax = xMin + NX * cellsize; } } System.Assign(cellsize, xMin, yMin, xMax, yMax); break; case 3: // Grid(s) if( pGridList == NULL || pGridList->Get_Count() == 0) { Message_Add(CSG_String::Format(_TL("\nError: the method Extent by Grid(s) requires grid(s) as input!\n"))); return false; } for (i=0; i<pGridList->Get_Count(); i++) { pDummy = pGridList->asGrid(i); extent = pDummy->Get_Extent(); if (i==0) { xMin = extent.Get_XMin(); yMin = extent.Get_YMin(); xMax = extent.Get_XMax(); yMax = extent.Get_YMax(); } else { xMin = (extent.Get_XMin() < xMin) ? extent.Get_XMin() : xMin; yMin = (extent.Get_YMin() < yMin) ? extent.Get_YMin() : yMin; xMax = (extent.Get_XMax() > xMax) ? extent.Get_XMax() : xMax; yMax = (extent.Get_YMax() > yMax) ? extent.Get_YMax() : yMax; } } if( useoff ) { xMin += offset_x; xMax += offset_x; yMin += offset_y; yMax += offset_y; } xRange = xMax - xMin; yRange = yMax - yMin; if( m_adjust == 0 ) // extent to cellsize { if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) floor(xRange / cellsize + 0.5); xMax = xMin + NX * cellsize; } if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) floor(yRange / cellsize + 0.5); yMax = yMin + NY * cellsize; } } else if( m_adjust == 1) // cellsize to W-E extent { if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) (xRange/cellsize); cellsize = xRange/NX; } if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) floor(yRange / cellsize + 0.5); yMax = yMin + NY * cellsize; } } else // cellsize to S-N extent { if( modf((yRange/cellsize), &n) != 0.0 ) { NY = (int) (yRange/cellsize); cellsize = yRange/NY; } if( modf((xRange/cellsize), &n) != 0.0 ) { NX = (int) floor(xRange / cellsize + 0.5); xMax = xMin + NX * cellsize; } } System.Assign(cellsize, xMin, yMin, xMax, yMax); break; } pDummy = SG_Create_Grid(System, SG_DATATYPE_Double); pDummy->Assign(initVal); pDummy->Set_Name(_TL("Dummy Grid")); Parameters("GRID")->Set_Value(pDummy); 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 ); }