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