Merge branch 'master' into CR32857_use_trim_surface

myGeom is now initialized by input surface for Draft_FaceInfo even if its type is Geom_RectangularTrimmedSurface.
input cylindric faces is not necessary to be trimmed (fixes bug712_1)

src/BRepAlgo/BRepAlgo_Loop.cxx

@@ -42,12 +42,14 @@
 #include <TopTools_SequenceOfShape.hxx>
 
 #include <stdio.h>
+//#define OCCT_DEBUG_ALGO
+//#define DRAW
 #ifdef DRAW
 #include <DBRep.hxx>
 #pragma comment(lib,"TKDraw")
 #endif
 #ifdef OCCT_DEBUG_ALGO
-Standard_Boolean AffichLoop  = Standard_False;
+Standard_Boolean AffichLoop  = Standard_True;
 Standard_Integer NbLoops     = 0;
 Standard_Integer NbWires     = 1;
 static char* name = new char[100];
@@ -58,7 +60,8 @@ static char* name = new char[100];
 //purpose  : 
 //=======================================================================
 
-BRepAlgo_Loop::BRepAlgo_Loop()
+BRepAlgo_Loop::BRepAlgo_Loop():
+  myTolConf (0.001)
 {
 }
 
@@ -185,7 +188,6 @@ static TopoDS_Vertex  UpdateClosedEdge(const TopoDS_Edge&         E,
   Standard_Boolean OnStart = 0, OnEnd = 0;
   //// modified by jgv, 13.04.04 for OCC5634 ////
   TopExp::Vertices (E,V1,V2);
-  //Standard_Real    Tol = Precision::Confusion();
   Standard_Real    Tol = BRep_Tool::Tolerance( V1 );
   ///////////////////////////////////////////////
   
@@ -427,13 +429,12 @@ static void StoreInMVE (const TopoDS_Face&                  F,
 			TopoDS_Edge&                  E,
 			TopTools_IndexedDataMapOfShapeListOfShape& MVE,
 			Standard_Boolean&                   YaCouture,
-			TopTools_DataMapOfShapeShape& VerticesForSubstitute )
+			TopTools_DataMapOfShapeShape& VerticesForSubstitute,
+            const Standard_Real theTolConf)
 {      
   TopoDS_Vertex V1, V2, V;
   TopTools_ListOfShape Empty;
   
-  Standard_Real Tol = 0.001; //5.e-05; //5.e-07;
-//  gp_Pnt P1, P2, P;
   gp_Pnt P1, P;
   BRep_Builder BB;
   for (Standard_Integer iV = 1; iV <= MVE.Extent(); iV++)
@@ -449,7 +450,7 @@ static void StoreInMVE (const TopoDS_Face&                  F,
 	{
 	  V1 = TopoDS::Vertex( itl.Value() );
 	  P1 = BRep_Tool::Pnt( V1 );
-	  if (P.IsEqual( P1, Tol ) && !V.IsSame(V1))
+	  if (P.IsEqual( P1, theTolConf ) && !V.IsSame(V1))
 	    {
 	      V.Orientation( V1.Orientation() );
 	      if (VerticesForSubstitute.IsBound( V1 ))
@@ -574,7 +575,7 @@ void BRepAlgo_Loop::Perform()
         TopoDS_Edge& E = TopoDS::Edge(itl1.Value());
         if (!Emap.Add(E))
           continue;
-        StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute);
+        StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute, myTolConf);
       }
     }
   }
@@ -586,7 +587,7 @@ void BRepAlgo_Loop::Perform()
   for (itl.Initialize(myConstEdges); itl.More(); itl.Next()) {
     TopoDS_Edge& E = TopoDS::Edge(itl.Value());
     if (DejaVu.Add(E))
-      StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute);
+      StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute, myTolConf);
   }
 
 #ifdef DRAW
@@ -626,42 +627,42 @@ void BRepAlgo_Loop::Perform()
     //--------------------------------
     RemovePendingEdges(MVE);
 
-    if (MVE.Extent() == 0) break; 
+    if (MVE.Extent() == 0) break;
     //--------------------------------
     // Start edge.
     //--------------------------------
     EF = CE = TopoDS::Edge(MVE(1).First());
-    TopExp::Vertices(CE,V1,V2);
+    TopExp::Vertices(CE, V1, V2);
     //--------------------------------
     // VF vertex start of new wire
     //--------------------------------
-    if (CE.Orientation() == TopAbs_FORWARD) { CV = VF = V1;}
-    else                                    { CV = VF = V2;}
+    if (CE.Orientation() == TopAbs_FORWARD) { CV = VF = V1; }
+    else { CV = VF = V2; }
     if (!MVE.Contains(CV)) continue;
     TopTools_ListOfShape& aListEdges = MVE.ChangeFromKey(CV);
-    for ( itl.Initialize(aListEdges); itl.More(); itl.Next()) {
+    for (itl.Initialize(aListEdges); itl.More(); itl.Next()) {
       if (itl.Value().IsEqual(CE)) {
-	aListEdges.Remove(itl);
-	break;
+        aListEdges.Remove(itl);
+        break;
       }
     }
-    End  = Standard_False;
-    
+    End = Standard_False;
+
     while (!End) {
       //-------------------------------
       // Construction of a wire.
       //-------------------------------
-      TopExp::Vertices(CE,V1,V2);
+      TopExp::Vertices(CE, V1, V2);
       if (!CV.IsSame(V1)) CV = V1; else CV = V2;
 
-      B.Add (NW,CE);
+      B.Add(NW, CE);
       UsedEdges.Add(CE);
 
       if (!MVE.Contains(CV) || MVE.FindFromKey(CV).IsEmpty()) {
         End = Standard_True;
       }
       else {
-        End = !SelectEdge(myFace,CE,CV,NE,MVE.ChangeFromKey(CV));
+        End = !SelectEdge(myFace, CE, CV, NE, MVE.ChangeFromKey(CV));
         if (!End) {
           CE = NE;
           if (MVE.FindFromKey(CV).IsEmpty())
@@ -672,35 +673,41 @@ void BRepAlgo_Loop::Perform()
     //--------------------------------------------------
     // Add new wire to the set of wires
     //------------------------------------------------
-    Standard_Real Tol = 0.001; //5.e-05; //5.e-07;
-    TopExp_Explorer explo( NW, TopAbs_VERTEX );
-    for (; explo.More(); explo.Next())
-      {
-      const TopoDS_Vertex& aV = TopoDS::Vertex( explo.Current() );
-      Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &(aV).TShape());
-      TV->Tolerance( Tol );
-      TV->Modified( Standard_True );
-      }
-    for (explo.Init( NW, TopAbs_EDGE ); explo.More(); explo.Next())
-      {
-      const TopoDS_Edge& aE = TopoDS::Edge( explo.Current() );
-      Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &(aE).TShape());
-      TE->Tolerance( Tol );
-      TE->Modified( Standard_True );
-      }
 
-    if (VF.IsSame(CV) && SamePnt2d(VF,EF,CE,myFace))
+    if (VF.IsSame(CV))
     {
-      NW.Closed (Standard_True);
-      myNewWires.Append (NW);
+      if (SamePnt2d(VF, EF, CE, myFace))
+      {
+        NW.Closed(Standard_True);
+        myNewWires.Append(NW);
+      }
+      else if(BRep_Tool::Tolerance(VF) < myTolConf)
+      {
+        BRep_Builder aBB;
+        aBB.UpdateVertex(VF, myTolConf);
+        if (SamePnt2d(VF, EF, CE, myFace))
+        {
+          NW.Closed(Standard_True);
+          myNewWires.Append(NW);
+        }
+#ifdef OCCT_DEBUG_ALGO
+        else
+        {
+          std::cout << "BRepAlgo_Loop: Open Wire" << std::endl;
+          if (AffichLoop)
+            std::cout << "OpenWire is : NW_" << NbLoops << "_" << NbWires << std::endl;
+        }
+#endif
+      }
     }
 #ifdef OCCT_DEBUG_ALGO
     else {
-      std::cout <<"BRepAlgo_Loop: Open Wire"<<std::endl;
+      std::cout << "BRepAlgo_Loop: Open Wire" << std::endl;
       if (AffichLoop)
-        std::cout << "OpenWire is : NW_"<<NbLoops<<"_"<<NbWires<<std::endl;
-      }
+        std::cout << "OpenWire is : NW_" << NbLoops << "_" << NbWires << std::endl;
+    }
 #endif
+
 #ifdef DRAW
     if (AffichLoop) {
       sprintf(name,"NW_%d_%d",NbLoops,NbWires++);	
@@ -777,8 +784,6 @@ void BRepAlgo_Loop::CutEdge (const TopoDS_Edge&          E,
       VF = TopoDS::Vertex(aLocalV);
       aLocalV = VCEI.Oriented(TopAbs_REVERSED); 
       VL = TopoDS::Vertex(aLocalV);
-//      VF = TopoDS::Vertex(VCEI.Oriented(TopAbs_FORWARD));
-//      VL = TopoDS::Vertex(VCEI.Oriented(TopAbs_REVERSED)); 
     }
     SV.Prepend(VF);
     SV.Append(VL);
@@ -813,13 +818,9 @@ void BRepAlgo_Loop::CutEdge (const TopoDS_Edge&          E,
       B.Add  (NewEdge,aLocalEdge);
       aLocalEdge = V2.Oriented(TopAbs_REVERSED);
       B.Add  (TopoDS::Edge(NewEdge),aLocalEdge);
-//      B.Add  (NewEdge,V1.Oriented(TopAbs_FORWARD));
-//      B.Add  (NewEdge,V2.Oriented(TopAbs_REVERSED));
       if (V1.IsSame(VF)) 
 	U1 = f;
       else 
-//	U1=BRep_Tool::Parameter
-//	  (TopoDS::Vertex(V1.Oriented(TopAbs_INTERNAL)),WE);
 	{
 	  TopoDS_Shape aLocalV = V1.Oriented(TopAbs_INTERNAL);
 	  U1=BRep_Tool::Parameter(TopoDS::Vertex(aLocalV),WE);
@@ -830,8 +831,6 @@ void BRepAlgo_Loop::CutEdge (const TopoDS_Edge&          E,
 	{
 	  TopoDS_Shape aLocalV = V2.Oriented(TopAbs_INTERNAL);
 	  U2=BRep_Tool::Parameter(TopoDS::Vertex(aLocalV),WE);
-//	U2=BRep_Tool::Parameter
-//	  (TopoDS::Vertex(V2.Oriented(TopAbs_INTERNAL)),WE);
 	}
       B.Range (TopoDS::Edge(NewEdge),U1,U2);
 #ifdef DRAW

src/BRepAlgo/BRepAlgo_Loop.hxx

@@ -86,8 +86,17 @@ public:
   
   Standard_EXPORT void VerticesForSubstitute (TopTools_DataMapOfShapeShape& VerVerMap);
 
+  //! Set maximal tolerance used for comparing distaces between vertices. 
+  void SetTolConf(const Standard_Real theTolConf)
+  {
+    myTolConf = theTolConf;
+  }
 
-
+  //! Get maximal tolerance used for comparing distaces between vertices. 
+  Standard_Real GetTolConf() const
+  {
+    return myTolConf;
+  }
 
 protected:
 
@@ -108,6 +117,7 @@ private:
   TopTools_DataMapOfShapeListOfShape myCutEdges;
   TopTools_DataMapOfShapeShape myVerticesForSubstitute;
   BRepAlgo_Image myImageVV;
+  Standard_Real myTolConf;
 
 
 };

src/BRepExtrema/BRepExtrema_ProximityDistTool.cxx

@@ -43,6 +43,8 @@ BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool()
 //=======================================================================
 BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
                                                               const Standard_Integer theNbSamples1,
+                                                              const BVH_Array3d& theAddVertices1,
+                                                              const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
                                                               const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                               const BRepExtrema_ShapeList& theShapeList1,
                                                               const BRepExtrema_ShapeList& theShapeList2)
@@ -55,6 +57,7 @@ BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool (const Handle(BRepE
 {
   LoadTriangleSets (theSet1, theSet2);
   LoadShapeLists (theShapeList1, theShapeList2);
+  LoadAdditionalPointsFirstSet (theAddVertices1, theAddStatus1);
 }
 
 //=======================================================================
@@ -69,7 +72,7 @@ void BRepExtrema_ProximityDistTool::LoadTriangleSets (const Handle(BRepExtrema_T
 }
 
 //=======================================================================
-//function : LoadTriangleSets
+//function : LoadShapeLists
 //purpose  : Loads the given list of subshapes into the proximity tool
 //=======================================================================
 void BRepExtrema_ProximityDistTool::LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
@@ -78,23 +81,33 @@ void BRepExtrema_ProximityDistTool::LoadShapeLists (const BRepExtrema_ShapeList&
   myShapeList1 = theShapeList1;
   myShapeList2 = theShapeList2;
 }
-//=======================================================================
-//function : Perform
-//purpose  : Performs searching of the proximity distance
-//=======================================================================
-void BRepExtrema_ProximityDistTool::Perform()
-{
-  SetBVHSet (mySet2.get());
 
-  const BVH_Array3d& aVertices1 = mySet1->GetVertices();
-  Standard_Integer aVtxSize = (Standard_Integer)aVertices1.size();
+//=======================================================================
+//function : LoadAdditionalPointsFirstSet
+//purpose  : Loads given additional vertices and their statuses
+//=======================================================================
+void BRepExtrema_ProximityDistTool::LoadAdditionalPointsFirstSet (const BVH_Array3d& theAddVertices1,
+                                                                  const NCollection_Vector<ProxPnt_Status>& theAddStatus1)
+{
+  myAddVertices1 = theAddVertices1;
+  myAddStatus1 = theAddStatus1;
+}
+
+//=======================================================================
+//function : goThroughtSet1
+//purpose  : Goes throught vertices from the 1st set
+//=======================================================================
+void BRepExtrema_ProximityDistTool::goThroughtSet1 (const BVH_Array3d& theVertices1,
+                                                    const Standard_Boolean theIsAdditionalSet)
+{
+  Standard_Integer aVtxSize = (Standard_Integer)theVertices1.size();
   Standard_Integer aVtxStep = Max (myNbSamples1 <= 0 ? 1 : aVtxSize / myNbSamples1, 1);
   for (Standard_Integer aVtxIdx = 0; aVtxIdx < aVtxSize; aVtxIdx += aVtxStep)
   {
     myDistance = std::numeric_limits<Standard_Real>::max();
     myMinDistance = std::numeric_limits<Standard_Real>::max();
     myIsDone = Standard_False;
-    SetObject (aVertices1[aVtxIdx]);
+    SetObject (theVertices1[aVtxIdx]);
 
     ComputeDistance();
 
@@ -102,20 +115,31 @@ void BRepExtrema_ProximityDistTool::Perform()
 
     if (IsDone() && myDistance > myProxDist)
     {
-      myPnt1 = aVertices1[aVtxIdx];
+      myPnt1 = theVertices1[aVtxIdx];
       myPnt2 = myExtremaPoint;
       myProxDist = myDistance;
       myProxVtxIdx1 = aVtxIdx;
+      myIsProxVtx1FromAddSet = theIsAdditionalSet;
       myProxPrjState = myExtPrjState;
     }
   }
+}
 
-   myIsDone = myProxDist > -1.;
+//=======================================================================
+//function : Perform
+//purpose  : Performs searching of the proximity distance
+//=======================================================================
+void BRepExtrema_ProximityDistTool::Perform()
+{
+  SetBVHSet (mySet2.get());
+  goThroughtSet1 (mySet1->GetVertices(), Standard_False);
+  goThroughtSet1 (myAddVertices1, Standard_True);
 
-   if (myIsDone)
-   {
-     DefineStatusProxPnt();
-   }
+  myIsDone = myProxDist > -1.;
+  if (myIsDone)
+  {
+    DefineStatusProxPnt();
+  }
 }
 
 static Standard_Real pointBoxSquareMaxDistance (const BVH_Vec3d& thePoint,
@@ -247,7 +271,12 @@ Standard_Real BRepExtrema_ProximityDistTool::ComputeDistance()
   return myDistance;
 }
 
-static Standard_Boolean isNodeOnBorder (const Standard_Integer theNodeIdx, const Handle (Poly_Triangulation)& theTr)
+//=======================================================================
+//function : IsNodeOnBorder
+//purpose  : Returns true if the node is on the boarder
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::IsNodeOnBorder (const Standard_Integer theNodeIdx,
+                                                                const Handle(Poly_Triangulation)& theTr)
 {
   Poly_Connect aPolyConnect (theTr);
 
@@ -279,12 +308,49 @@ static Standard_Boolean isNodeOnBorder (const Standard_Integer theNodeIdx, const
   return Standard_False;
 }
 
+//=======================================================================
+//function : IsEdgeOnBorder
+//purpose  : Returns true if the edge is on the boarder
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::IsEdgeOnBorder (const Standard_Integer theTrgIdx,
+                                                                const Standard_Integer theFirstEdgeNodeIdx,
+                                                                const Standard_Integer theSecondEdgeNodeIdx,
+                                                                const Handle(Poly_Triangulation)& theTr)
+{
+  Poly_Connect aPolyConnect (theTr);
+
+  Standard_Integer aAdjTrg[3];
+  aPolyConnect.Triangles (theTrgIdx, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
+
+  for (Standard_Integer j = 0; j < 3; j++)
+  {
+    Standard_Integer k = (j + 1) % 3;
+    if (aAdjTrg[j] == 0) //free segment of triangle
+    {
+      //are ends of free segment and it is a part of border
+      if (j == theFirstEdgeNodeIdx &&
+          k == theSecondEdgeNodeIdx)
+      {
+        return Standard_True;
+      }
+    }
+  }
+
+  return Standard_False;
+}
+
 //=======================================================================
 //function : defineStatusProxPnt1
 //purpose  : Defines the status of proximity point from 1st BVH
 //=======================================================================
 void BRepExtrema_ProximityDistTool::defineStatusProxPnt1()
 {
+  if (myIsProxVtx1FromAddSet)
+  {
+    myPntStatus1 = myAddStatus1[myProxVtxIdx1];
+    return;
+  }
+
   Standard_Integer aFaceID1 = mySet1->GetShapeIDOfVtx (myProxVtxIdx1);
 
   if (myShapeList1 (aFaceID1).ShapeType() == TopAbs_EDGE)
@@ -314,9 +380,9 @@ void BRepExtrema_ProximityDistTool::defineStatusProxPnt1()
 
     TopLoc_Location aLocation;
     const TopoDS_Face& aF = TopoDS::Face (myShapeList1 (aFaceID1));
-    Handle (Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
+    Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
 
-    if (isNodeOnBorder (aNodeIdx, aTr))
+    if (IsNodeOnBorder (aNodeIdx, aTr))
     {
       myPntStatus1 = ProxPnt_Status_BORDER;
     }
@@ -398,7 +464,7 @@ void BRepExtrema_ProximityDistTool::defineStatusProxPnt2()
     {
       TopLoc_Location aLocation;
       const TopoDS_Face& aF = TopoDS::Face (myShapeList2 (aFaceID2));
-      Handle (Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
+      Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
 
       NCollection_Array1<Standard_Integer> aVtxIndicesOfTrg;
       mySet2->GetVtxIndices (aTrgIdx, aVtxIndicesOfTrg);
@@ -408,7 +474,7 @@ void BRepExtrema_ProximityDistTool::defineStatusProxPnt2()
         Standard_Integer aNodeNum = myProxPrjState.GetNumberOfFirstNode();
         Standard_Integer aNodeIdx = mySet2->GetVtxIdxInShape (aVtxIndicesOfTrg[aNodeNum]) + 1;
 
-        if (isNodeOnBorder (aNodeIdx, aTr))
+        if (IsNodeOnBorder (aNodeIdx, aTr))
         {
           myPntStatus2 = ProxPnt_Status_BORDER;
         }
@@ -419,27 +485,18 @@ void BRepExtrema_ProximityDistTool::defineStatusProxPnt2()
       }
       else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
       {
-        myPntStatus2 = ProxPnt_Status_MIDDLE;
-
-        Poly_Connect aPolyConnect (aTr);
         Standard_Integer aTrgIdxInShape = mySet2->GetTrgIdxInShape (aTrgIdx) + 1;
 
-        Standard_Integer aAdjTrg[3];
-        aPolyConnect.Triangles (aTrgIdxInShape, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
-
-        for (Standard_Integer j = 0; j < 3; j++)
+        if (IsEdgeOnBorder (aTrgIdxInShape,
+                            myProxPrjState.GetNumberOfFirstNode(),
+                            myProxPrjState.GetNumberOfLastNode(),
+                            aTr))
         {
-          Standard_Integer k = (j + 1) % 3;
-          if (aAdjTrg[j] == 0) //free segment of triangle
-          {
-            //aVtxIndicesOfTrg[j] and aVtxIndicesOfTrg[k] are ends of free segment and it is a part of border
-            if (j == myProxPrjState.GetNumberOfFirstNode() &&
-                k == myProxPrjState.GetNumberOfLastNode())
-            {
-              myPntStatus2 = ProxPnt_Status_BORDER;
-              break;
-            }
-          }
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
         }
       } //else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
     }

src/BRepExtrema/BRepExtrema_ProximityDistTool.hxx

@@ -21,6 +21,7 @@
 #include <BRepExtrema_TriangleSet.hxx>
 #include <BVH_Distance.hxx>
 #include <BVH_Tools.hxx>
+#include <Poly_Triangulation.hxx>
 
 //! Tool class for computation the proximity distance from first 
 //! primitive set to second one that is the maximal from minimum 
@@ -93,6 +94,8 @@ public:
   //! Creates new tool for the given element sets.
   Standard_EXPORT BRepExtrema_ProximityDistTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
                                                  const Standard_Integer theNbSamples1,
+                                                 const BVH_Array3d& theAddVertices1,
+                                                 const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
                                                  const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                  const BRepExtrema_ShapeList& theShapeList1,
                                                  const BRepExtrema_ShapeList& theShapeList2);
@@ -107,6 +110,10 @@ public:
   Standard_EXPORT void LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
                                        const BRepExtrema_ShapeList& theShapeList2);
 
+  //! Loads given additional vertices and their statuses.
+  void LoadAdditionalPointsFirstSet (const BVH_Array3d& theAddVertices1,
+                                     const NCollection_Vector<ProxPnt_Status>& theAddStatus1);
+
   //! Performs searching of the proximity distance.
   Standard_EXPORT void Perform();
 
@@ -121,6 +128,20 @@ public: //! @name Reject/Accept implementations
   Standard_EXPORT virtual Standard_Boolean Accept (const Standard_Integer theSgmIdx,
                                                    const Standard_Real&) Standard_OVERRIDE;
 
+public:
+
+  //! Returns true if the node is on the boarder.
+  Standard_EXPORT static Standard_Boolean IsNodeOnBorder (const Standard_Integer theNodeIdx,
+                                                          const Handle (Poly_Triangulation)& theTr);
+
+  //! Returns true if the edge is on the boarder.
+  Standard_EXPORT static Standard_Boolean IsEdgeOnBorder (const Standard_Integer theTrgIdx,
+                                                          const Standard_Integer theFirstEdgeNodeIdx,
+                                                          const Standard_Integer theSecondEdgeNodeIdx,
+                                                          const Handle (Poly_Triangulation)& theTr);
+
+public:
+
   //! Returns points on triangles sets, which provide the proximity distance.
   void ProximityPoints (BVH_Vec3d& thePoint1, BVH_Vec3d& thePoint2) const
   {
@@ -148,6 +169,10 @@ protected:
 
 private:
 
+  //! Goes throught vertices from the 1st set.
+  void goThroughtSet1 (const BVH_Array3d& aVertices1,
+                       const Standard_Boolean theIsAdditionalSet);
+
   //! Defines the status of proximity point from 1st BVH.
   void defineStatusProxPnt1();
 
@@ -183,6 +208,11 @@ private:
 
   Standard_Integer myNbSamples1; //!< Number of samples points on the first shape
 
+  //! Is vertex corresponding to proximity point of 1st shape from additional set
+  Standard_Integer myIsProxVtx1FromAddSet;
+  BVH_Array3d myAddVertices1; //!< Additional vertices on the 1st shape
+  NCollection_Vector<ProxPnt_Status> myAddStatus1; //!< Status of additional vertices on the 1st shape
+
   //! Vertex index from 1st BVH corresponding to proximity point of 1st shape
   Standard_Integer myProxVtxIdx1;
 

src/BRepExtrema/BRepExtrema_ProximityValueTool.cxx

@@ -1,4 +1,4 @@
-// Created on: 2022-08-08
+// Created on: 2022-08-08
 // Created by: Kseniya NOSULKO
 // Copyright (c) 2022 OPEN CASCADE SAS
 //
@@ -14,17 +14,32 @@
 // commercial license or contractual agreement.
 
 #include <BRepExtrema_ProximityValueTool.hxx>
+#include <BRepExtrema_ProximityDistTool.hxx>
+
+#include <BRep_Tool.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <BRepGProp.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <GCPnts_QuasiUniformAbscissa.hxx>
+#include <GProp_GProps.hxx> 
+#include <Poly_Connect.hxx>
+#include <TopoDS.hxx>
 
 //=======================================================================
 //function : BRepExtrema_ProximityValueTool
 //purpose  : Creates new unitialized proximity tool
 //=======================================================================
 BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool()
-: myDistance (std::numeric_limits<Standard_Real>::max()),
+: myIsRefinementRequired1 (Standard_False),
+  myIsRefinementRequired2 (Standard_False),
+  myDistance (std::numeric_limits<Standard_Real>::max()),
   myIsDone (Standard_False),
   myNbSamples1(0),
   myNbSamples2(0)
-{}
+{
+  // Should be initialized later
+  myIsInitS1 = myIsInitS2 = Standard_False;
+}
 
 //=======================================================================
 //function : BRepExtrema_ProximityValueTool
@@ -34,13 +49,15 @@ BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool (const Handle(BRe
                                                                 const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                                 const BRepExtrema_ShapeList& theShapeList1,
                                                                 const BRepExtrema_ShapeList& theShapeList2)
-: myDistance (std::numeric_limits<Standard_Real>::max()),
+: myIsRefinementRequired1 (Standard_False),
+  myIsRefinementRequired2 (Standard_False),
+  myDistance (std::numeric_limits<Standard_Real>::max()),
   myIsDone (Standard_False),
-  myNbSamples1(0),
-  myNbSamples2(0)
+  myNbSamples1 (0),
+  myNbSamples2 (0)
 {
-  LoadTriangleSets (theSet1, theSet2);
   LoadShapeLists (theShapeList1, theShapeList2);
+  LoadTriangleSets (theSet1, theSet2);
 }
 
 //=======================================================================
@@ -53,7 +70,94 @@ void BRepExtrema_ProximityValueTool::LoadTriangleSets (const Handle(BRepExtrema_
   mySet1 = theSet1;
   mySet2 = theSet2;
 
-  myIsDone = Standard_False;
+  MarkDirty();
+}
+
+//=======================================================================
+//function : calcEdgeRefinementStep
+//purpose  : Calculates the edge refinement step
+//=======================================================================
+static Standard_Real calcEdgeRefinementStep (const TopoDS_Edge& theEdge,
+                                             const Standard_Integer theNbNodes)
+{
+  if (theNbNodes < 2)
+    return 0;
+
+  BRepAdaptor_Curve aBAC (theEdge);
+  Standard_Real aLen = GCPnts_AbscissaPoint::Length (aBAC);
+  return aLen / (Standard_Real)(theNbNodes - 1);
+}
+
+//=======================================================================
+//function : calcFaceRefinementStep
+//purpose  : Calculates the face refinement step as an approximate square
+// (Shape area / number triangles) * 2
+//=======================================================================
+static Standard_Real calcFaceRefinementStep (const TopoDS_Face& theFace,
+                                             const Standard_Integer theNbTrg)
+{
+  if (theNbTrg < 1)
+    return 0;
+
+  GProp_GProps props;
+  BRepGProp::SurfaceProperties (theFace, props);
+  Standard_Real aArea = props.Mass();
+  return 2 * (aArea / (Standard_Real)theNbTrg);
+}
+
+//=======================================================================
+//function : getInfoForRefinement
+//purpose  : Gets shape data for further refinement
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getInfoForRefinement (const TopoDS_Shape& theShape,
+                                                                       TopAbs_ShapeEnum& theShapeType,
+                                                                       Standard_Integer& theNbNodes,
+                                                                       Standard_Real& theStep)
+{
+  if (theShape.ShapeType() == TopAbs_FACE)
+  {
+    theShapeType = TopAbs_FACE;
+    TopoDS_Face aF = TopoDS::Face (theShape);
+
+    TopLoc_Location aLocation;
+    Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aF, aLocation);
+
+    if (aTriangulation.IsNull())
+    {
+      return Standard_False;
+    }
+
+    theNbNodes = aTriangulation->NbNodes();
+    Standard_Integer aNbTrg = aTriangulation->NbTriangles();
+    theStep = calcFaceRefinementStep (aF, aNbTrg);
+  }
+  else if (theShape.ShapeType() == TopAbs_EDGE)
+  {
+    theShapeType = TopAbs_EDGE;
+    TopoDS_Edge aE = TopoDS::Edge (theShape);
+
+    TopLoc_Location aLocation;
+    Handle(Poly_Polygon3D) aPolygon = BRep_Tool::Polygon3D (aE, aLocation);
+
+    if (aPolygon.IsNull())
+    {
+      return Standard_False;
+    }
+
+    theNbNodes = aPolygon->NbNodes();
+    theStep = calcEdgeRefinementStep (aE, theNbNodes);
+  }
+  else
+  {
+    return Standard_False;
+  }
+
+  if (theStep < Precision::Confusion())
+  {
+    return Standard_False;
+  }
+
+  return Standard_True;
 }
 
 //=======================================================================
@@ -66,7 +170,13 @@ void BRepExtrema_ProximityValueTool::LoadShapeLists (const BRepExtrema_ShapeList
   myShapeList1 = theShapeList1;
   myShapeList2 = theShapeList2;
 
-  myIsDone = Standard_False;
+  myShape1 = theShapeList1 (0);
+  myIsInitS1 = getInfoForRefinement (myShape1, myShapeType1, myNbNodes1, myStep1);
+
+  myShape2 = theShapeList2 (0);
+  myIsInitS2 = getInfoForRefinement (myShape2, myShapeType2, myNbNodes2, myStep2);
+
+  MarkDirty();
 }
 
 //=======================================================================
@@ -79,7 +189,7 @@ void BRepExtrema_ProximityValueTool::SetNbSamplePoints(const Standard_Integer th
   myNbSamples1 = theSamples1;
   myNbSamples2 = theSamples2;
 
-  myIsDone = Standard_False;
+  MarkDirty();
 }
 
 //=======================================================================
@@ -88,6 +198,8 @@ void BRepExtrema_ProximityValueTool::SetNbSamplePoints(const Standard_Integer th
 //=======================================================================
 Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle(BRepExtrema_TriangleSet)& theSet1,
                                                                     const Standard_Integer theNbSamples1,
+                                                                    const BVH_Array3d& theAddVertices1,
+                                                                    const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
                                                                     const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                                     const BRepExtrema_ShapeList& theShapeList1,
                                                                     const BRepExtrema_ShapeList& theShapeList2,
@@ -96,7 +208,8 @@ Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle
                                                                     ProxPnt_Status& thePointStatus1,
                                                                     ProxPnt_Status& thePointStatus2) const
 {
-  BRepExtrema_ProximityDistTool aProxDistTool (theSet1, theNbSamples1, theSet2, theShapeList1, theShapeList2);
+  BRepExtrema_ProximityDistTool aProxDistTool (theSet1, theNbSamples1, theAddVertices1, theAddStatus1,
+                                               theSet2, theShapeList1, theShapeList2);
   aProxDistTool.Perform();
 
   if (!aProxDistTool.IsDone())
@@ -108,21 +221,311 @@ Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle
   return aProxDistTool.ProximityDistance();
 }
 
+//=======================================================================
+//function : getEdgeAdditionalVertices
+//purpose  : Gets additional vertices and their statuses on the edge with the input step
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getEdgeAdditionalVertices (
+  const TopoDS_Edge& theEdge,
+  const Standard_Real theStep,
+  BVH_Array3d& theAddVertices,
+  NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  BRepAdaptor_Curve aBAC (theEdge);
+  
+  if (!aBAC.Is3DCurve() || theStep < Precision::Confusion())
+  {
+    return Standard_False;
+  }
+
+  Standard_Real aLen = GCPnts_AbscissaPoint::Length (aBAC);
+  Standard_Integer aNbSamplePoints = (Standard_Integer) (aLen / theStep) + 1;
+
+  GCPnts_QuasiUniformAbscissa aGCPnts (aBAC, Max (3, aNbSamplePoints));
+
+  if (!aGCPnts.IsDone())
+    return Standard_False;
+
+  Standard_Integer aNbNodes = aGCPnts.NbPoints();
+  for (Standard_Integer aVertIdx = 2; aVertIdx < aNbNodes; ++aVertIdx) //don't add extreme points
+  {
+    Standard_Real aPar = aGCPnts.Parameter (aVertIdx);
+    gp_Pnt aP = aBAC.Value (aPar);
+
+    theAddVertices.push_back (BVH_Vec3d (aP.X(), aP.Y(), aP.Z()));
+    theAddStatuses.Append (ProxPnt_Status::ProxPnt_Status_MIDDLE);
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : doRecurTrgSplit
+//purpose  : Splits the triangle into two ones recursively, halving the longest side
+//           untill the area of ​​the current triangle > input step
+//! @param theTrg points of the triangle to be splitted
+//! @param theEdgesStatus status of triangle edges - on the border or middle of the face
+//! @param theTol telerance used in search of coincidence points
+//! @param theStep minimum area of ​​the resulting triangle
+//! @param theAddVertices vertices obtained halving sides
+//! @param theAddStatuses status of obtained vertices - on the border or middle of the face,
+//! from triangulation of which the input triangle is
+//=======================================================================
+void BRepExtrema_ProximityValueTool::doRecurTrgSplit (const gp_Pnt (&theTrg)[3],
+                                                      const ProxPnt_Status (&theEdgesStatus)[3],
+                                                      const Standard_Real theTol,
+                                                      const Standard_Real theStep,
+                                                      BVH_Array3d& theAddVertices,
+                                                      NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  gp_XYZ aTrgSide1 = theTrg[1].Coord() - theTrg[0].Coord();
+  gp_XYZ aTrgSide2 = theTrg[2].Coord() - theTrg[0].Coord();
+  Standard_Real aTrgArea = 0.5 * aTrgSide1.CrossMagnitude (aTrgSide2);
+
+  if (aTrgArea - theStep < Precision::SquareConfusion())
+    return;
+
+  Standard_Real aD[3] { theTrg[0].Distance (theTrg[1]),
+                        theTrg[1].Distance (theTrg[2]),
+                        theTrg[2].Distance (theTrg[0]) };
+  Standard_Integer aBisectedEdgeIdx = aD[0] > aD[1] ? (aD[0] > aD[2] ? 0 : 2) : (aD[1] > aD[2] ? 1 : 2);
+  gp_Pnt aCenterOfMaxSide (theTrg[aBisectedEdgeIdx].Coord());
+  aCenterOfMaxSide.BaryCenter (0.5, theTrg[(aBisectedEdgeIdx + 1) % 3], 0.5);
+
+  Bnd_Box aBox;
+  aBox.Add (aCenterOfMaxSide);
+  aBox.Enlarge (theTol);
+  myInspector.SetCurrent (aCenterOfMaxSide.Coord());
+  myCells.Inspect (aBox.CornerMin().XYZ(), aBox.CornerMax().XYZ(), myInspector);
+  
+  if (myInspector.IsNeedAdd()) //is point aCenterOfMaxSide unique
+  {
+    BVH_Vec3d aBisectingPnt (aCenterOfMaxSide.X(), aCenterOfMaxSide.Y(), aCenterOfMaxSide.Z());
+    theAddVertices.push_back (aBisectingPnt);
+    theAddStatuses.Append (theEdgesStatus[aBisectedEdgeIdx]);
+    myInspector.Add (aCenterOfMaxSide.Coord());
+    myCells.Add (static_cast<BRepExtrema_VertexInspector::Target>(theAddVertices.size()),
+                 aBox.CornerMin().XYZ(), aBox.CornerMax().XYZ());
+  }
+
+  gp_Pnt aTrg1[3] = { theTrg[0], theTrg[1], theTrg[2] };
+  gp_Pnt aTrg2[3] = { theTrg[0], theTrg[1], theTrg[2] };
+  ProxPnt_Status aEdgesStatus1[3] = { theEdgesStatus[0], theEdgesStatus[1], theEdgesStatus[2] };
+  ProxPnt_Status aEdgesStatus2[3] = { theEdgesStatus[0], theEdgesStatus[1], theEdgesStatus[2] };
+  switch (aBisectedEdgeIdx)
+  {
+  case 0:
+    aTrg1[0] = aTrg2[1] = aCenterOfMaxSide;
+    aEdgesStatus1[2] = aEdgesStatus2[1] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  case 1:
+    aTrg1[1] = aTrg2[2] = aCenterOfMaxSide;
+    aEdgesStatus1[0] = aEdgesStatus2[2] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  case 2:
+    aTrg1[2] = aTrg2[0] = aCenterOfMaxSide;
+    aEdgesStatus1[1] = aEdgesStatus2[0] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  }
+
+  doRecurTrgSplit (aTrg1, aEdgesStatus1, theTol, theStep, theAddVertices, theAddStatuses);
+  doRecurTrgSplit (aTrg2, aEdgesStatus2, theTol, theStep, theAddVertices, theAddStatuses);
+}
+
+static Standard_Real getModelRange (const TopLoc_Location& theLocation,
+                                    const Handle(Poly_Triangulation)& theTr)
+{
+  Bnd_Box aBox;
+  theTr->MinMax (aBox, theLocation.Transformation());
+  Standard_Real aXm = 0.0, aYm = 0.0, aZm = 0.0, aXM = 0.0, aYM = 0.0, aZM = 0.0;
+  aBox.Get (aXm, aYm, aZm, aXM, aYM, aZM);
+  Standard_Real aRange = aXM - aXm;
+  aRange = Max (aRange, aYM - aYm);
+  aRange = Max (aRange, aZM - aZm);
+
+  return aRange;
+}
+
+static void getNodesOfTrg (const Standard_Integer theTriIdx,
+                           const TopLoc_Location& theLocation,
+                           const Handle (Poly_Triangulation)& theTr,
+                           gp_Pnt (&theTrg)[3])
+{
+  Standard_Integer aVtxIdx1;
+  Standard_Integer aVtxIdx2;
+  Standard_Integer aVtxIdx3;
+
+  theTr->Triangle (theTriIdx).Get (aVtxIdx1, aVtxIdx2, aVtxIdx3);
+
+  gp_Pnt aVtx1 = theTr->Node (aVtxIdx1);
+  aVtx1.Transform (theLocation);
+  theTrg[0] = aVtx1;
+
+  gp_Pnt aVtx2 = theTr->Node (aVtxIdx2);
+  aVtx2.Transform (theLocation);
+  theTrg[1] = aVtx2;
+
+  gp_Pnt aVtx3 = theTr->Node (aVtxIdx3);
+  aVtx3.Transform (theLocation);
+  theTrg[2] = aVtx3;
+}
+
+// Gets status of triangle edges - on the border or middle of the face
+static void getEdgesStatus(const Standard_Integer theTriIdx,
+                           const Handle(Poly_Triangulation)& theTr,
+                           ProxPnt_Status (&theEdgesStatus1)[3])
+{
+  for (Standard_Integer j = 0; j < 3; j++)
+  {
+    Standard_Integer k = (j + 1) % 3;
+
+    if (BRepExtrema_ProximityDistTool::IsEdgeOnBorder (theTriIdx, j, k, theTr))
+    {
+      theEdgesStatus1[j] = ProxPnt_Status::ProxPnt_Status_BORDER;
+    }
+    else
+    {
+      theEdgesStatus1[j] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    }
+  }
+}
+
+//=======================================================================
+//function : getFaceAdditionalVertices
+//purpose  : Gets additional vertices and their statuses on the face with the input step (triangle square)
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getFaceAdditionalVertices (
+  const TopoDS_Face& theFace,
+  const Standard_Real theStep,
+  BVH_Array3d& theAddVertices,
+  NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  Standard_Real aTol = Precision::Confusion();
+
+  TopLoc_Location aLocation;
+  Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (theFace, aLocation);
+
+  if (aTr.IsNull())
+  {
+    return Standard_False;
+  }
+
+  myCells.Reset (Max (aTol, getModelRange (aLocation, aTr) / IntegerLast()));
+
+  for (Standard_Integer aTriIdx = 1; aTriIdx <= aTr->NbTriangles(); ++aTriIdx)
+  {
+    gp_Pnt aTrg[3];
+    ProxPnt_Status aEdgesStatus[3];
+    getNodesOfTrg (aTriIdx, aLocation, aTr, aTrg);
+    getEdgesStatus (aTriIdx, aTr, aEdgesStatus);
+    doRecurTrgSplit (aTrg, aEdgesStatus, aTol, theStep, theAddVertices, theAddStatuses);
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : getShapesVertices
+//purpose  : Gets additional vertices on shapes with refining a coarser one if it's needed
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getShapesAdditionalVertices()
+{
+  // estimate the density of meshes of shapes to add points to a coarcer one
+  // target steps for refinement
+  Standard_Real aStep1 = myStep1;
+  Standard_Real aStep2 = myStep2;
+
+  if ((myShapeType1 == TopAbs_EDGE) && (myShapeType2 == TopAbs_EDGE))
+  {
+    if (myNbSamples1 > myNbNodes1) // 1st edge needs refinement
+    {
+      aStep1 = calcEdgeRefinementStep (TopoDS::Edge (myShape1), myNbSamples1);
+      myIsRefinementRequired1 = Standard_True;
+    }
+
+    if (myNbSamples2 > myNbNodes2) // 2nd edge needs refinement
+    {
+      aStep2 = calcEdgeRefinementStep (TopoDS::Edge (myShape2), myNbSamples2);
+      myIsRefinementRequired2 = Standard_True;
+    }
+
+    if (aStep1 / aStep2 > 2.) // 1st edge needs refinement
+    {
+      myIsRefinementRequired1 = Standard_True;
+      aStep1 = aStep2;
+    }
+    else if (aStep2 / aStep1 > 2.) // 2nd edge needs refinement
+    {
+      myIsRefinementRequired2 = Standard_True;
+      aStep2 = aStep1;
+    }
+
+    if (myIsRefinementRequired1)
+    {
+      if (!getEdgeAdditionalVertices (TopoDS::Edge (myShape1), aStep1, myAddVertices1, myAddStatus1))
+      {
+        return Standard_False;
+      }
+    }
+
+    if (myIsRefinementRequired2)
+    {
+      if (!getEdgeAdditionalVertices (TopoDS::Edge (myShape2), aStep2, myAddVertices2, myAddStatus2))
+      {
+        return Standard_False;
+      }
+    }
+  }
+  else if ((myShapeType1 == TopAbs_FACE) && (myShapeType2 == TopAbs_FACE))
+  {
+    if (aStep1 / aStep2 > 2) // 1st face needs refinement
+    {
+      myIsRefinementRequired1 = Standard_True;
+      aStep1 = myStep2;
+    }
+    else if (aStep2 / aStep1 > 2.) // 2nd face needs refinement
+    {
+      myIsRefinementRequired2 = Standard_True;
+      aStep2 = myStep1;
+    }
+
+    if (myIsRefinementRequired1)
+    {
+      return getFaceAdditionalVertices (TopoDS::Face (myShape1), aStep1, myAddVertices1, myAddStatus1);
+    }
+
+    if (myIsRefinementRequired2)
+    {
+      return getFaceAdditionalVertices (TopoDS::Face (myShape2), aStep2, myAddVertices2, myAddStatus2);
+    }
+  }
+
+  return Standard_True;
+}
+
 //=======================================================================
 //function : Perform
 //purpose  : Performs the computation of the proximity value
 //=======================================================================
 void BRepExtrema_ProximityValueTool::Perform (Standard_Real& theTolerance)
 {
-  myIsDone = Standard_False;
+  if (!myIsInitS1 || !myIsInitS2 || (myShapeType1 != myShapeType2))
+    return;
+
+  //get vertices on shapes with refining a coarser mesh if it's needed
+  if (!getShapesAdditionalVertices())
+    return;
 
   // max(min) dist from the 1st shape to the 2nd one
   BVH_Vec3d aP1_1, aP1_2;
   ProxPnt_Status aPointStatus1_1 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
   ProxPnt_Status aPointStatus1_2 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
 
-  Standard_Real aProximityDist1 = computeProximityDist (mySet1, myNbSamples1, mySet2, myShapeList1, myShapeList2,
-                                                        aP1_1, aP1_2, aPointStatus1_1, aPointStatus1_2);
+  Standard_Real aProximityDist1 = computeProximityDist (mySet1, myNbSamples1, myAddVertices1, myAddStatus1,
+                                                        mySet2,
+                                                        myShapeList1, myShapeList2,
+                                                        aP1_1, aP1_2,
+                                                        aPointStatus1_1, aPointStatus1_2);
 
   if (aProximityDist1 < 0.)
     return;
@@ -132,8 +535,11 @@ void BRepExtrema_ProximityValueTool::Perform (Standard_Real& theTolerance)
   ProxPnt_Status aPointStatus2_1 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
   ProxPnt_Status aPointStatus2_2 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
 
-  Standard_Real aProximityDist2 = computeProximityDist (mySet2, myNbSamples2, mySet1, myShapeList2, myShapeList1,
-                                                        aP2_2, aP2_1, aPointStatus2_2, aPointStatus2_1);
+  Standard_Real aProximityDist2 = computeProximityDist (mySet2, myNbSamples2, myAddVertices2, myAddStatus2,
+                                                        mySet1,
+                                                        myShapeList2, myShapeList1,
+                                                        aP2_2, aP2_1,
+                                                        aPointStatus2_2, aPointStatus2_1);
 
   if (aProximityDist2 < 0.)
     return;
@@ -159,3 +565,23 @@ void BRepExtrema_ProximityValueTool::Perform (Standard_Real& theTolerance)
   myIsDone = Standard_True;
   theTolerance = myDistance;
 }
+
+//=======================================================================
+//function : Inspect
+//purpose  : Used for selection and storage of coinciding nodes
+//=======================================================================
+NCollection_CellFilter_Action BRepExtrema_VertexInspector::Inspect (const Standard_Integer theTarget)
+{
+  myIsNeedAdd = Standard_True;
+
+  const gp_XYZ& aPnt = myPoints.Value (theTarget - 1);
+  Standard_Real aDx, aDy, aDz;
+  aDx = myCurrent.X() - aPnt.X();
+  aDy = myCurrent.Y() - aPnt.Y();
+  aDz = myCurrent.Z() - aPnt.Z();
+
+  if ((aDx * aDx <= myTol) && (aDy * aDy <= myTol) && (aDz * aDz <= myTol))
+    myIsNeedAdd = Standard_False;
+
+  return CellFilter_Keep;
+}

src/BRepExtrema/BRepExtrema_ProximityValueTool.hxx

@@ -1,4 +1,4 @@
-// Created on: 2022-08-08
+// Created on: 2022-08-08
 // Created by: Kseniya NOSULKO
 // Copyright (c) 2022 OPEN CASCADE SAS
 //
@@ -18,9 +18,67 @@
 
 #include <BRepExtrema_ProximityDistTool.hxx>
 #include <BRepExtrema_TriangleSet.hxx>
+#include <NCollection_CellFilter.hxx>
+#include <Precision.hxx>
+
+typedef NCollection_Vector<gp_XYZ> VectorOfPoint;
+
+//! Class BRepExtrema_VertexInspector
+//!   derived from NCollection_CellFilter_InspectorXYZ
+//!   This class define the Inspector interface for CellFilter algorithm,
+//!   working with gp_XYZ points in 3d space.
+//!   Used in search of coincidence points with a certain tolerance.
+class BRepExtrema_VertexInspector : public NCollection_CellFilter_InspectorXYZ
+{
+public:
+  typedef Standard_Integer Target;
+
+  //! Constructor; remembers the tolerance
+  BRepExtrema_VertexInspector()
+  : myTol (Precision::SquareConfusion()),
+    myIsNeedAdd (Standard_True)
+  {}
+
+  //! Keep the points used for comparison
+  void Add (const gp_XYZ& thePnt)
+  {
+    myPoints.Append (thePnt);
+  }
+
+  //! Set tolerance for comparison of point coordinates
+  void SetTol (const Standard_Real theTol)
+  {
+    myTol = theTol;
+  }
+
+  //! Set current point to search for coincidence
+  void SetCurrent (const gp_XYZ& theCurPnt)
+  {
+    myCurrent = theCurPnt;
+    myIsNeedAdd = Standard_True;
+  }
+
+  Standard_Boolean IsNeedAdd()
+  {
+    return myIsNeedAdd;
+  }
+
+  //! Implementation of inspection method
+  Standard_EXPORT NCollection_CellFilter_Action Inspect (const Standard_Integer theTarget);
+
+private:
+  Standard_Real myTol;
+  Standard_Boolean myIsNeedAdd;
+  VectorOfPoint myPoints;
+  gp_XYZ myCurrent;
+};
+
+typedef NCollection_CellFilter<BRepExtrema_VertexInspector> BRepExtrema_CellFilter;
+typedef typename BRepExtrema_ProximityDistTool::ProxPnt_Status ProxPnt_Status;
 
 //! Tool class for computation of the proximity value from one BVH
 //! primitive set to another, solving max(min) problem.
+//! Handles only edge/edge or face/face cases.
 //! This tool is not intended to be used independently, and is integrated
 //! in other classes, implementing algorithms based on shape tessellation
 //! (BRepExtrema_ShapeProximity and BRepExtrema_SelfIntersection).
@@ -29,8 +87,6 @@
 //! on the quality of input tessellation(s).
 class BRepExtrema_ProximityValueTool
 {
-public:
-  typedef typename BRepExtrema_ProximityDistTool::ProxPnt_Status ProxPnt_Status;
 
 public:
 
@@ -86,9 +142,17 @@ public:
 
 private:
 
+  //! Gets shape data for further refinement.
+  Standard_Boolean getInfoForRefinement (const TopoDS_Shape& theShapes,
+                                         TopAbs_ShapeEnum& theShapeType,
+                                         Standard_Integer& theNbNodes,
+                                         Standard_Real& theStep);
+
   //! Returns the computed proximity value from first BVH to another one.
   Standard_Real computeProximityDist (const Handle(BRepExtrema_TriangleSet)& theSet1,
                                       const Standard_Integer theNbSamples1,
+                                      const BVH_Array3d& theAddVertices1,
+                                      const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
                                       const Handle(BRepExtrema_TriangleSet)& theSet2,
                                       const BRepExtrema_ShapeList& theShapeList1,
                                       const BRepExtrema_ShapeList& theShapeList2,
@@ -97,6 +161,29 @@ private:
                                       ProxPnt_Status& thePointStatus1,
                                       ProxPnt_Status& thePointStatus2) const;
 
+  //! Gets additional vertices on shapes with refining a coarser one if it's needed.
+  Standard_Boolean getShapesAdditionalVertices();
+
+  //! Gets additional vertices and their statuses on the edge with the input step.
+  Standard_Boolean getEdgeAdditionalVertices (const TopoDS_Edge& theEdge,
+                                              const Standard_Real theStep,
+                                              BVH_Array3d& theAddVertices,
+                                              NCollection_Vector<ProxPnt_Status>& theAddStatuses);
+
+  //! Gets additional vertices and their statuses on the face with the input step (triangle square).
+  Standard_Boolean getFaceAdditionalVertices (const TopoDS_Face& theFace,
+                                              const Standard_Real theStep,
+                                              BVH_Array3d& theAddVertices,
+                                              NCollection_Vector<ProxPnt_Status>& theAddStatuses);
+
+  //! Splits the triangle recursively, halving the longest side
+  //! to the area of ​​the current triangle > input step
+  void doRecurTrgSplit (const gp_Pnt (&theTrg)[3],
+                        const ProxPnt_Status (&theEdgesStatus)[3],
+                        const Standard_Real theTol,
+                        const Standard_Real theStep,
+                        BVH_Array3d& theAddVertices,
+                        NCollection_Vector<ProxPnt_Status>& theAddStatuses);
 private:
 
   //! Set of all mesh primitives of the 1st shape.
@@ -109,6 +196,35 @@ private:
   //! List of subshapes of the 2nd shape.
   BRepExtrema_ShapeList myShapeList2;
 
+  //! The 1st shape.
+  TopoDS_Shape myShape1;
+  //! The 2nd shape.
+  TopoDS_Shape myShape2;
+
+  BVH_Array3d myAddVertices1; //!< Additional vertices on the 1st shape if its mesh is coarser.
+  BVH_Array3d myAddVertices2; //!< Additional vertices on the 2nd shape if its mesh is coarser.
+
+  NCollection_Vector<ProxPnt_Status> myAddStatus1; //!< Status of additional vertices on the 1st shape.
+  NCollection_Vector<ProxPnt_Status> myAddStatus2; //!< Status of additional vertices on the 2nd shape.
+
+  Standard_Boolean myIsInitS1; //!< Is the 1st shape initialized?
+  Standard_Boolean myIsInitS2; //!< Is the 2nd shape initialized?
+
+  Standard_Boolean myIsRefinementRequired1; //!< Flag about the need to refine the 1st shape.
+  Standard_Boolean myIsRefinementRequired2; //!< Flag about the need to refine the 2nd shape.
+
+  Standard_Integer myNbNodes1; //!< Number of nodes in triangulation of the 1st shape.
+  Standard_Integer myNbNodes2; //!< Number of nodes in triangulation of the 2nd shape.
+
+  Standard_Real myStep1; //!< Step for getting vertices on the 1st shape.
+  Standard_Real myStep2; //!< Step for getting vertices on the 2nd shape.
+
+  BRepExtrema_CellFilter myCells;
+  BRepExtrema_VertexInspector myInspector;
+
+  TopAbs_ShapeEnum myShapeType1; //!< 1st shape type.
+  TopAbs_ShapeEnum myShapeType2; //!< 2nd shape type.
+
   Standard_Real myDistance;  //!< Distance
   Standard_Boolean myIsDone; //!< State of the algorithm
 

src/BRepExtrema/BRepExtrema_ShapeProximity.cxx

@@ -129,6 +129,7 @@ void BRepExtrema_ShapeProximity::Perform()
                                     myElementSet2);
     myProxValTool.LoadShapeLists (myShapeList1,
                                   myShapeList2);
+    myProxValTool.SetNbSamplePoints (myNbSamples1, myNbSamples2);
 
     myProxValTool.Perform (myTolerance);
     myProxValTool.ProximityPoints(myProxPoint1, myProxPoint2);

src/BRepExtrema/BRepExtrema_ShapeProximity.hxx

@@ -37,7 +37,8 @@
 //! on distance less than the given tolerance from each other.
 //!
 //! Second approach:
-//! Compute the proximity value between two shapes if the tolerance is not defined (Precision::Infinite()).
+//! Compute the proximity value between two shapes (handles only edge/edge or face/face cases)
+//! if the tolerance is not defined (Precision::Infinite()).
 //! In this case the proximity value is a minimal thickness of a layer containing both shapes.
 //!
 //! For the both approaches the high performance is achieved through the use of existing
@@ -46,8 +47,6 @@
 //! triangulation).
 class BRepExtrema_ShapeProximity
 {
-public:
-  typedef typename BRepExtrema_ProximityValueTool::ProxPnt_Status ProxPnt_Status;
 
 public:
 

src/BRepFill/BRepFill_TrimShellCorner.cxx

@@ -56,6 +56,7 @@
 #include <TopTools_MapOfShape.hxx>
 #include <TopTools_SequenceOfShape.hxx>
 #include <BRepExtrema_ExtCC.hxx>
+#include <ShapeFix_Edge.hxx>
 
 static TopoDS_Edge FindEdgeCloseToBisectorPlane(const TopoDS_Vertex& theVertex,
                                                 TopoDS_Compound&     theComp,
@@ -534,6 +535,26 @@ BRepFill_TrimShellCorner::MakeFacesNonSec(const Standard_Integer
 
     if(bHasNewEdge) {
       aNewEdge.Orientation(TopAbs_FORWARD);
+
+      // Refer to BrepFill_Sweep.cxx BuildEdge Construct an edge via an iso
+      gp_Pnt P1, P2;
+      Standard_Real p11, p12, p21, p22;
+      P1 = BRep_Tool::Pnt(TopExp::FirstVertex(TopoDS::Edge(aNewEdge)));
+      P2 = BRep_Tool::Pnt(TopExp::LastVertex(TopoDS::Edge(aNewEdge)));
+
+      TopoDS_Edge aERef = TopoDS::Edge(fit == 1 ? aE1 : aE2);
+      p11 = P1.Distance(BRep_Tool::Pnt(TopExp::FirstVertex(aERef)));
+      p22 = P2.Distance(BRep_Tool::Pnt(TopExp::LastVertex(aERef)));
+      p12 = P1.Distance(BRep_Tool::Pnt(TopExp::LastVertex(aERef)));
+      p21 = P2.Distance(BRep_Tool::Pnt(TopExp::FirstVertex(aERef)));
+
+      if (p11 > p12 && p22 > p21) {
+        aNewEdge.Reverse();
+      }
+
+      // for nonPlane surface, we should add pCurve
+      Handle(ShapeFix_Edge) sfe = new ShapeFix_Edge();
+      sfe->FixAddPCurve(aNewEdge, TopoDS::Face(aFace), Standard_False);
     }
 
     TopTools_ListOfShape aOrderedList;

src/BRepLib/BRepLib.cxx

@@ -802,7 +802,7 @@ static void GetEdgeTol(const TopoDS_Edge& theEdge,
     }
     if(temp > d2) d2 = temp;
   }
-  d2 = 1.5*sqrt(d2);
+  d2 = 1.05*sqrt(d2);
   theEdTol = d2;
 }
 
@@ -884,10 +884,6 @@ static void UpdShTol(const TopTools_DataMapOfShapeReal& theShToTol,
     case TopAbs_VERTEX: 
       {
         const Handle(BRep_TVertex)& aTV = *((Handle(BRep_TVertex)*)&aNsh.TShape());
-        //
-        if(aTV->Locked())
-          throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
-        //
         if (theVForceUpdate)
           aTV->Tolerance(aTol);
         else
@@ -1709,8 +1705,8 @@ static void InternalUpdateTolerances(const TopoDS_Shape& theOldShape,
   for (iCur=1; iCur<=nbV; iCur++) {
     tol=0;
     const TopoDS_Vertex& V = TopoDS::Vertex(parents.FindKey(iCur));
-    Bnd_Box box;
-    box.Add(BRep_Tool::Pnt(V));
+    gp_Pnt aPV = BRep_Tool::Pnt(V);
+    Standard_Real aMaxDist = 0.;
     gp_Pnt p3d;
     for (lConx.Initialize(parents(iCur)); lConx.More(); lConx.Next()) {
       const TopoDS_Edge& E = TopoDS::Edge(lConx.Value());
@@ -1732,8 +1728,10 @@ static void InternalUpdateTolerances(const TopoDS_Shape& theOldShape,
           if (!C.IsNull()) { // edge non degenerated
             p3d = C->Value(par);
             p3d.Transform(L.Transformation());
-            box.Add(p3d);
-          }
+            Standard_Real aDist = p3d.SquareDistance(aPV);
+            if (aDist > aMaxDist)
+              aMaxDist = aDist;
+           }
         }
         else if (cr->IsCurveOnSurface()) {
           const Handle(Geom_Surface)& Su = cr->Surface();
@@ -1745,21 +1743,22 @@ static void InternalUpdateTolerances(const TopoDS_Shape& theOldShape,
           gp_Pnt2d p2d = PC->Value(par);
           p3d = Su->Value(p2d.X(),p2d.Y());
           p3d.Transform(L.Transformation());
-          box.Add(p3d);
+          Standard_Real aDist = p3d.SquareDistance(aPV);
+          if (aDist > aMaxDist)
+            aMaxDist = aDist;
           if (!PC2.IsNull()) {
             p2d = PC2->Value(par);
             p3d = Su->Value(p2d.X(),p2d.Y());
             p3d.Transform(L.Transformation());
-            box.Add(p3d);
+            aDist = p3d.SquareDistance(aPV);
+            if (aDist > aMaxDist)
+              aMaxDist = aDist;
           }
         }
         itcr.Next();
       }
     }
-    Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
-    box.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
-    aXmax -= aXmin; aYmax -= aYmin; aZmax -= aZmin;
-    tol = Max(tol,sqrt(aXmax*aXmax+aYmax*aYmax+aZmax*aZmax));
+    tol = Max(tol, sqrt(aMaxDist));
     tol += 2.*Epsilon(tol);
     //
     Standard_Real aVTol = BRep_Tool::Tolerance(V);

src/BRepOffset/BRepOffset_MakeOffset.cxx

@@ -336,8 +336,10 @@ static BRepOffset_Error checkSinglePoint(const Standard_Real theUParam,
                                          const NCollection_Vector<gp_Pnt>& theBadPoints);
 
 //---------------------------------------------------------------------
-static void UpdateTolerance (      TopoDS_Shape&               myShape,
-                             const TopTools_IndexedMapOfShape& myFaces);
+static void UpdateTolerance (      TopoDS_Shape&               theShape,
+                             const TopTools_IndexedMapOfShape& theFaces,
+                             const TopoDS_Shape& theInitShape);
+
 static Standard_Real ComputeMaxDist(const gp_Pln& thePlane, 
                                     const Handle(Geom_Curve)& theCrv,
                                     const Standard_Real theFirst,
@@ -1036,8 +1038,16 @@ void BRepOffset_MakeOffset::MakeOffsetShape(const Message_ProgressRange& theRang
   // MAJ Tolerance edge and Vertex
   // ----------------------------
   if (!myOffsetShape.IsNull()) {
-    UpdateTolerance (myOffsetShape,myFaces);
-    BRepLib::UpdateTolerances( myOffsetShape );
+    if (myThickening)
+    {
+      UpdateTolerance(myOffsetShape, myFaces, myShape);
+    }
+    else
+    {
+      TopoDS_Shape aDummy;
+      UpdateTolerance(myOffsetShape, myFaces, aDummy);
+    }
+    BRepLib::UpdateTolerances(myOffsetShape);
   }
 
   CorrectConicalFaces();
@@ -3165,13 +3175,38 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
       } //if both edges are arcs of circles
       if (NewFace.IsNull())
       {
-        BRepLib_MakeFace MF(theWire, Standard_True); //Only plane
-        if (MF.Error() == BRepLib_FaceDone)
+        Standard_Real anEdgeTol = BRep_Tool::Tolerance(anEdge);
+        //Tolerances of input shape should not be increased by BRepLib_MakeFace
+        BRepLib_FindSurface aFindPlane(theWire, anEdgeTol, Standard_True); //only plane
+        IsPlanar = Standard_False;
+        if(aFindPlane.Found() && aFindPlane.ToleranceReached() <= anEdgeTol)
         {
-          NewFace = MF.Face();
-          IsPlanar = Standard_True;
+          Standard_Real f, l;
+          Handle(Geom_Curve) aGC = BRep_Tool::Curve(anEdge, f, l);
+          Handle(Geom_Plane) aPln = Handle(Geom_Plane)::DownCast(aFindPlane.Surface());
+          Standard_Real aMaxDist = ComputeMaxDist(aPln->Pln(), aGC, f, l);
+          if (aMaxDist <= anEdgeTol)
+          {
+            BRepLib_MakeFace MF(aPln->Pln(), theWire);
+            if (MF.IsDone())
+            {
+              NewFace = MF.Face();
+              TopoDS_Iterator anItE(theWire);
+              for (; anItE.More(); anItE.Next())
+              {
+                const TopoDS_Edge& anE = TopoDS::Edge(anItE.Value());
+                if (anE.IsSame(anEdge))
+                  continue;
+                aGC = BRep_Tool::Curve(anE, f, l);
+                aMaxDist = ComputeMaxDist(aPln->Pln(), aGC, f, l);
+                BB.UpdateEdge(anE, aMaxDist);
+              }
+              IsPlanar = Standard_True;
+            }
+          }
         }
-        else //Extrusion (by thrusections)
+        //
+        if(!IsPlanar) //Extrusion (by thrusections)
         {
           Handle(Geom_Curve) EdgeCurve = BRep_Tool::Curve(anEdge, fpar, lpar);
           Handle(Geom_TrimmedCurve) TrEdgeCurve =
@@ -3185,7 +3220,6 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
           ThrusecGenerator.AddCurve( TrOffsetCurve );
           ThrusecGenerator.Perform( Precision::PConfusion() );
           theSurf = ThrusecGenerator.Surface();
-          //theSurf = new Geom_SurfaceOfLinearExtrusion( TrOffsetCurve, OffsetDir );
           Standard_Real Uf, Ul, Vf, Vl;
           theSurf->Bounds(Uf, Ul, Vf, Vl);
           TopLoc_Location Loc;
@@ -3272,8 +3306,14 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
           BB.Range( anE3, FirstPar, LastPar );
         }
       }
-      BRepLib::SameParameter(NewFace);
-      BRepTools::Update(NewFace);
+
+      if (!IsPlanar)
+      {
+        // For planar faces these operations are useless,
+        // because there are no curves on surface
+        BRepLib::SameParameter(NewFace);
+        BRepTools::Update(NewFace);
+      }
       //Check orientation
       TopAbs_Orientation anOr = OrientationOfEdgeInFace(anEdge, aFaceOfEdge);
       TopAbs_Orientation OrInNewFace = OrientationOfEdgeInFace(anEdge, NewFace);
@@ -3781,6 +3821,7 @@ void BRepOffset_MakeOffset::EncodeRegularity ()
 #endif
 }
 
+
 //=======================================================================
 //function : ComputeMaxDist
 //purpose  : 
@@ -3807,13 +3848,15 @@ Standard_Real ComputeMaxDist(const gp_Pln& thePlane,
   }
   return sqrt(aMaxDist)*1.05;
 }
+
 //=======================================================================
-//function : UpDateTolerance
+//function : UpdateTolerance
 //purpose  : 
 //=======================================================================
 
 void UpdateTolerance (TopoDS_Shape& S,
-                      const TopTools_IndexedMapOfShape& Faces)
+                      const TopTools_IndexedMapOfShape& Faces,
+                      const TopoDS_Shape& theInitShape)
 {
   BRep_Builder B;
   TopTools_MapOfShape View;
@@ -3829,12 +3872,31 @@ void UpdateTolerance (TopoDS_Shape& S,
     }
   }
   
-  Standard_Real Tol;
-  TopExp_Explorer ExpF;
-  for (ExpF.Init(S, TopAbs_FACE); ExpF.More(); ExpF.Next())
+  // The edges of initial shape are  not modified
+  TopTools_MapOfShape aMapInitF;
+  if (!theInitShape.IsNull())
   {
-    const TopoDS_Shape& F = ExpF.Current();
-    if (Faces.Contains(F))
+    TopExp_Explorer anExpF(theInitShape, TopAbs_FACE);
+    for (; anExpF.More(); anExpF.Next()) {
+      aMapInitF.Add(anExpF.Current());
+      TopExp_Explorer anExpE;
+      for (anExpE.Init(anExpF.Current(), TopAbs_EDGE); anExpE.More(); anExpE.Next()) {
+        View.Add(anExpE.Current());
+        TopoDS_Iterator anItV(anExpE.Current());
+        for (; anItV.More(); anItV.Next())
+        {
+          View.Add(anItV.Value());
+        }
+      }
+    }
+  }
+  
+  Standard_Real Tol;
+  TopExp_Explorer anExpF(S, TopAbs_FACE);
+  for (; anExpF.More(); anExpF.Next())
+  {
+    const TopoDS_Shape& F = anExpF.Current();
+    if (Faces.Contains(F) || aMapInitF.Contains(F))
     {
       continue;
     }
@@ -3843,6 +3905,7 @@ void UpdateTolerance (TopoDS_Shape& S,
     for (Exp.Init(F, TopAbs_EDGE); Exp.More(); Exp.Next()) {
       TopoDS_Edge E = TopoDS::Edge(Exp.Current());
       Standard_Boolean isUpdated = Standard_False;
+      Standard_Real aCurrTol = BRep_Tool::Tolerance(E);
       if (aBAS.GetType() == GeomAbs_Plane)
       {
         //Edge does not seem to have pcurve on plane,
@@ -3850,17 +3913,22 @@ void UpdateTolerance (TopoDS_Shape& S,
         Standard_Real aFirst, aLast;
         Handle(Geom_Curve) aCrv = BRep_Tool::Curve(E, aFirst, aLast);
         Standard_Real aMaxDist = ComputeMaxDist(aBAS.Plane(), aCrv, aFirst, aLast);
-        E.Locked (Standard_False);
-        B.UpdateEdge(E, aMaxDist);
-        isUpdated = Standard_True;
+        if (aMaxDist > aCurrTol)
+        {
+          B.UpdateEdge(E, aMaxDist);
+          isUpdated = Standard_True;
+        }
       }
       if (View.Add(E))
       {
-
+        E.Locked(Standard_False);       
         BRepCheck_Edge EdgeCorrector(E);
         Tol = EdgeCorrector.Tolerance();
-        B.UpdateEdge(E, Tol);
-        isUpdated = Standard_True;
+        if (Tol > aCurrTol)
+        {
+          B.UpdateEdge(E, Tol);
+          isUpdated = Standard_True;
+        }
       }
       if (isUpdated)
       {
@@ -3869,11 +3937,11 @@ void UpdateTolerance (TopoDS_Shape& S,
         TopExp::Vertices(E, V[0], V[1]);
 
         for (Standard_Integer i = 0; i <= 1; i++) {
+          V[i].Locked(Standard_False);
           if (View.Add(V[i])) {
             Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(V[i].TShape());
             TV->Tolerance(0.);
             BRepCheck_Vertex VertexCorrector(V[i]);
-            V[i].Locked (Standard_False);
             B.UpdateVertex(V[i], VertexCorrector.Tolerance());
             // use the occasion to clean the vertices.
             (TV->ChangePoints()).Clear();
@@ -4953,6 +5021,53 @@ Standard_Boolean BRepOffset_MakeOffset::IsPlanar()
       if (aPlanarityChecker.IsPlanar())
       {
         gp_Pln aPln = aPlanarityChecker.Plan();
+        Standard_Real u1, u2, v1, v2, um, vm;
+        aSurf->Bounds(u1, u2, v1, v2);
+        Standard_Boolean isInf1 = Precision::IsInfinite(u1), isInf2 = Precision::IsInfinite(u2);
+        if (!isInf1 && !isInf2)
+        {
+          um = (u1 + u2) / 2.;
+        }
+        else if(isInf1 && !isInf2)
+        {
+          um = u2 - 1.;
+        }
+        else if(!isInf1 && isInf2)
+        {
+          um = u1 + 1.;
+        }
+        else //isInf1 && isInf2
+        {
+          um = 0.;
+        }
+        isInf1 = Precision::IsInfinite(v1), isInf2 = Precision::IsInfinite(v2);
+        if (!isInf1 && !isInf2)
+        {
+          vm = (v1 + v2) / 2.;
+        }
+        else if (isInf1 && !isInf2)
+        {
+          vm = v2 - 1.;
+        }
+        else if(!isInf1 && isInf2)
+        {
+          vm = v1 + 1.;
+        }
+        else //isInf1 && isInf2
+        {
+          vm = 0.;
+        }
+        gp_Pnt aP;
+        gp_Vec aD1, aD2;
+        aBAS.D1(um, vm, aP, aD1, aD2);
+        gp_Vec aNorm = aD1.Crossed(aD2);
+        gp_Dir aPlnNorm = aPln.Position().Direction();
+        if (aNorm.Dot(aPlnNorm) < 0.)
+        {
+          aPlnNorm.Reverse();
+          gp_Ax1 anAx(aPln.Position().Location(), aPlnNorm);
+          aPln.SetAxis(anAx);
+        }
         Handle(Geom_Plane) aPlane = new Geom_Plane(aPln);
         TopoDS_Face aPlanarFace;
         aBB.MakeFace(aPlanarFace, aPlane, aTolForFace);

src/BSplCLib/BSplCLib.cxx

@@ -4234,6 +4234,133 @@ void BSplCLib::Resolution(      Standard_Real&        Poles,
     UTolerance = Tolerance3D / RealSmall();
 }
 
+//=======================================================================
+// function : Intervals 
+// purpose  : 
+//=======================================================================
+Standard_Integer BSplCLib::Intervals (const TColStd_Array1OfReal& theKnots,
+                                      const TColStd_Array1OfInteger& theMults,
+                                      Standard_Integer theDegree,
+                                      Standard_Boolean isPeriodic,
+                                      Standard_Integer theContinuity,
+                                      Standard_Real theFirst,
+                                      Standard_Real theLast,
+                                      Standard_Real theTolerance,
+                                      TColStd_Array1OfReal* theIntervals) 
+{
+  // remove all knots with multiplicity less or equal than (degree - continuity) except first and last
+  Standard_Integer aFirstIndex = isPeriodic ? 1 : FirstUKnotIndex (theDegree, theMults);
+  Standard_Integer aLastIndex = isPeriodic ? theKnots.Size() : LastUKnotIndex (theDegree, theMults);
+  TColStd_Array1OfReal aNewKnots (1, aLastIndex - aFirstIndex + 1);
+  Standard_Integer aNbNewKnots = 0;
+  for (Standard_Integer anIndex = aFirstIndex; anIndex <= aLastIndex; anIndex++)
+  {
+    if (theMults(anIndex) > (theDegree - theContinuity) ||
+    anIndex == aFirstIndex ||
+    anIndex == aLastIndex)
+    {
+      aNbNewKnots++;
+      aNewKnots(aNbNewKnots) = theKnots[anIndex];
+    }
+  }
+  aNewKnots.Resize (1, aNbNewKnots, Standard_True);
+
+  // the range boundaries 
+  Standard_Real aCurFirst = theFirst;
+  Standard_Real aCurLast = theLast;
+  Standard_Real aPeriod = 0.0;
+  Standard_Integer aFirstPeriod = 0;
+  Standard_Integer aLastPeriod = 0;
+  // move boundaries into period
+  if (isPeriodic)
+  {
+    Standard_Real aLower = theKnots.First();
+    Standard_Real anUpper = theKnots.Last();
+    aPeriod = anUpper - aLower;
+    
+    while (aCurFirst < aLower)
+    {
+      aCurFirst += aPeriod;
+      aFirstPeriod--;
+    }
+    while (aCurLast < aLower)
+    {
+      aCurLast += aPeriod;
+      aLastPeriod--;
+    }
+    while (aCurFirst >= anUpper)
+    {
+      aCurFirst -= aPeriod;
+      aFirstPeriod += 1;
+    }
+    while (aCurLast >= anUpper)
+    {
+      aCurLast -= aPeriod;
+      aLastPeriod += 1;
+    }
+  }
+  // locate the left and nearest knot for boundaries
+  Standard_Integer anIndex1 = 0;
+  Standard_Integer anIndex2 = 0;
+  Standard_Real aDummyDouble;
+  // we use version of LocateParameter that doesn't need multiplicities
+  LocateParameter(theDegree, aNewKnots, TColStd_Array1OfInteger(), aCurFirst, Standard_False, 1, aNbNewKnots, anIndex1, aDummyDouble);
+  LocateParameter(theDegree, aNewKnots, TColStd_Array1OfInteger(), aCurLast, Standard_False, 1, aNbNewKnots, anIndex2, aDummyDouble);
+  // the case when the beginning of the range coincides with the next knot
+  if (anIndex1 < aNbNewKnots && Abs(aNewKnots[anIndex1 + 1] - aCurFirst) < theTolerance)
+  {
+    anIndex1 += 1;
+  }
+  // the case when the ending of the range coincides with the current knot
+  if (aNbNewKnots && Abs(aNewKnots[anIndex2] - aCurLast) < theTolerance)
+  {
+    anIndex2 -= 1;
+  }
+  Standard_Integer aNbIntervals = anIndex2 - anIndex1 + 1 + (aLastPeriod - aFirstPeriod) * (aNbNewKnots - 1);
+  
+  // fill the interval array
+  if (theIntervals)
+  {
+    theIntervals->Resize (1, aNbIntervals + 1, Standard_False);
+    if (isPeriodic && aLastPeriod != aFirstPeriod)
+    {
+      Standard_Integer anIndex = 1;
+      // part from the begging of range to the end of the first period
+      for (Standard_Integer i = anIndex1; i < aNewKnots.Size(); i++, anIndex++)
+      {
+        theIntervals->ChangeValue(anIndex) = aNewKnots[i] + aFirstPeriod * aPeriod;
+      }
+      // full periods
+      for (Standard_Integer aPeriodNum = aFirstPeriod + 1; aPeriodNum < aLastPeriod; aPeriodNum++)
+      {
+        for (Standard_Integer i = 1; i < aNewKnots.Size(); i++, anIndex++)
+        {
+          theIntervals->ChangeValue(anIndex) = aNewKnots[i] + aPeriodNum * aPeriod;
+        }
+      }
+      // part from the begging of the last period to the end of range
+      for (Standard_Integer i = 1; i <= anIndex2; i++, anIndex++)
+      {
+        theIntervals->ChangeValue(anIndex) = aNewKnots[i] + aLastPeriod * aPeriod;
+      }
+    }
+    else
+    {
+      Standard_Integer anIndex = 1;
+      for (Standard_Integer i = anIndex1; i <= anIndex2; i++, anIndex++)
+      {
+        theIntervals->ChangeValue(anIndex) = aNewKnots[i] + aFirstPeriod * aPeriod;
+      }
+    }
+    // update the first position (the begging of range doesn't coincide with the knot at anIndex1 in general)
+    theIntervals->ChangeValue(1) = theFirst;
+    // write the ending of the range (we didn't write it at all)
+    theIntervals->ChangeValue(aNbIntervals + 1) = theLast;
+  }
+  
+  return aNbIntervals;
+}
+
 //=======================================================================
 // function: FlatBezierKnots
 // purpose :

src/BSplCLib/BSplCLib.hxx

@@ -1456,8 +1456,26 @@ public:
   //! we have |f (u1) - f (u0)| < Tolerance3D
   Standard_EXPORT static void Resolution (const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const Standard_Integer NumPoles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer Degree, const Standard_Real Tolerance3D, Standard_Real& UTolerance);
 
-
-
+  //! Splits the given range to BSpline intervals of given continuity
+  //! @param[in] theKnots the knots of BSpline
+  //! @param[in] theMults the knots' multiplicities
+  //! @param[in] theDegree the degree of BSpline
+  //! @param[in] isPeriodic the periodicity of BSpline
+  //! @param[in] theContinuity the target interval's continuity 
+  //! @param[in] theFirst the begin of the target range
+  //! @param[in] theLast the end of the target range
+  //! @param[in] theTolerance the tolerance
+  //! @param[in,out] theIntervals the array to store intervals if isn't nullptr
+  //! @return the number of intervals
+  Standard_EXPORT static Standard_Integer Intervals (const TColStd_Array1OfReal& theKnots,
+                                                     const TColStd_Array1OfInteger& theMults,
+                                                     Standard_Integer theDegree,
+                                                     Standard_Boolean isPeriodic,
+                                                     Standard_Integer theContinuity,
+                                                     Standard_Real theFirst,
+                                                     Standard_Real theLast,
+                                                     Standard_Real theTolerance,
+                                                     TColStd_Array1OfReal* theIntervals);
 
 protected:
 

src/BSplCLib/BSplCLib_2.cxx

@@ -1157,82 +1157,97 @@ void BSplCLib::MergeBSplineKnots
   index,
   num_knots ;
   if (StartValue < EndValue - Tolerance) {
-    TColStd_Array1OfReal knots1(1,Knots1.Length()) ;
-    TColStd_Array1OfReal knots2(1,Knots2.Length()) ;
-    degree = Degree1 + Degree2 ;
-    index = 1 ;
+    TColStd_Array1OfReal knots1(1, Knots1.Length());
+    TColStd_Array1OfReal knots2(1, Knots2.Length());
+    degree = Degree1 + Degree2;
+    index = 1;
 
-    for (ii = Knots1.Lower() ; ii <= Knots1.Upper() ; ii++) {
-      knots1(index) = Knots1(ii) ;
-      index += 1 ;
+    for (ii = Knots1.Lower(); ii <= Knots1.Upper(); ii++) {
+      knots1(index) = Knots1(ii);
+      index += 1;
     }
-    index = 1 ;
+    index = 1;
 
-    for (ii = Knots2.Lower() ; ii <= Knots2.Upper() ; ii++) {
-      knots2(index) = Knots2(ii) ;
-      index += 1 ;
+    for (ii = Knots2.Lower(); ii <= Knots2.Upper(); ii++) {
+      knots2(index) = Knots2(ii);
+      index += 1;
     }
     BSplCLib::Reparametrize(StartValue,
-			    EndValue,
-			    knots1) ;
-    
-    BSplCLib::Reparametrize(StartValue,
-			    EndValue,
-			    knots2) ;
-    num_knots = 0 ;
-    jj =  1 ;
+      EndValue,
+      knots1);
 
-    for (ii = 1 ; ii <= knots1.Length() ; ii++) {
+    BSplCLib::Reparametrize(StartValue,
+      EndValue,
+      knots2);
+    num_knots = 0;
+    jj = 1;
+
+    for (ii = 1; ii <= knots1.Length(); ii++) {
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) - Tolerance) {
-	jj += 1 ;
-	num_knots += 1 ;
+        jj += 1;
+        num_knots += 1;
       }
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) + Tolerance) {
-	jj += 1 ;
+        jj += 1;
       }
-      num_knots += 1 ;
+      num_knots += 1;
     }
-    NewKnots = 
-      new TColStd_HArray1OfReal(1,num_knots) ;
+    NewKnots =
+      new TColStd_HArray1OfReal(1, num_knots);
     NewMults =
-      new TColStd_HArray1OfInteger(1,num_knots) ;
-    num_knots = 1 ;
-    jj = 1 ;
+      new TColStd_HArray1OfInteger(1, num_knots);
+    num_knots = 1;
+    jj = 1;
 
-    for (ii = 1 ; ii <= knots1.Length() ; ii++) {
+    for (ii = 1; ii <= knots1.Length(); ii++) {
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) - Tolerance) {
-	NewKnots->ChangeArray1()(num_knots) = knots2(jj) ;
-        NewMults->ChangeArray1()(num_knots) = Mults2(jj) + Degree1 ;
-	jj += 1 ;
-	num_knots += 1 ;
+        NewKnots->ChangeArray1()(num_knots) = knots2(jj);
+        NewMults->ChangeArray1()(num_knots) = Mults2(jj) + Degree1;
+        jj += 1;
+        num_knots += 1;
       }
-      set_mults_flag = 0 ;
+      set_mults_flag = 0;
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) + Tolerance) {
-	continuity = Min(Degree1 - Mults1(ii), Degree2 - Mults2(jj)) ;
-        set_mults_flag = 1 ;
-	NewMults->ChangeArray1()(num_knots) = degree - continuity ;
-	jj += 1 ;
+        continuity = Min(Degree1 - Mults1(ii), Degree2 - Mults2(jj));
+        set_mults_flag = 1;
+        NewMults->ChangeArray1()(num_knots) = degree - continuity;
+        jj += 1;
       }
 
-      NewKnots->ChangeArray1()(num_knots) = knots1(ii) ;
-      if (! set_mults_flag) {
-	NewMults->ChangeArray1()(num_knots) = Mults1(ii) + Degree2 ;
+      NewKnots->ChangeArray1()(num_knots) = knots1(ii);
+      if (!set_mults_flag) {
+        NewMults->ChangeArray1()(num_knots) = Mults1(ii) + Degree2;
       }
-      num_knots += 1 ;
+      num_knots += 1;
     }
-    num_knots -= 1 ;
-    NewMults->ChangeArray1()(1) = degree + 1 ;
-    NewMults->ChangeArray1()(num_knots) = degree + 1 ;
-    index = 0 ;
+    num_knots -= 1;
+    NewMults->ChangeArray1()(1) = degree + 1;
+    NewMults->ChangeArray1()(num_knots) = degree + 1;
+    index = 0;
 
-    for (ii = 1 ; ii <= num_knots ; ii++) {
-      index += NewMults->Value(ii) ;
+    for (ii = 1; ii <= num_knots; ii++) {
+      index += NewMults->Value(ii);
     }
-    NumPoles = index  - degree - 1  ;
+    NumPoles = index - degree - 1;
+  }
+  else
+  {
+    degree = Degree1 + Degree2;
+    num_knots = 2;
+    NewKnots =
+      new TColStd_HArray1OfReal(1, num_knots);
+    NewKnots->ChangeArray1()(1) = StartValue;
+    NewKnots->ChangeArray1()(num_knots) = EndValue;
+
+    NewMults = 
+      new TColStd_HArray1OfInteger(1, num_knots);
+    NewMults->ChangeArray1()(1) = degree + 1;
+    NewMults->ChangeArray1()(num_knots) = degree + 1;
+    NumPoles = BSplCLib::NbPoles(degree, Standard_False, NewMults->Array1());
   }
 }
       

src/Draft/Draft_FaceInfo.cxx

@@ -37,9 +37,7 @@ Draft_FaceInfo::Draft_FaceInfo (const Handle(Geom_Surface)& S,\
 				const Standard_Boolean HasNewGeometry):
        myNewGeom(HasNewGeometry)
 {
-  Handle(Geom_RectangularTrimmedSurface) T = Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
-  if (!T.IsNull()) myGeom = T->BasisSurface();
-  else             myGeom = S;
+  myGeom = S;
 }
 
 

src/Draft/Draft_Modification_1.cxx

@@ -481,7 +481,7 @@ Standard_Boolean Draft_Modification::Propagate ()
           Handle(Geom_Surface)::DownCast(S->Transformed(L.Transformation()));
 
         const Handle(Standard_Type)& typs = S->DynamicType();
-        if (typs == STANDARD_TYPE(Geom_CylindricalSurface) ||
+        if (/*typs == STANDARD_TYPE(Geom_CylindricalSurface) ||*/
             typs == STANDARD_TYPE(Geom_ConicalSurface)) {
           Standard_Real umin,umax,vmin,vmax;
           BRepTools::UVBounds(F,umin,umax,vmin,vmax);
@@ -1062,7 +1062,11 @@ void Draft_Modification::Perform ()
               //Find the first curve to glue
               TColGeom_SequenceOfCurve Candidates;
               if (S1->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface) ||
-                  S1->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface)) 
+                  S1->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface) ||
+                  S1->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface) &&
+                  Handle(Geom_RectangularTrimmedSurface)::DownCast(S1)->BasisSurface()->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface) ||
+                  S1->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface) &&
+                  Handle(Geom_RectangularTrimmedSurface)::DownCast(S1)->BasisSurface()->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface))
               {
                 for (i = 1; i <= i2s.NbLines(); i++)
                 {

src/DrawTrSurf/DrawTrSurf_Debug.cxx

@@ -27,7 +27,7 @@
 // intended for use from debugger prompt (Command Window in Visual Studio)
 
 //! Save geometric object identified by pointer to handle
-const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
+Standard_EXPORT const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
 {
   if (theNameStr == 0 || theHandlePtr == 0)
   {
@@ -57,7 +57,7 @@ const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
 }
 
 //! Set point to DRAW variable
-const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
+Standard_EXPORT const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
 {
   if (theNameStr == 0 || thePntPtr == 0)
   {
@@ -77,7 +77,7 @@ const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
 }
 
 //! Set 2d point to DRAW variable
-const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
+Standard_EXPORT const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
 {
   if (theNameStr == 0 || thePnt2dPtr == 0)
   {
@@ -102,17 +102,17 @@ const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
 // work with them (DBX could, on SUN Solaris).
 #ifndef _MSC_VER
 
-const char* DrawTrSurf_Set (const char* name, const Handle(Standard_Transient)& G)
+Standard_EXPORT const char* DrawTrSurf_Set (const char* name, const Handle(Standard_Transient)& G)
 {
   return DrawTrSurf_Set (name, (void*)&G);
 }
 
-const char* DrawTrSurf_Set (const char* theName, const gp_Pnt& thePnt)
+Standard_EXPORT const char* DrawTrSurf_Set (const char* theName, const gp_Pnt& thePnt)
 {
   return DrawTrSurf_SetPnt (theName, (void*)&thePnt);
 }
 
-const char* DrawTrSurf_Set (const char* theName, const gp_Pnt2d& thePnt2d)
+Standard_EXPORT const char* DrawTrSurf_Set (const char* theName, const gp_Pnt2d& thePnt2d)
 {
   return DrawTrSurf_SetPnt2d (theName, (void*)&thePnt2d);
 }

src/Extrema/Extrema_ExtCC.cxx

@@ -674,7 +674,10 @@ void Extrema_ExtCC::PrepareParallelResult(const Standard_Real theUt11,
         Extrema_ExtPElC ExtPCir(aPCirc2,
                                 Extrema_CurveTool::Circle (*myC[0]),
                                 Precision::Confusion(), theUt11, theUt12);
-
+        if (ExtPCir.NbExt() < 1)
+        {
+          continue;
+        }
         Standard_Real aMinSqD = ExtPCir.SquareDistance(1);
         for (Standard_Integer anExtID = 2; anExtID <= ExtPCir.NbExt(); anExtID++)
         {

src/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx

@@ -58,65 +58,6 @@ static const Standard_Real PosTol = Precision::PConfusion() / 2;
 
 IMPLEMENT_STANDARD_RTTIEXT(Geom2dAdaptor_Curve, Adaptor2d_Curve2d)
 
-static void DefinFPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurFirst,
-  Standard_Integer &theFPer);
-
-static void DefinLPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurLast,
-  Standard_Integer &theLPer);
-
-static Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
-  const TColStd_Array1OfInteger& theTM,
-  const TColStd_Array1OfInteger& theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theNbInt,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real theEps,
-  const Standard_Boolean thePeriodicCur,
-  Standard_Integer theNbIntervals,
-  Standard_Real theLower = 0,
-  Standard_Real thePeriod = 0,
-  Standard_Integer theIndex1 = 0,
-  Standard_Integer theIndex2 = 0);
-
-static void WriteIntervals(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theNbInt,
-  const Standard_Integer theIndex1,
-  const Standard_Integer theIndex2,
-  const Standard_Real theCurPeriod,
-  const Standard_Boolean theFlagForFirst,
-  TColStd_Array1OfReal &theT,
-  TColStd_Array1OfInteger &theFinalIntervals,
-  Standard_Integer &theNbIntervals,
-  Standard_Integer &theCurInt);
-
-static void SpreadInt(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theTM,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theFPer,
-  const Standard_Integer theLPer,
-  const Standard_Integer theNbInt,
-  const Standard_Real theLower,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real thePeriod,
-  const Standard_Real theLastParam,
-  const Standard_Real theEps,
-  TColStd_Array1OfReal &theT,
-  Standard_Integer &theNbIntervals);
-
 //=======================================================================
 //function : ShallowCopy
 //purpose  : 
@@ -354,158 +295,6 @@ GeomAbs_Shape Geom2dAdaptor_Curve::Continuity() const
   }
 }
 
-//=======================================================================
-//function : DefinFPeriod
-//purpose  :
-//=======================================================================
-
-void DefinFPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurFirst,
-  Standard_Integer &theFPer)
-{
-  if (theCurFirst >= theLower)
-  {
-    while (theCurFirst >= theUpper)
-    {
-      theCurFirst = theCurFirst - thePeriod;
-      theFPer++;
-    }
-    if (Abs(theUpper - theCurFirst) <= theEps)
-    {
-      theFPer++;
-      theCurFirst = theLower;
-    }
-  }
-  else
-  {
-    while (theCurFirst < theLower)
-    {
-      theCurFirst = theCurFirst + thePeriod;
-      if (Abs(theLower - theCurFirst) > theEps)
-      {
-        theFPer--;
-      }
-    }
-
-    if (Abs(theUpper - theCurFirst) <= theEps)
-    {
-      theCurFirst = theLower;
-    }
-  }
-}
-
-//=======================================================================
-//function : DefinLPeriod
-//purpose  :
-//=======================================================================
-
-void DefinLPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurLast,
-  Standard_Integer &theLPer)
-{
-  if (theCurLast >= theLower)
-  {
-    if ((theCurLast >= theUpper) && (Abs(theCurLast - theUpper) <= theEps))
-    {
-      theCurLast = theUpper;
-    }
-    else
-    {
-      while (theCurLast >= theUpper)
-      {
-        theCurLast = theCurLast - thePeriod;
-        theLPer++;
-      }
-      if (Abs(theUpper - theCurLast) <= theEps)
-      {
-        theCurLast = theLower;
-      }
-    }
-  }
-  else
-  {
-    while (theCurLast < theLower)
-    {
-      theCurLast = theCurLast + thePeriod;
-      if (Abs(theLower - theCurLast) > theEps)
-      {
-        theLPer--;
-      }
-    }
-    if (Abs(theUpper - theCurLast) <= theEps)
-    {
-      theCurLast = theLower;
-    }
-  }
-}
-
-//=======================================================================
-//function : LocalNbIntervals
-//purpose  :
-//=======================================================================
-
-Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
-  const TColStd_Array1OfInteger& theTM,
-  const TColStd_Array1OfInteger& theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theNbInt,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real theEps,
-  const Standard_Boolean thePeriodicCur,
-  Standard_Integer theNbIntervals,
-  Standard_Real theLower,
-  Standard_Real thePeriod,
-  Standard_Integer theIndex1,
-  Standard_Integer theIndex2)
-{
-  Standard_Real aNewFirst = theFirst;
-  Standard_Real aNewLast = theLast;
-  if (theIndex1 == 0)
-  {
-    BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theFirst,
-      thePeriodicCur, 1, theNb, theIndex1, aNewFirst);
-  }
-  if (theIndex2 == 0)
-  {
-    BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theLast,
-      thePeriodicCur, 1, theNb, theIndex2, aNewLast);
-  }
-  // Protection against theFirst = UFirst - eps, which located as ULast - eps
-  if (thePeriodicCur && ((aNewLast - aNewFirst) < Precision::PConfusion()))
-  {
-    if (Abs(aNewLast - theLower) < Precision::PConfusion())
-    {
-      aNewLast += thePeriod;
-    }
-    else
-    {
-      aNewFirst -= thePeriod;
-    }
-  }
-
-  if (Abs(aNewFirst - theTK(theIndex1 + 1)) < theEps)
-  {
-    theIndex1++;
-  }
-  if ((aNewLast - theTK(theIndex2)) > theEps)
-  {
-    theIndex2++;
-  }
-  for (Standard_Integer i = 1; i <= theNbInt; i++)
-  {
-    if (theInter(i) > theIndex1 && theInter(i) < theIndex2) theNbIntervals++;
-  }
-  return theNbIntervals;
-}
-
 //=======================================================================
 //function : NbIntervals
 //purpose  : 
@@ -513,187 +302,49 @@ Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
 
 Standard_Integer Geom2dAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
 {
-  Standard_Integer myNbIntervals = 1;
-  Standard_Integer NbSplit;
-  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-    Standard_Integer LastIndex = myBSplineCurve->LastUKnotIndex();
-    TColStd_Array1OfInteger Inter(1, LastIndex - FirstIndex + 1);
-    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-    if (aContPer || aContNotPer) {
-      Standard_Integer Cont;
-      switch (S) {
-      case GeomAbs_G1:
-      case GeomAbs_G2:
-        throw Standard_DomainError("Geom2dAdaptor_Curve::NbIntervals");
-        break;
-      case GeomAbs_C0:
-        myNbIntervals = 1;
-        break;
-      case GeomAbs_C1:
-      case GeomAbs_C2:
-      case GeomAbs_C3:
-      case GeomAbs_CN:
-      {
-        if (S == GeomAbs_C1) Cont = 1;
-        else if (S == GeomAbs_C2) Cont = 2;
-        else if (S == GeomAbs_C3) Cont = 3;
-        else                       Cont = myBSplineCurve->Degree();
-        Standard_Integer Degree = myBSplineCurve->Degree();
-        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        TColStd_Array1OfInteger Mults(1, NbKnots);
-        myBSplineCurve->Multiplicities(Mults);
-        NbSplit = 1;
-        Standard_Integer Index = FirstIndex;
-        Inter(NbSplit) = Index;
-        Index++;
-        NbSplit++;
-        while (Index < LastIndex)
-        {
-          if (Degree - Mults(Index) < Cont)
-          {
-            Inter(NbSplit) = Index;
-            NbSplit++;
-          }
-          Index++;
-        }
-        Inter(NbSplit) = Index;
-
-        Standard_Integer NbInt = NbSplit - 1;
-
-        Standard_Integer Nb = myBSplineCurve->NbKnots();
-        TColStd_Array1OfReal    TK(1, Nb);
-        TColStd_Array1OfInteger TM(1, Nb);
-        myBSplineCurve->Knots(TK);
-        myBSplineCurve->Multiplicities(TM);
-        Standard_Real Eps = Min(Resolution(Precision::Confusion()),
-          Precision::PConfusion());
-
-        myNbIntervals = 1;
-
-        if (!myBSplineCurve->IsPeriodic())
-        {
-          myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-            myFirst, myLast, Eps, Standard_False, myNbIntervals);
-        }
-        else
-        {
-          Standard_Real aCurFirst = myFirst;
-          Standard_Real aCurLast = myLast;
-
-          Standard_Real aLower = myBSplineCurve->FirstParameter();
-          Standard_Real anUpper = myBSplineCurve->LastParameter();
-
-          if ((Abs(aCurFirst - aLower) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          if ((Abs(aCurLast - anUpper) < Eps) && (aCurLast < anUpper))
-          {
-            aCurLast = anUpper;
-          }
-
-          Standard_Real aPeriod = myBSplineCurve->Period();
-          Standard_Integer aLPer = 1; Standard_Integer aFPer = 1;
-          
-          if ((Abs(aLower - myFirst) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          else
-          {
-            DefinFPeriod(aLower, anUpper,
-              Eps, aPeriod, aCurFirst, aFPer);
-          }
-          DefinLPeriod(aLower, anUpper,
-            Eps, aPeriod, aCurLast, aLPer);
-
-          if ((Abs(aLower - myFirst) < Eps) && (Abs(anUpper - myLast) < Eps))
-          {
-            myNbIntervals = NbInt;
-          }
-          else
-          {
-            Standard_Integer aSumPer = Abs(aLPer - aFPer);
-            
-            Standard_Real aFirst = 0;
-            if (aLower < 0 && anUpper == 0)
-            {
-              if (Abs(aCurLast) < Eps)
-              {
-                aCurLast = 0;
-              }
-              aFirst = aLower;
-            }
-
-            if (aSumPer <= 1)
-            {
-              if ((Abs(myFirst - TK(Nb) - aPeriod * (aFPer - 1)) <= Eps) && (myLast < (TK(Nb) + aPeriod * (aLPer - 1))))
-              {
-                myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                  myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-                return myNbIntervals;
-              }
-              if ((Abs(myFirst - aLower) < Eps) && (Abs(myLast - anUpper) < Eps))
-              {
-                myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                  myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-                return myNbIntervals;
-              }
-            }
-
-            if (aSumPer != 0)
-            {
-              Standard_Integer aFInt = 0;
-              Standard_Integer aLInt = 0;
-              Standard_Integer aPInt = NbInt;
-
-              if ((aCurFirst != aPeriod) || ((aCurFirst != anUpper) && (Abs(myFirst) < Eps)))
-              {
-              aFInt = 1;
-              }
-              if ((aCurLast != 0) && (aCurLast != anUpper))
-              {
-                aLInt = 1;
-              }
-
-              aFInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                aCurFirst, anUpper, Eps, Standard_True, aFInt, aLower, aPeriod);
-
-              if (aCurLast == anUpper)
-              {
-                aLInt = NbInt;
-              }
-              else
-              {
-                if (Abs(aCurLast - aFirst) > Eps)
-                {
-                  aLInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                    aFirst, aCurLast, Eps, Standard_True, aLInt, aLower, aPeriod, 1);
-                }
-                else
-                {
-                  aLInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                    aFirst, aCurLast, Eps, Standard_True, aLInt, aLower, aPeriod);
-                }
-              }
-
-              myNbIntervals = aFInt + aLInt + aPInt * (aSumPer - 1);
-            }
-            else
-            {
-              myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                aCurFirst, aCurLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-            }
-          }
-        }
-      }
-      break;
-      }
+  if (myTypeCurve == GeomAbs_BSplineCurve)
+  {
+    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+    {
+      return 1;
     }
+    
+    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Integer aCont;
+
+    switch (S)
+    {
+      case GeomAbs_C1:
+        aCont = 1;
+        break;
+      case GeomAbs_C2:
+        aCont = 2;
+        break;
+      case GeomAbs_C3:
+        aCont = 3;
+        break;
+      case GeomAbs_CN:
+        aCont = aDegree;
+        break;
+      default:
+        throw Standard_DomainError ("Geom2dAdaptor_Curve::NbIntervals()");
+    }
+
+    Standard_Real anEps = Min(Resolution(Precision::Confusion()), Precision::PConfusion());
+
+    return BSplCLib::Intervals(myBSplineCurve->Knots(),
+                               myBSplineCurve->Multiplicities(),
+                               aDegree,
+                               myBSplineCurve->IsPeriodic(),
+                               aCont,
+                               myFirst,
+                               myLast,
+                               anEps,
+                               nullptr);
   }
+
   else if (myTypeCurve == GeomAbs_OffsetCurve){
+    Standard_Integer myNbIntervals = 1;
     GeomAbs_Shape BaseS=GeomAbs_C0;
     switch(S){
     case GeomAbs_G1:
@@ -705,208 +356,14 @@ Standard_Integer Geom2dAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
     case GeomAbs_C2: BaseS = GeomAbs_C3; break;
     default: BaseS = GeomAbs_CN;
     }
-    Geom2dAdaptor_Curve anAdaptor( Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve() );
+    Geom2dAdaptor_Curve anAdaptor (Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve(), myFirst, myLast);
     myNbIntervals = anAdaptor.NbIntervals(BaseS);
+    return myNbIntervals;
   }
 
-  return myNbIntervals;
-}
-
-//=======================================================================
-//function : WriteIntervals
-//purpose  :
-//=======================================================================
-
-void WriteIntervals(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theNbInt,
-  const Standard_Integer theIndex1,
-  const Standard_Integer theIndex2,
-  const Standard_Real theCurPeriod,
-  const Standard_Boolean theFlagForFirst,
-  TColStd_Array1OfReal &theT,
-  TColStd_Array1OfInteger &theFinalIntervals,
-  Standard_Integer &theNbIntervals,
-  Standard_Integer &theCurInt)
-{
-  if (theFlagForFirst)
-  {
-    for (Standard_Integer anId = 1; anId <= theNbInt; anId++)
-    {
-      if (theInter(anId) > theIndex1 && theInter(anId) <= theIndex2)
-      {
-        theNbIntervals++;
-        theFinalIntervals(theNbIntervals) = theInter(anId);
-      }
-    }
-  }
   else
   {
-    for (Standard_Integer anId = 1; anId <= theNbInt; anId++)
-    {
-      if (theInter(anId) > theIndex1 && theInter(anId) < theIndex2)
-      {
-        theNbIntervals++;
-        theFinalIntervals(theNbIntervals) = theInter(anId);
-      }
-    }
-  }
-
-  theFinalIntervals(theNbIntervals + 1) = theIndex2;
-
-  for (Standard_Integer anId = theCurInt; anId <= theNbIntervals + 1; anId++)
-  {
-    theT(anId) = theTK(theFinalIntervals(anId)) + theCurPeriod;
-    theCurInt++;
-  }
-}
-
-//=======================================================================
-//function : SpreadInt
-//purpose  :
-//=======================================================================
-void SpreadInt(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theTM,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theFPer,
-  const Standard_Integer theLPer,
-  const Standard_Integer theNbInt,
-  const Standard_Real theLower,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real thePeriod,
-  const Standard_Real theLastParam,
-  const Standard_Real theEps,
-  TColStd_Array1OfReal &theT,
-  Standard_Integer &theNbIntervals)
-{
-  Standard_Integer anIndex1 = 0;
-  Standard_Integer anIndex2 = 0;
-  Standard_Real aNewFirst, aNewLast;
-  Standard_Integer anUpper;
-  BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theFirst,
-    Standard_True, 1, theNb, anIndex1, aNewFirst);
-  BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theLastParam,
-    Standard_True, 1, theNb, anIndex2, aNewLast);
-
-  if (Abs(aNewFirst - theTK(anIndex1 + 1)) < theEps)
-  {
-    anIndex1++;
-  }
-  if ((aNewLast - theTK(anIndex2)) > theEps)
-  {
-    anIndex2++;
-  }
-  theNbIntervals = 1;
-
-  if (anIndex1 == theNb)
-  {
-    anIndex1 = 1;
-  }
-  
-  // Count the max number of boundaries of intervals
-  if (Abs(theLPer - theFPer) > 1)
-  {
-    anUpper = theNb - anIndex1 + anIndex2 + (theLPer - theFPer - 1) * theNb + 1;
-  }
-  else
-  {
-    anUpper = theNb - anIndex1 + anIndex2 + 1;
-  }
-
-  if (theLPer == theFPer)
-  {
-    anUpper = theInter.Upper();
-  }
-  TColStd_Array1OfInteger aFinalIntervals(1, anUpper);
-  aFinalIntervals(1) = anIndex1;
-
-  // If first and last are in the same period
-  if ((Abs(theLPer - theFPer) == 0))
-  {
-    Standard_Integer aCurInt = 1;
-    Standard_Real aCurPeriod = theFPer * thePeriod;
-
-    if (theFirst == aNewFirst && theLast == aNewLast)
-    {
-      aCurPeriod = 0;
-    }
-    WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-      anIndex2, aCurPeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-    return;
-  }
-
-  // If the first and the last are in neighboring periods
-  if (Abs(theLPer - theFPer) == 1)
-  {
-    Standard_Integer aCurInt = 1;
-
-    if (Abs(theLastParam - theLower) < theEps)
-    {
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
-    else
-    {
-      // For period with first
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      // For period with last
-      theNbIntervals++;
-      WriteIntervals(theTK, theInter, theNbInt, 1,
-        anIndex2, theLPer * thePeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
-  }
-  // If the first and the last are far apart
-  if (Abs(theLPer - theFPer) > 1)
-  {
-    Standard_Integer aCurInt = 1;
-    if (Abs(theLastParam - theLower) < theEps)
-    {
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-      Standard_Integer aNbPer = Abs(theLPer - theFPer);
-      Standard_Integer aCurPer = theFPer + 1;
-
-      while (aNbPer > 1)
-      {
-        theNbIntervals++;
-        WriteIntervals(theTK, theInter, theNbInt, 1,
-          theNb, aCurPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-        aNbPer--;
-        aCurPer++;
-      }
-      return;
-    }
-    else
-    {
-      // For period with first
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-      Standard_Integer aNbPer = Abs(theLPer - theFPer);
-      Standard_Integer aCurPer = theFPer + 1;
-      while (aNbPer > 1)
-      {
-        theNbIntervals++;
-        WriteIntervals(theTK, theInter, theNbInt, 1,
-          theNb, aCurPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-        aNbPer--;
-        aCurPer++;
-      }
-      // For period with last
-      theNbIntervals++;
-      WriteIntervals(theTK, theInter, theNbInt, 1,
-        anIndex2, theLPer * thePeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
+    return 1;
   }
 }
 
@@ -915,156 +372,53 @@ void SpreadInt(const TColStd_Array1OfReal &theTK,
 //purpose  : 
 //=======================================================================
 
-void Geom2dAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
-				    const GeomAbs_Shape S   ) const 
+void Geom2dAdaptor_Curve::Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const 
 {
-  Standard_Integer myNbIntervals = 1;
-  Standard_Integer NbSplit;
-  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-    Standard_Integer LastIndex  = myBSplineCurve->LastUKnotIndex();
-    TColStd_Array1OfInteger Inter (1, LastIndex-FirstIndex+1);
-    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-    if (aContPer || aContNotPer) {
-      Standard_Integer Cont;
-      switch ( S) {
-      case GeomAbs_G1:
-      case GeomAbs_G2:
-	throw Standard_DomainError("Geom2dAdaptor_Curve::NbIntervals");
-	break;
-      case GeomAbs_C0:
-	myNbIntervals = 1;
-	break;
-      case GeomAbs_C1:
-      case GeomAbs_C2:
-      case GeomAbs_C3: 
-      case GeomAbs_CN: 
-      {
-        if (S == GeomAbs_C1) Cont = 1;
-        else if (S == GeomAbs_C2) Cont = 2;
-        else if (S == GeomAbs_C3) Cont = 3;
-        else                       Cont = myBSplineCurve->Degree();
-        Standard_Integer Degree = myBSplineCurve->Degree();
-        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        TColStd_Array1OfInteger Mults(1, NbKnots);
-        myBSplineCurve->Multiplicities(Mults);
-        NbSplit = 1;
-        Standard_Integer Index = FirstIndex;
-        Inter(NbSplit) = Index;
-        Index++;
-        NbSplit++;
-        while (Index < LastIndex)
-        {
-          if (Degree - Mults(Index) < Cont)
-          {
-            Inter(NbSplit) = Index;
-            NbSplit++;
-          }
-          Index++;
-        }
-        Inter(NbSplit) = Index;
-        Standard_Integer NbInt = NbSplit - 1;
-
-        Standard_Integer Nb = myBSplineCurve->NbKnots();
-        Standard_Integer Index1 = 0;
-        Standard_Integer Index2 = 0;
-        Standard_Real newFirst, newLast;
-        TColStd_Array1OfReal    TK(1, Nb);
-        TColStd_Array1OfInteger TM(1, Nb);
-        myBSplineCurve->Knots(TK);
-        myBSplineCurve->Multiplicities(TM);
-        Standard_Real Eps = Min(Resolution(Precision::Confusion()),
-          Precision::PConfusion());
-
-        if (!myBSplineCurve->IsPeriodic())
-        {
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myFirst,
-            myBSplineCurve->IsPeriodic(),
-            1, Nb, Index1, newFirst);
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myLast,
-            myBSplineCurve->IsPeriodic(),
-            1, Nb, Index2, newLast);
-
-
-          // On decale eventuellement les indices  
-          // On utilise une "petite" tolerance, la resolution ne doit 
-                // servir que pour les tres longue courbes....(PRO9248)
-          if (Abs(newFirst - TK(Index1 + 1)) < Eps) Index1++;
-          if (newLast - TK(Index2) > Eps) Index2++;
-
-          Inter(1) = Index1;
-          myNbIntervals = 1;
-          for (Standard_Integer i = 1; i <= NbInt; i++) {
-            if (Inter(i) > Index1 && Inter(i) < Index2) {
-              myNbIntervals++;
-              Inter(myNbIntervals) = Inter(i);
-            }
-          }
-          Inter(myNbIntervals + 1) = Index2;
-
-          Standard_Integer ii = T.Lower() - 1;
-          for (Standard_Integer I = 1; I <= myNbIntervals + 1; I++) {
-            T(ii + I) = TK(Inter(I));
-          }
-        }
-        else
-        {
-          Standard_Real aFirst = myFirst;
-          Standard_Real aLast = myLast;
-
-          Standard_Real aCurFirst = aFirst;
-          Standard_Real aCurLast = aLast;
-
-          Standard_Real aPeriod = myBSplineCurve->Period();
-          Standard_Real aLower = myBSplineCurve->FirstParameter();
-          Standard_Real anUpper = myBSplineCurve->LastParameter();
-
-          Standard_Integer aLPer = 0; Standard_Integer aFPer = 0;
-
-          if (Abs(myFirst - aLower) <= Eps)
-          {
-            aCurFirst = aLower;
-            aFirst = aCurFirst;
-          }
-          if (Abs(myLast - anUpper) <= Eps)
-          {
-            aCurLast = anUpper;
-            aLast = aCurLast;
-          }
-
-          if ((Abs(aLower - myFirst) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          else
-          {
-            DefinFPeriod(aLower, anUpper,
-              Eps, aPeriod, aCurFirst, aFPer);
-          }
-          DefinLPeriod(aLower, anUpper,
-            Eps, aPeriod, aCurLast, aLPer);
-
-          if (myFirst == aLower)
-          {
-            aFPer = 0;
-          }
-
-          SpreadInt(TK, TM, Inter, myBSplineCurve->Degree(), Nb, aFPer, aLPer, NbInt, aLower, myFirst, myLast, aPeriod,
-            aCurLast, Eps, T, myNbIntervals);
-          T(T.Lower()) = aFirst;
-          T(T.Lower() + myNbIntervals) = aLast;
-          return;
-
-        }
-      }
-      T(T.Lower()) = myFirst;
-      T(T.Lower() + myNbIntervals) = myLast;
+  if (myTypeCurve == GeomAbs_BSplineCurve)
+  {
+    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+    {
+      T( T.Lower() ) = myFirst;
+      T( T.Lower() + 1 ) = myLast;
       return;
-      }
     }
+
+    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Integer aCont;
+
+    switch (S)
+    {
+      case GeomAbs_C1:
+        aCont = 1;
+        break;
+      case GeomAbs_C2:
+        aCont = 2;
+        break;
+      case GeomAbs_C3:
+        aCont = 3;
+        break;
+      case GeomAbs_CN:
+        aCont = aDegree;
+        break;
+      default:
+        throw Standard_DomainError ("Geom2dAdaptor_Curve::Intervals()");
+    }
+
+    Standard_Real anEps = Min(Resolution(Precision::Confusion()), Precision::PConfusion());
+
+    BSplCLib::Intervals(myBSplineCurve->Knots(),
+                        myBSplineCurve->Multiplicities(),
+                        aDegree,
+                        myBSplineCurve->IsPeriodic(),
+                        aCont,
+                        myFirst,
+                        myLast,
+                        anEps,
+                        &T);
   }
+
   else if (myTypeCurve == GeomAbs_OffsetCurve){
+    Standard_Integer myNbIntervals = 1;
     GeomAbs_Shape BaseS=GeomAbs_C0;
     switch(S){
     case GeomAbs_G1:
@@ -1077,13 +431,18 @@ void Geom2dAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
     default: BaseS = GeomAbs_CN;
     }
 
-    Geom2dAdaptor_Curve anAdaptor( Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve() );
+    Geom2dAdaptor_Curve anAdaptor (Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve(), myFirst, myLast);
     myNbIntervals = anAdaptor.NbIntervals(BaseS);
     anAdaptor.Intervals(T, BaseS);
+    T( T.Lower() ) = myFirst;
+    T( T.Lower() + myNbIntervals ) = myLast;
   }
 
-  T( T.Lower() ) = myFirst;
-  T( T.Lower() + myNbIntervals ) = myLast;
+  else
+  {
+    T( T.Lower() ) = myFirst;
+    T( T.Lower() + 1 ) = myLast;
+  }
 }
 
 //=======================================================================

src/Geom2dConvert/Geom2dConvert.cxx

@@ -515,7 +515,6 @@ static Handle(Geom2d_BSplineCurve) MultNumandDenom(const Handle(Geom2d_BSplineCu
   Handle(TColStd_HArray1OfReal)      resKnots;
   Handle(TColStd_HArray1OfInteger)   resMults; 
   Standard_Real                      start_value,end_value;
-  Standard_Real                      tolerance=Precision::Confusion();
   Standard_Integer                   resNbPoles,degree,
                                      ii,jj,
 				     aStatus;
@@ -527,6 +526,7 @@ static Handle(Geom2d_BSplineCurve) MultNumandDenom(const Handle(Geom2d_BSplineCu
   BS->KnotSequence(BSFlatKnots);
   start_value = BSKnots(1);
   end_value = BSKnots(BS->NbKnots());
+  Standard_Real tolerance = 10.*Epsilon(Abs(end_value));
 
   a->Knots(aKnots);
   a->Poles(aPoles);
@@ -565,22 +565,6 @@ static Handle(Geom2d_BSplineCurve) MultNumandDenom(const Handle(Geom2d_BSplineCu
 			     degree,
 			     resDenPoles,
 			     aStatus);
-//  BSplCLib::FunctionMultiply(law_evaluator,
-//			     BS->Degree(),
-//			     BSFlatKnots,
-//			     BSPoles,
-//			     resFlatKnots,
-//			     degree,
-//			     resNumPoles,
-//			     aStatus);
-//  BSplCLib::FunctionMultiply(law_evaluator,
-//			     BS->Degree(),
-//			     BSFlatKnots,
-//			     BSWeights,
-//			     resFlatKnots,
-//			     degree,
-//			     resDenPoles,
-//			     aStatus);
   for (ii=1;ii<=resNbPoles;ii++)
     for(jj=1;jj<=2;jj++) 
       resPoles(ii).SetCoord(jj,resNumPoles(ii).Coord(jj)/resDenPoles(ii));
@@ -1339,24 +1323,22 @@ void  Geom2dConvert::ConcatC1(TColGeom2d_Array1OfBSplineCurve&           ArrayOf
 	     Curve1Poles(ii).SetCoord(jj,Curve1Poles(ii).Coord(jj)*Curve1Weights(ii));
 //POP pour NT
 	 Geom2dConvert_reparameterise_evaluator ev (aPolynomialCoefficient);
-//	 BSplCLib::FunctionReparameterise(reparameterise_evaluator,
 	 BSplCLib::FunctionReparameterise(ev,
 					  Curve1->Degree(),
 					  Curve1FlatKnots,
 					  Curve1Poles,
 					  FlatKnots,
-                                          aNewCurveDegree,
+                      aNewCurveDegree,
 					  NewPoles,
 					  aStatus
 					  );
-         TColStd_Array1OfReal NewWeights(1, FlatKnots.Length() - (aNewCurveDegree + 1));
-//	 BSplCLib::FunctionReparameterise(reparameterise_evaluator,
+     TColStd_Array1OfReal NewWeights(1, FlatKnots.Length() - (aNewCurveDegree + 1));
 	 BSplCLib::FunctionReparameterise(ev,
 					  Curve1->Degree(),
 					  Curve1FlatKnots,
 					  Curve1Weights,
 					  FlatKnots,
-                                          aNewCurveDegree,
+                      aNewCurveDegree,
 					  NewWeights,
 					  aStatus
 					  );

src/GeomAdaptor/GeomAdaptor_Curve.cxx

@@ -58,65 +58,6 @@ static const Standard_Real PosTol = Precision::PConfusion() / 2;
 
 IMPLEMENT_STANDARD_RTTIEXT(GeomAdaptor_Curve, Adaptor3d_Curve)
 
-static void DefinFPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurFirst,
-  Standard_Integer &theFPer);
-
-static void DefinLPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurLast,
-  Standard_Integer &theLPer);
-
-static Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
-  const TColStd_Array1OfInteger& theTM,
-  const TColStd_Array1OfInteger& theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theNbInt,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real theEps,
-  const Standard_Boolean thePeriodicCur,
-  Standard_Integer theNbIntervals,
-  Standard_Real theLower = 0,
-  Standard_Real thePeriod = 0,
-  Standard_Integer theIndex1 = 0,
-  Standard_Integer theIndex2 = 0);
-
-static void WriteIntervals(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theNbInt,
-  const Standard_Integer theIndex1,
-  const Standard_Integer theIndex2,
-  const Standard_Real theCurPeriod,
-  const Standard_Boolean theFlagForFirst,
-  TColStd_Array1OfReal &theT,
-  TColStd_Array1OfInteger &theFinalIntervals,
-  Standard_Integer &theNbIntervals,
-  Standard_Integer &theCurInt);
-
-static void SpreadInt(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theTM,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theFPer,
-  const Standard_Integer theLPer,
-  const Standard_Integer theNbInt,
-  const Standard_Real theLower,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real thePeriod,
-  const Standard_Real theLastParam,
-  const Standard_Real theEps,
-  TColStd_Array1OfReal &theT,
-  Standard_Integer &theNbIntervals);
-
 //=======================================================================
 //function : ShallowCopy
 //purpose  : 
@@ -310,159 +251,6 @@ GeomAbs_Shape GeomAdaptor_Curve::Continuity() const
   return GeomAbs_CN;
 }
 
-//=======================================================================
-//function : DefinFPeriod
-//purpose  :
-//=======================================================================
-
-void DefinFPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurFirst,
-  Standard_Integer &theFPer)
-{
-  if (theCurFirst >= theLower)
-  {
-    while (theCurFirst >= theUpper)
-    {
-      theCurFirst = theCurFirst - thePeriod;
-      theFPer++;
-    }
-    if (Abs(theUpper - theCurFirst) <= theEps)
-    {
-      theFPer++;
-      theCurFirst = theLower;
-    }
-  }
-  else
-  {
-    while (theCurFirst < theLower)
-    {
-      theCurFirst = theCurFirst + thePeriod;
-      if ((Abs(theLower - theCurFirst)) > theEps)
-      {
-        theFPer--;
-      }
-    }
-
-    if (Abs(theUpper - theCurFirst) <= theEps)
-    {
-      theCurFirst = theLower;
-    }
-  }
-}
-
-//=======================================================================
-//function : DefinLPeriod
-//purpose  :
-//=======================================================================
-
-void DefinLPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurLast,
-  Standard_Integer &theLPer)
-{
-  if (theCurLast >= theLower)
-  {
-    if ((theCurLast >= theUpper) && (Abs(theCurLast - theUpper) <= theEps))
-    {
-      theCurLast = theUpper;
-    }
-    else
-    {
-      while (theCurLast >= theUpper)
-      {
-        theCurLast = theCurLast - thePeriod;
-        theLPer++;
-      }
-      if (Abs(theUpper - theCurLast) <= theEps)
-      {
-        theCurLast = theLower;
-      }
-    }
-  }
-  else
-  {
-    while (theCurLast < theLower)
-    {
-      theCurLast = theCurLast + thePeriod;
-      if (Abs(theLower - theCurLast) > theEps)
-      {
-        theLPer--;
-      }
-    }
-    if ((theUpper - theCurLast) <= theEps)
-    {
-      theCurLast = theLower;
-    }
-  }
-}
-
-//=======================================================================
-//function : LocalNbIntervals
-//purpose  :
-//=======================================================================
-
-Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
-  const TColStd_Array1OfInteger& theTM,
-  const TColStd_Array1OfInteger& theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theNbInt,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real theEps,
-  const Standard_Boolean thePeriodicCur,
-  Standard_Integer theNbIntervals,
-  Standard_Real theLower,
-  Standard_Real thePeriod,
-  Standard_Integer theIndex1,
-  Standard_Integer theIndex2)
-{
-  Standard_Real aNewFirst = theFirst;
-  Standard_Real aNewLast = theLast;
-  if (theIndex1 == 0)
-  {
-    BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theFirst,
-      thePeriodicCur, 1, theNb, theIndex1, aNewFirst);
-  }
-  if (theIndex2 == 0)
-  {
-    BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theLast,
-      thePeriodicCur, 1, theNb, theIndex2, aNewLast);
-  }
-  // Protection against theFirst = UFirst - eps, which located as ULast - eps
-  if (thePeriodicCur && ((aNewLast - aNewFirst) < Precision::PConfusion()))
-  {
-    if (Abs(aNewLast - theLower) < Precision::PConfusion())
-    {
-      aNewLast += thePeriod;
-    }
-    else
-    {
-      aNewFirst -= thePeriod;
-    }
-  }
-
-  if (Abs(aNewFirst - theTK(theIndex1 + 1)) < theEps)
-  {
-    theIndex1++;
-  }
-  if ((aNewLast - theTK(theIndex2)) > theEps)
-  {
-    theIndex2++;
-  }
-  for (Standard_Integer i = 1; i <= theNbInt; i++)
-  {
-    if (theInter(i) > theIndex1 && theInter(i) < theIndex2) theNbIntervals++;
-  }
-  return theNbIntervals;
-}
-
-
 //=======================================================================
 //function : NbIntervals
 //purpose  : 
@@ -470,207 +258,61 @@ Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
 
 Standard_Integer GeomAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
 {
-  Standard_Integer myNbIntervals = 1;
-  Standard_Integer NbSplit;
-  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-    Standard_Integer LastIndex = myBSplineCurve->LastUKnotIndex();
-    TColStd_Array1OfInteger Inter(1, LastIndex - FirstIndex + 1);
-    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-
-    if(aContPer || aContNotPer) {
-      Standard_Integer Cont;
-      switch (S) {
-      case GeomAbs_G1:
-      case GeomAbs_G2:
-        throw Standard_DomainError("GeomAdaptor_Curve::NbIntervals");
-        break;
-      case GeomAbs_C0:
-        myNbIntervals = 1;
-        break;
-      case GeomAbs_C1:
-      case GeomAbs_C2:
-      case GeomAbs_C3:
-      case GeomAbs_CN:
-      {
-        if (S == GeomAbs_C1) Cont = 1;
-        else if (S == GeomAbs_C2) Cont = 2;
-        else if (S == GeomAbs_C3) Cont = 3;
-        else                       Cont = myBSplineCurve->Degree();
-        Standard_Integer Degree = myBSplineCurve->Degree();
-        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        TColStd_Array1OfInteger Mults(1, NbKnots);
-        myBSplineCurve->Multiplicities(Mults);
-        NbSplit = 1;
-        Standard_Integer Index = FirstIndex;
-        Inter(NbSplit) = Index;
-        Index++;
-        NbSplit++;
-        while (Index < LastIndex)
-        {
-          if (Degree - Mults(Index) < Cont)
-          {
-            Inter(NbSplit) = Index;
-            NbSplit++;
-          }
-          Index++;
-        }
-        Inter(NbSplit) = Index;
-
-        Standard_Integer NbInt = NbSplit - 1;
-
-        Standard_Integer Nb = myBSplineCurve->NbKnots();
-        Standard_Integer Index1 = 0;
-        Standard_Integer Index2 = 0;
-        const TColStd_Array1OfReal& TK = myBSplineCurve->Knots();
-        const TColStd_Array1OfInteger& TM = myBSplineCurve->Multiplicities();
-        Standard_Real Eps = Min(Resolution(Precision::Confusion()),
-          Precision::PConfusion());
-
-        myNbIntervals = 1;
-
-        if (!myBSplineCurve->IsPeriodic())
-        {
-          myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-            myFirst, myLast, Eps, Standard_False, myNbIntervals);
-        }
-        else
-        {
-          Standard_Real aCurFirst = myFirst;
-          Standard_Real aCurLast = myLast;
-          Standard_Real aLower = myBSplineCurve->FirstParameter();
-          Standard_Real anUpper = myBSplineCurve->LastParameter();
-
-          if ((Abs(aCurFirst - aLower) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          if ((Abs(aCurLast - anUpper) < Eps) && (aCurLast < anUpper))
-          {
-            aCurLast = anUpper;
-          }
-
-          Standard_Real aPeriod = myBSplineCurve->Period();
-          Standard_Integer aLPer = 1; Standard_Integer aFPer = 1;
-          if ((Abs(aLower - myFirst) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          else
-          {
-            DefinFPeriod(aLower, anUpper,
-              Eps, aPeriod, aCurFirst, aFPer);
-          }
-          DefinLPeriod(aLower, anUpper,
-            Eps, aPeriod, aCurLast, aLPer);
-
-          Standard_Real aNewFirst;
-          Standard_Real aNewLast;
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myFirst,
-            Standard_True, 1, Nb, Index1, aNewFirst);
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myLast,
-            Standard_True, 1, Nb, Index2, aNewLast);
-          if ((aNewFirst == myFirst && aNewLast == myLast) && (aFPer != aLPer))
-          {
-            myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-              myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-          }
-          else
-          {
-            Standard_Integer aSumPer = Abs(aLPer - aFPer);
-            
-            Standard_Real aFirst = 0;
-            if (aLower < 0 && anUpper == 0)
-            {
-              if (Abs(aCurLast) < Eps)
-              {
-                aCurLast = 0;
-              }
-              aFirst = aLower;
-            }
-
-            if (aSumPer <= 1)
-            {
-              if ((Abs(myFirst - TK(Nb) - aPeriod * (aFPer - 1)) <= Eps) && (myLast < (TK(Nb) + aPeriod * (aLPer - 1))))
-              {
-                myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                  myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-                return myNbIntervals;
-              }
-              if ((Abs(myFirst - aLower) < Eps) && (Abs(myLast - anUpper) < Eps))
-              {
-                myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                  myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-                return myNbIntervals;
-              }
-            }
-
-            if (aSumPer != 0)
-            {
-              Standard_Integer aFInt = 0;
-              Standard_Integer aLInt = 0;
-              Standard_Integer aPInt = NbInt;
-
-              if ((aCurFirst != aPeriod) || ((aCurFirst != anUpper) && (Abs(myFirst) < Eps)))
-              {
-                aFInt = 1;
-              }
-              if ((aCurLast != aLower) && (aCurLast != anUpper))
-              {
-                aLInt = 1;
-              }
-
-              aFInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                aCurFirst, anUpper, Eps, Standard_True, aFInt, aLower, aPeriod);
-
-              if (aCurLast == anUpper)
-              {
-                aLInt = NbInt;
-              }
-              else
-              {
-                if (Abs(aCurLast - aFirst) > Eps)
-                {
-                  aLInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                    aFirst, aCurLast, Eps, Standard_True, aLInt, aLower, aPeriod, 1);
-                }
-                else
-                {
-                  aLInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                    aFirst, aCurLast, Eps, Standard_True, aLInt, aLower, aPeriod);
-                }
-              }
-
-              myNbIntervals = aFInt + aLInt + aPInt * (aSumPer - 1);
-            }
-            else
-            {
-              myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                aCurFirst, aCurLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-            }
-          }
-        }
-      }
-      break;
-      }
+  if (myTypeCurve == GeomAbs_BSplineCurve)
+  {
+    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+    {
+      return 1;
     }
+
+    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Integer aCont;
+
+    switch (S)
+    {
+      case GeomAbs_C1:
+        aCont = 1;
+        break;
+      case GeomAbs_C2:
+        aCont = 2;
+        break;
+      case GeomAbs_C3:
+        aCont = 3;
+        break;
+      case GeomAbs_CN:
+        aCont = aDegree;
+        break;
+      default:
+        throw Standard_DomainError ("GeomAdaptor_Curve::NbIntervals()");
+    }
+
+    Standard_Real anEps = Min(Resolution(Precision::Confusion()), Precision::PConfusion());
+
+    return BSplCLib::Intervals(myBSplineCurve->Knots(),
+                               myBSplineCurve->Multiplicities(),
+                               aDegree,
+                               myBSplineCurve->IsPeriodic(),
+                               aCont,
+                               myFirst,
+                               myLast,
+                               anEps,
+                               nullptr);
   }
   
   else if (myTypeCurve == GeomAbs_OffsetCurve) {
+    Standard_Integer myNbIntervals = 1;
     GeomAbs_Shape BaseS=GeomAbs_C0;
     switch(S){
-    case GeomAbs_G1:
-    case GeomAbs_G2:
-      throw Standard_DomainError("GeomAdaptor_Curve::NbIntervals");
-      break;
-    case GeomAbs_C0: BaseS = GeomAbs_C1; break;
-    case GeomAbs_C1: BaseS = GeomAbs_C2; break;
-    case GeomAbs_C2: BaseS = GeomAbs_C3; break;
-    default: BaseS = GeomAbs_CN;
+      case GeomAbs_G1:
+        case GeomAbs_G2:
+          throw Standard_DomainError("GeomAdaptor_Curve::NbIntervals");
+          break;
+          case GeomAbs_C0: BaseS = GeomAbs_C1; break;
+          case GeomAbs_C1: BaseS = GeomAbs_C2; break;
+          case GeomAbs_C2: BaseS = GeomAbs_C3; break;
+          default: BaseS = GeomAbs_CN;
     }
-    GeomAdaptor_Curve C
-      (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve());
+    GeomAdaptor_Curve C (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve(), myFirst, myLast);
     // akm 05/04/02 (OCC278)  If our curve is trimmed we must recalculate 
     //                    the number of intervals obtained from the basis to
     //              vvv   reflect parameter bounds
@@ -680,211 +322,16 @@ Standard_Integer GeomAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
       TColStd_Array1OfReal rdfInter(1,1+iNbBasisInt);
       C.Intervals(rdfInter,BaseS);
       for (iInt=1; iInt<=iNbBasisInt; iInt++)
-	if (rdfInter(iInt)>myFirst && rdfInter(iInt)<myLast)
-	  myNbIntervals++;
+        if (rdfInter(iInt)>myFirst && rdfInter(iInt)<myLast)
+          myNbIntervals++;
     }
     // akm 05/04/02 ^^^
+    return myNbIntervals;
   }
-  return myNbIntervals;
-}
 
-//=======================================================================
-//function : WriteIntervals
-//purpose  :
-//=======================================================================
-
-static void WriteIntervals(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theNbInt,
-  const Standard_Integer theIndex1,
-  const Standard_Integer theIndex2,
-  const Standard_Real theCurPeriod,
-  const Standard_Boolean theFlagForFirst,
-  TColStd_Array1OfReal &theT,
-  TColStd_Array1OfInteger &theFinalIntervals,
-  Standard_Integer &theNbIntervals,
-  Standard_Integer &theCurInt)
-{
-  if (theFlagForFirst)
-  {
-    for (Standard_Integer anId = 1; anId <= theNbInt; anId++)
-    {
-      if (theInter(anId) > theIndex1 && theInter(anId) <= theIndex2)
-      {
-        theNbIntervals++;
-        theFinalIntervals(theNbIntervals) = theInter(anId);
-      }
-    }
-  }
   else
   {
-    for (Standard_Integer anId = 1; anId <= theNbInt; anId++)
-    {
-      if (theInter(anId) > theIndex1 && theInter(anId) < theIndex2)
-      {
-        theNbIntervals++;
-        theFinalIntervals(theNbIntervals) = theInter(anId);
-      }
-    }
-  }
- 
-  theFinalIntervals(theNbIntervals + 1) = theIndex2;
-
-  for (Standard_Integer anId = theCurInt; anId <= theNbIntervals + 1; anId++)
-  {
-    theT(anId) = theTK(theFinalIntervals(anId)) + theCurPeriod;
-    theCurInt++;
-  }
-}
-
-//=======================================================================
-//function : SpreadInt
-//purpose  :
-//=======================================================================
-
-void SpreadInt(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theTM,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theFPer,
-  const Standard_Integer theLPer,
-  const Standard_Integer theNbInt,
-  const Standard_Real theLower,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real thePeriod,
-  const Standard_Real theLastParam,
-  const Standard_Real theEps,
-  TColStd_Array1OfReal &theT,
-  Standard_Integer &theNbIntervals)
-{
-  Standard_Integer anIndex1 = 0;
-  Standard_Integer anIndex2 = 0;
-  Standard_Real aNewFirst, aNewLast;
-  Standard_Integer anUpper;
-  BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theFirst,
-    Standard_True, 1, theNb, anIndex1, aNewFirst);
-  BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theLastParam,
-    Standard_True, 1, theNb, anIndex2, aNewLast);
-
-  if (Abs(aNewFirst - theTK(anIndex1 + 1)) < theEps)
-  {
-    anIndex1++;
-  }
-  if ((aNewLast - theTK(anIndex2)) > theEps)
-  {
-    anIndex2++;
-  }
-  theNbIntervals = 1;
-
-  if (anIndex1 == theNb)
-  {
-    anIndex1 = 1;
-  }
-
-  // Count the max number of boundaries of intervals
-  if (Abs(theLPer - theFPer) > 1)
-  {
-    anUpper = theNb - anIndex1 + anIndex2 + (theLPer - theFPer - 1) * theNb + 1;
-  }
-  else
-  {
-    anUpper = theNb - anIndex1 + anIndex2 + 1;
-  }
-
-  if (theLPer == theFPer)
-  {
-    anUpper = theInter.Upper();
-  }
-  TColStd_Array1OfInteger aFinalIntervals(1, anUpper);
-  aFinalIntervals(1) = anIndex1;
-
-  // If first and last are in the same period
-  if ((Abs(theLPer - theFPer) == 0))
-  {
-    Standard_Integer aCurInt = 1;
-    Standard_Real aCurPeriod = theFPer * thePeriod;
-
-    if (theFirst == aNewFirst && theLast == aNewLast)
-    {
-      aCurPeriod = 0;
-    }
-    WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-      anIndex2, aCurPeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-    return;
-  }
-
-  // If the first and the last are in neighboring periods
-  if (Abs(theLPer - theFPer) == 1)
-  {
-    Standard_Integer aCurInt = 1;
-
-    if (Abs(theLastParam - theLower) < theEps)
-    {
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
-    else
-    {
-      // For period with first
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      // For period with last
-      theNbIntervals++;
-      WriteIntervals(theTK, theInter, theNbInt, 1,
-        anIndex2, theLPer * thePeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
-  }
-  // If the first and the last are far apart
-  if (Abs(theLPer - theFPer) > 1)
-  {
-    Standard_Integer aCurInt = 1;
-
-    if (Abs(theLastParam - theLower) < theEps)
-    {
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-      Standard_Integer aNbPer = Abs(theLPer - theFPer);
-      Standard_Integer aCurPer = theFPer + 1;
-
-      while (aNbPer > 1)
-      {
-        theNbIntervals++;
-        WriteIntervals(theTK, theInter, theNbInt, 1,
-          theNb, aCurPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-        
-        aNbPer--;
-        aCurPer++;
-      }
-      return;
-    }
-    else
-    {
-      // For period with first
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      
-      Standard_Integer aNbPer = Abs(theLPer - theFPer);
-      Standard_Integer aCurPer = theFPer + 1;
-      while (aNbPer > 1)
-      {
-        theNbIntervals++;
-        WriteIntervals(theTK, theInter, theNbInt, 1,
-          theNb, aCurPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-        aNbPer--;
-        aCurPer++;
-      }
-      // For period with last
-      theNbIntervals++;
-      WriteIntervals(theTK, theInter, theNbInt, 1,
-        anIndex2, theLPer * thePeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
+    return 1;
   }
 }
 
@@ -893,175 +340,53 @@ void SpreadInt(const TColStd_Array1OfReal &theTK,
 //purpose  : 
 //=======================================================================
 
-void GeomAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
-                                  const GeomAbs_Shape S   ) const
+void GeomAdaptor_Curve::Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
 {
-  Standard_Integer myNbIntervals = 1;
-  Standard_Integer NbSplit;
-  Standard_Real FirstParam = myFirst, LastParam = myLast;
-
   if (myTypeCurve == GeomAbs_BSplineCurve)
   {
-    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-    Standard_Integer LastIndex = myBSplineCurve->LastUKnotIndex();
-    TColStd_Array1OfInteger Inter(1, LastIndex - FirstIndex + 1);
-    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-
-    if (aContPer || aContNotPer) {
-      Standard_Integer Cont;
-      switch (S) {
-      case GeomAbs_G1:
-      case GeomAbs_G2:
-        throw Standard_DomainError("Geom2dAdaptor_Curve::NbIntervals");
-        break;
-      case GeomAbs_C0:
-        myNbIntervals = 1;
-        break;
-      case GeomAbs_C1:
-      case GeomAbs_C2:
-      case GeomAbs_C3:
-      case GeomAbs_CN:
-      {
-        if (S == GeomAbs_C1) Cont = 1;
-        else if (S == GeomAbs_C2) Cont = 2;
-        else if (S == GeomAbs_C3) Cont = 3;
-        else                       Cont = myBSplineCurve->Degree();
-        Standard_Integer Degree = myBSplineCurve->Degree();
-        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        TColStd_Array1OfInteger Mults(1, NbKnots);
-        myBSplineCurve->Multiplicities(Mults);
-        NbSplit = 1;
-        Standard_Integer Index = FirstIndex;
-        Inter(NbSplit) = Index;
-        Index++;
-        NbSplit++;
-        while (Index < LastIndex)
-        {
-          if (Degree - Mults(Index) < Cont)
-          {
-            Inter(NbSplit) = Index;
-            NbSplit++;
-          }
-          Index++;
-        }
-        Inter(NbSplit) = Index;
-        Standard_Integer NbInt = NbSplit - 1;
-        //        GeomConvert_BSplineCurveKnotSplitting Convector(myBspl, Cont);
-        //        Standard_Integer NbInt = Convector.NbSplits()-1;
-        //        TColStd_Array1OfInteger Inter(1,NbInt+1);
-        //        Convector.Splitting( Inter);
-
-        Standard_Integer Nb = myBSplineCurve->NbKnots();
-        Standard_Integer Index1 = 0;
-        Standard_Integer Index2 = 0;
-        Standard_Real newFirst, newLast;
-        const TColStd_Array1OfReal& TK = myBSplineCurve->Knots();
-        const TColStd_Array1OfInteger& TM = myBSplineCurve->Multiplicities();
-        Standard_Real Eps = Min(Resolution(Precision::Confusion()),
-          Precision::PConfusion());
-
-        if (!myBSplineCurve->IsPeriodic() || ((Abs(myFirst - myBSplineCurve->FirstParameter()) < Eps) &&
-          (Abs(myLast - myBSplineCurve->LastParameter()) < Eps)))
-        {
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myFirst,
-            myBSplineCurve->IsPeriodic(),
-            1, Nb, Index1, newFirst);
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myLast,
-            myBSplineCurve->IsPeriodic(),
-            1, Nb, Index2, newLast);
-          FirstParam = newFirst;
-          LastParam = newLast;
-          // Protection against myFirst = UFirst - eps, which located as ULast - eps
-          if (myBSplineCurve->IsPeriodic() && (LastParam - FirstParam) < Precision::PConfusion())
-          {
-            if (Abs(LastParam - myBSplineCurve->FirstParameter()) < Precision::PConfusion())
-              LastParam += myBSplineCurve->Period();
-            else
-              FirstParam -= myBSplineCurve->Period();
-          }
-          // On decale eventuellement les indices  
-          // On utilise une "petite" tolerance, la resolution ne doit 
-          // servir que pour les tres longue courbes....(PRO9248)
-
-          if (Abs(FirstParam - TK(Index1 + 1)) < Eps) Index1++;
-          if (LastParam - TK(Index2) > Eps) Index2++;
-
-          myNbIntervals = 1;
-
-          TColStd_Array1OfInteger aFinalIntervals(1, Inter.Upper());
-          aFinalIntervals(1) = Index1;
-          for (Standard_Integer i = 1; i <= NbInt; i++) {
-            if (Inter(i) > Index1 && Inter(i) < Index2) {
-              myNbIntervals++;
-              aFinalIntervals(myNbIntervals) = Inter(i);
-            }
-          }
-          aFinalIntervals(myNbIntervals + 1) = Index2;
-
-          for (Standard_Integer I = 1; I <= myNbIntervals + 1; I++) {
-            T(I) = TK(aFinalIntervals(I));
-          }
-        }
-        else
-        {
-          Standard_Real aFirst = myFirst;
-          Standard_Real aLast = myLast;
-
-          Standard_Real aCurFirst = aFirst;
-          Standard_Real aCurLast = aLast;
-
-          Standard_Real aPeriod = myBSplineCurve->Period();
-          Standard_Real aLower = myBSplineCurve->FirstParameter();
-          Standard_Real anUpper = myBSplineCurve->LastParameter();
-
-          Standard_Integer aLPer = 0; Standard_Integer aFPer = 0;
-
-          if (Abs(myFirst - aLower) <= Eps)
-          {
-            aCurFirst = aLower;
-            aFirst = aCurFirst;
-          }
-
-          if (Abs(myLast - anUpper) <= Eps)
-          {
-            aCurLast = anUpper;
-            aLast = aCurLast;
-          }
-
-          if ((Abs(aLower - myFirst) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          else
-          {
-            DefinFPeriod(aLower, anUpper,
-              Eps, aPeriod, aCurFirst, aFPer);
-          }
-          DefinLPeriod(aLower, anUpper,
-            Eps, aPeriod, aCurLast, aLPer);
-
-          if (myFirst == aLower)
-          {
-            aFPer = 0;
-          }
-
-          SpreadInt(TK, TM, Inter, myBSplineCurve->Degree(), Nb, aFPer, aLPer, NbInt, aLower, myFirst, myLast, aPeriod,
-            aCurLast, Eps, T, myNbIntervals);
-
-          T(T.Lower()) = aFirst;
-          T(T.Lower() + myNbIntervals) = aLast;
-          return;
-        }
-      }
-      T(T.Lower()) = myFirst;
-      T(T.Lower() + myNbIntervals) = myLast;
+    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+    {
+      T( T.Lower() ) = myFirst;
+      T( T.Lower() + 1 ) = myLast;
       return;
-      }
     }
+
+    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Integer aCont;
+
+    switch (S)
+    {
+      case GeomAbs_C1:
+        aCont = 1;
+        break;
+      case GeomAbs_C2:
+        aCont = 2;
+        break;
+      case GeomAbs_C3:
+        aCont = 3;
+        break;
+      case GeomAbs_CN:
+        aCont = aDegree;
+        break;
+      default:
+        throw Standard_DomainError ("GeomAdaptor_Curve::Intervals()");
+    }
+
+    Standard_Real anEps = Min(Resolution(Precision::Confusion()), Precision::PConfusion());
+
+    BSplCLib::Intervals(myBSplineCurve->Knots(),
+                        myBSplineCurve->Multiplicities(),
+                        aDegree,
+                        myBSplineCurve->IsPeriodic(),
+                        aCont,
+                        myFirst,
+                        myLast,
+                        anEps,
+                        &T);
   }
 
   else if (myTypeCurve == GeomAbs_OffsetCurve){
+    Standard_Integer myNbIntervals = 1;
     GeomAbs_Shape BaseS=GeomAbs_C0;
     switch(S){
     case GeomAbs_G1:
@@ -1073,8 +398,7 @@ void GeomAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
     case GeomAbs_C2: BaseS = GeomAbs_C3; break;
     default: BaseS = GeomAbs_CN;
     }
-    GeomAdaptor_Curve C
-      (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve());
+    GeomAdaptor_Curve C (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve(), myFirst, myLast);
     // akm 05/04/02 (OCC278)  If our curve is trimmed we must recalculate 
     //                    the array of intervals obtained from the basis to
     //              vvv   reflect parameter bounds
@@ -1090,10 +414,15 @@ void GeomAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
     // old - myNbIntervals = C.NbIntervals(BaseS);
     // old - C.Intervals(T, BaseS);
     // akm 05/04/02 ^^^
+    T( T.Lower() ) = myFirst;
+    T( T.Lower() + myNbIntervals ) = myLast;
   }
   
-  T( T.Lower() ) = FirstParam;
-  T( T.Lower() + myNbIntervals ) = LastParam;
+  else
+  {
+    T( T.Lower() ) = myFirst;
+    T( T.Lower() + 1 ) = myLast;
+  }
 }
 
 //=======================================================================

src/GeomFill/GeomFill_SectionPlacement.cxx

@@ -276,6 +276,8 @@ GeomFill_SectionPlacement(const Handle(GeomFill_LocationLaw)& L,
 	      
 	      Standard_Integer NbLocalPnts = 10;
 	      Standard_Integer NbPnts = (NbKnots-1) * NbLocalPnts;
+	      if (NbPnts < 0)
+	        NbPnts = 0;
 	      if (I1 != I2)
 		NbPnts += NbLocalPnts;
 	      if (I3 != I4 && first < BC->Knot(I3))

src/GeomLib/GeomLib_IsPlanarSurface.cxx

@@ -30,18 +30,6 @@
 #include <TColgp_Array1OfPnt.hxx>
 #include <TColgp_HArray1OfPnt.hxx>
 
-static Standard_Boolean Controle(const TColgp_Array1OfPnt& P,
-			  const gp_Pln& Plan,
-			  const Standard_Real Tol) 
-{
-  Standard_Integer ii;
-  Standard_Boolean B=Standard_True;
-
-  for (ii=1; ii<=P.Length() && B; ii++)  
-      B = (Plan.Distance(P(ii)) < Tol);
-    
-  return B;
-}
 
 static Standard_Boolean Controle(const TColgp_Array1OfPnt& Poles,
 				 const Standard_Real Tol,
@@ -49,51 +37,36 @@ static Standard_Boolean Controle(const TColgp_Array1OfPnt& Poles,
 				 gp_Pln& Plan) 
 {
   Standard_Boolean IsPlan = Standard_False;
-  Standard_Boolean Essai = Standard_True;
   Standard_Real gx,gy,gz;
-  Standard_Integer Nb = Poles.Length();
-    gp_Pnt Bary;
+  gp_Pnt Bary;
   gp_Dir DX, DY;
+  Standard_Real aTolSingular = Precision::Confusion();
 
-  
-  if (Nb > 10) {
-    // Test allege (pour une rejection rapide)
-    TColgp_Array1OfPnt Aux(1,5);
-    Aux(1) = Poles(1);
-    Aux(2) = Poles(Nb/3);
-    Aux(3) = Poles(Nb/2);
-    Aux(4) = Poles(Nb/2+Nb/3);
-    Aux(5) =  Poles(Nb);
-    GeomLib::Inertia(Aux, Bary, DX, DY, gx, gy, gz);
-    Essai = (gz<Tol);
-  }
-  
-  if (Essai) { // Test Grandeur nature...
-    GeomLib::Inertia(Poles, Bary, DX, DY, gx, gy, gz);
-    if (gz<Tol && gy>Tol) {
-      gp_Pnt P;
-      gp_Vec DU, DV;
-      Standard_Real umin, umax, vmin, vmax;
-      S->Bounds(umin, umax, vmin, vmax);
-      S->D1( (umin+umax)/2, (vmin+vmax)/2, P, DU, DV);
-      // On prend DX le plus proche possible de DU
-      gp_Dir du(DU);
-      Standard_Real Angle1 = du.Angle(DX);
-      Standard_Real Angle2 = du.Angle(DY);
-      if (Angle1 > M_PI/2) Angle1 = M_PI-Angle1;
-      if (Angle2 > M_PI/2) Angle2 = M_PI-Angle2;
-      if (Angle2 < Angle1) {
-	du = DY; DY = DX; DX = du;
-      }
-      if (DX.Angle(DU) > M_PI/2) DX.Reverse();
-      if (DY.Angle(DV) > M_PI/2) DY.Reverse();      
-
-      gp_Ax3 axe(Bary, DX^DY, DX);
-      Plan.SetPosition(axe);
-      Plan.SetLocation(Bary);
-      IsPlan = Standard_True;
+    
+  GeomLib::Inertia(Poles, Bary, DX, DY, gx, gy, gz);
+  if (gz < Tol && gy > aTolSingular) {
+    gp_Pnt P;
+    gp_Vec DU, DV;
+    Standard_Real umin, umax, vmin, vmax;
+    S->Bounds(umin, umax, vmin, vmax);
+    S->D1((umin + umax) / 2, (vmin + vmax) / 2, P, DU, DV);
+    // On prend DX le plus proche possible de DU
+    gp_Dir du(DU);
+    Standard_Real Angle1 = du.Angle(DX);
+    Standard_Real Angle2 = du.Angle(DY);
+    if (Angle1 > M_PI / 2) Angle1 = M_PI - Angle1;
+    if (Angle2 > M_PI / 2) Angle2 = M_PI - Angle2;
+    if (Angle2 < Angle1) {
+      du = DY; DY = DX; DX = du;
     }
-  }   
+    if (DX.Angle(DU) > M_PI / 2) DX.Reverse();
+    if (DY.Angle(DV) > M_PI / 2) DY.Reverse();
+
+    gp_Ax3 axe(Bary, DX^DY, DX);
+    Plan.SetPosition(axe);
+    Plan.SetLocation(Bary);
+    IsPlan = Standard_True;
+  }
   return IsPlan;
 }
 
@@ -106,8 +79,6 @@ static Standard_Boolean Controle(const Handle(Geom_Curve)& C,
   GeomAbs_CurveType Type;
   GeomAdaptor_Curve AC(C);
   Type = AC.GetType();
-  Handle(TColgp_HArray1OfPnt) TabP;
-  TabP.Nullify();
 
   switch (Type) {
   case GeomAbs_Line :
@@ -131,40 +102,27 @@ static Standard_Boolean Controle(const Handle(Geom_Curve)& C,
   case GeomAbs_BezierCurve:
     {
       Nb =  AC.NbPoles();
-      Handle (Geom_BezierCurve) BZ = AC.Bezier();
-      TabP = new (TColgp_HArray1OfPnt) (1, AC.NbPoles());
-      for (ii=1; ii<=Nb; ii++) 
-	TabP->SetValue(ii, BZ->Pole(ii));
       break; 
     }
   case GeomAbs_BSplineCurve:
     {
       Nb =  AC.NbPoles();
-      Handle (Geom_BSplineCurve) BZ = AC.BSpline();
-      TabP = new (TColgp_HArray1OfPnt) (1, AC.NbPoles());
-      for (ii=1; ii<=Nb; ii++) 
-	TabP->SetValue(ii, BZ->Pole(ii));
       break; 
     }
-    default :
-      {
-	Nb = 8 + 3*AC.NbIntervals(GeomAbs_CN);
-      }
-  }
- 
-  if (TabP.IsNull()) {
-    Standard_Real u, du, f, l, d;
-    f = AC.FirstParameter();
-    l = AC.LastParameter();
-    du = (l-f)/(Nb-1);
-    for (ii=1; ii<=Nb && B ; ii++) {
-      u = (ii-1)*du + f;
-      d = Plan.Distance(C->Value(u));
-      B = (d < Tol); 
+  default :
+    {
+	 Nb = 8 + 3*AC.NbIntervals(GeomAbs_CN);
     }
   }
-  else {
-    B = Controle(TabP->Array1(), Plan, Tol);
+ 
+  Standard_Real u, du, f, l, d;
+  f = AC.FirstParameter();
+  l = AC.LastParameter();
+  du = (l - f) / (Nb - 1);
+  for (ii = 1; ii <= Nb && B; ii++) {
+    u = (ii - 1)*du + f;
+    d = Plan.Distance(C->Value(u));
+    B = d < Tol;
   }
 
   return B;
@@ -196,30 +154,6 @@ GeomLib_IsPlanarSurface::GeomLib_IsPlanarSurface(const Handle(Geom_Surface)& S,
      IsPlan = Standard_False;
      break;
     }
-  case GeomAbs_BezierSurface :
-  case GeomAbs_BSplineSurface :
-    {
-      Standard_Integer ii, jj, kk,
-      NbU = AS.NbUPoles(), NbV = AS.NbVPoles(); 
-      TColgp_Array1OfPnt Poles(1, NbU*NbV);
-      if (Type == GeomAbs_BezierSurface) {
-	Handle(Geom_BezierSurface) BZ;
-	BZ = AS.Bezier();
-	for(ii=1, kk=1; ii<=NbU; ii++)
-	  for(jj=1; jj<=NbV; jj++,kk++)
-	    Poles(kk) = BZ->Pole(ii,jj);
-      }
-      else {
-	Handle(Geom_BSplineSurface) BS;
-	BS = AS.BSpline();
-	for(ii=1, kk=1; ii<=NbU; ii++)
-	  for(jj=1; jj<=NbV; jj++,kk++)
-	    Poles(kk) = BS->Pole(ii,jj);
-      }
-
-      IsPlan =  Controle(Poles, Tol, S, myPlan);
-      break;      
-    }
 
   case GeomAbs_SurfaceOfRevolution :
     {
@@ -299,7 +233,7 @@ GeomLib_IsPlanarSurface::GeomLib_IsPlanarSurface(const Handle(Geom_Surface)& S,
       break;
     }
 
-    default :
+  default :
       {
 	Standard_Integer NbU,NbV, ii, jj, kk; 
 	NbU = 8 + 3*AS.NbUIntervals(GeomAbs_CN);

src/QABugs/QABugs_20.cxx

@@ -4359,6 +4359,120 @@ static Standard_Integer QACheckBends(Draw_Interpretor& theDI,
   return 0;
 }
 
+static Standard_Integer OCC26441(Draw_Interpretor& theDi, Standard_Integer theNbArgs, const char** theArgVec)
+{
+  if (theNbArgs < 3)
+  {
+    theDi << "Syntax error: wrong number of arguments!\n";
+    return 1;
+  }
+
+  const TopoDS_Shape& aShape = DBRep::Get(theArgVec[1]);
+  if (aShape.IsNull())
+  {
+    theDi << " Null Shape is not allowed here\n";
+    return 1;
+  }
+  const TopoDS_Shape& aRefShape = DBRep::Get(theArgVec[2]);
+  if (aRefShape.IsNull())
+  {
+    theDi << " Null Shape is not allowed here\n";
+    return 1;
+  }
+  if(aShape.ShapeType() != aRefShape.ShapeType())
+  {
+    theDi << " Shape types are not the same\n";
+    return 1;
+  }
+
+  Standard_Real anEps = Precision::Confusion();
+  if (theNbArgs > 3)
+  {
+    anEps = Draw::Atof(theArgVec[3]);
+  }
+
+  Standard_Boolean isAllDiff = Standard_False;
+  if (theNbArgs > 4)
+  {
+    Standard_Integer Inc = Draw::Atoi(theArgVec[4]);
+    if (Inc > 0)
+      isAllDiff = Standard_True;
+  }
+
+  BRep_Builder aBB;
+  TopExp_Explorer anExp, anExpRef;
+  Standard_Real aMaxE = 0., aMaxV = 0.;
+  TopTools_MapOfShape aChecked;
+  TopoDS_Vertex aV[2], aRefV[2];
+
+  //Checking edge and vertex tolerances
+  TopoDS_Compound aBadEdges;
+  aBB.MakeCompound(aBadEdges);
+  TopoDS_Compound aBadVerts;
+  aBB.MakeCompound(aBadVerts);
+  anExp.Init(aShape, TopAbs_EDGE);
+  anExpRef.Init(aRefShape, TopAbs_EDGE);
+  for (; anExpRef.More(); anExpRef.Next())
+  {
+    const TopoDS_Edge& aRefE = TopoDS::Edge(anExpRef.Current());
+    if (!anExp.More())
+    {
+      theDi << " Different number of edges\n";
+      return 1;
+    }
+    const TopoDS_Edge& anE = TopoDS::Edge(anExp.Current());
+    if (!aChecked.Add(anE))
+      continue;
+    Standard_Real aTolRef = BRep_Tool::Tolerance(aRefE);
+    Standard_Real aTol = BRep_Tool::Tolerance(anE);
+    Standard_Real aDiff = aTol - aTolRef;
+    if (isAllDiff && aDiff < 0)
+      aDiff = -aDiff;
+    if (aDiff > anEps)
+    {
+      if (aDiff > aMaxE)
+        aMaxE = aDiff;
+
+      aBB.Add(aBadEdges, anE);
+    }
+    TopExp::Vertices(aRefE, aRefV[0], aRefV[1]);
+    TopExp::Vertices(anE, aV[0], aV[1]);
+
+    for (int i = 0; i < 2; ++i)
+    {
+      if (aRefV[i].IsNull())
+        continue;
+      if (!aChecked.Add(aV[i]))
+        continue;
+      aTolRef = BRep_Tool::Tolerance(aRefV[i]);
+      aTol = BRep_Tool::Tolerance(aV[i]);
+      aDiff = aTol - aTolRef;
+      if (aDiff > anEps)
+      {
+        if (aDiff > aMaxV)
+          aMaxV = aDiff;
+
+        aBB.Add(aBadVerts, aV[i]);
+      }
+    }
+
+    anExp.Next();
+
+  }
+
+  if (aMaxE > anEps)
+  {
+    theDi << " Maximal difference for edges : " << aMaxE << "\n";
+    DBRep::Set("BadEdges", aBadEdges);
+  }
+  if (aMaxV > anEps)
+  {
+    theDi << " Maximal difference for vertices : " << aMaxV << "\n";
+    DBRep::Set("BadVerts", aBadVerts);
+  }
+
+  return 0;
+}
 
 
 void QABugs::Commands_20(Draw_Interpretor& theCommands) {
@@ -4466,6 +4580,10 @@ void QABugs::Commands_20(Draw_Interpretor& theCommands) {
     "QACheckBends curve [CosMaxAngle [theNbPoints]]",
     __FILE__,
     QACheckBends, group);
+  theCommands.Add("OCC26441",
+    "OCC26441 shape ref_shape [tol [all_diff 0/1]] \nif all_diff = 0, only icreasing tolerances is considered" ,
+    __FILE__,
+    OCC26441, group);
 
   return;
 }

src/STEPCAFControl/STEPCAFControl_Reader.cxx

@@ -221,6 +221,10 @@
 #include <StepVisual_TessellatedCurveSet.hxx>
 #include <StepVisual_CoordinatesList.hxx>
 #include <NCollection_Vector.hxx>
+#include <StepVisual_OverRidingStyledItem.hxx>
+#include <StepVisual_ContextDependentOverRidingStyledItem.hxx>
+#include <StepRepr_ShapeRepresentationRelationshipWithTransformation.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
 
 #include <TColgp_HArray1OfXYZ.hxx>
 #include <BRepBuilderAPI_MakeEdge.hxx>
@@ -937,6 +941,306 @@ static void propagateColorToParts(const Handle(XCAFDoc_ShapeTool)& theSTool,
       propagateColorToParts(theSTool, theCTool, anOriginalL);
   }
 }
+
+//=======================================================================
+//function : SetAssemblyComponentStyle
+//purpose  : auxiliary: set override style for assembly components
+//=======================================================================
+
+static void SetAssemblyComponentStyle(const Handle(Transfer_TransientProcess) &theTP,
+                                      const Handle(XCAFDoc_ColorTool)& theCTool, 
+                                      const STEPConstruct_Styles& theStyles,
+                                      const Handle(StepVisual_ContextDependentOverRidingStyledItem)& theStyle)
+{
+  if (theStyle.IsNull()) return;
+
+  Handle(StepVisual_Colour) aSurfCol, aBoundCol, aCurveCol, aRenderCol;
+  Standard_Real aRenderTransp;
+  // check if it is component style
+  Standard_Boolean anIsComponent = Standard_False;
+  if (!theStyles.GetColors(theStyle, aSurfCol, aBoundCol, aCurveCol, aRenderCol, aRenderTransp, anIsComponent))
+    return;
+
+  const Interface_Graph& aGraph = theTP->Graph();
+  TopLoc_Location aLoc; // init;
+  // find shape
+  TopoDS_Shape aShape;
+  Handle(Transfer_Binder) aBinder;
+  Handle(StepShape_ShapeRepresentation) aRepr = Handle(StepShape_ShapeRepresentation)::DownCast(theStyle->ItemAP242 ().Value ());
+  if (aRepr.IsNull())
+    return;
+  Handle(StepRepr_ShapeRepresentationRelationship) aSRR;
+  Interface_EntityIterator aSubs = theTP->Graph().Sharings(aRepr);
+  for (aSubs.Start(); aSubs.More(); aSubs.Next()) {
+    const Handle(Standard_Transient)& aSubsVal = aSubs.Value();
+    if (aSubsVal->IsKind (STANDARD_TYPE(StepRepr_ShapeRepresentationRelationship)))
+    {
+      // NB: C cast is used instead of DownCast() to improve performance on some cases.
+      // This saves ~10% of elapsed time on "testgrid perf de bug29* -parallel 0".
+      aSRR = (StepRepr_ShapeRepresentationRelationship*)(aSubsVal.get());
+    }
+  }
+
+  aBinder = theTP->Find(aSRR);
+  if (!aBinder.IsNull() ) {
+    aShape = TransferBRep::ShapeResult (aBinder);
+  }
+  if (aShape.IsNull())
+    return;     
+
+  //get transformation
+  aSubs = aGraph.Shareds (theStyle);
+  aSubs.Start();
+  for(; aSubs.More(); aSubs.Next())
+  {
+    Handle(StepRepr_ShapeRepresentationRelationshipWithTransformation) aRelation = Handle(StepRepr_ShapeRepresentationRelationshipWithTransformation)::DownCast (aSubs.Value ());
+    if(aRelation.IsNull()) continue;
+
+    auto aTransf = aRelation->TransformationOperator ();
+    if(auto anItemTransf = aTransf.ItemDefinedTransformation ())
+    {
+      Handle(StepGeom_Axis2Placement3d) anAxp1 = Handle(StepGeom_Axis2Placement3d)::DownCast(anItemTransf->TransformItem1 ());
+      Handle(StepGeom_Axis2Placement3d) anAxp2 = Handle(StepGeom_Axis2Placement3d)::DownCast(anItemTransf->TransformItem2 ());
+
+      if(!anAxp1.IsNull() && !anAxp2.IsNull())
+      {
+        Handle(Geom_Axis2Placement) anOrig = StepToGeom::MakeAxis2Placement (anAxp1);
+        Handle(Geom_Axis2Placement) aTarg = StepToGeom::MakeAxis2Placement (anAxp2);
+        gp_Ax3 anAx3Orig(anOrig->Ax2());
+        gp_Ax3 anAx3Targ(aTarg->Ax2());
+
+        gp_Trsf aTr1;
+        aTr1.SetTransformation(anAx3Targ, anAx3Orig);
+        TopLoc_Location aLoc1 (aTr1);
+        aLoc = aLoc.Multiplied(aLoc1);
+      }
+    }
+  }
+
+  aShape.Location( aLoc, Standard_False );
+
+  if(!aSurfCol.IsNull() || !aBoundCol.IsNull() || !aCurveCol.IsNull() || !aRenderCol.IsNull())
+  {
+    Quantity_Color aSCol,aBCol,aCCol,aRCol;
+    Quantity_ColorRGBA aFullSCol;
+    if(!aSurfCol.IsNull()) {
+      theStyles.DecodeColor(aSurfCol,aSCol);
+      aFullSCol = Quantity_ColorRGBA(aSCol);
+    }
+    if(!aBoundCol.IsNull())
+      theStyles.DecodeColor(aBoundCol,aBCol);
+    if(!aCurveCol.IsNull())
+      theStyles.DecodeColor(aCurveCol,aCCol);
+    if(!aRenderCol.IsNull()) {
+      theStyles.DecodeColor(aRenderCol,aRCol);
+      aFullSCol = Quantity_ColorRGBA(aRCol,static_cast<float>(1.0f - aRenderTransp));
+    }
+
+    if(!aSurfCol.IsNull() || !aRenderCol.IsNull())
+      theCTool->SetInstanceColor(aShape,XCAFDoc_ColorSurf,aFullSCol);
+    if(!aBoundCol.IsNull())
+      theCTool->SetInstanceColor(aShape,XCAFDoc_ColorCurv,aBCol);
+    if(!aCurveCol.IsNull())
+      theCTool->SetInstanceColor(aShape,XCAFDoc_ColorCurv,aCCol);
+  }
+}
+
+//=======================================================================
+//function : SetStyle
+//purpose  : auxiliary: set style for parts and instances
+//=======================================================================
+
+static void SetStyle(const Handle(XSControl_WorkSession) &theWS, 
+                     const XCAFDoc_DataMapOfShapeLabel& theMap, 
+                     const Handle(XCAFDoc_ColorTool)& theCTool, 
+                     const Handle(XCAFDoc_ShapeTool)& theSTool, 
+                     const STEPConstruct_Styles& theStyles, 
+                     const Handle(TColStd_HSequenceOfTransient)& theHSeqOfInvisStyle, 
+                     const Handle(StepVisual_StyledItem)& theStyle)
+{
+  if (theStyle.IsNull()) return;
+
+  const Handle(Transfer_TransientProcess) &aTP = theWS->TransferReader()->TransientProcess();
+  if (Handle(StepVisual_OverRidingStyledItem) anOverridingStyle = Handle(StepVisual_OverRidingStyledItem)::DownCast (theStyle))
+  {
+    SetStyle (theWS, theMap, theCTool, theSTool, theStyles, theHSeqOfInvisStyle, anOverridingStyle->OverRiddenStyle ());
+    if (Handle(StepVisual_ContextDependentOverRidingStyledItem) anAssemblyComponentStyle = Handle(StepVisual_ContextDependentOverRidingStyledItem)::DownCast (theStyle))
+    {
+      SetAssemblyComponentStyle (aTP, theCTool, theStyles,anAssemblyComponentStyle);
+      return;
+    }
+  }
+
+  Standard_Boolean anIsVisible = Standard_True;
+  // check the visibility of styled item.
+  for (Standard_Integer si = 1; si <= theHSeqOfInvisStyle->Length(); si++) {
+    if (theStyle != theHSeqOfInvisStyle->Value(si))
+      continue;
+    // found that current style is invisible.
+    anIsVisible = Standard_False;
+    break;
+  }
+  Handle(StepVisual_Colour) aSurfCol, aBoundCol, aCurveCol, aRenderCol;
+  Standard_Real aRenderTransp;
+  // check if it is component style
+  Standard_Boolean anIsComponent = Standard_False;
+  if (!theStyles.GetColors(theStyle, aSurfCol, aBoundCol, aCurveCol, aRenderCol, aRenderTransp, anIsComponent) && anIsVisible)
+    return;
+
+  // collect styled items
+  NCollection_Vector<StepVisual_StyledItemTarget> anItems;
+  if (!theStyle->ItemAP242().IsNull()) {
+    anItems.Append(theStyle->ItemAP242());
+  }
+
+  for (Standard_Integer itemIt = 0; itemIt < anItems.Length(); itemIt++) {
+    Standard_Integer anIndex = aTP->MapIndex(anItems.Value(itemIt).Value());
+    TopoDS_Shape aS;
+    if (anIndex > 0) {
+      Handle(Transfer_Binder) aBinder = aTP->MapItem(anIndex);
+      aS = TransferBRep::ShapeResult(aBinder);
+    }
+    Standard_Boolean isSkipSHUOstyle = Standard_False;
+    // take shape with real location.
+    while (anIsComponent) {
+    // take SR of NAUO
+    Handle(StepShape_ShapeRepresentation) aSR;
+    findStyledSR(theStyle, aSR);
+    // search for SR along model
+    if (aSR.IsNull())
+      break;
+    Interface_EntityIterator aSubs = theWS->HGraph()->Graph().Sharings(aSR);
+    Handle(StepShape_ShapeDefinitionRepresentation) aSDR;
+    for (aSubs.Start(); aSubs.More(); aSubs.Next()) {
+      aSDR = Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(aSubs.Value());
+      if (aSDR.IsNull())
+        continue;
+      StepRepr_RepresentedDefinition aPDSselect = aSDR->Definition();
+      Handle(StepRepr_ProductDefinitionShape) PDS =
+      Handle(StepRepr_ProductDefinitionShape)::DownCast(aPDSselect.PropertyDefinition());
+      if (PDS.IsNull())
+        continue;
+      StepRepr_CharacterizedDefinition aCharDef = PDS->Definition();
+
+      Handle(StepRepr_AssemblyComponentUsage) ACU =
+      Handle(StepRepr_AssemblyComponentUsage)::DownCast(aCharDef.ProductDefinitionRelationship());
+      if (ACU.IsNull())
+        continue;
+      // PTV 10.02.2003 skip styled item that refer to SHUO
+      if (ACU->IsKind(STANDARD_TYPE(StepRepr_SpecifiedHigherUsageOccurrence))) {
+        isSkipSHUOstyle = Standard_True;
+        break;
+      }
+      Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO =
+      Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(ACU);
+      if (NAUO.IsNull())
+        continue;
+
+      TopoDS_Shape aSh;
+      // PTV 10.02.2003 to find component of assembly CORRECTLY
+      STEPConstruct_Tool aTool(theWS);
+      TDF_Label aShLab = STEPCAFControl_Reader::FindInstance(NAUO, theCTool->ShapeTool(), aTool, theMap);
+      aSh = theCTool->ShapeTool()->GetShape(aShLab);
+      if (!aSh.IsNull()) {
+        aS = aSh;
+        break;
+      }
+    }
+    break;
+  }
+  if (isSkipSHUOstyle)
+    continue; // skip styled item which refer to SHUO
+
+  if (aS.IsNull())
+    continue;
+
+  if (!aSurfCol.IsNull() || !aBoundCol.IsNull() || !aCurveCol.IsNull() || !aRenderCol.IsNull() || !anIsVisible)
+  {
+    TDF_Label aL;
+    Standard_Boolean isFound = theSTool->SearchUsingMap(aS, aL, Standard_False, Standard_True);
+    if (!aSurfCol.IsNull() || !aBoundCol.IsNull() || !aCurveCol.IsNull() || !aRenderCol.IsNull())
+    {
+      Quantity_Color aSCol, aBCol, aCCol, aRCol;
+      Quantity_ColorRGBA aFullSCol;
+      if (!aSurfCol.IsNull()) {
+        theStyles.DecodeColor(aSurfCol, aSCol);
+        aFullSCol = Quantity_ColorRGBA(aSCol);
+      }
+      if (!aBoundCol.IsNull())
+        theStyles.DecodeColor(aBoundCol, aBCol);
+      if (!aCurveCol.IsNull())
+        theStyles.DecodeColor(aCurveCol, aCCol);
+      if (!aRenderCol.IsNull()) {
+        theStyles.DecodeColor(aRenderCol, aRCol);
+        aFullSCol = Quantity_ColorRGBA(aRCol, static_cast<float>(1.0f - aRenderTransp));
+      }
+      if (isFound)
+      {
+        if (!aSurfCol.IsNull() || !aRenderCol.IsNull())
+          theCTool->SetColor(aL, aFullSCol, XCAFDoc_ColorSurf);
+        if (!aBoundCol.IsNull())
+          theCTool->SetColor(aL, aBCol, XCAFDoc_ColorCurv);
+        if (!aCurveCol.IsNull())
+          theCTool->SetColor(aL, aCCol, XCAFDoc_ColorCurv);
+      }
+      else
+      {
+        for (TopoDS_Iterator it(aS); it.More(); it.Next())
+        {
+          TDF_Label aL1;
+          if (theSTool->SearchUsingMap(it.Value(), aL1, Standard_False, Standard_True))
+          {
+            if (!aSurfCol.IsNull() || !aRenderCol.IsNull())
+              theCTool->SetColor(aL1, aFullSCol, XCAFDoc_ColorSurf);
+            if (!aBoundCol.IsNull())
+              theCTool->SetColor(aL1, aBCol, XCAFDoc_ColorCurv);
+            if (!aCurveCol.IsNull())
+              theCTool->SetColor(aL1, aCCol, XCAFDoc_ColorCurv);
+          }
+        }
+      }
+    }
+    if (!anIsVisible)
+    {
+      // sets the invisibility for shape.
+      if (isFound)
+        theCTool->SetVisibility(aL, Standard_False);
+      }
+    }
+  }
+}
+
+//=======================================================================
+//function : IsOverriden
+//purpose  : auxiliary: check that style is overridden
+//=======================================================================
+
+static Standard_Boolean IsOverriden(const Interface_Graph& theGraph, 
+                                    const Handle(StepVisual_StyledItem)& theStyle, 
+                                    Standard_Boolean theIsRoot)
+{
+  Interface_EntityIterator aSubs = theGraph.Sharings (theStyle);
+  aSubs.Start();
+  for(; aSubs.More(); aSubs.Next())
+  {
+    Handle(StepVisual_OverRidingStyledItem) anOverRidingStyle = Handle(StepVisual_OverRidingStyledItem)::DownCast (aSubs.Value ());
+    if(!anOverRidingStyle.IsNull())
+    {
+      if(!theIsRoot)
+      {
+        return Standard_True;
+      }
+      // for root style returns true only if it is overridden by other root style
+      auto anItem = anOverRidingStyle->ItemAP242 ().Value ();
+      if(!anItem.IsNull() && anItem->IsKind(STANDARD_TYPE(StepShape_ShapeRepresentation)))
+      {
+        return Standard_True;
+      }
+    }
+  }
+  return Standard_False;
+}
+
 //=======================================================================
 //function : ReadColors
 //purpose  : 
@@ -961,152 +1265,36 @@ Standard_Boolean STEPCAFControl_Reader::ReadColors(const Handle(XSControl_WorkSe
   Handle(XCAFDoc_ShapeTool) STool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
   if (STool.IsNull()) return Standard_False;
 
+  const Interface_Graph& aGraph = Styles.Graph ();
+  
   // parse and search for color attributes
-  Standard_Integer nb = Styles.NbStyles();
-  for (Standard_Integer i = 1; i <= nb; i++) {
-    Handle(StepVisual_StyledItem) style = Styles.Style(i);
-    if (style.IsNull()) continue;
-
-    Standard_Boolean IsVisible = Standard_True;
-    // check the visibility of styled item.
-    for (Standard_Integer si = 1; si <= aHSeqOfInvisStyle->Length(); si++) {
-      if (style != aHSeqOfInvisStyle->Value(si))
-        continue;
-      // found that current style is invisible.
-      IsVisible = Standard_False;
-      break;
-    }
-
-    Handle(StepVisual_Colour) SurfCol, BoundCol, CurveCol, RenderCol;
-    Standard_Real RenderTransp;
-    // check if it is component style
-    Standard_Boolean IsComponent = Standard_False;
-    if (!Styles.GetColors(style, SurfCol, BoundCol, CurveCol, RenderCol, RenderTransp, IsComponent) && IsVisible)
-      continue;
-
-    // collect styled items
-    NCollection_Vector<StepVisual_StyledItemTarget> anItems;
-    if (!style->ItemAP242().IsNull()) {
-      anItems.Append(style->ItemAP242());
-    }
-
-    const Handle(Transfer_TransientProcess) &TP = WS->TransferReader()->TransientProcess();
-    for (Standard_Integer itemIt = 0; itemIt < anItems.Length(); itemIt++) {
-      Standard_Integer index = TP->MapIndex(anItems.Value(itemIt).Value());
-      TopoDS_Shape S;
-      if (index > 0) {
-        Handle(Transfer_Binder) binder = TP->MapItem(index);
-        S = TransferBRep::ShapeResult(binder);
-      }
-      Standard_Boolean isSkipSHUOstyle = Standard_False;
-      // take shape with real location.
-      while (IsComponent) {
-        // take SR of NAUO
-        Handle(StepShape_ShapeRepresentation) aSR;
-        findStyledSR(style, aSR);
-        // search for SR along model
-        if (aSR.IsNull())
-          break;
-        Interface_EntityIterator subs = WS->HGraph()->Graph().Sharings(aSR);
-        Handle(StepShape_ShapeDefinitionRepresentation) aSDR;
-        for (subs.Start(); subs.More(); subs.Next()) {
-          aSDR = Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(subs.Value());
-          if (aSDR.IsNull())
-            continue;
-          StepRepr_RepresentedDefinition aPDSselect = aSDR->Definition();
-          Handle(StepRepr_ProductDefinitionShape) PDS =
-            Handle(StepRepr_ProductDefinitionShape)::DownCast(aPDSselect.PropertyDefinition());
-          if (PDS.IsNull())
-            continue;
-          StepRepr_CharacterizedDefinition aCharDef = PDS->Definition();
-
-          Handle(StepRepr_AssemblyComponentUsage) ACU =
-            Handle(StepRepr_AssemblyComponentUsage)::DownCast(aCharDef.ProductDefinitionRelationship());
-          if (ACU.IsNull())
-            continue;
-          // PTV 10.02.2003 skip styled item that refer to SHUO
-          if (ACU->IsKind(STANDARD_TYPE(StepRepr_SpecifiedHigherUsageOccurrence))) {
-            isSkipSHUOstyle = Standard_True;
-            break;
-          }
-          Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO =
-            Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(ACU);
-          if (NAUO.IsNull())
-            continue;
-
-          TopoDS_Shape aSh;
-          // PTV 10.02.2003 to find component of assembly CORRECTLY
-          STEPConstruct_Tool Tool(WS);
-          TDF_Label aShLab = FindInstance(NAUO, CTool->ShapeTool(), Tool, myMap);
-          aSh = CTool->ShapeTool()->GetShape(aShLab);
-          if (!aSh.IsNull()) {
-            S = aSh;
-            break;
-          }
-        }
-        break;
-      }
-      if (isSkipSHUOstyle)
-        continue; // skip styled item which refer to SHUO
-
-      if (S.IsNull())
-        continue;
-
-      if (!SurfCol.IsNull() || !BoundCol.IsNull() || !CurveCol.IsNull() || !RenderCol.IsNull() || !IsVisible)
-      {
-        TDF_Label aL;
-        Standard_Boolean isFound = STool->SearchUsingMap(S, aL, Standard_False, Standard_True);
-        if (!SurfCol.IsNull() || !BoundCol.IsNull() || !CurveCol.IsNull() || !RenderCol.IsNull())
-        {
-          Quantity_Color aSCol, aBCol, aCCol, aRCol;
-          Quantity_ColorRGBA aFullSCol;
-          if (!SurfCol.IsNull()) {
-            Styles.DecodeColor(SurfCol, aSCol);
-            aFullSCol = Quantity_ColorRGBA(aSCol);
-          }
-          if (!BoundCol.IsNull())
-            Styles.DecodeColor(BoundCol, aBCol);
-          if (!CurveCol.IsNull())
-            Styles.DecodeColor(CurveCol, aCCol);
-          if (!RenderCol.IsNull()) {
-            Styles.DecodeColor(RenderCol, aRCol);
-            aFullSCol = Quantity_ColorRGBA(aRCol, static_cast<float>(1.0f - RenderTransp));
-          }
-          if (isFound)
-          {
-            if (!SurfCol.IsNull() || !RenderCol.IsNull())
-              CTool->SetColor(aL, aFullSCol, XCAFDoc_ColorSurf);
-            if (!BoundCol.IsNull())
-              CTool->SetColor(aL, aBCol, XCAFDoc_ColorCurv);
-            if (!CurveCol.IsNull())
-              CTool->SetColor(aL, aCCol, XCAFDoc_ColorCurv);
-          }
-          else
-          {
-            for (TopoDS_Iterator it(S); it.More(); it.Next())
-            {
-              TDF_Label aL1;
-              if (STool->SearchUsingMap(it.Value(), aL1, Standard_False, Standard_True))
-              {
-                if (!SurfCol.IsNull() || !RenderCol.IsNull())
-                  CTool->SetColor(aL1, aFullSCol, XCAFDoc_ColorSurf);
-                if (!BoundCol.IsNull())
-                  CTool->SetColor(aL1, aBCol, XCAFDoc_ColorCurv);
-                if (!CurveCol.IsNull())
-                  CTool->SetColor(aL1, aCCol, XCAFDoc_ColorCurv);
-              }
-            }
-          }
-        }
-        if (!IsVisible)
-        {
-          // sets the invisibility for shape.
-          if (isFound)
-            CTool->SetVisibility(aL, Standard_False);
-        }
-      }
+  Standard_Integer nb = Styles.NbRootStyles();
+  // apply root styles earlier, as they can be overridden
+  // function IsOverriden for root style returns true only if it is overridden by other root style
+  Standard_Boolean anIsRootStyle = Standard_True;
+  for(Standard_Integer i = 1; i <= nb; i++)
+  {
+    Handle(StepVisual_StyledItem) Style = Styles.RootStyle(i);
+    // check that style is overridden by other root style
+    if (!IsOverriden (aGraph, Style, anIsRootStyle))
+    {
+      SetStyle (WS, myMap, CTool, STool, Styles, aHSeqOfInvisStyle, Style);
     }
   }
+
+  nb = Styles.NbStyles();
+  // apply leaf styles, they can override root styles
+  anIsRootStyle = Standard_False;
+  for(Standard_Integer i = 1; i <= nb; i++)
+  {
+    Handle(StepVisual_StyledItem) Style = Styles.Style(i);
+    // check that style is overridden
+    if (!IsOverriden (aGraph, Style, anIsRootStyle))
+    {
+      SetStyle (WS, myMap, CTool, STool, Styles, aHSeqOfInvisStyle, Style);
+    }
+  }
+  
   CTool->ReverseChainsOfTreeNodes();
 
   // some colors can be attached to assemblies, propagate them to components

src/STEPConstruct/STEPConstruct_Styles.cxx

@@ -68,6 +68,8 @@
 #include <XSControl_TransferReader.hxx>
 #include <XSControl_TransferWriter.hxx>
 #include <XSControl_WorkSession.hxx>
+#include <StepVisual_ContextDependentOverRidingStyledItem.hxx>
+#include <StepShape_ShapeRepresentation.hxx>
 
 //=======================================================================
 //function : STEPConstruct_Styles
@@ -124,6 +126,26 @@ Handle(StepVisual_StyledItem) STEPConstruct_Styles::Style (const Standard_Intege
   return Handle(StepVisual_StyledItem)::DownCast ( myStyles.FindKey(i) );
 }
 
+//=======================================================================
+//function : NbRootStyles
+//purpose  : 
+//=======================================================================
+
+Standard_Integer STEPConstruct_Styles::NbRootStyles () const
+{
+  return myRootStyles.Extent();
+}
+
+//=======================================================================
+//function : RootStyle
+//purpose  : 
+//=======================================================================
+
+Handle(StepVisual_StyledItem) STEPConstruct_Styles::RootStyle (const Standard_Integer i) const
+{
+  return Handle(StepVisual_StyledItem)::DownCast ( myRootStyles.FindKey(i) );
+}
+
 
 //=======================================================================
 //function : ClearStyles
@@ -134,6 +156,7 @@ void STEPConstruct_Styles::ClearStyles ()
 {
   myStyles.Clear();
   myPSA.Clear();
+  myRootStyles.Clear();
 }
 
 
@@ -344,13 +367,15 @@ Standard_Boolean STEPConstruct_Styles::LoadStyles ()
 {
   myStyles.Clear();
   myPSA.Clear();
-  
+  myRootStyles.Clear();
+    
   // find all MDGPRs and DMs and collect all defined styles in myStyles
   Handle(Interface_InterfaceModel) model = Model();
   Standard_Integer nb = model->NbEntities();
   Handle(Standard_Type) tMDGPR = STANDARD_TYPE(StepVisual_MechanicalDesignGeometricPresentationRepresentation);
   Handle(Standard_Type) tDM = STANDARD_TYPE(StepVisual_DraughtingModel);
   Handle(Standard_Type) tSI = STANDARD_TYPE(StepVisual_StyledItem);
+  Handle(Standard_Type) tSR = STANDARD_TYPE(StepShape_ShapeRepresentation);
   for (Standard_Integer i = 1; i <= nb; i ++)
   {
     Handle(Standard_Transient) enti = model->Value(i);
@@ -364,13 +389,26 @@ Standard_Boolean STEPConstruct_Styles::LoadStyles ()
         Handle(StepVisual_StyledItem) style = 
           Handle(StepVisual_StyledItem)::DownCast ( container->ItemsValue(j) );
         if ( style.IsNull() ) continue;
-        myStyles.Add ( style );
+        auto anItem = style->ItemAP242 ().Value ();
+        if (!anItem.IsNull() && anItem->IsKind(tSR))
+        {
+          myRootStyles.Add (style);
+        }
+        else
+        {
+          myStyles.Add (style);
+        }
       }
     }
-    else if (enti->DynamicType() == tSI)
+    else if (enti->IsKind (STANDARD_TYPE(StepVisual_StyledItem)))
     {
       Handle(StepVisual_StyledItem) aStyledItem = Handle(StepVisual_StyledItem)::DownCast (enti);
-      if (!myStyles.Contains (aStyledItem))
+      auto anItem = aStyledItem->ItemAP242 ().Value ();
+      if (!anItem.IsNull() && anItem->IsKind(tSR) && !myRootStyles.Contains (aStyledItem))
+      {
+        myRootStyles.Add (aStyledItem);
+      }
+      else if (!myStyles.Contains (aStyledItem))
       {
         myStyles.Add (aStyledItem);
       }

src/STEPConstruct/STEPConstruct_Styles.hxx

@@ -69,6 +69,12 @@ public:
   
   //! Returns style with given index
   Standard_EXPORT Handle(StepVisual_StyledItem) Style (const Standard_Integer i) const;
+
+  //! Returns number of override styles
+  Standard_EXPORT Standard_Integer NbRootStyles() const;
+  
+  //! Returns override style with given index
+  Standard_EXPORT Handle(StepVisual_StyledItem) RootStyle (const Standard_Integer i) const;
   
   //! Clears all defined styles and PSA sequence
   Standard_EXPORT void ClearStyles();
@@ -159,6 +165,7 @@ private:
 
   TColStd_IndexedDataMapOfTransientTransient myMapOfStyles;
   TColStd_IndexedMapOfTransient myStyles;
+  TColStd_IndexedMapOfTransient myRootStyles;
   TColStd_SequenceOfTransient myPSA;
 
 

src/STEPControl/STEPControl_Controller.cxx

@@ -239,6 +239,7 @@ STEPControl_Controller::STEPControl_Controller ()
     Interface_Static::Init ("XSTEP", "FromSTEP.FixShape.FixNonAdjacentIntersectingEdgesMode", 't', "-1");
     Interface_Static::Init ("XSTEP", "FromSTEP.FixShape.FixVertexPositionMode",       't', "0");
     Interface_Static::Init ("XSTEP", "FromSTEP.FixShape.FixVertexToleranceMode",      't', "-1"); 
+    Interface_Static::Init ("XSTEP", "FromSTEP.FixFaceSize.Tolerance",                't', "1.e-7"); 
 
     // ika 28.07.16: Parameter to read all top level solids and shells,
     // should be used only in case of invalid shape_representation without links to shapes.

src/ShapeUpgrade/ShapeUpgrade_UnifySameDomain.cxx

@@ -753,7 +753,25 @@ static void ReconstructMissedSeam(const TopTools_SequenceOfShape& theRemovedEdge
       if ((theUperiod != 0. && aUdiff > theUperiod/2) ||
           (theVperiod != 0. && aVdiff > theVperiod/2))
       {
-        anEdge.Reverse();
+        if (aLastVertex.IsSame(theCurVertex) || (theUperiod != 0. && theVperiod != 0.))
+        {
+          anEdge.Reverse();
+        }
+        else
+        {
+          TopAbs_Orientation anOri = anEdge.Orientation();
+          anEdge.Orientation(TopAbs_FORWARD);
+          Handle(Geom2d_Curve) aPC1 = BRep_Tool::CurveOnSurface(anEdge, theFrefFace, Param1, Param2);
+          anEdge.Reverse();
+          Handle(Geom2d_Curve) aPC2 = BRep_Tool::CurveOnSurface(anEdge, theFrefFace, Param1, Param2);
+          anEdge.Reverse(); // again FORWARD
+          TopLoc_Location aLoc;
+          BRep_Builder aBB;
+          Standard_Real aTol = BRep_Tool::Tolerance(anEdge);
+          const  Handle(Geom_Surface)& aSurf = BRep_Tool::Surface(theFrefFace, aLoc);
+          aBB.UpdateEdge(anEdge, aPC2, aPC1, aSurf, aLoc, aTol);
+          anEdge.Orientation(anOri);
+        }
         aPC = BRep_Tool::CurveOnSurface(anEdge, theFrefFace, Param1, Param2);
         aParam = (anEdge.Orientation() == TopAbs_FORWARD)? Param1 : Param2;
         aPoint = aPC->Value(aParam);
@@ -2745,6 +2763,26 @@ void ShapeUpgrade_UnifySameDomain::UnifyFaces()
   for (Standard_Integer i = 1; i <= aFaceMap.Extent(); i++)
     TopExp::MapShapesAndAncestors (aFaceMap(i), TopAbs_EDGE, TopAbs_FACE, aGMapEdgeFaces);
 
+  // creating map of face shells for the whole shape to avoid
+  // unification of faces belonging to the different shells
+  DataMapOfShapeMapOfShape aGMapFaceShells;
+  for (TopExp_Explorer anExp (myShape, TopAbs_SHELL); anExp.More(); anExp.Next())
+  {
+    const TopoDS_Shape& aShell = anExp.Current();
+    for (TopoDS_Iterator anItF (aShell); anItF.More(); anItF.Next())
+    {
+      const TopoDS_Shape& aF = anItF.Value();
+      if (TopTools_MapOfShape* pShells = aGMapFaceShells.ChangeSeek (aF))
+      {
+        pShells->Add (aShell);
+      }
+      else
+      {
+        (aGMapFaceShells.Bound (aF, TopTools_MapOfShape()))->Add (aShell);
+      }
+    }
+  }
+
   // creating map of free boundaries
   TopTools_MapOfShape aFreeBoundMap;
   // look at only shells not belonging to solids
@@ -2766,7 +2804,7 @@ void ShapeUpgrade_UnifySameDomain::UnifyFaces()
   // unify faces in each shell separately
   TopExp_Explorer exps;
   for (exps.Init(myShape, TopAbs_SHELL); exps.More(); exps.Next())
-    IntUnifyFaces(exps.Current(), aGMapEdgeFaces, aFreeBoundMap);
+    IntUnifyFaces(exps.Current(), aGMapEdgeFaces, aGMapFaceShells, aFreeBoundMap);
 
   // gather all faces out of shells in one compound and unify them at once
   BRep_Builder aBB;
@@ -2777,7 +2815,10 @@ void ShapeUpgrade_UnifySameDomain::UnifyFaces()
     aBB.Add(aCmp, exps.Current());
 
   if (nbf > 0)
-    IntUnifyFaces(aCmp, aGMapEdgeFaces, aFreeBoundMap);
+  {
+    // No connection to shells, thus no need to pass the face-shell map
+    IntUnifyFaces(aCmp, aGMapEdgeFaces, DataMapOfShapeMapOfShape(), aFreeBoundMap);
+  }
   
   myShape = myContext->Apply(myShape);
 }
@@ -2800,13 +2841,52 @@ static void SetFixWireModes(ShapeFix_Face& theSff)
   aFixWire->FixSmallMode() = 0;
 }
 
+//=======================================================================
+//function : isSameSets
+//purpose  : Compares two sets of shapes. Returns true if they are the same,
+//           false otherwise.
+//=======================================================================
+
+template<class Container>
+static Standard_Boolean isSameSets(const Container* theFShells1,
+                                   const Container* theFShells2)
+{
+  // If both are null - no problem
+  if (theFShells1 == nullptr && theFShells2 == nullptr)
+  {
+    return Standard_True;
+  }
+  // If only one is null - not the same
+  if (theFShells1 == nullptr || theFShells2 == nullptr)
+  {
+    return Standard_False;
+  }
+  // Both not null
+  if (theFShells1->Extent() != theFShells2->Extent())
+  {
+    return Standard_False;
+  }
+  // number of shells in each set should be very small in normal cases - max 2.
+  // thus just check if all objects of one are contained in the other and vice versa.
+  for (typename Container::Iterator it1(*theFShells1), it2(*theFShells2);
+       it1.More() && it2.More(); it1.Next(), it2.Next())
+  {
+    if (!theFShells1->Contains(it2.Value()) || !theFShells2->Contains(it1.Value()))
+    {
+      return Standard_False;
+    }
+  }
+  return Standard_True;
+}
+
 //=======================================================================
 //function : IntUnifyFaces
 //purpose  : 
 //=======================================================================
 
 void ShapeUpgrade_UnifySameDomain::IntUnifyFaces(const TopoDS_Shape& theInpShape,
-                                                 TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces,
+                                                 const TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces,
+                                                 const DataMapOfShapeMapOfShape& theGMapFaceShells,
                                                  const TopTools_MapOfShape& theFreeBoundMap)
 {
   // creating map of edge faces for the shape
@@ -2855,6 +2935,9 @@ void ShapeUpgrade_UnifySameDomain::IntUnifyFaces(const TopoDS_Shape& theInpShape
     Standard_Real Uperiod = (aBaseSurface->IsUPeriodic())? aBaseSurface->UPeriod() : 0.;
     Standard_Real Vperiod = (aBaseSurface->IsVPeriodic())? aBaseSurface->VPeriod() : 0.;
 
+    // Get shells connected to the face (in normal cases should not be more than 2)
+    const TopTools_MapOfShape* pFShells1 = theGMapFaceShells.Seek (aFace);
+
     // find adjacent faces to union
     Standard_Integer i;
     for (i = 1; i <= edges.Length(); i++) {
@@ -2903,6 +2986,15 @@ void ShapeUpgrade_UnifySameDomain::IntUnifyFaces(const TopoDS_Shape& theInpShape
         if (aProcessed.Contains(aCheckedFace))
           continue;
 
+        // Get shells connected to the checked face
+        const TopTools_MapOfShape* pFShells2 = theGMapFaceShells.Seek (aCheckedFace);
+        // Faces can be unified only if the shells of faces connected to
+        // these faces are the same. Otherwise, topology would be broken.
+        if (!isSameSets (pFShells1, pFShells2))
+        {
+          continue;
+        }
+
         if (bCheckNormals) {
           // get normal of checked face using the same parameter on edge
           gp_Dir aDN2;

src/ShapeUpgrade/ShapeUpgrade_UnifySameDomain.hxx

@@ -70,6 +70,7 @@ class ShapeUpgrade_UnifySameDomain : public Standard_Transient
 public:
 
   typedef NCollection_DataMap<TopoDS_Shape, Handle(Geom_Plane), TopTools_ShapeMapHasher> DataMapOfFacePlane;
+  typedef NCollection_DataMap<TopoDS_Shape, TopTools_MapOfShape, TopTools_ShapeMapHasher> DataMapOfShapeMapOfShape;
   
   //! Empty constructor
   Standard_EXPORT ShapeUpgrade_UnifySameDomain();
@@ -168,7 +169,8 @@ protected:
   Standard_EXPORT void UnifyEdges();
 
   void IntUnifyFaces(const TopoDS_Shape& theInpShape,
-                     TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces,
+                     const TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces,
+                     const DataMapOfShapeMapOfShape& theGMapFaceShells,
                      const TopTools_MapOfShape& theFreeBoundMap);
 
   //! Splits the sequence of edges into the sequence of chains

src/ViewerTest/ViewerTest_CmdParser.cxx

@@ -1,4 +1,3 @@
-#include <limits>
 // Created on: 2015-03-15
 // Created by: Danila ULYANOV
 // Copyright (c) 2014 OPEN CASCADE SAS
@@ -8,9 +7,8 @@
 // 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.
+// 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.
@@ -23,36 +21,36 @@
 
 #include <algorithm>
 #include <iostream>
-#include <limits>
 
-namespace {
+namespace
+{
 
-//! Converts the given string to lowercase
-//! @param theString the string to be converted
-//! @return a converted string (a string in lowercase)
-static std::string toLowerCase(std::string theString) {
-  std::transform(theString.begin(), theString.end(), theString.begin(),
-                 ::LowerCase);
-  return theString;
-}
-
-//! Converts the vector of std::strings to a vector of pointers to its data
-//! @param theStringList the vector of strings to be converted
-//! @return a vector of pointers to the data of given strings
-static std::vector<const char *>
-convertToRawStringList(const std::vector<std::string> &theStringList) {
-  const std::size_t aListSize = theStringList.size();
-  std::vector<const char *> aRawStringList(aListSize);
-  for (std::size_t anIndex = 0; anIndex < aListSize; ++anIndex) {
-    aRawStringList[anIndex] = theStringList[anIndex].c_str();
+  //! Converts the given string to lowercase
+  //! @param theString the string to be converted
+  //! @return a converted string (a string in lowercase)
+  static std::string toLowerCase (std::string theString)
+  {
+    std::transform (theString.begin(), theString.end(), theString.begin(), ::LowerCase);
+    return theString;
+  }
+
+  //! Converts the vector of std::strings to a vector of pointers to its data
+  //! @param theStringList the vector of strings to be converted
+  //! @return a vector of pointers to the data of given strings
+  static std::vector<const char*> convertToRawStringList (const std::vector<std::string>& theStringList)
+  {
+    const std::size_t        aListSize = theStringList.size();
+    std::vector<const char*> aRawStringList (aListSize);
+    for (std::size_t anIndex = 0; anIndex < aListSize; ++anIndex)
+    {
+      aRawStringList[anIndex] = theStringList[anIndex].c_str();
+    }
+    return aRawStringList;
   }
-  return aRawStringList;
-}
 
 } // namespace
 
-const std::size_t ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY =
-    (std::numeric_limits<std::size_t>::max)();
+const std::size_t ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY = (std::numeric_limits<std::size_t>::max)();
 
 const std::size_t ViewerTest_CmdParser::THE_HELP_COMMAND_OPTION_KEY = 0;
 
@@ -60,48 +58,50 @@ const std::size_t ViewerTest_CmdParser::THE_HELP_COMMAND_OPTION_KEY = 0;
 // function : ViewerTest_CmdParser
 // purpose  :
 //===============================================================================================
-ViewerTest_CmdParser::ViewerTest_CmdParser(const std::string &theDescription)
-    : myDescription(theDescription) {
-  AddOption("help|h",
-            "Prints a short description of the command and its options.");
+ViewerTest_CmdParser::ViewerTest_CmdParser (const std::string& theDescription) : myDescription (theDescription)
+{
+  AddOption ("help|h", "Prints a short description of the command and its options.");
 }
 
 //===============================================================================================
 // function : AddOption
 // purpose  :
 //===============================================================================================
-ViewerTest_CommandOptionKey
-ViewerTest_CmdParser::AddOption(const std::string &theOptionNames,
-                                const std::string &theOptionDescription) {
+ViewerTest_CommandOptionKey ViewerTest_CmdParser::AddOption (const std::string& theOptionNames,
+                                                             const std::string& theOptionDescription)
+{
   CommandOption aNewOption;
 
   // extract option names
   std::vector<std::string> aNames;
-  std::stringstream aStream(theOptionNames);
-  std::string anItem;
-  while (std::getline(aStream, anItem, '|')) {
-    if (!anItem.empty()) {
-      aNames.push_back(anItem);
+  std::stringstream        aStream (theOptionNames);
+  std::string              anItem;
+  while (std::getline (aStream, anItem, '|'))
+  {
+    if (!anItem.empty())
+    {
+      aNames.push_back (anItem);
     }
   }
 
   aNewOption.Name = aNames.front();
-  if (aNames.size() > 1) {
+  if (aNames.size() > 1)
+  {
     const std::size_t aNumberOfAliases = aNames.size() - 1;
 
-    aNewOption.Aliases.reserve(aNumberOfAliases);
-    std::copy(aNames.begin() + 1, aNames.end(),
-              std::back_inserter(aNewOption.Aliases));
+    aNewOption.Aliases.reserve (aNumberOfAliases);
+    std::copy (aNames.begin() + 1, aNames.end(), std::back_inserter (aNewOption.Aliases));
   }
   aNewOption.Description = theOptionDescription;
 
   const ViewerTest_CommandOptionKey aNewOptionKey = myOptionStorage.size();
 
-  myOptionStorage.push_back(aNewOption);
+  myOptionStorage.push_back (aNewOption);
 
   std::vector<std::string>::const_iterator anIt = aNames.begin();
-  for (; anIt != aNames.end(); ++anIt) {
-    const std::string aNameInLowerCase = toLowerCase(*anIt);
+  for (; anIt != aNames.end(); ++anIt)
+  {
+    const std::string aNameInLowerCase = toLowerCase (*anIt);
 
     myOptionMap[aNameInLowerCase] = aNewOptionKey;
   }
@@ -113,18 +113,21 @@ ViewerTest_CmdParser::AddOption(const std::string &theOptionNames,
 // function : PrintHelp
 // purpose  :
 //===============================================================================================
-void ViewerTest_CmdParser::PrintHelp() const {
+void ViewerTest_CmdParser::PrintHelp() const
+{
   std::cout << myDescription << std::endl;
   std::vector<CommandOption>::const_iterator anIt = myOptionStorage.begin();
-  for (++anIt; anIt != myOptionStorage.end(); ++anIt) {
-    const CommandOption &aCommandOption = *anIt;
+  for (++anIt; anIt != myOptionStorage.end(); ++anIt)
+  {
+    const CommandOption& aCommandOption = *anIt;
     std::cout << "\n\t-" << aCommandOption.Name;
-    const OptionAliases &anAliases = aCommandOption.Aliases;
-    if (!anAliases.empty()) {
+    const OptionAliases& anAliases = aCommandOption.Aliases;
+    if (!anAliases.empty())
+    {
       std::cout << " (-" << anAliases.front();
-      for (OptionAliases::const_iterator anAliasIterator =
-               anAliases.begin() + 1;
-           anAliasIterator != anAliases.end(); ++anAliasIterator) {
+      for (OptionAliases::const_iterator anAliasIterator = anAliases.begin() + 1; anAliasIterator != anAliases.end();
+           ++anAliasIterator)
+      {
         std::cout << ", -" << *anAliasIterator;
       }
       std::cout << ")";
@@ -138,28 +141,34 @@ void ViewerTest_CmdParser::PrintHelp() const {
 // function : Parse
 // purpose  :
 //===============================================================================================
-void ViewerTest_CmdParser::Parse(const Standard_Integer theArgsNb,
-                                 const char *const *const theArgVec) {
+void ViewerTest_CmdParser::Parse (const Standard_Integer theArgsNb, const char* const* const theArgVec)
+{
   std::size_t aCurrentUsedOptionIndex = 0;
-  for (Standard_Integer anIter = 1; anIter < theArgsNb; ++anIter) {
-    const char *const anArgument = theArgVec[anIter];
-    if (anArgument[0] == '-' && !std::isdigit(anArgument[1])) {
-      const std::string anOptionName = toLowerCase(anArgument + 1);
-      OptionMap::iterator aMapIter = myOptionMap.find(anOptionName);
-      if (aMapIter != myOptionMap.end()) {
-        const ViewerTest_CommandOptionKey aCurrentUsedOptionKey =
-            aMapIter->second;
-        aCurrentUsedOptionIndex = addUsedOption(aCurrentUsedOptionKey);
-      } else {
-        Message::SendFail()
-            << "Error: unknown argument '" << anOptionName << "'";
+  for (Standard_Integer anIter = 1; anIter < theArgsNb; ++anIter)
+  {
+    const char* const anArgument = theArgVec[anIter];
+    if (anArgument[0] == '-' && !std::isdigit (anArgument[1]))
+    {
+      const std::string   anOptionName = toLowerCase (anArgument + 1);
+      OptionMap::iterator aMapIter     = myOptionMap.find (anOptionName);
+      if (aMapIter != myOptionMap.end())
+      {
+        const ViewerTest_CommandOptionKey aCurrentUsedOptionKey = aMapIter->second;
+        aCurrentUsedOptionIndex                                 = addUsedOption (aCurrentUsedOptionKey);
+      }
+      else
+      {
+        Message::SendFail() << "Error: unknown argument '" << anOptionName << "'";
         return;
       }
-    } else {
-      if (anIter == 1) {
-        aCurrentUsedOptionIndex = addUsedOption(THE_UNNAMED_COMMAND_OPTION_KEY);
+    }
+    else
+    {
+      if (anIter == 1)
+      {
+        aCurrentUsedOptionIndex = addUsedOption (THE_UNNAMED_COMMAND_OPTION_KEY);
       }
-      myOptionArgumentStorage[aCurrentUsedOptionIndex].push_back(anArgument);
+      myOptionArgumentStorage[aCurrentUsedOptionIndex].push_back (anArgument);
     }
   }
 }
@@ -168,9 +177,10 @@ void ViewerTest_CmdParser::Parse(const Standard_Integer theArgsNb,
 // function : GetOptionNameByKey
 // purpose  :
 //===============================================================================================
-std::string ViewerTest_CmdParser::GetOptionNameByKey(
-    const ViewerTest_CommandOptionKey theOptionKey) const {
-  if (theOptionKey == THE_UNNAMED_COMMAND_OPTION_KEY) {
+std::string ViewerTest_CmdParser::GetOptionNameByKey (const ViewerTest_CommandOptionKey theOptionKey) const
+{
+  if (theOptionKey == THE_UNNAMED_COMMAND_OPTION_KEY)
+  {
     return "Unnamed";
   }
   return myOptionStorage[theOptionKey].Name;
@@ -180,13 +190,14 @@ std::string ViewerTest_CmdParser::GetOptionNameByKey(
 // function : GetUsedOptions
 // purpose  :
 //===============================================================================================
-ViewerTest_CommandOptionKeySet ViewerTest_CmdParser::GetUsedOptions() const {
+ViewerTest_CommandOptionKeySet ViewerTest_CmdParser::GetUsedOptions() const
+{
   ViewerTest_CommandOptionKeySet aUsedOptions;
-  for (UsedOptionMap::const_iterator aUsedOptionMapIterator =
-           myUsedOptionMap.begin();
+  for (UsedOptionMap::const_iterator aUsedOptionMapIterator = myUsedOptionMap.begin();
        aUsedOptionMapIterator != myUsedOptionMap.end();
-       ++aUsedOptionMapIterator) {
-    aUsedOptions.insert(aUsedOptionMapIterator->first);
+       ++aUsedOptionMapIterator)
+  {
+    aUsedOptions.insert (aUsedOptionMapIterator->first);
   }
   return aUsedOptions;
 }
@@ -195,7 +206,8 @@ ViewerTest_CommandOptionKeySet ViewerTest_CmdParser::GetUsedOptions() const {
 // function : HasNoOption
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::HasNoOption() const {
+bool ViewerTest_CmdParser::HasNoOption() const
+{
   return myUsedOptionMap.empty();
 }
 
@@ -203,16 +215,17 @@ bool ViewerTest_CmdParser::HasNoOption() const {
 // function : HasUnnamedOption
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::HasUnnamedOption() const {
-  return myUsedOptionMap.find(THE_UNNAMED_COMMAND_OPTION_KEY) !=
-         myUsedOptionMap.end();
+bool ViewerTest_CmdParser::HasUnnamedOption() const
+{
+  return myUsedOptionMap.find (THE_UNNAMED_COMMAND_OPTION_KEY) != myUsedOptionMap.end();
 }
 
 //===============================================================================================
 // function : HasNoUnnamedOption
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::HasOnlyUnnamedOption() const {
+bool ViewerTest_CmdParser::HasOnlyUnnamedOption() const
+{
   return HasUnnamedOption() && (myUsedOptionMap.size() == 1);
 }
 
@@ -220,37 +233,37 @@ bool ViewerTest_CmdParser::HasOnlyUnnamedOption() const {
 // function : HasOption
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::HasOption(
-    const std::string &theOptionName,
-    const std::size_t theMandatoryArgsNb /* = 0 */,
-    const bool isFatal /* = false */) const {
+bool ViewerTest_CmdParser::HasOption (const std::string& theOptionName,
+                                      const std::size_t  theMandatoryArgsNb /* = 0 */,
+                                      const bool         isFatal /* = false */) const
+{
   ViewerTest_CommandOptionKey anOptionKey;
-  if (!findOptionKey(theOptionName, anOptionKey)) {
+  if (!findOptionKey (theOptionName, anOptionKey))
+  {
     return false;
   }
-  return HasOption(anOptionKey, theMandatoryArgsNb, isFatal);
+  return HasOption (anOptionKey, theMandatoryArgsNb, isFatal);
 }
 
 //===============================================================================================
 // function : HasOption
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::HasOption(
-    const ViewerTest_CommandOptionKey theOptionKey,
-    const std::size_t theMandatoryArgsNb /* = 0 */,
-    const bool isFatal /* = false */) const {
+bool ViewerTest_CmdParser::HasOption (const ViewerTest_CommandOptionKey theOptionKey,
+                                      const std::size_t                 theMandatoryArgsNb /* = 0 */,
+                                      const bool                        isFatal /* = false */) const
+{
   std::size_t aUsedOptionIndex = 0;
-  if (!findUsedOptionIndex(theOptionKey, aUsedOptionIndex)) {
+  if (!findUsedOptionIndex (theOptionKey, aUsedOptionIndex))
+  {
     return false;
   }
-  const OptionArguments &anOptionArguments =
-      myOptionArgumentStorage[aUsedOptionIndex];
-  const bool aResult = (anOptionArguments.size() >= theMandatoryArgsNb);
-  if (isFatal && !aResult) {
-    Message::SendFail() << "Error: wrong syntax at option '"
-                        << myOptionStorage[theOptionKey].Name << "'\n"
-                        << "At least " << theMandatoryArgsNb
-                        << "expected, but only " << anOptionArguments.size()
+  const OptionArguments& anOptionArguments = myOptionArgumentStorage[aUsedOptionIndex];
+  const bool             aResult           = (anOptionArguments.size() >= theMandatoryArgsNb);
+  if (isFatal && !aResult)
+  {
+    Message::SendFail() << "Error: wrong syntax at option '" << myOptionStorage[theOptionKey].Name << "'\n"
+                        << "At least " << theMandatoryArgsNb << "expected, but only " << anOptionArguments.size()
                         << "provided.";
   }
   return aResult;
@@ -260,63 +273,68 @@ bool ViewerTest_CmdParser::HasOption(
 // function : GetNumberOfOptionArguments
 // purpose  :
 //===============================================================================================
-Standard_Integer ViewerTest_CmdParser::GetNumberOfOptionArguments(
-    const std::string &theOptionName) const {
+Standard_Integer ViewerTest_CmdParser::GetNumberOfOptionArguments (const std::string& theOptionName) const
+{
   ViewerTest_CommandOptionKey anOptionKey = THE_UNNAMED_COMMAND_OPTION_KEY;
-  if (!findOptionKey(theOptionName, anOptionKey)) {
+  if (!findOptionKey (theOptionName, anOptionKey))
+  {
     return 0;
   }
-  return GetNumberOfOptionArguments(anOptionKey);
+  return GetNumberOfOptionArguments (anOptionKey);
 }
 
 //===============================================================================================
 // function : GetNumberOfOptionArguments
 // purpose  :
 //===============================================================================================
-Standard_Integer ViewerTest_CmdParser::GetNumberOfOptionArguments(
-    const ViewerTest_CommandOptionKey theOptionKey) const {
+Standard_Integer ViewerTest_CmdParser::GetNumberOfOptionArguments (const ViewerTest_CommandOptionKey theOptionKey) const
+{
   std::size_t aUsedOptionIndex = 0;
-  if (!findUsedOptionIndex(theOptionKey, aUsedOptionIndex)) {
+  if (!findUsedOptionIndex (theOptionKey, aUsedOptionIndex))
+  {
     return false;
   }
-  return static_cast<Standard_Integer>(
-      myOptionArgumentStorage[aUsedOptionIndex].size());
+  return static_cast<Standard_Integer> (myOptionArgumentStorage[aUsedOptionIndex].size());
 }
 
 //===============================================================================================
 // function : Arg
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::Arg(const std::string &theOptionName,
-                               const Standard_Integer theArgumentIndex,
-                               std::string &theOptionArgument) const {
-  Standard_ASSERT_RETURN(
-      theArgumentIndex >= 0,
-      "'theArgumentIndex' must be greater than or equal to zero.", false);
+bool ViewerTest_CmdParser::Arg (const std::string&     theOptionName,
+                                const Standard_Integer theArgumentIndex,
+                                std::string&           theOptionArgument) const
+{
+  Standard_ASSERT_RETURN (theArgumentIndex >= 0,
+                          "'theArgumentIndex' must be greater than or equal to zero.",
+                          false);
   ViewerTest_CommandOptionKey anOptionKey = THE_UNNAMED_COMMAND_OPTION_KEY;
-  if (!theOptionName.empty() && !findOptionKey(theOptionName, anOptionKey)) {
+  if (!theOptionName.empty() && !findOptionKey (theOptionName, anOptionKey))
+  {
     return false;
   }
-  return Arg(anOptionKey, theArgumentIndex, theOptionArgument);
+  return Arg (anOptionKey, theArgumentIndex, theOptionArgument);
 }
 
 //===============================================================================================
 // function : Arg
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::Arg(const ViewerTest_CommandOptionKey theOptionKey,
-                               const Standard_Integer theArgumentIndex,
-                               std::string &theOptionArgument) const {
-  Standard_ASSERT_RETURN(
-      theArgumentIndex >= 0,
-      "'theArgumentIndex' must be greater than or equal to zero.", false);
+bool ViewerTest_CmdParser::Arg (const ViewerTest_CommandOptionKey theOptionKey,
+                                const Standard_Integer            theArgumentIndex,
+                                std::string&                      theOptionArgument) const
+{
+  Standard_ASSERT_RETURN (theArgumentIndex >= 0,
+                          "'theArgumentIndex' must be greater than or equal to zero.",
+                          false);
   std::size_t aUsedOptionIndex = 0;
-  if (!findUsedOptionIndex(theOptionKey, aUsedOptionIndex)) {
+  if (!findUsedOptionIndex (theOptionKey, aUsedOptionIndex))
+  {
     return false;
   }
-  const OptionArguments &anOptionArguments =
-      myOptionArgumentStorage[aUsedOptionIndex];
-  if (static_cast<std::size_t>(theArgumentIndex) >= anOptionArguments.size()) {
+  const OptionArguments& anOptionArguments = myOptionArgumentStorage[aUsedOptionIndex];
+  if (static_cast<std::size_t> (theArgumentIndex) >= anOptionArguments.size())
+  {
     return false;
   }
   theOptionArgument = anOptionArguments[theArgumentIndex];
@@ -327,15 +345,14 @@ bool ViewerTest_CmdParser::Arg(const ViewerTest_CommandOptionKey theOptionKey,
 // function : Arg
 // purpose  :
 //===============================================================================================
-std::string
-ViewerTest_CmdParser::Arg(const std::string &theOptionName,
-                          const Standard_Integer theArgumentIndex) const {
-  Standard_ASSERT_RETURN(
-      theArgumentIndex >= 0,
-      "'theArgumentIndex' must be greater than or equal to zero.",
-      std::string());
+std::string ViewerTest_CmdParser::Arg (const std::string& theOptionName, const Standard_Integer theArgumentIndex) const
+{
+  Standard_ASSERT_RETURN (theArgumentIndex >= 0,
+                          "'theArgumentIndex' must be greater than or equal to zero.",
+                          std::string());
   std::string anOptionArgument;
-  if (!Arg(theOptionName, theArgumentIndex, anOptionArgument)) {
+  if (!Arg (theOptionName, theArgumentIndex, anOptionArgument))
+  {
     return std::string();
   }
   return anOptionArgument;
@@ -345,11 +362,12 @@ ViewerTest_CmdParser::Arg(const std::string &theOptionName,
 // function : Arg
 // purpose  :
 //===============================================================================================
-std::string
-ViewerTest_CmdParser::Arg(const ViewerTest_CommandOptionKey theOptionKey,
-                          const Standard_Integer theArgumentIndex) const {
+std::string ViewerTest_CmdParser::Arg (const ViewerTest_CommandOptionKey theOptionKey,
+                                       const Standard_Integer            theArgumentIndex) const
+{
   std::string anOptionArgument;
-  if (!Arg(theOptionKey, theArgumentIndex, anOptionArgument)) {
+  if (!Arg (theOptionKey, theArgumentIndex, anOptionArgument))
+  {
     return std::string();
   }
   return anOptionArgument;
@@ -359,92 +377,86 @@ ViewerTest_CmdParser::Arg(const ViewerTest_CommandOptionKey theOptionKey,
 // function : ArgVec3f
 // purpose  :
 //===============================================================================================
-Graphic3d_Vec3
-ViewerTest_CmdParser::ArgVec3f(const std::string &theOptionName,
-                               Standard_Integer theArgumentIndex) const {
-  return Graphic3d_Vec3(static_cast<Standard_ShortReal>(Draw::Atof(
-                            Arg(theOptionName, theArgumentIndex).c_str())),
-                        static_cast<Standard_ShortReal>(Draw::Atof(
-                            Arg(theOptionName, theArgumentIndex + 1).c_str())),
-                        static_cast<Standard_ShortReal>(Draw::Atof(
-                            Arg(theOptionName, theArgumentIndex + 2).c_str())));
+Graphic3d_Vec3 ViewerTest_CmdParser::ArgVec3f (const std::string& theOptionName,
+                                               Standard_Integer   theArgumentIndex) const
+{
+  return Graphic3d_Vec3 (
+    static_cast<Standard_ShortReal> (Draw::Atof (Arg (theOptionName, theArgumentIndex).c_str())),
+    static_cast<Standard_ShortReal> (Draw::Atof (Arg (theOptionName, theArgumentIndex + 1).c_str())),
+    static_cast<Standard_ShortReal> (Draw::Atof (Arg (theOptionName, theArgumentIndex + 2).c_str())));
 }
 
 //===============================================================================================
 // function : ArgVec3d
 // purpose  :
 //===============================================================================================
-Graphic3d_Vec3d
-ViewerTest_CmdParser::ArgVec3d(const std::string &theOptionName,
-                               Standard_Integer theArgumentIndex) const {
-  return Graphic3d_Vec3d(
-      Draw::Atof(Arg(theOptionName, theArgumentIndex).c_str()),
-      Draw::Atof(Arg(theOptionName, theArgumentIndex + 1).c_str()),
-      Draw::Atof(Arg(theOptionName, theArgumentIndex + 2).c_str()));
+Graphic3d_Vec3d ViewerTest_CmdParser::ArgVec3d (const std::string& theOptionName,
+                                                Standard_Integer   theArgumentIndex) const
+{
+  return Graphic3d_Vec3d (Draw::Atof (Arg (theOptionName, theArgumentIndex).c_str()),
+                          Draw::Atof (Arg (theOptionName, theArgumentIndex + 1).c_str()),
+                          Draw::Atof (Arg (theOptionName, theArgumentIndex + 2).c_str()));
 }
 
 //===============================================================================================
 // function : ArgVec
 // purpose  :
 //===============================================================================================
-gp_Vec ViewerTest_CmdParser::ArgVec(const std::string &theOptionName,
-                                    Standard_Integer theArgumentIndex) const {
-  return gp_Vec(Draw::Atof(Arg(theOptionName, theArgumentIndex).c_str()),
-                Draw::Atof(Arg(theOptionName, theArgumentIndex + 1).c_str()),
-                Draw::Atof(Arg(theOptionName, theArgumentIndex + 2).c_str()));
+gp_Vec ViewerTest_CmdParser::ArgVec (const std::string& theOptionName, Standard_Integer theArgumentIndex) const
+{
+  return gp_Vec (Draw::Atof (Arg (theOptionName, theArgumentIndex).c_str()),
+                 Draw::Atof (Arg (theOptionName, theArgumentIndex + 1).c_str()),
+                 Draw::Atof (Arg (theOptionName, theArgumentIndex + 2).c_str()));
 }
 
 //===============================================================================================
 // function : ArgPnt
 // purpose  :
 //===============================================================================================
-gp_Pnt ViewerTest_CmdParser::ArgPnt(const std::string &theOptionName,
-                                    Standard_Integer theArgumentIndex) const {
-  return gp_Pnt(Draw::Atof(Arg(theOptionName, theArgumentIndex).c_str()),
-                Draw::Atof(Arg(theOptionName, theArgumentIndex + 1).c_str()),
-                Draw::Atof(Arg(theOptionName, theArgumentIndex + 2).c_str()));
+gp_Pnt ViewerTest_CmdParser::ArgPnt (const std::string& theOptionName, Standard_Integer theArgumentIndex) const
+{
+  return gp_Pnt (Draw::Atof (Arg (theOptionName, theArgumentIndex).c_str()),
+                 Draw::Atof (Arg (theOptionName, theArgumentIndex + 1).c_str()),
+                 Draw::Atof (Arg (theOptionName, theArgumentIndex + 2).c_str()));
 }
 
 //===============================================================================================
 // function : ArgDouble
 // purpose  :
 //===============================================================================================
-Standard_Real
-ViewerTest_CmdParser::ArgDouble(const std::string &theOptionName,
-                                Standard_Integer theArgumentIndex) const {
-  return Draw::Atof(Arg(theOptionName, theArgumentIndex).c_str());
+Standard_Real ViewerTest_CmdParser::ArgDouble (const std::string& theOptionName,
+                                               Standard_Integer   theArgumentIndex) const
+{
+  return Draw::Atof (Arg (theOptionName, theArgumentIndex).c_str());
 }
 
 //===============================================================================================
 // function : ArgFloat
 // purpose  :
 //===============================================================================================
-Standard_ShortReal
-ViewerTest_CmdParser::ArgFloat(const std::string &theOptionName,
-                               Standard_Integer theArgumentIndex) const {
-  return static_cast<Standard_ShortReal>(
-      Draw::Atof(Arg(theOptionName, theArgumentIndex).c_str()));
+Standard_ShortReal ViewerTest_CmdParser::ArgFloat (const std::string& theOptionName,
+                                                   Standard_Integer   theArgumentIndex) const
+{
+  return static_cast<Standard_ShortReal> (Draw::Atof (Arg (theOptionName, theArgumentIndex).c_str()));
 }
 
 //===============================================================================================
 // function : ArgInt
 // purpose  :
 //===============================================================================================
-Standard_Integer
-ViewerTest_CmdParser::ArgInt(const std::string &theOptionName,
-                             const Standard_Integer theArgumentIndex) const {
-  return static_cast<Standard_Integer>(
-      Draw::Atoi(Arg(theOptionName, theArgumentIndex).c_str()));
+Standard_Integer ViewerTest_CmdParser::ArgInt (const std::string&     theOptionName,
+                                               const Standard_Integer theArgumentIndex) const
+{
+  return static_cast<Standard_Integer> (Draw::Atoi (Arg (theOptionName, theArgumentIndex).c_str()));
 }
 
 //===============================================================================================
 // function : ArgBool
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::ArgBool(
-    const std::string &theOptionName,
-    const Standard_Integer theArgumentIndex) const {
-  return Draw::Atoi(Arg(theOptionName, theArgumentIndex).c_str()) != 0;
+bool ViewerTest_CmdParser::ArgBool (const std::string& theOptionName, const Standard_Integer theArgumentIndex) const
+{
+  return Draw::Atoi (Arg (theOptionName, theArgumentIndex).c_str()) != 0;
 }
 
 //===============================================================================================
@@ -452,55 +464,54 @@ bool ViewerTest_CmdParser::ArgBool(
 // purpose  :
 //===============================================================================================
 template <typename TheColor>
-bool ViewerTest_CmdParser::ArgColor(const std::string &theOptionName,
-                                    Standard_Integer &theArgumentIndex,
-                                    TheColor &theColor) const {
+bool ViewerTest_CmdParser::ArgColor (const std::string& theOptionName,
+                                     Standard_Integer&  theArgumentIndex,
+                                     TheColor&          theColor) const
+{
   ViewerTest_CommandOptionKey anOptionKey;
-  if (!findOptionKey(theOptionName, anOptionKey)) {
+  if (!findOptionKey (theOptionName, anOptionKey))
+  {
     return false;
   }
-  return ArgColor(anOptionKey, theArgumentIndex, theColor);
+  return ArgColor (anOptionKey, theArgumentIndex, theColor);
 }
 
 //! ViewerTest_CmdParser::ArgColor() explicit template instantiation definitions
-template bool ViewerTest_CmdParser::ArgColor(const std::string &theOptionName,
-                                             Standard_Integer &theArgumentIndex,
-                                             Quantity_Color &theColor) const;
+template bool ViewerTest_CmdParser::ArgColor (const std::string& theOptionName,
+                                              Standard_Integer&  theArgumentIndex,
+                                              Quantity_Color&    theColor) const;
 
-template bool
-ViewerTest_CmdParser::ArgColor(const std::string &theOptionName,
-                               Standard_Integer &theArgumentIndex,
-                               Quantity_ColorRGBA &theColor) const;
+template bool ViewerTest_CmdParser::ArgColor (const std::string&  theOptionName,
+                                              Standard_Integer&   theArgumentIndex,
+                                              Quantity_ColorRGBA& theColor) const;
 
 //===============================================================================================
 // function : ArgColor
 // purpose  :
 //===============================================================================================
 template <typename TheColor>
-bool ViewerTest_CmdParser::ArgColor(
-    const ViewerTest_CommandOptionKey theOptionKey,
-    Standard_Integer &theArgumentIndex, TheColor &theColor) const {
+bool ViewerTest_CmdParser::ArgColor (const ViewerTest_CommandOptionKey theOptionKey,
+                                     Standard_Integer&                 theArgumentIndex,
+                                     TheColor&                         theColor) const
+{
   std::size_t aUsedOptionIndex = 0;
-  if (!findUsedOptionIndex(theOptionKey, aUsedOptionIndex)) {
+  if (!findUsedOptionIndex (theOptionKey, aUsedOptionIndex))
+  {
     return false;
   }
-  const RawStringArguments aRawStringArguments =
-      getRawStringArguments(aUsedOptionIndex);
-  const Standard_Integer aNumberOfArguments =
-      static_cast<Standard_Integer>(aRawStringArguments.size());
-  Standard_ASSERT_RETURN(
-      theArgumentIndex < aNumberOfArguments,
-      "'theArgumentIndex' must be less than the number of command-line "
-      "arguments "
-      "passed with the option which access key is 'theOptionKey'.",
-      false);
-  const Standard_Integer aNumberOfAvailableArguments =
-      aNumberOfArguments - theArgumentIndex;
-  TheColor aColor;
-  const Standard_Integer aNumberOfParsedArguments =
-      Draw::ParseColor(aNumberOfAvailableArguments,
-                       &aRawStringArguments[theArgumentIndex], aColor);
-  if (aNumberOfParsedArguments == 0) {
+  const RawStringArguments aRawStringArguments = getRawStringArguments (aUsedOptionIndex);
+  const Standard_Integer   aNumberOfArguments  = static_cast<Standard_Integer> (aRawStringArguments.size());
+  Standard_ASSERT_RETURN (theArgumentIndex < aNumberOfArguments,
+                          "'theArgumentIndex' must be less than the number of command-line arguments "
+                          "passed with the option which access key is 'theOptionKey'.",
+                          false);
+  const Standard_Integer aNumberOfAvailableArguments = aNumberOfArguments - theArgumentIndex;
+  TheColor               aColor;
+  const Standard_Integer aNumberOfParsedArguments = Draw::ParseColor (aNumberOfAvailableArguments,
+                                                                      &aRawStringArguments[theArgumentIndex],
+                                                                      aColor);
+  if (aNumberOfParsedArguments == 0)
+  {
     return false;
   }
   theArgumentIndex += aNumberOfParsedArguments;
@@ -509,27 +520,25 @@ bool ViewerTest_CmdParser::ArgColor(
 }
 
 //! ViewerTest_CmdParser::ArgColor() explicit template instantiation definitions
-template bool
-ViewerTest_CmdParser::ArgColor(ViewerTest_CommandOptionKey theOptionKey,
-                               Standard_Integer &theArgumentIndex,
-                               Quantity_Color &theColor) const;
+template bool ViewerTest_CmdParser::ArgColor (ViewerTest_CommandOptionKey theOptionKey,
+                                              Standard_Integer&           theArgumentIndex,
+                                              Quantity_Color&             theColor) const;
 
-template bool
-ViewerTest_CmdParser::ArgColor(ViewerTest_CommandOptionKey theOptionKey,
-                               Standard_Integer &theArgumentIndex,
-                               Quantity_ColorRGBA &theColor) const;
+template bool ViewerTest_CmdParser::ArgColor (ViewerTest_CommandOptionKey theOptionKey,
+                                              Standard_Integer&           theArgumentIndex,
+                                              Quantity_ColorRGBA&         theColor) const;
 
 //===============================================================================================
 // function : findUsedOptionKey
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::findOptionKey(
-    const std::string &theOptionName,
-    ViewerTest_CommandOptionKey &theOptionKey) const {
-  const std::string anOptionNameInLowercase = toLowerCase(theOptionName);
-  const OptionMap::const_iterator aMapIter =
-      myOptionMap.find(anOptionNameInLowercase);
-  if (aMapIter == myOptionMap.end()) {
+bool ViewerTest_CmdParser::findOptionKey (const std::string&           theOptionName,
+                                          ViewerTest_CommandOptionKey& theOptionKey) const
+{
+  const std::string               anOptionNameInLowercase = toLowerCase (theOptionName);
+  const OptionMap::const_iterator aMapIter                = myOptionMap.find (anOptionNameInLowercase);
+  if (aMapIter == myOptionMap.end())
+  {
     return false;
   }
   theOptionKey = aMapIter->second;
@@ -540,12 +549,12 @@ bool ViewerTest_CmdParser::findOptionKey(
 // function : findUsedOptionKey
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::findUsedOptionIndex(
-    const ViewerTest_CommandOptionKey theOptionKey,
-    std::size_t &theUsedOptionIndex) const {
-  const UsedOptionMap::const_iterator aUsedOptionIterator =
-      myUsedOptionMap.find(theOptionKey);
-  if (aUsedOptionIterator == myUsedOptionMap.end()) {
+bool ViewerTest_CmdParser::findUsedOptionIndex (const ViewerTest_CommandOptionKey theOptionKey,
+                                                std::size_t&                      theUsedOptionIndex) const
+{
+  const UsedOptionMap::const_iterator aUsedOptionIterator = myUsedOptionMap.find (theOptionKey);
+  if (aUsedOptionIterator == myUsedOptionMap.end())
+  {
     return false;
   }
   theUsedOptionIndex = aUsedOptionIterator->second;
@@ -556,14 +565,16 @@ bool ViewerTest_CmdParser::findUsedOptionIndex(
 // function : findUsedOptionIndex
 // purpose  :
 //===============================================================================================
-bool ViewerTest_CmdParser::findUsedOptionIndex(
-    const std::string &theOptionName, std::size_t &theUsedOptionIndex) const {
+bool ViewerTest_CmdParser::findUsedOptionIndex (const std::string& theOptionName, std::size_t& theUsedOptionIndex) const
+{
   ViewerTest_CommandOptionKey anOptionKey = THE_UNNAMED_COMMAND_OPTION_KEY;
-  if (!findOptionKey(theOptionName, anOptionKey)) {
+  if (!findOptionKey (theOptionName, anOptionKey))
+  {
     return false;
   }
   std::size_t aUsedOptionIndex = 0;
-  if (!findUsedOptionIndex(anOptionKey, aUsedOptionIndex)) {
+  if (!findUsedOptionIndex (anOptionKey, aUsedOptionIndex))
+  {
     return false;
   }
   theUsedOptionIndex = aUsedOptionIndex;
@@ -574,10 +585,10 @@ bool ViewerTest_CmdParser::findUsedOptionIndex(
 // function : addUsedOption
 // purpose  :
 //===============================================================================================
-std::size_t ViewerTest_CmdParser::addUsedOption(
-    const ViewerTest_CommandOptionKey theNewUsedOptionKey) {
+std::size_t ViewerTest_CmdParser::addUsedOption (const ViewerTest_CommandOptionKey theNewUsedOptionKey)
+{
   const std::size_t aNewUsedOptionIndex = myOptionArgumentStorage.size();
-  myOptionArgumentStorage.push_back(OptionArguments());
+  myOptionArgumentStorage.push_back (OptionArguments());
   myUsedOptionMap[theNewUsedOptionKey] = aNewUsedOptionIndex;
   return aNewUsedOptionIndex;
 }
@@ -586,14 +597,13 @@ std::size_t ViewerTest_CmdParser::addUsedOption(
 // function : getRawStringArguments
 // purpose  :
 //===============================================================================================
-ViewerTest_CmdParser::RawStringArguments
-ViewerTest_CmdParser::getRawStringArguments(
-    const std::size_t theUsedOptionIndex) const {
-  Standard_ASSERT_RETURN(theUsedOptionIndex < myOptionArgumentStorage.size(),
-                         "'theUsedOptionIndex' must be less than the size of "
-                         "'myOptionArgumentStorage'.",
-                         RawStringArguments());
-  const OptionArguments &anOptionArguments =
-      myOptionArgumentStorage[theUsedOptionIndex];
-  return convertToRawStringList(anOptionArguments);
+ViewerTest_CmdParser::RawStringArguments ViewerTest_CmdParser::getRawStringArguments (
+  const std::size_t theUsedOptionIndex) const
+{
+  Standard_ASSERT_RETURN (
+    theUsedOptionIndex < myOptionArgumentStorage.size(),
+    "'theUsedOptionIndex' must be less than the size of 'myOptionArgumentStorage'.",
+    RawStringArguments());
+  const OptionArguments& anOptionArguments = myOptionArgumentStorage[theUsedOptionIndex];
+  return convertToRawStringList (anOptionArguments);
 }

src/XCAFDoc/XCAFDoc_ShapeTool.cxx

@@ -48,6 +48,7 @@
 #include <XCAFDoc_GraphNode.hxx>
 #include <XCAFDoc_Location.hxx>
 #include <XCAFDoc_ShapeMapTool.hxx>
+#include <TopLoc_Datum3D.hxx>
 
 IMPLEMENT_DERIVED_ATTRIBUTE_WITH_TYPE(XCAFDoc_ShapeTool,TDataStd_GenericEmpty,"xcaf","ShapeTool")
 
@@ -1602,6 +1603,33 @@ Standard_Boolean XCAFDoc_ShapeTool::RemoveSHUO (const TDF_Label& L) const
 //purpose  : auxiliary
 //=======================================================================
 
+static Standard_Boolean IsEqual (const TopLoc_Location& theLoc1, const TopLoc_Location& theLoc2)
+{
+  if (theLoc1.IsEqual (theLoc2)) {return Standard_True; }
+  if (theLoc1.IsIdentity() || theLoc2.IsIdentity()) {return Standard_False; }
+  const Handle(TopLoc_Datum3D)& aDatum1 = theLoc1.FirstDatum();
+  const Handle(TopLoc_Datum3D)& aDatum2 = theLoc2.FirstDatum();
+  if (aDatum1 && aDatum2)
+  {
+    NCollection_Mat4<double> aMat41;
+    NCollection_Mat4<double> aMat42;
+    theLoc1.FirstDatum()->Transformation().GetMat4(aMat41);
+    theLoc2.FirstDatum()->Transformation().GetMat4(aMat42);
+    if ( !aMat41.IsEqual (aMat42)) {return Standard_False; }
+  }
+  else if (aDatum1 || aDatum2) {return Standard_False; }
+  if (theLoc1.FirstPower()  != theLoc2.FirstPower()  ) {return Standard_False; }
+  else { return IsEqual (theLoc1.NextLocation(), theLoc2.NextLocation());}
+}
+
+static Standard_Boolean IsSame (const TopoDS_Shape& theShape1, const TopoDS_Shape& theShape2)
+{
+  
+  return theShape1.TShape() == theShape2.TShape()
+        && theShape1.Orientation() == theShape2.Orientation()
+        && IsEqual (theShape1.Location(), theShape2.Location());
+}
+
 static Standard_Boolean checkForShape (const TopoDS_Shape& theShape,
                                        const TopoDS_Shape& theCurSh,
                                        const TDF_Label& theUserL,
@@ -1616,7 +1644,7 @@ static Standard_Boolean checkForShape (const TopoDS_Shape& theShape,
   aCompLoc = aCompLoc.Multiplied( theCurSh.Location() );
   aSupLoc = aSupLoc.Multiplied( aCompLoc );
   aCopySh.Location( aSupLoc, Standard_False );
-  if ( aCopySh.IsSame( theShape ) ) {
+  if ( IsSame ( theShape, aCopySh ) ) {
     theLabels.Prepend( theUserL );
     return Standard_True;
   }

tests/boolean/bopfuse_simple/ZP6

@@ -3,6 +3,8 @@
 #
 #Create 3 torus
 
+puts "TODO CR33225 Linux: Error : The area of result shape is 138625, expected 197700"
+
 ptorus a0 100 20
 tcopy a0 a1
 tcopy a0 a2

tests/bugs/caf/bug114

@@ -1,24 +0,0 @@
-puts "==========="
-puts "OCC114"
-puts "==========="
-
-# Max number of iterations for computing memory leackage
-set i_max 10
-puts "Amount of iterations is $i_max"
-
-NewDocument D BinOcaf
-UndoLimit D 10
-
-restore [locate_data_file OCC294.brep] s
-
-set listmem {}
-for {set i 1} {${i} <= ${i_max}} {incr i} {
-
-    OpenCommand D
-    SetShape D 0:1 s 
-    AbortCommand D
-
-    # check memory usage (with tolerance equal to half page size)
-    lappend listmem [meminfo h]
-    checktrend $listmem 50 50 "Memory leak detected"
-}

tests/bugs/caf/bug26293_2

@@ -1,17 +0,0 @@
-puts "==========="
-puts "OCC26293"
-puts "==========="
-puts ""
-#################################
-# Error opening the document
-#################################
-
-Open [locate_data_file bug26293_all_geom.sgd] D
-vinit
-for {set i 1} {$i < 1065} {incr i} {
-  if { ![catch {GetShape D 0:1:$i:1:1:2 res$i}] } {
-    vdisplay res$i
-  }
-}
-vfit
-checkview -screenshot -3d -path ${imagedir}/${test_image}.png

tests/bugs/fclasses/bug24831

@@ -1,3 +1,5 @@
+puts "TODO ?CR33225 Windows: Failed class "
+
 pload QAcommands
 
 QANTestStlIterators

tests/bugs/fclasses/bug7287_1

@@ -1,3 +1,4 @@
+puts "TODO ?СК33225 Linux: Checking trend failed "
 puts "TODO ?OCC7287 Linux: Tcl Exception: Memory leak detected"
 puts "TODO ?OCC7287 Linux: TEST INCOMPLETE"
 puts "TODO ?OCC7287 MacOS: Tcl Exception: Memory leak detected"

tests/bugs/fclasses/bug7287_5

@@ -1,3 +1,4 @@
+puts "TODO ?CR332257287 Linux: Checking trend failed: mean delta per step = 9432.0, sigma = 4220.013270121316, expected delta = 0"
 puts "TODO ?OCC7287 Linux: Tcl Exception: Memory leak detected"
 puts "TODO ?OCC7287 Linux: TEST INCOMPLETE"
 puts "TODO ?OCC7287 MacOS: Tcl Exception: Memory leak detected"

tests/bugs/fclasses/bug7287_6

@@ -1,3 +1,4 @@
+puts "TODO ?CR33225 Linux: Checking trend failed: mean delta per step = 7408.0, sigma = 2737.917456754312, expected delta = 0"
 puts "TODO ?OCC7287 Linux: Tcl Exception: Memory leak detected"
 puts "TODO ?OCC7287 Linux: TEST INCOMPLETE"
 puts "TODO ?OCC7287 MacOS: Tcl Exception: Memory leak detected"

tests/bugs/heal/bug33171_1

@@ -0,0 +1,71 @@
+puts "========================"
+puts " 	0033171: Modeling Algorithms - Invalid result of faces unification"
+puts "========================"
+puts ""
+
+# make outer prism
+polyline p 0 0 0  10 0 0  10 10 0  0 10 0  0 0 0
+mkplane f p
+prism s f 0 0 5
+
+# make section shells
+polyline p1 3 10 0  3 7 0  6 7 0  6 3 0  10 3 0
+polyline p2 6 7 0  10 7 0
+polyline p3 8 7 0  8 10 0
+polyline p4 0 5 0  10 5 0
+
+prism sh1 p1 0 0 5
+prism sh2 p2 0 0 5
+prism sh3 p3 0 0 5
+prism sh4 p4 0 0 5
+
+# split the prism
+bclearobjects
+bcleartools
+baddobjects s
+baddtools sh1 sh2 sh3 sh4
+bfillds
+bsplit r
+
+checkshape r
+if {![regexp "This shape seems to be OK" [bopcheck r]]} {
+    puts "Error: invalid shape after split"
+}
+
+# try to unify faces in the result compound
+unifysamedom ru1 r
+unifysamedom ru2 r +i
+
+checkshape ru1
+checkshape ru2
+
+checknbshapes ru1 -ref [nbshapes r -t] -t
+checknbshapes ru2 -ref [nbshapes r -t] -t
+
+if {![regexp "This shape seems to be OK" [bopcheck ru1]]} {
+    puts "Error: invalid shape after faces unification"
+}
+if {![regexp "This shape seems to be OK" [bopcheck ru2]]} {
+    puts "Error: invalid shape after faces unification"
+}
+
+# make compound of shells
+eval compound [explode r] shs
+
+unifysamedom shsu1 r
+unifysamedom shsu2 r +i
+
+checkshape shsu1
+checkshape shsu2
+
+checknbshapes shsu1 -ref [nbshapes shs -t] -t
+checknbshapes shsu2 -ref [nbshapes shs -t] -t
+
+if {![regexp "This shape seems to be OK" [bopcheck shsu1]]} {
+    puts "Error: invalid shape after faces unification"
+}
+if {![regexp "This shape seems to be OK" [bopcheck shsu2]]} {
+    puts "Error: invalid shape after faces unification"
+}
+
+checkview -display ru2 -2d -path ${imagedir}/${test_image}.png

tests/bugs/heal/bug33171_2

@@ -0,0 +1,57 @@
+puts "========================"
+puts " 	0033171: Modeling Algorithms - Invalid result of faces unification"
+puts "========================"
+puts ""
+
+# make two solids
+box b1 10 10 5
+box b2 10 0 0 5 5 5
+# make shared
+bclearobjects
+bcleartools
+baddobjects b1 b2
+bfillds
+bbuild r
+
+checkshape r
+if {![regexp "This shape seems to be OK" [bopcheck r]]} {
+    puts "Error: invalid shape after fuse"
+}
+
+# try to unify faces in the result compound
+unifysamedom ru1 r
+unifysamedom ru2 r +i
+
+checkshape ru1
+checkshape ru2
+
+checknbshapes ru1 -ref [nbshapes r -t] -t
+checknbshapes ru2 -ref [nbshapes r -t] -t
+
+if {![regexp "This shape seems to be OK" [bopcheck ru1]]} {
+    puts "Error: invalid shape after faces unification"
+}
+if {![regexp "This shape seems to be OK" [bopcheck ru2]]} {
+    puts "Error: invalid shape after faces unification"
+}
+
+# make compound of shells
+eval compound [explode r] shs
+
+unifysamedom shsu1 r
+unifysamedom shsu2 r +i
+
+checkshape shsu1
+checkshape shsu2
+
+checknbshapes shsu1 -ref [nbshapes shs -t] -t
+checknbshapes shsu2 -ref [nbshapes shs -t] -t
+
+if {![regexp "This shape seems to be OK" [bopcheck shsu1]]} {
+    puts "Error: invalid shape after faces unification"
+}
+if {![regexp "This shape seems to be OK" [bopcheck shsu2]]} {
+    puts "Error: invalid shape after faces unification"
+}
+
+checkview -display ru2 -2d -path ${imagedir}/${test_image}.png

tests/bugs/heal/bug33193

@@ -0,0 +1,19 @@
+puts "========================================="
+puts "0033193: Modeling Algorithms - Regression: UnifySameDomain raises SIGSEGV"
+puts "========================================="
+puts ""
+
+restore [locate_data_file bug33193.brep] a
+
+unifysamedom result a
+
+checkshape result
+
+checknbshapes result -t -solid 1 -shell 1 -face 152 -wire 202 -edge 411 -vertex 273
+
+set tolres [checkmaxtol result]
+
+if { ${tolres} > 1.26e-7} {
+   puts "Error: bad tolerance of result"
+}
+

tests/bugs/mesh/bug32424

@@ -1,18 +0,0 @@
-puts "======="
-puts "0032424: Mesh - Slow triangulation of a simple shape."
-puts "======="
-puts ""
-cpulimit 3
-
-restore [locate_data_file bug32424.brep] result
-
-incmesh result 0.17 -a 20
-
-checktrinfo result -tri 2360 -nod 1302
-
-vinit
-vdefaults -autoTriang 0
-vsetdispmode 1
-vdisplay result
-vfit
-checkview -screenshot -3d -path ${imagedir}/${test_image}.png

tests/bugs/modalg_1/bug19071

@@ -1,7 +1,12 @@
+puts "TODO CR33225 Linux: Error : The command is not valid. The area is 0."
+puts "TODO CR33225 Linux: Error : The area of result shape is 0, expected 177462"
+puts "TODO CR33225 Linux: is WRONG because number of "
+
 puts "============"
 puts "OCC19071"
 puts "============"
 puts ""
+
 #######################################################################
 # The MakeFuse or the MakePartition function crash together on 2 torus
 #######################################################################

tests/bugs/modalg_5/bug25199

@@ -1,4 +1,5 @@
 puts "TODO CR30351 Windows: Faulty OCC25199:  Bad tolerance edge generated by blend algorithm"
+puts "TODO CR33225 Linux: Faulty OCC25199:  Bad tolerance edge generated by blend algorithm"
 
 puts "============"
 puts "OCC25199"

tests/bugs/modalg_6/bug26616

@@ -1,20 +0,0 @@
-puts "========"
-puts "OCC26616"
-puts "========"
-puts ""
-############################################
-# Memory leak in IntTools_Context::Hatcher
-############################################
-
-restore [locate_data_file OCC26635_t0.brep] t0
-restore [locate_data_file OCC26635_t1.brep] t1
-
-bfuse res t0 t1
-
-set listmem {}
-for {set i 1} {$i < 10} {incr i} {
-    bfuse res t0 t1
-
-    lappend listmem [meminfo h]
-    checktrend $listmem 0 64 "Memory leak detected"
-}

tests/bugs/modalg_6/bug27884

@@ -3,6 +3,8 @@ puts "OCC27884: Modeling Algorithms - Possible improvement for 2d classifier"
 puts "================================================================="
 puts ""
 
+puts "TODO ?CR33225 Windows: Error: algorithm slowed down"
+
 pload ALL
 pload QAcommands
 

tests/bugs/modalg_7/bug29293_1

@@ -1,3 +1,5 @@
+puts "TODO ?CR33225 Windows: extra characters after close-quote "
+
 puts "========"
 puts "OCC29293"
 puts "========"

tests/bugs/modalg_7/bug29843_1

@@ -1,48 +0,0 @@
-puts "========"
-puts "0029843: Modeling Algorithms - Boolean FUSE produces incorrect result"
-puts "========"
-puts ""
-
-restore [locate_data_file bug29843.brep] s
-
-explode s
-bclearobjects
-bcleartools
-baddobjects s_1
-baddtools s_2
-bfillds
-
-bbop r_0 0
-bbop r_1 1
-bbop r_2 2
-bbop r_3 3
-bbop r_4 4
-bbuild r_5
-
-foreach i { 0 1 2 3 4 5} {
-  checkshape r_$i
-  if {![regexp "OK" [bopcheck r_$i]]} {
-    puts "Error: r_$i is self-intersecting shape"
-  }
-}
-
-checkprops r_0 -s 9.84429 -v 0.639311
-checknbshapes r_0 -wire 7 -face 5 -shell 1 -solid 1 -t
-
-checkprops r_1 -s 2121.39 -v 612.41
-checknbshapes r_1 -wire 38 -face 32 -shell 2 -solid 1 -t
-
-checkprops r_2 -s 2113.85 -v 611.569
-checknbshapes r_2 -wire 32 -face 26 -shell 2 -solid 1 -t
-
-checkprops r_3 -s 15.9893 -v 0.215264
-checknbshapes r_3 -wire 11 -face 9 -shell 2 -solid 2 -t
-
-checkprops r_4 -l 24.9725
-checksection r_4 -r 2
-
-checkprops r_5 -s 2139.68 -v 612.402
-checknbshapes r_5 -wire 44 -face 36 -shell 5 -solid 4 -t
-
-checkview -display r_0 -2d -path ${imagedir}/${test_image}.png
-

tests/bugs/modalg_7/bug30054

@@ -2,7 +2,7 @@ puts "================================================="
 puts "0030054: BRepOffset_MakeOffset fails to build joints in intersection mode"
 puts "================================================="
 puts ""
-
+puts "TODO OCC33166 ALL: Faulty shapes"
 restore [locate_data_file bug30054.brep] a
 
 thickshell result a 1 i

tests/bugs/modalg_8/bug26441

@@ -0,0 +1,40 @@
+puts "============"
+puts "0026441: Modeling Algorithms - BRepOffset_MakeOffset affects original shape"
+puts "============"
+puts ""
+
+pload QAcommands
+restore [locate_data_file bug26440_plate.brep] sh
+
+tcopy sh sh_ref
+thickshell result sh 160
+
+checkprops result -s 2.40831e+07 
+checkshape result
+
+set nbshapes_expected "
+Number of shapes in shape
+ VERTEX    : 196
+ EDGE      : 308
+ WIRE      : 110
+ FACE      : 110
+ SHELL     : 1
+ SOLID     : 1
+ COMPSOLID : 0
+ COMPOUND  : 0
+ SHAPE     : 726
+"
+checknbshapes result -ref ${nbshapes_expected} -t -m "solid construction"
+if { [info exist BadEdges] } {
+  unset BadEdges
+}
+if { [info exist BadVerts] } {
+  unset BadVerts
+}
+
+OCC26441 sh sh_ref 1.e-7 1
+
+if { [isdraw BadEdges] || [isdraw BadVerts]} {
+  puts "Error: tolerances of some subshapes of initial shape are changed"
+}
+

tests/bugs/modalg_8/bug32857

@@ -0,0 +1,72 @@
+puts "================"
+puts "0032857: Problem when finding the intersection between a new face made after a draft and the inner face of body"
+puts "================"
+puts ""
+# Script reproducing the problematic draft case in FreeCAD issue #2497
+#Category: Modeling
+#Title: OCCT Tutorial pocketed ring
+
+pload MODELING VISUALIZATION
+
+# Set basic dimensions. Problems appear when inner_rad < pocket_center.
+dset height 10
+dset inner_rad 39
+dset outer_rad 50
+dset pocket_center 40
+dset pocket_rad 20
+dset pocket_depth 5
+
+# Construct base profile (the "my_ring")
+puts "Constructing my_ring..."
+
+circle c_inner 0 0 0 0 0 1 inner_rad
+circle c_outer 0 0 0 0 0 1 outer_rad
+mkedge e_inner c_inner
+mkedge e_outer c_outer
+wire w_inner e_inner
+wire w_outer e_outer
+
+plane p0
+mkface my_ring_inner_base p0 w_inner
+mkface my_ring_outer_base p0 w_outer
+
+prism my_ring_inner my_ring_inner_base 0 0 height
+prism my_ring_outer my_ring_outer_base 0 0 height
+
+bcut my_ring my_ring_outer my_ring_inner
+
+# Make the pocket
+puts "Constructing pocket..."
+
+circle pocket_base pocket_center 0 0 0 0 1 pocket_rad
+mkedge pocket_base pocket_base
+wire pocket_base pocket_base
+
+mkface pocket_base p0 pocket_base
+
+prism my_pocket pocket_base 0 0 pocket_depth
+
+# Make the cut
+puts "Making the cut"
+
+bcut slotted_ring my_ring my_pocket
+
+explode slotted_ring F
+
+# Make the draft
+puts "Drafting the face"
+
+# Found face by trial and error: slotted_ring_3
+# Perform the draft
+depouille slotted_ring_with_draft slotted_ring 0 0 -1 slotted_ring_3 44 0 1 0 0 0 1
+
+#checking result
+checkshape slotted_ring_with_draft
+checknbshapes slotted_ring_with_draft -shape 48 -vertex 12 -edge 18 -face 7 -wire 8
+checkprops slotted_ring_with_draft -s 11466.5 -v 28662.9
+
+puts "Showing result..."
+
+# Display result
+checkview -display slotted_ring_with_draft -2d -path ${imagedir}/${test_image}.png
+

tests/bugs/modalg_8/bug33173

@@ -0,0 +1,15 @@
+puts "========"
+puts "0033173: Modeling Algorithms - Regression in BRepExtrema_DistShapeShape causing Standard_OutOfRange"
+puts "========"
+puts ""
+
+set MinDistExpected 7.049107166484117e-07
+restore [locate_data_file bug33173.brep] s
+explode s
+distmini dm s_1 s_2
+if {[isdraw dm]} {
+  checkreal MinDist $MinDistExpected [dval dm_val] 1.e-7 .01
+} else {
+  puts "Error: distmini failed"
+}
+

tests/bugs/modalg_8/bug33179

@@ -0,0 +1,9 @@
+puts "================================"
+puts "0033179: Modeling Algorithms - Crash in in ShapeFix_Shape with the attached object, when healing for fixing SameParameterFlag"
+puts "================================"
+
+restore [locate_data_file bug33179.brep] s
+
+fsameparameter s
+checkshape s
+

tests/bugs/modalg_8/bug33187

@@ -0,0 +1,9 @@
+puts "================================"
+puts "0033187: Modeling Algorithms - Crash in postprocessing of imported shape"
+puts "================================"
+
+restore [locate_data_file bug33187.brep] s
+
+if [catch { fixshape r s } catch_result] {
+  puts "${BugNumber}: Faulty"
+}

tests/bugs/moddata_3/bug162

@@ -2,6 +2,9 @@ puts "========"
 puts "OCC162"
 puts "========"
 
+puts "TODO ?CR33225 Linux: Checking trend failed "
+puts "TODO ?CR33225 Linux: Tcl Exception: Memory leak detected"
+
 pload QAcommands
 pload XDE
 

tests/bugs/step/bug27122

@@ -0,0 +1,27 @@
+puts "================"
+puts "OCC27122"
+puts "================"
+puts ""
+#####################################################################
+# STEP import regression: invalid shapes are produced during model translation due to huge face tolerance
+#####################################################################
+
+pload XDE
+
+# Empty resource file name to take params from InterfaceStatic
+param "read.step.resource.name" "\"\""
+# Add FixFaceSize operator
+param "FromSTEP.exec.op" FixShape,FixFaceSize
+# Set a tolerance exceeding the size of the problem face to FixFaceSize operator
+param "FromSTEP.FixFaceSize.Tolerance" 0.0508
+
+stepread [locate_data_file bug27122_280696.stp] a *
+
+# restore old params
+param "read.step.resource.name" STEP
+param "FromSTEP.exec.op" FixShape
+param "FromSTEP.FixFaceSize.Tolerance" 1.e-7
+
+checknbshapes a_1 -t -face 10
+
+checkview -display a_1 -3d -path ${imagedir}/${test_image}.png

tests/bugs/step/bug32977

@@ -0,0 +1,58 @@
+puts "===================================="
+puts "0032977: OCC V7.5, V7.6 cannot read STEP color correctly for the root label, but v6.8 can"
+puts "===================================="
+puts ""
+
+pload ALL
+
+# Read files
+# Check colors number
+
+ReadStep D1 [locate_data_file bug32977_1.stp]
+set info1 [XStat D1]
+regexp {Number +of +colors += +([-0-9.+eE]+)} $info1 full nbcolor
+regexp {Number +of +colors += +[-0-9.+eE]+\n([^\n]*)} $info1 full colors
+if {[string compare ${colors} "RED BLACK GRAY74 GRAY26 "] != 0} {
+    puts "Error: not expected colors ${colors}"
+  }
+if {$nbcolor != 4} {
+    puts "Error: not expected number of colors"
+  } 
+  
+ReadStep D2 [locate_data_file bug32977_2.step]
+set info2 [XStat D2]
+regexp {Number +of +colors += +([-0-9.+eE]+)} $info2 full nbcolor
+regexp {Number +of +colors += +[-0-9.+eE]+\n([^\n]*)} $info2 full colors
+if {[string compare ${colors} "LIGHTSTEELBLUE2 WHITE VIOLETRED3 GRAY25 "] != 0} {
+    puts "Error: not expected colors ${colors}"
+  }
+if {$nbcolor != 4} {
+    puts "Error: not expected number of colors"
+  } 
+  
+ReadStep D3 [locate_data_file trj10_pm8-id-214.stp]
+set info3 [XStat D3]
+regexp {Number +of +colors += +([-0-9.+eE]+)} $info3 full nbcolor
+regexp {Number +of +colors += +[-0-9.+eE]+\n([^\n]*)} $info3 full colors
+if {[string compare ${colors} "MAGENTA RED ORANGERED ORANGE DEEPSKYBLUE2 GREEN "] != 0} {
+    puts "Error: not expected colors ${colors}"
+  }
+if {$nbcolor != 6} {
+    puts "Error: not expected number of colors"
+  } 
+
+vinit View1
+XDisplay D1 -dispmode 1
+vfit
+checkview -screenshot -3d -path ${imagedir}/${test_image}1.png
+
+vclear
+XDisplay D2 -dispmode 1
+vfit
+checkview -screenshot -3d -path ${imagedir}/${test_image}2.png
+
+vclear
+XDisplay D3 -dispmode 1
+vfit
+checkview -screenshot -3d -path ${imagedir}/${test_image}3.png
+

tests/bugs/xde/bug22898

@@ -1,4 +1,5 @@
 puts "TODO OCC24156 MacOS: Error: unsupported locale specification"
+puts "TODO CR33225 Linux: Error: unsupported locale specification"
 
 # Test for issue #22898 and other functionality that can be affected by locale.
 # Just run multiple conversions of the shape to and from different formats and 

tests/cr/bugs/bug33170

@@ -0,0 +1,30 @@
+puts "============"
+puts "0033170: Modeling Algorithms - Checking for canonical geometry: plane detection problems" 
+puts "============"  
+puts ""               
+
+set ExpectGap 0.0051495320504590563
+brestore [locate_data_file bug33170.brep] f
+set log1 [getanasurf asurf1 f pln  0.006]
+regexp {Gap = +([-0-9.+eE]+)} $log1 full gap1
+if {[isdraw asurf1]} {
+  set log [dump asurf1]
+  if { [regexp {Plane} $log ] != 1 } {
+     puts "Error: surface is not a plane"
+  }
+} else {
+  puts "Error: required surface is not got"
+}
+checkreal FoundGap1 $gap1 $ExpectGap 1.0e-9 0.0
+# 
+set log2 [getanasurf asurf2 f pln  1.]
+regexp {Gap = +([-0-9.+eE]+)} $log1 full gap2
+if {[isdraw asurf2]} {
+  set log [dump asurf2]
+  if { [regexp {Plane} $log ] != 1 } {
+     puts "Error: surface is not a plane"
+  }
+} else {
+  puts "Error: required surface is not got"
+}
+checkreal FoundGap2 $gap2 $ExpectGap 1.0e-9 0.0

tests/cr/grids.list

@@ -1,2 +1,3 @@
 001 base
 002 approx
+003 bugs

tests/de/step_2/K4

@@ -8,10 +8,10 @@ CHECKSHAPE  : Wires    = 0  ( 0 )  Faces    = 0  ( 0 )  Shells   = 0  ( 0 )   So
 NBSHAPES    : Solid    = 3  ( 3 )  Shell    = 3  ( 3 )  Face     = 492  ( 492 ) 
 STATSHAPE   : Solid    = 57  ( 57 )  Shell    = 57  ( 57 )  Face     = 1894  ( 1894 )   FreeWire = 0  ( 0 ) 
 TOLERANCE   : MaxTol   =         1e-007  (         1e-007 )  AvgTol   =          1e-007  (          1e-007 )
-LABELS      : N0Labels = 5  ( 5 )  N1Labels = 31  ( 31 )  N2Labels = 0  ( 0 )   TotalLabels = 36  ( 36 )   NameLabels = 36  ( 36 )   ColorLabels = 3  ( 3 )   LayerLabels = 0  ( 0 )
+LABELS      : N0Labels = 5  ( 5 )  N1Labels = 32  ( 32 )  N2Labels = 0  ( 0 )   TotalLabels = 37  ( 37 )   NameLabels = 36  ( 36 )   ColorLabels = 4  ( 4 )   LayerLabels = 0  ( 0 )
 PROPS       : Centroid = 0  ( 0 )  Volume   = 0  ( 0 )  Area     = 0  ( 0 )
-NCOLORS     : NColors  = 3  ( 3 )
-COLORS      : Colors   = CYAN GREEN YELLOW  ( CYAN GREEN YELLOW )
+NCOLORS     : NColors  = 4  ( 4 )
+COLORS      : Colors   = CYAN GREEN RED YELLOW  ( CYAN GREEN RED YELLOW )
 NLAYERS     : NLayers  = 0  ( 0 )
 LAYERS      : Layers   =   (  )
 

tests/de/step_2/K5

@@ -8,10 +8,10 @@ CHECKSHAPE  : Wires    = 0  ( 0 )  Faces    = 0  ( 0 )  Shells   = 0  ( 0 )   So
 NBSHAPES    : Solid    = 3  ( 3 )  Shell    = 3  ( 3 )  Face     = 492  ( 492 ) 
 STATSHAPE   : Solid    = 57  ( 57 )  Shell    = 57  ( 57 )  Face     = 1894  ( 1894 )   FreeWire = 0  ( 0 ) 
 TOLERANCE   : MaxTol   =         1e-007  (         1e-007 )  AvgTol   =          1e-007  (          1e-007 )
-LABELS      : N0Labels = 5  ( 5 )  N1Labels = 31  ( 31 )  N2Labels = 0  ( 0 )   TotalLabels = 36  ( 36 )   NameLabels = 36  ( 36 )   ColorLabels = 3  ( 3 )   LayerLabels = 0  ( 0 )
+LABELS      : N0Labels = 5  ( 5 )  N1Labels = 32  ( 32 )  N2Labels = 0  ( 0 )   TotalLabels = 37  ( 37 )   NameLabels = 36  ( 36 )   ColorLabels = 4  ( 4 )   LayerLabels = 0  ( 0 )
 PROPS       : Centroid = 0  ( 0 )  Volume   = 0  ( 0 )  Area     = 0  ( 0 )
-NCOLORS     : NColors  = 3  ( 3 )
-COLORS      : Colors   = CYAN GREEN YELLOW  ( CYAN GREEN YELLOW )
+NCOLORS     : NColors  = 4  ( 4 )
+COLORS      : Colors   = CYAN GREEN RED YELLOW  ( CYAN GREEN RED YELLOW )
 NLAYERS     : NLayers  = 0  ( 0 )
 LAYERS      : Layers   =   (  )
 

tests/de_mesh/gltf_write/010

@@ -1,16 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-Close D0 -silent
-ReadGltf D0 [locate_data_file bug32867_010.glb]
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-set aGltfFile2 "${imagedir}/${casename}_tmp2.glb"
-
-WriteGltf D0 "$aGltfFile1" -draco on -mergefaces
-WriteGltf D0 "$aGltfFile2" -draco on
-
-ReadGltf D1 "$aGltfFile1"
-ReadGltf D "$aGltfFile2"

tests/de_mesh/gltf_write/Diamond

@@ -1,16 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-Close D0 -silent
-ReadGltf D0 [locate_data_file bug32867_Diamond.glb]
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-set aGltfFile2 "${imagedir}/${casename}_tmp2.glb"
-
-WriteGltf D0 "$aGltfFile1" -draco on
-WriteGltf D0 "$aGltfFile2" -draco on -mergefaces
-
-ReadGltf D1 "$aGltfFile1"
-ReadGltf D "$aGltfFile2"

tests/de_mesh/gltf_write/as1draco

@@ -1,18 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-Close D0 -silent
-ReadStep D0 [locate_data_file as1-oc-214-mat.stp]
-XGetOneShape ss D0
-incmesh ss 1.0
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-set aGltfFile2 "${imagedir}/${casename}_tmp2.glb"
-
-WriteGltf D0 "$aGltfFile1" -draco on
-WriteGltf D0 "$aGltfFile2" -draco on -mergefaces
-
-ReadGltf D1 "$aGltfFile1"
-ReadGltf D "$aGltfFile2"

tests/de_mesh/gltf_write/bearing

@@ -1,16 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-restore [locate_data_file bearing.brep] b
-incmesh b 0.1
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-set aGltfFile2 "${imagedir}/${casename}_tmp2.glb"
-
-WriteGltf b "$aGltfFile1" -draco on
-WriteGltf b "$aGltfFile2" -draco on -mergefaces
-
-ReadGltf D0 "$aGltfFile1"
-ReadGltf D "$aGltfFile2"

tests/de_mesh/gltf_write/bull

@@ -1,16 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-Close D0 -silent
-ReadGltf D0 [locate_data_file bug32867_bull.glb]
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-set aGltfFile2 "${imagedir}/${casename}_tmp2.glb"
-
-WriteGltf D0 "$aGltfFile1" -draco on
-WriteGltf D0 "$aGltfFile2" -draco on -mergefaces
-
-ReadGltf D1 "$aGltfFile1"
-ReadGltf D "$aGltfFile2"

tests/de_mesh/gltf_write/bull_parallel

@@ -1,13 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-Close D0 -silent
-ReadGltf D0 [locate_data_file bug32867_bull.glb]
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-
-WriteGltf D0 "$aGltfFile1" -draco on -parallel
-
-ReadGltf D "$aGltfFile1"

tests/de_mesh/gltf_write/screw

@@ -1,18 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-Close D0 -silent
-ReadStep D0 [locate_data_file screw.step]
-XGetOneShape ss D0
-incmesh ss 1.0
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-set aGltfFile2 "${imagedir}/${casename}_tmp2.glb"
-
-WriteGltf D0 "$aGltfFile1" -draco on -mergefaces
-WriteGltf D0 "$aGltfFile2" -draco on
-
-ReadGltf D1 "$aGltfFile1"
-ReadGltf D "$aGltfFile2"

tests/de_mesh/gltf_write/soapbox

@@ -1,17 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-ReadStep D0 [locate_data_file ec_soapbox-A.stp]
-XGetOneShape ss D0
-incmesh ss 1.0
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-set aGltfFile2 "${imagedir}/${casename}_tmp2.glb"
-
-WriteGltf D0 "$aGltfFile1" -draco on
-WriteGltf D0 "$aGltfFile2" -draco on -mergefaces
-
-ReadGltf D1 "$aGltfFile1"
-ReadGltf D "$aGltfFile2"

tests/de_mesh/gltf_write/test

@@ -1,20 +0,0 @@
-puts "========"
-puts "0032867: Data Exchange - Implement Draco compression for writing glTF"
-puts "Test case exporting model into glb (binary glTF) file."
-puts "========"
-
-Close D0 -silent
-ReadGltf D0 [locate_data_file bug32867_test.glb]
-
-set aGltfFile1 "${imagedir}/${casename}_tmp1.glb"
-set aGltfFile2 "${imagedir}/${casename}_tmp2.glb"
-
-WriteGltf D0 "$aGltfFile1" -draco on
-WriteGltf D0 "$aGltfFile2" -draco on -mergefaces
-
-ReadGltf D1 "$aGltfFile1"
-XGetOneShape s1 D1
-checktrinfo s1 -tri 9366
-ReadGltf D "$aGltfFile2"
-XGetOneShape s2 D
-checktrinfo s2 -tri 9366

tests/heal/checkshape/bug32448_10

@@ -1,8 +0,0 @@
-puts "REQUIRED All: Faulty shapes in variables faulty_1 to faulty_6101"
-puts "=========="
-puts "0032448: Provide exact validating (as option) using GeomLib_CheckCurveOnSurface"
-puts "=========="
-puts ""
-
-restore [locate_data_file OCC54.brep] b
-checkshape b -exact -parallel

tests/hlr/poly_hlr/A1

@@ -4,7 +4,7 @@ puts "====================================="
 puts ""
 
 set viewname ""
-set length 6.30238
+set length 6.30139
 
 restore [locate_data_file bug27341_hlrsave.brep] a
 COMPUTE_HLR $viewname $algotype

tests/hlr/poly_hlr/A2

@@ -1,4 +1,4 @@
-puts "TODO OCC30286 ALL: Error : The length of result shape is 8.06872, expected 8.05281"
+puts "TODO OCC30286 ALL: Error : The length of result shape is 7.9487, expected 8.05281"
 
 puts "====================================="
 puts "OCC27341: Incorrect exact HLR results"

tests/hlr/poly_hlr/A3

@@ -4,7 +4,7 @@ puts "====================================="
 puts ""
 
 set viewname "vbottom"
-set length 8.39744
+set length 8.40196
 
 restore [locate_data_file bug27341_hlrsave.brep] a
 COMPUTE_HLR $viewname $algotype

tests/hlr/poly_hlr/A4

@@ -1,4 +1,4 @@
-puts "TODO OCC30286 ALL: Error : The length of result shape is 7.44464, expected 7.39488"
+puts "TODO OCC30286 ALL: Error : The length of result shape is 7.4452, expected 7.39488"
 
 puts "====================================="
 puts "OCC27341: Incorrect exact HLR results"

tests/hlr/poly_hlr/A5

@@ -1,4 +1,4 @@
-puts "TODO OCC30286 ALL: Error : The length of result shape is 9.10542, expected 9.47163"
+puts "TODO OCC30286 ALL: Error : The length of result shape is 9.08401, expected 9.47163"
 
 puts "====================================="
 puts "OCC27341: Incorrect exact HLR results"

tests/hlr/poly_hlr/A6

@@ -4,7 +4,7 @@ puts "====================================="
 puts ""
 
 set viewname "vleft"
-set length 7.64599
+set length 7.64618
 
 restore [locate_data_file bug27341_hlrsave.brep] a
 COMPUTE_HLR $viewname $algotype

tests/hlr/poly_hlr/A7

@@ -4,7 +4,7 @@ puts "====================================="
 puts ""
 
 set viewname "vright"
-set length 9.30381
+set length 9.30402
 
 restore [locate_data_file bug27341_hlrsave.brep] a
 COMPUTE_HLR $viewname $algotype

tests/hlr/poly_hlr/Plate

@@ -1,5 +1,5 @@
 puts "TODO OCC30286 Windows: Error : The length of result shape is 404.004, expected 404.386"
-puts "TODO OCC30286 Linux: Error : The length of result shape is 404.492, expected 404.386"
+puts "TODO CR33225 Linux: Error : The length of result shape is 404.004, expected 404.386"
 
 polyline f1 0 0 0  0 -10 0  100 -10 0  100 0 0  0 0 0
 polyline f2 100 0 0  110 0 0  110 100 0  100 100 0  100 0 0

tests/lowalgos/proximity/D4

@@ -0,0 +1,29 @@
+puts "============"
+puts "0033144: Modeling Algorithms - Wrong result of Shape Proximity"
+puts "==========="
+puts "" 
+
+sphere s1 0 1 0 0 0 1 1
+trimu s1 s1 0 pi
+mkface fs1 s1
+incmesh fs1 1e-3
+
+plane p1 0 0 0 0 1 0
+trim p1 p1 -1 1 -1 1 
+mkface f2 p1
+incmesh f2 1e-3
+
+set log [proximity fs1 f2 -value -profile]
+
+regexp {Proximity value: ([0-9+-.eE]*)} $log full val;
+
+set tol 1.e-2
+set expected 2.0
+
+regexp {Status of ProxPnt1 on ([A-Za-z0-9._-]*) : ([A-Za-z]*)} $log full val1 val2
+set status1 ${val2}
+set expected_status1 Middle
+
+regexp {Status of ProxPnt2 on ([A-Za-z0-9._-]*) : ([A-Za-z]*)} $log full val1 val2
+set status2 ${val2}
+set expected_status2 Middle

tests/lowalgos/proximity/E3

@@ -1,26 +1,23 @@
 puts "============"
-puts "0033017: Implement an algorithm to find a proximity between a pair of shapes"
+puts "0033144: Modeling Algorithms - Wrong result of Shape Proximity"
 puts "==========="
 puts "" 
 
-plane p1 0 0 0 0 0 1
-trim p1 p1 -1 1 -1 1
-mkface f1 p1
-incmesh f1 1.e-3
+restore [locate_data_file bug33144_e1.brep] e1 
+restore [locate_data_file bug33144_e2.brep] e2 
 
-circle c 0 0 1 1
-mkedge e1 c
-incmesh e1 1.e-3
+incmesh e1 1e-3
+incmesh e2 1e-3
 
-set log [proximity f1 e1 -value -profile]
+set log [proximity e1 e2 -value -profile]
 regexp {Proximity value: ([0-9+-.eE]*)} $log full val;
 
 set tol 1.e-3
-set expected 1.0
+set expected 0.6996
 
 regexp {Status of ProxPnt1 on ([A-Za-z0-9._-]*) : ([A-Za-z]*)} $log full val1 val2
 set status1 ${val2}
-set expected_status1 Border
+set expected_status1 Middle
 
 regexp {Status of ProxPnt2 on ([A-Za-z0-9._-]*) : ([A-Za-z]*)} $log full val1 val2
 set status2 ${val2}

tests/offset/faces_type_i/B3

@@ -1,6 +1,6 @@
-puts "TODO OCC23748 ALL: ERROR. offsetperform operation not done."
-puts "TODO OCC23748 ALL: Error: The command cannot be built"
-puts "TODO OCC26556 ALL: Error : The offset cannot be built."
+puts "TODO OCC26556 ALL: Error : The volume"
+puts "TODO OCC26556 ALL: Faulty shapes"
+puts "TODO OCC26556 ALL: Error : The area"
 
 pcone s 5 0 12 270
 

tests/offset/faces_type_i/C8

@@ -1,5 +1,6 @@
 puts "TODO OCC25406 ALL: Error : The volume of result shape is"
 puts "TODO OCC25406 ALL: Error: bsection of the result and s is not equal to zero"
+puts "TODO OCC25406 ALL: Faulty shapes"
 
 ellipse w1 0 0 0 15 10
 mkedge w1 w1 0 pi/2

tests/offset/shape_type_i/A7

@@ -1,5 +1,4 @@
 puts "TODO OCC23068 ALL: Error : The volume of result shape "
-puts "TODO OCC25406 ALL: Error: bsection of the result and s is not equal to zero"
 
 pcone s 5 0 12 270
 

tests/offset/shape_type_i/C8

@@ -1,5 +1,6 @@
 puts "TODO OCC23068 ALL: Error : The volume of result shape is"
 puts "TODO OCC23068 ALL: Error: bsection of the result and s is not equal to zero"
+puts "TODO OCC23068 ALL: Faulty shapes"
 
 ellipse w1 0 0 0 15 10
 mkedge w1 w1 0 pi/2

tests/opengl/data/background/skydome

@@ -1,43 +0,0 @@
-puts "============"
-puts "0032606: Visualization - add a shader for sky"
-puts "============"
-puts ""
-
-set THE_DIM 256
-
-pload MODELING VISUALIZATION
-psphere s 1
-
-vinit View1 -width 768 -height 512
-vcamera -persp -fovy 120
-
-chrono t restart
-vbackground -skydome -size $THE_DIM -cloud 0.3 -sunDir 1.0 0.5 0.0 -time 10 -fog 0.3
-chrono t show
-vaxo
-vdump $imagedir/${casename}_day.png
-
-chrono t restart
-vbackground -skydome -size $THE_DIM -cloud 0.3 -sunDir 1.0 -0.5 0.0 -time -10 -fog 0.05
-chrono t show
-vaxo
-vdump $imagedir/${casename}_night.png
-
-chrono t restart
-vbackground -skydome -size $THE_DIM -cloud 0.15 -sunDir 1.0 0.15 0.0 -time 10
-chrono t show
-vaxo
-vdump $imagedir/${casename}_sunset.png
-
-chrono t restart
-vbackground -skydome -size $THE_DIM
-chrono t show
-vaxo
-vdump $imagedir/${casename}_defaults.png
-
-vdisplay -dispMode 1 s
-vfit
-vaspects s -material SILVER
-vrenderparams -shadingModel pbr
-vlight headlight -enabled 0
-vdump $imagedir/${casename}_pbr.png

tests/opengl/data/general/bug25679

@@ -1,33 +0,0 @@
-puts "========"
-puts "OCC25679: Visualization, TKOpenGl - View frustum culling clips wrong objects"
-puts "========"
-puts ""
-
-pload MODELING VISUALIZATION
-
-set LINES_IN_ROW 50
-
-set aNoCulling $imagedir/${casename}_without.png
-set aWithCulling $imagedir/${casename}_with.png
-set aDiff $imagedir/${casename}_diff.png
-
-vinit View1
-
-for {set i 0} {$i < $LINES_IN_ROW} {incr i} {
-  for {set j 0} {$j < $LINES_IN_ROW} {incr j} {
-    set aLineName "line"
-    append aLineName [expr $i * $LINES_IN_ROW + $j]
-    vline $aLineName 0 0 0 1 0 0
-    vsetlocation $aLineName [expr $i * 3] [expr $j * 3] 0
-  }
-}
-
-vfit
-
-vrenderparams -frustumculling on
-vdump $aWithCulling
-vrenderparams -frustumculling off
-vdump $aNoCulling
-
-set aDiffRes [diffimage $aWithCulling $aNoCulling 0.1 0 0 $aDiff]
-if {$aDiffRes != 0} { puts "ERROR : Test failed: there is a difference between images rendered with and without frustum culling" }

tests/opengl/data/raytrace/bug25201

@@ -1,53 +0,0 @@
-puts "========"
-puts "OCC25201: Visualization - Implementing soft shadows and ambient occlusion in OCCT ray-tracing core"
-puts "========"
-
-pload MODELING VISUALIZATION
-
-# custom shapes
-set aShape1 [locate_data_file occ/Top.brep]
-set aShape2 [locate_data_file occ/Bottom.brep]
-
-# setup 3D viewer content
-vinit name=View1 w=512 h=512
-vglinfo
-
-vvbo 0
-vsetdispmode 1
-vbackground -gradient B4C8FF B4B4B4 -gradientMode VERTICAL
-vtextureenv on 4
-restore $aShape1 s1
-restore $aShape2 s2
-vdisplay s1 s2
-vsetmaterial s1 Gold
-vsetmaterial s2 Silver
-vsetlocation s1 0.0 0.1 0.0
-vlight -change 0 -dir 0.667 -0.667 -0.333 -smoothAngle 6 -intensity 100
-vturnview 3.0 -1.2 -0.1
-vfit
-
-# activate path tracing
-vrenderparams -raytrace
-vrenderparams -gi
-vrenderparams -rayDepth 12
-
-set aModeNum 0
-
-vbsdf s1 roughness 6400
-
-vfps 200
-vdump $imagedir/${casename}_${aModeNum}.png
-incr aModeNum
-
-vsetmaterial s1 glass
-vbsdf s1 absorpcoeff 1.0
-
-vfps 200
-vdump $imagedir/${casename}_${aModeNum}.png
-incr aModeNum
-
-vsetmaterial s2 plaster
-
-vfps 200
-vdump $imagedir/${casename}_${aModeNum}.png
-incr aModeNum

tests/opengl/data/raytrace/dof_mono

@@ -1,10 +0,0 @@
-puts "========"
-puts "Ray Tracing - check depth-of-field"
-puts "========"
-
-source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_cube.tcl
-
-vrenderparams -ray -gi -rayDepth 10 -iss
-vrenderparams -aperture 0.1 -focal 2.0
-vfps 200
-vdump ${imagedir}/${casename}.png

tests/opengl/data/raytrace/dof_stereo

@@ -1,16 +0,0 @@
-puts "========"
-puts "Ray Tracing - check depth-of-field"
-puts "========"
-
-source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_cube.tcl
-
-vrenderparams -ray -gi -rayDepth 10 -iss
-vrenderparams -aperture 0.1 -focal 2.0
-
-# activate stereo
-vstereo on
-vstereo -mode anaglyph
-vcamera -iod 0.1
-vfit 
-vfps 200
-vdump ${imagedir}/${casename}.png -stereo blend

tests/opengl/data/raytrace/normal_map

@@ -1,34 +0,0 @@
-puts "========"
-puts "0031275: Visualization, TKOpenGl - handle normal-map texture with Path-Tracing"
-puts "========"
-
-pload XDE OCAF MODELING VISUALIZATION
-Close D -silent
-ReadGltf D [locate_data_file bug31275_SphereWithNormalMap.glb]
-
-vclear
-vinit v -w 1024 -h 1024
-vbackground -cubemap [locate_data_file Circus_CubeMap_V.png]
-vcamera -persp
-vlight -clear
-vlight -add ambient
-XDisplay -dispmode 1 D
-vback
-vfit
-
-vrenderparams -ignoreNormalMap on
-vrenderparams -ray -gi -rayDepth 10
-vfps 200
-vdump ${imagedir}/${casename}_without_normal_map.png
-
-vrenderparams -ignoreNormalMap off
-vfps 200
-vdump ${imagedir}/${casename}_with_normal_map_back.png
-
-vfront
-vfps 200
-vdump ${imagedir}/${casename}_with_normal_map_front.png
-
-vlight -add positional -pos 0 0 0 -head 1 -intensity 10
-vfps 200
-vdump ${imagedir}/${casename}_point_light.png

tests/opengl/data/raytrace/pbr_spheres

@@ -1,43 +0,0 @@
-puts "========"
-puts "0031225: Visualization, TKOpenGl - support cubemap for environment texture within Ray-Tracing"
-puts "Spheres grid with different roughness values"
-puts "========"
-
-cpulimit 600
-
-pload MODELING VISUALIZATION
-vclear
-vclose ALL
-source $env(CSF_OCCTSamplesPath)/tcl/vis_pbr_spheres.tcl
-
-vrenderparams -ray -gi -rayDepth 10
-vcamera -ortho
-vfit
-vlight -change 1 -intensity 0.0001
-vfps 200
-vdump $::imagedir/${::casename}_ortho0.png
-
-vlight -change 1 -intensity 0.3
-vfps 200
-vdump $::imagedir/${::casename}_ortho30.png
-
-vcamera -persp
-vfit
-vlight -change 1 -intensity 0.0001
-vfps 200
-vdump $::imagedir/${::casename}_persp0.png
-
-vlight -change 1 -intensity 0.3
-vfps 200
-vdump $::imagedir/${::casename}_persp30.png
-
-set aCubeMap [locate_data_file Circus_CubeMap_V.png]
-vlight -change 1 -intensity 1
-vbackground -cubemap $aCubeMap
-vcamera -ortho
-vfps 200
-vdump $::imagedir/${::casename}_orthoenv.png
-
-vcamera -persp
-vfps 200
-vdump $::imagedir/${::casename}_perspenv.png

tests/opengl/data/raytrace/sample_ball_alpha

@@ -1,13 +0,0 @@
-puts "============"
-puts "Visualization - Path Tracing, Ball sample"
-puts "============"
-puts ""
-
-source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_ball.tcl
-
-vtexture ball 21 -scale 0.1 0.1
-vsetmaterial ball plaster
-vbsdf ball -coatFresnel Constant 0.0
-
-vfps 100
-vdump $imagedir/${casename}_zoom.png

tests/opengl/data/raytrace/sample_ball_iss

@@ -1,20 +0,0 @@
-puts "============"
-puts "Visualization - Path Tracing, Ball sample (ISS mode)"
-puts "============"
-puts ""
-
-cpulimit 1000
-
-source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_ball.tcl
-
-vrenderparams -iss -nbtiles 64
-vfps 1024
-vdump $imagedir/${casename}_iss_64.png
-
-vrenderparams -iss -nbtiles 256
-vfps 256
-vdump $imagedir/${casename}_iss_256.png
-
-vrenderparams -iss -nbtiles 1024
-vfps 64
-vdump $imagedir/${casename}_iss_1024.png

tests/opengl/data/raytrace/sample_ball_wood

@@ -1,13 +0,0 @@
-puts "============"
-puts "0031135: Visualization, TKOpenGl - texture sRGB -> linear conversion is applied twice by Path Tracer"
-puts "============"
-puts ""
-
-source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_ball.tcl
-
-vtexture ball 11 -scale 0.1 0.1
-vsetmaterial ball plaster
-vbsdf ball -coatFresnel Constant 0.0
-
-vfps 100
-vdump $imagedir/${casename}_zoom.png

tests/opengl/data/raytrace/sample_cube

@@ -1,8 +0,0 @@
-puts "============"
-puts "Visualization - Path Tracing, Cube sample"
-puts "============"
-puts ""
-
-source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_cube.tcl
-vfps 200
-vdump ${imagedir}/${casename}.png

tests/opengl/data/raytrace/sample_cube_clamp

@@ -1,22 +0,0 @@
-puts "============"
-puts "Visualization - Path Tracing, Cube sample with radiance clamping"
-puts "============"
-puts ""
-
-source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_cube.tcl
-
-vrenderparams -maxrad 1.0
-vfps 100
-vdump $imagedir/${casename}_1.png
-
-vrenderparams -maxrad 2.0
-vfps 100
-vdump $imagedir/${casename}_2.png
-
-vrenderparams -maxrad 10.0
-vfps 100
-vdump $imagedir/${casename}_10.png
-
-vrenderparams -maxrad 100.0
-vfps 100
-vdump $imagedir/${casename}_100.png

tests/opengl/data/raytrace/sample_cube_twosided

@@ -1,19 +0,0 @@
-puts "============"
-puts "Visualization - Path Tracing, Cube sample"
-puts "============"
-puts ""
-
-source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_cube.tcl
-
-vaxo
-vfit
-vfps 100
-
-# Dump image produced with one-sided BSDFs
-vdump $imagedir/${casename}_onesided.png
-
-vrenderparams -twoside
-vfps 100
-
-# Dump image produced with two-sided BSDFs
-vdump $imagedir/${casename}_twosided.png