//---------------------------------------------------------
bool CGeoref_Grid::Get_Target_Extent(CSG_Rect &Extent, bool bEdge)
{
if( Parameters("METHOD")->asInt() == GEOREF_Triangulation ) // triangulation
{
return( m_Engine.Get_Reference_Extent(Extent) );
}
//-----------------------------------------------------
CSG_Grid *pGrid = Parameters("GRID")->asGrid();
Extent.m_rect.xMin = Extent.m_rect.yMin = 1.0;
Extent.m_rect.xMax = Extent.m_rect.yMax = 0.0;
//-----------------------------------------------------
if( bEdge )
{
for(int y=0; y<pGrid->Get_NY(); y++)
{
Add_Target_Extent(Extent, pGrid->Get_XMin(), pGrid->Get_System().Get_yGrid_to_World(y));
Add_Target_Extent(Extent, pGrid->Get_XMax(), pGrid->Get_System().Get_yGrid_to_World(y));
}
for(int x=0; x<pGrid->Get_NX(); x++)
{
Add_Target_Extent(Extent, pGrid->Get_System().Get_xGrid_to_World(x), pGrid->Get_YMin());
Add_Target_Extent(Extent, pGrid->Get_System().Get_xGrid_to_World(x), pGrid->Get_YMax());
}
}
//-----------------------------------------------------
else
{
for(int y=0; y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++)
{
for(int x=0; x<pGrid->Get_NX(); x++)
{
if( !pGrid->is_NoData(x, y) )
{
TSG_Point p = pGrid->Get_System().Get_Grid_to_World(x, y);
Add_Target_Extent(Extent, p.x, p.y);
}
}
}
}
return( is_Progress() && Extent.Get_XRange() > 0.0 && Extent.Get_YRange() > 0.0 );
}
//---------------------------------------------------------
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 CSurfer_Export::On_Execute(void)
{
const char ID_BINARY[] = "DSBB";
FILE *Stream;
CSG_Grid *pGrid = Parameters("GRID")->asGrid();
CSG_String File = Parameters("FILE")->asString();
bool bNoData = Parameters("NODATA")->asBool();
switch( Parameters("FORMAT")->asInt() )
{
//-----------------------------------------------------
case 0: // Surfer 6 - Binary...
if( (Stream = fopen(File.b_str(), "wb")) != NULL )
{
short sValue;
double dValue;
fwrite(ID_BINARY, 4, sizeof(char), Stream);
sValue = (short)pGrid->Get_NX (); fwrite(&sValue, 1, sizeof(short ), Stream);
sValue = (short)pGrid->Get_NY (); fwrite(&sValue, 1, sizeof(short ), Stream);
dValue = pGrid->Get_XMin(); fwrite(&dValue, 1, sizeof(double), Stream);
dValue = pGrid->Get_XMax(); fwrite(&dValue, 1, sizeof(double), Stream);
dValue = pGrid->Get_YMin(); fwrite(&dValue, 1, sizeof(double), Stream);
dValue = pGrid->Get_YMax(); fwrite(&dValue, 1, sizeof(double), Stream);
dValue = pGrid->Get_Min (); fwrite(&dValue, 1, sizeof(double), Stream);
dValue = pGrid->Get_Max (); fwrite(&dValue, 1, sizeof(double), Stream);
//---------------------------------------------
float *fLine = (float *)SG_Malloc(pGrid->Get_NX() * sizeof(float));
for(int y=0; y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++)
{
for(int x=0; x<pGrid->Get_NX(); x++)
{
fLine[x] = bNoData && pGrid->is_NoData(x, y) ? NODATAVALUE : pGrid->asFloat(x, y);
}
fwrite(fLine, pGrid->Get_NX(), sizeof(float), Stream);
}
SG_Free(fLine);
fclose(Stream);
return( true );
}
break;
//-----------------------------------------------------
case 1: // Surfer - ASCII...
if( (Stream = fopen(File.b_str(), "w")) != NULL )
{
fprintf(Stream, "DSAA\n");
fprintf(Stream, "%d %d\n", pGrid->Get_NX (), pGrid->Get_NY ());
fprintf(Stream, "%f %f\n", pGrid->Get_XMin(), pGrid->Get_XMax());
fprintf(Stream, "%f %f\n", pGrid->Get_YMin(), pGrid->Get_YMax());
fprintf(Stream, "%f %f\n", pGrid->Get_Min (), pGrid->Get_Max ());
//---------------------------------------------
for(int y=0; y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++)
{
for(int x=0; x<pGrid->Get_NX(); x++)
{
fprintf(Stream, "%f ", bNoData && pGrid->is_NoData(x, y) ? NODATAVALUE : pGrid->asFloat(x, y));
}
fprintf(Stream, "\n");
}
fclose(Stream);
return( true );
}
break;
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Set_Target_System(CSG_Parameters *pParameters, int Resolution, bool bEdges)
{
if( !pParameters || !pParameters->Get_Parameter("SOURCE") || !pParameters->Get_Parameter("CRS_PROJ4") )
{
return( false );
}
CSG_Grid *pGrid = m_bList
? pParameters->Get_Parameter("SOURCE")->asGridList()->asGrid(0)
: pParameters->Get_Parameter("SOURCE")->asGrid();
if( !pGrid || !pGrid->is_Valid() || !pGrid->Get_Projection().is_Okay()
|| !m_Projector.Set_Target(CSG_Projection(pParameters->Get_Parameter("CRS_PROJ4")->asString(), SG_PROJ_FMT_Proj4))
|| !m_Projector.Get_Target().is_Okay()
|| !m_Projector.Set_Source(pGrid->Get_Projection()) )
{
return( false );
}
//-----------------------------------------------------
int x, y;
TSG_Rect Extent;
Extent.xMin = Extent.yMin = 1.0;
Extent.xMax = Extent.yMax = 0.0;
Get_MinMax(Extent, pGrid->Get_XMin(), pGrid->Get_YMin());
Get_MinMax(Extent, pGrid->Get_XMax(), pGrid->Get_YMin());
Get_MinMax(Extent, pGrid->Get_XMin(), pGrid->Get_YMax());
Get_MinMax(Extent, pGrid->Get_XMax(), pGrid->Get_YMax());
//-----------------------------------------------------
if( bEdges ) // edges
{
double d;
int yStep = 1 + pGrid->Get_NY() / Resolution;
for(y=0, d=pGrid->Get_YMin(); y<pGrid->Get_NY(); y+=yStep, d+=yStep*pGrid->Get_Cellsize())
{
Get_MinMax(Extent, pGrid->Get_XMin(), d);
Get_MinMax(Extent, pGrid->Get_XMax(), d);
}
int xStep = 1 + pGrid->Get_NX() / Resolution;
for(x=0, d=pGrid->Get_XMin(); x<pGrid->Get_NX(); x+=xStep, d+=xStep*pGrid->Get_Cellsize())
{
Get_MinMax(Extent, d, pGrid->Get_YMin());
Get_MinMax(Extent, d, pGrid->Get_YMax());
}
}
//-----------------------------------------------------
else // all cells
{
TSG_Point p;
int xStep = 1 + pGrid->Get_NX() / Resolution;
int yStep = 1 + pGrid->Get_NY() / Resolution;
for(y=0, p.y=pGrid->Get_YMin(); y<pGrid->Get_NY(); y+=yStep, p.y+=yStep*pGrid->Get_Cellsize())
{
for(x=0, p.x=pGrid->Get_XMin(); x<pGrid->Get_NX(); x+=xStep, p.x+=xStep*pGrid->Get_Cellsize())
{
Get_MinMax(Extent, p.x, p.y);
}
}
}
return( Extent.xMin < Extent.xMax && Extent.yMin < Extent.yMax
&& m_Grid_Target.Set_User_Defined(pParameters, Extent, pGrid->Get_NY())
&& m_Grid_Target.Get_System().is_Valid()
);
}