//---------------------------------------------------------
bool Cut_Set_Extent(CSG_Rect Extent, CSG_Shapes *pExtent, bool bClear)
{
if( pExtent )
{
if( bClear )
{
pExtent->Create(SHAPE_TYPE_Polygon, _TL("Extent [Cut]"));
pExtent->Add_Field("ID", SG_DATATYPE_Int);
}
if( pExtent->Get_Type() == SHAPE_TYPE_Polygon )
{
CSG_Shape *pShape = pExtent->Add_Shape();
pShape->Set_Value(SG_T("ID"), pExtent->Get_Count());
pShape->Add_Point(Extent.Get_XMin(), Extent.Get_YMin());
pShape->Add_Point(Extent.Get_XMin(), Extent.Get_YMax());
pShape->Add_Point(Extent.Get_XMax(), Extent.Get_YMax());
pShape->Add_Point(Extent.Get_XMax(), Extent.Get_YMin());
pShape->Add_Point(Extent.Get_XMin(), Extent.Get_YMin());
return( true );
}
}
return( false );
}
//---------------------------------------------------------
double CGrid_Class_Statistics_For_Polygons::Get_Intersection(CSG_Shape_Polygon *pPolygon, TSG_Point p, bool bCenter)
{
//-----------------------------------------------------
if( bCenter )
{
return( pPolygon->Contains(p) ? Get_Cellarea() : 0.0 );
}
//-----------------------------------------------------
CSG_Shapes Cells(SHAPE_TYPE_Polygon);
CSG_Shape *pCell = Cells.Add_Shape();
CSG_Shape *pArea = Cells.Add_Shape();
pCell->Add_Point(p.x - 0.5 * Get_Cellsize(), p.y - 0.5 * Get_Cellsize());
pCell->Add_Point(p.x - 0.5 * Get_Cellsize(), p.y + 0.5 * Get_Cellsize());
pCell->Add_Point(p.x + 0.5 * Get_Cellsize(), p.y + 0.5 * Get_Cellsize());
pCell->Add_Point(p.x + 0.5 * Get_Cellsize(), p.y - 0.5 * Get_Cellsize());
if( SG_Polygon_Intersection(pPolygon, pCell, pArea) )
{
return( ((CSG_Shape_Polygon *)pArea)->Get_Area() );
}
return( 0.0 );
}
//---------------------------------------------------------
bool CLines_From_Polygons::On_Execute(void)
{
CSG_Shapes *pLines, *pPolygons;
pPolygons = Parameters("POLYGONS") ->asShapes();
pLines = Parameters("LINES") ->asShapes();
//-----------------------------------------------------
if( pPolygons->Get_Count() <= 0 )
{
Error_Set(_TL("no polygons in input"));
return( false );
}
//-----------------------------------------------------
pLines->Create(SHAPE_TYPE_Line, pPolygons->Get_Name(), pPolygons, pPolygons->Get_Vertex_Type());
for(int iPolygon=0; iPolygon<pPolygons->Get_Count(); iPolygon++)
{
CSG_Shape *pPolygon = pPolygons ->Get_Shape(iPolygon);
CSG_Shape *pLine = pLines ->Add_Shape(pPolygon, SHAPE_COPY_ATTR);
for(int iPart=0; iPart<pPolygon->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pPolygon->Get_Point_Count(iPart); iPoint++)
{
pLine->Add_Point(pPolygon->Get_Point(iPoint, iPart), iPart);
if( pPolygons->Get_Vertex_Type() != SG_VERTEX_TYPE_XY )
{
pLine->Set_Z(pPolygon->Get_Z(iPoint, iPart), iPoint, iPart);
if( pPolygons->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
pLine->Set_M(pPolygon->Get_M(iPoint, iPart), iPoint, iPart);
}
}
}
if( !CSG_Point(pPolygon->Get_Point(0, iPart)).is_Equal(pPolygon->Get_Point(pPolygon->Get_Point_Count(iPart) - 1, iPart)) )
{
pLine->Add_Point(pPolygon->Get_Point(0, iPart), iPart);
if( pPolygons->Get_Vertex_Type() != SG_VERTEX_TYPE_XY )
{
pLine->Set_Z(pPolygon->Get_Z(0, iPart), pLine->Get_Point_Count(iPart) - 1, iPart);
if( pPolygons->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
pLine->Set_M(pPolygon->Get_M(0, iPart), pLine->Get_Point_Count(iPart) - 1, iPart);
}
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CTIN_Gradient::On_Execute(void)
{
bool bDegree;
int iTriangle, zField;
double a, b;
CSG_TIN_Triangle *pTriangle;
CSG_TIN *pTIN;
CSG_Shape *pShape;
CSG_Shapes *pShapes;
//-----------------------------------------------------
pTIN = Parameters("TIN") ->asTIN();
zField = Parameters("ZFIELD") ->asInt();
pShapes = Parameters("GRADIENT") ->asShapes();
bDegree = Parameters("DEGREE") ->asInt() == 1;
//-----------------------------------------------------
pShapes->Create(SHAPE_TYPE_Polygon, CSG_String::Format(SG_T("%s [%s], %s [%s]"), _TL("TIN_Gradient"), pTIN->Get_Field_Name(zField), _TL("TIN"), pTIN->Get_Name()));
pShapes->Add_Field(_TL("ID") , SG_DATATYPE_Int);
pShapes->Add_Field(_TL("AREA") , SG_DATATYPE_Double);
pShapes->Add_Field(_TL("DECLINE"), SG_DATATYPE_Double);
pShapes->Add_Field(_TL("AZIMUTH"), SG_DATATYPE_Double);
//-----------------------------------------------------
for(iTriangle=0; iTriangle<pTIN->Get_Triangle_Count() && Set_Progress(iTriangle, pTIN->Get_Triangle_Count()); iTriangle++)
{
pTriangle = pTIN->Get_Triangle(iTriangle);
if( pTriangle->Get_Gradient(zField, a, b) )
{
if( bDegree )
{
a *= M_RAD_TO_DEG;
b *= M_RAD_TO_DEG;
}
pShape = pShapes->Add_Shape();
pShape->Add_Point(pTriangle->Get_Node(0)->Get_Point());
pShape->Add_Point(pTriangle->Get_Node(1)->Get_Point());
pShape->Add_Point(pTriangle->Get_Node(2)->Get_Point());
pShape->Set_Value(0, iTriangle + 1);
pShape->Set_Value(1, pTriangle->Get_Area());
pShape->Set_Value(2, a);
pShape->Set_Value(3, b);
}
}
return( true );
}
bool CCreatePointGrid::On_Execute(void){
CSG_Shape *pShape;
double dXMin = ((CSG_Parameter_Range *) Parameters("X_EXTENT")->Get_Data())->Get_LoVal();
double dYMin = ((CSG_Parameter_Range *) Parameters("Y_EXTENT")->Get_Data())->Get_LoVal();
double dXMax = ((CSG_Parameter_Range *) Parameters("X_EXTENT")->Get_Data())->Get_HiVal();
double dYMax = ((CSG_Parameter_Range *) Parameters("Y_EXTENT")->Get_Data())->Get_HiVal();
double dDistance = Parameters("DIST")->asDouble();
if (dDistance<=0){
return false;
}//if
CSG_Shapes *pShapes = Parameters("POINTS")->asShapes();
pShapes->Create(SHAPE_TYPE_Point, _TL("Point Grid"));
pShapes->Add_Field("X", SG_DATATYPE_Double);
pShapes->Add_Field("Y", SG_DATATYPE_Double);
for (double x=dXMin; x<dXMax; x=x+dDistance){
for (double y=dYMin; y<dYMax; y=y+dDistance){
pShape = pShapes->Add_Shape();
pShape->Add_Point(x,y);
pShape->Set_Value(0, x);
pShape->Set_Value(1, y);
}//for
}//for
return true;
}//method
bool CPoints_From_Table::On_Execute(void)
{
int iRecord, iXField, iYField;
double dX, dY;
CSG_Table *pTable;
CSG_Table_Record *pRecord;
CSG_Shapes *pShapes;
CSG_Shape *pShape;
pTable = Parameters("TABLE") ->asTable();
pShapes = Parameters("POINTS") ->asShapes();
iXField = Parameters("X") ->asInt();
iYField = Parameters("Y") ->asInt();
pShapes->Create(SHAPE_TYPE_Point, pTable->Get_Name(), pTable);
if( pTable->Get_Field_Count() > 1 && pTable->Get_Record_Count() > 0 )
{
for(iRecord=0; iRecord<pTable->Get_Record_Count() && Set_Progress(iRecord, pTable->Get_Record_Count()); iRecord++)
{
pRecord = pTable->Get_Record(iRecord);
dX = pRecord->asDouble(iXField);
dY = pRecord->asDouble(iYField);
pShape = pShapes->Add_Shape(pRecord, SHAPE_COPY_ATTR);
pShape->Add_Point(dX, dY);
}//for
return( true );
}//if
return( false );
}//method
//---------------------------------------------------------
bool CCollect_Points::On_Execute_Finish(void)
{
CSG_Shapes *pTarget = Parameters("REF_TARGET")->asShapes();
if( pTarget != NULL )
{
pTarget->Create(SHAPE_TYPE_Point, _TL("Reference Points (Projection)"));
pTarget->Add_Field("X_SRC", SG_DATATYPE_Double);
pTarget->Add_Field("Y_SRC", SG_DATATYPE_Double);
pTarget->Add_Field("X_MAP", SG_DATATYPE_Double);
pTarget->Add_Field("Y_MAP", SG_DATATYPE_Double);
pTarget->Add_Field("RESID", SG_DATATYPE_Double);
for(int iPoint=0; iPoint<m_pPoints->Get_Count(); iPoint++)
{
CSG_Shape *pPoint = pTarget->Add_Shape(m_pPoints->Get_Shape(iPoint), SHAPE_COPY_ATTR);
pPoint->Add_Point(
pPoint->asDouble(2),
pPoint->asDouble(3)
);
}
}
m_Engine.Destroy();
return( true );
}
//---------------------------------------------------------
bool CGEOTRANS_Grid::Set_Shapes(CSG_Grid *pSource, CSG_Shapes *pTarget)
{
int x, y;
TSG_Point Pt_Source, Pt_Target;
CSG_Shape *pShape;
if( pSource && pTarget )
{
pTarget->Create(SHAPE_TYPE_Point, pSource->Get_Name());
pTarget->Add_Field("Z", SG_DATATYPE_Double);
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);
pShape->Set_Value(0, pSource->asDouble(x, y));
}
}
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
void CPolygon_Clip::Clip_Points(CSG_Shapes *pClips, CSG_Shapes *pInputs, CSG_Shapes *pOutputs)
{
for(int iClip=0; iClip<pClips->Get_Count() && Set_Progress(iClip, pClips->Get_Count()); iClip++)
{
CSG_Shape_Polygon *pClip = (CSG_Shape_Polygon *)pClips->Get_Shape(iClip);
for(int iInput=0; iInput<pInputs->Get_Count(); iInput++)
{
CSG_Shape *pInput = pInputs->Get_Shape(iInput);
CSG_Shape *pOutput = NULL;
for(int iPoint=0; iPoint<pInput->Get_Point_Count(0); iPoint++)
{
if( pClip->Contains(pInput->Get_Point(iPoint, 0)) )
{
if( pOutput == NULL )
{
pOutput = pOutputs->Add_Shape(pInput, SHAPE_COPY_ATTR);
}
pOutput->Add_Point(pInput->Get_Point(iPoint, 0));
}
}
}
}
}
//---------------------------------------------------------
bool CGPX_Import::Add_Point(CSG_MetaData *pNode, CSG_Shapes *pPoints)
{
const SG_Char *cString;
TSG_Point Point;
if( (cString = pNode->Get_Property(SG_T("lon"))) != NULL && CSG_String(cString).asDouble(Point.x)
&& (cString = pNode->Get_Property(SG_T("lat"))) != NULL && CSG_String(cString).asDouble(Point.y)
&& Add_Fields(pNode, pPoints) )
{
CSG_Shape *pPoint = pPoints->Add_Shape();
pPoint->Add_Point(Point, 0);
for(int i=0; i<pNode->Get_Children_Count(); i++)
{
CSG_MetaData *pChild = pNode->Get_Child(i);
pPoint->Set_Value(pChild->Get_Name(), pChild->Get_Content());
}
if( m_bTime )
{
double h = CSG_String(pPoint->asString(SG_T("time"))).AfterFirst(SG_T('T')).asDouble();
double m = CSG_String(pPoint->asString(SG_T("time"))).AfterFirst(SG_T(':')).asDouble();
double s = CSG_String(pPoint->asString(SG_T("time"))).AfterLast (SG_T(':')).asDouble();
pPoint->Set_Value(SG_T("dtime"), h + m / 60.0 + s / 3600.0);
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGeoref_Grid::Set_Points(CSG_Grid *pGrid, CSG_Shapes *pReferenced)
{
if( !pGrid || !pReferenced || pReferenced->Get_Type() != SHAPE_TYPE_Point || !m_Engine.is_Okay() )
{
return( false );
}
//-----------------------------------------------------
pReferenced->Create(SHAPE_TYPE_Point, pGrid->Get_Name());
pReferenced->Add_Field("Z", SG_DATATYPE_Double);
//-----------------------------------------------------
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 Point = pGrid->Get_System().Get_Grid_to_World(x, y);
if( m_Engine.Get_Converted(Point) )
{
CSG_Shape *pPoint = pReferenced->Add_Shape();
pPoint->Add_Point(Point);
pPoint->Set_Value(0, pGrid->asDouble(x, y));
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPolygon_Split_Parts::On_Execute(void)
{
bool bIgnoreLakes;
CSG_Shapes *pPolygons, *pParts;
pPolygons = Parameters("POLYGONS") ->asShapes();
pParts = Parameters("PARTS") ->asShapes();
bIgnoreLakes = Parameters("LAKES") ->asBool();
pParts->Create(SHAPE_TYPE_Polygon, CSG_String::Format(SG_T("%s [%s]"), pPolygons->Get_Name(), _TL("Parts")), pPolygons);
//-----------------------------------------------------
for(int iShape=0; iShape<pPolygons->Get_Count() && Set_Progress(iShape, pPolygons->Get_Count()); iShape++)
{
CSG_Shape *pPolygon = pPolygons->Get_Shape(iShape);
for(int iPart=0; iPart<pPolygon->Get_Part_Count() && Process_Get_Okay(); iPart++)
{
if( bIgnoreLakes || !((CSG_Shape_Polygon *)pPolygon)->is_Lake(iPart) )
{
CSG_Shape *pPart = pParts->Add_Shape(pPolygon, SHAPE_COPY_ATTR);
for(int iPoint=0; iPoint<pPolygon->Get_Point_Count(iPart); iPoint++)
{
pPart->Add_Point(pPolygon->Get_Point(iPoint, iPart));
}
if( !bIgnoreLakes )
{
for(int jPart=0; jPart<pPolygon->Get_Part_Count(); jPart++)
{
if( ((CSG_Shape_Polygon *)pPolygon)->is_Lake(jPart)
&& ((CSG_Shape_Polygon *)pPart)->Contains(pPolygon->Get_Point(0, jPart)) )
{
for(int jPoint=0, nPart=pPart->Get_Part_Count(); jPoint<pPolygon->Get_Point_Count(jPart); jPoint++)
{
pPart->Add_Point(pPolygon->Get_Point(jPoint, jPart), nPart);
}
}
}
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CKinWav_D8::Gauges_Initialise(void)
{
if( m_pGauges_Flow != NULL )
{
if( m_pGauges == NULL )
{
DataObject_Add(m_pGauges = SG_Create_Shapes(SHAPE_TYPE_Point, _TL("Gauges")));
Parameters("GAUGES")->Set_Value(m_pGauges);
m_pGauges->Add_Field(_TL("ID"), SG_DATATYPE_Int);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
bool bBorder = false;
bool bLowest = true;
for(int i=0; i<8; i++)
{
int ix = Get_xTo(i, x);
int iy = Get_yTo(i, y);
if( !m_pDEM->is_InGrid(ix, iy) )
{
bBorder = true;
}
else if( m_pDEM->asDouble(ix, iy) < m_pDEM->asDouble(x, y) )
{
bLowest = false;
}
}
if( bLowest && bBorder )
{
CSG_Shape *pGauge = m_pGauges->Add_Shape();
pGauge->Add_Point(Get_System()->Get_Grid_to_World(x, y));
pGauge->Set_Value(0, m_pGauges->Get_Count() + 1);
}
}
}
}
m_pGauges_Flow->Destroy();
m_pGauges_Flow->Set_Name(_TL("Outlet Hydrographs"));
m_pGauges_Flow->Add_Field("TIME", SG_DATATYPE_Double);
for(int i=0; i<m_pGauges->Get_Count(); i++)
{
m_pGauges_Flow->Add_Field(CSG_String::Format(SG_T("GAUGE_%02d"), i + 1), SG_DATATYPE_Double);
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CPoint_Zonal_Multi_Grid_Regression::Set_Residuals(CSG_Shapes *pPoints, CSG_Grid *pRegression)
{
CSG_Shapes *pResiduals = Parameters("RESIDUALS")->asShapes();
int iAttribute = Parameters("ATTRIBUTE")->asInt ();
if( !pRegression || !pResiduals )
{
return( false );
}
//-----------------------------------------------------
pResiduals->Create(SHAPE_TYPE_Point, CSG_String::Format(SG_T("%s [%s]"), Parameters("ATTRIBUTE")->asString(), _TL("Residuals")));
pResiduals->Add_Field(pPoints->Get_Field_Name(iAttribute), SG_DATATYPE_Double);
pResiduals->Add_Field("TREND" , SG_DATATYPE_Double);
pResiduals->Add_Field("RESIDUAL", SG_DATATYPE_Double);
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;
}
//-----------------------------------------------------
for(int iShape=0; iShape<pPoints->Get_Count() && Set_Progress(iShape, pPoints->Get_Count()); iShape++)
{
CSG_Shape *pShape = pPoints->Get_Shape(iShape);
if( !pShape->is_NoData(iAttribute) )
{
double zShape = pShape->asDouble(iAttribute);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
double zGrid;
TSG_Point Point = pShape->Get_Point(iPoint, iPart);
if( pRegression->Get_Value(Point, zGrid, Resampling) )
{
CSG_Shape *pResidual = pResiduals->Add_Shape();
pResidual->Add_Point(Point);
pResidual->Set_Value(0, zShape);
pResidual->Set_Value(1, zGrid);
pResidual->Set_Value(2, zShape - zGrid);
}
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
void CQuadTree_Structure::Get_Shapes(CSG_Shapes *pShapes, CSG_PRQuadTree_Item *pItem, int Level)
{
if( pItem )
{
if( pShapes->Get_Type() == SHAPE_TYPE_Line )
{
if( pItem->is_Node() )
{
CSG_Shape *pShape = pShapes->Add_Shape();
pShape->Set_Value(0, Level);
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yCenter(), 0);
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yCenter(), 0);
pShape->Add_Point(pItem->Get_xCenter(), pItem->Get_yMin(), 1);
pShape->Add_Point(pItem->Get_xCenter(), pItem->Get_yMax(), 1);
for(int i=0; i<4; i++)
{
Get_Shapes(pShapes, pItem->asNode()->Get_Child(i), Level + 1);
}
}
}
if( pShapes->Get_Type() == SHAPE_TYPE_Polygon )
{
if( pItem->is_Node() )
{
for(int i=0; i<4; i++)
{
Get_Shapes(pShapes, pItem->asNode()->Get_Child(i), Level + 1);
}
}
else // if( pItem->is_Leaf() )
{
CSG_Shape *pShape = pShapes->Add_Shape();
pShape->Set_Value(0, Level + 1);
pShape->Set_Value(1, pItem->asLeaf()->Get_Z());
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMin());
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMax());
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yMax());
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yMin());
}
}
}
}
//---------------------------------------------------------
bool CSG_Network::Add_Shape(CSG_Shape *pShape)
{
if( !pShape || !pShape->is_Valid() )
{
return( false );
}
//-----------------------------------------------------
CSG_Shapes Part(SHAPE_TYPE_Line);
CSG_Shape *pPart = Part.Add_Shape();
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
if( pShape->Get_Point_Count(iPart) > 1 )
{
bool bAscending = pShape->Get_Type() != SHAPE_TYPE_Polygon
|| ((CSG_Shape_Polygon *)pShape)->is_Lake(iPart) != ((CSG_Shape_Polygon *)pShape)->is_Clockwise(iPart);
CSG_Point q, p = pShape->Get_Point(0, iPart, bAscending);
pPart->Add_Point(p);
for(int iPoint=1; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
if( !p.is_Equal(q = pShape->Get_Point(iPoint, iPart, bAscending)) )
{
p = q;
pPart->Add_Point(p);
}
}
if( pPart->Get_Point_Count(0) > 1 )
{
_Add_Line(pPart, pShape->Get_Type());
}
pPart->Del_Parts();
}
}
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 CPolygon_Centroids::On_Execute(void)
{
bool bPart;
int iShape, iPart;
CSG_Shape *pCentroid;
CSG_Shape_Polygon *pPolygon;
CSG_Shapes *pPolygons, *pCentroids;
pPolygons = Parameters("POLYGONS") ->asShapes();
pCentroids = Parameters("CENTROIDS") ->asShapes();
bPart = Parameters("METHOD") ->asBool();
if( pPolygons->Get_Type() == SHAPE_TYPE_Polygon && pPolygons->Get_Count() > 0 )
{
pCentroids->Create(SHAPE_TYPE_Point, pPolygons->Get_Name(), pPolygons);
//-------------------------------------------------
for(iShape=0; iShape<pPolygons->Get_Count(); iShape++)
{
pPolygon = (CSG_Shape_Polygon *)pPolygons->Get_Shape(iShape);
if( bPart )
{
for(iPart=0; iPart<pPolygon->Get_Part_Count(); iPart++)
{
pCentroid = pCentroids->Add_Shape(pPolygon, SHAPE_COPY_ATTR);
pCentroid->Add_Point(pPolygon->Get_Centroid(iPart));
}
}
else
{
pCentroid = pCentroids->Add_Shape(pPolygon, SHAPE_COPY_ATTR);
pCentroid->Add_Point(pPolygon->Get_Centroid());
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
void CDXF_Import::addPoint(const DL_PointData &data)
{
if( !Check_Layer(attributes.getLayer().c_str()) )
return;
CSG_Shape *pPoint = m_pPoints->Add_Shape();
pPoint->Add_Point(m_Offset.x + data.x, m_Offset.y + data.y);
pPoint->Set_Value(TBL_POINTS_LAYER , CSG_String(attributes.getLayer().c_str()));
pPoint->Set_Value(TBL_POINTS_Z , m_Offset.z + data.z);
}
//---------------------------------------------------------
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 CQuadTree_Structure::Get_Shapes(CSG_Shapes *pShapes, CSG_PRQuadTree_Item *pItem, TSG_Shape_Type Type)
{
CSG_Shape *pShape;
if( pItem )
{
switch( Type )
{
default:
return( false );
case SHAPE_TYPE_Line:
pShapes->Create(SHAPE_TYPE_Line, _TL("QuadTree - Lines"));
pShapes->Add_Field("LEVEL", SG_DATATYPE_Int);
pShape = pShapes->Add_Shape();
pShape->Set_Value(0, 0.0);
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMin());
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMax());
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yMax());
pShape->Add_Point(pItem->Get_xMax(), pItem->Get_yMin());
pShape->Add_Point(pItem->Get_xMin(), pItem->Get_yMin());
break;
case SHAPE_TYPE_Polygon:
pShapes->Create(SHAPE_TYPE_Polygon, _TL("QuadTree - Squares"));
pShapes->Add_Field("LEVEL", SG_DATATYPE_Int);
pShapes->Add_Field("VALUE", SG_DATATYPE_Double);
break;
}
Get_Shapes(pShapes, pItem, 1);
return( true );
}
return( false );
}
//---------------------------------------------------------
void CDXF_Import::addLine(const DL_LineData &data)
{
if( !Check_Layer(attributes.getLayer().c_str()) )
return;
CSG_Shape *pLine = m_pLines->Add_Shape();
pLine->Add_Point(m_Offset.x + data.x1, m_Offset.y + data.y1);
pLine->Add_Point(m_Offset.x + data.x2, m_Offset.y + data.y2);
pLine->Set_Value(TBL_LINES_LAYER , CSG_String(attributes.getLayer().c_str()));
pLine->Set_Value(TBL_LINES_Z1 , m_Offset.z + data.z1);
pLine->Set_Value(TBL_LINES_Z2 , m_Offset.z + data.z2);
}
//---------------------------------------------------------
void CD8_Flow_Analysis::Get_Segment(int x, int y)
{
int i = m_pDir->asInt(x, y);
if( i >= 0 )
{
CSG_Shape *pSegment = m_pSegments->Add_Shape();
pSegment->Set_Value(0, m_pSegments->Get_Count()); // SEGMENT_ID
pSegment->Set_Value(1, m_Nodes.asInt(x, y)); // NODE_A
pSegment->Set_Value(3, m_pBasins->asInt(x, y)); // BASIN
pSegment->Set_Value(4, m_pOrder->asInt(x, y) + 1 - m_Threshold); // ORDER
pSegment->Set_Value(5, m_pOrder->asInt(x, y)); // ORDER_CELL
pSegment->Add_Point(Get_System()->Get_Grid_to_World(x, y));
pSegment->Set_Z(m_pDEM->asDouble(x, y), pSegment->Get_Point_Count() - 1);
do
{
x += Get_xTo(i);
y += Get_yTo(i);
pSegment->Add_Point(Get_System()->Get_Grid_to_World(x, y));
pSegment->Set_Z(m_pDEM->asDouble(x, y), pSegment->Get_Point_Count() - 1);
if( m_Nodes.asInt(x, y) )
{
pSegment->Set_Value(2, m_Nodes.asInt(x, y)); // NODE_B
pSegment->Set_Value(6, ((CSG_Shape_Line *)pSegment)->Get_Length()); // LENGTH
return;
}
}
while( (i = m_pDir->asInt(x, y)) >= 0 );
}
}
//---------------------------------------------------------
bool CGrid_Flow_Profile::Add_Point(int x, int y)
{
if( !m_pDEM->is_InGrid(x, y) )
{
return( false );
}
TSG_Point Point = Get_System()->Get_Grid_to_World(x, y);
double d, dSurface;
if( m_pPoints->Get_Count() == 0 )
{
d = dSurface = 0.0;
}
else
{
CSG_Shape *pLast = m_pPoints->Get_Shape(m_pPoints->Get_Count() - 1);
d = SG_Get_Distance(Point, pLast->Get_Point(0));
dSurface = pLast->asDouble(5) - m_pDEM->asDouble(x, y);
dSurface = sqrt(d*d + dSurface*dSurface);
d += pLast->asDouble(1);
dSurface += pLast->asDouble(2);
}
CSG_Shape *pPoint = m_pPoints->Add_Shape();
pPoint->Add_Point(Point);
pPoint->Set_Value(0, m_pPoints->Get_Count());
pPoint->Set_Value(1, d);
pPoint->Set_Value(2, dSurface);
pPoint->Set_Value(3, Point.x);
pPoint->Set_Value(4, Point.y);
pPoint->Set_Value(5, m_pDEM->asDouble(x, y));
for(int i=0; i<m_pValues->Get_Count(); i++)
{
pPoint->Set_Value(VALUE_OFFSET + i, m_pValues->asGrid(i)->asDouble(x, y));
}
m_pLine->Add_Point(Point);
return( true );
}
//---------------------------------------------------------
bool CXYZ_Import::On_Execute(void)
{
CSG_File Stream;
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_R) )
{
Error_Set(_TL("file could not be opened"));
return( false );
}
//-----------------------------------------------------
CSG_Shapes *pPoints = Parameters("POINTS")->asShapes();
pPoints->Create(SHAPE_TYPE_Point, SG_File_Get_Name(Parameters("FILENAME")->asString(), false));
pPoints->Add_Field("Z", SG_DATATYPE_Double);
//-----------------------------------------------------
if( Parameters("HEADLINE")->asBool() )
{
CSG_String sLine;
if( !Stream.Read_Line(sLine) )
{
Error_Set(_TL("could not read headline"));
return( false );
}
}
//-----------------------------------------------------
sLong Length = Stream.Length();
double x, y, z;
while( Stream.Scan(x) && Stream.Scan(y) && Stream.Scan(z) && Set_Progress((double)Stream.Tell(), (double)Length) )
{
CSG_Shape *pPoint = pPoints->Add_Shape();
pPoint->Add_Point(x, y);
pPoint->Set_Value(0, z);
}
return( pPoints->Get_Count() > 0 );
}
//---------------------------------------------------------
bool CGW_Regression_Grid::Set_Residuals(void)
{
CSG_Shapes *pResiduals = Parameters("RESIDUALS")->asShapes();
if( !pResiduals || !m_pPoints || !m_pRegression )
{
return( false );
}
//-----------------------------------------------------
pResiduals->Create(SHAPE_TYPE_Point, CSG_String::Format(SG_T("%s [%s]"), m_pPoints->Get_Name(), _TL("Residuals")));
pResiduals->Add_Field(m_pPoints->Get_Field_Name(m_iDependent), SG_DATATYPE_Double);
pResiduals->Add_Field("TREND" , SG_DATATYPE_Double);
pResiduals->Add_Field("RESIDUAL", SG_DATATYPE_Double);
//-------------------------------------------------
for(int iShape=0; iShape<m_pPoints->Get_Count() && Set_Progress(iShape, m_pPoints->Get_Count()); iShape++)
{
CSG_Shape *pShape = m_pPoints->Get_Shape(iShape);
double zShape = pShape->asDouble(m_iDependent);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
double zRegression;
TSG_Point Point = pShape->Get_Point(iPoint, iPart);
if( m_pRegression->Get_Value(Point, zRegression) )
{
CSG_Shape *pResidual = pResiduals->Add_Shape();
pResidual->Add_Point(Point);
pResidual->Set_Value(0, zShape);
pResidual->Set_Value(1, zRegression);
pResidual->Set_Value(2, zShape - zRegression);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
void CDXF_Import::add3dFace(const DL_3dFaceData &data)
{
if( !Check_Layer(attributes.getLayer().c_str()) )
return;
CSG_Shape *pTriangle = m_pTriangles->Add_Shape();
for(int i=0; i<3; i++)
{
pTriangle->Add_Point(m_Offset.x + data.x[i], m_Offset.y + data.y[i]);
}
pTriangle->Set_Value(TBL_TRIANGLE_LAYER , CSG_String(attributes.getLayer().c_str()));
pTriangle->Set_Value(TBL_TRIANGLE_THICK , data.thickness);
pTriangle->Set_Value(TBL_TRIANGLE_Z1 , m_Offset.z + data.z[0]);
pTriangle->Set_Value(TBL_TRIANGLE_Z2 , m_Offset.z + data.z[1]);
pTriangle->Set_Value(TBL_TRIANGLE_Z3 , m_Offset.z + data.z[2]);
}
//---------------------------------------------------------
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 CCollect_Points::On_Execute_Position(CSG_Point ptWorld, TSG_Module_Interactive_Mode Mode)
{
if( Mode == MODULE_INTERACTIVE_LUP )
{
TSG_Point ptTarget;
if( m_Engine.Get_Converted(ptTarget = ptWorld) )
{
Get_Parameters("REFERENCE")->Get_Parameter("X")->Set_Value(ptTarget.x);
Get_Parameters("REFERENCE")->Get_Parameter("Y")->Set_Value(ptTarget.y);
}
if( Dlg_Parameters("REFERENCE") )
{
int Method = Parameters("METHOD")->asInt();
int Order = Parameters("ORDER" )->asInt();
CSG_Shape *pPoint = m_pPoints->Add_Shape();
pPoint->Add_Point(ptWorld);
pPoint->Set_Value(0, ptWorld.Get_X());
pPoint->Set_Value(1, ptWorld.Get_Y());
pPoint->Set_Value(2, ptTarget.x = Get_Parameters("REFERENCE")->Get_Parameter("X")->asDouble());
pPoint->Set_Value(3, ptTarget.y = Get_Parameters("REFERENCE")->Get_Parameter("Y")->asDouble());
if( m_Engine.Add_Reference(ptWorld, ptTarget) && m_Engine.Evaluate(Method, Order) && m_pPoints->Get_Count() == m_Engine.Get_Reference_Count() )
{
for(int i=0; i<m_pPoints->Get_Count(); i++)
{
m_pPoints->Get_Shape(i)->Set_Value(4, m_Engine.Get_Reference_Residual(i));
}
}
DataObject_Update(m_pPoints);
}
}
return( true );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Transform(CSG_Grid *pGrid, CSG_Shapes *pPoints)
{
if( !pPoints || !pGrid )
{
return( false );
}
if( !m_Projector.Set_Source(pGrid->Get_Projection()) )
{
return( false );
}
int x, y;
TSG_Point Point;
pPoints->Create(SHAPE_TYPE_Point, _TL("Points"));
pPoints->Get_Projection() = m_Projector.Get_Target();
pPoints->Add_Field(pGrid->Get_Name(), pGrid->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( !pGrid->is_NoData(x, y) && m_Projector.Get_Projection(Point_Transformed) )
{
CSG_Shape *pPoint = pPoints->Add_Shape();
pPoint->Add_Point(Point_Transformed);
pPoint->Set_Value(0, pGrid->asDouble(x, y));
}
}
}
return( true );
}