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 CCRS_Transform_Grid::Transform(CSG_Parameter_Grid_List *pGrids, CSG_Shapes *pPoints)
{
if( !pPoints || !pGrids || pGrids->Get_Count() < 1 )
{
return( false );
}
CSG_Grid *pGrid = pGrids->asGrid(0);
if( !m_Projector.Set_Source(pGrid->Get_Projection()) )
{
return( false );
}
int x, y, i;
TSG_Point Point;
pPoints->Create(SHAPE_TYPE_Point, _TL("Points"));
pPoints->Get_Projection() = m_Projector.Get_Target();
for(i=0; i<pGrids->Get_Count(); i++)
{
pPoints->Add_Field(pGrids->asGrid(i)->Get_Name(), pGrids->asGrid(i)->Get_Type());
}
for(y=0, Point.y=pGrid->Get_YMin(); y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++, Point.y+=pGrid->Get_Cellsize())
{
for(x=0, Point.x=pGrid->Get_XMin(); x<pGrid->Get_NX(); x++, Point.x+=pGrid->Get_Cellsize())
{
TSG_Point Point_Transformed = Point;
if( m_Projector.Get_Projection(Point_Transformed) )
{
CSG_Shape *pPoint = pPoints->Add_Shape();
pPoint->Add_Point(Point_Transformed);
for(i=0; i<pGrids->Get_Count(); i++)
{
if( !pGrids->asGrid(i)->is_NoData(x, y) )
{
pPoint->Set_Value(i, pGrids->asGrid(i)->asDouble(x, y));
}
else
{
pPoint->Set_NoData(i);
}
}
}
}
}
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 CGridding_Spline_Base::_Get_Points(CSG_Points_Z &Points, bool bInGridOnly)
{
Points.Clear();
if( m_bGridPoints )
{
int x, y;
TSG_Point p;
CSG_Grid *pGrid = Parameters("GRIDPOINTS") ->asGrid();
for(y=0, p.y=pGrid->Get_YMin(); y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++, p.y+=pGrid->Get_Cellsize())
{
for(x=0, p.x=pGrid->Get_XMin(); x<pGrid->Get_NX(); x++, p.x+=pGrid->Get_Cellsize())
{
if( !pGrid->is_NoData(x, y) && (!bInGridOnly || m_pGrid->is_InGrid_byPos(p)) )
{
Points.Add(p.x, p.y, pGrid->asDouble(x, y));
}
}
}
}
else
{
CSG_Shapes *pShapes = Parameters("SHAPES") ->asShapes();
int zField = Parameters("FIELD") ->asInt();
for(int iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
if( !pShape->is_NoData(zField) )
{
double zValue = pShape->asDouble(zField);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
TSG_Point p = pShape->Get_Point(iPoint, iPart);
if( !bInGridOnly || m_pGrid->is_InGrid_byPos(p) )
{
Points.Add(p.x, p.y, zValue);
}
}
}
}
}
}
return( Points.Get_Count() >= 3 );
}
//---------------------------------------------------------
bool CGridding_Spline_MBA::_Get_Difference(CSG_Grid &Phi)
{
int i, nErrors;
double x, y, z, zMax, zMean;
CSG_String s;
//-----------------------------------------------------
for(i=0, zMax=0.0, nErrors=0, zMean=0.0; i<m_Points.Get_Count(); i++)
{
x = (m_Points[i].x - Phi.Get_XMin()) / Phi.Get_Cellsize();
y = (m_Points[i].y - Phi.Get_YMin()) / Phi.Get_Cellsize();
z = (m_Points[i].z = m_Points[i].z - BA_Get_Value(x, y, Phi));
if( (z = fabs(z)) > m_Epsilon )
{
nErrors ++;
zMean += fabs(z);
if( fabs(z) > zMax )
{
zMax = fabs(z);
}
}
else
{
m_Points[i].z = 0.0;
}
}
if( nErrors > 0 )
{
zMean /= nErrors;
}
//-----------------------------------------------------
i = 1 + (int)(0.5 + log(Phi.Get_NX() - 4.0) / log(2.0));
s.Printf(SG_T("%s:%d, %s:%d, %s:%f, %s:%f"),
_TL("level"), i,
_TL("error"), nErrors,
_TL("max") , zMax,
_TL("mean") , zMean
);
Process_Set_Text(s);
Message_Add (s);
return( zMax >= m_Epsilon && i < m_Level_Max && Process_Get_Okay(false) );
}
//---------------------------------------------------------
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_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 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 CGridding_Spline_MBA::BA_Get_Phi(CSG_Grid &Phi)
{
int iPoint, _x, _y, ix, iy;
double x, y, z, dx, dy, wxy, wy, SW2, W[4][4];
CSG_Grid Delta;
//-----------------------------------------------------
Phi .Assign(0.0);
Delta .Create(Phi.Get_System());
//-----------------------------------------------------
for(iPoint=0; iPoint<m_Points.Get_Count() && Set_Progress(iPoint, m_Points.Get_Count()); iPoint++)
{
x = (m_Points[iPoint].x - Phi.Get_XMin()) / Phi.Get_Cellsize();
y = (m_Points[iPoint].y - Phi.Get_YMin()) / Phi.Get_Cellsize();
z = m_Points[iPoint].z;
if( (_x = (int)x) >= 0 && _x < Phi.Get_NX() - 3
&& (_y = (int)y) >= 0 && _y < Phi.Get_NY() - 3 )
{
dx = x - _x;
dy = y - _y;
for(iy=0, SW2=0.0; iy<4; iy++) // compute W[k,l] and Sum[a=0-3, b=0-3](W²[a,b])
{
wy = BA_Get_B(iy, dy);
for(ix=0; ix<4; ix++)
{
wxy = W[iy][ix] = wy * BA_Get_B(ix, dx);
SW2 += wxy*wxy;
}
}
for(iy=0; iy<4; iy++)
{
for(ix=0; ix<4; ix++)
{
wxy = W[iy][ix];
Delta.Add_Value(_x + ix, _y + iy, wxy*wxy * ((wxy * z) / SW2)); // Numerator
Phi .Add_Value(_x + ix, _y + iy, wxy*wxy); // Denominator
}
}
}
}
//-----------------------------------------------------
for(iy=0; iy<Phi.Get_NY(); iy++)
{
for(ix=0; ix<Phi.Get_NX(); ix++)
{
if( (z = Phi.asDouble(ix, iy)) != 0.0 )
{
Phi.Set_Value(ix, iy, Delta.asDouble(ix, iy) / z);
}
}
}
//-----------------------------------------------------
return( true );
}
bool CProfileFromPoints::On_Execute(void){
CSG_Table* pTable;
CSG_Table* pProfileTable;
CSG_Table_Record* pRecord;
CSG_Grid* pGrid;
int iXField, iYField;
int i;
int x1,x2,y1,y2;
float fPartialDist;
float fDist = 0;
pGrid = Parameters("GRID")->asGrid();
pTable = Parameters("TABLE")->asTable();
pProfileTable = Parameters("RESULT")->asTable();
iXField = Parameters("X")->asInt();
iYField = Parameters("Y")->asInt();
pProfileTable->Create((CSG_Table*)NULL);
pProfileTable->Set_Name(_TL("Profile"));
pProfileTable->Add_Field(_TL("Distance"), SG_DATATYPE_Double);
pProfileTable->Add_Field("Z", SG_DATATYPE_Double);
for (i = 0; i < pTable->Get_Record_Count()-1; i++){
x1=(int)(0.5 + (pTable->Get_Record(i )->asDouble(iXField) - pGrid->Get_XMin()) / pGrid->Get_Cellsize());
x2=(int)(0.5 + (pTable->Get_Record(i+1)->asDouble(iXField) - pGrid->Get_XMin()) / pGrid->Get_Cellsize());
y1=(int)(0.5 + (pTable->Get_Record(i )->asDouble(iYField) - pGrid->Get_YMin()) / pGrid->Get_Cellsize());
y2=(int)(0.5 + (pTable->Get_Record(i+1)->asDouble(iYField) - pGrid->Get_YMin()) / pGrid->Get_Cellsize());
int x = x1, y = y1, D = 0, HX = x2 - x1, HY = y2 - y1,
c, M, xInc = 1, yInc = 1, iLastX = x1, iLastY = y1;
if (HX < 0) {
xInc = -1;
HX = -HX;
}//if
if (HY < 0) {
yInc = -1;
HY = -HY;
}//if
if (HY <= HX) {
c = 2 * HX;
M = 2 * HY;
for (;;) {
fPartialDist = (float)(M_GET_LENGTH(x-iLastX, y-iLastY) * pGrid->Get_Cellsize());
if (pGrid->is_InGrid(x,y) && fPartialDist){
fDist+=fPartialDist;
pRecord = pProfileTable->Add_Record();
pRecord->Set_Value(0, fDist);
pRecord->Set_Value(1, pGrid->asFloat(x,y));
}//if
iLastX = x;
iLastY = y;
if (x == x2) {
break;
}// if
x += xInc;
D += M;
if (D > HX) {
y += yInc;
D -= c;
}// if
}// for
}// if
else {
c = 2 * HY;
M = 2 * HX;
for (;;) {
fPartialDist = (float)(M_GET_LENGTH(x-iLastX, y-iLastY) * pGrid->Get_Cellsize());
if (pGrid->is_InGrid(x,y) && fPartialDist){
fDist+=fPartialDist;
pRecord = pProfileTable->Add_Record();
pRecord->Set_Value(0, fDist);
pRecord->Set_Value(1, pGrid->asFloat(x,y));
}//if
iLastX = x;
iLastY = y;
if (y == y2) {
break;
}// if
y += yInc;
D += M;
if (D > HY) {
x += xInc;
D -= c;
}// if
}// for
}// else
}//for
return true;
}// method
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
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 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()
);
}
bool CWaterRetentionCapacity::On_Execute(void){
int i,j;
int x,y;
int iField;
int iShape;
int iRows;
float fValue = 0;
float **pData;
int iX, iY;
float fC;
double dSlope,dAspect;
CSG_Shape* pShape;
CSG_Shapes* pShapes = Parameters("SHAPES")->asShapes();
CSG_Grid* pDEM = Parameters("DEM")->asGrid();
m_pRetention = Parameters("RETENTION")->asGrid();
m_pSlope = SG_Create_Grid(pDEM);
m_pOutput = Parameters("OUTPUT")->asShapes();
m_pOutput->Assign(pShapes);
m_pOutput->Add_Field("CCC", SG_DATATYPE_Double);
m_pOutput->Add_Field("CIL", SG_DATATYPE_Double);
m_pOutput->Add_Field(_TL("Permeability"), SG_DATATYPE_Double);
m_pOutput->Add_Field(_TL("Equivalent Moisture"), SG_DATATYPE_Double);
m_pOutput->Add_Field(_TL("Water Retention Capacity"), SG_DATATYPE_Double);
for(y=0; y<Get_NY() && Set_Progress(y); y++){
for(x=0; x<Get_NX(); x++){
if( pDEM->Get_Gradient(x, y, dSlope, dAspect) ){
m_pSlope->Set_Value(x, y, dSlope);
}
else{
m_pSlope->Set_NoData(x, y);
}
}
}
iRows = pShapes->Get_Field_Count() / 5;
pData = new float*[iRows];
for (iShape = 0; iShape < pShapes->Get_Count(); iShape++){
pShape = pShapes->Get_Shape(iShape);
for (i = 0; i< iRows; i++){
pData[i] = new float[5];
for (j = 0; j < 5; j++){
pData[i][j] = 0;
try{
pData[i][j] = pShape->asFloat(j+i*5);
}//try
catch(...){}
}//for
}//for
iX = (int)((pShape->Get_Point(0).x - pDEM->Get_XMin())/pDEM->Get_Cellsize());
iY = (int)((pShape->Get_Point(0).y - pDEM->Get_YMin())/pDEM->Get_Cellsize());
fC = (float)(1. - tan(m_pSlope->asFloat(iX,iY,false)));
pShape = m_pOutput->Get_Shape(iShape);
CalculateWaterRetention(pData, iRows, fC, pShape);
}//for
iField = m_pOutput->Get_Field_Count()-1;
CIDW IDW;
IDW.setParameters(m_pRetention, m_pOutput, iField);
IDW.Interpolate();
CorrectWithSlope();
return true;
}//method
