0028639: Improve performance of the IntPolyh_MaillageAffinage algorithm
authoremv <emv@opencascade.com>
Fri, 7 Apr 2017 04:43:44 +0000 (07:43 +0300)
committerbugmaster <bugmaster@opencascade.com>
Fri, 28 Apr 2017 09:48:40 +0000 (12:48 +0300)
The following improvements have been made:
1. Linking edges to triangles while creating the edges.
2. Replacing the array of couples of intersecting triangles with the list to avoid unnecessary allocations of memory.
3. Using the algorithm of unbalanced binary tree when looking for pairs of interfering triangles.
4. Building bounding boxes for the triangles only once and then reusing it.
5. Making the simple methods of the IntPolyh_Point, IntPolyh_Edge, IntPolyh_Triangle, IntPolyh_Couple classes inline.
6. The following methods of the *IntPolyh_Triangle* class have been removed as unused:
  - *CheckCommonEdge*
  - *SetEdgeandOrientation*
  - *MultipleMiddleRefinement2*.
7. The method *IntPolyh_Triangle::TriangleDeflection* has been replaced with the *IntPolyh_Triangle::ComputeDeflection*.
8. The following methods of the *IntPolyh_MaillageAffinage* class have been removed as unused:
  - *LinkEdges2Triangles*;
  - *TriangleEdgeContact2*;
  - *StartingPointsResearch2*;
  - *NextStartingPointsResearch2*;
  - *TriangleComparePSP*;
  - *StartPointsCalcul*.

18 files changed:
dox/dev_guides/upgrade/upgrade.md
src/IntPolyh/FILES
src/IntPolyh/IntPolyh_ArrayOfStartPoints.hxx [deleted file]
src/IntPolyh/IntPolyh_Couple.cxx
src/IntPolyh/IntPolyh_Couple.hxx
src/IntPolyh/IntPolyh_CoupleMapHasher.hxx [new file with mode: 0644]
src/IntPolyh/IntPolyh_Edge.cxx
src/IntPolyh/IntPolyh_Edge.hxx
src/IntPolyh/IntPolyh_Intersection.cxx
src/IntPolyh/IntPolyh_Intersection.hxx
src/IntPolyh/IntPolyh_Intersection_1.cxx
src/IntPolyh/IntPolyh_ListOfCouples.hxx [moved from src/IntPolyh/IntPolyh_ArrayOfCouples.hxx with 73% similarity]
src/IntPolyh/IntPolyh_MaillageAffinage.cxx
src/IntPolyh/IntPolyh_MaillageAffinage.hxx
src/IntPolyh/IntPolyh_Point.cxx
src/IntPolyh/IntPolyh_Point.hxx
src/IntPolyh/IntPolyh_Triangle.cxx
src/IntPolyh/IntPolyh_Triangle.hxx

index 3b2aa27..cbe32b0 100644 (file)
@@ -1131,6 +1131,18 @@ The following obsolete features have been removed:
 * The package *TestTopOpeDraw* has been removed;
 * The package *TestTopOpeTools* has been removed.
 * The packages *QANewModTopOpe*, *QANewBRepNaming* and *QANewDBRepNaming* have been removed as containing obsolete features.
+* The following methods of the *IntPolyh_Triangle* class have been removed as unused:
+  - *CheckCommonEdge*
+  - *SetEdgeandOrientation*
+  - *MultipleMiddleRefinement2*.
+* The method *IntPolyh_Triangle::TriangleDeflection* has been renamed to *IntPolyh_Triangle::ComputeDeflection*.
+* The following methods of the *IntPolyh_MaillageAffinage* class have been removed as unused:
+  - *LinkEdges2Triangles*;
+  - *TriangleEdgeContact2*;
+  - *StartingPointsResearch2*;
+  - *NextStartingPointsResearch2*;
+  - *TriangleComparePSP*;
+  - *StartPointsCalcul*.
 
 @subsection upgrade_occt720_correction_of_Offset_API Corrections in BRepOffset API
 
index 0d2445e..be4aa88 100755 (executable)
@@ -1,18 +1,18 @@
 IntPolyh_Array.hxx
-IntPolyh_ArrayOfCouples.hxx
 IntPolyh_ArrayOfEdges.hxx
 IntPolyh_ArrayOfPoints.hxx
 IntPolyh_ArrayOfSectionLines.hxx
-IntPolyh_ArrayOfStartPoints.hxx
 IntPolyh_ArrayOfTangentZones.hxx
 IntPolyh_ArrayOfTriangles.hxx
 IntPolyh_Couple.cxx
 IntPolyh_Couple.hxx
+IntPolyh_CoupleMapHasher.hxx
 IntPolyh_Edge.cxx
 IntPolyh_Edge.hxx
 IntPolyh_Intersection.cxx
 IntPolyh_Intersection.hxx
 IntPolyh_Intersection_1.cxx
+IntPolyh_ListOfCouples.hxx
 IntPolyh_MaillageAffinage.cxx
 IntPolyh_MaillageAffinage.hxx
 IntPolyh_PMaillageAffinage.hxx
@@ -24,4 +24,4 @@ IntPolyh_SeqOfStartPoints.hxx
 IntPolyh_StartPoint.cxx
 IntPolyh_StartPoint.hxx
 IntPolyh_Triangle.cxx
-IntPolyh_Triangle.hxx
+IntPolyh_Triangle.hxx
\ No newline at end of file
diff --git a/src/IntPolyh/IntPolyh_ArrayOfStartPoints.hxx b/src/IntPolyh/IntPolyh_ArrayOfStartPoints.hxx
deleted file mode 100644 (file)
index 917111c..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-// Created on: 2012-11-13
-// Created by: Peter KURNEV
-// Copyright (c) 2012-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef IntPolyh_ArrayOfStartPoints_HeaderFile
-#define IntPolyh_ArrayOfStartPoints_HeaderFile
-
-#include <IntPolyh_Array.hxx>
-#include <IntPolyh_StartPoint.hxx>
-
-typedef IntPolyh_Array <IntPolyh_StartPoint> IntPolyh_ArrayOfStartPoints;
-
-#endif
index e5cefe0..cc4f65e 100644 (file)
 
 
 #include <IntPolyh_Couple.hxx>
-
 #include <stdio.h>
-IntPolyh_Couple::IntPolyh_Couple() : t1(-1),t2(-1),ia(0),angle(-2.0) {  } 
-
-IntPolyh_Couple::IntPolyh_Couple(const Standard_Integer a,const Standard_Integer b) : t1(a),t2(b),ia(0),angle(-2.0) {  }
-
-Standard_Integer IntPolyh_Couple::FirstValue()  const{ return(t1);}
-Standard_Integer IntPolyh_Couple::SecondValue() const{ return(t2);}
-Standard_Integer IntPolyh_Couple::AnalyseFlagValue() const{ return(ia);}
-Standard_Real IntPolyh_Couple::AngleValue() const{ return(angle);}
-
-void IntPolyh_Couple::SetCoupleValue(const Standard_Integer a,const Standard_Integer b) 
-{ t1=a; t2=b; } 
-void IntPolyh_Couple::SetAnalyseFlag(const Standard_Integer iiaa) { ia=iiaa; }    
-void IntPolyh_Couple::SetAngleValue(const Standard_Real ang) { angle=ang; }    
 
-void IntPolyh_Couple::Dump(const Standard_Integer i) const{ 
-  printf("\nCouple(%3d) : %5d %5d %3d %5f\n",i,t1,t2,ia,angle);
+//=======================================================================
+//function : Dump
+//purpose  : 
+//=======================================================================
+void IntPolyh_Couple::Dump(const Standard_Integer i) const{
+  printf("\nCouple(%3d) : %5d %5d %3d %5f\n", i, myIndex1, myIndex2, myAnalyzed, myAngle);
 }
-
-
-
-
index d214c33..3c49c2c 100644 (file)
 #include <Standard_Integer.hxx>
 #include <Standard_Real.hxx>
 
-
-//! couple of triangles
-class IntPolyh_Couple 
+//! The class represents the couple of indices with additional
+//! characteristics such as analyzed flag and an angle.<br>
+//! In IntPolyh_MaillageAffinage algorithm the class is used as a
+//! couple of interfering triangles with the intersection angle.
+class IntPolyh_Couple
 {
 public:
 
   DEFINE_STANDARD_ALLOC
 
-  
-  Standard_EXPORT IntPolyh_Couple();
-  
-  Standard_EXPORT IntPolyh_Couple(const Standard_Integer i1, const Standard_Integer i2);
-  
-  Standard_EXPORT Standard_Integer FirstValue() const;
-  
-  Standard_EXPORT Standard_Integer SecondValue() const;
-  
-  Standard_EXPORT Standard_Integer AnalyseFlagValue() const;
-  
-  Standard_EXPORT Standard_Real AngleValue() const;
-  
-  Standard_EXPORT void SetCoupleValue (const Standard_Integer v, const Standard_Integer w);
-  
-  Standard_EXPORT void SetAnalyseFlag (const Standard_Integer v);
-  
-  Standard_EXPORT void SetAngleValue (const Standard_Real ang);
-  
+  //! Constructor
+  IntPolyh_Couple() :
+    myIndex1(-1),myIndex2(-1),myAnalyzed(0),myAngle(-2.0)
+  {}
+  //! Constructor
+  IntPolyh_Couple(const Standard_Integer theTriangle1,
+                  const Standard_Integer theTriangle2,
+                  const Standard_Real theAngle = -2.0)
+  :
+    myIndex1(theTriangle1),
+    myIndex2(theTriangle2),
+    myAnalyzed(Standard_False),
+    myAngle(theAngle)
+  {}
+
+  //! Returns the first index
+  Standard_Integer FirstValue() const
+  {
+    return myIndex1;
+  }
+  //! Returns the second index
+  Standard_Integer SecondValue() const
+  {
+    return myIndex2;
+  }
+  //! Returns TRUE if the couple has been analyzed
+  Standard_Boolean IsAnalyzed() const
+  {
+    return myAnalyzed;
+  }
+  //! Returns the angle
+  Standard_Real Angle() const
+  {
+    return myAngle;
+  }
+  //! Sets the triangles
+  void SetCoupleValue(const Standard_Integer theInd1,
+                      const Standard_Integer theInd2)
+  {
+    myIndex1 = theInd1;
+    myIndex2 = theInd2;
+  }
+  //! Sets the analyzed flag
+  void SetAnalyzed(const Standard_Boolean theAnalyzed)
+  {
+    myAnalyzed = theAnalyzed;
+  }
+  //! Sets the angle
+  void SetAngle(const Standard_Real theAngle)
+  {
+    myAngle = theAngle;
+  }
+  //! Returns true if the Couple is equal to <theOther>
+  Standard_Boolean IsEqual (const IntPolyh_Couple& theOther) const
+  {
+    return (myIndex1 == theOther.myIndex1 && myIndex2 == theOther.myIndex2) ||
+           (myIndex1 == theOther.myIndex2 && myIndex2 == theOther.myIndex1);
+  }
+  //
+  //! Returns hash code
+  Standard_Integer HashCode (const Standard_Integer theUpper) const
+  {
+    return ::HashCode(myIndex1 + myIndex2, theUpper);
+  }
+  // Dump
   Standard_EXPORT void Dump (const Standard_Integer v) const;
 
-
-
-
 protected:
 
-
-
-
-
 private:
 
-
-
-  Standard_Integer t1;
-  Standard_Integer t2;
-  Standard_Integer ia;
-  Standard_Real angle;
-
+  Standard_Integer myIndex1;
+  Standard_Integer myIndex2;
+  Standard_Boolean myAnalyzed;
+  Standard_Real myAngle;
 
 };
 
-
-
-
-
-
-
 #endif // _IntPolyh_Couple_HeaderFile
diff --git a/src/IntPolyh/IntPolyh_CoupleMapHasher.hxx b/src/IntPolyh/IntPolyh_CoupleMapHasher.hxx
new file mode 100644 (file)
index 0000000..5086d77
--- /dev/null
@@ -0,0 +1,46 @@
+// Created by: Eugeny MALTCHIKOV
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _IntPolyh_CoupleMapHasher_HeaderFile
+#define _IntPolyh_CoupleMapHasher_HeaderFile
+
+#include <Standard_Integer.hxx>
+#include <Standard_Boolean.hxx>
+#include <IntPolyh_Couple.hxx>
+
+class IntPolyh_Couple;
+
+class IntPolyh_CoupleMapHasher 
+{
+public:
+
+  static Standard_Integer HashCode(const IntPolyh_Couple& theCouple,
+                                   const Standard_Integer Upper)
+  {
+    return theCouple.HashCode(Upper);
+  }
+  static Standard_Boolean IsEqual(const IntPolyh_Couple& theCouple1,
+                                  const IntPolyh_Couple& theCouple2)
+  {
+    return theCouple1.IsEqual(theCouple2);
+  }
+
+protected:
+
+private:
+
+};
+
+#endif // _IntPolyh_CoupleMapHasher_HeaderFile
index 7fba60f..0122125 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-
 #include <IntPolyh_Edge.hxx>
-
 #include <stdio.h>
-IntPolyh_Edge::IntPolyh_Edge() : p1(-1),p2(-1),t1(-1),t2(-1),ia(-1) { } 
-
-IntPolyh_Edge::IntPolyh_Edge(const Standard_Integer a, const Standard_Integer b, 
-                            const Standard_Integer c, const Standard_Integer d) : p1(a),p2(b),t1(c),t2(d),ia(-1) { 
-}
-
-Standard_Integer IntPolyh_Edge::FirstPoint()  const{ return(p1);} 
-Standard_Integer IntPolyh_Edge::SecondPoint() const{ return(p2);}
-Standard_Integer IntPolyh_Edge::FirstTriangle()  const{ return(t1);} 
-Standard_Integer IntPolyh_Edge::SecondTriangle() const{ return(t2);}
-Standard_Integer IntPolyh_Edge::AnalysisFlag() const{ return(ia);}
-
-void IntPolyh_Edge::SetFirstPoint(const Standard_Integer a) { p1=a; } 
-void IntPolyh_Edge::SetSecondPoint(const Standard_Integer b) { p2=b; }    
-void IntPolyh_Edge::SetFirstTriangle(const Standard_Integer c) { t1=c; } 
-void IntPolyh_Edge::SetSecondTriangle(const Standard_Integer d) { t2=d; }    
-void IntPolyh_Edge::SetAnalysisFlag(const Standard_Integer e) { ia=e; }    
 
+//=======================================================================
+//function : Dump
+//purpose  : 
+//=======================================================================
 void IntPolyh_Edge::Dump(const Standard_Integer i) const{ 
-  printf("\nEdge(%3d) : P1:%5d   P2:%5d   T1:%5d   T2:%5d    AnalysisFlag:%5d\n",i,p1,p2,t1,t2,ia);
+  printf("\nEdge(%3d) : P1:%5d   P2:%5d   T1:%5d   T2:%5d\n",
+         i, myPoint1, myPoint2, myTriangle1, myTriangle2);
 }
-
-
-
index fffed69..72e5173 100644 (file)
 
 #include <Standard_Integer.hxx>
 
-
-
-class IntPolyh_Edge 
+//! The class represents the edge built between the two IntPolyh points.<br>
+//! It is linked to two IntPolyh triangles.
+class IntPolyh_Edge
 {
 public:
 
   DEFINE_STANDARD_ALLOC
 
-  
-  Standard_EXPORT IntPolyh_Edge();
-  
-  Standard_EXPORT IntPolyh_Edge(const Standard_Integer i1, const Standard_Integer i2, const Standard_Integer i3, const Standard_Integer i4);
-  
-  Standard_EXPORT Standard_Integer FirstPoint() const;
-  
-  Standard_EXPORT Standard_Integer SecondPoint() const;
-  
-  Standard_EXPORT Standard_Integer FirstTriangle() const;
-  
-  Standard_EXPORT Standard_Integer SecondTriangle() const;
-  
-  Standard_EXPORT Standard_Integer AnalysisFlag() const;
-  
-  Standard_EXPORT void SetFirstPoint (const Standard_Integer v);
-  
-  Standard_EXPORT void SetSecondPoint (const Standard_Integer v);
-  
-  Standard_EXPORT void SetFirstTriangle (const Standard_Integer v);
-  
-  Standard_EXPORT void SetSecondTriangle (const Standard_Integer v);
-  
-  Standard_EXPORT void SetAnalysisFlag (const Standard_Integer v);
+  //! Constructor
+  IntPolyh_Edge() :
+    myPoint1(-1), myPoint2(-1), myTriangle1(-1), myTriangle2(-1)
+  {}
+  //! Constructor
+  IntPolyh_Edge(const Standard_Integer thePoint1,
+                const Standard_Integer thePoint2,
+                const Standard_Integer theTriangle1,
+                const Standard_Integer theTriangle2)
+  :
+    myPoint1(thePoint1),
+    myPoint2(thePoint2),
+    myTriangle1(theTriangle1),
+    myTriangle2(theTriangle2)
+  {}
+
+  //! Returns the first point
+  Standard_Integer FirstPoint() const
+  {
+    return myPoint1;
+  }
+  //! Returns the second point
+  Standard_Integer SecondPoint() const
+  {
+    return myPoint2;
+  }
+  //! Returns the first triangle
+  Standard_Integer FirstTriangle() const
+  {
+    return myTriangle1;
+  }
+  //! Returns the second triangle
+  Standard_Integer SecondTriangle() const
+  {
+    return myTriangle2;
+  }
+  //! Sets the first point
+  void SetFirstPoint (const Standard_Integer thePoint)
+  {
+    myPoint1 = thePoint;
+  }
+  //! Sets the second point
+  void SetSecondPoint (const Standard_Integer thePoint)
+  {
+    myPoint2 = thePoint;
+  }
+  //! Sets the first triangle
+  void SetFirstTriangle (const Standard_Integer theTriangle)
+  {
+    myTriangle1 = theTriangle;
+  }
+  //! Sets the second triangle
+  void SetSecondTriangle (const Standard_Integer theTriangle)
+  {
+    myTriangle2 = theTriangle;
+  }
   
   Standard_EXPORT void Dump (const Standard_Integer v) const;
 
-
-
-
 protected:
 
-
-
-
-
 private:
 
-
-
-  Standard_Integer p1;
-  Standard_Integer p2;
-  Standard_Integer t1;
-  Standard_Integer t2;
-  Standard_Integer ia;
-
-
+  Standard_Integer myPoint1;
+  Standard_Integer myPoint2;
+  Standard_Integer myTriangle1;
+  Standard_Integer myTriangle2;
 };
 
-
-
-
-
-
-
 #endif // _IntPolyh_Edge_HeaderFile
index 4ebcea8..0d88026 100644 (file)
@@ -24,6 +24,8 @@
 #include <IntPolyh_SectionLine.hxx>
 #include <IntPolyh_StartPoint.hxx>
 #include <IntPolyh_Triangle.hxx>
+#include <NCollection_Map.hxx>
+#include <IntPolyh_CoupleMapHasher.hxx>
 
 Standard_Integer MYDISPLAY = 0;
 Standard_Integer MYPRINT   = 0;
@@ -229,14 +231,12 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage
   theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
                          xx0, yy0, zz0, xx1, yy1, zz1);
   
-  theMaillageS->FillArrayOfEdges(1);
-  theMaillageS->FillArrayOfEdges(2);
-
   theMaillageS->FillArrayOfTriangles(1);
   theMaillageS->FillArrayOfTriangles(2);
   
-  theMaillageS->LinkEdges2Triangles();
-  
+  theMaillageS->FillArrayOfEdges(1);
+  theMaillageS->FillArrayOfEdges(2);
+
   theMaillageS->TrianglesDeflectionsRefinementBSB();
 
   Standard_Integer FinTTC = theMaillageS->TriangleCompare();
@@ -272,14 +272,12 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(IntPolyh_PMaillageAffina
   theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
                          xx0, yy0, zz0, xx1, yy1, zz1);
   
-  theMaillageS->FillArrayOfEdges(1);
-  theMaillageS->FillArrayOfEdges(2);
-
   theMaillageS->FillArrayOfTriangles(1);
   theMaillageS->FillArrayOfTriangles(2);
   
-  theMaillageS->LinkEdges2Triangles();
-  
+  theMaillageS->FillArrayOfEdges(1);
+  theMaillageS->FillArrayOfEdges(2);
+
   theMaillageS->TrianglesDeflectionsRefinementBSB();
 
   Standard_Integer FinTTC = theMaillageS->TriangleCompare();
@@ -291,113 +289,63 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(IntPolyh_PMaillageAffina
     theMaillageS->FillArrayOfPnt(2);
     theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
                            xx0, yy0, zz0, xx1, yy1, zz1);
-    theMaillageS->FillArrayOfEdges(1);
-    theMaillageS->FillArrayOfEdges(2);
     theMaillageS->FillArrayOfTriangles(1);
     theMaillageS->FillArrayOfTriangles(2);
-    theMaillageS->LinkEdges2Triangles();
+    theMaillageS->FillArrayOfEdges(1);
+    theMaillageS->FillArrayOfEdges(2);
     theMaillageS->TrianglesDeflectionsRefinementBSB();
     FinTTC = theMaillageS->TriangleCompare();
     myZone = Standard_False;
     theMaillageS->SetEnlargeZone( myZone );
   }
 
-  /*
-  // if too many intersections, consider surfaces parallel (eap)
-  if(FinTTC > 200 &&
-     (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() ||
-      FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) {
-    return Standard_False;
-  }
-  */
-  
   return Standard_True;
 }
 
 //=======================================================================
 //function : MergeCouples
-//purpose  : This method analyzes arrays to find same couples. If some 
-//           are detected it leaves the couple in only one array 
+//purpose  : This method analyzes the lists to find same couples.
+//           If some are detected it leaves the couple in only one list
 //           deleting from others.
 //=======================================================================
 
-void IntPolyh_Intersection::MergeCouples
-                            (IntPolyh_ArrayOfCouples &anArrayFF,
-                            IntPolyh_ArrayOfCouples &anArrayFR,
-                            IntPolyh_ArrayOfCouples &anArrayRF,
-                            IntPolyh_ArrayOfCouples &anArrayRR) const
+void IntPolyh_Intersection::MergeCouples(IntPolyh_ListOfCouples &anArrayFF,
+                                         IntPolyh_ListOfCouples &anArrayFR,
+                                         IntPolyh_ListOfCouples &anArrayRF,
+                                         IntPolyh_ListOfCouples &anArrayRR) const
 {
-  // Step 1: Sorting arrays.
-  IntPolyh_ArrayOfCouples *anArrays[4];
-  Standard_Integer         aNbCouples[4];
-  Standard_Integer         i;
-  IntPolyh_ArrayOfCouples *aTmpPtr;
-  Standard_Integer         aTmpNbr;
-
-  anArrays[0] = &anArrayFF;
-  anArrays[1] = &anArrayFR;
-  anArrays[2] = &anArrayRF;
-  anArrays[3] = &anArrayRR;
-
-  for (i = 0; i < 4; i++)
-    aNbCouples[i] = anArrays[i]->NbItems();
-
-  Standard_Boolean isChanged = Standard_True;
-
-  while (isChanged) {
-    isChanged = Standard_False;
-
-    for (i = 0; i < 3; i++) {
-      if (aNbCouples[i] < aNbCouples[i + 1]) {
-       aTmpPtr           = anArrays[i];
-       anArrays[i]       = anArrays[i + 1];
-       anArrays[i + 1]   = aTmpPtr;
-       aTmpNbr           = aNbCouples[i];
-       aNbCouples[i]     = aNbCouples[i + 1];
-       aNbCouples[i + 1] = aTmpNbr;
-       isChanged         = Standard_True;
-      }
-    }
-  }
-
-  // Step 2: Searching for same couples.
-  Standard_Integer j;
-  Standard_Integer indC1;
-  Standard_Integer indC2;
-
-  for (i = 0; i < 3; i++) {
-    for (j = i + 1; j < 4; j++) {
-      for (indC1 = 1; indC1 <= aNbCouples[i]; indC1++) {
-       IntPolyh_Couple &aCouple1 = anArrays[i]->ChangeValue(indC1);
-
-       if (aCouple1.AnalyseFlagValue() == 1)
-         continue;
-
-       for (indC2 = 1; indC2 <= aNbCouples[j]; indC2++) {
-         IntPolyh_Couple &aCouple2 = anArrays[j]->ChangeValue(indC2);
-
-         if (aCouple2.AnalyseFlagValue() == 1)
-           continue;
-
-         if (aCouple1.FirstValue()  == aCouple2.FirstValue() &&
-             aCouple1.SecondValue() == aCouple2.SecondValue()) {
-           aCouple2.SetAnalyseFlag(1);
-         }
-       }
+  // Fence map to remove from the lists the duplicating elements.
+  NCollection_Map<IntPolyh_Couple, IntPolyh_CoupleMapHasher> aFenceMap;
+  //
+  IntPolyh_ListOfCouples* pLists[4] = {&anArrayFF, &anArrayFR, &anArrayRF, &anArrayRR};
+  for (Standard_Integer i = 0; i < 4; ++i) {
+    IntPolyh_ListIteratorOfListOfCouples aIt(*pLists[i]);
+    for (; aIt.More();) {
+      if (!aFenceMap.Add(aIt.Value())) {
+        pLists[i]->Remove(aIt);
+        continue;
       }
+      aIt.Next();
     }
   }
 }
-//  Modified by skv - Thu Sep 25 18:07:42 2003 OCC567 End
 
+//=======================================================================
+//function : PerformStd
+//purpose  : 
+//=======================================================================
 Standard_Boolean IntPolyh_Intersection::PerformStd(IntPolyh_PMaillageAffinage& MaillageS,
                                                   Standard_Integer&           NbCouples)
 {
   Standard_Boolean isdone = PerformMaillage(MaillageS);
-  NbCouples = (isdone) ? (MaillageS->GetArrayOfCouples().NbItems()) : 0;
+  NbCouples = (isdone) ? (MaillageS->GetCouples().Extent()) : 0;
   return isdone;
 }
 
+//=======================================================================
+//function : PerformAdv
+//purpose  : 
+//=======================================================================
 Standard_Boolean IntPolyh_Intersection::PerformAdv(IntPolyh_PMaillageAffinage& MaillageFF,
                                                   IntPolyh_PMaillageAffinage& MaillageFR,
                                                   IntPolyh_PMaillageAffinage& MaillageRF,
@@ -414,14 +362,14 @@ Standard_Boolean IntPolyh_Intersection::PerformAdv(IntPolyh_PMaillageAffinage& M
     isdone = Standard_False; 
 
   if(isdone) {
-    NbCouples = MaillageFF->GetArrayOfCouples().NbItems() +
-      MaillageFR->GetArrayOfCouples().NbItems() +
-       MaillageRF->GetArrayOfCouples().NbItems() +
-         MaillageRR->GetArrayOfCouples().NbItems();
+    NbCouples = MaillageFF->GetCouples().Extent() +
+      MaillageFR->GetCouples().Extent() +
+       MaillageRF->GetCouples().Extent() +
+         MaillageRR->GetCouples().Extent();
 
     if(NbCouples > 0)
-      MergeCouples(MaillageFF->GetArrayOfCouples(),MaillageFR->GetArrayOfCouples(),
-                  MaillageRF->GetArrayOfCouples(),MaillageRR->GetArrayOfCouples());
+      MergeCouples(MaillageFF->GetCouples(),MaillageFR->GetCouples(),
+                  MaillageRF->GetCouples(),MaillageRR->GetCouples());
   }
   return isdone;
 }
index 4ec0e6b..5103fb1 100644 (file)
@@ -28,7 +28,7 @@
 #include <TColStd_Array1OfReal.hxx>
 #include <Standard_Real.hxx>
 #include <IntPolyh_PMaillageAffinage.hxx>
-#include <IntPolyh_ArrayOfCouples.hxx>
+#include <IntPolyh_ListOfCouples.hxx>
 class Adaptor3d_HSurface;
 
 
@@ -109,7 +109,7 @@ private:
   //! This method analyzes arrays to find same couples. If some
   //! are detected it leaves the couple in only one array
   //! deleting from others.
-  Standard_EXPORT void MergeCouples (IntPolyh_ArrayOfCouples& anArrayFF, IntPolyh_ArrayOfCouples& anArrayFR, IntPolyh_ArrayOfCouples& anArrayRF, IntPolyh_ArrayOfCouples& anArrayRR) const;
+  Standard_EXPORT void MergeCouples (IntPolyh_ListOfCouples& anArrayFF, IntPolyh_ListOfCouples& anArrayFR, IntPolyh_ListOfCouples& anArrayRF, IntPolyh_ListOfCouples& anArrayRR) const;
   
   //! Process default interference
   Standard_EXPORT Standard_Boolean PerformStd (IntPolyh_PMaillageAffinage& MaillageS, Standard_Integer& NbCouples);
index 639ae60..512754a 100644 (file)
@@ -15,7 +15,7 @@
 
 
 #include <Adaptor3d_HSurface.hxx>
-#include <IntPolyh_ArrayOfCouples.hxx>
+#include <IntPolyh_ListOfCouples.hxx>
 #include <IntPolyh_Couple.hxx>
 #include <IntPolyh_Intersection.hxx>
 #include <IntPolyh_MaillageAffinage.hxx>
@@ -153,34 +153,26 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const Standard_Boolean i
   theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
                          xx0, yy0, zz0, xx1, yy1, zz1);
   
+  theMaillageS->FillArrayOfTriangles(1);
+  theMaillageS->FillArrayOfTriangles(2);
+
   theMaillageS->FillArrayOfEdges(1);
   theMaillageS->FillArrayOfEdges(2);
 
-  theMaillageS->FillArrayOfTriangles(1);
-  theMaillageS->FillArrayOfTriangles(2);
-  
-  theMaillageS->LinkEdges2Triangles();
-  
   theMaillageS->TrianglesDeflectionsRefinementBSB();
 
   Standard_Integer FinTTC = theMaillageS->TriangleCompare();
 
   // if too many intersections, consider surfaces parallel (eap)
-/*
-  if(FinTTC > 200 &&
-     (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() ||
-      FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) {
-    return Standard_False;
-  }
-*/
-//IFV test for parallel surf
+  // test for parallel surf
   if(FinTTC > 200) {
     const Standard_Real eps = .996; //~ cos of 5deg.
-    IntPolyh_ArrayOfCouples& Couples = theMaillageS->GetArrayOfCouples();
+    IntPolyh_ListOfCouples& Couples = theMaillageS->GetCouples();
 
-    Standard_Integer i, npara = 0;
-    for(i = 0; i < FinTTC; ++i) {
-      Standard_Real cosa = Abs(Couples[i].AngleValue());
+    Standard_Integer npara = 0;
+    IntPolyh_ListIteratorOfListOfCouples aIt(Couples);
+    for(; aIt.More(); aIt.Next()) {
+      Standard_Real cosa = Abs(aIt.Value().Angle());
       if(cosa > eps) ++npara;
     }
     if(npara >= theMaillageS->GetArrayOfTriangles(1).NbItems() ||
@@ -214,14 +206,13 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const TColStd_Array1OfRe
   Standard_Real xx0,yy0,zz0,xx1,yy1,zz1;
   theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
                          xx0, yy0, zz0, xx1, yy1, zz1);
-  theMaillageS->FillArrayOfEdges(1);
-  theMaillageS->FillArrayOfEdges(2);
 
   theMaillageS->FillArrayOfTriangles(1);
   theMaillageS->FillArrayOfTriangles(2);
-  
-  theMaillageS->LinkEdges2Triangles();
-  
+
+  theMaillageS->FillArrayOfEdges(1);
+  theMaillageS->FillArrayOfEdges(2);
+
   theMaillageS->TrianglesDeflectionsRefinementBSB();
 
   Standard_Integer FinTTC = theMaillageS->TriangleCompare();
@@ -233,11 +224,10 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const TColStd_Array1OfRe
     theMaillageS->FillArrayOfPnt(2);
     theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
                            xx0, yy0, zz0, xx1, yy1, zz1);
-    theMaillageS->FillArrayOfEdges(1);
-    theMaillageS->FillArrayOfEdges(2);
     theMaillageS->FillArrayOfTriangles(1);
     theMaillageS->FillArrayOfTriangles(2);
-    theMaillageS->LinkEdges2Triangles();
+    theMaillageS->FillArrayOfEdges(1);
+    theMaillageS->FillArrayOfEdges(2);
     theMaillageS->TrianglesDeflectionsRefinementBSB();
     FinTTC = theMaillageS->TriangleCompare();
     myZone = Standard_False;
@@ -245,21 +235,15 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const TColStd_Array1OfRe
   }
 
   // if too many intersections, consider surfaces parallel (eap)
-/*
-  if(FinTTC > 200 &&
-     (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() ||
-      FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) {
-    return Standard_False;
-  }
-*/
 //IFV test for parallel surf
   if(FinTTC > 200) {
     const Standard_Real eps = .996; //~ cos of 5deg.
-    IntPolyh_ArrayOfCouples& Couples = theMaillageS->GetArrayOfCouples();
+    IntPolyh_ListOfCouples& Couples = theMaillageS->GetCouples();
 
-    Standard_Integer i, npara = 0;
-    for(i = 0; i < FinTTC; ++i) {
-      Standard_Real cosa = Abs(Couples[i].AngleValue());
+    Standard_Integer npara = 0;
+    IntPolyh_ListIteratorOfListOfCouples aIt(Couples);
+    for(; aIt.More(); aIt.Next()) {
+      Standard_Real cosa = Abs(aIt.Value().Angle());
       if(cosa > eps) ++npara;
     }
     if(npara >= theMaillageS->GetArrayOfTriangles(1).NbItems() ||
@@ -303,14 +287,14 @@ Standard_Boolean IntPolyh_Intersection::PerformAdv(const TColStd_Array1OfReal& U
     isdone = Standard_False; 
 
   if(isdone) {
-    NbCouples = MaillageFF->GetArrayOfCouples().NbItems() +
-      MaillageFR->GetArrayOfCouples().NbItems() +
-       MaillageRF->GetArrayOfCouples().NbItems() +
-         MaillageRR->GetArrayOfCouples().NbItems();
+    NbCouples = MaillageFF->GetCouples().Extent() +
+      MaillageFR->GetCouples().Extent() +
+       MaillageRF->GetCouples().Extent() +
+         MaillageRR->GetCouples().Extent();
 
     if(NbCouples > 0)
-      MergeCouples(MaillageFF->GetArrayOfCouples(),MaillageFR->GetArrayOfCouples(),
-                  MaillageRF->GetArrayOfCouples(),MaillageRR->GetArrayOfCouples());
+      MergeCouples(MaillageFF->GetCouples(),MaillageFR->GetCouples(),
+                  MaillageRF->GetCouples(),MaillageRR->GetCouples());
   }
   return isdone;
 }
@@ -328,6 +312,6 @@ Standard_Boolean IntPolyh_Intersection::PerformStd(const TColStd_Array1OfReal& U
 {
   Standard_Boolean isdone = PerformMaillage(Upars1, Vpars1, Upars2, Vpars2, 
                                            MaillageS);
-  NbCouples = (isdone) ? (MaillageS->GetArrayOfCouples().NbItems()) : 0;
+  NbCouples = (isdone) ? (MaillageS->GetCouples().Extent()) : 0;
   return isdone;
 }
similarity index 73%
rename from src/IntPolyh/IntPolyh_ArrayOfCouples.hxx
rename to src/IntPolyh/IntPolyh_ListOfCouples.hxx
index 8373cbc..0eee2a6 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifndef IntPolyh_ArrayOfCouples_HeaderFile
-#define IntPolyh_ArrayOfCouples_HeaderFile
+#ifndef IntPolyh_ListOfCouples_HeaderFile
+#define IntPolyh_ListOfCouples_HeaderFile
 
-#include <IntPolyh_Array.hxx>
+#include <NCollection_List.hxx>
 #include <IntPolyh_Couple.hxx>
 
-typedef IntPolyh_Array <IntPolyh_Couple> IntPolyh_ArrayOfCouples;
+typedef NCollection_List <IntPolyh_Couple> IntPolyh_ListOfCouples;
+typedef IntPolyh_ListOfCouples::Iterator IntPolyh_ListIteratorOfListOfCouples;
 
 #endif
index 5f85179..9d18c37 100644 (file)
@@ -30,7 +30,7 @@
 #include <gp.hxx>
 #include <gp_Pnt.hxx>
 #include <IntCurveSurface_ThePolyhedronOfHInter.hxx>
-#include <IntPolyh_ArrayOfCouples.hxx>
+#include <IntPolyh_ListOfCouples.hxx>
 #include <IntPolyh_Couple.hxx>
 #include <IntPolyh_Edge.hxx>
 #include <IntPolyh_MaillageAffinage.hxx>
 #include <IntPolyh_StartPoint.hxx>
 #include <IntPolyh_Triangle.hxx>
 #include <Precision.hxx>
+#include <TColStd_Array1OfInteger.hxx>
+#include <TColStd_MapOfInteger.hxx>
 #include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <NCollection_UBTree.hxx>
+#include <NCollection_UBTreeFiller.hxx>
+#include <algorithm>
+#include <NCollection_IndexedDataMap.hxx>
+
+typedef NCollection_Array1<Standard_Integer> IntPolyh_ArrayOfInteger;
+typedef NCollection_IndexedDataMap
+  <Standard_Integer,
+   IntPolyh_ArrayOfInteger,
+   TColStd_MapIntegerHasher> IntPolyh_IndexedDataMapOfIntegerArrayOfInteger;
+
 
 static Standard_Real MyTolerance=10.0e-7;
 static Standard_Real MyConfusionPrecision=10.0e-12;
@@ -73,46 +86,33 @@ static
 static
   void CalculPtsInterTriEdgeCoplanaires(const Standard_Integer TriSurfID,
                                         const IntPolyh_Point &NormaleTri,
+                                        const IntPolyh_Triangle &Tri1,
+                                        const IntPolyh_Triangle &Tri2,
                                         const IntPolyh_Point &PE1,
                                         const IntPolyh_Point &PE2,
                                         const IntPolyh_Point &Edge,
+                                        const Standard_Integer EdgeIndex,
                                         const IntPolyh_Point &PT1,
                                         const IntPolyh_Point &PT2,
                                         const IntPolyh_Point &Cote,
                                         const Standard_Integer CoteIndex,
                                         IntPolyh_StartPoint &SP1,
                                         IntPolyh_StartPoint &SP2,
-                                        Standard_Integer &NbPoints);
+                                        Standard_Integer &NbPoints); 
 static
-  void CalculPtsInterTriEdgeCoplanaires2(const Standard_Integer TriSurfID,
-                                         const IntPolyh_Point &NormaleTri,
-                                         const IntPolyh_Triangle &Tri1,
-                                         const IntPolyh_Triangle &Tri2,
-                                         const IntPolyh_Point &PE1,
-                                         const IntPolyh_Point &PE2,
-                                         const IntPolyh_Point &Edge,
-                                         const Standard_Integer EdgeIndex,
-                                         const IntPolyh_Point &PT1,
-                                         const IntPolyh_Point &PT2,
-                                         const IntPolyh_Point &Cote,
-                                       const Standard_Integer CoteIndex,
-                                         IntPolyh_StartPoint &SP1,
-                                         IntPolyh_StartPoint &SP2,
-                                         Standard_Integer &NbPoints); 
-static
-  Standard_Integer CheckCoupleAndGetAngle(const Standard_Integer T1, 
+  Standard_Boolean CheckCoupleAndGetAngle(const Standard_Integer T1, 
                                           const Standard_Integer T2,
                                           Standard_Real& Angle, 
-                                          IntPolyh_ArrayOfCouples &TTrianglesContacts);
+                                          IntPolyh_ListOfCouples &TTrianglesContacts);
 static
-  Standard_Integer CheckCoupleAndGetAngle2(const Standard_Integer T1,
+  Standard_Boolean CheckCoupleAndGetAngle2(const Standard_Integer T1,
                                            const Standard_Integer T2,
                                            const Standard_Integer T11, 
                                            const Standard_Integer T22,
-                                           Standard_Integer &CT11,
-                                           Standard_Integer &CT22, 
+                                           IntPolyh_ListIteratorOfListOfCouples& theItCT11,
+                                           IntPolyh_ListIteratorOfListOfCouples& theItCT22,
                                            Standard_Real & Angle,
-                                           IntPolyh_ArrayOfCouples &TTrianglesContacts);
+                                           IntPolyh_ListOfCouples &TTrianglesContacts);
 static
   Standard_Integer CheckNextStartPoint(IntPolyh_SectionLine & SectionLine,
                                        IntPolyh_ArrayOfTangentZones & TTangentZones,
@@ -137,7 +137,95 @@ static
                    Standard_Real &u1, 
                    Standard_Real &v0, 
                    Standard_Real &v1);
+
+//=======================================================================
+//class : IntPolyh_BoxBndTreeSelector
+//purpose  : Select interfering bounding boxes
+//=======================================================================
+typedef NCollection_UBTree<Standard_Integer, Bnd_Box> IntPolyh_BoxBndTree;
+class IntPolyh_BoxBndTreeSelector : public IntPolyh_BoxBndTree::Selector {
+ public:
+  IntPolyh_BoxBndTreeSelector(const Bnd_Box& theBox) : myBox(theBox) {}
+  //
+  virtual Standard_Boolean Reject(const Bnd_Box& theOther) const
+  {
+    return myBox.IsOut(theOther);
+  }
+  //
+  virtual Standard_Boolean Accept(const Standard_Integer &theInd)
+  {
+    myIndices.Append(theInd);
+    return Standard_True;
+  }
+  //
+  const TColStd_ListOfInteger& Indices() const
+  {
+    return myIndices;
+  }
+ private:
+  Bnd_Box myBox;
+  TColStd_ListOfInteger myIndices;
+};
+
+//=======================================================================
+//function : GetInterferingTriangles
+//purpose  : Returns indices of the triangles with interfering bounding boxes
+//=======================================================================
+static
+  void GetInterferingTriangles(IntPolyh_ArrayOfTriangles& theTriangles1,
+                               const IntPolyh_ArrayOfPoints& thePoints1,
+                               IntPolyh_ArrayOfTriangles& theTriangles2,
+                               const IntPolyh_ArrayOfPoints& thePoints2,
+                               IntPolyh_IndexedDataMapOfIntegerArrayOfInteger& theCouples)
+{
+  // To find the triangles with interfering bounding boxes
+  // use the algorithm of unbalanced binary tree of overlapping bounding boxes
+  IntPolyh_BoxBndTree aBBTree;
+  NCollection_UBTreeFiller <Standard_Integer, Bnd_Box> aTreeFiller(aBBTree);
+  // 1. Fill the tree with the boxes of the triangles from second surface
+  Standard_Integer i, aNbT2 = theTriangles2.NbItems();
+  for (i = 0; i < aNbT2; ++i) {
+    IntPolyh_Triangle& aT = theTriangles2[i];
+    if (!aT.IsIntersectionPossible() || aT.IsDegenerated()) {
+      continue;
+    }
+    //
+    const Bnd_Box& aBox = aT.BoundingBox(thePoints2);
+    aTreeFiller.Add(i, aBox);
+  }
+  //
+  // 2. Shake the tree filler
+  aTreeFiller.Fill();
+  //
+  // 3. Find boxes interfering with the first triangles
+  Standard_Integer aNbT1 = theTriangles1.NbItems();
+  for (i = 0; i < aNbT1; ++i) {
+    IntPolyh_Triangle& aT = theTriangles1[i];
+    if (!aT.IsIntersectionPossible() || aT.IsDegenerated()) {
+      continue;
+    }
+    //
+    const Bnd_Box& aBox = aT.BoundingBox(thePoints1);
+    //
+    IntPolyh_BoxBndTreeSelector aSelector(aBox);
+    if (!aBBTree.Select(aSelector)) {
+      continue;
+    }
+    //
+    const TColStd_ListOfInteger& aLI = aSelector.Indices();
+    // Sort the indices
+    IntPolyh_ArrayOfInteger anArr(1, aLI.Extent());
+    TColStd_ListIteratorOfListOfInteger aItLI(aLI);
+    for (Standard_Integer j = 1; aItLI.More(); aItLI.Next(), ++j) {
+      anArr(j) = aItLI.Value();
+    }
+    //
+    std::sort(anArr.begin(), anArr.end());
+    //
+    theCouples.Add(i, anArr);
+  }
+}
+
 //=======================================================================
 //function : IntPolyh_MaillageAffinage
 //purpose  : 
@@ -589,6 +677,7 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges
 {
 
   IntPolyh_ArrayOfEdges &TEdges=(SurfID==1)? TEdges1:TEdges2;
+  IntPolyh_ArrayOfTriangles &TTriangles=(SurfID==1)? TTriangles1:TTriangles2;
   Standard_Integer NbSamplesU=(SurfID==1)? NbSamplesU1:NbSamplesU2;
   Standard_Integer NbSamplesV=(SurfID==1)? NbSamplesV1:NbSamplesV2;
 
@@ -603,20 +692,22 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges
   //maillage u0 v0
   TEdges[CpteurTabEdges].SetFirstPoint(0);                // U V
   TEdges[CpteurTabEdges].SetSecondPoint(1);             // U V+1
-  //  TEdges[CpteurTabEdges].SetFirstTriangle(-1);
   TEdges[CpteurTabEdges].SetSecondTriangle(0);
+  TTriangles[0].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
   CpteurTabEdges++;
-  
+
   TEdges[CpteurTabEdges].SetFirstPoint(0);                // U V
   TEdges[CpteurTabEdges].SetSecondPoint(NbSamplesV);    // U+1 V
-  TEdges[CpteurTabEdges].SetFirstTriangle(0);
-  TEdges[CpteurTabEdges].SetSecondTriangle(1);
+  TEdges[CpteurTabEdges].SetFirstTriangle(1);
+  TTriangles[1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
   CpteurTabEdges++;
   
   TEdges[CpteurTabEdges].SetFirstPoint(0);                // U V
   TEdges[CpteurTabEdges].SetSecondPoint(NbSamplesV+1);  // U+1 V+1
-  TEdges[CpteurTabEdges].SetFirstTriangle(1);
-  //  TEdges[CpteurTabEdges].SetSecondTriangle(-1);
+  TEdges[CpteurTabEdges].SetFirstTriangle(0);
+  TTriangles[0].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
+  TEdges[CpteurTabEdges].SetSecondTriangle(1);
+  TTriangles[1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
   CpteurTabEdges++;
   
   //maillage surU=u0
@@ -627,18 +718,23 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges
     TEdges[CpteurTabEdges].SetSecondPoint(PntInit+1);             // U V+1
     //    TEdges[CpteurTabEdges].SetFirstTriangle(-1);
     TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*2);
+    TTriangles[BoucleMeshV*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     CpteurTabEdges++;
     
     TEdges[CpteurTabEdges].SetFirstPoint(PntInit);                // U V
     TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV+1);    // U+1 V+1
     TEdges[CpteurTabEdges].SetFirstTriangle(BoucleMeshV*2);
+    TTriangles[BoucleMeshV*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*2+1);
+    TTriangles[BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     CpteurTabEdges++;
     
     TEdges[CpteurTabEdges].SetFirstPoint(PntInit);                // U V
     TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV);  // U+1 V
     TEdges[CpteurTabEdges].SetFirstTriangle(BoucleMeshV*2+1);
+    TTriangles[BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*2-2);
+    TTriangles[BoucleMeshV*2-2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     CpteurTabEdges++;
     PntInit++;
   }  
@@ -649,19 +745,23 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges
     TEdges[CpteurTabEdges].SetFirstPoint(PntInit);    // U V
     TEdges[CpteurTabEdges].SetSecondPoint(PntInit+1); // U V+1
     TEdges[CpteurTabEdges].SetFirstTriangle((BoucleMeshV-1)*(NbSamplesV-1)*2+1);
+    TTriangles[(BoucleMeshV-1)*(NbSamplesV-1)*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*(NbSamplesV-1)*2);
+    TTriangles[BoucleMeshV*(NbSamplesV-1)*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     CpteurTabEdges++;
     
     TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V
     TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV+1);     // U+1 V+1
     TEdges[CpteurTabEdges].SetFirstTriangle(BoucleMeshV*(NbSamplesV-1)*2);
+    TTriangles[BoucleMeshV*(NbSamplesV-1)*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*(NbSamplesV-1)*2+1);
+    TTriangles[BoucleMeshV*(NbSamplesV-1)*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     CpteurTabEdges++;
     
     TEdges[CpteurTabEdges].SetFirstPoint(PntInit);  // U V
     TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV);    // U+1 V
     TEdges[CpteurTabEdges].SetFirstTriangle(BoucleMeshV*(NbSamplesV-1)*2+1);
-    //    TEdges[CpteurTabEdges].SetSecondTriangle(-1);
+    TTriangles[BoucleMeshV*(NbSamplesV-1)*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     CpteurTabEdges++;
     PntInit+=NbSamplesV;
   }
@@ -673,19 +773,25 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges
       TEdges[CpteurTabEdges].SetFirstPoint(PntInit);                // U V
       TEdges[CpteurTabEdges].SetSecondPoint(PntInit+1);             // U V+1
       TEdges[CpteurTabEdges].SetFirstTriangle((NbSamplesV-1)*2*(BoucleMeshU-1)+BoucleMeshV*2+1);
+      TTriangles[(NbSamplesV-1)*2*(BoucleMeshU-1)+BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
       TEdges[CpteurTabEdges].SetSecondTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2);
+      TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
       CpteurTabEdges++;
       
       TEdges[CpteurTabEdges].SetFirstPoint(PntInit);                // U V
       TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV+1);    // U+1 V+1 
       TEdges[CpteurTabEdges].SetFirstTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2);
+      TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
       TEdges[CpteurTabEdges].SetSecondTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2+1);
+      TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
       CpteurTabEdges++;
       
       TEdges[CpteurTabEdges].SetFirstPoint(PntInit);                // U V
       TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV);  // U+1 V
       TEdges[CpteurTabEdges].SetFirstTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2+1);
+      TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
       TEdges[CpteurTabEdges].SetSecondTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2-2);
+      TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2-2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
       CpteurTabEdges++;            
       PntInit++;//Pass to the next point
     }
@@ -699,7 +805,7 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges
     TEdges[CpteurTabEdges].SetFirstPoint(PntInit);           //U=u1 V
     TEdges[CpteurTabEdges].SetSecondPoint(PntInit+1);        //U=u1 V+1
     TEdges[CpteurTabEdges].SetFirstTriangle((NbSamplesU-2)*(NbSamplesV-1)*2+BoucleMeshV*2+1);
-    //    TEdges[CpteurTabEdges].SetSecondTriangle(-1);
+    TTriangles[(NbSamplesU-2)*(NbSamplesV-1)*2+BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     CpteurTabEdges++;
     PntInit++;
   }
@@ -708,8 +814,8 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges
   for(BoucleMeshV=0; BoucleMeshV<NbSamplesU-1;BoucleMeshV++){      
     TEdges[CpteurTabEdges].SetFirstPoint(NbSamplesV-1+BoucleMeshV*NbSamplesV);       // U V=v1
     TEdges[CpteurTabEdges].SetSecondPoint(NbSamplesV-1+(BoucleMeshV+1)*NbSamplesV);  //U+1 V=v1
-    //    TEdges[CpteurTabEdges].SetFirstTriangle(-1);
     TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*2*(NbSamplesV-1)+(NbSamplesV-2)*2);
+    TTriangles[BoucleMeshV*2*(NbSamplesV-1)+(NbSamplesV-2)*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges);
     CpteurTabEdges++;
   }
   TEdges.SetNbItems(CpteurTabEdges);
@@ -748,7 +854,7 @@ void IntPolyh_MaillageAffinage::FillArrayOfTriangles
          &&( (TPoints[PntInit+1].PartOfCommon()) & (TPoints[PntInit+NbSamplesV+1].PartOfCommon()))
          &&( (TPoints[PntInit+NbSamplesV+1].PartOfCommon()) & (TPoints[PntInit].PartOfCommon())) ) 
         //IF NOT IP=0
-        TTriangles[CpteurTabTriangles].SetIndiceIntersectionPossible(0);
+        TTriangles[CpteurTabTriangles].SetIntersectionPossible(Standard_False);
 
       CpteurTabTriangles++;
 
@@ -761,7 +867,7 @@ void IntPolyh_MaillageAffinage::FillArrayOfTriangles
       if( ( (TPoints[PntInit].PartOfCommon()) & (TPoints[PntInit+NbSamplesV+1].PartOfCommon()) )
          &&( (TPoints[PntInit+NbSamplesV+1].PartOfCommon()) & (TPoints[PntInit+NbSamplesV].PartOfCommon()))
          &&( (TPoints[PntInit+NbSamplesV].PartOfCommon()) & (TPoints[PntInit].PartOfCommon())) ) 
-        TTriangles[CpteurTabTriangles].SetIndiceIntersectionPossible(0);
+        TTriangles[CpteurTabTriangles].SetIntersectionPossible(Standard_False);
 
 
       CpteurTabTriangles++;
@@ -776,33 +882,6 @@ void IntPolyh_MaillageAffinage::FillArrayOfTriangles
   }
 }
 //=======================================================================
-//function : LinkEdges2Triangles
-//purpose  : fill the  edge fields in  Triangle object  for the
-//           two array of triangles.
-//=======================================================================
-void IntPolyh_MaillageAffinage::LinkEdges2Triangles() 
-{
-  const Standard_Integer FinTT1 = TTriangles1.NbItems();
-  const Standard_Integer FinTT2 = TTriangles2.NbItems();
-
-  for(Standard_Integer uiui1=0; uiui1<FinTT1; uiui1++) {
-    IntPolyh_Triangle & MyTriangle1=TTriangles1[uiui1];
-    if ( (MyTriangle1.FirstEdge()) == -1 ) {
-      MyTriangle1.SetEdgeandOrientation(1,TEdges1);
-      MyTriangle1.SetEdgeandOrientation(2,TEdges1);
-      MyTriangle1.SetEdgeandOrientation(3,TEdges1);
-    }
-  }
-  for(Standard_Integer uiui2=0; uiui2<FinTT2; uiui2++) {
-    IntPolyh_Triangle & MyTriangle2=TTriangles2[uiui2];
-    if ( (MyTriangle2.FirstEdge()) == -1 ) {
-      MyTriangle2.SetEdgeandOrientation(1,TEdges2);
-      MyTriangle2.SetEdgeandOrientation(2,TEdges2);
-      MyTriangle2.SetEdgeandOrientation(3,TEdges2);
-    }
-  }
-}
-//=======================================================================
 //function : CommonPartRefinement
 //purpose  : Refine systematicaly all marked triangles of both surfaces
 //           REFINING OF THE COMMON
@@ -811,13 +890,13 @@ void IntPolyh_MaillageAffinage::CommonPartRefinement()
 {
   Standard_Integer FinInit1 = TTriangles1.NbItems();
   for(Standard_Integer i=0; i<FinInit1; i++) {
-    if(TTriangles1[i].IndiceIntersectionPossible()!=0) 
+    if(TTriangles1[i].IsIntersectionPossible())
       TTriangles1[i].MiddleRefinement(i,MaSurface1,TPoints1,TTriangles1,TEdges1);
   }
 
   Standard_Integer FinInit2=TTriangles2.NbItems();
   for(Standard_Integer ii=0; ii<FinInit2; ii++) {
-    if(TTriangles2[ii].IndiceIntersectionPossible()!=0) 
+    if(TTriangles2[ii].IsIntersectionPossible())
       TTriangles2[ii].MiddleRefinement(ii,MaSurface2,TPoints2,TTriangles2,TEdges2); 
   }
 
@@ -831,7 +910,7 @@ void IntPolyh_MaillageAffinage::LocalSurfaceRefinement(const Standard_Integer Su
   if (SurfID==1) {
     const Standard_Integer FinInit1 = TTriangles1.NbItems();
     for(Standard_Integer i=0; i<FinInit1; i++) {
-      if(TTriangles1[i].IndiceIntersectionPossible()!=0)
+      if(TTriangles1[i].IsIntersectionPossible())
         TTriangles1[i].MiddleRefinement(i,MaSurface1,TPoints1,TTriangles1,TEdges1);
     }
   }
@@ -839,7 +918,7 @@ void IntPolyh_MaillageAffinage::LocalSurfaceRefinement(const Standard_Integer Su
   if (SurfID==2) {
     const Standard_Integer FinInit2 = TTriangles2.NbItems();
     for(Standard_Integer ii=0; ii<FinInit2; ii++) {
-      if(TTriangles2[ii].IndiceIntersectionPossible()!=0) 
+      if(TTriangles2[ii].IsIntersectionPossible()) 
         TTriangles2[ii].MiddleRefinement(ii,MaSurface2,TPoints2,TTriangles2,TEdges2); 
     }
   }
@@ -856,389 +935,242 @@ void IntPolyh_MaillageAffinage::LocalSurfaceRefinement(const Standard_Integer Su
 void IntPolyh_MaillageAffinage::ComputeDeflections
   (const Standard_Integer SurfID)
 {
-  Handle(Adaptor3d_HSurface) MaSurface=(SurfID==1)? MaSurface1:MaSurface2;
+  Handle(Adaptor3d_HSurface) aSurface=(SurfID==1)? MaSurface1:MaSurface2;
   IntPolyh_ArrayOfPoints &TPoints=(SurfID==1)? TPoints1:TPoints2;
   IntPolyh_ArrayOfTriangles &TTriangles=(SurfID==1)? TTriangles1:TTriangles2;
   Standard_Real &FlecheMin=(SurfID==1)? FlecheMin1:FlecheMin2;
   Standard_Real &FlecheMoy=(SurfID==1)? FlecheMoy1:FlecheMoy2;
   Standard_Real &FlecheMax=(SurfID==1)? FlecheMax1:FlecheMax2;
 
-  Standard_Integer CpteurTabFleche=0;
   FlecheMax=-RealLast();
   FlecheMin=RealLast();
   FlecheMoy=0.0;
   const Standard_Integer FinTT = TTriangles.NbItems();
   
-  for(CpteurTabFleche=0; CpteurTabFleche<FinTT; CpteurTabFleche++) {
-    IntPolyh_Triangle &Triangle = TTriangles[CpteurTabFleche];
-    if ( Triangle.GetFleche() < 0) { //pas normal
+  for(Standard_Integer i = 0; i < FinTT; i++) {
+    IntPolyh_Triangle& aTriangle = TTriangles[i];
+    Standard_Real Fleche = aTriangle.ComputeDeflection(aSurface, TPoints);
+    if (Fleche > FlecheMax)
+      FlecheMax = Fleche;
+    if (Fleche < FlecheMin)
+      FlecheMin = Fleche;
+  }
+}
 
+//=======================================================================
+//function : TrianglesDeflectionsRefinement
+//purpose  : Refinement of the triangles depending on the deflection
+//=======================================================================
+static
+  void TrianglesDeflectionsRefinement(const Handle(Adaptor3d_HSurface)& theS1,
+                                      IntPolyh_ArrayOfTriangles& theTriangles1,
+                                      IntPolyh_ArrayOfEdges& theEdges1,
+                                      IntPolyh_ArrayOfPoints& thePoints1,
+                                      const Standard_Real theFlecheCritique1,
+                                      const Handle(Adaptor3d_HSurface)& theS2,
+                                      IntPolyh_ArrayOfTriangles& theTriangles2,
+                                      IntPolyh_ArrayOfEdges& theEdges2,
+                                      IntPolyh_ArrayOfPoints& thePoints2,
+                                      const Standard_Real theFlecheCritique2)
+{
+  // Find the intersecting triangles
+  IntPolyh_IndexedDataMapOfIntegerArrayOfInteger aDMILI;
+  GetInterferingTriangles(theTriangles1, thePoints1, theTriangles2, thePoints2, aDMILI);
+  //
+  // Interfering triangles of second surface
+  TColStd_MapOfInteger aMIntS2;
+  // Since the number of the triangles may change during refinement,
+  // save the number of triangles before refinement
+  Standard_Integer FinTT1 = theTriangles1.NbItems();
+  Standard_Integer FinTT2 = theTriangles2.NbItems();
+  //
+  // Analyze interfering triangles
+  for (Standard_Integer i_S1 = 0; i_S1 < FinTT1; i_S1++) {
+    IntPolyh_Triangle& aTriangle1 = theTriangles1[i_S1];
+    if (!aTriangle1.IsIntersectionPossible()) {
+      continue;
     }
-    else{
-      Triangle.TriangleDeflection(MaSurface, TPoints);
-      Standard_Real Fleche=Triangle.GetFleche();
-
-      if (Fleche > FlecheMax)
-        FlecheMax=Fleche;
-      if (Fleche < FlecheMin)
-        FlecheMin=Fleche;
+    //
+    const IntPolyh_ArrayOfInteger *pLI = aDMILI.Seek(i_S1);
+    if (!pLI || !pLI->Length()) {
+      // Mark non-interfering triangles of S1 to avoid their repeated usage
+      aTriangle1.SetIntersectionPossible(Standard_False);
+      continue;
+    }
+    //
+    if (aTriangle1.Deflection() > theFlecheCritique1) {
+      aTriangle1.MiddleRefinement(i_S1, theS1, thePoints1, theTriangles1, theEdges1);
+    }
+    //
+    IntPolyh_ArrayOfInteger::Iterator Iter(*pLI);
+    for (; Iter.More(); Iter.Next()) {
+      Standard_Integer i_S2 = Iter.Value();
+      if (aMIntS2.Add(i_S2)) {
+        IntPolyh_Triangle & aTriangle2 = theTriangles2[i_S2];
+        if (aTriangle2.Deflection() > theFlecheCritique2) {
+          // Refinement of the larger triangles
+          aTriangle2.MiddleRefinement(i_S2, theS2, thePoints2, theTriangles2, theEdges2);
+        }
+      }
+    }
+  }
+  //
+  // Mark non-interfering triangles of S2 to avoid their repeated usage
+  if (aMIntS2.Extent() < FinTT2) {
+    for (Standard_Integer i_S2 = 0; i_S2 < FinTT2; i_S2++) {
+      if (!aMIntS2.Contains(i_S2)) {
+        theTriangles2[i_S2].SetIntersectionPossible(Standard_False);
+      }
+    }
+  }
+}
+//=======================================================================
+//function : LargeTrianglesDeflectionsRefinement
+//purpose  : Refinement of the large triangles in case one surface is
+//           much smaller then the other.
+//=======================================================================
+static
+  void LargeTrianglesDeflectionsRefinement(const Handle(Adaptor3d_HSurface)& theS,
+                                           IntPolyh_ArrayOfTriangles& theTriangles,
+                                           IntPolyh_ArrayOfEdges& theEdges,
+                                           IntPolyh_ArrayOfPoints& thePoints,
+                                           const Bnd_Box& theOppositeBox)
+{
+  // Find all triangles of the bigger surface with bounding boxes
+  // overlapping the bounding box the other surface
+  TColStd_ListOfInteger aLIT;
+  Standard_Integer i, aNbT = theTriangles.NbItems();
+  for (i = 0; i < aNbT; ++i) {
+    IntPolyh_Triangle& aTriangle = theTriangles[i];
+    if (!aTriangle.IsIntersectionPossible() || aTriangle.IsDegenerated()) {
+      continue;
+    }
+    //
+    const Bnd_Box& aBox = aTriangle.BoundingBox(thePoints);
+    if (aBox.IsVoid()) {
+      continue;
+    }
+    //
+    if (aBox.IsOut(theOppositeBox)) {
+      aTriangle.SetIntersectionPossible(Standard_False);
+      continue;
+    }
+    //
+    aLIT.Append(i);
+  }
+  //
+  if (aLIT.IsEmpty()) {
+    return;
+  }
+  //
+  // One surface is very small relatively to the other.
+  // The criterion of refining for large surface depends on the size of
+  // the bounding box of the other - since the criterion should be minimized,
+  // the smallest side of the bounding box is taken
+  Standard_Real x0, y0, z0, x1, y1, z1;
+  theOppositeBox.Get(x0, y0, z0, x1, y1, z1);
+  Standard_Real dx = Abs(x1 - x0);
+  Standard_Real dy = Abs(y1 - y0);
+  Standard_Real diag = Abs(z1 - z0);
+  Standard_Real dd = (dx > dy) ? dy : dx;
+  if (diag > dd) diag = dd;
+
+  // calculation of the criterion of refining
+  Standard_Real CritereAffinage = 0.0;
+  Standard_Real DiagPonderation = 0.5;
+  CritereAffinage = diag*DiagPonderation;
+  //
+  // The deflection of the greater is compared to the size of the smaller
+  TColStd_ListIteratorOfListOfInteger Iter(aLIT);
+  for (; Iter.More(); Iter.Next()) {
+    i = Iter.Value();
+    IntPolyh_Triangle & aTriangle = theTriangles[i];
+    if (aTriangle.Deflection() > CritereAffinage) {
+      aTriangle.MultipleMiddleRefinement(CritereAffinage, theOppositeBox, i,
+                                         theS, thePoints, theTriangles, theEdges);
+    }
+    else {
+      aTriangle.MiddleRefinement(i, theS, thePoints, theTriangles, theEdges);
     }
   }
 }
 //=======================================================================
 //function : TrianglesDeflectionsRefinementBSB
-//purpose  : Refine  both  surfaces using  BoundSortBox  as --
-//           rejection.  The  criterions  used to refine a  --
-//           triangle are:  The deflection The  size of the --
-//           bounding boxes   (one surface may be   very small
-//           compared to the other)
+//purpose  : Refine both surfaces using UBTree as rejection.
+//           The criterion used to refine a triangle are:
+//           - The deflection;
+//           - The  size of the - bounding boxes (one surface may be
+//           very small compared to the other).
 //=======================================================================
-void IntPolyh_MaillageAffinage::TrianglesDeflectionsRefinementBSB() 
+void IntPolyh_MaillageAffinage::TrianglesDeflectionsRefinementBSB()
 {
-  const Standard_Integer FinTT1 = TTriangles1.NbItems();
-  const Standard_Integer FinTT2 = TTriangles2.NbItems();
-  
+  // To estimate a surface in general it can be interesting
+  // to calculate all deflections
   ComputeDeflections(1);
-  // To estimate a surface in general it can be interesting 
-  //to calculate all deflections
-  //-- Check deflection at output
-                                                                 
+  // Check deflection at output
   Standard_Real FlecheCritique1;
-  if(FlecheMin1>FlecheMax1) {
-    return;    
+  if (FlecheMin1 > FlecheMax1) {
+    return;
   }
-  else {//fleche min + (flechemax-flechemin) * 80/100
-    FlecheCritique1 = FlecheMin1*0.2+FlecheMax1*0.8;
+  else {
+    // fleche min + (flechemax-flechemin) * 80/100
+    FlecheCritique1 = FlecheMin1*0.2 + FlecheMax1*0.8;
   }
-  
+
+  // Compute deflections for the second surface
   ComputeDeflections(2);
+
   //-- Check arrows at output
-  
   Standard_Real FlecheCritique2;
-  if(FlecheMin2>FlecheMax2) { 
-
+  if (FlecheMin2 > FlecheMax2) {
     return;
   }
-  else {//fleche min + (flechemax-flechemin) * 80/100
-    FlecheCritique2 = FlecheMin2*0.2+FlecheMax2*0.8;
-  }
-  
-  //Bounding boxes
-  Bnd_BoundSortBox BndBSB;
-  Standard_Real diag1,diag2;
-  Standard_Real x0,y0,z0,x1,y1,z1;
-  
-  //The greatest of two bounding boxes created in FillArrayOfPoints is found.
-  //Then this value is weighted depending on the discretization 
-  //(NbSamplesU and NbSamplesV)
-  MyBox1.Get(x0,y0,z0,x1,y1,z1);
-  x0-=x1; y0-=y1; z0-=z1;
-  diag1=x0*x0+y0*y0+z0*z0;
-  const Standard_Real NbSamplesUV1=Standard_Real(NbSamplesU1) * Standard_Real(NbSamplesV1);
-  diag1/=NbSamplesUV1;
-
-  MyBox2.Get(x0,y0,z0,x1,y1,z1);
-  x0-=x1; y0-=y1; z0-=z1;
-  diag2=x0*x0+y0*y0+z0*z0;
-  const Standard_Real NbSamplesUV2=Standard_Real(NbSamplesU2) * Standard_Real(NbSamplesV2);
-  diag2/=NbSamplesUV2;
-  
-  //-- The surface with the greatest bounding box is "discretized"
-  
-  //Standard_Integer NbInterTentees=0;
-  
-  if(diag1<diag2) { 
-    
-    if(FlecheCritique2<diag1) {//the corresponding sizes are not too disproportional
-
-      Handle(Bnd_HArray1OfBox) HBnd = new  Bnd_HArray1OfBox(1,FinTT2);
-        
-      for(Standard_Integer i=0; i<FinTT2; i++){
-        if (TTriangles2[i].IndiceIntersectionPossible()!=0) {
-          Bnd_Box b;
-          const IntPolyh_Triangle& T=TTriangles2[i];
-          const IntPolyh_Point&    PA=TPoints2[T.FirstPoint()];
-          const IntPolyh_Point&    PB=TPoints2[T.SecondPoint()]; 
-          const IntPolyh_Point&    PC=TPoints2[T.ThirdPoint()]; 
-          gp_Pnt pntA(PA.X(),PA.Y(),PA.Z());
-          gp_Pnt pntB(PB.X(),PB.Y(),PB.Z());
-          gp_Pnt pntC(PC.X(),PC.Y(),PC.Z());
-          b.Add(pntA);//Box b, which contains triangle i of surface 2 is created./
-          b.Add(pntB);
-          b.Add(pntC);
-          b.Enlarge(T.GetFleche()+MyTolerance);
-          HBnd->SetValue(i+1,b);//Box b is added in the array HBnd
-        }
-      }
-      
-      //Inititalization of the boundary, sorting of boxes
-      BndBSB.Initialize(HBnd);//contains boxes of 2
-      
-      Standard_Integer FinTT1Init=FinTT1;
-      for(Standard_Integer i_S1=0; i_S1<FinTT1Init; i_S1++) {
-        if(TTriangles1[i_S1].IndiceIntersectionPossible()!=0) {
-          //-- Loop on the boxes of mesh 1 
-          Bnd_Box b;
-          const IntPolyh_Triangle& T=TTriangles1[i_S1];
-          const IntPolyh_Point&    PA=TPoints1[T.FirstPoint()]; 
-          const IntPolyh_Point&    PB=TPoints1[T.SecondPoint()]; 
-          const IntPolyh_Point&    PC=TPoints1[T.ThirdPoint()]; 
-          gp_Pnt pntA(PA.X(),PA.Y(),PA.Z());
-          gp_Pnt pntB(PB.X(),PB.Y(),PB.Z());
-          gp_Pnt pntC(PC.X(),PC.Y(),PC.Z());
-          b.Add(pntA);
-          b.Add(pntB);
-          b.Add(pntC);
-          b.Enlarge(T.GetFleche());
-          //-- List of boxes of 2, which touch this box (of 1)
-          const TColStd_ListOfInteger& ListeOf2 = BndBSB.Compare(b);
-          
-          if((ListeOf2.IsEmpty())==0) {
-            IntPolyh_Triangle &Triangle1 = TTriangles1[i_S1];
-            if(Triangle1.GetFleche()>FlecheCritique1)
-              Triangle1.MiddleRefinement(i_S1,MaSurface1,TPoints1,
-                                         TTriangles1, TEdges1);
-            
-            for (TColStd_ListIteratorOfListOfInteger Iter(ListeOf2); 
-                 Iter.More(); 
-                 Iter.Next()) {
-              Standard_Integer i_S2=Iter.Value()-1;
-              //if the box of s1 contacts with the boxes of s2 
-              //the arrow of the triangle is checked
-              IntPolyh_Triangle & Triangle2 = TTriangles2[i_S2];
-              if(Triangle2.IndiceIntersectionPossible()!=0)
-                if(Triangle2.GetFleche()>FlecheCritique2)
-                  Triangle2.MiddleRefinement( i_S2, MaSurface2, TPoints2,
-                                             TTriangles2, TEdges2);
-            }
-          }
-        }
-      }
+  else {
+    //fleche min + (flechemax-flechemin) * 80/100
+    FlecheCritique2 = FlecheMin2*0.2 + FlecheMax2*0.8;
+  }
+
+  // The greatest of two bounding boxes created in FillArrayOfPoints is found.
+  // Then this value is weighted depending on the discretization 
+  // (NbSamplesU and NbSamplesV)
+  Standard_Real diag1, diag2;
+  Standard_Real x0, y0, z0, x1, y1, z1;
+
+  MyBox1.Get(x0, y0, z0, x1, y1, z1);
+  x0 -= x1; y0 -= y1; z0 -= z1;
+  diag1 = x0*x0 + y0*y0 + z0*z0;
+  const Standard_Real NbSamplesUV1 = Standard_Real(NbSamplesU1) * Standard_Real(NbSamplesV1);
+  diag1 /= NbSamplesUV1;
+
+  MyBox2.Get(x0, y0, z0, x1, y1, z1);
+  x0 -= x1; y0 -= y1; z0 -= z1;
+  diag2 = x0*x0 + y0*y0 + z0*z0;
+  const Standard_Real NbSamplesUV2 = Standard_Real(NbSamplesU2) * Standard_Real(NbSamplesV2);
+  diag2 /= NbSamplesUV2;
+
+  // The surface with the greatest bounding box is "discretized"
+  if (diag1 < diag2) {
+    // second is discretized
+    if (FlecheCritique2 < diag1) {
+      // The corresponding sizes are not too disproportional
+      TrianglesDeflectionsRefinement(MaSurface1, TTriangles1, TEdges1, TPoints1, FlecheCritique1,
+                                     MaSurface2, TTriangles2, TEdges2, TPoints2, FlecheCritique2);
     }
-
-    //--------------------------------------------------------------------
-    //FlecheCritique2 > diag1
     else {
-      //2 is discretized
-
-      Handle(Bnd_HArray1OfBox) HBnd = new  Bnd_HArray1OfBox(1,FinTT2);
-    
-      for(Standard_Integer i=0; i<FinTT2; i++){
-        if (TTriangles2[i].IndiceIntersectionPossible()!=0) {
-          Bnd_Box b;
-          const IntPolyh_Triangle& T=TTriangles2[i];
-          const IntPolyh_Point&    PA=TPoints2[T.FirstPoint()];
-          const IntPolyh_Point&    PB=TPoints2[T.SecondPoint()]; 
-          const IntPolyh_Point&    PC=TPoints2[T.ThirdPoint()]; 
-          gp_Pnt pntA(PA.X(),PA.Y(),PA.Z());
-          gp_Pnt pntB(PB.X(),PB.Y(),PB.Z());
-          gp_Pnt pntC(PC.X(),PC.Y(),PC.Z());
-          b.Add(pntA);//Box b, which contains triangle i of surface 2 is created/
-          b.Add(pntB);
-          b.Add(pntC);
-          b.Enlarge(T.GetFleche()+MyTolerance);
-          //-- BndBSB.Add(b,i+1);
-          HBnd->SetValue(i+1,b);//Box b is added in array HBnd
-        }
-      }
-      
-      //Inititalization of the ouput bounding box
-      BndBSB.Initialize(HBnd);//contains boxes of 2
-      
-
-      //The bounding box Be1 of surface1 is compared BSB of surface2
-      const TColStd_ListOfInteger& ListeOf2 = BndBSB.Compare(MyBox1);
-      
-      if((ListeOf2.IsEmpty())==0) {
-        //if the bounding box Be1 of s1 contacts with 
-        //the boxes of s2 the deflection of triangle of s2 is checked
-
-        // Be1 is very small in relation to Be2
-        //The criterion of refining for surface2 depends on the size of Be1
-        //As it is known that this criterion should be minimized, 
-        //the smallest side of the bounding box is taken
-        MyBox1.Get(x0,y0,z0,x1,y1,z1);
-        Standard_Real dx=Abs(x1-x0);
-        Standard_Real dy=Abs(y1-y0);
-        Standard_Real diag=Abs(z1-z0);
-        Standard_Real dd=-1.0;
-        if (dx>dy)
-          dd=dy;
-        else
-          dd=dx;
-        if (diag>dd) diag=dd;
-        
-        //if Be1 contacts with the boxes of s2, the deflection 
-        //of the triangles of s2 is checked (greater)
-        //in relation to the size of Be1 (smaller)
-        for (TColStd_ListIteratorOfListOfInteger Iter(ListeOf2); 
-             Iter.More(); 
-             Iter.Next()) {
-          Standard_Integer i_S2=Iter.Value()-1;
-          
-          IntPolyh_Triangle & Triangle2=TTriangles2[i_S2];
-          if(Triangle2.IndiceIntersectionPossible()) {
-            
-            //calculation of the criterion of refining
-            //The deflection of the greater is compared to the size of the smaller
-            Standard_Real CritereAffinage=0.0;
-            Standard_Real DiagPonderation=0.5;
-            CritereAffinage = diag*DiagPonderation;
-            if(Triangle2.GetFleche()>CritereAffinage)
-              Triangle2.MultipleMiddleRefinement2(CritereAffinage, MyBox1, i_S2,
-                                                  MaSurface2, TPoints2,
-                                                  TTriangles2,TEdges2);
-            
-            else Triangle2.MiddleRefinement(i_S2,MaSurface2,TPoints2,
-                                            TTriangles2, TEdges2);
-          }
-        }
-      }
+      // second surface is much larger then the first
+      LargeTrianglesDeflectionsRefinement(MaSurface2, TTriangles2, TEdges2, TPoints2, MyBox1);
     }
   }
-  
-  
-  else {     //-- The greater is discretised
-
-    if(FlecheCritique1<diag2) {//the respective sizes are not to much disproportional
-    
-      Handle(Bnd_HArray1OfBox) HBnd = new  Bnd_HArray1OfBox(1,FinTT1);
-      
-      for(Standard_Integer i=0; i<FinTT1; i++){
-        if(TTriangles1[i].IndiceIntersectionPossible()!=0) {
-          Bnd_Box b;
-          const IntPolyh_Triangle& T=TTriangles1[i];
-          const IntPolyh_Point&    PA=TPoints1[T.FirstPoint()];
-          const IntPolyh_Point&    PB=TPoints1[T.SecondPoint()]; 
-          const IntPolyh_Point&    PC=TPoints1[T.ThirdPoint()]; 
-          gp_Pnt pntA(PA.X(),PA.Y(),PA.Z());
-          gp_Pnt pntB(PB.X(),PB.Y(),PB.Z());
-          gp_Pnt pntC(PC.X(),PC.Y(),PC.Z());
-          b.Add(pntA);//Box b, which contains triangle i of surface 2 is created.
-          b.Add(pntB);
-          b.Add(pntC);
-          b.Enlarge(T.GetFleche()+MyTolerance);
-          HBnd->SetValue(i+1,b);//Boite b is added in the array HBnd
-        }
-      }
-      BndBSB.Initialize(HBnd);
-      
-      Standard_Integer FinTT2init=FinTT2;
-      for(Standard_Integer i_S2=0; i_S2<FinTT2init; i_S2++) {
-        if (TTriangles2[i_S2].IndiceIntersectionPossible()!=0) {      
-          //-- Loop on the boxes of mesh 2 
-          Bnd_Box b;
-          const IntPolyh_Triangle& T=TTriangles2[i_S2];
-          const IntPolyh_Point&    PA=TPoints2[T.FirstPoint()]; 
-          const IntPolyh_Point&    PB=TPoints2[T.SecondPoint()]; 
-          const IntPolyh_Point&    PC=TPoints2[T.ThirdPoint()]; 
-          gp_Pnt pntA(PA.X(),PA.Y(),PA.Z());
-          gp_Pnt pntB(PB.X(),PB.Y(),PB.Z());
-          gp_Pnt pntC(PC.X(),PC.Y(),PC.Z());
-          b.Add(pntA);
-          b.Add(pntB);
-          b.Add(pntC);
-          b.Enlarge(T.GetFleche()+MyTolerance);
-          //-- List of boxes of 1 touching this box (of 2)
-          const TColStd_ListOfInteger& ListeOf1 = BndBSB.Compare(b);
-          IntPolyh_Triangle & Triangle2=TTriangles2[i_S2];
-          if((ListeOf1.IsEmpty())==0) {
-            
-            if(Triangle2.GetFleche()>FlecheCritique2)
-              Triangle2.MiddleRefinement(i_S2,MaSurface2,TPoints2,
-                                         TTriangles2, TEdges2);
-            
-            for (TColStd_ListIteratorOfListOfInteger Iter(ListeOf1); 
-                 Iter.More(); 
-                 Iter.Next()) {
-              Standard_Integer i_S1=Iter.Value()-1;
-              IntPolyh_Triangle & Triangle1=TTriangles1[i_S1];
-              if (Triangle1.IndiceIntersectionPossible())
-                if(Triangle1.GetFleche()>FlecheCritique1)
-                  Triangle1.MiddleRefinement(i_S1,MaSurface1,TPoints1,
-                                             TTriangles1, TEdges1); 
-            }
-          }
-        }
-      }
+  else {
+    // first is discretized
+    if (FlecheCritique1 < diag2) {
+      // The corresponding sizes are not too disproportional
+      TrianglesDeflectionsRefinement(MaSurface2, TTriangles2, TEdges2, TPoints2, FlecheCritique2,
+                                     MaSurface1, TTriangles1, TEdges1, TPoints1, FlecheCritique1);
     }
-    //-----------------------------------------------------------------------------
-    else {// FlecheCritique1>diag2
-      // 1 is discretized
-
-      Handle(Bnd_HArray1OfBox) HBnd = new  Bnd_HArray1OfBox(1,FinTT1);
-    
-      for(Standard_Integer i=0; i<FinTT1; i++){
-        if (TTriangles1[i].IndiceIntersectionPossible()!=0) {
-          Bnd_Box b;
-          const IntPolyh_Triangle& T=TTriangles1[i];
-          const IntPolyh_Point&    PA=TPoints1[T.FirstPoint()];
-          const IntPolyh_Point&    PB=TPoints1[T.SecondPoint()]; 
-          const IntPolyh_Point&    PC=TPoints1[T.ThirdPoint()]; 
-          gp_Pnt pntA(PA.X(),PA.Y(),PA.Z());
-          gp_Pnt pntB(PB.X(),PB.Y(),PB.Z());
-          gp_Pnt pntC(PC.X(),PC.Y(),PC.Z());
-          b.Add(pntA);//Box b, which contains triangle i of surface 1 is created./
-          b.Add(pntB);
-          b.Add(pntC);
-          b.Enlarge(T.GetFleche()+MyTolerance);
-          HBnd->SetValue(i+1,b);//Box b is added in the array HBnd
-        }
-      }
-      
-      //Inititalisation of the boundary output box
-      BndBSB.Initialize(HBnd);//contains boxes of 1
-      
-      //Bounding box Be2 of surface2 is compared to BSB of surface1
-      const TColStd_ListOfInteger& ListeOf1 = BndBSB.Compare(MyBox2);
-      
-      if((ListeOf1.IsEmpty())==0) {
-        //if the bounding box Be2 of s2 contacts 
-        //with boxes of s1 the deflection of the triangle of s1 is checked
-        
-        // Be2 is very small compared to Be1
-        //The criterion of refining for surface1 depends on the size of Be2
-        //As this criterion should be minimized, 
-        //the smallest side of the bounding box is taken
-        MyBox2.Get(x0,y0,z0,x1,y1,z1);
-        Standard_Real dx=Abs(x1-x0);
-        Standard_Real dy=Abs(y1-y0);
-        Standard_Real diag=Abs(z1-z0);
-        Standard_Real dd=-1.0;
-        if (dx>dy)
-          dd=dy;
-        else
-          dd=dx;
-        if (diag>dd) diag=dd;
-        
-        //if Be2 contacts with boxes of s1, the deflection of 
-        //triangles of s1 (greater) is checked
-        //comparatively to the size of Be2 (smaller).
-        for (TColStd_ListIteratorOfListOfInteger Iter(ListeOf1); 
-             Iter.More(); 
-             Iter.Next()) {
-          Standard_Integer i_S1=Iter.Value()-1;
-
-          IntPolyh_Triangle & Triangle1=TTriangles1[i_S1];
-          if(Triangle1.IndiceIntersectionPossible()) {
-
-            //calculation of the criterion of refining
-            //The deflection of the greater is compared 
-            //with the size of the smaller.
-            Standard_Real CritereAffinage=0.0;
-            Standard_Real DiagPonderation=0.5;
-            CritereAffinage = diag*DiagPonderation;;
-            if(Triangle1.GetFleche()>CritereAffinage)
-              Triangle1.MultipleMiddleRefinement2(CritereAffinage,MyBox2, i_S1,
-                                                  MaSurface1, TPoints1,
-                                                  TTriangles1, TEdges1); 
-            
-            else Triangle1.MiddleRefinement(i_S1,MaSurface1,TPoints1,
-                                            TTriangles1, TEdges1);
-            
-          }
-        }
-      }
+    else {
+      // first surface is much larger then the second
+      LargeTrianglesDeflectionsRefinement(MaSurface1, TTriangles1, TEdges1, TPoints1, MyBox2);
     }
   }
 }
@@ -1425,7 +1357,7 @@ void TestNbPoints(const Standard_Integer ,
                   IntPolyh_StartPoint &SP1,
                   IntPolyh_StartPoint &SP2)
 {
-  // already checked in TriangleEdgeContact2
+  // already checked in TriangleEdgeContact
   //  if( (NbPoints==2)&&(Pt1.CheckSameSP(Pt2)) ) NbPoints=1;
 
   if(NbPoints>2) {
@@ -1475,113 +1407,11 @@ void TestNbPoints(const Standard_Integer ,
 }
 //=======================================================================
 //function : StartingPointsResearch
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_MaillageAffinage::StartingPointsResearch
-  (const Standard_Integer T1,
-   const Standard_Integer T2,
-   IntPolyh_StartPoint &SP1, 
-   IntPolyh_StartPoint &SP2) const 
-{
-  const IntPolyh_Point &P1=TPoints1[TTriangles1[T1].FirstPoint()];
-  const IntPolyh_Point &P2=TPoints1[TTriangles1[T1].SecondPoint()];
-  const IntPolyh_Point &P3=TPoints1[TTriangles1[T1].ThirdPoint()];
-  const IntPolyh_Point &Q1=TPoints2[TTriangles2[T2].FirstPoint()];
-  const IntPolyh_Point &Q2=TPoints2[TTriangles2[T2].SecondPoint()];
-  const IntPolyh_Point &Q3=TPoints2[TTriangles2[T2].ThirdPoint()];
-
-
-  /* The first triangle is (p1,p2,p3).  The other is (q1,q2,q3).
-     The sides are (e1,e2,e3) and (f1,f2,f3).
-     The normals are n1 and m1*/
-
-  const IntPolyh_Point  e1=P2-P1;
-  const IntPolyh_Point  e2=P3-P2;
-  const IntPolyh_Point  e3=P1-P3;
-
-  const IntPolyh_Point  f1=Q2-Q1;
-  const IntPolyh_Point  f2=Q3-Q2;
-  const IntPolyh_Point  f3=Q1-Q3;
-  
-
-  IntPolyh_Point nn1,mm1;
-  nn1.Cross(e1, e2); //normal of the first triangle
-  mm1.Cross(f1, f2); //normal of the  second triangle
-
-  Standard_Real nn1modulus, mm1modulus;
-  nn1modulus=sqrt(nn1.SquareModulus());
-  mm1modulus=sqrt(mm1.SquareModulus());
-
-  //-------------------------------------------------------
-  ///calculation of intersection points between two triangles
-  //-------------------------------------------------------
-  Standard_Integer NbPoints=0;
-  Standard_Integer NbPointsTotal=0;
-  IntPolyh_StartPoint Pt1,Pt2;
-
-
-    ///check T1 normal
-    if(Abs(nn1modulus)<MyConfusionPrecision){//10.0e-20) {
-
-    }
-    else {
-      const IntPolyh_Point n1=nn1.Divide(nn1modulus);
-      ///T2 edges with T1
-      if(NbPointsTotal<2) {
-        NbPoints=TriangleEdgeContact(1,1,P1,P2,P3,e1,e2,e3,Q1,Q2,f1,n1,Pt1,Pt2);
-        TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-      
-      if(NbPointsTotal<2) {
-        NbPoints=TriangleEdgeContact(1,2,P1,P2,P3,e1,e2,e3,Q2,Q3,f2,n1,Pt1,Pt2);
-        TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-      
-      if(NbPointsTotal<2) {
-        NbPoints=TriangleEdgeContact(1,3,P1,P2,P3,e1,e2,e3,Q3,Q1,f3,n1,Pt1,Pt2);
-        TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-    }
-
-    ///check T2 normal
-    if(Abs(mm1modulus)<MyConfusionPrecision) {//10.0e-20){
-
-    }
-    else {
-      const IntPolyh_Point m1=mm1.Divide(mm1modulus);
-      ///T1 edges with T2  
-      if(NbPointsTotal<2) {
-        NbPoints=TriangleEdgeContact(2,1,Q1,Q2,Q3,f1,f2,f3,P1,P2,e1,m1,Pt1,Pt2);
-        TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-      
-      if(NbPointsTotal<2) { 
-        NbPoints=TriangleEdgeContact(2,2,Q1,Q2,Q3,f1,f2,f3,P2,P3,e2,m1,Pt1,Pt2);
-        TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-      
-      if(NbPointsTotal<2) {
-        NbPoints=TriangleEdgeContact(2,3,Q1,Q2,Q3,f1,f2,f3,P3,P1,e3,m1,Pt1,Pt2);
-        TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-    }
-
-  /*  if( (NbPointsTotal >1)&&( Abs(SP1.U1()-SP2.U1())<MyConfusionPrecision)
-      &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) )*/
-  if( (NbPoints)&&(SP1.CheckSameSP(SP2)) )
-    NbPointsTotal=1;
-  
-  SP1.SetCoupleValue(T1,T2);
-  SP2.SetCoupleValue(T1,T2);
-  return (NbPointsTotal);
-}
-//=======================================================================
-//function : StartingPointsResearch2
 //purpose  : From  two  triangles compute intersection  points.
 //           If I found   more  than two intersection  points
 //           it  means that those triangle are coplanar
 //=======================================================================
-Standard_Integer IntPolyh_MaillageAffinage::StartingPointsResearch2
+Standard_Integer IntPolyh_MaillageAffinage::StartingPointsResearch
   (const Standard_Integer T1,
    const Standard_Integer T2,
    IntPolyh_StartPoint &SP1, 
@@ -1636,19 +1466,19 @@ Standard_Integer IntPolyh_MaillageAffinage::StartingPointsResearch2
       ///T2 edges with T1
       if(NbPointsTotal<3) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(1,1,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q1,Q2,f1,n1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(1,1,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q1,Q2,f1,n1,Pt1,Pt2);
         TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
       
       if(NbPointsTotal<3) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(1,2,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q2,Q3,f2,n1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(1,2,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q2,Q3,f2,n1,Pt1,Pt2);
         TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
       
       if(NbPointsTotal<3) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(1,3,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q3,Q1,f3,n1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(1,3,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q3,Q1,f3,n1,Pt1,Pt2);
         TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
     }
@@ -1662,19 +1492,19 @@ Standard_Integer IntPolyh_MaillageAffinage::StartingPointsResearch2
       ///T1 edges with T2
       if(NbPointsTotal<3) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(2,1,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P1,P2,e1,m1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(2,1,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P1,P2,e1,m1,Pt1,Pt2);
         TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
       
       if(NbPointsTotal<3) { 
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(2,2,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P2,P3,e2,m1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(2,2,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P2,P3,e2,m1,Pt1,Pt2);
         TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
       
       if(NbPointsTotal<3) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(2,3,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P3,P1,e3,m1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(2,3,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P3,P1,e3,m1,Pt1,Pt2);
         TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
     }
@@ -1697,7 +1527,9 @@ Standard_Integer IntPolyh_MaillageAffinage::StartingPointsResearch2
 }
 //=======================================================================
 //function : NextStartingPointsResearch
-//purpose  : 
+//purpose  : from  two triangles  and an intersection   point I
+//           seach the other point (if it exist).
+//           This function is used by StartPointChain
 //=======================================================================
 Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch
   (const Standard_Integer T1,
@@ -1706,17 +1538,23 @@ Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch
    IntPolyh_StartPoint &SPNext) const 
 {
   Standard_Integer NbPointsTotal=0;
+  Standard_Integer EdgeInit1=SPInit.E1();
+  Standard_Integer EdgeInit2=SPInit.E2();
   if( (T1<0)||(T2<0) ) NbPointsTotal=0;
   else {
-    const IntPolyh_Point &P1=TPoints1[TTriangles1[T1].FirstPoint()];
-    const IntPolyh_Point &P2=TPoints1[TTriangles1[T1].SecondPoint()];
-    const IntPolyh_Point &P3=TPoints1[TTriangles1[T1].ThirdPoint()];
-    const IntPolyh_Point &Q1=TPoints2[TTriangles2[T2].FirstPoint()];
-    const IntPolyh_Point &Q2=TPoints2[TTriangles2[T2].SecondPoint()];
-    const IntPolyh_Point &Q3=TPoints2[TTriangles2[T2].ThirdPoint()];
+    
+    const IntPolyh_Triangle &Tri1=TTriangles1[T1];
+    const IntPolyh_Triangle &Tri2=TTriangles2[T2];
+
+    const IntPolyh_Point &P1=TPoints1[Tri1.FirstPoint()];
+    const IntPolyh_Point &P2=TPoints1[Tri1.SecondPoint()];
+    const IntPolyh_Point &P3=TPoints1[Tri1.ThirdPoint()];
+    const IntPolyh_Point &Q1=TPoints2[Tri2.FirstPoint()];
+    const IntPolyh_Point &Q2=TPoints2[Tri2.SecondPoint()];
+    const IntPolyh_Point &Q3=TPoints2[Tri2.ThirdPoint()];
     
   /* The first triangle is (p1,p2,p3).  The other is (q1,q2,q3).
-     The sides are (e1,e2,e3) and (f1,f2,f3).
+     The edges are (e1,e2,e3) and (f1,f2,f3).
      The normals are n1 and m1*/
 
     const IntPolyh_Point  e1=P2-P1;
@@ -1734,150 +1572,14 @@ Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch
     Standard_Real nn1modulus, mm1modulus;
     nn1modulus=sqrt(nn1.SquareModulus());
     mm1modulus=sqrt(mm1.SquareModulus());
-     
+    
     //-------------------------------------------------
     ///calculation of intersections points between triangles
     //-------------------------------------------------
+
     Standard_Integer NbPoints=0;
     IntPolyh_StartPoint SP1,SP2;
-            
-    ///check T1 normal
-    if(Abs(nn1modulus)<MyConfusionPrecision) {//10.0e-20){
-
-    }
-    else {
-      const IntPolyh_Point n1=nn1.Divide(nn1modulus);
-      ///T2 edges with T1
-      if(NbPointsTotal<3) {
-        IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact(1,1,P1,P2,P3,e1,e2,e3,Q1,Q2,f1,n1,Pt1,Pt2);
-        TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-      
-      if(NbPointsTotal<3) {
-        IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact(1,2,P1,P2,P3,e1,e2,e3,Q2,Q3,f2,n1,Pt1,Pt2);
-        TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-      
-      if(NbPointsTotal<3) {
-        IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact(1,3,P1,P2,P3,e1,e2,e3,Q3,Q1,f3,n1,Pt1,Pt2);
-        TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-    }
-
-    ///check T2 normal
-    if(Abs(mm1modulus)<MyConfusionPrecision) {//10.0e-20){
-
-    }
-    else {
-      const IntPolyh_Point m1=mm1.Divide(mm1modulus);
-      ///T1 edges with T2
-      if(NbPointsTotal<3) {
-        IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact(2,1,Q1,Q2,Q3,f1,f2,f3,P1,P2,e1,m1,Pt1,Pt2);
-        TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-      
-      if(NbPointsTotal<3) {
-        IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact(2,2,Q1,Q2,Q3,f1,f2,f3,P2,P3,e2,m1,Pt1,Pt2);
-        TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-      
-      if(NbPointsTotal<3) {
-        IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact(2,3,Q1,Q2,Q3,f1,f2,f3,P3,P1,e3,m1,Pt1,Pt2);
-        TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
-      }
-    }
-
-    if (NbPointsTotal==1) {
-      /*      if( (Abs(SP1.U1()-SPInit.U1())<MyConfusionPrecision)
-              &&(Abs(SP1.V1()-SPInit.V1())<MyConfusionPrecision) ) */
-      if(SP1.CheckSameSP(SP2))
-        NbPointsTotal=0;
-      else {
-
-        NbPointsTotal=0;
-      }
-    }
-
-    //    if ( (NbPointsTotal==2)&&( Abs(SP1.U1()-SPInit.U1())<MyConfusionPrecision)
-    //&&( Abs(SP1.V1()-SPInit.V1())<MyConfusionPrecision) ) {
-    if( (NbPointsTotal==2)&&(SP1.CheckSameSP(SPInit)) ) {
-      NbPointsTotal=1;//SP1 et SPInit sont identiques
-      SPNext=SP2;
-    }
-    //    if( (NbPointsTotal==2)&&( Abs(SP2.U1()-SPInit.U1())<MyConfusionPrecision)
-    //&&( Abs(SP2.V1()-SPInit.V1())<MyConfusionPrecision) ) {
-    if( (NbPointsTotal==2)&&(SP2.CheckSameSP(SPInit)) ) {
-      NbPointsTotal=1;//SP2 et SPInit sont identiques
-      SPNext=SP1;
-    }
-    if(NbPointsTotal>1) {
-
-    }
-  }
-  SPNext.SetCoupleValue(T1,T2);
-  return (NbPointsTotal);
-}
-//=======================================================================
-//function : NextStartingPointsResearch2
-//purpose  : from  two triangles  and an intersection   point I
-//           seach the other point (if it exist).
-//           This function is used by StartPointChain
-//=======================================================================
-Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch2
-  (const Standard_Integer T1,
-   const Standard_Integer T2,
-   const IntPolyh_StartPoint &SPInit,
-   IntPolyh_StartPoint &SPNext) const 
-{
-  Standard_Integer NbPointsTotal=0;
-  Standard_Integer EdgeInit1=SPInit.E1();
-  Standard_Integer EdgeInit2=SPInit.E2();
-  if( (T1<0)||(T2<0) ) NbPointsTotal=0;
-  else {
-    
-    const IntPolyh_Triangle &Tri1=TTriangles1[T1];
-    const IntPolyh_Triangle &Tri2=TTriangles2[T2];
-
-    const IntPolyh_Point &P1=TPoints1[Tri1.FirstPoint()];
-    const IntPolyh_Point &P2=TPoints1[Tri1.SecondPoint()];
-    const IntPolyh_Point &P3=TPoints1[Tri1.ThirdPoint()];
-    const IntPolyh_Point &Q1=TPoints2[Tri2.FirstPoint()];
-    const IntPolyh_Point &Q2=TPoints2[Tri2.SecondPoint()];
-    const IntPolyh_Point &Q3=TPoints2[Tri2.ThirdPoint()];
-    
-  /* The first triangle is (p1,p2,p3).  The other is (q1,q2,q3).
-     The edges are (e1,e2,e3) and (f1,f2,f3).
-     The normals are n1 and m1*/
-
-    const IntPolyh_Point  e1=P2-P1;
-    const IntPolyh_Point  e2=P3-P2;
-    const IntPolyh_Point  e3=P1-P3;
-    
-    const IntPolyh_Point  f1=Q2-Q1;
-    const IntPolyh_Point  f2=Q3-Q2;
-    const IntPolyh_Point  f3=Q1-Q3;
-    
-    IntPolyh_Point nn1,mm1;
-    nn1.Cross(e1, e2); //normal to the first triangle
-    mm1.Cross(f1, f2); //normal to the second triangle
-
-    Standard_Real nn1modulus, mm1modulus;
-    nn1modulus=sqrt(nn1.SquareModulus());
-    mm1modulus=sqrt(mm1.SquareModulus());
-    
-    //-------------------------------------------------
-    ///calculation of intersections points between triangles
-    //-------------------------------------------------
-
-    Standard_Integer NbPoints=0;
-    IntPolyh_StartPoint SP1,SP2;
-
+
     ///check T1 normal
     if(Abs(nn1modulus)<MyConfusionPrecision) {//10.0e-20){
 
@@ -1887,19 +1589,19 @@ Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch2
       ///T2 edges with T1
       if( (NbPointsTotal<3)&&(EdgeInit2!=Tri2.FirstEdge()) ) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(1,1,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q1,Q2,f1,n1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(1,1,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q1,Q2,f1,n1,Pt1,Pt2);
         TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
       
       if( (NbPointsTotal<3)&&(EdgeInit2!=Tri2.SecondEdge()) ) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(1,2,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q2,Q3,f2,n1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(1,2,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q2,Q3,f2,n1,Pt1,Pt2);
         TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
       
       if( (NbPointsTotal<3)&&(EdgeInit2!=Tri2.ThirdEdge()) ) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(1,3,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q3,Q1,f3,n1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(1,3,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q3,Q1,f3,n1,Pt1,Pt2);
         TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
     }
@@ -1912,19 +1614,19 @@ Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch2
       ///T1 edges with T2
       if( (NbPointsTotal<3)&&(EdgeInit1!=Tri1.FirstEdge()) ) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(2,1,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P1,P2,e1,m1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(2,1,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P1,P2,e1,m1,Pt1,Pt2);
         TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
       
       if( (NbPointsTotal<3)&&(EdgeInit1!=Tri1.SecondEdge()) ) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(2,2,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P2,P3,e2,m1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(2,2,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P2,P3,e2,m1,Pt1,Pt2);
         TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
       
       if( (NbPointsTotal<3)&&(EdgeInit1!=Tri1.ThirdEdge()) ) {
         IntPolyh_StartPoint Pt1,Pt2;
-        NbPoints=TriangleEdgeContact2(2,3,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P3,P1,e3,m1,Pt1,Pt2);
+        NbPoints=TriangleEdgeContact(2,3,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P3,P1,e3,m1,Pt1,Pt2);
         TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2);
       }
     }
@@ -1958,216 +1660,19 @@ Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch2
 //=======================================================================
 void CalculPtsInterTriEdgeCoplanaires(const Standard_Integer TriSurfID,
                                       const IntPolyh_Point &NormaleTri,
+                                      const IntPolyh_Triangle &Tri1,
+                                      const IntPolyh_Triangle &Tri2,
                                       const IntPolyh_Point &PE1,
                                       const IntPolyh_Point &PE2,
                                       const IntPolyh_Point &Edge,
+                                      const Standard_Integer EdgeIndex,
                                       const IntPolyh_Point &PT1,
                                       const IntPolyh_Point &PT2,
                                       const IntPolyh_Point &Cote,
                                       const Standard_Integer CoteIndex,
                                       IntPolyh_StartPoint &SP1,
                                       IntPolyh_StartPoint &SP2,
-                                      Standard_Integer &NbPoints) 
-{
-  IntPolyh_Point TestParalleles;
-  TestParalleles.Cross(Edge,Cote);
-  if(sqrt(TestParalleles.SquareModulus())<MyConfusionPrecision) {
-    IntPolyh_Point Per;
-    Per.Cross(NormaleTri,Cote);
-    Standard_Real p1p = Per.Dot(PE1);
-    Standard_Real p2p = Per.Dot(PE2);
-    Standard_Real p0p = Per.Dot(PT1);    
-    if ( ( (p1p>=p0p)&&(p2p<=p0p) )||( (p1p<=p0p)&&(p2p>=p0p) ) ) {
-      Standard_Real lambda=(p1p-p0p)/(p1p-p2p);
-      if (lambda<-MyConfusionPrecision) {
-
-      }
-      IntPolyh_Point PIE=PE1+Edge*lambda;        
-      Standard_Real alpha=RealLast();
-      if(Cote.X()!=0) alpha=(PIE.X()-PT1.X())/Cote.X();
-      else if (Cote.Y()!=0) alpha=(PIE.Y()-PT1.Y())/Cote.Y();
-      else if (Cote.Z()!=0) alpha=(PIE.Z()-PT1.Z())/Cote.Z();
-      else {
-
-      }
-      if (alpha<-MyConfusionPrecision) {
-
-      }
-      else {
-        if (NbPoints==0) {
-          SP1.SetXYZ(PIE.X(),PIE.Y(),PIE.Z());
-          if (TriSurfID==1) {
-            SP1.SetUV1(PT1.U()+Cote.U()*alpha,PT1.V()+Cote.V()*alpha);
-            SP1.SetUV2(PIE.U(),PIE.V());
-            SP1.SetEdge1(CoteIndex);
-            NbPoints++;
-          }
-          else if (TriSurfID==2) {
-            SP1.SetUV1(PIE.U(),PIE.V());
-            SP1.SetUV2(PT1.U()+Cote.U()*alpha,PT1.V()+Cote.V()*alpha);
-            SP1.SetEdge2(CoteIndex);
-            NbPoints++;
-          }
-          else {
-
-          }
-        }
-
-        else if (NbPoints==1) {
-          SP2.SetXYZ(PIE.X(),PIE.Y(),PIE.Z());
-          if (TriSurfID==1) {
-            SP2.SetUV1(PT1.U()+Cote.U()*alpha,PT1.V()+Cote.V()*alpha);
-            SP2.SetUV2(PIE.U(),PIE.V());
-            SP2.SetEdge1(CoteIndex);
-            NbPoints++;
-          }
-          else if (TriSurfID==2) {
-            SP2.SetUV1(PIE.U(),PIE.V());
-            SP2.SetUV2(PT1.U()+Cote.U()*alpha,PT1.V()+Cote.V()*alpha);
-            SP2.SetEdge2(CoteIndex);
-            NbPoints++;
-          }
-          else {
-
-          }
-        }
-
-        else if( (NbPoints>2)||(NbPoints<0) ) {
-
-        }
-      }
-    }
-  }
-  else {    //Cote et Edge paralleles, avec les rejections precedentes ils sont sur la meme droite
-    //On projette les points sur cette droite
-    Standard_Real pe1p= Cote.Dot(PE1);
-    Standard_Real pe2p= Cote.Dot(PE2);
-    Standard_Real pt1p= Cote.Dot(PT1);
-    Standard_Real pt2p= Cote.Dot(PT2);
-    
-    IntPolyh_Point PEP1,PTP1,PEP2,PTP2;
-
-    //PEP1 et PEP2 sont les points de contact entre le triangle et l'edge dans le repere UV de l'edge
-    //PTP1 et PTP2 sont les correspondants respectifs a PEP1 et PEP2 dans le repere UV du triangle
-
-
-    if (pe1p>pe2p) {
-      if ( (pt1p<pe1p)&&(pe1p<=pt2p) ) {
-        PEP1=PE1;
-        PTP1=PT1+Cote*((pe1p-pt1p)/(pt2p-pt1p));
-        NbPoints=1;
-        if (pt1p<=pe2p) {
-          PEP2=PE2;
-          PTP2=PT1+Cote*((pe2p-pt1p)/(pt2p-pt1p));
-          NbPoints=2;
-        }
-        else {
-          PEP2=PE1+Edge*((pt1p-pe1p)/(pe2p-pe1p));
-          PTP2=PT1;
-          NbPoints=2;
-        }
-      }
-      else if( (pt2p<pe1p)&&(pe1p<=pt1p) ) {
-        PEP1=PE1;
-        PTP1=PT1+Cote*((pt1p-pe1p)/(pt1p-pt2p));
-        NbPoints=1;
-        if (pt2p<=pe2p) {
-          PEP2=PE2;
-          PTP2=PT1+Cote*((pe2p-pt1p)/(pt2p-pt1p));
-          NbPoints=2;
-        }
-        else {
-          PEP2=PE1+Edge*((pt2p-pe1p)/(pe2p-pe1p));
-          PTP2=PT2;
-          NbPoints=2;
-        }
-      }
-    }
-    
-    if (pe1p<pe2p) {
-      if ( (pt1p<pe2p)&&(pe2p<=pt2p) ) {
-        PEP1=PE2;
-        PTP1=PT1+Cote*((pe2p-pt1p)/(pt2p-pt1p));
-        NbPoints=1;
-        if (pt1p<=pe1p) {
-          PEP2=PE1;
-          PTP2=PT1+Cote*((pe1p-pt1p)/(pt2p-pt1p));
-          NbPoints=2;
-        }
-        else {
-          PEP2=PE2+Edge*((pt1p-pe1p)/(pe2p-pe1p));
-          PTP2=PT1;
-          NbPoints=2;
-        }
-      }
-      else if( (pt2p<pe2p)&&(pe2p<=pt1p) ) {
-        PEP1=PE2;
-        PTP1=PT1+Cote*((pt1p-pe2p)/(pt1p-pt2p));
-        NbPoints=1;
-        if (pt2p<=pe1p) {
-          PEP2=PE1;
-          PTP2=PT1+Cote*((pe1p-pt1p)/(pt2p-pt1p));
-          NbPoints=2;
-        }
-        else {
-          PEP2=PE1+Edge*((pt2p-pe1p)/(pe2p-pe1p));
-          PTP2=PT2;
-          NbPoints=2;
-        }
-      }
-    }
-  
-    if (NbPoints!=0) {
-      if (Abs(PEP1.U()-PEP2.U())<MyConfusionPrecision
-          &&(Abs(PEP1.V()-PEP2.V())<MyConfusionPrecision) ) NbPoints=1;
-      
-      SP1.SetXYZ(PEP1.X(),PEP1.Y(),PEP1.Z());
-      if (TriSurfID==1) {
-        SP1.SetUV1(PTP1.U(),PTP1.V());          
-        SP1.SetUV2(PEP1.U(),PEP1.V());
-        SP1.SetEdge1(CoteIndex);
-      }
-      if (TriSurfID==2) {
-        SP1.SetUV1(PEP1.U(),PTP1.V());          
-        SP1.SetUV2(PTP1.U(),PEP1.V());
-        SP1.SetEdge2(CoteIndex);
-      }
-      
-      if (NbPoints==2) {
-        SP2.SetXYZ(PEP2.X(),PEP2.Y(),PEP2.Z());
-        if (TriSurfID==1) {
-          SP2.SetUV1(PTP2.U(),PTP2.V());          
-          SP2.SetUV2(PEP2.U(),PEP2.V());
-          SP2.SetEdge1(CoteIndex);
-        }
-        if (TriSurfID==2) {
-          SP2.SetUV1(PEP2.U(),PTP2.V());          
-          SP2.SetUV2(PTP2.U(),PEP2.V());
-          SP2.SetEdge2(CoteIndex);
-        } 
-      }
-    }
-  }
-}
-//=======================================================================
-//function : CalculPtsInterTriEdgeCoplanaires2
-//purpose  : 
-//=======================================================================
-void CalculPtsInterTriEdgeCoplanaires2(const Standard_Integer TriSurfID,
-                                       const IntPolyh_Point &NormaleTri,
-                                       const IntPolyh_Triangle &Tri1,
-                                       const IntPolyh_Triangle &Tri2,
-                                       const IntPolyh_Point &PE1,
-                                       const IntPolyh_Point &PE2,
-                                       const IntPolyh_Point &Edge,
-                                       const Standard_Integer EdgeIndex,
-                                       const IntPolyh_Point &PT1,
-                                       const IntPolyh_Point &PT2,
-                                       const IntPolyh_Point &Cote,
-                                       const Standard_Integer CoteIndex,
-                                       IntPolyh_StartPoint &SP1,
-                                       IntPolyh_StartPoint &SP2,
-                                       Standard_Integer &NbPoints)
+                                      Standard_Integer &NbPoints)
 {
   Standard_Real aDE, aDC;
   //
@@ -2409,386 +1914,99 @@ void CalculPtsInterTriEdgeCoplanaires2(const Standard_Integer TriSurfID,
           PTP2=PT1+Cote*alpha2;
           NbPoints=2;
         }
-        else {
-          lambda2=((pt2p-pe1p)/(pe2p-pe1p));
-          PEP2=PE1+Edge*lambda2;
-          alpha2=1.0;
-          PTP2=PT2;
-          NbPoints=2;
-        }
-      }
-    }
-  
-    if (NbPoints!=0) {
-      SP1.SetXYZ(PEP1.X(),PEP1.Y(),PEP1.Z());
-      if (TriSurfID==1) {///cote appartient a Tri1
-        SP1.SetUV1(PTP1.U(),PTP1.V());          
-        SP1.SetUV2(PEP1.U(),PEP1.V());
-        SP1.SetEdge1(Tri1.GetEdgeNumber(CoteIndex));
-
-        if(Tri1.GetEdgeOrientation(CoteIndex)>0) SP1.SetLambda1(alpha1);
-        else SP1.SetLambda1(1.0-alpha1);
-        
-        if(Tri2.GetEdgeOrientation(EdgeIndex)>0) SP1.SetLambda2(lambda1);
-        else SP1.SetLambda2(1.0-lambda1);
-      }
-      if (TriSurfID==2) {///cote appartient a Tri2
-        SP1.SetUV1(PEP1.U(),PTP1.V());          
-        SP1.SetUV2(PTP1.U(),PEP1.V());
-        SP1.SetEdge2(Tri2.GetEdgeNumber(CoteIndex));
-
-        if(Tri2.GetEdgeOrientation(CoteIndex)>0) SP1.SetLambda1(alpha1);
-        else SP1.SetLambda1(1.0-alpha1);
-        
-        if(Tri1.GetEdgeOrientation(EdgeIndex)>0) SP1.SetLambda2(lambda1);
-        else SP1.SetLambda2(1.0-lambda1);
-      }
-      
-      //It is checked if PEP1!=PEP2
-      if ( (NbPoints==2)&&(Abs(PEP1.U()-PEP2.U())<MyConfusionPrecision)
-         &&(Abs(PEP1.V()-PEP2.V())<MyConfusionPrecision) ) NbPoints=1;
-      if (NbPoints==2) {
-        SP2.SetXYZ(PEP2.X(),PEP2.Y(),PEP2.Z());
-        if (TriSurfID==1) {
-          SP2.SetUV1(PTP2.U(),PTP2.V());          
-          SP2.SetUV2(PEP2.U(),PEP2.V());
-          SP2.SetEdge1(Tri1.GetEdgeNumber(CoteIndex));
-
-          if(Tri1.GetEdgeOrientation(CoteIndex)>0) SP2.SetLambda1(alpha1);
-          else SP2.SetLambda1(1.0-alpha1);
-          
-          if(Tri2.GetEdgeOrientation(EdgeIndex)>0) SP2.SetLambda2(lambda1);
-          else SP2.SetLambda2(1.0-lambda1);
-        }
-        if (TriSurfID==2) {
-          SP2.SetUV1(PEP2.U(),PTP2.V());          
-          SP2.SetUV2(PTP2.U(),PEP2.V());
-          SP2.SetEdge2(Tri2.GetEdgeNumber(CoteIndex));
-
-          if(Tri1.GetEdgeOrientation(CoteIndex)>0) SP2.SetLambda1(alpha1);
-          else SP2.SetLambda1(1.0-alpha1);
-          
-          if(Tri2.GetEdgeOrientation(EdgeIndex)>0) SP2.SetLambda2(lambda1);
-          else SP2.SetLambda2(1.0-lambda1);
-        } 
-      }
-    }
-  }
-  //Filter if the point is placed on top, the edge is set  to -1
-  if (NbPoints>0) {
-    if(Abs(SP1.Lambda1())<MyConfusionPrecision)
-      SP1.SetEdge1(-1);
-    if(Abs(SP1.Lambda1()-1)<MyConfusionPrecision)
-      SP1.SetEdge1(-1);
-    if(Abs(SP1.Lambda2())<MyConfusionPrecision)
-      SP1.SetEdge2(-1);
-    if(Abs(SP1.Lambda2()-1)<MyConfusionPrecision)
-      SP1.SetEdge2(-1);
-  }
-  if (NbPoints==2) {
-    if(Abs(SP2.Lambda1())<MyConfusionPrecision)
-      SP2.SetEdge1(-1);
-    if(Abs(SP2.Lambda1()-1)<MyConfusionPrecision)
-      SP2.SetEdge1(-1);
-    if(Abs(SP2.Lambda2())<MyConfusionPrecision)
-      SP2.SetEdge2(-1);
-    if(Abs(SP2.Lambda2()-1)<MyConfusionPrecision)
-      SP2.SetEdge2(-1);
-  }
-}
-//=======================================================================
-//function : TriangleEdgeContact
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_MaillageAffinage::TriangleEdgeContact
-  (const Standard_Integer TriSurfID,
-   const Standard_Integer EdgeIndex,
-   const IntPolyh_Point &PT1,
-   const IntPolyh_Point &PT2,
-   const IntPolyh_Point &PT3,
-   const IntPolyh_Point &Cote12,
-   const IntPolyh_Point &Cote23,
-   const IntPolyh_Point &Cote31,
-   const IntPolyh_Point &PE1,const IntPolyh_Point &PE2,
-   const IntPolyh_Point &Edge,
-   const IntPolyh_Point &NormaleT,
-   IntPolyh_StartPoint &SP1,IntPolyh_StartPoint &SP2) const 
-{
-
-  Standard_Real lambda =0.;
-  Standard_Real alpha =0.;
-  Standard_Real beta =0.;
-
-    
-  //The edge, on which the point is located, is known.
-  if (TriSurfID==1) {
-    SP1.SetEdge2(EdgeIndex);
-    SP2.SetEdge2(EdgeIndex);
-  }
-  else if (TriSurfID==2) {
-    SP1.SetEdge1(EdgeIndex);
-    SP2.SetEdge1(EdgeIndex);
-  }
-  else {
-
-  }
-
-/**The edge is projected on the normal of the triangle if yes 
-  --> free intersection (point I)--> start point is found*/
-  Standard_Integer NbPoints=0;
-
-  if(NormaleT.SquareModulus()==0) {
-
-  }
-  else if( (Cote12.SquareModulus()==0)
-       ||(Cote23.SquareModulus()==0)
-       ||(Cote31.SquareModulus()==0) ) {
-
-  }
-  else if(Edge.SquareModulus()==0) {
-
-  }
-  else {
-    Standard_Real pe1 = NormaleT.Dot(PE1);
-    Standard_Real pe2 = NormaleT.Dot(PE2);
-    Standard_Real pt1 = NormaleT.Dot(PT1);  
-    
-    // PE1I = lambda.Edge
-    
-    if( (Abs(pe1-pe2)<MyConfusionPrecision)&&(Abs(pe1-pt1)<MyConfusionPrecision) ) {
-      //edge and triangle are coplanar (two contact points maximum)
-
-      //The tops of the triangle are projected on the perpendicular of the edge 
-      
-      IntPolyh_Point PerpEdge;
-      PerpEdge.Cross(NormaleT,Edge);
-      Standard_Real pp1 = PerpEdge.Dot(PT1);
-      Standard_Real pp2 = PerpEdge.Dot(PT2);
-      Standard_Real pp3 = PerpEdge.Dot(PT3);
-      Standard_Real ppe1 = PerpEdge.Dot(PE1);
-               
-      if ( ( (pp1>ppe1)&&(pp2<=ppe1)&&(pp3<=ppe1) ) || ( (pp1<ppe1)&&(pp2>=ppe1)&&(pp3>=ppe1) ) ){
-        //there are two sides (commun top PT1) that can cut the edge
-        
-        //first side
-        CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,
-                                         PE1,PE2,Edge,PT1,PT2,
-                                         Cote12,1,SP1,SP2,NbPoints);
-
-        if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
-            &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
-
-        //second side
-        if (NbPoints<2) {
-          CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,
-                                           PE1,PE2,Edge,PT3,PT1,
-                                           Cote31,3,SP1,SP2,NbPoints);
+        else {
+          lambda2=((pt2p-pe1p)/(pe2p-pe1p));
+          PEP2=PE1+Edge*lambda2;
+          alpha2=1.0;
+          PTP2=PT2;
+          NbPoints=2;
         }
       }
-
-      if ( (NbPoints>1)&&(Abs(SP1.U1()-SP2.U1())<MyConfusionPrecision)
-          &&(Abs(SP1.V2()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
-      if (NbPoints>=2) return(NbPoints);
-              
-      else if ( ( ( (pp2>ppe1)&&(pp1<=ppe1)&&(pp3<=ppe1) ) || ( (pp2<ppe1)&&(pp1>=ppe1)&&(pp3>=ppe1) ) )
-               && (NbPoints<2) ) {
-        //there are two sides (common top PT2) that can cut the edge
-        
-        //first side
-        CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,
-                                         PE1,PE2,Edge,PT1,PT2,
-                                         Cote12,1,SP1,SP2,NbPoints);
-
-        if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
-            &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
-
-        //second side
-        if(NbPoints<2) CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,
-                                                        PE1,PE2,Edge,PT2,PT3,
-                                                        Cote23,2,SP1,SP2,NbPoints);
-      }
-      if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
-          &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
-      if (NbPoints>=2) return(NbPoints);
-                     //= remove
-      else if ( (( (pp3>ppe1)&&(pp1<=ppe1)&&(pp2<=ppe1) ) || ( (pp3<ppe1)&&(pp1>=ppe1)&&(pp2>=ppe1) ))
-               && (NbPoints<2) ) {
-        //there are two sides (common top PT3) that can cut the edge
-        
-        //first side
-        CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,
-                                         PE1,PE2,Edge,PT3,PT1,Cote31,
-                                         3,SP1,SP2,NbPoints);
-        
-        if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
-            &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
-
-        //second side
-        if (NbPoints<2) CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,
-                                                         PE1,PE2,Edge,PT2,PT3,
-                                                         Cote23,2,SP1,SP2,NbPoints);
-      }
-      if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
-          &&(Abs(SP2.V1()-SP1.V1())<MyConfusionPrecision) ) NbPoints=1;
-      if (NbPoints>=2) return(NbPoints);
     }
-    
-
-    //------------------------------------------------------
-    // edge and triangle NON COPLANAR (a contact point)
-    //------------------------------------------------------
-    else if(   ( (pe1>=pt1)&&(pe2<=pt1) ) || ( (pe1<=pt1)&&(pe2>=pt1) )  ) {
-      lambda=(pe1-pt1)/(pe1-pe2);
-      IntPolyh_Point PI;
-      if (lambda<-MyConfusionPrecision) {
-
-  }
-      else if (Abs(lambda)<MyConfusionPrecision) {//lambda==0
-        PI=PE1;
-        if(TriSurfID==1) SP1.SetEdge2(0);
-        else SP1.SetEdge1(0);
-      }
-      else if (Abs(lambda-1.0)<MyConfusionPrecision) {//lambda==1
-        PI=PE2;
-        if(TriSurfID==1) SP1.SetEdge2(0);
-        else SP1.SetEdge1(0);
-      }
-      else {
-        PI=PE1+Edge*lambda;
-        if(TriSurfID==1) SP1.SetEdge2(EdgeIndex);
-        else SP1.SetEdge1(EdgeIndex);
-      }
-     
-      if(Abs(Cote23.X())>MyConfusionPrecision) {
-        Standard_Real D=(Cote12.Y()-Cote12.X()*Cote23.Y()/Cote23.X());
-        if(D!=0) alpha = (PI.Y()-PT1.Y()-(PI.X()-PT1.X())*Cote23.Y()/Cote23.X())/D;
-        else { 
+  
+    if (NbPoints!=0) {
+      SP1.SetXYZ(PEP1.X(),PEP1.Y(),PEP1.Z());
+      if (TriSurfID==1) {///cote appartient a Tri1
+        SP1.SetUV1(PTP1.U(),PTP1.V());          
+        SP1.SetUV2(PEP1.U(),PEP1.V());
+        SP1.SetEdge1(Tri1.GetEdgeNumber(CoteIndex));
 
-        }
-        if ((alpha<-MyConfusionPrecision)||(alpha>(1.0+MyConfusionPrecision))) return(0);
-        else beta = (PI.X()-PT1.X()-alpha*Cote12.X())/Cote23.X();
-      }
-      
-      else if (Abs(Cote12.X())>MyConfusionPrecision) { //On a Cote23.X()==0
-        alpha = (PI.X()-PT1.X())/Cote12.X();
-        
-        if ((alpha<-MyConfusionPrecision)||(alpha>(1.0+MyConfusionPrecision))) return(0);
+        if(Tri1.GetEdgeOrientation(CoteIndex)>0) SP1.SetLambda1(alpha1);
+        else SP1.SetLambda1(1.0-alpha1);
         
-        else if (Abs(Cote23.Y())>MyConfusionPrecision) beta = (PI.Y()-PT1.Y()-alpha*Cote12.Y())/Cote23.Y();
-        else if (Abs(Cote23.Z())>MyConfusionPrecision) beta = (PI.Z()-PT1.Z()-alpha*Cote12.Z())/Cote23.Z();
-        else  {
-
-        }
+        if(Tri2.GetEdgeOrientation(EdgeIndex)>0) SP1.SetLambda2(lambda1);
+        else SP1.SetLambda2(1.0-lambda1);
       }
-      
-      else if (Abs(Cote23.Y())>MyConfusionPrecision) {
-        //On a Cote23.X()==0 et Cote12.X()==0 ==> equation can't be used
-        Standard_Real D=(Cote12.Z()-Cote12.Y()*Cote23.Z()/Cote23.Y());
-        
-        if(D!=0) alpha = (PI.Z()-PT1.Z()-(PI.Y()-PT1.Y())*Cote23.Z()/Cote23.Y())/D;
-        else{ 
+      if (TriSurfID==2) {///cote appartient a Tri2
+        SP1.SetUV1(PEP1.U(),PTP1.V());          
+        SP1.SetUV2(PTP1.U(),PEP1.V());
+        SP1.SetEdge2(Tri2.GetEdgeNumber(CoteIndex));
 
-        }
-  
-        if ( (alpha<-MyConfusionPrecision)||(alpha>(1.0+MyConfusionPrecision)) ) return(0);
-        else beta = (PI.Y()-PT1.Y()-alpha*Cote12.Y())/Cote23.Y();
-      }
-      
-      else if (Abs(Cote12.Y())>MyConfusionPrecision) {
-        //On a Cote23.X()==0, Cote12.X()==0 et Cote23.Y()==0
-        alpha = (PI.Y()-PT1.Y())/Cote12.Y();
-        
-        if ((Abs(alpha)<MyConfusionPrecision)||(Abs(alpha-1.0)<MyConfusionPrecision)) return(0);
-        
-        else if (Abs(Cote23.Z())>MyConfusionPrecision) beta = (PI.Z()-PT1.Z()-alpha*Cote12.Z())/Cote23.Z();
+        if(Tri2.GetEdgeOrientation(CoteIndex)>0) SP1.SetLambda1(alpha1);
+        else SP1.SetLambda1(1.0-alpha1);
         
-        else {
-
-        }
-      }    
-      
-      else { //two equations of three can't be used
-
-        alpha=RealLast();
-        beta=RealLast();
+        if(Tri1.GetEdgeOrientation(EdgeIndex)>0) SP1.SetLambda2(lambda1);
+        else SP1.SetLambda2(1.0-lambda1);
       }
       
-      if( (beta<-MyConfusionPrecision)||(beta>(alpha+MyConfusionPrecision)) ) return(0);
-      else {
-        SP1.SetXYZ(PI.X(),PI.Y(),PI.Z());
-
+      //It is checked if PEP1!=PEP2
+      if ( (NbPoints==2)&&(Abs(PEP1.U()-PEP2.U())<MyConfusionPrecision)
+         &&(Abs(PEP1.V()-PEP2.V())<MyConfusionPrecision) ) NbPoints=1;
+      if (NbPoints==2) {
+        SP2.SetXYZ(PEP2.X(),PEP2.Y(),PEP2.Z());
         if (TriSurfID==1) {
-          SP1.SetUV2(PI.U(),PI.V());
-          SP1.SetUV1(PT1.U()+Cote12.U()*alpha+Cote23.U()*beta, PT1.V()+Cote12.V()*alpha+Cote23.V()*beta);
-          NbPoints++;
-          if (beta<MyConfusionPrecision) {//beta==0 && alpha
-            SP1.SetEdge1(1);
-            SP1.SetLambda1(alpha);
-          }
-          if (Abs(beta-alpha)<MyConfusionPrecision) {//beta==alpha  
-            SP1.SetEdge1(3);
-            SP1.SetLambda1(1.0-alpha);
-          }
-          if (Abs(alpha-1)<MyConfusionPrecision)//alpha==1
-            SP1.SetEdge1(2);
-          if (alpha<MyConfusionPrecision) {//alpha=0 --> beta==0
-            SP1.SetXYZ(PT1.X(),PT1.Y(),PT1.Z());
-            SP1.SetUV1(PT1.U(),PT1.V());
-            SP1.SetEdge1(0);
-          }
-          if ( (beta<MyConfusionPrecision)&&(Abs(1-alpha)<MyConfusionPrecision) ) {//beta==0 alpha==1
-            SP1.SetXYZ(PT2.X(),PT2.Y(),PT2.Z());
-            SP1.SetUV1(PT2.U(),PT2.V());
-            SP1.SetEdge1(0);
-          }
-          if ( (Abs(beta-1)<MyConfusionPrecision)||(Abs(1-alpha)<MyConfusionPrecision) ) {//beta==1 alpha==1
-            SP1.SetXYZ(PT3.X(),PT3.Y(),PT3.Z());
-            SP1.SetUV1(PT3.U(),PT3.V());
-            SP1.SetEdge1(0);
-          }
-        }
-        else if(TriSurfID==2) {
-          SP1.SetUV1(PI.U(),PI.V());
-          SP1.SetUV2(PT1.U()+Cote12.U()*alpha+Cote23.U()*beta, PT1.V()+Cote12.V()*alpha+Cote23.V()*beta);
-          NbPoints++;
-          if (beta<MyConfusionPrecision) { //beta==0
-            SP1.SetEdge2(1);
-          }
-          if (Abs(beta-alpha)<MyConfusionPrecision)//beta==alpha
-            SP1.SetEdge2(3);
-          if (Abs(alpha-1)<MyConfusionPrecision)//alpha==1
-            SP1.SetEdge2(2);        
-          if (alpha<MyConfusionPrecision) {//alpha=0 --> beta==0
-            SP1.SetXYZ(PT1.X(),PT1.Y(),PT1.Z());
-            SP1.SetUV2(PT1.U(),PT1.V());
-            SP1.SetEdge2(0);
-          }
-          if ( (beta<MyConfusionPrecision)&&(Abs(1-alpha)<MyConfusionPrecision) ) {//beta==0 alpha==1
-            SP1.SetXYZ(PT2.X(),PT2.Y(),PT2.Z());
-            SP1.SetUV2(PT2.U(),PT2.V());
-            SP1.SetEdge2(0);
-          }
-          if ( (Abs(beta-1)<MyConfusionPrecision)||(Abs(1-alpha)<MyConfusionPrecision) ) {//beta==1 alpha==1
-            SP1.SetXYZ(PT3.X(),PT3.Y(),PT3.Z());
-            SP1.SetUV2(PT3.U(),PT3.V());
-            SP1.SetEdge2(0);
-          }
-        }
-        else{ 
+          SP2.SetUV1(PTP2.U(),PTP2.V());          
+          SP2.SetUV2(PEP2.U(),PEP2.V());
+          SP2.SetEdge1(Tri1.GetEdgeNumber(CoteIndex));
 
+          if(Tri1.GetEdgeOrientation(CoteIndex)>0) SP2.SetLambda1(alpha1);
+          else SP2.SetLambda1(1.0-alpha1);
+          
+          if(Tri2.GetEdgeOrientation(EdgeIndex)>0) SP2.SetLambda2(lambda1);
+          else SP2.SetLambda2(1.0-lambda1);
         }
+        if (TriSurfID==2) {
+          SP2.SetUV1(PEP2.U(),PTP2.V());          
+          SP2.SetUV2(PTP2.U(),PEP2.V());
+          SP2.SetEdge2(Tri2.GetEdgeNumber(CoteIndex));
+
+          if(Tri1.GetEdgeOrientation(CoteIndex)>0) SP2.SetLambda1(alpha1);
+          else SP2.SetLambda1(1.0-alpha1);
+          
+          if(Tri2.GetEdgeOrientation(EdgeIndex)>0) SP2.SetLambda2(lambda1);
+          else SP2.SetLambda2(1.0-lambda1);
+        } 
       }
     }
-    else return 0;
   }
-  return (NbPoints);
+  //Filter if the point is placed on top, the edge is set  to -1
+  if (NbPoints>0) {
+    if(Abs(SP1.Lambda1())<MyConfusionPrecision)
+      SP1.SetEdge1(-1);
+    if(Abs(SP1.Lambda1()-1)<MyConfusionPrecision)
+      SP1.SetEdge1(-1);
+    if(Abs(SP1.Lambda2())<MyConfusionPrecision)
+      SP1.SetEdge2(-1);
+    if(Abs(SP1.Lambda2()-1)<MyConfusionPrecision)
+      SP1.SetEdge2(-1);
+  }
+  if (NbPoints==2) {
+    if(Abs(SP2.Lambda1())<MyConfusionPrecision)
+      SP2.SetEdge1(-1);
+    if(Abs(SP2.Lambda1()-1)<MyConfusionPrecision)
+      SP2.SetEdge1(-1);
+    if(Abs(SP2.Lambda2())<MyConfusionPrecision)
+      SP2.SetEdge2(-1);
+    if(Abs(SP2.Lambda2()-1)<MyConfusionPrecision)
+      SP2.SetEdge2(-1);
+  }
 }
 
 //=======================================================================
-//function : TriangleEdgeContact2
+//function : TriangleEdgeContact
 //purpose  : 
 //=======================================================================
-Standard_Integer IntPolyh_MaillageAffinage::TriangleEdgeContact2
+Standard_Integer IntPolyh_MaillageAffinage::TriangleEdgeContact
   (const Standard_Integer TriSurfID,
    const Standard_Integer EdgeIndex,
    const IntPolyh_Triangle &Tri1,
@@ -2862,15 +2080,15 @@ Standard_Integer IntPolyh_MaillageAffinage::TriangleEdgeContact2
           //there are two sides (common top PT1) that can cut the edge
           
           //first side
-          CalculPtsInterTriEdgeCoplanaires2(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
-                                            PT1,PT2,Cote12,1,SP1,SP2,NbPoints);
+          CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
+                                           PT1,PT2,Cote12,1,SP1,SP2,NbPoints);
           
           if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
               &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
           
           //second side
-          if (NbPoints<2) CalculPtsInterTriEdgeCoplanaires2(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
-                                                            PT3,PT1,Cote31,3,SP1,SP2,NbPoints);
+          if (NbPoints<2) CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
+                                                           PT3,PT1,Cote31,3,SP1,SP2,NbPoints);
         }
         
         if ( (NbPoints>1)&&(Abs(SP1.U1()-SP2.U1())<MyConfusionPrecision)
@@ -2882,15 +2100,15 @@ Standard_Integer IntPolyh_MaillageAffinage::TriangleEdgeContact2
           //there are two sides (common top PT2) that can cut the edge
           
           //first side
-          CalculPtsInterTriEdgeCoplanaires2(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
-                                            PT1,PT2,Cote12,1,SP1,SP2,NbPoints);
+          CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
+                                           PT1,PT2,Cote12,1,SP1,SP2,NbPoints);
           
           if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
               &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
           
           //second side
-          if(NbPoints<2) CalculPtsInterTriEdgeCoplanaires2(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
-                                                           PT2,PT3,Cote23,2,SP1,SP2,NbPoints);
+          if(NbPoints<2) CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
+                                                          PT2,PT3,Cote23,2,SP1,SP2,NbPoints);
         }
         if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
             &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
@@ -2901,15 +2119,15 @@ Standard_Integer IntPolyh_MaillageAffinage::TriangleEdgeContact2
           //there are two sides (common top PT3) that can cut the edge
           
           //first side
-          CalculPtsInterTriEdgeCoplanaires2(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
-                                            PT3,PT1,Cote31,3,SP1,SP2,NbPoints);
+          CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
+                                           PT3,PT1,Cote31,3,SP1,SP2,NbPoints);
           
           if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
               &&(Abs(SP1.V1()-SP2.V1())<MyConfusionPrecision) ) NbPoints=1;
           
           //second side
-          if (NbPoints<2) CalculPtsInterTriEdgeCoplanaires2(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
-                                                            PT2,PT3,Cote23,2,SP1,SP2,NbPoints);
+          if (NbPoints<2) CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT,Tri1,Tri2,PE1,PE2,Edge,EdgeIndex,
+                                                           PT2,PT3,Cote23,2,SP1,SP2,NbPoints);
         }
         if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())<MyConfusionPrecision)
             &&(Abs(SP2.V1()-SP1.V1())<MyConfusionPrecision) ) NbPoints=1;
@@ -3121,92 +2339,6 @@ Standard_Integer IntPolyh_MaillageAffinage::TriangleEdgeContact2
   return (NbPoints);
 }
 //=======================================================================
-//function : TriangleComparePSP
-//purpose  : The   same as   TriangleCompare, plus compute the
-//           StartPoints without chaining them.
-//=======================================================================
-Standard_Integer IntPolyh_MaillageAffinage::TriangleComparePSP () 
-{
-  Standard_Integer CpteurTab=0;
-  Standard_Integer CpteurTabSP=0;
-  Standard_Real CoupleAngle=-2.0;
-  const Standard_Integer FinTT1 = TTriangles1.NbItems();
-  const Standard_Integer FinTT2 = TTriangles2.NbItems();
-
-  for(Standard_Integer i_S1=0; i_S1<FinTT1; i_S1++) {
-    IntPolyh_Triangle &Triangle1 =  TTriangles1[i_S1];
-    if ((Triangle1.IndiceIntersectionPossible() == 0) ||
-        (Triangle1.GetFleche() < 0.))
-      continue;
-    for(Standard_Integer i_S2=0; i_S2<FinTT2; i_S2++){
-      IntPolyh_Triangle &Triangle2 =  TTriangles2[i_S2];
-      if ((Triangle2.IndiceIntersectionPossible() != 0) && 
-          (Triangle2.GetFleche() >= 0.)) {
-        IntPolyh_StartPoint SP1, SP2;
-        //If a triangle is dead or not in BSB, comparison is not possible
-        //
-        Standard_Integer iDeg1, iDeg2, iDeg3, iDeg;
-        //
-        const IntPolyh_Point& P1=TPoints1[Triangle1.FirstPoint()];
-        const IntPolyh_Point& P2=TPoints1[Triangle1.SecondPoint()];
-        const IntPolyh_Point& P3=TPoints1[Triangle1.ThirdPoint()];
-        iDeg1=(P1.Degenerated()) ? 1 : 0;
-        iDeg2=(P2.Degenerated()) ? 1 : 0;
-        iDeg3=(P3.Degenerated()) ? 1 : 0;
-        iDeg=iDeg1+iDeg2+iDeg3;
-        if (iDeg>1) {
-          continue;
-        }
-        //
-        const IntPolyh_Point& Q1=TPoints2[Triangle2.FirstPoint()];
-        const IntPolyh_Point& Q2=TPoints2[Triangle2.SecondPoint()];
-        const IntPolyh_Point& Q3=TPoints2[Triangle2.ThirdPoint()];
-        iDeg1=(Q1.Degenerated()) ? 1 : 0;
-        iDeg2=(Q2.Degenerated()) ? 1 : 0;
-        iDeg3=(Q3.Degenerated()) ? 1 : 0;
-        iDeg=iDeg1+iDeg2+iDeg3;
-        if (iDeg>1) {
-          continue;
-        }
-        //
-        if (TriContact(P1, P2, P3, Q1, Q2, Q3, CoupleAngle)) {
-          Triangle1.SetIndiceIntersection(1);//The triangle is cut by another
-          Triangle2.SetIndiceIntersection(1);
-          
-          Standard_Integer NbPoints;
-          NbPoints=StartingPointsResearch(i_S1,i_S2,SP1, SP2);
-          
-          if (NbPoints==0) {
-            
-          }
-          
-          if ( (NbPoints>0)&&(NbPoints<3) ) {
-            SP1.SetCoupleValue(i_S1,i_S2);
-            TStartPoints[CpteurTabSP]=SP1;
-            CpteurTabSP++;
-            
-            
-          }
-          
-          if(NbPoints==2) {           
-            SP2.SetCoupleValue(i_S1,i_S2);
-            TStartPoints[CpteurTabSP]=SP2;
-            CpteurTabSP++;
-            
-            
-          }
-          
-          if(NbPoints>2) {
-            
-          }
-          CpteurTab++;
-        }
-      }
-    }
-  }
-  return(CpteurTabSP);
-}
-//=======================================================================
 //function : TriangleCompare
 //purpose  : Analyze  each couple of  triangles from the two --
 //           array  of triangles,  to   see  if they are  in
@@ -3215,167 +2347,121 @@ Standard_Integer IntPolyh_MaillageAffinage::TriangleComparePSP ()
 //=======================================================================
 Standard_Integer IntPolyh_MaillageAffinage::TriangleCompare ()
 {
-  Standard_Integer CpteurTab=0;
-
-  const Standard_Integer FinTT1 = TTriangles1.NbItems();
-  const Standard_Integer FinTT2 = TTriangles2.NbItems();
-
-  Standard_Integer TTClimit = 200;
-  Standard_Integer NbTTC = FinTT1 * FinTT2 / 10;
-  if (NbTTC < TTClimit)
-    NbTTC = TTClimit;
-  TTrianglesContacts.Init(NbTTC);
-  // eap
-  //TTrianglesContacts.Init(FinTT1 * FinTT2 / 10);
-
-  Standard_Real CoupleAngle=-2.0;
-  for(Standard_Integer i_S1=0; i_S1<FinTT1; i_S1++) {
+  // Find couples with interfering bounding boxes
+  IntPolyh_IndexedDataMapOfIntegerArrayOfInteger aDMILI;
+  GetInterferingTriangles(TTriangles1, TPoints1,
+                          TTriangles2, TPoints2,
+                          aDMILI);
+  if (aDMILI.IsEmpty()) {
+    return 0;
+  }
+  //
+  Standard_Real CoupleAngle = -2.0;
+  //
+  // Intersection of the triangles
+  Standard_Integer i, aNb = aDMILI.Extent();
+  for (i = 1; i <= aNb; ++i) {
+    const Standard_Integer i_S1 = aDMILI.FindKey(i);
     IntPolyh_Triangle &Triangle1 =  TTriangles1[i_S1];
-    if ((Triangle1.IndiceIntersectionPossible() == 0) || 
-        (Triangle1.GetFleche() < 0.))
-      continue;
-    for(Standard_Integer i_S2=0; i_S2<FinTT2; i_S2++){
+    const IntPolyh_Point& P1 = TPoints1[Triangle1.FirstPoint()];
+    const IntPolyh_Point& P2 = TPoints1[Triangle1.SecondPoint()];
+    const IntPolyh_Point& P3 = TPoints1[Triangle1.ThirdPoint()];
+    //
+    const IntPolyh_ArrayOfInteger& aLI2 = aDMILI(i);
+    IntPolyh_ArrayOfInteger::Iterator aItLI(aLI2);
+    for (; aItLI.More(); aItLI.Next()) {
+      const Standard_Integer i_S2 = aItLI.Value();
       IntPolyh_Triangle &Triangle2 =  TTriangles2[i_S2];
-      if ((Triangle2.IndiceIntersectionPossible() != 0) && 
-          (Triangle2.GetFleche() >= 0.)) {
-        //If a triangle is dead or not in BSB, comparison is not possible
-        Standard_Integer iDeg1, iDeg2, iDeg3, iDeg;
-        //
-        const IntPolyh_Point& P1=TPoints1[Triangle1.FirstPoint()];
-        const IntPolyh_Point& P2=TPoints1[Triangle1.SecondPoint()];
-        const IntPolyh_Point& P3=TPoints1[Triangle1.ThirdPoint()];
-        iDeg1=(P1.Degenerated()) ? 1 : 0;
-        iDeg2=(P2.Degenerated()) ? 1 : 0;
-        iDeg3=(P3.Degenerated()) ? 1 : 0;
-        iDeg=iDeg1+iDeg2+iDeg3;
-        if (iDeg>1) {
-          continue;
-        }
-        //
-        const IntPolyh_Point& Q1=TPoints2[Triangle2.FirstPoint()];
-        const IntPolyh_Point& Q2=TPoints2[Triangle2.SecondPoint()];
-        const IntPolyh_Point& Q3=TPoints2[Triangle2.ThirdPoint()];
-        iDeg1=(Q1.Degenerated()) ? 1 : 0;
-        iDeg2=(Q2.Degenerated()) ? 1 : 0;
-        iDeg3=(Q3.Degenerated()) ? 1 : 0;
-        iDeg=iDeg1+iDeg2+iDeg3;
-        if (iDeg>1) {
-          continue;
-        }
+      const IntPolyh_Point& Q1 = TPoints2[Triangle2.FirstPoint()];
+      const IntPolyh_Point& Q2 = TPoints2[Triangle2.SecondPoint()];
+      const IntPolyh_Point& Q3 = TPoints2[Triangle2.ThirdPoint()];
+      //
+      if (TriContact(P1, P2, P3, Q1, Q2, Q3, CoupleAngle)) {
+        IntPolyh_Couple aCouple(i_S1, i_S2, CoupleAngle);
+        TTrianglesContacts.Append(aCouple);
         //
-        if (TriContact(P1, P2, P3, Q1, Q2, Q3, CoupleAngle)) {
-          if (CpteurTab >= NbTTC)
-          {
-            TTrianglesContacts.SetNbItems(CpteurTab);
-            return(CpteurTab);
-          }
-          TTrianglesContacts[CpteurTab].SetCoupleValue(i_S1, i_S2);
-          TTrianglesContacts[CpteurTab].SetAngleValue(CoupleAngle);
-          //test  TTrianglesContacts[CpteurTab].Dump(CpteurTab);
-          
-          Triangle1.SetIndiceIntersection(1);//The triangle is cut by another
-          Triangle2.SetIndiceIntersection(1);
-          CpteurTab++;
-        }
+        Triangle1.SetIntersection(Standard_True);
+        Triangle2.SetIntersection(Standard_True);
       }
     }
   }
-  TTrianglesContacts.SetNbItems(CpteurTab);
-
-  return(CpteurTab);
+  return TTrianglesContacts.Extent();
 }
 
 //=======================================================================
-//function : StartPointsCalcul
-//purpose  : From the array  of couples compute  all the start
-//           points and display them on the screen
-//=======================================================================
-void IntPolyh_MaillageAffinage::StartPointsCalcul() const
-{
-  const Standard_Integer FinTTC = TTrianglesContacts.NbItems();
-//   printf("StartPointsCalcul() from IntPolyh_MaillageAffinage.cxx : StartPoints:\n");
-  for(Standard_Integer ii=0; ii<FinTTC; ii++) {
-    IntPolyh_StartPoint SP1,SP2;
-    Standard_Integer T1,T2;
-    T1=TTrianglesContacts[ii].FirstValue();
-    T2=TTrianglesContacts[ii].SecondValue();
-    StartingPointsResearch(T1,T2,SP1,SP2);
-    if ( (SP1.E1()!=-1)&&(SP1.E2()!=-1) ) SP1.Dump(ii);
-    if ( (SP2.E1()!=-1)&&(SP2.E2()!=-1) ) SP2.Dump(ii);
-  }
-}
-//=======================================================================
 //function : CheckCoupleAndGetAngle
 //purpose  : 
 //=======================================================================
-Standard_Integer CheckCoupleAndGetAngle(const Standard_Integer T1, 
+Standard_Boolean CheckCoupleAndGetAngle(const Standard_Integer T1, 
                                         const Standard_Integer T2,
                                         Standard_Real& Angle, 
-                                        IntPolyh_ArrayOfCouples &TTrianglesContacts) 
+                                        IntPolyh_ListOfCouples &TTrianglesContacts) 
 {
-  Standard_Integer Test=0;
-  const Standard_Integer FinTTC = TTrianglesContacts.NbItems();
-  for (Standard_Integer oioi=0; oioi<FinTTC; oioi++) {
-    IntPolyh_Couple TestCouple = TTrianglesContacts[oioi];
-    if ( (TestCouple.FirstValue()==T1)&&(TestCouple.AnalyseFlagValue()!=1) ) {
-      if (TestCouple.SecondValue()==T2) {
-        Test=oioi;
-        TTrianglesContacts[oioi].SetAnalyseFlag(1);
-        Angle=TTrianglesContacts[oioi].AngleValue();
-        oioi=FinTTC;
+  IntPolyh_ListIteratorOfListOfCouples aIt(TTrianglesContacts);
+  for (; aIt.More(); aIt.Next()) {
+    IntPolyh_Couple& TestCouple = aIt.ChangeValue();
+    if (!TestCouple.IsAnalyzed()) {
+      if (TestCouple.FirstValue() == T1 && TestCouple.SecondValue() == T2) {
+        TestCouple.SetAnalyzed(Standard_True);
+        Angle = TestCouple.Angle();
+        return Standard_True;
       }
     }
   }
-  return(Test);
+  return Standard_False;
 }
 //=======================================================================
 //function : CheckCoupleAndGetAngle2
 //purpose  : 
 //=======================================================================
-Standard_Integer CheckCoupleAndGetAngle2(const Standard_Integer T1,
+Standard_Boolean CheckCoupleAndGetAngle2(const Standard_Integer T1,
                                          const Standard_Integer T2,
-                                         const Standard_Integer T11, 
+                                         const Standard_Integer T11,
                                          const Standard_Integer T22,
-                                         Standard_Integer &CT11,
-                                         Standard_Integer &CT22, 
+                                         IntPolyh_ListIteratorOfListOfCouples& theItCT11,
+                                         IntPolyh_ListIteratorOfListOfCouples& theItCT22,
                                          Standard_Real & Angle,
-                                         IntPolyh_ArrayOfCouples &TTrianglesContacts) 
+                                         IntPolyh_ListOfCouples &TTrianglesContacts) 
 {
   ///couple T1 T2 is found in the list
   ///T11 and T22 are two other triangles implied  in the contact edge edge
   /// CT11 couple( T1,T22) and CT22 couple (T2,T11)
   /// these couples will be marked if there is a start point
-  Standard_Integer Test1=0;
-  Standard_Integer Test2=0;
-  Standard_Integer Test3=0;
-  const Standard_Integer FinTTC = TTrianglesContacts.NbItems();
-  for (Standard_Integer oioi=0; oioi<FinTTC; oioi++) {
-    IntPolyh_Couple TestCouple = TTrianglesContacts[oioi];
-    if( (Test1==0)||(Test2==0)||(Test3==0) ) {
-      if ( (TestCouple.FirstValue()==T1)&&(TestCouple.AnalyseFlagValue()!=1) ) {
-        if (TestCouple.SecondValue()==T2) {
-          Test1=1;
-          TTrianglesContacts[oioi].SetAnalyseFlag(1);
-          Angle=TTrianglesContacts[oioi].AngleValue();
-        }
-        else if (TestCouple.SecondValue()==T22) {
-          Test2=1;
-          CT11=oioi;
-          Angle=TTrianglesContacts[oioi].AngleValue();
-        }
+  Standard_Boolean Test1 , Test2, Test3;
+  Test1 = Test2 = Test3 = Standard_False;
+  //
+  IntPolyh_ListIteratorOfListOfCouples aIt(TTrianglesContacts);
+  for (; aIt.More(); aIt.Next()) {
+    IntPolyh_Couple& TestCouple = aIt.ChangeValue();
+    if (TestCouple.IsAnalyzed()) {
+      continue;
+    }
+    //
+    if (TestCouple.FirstValue() == T1) {
+      if (TestCouple.SecondValue() == T2) {
+        Test1 = Standard_True;
+        TestCouple.SetAnalyzed(Standard_True);
+        Angle = TestCouple.Angle();
       }
-      else if( (TestCouple.FirstValue()==T11)&&(TestCouple.AnalyseFlagValue()!=1) ) {
-        if (TestCouple.SecondValue()==T2) {
-          Test3=1;
-          CT22=oioi;
-          Angle=TTrianglesContacts[oioi].AngleValue();
-        }
+      else if (TestCouple.SecondValue() == T22) {
+        Test2 = Standard_True;
+        theItCT11 = aIt;
+        Angle = TestCouple.Angle();
+      }
+    }
+    else if (TestCouple.FirstValue() == T11) {
+      if (TestCouple.SecondValue() == T2) {
+        Test3 = Standard_True;
+        theItCT22 = aIt;
+        Angle = TestCouple.Angle();
       }
     }
-    else
-      oioi=FinTTC;
+    //
+    if (Test1 && Test2 && Test3) {
+      break;
+    }
   }
-  return(Test1);
+  return Test1;
 }
 //=======================================================================
 //function : CheckNextStartPoint
@@ -3435,14 +2521,12 @@ Standard_Integer IntPolyh_MaillageAffinage::StartPointsChain
   (IntPolyh_ArrayOfSectionLines& TSectionLines,
    IntPolyh_ArrayOfTangentZones& TTangentZones) 
 {
-//Loop on the array of couples filled in the function COMPARE()
-  const Standard_Integer FinTTC = TTrianglesContacts.NbItems();
-
-//Array of tops of triangles
-  for(Standard_Integer IndexA=0; IndexA<FinTTC; IndexA++) {
-    //First couple of triangles.
-    //It is checked if the couple of triangles has not been already examined.
-    if(TTrianglesContacts[IndexA].AnalyseFlagValue()!=1) {
+  //Loop on the array of couples filled in the function COMPARE()
+  IntPolyh_ListIteratorOfListOfCouples aIt(TTrianglesContacts);
+  for (; aIt.More(); aIt.Next()) {
+    IntPolyh_Couple& aCouple = aIt.ChangeValue();
+    // Check if the couple of triangles has not been already examined.
+    if(!aCouple.IsAnalyzed()) {
 
       Standard_Integer SectionLineIndex=TSectionLines.NbItems();
       // fill last section line if still empty (eap)
@@ -3459,18 +2543,18 @@ Standard_Integer IntPolyh_MaillageAffinage::StartPointsChain
 
       Standard_Integer NbPoints=-1;
       Standard_Integer T1I, T2I;
-      T1I = TTrianglesContacts[IndexA].FirstValue();
-      T2I = TTrianglesContacts[IndexA].SecondValue();
+      T1I = aCouple.FirstValue();
+      T2I = aCouple.SecondValue();
       
       // Start points for the current couple are found
       IntPolyh_StartPoint SP1, SP2;
-      NbPoints=StartingPointsResearch2(T1I,T2I,SP1, SP2);//first calculation
-      TTrianglesContacts[IndexA].SetAnalyseFlag(1);//the couple is marked
+      NbPoints=StartingPointsResearch(T1I,T2I,SP1, SP2);//first calculation
+      aCouple.SetAnalyzed(Standard_True);//the couple is marked
 
       if(NbPoints==1) {// particular case top/triangle or edge/edge
         //the start point is input in the array
         SP1.SetChainList(SectionLineIndex);
-        SP1.SetAngle(TTrianglesContacts[IndexA].AngleValue());
+        SP1.SetAngle(aCouple.Angle());
         //it is checked if the point is not atop of the triangle
         if(CheckNextStartPoint(MySectionLine,TTangentZones,SP1)) {
           IntPolyh_StartPoint SPNext1;
@@ -3487,7 +2571,7 @@ Standard_Integer IntPolyh_MaillageAffinage::StartPointsChain
             if (CheckCoupleAndGetAngle(NextTriangle1,T2I,Angle,TTrianglesContacts)) {
               //it is checked if the couple exists and is marked
               Standard_Integer NbPoints11=0;
-              NbPoints11=NextStartingPointsResearch2(NextTriangle1,T2I,SP1,SP11);
+              NbPoints11=NextStartingPointsResearch(NextTriangle1,T2I,SP1,SP11);
               if (NbPoints11==1) {
                 SP11.SetChainList(SectionLineIndex);
                 SP11.SetAngle(Angle);
@@ -3531,7 +2615,7 @@ Standard_Integer IntPolyh_MaillageAffinage::StartPointsChain
             Standard_Real Angle=-2.0;
             if(CheckCoupleAndGetAngle(T1I,NextTriangle2,Angle,TTrianglesContacts)) {
               Standard_Integer NbPoints12=0;
-              NbPoints12=NextStartingPointsResearch2(T1I,NextTriangle2,SP1, SP12);
+              NbPoints12=NextStartingPointsResearch(T1I,NextTriangle2,SP1, SP12);
               if (NbPoints12==1) {
                 
                 SP12.SetChainList(SectionLineIndex);
@@ -3578,7 +2662,7 @@ Standard_Integer IntPolyh_MaillageAffinage::StartPointsChain
         Standard_Integer EndChainList=1;
 
         SP1.SetChainList(SectionLineIndex);
-        SP1.SetAngle(TTrianglesContacts[IndexA].AngleValue());
+        SP1.SetAngle(aCouple.Angle());
         if(CheckNextStartPoint(MySectionLine,TTangentZones,SP1)) {
 
           //chain of a side
@@ -3595,7 +2679,7 @@ Standard_Integer IntPolyh_MaillageAffinage::StartPointsChain
         }
         
         SP2.SetChainList(SectionLineIndex);
-        SP2.SetAngle(TTrianglesContacts[IndexA].AngleValue());
+        SP2.SetAngle(aCouple.Angle());
         Standard_Boolean Prepend = Standard_True; // eap
 
         if(CheckNextStartPoint(MySectionLine,TTangentZones,SP2,Prepend)) {
@@ -3655,7 +2739,7 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint
     //If is checked if two triangles intersect
     Standard_Real Angle= -2.0;
     if (CheckCoupleAndGetAngle(NextTriangle1,SP.T2(),Angle,TTrianglesContacts)) {
-      NbPoints=NextStartingPointsResearch2(NextTriangle1,SP.T2(),SP,SPNext);
+      NbPoints=NextStartingPointsResearch(NextTriangle1,SP.T2(),SP,SPNext);
       if( NbPoints!=1 ) {
         if (NbPoints>1)
           CheckNextStartPoint(MySectionLine,TTangentZones,SPNext,Prepend);
@@ -3677,7 +2761,7 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint
       NextTriangle2=TEdges2[SP.E2()].SecondTriangle();
     Standard_Real Angle= -2.0;
     if (CheckCoupleAndGetAngle(SP.T1(),NextTriangle2,Angle,TTrianglesContacts)) {
-      NbPoints=NextStartingPointsResearch2(SP.T1(),NextTriangle2,SP,SPNext);
+      NbPoints=NextStartingPointsResearch(SP.T1(),NextTriangle2,SP,SPNext);
       if( NbPoints!=1 ) {
         if (NbPoints>1)
           CheckNextStartPoint(MySectionLine,TTangentZones,SPNext,Prepend);
@@ -3699,8 +2783,6 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint
   else if( (SP.E1()>=0)&&(SP.E2()>=0) ) {
     ///the point is located on two edges
       Standard_Integer NextTriangle1;
-      Standard_Integer CpleT11=-1;
-      Standard_Integer CpleT22=-1;
       if (TEdges1[SP.E1()].FirstTriangle()!=SP.T1()) NextTriangle1=TEdges1[SP.E1()].FirstTriangle();
       else 
         NextTriangle1=TEdges1[SP.E1()].SecondTriangle();
@@ -3709,10 +2791,12 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint
       else 
         NextTriangle2=TEdges2[SP.E2()].SecondTriangle();
       Standard_Real Angle= -2.0;
+
+      IntPolyh_ListIteratorOfListOfCouples aItCT11, aItCT22;
       if (CheckCoupleAndGetAngle2(NextTriangle1,NextTriangle2,
-                                  SP.T1(),SP.T2(),CpleT11,CpleT22,
+                                  SP.T1(),SP.T2(), aItCT11, aItCT22,
                                   Angle,TTrianglesContacts)) {
-        NbPoints=NextStartingPointsResearch2(NextTriangle1,NextTriangle2,SP,SPNext);
+        NbPoints=NextStartingPointsResearch(NextTriangle1,NextTriangle2,SP,SPNext);
         if( NbPoints!=1 ) {
           if (NbPoints>1) {
             ///The new point is checked
@@ -3725,16 +2809,9 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint
           NbPoints=0;
         }
         else {//NbPoints==1
-          SPNext.SetAngle(Angle);     
-          //The couples (Ti,Tj) (Ti',Tj') are marked
-          if (CpleT11>=0) TTrianglesContacts[CpleT11].SetAnalyseFlag(1);
-          else {
-
-          }
-          if (CpleT22>=0) TTrianglesContacts[CpleT22].SetAnalyseFlag(1);
-          else {
-
-          }
+          SPNext.SetAngle(Angle);
+          if (aItCT11.More()) aItCT11.ChangeValue().SetAnalyzed(Standard_True);
+          if (aItCT22.More()) aItCT22.ChangeValue().SetAnalyzed(Standard_True);
         }
       }
       else NbPoints=0;
@@ -3789,26 +2866,11 @@ Bnd_Box IntPolyh_MaillageAffinage::GetBox(const Standard_Integer SurfID) const
   return(MyBox1);
   return(MyBox2);
 }
-
-//=======================================================================
-//function : GetBoxDraw
-//purpose  : 
-//=======================================================================
-void IntPolyh_MaillageAffinage::GetBoxDraw(const Standard_Integer SurfID)const
-{
-Standard_Real x0,y0,z0,x1,y1,z1;
-  if (SurfID==1) {
-    MyBox1.Get(x0,y0,z0,x1,y1,z1);
-  }
-  else {
-    MyBox2.Get(x0,y0,z0,x1,y1,z1);
-  }
-}
 //=======================================================================
 //function : GetArrayOfCouples
 //purpose  : 
 //=======================================================================
-IntPolyh_ArrayOfCouples &IntPolyh_MaillageAffinage::GetArrayOfCouples()
+IntPolyh_ListOfCouples &IntPolyh_MaillageAffinage::GetCouples()
 {
   return TTrianglesContacts;
 }
index 6ba2433..693b581 100644 (file)
@@ -27,8 +27,7 @@
 #include <IntPolyh_ArrayOfPoints.hxx>
 #include <IntPolyh_ArrayOfEdges.hxx>
 #include <IntPolyh_ArrayOfTriangles.hxx>
-#include <IntPolyh_ArrayOfCouples.hxx>
-#include <IntPolyh_ArrayOfStartPoints.hxx>
+#include <IntPolyh_ListOfCouples.hxx>
 #include <Standard_Boolean.hxx>
 #include <TColStd_Array1OfReal.hxx>
 #include <IntPolyh_ArrayOfSectionLines.hxx>
@@ -92,10 +91,6 @@ public:
   //! CommonBox function.
   Standard_EXPORT void FillArrayOfTriangles (const Standard_Integer SurfID);
   
-  //! fill the  edge fields in  Triangle object  for the
-  //! two array of triangles.
-  Standard_EXPORT void LinkEdges2Triangles();
-  
   //! Refine systematicaly all marked triangles of both surfaces
   Standard_EXPORT void CommonPartRefinement();
   
@@ -118,23 +113,17 @@ public:
   //! if no.
   Standard_EXPORT Standard_Integer TriContact (const IntPolyh_Point& P1, const IntPolyh_Point& P2, const IntPolyh_Point& P3, const IntPolyh_Point& Q1, const IntPolyh_Point& Q2, const IntPolyh_Point& Q3, Standard_Real& Angle) const;
   
-  Standard_EXPORT Standard_Integer TriangleEdgeContact (const Standard_Integer TriSurfID, const Standard_Integer EdgeIndice, const IntPolyh_Point& P1, const IntPolyh_Point& P2, const IntPolyh_Point& P3, const IntPolyh_Point& C1, const IntPolyh_Point& C2, const IntPolyh_Point& C3, const IntPolyh_Point& Pe1, const IntPolyh_Point& Pe2, const IntPolyh_Point& E, const IntPolyh_Point& N, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const;
-  
-  Standard_EXPORT Standard_Integer TriangleEdgeContact2 (const Standard_Integer TriSurfID, const Standard_Integer EdgeIndice, const IntPolyh_Triangle& Tri1, const IntPolyh_Triangle& Tri2, const IntPolyh_Point& P1, const IntPolyh_Point& P2, const IntPolyh_Point& P3, const IntPolyh_Point& C1, const IntPolyh_Point& C2, const IntPolyh_Point& C3, const IntPolyh_Point& Pe1, const IntPolyh_Point& Pe2, const IntPolyh_Point& E, const IntPolyh_Point& N, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const;
-  
-  Standard_EXPORT Standard_Integer StartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const;
+  Standard_EXPORT Standard_Integer TriangleEdgeContact (const Standard_Integer TriSurfID, const Standard_Integer EdgeIndice, const IntPolyh_Triangle& Tri1, const IntPolyh_Triangle& Tri2, const IntPolyh_Point& P1, const IntPolyh_Point& P2, const IntPolyh_Point& P3, const IntPolyh_Point& C1, const IntPolyh_Point& C2, const IntPolyh_Point& C3, const IntPolyh_Point& Pe1, const IntPolyh_Point& Pe2, const IntPolyh_Point& E, const IntPolyh_Point& N, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const;
   
   //! From  two  triangles compute intersection  points.
   //! If I found   more  than two intersection  points
   //! that's mean that those triangle are coplanar
-  Standard_EXPORT Standard_Integer StartingPointsResearch2 (const Standard_Integer T1, const Standard_Integer T2, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const;
-  
-  Standard_EXPORT Standard_Integer NextStartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, const IntPolyh_StartPoint& SPInit, IntPolyh_StartPoint& SPNext) const;
+  Standard_EXPORT Standard_Integer StartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const;
   
   //! from  two triangles  and an intersection   point I
   //! seach the other point (if it exist).
   //! This function is used by StartPointChain
-  Standard_EXPORT Standard_Integer NextStartingPointsResearch2 (const Standard_Integer T1, const Standard_Integer T2, const IntPolyh_StartPoint& SPInit, IntPolyh_StartPoint& SPNext) const;
+  Standard_EXPORT Standard_Integer NextStartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, const IntPolyh_StartPoint& SPInit, IntPolyh_StartPoint& SPNext) const;
   
   //! Analyse  each couple of  triangles from the two --
   //! array  of triangles,  to   see  if they are  in
@@ -142,14 +131,6 @@ public:
   //! couples  in contact  in  the  array  of  couples
   Standard_EXPORT Standard_Integer TriangleCompare();
   
-  //! The   same as   TriangleCompare, plus compute the
-  //! StartPoints without chaining them.
-  Standard_EXPORT Standard_Integer TriangleComparePSP();
-  
-  //! From the array  of couples compute  all the start
-  //! points and display them on the screen
-  Standard_EXPORT void StartPointsCalcul() const;
-  
   //! Loop on the array of couples. Compute StartPoints.
   //! Try to chain  the StartPoints into SectionLines or
   //! put  the  point  in  the    ArrayOfTangentZones if
@@ -172,12 +153,8 @@ public:
   
   Standard_EXPORT Bnd_Box GetBox (const Standard_Integer SurfID) const;
   
-  Standard_EXPORT void GetBoxDraw (const Standard_Integer SurfID) const;
-  
-  Standard_EXPORT const IntPolyh_ArrayOfStartPoints& GetArrayOfSP() const;
-  
-  //! This method returns array of couples of contact triangles.
-  Standard_EXPORT IntPolyh_ArrayOfCouples& GetArrayOfCouples();
+  //! This method returns list of couples of contact triangles.
+  Standard_EXPORT IntPolyh_ListOfCouples& GetCouples();
   
   Standard_EXPORT void SetEnlargeZone (Standard_Boolean& EnlargeZone);
   
@@ -190,14 +167,9 @@ public:
   Standard_EXPORT Standard_Real GetMaxDeflection (const Standard_Integer SurfID) const;
 
 
-
-
 protected:
 
 
-
-
-
 private:
 
 
@@ -216,23 +188,21 @@ private:
   Standard_Real FlecheMin2;
   Standard_Real FlecheMoy1;
   Standard_Real FlecheMoy2;
+  // For the arrays of Points, Edges and Triangles we need instant access to the items.
+  // Moreover, we might add new items during refinement process in case the deflection
+  // is too big, thus the vectors should be used.
   IntPolyh_ArrayOfPoints TPoints1;
   IntPolyh_ArrayOfPoints TPoints2;
   IntPolyh_ArrayOfEdges TEdges1;
   IntPolyh_ArrayOfEdges TEdges2;
   IntPolyh_ArrayOfTriangles TTriangles1;
   IntPolyh_ArrayOfTriangles TTriangles2;
-  IntPolyh_ArrayOfCouples TTrianglesContacts;
-  IntPolyh_ArrayOfStartPoints TStartPoints;
-  Standard_Boolean myEnlargeZone;
+  // The intersecting triangles are just filled and then
+  // sequentially analyzed, thus we might use the list.
+  IntPolyh_ListOfCouples TTrianglesContacts;
 
+  Standard_Boolean myEnlargeZone;
 
 };
 
-
-
-
-
-
-
 #endif // _IntPolyh_MaillageAffinage_HeaderFile
index 5788a7e..a1ac8a9 100644 (file)
 #include <IntPolyh_Point.hxx>
 
 #include <stdio.h>
-//=======================================================================
-//function : IntPolyh_Point
-//purpose  : 
-//=======================================================================
-IntPolyh_Point::IntPolyh_Point() 
-: 
-  x(0),y(0),z(0),u(0),v(0),POC(1), 
-  myDegenerated(Standard_False) 
-{
-}
-
-//=======================================================================
-//function : IntPolyh_Point
-//purpose  : 
-//=======================================================================
-IntPolyh_Point::IntPolyh_Point(const Standard_Real _x,
-                              const Standard_Real _y,
-                              const Standard_Real _z,
-                              const Standard_Real _u,
-                              const Standard_Real _v)
-:
-  POC(1),
-  myDegenerated(Standard_False) 
-{ 
-  x=_x; y=_y; z=_z; u=_u; v=_v;
-}
-//=======================================================================
-//function : X
-//purpose  : 
-//=======================================================================
-Standard_Real IntPolyh_Point::X() const 
-{ 
-  return x; 
-} 
-//=======================================================================
-//function : Y
-//purpose  : 
-//=======================================================================
-Standard_Real IntPolyh_Point::Y() const 
-{
-  return y;   
-}
-//=======================================================================
-//function : Z
-//purpose  : 
-//=======================================================================
-Standard_Real IntPolyh_Point::Z() const 
-{
-  return z;
- } 
-//=======================================================================
-//function : U
-//purpose  : 
-//=======================================================================
-Standard_Real IntPolyh_Point::U() const 
-{ 
-  return u;
-} 
-//=======================================================================
-//function : V
-//purpose  : 
-//=======================================================================
-Standard_Real IntPolyh_Point::V() const 
-{ 
-  return v; 
-}
-//=======================================================================
-//function : PartOfCommon
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Point::PartOfCommon() const 
-{
-  return POC;
-}
-//=======================================================================
-//function : Set
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::Set(const Standard_Real _x,
-                        const Standard_Real _y,
-                        const Standard_Real _z,
-                        const Standard_Real _u, 
-                        const Standard_Real _v, 
-                        const Standard_Integer II) 
-{ 
-  x=_x; 
-  y=_y; 
-  z=_z; 
-  u=_u; 
-  v=_v; 
-  POC=II;
-}
-//=======================================================================
-//function : Equal
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::Equal(const IntPolyh_Point &Pt) 
-{
-  x = Pt.x;
-  y = Pt.y;
-  z = Pt.z;
-  u = Pt.u;
-  v = Pt.v;
-}
-//=======================================================================
-//function : SetX
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::SetX(const Standard_Real _x) 
-{
-  x=_x;
-} 
-//=======================================================================
-//function : SetY
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::SetY(const Standard_Real _y) 
-{
-  y=_y; 
-} 
-//=======================================================================
-//function : SetZ
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::SetZ(const Standard_Real _z) 
-{
-  z=_z; 
-} 
-//=======================================================================
-//function : SetU
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::SetU(const Standard_Real _u) 
-{
-  u=_u;
-} 
-//=======================================================================
-//function : SetV
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::SetV(const Standard_Real _v) 
-{
-  v=_v;
-} 
-//=======================================================================
-//function : SetPartOfCommon
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::SetPartOfCommon(const Standard_Integer ii) 
-{
-  POC=ii;
-}
-
 
 //=======================================================================
 //function : Middle
@@ -180,14 +27,14 @@ void IntPolyh_Point::SetPartOfCommon(const Standard_Integer ii)
 void IntPolyh_Point::Middle(const Handle(Adaptor3d_HSurface)& MySurface,
                                      const IntPolyh_Point & Point1, 
                                      const IntPolyh_Point & Point2){
-  u = (Point1.U()+Point2.U())*0.5;
-  v = (Point1.V()+Point2.V())*0.5;
+  myU = (Point1.U()+Point2.U())*0.5;
+  myV = (Point1.V()+Point2.V())*0.5;
   
-  gp_Pnt PtXYZ = (MySurface)->Value(u, v);
+  gp_Pnt PtXYZ = (MySurface)->Value(myU, myV);
 
-  x=PtXYZ.X();
-  y=PtXYZ.Y(); 
-  z=PtXYZ.Z();
+  myX=PtXYZ.X();
+  myY=PtXYZ.Y(); 
+  myZ=PtXYZ.Z();
 }
 //=======================================================================
 //function : Add
@@ -197,11 +44,11 @@ IntPolyh_Point IntPolyh_Point::Add(const IntPolyh_Point &P1)const
 {
   IntPolyh_Point res;
   //
-  res.SetX(x+P1.X());
-  res.SetY(y+P1.Y());
-  res.SetZ(z+P1.Z());
-  res.SetU(u+P1.U());
-  res.SetV(v+P1.V());
+  res.SetX(myX+P1.X());
+  res.SetY(myY+P1.Y());
+  res.SetZ(myZ+P1.Z());
+  res.SetU(myU+P1.U());
+  res.SetV(myV+P1.V());
   return res;
 }  
 
@@ -213,11 +60,11 @@ IntPolyh_Point IntPolyh_Point::Sub(const IntPolyh_Point &P1)const
 { 
   IntPolyh_Point res;
   //
-  res.SetX(x-P1.X());
-  res.SetY(y-P1.Y());
-  res.SetZ(z-P1.Z());
-  res.SetU(u-P1.U());
-  res.SetV(v-P1.V());
+  res.SetX(myX-P1.X());
+  res.SetY(myY-P1.Y());
+  res.SetZ(myZ-P1.Z());
+  res.SetU(myU-P1.U());
+  res.SetV(myV-P1.V());
   return res;
 } 
 //=======================================================================
@@ -229,11 +76,11 @@ IntPolyh_Point IntPolyh_Point::Divide(const Standard_Real RR)const
   IntPolyh_Point res;
   //
   if (Abs(RR)>10.0e-20) {
-    res.SetX(x/RR);
-    res.SetY(y/RR);
-    res.SetZ(z/RR);
-    res.SetU(u/RR);
-    res.SetV(v/RR);
+    res.SetX(myX/RR);
+    res.SetY(myY/RR);
+    res.SetZ(myZ/RR);
+    res.SetU(myU/RR);
+    res.SetV(myV/RR);
   }
   else { 
    printf("Division par zero RR=%f\n",RR);
@@ -248,11 +95,11 @@ IntPolyh_Point IntPolyh_Point::Multiplication(const Standard_Real RR)const
 { 
   IntPolyh_Point res;
   //
-  res.SetX(x*RR);
-  res.SetY(y*RR);
-  res.SetZ(z*RR);
-  res.SetU(u*RR);
-  res.SetV(v*RR);
+  res.SetX(myX*RR);
+  res.SetY(myY*RR);
+  res.SetZ(myZ*RR);
+  res.SetU(myU*RR);
+  res.SetV(myV*RR);
   return res;
 }
 //=======================================================================
@@ -261,7 +108,7 @@ IntPolyh_Point IntPolyh_Point::Multiplication(const Standard_Real RR)const
 //=======================================================================
 Standard_Real IntPolyh_Point::SquareModulus()const
 {
-  Standard_Real res=x*x+y*y+z*z;
+  Standard_Real res=myX*myX+myY*myY+myZ*myZ;
   return res;
 }
 
@@ -271,7 +118,7 @@ Standard_Real IntPolyh_Point::SquareModulus()const
 //=======================================================================
 Standard_Real IntPolyh_Point::SquareDistance(const IntPolyh_Point &P2)const
 {
-  Standard_Real res=(x-P2.x)*(x-P2.x)+(y-P2.y)*(y-P2.y)+(z-P2.z)*(z-P2.z);
+  Standard_Real res=(myX-P2.myX)*(myX-P2.myX)+(myY-P2.myY)*(myY-P2.myY)+(myZ-P2.myZ)*(myZ-P2.myZ);
   return res;
 }
 //=======================================================================
@@ -280,7 +127,7 @@ Standard_Real IntPolyh_Point::SquareDistance(const IntPolyh_Point &P2)const
 //=======================================================================
 Standard_Real IntPolyh_Point::Dot(const IntPolyh_Point &b ) const
 { 
-  Standard_Real t=x*b.x+y*b.y+z*b.z;
+  Standard_Real t=myX*b.myX+myY*b.myY+myZ*b.myZ;
   return t;
 }
 //=======================================================================
@@ -288,9 +135,9 @@ Standard_Real IntPolyh_Point::Dot(const IntPolyh_Point &b ) const
 //purpose  : 
 //=======================================================================
 void IntPolyh_Point::Cross(const IntPolyh_Point &a,const IntPolyh_Point &b){ 
-  x=a.y*b.z-a.z*b.y;
-  y=a.z*b.x-a.x*b.z;
-  z=a.x*b.y-a.y*b.x;
+  myX=a.myY*b.myZ-a.myZ*b.myY;
+  myY=a.myZ*b.myX-a.myX*b.myZ;
+  myZ=a.myX*b.myY-a.myY*b.myX;
 }
 //=======================================================================
 //function : Dump
@@ -298,7 +145,7 @@ void IntPolyh_Point::Cross(const IntPolyh_Point &a,const IntPolyh_Point &b){
 //=======================================================================
 void IntPolyh_Point::Dump() const
 { 
-  printf("\nPoint : x=%+8.3eg y=%+8.3eg z=%+8.3eg u=%+8.3eg v=%+8.3eg\n",x,y,z,u,v);
+  printf("\nPoint : x=%+8.3eg y=%+8.3eg z=%+8.3eg u=%+8.3eg v=%+8.3eg\n",myX,myY,myZ,myU,myV);
 }
 //=======================================================================
 //function : Dump
@@ -307,29 +154,5 @@ void IntPolyh_Point::Dump() const
 void IntPolyh_Point::Dump(const Standard_Integer i) const
 { 
   printf("\nPoint(%3d) : x=%+8.3eg y=%+8.3eg z=%+8.3eg u=%+8.3eg v=%+8.3eg poc=%3d\n",
-        i,x,y,z,u,v,POC);
-}
-//modified by NIZNHY-PKV Fri Jan 20 12:13:03 2012f
-//=======================================================================
-//function : SetDegenerated
-//purpose  : 
-//=======================================================================
-void IntPolyh_Point::SetDegenerated(const Standard_Boolean theFlag) 
-{
-  myDegenerated=theFlag;
+        i,myX,myY,myZ,myU,myV,myPOC);
 }
-//=======================================================================
-//function : Degenerated
-//purpose  : 
-//=======================================================================
-Standard_Boolean IntPolyh_Point::Degenerated()const 
-{
-  return myDegenerated;
-}
-
-
-
-
-
-
-
index 95a4395..0f8903c 100644 (file)
 #include <Standard_Boolean.hxx>
 class Adaptor3d_HSurface;
 
-
-
-class IntPolyh_Point 
+//! The class represents the point on the surface with
+//! both 3D and 2D points.
+class IntPolyh_Point
 {
 public:
 
   DEFINE_STANDARD_ALLOC
 
-  
-  Standard_EXPORT IntPolyh_Point();
-  
-  Standard_EXPORT IntPolyh_Point(const Standard_Real xx, const Standard_Real yy, const Standard_Real zz, const Standard_Real uu, const Standard_Real vv);
-  
-  Standard_EXPORT Standard_Real X() const;
-  
-  Standard_EXPORT Standard_Real Y() const;
-  
-  Standard_EXPORT Standard_Real Z() const;
-  
-  Standard_EXPORT Standard_Real U() const;
-  
-  Standard_EXPORT Standard_Real V() const;
-  
-  Standard_EXPORT Standard_Integer PartOfCommon() const;
-  
-  Standard_EXPORT void Equal (const IntPolyh_Point& Pt);
-void operator = (const IntPolyh_Point& Pt)
-{
-  Equal(Pt);
-}
-  
-  Standard_EXPORT void Set (const Standard_Real v1, const Standard_Real v2, const Standard_Real v3, const Standard_Real v4, const Standard_Real v5, const Standard_Integer II = 1);
-  
-  Standard_EXPORT void SetX (const Standard_Real v);
-  
-  Standard_EXPORT void SetY (const Standard_Real v);
-  
-  Standard_EXPORT void SetZ (const Standard_Real v);
-  
-  Standard_EXPORT void SetU (const Standard_Real v);
-  
-  Standard_EXPORT void SetV (const Standard_Real v);
-  
-  Standard_EXPORT void SetPartOfCommon (const Standard_Integer ii);
-  
+  //! Constructor
+  IntPolyh_Point() :
+    myX(0.), myY(0.), myZ(0.), myU(0.), myV(0.), myPOC(1), myDegenerated(Standard_False)
+  {}
+  //! Constructor
+  IntPolyh_Point(const Standard_Real x,
+                 const Standard_Real y,
+                 const Standard_Real z,
+                 const Standard_Real u,
+                 const Standard_Real v)
+  :
+    myX(x), myY(y), myZ(z), myU(u), myV(v), myPOC(1), myDegenerated(Standard_False)
+  {}
+
+  //! Returns X coordinate of the 3D point
+  Standard_Real X() const
+  {
+    return myX;
+  }
+  //! Returns Y coordinate of the 3D point
+  Standard_Real Y() const
+  {
+    return myY;
+  }
+  //! Returns the Z coordinate of the 3D point
+  Standard_Real Z() const
+  {
+    return myZ;
+  }
+  //! Returns the U coordinate of the 2D point
+  Standard_Real U() const
+  {
+    return myU;
+  }
+  //! Returns the V coordinate of the 2D point
+  Standard_Real V() const
+  {
+    return myV;
+  }
+  //! Returns 0 if the point is not common with the other surface
+  Standard_Integer PartOfCommon() const
+  {
+    return myPOC;
+  }
+  //! Assignment operator
+  void Equal (const IntPolyh_Point& Pt)
+  {
+    myX = Pt.myX;
+    myY = Pt.myY;
+    myZ = Pt.myZ;
+    myU = Pt.myU;
+    myV = Pt.myV;
+  }
+  void operator = (const IntPolyh_Point& Pt)
+  {
+    Equal(Pt);
+  }
+  //! Sets the point
+  void Set (const Standard_Real x,
+            const Standard_Real y,
+            const Standard_Real z,
+            const Standard_Real u,
+            const Standard_Real v,
+            const Standard_Integer II = 1)
+  {
+    myX = x;
+    myY = y;
+    myZ = z;
+    myU = u;
+    myV = v;
+    myPOC = II;
+  }
+  //! Sets the X coordinate for the 3D point
+  void SetX (const Standard_Real x)
+  {
+    myX = x;
+  }
+  //! Sets the Y coordinate for the 3D point
+  void SetY (const Standard_Real y)
+  {
+    myY = y;
+  }
+  //! Sets the Z coordinate for the 3D point
+  void SetZ (const Standard_Real z)
+  {
+    myZ = z;
+  }
+  //! Sets the U coordinate for the 2D point
+  void SetU (const Standard_Real u)
+  {
+    myU = u;
+  }
+  //! Sets the V coordinate for the 2D point
+  void SetV (const Standard_Real v)
+  {
+    myV = v;
+  }
+  //! Sets the part of common
+  void SetPartOfCommon (const Standard_Integer ii)
+  {
+    myPOC = ii;
+  }
+  //! Creates middle point from P1 and P2 and stores it to this
   Standard_EXPORT void Middle (const Handle(Adaptor3d_HSurface)& MySurface, const IntPolyh_Point& P1, const IntPolyh_Point& P2);
-  
+  //! Addition
   Standard_EXPORT IntPolyh_Point Add (const IntPolyh_Point& P1) const;
-IntPolyh_Point operator + (const IntPolyh_Point& P1) const
-{
-  return Add(P1);
-}
-  
+  IntPolyh_Point operator + (const IntPolyh_Point& P1) const
+  {
+    return Add(P1);
+  }
+  //! Subtraction
   Standard_EXPORT IntPolyh_Point Sub (const IntPolyh_Point& P1) const;
-IntPolyh_Point operator - (const IntPolyh_Point& P1) const
-{
-  return Sub(P1);
-}
-  
+  IntPolyh_Point operator - (const IntPolyh_Point& P1) const
+  {
+    return Sub(P1);
+  }
+  //! Division
   Standard_EXPORT IntPolyh_Point Divide (const Standard_Real rr) const;
-IntPolyh_Point operator / (const Standard_Real rr) const
-{
-  return Divide(rr);
-}
-  
+  IntPolyh_Point operator / (const Standard_Real rr) const
+  {
+    return Divide(rr);
+  }
+  //! Multiplication
   Standard_EXPORT IntPolyh_Point Multiplication (const Standard_Real rr) const;
-IntPolyh_Point operator * (const Standard_Real rr) const
-{
-  return Multiplication(rr);
-}
-  
+  IntPolyh_Point operator * (const Standard_Real rr) const
+  {
+    return Multiplication(rr);
+  }
+  //! Square modulus
   Standard_EXPORT Standard_Real SquareModulus() const;
-  
+  //! Square distance to the other point
   Standard_EXPORT Standard_Real SquareDistance (const IntPolyh_Point& P2) const;
-  
+  //! Dot
   Standard_EXPORT Standard_Real Dot (const IntPolyh_Point& P2) const;
-  
+  //! Cross
   Standard_EXPORT void Cross (const IntPolyh_Point& P1, const IntPolyh_Point& P2);
-  
+  //! Dump
   Standard_EXPORT void Dump() const;
-  
+  //! Dump
   Standard_EXPORT void Dump (const Standard_Integer i) const;
-  
-  Standard_EXPORT void SetDegenerated (const Standard_Boolean theFlag);
-  
-  Standard_EXPORT Standard_Boolean Degenerated() const;
-
-
-
+  //! Sets the degenerated flag
+  void SetDegenerated (const Standard_Boolean theFlag)
+  {
+    myDegenerated = theFlag;
+  }
+  //! Returns the degenerated flag
+  Standard_Boolean Degenerated() const
+  {
+    return myDegenerated;
+  }
 
 protected:
 
-
-
-
-
 private:
 
-
-
-  Standard_Real x;
-  Standard_Real y;
-  Standard_Real z;
-  Standard_Real u;
-  Standard_Real v;
-  Standard_Integer POC;
+  Standard_Real myX;
+  Standard_Real myY;
+  Standard_Real myZ;
+  Standard_Real myU;
+  Standard_Real myV;
+  Standard_Integer myPOC;
   Standard_Boolean myDegenerated;
 
-
 };
 
-
-
-
-
-
-
 #endif // _IntPolyh_Point_HeaderFile
index efa7835..4308a8c 100644 (file)
 
 #include <Adaptor3d_HSurface.hxx>
 #include <Bnd_Box.hxx>
-#include <IntPolyh_Couple.hxx>
 #include <IntPolyh_Edge.hxx>
 #include <IntPolyh_Point.hxx>
-#include <IntPolyh_StartPoint.hxx>
 #include <IntPolyh_Triangle.hxx>
 
 #include <stdio.h>
@@ -57,418 +55,95 @@ static
               IntPolyh_ArrayOfEdges & TEdges) ;
 
 //=======================================================================
-//function : IntPolyh_Triangle
-//purpose  : 
-//=======================================================================
-IntPolyh_Triangle::IntPolyh_Triangle() 
-: 
-  p1(-1),p2(-1),p3(-1),
-  e1(-1),oe1(0),e2(-1),oe2(0),e3(-1),oe3(0),
-  II(0),IP(1),Fleche(0.0) 
-{
-} 
-//=======================================================================
-//function : IntPolyh_Triangle
-//purpose  : 
-//=======================================================================
-IntPolyh_Triangle::IntPolyh_Triangle(const Standard_Integer a,
-                                    const Standard_Integer b,
-                                    const Standard_Integer c) 
-:
-  p1(a),p2(b),p3(c),
-  e1(-1),oe1(0),e2(-1),oe2(0),e3(-1),oe3(0),
-  II(0),IP(1),Fleche(0.0) 
-{ 
-}
-//=======================================================================
-//function : FirstPoint
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::FirstPoint() const 
-{ 
-  return(p1); 
-} 
-//=======================================================================
-//function : SecondPoint
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::SecondPoint() const 
-{ 
-  return(p2); 
-}
-//=======================================================================
-//function : ThirdPoint
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::ThirdPoint() const 
-{
-  return(p3); 
-}
-//=======================================================================
-//function : FirstEdge
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::FirstEdge() const
-{
-  return(e1); 
-}
-//=======================================================================
-//function : FirstEdgeOrientation
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::FirstEdgeOrientation() const 
-{
-  return(oe1); 
-}
-//=======================================================================
-//function : SecondEdge
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::SecondEdge() const 
-{
-  return(e2); 
-}
-//=======================================================================
-//function : SecondEdgeOrientation
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::SecondEdgeOrientation() const 
-{ 
-  return(oe2); 
-}
-//=======================================================================
-//function : ThirdEdge
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::ThirdEdge() const 
-{
-  return(e3); 
-}
-//=======================================================================
-//function : ThirdEdgeOrientation
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::ThirdEdgeOrientation() const
-{
-  return(oe3); 
-}
-//=======================================================================
-//function : GetFleche
-//purpose  : 
-//=======================================================================
-Standard_Real IntPolyh_Triangle::GetFleche() const 
-{
-  return(Fleche); 
-}
-//=======================================================================
-//function : IndiceIntersectionPossible
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::IndiceIntersectionPossible() const 
-{
-  return(IP); 
-}
-//=======================================================================
-//function : IndiceIntersection
-//purpose  : 
-//=======================================================================
-Standard_Integer IntPolyh_Triangle::IndiceIntersection() const 
-{
-  return(II); 
-}
-//=======================================================================
-//function : SetFirstPoint
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetFirstPoint(const Standard_Integer a) 
-{
-  p1=a; 
-} 
-//=======================================================================
-//function : SetSecondPoint
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetSecondPoint(const Standard_Integer b)
-{
-  p2=b; 
-}    
-//=======================================================================
-//function : SetThirdPoint
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetThirdPoint(const Standard_Integer c) 
-{ 
-  p3=c;
-}
-//=======================================================================
-//function : SetFirstEdge
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetFirstEdge(const Standard_Integer e, 
-                                    const Standard_Integer oe) 
-{
-  e1=e; 
-  oe1=oe;
-}
-//=======================================================================
-//function : SetSecondEdge
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetSecondEdge(const Standard_Integer f, 
-                                     const Standard_Integer of) 
-{
-  e2=f; 
-  oe2=of; 
-}
-//=======================================================================
-//function : SetThirdEdge
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetThirdEdge(const Standard_Integer g, 
-                                    const Standard_Integer og) 
-{
-  e3=g; 
-  oe3=og; 
-}
-//=======================================================================
-//function : SetFleche
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetFleche(const Standard_Real A) 
-{
-  Fleche=A;
-}
-//=======================================================================
-//function : SetIndiceIntersectionPossible
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetIndiceIntersectionPossible(const Standard_Integer I) 
-{
-  IP=I; 
-}
-//=======================================================================
-//function : SetIndiceIntersection
-//purpose  : 
+//function : ComputeDeflection
+//purpose  : Computes the deflection of the triangle.
+//           It is computed as a distance between triangles plane and
+//           barycenter of the triangle in UV space.
 //=======================================================================
-void IntPolyh_Triangle::SetIndiceIntersection(const Standard_Integer I)
+Standard_Real
+  IntPolyh_Triangle::ComputeDeflection(const Handle(Adaptor3d_HSurface)& theSurface,
+                                       const IntPolyh_ArrayOfPoints& TPoints)
 {
-  II=I; 
-}
-//=======================================================================
-//function : GetEdgeNumber
-//purpose  : 
-//=======================================================================
-Standard_Integer 
-  IntPolyh_Triangle::GetEdgeNumber(const Standard_Integer EdgeIndex) const 
-{ 
-  if(EdgeIndex==1)
-    return(e1);
-  if(EdgeIndex==2)
-    return(e2);
-  if(EdgeIndex==3)
-    return(e3);
-
-  return 0;
-}  
-//=======================================================================
-//function : SetEdge
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetEdge(const Standard_Integer EdgeIndex,
-                               const Standard_Integer EdgeNumber) 
-{
-  if(EdgeIndex==1)
-    e1=EdgeNumber;
-  if(EdgeIndex==2)
-    e2=EdgeNumber;
-  if(EdgeIndex==3)
-    e3=EdgeNumber;
-}  
-//=======================================================================
-//function : GetEdgeOrientation
-//purpose  : 
-//=======================================================================
-Standard_Integer 
-  IntPolyh_Triangle::GetEdgeOrientation(const Standard_Integer EdgeIndex) const 
-{
-  if(EdgeIndex==1)
-    return(oe1);
-  if(EdgeIndex==2)
-    return(oe2);
-  if(EdgeIndex==3)
-    return(oe3);
-
-  return 0;
-
-}  
-//=======================================================================
-//function : SetEdgeOrientation
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::SetEdgeOrientation(const Standard_Integer EdgeIndex,
-                                          const Standard_Integer OrEd) 
-{
-  if(EdgeIndex==1)
-    oe1=OrEd;
-  if(EdgeIndex==2)
-    oe2=OrEd;
-  if(EdgeIndex==3)
-    oe3=OrEd;
-}  
-
-      
-//=======================================================================
-//function : TriangleDeflection
-//purpose  : 
-/*Calcul de la fleche pour un triangle**************
-  Distance entre le plan forme par le triangle et
-  le barycentre situe sur la surface calcule avec les coordonnees Gu,Gv
-  (coordonnees du barycentre du triangle dans l'espace UV)*/
-//=======================================================================
-void IntPolyh_Triangle::TriangleDeflection(const Handle(Adaptor3d_HSurface)& MySurface,
-                                          const IntPolyh_ArrayOfPoints& TPoints)
-{
-  const IntPolyh_Point & P1 = TPoints[p1];
-  const IntPolyh_Point & P2 = TPoints[p2];
-  const IntPolyh_Point & P3 = TPoints[p3];
+  myDeflection = 0.;
+  //
+  const IntPolyh_Point & P1 = TPoints[myPoints[0]];
+  const IntPolyh_Point & P2 = TPoints[myPoints[1]];
+  const IntPolyh_Point & P3 = TPoints[myPoints[2]];
   //
-  //modified by NIZNHY-PKV Fri Jan 20 14:25:11 2012f
   {
-    Standard_Integer iDeg1, iDeg2, iDeg3, iDeg;
-    //
-    iDeg1=(P1.Degenerated()) ? 1 : 0;
-    iDeg2=(P2.Degenerated()) ? 1 : 0;
-    iDeg3=(P3.Degenerated()) ? 1 : 0;
-    iDeg=iDeg1+iDeg2+iDeg3;
-    if (iDeg>1) {
-      Fleche=0.;
-      return;
+    // check if the triangle is not degenerated - no more than one point
+    // has a degenerated flag
+    Standard_Integer iDeg = (P1.Degenerated() ? 1 : 0) +
+                            (P2.Degenerated() ? 1 : 0) +
+                            (P3.Degenerated() ? 1 : 0);
+    if (iDeg > 1) {
+      myIsDegenerated = Standard_True;
+      return myDeflection;
     }
   }
-  //modified by NIZNHY-PKV Fri Jan 20 14:25:13 2012t
-  Standard_Real Gu, Gv, SqNorme;
-  gp_Pnt PtXYZ;
   //
-  Gu=(P1.U()+P2.U()+P3.U())/3.0;
-  Gv=(P1.V()+P2.V()+P3.V())/3.0;
-
-  PtXYZ = (MySurface)->Value( Gu, Gv);
-  IntPolyh_Point BarycentreReel(PtXYZ.X(), PtXYZ.Y(), PtXYZ.Z(), Gu, Gv);
+  // Plane of the triangle
   IntPolyh_Point NormaleTri;
   NormaleTri.Cross(P2-P1,P3-P1);
-  SqNorme=NormaleTri.SquareModulus();
-  
-  if (SqNorme > SquareMyConfusionPrecision) {
-    NormaleTri=NormaleTri/sqrt(SqNorme);
-    Fleche=Abs(NormaleTri.Dot( BarycentreReel-P1));
+  Standard_Real SqNorm = NormaleTri.SquareModulus();
+  if (SqNorm < SquareMyConfusionPrecision) {
+    // The triangle is degenerated
+    myIsDegenerated = Standard_True;
+    return myDeflection;
   }
-  else {
-    // On calcule la fleche sur le plus grand des edges
-    // calcul des longueurs des cotes au carre
-      Standard_Real L12 = P1.SquareDistance(P2);
-      Standard_Real L23 = P2.SquareDistance(P3);
-      Standard_Real L31 = P3.SquareDistance(P1);
-
-      IntPolyh_Point Milieu; // milieu du plus grand des edges
-
-      if ((L12>L23) && (L12>L31))
-       Milieu.Middle( MySurface,P1, P2);
-      else if ((L23>L31) && (L23>L12))
-       Milieu.Middle( MySurface,P2, P3);
-      else if ((L31>L12) && (L31>L23))
-       Milieu.Middle( MySurface,P3, P1);
-       
-       
-      gp_Pnt PtXYZMilieu = (MySurface)->Value( Milieu.U(), Milieu.V());
-      IntPolyh_Point MilieuReel(PtXYZMilieu.X(), PtXYZMilieu.Y(), PtXYZMilieu.Z(), Milieu.U(), Milieu.V());
-      Fleche = sqrt(Milieu.SquareDistance(MilieuReel));
-    }
+  //
+  // Compute point on the surface
+  Standard_Real Gu=(P1.U()+P2.U()+P3.U())/3.0;
+  Standard_Real Gv=(P1.V()+P2.V()+P3.V())/3.0;
+  gp_Pnt PtXYZ = theSurface->Value( Gu, Gv);
+  // Point on the surface
+  IntPolyh_Point BarycentreReel(PtXYZ.X(), PtXYZ.Y(), PtXYZ.Z(), Gu, Gv);
+  // compute distance to plane
+  NormaleTri = NormaleTri / sqrt(SqNorm);
+  myDeflection = Abs(NormaleTri.Dot(BarycentreReel - P1));
+  return myDeflection;
 }
 
 //=======================================================================
-//function : CheckCommonEdge
-//purpose  : 
-//=======================================================================
-Standard_Integer 
-  IntPolyh_Triangle::CheckCommonEdge(const Standard_Integer PT1,
-                                    const Standard_Integer PT2,
-                                    const Standard_Integer PT3,
-                                    const Standard_Integer Index,
-                                    const IntPolyh_ArrayOfTriangles &TTriangles)  const 
-{
-  Standard_Integer P1,P2,P3,res=-1;
-  P1=TTriangles[Index].FirstPoint();
-  P2=TTriangles[Index].SecondPoint();
-  P3=TTriangles[Index].ThirdPoint();
-  
-  if ( (P1==PT1)||(P1==PT2) ) {
-    if ( ( (P2==PT1)||(P2==PT2) )&&(P3!=PT3) ) res = Index; //edge commun P1P2
-    else if ( ( (P3==PT1)||(P3==PT2) )&&(P2!=PT3) ) res = Index;//edge commun P1P3
-  }
-  else if ( (P2==PT1)||(P2==PT2) ) {
-    if ( ( (P3==PT1)||(P3==PT2) )&&(P1!=PT3) ) res = Index; //edge commun P2P3
-  }
-  else res=-1;
-  return(res);
-}
-//=======================================================================
-//function : GetNextTriangle2
+//function : GetNextTriangle
 //purpose  : 
 //=======================================================================
-Standard_Integer 
-  IntPolyh_Triangle::GetNextTriangle2(const Standard_Integer NumTri,
-                                     const Standard_Integer NumEdge,
-                                     const IntPolyh_ArrayOfEdges &TEdges) const 
+Standard_Integer
+  IntPolyh_Triangle::GetNextTriangle(const Standard_Integer theTriangle,
+                                     const Standard_Integer theEdgeNum,
+                                     const IntPolyh_ArrayOfEdges& TEdges) const
 {
-  Standard_Integer NumNextTri=-1;
-  if (NumEdge==1) {
-    const IntPolyh_Edge & Edge1=TEdges[e1];
-    if(Edge1.FirstTriangle()==NumTri)
-      NumNextTri=Edge1.SecondTriangle();
-    else
-      NumNextTri=Edge1.FirstTriangle();
+  Standard_Integer aNextTriangle = -1;
+  if (theEdgeNum < 1 || theEdgeNum > 3) {
+    return aNextTriangle;
   }
-  else if (NumEdge==2) {
-    const IntPolyh_Edge & Edge2=TEdges[e2];
-    if(Edge2.FirstTriangle()==NumTri)
-      NumNextTri=Edge2.SecondTriangle();
-    else
-      NumNextTri=Edge2.FirstTriangle();
-  }
-  else if (NumEdge==3) {
-    const IntPolyh_Edge & Edge3=TEdges[e3];
-    if(Edge3.FirstTriangle()==NumTri)
-      NumNextTri=Edge3.SecondTriangle();
-    else
-      NumNextTri=Edge3.FirstTriangle();
-  }
-  return (NumNextTri);
+  //
+  const IntPolyh_Edge & anEdge = TEdges[myEdges[theEdgeNum-1]];
+  aNextTriangle = ((anEdge.FirstTriangle() == theTriangle) ?
+    anEdge.SecondTriangle() : anEdge.FirstTriangle());
+  return aNextTriangle;
 }
 
-
 //=======================================================================
 //function : LinkEdges2Triangle
 //purpose  : 
 //=======================================================================
-void IntPolyh_Triangle::LinkEdges2Triangle(const IntPolyh_ArrayOfEdges & TEdges,
-                                          const Standard_Integer edge1,
-                                          const Standard_Integer edge2,
-                                          const Standard_Integer edge3) {
-  if( (edge1<0)||(edge2<0)||(edge3<0) ) {
-
-  }
-  else {
-    e1=edge1;  
-    e2=edge2;
-    e3=edge3;
-    
-    if(TEdges[e1].FirstPoint()==p1) oe1=1;
-    else oe1=-1;
-    if(TEdges[e2].FirstPoint()==p2) oe2=1;
-    else oe2=-1;
-    if(TEdges[e3].FirstPoint()==p3) oe3=1;
-    else oe3=-1;
+void IntPolyh_Triangle::LinkEdges2Triangle(const IntPolyh_ArrayOfEdges& TEdges,
+                                           const Standard_Integer theEdge1,
+                                           const Standard_Integer theEdge2,
+                                           const Standard_Integer theEdge3)
+{
+  if (theEdge1 < 0 || theEdge2 < 0 || theEdge3 < 0) {
+    return;
   }
+  //
+  myEdges[0] = theEdge1;
+  myEdges[1] = theEdge2;
+  myEdges[2] = theEdge3;
+  //
+  myEdgesOrientations[0] = ((TEdges[myEdges[0]].FirstPoint() == myPoints[0]) ? 1 : -1);
+  myEdgesOrientations[1] = ((TEdges[myEdges[1]].FirstPoint() == myPoints[1]) ? 1 : -1);
+  myEdgesOrientations[2] = ((TEdges[myEdges[2]].FirstPoint() == myPoints[2]) ? 1 : -1);
 }
 
 //=======================================================================
@@ -549,7 +224,7 @@ void NewTriangle(const Standard_Integer P1,
   TTriangles[FinTT].SetFirstPoint(P1);
   TTriangles[FinTT].SetSecondPoint(P2);
   TTriangles[FinTT].SetThirdPoint(P3);
-  TTriangles[FinTT].TriangleDeflection(MySurface, TPoints);
+  TTriangles[FinTT].ComputeDeflection(MySurface, TPoints);
   TTriangles.IncrementNbItems();
 }
 
@@ -595,27 +270,25 @@ void OldEdge(const Standard_Integer EdgeN,
 //purpose  : 
 //=======================================================================
 void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
-                                        const Handle(Adaptor3d_HSurface)& MySurface,
-                                        IntPolyh_ArrayOfPoints &TPoints,
-                                        IntPolyh_ArrayOfTriangles &TTriangles,
-                                        IntPolyh_ArrayOfEdges & TEdges) {
+                                         const Handle(Adaptor3d_HSurface)& MySurface,
+                                         IntPolyh_ArrayOfPoints &TPoints,
+                                         IntPolyh_ArrayOfTriangles &TTriangles,
+                                         IntPolyh_ArrayOfEdges & TEdges)
+{
 
   Standard_Integer FinTE = TEdges.NbItems();
   Standard_Integer FinTT = TTriangles.NbItems();
-  
-  ///Raffinage de la maille et de ses voisines par le milieu du plus grand des cotes
 
+  // Refinement of the mesh by the middle of the largest dimensions
   Standard_Integer numP1 = FirstPoint();
   Standard_Integer numP2 = SecondPoint();
   Standard_Integer numP3 = ThirdPoint();
 
-  IntPolyh_Point P1 = TPoints[numP1];
-  IntPolyh_Point P2 = TPoints[numP2];
-  IntPolyh_Point P3 = TPoints[numP3];
-
+  const IntPolyh_Point& P1 = TPoints[numP1];
+  const IntPolyh_Point& P2 = TPoints[numP2];
+  const IntPolyh_Point& P3 = TPoints[numP3];
 
-  ///calcul des longueurs des cotes au carre
-       
+  // compute the largest dimension
   Standard_Real L12 = P1.SquareDistance(P2);
   Standard_Real L23 = P2.SquareDistance(P3);
   Standard_Real L31 = P3.SquareDistance(P1);
@@ -636,7 +309,7 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
 
     ///***AFFINAGE DU TRIANGLE ADJACENT***
 
-    Standard_Integer numTA = GetNextTriangle2(NumTri,1,TEdges);
+    Standard_Integer numTA = GetNextTriangle(NumTri,1,TEdges);
 
     if (numTA>=0) {
       Standard_Integer numP3b = -1;
@@ -669,20 +342,20 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
       NewEdge(FinTP,numP3b,T3,T4,TEdges);
 
       ///On met a jour les anciens edges
-      OldEdge(e2,NumTri,T1,TEdges);
-      OldEdge(e3,NumTri,T2,TEdges);
+      OldEdge(myEdges[1],NumTri,T1,TEdges);
+      OldEdge(myEdges[2],NumTri,T2,TEdges);
       OldEdge(Edge2b,numTA,T3,TEdges);
       OldEdge(Edge3b,numTA,T4,TEdges);
       
       /// On remplit les nouveaux triangles avec les edges
-      TTriangles[T1].LinkEdges2Triangle(TEdges,e2,E3,E2);
-      TTriangles[T2].LinkEdges2Triangle(TEdges,e3,E1,E3);
+      TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[1],E3,E2);
+      TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[2],E1,E3);
       TTriangles[T3].LinkEdges2Triangle(TEdges,Edge2b,E4,E2);
       TTriangles[T4].LinkEdges2Triangle(TEdges,Edge3b,E1,E4);
 
       ///On tue le triangle adjacent
-      TTriangles[numTA].Fleche=-1.0;
-      TTriangles[numTA].IP=0;
+      TTriangles[numTA].SetDeflection(-1.0);
+      TTriangles[numTA].SetIntersectionPossible(Standard_False);
 
     }
     else { ///seulement deux nouveaux triangles
@@ -699,12 +372,12 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
       NewEdge(FinTP,numP3,T1,T2,TEdges);
 
       ///On met a jour les anciens edges
-      OldEdge(e2,NumTri,T1,TEdges);
-      OldEdge(e3,NumTri,T2,TEdges);
+      OldEdge(myEdges[1],NumTri,T1,TEdges);
+      OldEdge(myEdges[2],NumTri,T2,TEdges);
       
       /// On remplit les nouveaux triangles avec les edges
-      TTriangles[T1].LinkEdges2Triangle(TEdges,e2,E3,E2);
-      TTriangles[T2].LinkEdges2Triangle(TEdges,e3,E1,E3);
+      TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[1],E3,E2);
+      TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[2],E1,E3);
     }
   }
   
@@ -724,7 +397,7 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
     
     ///*RAFFINAGE DU TRIANGLE ADJACENT***
 
-    Standard_Integer numTA = GetNextTriangle2(NumTri,2,TEdges);
+    Standard_Integer numTA = GetNextTriangle(NumTri,2,TEdges);
 
     if (numTA>=0) {
       Standard_Integer numP1b=-1;
@@ -757,20 +430,20 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
       NewEdge(FinTP,numP1b,T3,T4,TEdges);
 
       ///On met a jour les anciens edges
-      OldEdge(e1,NumTri,T1,TEdges);
-      OldEdge(e3,NumTri,T2,TEdges);
+      OldEdge(myEdges[0],NumTri,T1,TEdges);
+      OldEdge(myEdges[2],NumTri,T2,TEdges);
       OldEdge(Edge1b,numTA,T3,TEdges);
       OldEdge(Edge3b,numTA,T4,TEdges);
       
       /// On remplit les nouveaux triangles avec les edges
-      TTriangles[T1].LinkEdges2Triangle(TEdges,e1,E1,E3);
-      TTriangles[T2].LinkEdges2Triangle(TEdges,e3,E3,E2);
+      TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[0],E1,E3);
+      TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[2],E3,E2);
       TTriangles[T3].LinkEdges2Triangle(TEdges,Edge1b,E4,E1);
       TTriangles[T4].LinkEdges2Triangle(TEdges,Edge3b,E2,E4);
 
       ///On tue le triangle adjacent
-      TTriangles[numTA].Fleche=-1.0;
-      TTriangles[numTA].IP=0;
+      TTriangles[numTA].SetDeflection(-1.0);
+      TTriangles[numTA].SetIntersectionPossible(Standard_False);
     }
     else { ///seulement deux nouveaux triangles
       ///Nouveaux Edges
@@ -786,12 +459,12 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
       NewEdge(FinTP,numP1,T1,T2,TEdges);
 
       ///On met a jour les anciens edges
-      OldEdge(e1,NumTri,T1,TEdges);
-      OldEdge(e3,NumTri,T2,TEdges);
+      OldEdge(myEdges[0],NumTri,T1,TEdges);
+      OldEdge(myEdges[2],NumTri,T2,TEdges);
       
       /// On remplit les nouveaux triangles avec les edges
-      TTriangles[T1].LinkEdges2Triangle(TEdges,e1,E1,E3);
-      TTriangles[T2].LinkEdges2Triangle(TEdges,e3,E3,E2);
+      TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[0],E1,E3);
+      TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[2],E3,E2);
     }
   }
     else {
@@ -809,7 +482,7 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
     
     ///*RAFFINAGE DU TRIANGLE ADJACENT***
 
-    Standard_Integer numTA = GetNextTriangle2(NumTri,3,TEdges);
+    Standard_Integer numTA = GetNextTriangle(NumTri,3,TEdges);
 
     if (numTA>=0) {
 
@@ -843,20 +516,20 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
       NewEdge(FinTP,numP1,T1,T3,TEdges);
 
       ///On met a jour les anciens edges
-      OldEdge(e1,NumTri,T1,TEdges);
-      OldEdge(e2,NumTri,T2,TEdges);
+      OldEdge(myEdges[0],NumTri,T1,TEdges);
+      OldEdge(myEdges[1],NumTri,T2,TEdges);
       OldEdge(Edge1b,numTA,T3,TEdges);
       OldEdge(Edge2b,numTA,T4,TEdges);
       
       /// On remplit les nouveaux triangles avec les edges
-      TTriangles[T1].LinkEdges2Triangle(TEdges,e1,E1,E4);
-      TTriangles[T2].LinkEdges2Triangle(TEdges,e2,E2,E1);
+      TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[0],E1,E4);
+      TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[1],E2,E1);
       TTriangles[T3].LinkEdges2Triangle(TEdges,Edge1b,E3,E4);
       TTriangles[T4].LinkEdges2Triangle(TEdges,Edge2b,E2,E3);
 
       ///On tue le triangle adjacent
-      TTriangles[numTA].Fleche=-1.0;
-      TTriangles[numTA].IP=0;
+      TTriangles[numTA].SetDeflection(-1.0);
+      TTriangles[numTA].SetIntersectionPossible(Standard_False);
     }
     else { ///seulement deux nouveaux triangles
       ///Nouveaux Edges
@@ -872,197 +545,113 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri,
       NewEdge(FinTP,numP1,T1,-1,TEdges);
 
       ///On met a jour les anciens edges
-      OldEdge(e1,NumTri,T1,TEdges);
-      OldEdge(e2,NumTri,T2,TEdges);
+      OldEdge(myEdges[0],NumTri,T1,TEdges);
+      OldEdge(myEdges[1],NumTri,T2,TEdges);
 
       /// On remplit les nouveaux triangles avec les edges
-      TTriangles[T1].LinkEdges2Triangle(TEdges,e1,E1,E4);
-      TTriangles[T2].LinkEdges2Triangle(TEdges,e2,E2,E1);
+      TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[0],E1,E4);
+      TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[1],E2,E1);
     }
   }
-  /// Le triangle traite est maintenant obsolete 
-  ///***On tue le triangle***
-  Fleche=-1.0;
-  IP=0;
-
   TPoints.IncrementNbItems();
+
+  // make the triangle obsolete
+  myDeflection = -1.0;
+  myIsIntersectionPossible = Standard_False;
 }
 
 //=======================================================================
 //function : MultipleMiddleRefinement
 //purpose  : 
 //=======================================================================
-void IntPolyh_Triangle::MultipleMiddleRefinement(const Standard_Integer NbAffinages,
-                                                const Standard_Integer NumTri,
-                                                const Handle(Adaptor3d_HSurface)& MySurface,
-                                                IntPolyh_ArrayOfPoints &TPoints,
-                                                IntPolyh_ArrayOfTriangles &TTriangles,
-                                                IntPolyh_ArrayOfEdges & TEdges) {
-
+void IntPolyh_Triangle::MultipleMiddleRefinement(const Standard_Real theRefineCriterion,
+                                                 const Bnd_Box& theBox,
+                                                 const Standard_Integer theTriangleNumber,
+                                                 const Handle(Adaptor3d_HSurface)& theSurface,
+                                                 IntPolyh_ArrayOfPoints& TPoints,
+                                                 IntPolyh_ArrayOfTriangles& TTriangles,
+                                                 IntPolyh_ArrayOfEdges& TEdges)
+{
+  // Number of triangles before refinement of current triangle
   const Standard_Integer FinTTInit = TTriangles.NbItems();
-
-  //On sait qu'il faut affiner au moins une fois
-  TTriangles[NumTri].MiddleRefinement(NumTri,MySurface,TPoints,
-                                     TTriangles,TEdges);
-
-  if (NbAffinages>1) {
-    Standard_Integer MyNbAffinages=0;
-    if (NbAffinages > 5)
-      MyNbAffinages = 4;//5 est le maximum et on a deja affine une fois
-    //On a decide d'arreter a 5 car avec un triangle on peut en obtenir 1024
-    else MyNbAffinages = NbAffinages-1;//dans tous les cas MyNbAffinages>0
-    
-
-    //Un affinage peut donner deux ou quatre nouveaux triangles
-    // ils seront ajoute a la fin du tableau de triangles, et auront comme indice
-    // FinTTInit, FinTTInit+1,... 
-
-
-    Standard_Integer NombreReelsAffinages = 4;
-    for(Standard_Integer iii=1; iii<MyNbAffinages; iii++) 
-      NombreReelsAffinages*=4;
-    //Avec ce calcul on fait l'hypothese que chaque triangle affine donne quatre nouveaux triangles
-    //ce qui peut etre faux si on n'affine pas le triangle adjacent
-    //dans quel cas on n'obtient que deux nouveaux triangles
-    
-    Standard_Integer FinTTAffinage = FinTTInit + NombreReelsAffinages;
-    
-    for(Standard_Integer NumTriangle=FinTTInit; NumTriangle < FinTTAffinage; NumTriangle++)
-      TTriangles[NumTriangle].MiddleRefinement(NumTriangle,MySurface,TPoints,
-                                              TTriangles,TEdges);
+  // Split the current triangle
+  MiddleRefinement(theTriangleNumber, theSurface, TPoints, TTriangles, TEdges);
+  // Refine the new triangles
+  for (Standard_Integer i = FinTTInit; i < TTriangles.NbItems(); ++i) {
+    IntPolyh_Triangle& aTriangle = TTriangles[i];
+    if(theBox.IsOut(aTriangle.BoundingBox(TPoints))) {
+      aTriangle.SetIntersectionPossible(Standard_False);
+    }
+    else if (aTriangle.Deflection() > theRefineCriterion) {
+      aTriangle.MiddleRefinement(i, theSurface, TPoints, TTriangles, TEdges);
+    }
   }
 }
 
 //=======================================================================
-//function : CompareBoxTriangle
+//function : SetEdgeAndOrientation
 //purpose  : 
 //=======================================================================
-Standard_Integer IntPolyh_Triangle::CompareBoxTriangle(const Bnd_Box &b,
-                                                      const IntPolyh_ArrayOfPoints &TPoints) const{
-  Standard_Integer Test=0;
-  Bnd_Box maboite;
-  const IntPolyh_Point&    PA=TPoints[p1]; 
-  const IntPolyh_Point&    PB=TPoints[p2]; 
-  const IntPolyh_Point&    PC=TPoints[p3]; 
-  gp_Pnt pntA(PA.X(),PA.Y(),PA.Z());
-  gp_Pnt pntB(PB.X(),PB.Y(),PB.Z());
-  gp_Pnt pntC(PC.X(),PC.Y(),PC.Z());
-  maboite.Add(pntA);
-  maboite.Add(pntB);
-  maboite.Add(pntC);
-  maboite.Enlarge(Fleche+MyTolerance);
-  if (maboite.IsOut(b))
-    Test=0;
-  else  
-    Test=1;
-  return(Test);
-  //Pour gagner du temps on pourrait envisager de garder la boite englobante dans la structure du triangle
-}
-
-//=======================================================================
-//function : MultipleMiddleRefinement2
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::MultipleMiddleRefinement2(const Standard_Real CritereAffinage,
-                                                 const Bnd_Box &b,//boite englobante de l'autre surface
-                                                 const Standard_Integer NumTri,
-                                                 const Handle(Adaptor3d_HSurface)& MySurface,
-                                                 IntPolyh_ArrayOfPoints &TPoints,
-                                                 IntPolyh_ArrayOfTriangles &TTriangles,
-                                                 IntPolyh_ArrayOfEdges & TEdges) {
-
-  const Standard_Integer FinTTInit = TTriangles.NbItems();
-  Standard_Integer CritereArret=FinTTInit+250;
-
-  //On sait qu'il faut affiner une fois au moins
-  MiddleRefinement(NumTri,MySurface,TPoints,
-                  TTriangles,TEdges);
-
-  Standard_Integer FinTT = TTriangles.NbItems();// FinTT n'est pas une constante, elle augmente avec l'affinage
-
-  for(Standard_Integer iii=FinTTInit; iii<(FinTT=TTriangles.NbItems()); iii++) {
-    IntPolyh_Triangle& TriangleCourant = TTriangles[iii];
-    if(TriangleCourant.CompareBoxTriangle(b,TPoints)==0)
-      //On n'affine pas le triangle
-      TriangleCourant.IP=0;
-    else if (TriangleCourant.Fleche > CritereAffinage)
-      TriangleCourant.MiddleRefinement(iii,MySurface,TPoints,
-                                      TTriangles,TEdges);
-      
-    if ( FinTT > CritereArret )//critere d'arret 250 nouveaux triangles
-      iii = FinTT;
+void IntPolyh_Triangle::SetEdgeAndOrientation(const IntPolyh_Edge& theEdge,
+                                              const Standard_Integer theEdgeIndex)
+{
+  // Points on the edge - pe1, pe2
+  Standard_Integer pe1 = theEdge.FirstPoint(), pe2 = theEdge.SecondPoint();
+  //
+  // We have points on the triangle - p1, p2 and p3;
+  // And points on the edge - pe1, pe2;
+  // By comparing these points we should define which
+  // edge it is for the triangle and its orientation on it:
+  // e1 = p1->p2;
+  // e2 = p2->p3;
+  // e3 = p3->p1;
+  // In case the order of points on the edge is forward,
+  // the orientation is positive, otherwise it is negative.
+
+  for (Standard_Integer i = 0, i1 = 1; i < 3; ++i, ++i1) {
+    if (i1 > 2) {
+      i1 = 0;
+    }
+    //
+    if (pe1 == myPoints[i] && pe2 == myPoints[i1]) {
+      myEdges[i] = theEdgeIndex;
+      myEdgesOrientations[i] = 1;
+      break;
+    }
+    if (pe1 == myPoints[i1] && pe2 == myPoints[i]) {
+      myEdges[i] = theEdgeIndex;
+      myEdgesOrientations[i] = -1;
+      break;
+    }
   }
 }
 
 //=======================================================================
-//function : SetEdgeandOrientation
+//function : BoundingBox
 //purpose  : 
 //=======================================================================
-void IntPolyh_Triangle::SetEdgeandOrientation(const Standard_Integer EdgeIndex,
-                                             const IntPolyh_ArrayOfEdges &TEdges) {
-  const Standard_Integer FinTE = TEdges.NbItems();
-
-  Standard_Integer PE1 =0,PE2 =0;
-
-  Standard_Integer Test=1;
-
-  if (EdgeIndex==1) { PE1=p1; PE2=p2; }
-  else if (EdgeIndex==2) { PE1=p2; PE2=p3; }
-  else if (EdgeIndex==3) { PE1=p3; PE2=p1; }
-  else { 
-    Test=0;
-  }
-  if (Test!=0) {
-    for(Standard_Integer iioo=0; iioo<FinTE; iioo++) {
-      Standard_Integer EFP=TEdges[iioo].FirstPoint();
-      if (EFP==PE1) {
-       Standard_Integer ESP=TEdges[iioo].SecondPoint();
-       if (ESP!=EFP) {
-         if (ESP==PE2) {
-           SetEdgeOrientation(EdgeIndex,1);
-           SetEdge(EdgeIndex,iioo);
-           iioo=FinTE;
-         }
-       }
-       else {
-
-         Test=0;
-       }
-      }
-      else if (EFP==PE2) {
-       Standard_Integer ESP=TEdges[iioo].SecondPoint();
-       if (ESP!=EFP) {
-         if (ESP==PE1) {
-           SetEdgeOrientation(EdgeIndex,-1);
-           SetEdge(EdgeIndex,iioo);
-           iioo=FinTE;
-         }
-       }
-       else {
-
-       }   
-      }
-    }
+const Bnd_Box& IntPolyh_Triangle::BoundingBox(const IntPolyh_ArrayOfPoints& thePoints)
+{
+  if (myBox.IsVoid()) {
+    const IntPolyh_Point& aP1 = thePoints[myPoints[0]];
+    const IntPolyh_Point& aP2 = thePoints[myPoints[1]];
+    const IntPolyh_Point& aP3 = thePoints[myPoints[2]];
+    myBox.Add(gp_Pnt(aP1.X(), aP1.Y(), aP1.Z()));
+    myBox.Add(gp_Pnt(aP2.X(), aP2.Y(), aP2.Z()));
+    myBox.Add(gp_Pnt(aP3.X(), aP3.Y(), aP3.Z()));
+    myBox.SetGap(myDeflection + Precision::Confusion());
   }
+  return myBox;
 }
-
-
 //=======================================================================
 //function : Dump
 //purpose  : 
 //=======================================================================
 void IntPolyh_Triangle::Dump (const Standard_Integer i) const
 { 
-  printf("\nTriangle(%3d) : Points %5d %5d %5d Edges %5d %5d %5d fleche: %8f  intersection possible %8d  intersection: %5d\n"
-        ,i,p1,p2,p3,e1,e2,e3,Fleche,IP,II);
+  printf("\nTriangle(%3d) : Points %5d %5d %5d Edges %5d %5d %5d deflection: %8f "
+         "intersection possible %8d  intersection: %5d\n",
+         i, myPoints[0], myPoints[1], myPoints[2],
+         myEdges[0], myEdges[1], myEdges[2],
+         myDeflection, (myIsIntersectionPossible ? 1 : 0), (myHasIntersection ? 1 : 0));
 }
-
-
-//=======================================================================
-//function : DumpFleche
-//purpose  : 
-//=======================================================================
-void IntPolyh_Triangle::DumpFleche (const Standard_Integer i) const { 
-  printf("\nTriangle(%3d) fleche: %5f\n",i,Fleche);
-}
-
index 27769c5..f27e924 100644 (file)
 
 #include <Standard_Integer.hxx>
 #include <Standard_Real.hxx>
+#include <Bnd_Box.hxx>
 #include <IntPolyh_ArrayOfPoints.hxx>
 #include <IntPolyh_ArrayOfTriangles.hxx>
 #include <IntPolyh_ArrayOfEdges.hxx>
-#include <IntPolyh_ArrayOfCouples.hxx>
 class Adaptor3d_HSurface;
-class Bnd_Box;
 class IntPolyh_StartPoint;
 
-
-
+//! The class represents the triangle built from three IntPolyh points
+//! and three IntPolyh edges.
 class IntPolyh_Triangle 
 {
 public:
 
   DEFINE_STANDARD_ALLOC
 
-  
-  Standard_EXPORT IntPolyh_Triangle();
-  
-  Standard_EXPORT IntPolyh_Triangle(const Standard_Integer i1, const Standard_Integer i2, const Standard_Integer i3);
-  
-  Standard_EXPORT Standard_Integer FirstPoint() const;
-  
-  Standard_EXPORT Standard_Integer SecondPoint() const;
-  
-  Standard_EXPORT Standard_Integer ThirdPoint() const;
-  
-  Standard_EXPORT Standard_Integer FirstEdge() const;
-  
-  Standard_EXPORT Standard_Integer FirstEdgeOrientation() const;
-  
-  Standard_EXPORT Standard_Integer SecondEdge() const;
-  
-  Standard_EXPORT Standard_Integer SecondEdgeOrientation() const;
-  
-  Standard_EXPORT Standard_Integer ThirdEdge() const;
-  
-  Standard_EXPORT Standard_Integer ThirdEdgeOrientation() const;
-  
-  Standard_EXPORT Standard_Real GetFleche() const;
-  
-  Standard_EXPORT Standard_Integer IndiceIntersectionPossible() const;
-  
-  Standard_EXPORT Standard_Integer IndiceIntersection() const;
-  
-  Standard_EXPORT void SetFirstPoint (const Standard_Integer v);
-  
-  Standard_EXPORT void SetSecondPoint (const Standard_Integer v);
-  
-  Standard_EXPORT void SetThirdPoint (const Standard_Integer v);
-  
-  Standard_EXPORT void SetFirstEdge (const Standard_Integer v, const Standard_Integer s);
-  
-  Standard_EXPORT void SetSecondEdge (const Standard_Integer v, const Standard_Integer s);
-  
-  Standard_EXPORT void SetThirdEdge (const Standard_Integer v, const Standard_Integer s);
-  
-  Standard_EXPORT void SetFleche (const Standard_Real v);
-  
-  Standard_EXPORT void SetIndiceIntersectionPossible (const Standard_Integer v);
-  
-  Standard_EXPORT void SetIndiceIntersection (const Standard_Integer v);
-  
-  Standard_EXPORT Standard_Integer GetEdgeNumber (const Standard_Integer v) const;
-  
-  Standard_EXPORT void SetEdge (const Standard_Integer v, const Standard_Integer en);
-  
-  Standard_EXPORT Standard_Integer GetEdgeOrientation (const Standard_Integer v) const;
-  
-  Standard_EXPORT void SetEdgeOrientation (const Standard_Integer v, const Standard_Integer oe);
-  
-  Standard_EXPORT void TriangleDeflection (const Handle(Adaptor3d_HSurface)& MaSurface, const IntPolyh_ArrayOfPoints& TP);
-  
-  Standard_EXPORT Standard_Integer CheckCommonEdge (const Standard_Integer PE1, const Standard_Integer PE2, const Standard_Integer P3, const Standard_Integer Index, const IntPolyh_ArrayOfTriangles& TTriangles) const;
-  
-  Standard_EXPORT Standard_Integer GetNextTriangle2 (const Standard_Integer NumTri, const Standard_Integer NumEdge, const IntPolyh_ArrayOfEdges& TEdges) const;
-  
-  Standard_EXPORT void MiddleRefinement (const Standard_Integer TriangleNumber, const Handle(Adaptor3d_HSurface)& MySurface, IntPolyh_ArrayOfPoints& TPoints, IntPolyh_ArrayOfTriangles& TTriangles, IntPolyh_ArrayOfEdges& TEdges);
-  
-  Standard_EXPORT void MultipleMiddleRefinement (const Standard_Integer NombreAffinages, const Standard_Integer TriangleNumber, const Handle(Adaptor3d_HSurface)& MySurface, IntPolyh_ArrayOfPoints& TPoints, IntPolyh_ArrayOfTriangles& TTriangles, IntPolyh_ArrayOfEdges& TEdges);
-  
-  Standard_EXPORT Standard_Integer CompareBoxTriangle (const Bnd_Box& b, const IntPolyh_ArrayOfPoints& TPoints) const;
-  
-  Standard_EXPORT void MultipleMiddleRefinement2 (const Standard_Real RefineCriterion, const Bnd_Box& thebox, const Standard_Integer TriangleNumber, const Handle(Adaptor3d_HSurface)& MySurface, IntPolyh_ArrayOfPoints& TPoints, IntPolyh_ArrayOfTriangles& TTriangles, IntPolyh_ArrayOfEdges& TEdges);
-  
-  Standard_EXPORT Standard_Integer GetNextChainTriangle (const IntPolyh_StartPoint& SPIni, const Standard_Integer LastTTC, IntPolyh_ArrayOfCouples& TriContactsArray, const IntPolyh_ArrayOfTriangles& TTriangles1, const IntPolyh_ArrayOfTriangles& TTriangles2, Standard_Integer& NumContact, Standard_Integer& NextTriangle) const;
-  
-  Standard_EXPORT void LinkEdges2Triangle (const IntPolyh_ArrayOfEdges& TEdges, const Standard_Integer ed1, const Standard_Integer ed2, const Standard_Integer ed3);
-  
-  Standard_EXPORT void SetEdgeandOrientation (const Standard_Integer Edge, const IntPolyh_ArrayOfEdges& TEdges);
-  
-  Standard_EXPORT void Dump (const Standard_Integer v) const;
-  
-  Standard_EXPORT void DumpFleche (const Standard_Integer v) const;
+  //! Constructor
+  IntPolyh_Triangle() :
+    myHasIntersection(Standard_False),
+    myIsIntersectionPossible(Standard_True),
+    myIsDegenerated(Standard_False),
+    myDeflection(0.0)
+  {
+    myPoints[0] = -1;
+    myPoints[1] = -1;
+    myPoints[2] = -1;
+    myEdges[0] = -1;
+    myEdges[1] = -1;
+    myEdges[2] = -1;
+    myEdgesOrientations[0] = 0;
+    myEdgesOrientations[1] = 0;
+    myEdgesOrientations[2] = 0;
+  }
 
+  //! Constructor
+  IntPolyh_Triangle(const Standard_Integer thePoint1,
+                    const Standard_Integer thePoint2,
+                    const Standard_Integer thePoint3)
+  :
+    myHasIntersection(Standard_False),
+    myIsIntersectionPossible(Standard_True),
+    myIsDegenerated(Standard_False),
+    myDeflection(0.0)
+  {
+    myPoints[0] = thePoint1;
+    myPoints[1] = thePoint2;
+    myPoints[2] = thePoint3;
+    myEdges[0] = -1;
+    myEdges[1] = -1;
+    myEdges[2] = -1;
+    myEdgesOrientations[0] = 0;
+    myEdgesOrientations[1] = 0;
+    myEdgesOrientations[2] = 0;
+  }
 
+  //! Returns the first point
+  Standard_Integer FirstPoint() const
+  {
+    return myPoints[0];
+  }
+  //! Returns the second point
+  Standard_Integer SecondPoint() const
+  {
+    return myPoints[1];
+  }
+  //! Returns the third point
+  Standard_Integer ThirdPoint() const
+  {
+    return myPoints[2];
+  }
+  //! Returns the first edge
+  Standard_Integer FirstEdge() const
+  {
+    return myEdges[0];
+  }
+  //! Returns the orientation of the first edge
+  Standard_Integer FirstEdgeOrientation() const
+  {
+    return myEdgesOrientations[0];
+  }
+  //! Returns the second edge
+  Standard_Integer SecondEdge() const
+  {
+    return myEdges[1];
+  }
+  //! Returns the orientation of the second edge
+  Standard_Integer SecondEdgeOrientation() const
+  {
+    return myEdgesOrientations[1];
+  }
+  //! Returns the third edge
+  Standard_Integer ThirdEdge() const
+  {
+    return myEdges[2];
+  }
+  //! Returns the orientation of the third edge
+  Standard_Integer ThirdEdgeOrientation() const
+  {
+    return myEdgesOrientations[2];
+  }
+  //! Returns the deflection of the triangle
+  Standard_Real Deflection() const
+  {
+    return myDeflection;
+  }
+  //! Returns possibility of the intersection
+  Standard_Boolean IsIntersectionPossible() const
+  {
+    return myIsIntersectionPossible;
+  }
+  //! Returns true if the triangle has interfered the other triangle
+  Standard_Boolean HasIntersection() const
+  {
+    return myHasIntersection;
+  }
+  //! Returns the Degenerated flag
+  Standard_Boolean IsDegenerated() const
+  {
+    return myIsDegenerated;
+  }
+  //! Sets the first point
+  void SetFirstPoint(const Standard_Integer thePoint)
+  {
+    myPoints[0] = thePoint;
+  }
+  //! Sets the second point
+  void SetSecondPoint(const Standard_Integer thePoint)
+  {
+    myPoints[1] = thePoint;
+  }
+  //! Sets the third point
+  void SetThirdPoint(const Standard_Integer thePoint)
+  {
+    myPoints[2] = thePoint;
+  }
+  //! Sets the first edge
+  void SetFirstEdge(const Standard_Integer theEdge,
+                    const Standard_Integer theEdgeOrientation)
+  {
+    myEdges[0] = theEdge;
+    myEdgesOrientations[0] = theEdgeOrientation;
+  }
+  //! Sets the second edge
+  void SetSecondEdge(const Standard_Integer theEdge,
+                     const Standard_Integer theEdgeOrientation)
+  {
+    myEdges[1] = theEdge;
+    myEdgesOrientations[1] = theEdgeOrientation;
+  }
+  //! Sets the third edge
+  void SetThirdEdge(const Standard_Integer theEdge,
+                    const Standard_Integer theEdgeOrientation)
+  {
+    myEdges[2] = theEdge;
+    myEdgesOrientations[2] = theEdgeOrientation;
+  }
+  //! Sets the deflection
+  void SetDeflection(const Standard_Real theDeflection)
+  {
+    myDeflection = theDeflection;
+  }
+  //! Sets the flag of possibility of intersection
+  void SetIntersectionPossible(const Standard_Boolean theIP)
+  {
+    myIsIntersectionPossible = theIP;
+  }
+  //! Sets the flag of intersection
+  void SetIntersection(const Standard_Boolean theInt)
+  {
+    myHasIntersection = theInt;
+  }
+  //! Sets the degenerated flag
+  void SetDegenerated(const Standard_Boolean theDegFlag)
+  {
+    myIsDegenerated = theDegFlag;
+  }
+  //! Gets the edge number by the index
+  Standard_Integer GetEdgeNumber(const Standard_Integer theEdgeIndex) const
+  {
+    return ((theEdgeIndex >= 1 && theEdgeIndex <= 3) ? myEdges[theEdgeIndex - 1] : 0);
+  }
+  //! Sets the edge by the index
+  void SetEdge(const Standard_Integer theEdgeIndex,
+               const Standard_Integer theEdgeNumber)
+  {
+    if (theEdgeIndex >= 1 && theEdgeIndex <= 3) {
+      myEdges[theEdgeIndex - 1] = theEdgeNumber;
+    }
+  }
+  //! Gets the edges orientation by the index
+  Standard_Integer GetEdgeOrientation(const Standard_Integer theEdgeIndex) const
+  {
+    return ((theEdgeIndex >= 1 && theEdgeIndex <= 3) ?
+      myEdgesOrientations[theEdgeIndex - 1] : 0);
+  }
+  //! Sets the edges orientation by the index
+  void SetEdgeOrientation(const Standard_Integer theEdgeIndex,
+                          const Standard_Integer theEdgeOrientation)
+  {
+    if (theEdgeIndex >= 1 && theEdgeIndex <= 3) {
+      myEdgesOrientations[theEdgeIndex - 1] = theEdgeOrientation;
+    }
+  }
 
+  //! Computes the deflection for the triangle
+  Standard_EXPORT Standard_Real ComputeDeflection(const Handle(Adaptor3d_HSurface)& theSurface,
+                                                  const IntPolyh_ArrayOfPoints& thePoints);
 
-protected:
+  //! Gets the adjacent triangle
+  Standard_EXPORT Standard_Integer GetNextTriangle(const Standard_Integer theTriangle,
+                                                   const Standard_Integer theEdgeNum,
+                                                   const IntPolyh_ArrayOfEdges& TEdges) const;
 
+  //! Splits the triangle on two to decrease its deflection
+  Standard_EXPORT void MiddleRefinement(const Standard_Integer theTriangleNumber,
+                                        const Handle(Adaptor3d_HSurface)& theSurface,
+                                        IntPolyh_ArrayOfPoints& TPoints,
+                                        IntPolyh_ArrayOfTriangles& TTriangles,
+                                        IntPolyh_ArrayOfEdges& TEdges);
 
+  //! Splits the current triangle and new triangles until the refinement
+  //! criterion is not achieved
+  Standard_EXPORT void MultipleMiddleRefinement(const Standard_Real theRefineCriterion,
+                                                const Bnd_Box& theBox,
+                                                const Standard_Integer theTriangleNumber,
+                                                const Handle(Adaptor3d_HSurface)& theSurface,
+                                                IntPolyh_ArrayOfPoints& TPoints,
+                                                IntPolyh_ArrayOfTriangles& TTriangles,
+                                                IntPolyh_ArrayOfEdges& TEdges);
 
+  //! Links edges to triangle
+  Standard_EXPORT void LinkEdges2Triangle(const IntPolyh_ArrayOfEdges& TEdges,
+                                          const Standard_Integer theEdge1,
+                                          const Standard_Integer theEdge2,
+                                          const Standard_Integer theEdge3);
 
+  //! Sets the appropriate edge and orientation for the triangle.
+  Standard_EXPORT void SetEdgeAndOrientation(const IntPolyh_Edge& theEdge,
+                                             const Standard_Integer theEdgeIndex);
 
-private:
+  //! Returns the bounding box of the triangle.
+  Standard_EXPORT const Bnd_Box& BoundingBox(const IntPolyh_ArrayOfPoints& thePoints);
 
+  //! Dumps the contents of the triangle.
+  Standard_EXPORT void Dump (const Standard_Integer v) const;
 
+protected:
 
-  Standard_Integer p1;
-  Standard_Integer p2;
-  Standard_Integer p3;
-  Standard_Integer e1;
-  Standard_Integer oe1;
-  Standard_Integer e2;
-  Standard_Integer oe2;
-  Standard_Integer e3;
-  Standard_Integer oe3;
-  Standard_Integer II;
-  Standard_Integer IP;
-  Standard_Real Fleche;
+private:
 
+  Standard_Integer myPoints[3];
+  Standard_Integer myEdges[3];
+  Standard_Integer myEdgesOrientations[3];
+  Standard_Boolean myHasIntersection:1;
+  Standard_Boolean myIsIntersectionPossible:1;
+  Standard_Boolean myIsDegenerated:1;
+  Standard_Real myDeflection;
+  Bnd_Box myBox;
 
 };
 
-
-
-
-
-
-
 #endif // _IntPolyh_Triangle_HeaderFile