//---------------------------------------------------------
bool CTopographic_Openness::Get_Angles_Multi_Scale(int x, int y, CSG_Vector &Max, CSG_Vector &Min)
{
if( m_pDEM->is_NoData(x, y) )
{
return( false );
}
double z, d;
TSG_Point p, q;
z = m_pDEM->asDouble(x, y);
p = Get_System()->Get_Grid_to_World(x, y);
//-----------------------------------------------------
for(int iGrid=-1; iGrid<m_nLevels; iGrid++)
{
bool bOkay = false;
CSG_Grid *pGrid = m_Pyramid.Get_Grid(iGrid);
for(int i=0; i<m_Direction.Get_Count(); i++)
{
q.x = p.x + pGrid->Get_Cellsize() * m_Direction[i].x;
q.y = p.y + pGrid->Get_Cellsize() * m_Direction[i].y;
if( pGrid->Get_Value(q, d) )
{
d = (d - z) / pGrid->Get_Cellsize();
if( bOkay == false )
{
bOkay = true;
Max[i] = Min[i] = d;
}
else if( Max[i] < d )
{
Max[i] = d;
}
else if( Min[i] > d )
{
Min[i] = d;
}
}
}
if(0|| bOkay == false )
{
return( false );
}
}
return( true );
}
//---------------------------------------------------------
int CDecision_Tree::Get_Class(CSG_Parameters *pDecision, const TSG_Point &Point)
{
double Value;
CSG_Grid *pGrid = pDecision->Get_Parameter("GRID")->asGrid();
if( pGrid && pGrid->Get_Value(Point, Value) )
{
CSG_String ID = pDecision->Get_Identifier(); if( !ID.Cmp(SG_T("ROOT")) ) ID.Clear();
ID += Value < pDecision->Get_Parameter("THRESHOLD")->asDouble() ? SG_T("A") : SG_T("B");
if( pDecision->Get_Parameter(ID + SG_T("|NODE"))->asBool() )
{
return( Get_Class(pDecision->Get_Parameter(ID)->asParameters(), Point) );
}
else
{
return( Get_Class(ID) );
}
}
return( -1 );
}
//---------------------------------------------------------
bool CGrid_Values_AddTo_Points::On_Execute(void)
{
int iShape, iGrid, iField, Offset, Interpolation;
double Value;
CSG_Shapes *pShapes;
CSG_Parameter_Grid_List *pGrids;
//-----------------------------------------------------
pShapes = Parameters("RESULT") ->asShapes();
pGrids = Parameters("GRIDS" ) ->asGridList();
Interpolation = Parameters("INTERPOL") ->asInt();
//-----------------------------------------------------
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());
}
Offset = pShapes->Get_Field_Count();
//-----------------------------------------------------
for(iGrid=0; iGrid<pGrids->Get_Count(); iGrid++)
{
pShapes->Add_Field(pGrids->asGrid(iGrid)->Get_Name(), SG_DATATYPE_Double);
}
//-----------------------------------------------------
for(iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
for(iGrid=0, iField=Offset; iGrid<pGrids->Get_Count(); iGrid++, iField++)
{
CSG_Grid *pGrid = pGrids->asGrid(iGrid);
if( pGrid->Get_Value(pShape->Get_Point(0), Value, Interpolation) )
{
pShape->Set_Value(iField, Value);
}
else
{
pShape->Set_NoData(iField);
}
}
}
//-----------------------------------------------------
if( pShapes == Parameters("SHAPES")->asShapes() )
{
DataObject_Update(pShapes);
}
return( true );
}
//---------------------------------------------------------
bool CDirect_Georeferencing::On_Execute(void)
{
//-----------------------------------------------------
if( !m_Georeferencer.Set_Transformation(Parameters, Get_NX(), Get_NY()) )
{
return( false );
}
//-----------------------------------------------------
CSG_Grid *pDEM = Parameters("DEM" )->asGrid();
double zRef = Parameters("ZREF" )->asDouble();
bool bFlip = Parameters("ROW_ORDER")->asInt() == 1;
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline; break;
case 3: Resampling = GRID_RESAMPLING_BSpline; break;
}
//-----------------------------------------------------
TSG_Point p[4];
p[0] = m_Georeferencer.Image_to_World( 0, 0, zRef);
p[1] = m_Georeferencer.Image_to_World(Get_NX(), 0, zRef);
p[2] = m_Georeferencer.Image_to_World(Get_NX(), Get_NY(), zRef);
p[3] = m_Georeferencer.Image_to_World( 0, Get_NY(), zRef);
CSG_Rect r(p[0], p[1]); r.Union(p[2]); r.Union(p[3]);
//-----------------------------------------------------
CSG_Shapes *pShapes = Parameters("EXTENT")->asShapes();
if( pShapes )
{
pShapes->Create(SHAPE_TYPE_Polygon, _TL("Extent"));
pShapes->Add_Field(_TL("OID"), SG_DATATYPE_Int);
CSG_Shape *pExtent = pShapes->Add_Shape();
pExtent->Add_Point(p[0]);
pExtent->Add_Point(p[1]);
pExtent->Add_Point(p[2]);
pExtent->Add_Point(p[3]);
}
//-----------------------------------------------------
double Cellsize = SG_Get_Distance(p[0], p[1]) / Get_NX();
CSG_Grid_System System(Cellsize, r);
m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), r, Get_NX());
if( !Dlg_Parameters("TARGET") )
{
return( false );
}
System = m_Grid_Target.Get_System();
if( !System.is_Valid() )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList();
CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList();
pOutput->Del_Items();
if( pInput->Get_Count() <= 0 )
{
return( false );
}
else
{
TSG_Data_Type Type;
switch( Parameters("DATA_TYPE")->asInt() )
{
case 0: Type = SG_DATATYPE_Byte; break;
case 1: Type = SG_DATATYPE_Char; break;
case 2: Type = SG_DATATYPE_Word; break;
case 3: Type = SG_DATATYPE_Short; break;
case 4: Type = SG_DATATYPE_DWord; break;
case 5: Type = SG_DATATYPE_Int; break;
case 6: Type = SG_DATATYPE_Float; break;
case 7: Type = SG_DATATYPE_Double; break;
default: Type = SG_DATATYPE_Undefined; break;
}
for(int i=0; i<pInput->Get_Count(); i++)
{
CSG_Grid *pGrid = SG_Create_Grid(System, Type != SG_DATATYPE_Undefined ? Type : pInput->asGrid(i)->Get_Type());
if( !pGrid || !pGrid->is_Valid() )
{
if( pGrid )
{
delete(pGrid);
}
return( false );
}
pOutput->Add_Item(pGrid);
pGrid->Set_Name(pInput->asGrid(i)->Get_Name());
}
}
//-----------------------------------------------------
for(int y=0; y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y++)
{
double py = System.Get_YMin() + y * System.Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<System.Get_NX(); x++)
{
double pz, px = System.Get_XMin() + x * System.Get_Cellsize();
if( !pDEM || !pDEM->Get_Value(px, py, pz) )
{
pz = zRef;
}
TSG_Point p = m_Georeferencer.World_to_Image(px, py, pz);
if( bFlip )
{
p.y = (Get_NY() - 1) - p.y;
}
for(int i=0; i<pInput->Get_Count(); i++)
{
if( pInput->asGrid(i)->Get_Value(p.x, p.y, pz, Resampling) )
{
pOutput->asGrid(i)->Set_Value(x, y, pz);
}
else
{
pOutput->asGrid(i)->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGrid_Gaps_Resampling::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pGrid = Parameters("RESULT")->asGrid();
CSG_Grid *pMask = Parameters("MASK" )->asGrid();
if( pGrid == NULL )
{
pGrid = Parameters("INPUT")->asGrid();
}
else
{
pGrid->Assign(Parameters("INPUT")->asGrid());
pGrid->Fmt_Name("%s [%s]", Parameters("INPUT")->asGrid()->Get_Name(), _TL("no gaps"));
}
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear ; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline ; break;
case 3: Resampling = GRID_RESAMPLING_BSpline ; break;
}
//-----------------------------------------------------
CSG_Grid_Pyramid Pyramid;
if( !Pyramid.Create(pGrid, Parameters("GROW")->asDouble()) )
{
Error_Set(_TL("failed to create pyramid"));
return( false );
}
//-----------------------------------------------------
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) && (!pMask || !pMask->is_NoData(x, y)) )
{
double px = Get_XMin() + x * Get_Cellsize();
for(int i=0; i<Pyramid.Get_Count(); i++)
{
CSG_Grid *pPatch = Pyramid.Get_Grid(i);
if( pPatch->is_InGrid_byPos(px, py) )
{
pGrid->Set_Value(x, y, pPatch->Get_Value(px, py, Resampling));
break;
}
}
}
}
}
//-----------------------------------------------------
if( pGrid == Parameters("INPUT")->asGrid() )
{
DataObject_Update(pGrid);
}
return( true );
}
