//---------------------------------------------------------
// 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 );
}
