0032818: Modeling Algorithms - Result of sweep operation is invalid

BRepFill_TrimShellCorner.cxx - setting correct orientation for NewEdge
tests/pipe/bugs/bug32818 - new test case added

src/BRepAlgo/BRepAlgo_Loop.cxx

@@ -42,14 +42,12 @@
 #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_True;
+Standard_Boolean AffichLoop  = Standard_False;
 Standard_Integer NbLoops     = 0;
 Standard_Integer NbWires     = 1;
 static char* name = new char[100];
@@ -60,8 +58,7 @@ static char* name = new char[100];
 //purpose  : 
 //=======================================================================
 
-BRepAlgo_Loop::BRepAlgo_Loop():
+BRepAlgo_Loop::BRepAlgo_Loop()
-  myTolConf (0.001)
 {
 }
 
@@ -188,6 +185,7 @@ 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 );
   ///////////////////////////////////////////////
   
@@ -429,12 +427,13 @@ 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++)
@@ -450,7 +449,7 @@ static void StoreInMVE (const TopoDS_Face&                  F,
 	{
 	  V1 = TopoDS::Vertex( itl.Value() );
 	  P1 = BRep_Tool::Pnt( V1 );
-	  if (P.IsEqual( P1, theTolConf ) && !V.IsSame(V1))
+	  if (P.IsEqual( P1, Tol ) && !V.IsSame(V1))
 	    {
 	      V.Orientation( V1.Orientation() );
 	      if (VerticesForSubstitute.IsBound( V1 ))
@@ -575,7 +574,7 @@ void BRepAlgo_Loop::Perform()
         TopoDS_Edge& E = TopoDS::Edge(itl1.Value());
         if (!Emap.Add(E))
           continue;
-        StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute, myTolConf);
+        StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute);
       }
     }
   }
@@ -587,7 +586,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, myTolConf);
+      StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute);
   }
 
 #ifdef DRAW
@@ -627,42 +626,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; }
+    if (CE.Orientation() == TopAbs_FORWARD) { CV = VF = V1;}
-    else { CV = VF = V2; }
+    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);
+	aListEdges.Remove(itl);
-        break;
+	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())
@@ -673,41 +672,35 @@ 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))
+    if (VF.IsSame(CV) && SamePnt2d(VF,EF,CE,myFace))
     {
-      if (SamePnt2d(VF, EF, CE, myFace))
+      NW.Closed (Standard_True);
-      {
+      myNewWires.Append (NW);
-        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++);	
@@ -784,6 +777,8 @@ 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);
@@ -818,9 +813,13 @@ 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);
@@ -831,6 +830,8 @@ 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,17 +86,8 @@ 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:
 
@@ -117,7 +108,6 @@ private:
   TopTools_DataMapOfShapeListOfShape myCutEdges;
   TopTools_DataMapOfShapeShape myVerticesForSubstitute;
   BRepAlgo_Image myImageVV;
-  Standard_Real myTolConf;
 
 
 };

src/BRepExtrema/BRepExtrema_ProximityDistTool.cxx

@@ -43,8 +43,6 @@ 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)
@@ -57,7 +55,6 @@ BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool (const Handle(BRepE
 {
   LoadTriangleSets (theSet1, theSet2);
   LoadShapeLists (theShapeList1, theShapeList2);
-  LoadAdditionalPointsFirstSet (theAddVertices1, theAddStatus1);
 }
 
 //=======================================================================
@@ -72,7 +69,7 @@ void BRepExtrema_ProximityDistTool::LoadTriangleSets (const Handle(BRepExtrema_T
 }
 
 //=======================================================================
-//function : LoadShapeLists
+//function : LoadTriangleSets
 //purpose  : Loads the given list of subshapes into the proximity tool
 //=======================================================================
 void BRepExtrema_ProximityDistTool::LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
@@ -81,50 +78,6 @@ void BRepExtrema_ProximityDistTool::LoadShapeLists (const BRepExtrema_ShapeList&
   myShapeList1 = theShapeList1;
   myShapeList2 = theShapeList2;
 }
-
-//=======================================================================
-//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 (theVertices1[aVtxIdx]);
-
-    ComputeDistance();
-
-    if (!IsDone() && myProxDist < 0.) return;
-
-    if (IsDone() && myDistance > myProxDist)
-    {
-      myPnt1 = theVertices1[aVtxIdx];
-      myPnt2 = myExtremaPoint;
-      myProxDist = myDistance;
-      myProxVtxIdx1 = aVtxIdx;
-      myIsProxVtx1FromAddSet = theIsAdditionalSet;
-      myProxPrjState = myExtPrjState;
-    }
-  }
-}
-
 //=======================================================================
 //function : Perform
 //purpose  : Performs searching of the proximity distance
@@ -132,14 +85,37 @@ void BRepExtrema_ProximityDistTool::goThroughtSet1 (const BVH_Array3d& theVertic
 void BRepExtrema_ProximityDistTool::Perform()
 {
   SetBVHSet (mySet2.get());
-  goThroughtSet1 (mySet1->GetVertices(), Standard_False);
-  goThroughtSet1 (myAddVertices1, Standard_True);
 
-  myIsDone = myProxDist > -1.;
+  const BVH_Array3d& aVertices1 = mySet1->GetVertices();
-  if (myIsDone)
+  Standard_Integer aVtxSize = (Standard_Integer)aVertices1.size();
+  Standard_Integer aVtxStep = Max (myNbSamples1 <= 0 ? 1 : aVtxSize / myNbSamples1, 1);
+  for (Standard_Integer aVtxIdx = 0; aVtxIdx < aVtxSize; aVtxIdx += aVtxStep)
   {
-    DefineStatusProxPnt();
+    myDistance = std::numeric_limits<Standard_Real>::max();
+    myMinDistance = std::numeric_limits<Standard_Real>::max();
+    myIsDone = Standard_False;
+    SetObject (aVertices1[aVtxIdx]);
+
+    ComputeDistance();
+
+    if (!IsDone() && myProxDist < 0.) return;
+
+    if (IsDone() && myDistance > myProxDist)
+    {
+      myPnt1 = aVertices1[aVtxIdx];
+      myPnt2 = myExtremaPoint;
+      myProxDist = myDistance;
+      myProxVtxIdx1 = aVtxIdx;
+      myProxPrjState = myExtPrjState;
+    }
   }
+
+   myIsDone = myProxDist > -1.;
+
+   if (myIsDone)
+   {
+     DefineStatusProxPnt();
+   }
 }
 
 static Standard_Real pointBoxSquareMaxDistance (const BVH_Vec3d& thePoint,
@@ -271,12 +247,7 @@ 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);
 
@@ -308,49 +279,12 @@ Standard_Boolean BRepExtrema_ProximityDistTool::IsNodeOnBorder (const Standard_I
   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)
@@ -380,9 +314,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;
     }
@@ -464,7 +398,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);
@@ -474,7 +408,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;
         }
@@ -485,18 +419,27 @@ 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;
 
-        if (IsEdgeOnBorder (aTrgIdxInShape,
+        Standard_Integer aAdjTrg[3];
-                            myProxPrjState.GetNumberOfFirstNode(),
+        aPolyConnect.Triangles (aTrgIdxInShape, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
-                            myProxPrjState.GetNumberOfLastNode(),
+
-                            aTr))
+        for (Standard_Integer j = 0; j < 3; j++)
         {
-          myPntStatus2 = ProxPnt_Status_BORDER;
+          Standard_Integer k = (j + 1) % 3;
-        }
+          if (aAdjTrg[j] == 0) //free segment of triangle
-        else
+          {
-        {
+            //aVtxIndicesOfTrg[j] and aVtxIndicesOfTrg[k] are ends of free segment and it is a part of border
-          myPntStatus2 = ProxPnt_Status_MIDDLE;
+            if (j == myProxPrjState.GetNumberOfFirstNode() &&
+                k == myProxPrjState.GetNumberOfLastNode())
+            {
+              myPntStatus2 = ProxPnt_Status_BORDER;
+              break;
+            }
+          }
         }
       } //else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
     }

src/BRepExtrema/BRepExtrema_ProximityDistTool.hxx

@@ -21,7 +21,6 @@
 #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 
@@ -94,8 +93,6 @@ 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);
@@ -110,10 +107,6 @@ 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();
 
@@ -128,20 +121,6 @@ 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
   {
@@ -169,10 +148,6 @@ 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();
 
@@ -208,11 +183,6 @@ 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,32 +14,17 @@
 // 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()
-: myIsRefinementRequired1 (Standard_False),
+: myDistance (std::numeric_limits<Standard_Real>::max()),
-  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
@@ -49,15 +34,13 @@ BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool (const Handle(BRe
                                                                 const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                                 const BRepExtrema_ShapeList& theShapeList1,
                                                                 const BRepExtrema_ShapeList& theShapeList2)
-: myIsRefinementRequired1 (Standard_False),
+: myDistance (std::numeric_limits<Standard_Real>::max()),
-  myIsRefinementRequired2 (Standard_False),
-  myDistance (std::numeric_limits<Standard_Real>::max()),
   myIsDone (Standard_False),
-  myNbSamples1 (0),
+  myNbSamples1(0),
-  myNbSamples2 (0)
+  myNbSamples2(0)
 {
-  LoadShapeLists (theShapeList1, theShapeList2);
   LoadTriangleSets (theSet1, theSet2);
+  LoadShapeLists (theShapeList1, theShapeList2);
 }
 
 //=======================================================================
@@ -70,94 +53,7 @@ void BRepExtrema_ProximityValueTool::LoadTriangleSets (const Handle(BRepExtrema_
   mySet1 = theSet1;
   mySet2 = theSet2;
 
-  MarkDirty();
+  myIsDone = Standard_False;
-}
-
-//=======================================================================
-//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;
 }
 
 //=======================================================================
@@ -170,13 +66,7 @@ void BRepExtrema_ProximityValueTool::LoadShapeLists (const BRepExtrema_ShapeList
   myShapeList1 = theShapeList1;
   myShapeList2 = theShapeList2;
 
-  myShape1 = theShapeList1 (0);
+  myIsDone = Standard_False;
-  myIsInitS1 = getInfoForRefinement (myShape1, myShapeType1, myNbNodes1, myStep1);
-
-  myShape2 = theShapeList2 (0);
-  myIsInitS2 = getInfoForRefinement (myShape2, myShapeType2, myNbNodes2, myStep2);
-
-  MarkDirty();
 }
 
 //=======================================================================
@@ -189,7 +79,7 @@ void BRepExtrema_ProximityValueTool::SetNbSamplePoints(const Standard_Integer th
   myNbSamples1 = theSamples1;
   myNbSamples2 = theSamples2;
 
-  MarkDirty();
+  myIsDone = Standard_False;
 }
 
 //=======================================================================
@@ -198,8 +88,6 @@ 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,
@@ -208,8 +96,7 @@ Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle
                                                                     ProxPnt_Status& thePointStatus1,
                                                                     ProxPnt_Status& thePointStatus2) const
 {
-  BRepExtrema_ProximityDistTool aProxDistTool (theSet1, theNbSamples1, theAddVertices1, theAddStatus1,
+  BRepExtrema_ProximityDistTool aProxDistTool (theSet1, theNbSamples1, theSet2, theShapeList1, theShapeList2);
-                                               theSet2, theShapeList1, theShapeList2);
   aProxDistTool.Perform();
 
   if (!aProxDistTool.IsDone())
@@ -221,311 +108,21 @@ 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)
 {
-  if (!myIsInitS1 || !myIsInitS2 || (myShapeType1 != myShapeType2))
+  myIsDone = Standard_False;
-    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, myAddVertices1, myAddStatus1,
+  Standard_Real aProximityDist1 = computeProximityDist (mySet1, myNbSamples1, mySet2, myShapeList1, myShapeList2,
-                                                        mySet2,
+                                                        aP1_1, aP1_2, aPointStatus1_1, aPointStatus1_2);
-                                                        myShapeList1, myShapeList2,
-                                                        aP1_1, aP1_2,
-                                                        aPointStatus1_1, aPointStatus1_2);
 
   if (aProximityDist1 < 0.)
     return;
@@ -535,11 +132,8 @@ 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, myAddVertices2, myAddStatus2,
+  Standard_Real aProximityDist2 = computeProximityDist (mySet2, myNbSamples2, mySet1, myShapeList2, myShapeList1,
-                                                        mySet1,
+                                                        aP2_2, aP2_1, aPointStatus2_2, aPointStatus2_1);
-                                                        myShapeList2, myShapeList1,
-                                                        aP2_2, aP2_1,
-                                                        aPointStatus2_2, aPointStatus2_1);
 
   if (aProximityDist2 < 0.)
     return;
@@ -565,23 +159,3 @@ 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,67 +18,9 @@
 
 #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).
@@ -87,6 +29,8 @@ typedef typename BRepExtrema_ProximityDistTool::ProxPnt_Status ProxPnt_Status;
 //! on the quality of input tessellation(s).
 class BRepExtrema_ProximityValueTool
 {
+public:
+  typedef typename BRepExtrema_ProximityDistTool::ProxPnt_Status ProxPnt_Status;
 
 public:
 
@@ -142,17 +86,9 @@ 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,
@@ -161,29 +97,6 @@ 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.
@@ -196,35 +109,6 @@ 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,7 +129,6 @@ 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,8 +37,7 @@
 //! on distance less than the given tolerance from each other.
 //!
 //! Second approach:
-//! Compute the proximity value between two shapes (handles only edge/edge or face/face cases)
+//! Compute the proximity value between two shapes if the tolerance is not defined (Precision::Infinite()).
-//! 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
@@ -47,6 +46,8 @@
 //! triangulation).
 class BRepExtrema_ShapeProximity
 {
+public:
+  typedef typename BRepExtrema_ProximityValueTool::ProxPnt_Status ProxPnt_Status;
 
 public:
 

src/BRepLib/BRepLib.cxx

@@ -802,7 +802,7 @@ static void GetEdgeTol(const TopoDS_Edge& theEdge,
     }
     if(temp > d2) d2 = temp;
   }
-  d2 = 1.05*sqrt(d2);
+  d2 = 1.5*sqrt(d2);
   theEdTol = d2;
 }
 
@@ -884,6 +884,10 @@ 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
@@ -1705,8 +1709,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));
-    gp_Pnt aPV = BRep_Tool::Pnt(V);
+    Bnd_Box box;
-    Standard_Real aMaxDist = 0.;
+    box.Add(BRep_Tool::Pnt(V));
     gp_Pnt p3d;
     for (lConx.Initialize(parents(iCur)); lConx.More(); lConx.Next()) {
       const TopoDS_Edge& E = TopoDS::Edge(lConx.Value());
@@ -1728,10 +1732,8 @@ static void InternalUpdateTolerances(const TopoDS_Shape& theOldShape,
           if (!C.IsNull()) { // edge non degenerated
             p3d = C->Value(par);
             p3d.Transform(L.Transformation());
-            Standard_Real aDist = p3d.SquareDistance(aPV);
+            box.Add(p3d);
-            if (aDist > aMaxDist)
+          }
-              aMaxDist = aDist;
-           }
         }
         else if (cr->IsCurveOnSurface()) {
           const Handle(Geom_Surface)& Su = cr->Surface();
@@ -1743,22 +1745,21 @@ static void InternalUpdateTolerances(const TopoDS_Shape& theOldShape,
           gp_Pnt2d p2d = PC->Value(par);
           p3d = Su->Value(p2d.X(),p2d.Y());
           p3d.Transform(L.Transformation());
-          Standard_Real aDist = p3d.SquareDistance(aPV);
+          box.Add(p3d);
-          if (aDist > aMaxDist)
-            aMaxDist = aDist;
           if (!PC2.IsNull()) {
             p2d = PC2->Value(par);
             p3d = Su->Value(p2d.X(),p2d.Y());
             p3d.Transform(L.Transformation());
-            aDist = p3d.SquareDistance(aPV);
+            box.Add(p3d);
-            if (aDist > aMaxDist)
-              aMaxDist = aDist;
           }
         }
         itcr.Next();
       }
     }
-    tol = Max(tol, sqrt(aMaxDist));
+    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 += 2.*Epsilon(tol);
     //
     Standard_Real aVTol = BRep_Tool::Tolerance(V);

src/BRepOffset/BRepOffset_MakeOffset.cxx

@@ -336,10 +336,8 @@ static BRepOffset_Error checkSinglePoint(const Standard_Real theUParam,
                                          const NCollection_Vector<gp_Pnt>& theBadPoints);
 
 //---------------------------------------------------------------------
-static void UpdateTolerance (      TopoDS_Shape&               theShape,
+static void UpdateTolerance (      TopoDS_Shape&               myShape,
-                             const TopTools_IndexedMapOfShape& theFaces,
+                             const TopTools_IndexedMapOfShape& myFaces);
-                             const TopoDS_Shape& theInitShape);
-
 static Standard_Real ComputeMaxDist(const gp_Pln& thePlane, 
                                     const Handle(Geom_Curve)& theCrv,
                                     const Standard_Real theFirst,
@@ -1038,16 +1036,8 @@ void BRepOffset_MakeOffset::MakeOffsetShape(const Message_ProgressRange& theRang
   // MAJ Tolerance edge and Vertex
   // ----------------------------
   if (!myOffsetShape.IsNull()) {
-    if (myThickening)
+    UpdateTolerance (myOffsetShape,myFaces);
-    {
+    BRepLib::UpdateTolerances( myOffsetShape );
-      UpdateTolerance(myOffsetShape, myFaces, myShape);
-    }
-    else
-    {
-      TopoDS_Shape aDummy;
-      UpdateTolerance(myOffsetShape, myFaces, aDummy);
-    }
-    BRepLib::UpdateTolerances(myOffsetShape);
   }
 
   CorrectConicalFaces();
@@ -3175,38 +3165,13 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
       } //if both edges are arcs of circles
       if (NewFace.IsNull())
       {
-        Standard_Real anEdgeTol = BRep_Tool::Tolerance(anEdge);
+        BRepLib_MakeFace MF(theWire, Standard_True); //Only plane
-        //Tolerances of input shape should not be increased by BRepLib_MakeFace
+        if (MF.Error() == BRepLib_FaceDone)
-        BRepLib_FindSurface aFindPlane(theWire, anEdgeTol, Standard_True); //only plane
-        IsPlanar = Standard_False;
-        if(aFindPlane.Found() && aFindPlane.ToleranceReached() <= anEdgeTol)
         {
-          Standard_Real f, l;
+          NewFace = MF.Face();
-          Handle(Geom_Curve) aGC = BRep_Tool::Curve(anEdge, f, l);
+          IsPlanar = Standard_True;
-          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 =
@@ -3220,6 +3185,7 @@ 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;
@@ -3306,14 +3272,8 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
           BB.Range( anE3, FirstPar, LastPar );
         }
       }
-
+      BRepLib::SameParameter(NewFace);
-      if (!IsPlanar)
+      BRepTools::Update(NewFace);
-      {
-        // 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);
@@ -3821,7 +3781,6 @@ void BRepOffset_MakeOffset::EncodeRegularity ()
 #endif
 }
 
-
 //=======================================================================
 //function : ComputeMaxDist
 //purpose  : 
@@ -3848,15 +3807,13 @@ 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;
@@ -3872,31 +3829,12 @@ void UpdateTolerance (TopoDS_Shape& S,
     }
   }
   
-  // The edges of initial shape are  not modified
-  TopTools_MapOfShape aMapInitF;
-  if (!theInitShape.IsNull())
-  {
-    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);
+  TopExp_Explorer ExpF;
-  for (; anExpF.More(); anExpF.Next())
+  for (ExpF.Init(S, TopAbs_FACE); ExpF.More(); ExpF.Next())
   {
-    const TopoDS_Shape& F = anExpF.Current();
+    const TopoDS_Shape& F = ExpF.Current();
-    if (Faces.Contains(F) || aMapInitF.Contains(F))
+    if (Faces.Contains(F))
     {
       continue;
     }
@@ -3905,7 +3843,6 @@ 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,
@@ -3913,22 +3850,17 @@ 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);
-        if (aMaxDist > aCurrTol)
+        E.Locked (Standard_False);
-        {
+        B.UpdateEdge(E, aMaxDist);
-          B.UpdateEdge(E, aMaxDist);
+        isUpdated = Standard_True;
-          isUpdated = Standard_True;
-        }
       }
       if (View.Add(E))
       {
-        E.Locked(Standard_False);       
+
         BRepCheck_Edge EdgeCorrector(E);
         Tol = EdgeCorrector.Tolerance();
-        if (Tol > aCurrTol)
+        B.UpdateEdge(E, Tol);
-        {
+        isUpdated = Standard_True;
-          B.UpdateEdge(E, Tol);
-          isUpdated = Standard_True;
-        }
       }
       if (isUpdated)
       {
@@ -3937,11 +3869,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();
@@ -5021,53 +4953,6 @@ 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,133 +4234,6 @@ 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,26 +1456,8 @@ 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,97 +1157,82 @@ void BSplCLib::MergeBSplineKnots
   index,
   num_knots ;
   if (StartValue < EndValue - Tolerance) {
-    TColStd_Array1OfReal knots1(1, Knots1.Length());
+    TColStd_Array1OfReal knots1(1,Knots1.Length()) ;
-    TColStd_Array1OfReal knots2(1, Knots2.Length());
+    TColStd_Array1OfReal knots2(1,Knots2.Length()) ;
-    degree = Degree1 + Degree2;
+    degree = Degree1 + Degree2 ;
-    index = 1;
+    index = 1 ;
 
-    for (ii = Knots1.Lower(); ii <= Knots1.Upper(); ii++) {
+    for (ii = Knots1.Lower() ; ii <= Knots1.Upper() ; ii++) {
-      knots1(index) = Knots1(ii);
+      knots1(index) = Knots1(ii) ;
-      index += 1;
+      index += 1 ;
     }
-    index = 1;
+    index = 1 ;
 
-    for (ii = Knots2.Lower(); ii <= Knots2.Upper(); ii++) {
+    for (ii = Knots2.Lower() ; ii <= Knots2.Upper() ; ii++) {
-      knots2(index) = Knots2(ii);
+      knots2(index) = Knots2(ii) ;
-      index += 1;
+      index += 1 ;
     }
     BSplCLib::Reparametrize(StartValue,
-      EndValue,
+			    EndValue,
-      knots1);
+			    knots1) ;
-
+    
     BSplCLib::Reparametrize(StartValue,
-      EndValue,
+			    EndValue,
-      knots2);
+			    knots2) ;
-    num_knots = 0;
+    num_knots = 0 ;
-    jj = 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) {
-        jj += 1;
+	jj += 1 ;
-        num_knots += 1;
+	num_knots += 1 ;
       }
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) + Tolerance) {
-        jj += 1;
+	jj += 1 ;
       }
-      num_knots += 1;
+      num_knots += 1 ;
     }
-    NewKnots =
+    NewKnots = 
-      new TColStd_HArray1OfReal(1, num_knots);
+      new TColStd_HArray1OfReal(1,num_knots) ;
     NewMults =
-      new TColStd_HArray1OfInteger(1, num_knots);
+      new TColStd_HArray1OfInteger(1,num_knots) ;
-    num_knots = 1;
+    num_knots = 1 ;
-    jj = 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);
+	NewKnots->ChangeArray1()(num_knots) = knots2(jj) ;
-        NewMults->ChangeArray1()(num_knots) = Mults2(jj) + Degree1;
+        NewMults->ChangeArray1()(num_knots) = Mults2(jj) + Degree1 ;
-        jj += 1;
+	jj += 1 ;
-        num_knots += 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));
+	continuity = Min(Degree1 - Mults1(ii), Degree2 - Mults2(jj)) ;
-        set_mults_flag = 1;
+        set_mults_flag = 1 ;
-        NewMults->ChangeArray1()(num_knots) = degree - continuity;
+	NewMults->ChangeArray1()(num_knots) = degree - continuity ;
-        jj += 1;
+	jj += 1 ;
       }
 
-      NewKnots->ChangeArray1()(num_knots) = knots1(ii);
+      NewKnots->ChangeArray1()(num_knots) = knots1(ii) ;
-      if (!set_mults_flag) {
+      if (! set_mults_flag) {
-        NewMults->ChangeArray1()(num_knots) = Mults1(ii) + Degree2;
+	NewMults->ChangeArray1()(num_knots) = Mults1(ii) + Degree2 ;
       }
-      num_knots += 1;
+      num_knots += 1 ;
     }
-    num_knots -= 1;
+    num_knots -= 1 ;
-    NewMults->ChangeArray1()(1) = degree + 1;
+    NewMults->ChangeArray1()(1) = degree + 1 ;
-    NewMults->ChangeArray1()(num_knots) = degree + 1;
+    NewMults->ChangeArray1()(num_knots) = degree + 1 ;
-    index = 0;
+    index = 0 ;
 
-    for (ii = 1; ii <= num_knots; ii++) {
+    for (ii = 1 ; ii <= num_knots ; ii++) {
-      index += NewMults->Value(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,7 +37,9 @@ Draft_FaceInfo::Draft_FaceInfo (const Handle(Geom_Surface)& S,\
 				const Standard_Boolean HasNewGeometry):
        myNewGeom(HasNewGeometry)
 {
-  myGeom = S;
+  Handle(Geom_RectangularTrimmedSurface) T = Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
+  if (!T.IsNull()) myGeom = T->BasisSurface();
+  else             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,11 +1062,7 @@ 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
-Standard_EXPORT const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
+const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
 {
   if (theNameStr == 0 || theHandlePtr == 0)
   {
@@ -57,7 +57,7 @@ Standard_EXPORT const char* DrawTrSurf_Set (const char* theNameStr, void* theHan
 }
 
 //! Set point to DRAW variable
-Standard_EXPORT const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
+const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
 {
   if (theNameStr == 0 || thePntPtr == 0)
   {
@@ -77,7 +77,7 @@ Standard_EXPORT const char* DrawTrSurf_SetPnt (const char* theNameStr, void* the
 }
 
 //! Set 2d point to DRAW variable
-Standard_EXPORT const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
+const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
 {
   if (theNameStr == 0 || thePnt2dPtr == 0)
   {
@@ -102,17 +102,17 @@ Standard_EXPORT const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* t
 // work with them (DBX could, on SUN Solaris).
 #ifndef _MSC_VER
 
-Standard_EXPORT const char* DrawTrSurf_Set (const char* name, const Handle(Standard_Transient)& G)
+const char* DrawTrSurf_Set (const char* name, const Handle(Standard_Transient)& G)
 {
   return DrawTrSurf_Set (name, (void*)&G);
 }
 
-Standard_EXPORT const char* DrawTrSurf_Set (const char* theName, const gp_Pnt& thePnt)
+const char* DrawTrSurf_Set (const char* theName, const gp_Pnt& thePnt)
 {
   return DrawTrSurf_SetPnt (theName, (void*)&thePnt);
 }
 
-Standard_EXPORT const char* DrawTrSurf_Set (const char* theName, const gp_Pnt2d& thePnt2d)
+const char* DrawTrSurf_Set (const char* theName, const gp_Pnt2d& thePnt2d)
 {
   return DrawTrSurf_SetPnt2d (theName, (void*)&thePnt2d);
 }

src/Extrema/Extrema_ExtCC.cxx

@@ -674,10 +674,7 @@ 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,6 +58,65 @@ 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  : 
@@ -295,6 +354,158 @@ 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  : 
@@ -302,49 +513,187 @@ GeomAbs_Shape Geom2dAdaptor_Curve::Continuity() const
 
 Standard_Integer Geom2dAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
 {
-  if (myTypeCurve == GeomAbs_BSplineCurve)
+  Standard_Integer myNbIntervals = 1;
-  {
+  Standard_Integer NbSplit;
-    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    {
+    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-      return 1;
+    Standard_Integer LastIndex = myBSplineCurve->LastUKnotIndex();
-    }
+    TColStd_Array1OfInteger Inter(1, LastIndex - FirstIndex + 1);
-    
+    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-    Standard_Integer aCont;
+    if (aContPer || aContNotPer) {
-
+      Standard_Integer Cont;
-    switch (S)
+      switch (S) {
-    {
+      case GeomAbs_G1:
+      case GeomAbs_G2:
+        throw Standard_DomainError("Geom2dAdaptor_Curve::NbIntervals");
+        break;
+      case GeomAbs_C0:
+        myNbIntervals = 1;
+        break;
       case GeomAbs_C1:
-        aCont = 1;
-        break;
       case GeomAbs_C2:
-        aCont = 2;
-        break;
       case GeomAbs_C3:
-        aCont = 3;
-        break;
       case GeomAbs_CN:
-        aCont = aDegree;
+      {
-        break;
+        if (S == GeomAbs_C1) Cont = 1;
-      default:
+        else if (S == GeomAbs_C2) Cont = 2;
-        throw Standard_DomainError ("Geom2dAdaptor_Curve::NbIntervals()");
+        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;
+      }
     }
-
-    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:
@@ -356,14 +705,208 @@ 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(), myFirst, myLast);
+    Geom2dAdaptor_Curve anAdaptor( Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve() );
     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
   {
-    return 1;
+    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;
+    }
   }
 }
 
@@ -372,53 +915,156 @@ Standard_Integer Geom2dAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
 //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 
 {
-  if (myTypeCurve == GeomAbs_BSplineCurve)
+  Standard_Integer myNbIntervals = 1;
-  {
+  Standard_Integer NbSplit;
-    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    {
+    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-      T( T.Lower() ) = myFirst;
+    Standard_Integer LastIndex  = myBSplineCurve->LastUKnotIndex();
-      T( T.Lower() + 1 ) = myLast;
+    TColStd_Array1OfInteger Inter (1, LastIndex-FirstIndex+1);
-      return;
+    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    }
+    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-
+    if (aContPer || aContNotPer) {
-    Standard_Integer aDegree = myBSplineCurve->Degree();
+      Standard_Integer Cont;
-    Standard_Integer aCont;
+      switch ( S) {
-
+      case GeomAbs_G1:
-    switch (S)
+      case GeomAbs_G2:
-    {
+	throw Standard_DomainError("Geom2dAdaptor_Curve::NbIntervals");
+	break;
+      case GeomAbs_C0:
+	myNbIntervals = 1;
+	break;
       case GeomAbs_C1:
-        aCont = 1;
-        break;
       case GeomAbs_C2:
-        aCont = 2;
+      case GeomAbs_C3: 
-        break;
+      case GeomAbs_CN: 
-      case GeomAbs_C3:
+      {
-        aCont = 3;
+        if (S == GeomAbs_C1) Cont = 1;
-        break;
+        else if (S == GeomAbs_C2) Cont = 2;
-      case GeomAbs_CN:
+        else if (S == GeomAbs_C3) Cont = 3;
-        aCont = aDegree;
+        else                       Cont = myBSplineCurve->Degree();
-        break;
+        Standard_Integer Degree = myBSplineCurve->Degree();
-      default:
+        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        throw Standard_DomainError ("Geom2dAdaptor_Curve::Intervals()");
+        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;
+      return;
+      }
     }
-
-    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:
@@ -431,18 +1077,13 @@ void Geom2dAdaptor_Curve::Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shap
     default: BaseS = GeomAbs_CN;
     }
 
-    Geom2dAdaptor_Curve anAdaptor (Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve(), myFirst, myLast);
+    Geom2dAdaptor_Curve anAdaptor( Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve() );
     myNbIntervals = anAdaptor.NbIntervals(BaseS);
     anAdaptor.Intervals(T, BaseS);
-    T( T.Lower() ) = myFirst;
-    T( T.Lower() + myNbIntervals ) = myLast;
   }
 
-  else
+  T( T.Lower() ) = myFirst;
-  {
+  T( T.Lower() + myNbIntervals ) = myLast;
-    T( T.Lower() ) = myFirst;
-    T( T.Lower() + 1 ) = myLast;
-  }
 }
 
 //=======================================================================

src/Geom2dConvert/Geom2dConvert.cxx

@@ -515,6 +515,7 @@ 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;
@@ -526,7 +527,6 @@ 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,6 +565,22 @@ 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));
@@ -1323,22 +1339,24 @@ 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));
+         TColStd_Array1OfReal NewWeights(1, FlatKnots.Length() - (aNewCurveDegree + 1));
+//	 BSplCLib::FunctionReparameterise(reparameterise_evaluator,
 	 BSplCLib::FunctionReparameterise(ev,
 					  Curve1->Degree(),
 					  Curve1FlatKnots,
 					  Curve1Weights,
 					  FlatKnots,
-                      aNewCurveDegree,
+                                          aNewCurveDegree,
 					  NewWeights,
 					  aStatus
 					  );

src/GeomAdaptor/GeomAdaptor_Curve.cxx

@@ -58,6 +58,65 @@ 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  : 
@@ -251,6 +310,159 @@ 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  : 
@@ -258,135 +470,194 @@ GeomAbs_Shape GeomAdaptor_Curve::Continuity() const
 
 Standard_Integer GeomAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
 {
-  if (myTypeCurve == GeomAbs_BSplineCurve)
+  Standard_Integer myNbIntervals = 1;
-  {
+  Standard_Integer NbSplit;
-    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    {
+    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-      return 1;
+    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();
 
-    Standard_Integer aDegree = myBSplineCurve->Degree();
+    if(aContPer || aContNotPer) {
-    Standard_Integer aCont;
+      Standard_Integer Cont;
-
+      switch (S) {
-    switch (S)
+      case GeomAbs_G1:
-    {
+      case GeomAbs_G2:
+        throw Standard_DomainError("GeomAdaptor_Curve::NbIntervals");
+        break;
+      case GeomAbs_C0:
+        myNbIntervals = 1;
+        break;
       case GeomAbs_C1:
-        aCont = 1;
-        break;
       case GeomAbs_C2:
-        aCont = 2;
-        break;
       case GeomAbs_C3:
-        aCont = 3;
-        break;
       case GeomAbs_CN:
-        aCont = aDegree;
+      {
-        break;
+        if (S == GeomAbs_C1) Cont = 1;
-      default:
+        else if (S == GeomAbs_C2) Cont = 2;
-        throw Standard_DomainError ("GeomAdaptor_Curve::NbIntervals()");
+        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;
+      }
     }
-
-    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;
-    }
-    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
-    Standard_Integer iNbBasisInt = C.NbIntervals(BaseS), iInt;
-    if (iNbBasisInt>1)
-    {
-      TColStd_Array1OfReal rdfInter(1,1+iNbBasisInt);
-      C.Intervals(rdfInter,BaseS);
-      for (iInt=1; iInt<=iNbBasisInt; iInt++)
-        if (rdfInter(iInt)>myFirst && rdfInter(iInt)<myLast)
-          myNbIntervals++;
-    }
-    // akm 05/04/02 ^^^
-    return myNbIntervals;
-  }
-
-  else
-  {
-    return 1;
-  }
-}
-
-//=======================================================================
-//function : Intervals
-//purpose  : 
-//=======================================================================
-
-void GeomAdaptor_Curve::Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
-{
-  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 ("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:
@@ -398,7 +669,412 @@ void GeomAdaptor_Curve::Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape
     case GeomAbs_C2: BaseS = GeomAbs_C3; break;
     default: BaseS = GeomAbs_CN;
     }
-    GeomAdaptor_Curve C (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve(), myFirst, myLast);
+    GeomAdaptor_Curve C
+      (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve());
+    // 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
+    Standard_Integer iNbBasisInt = C.NbIntervals(BaseS), iInt;
+    if (iNbBasisInt>1)
+    {
+      TColStd_Array1OfReal rdfInter(1,1+iNbBasisInt);
+      C.Intervals(rdfInter,BaseS);
+      for (iInt=1; iInt<=iNbBasisInt; iInt++)
+	if (rdfInter(iInt)>myFirst && rdfInter(iInt)<myLast)
+	  myNbIntervals++;
+    }
+    // akm 05/04/02 ^^^
+  }
+  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;
+    }
+  }
+}
+
+//=======================================================================
+//function : Intervals
+//purpose  : 
+//=======================================================================
+
+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;
+      return;
+      }
+    }
+  }
+
+  else if (myTypeCurve == GeomAbs_OffsetCurve){
+    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;
+    }
+    GeomAdaptor_Curve C
+      (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve());
     // 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
@@ -414,15 +1090,10 @@ void GeomAdaptor_Curve::Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape
     // old - myNbIntervals = C.NbIntervals(BaseS);
     // old - C.Intervals(T, BaseS);
     // akm 05/04/02 ^^^
-    T( T.Lower() ) = myFirst;
-    T( T.Lower() + myNbIntervals ) = myLast;
   }
   
-  else
+  T( T.Lower() ) = FirstParam;
-  {
+  T( T.Lower() + myNbIntervals ) = LastParam;
-    T( T.Lower() ) = myFirst;
-    T( T.Lower() + 1 ) = myLast;
-  }
 }
 
 //=======================================================================

src/GeomFill/GeomFill_SectionPlacement.cxx

@@ -276,8 +276,6 @@ 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,6 +30,18 @@
 #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,
@@ -37,36 +49,51 @@ 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;
-  gp_Pnt Bary;
+  Standard_Integer Nb = Poles.Length();
+    gp_Pnt Bary;
   gp_Dir DX, DY;
-  Standard_Real aTolSingular = Precision::Confusion();
 
-    
+  
-  GeomLib::Inertia(Poles, Bary, DX, DY, gx, gy, gz);
+  if (Nb > 10) {
-  if (gz < Tol && gy > aTolSingular) {
+    // Test allege (pour une rejection rapide)
-    gp_Pnt P;
+    TColgp_Array1OfPnt Aux(1,5);
-    gp_Vec DU, DV;
+    Aux(1) = Poles(1);
-    Standard_Real umin, umax, vmin, vmax;
+    Aux(2) = Poles(Nb/3);
-    S->Bounds(umin, umax, vmin, vmax);
+    Aux(3) = Poles(Nb/2);
-    S->D1((umin + umax) / 2, (vmin + vmax) / 2, P, DU, DV);
+    Aux(4) = Poles(Nb/2+Nb/3);
-    // On prend DX le plus proche possible de DU
+    Aux(5) =  Poles(Nb);
-    gp_Dir du(DU);
+    GeomLib::Inertia(Aux, Bary, DX, DY, gx, gy, gz);
-    Standard_Real Angle1 = du.Angle(DX);
+    Essai = (gz<Tol);
-    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;
   }
+  
+  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;
+    }
+  }   
   return IsPlan;
 }
 
@@ -79,6 +106,8 @@ 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 :
@@ -102,27 +131,40 @@ 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 :
+    default :
-    {
+      {
-	 Nb = 8 + 3*AC.NbIntervals(GeomAbs_CN);
+	Nb = 8 + 3*AC.NbIntervals(GeomAbs_CN);
-    }
+      }
   }
  
-  Standard_Real u, du, f, l, d;
+  if (TabP.IsNull()) {
-  f = AC.FirstParameter();
+    Standard_Real u, du, f, l, d;
-  l = AC.LastParameter();
+    f = AC.FirstParameter();
-  du = (l - f) / (Nb - 1);
+    l = AC.LastParameter();
-  for (ii = 1; ii <= Nb && B; ii++) {
+    du = (l-f)/(Nb-1);
-    u = (ii - 1)*du + f;
+    for (ii=1; ii<=Nb && B ; ii++) {
-    d = Plan.Distance(C->Value(u));
+      u = (ii-1)*du + f;
-    B = d < Tol;
+      d = Plan.Distance(C->Value(u));
+      B = (d < Tol); 
+    }
+  }
+  else {
+    B = Controle(TabP->Array1(), Plan, Tol);
   }
 
   return B;
@@ -154,6 +196,30 @@ 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 :
     {
@@ -233,7 +299,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,120 +4359,6 @@ 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) {
@@ -4580,10 +4466,6 @@ 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,10 +221,6 @@
 #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>
@@ -941,306 +937,6 @@ 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  : 
@@ -1265,36 +961,152 @@ 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.NbRootStyles();
+  Standard_Integer nb = Styles.NbStyles();
-  // apply root styles earlier, as they can be overridden
+  for (Standard_Integer i = 1; i <= nb; i++) {
-  // function IsOverriden for root style returns true only if it is overridden by other root style
+    Handle(StepVisual_StyledItem) style = Styles.Style(i);
-  Standard_Boolean anIsRootStyle = Standard_True;
+    if (style.IsNull()) continue;
-  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();
+    Standard_Boolean IsVisible = Standard_True;
-  // apply leaf styles, they can override root styles
+    // check the visibility of styled item.
-  anIsRootStyle = Standard_False;
+    for (Standard_Integer si = 1; si <= aHSeqOfInvisStyle->Length(); si++) {
-  for(Standard_Integer i = 1; i <= nb; i++)
+      if (style != aHSeqOfInvisStyle->Value(si))
-  {
+        continue;
-    Handle(StepVisual_StyledItem) Style = Styles.Style(i);
+      // found that current style is invisible.
-    // check that style is overridden
+      IsVisible = Standard_False;
-    if (!IsOverriden (aGraph, Style, anIsRootStyle))
+      break;
-    {
+    }
-      SetStyle (WS, myMap, CTool, STool, Styles, aHSeqOfInvisStyle, Style);
+
+    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);
+        }
+      }
     }
   }
-  
   CTool->ReverseChainsOfTreeNodes();
 
   // some colors can be attached to assemblies, propagate them to components

src/STEPConstruct/STEPConstruct_Styles.cxx

@@ -68,8 +68,6 @@
 #include <XSControl_TransferReader.hxx>
 #include <XSControl_TransferWriter.hxx>
 #include <XSControl_WorkSession.hxx>
-#include <StepVisual_ContextDependentOverRidingStyledItem.hxx>
-#include <StepShape_ShapeRepresentation.hxx>
 
 //=======================================================================
 //function : STEPConstruct_Styles
@@ -126,26 +124,6 @@ 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
@@ -156,7 +134,6 @@ void STEPConstruct_Styles::ClearStyles ()
 {
   myStyles.Clear();
   myPSA.Clear();
-  myRootStyles.Clear();
 }
 
 
@@ -367,15 +344,13 @@ 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);
@@ -389,26 +364,13 @@ Standard_Boolean STEPConstruct_Styles::LoadStyles ()
         Handle(StepVisual_StyledItem) style = 
           Handle(StepVisual_StyledItem)::DownCast ( container->ItemsValue(j) );
         if ( style.IsNull() ) continue;
-        auto anItem = style->ItemAP242 ().Value ();
+        myStyles.Add ( style );
-        if (!anItem.IsNull() && anItem->IsKind(tSR))
-        {
-          myRootStyles.Add (style);
-        }
-        else
-        {
-          myStyles.Add (style);
-        }
       }
     }
-    else if (enti->IsKind (STANDARD_TYPE(StepVisual_StyledItem)))
+    else if (enti->DynamicType() == tSI)
     {
       Handle(StepVisual_StyledItem) aStyledItem = Handle(StepVisual_StyledItem)::DownCast (enti);
-      auto anItem = aStyledItem->ItemAP242 ().Value ();
+      if (!myStyles.Contains (aStyledItem))
-      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,12 +69,6 @@ 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();
@@ -165,7 +159,6 @@ private:
 
   TColStd_IndexedDataMapOfTransientTransient myMapOfStyles;
   TColStd_IndexedMapOfTransient myStyles;
-  TColStd_IndexedMapOfTransient myRootStyles;
   TColStd_SequenceOfTransient myPSA;
 
 

src/STEPControl/STEPControl_Controller.cxx

@@ -239,7 +239,6 @@ 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,25 +753,7 @@ static void ReconstructMissedSeam(const TopTools_SequenceOfShape& theRemovedEdge
       if ((theUperiod != 0. && aUdiff > theUperiod/2) ||
           (theVperiod != 0. && aVdiff > theVperiod/2))
       {
-        if (aLastVertex.IsSame(theCurVertex) || (theUperiod != 0. && theVperiod != 0.))
+        anEdge.Reverse();
-        {
-          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);
@@ -2763,26 +2745,6 @@ 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
@@ -2804,7 +2766,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, aGMapFaceShells, aFreeBoundMap);
+    IntUnifyFaces(exps.Current(), aGMapEdgeFaces, aFreeBoundMap);
 
   // gather all faces out of shells in one compound and unify them at once
   BRep_Builder aBB;
@@ -2815,10 +2777,7 @@ 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);
 }
@@ -2841,52 +2800,13 @@ 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,
-                                                 const TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces,
+                                                 TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces,
-                                                 const DataMapOfShapeMapOfShape& theGMapFaceShells,
                                                  const TopTools_MapOfShape& theFreeBoundMap)
 {
   // creating map of edge faces for the shape
@@ -2935,9 +2855,6 @@ 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++) {
@@ -2986,15 +2903,6 @@ 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,7 +70,6 @@ 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();
@@ -169,8 +168,7 @@ protected:
   Standard_EXPORT void UnifyEdges();
 
   void IntUnifyFaces(const TopoDS_Shape& theInpShape,
-                     const TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces,
+                     TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces,
-                     const DataMapOfShapeMapOfShape& theGMapFaceShells,
                      const TopTools_MapOfShape& theFreeBoundMap);
 
   //! Splits the sequence of edges into the sequence of chains

src/XCAFDoc/XCAFDoc_ShapeTool.cxx

@@ -48,7 +48,6 @@
 #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")
 
@@ -1603,33 +1602,6 @@ 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,
@@ -1644,7 +1616,7 @@ static Standard_Boolean checkForShape (const TopoDS_Shape& theShape,
   aCompLoc = aCompLoc.Multiplied( theCurSh.Location() );
   aSupLoc = aSupLoc.Multiplied( aCompLoc );
   aCopySh.Location( aSupLoc, Standard_False );
-  if ( IsSame ( theShape, aCopySh ) ) {
+  if ( aCopySh.IsSame( theShape ) ) {
     theLabels.Prepend( theUserL );
     return Standard_True;
   }

tests/boolean/bopfuse_simple/ZP6

@@ -3,8 +3,6 @@
 #
 #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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,17 @@
+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,5 +1,3 @@
-puts "TODO ?CR33225 Windows: Failed class "
-
 pload QAcommands
 
 QANTestStlIterators

tests/bugs/fclasses/bug7287_1

@@ -1,4 +1,3 @@
-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,4 +1,3 @@
-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,4 +1,3 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -0,0 +1,18 @@
+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,12 +1,7 @@
-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,5 +1,4 @@
 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

@@ -0,0 +1,20 @@
+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,8 +3,6 @@ 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,5 +1,3 @@
-puts "TODO ?CR33225 Windows: extra characters after close-quote "
-
 puts "========"
 puts "OCC29293"
 puts "========"

tests/bugs/modalg_7/bug29843_1

@@ -0,0 +1,48 @@
+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

@@ -1,40 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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,9 +2,6 @@ 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

@@ -1,27 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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,5 +1,4 @@
 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

@@ -1,30 +0,0 @@
-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,3 +1,2 @@
 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 = 32  ( 32 )  N2Labels = 0  ( 0 )   TotalLabels = 37  ( 37 )   NameLabels = 36  ( 36 )   ColorLabels = 4  ( 4 )   LayerLabels = 0  ( 0 )
+LABELS      : N0Labels = 5  ( 5 )  N1Labels = 31  ( 31 )  N2Labels = 0  ( 0 )   TotalLabels = 36  ( 36 )   NameLabels = 36  ( 36 )   ColorLabels = 3  ( 3 )   LayerLabels = 0  ( 0 )
 PROPS       : Centroid = 0  ( 0 )  Volume   = 0  ( 0 )  Area     = 0  ( 0 )
-NCOLORS     : NColors  = 4  ( 4 )
+NCOLORS     : NColors  = 3  ( 3 )
-COLORS      : Colors   = CYAN GREEN RED YELLOW  ( CYAN GREEN RED YELLOW )
+COLORS      : Colors   = CYAN GREEN YELLOW  ( CYAN GREEN 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 = 32  ( 32 )  N2Labels = 0  ( 0 )   TotalLabels = 37  ( 37 )   NameLabels = 36  ( 36 )   ColorLabels = 4  ( 4 )   LayerLabels = 0  ( 0 )
+LABELS      : N0Labels = 5  ( 5 )  N1Labels = 31  ( 31 )  N2Labels = 0  ( 0 )   TotalLabels = 36  ( 36 )   NameLabels = 36  ( 36 )   ColorLabels = 3  ( 3 )   LayerLabels = 0  ( 0 )
 PROPS       : Centroid = 0  ( 0 )  Volume   = 0  ( 0 )  Area     = 0  ( 0 )
-NCOLORS     : NColors  = 4  ( 4 )
+NCOLORS     : NColors  = 3  ( 3 )
-COLORS      : Colors   = CYAN GREEN RED YELLOW  ( CYAN GREEN RED YELLOW )
+COLORS      : Colors   = CYAN GREEN YELLOW  ( CYAN GREEN YELLOW )
 NLAYERS     : NLayers  = 0  ( 0 )
 LAYERS      : Layers   =   (  )
 

tests/de_mesh/gltf_write/010

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,8 @@
+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.30139
+set length 6.30238
 
 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 7.9487, expected 8.05281"
+puts "TODO OCC30286 ALL: Error : The length of result shape is 8.06872, 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.40196
+set length 8.39744
 
 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.4452, expected 7.39488"
+puts "TODO OCC30286 ALL: Error : The length of result shape is 7.44464, 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.08401, expected 9.47163"
+puts "TODO OCC30286 ALL: Error : The length of result shape is 9.10542, 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.64618
+set length 7.64599
 
 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.30402
+set length 9.30381
 
 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 CR33225 Linux: 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"
 
 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/B6

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

tests/lowalgos/proximity/D4

@@ -1,29 +0,0 @@
-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/offset/faces_type_i/B3

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

tests/offset/faces_type_i/C8

@@ -1,6 +1,5 @@
 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,4 +1,5 @@
 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,6 +1,5 @@
 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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,19 @@
+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

tests/opengl/data/raytrace/sample_materials

@@ -0,0 +1,7 @@
+puts "============"
+puts "Visualization - Path Tracing, Materials sample"
+puts "============"
+puts ""
+
+source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_materials.tcl
+vdump $imagedir/${casename}_materials.png

tests/opengl/data/raytrace/tone_mapping

@@ -0,0 +1,14 @@
+puts "========"
+puts "Ray Tracing - check tone mapping"
+puts "========"
+
+source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_cube.tcl
+
+vrenderparams -ray -gi -rayDepth 10 -iss
+
+vrenderparams -tonemapping filmic
+vrenderparams -exposure -1.0
+vrenderparams -whitepoint 7.0
+vfit
+vfps 200
+vdump ${imagedir}/${casename}.png