X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_PolylineXY.cxx;h=1c824402a3276a9d19d48de047d4790d619d2061;hb=18bf2fdae8933e8a31ca58f36b6dceb7a4a8cf42;hp=eaea172a650df3981ce37149b8c72b573c54743c;hpb=86bb78f9a20bd772dfa846009ce397120540caf1;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_PolylineXY.cxx b/src/HYDROData/HYDROData_PolylineXY.cxx index eaea172a..1c824402 100755 --- a/src/HYDROData/HYDROData_PolylineXY.cxx +++ b/src/HYDROData/HYDROData_PolylineXY.cxx @@ -1,16 +1,41 @@ +// Copyright (C) 2014-2015 EDF-R&D +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #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 @@ -18,6 +43,7 @@ #include #include +#include #include @@ -27,25 +53,65 @@ #include #include +#include + +#include #include #include #include #include #include +#include #include #include #include +#include #include #include + #include #include #include -#define PYTHON_POLYLINEXY_ID "KIND_POLYLINEXY" +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 ) ); + + 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) @@ -60,43 +126,71 @@ HYDROData_PolylineXY::~HYDROData_PolylineXY() QStringList HYDROData_PolylineXY::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const { - QStringList aResList; - - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); - if ( aDocument.IsNull() ) - return aResList; - - QString aDocName = aDocument->GetDocPyName(); - QString aPolylineName = GetName(); + QStringList aResList = dumpObjectCreation( theTreatedObjects ); + QString aPolylineName = GetObjPyName(); - aResList << QString( "%1 = %2.CreateObject( %3 );" ) - .arg( aPolylineName ).arg( aDocName ).arg( PYTHON_POLYLINEXY_ID ); - aResList << QString( "%1.SetName( \"%1\" );" ).arg( aPolylineName ); + // Set the wire color + QStringList aWireColorDef; - // Set polilyne data - NCollection_Sequence aSectNames; - NCollection_Sequence aSectTypes; - NCollection_Sequence aSectClosures; - GetSections( aSectNames, aSectTypes, aSectClosures ); + QColor aWireColor = GetWireColor(); + setPythonObjectColor( aWireColorDef, aWireColor, DefaultWireColor(), "SetWireColor" ); + + if ( !aWireColorDef.isEmpty() ) + { + aResList << aWireColorDef; + aResList << QString( "" ); + } - for ( int i = 1, n = aSectNames.Size(); i <= n; ++i ) + bool anIsEditable = IsEditable(); + if ( !anIsEditable ) { - const TCollection_AsciiString& aSectName = aSectNames.Value( i ); - const SectionType& aSectType = aSectTypes.Value( i ); - bool aSectClosure = aSectClosures.Value( i ); + // If polyline is not editable we try to import the shape from geom + TCollection_AsciiString aGeomObjectEntry = GetGeomObjectEntry(); + if ( !aGeomObjectEntry.IsEmpty() ) + { + QString aSalomeObjName = HYDROData_Tool::GenerateNameForPython( theTreatedObjects, "polyline_sobj" ); + aResList << QString( "%1 = salome.myStudy.FindObjectID( \"%2\" );" ) + .arg( aSalomeObjName ).arg( aGeomObjectEntry.ToCString() ); - aResList << QString( "%1.AddSection( \"%2\", %3, %4 );" ).arg( aPolylineName ) - .arg( aSectName.ToCString() ).arg( aSectType ).arg( aSectClosure ); + aResList << QString( "%1.ImportFromGeomIOR( %2.GetIOR() );" ) + .arg( aPolylineName ).arg( aSalomeObjName ); - HYDROData_PolylineXY::PointsList aSectPointsList = GetPoints( i ); - for ( int k = 1, aNbPoints = aSectPointsList.Size(); k <= aNbPoints; ++k ) + aResList << QString( "%1.SetGeomObjectEntry( \"%2\" );" ) + .arg( aPolylineName ).arg( aGeomObjectEntry.ToCString() ); + } + } + else + { + // 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 Point& aSectPoint = aSectPointsList.Value( k ); + 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 ); - aResList << QString( "%1.AddPoint( %2, QPointF( %3, %4 ) );" ).arg( aPolylineName ) - .arg( i - 1 ).arg( aSectPoint.X() ).arg( aSectPoint.Y() ); + HYDROData_IPolyline::PointsList aSectPointsList = GetPoints( i - 1 ); + for ( int k = 1, aNbPoints = aSectPointsList.Size(); k <= aNbPoints; ++k ) + { + const Point& aSectPoint = aSectPointsList.Value( k ); + + QString anXStr = QString::number( aSectPoint.X(), 'f', 2 ); + QString anYStr = QString::number( aSectPoint.Y(), 'f', 2 ); + aResList << QString( "%1.AddPoint( %2, gp_XY( %3, %4 ) );" ).arg( aPolylineName ) + .arg( i - 1 ).arg( anXStr ).arg( anYStr ); + } } } + aResList << QString( "" ); + aResList << QString( "%1.Update();" ).arg( aPolylineName ); + aResList << QString( "" ); return aResList; } @@ -116,58 +210,234 @@ QColor HYDROData_PolylineXY::DefaultWireColor() return QColor( Qt::red ); } -TopoDS_Shape HYDROData_PolylineXY::GetShape() +bool HYDROData_PolylineXY::ImportFromGeomIOR( const TCollection_AsciiString& theIOR ) +{ + if ( theIOR.IsEmpty() ) + return false; + + TopoDS_Shape aShape = GEOMBase::GetShapeFromIOR( theIOR.ToCString() ); + if ( aShape.IsNull() ) + return false; + + return ImportShape( aShape ); +} + +void HYDROData_PolylineXY::SetGeomObjectEntry( const TCollection_AsciiString& theEntry ) +{ + TDataStd_AsciiString::Set( myLab.FindChild( DataTag_GeomObjectEntry ), theEntry ); +} + +TCollection_AsciiString HYDROData_PolylineXY::GetGeomObjectEntry() const +{ + TCollection_AsciiString aRes; + + TDF_Label aLabel = myLab.FindChild( DataTag_GeomObjectEntry, false ); + if ( !aLabel.IsNull() ) + { + Handle(TDataStd_AsciiString) anAsciiStr; + if ( aLabel.FindAttribute( TDataStd_AsciiString::GetID(), anAsciiStr ) ) + aRes = anAsciiStr->Get(); + } + + return aRes; +} + +TopoDS_Shape HYDROData_PolylineXY::GetShape() const { return getPolylineShape(); } -TopoDS_Wire HYDROData_PolylineXY::BuildWire( const SectionType& theType, - const bool& theIsClosed, - const NCollection_Sequence& thePoints ) +bool convertEdgeToSection( const TopoDS_Edge& theEdge, + NCollection_Sequence& theSectNames, + NCollection_Sequence& theSectTypes, + NCollection_Sequence& theSectClosures, + NCollection_Sequence& theSectPoints, + const bool theIsCanBeClosed ) { - BRepBuilderAPI_MakeWire aMakeWire; - - if( theType == SECTION_POLYLINE ) + Standard_Real aFirst = 0.0, aLast = 0.0; + Handle(Geom_Curve) anEdgeGeomCurve = BRep_Tool::Curve( theEdge, aFirst, aLast ); + if ( anEdgeGeomCurve.IsNull() ) + return false; + + 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) ) ) { - for( int i = 1, n = thePoints.Size(); i <= n; ++i ) + Handle(Geom_Line) aGeomLine = Handle(Geom_Line)::DownCast( anEdgeGeomCurve ); + + gp_Pnt aFirstPoint, aLastPoint; + aGeomLine->D0( aFirst, aFirstPoint ); + aGeomLine->D0( aLast, aLastPoint ); + + HYDROData_PolylineXY::Point aSectFirstPoint( aFirstPoint.X(), aFirstPoint.Y() ); + aPointsList.Append( aSectFirstPoint ); + + 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 gp_XYZ& aFirstPoint = thePoints.Value( i ); + const Standard_Real& aKnot = aSplineKnots.Value( i ); - gp_XYZ aLastPoint; - if ( i == n ) - { - if( theIsClosed ) - aLastPoint = thePoints.Value( 1 ); - else - break; - } - else - { - aLastPoint = thePoints.Value( i + 1 ); - } + gp_Pnt aPoint; + aGeomSpline->D0( aKnot, aPoint ); - gp_Pnt aPnt1( aFirstPoint.X(), aFirstPoint.Y(), aFirstPoint.Z() ); - gp_Pnt aPnt2( aLastPoint.X(), aLastPoint.Y(), aLastPoint.Z() ); + HYDROData_PolylineXY::Point aSectPoint( aPoint.X(), aPoint.Y() ); + aPointsList.Append( aSectPoint ); + } + } + else + { + // Other curve types are not supported + return false; + } - if ( aPnt1.IsEqual( aPnt2, LOCAL_SELECTION_TOLERANCE ) ) - continue; + if ( aPointsList.IsEmpty() ) + return false; - TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aPnt1, aPnt2 ).Edge(); - aMakeWire.Add( anEdge ); + theSectNames.Append( aSectName ); + theSectTypes.Append( aSectionType ); + theSectClosures.Append( anIsEdgeClosed ); + theSectPoints.Append( aPointsList ); + + return true; +} + +bool HYDROData_PolylineXY::ImportShape( const TopoDS_Shape& theShape ) +{ + if ( theShape.IsNull() ) + return false; + + RemoveSections(); + + bool anIsCanBeImported = false; + + 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 ); + + anIsCanBeImported = !anEdges.IsEmpty(); + for ( int i = 1, n = anEdges.Length(); i <= n && anIsCanBeImported; ++i ) + { + TopoDS_Edge aWireEdge = TopoDS::Edge( anEdges.Value( i ) ); + anIsCanBeImported = convertEdgeToSection( aWireEdge, aSectNames, aSectTypes, aSectClosures, aSectPoints, false ); } } - else //if( theType == PolylineSection::SECTION_SPLINE ) + + if ( anIsCanBeImported ) { - HYDROData_BSplineOperation aBSpline( thePoints, theIsClosed, LOCAL_SELECTION_TOLERANCE ); + 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 ); - TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aBSpline.Curve() ).Edge(); - aMakeWire.Add( anEdge ); + 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 ); + } + + setEditable( anIsCanBeImported ); + + return true; +} + +TopoDS_Wire HYDROData_PolylineXY::BuildWire( const SectionType& theType, + const bool& theIsClosed, + const NCollection_Sequence& thePoints ) +{ TopoDS_Wire aWire; - aMakeWire.Build(); - if ( aMakeWire.IsDone() ) - aWire = aMakeWire; + if( theType == SECTION_POLYLINE ) + { + int aNbPoints = thePoints.Length(); + BRepBuilderAPI_MakePolygon aMakeWire; + for ( int i = 1, n = aNbPoints; i <= n ; ++i ) + { + gp_XYZ aPoint = thePoints.Value( i ); + gp_Pnt aPnt( aPoint.X(), aPoint.Y(), aPoint.Z() ); + aMakeWire.Add( aPnt ); + } + if( theIsClosed && ( aNbPoints > 2 ) ) + aMakeWire.Close(); + + if ( aMakeWire.IsDone() ) + aWire = aMakeWire.Wire(); + } + else //if( theType == PolylineSection::SECTION_SPLINE ) + { + BRepBuilderAPI_MakeWire aMakeWire; + + if ( thePoints.Size() > 1 ) + { + Handle(Geom_BSplineCurve) aCurve = + HYDROData_BSplineOperation::ComputeCurve( thePoints, theIsClosed, LOCAL_SELECTION_TOLERANCE ); + + TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aCurve ).Edge(); + aMakeWire.Add( anEdge ); + } + aMakeWire.Build(); + if ( aMakeWire.IsDone() ) + aWire = aMakeWire; + } return aWire; } @@ -197,13 +467,21 @@ void HYDROData_PolylineXY::BuildPainterPath( QPainterPath& } else { - HYDROData_BSplineOperation aBSpline( thePoints, theIsClosed, LOCAL_SELECTION_TOLERANCE ); - aBSpline.ComputePath( thePath ); + Handle(Geom_BSplineCurve) aCurve = + HYDROData_BSplineOperation::ComputeCurve( thePoints, theIsClosed, LOCAL_SELECTION_TOLERANCE ); + HYDROData_BSplineOperation::ComputePath( aCurve, thePath ); } } void HYDROData_PolylineXY::Update() { + if ( !IsEditable() ) + { + // If polyline is not editable we no need to update it wire + SetToUpdate( false ); + return; + } + HYDROData_IPolyline::Update(); NCollection_Sequence aSectNames; @@ -244,67 +522,89 @@ void HYDROData_PolylineXY::Update() Handle(TopTools_HSequenceOfShape) aSeqWires = new TopTools_HSequenceOfShape; Handle(TopTools_HSequenceOfShape) aSeqEdges = new TopTools_HSequenceOfShape; TopTools_ListIteratorOfListOfShape it(aSectionWiresList); - for(;it.More();it.Next()) { - TopoDS_Iterator it2(it.Value()); - for(;it2.More();it2.Next()) - aSeqEdges->Append(it2.Value()); - } - BRep_Builder aBB; - TopoDS_Compound aCmp; - aBB.MakeCompound(aCmp); - if(aSeqEdges->Length() >1) { - ShapeAnalysis_FreeBounds::ConnectEdgesToWires(aSeqEdges,Precision::Confusion(),Standard_True,aSeqWires); - for (Standard_Integer i = 1; i <= aSeqWires->Length();i++) { - const TopoDS_Shape& aS1 = aSeqWires->Value(i); - aBB.Add(aCmp, aS1); - } - } else if (aSeqEdges->Length() == 1) { - BRepBuilderAPI_MakeWire mkWire (TopoDS::Edge(aSeqEdges->Value(1))); - if (mkWire.IsDone()) - aBB.Add(aCmp, mkWire.Wire()); - } - - -/* - if ( aMakeWire.IsDone() ) + for(;it.More();it.Next()) { - aShape = aMakeWire.Shape(); + TopExp_Explorer it2(it.Value(), TopAbs_EDGE); + for(;it2.More();it2.Next()) + aSeqEdges->Append(it2.Current()); } - else if ( !aSectionWiresList.IsEmpty() ) + + BRep_Builder aBB; + TopoDS_Compound aCmp; + TopoDS_Shape aResult; + aBB.MakeCompound(aCmp); + if(aSeqEdges->Length() >1) { - // build compound - TopoDS_Compound aCompound; - - BRep_Builder aBuilder; - aBuilder.MakeCompound( aCompound ); - - TopTools_ListIteratorOfListOfShape anIter( aSectionWiresList ); - for ( ; anIter.More(); anIter.Next() ) + ShapeAnalysis_FreeBounds::ConnectEdgesToWires(aSeqEdges,1E-5,Standard_False,aSeqWires); + + if( aSeqWires->Length()==1 ) + aResult = aSeqWires->Value( 1 ); + else { - aBuilder.Add( aCompound, anIter.Value() ); + for (Standard_Integer i = 1; i <= aSeqWires->Length();i++) + { + const TopoDS_Shape& aS1 = aSeqWires->Value(i); + aBB.Add(aCmp, aS1); + } + aResult = aCmp; } - - aShape = aCompound; } -*/ - setPolylineShape( 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::IsHas2dPrs() const +{ + return true; +} + +bool HYDROData_PolylineXY::IsEditable() const +{ + 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 ); } /** * Returns true if polyline is closed */ -bool HYDROData_PolylineXY::IsClosed() const +bool HYDROData_PolylineXY::IsClosed( const bool theIsSimpleCheck ) const { - NCollection_Sequence aSectNames; - NCollection_Sequence aSectTypes; - NCollection_Sequence aSectClosures; - GetSections( aSectNames, aSectTypes, aSectClosures ); - if( aSectNames.IsEmpty() ) - return false; + bool anIsClosed = false; + + TopoDS_Shape aShape = GetShape(); + if ( aShape.IsNull() ) + return anIsClosed; - bool anIsClosed = true; - for( int i = 1, n = aSectClosures.Size(); i <= n && anIsClosed; ++i ) - anIsClosed = anIsClosed && aSectClosures.Value( i ); + TopTools_SequenceOfShape aWires; + HYDROData_ShapesTool::ExploreShapeToShapes( aShape, TopAbs_WIRE, aWires ); + + int aNbWires = aWires.Length(); + if ( theIsSimpleCheck ) + { + anIsClosed = aNbWires > 0; + for ( int i = 1; i <= aNbWires && anIsClosed; ++i ) + { + const TopoDS_Shape& aWire = aWires.Value( i ); + anIsClosed = BRep_Tool::IsClosed( aWire ); + } + } + else + { + anIsClosed = aNbWires == 1 && BRep_Tool::IsClosed( aWires.First() ); + } return anIsClosed; } @@ -357,18 +657,19 @@ double HYDROData_PolylineXY::GetDistance( const int theSectionIndex, aPointToTest = aPoint; } - HYDROData_BSplineOperation aBSpline( aPoints, anIsSectionClosed, LOCAL_SELECTION_TOLERANCE ); + Handle(Geom_BSplineCurve) aCurve = + HYDROData_BSplineOperation::ComputeCurve( aPoints, anIsSectionClosed, LOCAL_SELECTION_TOLERANCE ); - Quantity_Parameter aFirstParam = aBSpline.Curve()->FirstParameter(); - Quantity_Parameter aSecondParam = aBSpline.Curve()->LastParameter(); + Quantity_Parameter aFirstParam = aCurve->FirstParameter(); + Quantity_Parameter aSecondParam = aCurve->LastParameter(); if ( thePointIndex != aSectNbPoints - 1 ) { - GeomAPI_ProjectPointOnCurve aProject( aPointToTest, aBSpline.Curve() ); + GeomAPI_ProjectPointOnCurve aProject( aPointToTest, aCurve ); aSecondParam = aProject.LowerDistanceParameter(); } - GeomAdaptor_Curve anAdap( aBSpline.Curve() ); + GeomAdaptor_Curve anAdap( aCurve ); aResDistance = GCPnts_AbscissaPoint::Length( anAdap, aFirstParam, aSecondParam ); } @@ -386,27 +687,6 @@ int HYDROData_PolylineXY::NbSections() const return !aClosuresList.IsNull() ? aClosuresList->Extent() : 0; } -TCollection_ExtendedString getUniqueSectionName( const Handle(TDataStd_ExtStringList)& theNamesList ) -{ - NCollection_Map aNamesMap; - - TDataStd_ListIteratorOfListOfExtendedString aNamesIter( theNamesList->List() ); - for ( ; aNamesIter.More(); aNamesIter.Next() ) - aNamesMap.Add( aNamesIter.Value() ); - - TCollection_ExtendedString aResName; - - int aPrefIdx = 1; - do - { - aResName = "Section_" + aPrefIdx; - ++aPrefIdx; - } - while ( aNamesMap.Contains( aResName ) ); - - return aResName; -} - void HYDROData_PolylineXY::AddSection( const TCollection_AsciiString& theSectName, const SectionType theSectionType, const bool theIsClosed ) @@ -734,6 +1014,23 @@ void HYDROData_PolylineXY::SetPoint( const int theSectionIndex, 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(); + + for ( int i = 1, n = thePoints.Length(); i <= n; ++i ) + { + const Point& aPoint = thePoints.Value( i ); + aListX->Append( aPoint.X() ); + aListY->Append( aPoint.Y() ); + } +} + void HYDROData_PolylineXY::RemovePoint( const int theSectionIndex, const int thePointIndex ) { @@ -827,4 +1124,47 @@ QPainterPath HYDROData_PolylineXY::GetPainterPath() const return aPath; } +void HYDROData_PolylineXY::UpdateLocalCS( double theDx, double theDy ) +{ + NCollection_Sequence aSectNames; + NCollection_Sequence aSectTypes; + NCollection_Sequence aSectClosures; + GetSections( aSectNames, aSectTypes, aSectClosures ); + + gp_XY aDelta( theDx, theDy ); + for ( int i = 0, aNbSects = aSectNames.Size(); i < aNbSects; i++ ) + { + PointsList aPoints = GetPoints( i ); + for( int j = 1, n = aPoints.Size(); j <= n; ++j ) + { + Point& aPoint = aPoints.ChangeValue( j ); + aPoint += aDelta; + } + SetPoints( i, aPoints ); + } + SetToUpdate( true ); +} + +void HYDROData_PolylineXY::Transform( const QTransform& theTrsf ) +{ + NCollection_Sequence aSectNames; + NCollection_Sequence aSectTypes; + NCollection_Sequence aSectClosures; + GetSections( aSectNames, aSectTypes, aSectClosures ); + + for ( int i = 0, aNbSects = aSectNames.Size(); i < aNbSects; i++ ) { + PointsList aPoints = GetPoints( i ); + for( int j = 1, n = aPoints.Size(); j <= n; ++j ) { + Point& aPoint = aPoints.ChangeValue( j ); + + QPointF aTrsfPoint = theTrsf.map( QPointF( aPoint.X(), aPoint.Y() ) ); + + aPoint.SetX( aTrsfPoint.x() ); + aPoint.SetY( aTrsfPoint.y() ); + } + SetPoints( i, aPoints ); + } + + Update(); +}