X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_PolylineXY.cxx;h=d418144a2e1865ef4b2fa25d71411bc399ed1274;hb=4a4e234c1bde9db8ac7e1020842ab355e03335b0;hp=d2f997940f6daa4b80ab18c93b261f8ea543f6b2;hpb=7e825ec456c9331ef0df1cb59865cc55f0d8516a;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_PolylineXY.cxx b/src/HYDROData/HYDROData_PolylineXY.cxx index d2f99794..d418144a 100755 --- a/src/HYDROData/HYDROData_PolylineXY.cxx +++ b/src/HYDROData/HYDROData_PolylineXY.cxx @@ -1,25 +1,96 @@ #include "HYDROData_PolylineXY.h" +#include "HYDROData_BSplineOperation.h" +#include "HYDROData_Document.h" +#include "HYDROData_ShapesTool.h" #include "HYDROData_Tool.h" +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include + #include #include #include -#include #include #include +#include + #include #include -#include #include +#include #include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +static const Standard_GUID GUID_IS_UNEDITABLE("e5799736-9030-4051-91a4-2e58321fa153"); + +const double LOCAL_SELECTION_TOLERANCE = 0.0001; + +TCollection_AsciiString getUniqueSectionName( const NCollection_Sequence& theNamesSeq ) +{ + NCollection_Map aNamesMap; + + for ( int i = 1, n = theNamesSeq.Size(); i <= n; ++i ) + { + const TCollection_AsciiString& aSectName = theNamesSeq.Value( i ); + aNamesMap.Add( aSectName ); + } + + TCollection_AsciiString aResName; + + int aPrefIdx = 1; + do + { + aResName = TCollection_AsciiString( "Section_" ) + aPrefIdx; + ++aPrefIdx; + } + while ( aNamesMap.Contains( aResName ) ); -#include + return aResName; +} +TCollection_AsciiString getUniqueSectionName( const Handle(TDataStd_ExtStringList)& theNamesList ) +{ + NCollection_Sequence aNamesSeq; + + TDataStd_ListIteratorOfListOfExtendedString aNamesIter( theNamesList->List() ); + for ( ; aNamesIter.More(); aNamesIter.Next() ) + aNamesSeq.Append( aNamesIter.Value() ); + + return getUniqueSectionName( aNamesSeq ); +} IMPLEMENT_STANDARD_HANDLE(HYDROData_PolylineXY, HYDROData_IPolyline) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_PolylineXY, HYDROData_IPolyline) @@ -33,344 +104,543 @@ HYDROData_PolylineXY::~HYDROData_PolylineXY() { } -CurveCreator_ICurve::ListAISObjects HYDROData_PolylineXY::constructWire() const +QStringList HYDROData_PolylineXY::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const { - // TODO - ListAISObjects aProfileObjects; - return aProfileObjects; + QStringList aResList = dumpObjectCreation( theTreatedObjects ); + QString aPolylineName = GetObjPyName(); + + // Set polilyne data + NCollection_Sequence aSectNames; + NCollection_Sequence aSectTypes; + NCollection_Sequence aSectClosures; + GetSections( aSectNames, aSectTypes, aSectClosures ); + + for ( int i = 1, n = aSectNames.Size(); i <= n; ++i ) + { + const TCollection_AsciiString& aSectName = aSectNames.Value( i ); + const SectionType& aSectType = aSectTypes.Value( i ); + bool aSectClosure = aSectClosures.Value( i ); + + aResList << QString( "%1.AddSection( \"%2\", %3, %4 );" ).arg( aPolylineName ) + .arg( aSectName.ToCString() ).arg( aSectType ).arg( aSectClosure ); + + HYDROData_IPolyline::PointsList aSectPointsList = GetPoints( i - 1 ); + for ( int k = 1, aNbPoints = aSectPointsList.Size(); k <= aNbPoints; ++k ) + { + const Point& aSectPoint = aSectPointsList.Value( k ); + + aResList << QString( "%1.AddPoint( %2, gp_XY( %3, %4 ) );" ).arg( aPolylineName ) + .arg( i - 1 ).arg( aSectPoint.X() ).arg( aSectPoint.Y() ); + } + } + + aResList << QString( "" ); + aResList << QString( "%1.Update();" ).arg( aPolylineName ); + aResList << QString( "" ); + + return aResList; } -bool HYDROData_PolylineXY::clear() +QVariant HYDROData_PolylineXY::GetDataVariant() { - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); + QPainterPath aPath = GetPainterPath(); - removeSectionsLists(); - removePointsLists(); + QVariant aVarData; + aVarData.setValue( aPath ); + + return aVarData; +} - if ( !anIsOperation ) - commitOperation(); +QColor HYDROData_PolylineXY::DefaultWireColor() +{ + return QColor( Qt::red ); +} - return true; +TopoDS_Shape HYDROData_PolylineXY::GetShape() const +{ + return getPolylineShape(); } -bool HYDROData_PolylineXY::join( const int theISectionTo, - const int theISectionFrom ) +bool convertEdgeToSection( const TopoDS_Edge& theEdge, + NCollection_Sequence& theSectNames, + NCollection_Sequence& theSectTypes, + NCollection_Sequence& theSectClosures, + NCollection_Sequence& theSectPoints, + const bool theIsCanBeClosed ) { - Handle(TDataStd_ExtStringList) aNamesList; - Handle(TDataStd_IntegerList) aTypesList; - Handle(TDataStd_BooleanList) aClosuresList; - getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); - if ( aNamesList.IsNull() || aNamesList->Extent() <= 1 ) + Standard_Real aFirst = 0.0, aLast = 0.0; + Handle(Geom_Curve) anEdgeGeomCurve = BRep_Tool::Curve( theEdge, aFirst, aLast ); + if ( anEdgeGeomCurve.IsNull() ) return false; - - bool anIsOperation = myIsOperation; - if ( theISectionTo == -1 || theISectionFrom == -1 ) + TCollection_AsciiString aSectName = getUniqueSectionName( theSectNames ); + bool anIsEdgeClosed = anEdgeGeomCurve->IsClosed(); + + HYDROData_PolylineXY::SectionType aSectionType = HYDROData_PolylineXY::SECTION_POLYLINE; + HYDROData_PolylineXY::PointsList aPointsList; + + if ( anEdgeGeomCurve->IsKind( STANDARD_TYPE(Geom_Line) ) ) { - // Join all sections to one - if ( !anIsOperation ) - startOperation(); + Handle(Geom_Line) aGeomLine = Handle(Geom_Line)::DownCast( anEdgeGeomCurve ); - TCollection_ExtendedString aSectName = aNamesList->First(); - CurveCreator::SectionType aSectType = (CurveCreator::SectionType)aTypesList->First(); - bool anIsClosed = aClosuresList->First(); + gp_Pnt aFirstPoint, aLastPoint; + aGeomLine->D0( aFirst, aFirstPoint ); + aGeomLine->D0( aLast, aLastPoint ); - aNamesList->Clear(); - aTypesList->Clear(); - aClosuresList->Clear(); - - aNamesList->Append( aSectName ); - aTypesList->Append( aSectType ); - aClosuresList->Append( anIsClosed ); + HYDROData_PolylineXY::Point aSectFirstPoint( aFirstPoint.X(), aFirstPoint.Y() ); + aPointsList.Append( aSectFirstPoint ); - CurveCreator::Coordinates anAllPoints = getPoints(); - removePointsLists(); + HYDROData_PolylineXY::Point aSectLastPoint( aLastPoint.X(), aLastPoint.Y() ); + aPointsList.Append( aSectLastPoint ); + } + else if ( anEdgeGeomCurve->IsKind( STANDARD_TYPE(Geom_BSplineCurve) ) ) + { + aSectionType = HYDROData_PolylineXY::SECTION_SPLINE; + + Handle(Geom_BSplineCurve) aGeomSpline = + Handle(Geom_BSplineCurve)::DownCast( anEdgeGeomCurve ); + + int aNbKnots = aGeomSpline->NbKnots(); + + TColStd_Array1OfReal aSplineKnots( 1, aNbKnots ); + aGeomSpline->Knots( aSplineKnots ); + + // Decrease the number of imported knots because of last one + // knot is the closing point which are the start point + if ( anIsEdgeClosed ) aNbKnots--; + + for ( int i = 1; i <= aNbKnots; ++i ) + { + const Standard_Real& aKnot = aSplineKnots.Value( i ); + + gp_Pnt aPoint; + aGeomSpline->D0( aKnot, aPoint ); - addPoints( anAllPoints, 0 ); + HYDROData_PolylineXY::Point aSectPoint( aPoint.X(), aPoint.Y() ); + aPointsList.Append( aSectPoint ); + } } else { - // Join selected range of sections to one - if ( theISectionFrom >= theISectionTo ) - return false; + // Other curve types are not supported + return false; + } - if ( !anIsOperation ) - startOperation(); + if ( aPointsList.IsEmpty() ) + return false; - TDataStd_ListOfExtendedString anOldNamesList; - anOldNamesList = aNamesList->List(); + theSectNames.Append( aSectName ); + theSectTypes.Append( aSectionType ); + theSectClosures.Append( anIsEdgeClosed ); + theSectPoints.Append( aPointsList ); - TColStd_ListOfInteger anOldTypesList; - anOldTypesList = aTypesList->List(); + return true; +} - TDataStd_ListOfByte anOldClosuresList; - anOldClosuresList = aClosuresList->List(); +bool HYDROData_PolylineXY::ImportShape( const TopoDS_Shape& theShape ) +{ + if ( theShape.IsNull() ) + return false; - // Refill the existing lists - aNamesList->Clear(); - aTypesList->Clear(); - aClosuresList->Clear(); + RemoveSections(); - Handle(TDataStd_RealList) aJoinListX, aJoinListY; + bool anIsCanBeImported = false; - TDataStd_ListIteratorOfListOfExtendedString aNamesIter( anOldNamesList ); - TColStd_ListIteratorOfListOfInteger aTypesIter( anOldTypesList ); - TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList ); + NCollection_Sequence aSectNames; + NCollection_Sequence aSectTypes; + NCollection_Sequence aSectClosures; + NCollection_Sequence aSectPoints; + + if ( theShape.ShapeType() == TopAbs_EDGE ) + { + TopoDS_Edge anEdge = TopoDS::Edge( theShape ); + anIsCanBeImported = convertEdgeToSection( anEdge, aSectNames, aSectTypes, aSectClosures, aSectPoints, true ); + } + else if ( theShape.ShapeType() == TopAbs_WIRE ) + { + TopTools_SequenceOfShape anEdges; + HYDROData_ShapesTool::ExploreShapeToShapes( theShape, TopAbs_EDGE, anEdges ); - int aNbSect = 0; - for ( ; aNamesIter.More() && aTypesIter.More() && aClosuresIter.More(); - aNamesIter.Next(), aTypesIter.Next(), aClosuresIter.Next(), ++aNbSect ) + anIsCanBeImported = !anEdges.IsEmpty(); + for ( int i = 1, n = anEdges.Length(); i <= n && anIsCanBeImported; ++i ) { - if ( aNbSect < theISectionFrom || aNbSect > theISectionTo ) - { - aNamesList->Append( aNamesIter.Value() ); - aTypesList->Append( aTypesIter.Value() ); - aClosuresList->Append( (bool)aClosuresIter.Value() ); - } - else - { - if ( aNbSect == theISectionFrom ) - { - aNamesList->Append( aNamesIter.Value() ); - aTypesList->Append( aTypesIter.Value() ); - aClosuresList->Append( (bool)aClosuresIter.Value() ); - - getPointsLists( aNbSect, aJoinListX, aJoinListY ); - } - else - { - Handle(TDataStd_RealList) aListX, aListY; - getPointsLists( aNbSect, aListX, aListY ); - - TColStd_ListIteratorOfListOfReal anIterX( aListX->List() ); - TColStd_ListIteratorOfListOfReal anIterY( aListY->List() ); - for ( ; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next() ) - { - aJoinListX->Append( anIterX.Value() ); - aJoinListY->Append( anIterY.Value() ); - } - - removePointsLists( aNbSect ); - } - } + TopoDS_Edge aWireEdge = TopoDS::Edge( anEdges.Value( i ) ); + anIsCanBeImported = convertEdgeToSection( aWireEdge, aSectNames, aSectTypes, aSectClosures, aSectPoints, false ); + } + } - // Move the list which are after theISectionTo to correct place - for ( int i = theISectionTo + 1, j = theISectionFrom + 1; i < aNbSect; ++i, j++ ) - { - CurveCreator::Coordinates aPoints = getPoints( i ); - removePointsLists( i ); - addPoints( aPoints, j ); - } + if ( anIsCanBeImported ) + { + for ( int i = 1, n = aSectNames.Length(); i <= n; ++i ) + { + const TCollection_AsciiString& aSectName = aSectNames.Value( i ); + const SectionType& aSectType = aSectTypes.Value( i ); + bool anIsSectionClosed = aSectClosures.Value( i ); + const PointsList& aSectPointsList = aSectPoints( i ); + + AddSection( aSectName, aSectType, anIsSectionClosed ); + SetPoints( i - 1, aSectPointsList ); } } + else + { + TopoDS_Shape aShape = theShape; + + if ( theShape.ShapeType() == TopAbs_EDGE ) + { + // We make the wire from incoming edge because of other algorithms + // are waiting at least the wire from polyline + TopoDS_Edge anEdge = TopoDS::Edge( theShape ); + BRepBuilderAPI_MakeWire aMakeWire( anEdge ); + aMakeWire.Build(); + if ( aMakeWire.IsDone() ) + aShape = aMakeWire.Wire(); + } + + gp_Pln aPlane( gp_Pnt( 0, 0, 0 ), gp_Dir( 0, 0, 1 ) ); + BRepBuilderAPI_MakeFace aMakeFace( aPlane ); + aMakeFace.Build(); + BRepOffsetAPI_NormalProjection aProj( aMakeFace.Face() ); + aProj.Add( aShape ); + aProj.Build(); + TopoDS_Shape aResult; + if( aProj.IsDone() ) + aResult = aProj.Shape(); + + setPolylineShape( aResult ); + } - if ( !anIsOperation ) - commitOperation(); + setEditable( anIsCanBeImported ); return true; } -int HYDROData_PolylineXY::getNbSections() const +TopoDS_Wire HYDROData_PolylineXY::BuildWire( const SectionType& theType, + const bool& theIsClosed, + const NCollection_Sequence& thePoints ) { - Handle(TDataStd_ExtStringList) aNamesList; - Handle(TDataStd_IntegerList) aTypesList; - Handle(TDataStd_BooleanList) aClosuresList; - getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); + TopoDS_Wire aWire; + if( theType == SECTION_POLYLINE ) + { + BRepBuilderAPI_MakePolygon aMakeWire; + for ( int i = 1, n = thePoints.Length(); i <= n ; ++i ) + { + gp_XYZ aPoint = thePoints.Value( i ); + gp_Pnt aPnt( aPoint.X(), aPoint.Y(), aPoint.Z() ); + aMakeWire.Add( aPnt ); + } + if( theIsClosed ) + aMakeWire.Close(); + + if ( aMakeWire.IsDone() ) + aWire = aMakeWire.Wire(); + } + else //if( theType == PolylineSection::SECTION_SPLINE ) + { + BRepBuilderAPI_MakeWire aMakeWire; - return aNamesList.IsNull() ? 0 : aNamesList->Extent(); + if ( thePoints.Size() > 1 ) + { + HYDROData_BSplineOperation aBSpline( thePoints, theIsClosed, LOCAL_SELECTION_TOLERANCE ); + + TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aBSpline.Curve() ).Edge(); + aMakeWire.Add( anEdge ); + } + aMakeWire.Build(); + if ( aMakeWire.IsDone() ) + aWire = aMakeWire; + } + + return aWire; } -TCollection_ExtendedString getUniqueSectionName( const Handle(TDataStd_ExtStringList)& theNamesList ) +void HYDROData_PolylineXY::BuildPainterPath( QPainterPath& thePath, + const SectionType& theType, + const bool& theIsClosed, + const NCollection_Sequence& thePoints ) { - NCollection_Map aNamesMap; + if ( thePoints.IsEmpty() ) + return; - TDataStd_ListIteratorOfListOfExtendedString aNamesIter( theNamesList->List() ); - for ( ; aNamesIter.More(); aNamesIter.Next() ) - aNamesMap.Add( aNamesIter.Value() ); + if ( theType == SECTION_POLYLINE ) + { + const gp_XYZ& aFirstPoint = thePoints.Value( 1 ); + thePath.moveTo( aFirstPoint.X(), aFirstPoint.Y() ); - TCollection_ExtendedString aResName; + for( int i = 2, n = thePoints.Size(); i <= n; ++i ) + { + const gp_XYZ& aSectPoint = thePoints.Value( i ); - int aPrefIdx = 1; - do + thePath.lineTo( aSectPoint.X(), aSectPoint.Y() ); + } + + if( theIsClosed ) + thePath.closeSubpath(); + } + else { - aResName = "Section_" + aPrefIdx; - ++aPrefIdx; + HYDROData_BSplineOperation aBSpline( thePoints, theIsClosed, LOCAL_SELECTION_TOLERANCE ); + aBSpline.ComputePath( thePath ); } - while ( aNamesMap.Contains( aResName ) ); - - return aResName; } -int HYDROData_PolylineXY::addSection( const std::string& theName, - const CurveCreator::SectionType theType, - const bool theIsClosed ) +void HYDROData_PolylineXY::Update() { - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); + if ( !IsEditable() ) + { + // If polyline is not editable we no need to update it wire + SetToUpdate( false ); + return; + } - Handle(TDataStd_ExtStringList) aNamesList; - Handle(TDataStd_IntegerList) aTypesList; - Handle(TDataStd_BooleanList) aClosuresList; - getSectionsLists( aNamesList, aTypesList, aClosuresList ); + HYDROData_IPolyline::Update(); - TCollection_ExtendedString aSectName = theName.c_str(); - if ( aSectName.Length() <= 0 ) - aSectName = getUniqueSectionName( aNamesList ); + NCollection_Sequence aSectNames; + NCollection_Sequence aSectTypes; + NCollection_Sequence aSectClosures; + GetSections( aSectNames, aSectTypes, aSectClosures ); - aNamesList->Append( aSectName ); - aTypesList->Append( theType ); - aClosuresList->Append( theIsClosed ); + BRepBuilderAPI_MakeWire aMakeWire; - int aSectId = aNamesList->Extent() - 1; + TopTools_ListOfShape aSectionWiresList; - // Just to create empty data - Handle(TDataStd_RealList) aListX, aListY; - getPointsLists( aSectId, aListX, aListY ); + for ( int aSectionId = 1, aNbSects = aSectNames.Size(); aSectionId <= aNbSects; aSectionId++ ) + { + TCollection_AsciiString aSectName = aSectNames.Value( aSectionId ); + SectionType aSectionType = aSectTypes.Value( aSectionId ); + bool anIsSectionClosed = aSectClosures.Value( aSectionId ); - if ( !anIsOperation ) - commitOperation(); + PointsList aSectPointsList = GetPoints( aSectionId - 1 ); + if ( aSectPointsList.IsEmpty() ) + continue; + + NCollection_Sequence aPoints; + for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i ) + { + const Point& aSectPoint = aSectPointsList.Value( i ); - return aSectId; + gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 ); + aPoints.Append( aPoint ); + } + + TopoDS_Wire aSectionWire = BuildWire( aSectionType, anIsSectionClosed, aPoints ); + if ( !aSectionWire.IsNull() ) { + aSectionWiresList.Append( aSectionWire ); + aMakeWire.Add( aSectionWire ); + } + } +// all input wires in the + Handle(TopTools_HSequenceOfShape) aSeqWires = new TopTools_HSequenceOfShape; + Handle(TopTools_HSequenceOfShape) aSeqEdges = new TopTools_HSequenceOfShape; + TopTools_ListIteratorOfListOfShape it(aSectionWiresList); + for(;it.More();it.Next()) + { + TopExp_Explorer it2(it.Value(), TopAbs_EDGE); + for(;it2.More();it2.Next()) + aSeqEdges->Append(it2.Current()); + } + + BRep_Builder aBB; + TopoDS_Compound aCmp; + TopoDS_Shape aResult; + aBB.MakeCompound(aCmp); + if(aSeqEdges->Length() >1) + { + ShapeAnalysis_FreeBounds::ConnectEdgesToWires(aSeqEdges,1E-5,Standard_False,aSeqWires); + + if( aSeqWires->Length()==1 ) + aResult = aSeqWires->Value( 1 ); + else + { + for (Standard_Integer i = 1; i <= aSeqWires->Length();i++) + { + const TopoDS_Shape& aS1 = aSeqWires->Value(i); + aBB.Add(aCmp, aS1); + } + aResult = aCmp; + } + } + else if (aSeqEdges->Length() == 1) + { + BRepBuilderAPI_MakeWire mkWire (TopoDS::Edge(aSeqEdges->Value(1))); + if (mkWire.IsDone()) + aResult = mkWire.Wire(); + } + + setPolylineShape( aResult ); } -bool HYDROData_PolylineXY::removeSection( const int theISection ) +bool HYDROData_PolylineXY::IsEditable() const { - Handle(TDataStd_ExtStringList) aNamesList; - Handle(TDataStd_IntegerList) aTypesList; - Handle(TDataStd_BooleanList) aClosuresList; - getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); - if ( aNamesList.IsNull() || aNamesList->IsEmpty() ) - return false; + return !myLab.IsAttribute( GUID_IS_UNEDITABLE ); +} + +void HYDROData_PolylineXY::setEditable( const bool theIsEditable ) +{ + if ( !theIsEditable ) + TDataStd_UAttribute::Set( myLab, GUID_IS_UNEDITABLE ); + else + myLab.ForgetAttribute( GUID_IS_UNEDITABLE ); +} - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); +/** + * Returns true if polyline is closed + */ +bool HYDROData_PolylineXY::IsClosed( const bool theIsSimpleCheck ) const +{ + bool anIsClosed = false; - if ( aNamesList->Extent() == 1 ) + TopoDS_Shape aShape = GetShape(); + if ( aShape.IsNull() ) + return anIsClosed; + + TopTools_SequenceOfShape aWires; + HYDROData_ShapesTool::ExploreShapeToShapes( aShape, TopAbs_WIRE, aWires ); + + int aNbWires = aWires.Length(); + if ( theIsSimpleCheck ) { - removeSectionsLists(); - removePointsLists(); + anIsClosed = aNbWires > 0; + for ( int i = 1; i <= aNbWires && anIsClosed; ++i ) + { + const TopoDS_Shape& aWire = aWires.Value( i ); + anIsClosed = BRep_Tool::IsClosed( aWire ); + } } else { - TDataStd_ListOfExtendedString anOldNamesList; - anOldNamesList = aNamesList->List(); + anIsClosed = aNbWires == 1 && BRep_Tool::IsClosed( aWires.First() ); + } - TColStd_ListOfInteger anOldTypesList; - anOldTypesList = aTypesList->List(); + return anIsClosed; +} - TDataStd_ListOfByte anOldClosuresList; - anOldClosuresList = aClosuresList->List(); +double HYDROData_PolylineXY::GetDistance( const int theSectionIndex, + const int thePointIndex ) const +{ + double aResDistance = -1; + if ( theSectionIndex < 0 || theSectionIndex >= NbSections() ) + return aResDistance; - // Refill the existing lists - aNamesList->Clear(); - aTypesList->Clear(); - aClosuresList->Clear(); + if ( thePointIndex == 0 ) + return 0.0; - TDataStd_ListIteratorOfListOfExtendedString aNamesIter( anOldNamesList ); - TColStd_ListIteratorOfListOfInteger aTypesIter( anOldTypesList ); - TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList ); - for ( int i = 0; aNamesIter.More() && aTypesIter.More() && aClosuresIter.More(); - aNamesIter.Next(), aTypesIter.Next(), aClosuresIter.Next(), ++i ) + SectionType aSectionType = GetSectionType( theSectionIndex ); + bool anIsSectionClosed = IsClosedSection( theSectionIndex ); + PointsList aSectPointsList = GetPoints( theSectionIndex ); + if ( thePointIndex < 0 || thePointIndex >= aSectPointsList.Size() ) + return aResDistance; + + if ( aSectionType == SECTION_POLYLINE ) + { + aResDistance = 0.0; + + Point aPrevPoint = aSectPointsList.Value( 1 ); + for ( int i = 2, aNbPoints = aSectPointsList.Size(); i <= aNbPoints; ++i ) { - if ( i == theISection ) - continue; // skip index to remove + const Point& aSectPoint = aSectPointsList.Value( i ); + aResDistance += gp_Pnt2d( aPrevPoint ).Distance( aSectPoint ); + aPrevPoint = aSectPoint; - aNamesList->Append( aNamesIter.Value() ); - aTypesList->Append( aTypesIter.Value() ); - aClosuresList->Append( (bool)aClosuresIter.Value() ); + if ( thePointIndex == i - 1 ) + break; } - - // Remove points that belong to removed section - removePointsLists( theISection ); } + else + { + gp_XYZ aPointToTest; - if ( !anIsOperation ) - commitOperation(); + int aSectNbPoints = aSectPointsList.Size(); + NCollection_Sequence aPoints; + for( int i = 1 ; i <= aSectNbPoints; ++i ) + { + const Point& aSectPoint = aSectPointsList.Value( i ); - return true; -} + gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 ); + aPoints.Append( aPoint ); -bool HYDROData_PolylineXY::isClosed( const int theISection ) const -{ - Handle(TDataStd_ExtStringList) aNamesList; - Handle(TDataStd_IntegerList) aTypesList; - Handle(TDataStd_BooleanList) aClosuresList; - getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); - if ( aNamesList.IsNull() || theISection >= aNamesList->Extent() ) - return false; + if ( thePointIndex == i - 1 ) + aPointToTest = aPoint; + } - TDataStd_ListIteratorOfListOfByte aClosuresIter( aClosuresList->List() ); - for ( int i = 0; aClosuresIter.More() && i != theISection; aClosuresIter.Next(), ++i ); + HYDROData_BSplineOperation aBSpline( aPoints, anIsSectionClosed, LOCAL_SELECTION_TOLERANCE ); - return aClosuresIter.More() ? (bool)aClosuresIter.Value() : false; + Quantity_Parameter aFirstParam = aBSpline.Curve()->FirstParameter(); + Quantity_Parameter aSecondParam = aBSpline.Curve()->LastParameter(); + + if ( thePointIndex != aSectNbPoints - 1 ) + { + GeomAPI_ProjectPointOnCurve aProject( aPointToTest, aBSpline.Curve() ); + aSecondParam = aProject.LowerDistanceParameter(); + } + + GeomAdaptor_Curve anAdap( aBSpline.Curve() ); + + aResDistance = GCPnts_AbscissaPoint::Length( anAdap, aFirstParam, aSecondParam ); + } + + return aResDistance; } -bool HYDROData_PolylineXY::setClosed( const int theISection, - const bool theIsClosed ) +int HYDROData_PolylineXY::NbSections() const { Handle(TDataStd_ExtStringList) aNamesList; - Handle(TDataStd_IntegerList) aTypesList; - Handle(TDataStd_BooleanList) aClosuresList; + Handle(TDataStd_IntegerList) aTypesList; + Handle(TDataStd_BooleanList) aClosuresList; getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); - if ( aNamesList.IsNull() || theISection >= aNamesList->Extent() ) - return false; - - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); - TDataStd_ListOfByte anOldClosuresList; - anOldClosuresList = aClosuresList->List(); + return !aClosuresList.IsNull() ? aClosuresList->Extent() : 0; +} - // Refill the existing list - aClosuresList->Clear(); +void HYDROData_PolylineXY::AddSection( const TCollection_AsciiString& theSectName, + const SectionType theSectionType, + const bool theIsClosed ) +{ + Handle(TDataStd_ExtStringList) aNamesList; + Handle(TDataStd_IntegerList) aTypesList; + Handle(TDataStd_BooleanList) aClosuresList; + getSectionsLists( aNamesList, aTypesList, aClosuresList ); - TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList ); - for ( int i = 0; aClosuresIter.More(); aClosuresIter.Next(), ++i ) - aClosuresList->Append( i == theISection ? theIsClosed : (bool)aClosuresIter.Value() ); + TCollection_ExtendedString aSectName( theSectName ); + if ( aSectName.Length() <= 0 ) + aSectName = getUniqueSectionName( aNamesList ); - if ( !anIsOperation ) - commitOperation(); + aNamesList->Append( aSectName ); + aTypesList->Append( theSectionType ); + aClosuresList->Append( theIsClosed ); - return true; + SetToUpdate( true ); } -std::string HYDROData_PolylineXY::getSectionName( const int theISection ) const +TCollection_AsciiString HYDROData_PolylineXY::GetSectionName( const int theSectionIndex ) const { + TCollection_AsciiString aResName; + Handle(TDataStd_ExtStringList) aNamesList; Handle(TDataStd_IntegerList) aTypesList; Handle(TDataStd_BooleanList) aClosuresList; getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); - if ( aNamesList.IsNull() || theISection >= aNamesList->Extent() ) - return ""; + if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() ) + return aResName; TDataStd_ListIteratorOfListOfExtendedString aNamesIter( aNamesList->List() ); - for ( int i = 0; aNamesIter.More() && i != theISection; aNamesIter.Next(), ++i ); + for ( int i = 0; aNamesIter.More() && i != theSectionIndex; aNamesIter.Next(), ++i ); - TCollection_AsciiString aResName; if ( aNamesIter.More() ) aResName = aNamesIter.Value(); - return aResName.ToCString(); + return aResName; } -bool HYDROData_PolylineXY::setSectionName( const int theISection, - const std::string& theName ) +void HYDROData_PolylineXY::SetSectionName( const int theSectionIndex, + const TCollection_AsciiString& theSectionName ) { Handle(TDataStd_ExtStringList) aNamesList; Handle(TDataStd_IntegerList) aTypesList; Handle(TDataStd_BooleanList) aClosuresList; getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); - if ( aNamesList.IsNull() || theISection >= aNamesList->Extent() ) - return false; - - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); + if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() ) + return; TDataStd_ListOfExtendedString anOldNamesList; anOldNamesList = aNamesList->List(); @@ -378,44 +648,39 @@ bool HYDROData_PolylineXY::setSectionName( const int theISection, // Refill the existing list aNamesList->Clear(); - TDataStd_ListIteratorOfListOfExtendedString aNamesIter( aNamesList->List() ); - for ( int i = 0; aNamesIter.More(); aNamesIter.Next(), ++i ) - aNamesList->Append( i == theISection ? theName.c_str() : aNamesIter.Value() ); + TCollection_ExtendedString aNewSectName = theSectionName; - if ( !anIsOperation ) - commitOperation(); + TDataStd_ListIteratorOfListOfExtendedString aNamesIter( anOldNamesList ); + for ( int i = 0; aNamesIter.More(); aNamesIter.Next(), ++i ) + aNamesList->Append( i == theSectionIndex ? aNewSectName : aNamesIter.Value() ); - return true; + SetToUpdate( true ); } -CurveCreator::SectionType HYDROData_PolylineXY::getSectionType( const int theISection ) const +HYDROData_PolylineXY::SectionType HYDROData_PolylineXY::GetSectionType( const int theSectionIndex ) const { Handle(TDataStd_ExtStringList) aNamesList; Handle(TDataStd_IntegerList) aTypesList; Handle(TDataStd_BooleanList) aClosuresList; getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); - if ( aNamesList.IsNull() || theISection >= aNamesList->Extent() ) - return CurveCreator::Polyline; + if ( aTypesList.IsNull() || theSectionIndex >= aTypesList->Extent() ) + return SECTION_POLYLINE; TColStd_ListIteratorOfListOfInteger aTypesIter( aTypesList->List() ); - for ( int i = 0; aTypesIter.More() && i != theISection; aTypesIter.Next(), ++i ); + for ( int i = 0; aTypesIter.More() && i != theSectionIndex; aTypesIter.Next(), ++i ); - return aTypesIter.More() ? (CurveCreator::SectionType)aTypesIter.Value() : CurveCreator::Polyline; + return aTypesIter.More() ? (SectionType)aTypesIter.Value() : SECTION_POLYLINE; } -bool HYDROData_PolylineXY::setSectionType( const int theISection, - const CurveCreator::SectionType theType ) +void HYDROData_PolylineXY::SetSectionType( const int theSectionIndex, + const SectionType theSectionType ) { Handle(TDataStd_ExtStringList) aNamesList; Handle(TDataStd_IntegerList) aTypesList; Handle(TDataStd_BooleanList) aClosuresList; getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); - if ( aNamesList.IsNull() || theISection >= aNamesList->Extent() ) - return false; - - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); + if ( aTypesList.IsNull() || theSectionIndex >= aTypesList->Extent() ) + return; TColStd_ListOfInteger anOldTypesList; anOldTypesList = aTypesList->List(); @@ -425,56 +690,149 @@ bool HYDROData_PolylineXY::setSectionType( const int theIS TColStd_ListIteratorOfListOfInteger aTypesIter( anOldTypesList ); for ( int i = 0; aTypesIter.More(); aTypesIter.Next(), ++i ) - aTypesList->Append( i == theISection ? theType : aTypesIter.Value() ); + aTypesList->Append( i == theSectionIndex ? theSectionType : aTypesIter.Value() ); - if ( !anIsOperation ) - commitOperation(); + SetToUpdate( true ); +} - return true; +bool HYDROData_PolylineXY::IsClosedSection( const int theSectionIndex ) const +{ + Handle(TDataStd_ExtStringList) aNamesList; + Handle(TDataStd_IntegerList) aTypesList; + Handle(TDataStd_BooleanList) aClosuresList; + getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); + if ( aClosuresList.IsNull() || theSectionIndex >= aClosuresList->Extent() ) + return false; + + TDataStd_ListIteratorOfListOfByte aClosuresIter( aClosuresList->List() ); + for ( int i = 0; aClosuresIter.More() && i != theSectionIndex; aClosuresIter.Next(), ++i ); + + return aClosuresIter.More() ? (bool)aClosuresIter.Value() : false; +} + +void HYDROData_PolylineXY::SetSectionClosed( const int theSectionIndex, + const bool theIsClosed ) +{ + Handle(TDataStd_ExtStringList) aNamesList; + Handle(TDataStd_IntegerList) aTypesList; + Handle(TDataStd_BooleanList) aClosuresList; + getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); + if ( aClosuresList.IsNull() || theSectionIndex >= aClosuresList->Extent() ) + return; + + TDataStd_ListOfByte anOldClosuresList; + anOldClosuresList = aClosuresList->List(); + + // Refill the existing list + aClosuresList->Clear(); + + TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList ); + for ( int i = 0; aClosuresIter.More(); aClosuresIter.Next(), ++i ) + aClosuresList->Append( i == theSectionIndex ? theIsClosed : (bool)aClosuresIter.Value() ); + + SetToUpdate( true ); } -void addPointsToLists( const CurveCreator::Coordinates& theCoords, - Handle(TDataStd_RealList)& theListX, - Handle(TDataStd_RealList)& theListY, - const bool theIsAppend ) +void HYDROData_PolylineXY::GetSections( NCollection_Sequence& theSectNames, + NCollection_Sequence& theSectTypes, + NCollection_Sequence& theSectClosures ) const { - CurveCreator::Coordinates::const_iterator aBegIter = theCoords.begin(); - CurveCreator::Coordinates::const_iterator anEndIter = theCoords.end(); - while ( aBegIter != anEndIter ) + theSectNames.Clear(); + theSectTypes.Clear(); + theSectClosures.Clear(); + + Handle(TDataStd_ExtStringList) aNamesList; + Handle(TDataStd_IntegerList) aTypesList; + Handle(TDataStd_BooleanList) aClosuresList; + getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); + if ( aNamesList.IsNull() || aTypesList.IsNull() || aClosuresList.IsNull() ) + return; + + TDataStd_ListIteratorOfListOfExtendedString aNamesIter( aNamesList->List() ); + TColStd_ListIteratorOfListOfInteger aTypesIter( aTypesList->List() ); + TDataStd_ListIteratorOfListOfByte aClosuresIter( aClosuresList->List() ); + for ( ; aNamesIter.More() && aTypesIter.More() && aClosuresIter.More(); + aNamesIter.Next(), aTypesIter.Next(), aClosuresIter.Next() ) { - const CurveCreator::TypeCoord& aCoordX = *aBegIter++; - if ( aBegIter == anEndIter ) - break; + const TCollection_ExtendedString& aSectName = aNamesIter.Value(); + SectionType aSectType = (SectionType)aTypesIter.Value(); + bool aSectClosures = aClosuresIter.Value(); - const CurveCreator::TypeCoord& aCoordY = *aBegIter++; + theSectNames.Append( aSectName ); + theSectTypes.Append( aSectType ); + theSectClosures.Append( aSectClosures ); + } +} - if ( theIsAppend ) - { - theListX->Append( aCoordX ); - theListY->Append( aCoordY ); - } - else +void HYDROData_PolylineXY::RemoveSection( const int theSectionIndex ) +{ + Handle(TDataStd_ExtStringList) aNamesList; + Handle(TDataStd_IntegerList) aTypesList; + Handle(TDataStd_BooleanList) aClosuresList; + getSectionsLists( aNamesList, aTypesList, aClosuresList, false ); + if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() ) + return; + + if ( aNamesList->Extent() == 1 ) + { + removeSectionsLists(); + removePointsLists(); + } + else + { + TDataStd_ListOfExtendedString anOldNamesList; + anOldNamesList = aNamesList->List(); + + TColStd_ListOfInteger anOldTypesList; + anOldTypesList = aTypesList->List(); + + TDataStd_ListOfByte anOldClosuresList; + anOldClosuresList = aClosuresList->List(); + + // Refill the existing lists + aNamesList->Clear(); + aTypesList->Clear(); + aClosuresList->Clear(); + + TDataStd_ListIteratorOfListOfExtendedString aNamesIter( anOldNamesList ); + TColStd_ListIteratorOfListOfInteger aTypesIter( anOldTypesList ); + TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList ); + for ( int i = 0; aNamesIter.More() && aTypesIter.More() && aClosuresIter.More(); + aNamesIter.Next(), aTypesIter.Next(), aClosuresIter.Next(), ++i ) { - theListX->Prepend( aCoordX ); - theListY->Prepend( aCoordY ); + if ( i == theSectionIndex ) + continue; // skip index to remove + + aNamesList->Append( aNamesIter.Value() ); + aTypesList->Append( aTypesIter.Value() ); + aClosuresList->Append( (bool)aClosuresIter.Value() ); } + + // Remove points that belongs to removed section + removePointsLists( theSectionIndex ); } + + SetToUpdate( true ); } -bool HYDROData_PolylineXY::addPoints( const CurveCreator::Coordinates& theCoords, - const int theISection, - const int theIPnt ) +void HYDROData_PolylineXY::RemoveSections() { - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); + removeSectionsLists(); + removePointsLists(); + SetToUpdate( true ); +} +void HYDROData_PolylineXY::AddPoint( const int theSectionIndex, + const Point& thePoint, + const int thePointIndex ) +{ Handle(TDataStd_RealList) aListX, aListY; - getPointsLists( theISection, aListX, aListY ); + getPointsLists( theSectionIndex, aListX, aListY ); - if ( theIPnt < 0 || theIPnt >= aListX->Extent() ) + if ( thePointIndex < 0 || thePointIndex >= aListX->Extent() ) { - addPointsToLists( theCoords, aListX, aListY, true ); + aListX->Append( thePoint.X() ); + aListY->Append( thePoint.Y() ); } else { @@ -495,10 +853,11 @@ bool HYDROData_PolylineXY::addPoints( const CurveCreator::Coordinates& theCoords double aCoordX = anIterX.Value(); double aCoordY = anIterY.Value(); - if ( i == theIPnt ) + if ( i == thePointIndex ) { - // Insert our new points - addPointsToLists( theCoords, aListX, aListY, true ); + // Insert our new point + aListX->Append( thePoint.X() ); + aListY->Append( thePoint.Y() ); } aListX->Append( aCoordX ); @@ -506,40 +865,28 @@ bool HYDROData_PolylineXY::addPoints( const CurveCreator::Coordinates& theCoords } } - if ( !anIsOperation ) - commitOperation(); - - return true; + SetToUpdate( true ); } -bool HYDROData_PolylineXY::setPoint( const int theISection, - const int theIPnt, - const CurveCreator::Coordinates& theCoords ) +void HYDROData_PolylineXY::SetPoint( const int theSectionIndex, + const Point& thePoint, + const int thePointIndex ) { - if ( theCoords.size() < 2 ) - return false; - - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); - Handle(TDataStd_RealList) aListX, aListY; - getPointsLists( theISection, aListX, aListY ); + getPointsLists( theSectionIndex, aListX, aListY ); - if ( theIPnt < 0 ) + if ( thePointIndex < 0 ) { - addPointsToLists( theCoords, aListX, aListY, false ); + aListX->Prepend( thePoint.X() ); + aListY->Prepend( thePoint.Y() ); } - else if ( theIPnt >= aListX->Extent() ) + else if ( thePointIndex >= aListX->Extent() ) { - addPointsToLists( theCoords, aListX, aListY, true ); + aListX->Append( thePoint.X() ); + aListY->Append( thePoint.Y() ); } else { - CurveCreator::Coordinates::const_iterator aBegIter = theCoords.begin(); - const CurveCreator::TypeCoord& aNewCoordX = *aBegIter++; - const CurveCreator::TypeCoord& aNewCoordY = *aBegIter++; - TColStd_ListOfReal anOldListX; anOldListX = aListX->List(); @@ -557,11 +904,11 @@ bool HYDROData_PolylineXY::setPoint( const int theISectio double aCoordX = anIterX.Value(); double aCoordY = anIterY.Value(); - if ( i == theIPnt ) + if ( i == thePointIndex ) { - // Insert our new points instead of old one - aCoordX = aNewCoordX; - aCoordY = aNewCoordY; + // Insert our new point instead of old one + aCoordX = thePoint.X(); + aCoordY = thePoint.Y(); } aListX->Append( aCoordX ); @@ -569,27 +916,37 @@ bool HYDROData_PolylineXY::setPoint( const int theISectio } } - if ( !anIsOperation ) - commitOperation(); + SetToUpdate( true ); +} + +void HYDROData_PolylineXY::SetPoints( const int theSectionIndex, + const PointsList& thePoints ) +{ + Handle(TDataStd_RealList) aListX, aListY; + getPointsLists( theSectionIndex, aListX, aListY ); + + aListX->Clear(); + aListY->Clear(); - return true; + for ( int i = 1, n = thePoints.Length(); i <= n; ++i ) + { + const Point& aPoint = thePoints.Value( i ); + aListX->Append( aPoint.X() ); + aListY->Append( aPoint.Y() ); + } } -bool HYDROData_PolylineXY::removePoint( const int theISection, - const int theIPnt ) +void HYDROData_PolylineXY::RemovePoint( const int theSectionIndex, + const int thePointIndex ) { Handle(TDataStd_RealList) aListX, aListY; - getPointsLists( theISection, aListX, aListY, false ); + getPointsLists( theSectionIndex, aListX, aListY, false ); if ( aListX.IsNull() || aListY.IsNull() || aListX->IsEmpty() ) - return false; - - bool anIsOperation = myIsOperation; - if ( !anIsOperation ) - startOperation(); + return; if ( aListX->Extent() == 1 ) { - removePointsLists( theISection ); + removePointsLists( theSectionIndex ); } else { @@ -607,7 +964,7 @@ bool HYDROData_PolylineXY::removePoint( const int theISection, TColStd_ListIteratorOfListOfReal anIterY( anOldListY ); for ( int i = 0; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next(), ++i ) { - if ( i == theIPnt ) + if ( i == thePointIndex ) continue; // skip index to remove aListX->Append( anIterX.Value() ); @@ -615,45 +972,61 @@ bool HYDROData_PolylineXY::removePoint( const int theISection, } } - if ( !anIsOperation ) - commitOperation(); - - return true; + SetToUpdate( true ); } -CurveCreator::Coordinates HYDROData_PolylineXY::getPoints( const int theISection ) const +HYDROData_PolylineXY::PointsList HYDROData_PolylineXY::GetPoints( const int theSectionIndex ) const { - CurveCreator::Coordinates aResList; + PointsList aResList; + + Handle(TDataStd_RealList) aListX, aListY; + getPointsLists( theSectionIndex, aListX, aListY, false ); + if ( aListX.IsNull() || aListY.IsNull() || aListX->IsEmpty() ) + return aResList; - if ( theISection < 0 ) + TColStd_ListIteratorOfListOfReal anIterX( aListX->List() ); + TColStd_ListIteratorOfListOfReal anIterY( aListY->List() ); + for ( ; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next() ) { - int aNbSections = getNbSections(); - for ( int i = 0; i < aNbSections; ++i ) - { - CurveCreator::Coordinates aSectCoords = getPoints( i ); - aResList.insert( aResList.end(), aSectCoords.begin(), aSectCoords.end()); - } + Point aPoint( anIterX.Value(), anIterY.Value() ); + aResList.Append( aPoint ); } - else + + return aResList; +} + +QPainterPath HYDROData_PolylineXY::GetPainterPath() const +{ + QPainterPath aPath; + + NCollection_Sequence aSectNames; + NCollection_Sequence aSectTypes; + NCollection_Sequence aSectClosures; + GetSections( aSectNames, aSectTypes, aSectClosures ); + + for ( int aSectionId = 1, aNbSects = aSectNames.Size(); aSectionId <= aNbSects; aSectionId++ ) { - Handle(TDataStd_RealList) aListX, aListY; - getPointsLists( theISection, aListX, aListY, false ); - if ( !aListX.IsNull() && !aListY.IsNull() ) + TCollection_AsciiString aSectName = aSectNames.Value( aSectionId ); + SectionType aSectionType = aSectTypes.Value( aSectionId ); + bool anIsSectionClosed = aSectClosures.Value( aSectionId ); + + PointsList aSectPointsList = GetPoints( aSectionId - 1 ); + if ( aSectPointsList.IsEmpty() ) + continue; + + NCollection_Sequence aPoints; + for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i ) { - TColStd_ListIteratorOfListOfReal anIterX( aListX->List() ); - TColStd_ListIteratorOfListOfReal anIterY( aListY->List() ); - for ( ; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next() ) - { - const double& aCoordX = anIterX.Value(); - const double& aCoordY = anIterY.Value(); + const Point& aSectPoint = aSectPointsList.Value( i ); - aResList.push_back( aCoordX ); - aResList.push_back( aCoordY ); - } + gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 ); + aPoints.Append( aPoint ); } + + BuildPainterPath( aPath, aSectionType, anIsSectionClosed, aPoints ); } - return aResList; + return aPath; }