A fix for a refs #266 - Point insertion in a polyline with type spline

[modules/hydro.git] / src / HYDROCurveCreator / CurveCreator_Utils.cxx

diff --git a/src/HYDROCurveCreator/CurveCreator_Utils.cxx b/src/HYDROCurveCreator/CurveCreator_Utils.cxx
index 1fcc4084030de42aba451f7fe357f77c117470e8..25371beb09d6e7032849828b0e4b79cfa5d1fd64 100644 (file)
--- a/src/HYDROCurveCreator/CurveCreator_Utils.cxx
+++ b/src/HYDROCurveCreator/CurveCreator_Utils.cxx
@@ -56,6 +56,8 @@
 #include <BRepBuilderAPI_MakeWire.hxx>
 
 #include <TColgp_HArray1OfPnt.hxx>
+#include <TColStd_HArray1OfBoolean.hxx>
+#include <TColgp_Array1OfVec.hxx>
 #include <GeomAPI_Interpolate.hxx>
 
 #include <ProjLib.hxx>
@@ -102,40 +104,75 @@ void CurveCreator_Utils::constructShape( const CurveCreator_ICurve* theCurve,
 
     CurveCreator::SectionType aSectType = theCurve->getSectionType( theISection );
     int aPointSize = theCurve->getNbPoints( theISection );
+    if ( aPointSize == 0 )
+      continue;
+
     bool aSectIsClosed = theCurve->isClosed( theISection );
     bool isPolyline = aSectType == CurveCreator::Polyline;
+
     int iPoint = 0;
     gp_Pnt aPrevPoint, aPoint;
-    if ( aPointSize == 1 ) {
+    // filters the curve points to skip equal points
+    std::vector<gp_Pnt> aPoints;
+    CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+    aPoints.push_back( aPoint );
+    aPrevPoint = aPoint;
+    iPoint++;
+    for( ; iPoint < aPointSize; iPoint++ ) {
       CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+      if ( !isEqualPoints( aPrevPoint, aPoint ) )
+        aPoints.push_back( aPoint );
+      aPrevPoint = aPoint;
+    }
+    int aNbPoints = aPoints.size();
+
+    if ( aNbPoints == 1 ) {
+      aPoint = aPoints.front();
       TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
       aBuilder.Add( aComp, aVertex );
     }
-    else if ( aPointSize > 1 ) {
-      Handle(TColgp_HArray1OfPnt) aHCurvePoints = new TColgp_HArray1OfPnt (1, aPointSize);
-      int aHIndex = 1;
+    else if ( aNbPoints > 1 ) {
+      Handle(TColgp_HArray1OfPnt) aHCurvePoints = new TColgp_HArray1OfPnt(1, aNbPoints);
+      TColgp_Array1OfVec aTangents(1, aNbPoints);
+      Handle(TColStd_HArray1OfBoolean) aTangentFlags = new TColStd_HArray1OfBoolean(1, aNbPoints);
+      gp_Vec aNullVec(0, 0, 0);
 
       TopoDS_Edge aPointEdge;
       TopoDS_Vertex aVertex;
-      CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+
+      std::vector<gp_Pnt>::const_iterator aPointIt = aPoints.begin(), aPointLast = aPoints.end();
+      aPoint = *aPointIt;
+
+      int aHIndex = 1;
       aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
       aBuilder.Add( aComp, aVertex );
-      aHCurvePoints->SetValue(aHIndex++, aPoint);
+      if ( !isPolyline ) {
+        aHCurvePoints->SetValue( aHIndex, aPoint );
+        aTangents.SetValue( aHIndex, aNullVec );
+        aTangentFlags->SetValue( aHIndex, Standard_False );
+        aHIndex++;
+      }
+
       aPrevPoint = aPoint;
-      iPoint++;
-      for( ; iPoint < aPointSize; iPoint++ ) {
-        CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+      aPointIt++;
+      for( ; aPointIt != aPointLast; aPointIt++ ) {
+        aPoint = *aPointIt;
         aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
         aBuilder.Add( aComp, aVertex );
-        aHCurvePoints->SetValue(aHIndex++, aPoint);
         if ( isPolyline ) {
-          aPointEdge = BRepBuilderAPI_MakeEdge( aPrevPoint, aPoint ).Edge();
+          TopoDS_Edge aPointEdge = BRepBuilderAPI_MakeEdge( aPrevPoint, aPoint ).Edge();
           aBuilder.Add( aComp, aPointEdge );
         }
+        else {
+          aHCurvePoints->SetValue( aHIndex, aPoint );
+          aTangents.SetValue( aHIndex, aNullVec );
+          aTangentFlags->SetValue( aHIndex, Standard_False );
+          aHIndex++;
+        }
         aPrevPoint = aPoint;
       }
-      if( aSectIsClosed && ( aPointSize > 2 ) ) {
-        CurveCreator_UtilsICurve::getPoint( theCurve, theISection, 0, aPoint );
+      if( aSectIsClosed && ( aNbPoints > 2 ) ) {
+        aPoint = aPoints.front();
         aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
         aBuilder.Add( aComp, aVertex );
         if ( isPolyline ) {
@@ -147,6 +184,8 @@ void CurveCreator_Utils::constructShape( const CurveCreator_ICurve* theCurve,
         // compute BSpline
         Handle(Geom_BSplineCurve) aBSplineCurve;
         GeomAPI_Interpolate aGBC(aHCurvePoints, aSectIsClosed, gp::Resolution());
+        aGBC.Load(aTangents, aTangentFlags);
+
         aGBC.Perform();
         if ( aGBC.IsDone() )
           aBSplineCurve = aGBC.Curve();
@@ -159,26 +198,27 @@ void CurveCreator_Utils::constructShape( const CurveCreator_ICurve* theCurve,
   theShape = aComp;
 }
 
-class ComparePnt
+class CompareSectionToPoint
 {
 public:
-  ComparePnt( const gp_Pnt& thePoint ) : myPoint( thePoint) {};
-  ~ComparePnt() {}
+  CompareSectionToPoint( const int theISection = -1, const int theIPoint = -1 )
+    : mySectionId( theISection ), myPointId( theIPoint ) {};
+  ~CompareSectionToPoint() {}
 
-  bool operator < ( const ComparePnt& theOtherPoint ) const
+  bool operator < ( const CompareSectionToPoint& theOther ) const
   {
-    bool isLess = myPoint.X() < theOtherPoint.myPoint.X();
-    if ( !isLess && myPoint.X() == theOtherPoint.myPoint.X() ) {
-      isLess = myPoint.Y() < theOtherPoint.myPoint.Y();
-      if ( !isLess && myPoint.Y() == theOtherPoint.myPoint.Y() )
-        isLess = myPoint.Z() < theOtherPoint.myPoint.Z();
-    }
+    bool isLess = mySectionId < theOther.mySectionId;
+    if ( !isLess && mySectionId == theOther.mySectionId )
+      isLess = myPointId < theOther.myPointId;
     return isLess;
   }
+
 private:
-  gp_Pnt myPoint;
+  int mySectionId;
+  int myPointId;
 };
 
+
 void CurveCreator_Utils::getSelectedPoints( Handle(AIS_InteractiveContext) theContext,
                                             const CurveCreator_ICurve* theCurve,
                                             CurveCreator_ICurve::SectionToPointList& thePoints )
@@ -187,7 +227,7 @@ void CurveCreator_Utils::getSelectedPoints( Handle(AIS_InteractiveContext) theCo
 
   std::list<float> aSelectedPoints;
   gp_Pnt aPnt;
-  std::map<ComparePnt, int> aPntMap;
+  std::map<CompareSectionToPoint, int> aPointsMap;
 
   CurveCreator_ICurve::SectionToPointList aPoints;
   for ( theContext->InitSelected(); theContext->MoreSelected(); theContext->NextSelected() ) {
@@ -199,15 +239,19 @@ void CurveCreator_Utils::getSelectedPoints( Handle(AIS_InteractiveContext) theCo
     if ( aVertex.IsNull() )
       continue;
     aPnt = BRep_Tool::Pnt( aVertex );
-    if ( aPntMap.find( aPnt ) != aPntMap.end() )
-      continue;
-    aPntMap[aPnt] = 0;
 
     CurveCreator_UtilsICurve::findSectionsToPoints( theCurve, aPnt.X(), aPnt.Y(), aPoints );
     CurveCreator_ICurve::SectionToPointList::const_iterator anIt = aPoints.begin(),
                                                             aLast = aPoints.end();
-    for ( ; anIt != aLast; anIt++ )
+    CompareSectionToPoint aPoint;
+    for ( ; anIt != aLast; anIt++ ) {
+      aPoint = CompareSectionToPoint( (*anIt).first, (*anIt).second );
+      if ( aPointsMap.find( aPoint ) != aPointsMap.end() )
+        continue;
+      aPointsMap[aPoint] = 0;
+
       thePoints.push_back( *anIt );
+    }
   }
 }
 
@@ -439,3 +483,8 @@ bool CurveCreator_Utils::isEqualPixels( const int theX, const int theY, const in
 
   return aXDelta < theTolerance && anYDelta < theTolerance;
 }
+
+bool CurveCreator_Utils::isEqualPoints( const gp_Pnt& thePoint, const gp_Pnt& theOtherPoint )
+{
+  return theOtherPoint.IsEqual( thePoint, LOCAL_SELECTION_TOLERANCE );
+}