//---------------------------------------------------------
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 CPC_From_Shapes::On_Execute(void)
{
int zField, iField, nFields, *Fields;
CSG_PointCloud *pPoints;
CSG_Shapes *pShapes;
pShapes = Parameters("SHAPES") ->asShapes();
pPoints = Parameters("POINTS") ->asPointCloud();
zField = Parameters("ZFIELD") ->asInt();
if( !pShapes->is_Valid() )
{
return( false );
}
//-----------------------------------------------------
pPoints->Create();
pPoints->Set_Name(pShapes->Get_Name());
nFields = 0;
Fields = new int[pShapes->Get_Field_Count()];
if( Parameters("OUTPUT")->asInt() == 1 )
{
for(iField=0, nFields=0; iField<pShapes->Get_Field_Count(); iField++)
{
if( iField != zField && SG_Data_Type_Get_Size(pShapes->Get_Field_Type(iField)) > 0 )
{
Fields[nFields++] = iField;
pPoints->Add_Field(pShapes->Get_Field_Name(iField), pShapes->Get_Field_Type(iField));
}
}
}
//-----------------------------------------------------
for(int iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
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);
pPoints->Add_Point(p.x, p.y, zField < 0 ? pShape->Get_Z(iPoint, iPart) : pShape->asDouble(zField));
for(iField=0; iField<nFields; iField++)
{
pPoints->Set_Value(3 + iField, pShape->asDouble(Fields[iField]));
}
}
}
}
//-----------------------------------------------------
delete [] Fields;
return( pPoints->Get_Count() > 0 );
}
//---------------------------------------------------------
bool CAddCoordinates::On_Execute(void)
{
CSG_Shapes *pShapes = Parameters("OUTPUT")->asShapes();
if( pShapes )
{
pShapes->Assign(Parameters("INPUT")->asShapes());
}
else
{
pShapes = Parameters("INPUT")->asShapes();
}
//-----------------------------------------------------
int xField = pShapes->Get_Field_Count();
pShapes->Add_Field("X", SG_DATATYPE_Double);
int yField = pShapes->Get_Field_Count();
pShapes->Add_Field("Y", SG_DATATYPE_Double);
int zField = 0, mField = 0;
if( pShapes->Get_Vertex_Type() != SG_VERTEX_TYPE_XY )
{
zField = pShapes->Get_Field_Count();
pShapes->Add_Field("Z", SG_DATATYPE_Double);
if( pShapes->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
mField = pShapes->Get_Field_Count();
pShapes->Add_Field("M", SG_DATATYPE_Double);
}
}
//-----------------------------------------------------
for(int i=0; i<pShapes->Get_Count(); i++)
{
CSG_Shape *pShape = pShapes->Get_Shape(i);
pShape->Set_Value(xField, pShape->Get_Point(0).x);
pShape->Set_Value(yField, pShape->Get_Point(0).y);
if( pShapes->Get_Vertex_Type() != SG_VERTEX_TYPE_XY )
{
pShape->Set_Value(zField, pShape->Get_Z(0));
if( pShapes->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
pShape->Set_Value(mField, pShape->Get_M(0));
}
}
}
DataObject_Update(pShapes);
return( true );
}
//---------------------------------------------------------
bool CSelection_Copy::On_Execute(void)
{
CSG_Shapes *pInput, *pOutput;
pInput = Parameters("INPUT") ->asShapes();
pOutput = Parameters("OUTPUT")->asShapes();
if( pInput->Get_Selection_Count() <= 0 )
{
Error_Set(_TL("no shapes in selection"));
return( false );
}
if( pOutput->Get_Type() != SHAPE_TYPE_Undefined && pOutput->Get_Type() != pInput->Get_Type() && pOutput->Get_Vertex_Type() != pInput->Get_Vertex_Type() )
{
Parameters("OUTPUT")->Set_Value(pOutput = SG_Create_Shapes());
}
pOutput->Create(pInput->Get_Type(), CSG_String::Format(SG_T("%s [%s]"), pInput->Get_Name(), _TL("Selection")), pInput, pInput->Get_Vertex_Type());
for(int i=0; i<pInput->Get_Selection_Count() && Set_Progress(i, pInput->Get_Selection_Count()); i++)
{
CSG_Shape *pShape = pInput->Get_Selection(i);
pOutput->Add_Shape(pShape);
if( pInput->Get_Vertex_Type() > SG_VERTEX_TYPE_XY )
{
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
pOutput->Get_Shape(i)->Set_Z(pShape->Get_Z(iPoint, iPart), iPoint, iPart);
if( pInput->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
pOutput->Get_Shape(i)->Set_M(pShape->Get_M(iPoint, iPart), iPoint, iPart);
}
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CPoints_From_MultiPoints::On_Execute(void)
{
//-----------------------------------------------------
CSG_Shapes *pMultipoints = Parameters("MULTIPOINTS") ->asShapes();
CSG_Shapes *pPoints = Parameters("POINTS") ->asShapes();
pPoints->Create(SHAPE_TYPE_Point, pMultipoints->Get_Name(), pMultipoints, pMultipoints->Get_Vertex_Type());
//-----------------------------------------------------
for(int iMultipoint=0; iMultipoint<pMultipoints->Get_Count() && Set_Progress(iMultipoint, pMultipoints->Get_Count()); iMultipoint++)
{
CSG_Shape *pMultipoint = pMultipoints->Get_Shape(iMultipoint);
for(int iPart=0; iPart<pMultipoint->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pMultipoint->Get_Point_Count(iPart); iPoint++)
{
CSG_Shape *pPoint = pPoints->Add_Shape(pMultipoint, SHAPE_COPY_ATTR);
pPoint->Add_Point(pMultipoint->Get_Point(iPoint, iPart));
if( pMultipoints->Get_Vertex_Type() != SG_VERTEX_TYPE_XY )
{
pPoint->Set_Z(pMultipoint->Get_Z(iPoint, iPart), 0);
if( pMultipoints->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
pPoint->Set_M(pMultipoint->Get_M(iPoint, iPart), 0);
}
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CShapes_Convert_Vertex_Type::On_Execute(void)
{
CSG_Shapes *pInput, *pOutput;
int iFieldZ, iFieldM;
pInput = Parameters("INPUT")->asShapes();
iFieldZ = Parameters("FIELD_Z")->asInt();
iFieldM = Parameters("FIELD_M")->asInt();
pOutput = Parameters("OUTPUT")->asShapes();
if( pInput->Get_Count() < 1 )
{
SG_UI_Msg_Add_Error(_TL("Input shape is empty!"));
return (false);
}
//-----------------------------------------------------
if( pInput->Get_Vertex_Type() == SG_VERTEX_TYPE_XY )
{
if( iFieldZ < 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide an attribute field with z-information!"));
return( false );
}
if( iFieldM < 0 )
{
pOutput->Create(pInput->Get_Type(), CSG_String::Format(SG_T("%s_Z"), pInput->Get_Name()), pInput, SG_VERTEX_TYPE_XYZ);
}
else
{
pOutput->Create(pInput->Get_Type(), CSG_String::Format(SG_T("%s_ZM"), pInput->Get_Name()), pInput, SG_VERTEX_TYPE_XYZM);
}
}
else
{
pOutput->Create(pInput->Get_Type(), CSG_String::Format(SG_T("%s_XY"), pInput->Get_Name()), pInput, SG_VERTEX_TYPE_XY);
pOutput->Add_Field(SG_T("Z"), SG_DATATYPE_Double);
if( pInput->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
pOutput->Add_Field(SG_T("M"), SG_DATATYPE_Double);
}
}
//-----------------------------------------------------
for(int iShape=0; iShape<pInput->Get_Count(); iShape++)
{
CSG_Shape *pShapeIn = pInput ->Get_Shape(iShape);
CSG_Shape *pShapeOut = pOutput ->Add_Shape(pShapeIn, SHAPE_COPY_ATTR);
for(int iPart=0; iPart<pShapeIn->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShapeIn->Get_Point_Count(iPart); iPoint++)
{
pShapeOut->Add_Point(pShapeIn->Get_Point(iPoint, iPart), iPart);
if( pInput->Get_Vertex_Type() == SG_VERTEX_TYPE_XY )
{
pShapeOut->Set_Z(pShapeIn->asDouble(iFieldZ), iPoint, iPart);
if( pOutput->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
pShapeOut->Set_M(pShapeIn->asDouble(iFieldM), iPoint, iPart);
}
}
else
{
if( pInput->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
pShapeOut->Set_Value(pOutput->Get_Field_Count() - 1, pShapeIn->Get_M(iPoint, iPart));
pShapeOut->Set_Value(pOutput->Get_Field_Count() - 2, pShapeIn->Get_Z(iPoint, iPart));
}
else
{
pShapeOut->Set_Value(pOutput->Get_Field_Count() - 1, pShapeIn->Get_Z(iPoint, iPart));
}
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
CSG_Shape * CSG_PointCloud::_Set_Shape(int iPoint)
{
SG_UI_Progress_Lock(true);
CSG_Shape *pShape = m_Shapes.Get_Shape(0);
if( pShape->is_Modified() && m_Shapes_Index >= 0 && m_Shapes_Index < Get_Count() )
{
m_Cursor = m_Points[m_Shapes_Index];
for(int i=0; i<Get_Field_Count(); i++)
{
switch( Get_Field_Type(i) )
{
default:
Set_Value(i, pShape->asDouble(i));
break;
case SG_DATATYPE_Date:
case SG_DATATYPE_String:
Set_Value(i, pShape->asString(i));
break;
}
}
Set_Value(0, pShape->Get_Point(0).x);
Set_Value(1, pShape->Get_Point(0).y);
Set_Value(2, pShape->Get_Z (0) );
}
if( iPoint >= 0 && iPoint < Get_Count() )
{
if(1|| iPoint != m_Shapes_Index )
{
m_Cursor = m_Points[iPoint];
pShape->Set_Point(Get_X(), Get_Y(), 0, 0);
pShape->Set_Z (Get_Z() , 0, 0);
for(int i=0; i<Get_Field_Count(); i++)
{
switch( Get_Field_Type(i) )
{
default:
pShape->Set_Value(i, Get_Value(i));
break;
case SG_DATATYPE_Date:
case SG_DATATYPE_String:
{
CSG_String s;
Get_Value(i, s);
pShape->Set_Value(i, s);
}
break;
}
}
m_Shapes_Index = iPoint;
pShape->m_Index = iPoint;
pShape->Set_Selected(is_Selected(iPoint));
}
m_Shapes.Set_Modified(false);
SG_UI_Progress_Lock(false);
return( pShape );
}
m_Shapes_Index = -1;
SG_UI_Progress_Lock(false);
return( NULL );
}
