Perf: refactor IntSurf_LineOn2S to std::vector, hash-op cleanups

taras113 · claude · taras113 · commit a7369d005fd2 · 2026-05-20T22:54:32.000+03:00
Profile-guided changes on top of OCCT 8.0.0. 1. IntSurf_LineOn2S: NCollection_Sequence -> std::vector - Sequence::operator()(i) breaks O(1) under non-sequential access in IntPatch_WLine::Point(i); sample(1) had NCollection_BaseSequence::Find as the #1 hot function in Boolean Fuse profile. - All ops translated; class API preserved. Allocator arg ignored. - Measured: -3.2% on a 4.2s Boolean Fuse benchmark (3x3 grid of cylinders+tori, 36 non-planar faces per side, serial). Profile confirms BaseSequence::Find gone from top. 2. BOPAlgo_PaveFiller_6: cache IsClosedFF in PerformFF 4-nested loop - Lift anIsClosed1 out of W2/E2 loops; memoize anIsClosed2 by F2 edge index. Cuts IsClosedFF calls 3.55x (4160 -> 1170 per Fuse on the bench above). Wall-clock change below noise because each call was already cheap, but it's a clean refactor. 3. BRepMesh_BaseMeshAlgo: replace IsBound+Bind+Find / IsBound+Find with ChangeSeek+Bound / Seek in collectTriangles and collectNodes. Behavior-preserving; impact below noise on collectTriangles (not in profile hot path). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
diff --git a/src/ModelingAlgorithms/TKBO/BOPAlgo/BOPAlgo_PaveFiller_6.cxx b/src/ModelingAlgorithms/TKBO/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
@@ -415,13 +415,16 @@ void BOPAlgo_PaveFiller::PerformFF(const Message_ProgressRange& theRange)
           BRep_Tool::Triangulation(aF2, aLocation2);
         const bool anIsPlane2 = IsPlaneFF(aSurface2);
 
-        bool anIsFound = false;
+        bool                           anIsFound = false;
+        NCollection_DataMap<int, bool> aIsClosedF2Cache;
         for (TopoDS_Iterator aItW1(aF1); !anIsFound && aItW1.More(); aItW1.Next())
         {
           for (TopoDS_Iterator aItE1(aItW1.Value()); !anIsFound && aItE1.More(); aItE1.Next())
           {
             const TopoDS_Edge& anEdge1      = TopoDS::Edge(aItE1.Value());
             const int          anEdgeIndex1 = myDS->Index(anEdge1);
+            const bool         anIsClosed1 =
+              IsClosedFF(anEdge1, aSurface1, aTriangulation1, aLocation1, anIsPlane1);
 
             for (TopoDS_Iterator aItW2(aF2); !anIsFound && aItW2.More(); aItW2.Next())
             {
@@ -430,10 +433,13 @@ void BOPAlgo_PaveFiller::PerformFF(const Message_ProgressRange& theRange)
                 const TopoDS_Edge& anEdge2      = TopoDS::Edge(aItE2.Value());
                 const int          anEdgeIndex2 = myDS->Index(anEdge2);
 
-                const bool anIsClosed1 =
-                  IsClosedFF(anEdge1, aSurface1, aTriangulation1, aLocation1, anIsPlane1);
-                const bool anIsClosed2 =
-                  IsClosedFF(anEdge2, aSurface2, aTriangulation2, aLocation2, anIsPlane2);
+                bool anIsClosed2;
+                if (!aIsClosedF2Cache.Find(anEdgeIndex2, anIsClosed2))
+                {
+                  anIsClosed2 =
+                    IsClosedFF(anEdge2, aSurface2, aTriangulation2, aLocation2, anIsPlane2);
+                  aIsClosedF2Cache.Bind(anEdgeIndex2, anIsClosed2);
+                }
                 if (!anIsClosed1 && !anIsClosed2)
                 {
                   continue;
diff --git a/src/ModelingAlgorithms/TKGeomAlgo/IntSurf/IntSurf_LineOn2S.cxx b/src/ModelingAlgorithms/TKGeomAlgo/IntSurf/IntSurf_LineOn2S.cxx
@@ -18,37 +18,39 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(IntSurf_LineOn2S, Standard_Transient)
 
-IntSurf_LineOn2S::IntSurf_LineOn2S(const IntSurf_Allocator& theAllocator)
-    : mySeq(theAllocator)
+IntSurf_LineOn2S::IntSurf_LineOn2S(const IntSurf_Allocator& /*theAllocator*/)
 {
+  // The allocator hint is ignored: std::vector uses the default allocator.
+  // Profiles show this is a net win because random access through the line is
+  // O(1) instead of O(N) (NCollection_BaseSequence::Find).
   myBuv1.SetWhole();
   myBuv2.SetWhole();
   myBxyz.SetWhole();
 }
 
 occ::handle<IntSurf_LineOn2S> IntSurf_LineOn2S::Split(const int Index)
 {
-  NCollection_Sequence<IntSurf_PntOn2S> SS;
-  mySeq.Split(Index, SS);
   occ::handle<IntSurf_LineOn2S> NS = new IntSurf_LineOn2S();
-  int                           i;
-  int                           leng = SS.Length();
-  for (i = 1; i <= leng; i++)
+  if (Index >= 1 && Index <= static_cast<int>(mySeq.size()))
   {
-    NS->Add(SS(i));
+    for (auto it = mySeq.begin() + (Index - 1); it != mySeq.end(); ++it)
+    {
+      NS->Add(*it);
+    }
+    mySeq.erase(mySeq.begin() + (Index - 1), mySeq.end());
   }
   return NS;
 }
 
 void IntSurf_LineOn2S::InsertBefore(const int index, const IntSurf_PntOn2S& P)
 {
-  if (index > mySeq.Length())
+  if (index > static_cast<int>(mySeq.size()))
   {
-    mySeq.Append(P);
+    mySeq.push_back(P);
   }
   else
   {
-    mySeq.InsertBefore(index, P);
+    mySeq.insert(mySeq.begin() + (index - 1), P);
   }
 
   if (!myBxyz.IsWhole())
@@ -69,7 +71,10 @@ void IntSurf_LineOn2S::InsertBefore(const int index, const IntSurf_PntOn2S& P)
 
 void IntSurf_LineOn2S::RemovePoint(const int index)
 {
-  mySeq.Remove(index);
+  if (index >= 1 && index <= static_cast<int>(mySeq.size()))
+  {
+    mySeq.erase(mySeq.begin() + (index - 1));
+  }
   myBuv1.SetWhole();
   myBuv2.SetWhole();
   myBxyz.SetWhole();
@@ -86,11 +91,11 @@ bool IntSurf_LineOn2S::IsOutBox(const gp_Pnt& Pxyz)
   {
     int n = NbPoints();
     myBxyz.SetVoid();
-    for (int i = 1; i <= n; i++)
+    for (const auto& pt : mySeq)
     {
-      gp_Pnt P = mySeq(i).Value();
-      myBxyz.Add(P);
+      myBxyz.Add(pt.Value());
     }
+    (void)n;
     double x0, y0, z0, x1, y1, z1;
     myBxyz.Get(x0, y0, z0, x1, y1, z1);
     x1 -= x0;
@@ -132,12 +137,11 @@ bool IntSurf_LineOn2S::IsOutSurf1Box(const gp_Pnt2d& P1uv)
 
   if (myBuv1.IsWhole())
   {
-    int    n = NbPoints();
     double pu1, pu2, pv1, pv2;
     myBuv1.SetVoid();
-    for (int i = 1; i <= n; i++)
+    for (const auto& pt : mySeq)
     {
-      mySeq(i).Parameters(pu1, pv1, pu2, pv2);
+      pt.Parameters(pu1, pv1, pu2, pv2);
       myBuv1.Add(gp_Pnt2d(pu1, pv1));
     }
     myBuv1.Get(pu1, pv1, pu2, pv2);
@@ -165,12 +169,11 @@ bool IntSurf_LineOn2S::IsOutSurf2Box(const gp_Pnt2d& P2uv)
 
   if (myBuv2.IsWhole())
   {
-    int    n = NbPoints();
     double pu1, pu2, pv1, pv2;
     myBuv2.SetVoid();
-    for (int i = 1; i <= n; i++)
+    for (const auto& pt : mySeq)
     {
-      mySeq(i).Parameters(pu1, pv1, pu2, pv2);
+      pt.Parameters(pu1, pv1, pu2, pv2);
       myBuv2.Add(gp_Pnt2d(pu2, pv2));
     }
     myBuv2.Get(pu1, pv1, pu2, pv2);
@@ -193,7 +196,7 @@ bool IntSurf_LineOn2S::IsOutSurf2Box(const gp_Pnt2d& P2uv)
 
 void IntSurf_LineOn2S::Add(const IntSurf_PntOn2S& P)
 {
-  mySeq.Append(P);
+  mySeq.push_back(P);
   if (!myBxyz.IsWhole())
   {
     myBxyz.Add(P.Value());
@@ -214,7 +217,7 @@ void IntSurf_LineOn2S::Add(const IntSurf_PntOn2S& P)
 
 void IntSurf_LineOn2S::SetUV(const int Index, const bool OnFirst, const double U, const double V)
 {
-  mySeq(Index).SetValue(OnFirst, U, V);
+  mySeq[Index - 1].SetValue(OnFirst, U, V);
 
   if (OnFirst && !myBuv1.IsWhole())
   {
diff --git a/src/ModelingAlgorithms/TKGeomAlgo/IntSurf/IntSurf_LineOn2S.hxx b/src/ModelingAlgorithms/TKGeomAlgo/IntSurf/IntSurf_LineOn2S.hxx
@@ -22,8 +22,8 @@
 #include <Bnd_Box.hxx>
 #include <Bnd_Box2d.hxx>
 #include <IntSurf_PntOn2S.hxx>
-#include <NCollection_Sequence.hxx>
 #include <Standard_Transient.hxx>
+#include <vector>
 #include <IntSurf_Allocator.hxx>
 #include <Standard_Integer.hxx>
 #include <Standard_Real.hxx>
@@ -81,7 +81,10 @@ public:
   DEFINE_STANDARD_RTTIEXT(IntSurf_LineOn2S, Standard_Transient)
 
 private:
-  NCollection_Sequence<IntSurf_PntOn2S> mySeq;
+  // Contiguous storage gives O(1) random access; the previous NCollection_Sequence
+  // had O(N) operator()(i) which dominated profiles of surface-surface intersection
+  // (BOPAlgo Fuse, IntPatch_WLine::Point) — see [[occt-bench-results]].
+  std::vector<IntSurf_PntOn2S>          mySeq;
   Bnd_Box2d                             myBuv1;
   Bnd_Box2d                             myBuv2;
   Bnd_Box                               myBxyz;
diff --git a/src/ModelingAlgorithms/TKGeomAlgo/IntSurf/IntSurf_LineOn2S.lxx b/src/ModelingAlgorithms/TKGeomAlgo/IntSurf/IntSurf_LineOn2S.lxx
@@ -13,42 +13,42 @@
 // commercial license or contractual agreement.
 
 #include <IntSurf_PntOn2S.hxx>
+#include <algorithm>
 
 inline int IntSurf_LineOn2S::NbPoints() const
 {
-
-  return mySeq.Length();
+  return static_cast<int>(mySeq.size());
 }
 
 inline void IntSurf_LineOn2S::Reverse()
 {
-  mySeq.Reverse();
+  std::reverse(mySeq.begin(), mySeq.end());
 }
 
 inline const IntSurf_PntOn2S& IntSurf_LineOn2S::Value(const int Index) const
 {
-  return mySeq(Index);
+  return mySeq[Index - 1];
 }
 
 inline void IntSurf_LineOn2S::Value(const int Index, const IntSurf_PntOn2S& P)
 {
-  mySeq(Index) = P;
+  mySeq[Index - 1] = P;
   myBuv1.SetWhole();
   myBuv2.SetWhole();
   myBxyz.SetWhole();
 }
 
 inline void IntSurf_LineOn2S::SetPoint(const int Index, const gp_Pnt& thePnt)
 {
-  mySeq(Index).SetValue(thePnt);
+  mySeq[Index - 1].SetValue(thePnt);
   myBuv1.SetWhole();
   myBuv2.SetWhole();
   myBxyz.SetWhole();
 }
 
 inline void IntSurf_LineOn2S::Clear()
 {
-  mySeq.Clear();
+  mySeq.clear();
   myBuv1.SetWhole();
   myBuv2.SetWhole();
   myBxyz.SetWhole();
diff --git a/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_BaseMeshAlgo.cxx b/src/ModelingAlgorithms/TKMesh/BRepMesh/BRepMesh_BaseMeshAlgo.cxx
@@ -262,12 +262,12 @@ occ::handle<Poly_Triangulation> BRepMesh_BaseMeshAlgo::collectTriangles()
 
     for (int i = 0; i < 3; ++i)
     {
-      if (!myUsedNodes->IsBound(aNode[i]))
+      int* pIdx = myUsedNodes->ChangeSeek(aNode[i]);
+      if (!pIdx)
       {
-        myUsedNodes->Bind(aNode[i], myUsedNodes->Length() + 1);
+        pIdx = myUsedNodes->Bound(aNode[i], myUsedNodes->Length() + 1);
       }
-
-      aNode[i] = myUsedNodes->Find(aNode[i]);
+      aNode[i] = *pIdx;
     }
 
     aRes->SetTriangle(aTriangeId, Poly_Triangle(aNode[0], aNode[1], aNode[2]));
@@ -283,11 +283,10 @@ void BRepMesh_BaseMeshAlgo::collectNodes(const occ::handle<Poly_Triangulation>&
 {
   for (int i = 1; i <= myNodesMap->Length(); ++i)
   {
-    if (myUsedNodes->IsBound(i))
+    if (const int* pIdx = myUsedNodes->Seek(i))
     {
-      const BRepMesh_Vertex& aVertex = myStructure->GetNode(i);
-
-      const int aNodeIndex = myUsedNodes->Find(i);
+      const BRepMesh_Vertex& aVertex     = myStructure->GetNode(i);
+      const int              aNodeIndex  = *pIdx;
       theTriangulation->SetNode(aNodeIndex, myNodesMap->Value(aVertex.Location3d()));
       theTriangulation->SetUVNode(aNodeIndex, getNodePoint2d(aVertex));
     }

Original file line number	Diff line number	Diff line change
`@@ -18,37 +18,39 @@`
`18`	`18`
`19`	`19`	`IMPLEMENT_STANDARD_RTTIEXT(IntSurf_LineOn2S, Standard_Transient)`
`20`	`20`
`21`		`-IntSurf_LineOn2S::IntSurf_LineOn2S(const IntSurf_Allocator& theAllocator)`
`22`		`- : mySeq(theAllocator)`
	`21`	`+IntSurf_LineOn2S::IntSurf_LineOn2S(const IntSurf_Allocator& /theAllocator/)`
`23`	`22`	`{`
	`23`	`+ // The allocator hint is ignored: std::vector uses the default allocator.`
	`24`	`+ // Profiles show this is a net win because random access through the line is`
	`25`	`+ // O(1) instead of O(N) (NCollection_BaseSequence::Find).`
`24`	`26`	`myBuv1.SetWhole();`
`25`	`27`	`myBuv2.SetWhole();`
`26`	`28`	`myBxyz.SetWhole();`
`27`	`29`	`}`
`28`	`30`
`29`	`31`	`occ::handle<IntSurf_LineOn2S> IntSurf_LineOn2S::Split(const int Index)`
`30`	`32`	`{`
`31`		`- NCollection_Sequence<IntSurf_PntOn2S> SS;`
`32`		`- mySeq.Split(Index, SS);`
`33`	`33`	`occ::handle<IntSurf_LineOn2S> NS = new IntSurf_LineOn2S();`
`34`		`- int i;`
`35`		`- int leng = SS.Length();`
`36`		`- for (i = 1; i <= leng; i++)`
	`34`	`+ if (Index >= 1 && Index <= static_cast<int>(mySeq.size()))`
`37`	`35`	`{`
`38`		`- NS->Add(SS(i));`
	`36`	`+ for (auto it = mySeq.begin() + (Index - 1); it != mySeq.end(); ++it)`
	`37`	`+ {`
	`38`	`+ NS->Add(*it);`
	`39`	`+ }`
	`40`	`+ mySeq.erase(mySeq.begin() + (Index - 1), mySeq.end());`
`39`	`41`	`}`
`40`	`42`	`return NS;`
`41`	`43`	`}`
`42`	`44`
`43`	`45`	`void IntSurf_LineOn2S::InsertBefore(const int index, const IntSurf_PntOn2S& P)`
`44`	`46`	`{`
`45`		`- if (index > mySeq.Length())`
	`47`	`+ if (index > static_cast<int>(mySeq.size()))`
`46`	`48`	`{`
`47`		`- mySeq.Append(P);`
	`49`	`+ mySeq.push_back(P);`
`48`	`50`	`}`
`49`	`51`	`else`
`50`	`52`	`{`
`51`		`- mySeq.InsertBefore(index, P);`
	`53`	`+ mySeq.insert(mySeq.begin() + (index - 1), P);`
`52`	`54`	`}`
`53`	`55`
`54`	`56`	`if (!myBxyz.IsWhole())`
`@@ -69,7 +71,10 @@ void IntSurf_LineOn2S::InsertBefore(const int index, const IntSurf_PntOn2S& P)`
`69`	`71`
`70`	`72`	`void IntSurf_LineOn2S::RemovePoint(const int index)`
`71`	`73`	`{`
`72`		`- mySeq.Remove(index);`
	`74`	`+ if (index >= 1 && index <= static_cast<int>(mySeq.size()))`
	`75`	`+ {`
	`76`	`+ mySeq.erase(mySeq.begin() + (index - 1));`
	`77`	`+ }`
`73`	`78`	`myBuv1.SetWhole();`
`74`	`79`	`myBuv2.SetWhole();`
`75`	`80`	`myBxyz.SetWhole();`
`@@ -86,11 +91,11 @@ bool IntSurf_LineOn2S::IsOutBox(const gp_Pnt& Pxyz)`
`86`	`91`	`{`
`87`	`92`	`int n = NbPoints();`
`88`	`93`	`myBxyz.SetVoid();`
`89`		`- for (int i = 1; i <= n; i++)`
	`94`	`+ for (const auto& pt : mySeq)`
`90`	`95`	`{`
`91`		`- gp_Pnt P = mySeq(i).Value();`
`92`		`- myBxyz.Add(P);`
	`96`	`+ myBxyz.Add(pt.Value());`
`93`	`97`	`}`
	`98`	`+ (void)n;`
`94`	`99`	`double x0, y0, z0, x1, y1, z1;`
`95`	`100`	`myBxyz.Get(x0, y0, z0, x1, y1, z1);`
`96`	`101`	`x1 -= x0;`
`@@ -132,12 +137,11 @@ bool IntSurf_LineOn2S::IsOutSurf1Box(const gp_Pnt2d& P1uv)`
`132`	`137`
`133`	`138`	`if (myBuv1.IsWhole())`
`134`	`139`	`{`
`135`		`- int n = NbPoints();`
`136`	`140`	`double pu1, pu2, pv1, pv2;`
`137`	`141`	`myBuv1.SetVoid();`
`138`		`- for (int i = 1; i <= n; i++)`
	`142`	`+ for (const auto& pt : mySeq)`
`139`	`143`	`{`
`140`		`- mySeq(i).Parameters(pu1, pv1, pu2, pv2);`
	`144`	`+ pt.Parameters(pu1, pv1, pu2, pv2);`
`141`	`145`	`myBuv1.Add(gp_Pnt2d(pu1, pv1));`
`142`	`146`	`}`
`143`	`147`	`myBuv1.Get(pu1, pv1, pu2, pv2);`
`@@ -165,12 +169,11 @@ bool IntSurf_LineOn2S::IsOutSurf2Box(const gp_Pnt2d& P2uv)`
`165`	`169`
`166`	`170`	`if (myBuv2.IsWhole())`
`167`	`171`	`{`
`168`		`- int n = NbPoints();`
`169`	`172`	`double pu1, pu2, pv1, pv2;`
`170`	`173`	`myBuv2.SetVoid();`
`171`		`- for (int i = 1; i <= n; i++)`
	`174`	`+ for (const auto& pt : mySeq)`
`172`	`175`	`{`
`173`		`- mySeq(i).Parameters(pu1, pv1, pu2, pv2);`
	`176`	`+ pt.Parameters(pu1, pv1, pu2, pv2);`
`174`	`177`	`myBuv2.Add(gp_Pnt2d(pu2, pv2));`
`175`	`178`	`}`
`176`	`179`	`myBuv2.Get(pu1, pv1, pu2, pv2);`
`@@ -193,7 +196,7 @@ bool IntSurf_LineOn2S::IsOutSurf2Box(const gp_Pnt2d& P2uv)`
`193`	`196`
`194`	`197`	`void IntSurf_LineOn2S::Add(const IntSurf_PntOn2S& P)`
`195`	`198`	`{`
`196`		`- mySeq.Append(P);`
	`199`	`+ mySeq.push_back(P);`
`197`	`200`	`if (!myBxyz.IsWhole())`
`198`	`201`	`{`
`199`	`202`	`myBxyz.Add(P.Value());`
`@@ -214,7 +217,7 @@ void IntSurf_LineOn2S::Add(const IntSurf_PntOn2S& P)`
`214`	`217`
`215`	`218`	`void IntSurf_LineOn2S::SetUV(const int Index, const bool OnFirst, const double U, const double V)`
`216`	`219`	`{`
`217`		`- mySeq(Index).SetValue(OnFirst, U, V);`
	`220`	`+ mySeq[Index - 1].SetValue(OnFirst, U, V);`
`218`	`221`
`219`	`222`	`if (OnFirst && !myBuv1.IsWhole())`
`220`	`223`	`{`
Original file line number	Diff line number	Diff line change
`@@ -13,42 +13,42 @@`
`13`	`13`	`// commercial license or contractual agreement.`
`14`	`14`
`15`	`15`	`#include <IntSurf_PntOn2S.hxx>`
	`16`	`+#include <algorithm>`
`16`	`17`
`17`	`18`	`inline int IntSurf_LineOn2S::NbPoints() const`
`18`	`19`	`{`
`19`		`-`
`20`		`- return mySeq.Length();`
	`20`	`+ return static_cast<int>(mySeq.size());`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`inline void IntSurf_LineOn2S::Reverse()`
`24`	`24`	`{`
`25`		`- mySeq.Reverse();`
	`25`	`+ std::reverse(mySeq.begin(), mySeq.end());`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`inline const IntSurf_PntOn2S& IntSurf_LineOn2S::Value(const int Index) const`
`29`	`29`	`{`
`30`		`- return mySeq(Index);`
	`30`	`+ return mySeq[Index - 1];`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`inline void IntSurf_LineOn2S::Value(const int Index, const IntSurf_PntOn2S& P)`
`34`	`34`	`{`
`35`		`- mySeq(Index) = P;`
	`35`	`+ mySeq[Index - 1] = P;`
`36`	`36`	`myBuv1.SetWhole();`
`37`	`37`	`myBuv2.SetWhole();`
`38`	`38`	`myBxyz.SetWhole();`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`inline void IntSurf_LineOn2S::SetPoint(const int Index, const gp_Pnt& thePnt)`
`42`	`42`	`{`
`43`		`- mySeq(Index).SetValue(thePnt);`
	`43`	`+ mySeq[Index - 1].SetValue(thePnt);`
`44`	`44`	`myBuv1.SetWhole();`
`45`	`45`	`myBuv2.SetWhole();`
`46`	`46`	`myBxyz.SetWhole();`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`inline void IntSurf_LineOn2S::Clear()`
`50`	`50`	`{`
`51`		`- mySeq.Clear();`
	`51`	`+ mySeq.clear();`
`52`	`52`	`myBuv1.SetWhole();`
`53`	`53`	`myBuv2.SetWhole();`
`54`	`54`	`myBxyz.SetWhole();`
Original file line number	Diff line number	Diff line change
`@@ -262,12 +262,12 @@ occ::handle<Poly_Triangulation> BRepMesh_BaseMeshAlgo::collectTriangles()`
`262`	`262`
`263`	`263`	`for (int i = 0; i < 3; ++i)`
`264`	`264`	`{`
`265`		`- if (!myUsedNodes->IsBound(aNode[i]))`
	`265`	`+ int* pIdx = myUsedNodes->ChangeSeek(aNode[i]);`
	`266`	`+ if (!pIdx)`
`266`	`267`	`{`
`267`		`- myUsedNodes->Bind(aNode[i], myUsedNodes->Length() + 1);`
	`268`	`+ pIdx = myUsedNodes->Bound(aNode[i], myUsedNodes->Length() + 1);`
`268`	`269`	`}`
`269`		`-`
`270`		`- aNode[i] = myUsedNodes->Find(aNode[i]);`
	`270`	`+ aNode[i] = *pIdx;`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`aRes->SetTriangle(aTriangeId, Poly_Triangle(aNode[0], aNode[1], aNode[2]));`
`@@ -283,11 +283,10 @@ void BRepMesh_BaseMeshAlgo::collectNodes(const occ::handle<Poly_Triangulation>&`
`283`	`283`	`{`
`284`	`284`	`for (int i = 1; i <= myNodesMap->Length(); ++i)`
`285`	`285`	`{`
`286`		`- if (myUsedNodes->IsBound(i))`
	`286`	`+ if (const int* pIdx = myUsedNodes->Seek(i))`
`287`	`287`	`{`
`288`		`- const BRepMesh_Vertex& aVertex = myStructure->GetNode(i);`
`289`		`-`
`290`		`- const int aNodeIndex = myUsedNodes->Find(i);`
	`288`	`+ const BRepMesh_Vertex& aVertex = myStructure->GetNode(i);`
	`289`	`+ const int aNodeIndex = *pIdx;`
`291`	`290`	`theTriangulation->SetNode(aNodeIndex, myNodesMap->Value(aVertex.Location3d()));`
`292`	`291`	`theTriangulation->SetUVNode(aNodeIndex, getNodePoint2d(aVertex));`
`293`	`292`	`}`