0030510: Application Framework - add missing NULL check within TDataStd_RealArray::ChangeArray()

- Disable code introduced by fix for issue 28747, causing compilation failure

src/BOPTools/BOPTools_AlgoTools.cxx

@@ -617,46 +617,50 @@ TopAbs_State BOPTools_AlgoTools::ComputeState
   (const TopoDS_Face& theF,
    const TopoDS_Solid& theRef,
    const Standard_Real theTol,
-   TopTools_IndexedMapOfShape& theBounds,
+   const TopTools_IndexedMapOfShape& theBounds,
    const Handle(IntTools_Context)& theContext)
 {
-  TopAbs_State aState;
-  TopExp_Explorer aExp; 
-  TopoDS_Edge aE1;
-  gp_Pnt2d aP2D;
-  gp_Pnt aP3D; 
-  //
-  aState=TopAbs_UNKNOWN;
-  //
-  aExp.Init(theF, TopAbs_EDGE);
-  for (; aExp.More(); aExp.Next()) {
-    const TopoDS_Edge& aSE=(*(TopoDS_Edge*)(&aExp.Current()));
-    if (BRep_Tool::Degenerated(aSE)) {
+  TopAbs_State aState = TopAbs_UNKNOWN;
+
+  // Try to find the edge on the face which does not
+  // belong to the solid and classify the middle point of that
+  // edge relatively solid.
+  TopExp_Explorer aExp(theF, TopAbs_EDGE);
+  for (; aExp.More(); aExp.Next())
+  {
+    const TopoDS_Edge& aSE = (*(TopoDS_Edge*)(&aExp.Current()));
+    if (BRep_Tool::Degenerated(aSE))
       continue;
-    }
-    //
-    if (!theBounds.Contains(aSE)) {
-      const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aSE));
-      aState=BOPTools_AlgoTools::ComputeState(aE, theRef, theTol, 
-                                              theContext);
+
+    if (!theBounds.Contains(aSE))
+    {
+      aState = BOPTools_AlgoTools::ComputeState(aSE, theRef, theTol, theContext);
       return aState;
     }
-    if (aE1.IsNull()) {
-      aE1=(*(TopoDS_Edge*)(&aSE));
-    }
   }
-  // !!<- process edges that are all on theRef
-  if (!aE1.IsNull()) {
-    const Standard_Integer anErrID = BOPTools_AlgoTools3D::PointNearEdge(aE1, theF,
-                                                                         aP2D, aP3D,
-                                                                         theContext);
-    if(anErrID == 0)
+
+  // All edges of the face are on the solid.
+  // Get point inside the face and classify it relatively solid.
+  gp_Pnt aP3D;
+  gp_Pnt2d aP2D;
+  Standard_Integer iErr = BOPTools_AlgoTools3D::PointInFace(theF, aP3D, aP2D, theContext);
+  if (iErr != 0)
+  {
+    // Hatcher fails to find the point -> get point near some edge
+    aExp.Init(theF, TopAbs_EDGE);
+    for (; aExp.More() && iErr != 0; aExp.Next())
     {
-      aState = BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol,
-                                                theContext);
+      const TopoDS_Edge& aSE = TopoDS::Edge(aExp.Current());
+      if (BRep_Tool::Degenerated(aSE))
+        continue;
+
+      iErr = BOPTools_AlgoTools3D::PointNearEdge(aSE, theF, aP2D, aP3D, theContext);
     }
   }
-  //
+
+  if (iErr == 0)
+    aState = BOPTools_AlgoTools::ComputeState(aP3D, theRef, theTol, theContext);
+
   return aState;
 }
 //=======================================================================

src/BOPTools/BOPTools_AlgoTools.hxx

@@ -202,13 +202,13 @@ public: //! @name Point/Edge/Face classification relatively solid
   //! Computes the 3-D state of the face theFace
   //! toward solid theSolid.
   //! theTol - value of precision of computation
-  //! theBounds - set of edges of theFace to avoid
+  //! theBounds - set of edges of <theSolid> to avoid
   //! theContext- cahed geometrical tools
   //! Returns 3-D state.
   Standard_EXPORT static TopAbs_State ComputeState(const TopoDS_Face& theFace,
                                                    const TopoDS_Solid& theSolid,
                                                    const Standard_Real theTol,
-                                                   TopTools_IndexedMapOfShape& theBounds,
+                                                   const TopTools_IndexedMapOfShape& theBounds,
                                                    const Handle(IntTools_Context)& theContext);
   
   //! Computes the 3-D state of the shape theShape

src/BRepAlgo/BRepAlgo.cxx

@@ -421,9 +421,9 @@ TopoDS_Edge  BRepAlgo::ConcatenateWireC0(const TopoDS_Wire& aWire)
     isReverse = !IsFwdSeq(1);
   }
 
-  TopoDS_Vertex FirstVtx_final = (isReverse)? LastVertex : FirstVertex;
+  TopoDS_Vertex FirstVtx_final = FirstVertex;
   FirstVtx_final.Orientation(TopAbs_FORWARD);
-  TopoDS_Vertex LastVtx_final = (isReverse)? FirstVertex : LastVertex;
+  TopoDS_Vertex LastVtx_final = LastVertex;
   LastVtx_final.Orientation(TopAbs_REVERSED);
 
   if (CurveSeq.IsEmpty())

src/BRepCheck/BRepCheck.cxx

@@ -24,6 +24,11 @@
 #include <TopoDS_Face.hxx>
 #include <TopoDS_Iterator.hxx>
 #include <TopoDS_Wire.hxx>
+#include <Adaptor3d_Curve.hxx>
+#include <Adaptor3d_HSurface.hxx>
+#include <GeomAbs_CurveType.hxx>
+#include <GeomAbs_SurfaceType.hxx>
+#include <gp_Elips.hxx>
 
 //=======================================================================
 //function : Add
@@ -45,6 +50,7 @@ void BRepCheck::Add(BRepCheck_ListOfStatus& lst, const BRepCheck_Status stat)
   }
   lst.Append(stat);
 }
+
 //=======================================================================
 //function : SelfIntersection
 //purpose  : 
@@ -58,6 +64,67 @@ Standard_Boolean BRepCheck::SelfIntersection(const TopoDS_Wire& W,
   BRepCheck_Status stat = chkw->SelfIntersect(myFace,RetE1,RetE2);
   return (stat == BRepCheck_SelfIntersectingWire);
 }
+
+//=======================================================================
+//function : PrecCurve
+//purpose  : 
+//=======================================================================
+Standard_Real BRepCheck::PrecCurve(const Adaptor3d_Curve& aAC3D)
+{
+  Standard_Real aXEmax = RealEpsilon(); 
+  //
+  GeomAbs_CurveType aCT = aAC3D.GetType();
+  if (aCT==GeomAbs_Ellipse) {
+    Standard_Real aX[5];
+    //
+    gp_Elips aEL3D=aAC3D.Ellipse();
+    aEL3D.Location().Coord(aX[0], aX[1], aX[2]);
+    aX[3]=aEL3D.MajorRadius();
+    aX[4]=aEL3D.MinorRadius();
+    aXEmax=-1.;
+    for (Standard_Integer i = 0; i < 5; ++i) {
+      if (aX[i]<0.) {
+        aX[i]=-aX[i];
+      }
+      Standard_Real aXE = Epsilon(aX[i]);
+      if (aXE > aXEmax) {
+        aXEmax = aXE;
+      }
+    }
+  }//if (aCT=GeomAbs_Ellipse) {
+  //
+  return aXEmax;
+}
+
+//=======================================================================
+//function : PrecSurface
+//purpose  : 
+//=======================================================================
+Standard_Real BRepCheck::PrecSurface(const Handle(Adaptor3d_HSurface)& aAHSurf)
+{
+  Standard_Real aXEmax = RealEpsilon(); 
+  //
+  GeomAbs_SurfaceType aST = aAHSurf->GetType();
+  if (aST == GeomAbs_Cone) {
+    gp_Cone aCone=aAHSurf->Cone();
+    Standard_Real aX[4];
+    //
+    aCone.Location().Coord(aX[0], aX[1], aX[2]);
+    aX[3]=aCone.RefRadius();
+    aXEmax=-1.;
+    for (Standard_Integer i = 0; i < 4; ++i) {
+      if (aX[i] < 0.) {
+        aX[i] = -aX[i];
+      }
+      Standard_Real aXE = Epsilon(aX[i]);
+      if (aXE > aXEmax) {
+        aXEmax = aXE;
+      }
+    }
+  }//if (aST==GeomAbs_Cone) {
+  return aXEmax;
+}
+
 //=======================================================================
 //function : Print
 //purpose  : 

src/BRepCheck/BRepCheck.hxx

@@ -28,6 +28,8 @@
 class TopoDS_Wire;
 class TopoDS_Face;
 class TopoDS_Edge;
+class Adaptor3d_Curve;
+class Adaptor3d_HSurface;
 class BRepCheck_Result;
 class BRepCheck_Vertex;
 class BRepCheck_Edge;
@@ -53,6 +55,11 @@ public:
   
   Standard_EXPORT static Standard_Boolean SelfIntersection (const TopoDS_Wire& W, const TopoDS_Face& F, TopoDS_Edge& E1, TopoDS_Edge& E2);
 
+  //! Returns the resolution on the 3d curve
+  Standard_EXPORT static Standard_Real PrecCurve(const Adaptor3d_Curve& aAC3D);
+
+  //! Returns the resolution on the surface
+  Standard_EXPORT static Standard_Real PrecSurface(const Handle(Adaptor3d_HSurface)& aAHSurf);
 
 
 

src/BRepCheck/BRepCheck_Edge.cxx

@@ -77,10 +77,6 @@ static
 static
   Standard_Real Prec(const Adaptor3d_Curve& aAC3D,
   const Adaptor3d_CurveOnSurface& aACS);
-static
-  Standard_Real PrecCurve(const Adaptor3d_Curve& aAC3D);
-static
-  Standard_Real PrecSurface(const Adaptor3d_CurveOnSurface& aACS);
 
 //static Standard_Boolean Validate(const Adaptor3d_Curve&,
 //				 const Adaptor3d_Curve&,
@@ -898,87 +894,23 @@ Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
   return Status ;
 
 }
+
 //=======================================================================
 //function : Prec
 //purpose  : 
 //=======================================================================
 Standard_Real Prec(const Adaptor3d_Curve& aAC3D,
-  const Adaptor3d_CurveOnSurface& aACS)
+                   const Adaptor3d_CurveOnSurface& aACS)
 {
   Standard_Real aXEmax, aXC, aXS;
+  const Handle(Adaptor3d_HSurface)& aAHS = aACS.GetSurface();
   //
-  aXC=PrecCurve(aAC3D);
-  aXS=PrecSurface(aACS);
-  aXEmax=(aXC>aXS) ? aXC: aXS;
-  return aXEmax;
-}
-//=======================================================================
-//function : PrecCurve
-//purpose  : 
-//=======================================================================
-Standard_Real PrecCurve(const Adaptor3d_Curve& aAC3D)
-{
-  Standard_Real aXEmax;
-  GeomAbs_CurveType aCT;
-  //
-  aXEmax=RealEpsilon(); 
-  //
-  aCT=aAC3D.GetType();
-  if (aCT==GeomAbs_Ellipse) {
-    Standard_Integer i;
-    Standard_Real aX[5], aXE;
-    //
-    gp_Elips aEL3D=aAC3D.Ellipse();
-    aEL3D.Location().Coord(aX[0], aX[1], aX[2]);
-    aX[3]=aEL3D.MajorRadius();
-    aX[4]=aEL3D.MinorRadius();
-    aXEmax=-1.;
-    for (i=0; i<5; ++i) {
-      if (aX[i]<0.) {
-        aX[i]=-aX[i];
-      }
-      aXE=Epsilon(aX[i]);
-      if (aXE>aXEmax) {
-        aXEmax=aXE;
-      }
-    }
-  }//if (aCT=GeomAbs_Ellipse) {
-  //
-  return aXEmax;
-}
-//=======================================================================
-//function : PrecSurface
-//purpose  : 
-//=======================================================================
-Standard_Real PrecSurface(const Adaptor3d_CurveOnSurface& aACS)
-{
-  Standard_Real aXEmax;
-  GeomAbs_SurfaceType aST;
-  //
-  aXEmax=RealEpsilon(); 
-  //
-  const Handle(Adaptor3d_HSurface)& aAHS=aACS.GetSurface();
-  aST=aAHS->GetType();
-  if (aST==GeomAbs_Cone) {
-    gp_Cone aCone=aAHS->Cone();
-    Standard_Integer i;
-    Standard_Real aX[4], aXE;
-    //
-    aCone.Location().Coord(aX[0], aX[1], aX[2]);
-    aX[3]=aCone.RefRadius();
-    aXEmax=-1.;
-    for (i=0; i<4; ++i) {
-      if (aX[i]<0.) {
-        aX[i]=-aX[i];
-      }
-      aXE=Epsilon(aX[i]);
-      if (aXE>aXEmax) {
-        aXEmax=aXE;
-      }
-    }
-  }//if (aST==GeomAbs_Cone) {
+  aXC = BRepCheck::PrecCurve(aAC3D);
+  aXS = BRepCheck::PrecSurface(aAHS);
+  aXEmax = (aXC>aXS) ? aXC: aXS;
   return aXEmax;
 }
+
 //=======================================================================
 //function : PrintProblematicPoint
 //purpose  : 

src/BRepFill/BRepFill_Pipe.cxx

@@ -62,6 +62,7 @@
 #include <TopoDS_Vertex.hxx>
 #include <TopoDS_Wire.hxx>
 #include <TopTools_DataMapOfShapeInteger.hxx>
+#include <TopTools_DataMapOfIntegerShape.hxx>
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 #include <TopTools_SequenceOfShape.hxx>
 
@@ -250,7 +251,7 @@ void BRepFill_Pipe::Perform(const TopoDS_Wire&  Spine,
   TopoDS_Shape aux;
   TheProf =  myProfile;
   TheProf.Location(Loc2.Multiplied(Loc1));
- 
+
   // Construct First && Last Shape
   Handle(GeomFill_LocationLaw) law;
 
@@ -307,7 +308,7 @@ void BRepFill_Pipe::Perform(const TopoDS_Wire&  Spine,
  }
 #endif
  
-  myShape = MakeShape(TheProf, myFirst, myLast);
+  myShape = MakeShape(TheProf, myProfile, myFirst, myLast);
 }
 
 
@@ -382,36 +383,8 @@ void BRepFill_Pipe::Generated(const TopoDS_Shape&   theShape,
 {
   theList.Clear();
 
-  if (theShape.IsSame(myProfile))
-    theList.Append(myShape);
-  else
-  {
-    if (theShape.ShapeType() == TopAbs_FACE ||
-        theShape.ShapeType() == TopAbs_WIRE)
-    {
-      if(myGenMap.IsBound(theShape))
-        theList = myGenMap.Find(theShape);
-    }
-    else if (theShape.ShapeType() == TopAbs_EDGE)
-    {
-      TopoDS_Iterator itw(mySpine);
-      for (; itw.More(); itw.Next())
-      {
-        const TopoDS_Edge& aSpineEdge = TopoDS::Edge(itw.Value());
-        const TopoDS_Shape& aFace = Face(aSpineEdge, TopoDS::Edge(theShape));
-        theList.Append(aFace);
-      }
-    }
-    else if (theShape.ShapeType() == TopAbs_VERTEX)
-    {
-      TopoDS_Iterator itw(mySpine);
-      for (; itw.More(); itw.Next())
-      {
-        const TopoDS_Edge& aSpineEdge = TopoDS::Edge(itw.Value());
-        const TopoDS_Shape& anEdge = Edge(aSpineEdge, TopoDS::Vertex(theShape));
-        theList.Append(anEdge);
-      }
-    }
+  if(myGenMap.IsBound(theShape)) {
+    theList = myGenMap.Find(theShape);
   }
 }
 
@@ -540,9 +513,9 @@ TopoDS_Wire BRepFill_Pipe::PipeLine(const gp_Pnt& Point)
  P = Point;
  P.Transform(myTrsf);
 
- BRepLib_MakeVertex MkV(P); 
+ TopoDS_Vertex VertexSection = BRepLib_MakeVertex(P); 
  Handle(BRepFill_ShapeLaw) Section = 
-	new (BRepFill_ShapeLaw) (MkV.Vertex());
+	new (BRepFill_ShapeLaw) (VertexSection);
 
  // Sweeping
  BRepFill_Sweep MkSw(Section, myLoc, Standard_True);
@@ -551,6 +524,7 @@ TopoDS_Wire BRepFill_Pipe::PipeLine(const gp_Pnt& Point)
              BRepFill_Modified, myContinuity, GeomFill_Location, myDegmax, mySegmax );
  TopoDS_Shape aLocalShape = MkSw.Shape();
  myErrorOnSurf = MkSw.ErrorOnSurface();
+ BuildHistory(MkSw, VertexSection);
  return TopoDS::Wire(aLocalShape);
 // return TopoDS::Wire(MkSw.Shape());
 }
@@ -561,6 +535,7 @@ TopoDS_Wire BRepFill_Pipe::PipeLine(const gp_Pnt& Point)
 //=======================================================================
 
 TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
+                                      const TopoDS_Shape& theOriginalS,
 				      const TopoDS_Shape& FirstShape,
 				      const TopoDS_Shape& LastShape)
 {
@@ -574,6 +549,8 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
   TheLast = LastShape;
   if (! myFaces.IsNull()) InitialLength = myFaces->ColLength();
 
+  TopLoc_Location BackLoc(myTrsf.Inverted());
+
   // there are two kinds of generation
   //  1. generate with S from each Filler (Vertex, Edge)
   //  2. call MakeShape recursively on the subshapes of S
@@ -658,13 +635,15 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
     if (!TheFirst.IsNull()) itFirst.Initialize(TheFirst);
     if (!TheLast.IsNull()) itLast.Initialize(TheLast);
 
-    for (TopoDS_Iterator it(S); it.More(); it.Next()) {
+    TopoDS_Iterator it(S);
+    TopoDS_Iterator itorig(theOriginalS);
+    for (; it.More(); it.Next(),itorig.Next()) {
       if (!TheFirst.IsNull()) first = itFirst.Value();
       if (!TheLast.IsNull())  last = itLast.Value();
       if (TheS.ShapeType() == TopAbs_FACE ) 
-	MakeShape(it.Value(), first, last);
+	MakeShape(it.Value(), itorig.Value(), first, last);
       else
-	B.Add(result,MakeShape(it.Value(), first, last));
+	B.Add(result,MakeShape(it.Value(), itorig.Value(), first, last));
 
       if (!TheFirst.IsNull()) itFirst.Next();
       if (!TheLast.IsNull())  itLast.Next();
@@ -680,7 +659,7 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
       MkSw.Build( myReversedEdges, myTapes, myRails,
                   BRepFill_Modified, myContinuity, GeomFill_Location, myDegmax, mySegmax );
       result = MkSw.Shape();
-      UpdateMap(TheS.Located(myProfile.Location()), result, myGenMap);
+      UpdateMap(theOriginalS, result, myGenMap);
       myErrorOnSurf = MkSw.ErrorOnSurface();
 
       Handle(TopTools_HArray2OfShape) aSections = MkSw.Sections();
@@ -691,6 +670,8 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
         myFirst = aSections->Value(1, 1);
         myLast  = aSections->Value(1, aVLast);
       }
+
+      BuildHistory(MkSw, theOriginalS);
     }
 
     if (TheS.ShapeType() == TopAbs_WIRE ) {
@@ -703,7 +684,6 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
       MkSw.Build( myReversedEdges, myTapes, myRails,
                   BRepFill_Modified, myContinuity, GeomFill_Location, myDegmax, mySegmax );
       result = MkSw.Shape();
-      UpdateMap(TheS.Located(myProfile.Location()), result, myGenMap);
       myErrorOnSurf = MkSw.ErrorOnSurface();
 
       // Labeling of elements
@@ -762,6 +742,8 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
 
 	myEdges = Somme;
       }
+
+      BuildHistory(MkSw, theOriginalS);
     }
   }
       
@@ -808,7 +790,7 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
       BS.Add(solid,TopoDS::Shell(aLocalShape));
 //      BS.Add(solid,TopoDS::Shell(result.Reversed()));
     }
-    UpdateMap(TheS.Located(myProfile.Location()), solid, myGenMap);
+    UpdateMap(theOriginalS, solid, myGenMap);
     return solid;
   }
   else {
@@ -1030,3 +1012,110 @@ void BRepFill_Pipe::RebuildTopOrBottomFace(const TopoDS_Shape& aFace,
     }
   }
 }
+
+//=======================================================================
+//function : BuildHistory
+//purpose  : Builds history for edges and vertices
+//           of section and path
+//=======================================================================
+void BRepFill_Pipe::BuildHistory(const BRepFill_Sweep& theSweep,
+                                 const TopoDS_Shape&   theSection)
+{
+  //Filling of <myGenMap>
+  const Handle(TopTools_HArray2OfShape)& anUEdges = theSweep.InterFaces();
+  
+  Standard_Integer inde;
+  TopoDS_Iterator itw;
+
+  if (theSection.ShapeType() == TopAbs_WIRE)
+  {
+    TopoDS_Wire aSection = TopoDS::Wire(theSection);
+    BRepTools_WireExplorer wexp_sec(aSection);
+    for (inde = 0; wexp_sec.More(); wexp_sec.Next())
+    {
+      inde++;
+      const TopoDS_Edge& anEdge = TopoDS::Edge(wexp_sec.Current());
+      if (BRep_Tool::Degenerated(anEdge))
+        continue;
+      if (myGenMap.IsBound(anEdge))
+        continue;
+      
+      TopoDS_Vertex aVertex [2];
+      TopExp::Vertices(anEdge, aVertex[0], aVertex[1]);
+      
+      //For an edge generated shape is a "tape" -
+      //a shell usually containing this edge and
+      //passing from beginning of path to its end
+      TopoDS_Shell aTape = TopoDS::Shell(theSweep.Tape(inde));
+      
+      //Processing of vertices of <anEdge>
+      //We should choose right index in <anUEdges>
+      //for each vertex of edge 
+      Standard_Integer UIndex [2];
+      UIndex[0] = inde;
+      UIndex[1] = inde+1;
+      
+      if (anEdge.Orientation() == TopAbs_REVERSED)
+      { Standard_Integer Tmp = UIndex[0]; UIndex[0] = UIndex[1]; UIndex[1] = Tmp; }
+      
+      for (Standard_Integer kk = 0; kk < 2; kk++)
+      {
+        if (myGenMap.IsBound(aVertex[kk]))
+          continue;
+        
+        //Assemble the list of edges ("rail" along the path)
+        TopTools_ListOfShape* Elist = myGenMap.Bound(aVertex[kk], TopTools_ListOfShape());
+        Standard_Integer jj;
+        for (jj = 1; jj <= anUEdges->UpperCol(); jj++)
+        {
+          const TopoDS_Shape& anUedge = anUEdges->Value(UIndex[kk], jj);
+          if (!anUedge.IsNull())
+            Elist->Append(anUedge);
+        }
+      } //for (Standard_Integer kk = 0; kk < 2; kk++)
+      
+      TopTools_ListOfShape* Flist = myGenMap.Bound(anEdge, TopTools_ListOfShape());
+      TopoDS_Iterator itsh(aTape);
+      for (; itsh.More(); itsh.Next())
+        Flist->Append(itsh.Value());
+    } //for (inde = 0; wexp_sec.More(); wexp_sec.Next())
+  } //if (theSection.ShapeType() == TopAbs_WIRE)
+
+  //For subshapes of spine
+  const Handle(TopTools_HArray2OfShape)& aFaces  = theSweep.SubShape();
+  const Handle(TopTools_HArray2OfShape)& aVEdges = theSweep.Sections();
+  
+  BRepTools_WireExplorer wexp(mySpine);
+  inde = 0;
+  Standard_Boolean ToExit = Standard_False;
+  for (;;)
+  {
+    if (!wexp.More())
+      ToExit = Standard_True;
+    
+    inde++;
+
+    if (!ToExit)
+    {
+      const TopoDS_Edge& anEdgeOfSpine = wexp.Current();
+      for (Standard_Integer i = 1; i <= aFaces->UpperRow(); i++)
+      {
+        const TopoDS_Shape& aFace = aFaces->Value(i, inde);
+        UpdateMap(anEdgeOfSpine, aFace, myGenMap);
+      }
+    }
+    
+    const TopoDS_Vertex& aVertexOfSpine = wexp.CurrentVertex();
+    for (Standard_Integer i = 1; i <= aVEdges->UpperRow(); i++)
+    {
+      const TopoDS_Shape& aVedge = aVEdges->Value(i, inde);
+      UpdateMap(aVertexOfSpine, aVedge, myGenMap);
+    }
+
+    if (ToExit)
+      break;
+
+    if (wexp.More())
+      wexp.Next();
+  }
+}

src/BRepFill/BRepFill_Pipe.hxx

@@ -42,6 +42,7 @@ class TopoDS_Face;
 class TopoDS_Edge;
 class TopoDS_Vertex;
 class gp_Pnt;
+class BRepFill_Sweep;
 
 
 //! Create a  shape by sweeping a shape  (the profile)
@@ -59,9 +60,15 @@ public:
   
   Standard_EXPORT BRepFill_Pipe();
   
-  Standard_EXPORT BRepFill_Pipe(const TopoDS_Wire& Spine, const TopoDS_Shape& Profile, const GeomFill_Trihedron aMode = GeomFill_IsCorrectedFrenet, const Standard_Boolean ForceApproxC1 = Standard_False, const Standard_Boolean GeneratePartCase = Standard_False);
+  Standard_EXPORT BRepFill_Pipe(const TopoDS_Wire& Spine,
+                                const TopoDS_Shape& Profile,
+                                const GeomFill_Trihedron aMode = GeomFill_IsCorrectedFrenet,
+                                const Standard_Boolean ForceApproxC1 = Standard_False,
+                                const Standard_Boolean GeneratePartCase = Standard_False);
   
-  Standard_EXPORT void Perform (const TopoDS_Wire& Spine, const TopoDS_Shape& Profile, const Standard_Boolean GeneratePartCase = Standard_False);
+  Standard_EXPORT void Perform (const TopoDS_Wire& Spine,
+                                const TopoDS_Shape& Profile,
+                                const Standard_Boolean GeneratePartCase = Standard_False);
   
   Standard_EXPORT const TopoDS_Shape& Spine() const;
   
@@ -113,22 +120,27 @@ private:
   
   //! Auxiliary  recursive  method  used  to  build  the
   //! result.
-  Standard_EXPORT TopoDS_Shape MakeShape (const TopoDS_Shape& S, const TopoDS_Shape& FirstShape, const TopoDS_Shape& LastShape);
+  Standard_EXPORT TopoDS_Shape MakeShape (const TopoDS_Shape& S,
+                                          const TopoDS_Shape& theOriginalS,
+                                          const TopoDS_Shape& FirstShape,
+                                          const TopoDS_Shape& LastShape);
   
   //! Auxiliary recursive method used to find the edge's index
-  Standard_EXPORT Standard_Integer FindEdge (const TopoDS_Shape& S, const TopoDS_Edge& E, Standard_Integer& Init) const;
+  Standard_EXPORT Standard_Integer FindEdge (const TopoDS_Shape& S,
+                                             const TopoDS_Edge& E,
+                                             Standard_Integer& Init) const;
   
-  Standard_EXPORT Standard_Integer FindVertex (const TopoDS_Shape& S, const TopoDS_Vertex& V, Standard_Integer& Init) const;
+  Standard_EXPORT Standard_Integer FindVertex (const TopoDS_Shape& S, const
+                                               TopoDS_Vertex& V,
+                                               Standard_Integer& Init) const;
   
   Standard_EXPORT void DefineRealSegmax();
   
-  Standard_EXPORT void RebuildTopOrBottomFace (const TopoDS_Shape& aFace, const Standard_Boolean IsTop) const;
+  Standard_EXPORT void RebuildTopOrBottomFace (const TopoDS_Shape& aFace,
+                                               const Standard_Boolean IsTop) const;
   
-  //! Performs sharing coincident faces in theShape. Also modifies
-  //! myFaces, mySections and myEdges to contain shared shapes.
-  //! Returns the shared shape. If theShape is not modified this
-  //! method returns it.
-  Standard_EXPORT TopoDS_Shape ShareFaces (const TopoDS_Shape& theShape, const Standard_Integer theInitialFacesLen, const Standard_Integer theInitialEdgesLen, const Standard_Integer theInitialSectionsLen);
+  Standard_EXPORT void BuildHistory (const BRepFill_Sweep& theSweep,
+                                     const TopoDS_Shape&   theSection);
 
 
   TopoDS_Wire mySpine;

src/BRepFill/BRepFill_PipeShell.cxx

@@ -1203,8 +1203,8 @@ void BRepFill_PipeShell::Place(const BRepFill_Section& Sec,
 
 //=======================================================================
 //function : BuildHistory
-//purpose  : Builds history for edges and vertices 
-//           of sections
+//purpose  : Builds history for edges and vertices of sections,
+//           for edges and vertices of spine
 //=======================================================================
 void BRepFill_PipeShell::BuildHistory(const BRepFill_Sweep& theSweep) 
 {
@@ -1226,11 +1226,11 @@ void BRepFill_PipeShell::BuildHistory(const BRepFill_Sweep& theSweep)
       //for punctual sections (first or last)
       //we take all the wires generated along the path
       
-      TopTools_ListOfShape Elist;
+      TopTools_ListOfShape* Elist = myGenMap.Bound(Section, TopTools_ListOfShape());
       for (Standard_Integer i = 1; i <= anUEdges->UpperRow(); i++)
         for (Standard_Integer j = 1; j <= anUEdges->UpperCol(); j++)
-          Elist.Append(anUEdges->Value(i,j));
-      myGenMap.Bind(Section, Elist);
+          Elist->Append(anUEdges->Value(i,j));
+
       continue;
     }
     else
@@ -1319,9 +1319,11 @@ void BRepFill_PipeShell::BuildHistory(const BRepFill_Sweep& theSweep)
           continue;
         if (IndWireMap.IsBound(UIndex[kk]))
         {
-          TopTools_ListOfShape Wlist;
-          Wlist.Append(IndWireMap(UIndex[kk]));
-          myGenMap.Bind(aVertex[kk], Wlist);
+          TopTools_ListOfShape* Elist = myGenMap.Bound(aVertex[kk], TopTools_ListOfShape());
+          
+          for (itw.Initialize( IndWireMap(UIndex[kk]) ); itw.More(); itw.Next())
+            Elist->Append(itw.Value());
+          
           continue;
         }
         
@@ -1393,22 +1395,88 @@ void BRepFill_PipeShell::BuildHistory(const BRepFill_Sweep& theSweep)
             }
           }
         }
-        TopTools_ListOfShape Wlist;
-        Wlist.Append(aWire);
-        myGenMap.Bind(aVertex[kk], Wlist);
+
+        TopTools_ListOfShape* Elist = myGenMap.Bound(aVertex[kk], TopTools_ListOfShape());
+
+        for (itw.Initialize(aWire); itw.More(); itw.Next())
+          Elist->Append(itw.Value());
+        
         //Save already built wire with its index
         IndWireMap.Bind(UIndex[kk], aWire);
       } //for (Standard_Integer kk = 0; kk < 2; kk++)
       ////////////////////////////////////
       
-      TopTools_ListOfShape ListShell;
-      ListShell.Append(aShell);
-      myGenMap.Bind(anOriginalEdge, ListShell);
+      TopTools_ListOfShape* Flist = myGenMap.Bound(anOriginalEdge, TopTools_ListOfShape());
+      TopoDS_Iterator itsh(aShell);
+      for (; itsh.More(); itsh.Next())
+        Flist->Append(itsh.Value());
       ////////////////////////
 
       inde++;
     }
   }
+
+  //For subshapes of spine
+  const Handle(TopTools_HArray2OfShape)& aFaces  = theSweep.SubShape();
+  const Handle(TopTools_HArray2OfShape)& aVEdges = theSweep.Sections();
+  
+  BRepTools_WireExplorer wexp(mySpine);
+  inde = 0;
+  Standard_Boolean ToExit = Standard_False;
+  for (;;)
+  {
+    if (!wexp.More())
+      ToExit = Standard_True;
+    
+    inde++;
+
+    if (!ToExit)
+    {
+      const TopoDS_Edge& anEdgeOfSpine = wexp.Current();
+      
+      TopTools_ListOfShape* Flist = myGenMap.Bound(anEdgeOfSpine, TopTools_ListOfShape());
+      
+      for (Standard_Integer i = 1; i <= aFaces->UpperRow(); i++)
+      {
+        const TopoDS_Shape& aFace = aFaces->Value(i, inde);
+        if (aFace.ShapeType() == TopAbs_FACE)
+          Flist->Append(aFace);
+      }
+    }
+    
+    const TopoDS_Vertex& aVertexOfSpine = wexp.CurrentVertex();
+    TopTools_ListOfShape* ListVshapes = myGenMap.Bound(aVertexOfSpine, TopTools_ListOfShape());
+    for (Standard_Integer i = 1; i <= aVEdges->UpperRow(); i++)
+    {
+      const TopoDS_Shape& aVshape = aVEdges->Value(i, inde);
+      if (aVshape.ShapeType() == TopAbs_EDGE ||
+          aVshape.ShapeType() == TopAbs_FACE)
+        ListVshapes->Append(aVshape);
+      else
+      {
+        TopoDS_Iterator itvshape(aVshape);
+        for (; itvshape.More(); itvshape.Next())
+        {
+          const TopoDS_Shape& aSubshape = itvshape.Value();
+          if (aSubshape.ShapeType() == TopAbs_EDGE ||
+              aSubshape.ShapeType() == TopAbs_FACE)
+            ListVshapes->Append(aSubshape);
+          else
+          {
+            //it is wire
+            for (itw.Initialize(aSubshape); itw.More(); itw.Next())
+              ListVshapes->Append(itw.Value());
+          }
+        }
+      }
+    }
+
+    if (ToExit)
+      break;
+
+    if (wexp.More())
+      wexp.Next();
+  }
 }
 
 

src/BRepFill/BRepFill_PipeShell.hxx

@@ -192,6 +192,12 @@ public:
       theProfiles.Append(mySeq(i).OriginalShape());
   }
 
+  //! Returns the spine
+  const TopoDS_Wire& Spine()
+  {
+    return mySpine;
+  }
+
   //! Returns the  list   of shapes generated   from the
   //! shape <S>.
   Standard_EXPORT void Generated (const TopoDS_Shape& S, TopTools_ListOfShape& L);

src/BRepFill/BRepFill_Sweep.cxx

@@ -2938,9 +2938,10 @@ void BRepFill_Sweep::Build(TopTools_MapOfShape& ReversedEdges,
     // Management of looping ends
     if ( (NbTrous>0) && (myLoc->IsClosed()) &&
 	 (Trous->Value(NbTrous) == NbPath+1) ) {
-      Translate(myVEdges,  NbPath+1, Bounds, 1);
-      Translate(myVEdges,  1, Bounds, 2);
+      Translate(myVEdges, NbPath+1, Bounds, 1);
+      Translate(myVEdges, 1, Bounds, 2);
       PerformCorner(1, Transition, Bounds); 
+      Translate(myVEdges, 1, myVEdges, NbPath+1);
     }
 
     // Construction of the shell
@@ -3038,7 +3039,8 @@ void BRepFill_Sweep::Build(TopTools_MapOfShape& ReversedEdges,
       for (jj = myUEdges->LowerCol(); jj <= myUEdges->UpperCol(); jj++)
       {
 	TopoDS_Edge anEdge = TopoDS::Edge(myUEdges->Value(ii, jj));
-        if (anEdge.IsNull())
+        if (anEdge.IsNull() ||
+            BRep_Tool::Degenerated(anEdge))
           continue;
         TopoDS_Face Face1, Face2;
         Standard_Integer i1 = ii-1, i2 = ii;
@@ -3047,10 +3049,19 @@ void BRepFill_Sweep::Build(TopTools_MapOfShape& ReversedEdges,
         if (i2 > myFaces->UpperRow())
           i2 = 0;
         if (i1 != 0)
-          Face1 = TopoDS::Face(myFaces->Value(i1, jj));
+        {
+          const TopoDS_Shape& aShape1 = myFaces->Value(i1, jj);
+          if (aShape1.ShapeType() == TopAbs_FACE)
+            Face1 = TopoDS::Face(aShape1);
+        }
         if (i2 != 0)
-          Face2 = TopoDS::Face(myFaces->Value(i2, jj));
-        CorrectSameParameter(anEdge, Face1, Face2);
+        {
+          const TopoDS_Shape& aShape2 = myFaces->Value(i2, jj);
+          if (aShape2.ShapeType() == TopAbs_FACE)
+            Face2 = TopoDS::Face(aShape2);
+        }
+        if (!Face1.IsNull() && !Face2.IsNull())
+          CorrectSameParameter(anEdge, Face1, Face2);
       }
     }
 
@@ -3263,10 +3274,27 @@ TopoDS_Shape BRepFill_Sweep::Tape(const Standard_Integer Index) const
   BRepFill_TrimShellCorner aTrim(aFaces, Transition, AxeOfBisPlane);
   aTrim.AddBounds(Bounds);
   aTrim.AddUEdges(aUEdges);
+  aTrim.AddVEdges(myVEdges, Index);
   aTrim.Perform();
 
   if (aTrim.IsDone()) {
+
     TopTools_ListOfShape listmodif;
+    for (ii = 1; ii <= mySec->NbLaw(); ii++)
+    {
+      listmodif.Clear();
+      aTrim.Modified(myVEdges->Value(ii, Index), listmodif);
+      
+      if (listmodif.IsEmpty())
+      {
+        TopoDS_Edge NullEdge;
+        myVEdges->SetValue(ii, Index, NullEdge);
+      }
+      else
+        myVEdges->SetValue(ii, Index, listmodif.First());
+    }
+    
+    listmodif.Clear();
     Standard_Integer iit = 0;
 
     for(iit = 0; iit < 2; iit++) {
@@ -3353,8 +3381,15 @@ TopoDS_Shape BRepFill_Sweep::Tape(const Standard_Integer Index) const
 	  
 	  if (B) {
 	    myAuxShape.Append(FF);
-	    myVEdges->ChangeValue(ii, I2) = FF;
             BRep_Builder BB;
+            TopoDS_Shape aVshape = myVEdges->Value(ii, I2);
+            TopoDS_Compound aCompound;
+            BB.MakeCompound(aCompound);
+            if (!aVshape.IsNull())
+              BB.Add(aCompound, aVshape);
+            BB.Add(aCompound, FF);
+            myVEdges->ChangeValue(ii, I2) = aCompound;
+            
             BB.Add(myTapes->ChangeValue(ii), FF);
 	    HasFilling = Standard_True;
 	  }

src/BRepFill/BRepFill_TrimShellCorner.cxx

@@ -91,6 +91,11 @@ static Standard_Boolean SplitUEdges(const Handle(TopTools_HArray2OfShape)&     t
                                     const BOPDS_PDS&                           theDS,
                                     TopTools_DataMapOfShapeListOfShape&        theHistMap);
 
+static void StoreVedgeInHistMap(const Handle(TopTools_HArray1OfShape)&     theVEdges,
+                                const Standard_Integer                     theIndex,
+                                const TopoDS_Shape&                        theNewVedge,
+                                TopTools_DataMapOfShapeListOfShape&        theHistMap);
+
 static void FindFreeVertices(const TopoDS_Shape&         theShape,
                              const TopTools_MapOfShape&  theVerticesToAvoid,
                              TopTools_ListOfShape&       theListOfVertex);
@@ -229,6 +234,19 @@ void BRepFill_TrimShellCorner::AddUEdges(const Handle(TopTools_HArray2OfShape)&
   myUEdges->ChangeArray2() = theUEdges->Array2();
 }
 
+// ===========================================================================================
+// function: AddVEdges
+// purpose:
+// ===========================================================================================
+void BRepFill_TrimShellCorner::AddVEdges(const Handle(TopTools_HArray2OfShape)& theVEdges,
+                                         const Standard_Integer theIndex)
+{
+  myVEdges = new TopTools_HArray1OfShape(theVEdges->LowerRow(), theVEdges->UpperRow());
+
+  for (Standard_Integer i = theVEdges->LowerRow(); i <= theVEdges->UpperRow(); i++)
+    myVEdges->SetValue(i, theVEdges->Value(i, theIndex));
+}
+
 // ===========================================================================================
 // function: Perform
 // purpose:
@@ -479,9 +497,12 @@ BRepFill_TrimShellCorner::MakeFacesNonSec(const Standard_Integer
       aMapV.Add(aV);
       aBB.Add(aComp, aUE);
     }
+    
     if(bHasNewEdge) {
       aBB.Add(aComp, aNewEdge);
+      StoreVedgeInHistMap(myVEdges, theIndex, aNewEdge, myHistMap);
     }
+    
     TopTools_ListOfShape alonevertices;
     FindFreeVertices(aComp, aMapV, alonevertices);
 
@@ -686,6 +707,8 @@ BRepFill_TrimShellCorner::MakeFacesSec(const Standard_Integer
     for (; explo.More(); explo.Next())
       BB.Add( aComp, explo.Current() );
     aSecEdges = aComp;
+
+    StoreVedgeInHistMap(myVEdges, theIndex, SecWire, myHistMap);
   }
 
   TopTools_ListOfShape aCommonVertices;
@@ -1123,6 +1146,22 @@ Standard_Boolean SplitUEdges(const Handle(TopTools_HArray2OfShape)&     theUEdge
   return Standard_True;
 }
 
+// ------------------------------------------------------------------------------------------
+// static function: StoreVedgeInHistMap
+// purpose:
+// ------------------------------------------------------------------------------------------
+void StoreVedgeInHistMap(const Handle(TopTools_HArray1OfShape)&     theVEdges,
+                         const Standard_Integer                     theIndex,
+                         const TopoDS_Shape&                        theNewVshape,
+                         TopTools_DataMapOfShapeListOfShape&        theHistMap)
+{
+  //Replace default value in the map (v-iso edge of face)
+  //by intersection of two consecutive faces
+  const TopoDS_Shape& aVEdge = theVEdges->Value(theIndex);
+
+  theHistMap.Bound(aVEdge, TopTools_ListOfShape())->Append(theNewVshape);
+}
+
 // ------------------------------------------------------------------------------------------
 // static function: FindFreeVertices
 // purpose:

src/BRepFill/BRepFill_TrimShellCorner.hxx

@@ -26,6 +26,7 @@
 #include <TopoDS_Wire.hxx>
 #include <TopoDS_Face.hxx>
 #include <TopTools_HArray2OfShape.hxx>
+#include <TopTools_HArray1OfShape.hxx>
 #include <Standard_Boolean.hxx>
 #include <TopTools_DataMapOfShapeListOfShape.hxx>
 #include <TopTools_ListOfShape.hxx>
@@ -55,6 +56,9 @@ public:
   
   Standard_EXPORT void AddUEdges (const Handle(TopTools_HArray2OfShape)& theUEdges);
   
+  Standard_EXPORT void AddVEdges (const Handle(TopTools_HArray2OfShape)& theVEdges,
+                                  const Standard_Integer theIndex);
+  
   Standard_EXPORT void Perform();
   
   Standard_EXPORT Standard_Boolean IsDone() const;
@@ -99,6 +103,7 @@ private:
   TopoDS_Shape myShape2;
   Handle(TopTools_HArray2OfShape) myBounds;
   Handle(TopTools_HArray2OfShape) myUEdges;
+  Handle(TopTools_HArray1OfShape) myVEdges;
   Handle(TopTools_HArray2OfShape) myFaces;
   Standard_Boolean myDone;
   Standard_Boolean myHasSection;

src/BRepLib/BRepLib.cxx

@@ -29,6 +29,7 @@
 #include <BRep_GCurve.hxx>
 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
 #include <BRep_ListOfCurveRepresentation.hxx>
+#include <BRepCheck.hxx>
 #include <BRep_TEdge.hxx>
 #include <BRep_TFace.hxx>
 #include <BRep_Tool.hxx>
@@ -1311,6 +1312,8 @@ TopoDS_Edge BRepLib::SameParameter(const TopoDS_Edge& theEdge,
   }
   GAC.Load(C3d,f3d,l3d);
 
+  Standard_Real Prec_C3d = BRepCheck::PrecCurve(GAC);
+
   Standard_Boolean IsSameP = 1;
   Standard_Real maxdist = 0.;
 
@@ -1597,7 +1600,9 @@ TopoDS_Edge BRepLib::SameParameter(const TopoDS_Edge& theEdge,
 
         //  Modified by skv - Thu Jun  3 12:39:19 2004 OCC5898 Begin
         if (!IsSameP) {
-          if (anEdgeTol >= error) {
+          Standard_Real Prec_Surf = BRepCheck::PrecSurface(HS);
+          Standard_Real CurTol = anEdgeTol + Max(Prec_C3d, Prec_Surf);
+          if (CurTol >= error) {
             maxdist = Max(maxdist, anEdgeTol);
             IsSameP = Standard_True;
           }

src/BRepOffsetAPI/BRepOffsetAPI_MakePipeShell.hxx

@@ -267,7 +267,11 @@ public:
     myPipe->Profiles(theProfiles);
   }
 
-
+  //! Returns the spine
+  const TopoDS_Wire& Spine()
+  {
+    return myPipe->Spine();
+  }
 
 protected:
 

src/BRepTest/BRepTest_CheckCommands.cxx

@@ -298,9 +298,25 @@ static Standard_Integer checksection(Draw_Interpretor& di,
 				     Standard_Integer narg, const char** a)
 {
   if (narg < 2) {
+    di << a[0] << " shape [-r <ref_val>]\n";
     return 1;
   }
+
+  Standard_Integer aCompareValue = -1;
   TopoDS_Shape S = DBRep::Get(a[1]);
+
+  for (Standard_Integer anAI = 2; anAI < narg; anAI++)
+  {
+    if (!strcmp(a[anAI], "-r"))
+    {
+      aCompareValue = Draw::Atoi(a[++anAI]);
+    }
+    else
+    {
+      di << "Error: Wrong option" << a[anAI] << "\n";
+    }
+  }
+
   TopTools_MapOfShape theVertices;
   TopExp_Explorer exp;
   for (exp.Init(S, TopAbs_VERTEX); exp.More(); exp.Next()) {
@@ -309,6 +325,20 @@ static Standard_Integer checksection(Draw_Interpretor& di,
   }
   //cout << " nb alone Vertices : " << theVertices.Extent() << endl;
   di << " nb alone Vertices : " << theVertices.Extent() << "\n";
+
+  if (aCompareValue >= 0)
+  {
+    if (theVertices.Extent() == aCompareValue)
+    {
+      di << "Section is OK\n";
+    }
+    else
+    {
+      di << "Error: "<< aCompareValue << " vertices are expected but " <<
+                        theVertices.Extent() << " are found.\n";
+    }
+  }
+
   char Name[32];
   Standard_Integer ipp=0;
   TopTools_MapIteratorOfMapOfShape itvx;
@@ -1698,7 +1728,8 @@ void BRepTest::CheckCommands(Draw_Interpretor& theCommands)
 //  Modified by skv - Tue Apr 27 13:35:39 2004 End
 
   theCommands.Add("checksection", 
-		  "checks the closure of a section : checksection name",
+		  "checks the closure of a section : checksection name [-r <RefVal>]\n"
+                  "\"-r\" - allowed number of allone vertices.",
 		  __FILE__,
 		  checksection,
 		  g);

src/BRepTest/BRepTest_SweepCommands.cxx

@@ -164,10 +164,11 @@ static Standard_Integer pipe(Draw_Interpretor& di,
   if (n >= 6)
     ForceApproxC1 = Standard_True;
   
-  TopoDS_Shape S = BRepOffsetAPI_MakePipe(TopoDS::Wire(Spine),
-                                          Profile,
-                                          Mode,
-                                          ForceApproxC1);
+  BRepOffsetAPI_MakePipe PipeBuilder(TopoDS::Wire(Spine),
+                                     Profile,
+                                     Mode,
+                                     ForceApproxC1);
+  TopoDS_Shape S = PipeBuilder.Shape();
 
   DBRep::Set(a[1],S);
   
@@ -769,9 +770,11 @@ static Standard_Integer buildsweep(Draw_Interpretor& di,
     result = Sweep->Shape();
     DBRep::Set(a[1],result);
     // Save history of sweep
-    TopTools_ListOfShape aProfiles;
-    Sweep->Profiles(aProfiles);
-    BRepTest_Objects::SetHistory(aProfiles, *Sweep);
+      TopTools_ListOfShape aList;
+      Sweep->Profiles(aList);
+      TopoDS_Shape aSpine = Sweep->Spine();
+      aList.Append(aSpine);
+      BRepTest_Objects::SetHistory(aList, *Sweep);
   }
 
   return 0;

src/CSLib/CSLib_Class2d.cxx

@@ -26,82 +26,97 @@ static inline
 			    const Standard_Real umaxmumin);
 
 //=======================================================================
-//function : CSLib_Class2d
-//purpose  : 
+//function : Init
+//purpose  :
 //=======================================================================
-CSLib_Class2d::CSLib_Class2d(const TColgp_Array1OfPnt2d& TP2d,
-			     const Standard_Real aTolu,
-			     const Standard_Real aTolv,
-			     const Standard_Real umin,
-			     const Standard_Real vmin,
-			     const Standard_Real umax,
-			     const Standard_Real vmax) 
+template <class TCol_Containers2d>
+void CSLib_Class2d::Init(const TCol_Containers2d& TP2d,
+                 const Standard_Real aTolu,
+                 const Standard_Real aTolv,
+                 const Standard_Real umin,
+                 const Standard_Real vmin,
+                 const Standard_Real umax,
+                 const Standard_Real vmax)
 {
-  Umin=umin;
-  Vmin=vmin;
-  Umax=umax;
-  Vmax=vmax;
+  Umin = umin;
+  Vmin = vmin;
+  Umax = umax;
+  Vmax = vmax;
   //
-  if(umax<=umin || vmax<=vmin) { 
-    MyPnts2dX=NULL;
-    MyPnts2dY=NULL;
-    N=0;
+  if ((umax <= umin) || (vmax <= vmin) || (TP2d.Length() < 3))
+  {
+    MyPnts2dX.Nullify();
+    MyPnts2dY.Nullify();
+    N = 0;
   }
   //
-  else {
+  else
+  {
     Standard_Integer i, iLower;
-    Standard_Real du,dv,*Pnts2dX,*Pnts2dY, aPrc;   
+    Standard_Real du, dv, aPrc;
     //
-    aPrc=1.e-10;
+    aPrc = 1.e-10;
     N = TP2d.Length();
     Tolu = aTolu;
     Tolv = aTolv;
-    MyPnts2dX = new Standard_Real [N+1];
-    MyPnts2dY = new Standard_Real [N+1];
-    du=umax-umin;
-    dv=vmax-vmin;
-    Pnts2dX = (Standard_Real *)MyPnts2dX;
-    Pnts2dY = (Standard_Real *)MyPnts2dY;
+    MyPnts2dX = new TColStd_Array1OfReal(0, N);
+    MyPnts2dY = new TColStd_Array1OfReal(0, N);
+    du = umax - umin;
+    dv = vmax - vmin;
     //
-    iLower=TP2d.Lower();
-    for(i = 0; i<N; ++i) { 
-      const gp_Pnt2d& aP2D=TP2d(i+iLower);
-      Pnts2dX[i] = Transform2d(aP2D.X(), umin, du);
-      Pnts2dY[i] = Transform2d(aP2D.Y(), vmin, dv);
+    iLower = TP2d.Lower();
+    for (i = 0; i<N; ++i)
+    {
+      const gp_Pnt2d& aP2D = TP2d(i + iLower);
+      MyPnts2dX->ChangeValue(i) = Transform2d(aP2D.X(), umin, du);
+      MyPnts2dY->ChangeValue(i) = Transform2d(aP2D.Y(), vmin, dv);
     }
-    Pnts2dX[N]=Pnts2dX[0];
-    Pnts2dY[N]=Pnts2dY[0];
+    MyPnts2dX->ChangeLast() = MyPnts2dX->First();
+    MyPnts2dY->ChangeLast() = MyPnts2dY->First();
     //
-    if(du>aPrc) {
-      Tolu/=du;
+    if (du>aPrc)
+    {
+      Tolu /= du;
     }
-    if(dv>aPrc) {
-      Tolv/=dv;
+    if (dv>aPrc)
+    {
+      Tolv /= dv;
     }
   }
 }
-//=======================================================================
-//function : Destroy
-//purpose  : 
-//=======================================================================
-void CSLib_Class2d::Destroy() { 
-  if(MyPnts2dX) { 
-    delete [] (Standard_Real *)MyPnts2dX;
-    MyPnts2dX=NULL;
-  }
-  if(MyPnts2dY) { 
-    delete [] (Standard_Real *)MyPnts2dY;
-    MyPnts2dY=NULL;
-  }
-}
 
-//-- Attention   Table of 0 ------> N + 1 
-//--                      P1 ..... Pn P1
-//--
-//--     1  2  3
-//--     4  0  5
-//--     6  7  8
-//-- 
+//=======================================================================
+//function : CSLib_Class2d
+//purpose  : 
+//=======================================================================
+CSLib_Class2d::CSLib_Class2d(const TColgp_Array1OfPnt2d& thePnts2d,
+                             const Standard_Real theTolU,
+                             const Standard_Real theTolV,
+                             const Standard_Real theUMin,
+                             const Standard_Real theVMin,
+                             const Standard_Real theUMax,
+                             const Standard_Real theVMax)
+{
+  Init(thePnts2d, theTolU, theTolV, theUMin,
+       theVMin, theUMax, theVMax);
+}
+
+//=======================================================================
+//function : CSLib_Class2d
+//purpose  : 
+//=======================================================================
+CSLib_Class2d::CSLib_Class2d(const TColgp_SequenceOfPnt2d& thePnts2d,
+                             const Standard_Real theTolU,
+                             const Standard_Real theTolV,
+                             const Standard_Real theUMin,
+                             const Standard_Real theVMin,
+                             const Standard_Real theUMax,
+                             const Standard_Real theVMax)
+{
+  Init(thePnts2d, theTolU, theTolV, theUMin,
+       theVMin, theUMax, theVMax);
+}
+
 //=======================================================================
 //function : SiDans
 //purpose  : 
@@ -187,21 +202,18 @@ Standard_Integer CSLib_Class2d::InternalSiDans(const Standard_Real Px,
 					       const Standard_Real Py) const
 { 
   Standard_Integer nbc, i, ip1, SH, NH;
-  Standard_Real *Pnts2dX, *Pnts2dY;
   Standard_Real  x, y, nx, ny;
   //
   nbc = 0;
   i   = 0;
   ip1 = 1;
-  Pnts2dX = (Standard_Real *)MyPnts2dX;
-  Pnts2dY = (Standard_Real *)MyPnts2dY;
-  x   = (Pnts2dX[i]-Px);
-  y   = (Pnts2dY[i]-Py);
+  x   = (MyPnts2dX->Value(i)-Px);
+  y   = (MyPnts2dY->Value(i)-Py);
   SH  = (y<0.)? -1 : 1;
   //
   for(i=0; i<N ; i++,ip1++) { 
-    nx = Pnts2dX[ip1] - Px;
-    ny = Pnts2dY[ip1] - Py;
+    nx = MyPnts2dX->Value(ip1) - Px;
+    ny = MyPnts2dY->Value(ip1) - Py;
     
     NH = (ny<0.)? -1 : 1;
     if(NH!=SH) { 
@@ -230,23 +242,20 @@ Standard_Integer CSLib_Class2d::InternalSiDansOuOn(const Standard_Real Px,
 						   const Standard_Real Py) const 
 { 
   Standard_Integer nbc, i, ip1, SH, NH, iRet;
-  Standard_Real *Pnts2dX, *Pnts2dY;
   Standard_Real x, y, nx, ny, aX;
   Standard_Real aYmin;
   //
   nbc = 0;
   i   = 0;
   ip1 = 1;
-  Pnts2dX = (Standard_Real *)MyPnts2dX;
-  Pnts2dY = (Standard_Real *)MyPnts2dY;
-  x   = (Pnts2dX[i]-Px);
-  y   = (Pnts2dY[i]-Py);
+  x   = (MyPnts2dX->Value(i)-Px);
+  y   = (MyPnts2dY->Value(i)-Py);
   aYmin=y;
   SH  = (y<0.)? -1 : 1;
   for(i=0; i<N ; i++, ip1++) { 
    
-    nx = Pnts2dX[ip1] - Px;
-    ny = Pnts2dY[ip1] - Py;
+    nx = MyPnts2dX->Value(ip1) - Px;
+    ny = MyPnts2dY->Value(ip1) - Py;
     //-- le 14 oct 97 
     if(nx<Tolu && nx>-Tolu && ny<Tolv && ny>-Tolv) { 
       iRet=-1;
@@ -254,11 +263,11 @@ Standard_Integer CSLib_Class2d::InternalSiDansOuOn(const Standard_Real Px,
     }
     //find Y coordinate of polyline for current X gka
     //in order to detect possible status ON
-    Standard_Real aDx = (Pnts2dX[ip1] - Pnts2dX[ip1-1]);
-    if( (Pnts2dX[ip1-1] - Px) * nx < 0.)
+    Standard_Real aDx = (MyPnts2dX->Value(ip1) - MyPnts2dX->Value(ip1-1));
+    if( (MyPnts2dX->Value(ip1-1) - Px) * nx < 0.)
     {
      
-      Standard_Real aCurPY =  Pnts2dY[ip1] - (Pnts2dY[ip1] - Pnts2dY[ip1-1])/aDx *nx;
+      Standard_Real aCurPY = MyPnts2dY->Value(ip1) - (MyPnts2dY->Value(ip1) - MyPnts2dY->Value(ip1-1))/aDx *nx;
       Standard_Real aDeltaY = aCurPY - Py;
       if(aDeltaY >= -Tolv && aDeltaY <= Tolv)
       {
@@ -296,17 +305,6 @@ Standard_Integer CSLib_Class2d::InternalSiDansOuOn(const Standard_Real Px,
 }
 //modified by NIZNHY-PKV Fri Jan 15 09:03:55 2010t
 //=======================================================================
-//function : Copy
-//purpose  : 
-//=======================================================================
-const CSLib_Class2d& CSLib_Class2d::Copy(const CSLib_Class2d& ) const 
-{ 
-#ifdef OCCT_DEBUG
-  cerr<<"Copy not allowed in CSLib_Class2d"<<endl;
-#endif
-  throw Standard_ConstructionError();
-}
-//=======================================================================
 //function : Transform2d
 //purpose  : 
 //=======================================================================

src/CSLib/CSLib_Class2d.hxx

@@ -25,6 +25,10 @@
 #include <Standard_Real.hxx>
 #include <Standard_Integer.hxx>
 #include <TColgp_Array1OfPnt2d.hxx>
+#include <NCollection_Handle.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColgp_SequenceOfPnt2d.hxx>
+
 class gp_Pnt2d;
 
 
@@ -38,8 +42,38 @@ public:
   DEFINE_STANDARD_ALLOC
 
   
-  Standard_EXPORT CSLib_Class2d(const TColgp_Array1OfPnt2d& TP, const Standard_Real aTolu, const Standard_Real aTolv, const Standard_Real umin, const Standard_Real vmin, const Standard_Real umax, const Standard_Real vmax);
-  
+    //! Constructs the 2D-polygon.
+    //! thePnts2d is the set of the vertices (closed polygon
+    //! will always be created inside of this constructor;
+    //! consequently, there is no point in repeating first and
+    //! last point in thePnts2d).
+    //! theTolu and theTolv are tolerances.
+    //! theUmin, theVmin, theUmax, theVmax are
+    //! UV-bounds of the polygon.
+    Standard_EXPORT CSLib_Class2d(const TColgp_Array1OfPnt2d& thePnts2d,
+                                  const Standard_Real theTolU,
+                                  const Standard_Real theTolV,
+                                  const Standard_Real theUMin,
+                                  const Standard_Real theVMin,
+                                  const Standard_Real theUMax,
+                                  const Standard_Real theVMax);
+
+  //! Constructs the 2D-polygon.
+  //! thePnts2d is the set of the vertices (closed polygon
+  //! will always be created inside of this constructor;
+  //! consequently, there is no point in repeating first and
+  //! last point in thePnts2d).
+  //! theTolu and theTolv are tolerances.
+  //! theUmin, theVmin, theUmax, theVmax are
+  //! UV-bounds of the polygon.
+  Standard_EXPORT CSLib_Class2d(const TColgp_SequenceOfPnt2d& thePnts2d,
+                                const Standard_Real theTolU,
+                                const Standard_Real theTolV,
+                                const Standard_Real theUMin,
+                                const Standard_Real theVMin,
+                                const Standard_Real theUMax,
+                                const Standard_Real theVMax);
+
   Standard_EXPORT Standard_Integer SiDans (const gp_Pnt2d& P) const;
   
   Standard_EXPORT Standard_Integer SiDans_OnMode (const gp_Pnt2d& P, const Standard_Real Tol) const;
@@ -48,33 +82,25 @@ public:
   
   Standard_EXPORT Standard_Integer InternalSiDansOuOn (const Standard_Real X, const Standard_Real Y) const;
   
-  Standard_EXPORT const CSLib_Class2d& Copy (const CSLib_Class2d& Other) const;
-const CSLib_Class2d& operator= (const CSLib_Class2d& Other) const
-{
-  return Copy(Other);
-}
-  
-  Standard_EXPORT void Destroy();
-~CSLib_Class2d()
-{
-  Destroy();
-}
-
-
-
-
 protected:
 
 
-
-
-
 private:
 
+  //! Initializes theObj
+  template <class TCol_Containers2d>
+  void Init(const TCol_Containers2d& TP2d,
+                          const Standard_Real aTolu,
+                          const Standard_Real aTolv,
+                          const Standard_Real umin,
+                          const Standard_Real vmin,
+                          const Standard_Real umax,
+                          const Standard_Real vmax);
 
+  //! Assign operator is forbidden
+  const CSLib_Class2d& operator= (const CSLib_Class2d& Other) const;
 
-  Standard_Address MyPnts2dX;
-  Standard_Address MyPnts2dY;
+  NCollection_Handle <TColStd_Array1OfReal> MyPnts2dX, MyPnts2dY;
   Standard_Real Tolu;
   Standard_Real Tolv;
   Standard_Integer N;

src/Geom/Geom_ConicalSurface.hxx

@@ -40,7 +40,7 @@ class Geom_ConicalSurface;
 DEFINE_STANDARD_HANDLE(Geom_ConicalSurface, Geom_ElementarySurface)
 
 //! Describes a cone.
-//! A cone is defined by the half-angle at its apex, and
+//! A cone is defined by the half-angle (can be negative) at its apex, and
 //! is positioned in space by a coordinate system (a
 //! gp_Ax3 object) and a reference radius as follows:
 //! - The "main Axis" of the coordinate system is the
@@ -79,7 +79,8 @@ public:
   
 
   //! A3 defines the local coordinate system of the conical surface.
-  //! Ang is the conical surface semi-angle ]0, PI/2[.
+  //! Ang is the conical surface semi-angle. Its absolute value is in range
+  //! ]0, PI/2[.
   //! Radius is the radius of the circle Viso in the placement plane
   //! of the conical surface defined with "XAxis" and "YAxis".
   //! The "ZDirection" of A3 defines the direction of the surface's
@@ -90,8 +91,8 @@ public:
   //! such that the normal Vector (N = D1U ^ D1V) is oriented towards
   //! the "outside region" of the surface.
   //!
-  //! Raised if Radius < 0.0 or Ang < Resolution from gp or
-  //! Ang >= PI/2 - Resolution
+  //! Raised if Radius < 0.0 or Abs(Ang) < Resolution from gp or
+  //! Abs(Ang) >= PI/2 - Resolution
   Standard_EXPORT Geom_ConicalSurface(const gp_Ax3& A3, const Standard_Real Ang, const Standard_Real Radius);
   
 
@@ -112,9 +113,11 @@ public:
   
 
   //! Changes the semi angle of the conical surface.
-  //!
-  //! Raised if Ang < Resolution or Ang >= PI/2 - Resolution
-  Standard_EXPORT void SetSemiAngle (const Standard_Real Ang);
+  //! Semi-angle can be negative. Its absolute value
+  //! Abs(Ang) is in range ]0,PI/2[.
+  //! Raises ConstructionError if Abs(Ang) < Resolution from gp or
+  //! Abs(Ang) >= PI/2 - Resolution
+  Standard_EXPORT void SetSemiAngle(const Standard_Real Ang);
   
 
   //! returns a non transient cone with the same geometric properties
@@ -206,7 +209,8 @@ public:
   Standard_EXPORT Standard_Real RefRadius() const;
   
 
-  //! returns the semi-angle of the conical surface ]0.0, PI/2[.
+  //! Returns the semi-angle at the apex of this cone.
+  //! Attention! Semi-angle can be negative.
   Standard_EXPORT Standard_Real SemiAngle() const;
   
   //! returns True.

src/GeomInt/GeomInt_LineConstructor.cxx

@@ -14,6 +14,7 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <algorithm>
 
 #include <Adaptor2d_HCurve2d.hxx>
 #include <Adaptor3d_TopolTool.hxx>
@@ -41,96 +42,83 @@
 #include <TColStd_IndexedMapOfInteger.hxx>
 #include <TopAbs_Orientation.hxx>
 
-static
-  void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
-                  const gp_Pnt& Ptref,
-                  Standard_Real& U1,
-                  Standard_Real& V1);
-static
-  void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
-                  const Handle(GeomAdaptor_HSurface)& myHS2,
-                  const gp_Pnt& Ptref,
-                  Standard_Real& U1,
-                  Standard_Real& V1,
-                  Standard_Real& U2,
-                  Standard_Real& V2);
+static const Standard_Real TwoPI = M_PI + M_PI;
 
-static 
-  void GLinePoint(const IntPatch_IType typl,
-                  const Handle(IntPatch_GLine)& GLine,
-                  const Standard_Real aT,
-                  gp_Pnt& aP);
-static
-  void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
-               const Handle(GeomAdaptor_HSurface)& myHS2,
-               Standard_Real& u1,
-               Standard_Real& v1,
-               Standard_Real& u2,
-               Standard_Real& v2);
-
-//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-//
 //=======================================================================
-//class    : GeomInt_RealWithFlag
-//purpose  : 
+//class    : GeomInt_Vertex
+//purpose  : This class has been created in order to provide possibility
+//            to sort IntPatch_Points by their parameter on line.
 //=======================================================================
-class GeomInt_RealWithFlag {
- public:
-  GeomInt_RealWithFlag() : 
-    myValue(-99.), myFlag(1) 
+class GeomInt_Vertex
+{
+public:
+  GeomInt_Vertex()
   {
   };
-  //
-  ~GeomInt_RealWithFlag() {
-  };
-  //
-  void SetValue(const Standard_Real aT) {
-    myValue=aT;
-  };
-  //
-  Standard_Real Value() const {
-    return myValue;
+
+  //! Initializes this class by IntPatch_Point
+  void SetVertex(const IntPatch_Point& theOther)
+  {
+    myVertex = theOther;
+    const Standard_Real aNewParam = ElCLib::InPeriod(theOther.ParameterOnLine(), 0.0, TwoPI);
+    SetParameter(aNewParam);
   }
-  //
-  void SetFlag(const Standard_Integer aFlag) {
-    myFlag=aFlag;
-  };
-  //
-  Standard_Integer Flag() const {
-    return myFlag;
+
+  //! Sets Parameter on Line
+  void SetParameter(const Standard_Real theParam)
+  {
+    myVertex.SetParameter(theParam);
   }
-  //
-  Standard_Boolean operator < (const GeomInt_RealWithFlag& aOther) {
-    return myValue<aOther.myValue;
+
+  //! Returns IntPatch_Point
+  const IntPatch_Point& Getvertex() const
+  {
+    return myVertex;
   }
-  //
- protected:
-  Standard_Real myValue;
-  Standard_Integer myFlag;
+
+  //! To provide sort
+  Standard_Boolean operator < (const GeomInt_Vertex& theOther) const
+  {
+    return myVertex.ParameterOnLine() < theOther.myVertex.ParameterOnLine();
+  }
+
+private:
+  IntPatch_Point myVertex;
 };
+
 //------------
-static 
-  void SortShell(const Standard_Integer, 
-                 GeomInt_RealWithFlag *); 
-static
-  void RejectDuplicates(Standard_Integer& aNbVtx, 
-                        GeomInt_RealWithFlag *pVtx, 
-                        Standard_Real aTolPrm);
-static
-  void RejectNearBeacons(Standard_Integer& aNbVtx, 
-                         GeomInt_RealWithFlag *pVtx, 
-                         Standard_Real aTolPC1,
-                         const GeomAbs_SurfaceType aTS1,
-                         const GeomAbs_SurfaceType aTS2); 
-static
-  Standard_Real AdjustOnPeriod(const Standard_Real aTr,
-                               const Standard_Real aPeriod);
+static void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
+                       const gp_Pnt& Ptref,
+                       Standard_Real& U1,
+                       Standard_Real& V1);
+
+static void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
+                       const Handle(GeomAdaptor_HSurface)& myHS2,
+                       const gp_Pnt& Ptref,
+                       Standard_Real& U1,
+                       Standard_Real& V1,
+                       Standard_Real& U2,
+                       Standard_Real& V2);
+
+static void GLinePoint(const IntPatch_IType typl,
+                       const Handle(IntPatch_GLine)& GLine,
+                       const Standard_Real aT,
+                       gp_Pnt& aP);
+
+static void AdjustPeriodic(const Handle(GeomAdaptor_HSurface)& myHS1,
+                           const Handle(GeomAdaptor_HSurface)& myHS2,
+                           Standard_Real& u1,
+                           Standard_Real& v1,
+                           Standard_Real& u2,
+                           Standard_Real& v2);
 
 static
   Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
                                      const IntPatch_IType aType,
                                      const Standard_Real aTol3D);
 
+static void RejectDuplicates(NCollection_Array1<GeomInt_Vertex>& theVtxArr);
+
 //=======================================================================
 //function : Perform
 //purpose  : 
@@ -154,7 +142,7 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
         const Standard_Real pmid = (firstp+lastp)*0.5;
         const gp_Pnt Pmid = ALine->Value(pmid);
         Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
-        Recadre(myHS1,myHS2,u1,v1,u2,v2);
+        AdjustPeriodic(myHS1, myHS2, u1, v1, u2, v2);
         const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
         if(in1 !=  TopAbs_OUT) {
           const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
@@ -181,7 +169,7 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
           const Standard_Integer pmid = (Standard_Integer )( (firstp+lastp)/2);
           const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
           Pmid.Parameters(u1,v1,u2,v2);
-          Recadre(myHS1,myHS2,u1,v1,u2,v2);
+          AdjustPeriodic(myHS1, myHS2, u1, v1, u2, v2);
           const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
           if(in1 !=  TopAbs_OUT) {   
             const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
@@ -194,14 +182,14 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
         else {
           const IntSurf_PntOn2S& Pfirst = WLine->Point((Standard_Integer)(firstp));
           Pfirst.Parameters(u1,v1,u2,v2);
-          Recadre(myHS1,myHS2,u1,v1,u2,v2);
+          AdjustPeriodic(myHS1, myHS2, u1, v1, u2, v2);
           TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
           if(in1 !=  TopAbs_OUT) {  //-- !=ON donne Pb 
             TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
             if(in2 != TopAbs_OUT) { //-- !=ON  
               const IntSurf_PntOn2S& Plast = WLine->Point((Standard_Integer)(lastp));
               Plast.Parameters(u1,v1,u2,v2);
-              Recadre(myHS1,myHS2,u1,v1,u2,v2);
+              AdjustPeriodic(myHS1, myHS2, u1, v1, u2, v2);
               in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
               if(in1 !=  TopAbs_OUT) {  //-- !=ON donne Pb 
                 in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
@@ -309,7 +297,7 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
         GLinePoint(typl, GLine, pmid, Pmid);
         //
         Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
-        Recadre(myHS1,myHS2,u1,v1,u2,v2);
+        AdjustPeriodic(myHS1, myHS2, u1, v1, u2, v2);
         const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
         if(in1 !=  TopAbs_OUT) { 
           const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
@@ -549,26 +537,88 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
   done = Standard_True;
 }
 
-
 //=======================================================================
-//function : Recadre
+//function : TreatCircle
 //purpose  : 
 //=======================================================================
-void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
-             const Handle(GeomAdaptor_HSurface)& myHS2,
-             Standard_Real& u1,
-             Standard_Real& v1,
-             Standard_Real& u2,
-             Standard_Real& v2)
-{ 
-  Standard_Boolean myHS1IsUPeriodic,myHS1IsVPeriodic;
+void GeomInt_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& theLine,
+                                           const Standard_Real theTol)
+{  
+  const IntPatch_IType aType = theLine->ArcType();
+  const Handle(IntPatch_GLine) aGLine(Handle(IntPatch_GLine)::DownCast(theLine));
+  if (RejectMicroCircle(aGLine, aType, theTol))
+  {
+    return;
+  }
+  //----------------------------------------
+  const Standard_Integer aNbVtx = aGLine->NbVertex();
+  NCollection_Array1<GeomInt_Vertex> aVtxArr(1, aNbVtx + 1);
+  for (Standard_Integer i = 1; i <= aNbVtx; i++)
+  {
+    aVtxArr(i).SetVertex(aGLine->Vertex(i));
+  }
+
+  std::sort(aVtxArr.begin(), aVtxArr.begin() + aNbVtx);
+  
+  //Create last vertex
+  const Standard_Real aMinPrm = aVtxArr.First().Getvertex().ParameterOnLine() + TwoPI;
+  aVtxArr.ChangeLast().SetParameter(aMinPrm);
+
+  RejectDuplicates(aVtxArr);
+
+  std::sort(aVtxArr.begin(), aVtxArr.end());
+
+  Standard_Real aU1, aV1, aU2, aV2;
+  gp_Pnt aPmid;
+  gp_Pnt2d aP2D;
+  for (Standard_Integer i = aVtxArr.Lower(); i <= aVtxArr.Upper() - 1; i++)
+  {
+    const Standard_Real aT1 = aVtxArr(i).Getvertex().ParameterOnLine();
+    const Standard_Real aT2 = aVtxArr(i + 1).Getvertex().ParameterOnLine();
+
+    if (aT2 == RealLast())
+      break;
+
+    const Standard_Real aTmid = (aT1 + aT2)*0.5;
+    GLinePoint(aType, aGLine, aTmid, aPmid);
+    //
+    Parameters(myHS1, myHS2, aPmid, aU1, aV1, aU2, aV2);
+    AdjustPeriodic(myHS1, myHS2, aU1, aV1, aU2, aV2);
+    //
+    aP2D.SetCoord(aU1, aV1);
+    TopAbs_State aState = myDom1->Classify(aP2D, theTol);
+    if (aState != TopAbs_OUT)
+    {
+      aP2D.SetCoord(aU2, aV2);
+      aState = myDom2->Classify(aP2D, theTol);
+      if (aState != TopAbs_OUT)
+      {
+        seqp.Append(aT1);
+        seqp.Append(aT2);
+      }
+    }
+  }
+}
+
+//=======================================================================
+//function : AdjustPeriodic
+//purpose  : 
+//=======================================================================
+void AdjustPeriodic(const Handle(GeomAdaptor_HSurface)& myHS1,
+                    const Handle(GeomAdaptor_HSurface)& myHS2,
+                    Standard_Real& u1,
+                    Standard_Real& v1,
+                    Standard_Real& u2,
+                    Standard_Real& v2)
+{
+  Standard_Boolean myHS1IsUPeriodic, myHS1IsVPeriodic;
   const GeomAbs_SurfaceType typs1 = myHS1->GetType();
   switch (typs1)
-  { 
+  {
     case GeomAbs_Cylinder:
     case GeomAbs_Cone:
-    case GeomAbs_Sphere: 
-    { 
+    case GeomAbs_Sphere:
+    {
       myHS1IsUPeriodic = Standard_True;
       myHS1IsVPeriodic = Standard_False;
       break;
@@ -585,14 +635,14 @@ void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
       break;
     }
   }
-  Standard_Boolean myHS2IsUPeriodic,myHS2IsVPeriodic;
+  Standard_Boolean myHS2IsUPeriodic, myHS2IsVPeriodic;
   const GeomAbs_SurfaceType typs2 = myHS2->GetType();
   switch (typs2)
-  { 
+  {
     case GeomAbs_Cylinder:
     case GeomAbs_Cone:
-    case GeomAbs_Sphere: 
-    { 
+    case GeomAbs_Sphere:
+    {
       myHS2IsUPeriodic = Standard_True;
       myHS2IsVPeriodic = Standard_False;
       break;
@@ -611,31 +661,36 @@ void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
   }
   Standard_Real du, dv;
   //
-  if(myHS1IsUPeriodic) {
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS1->UPeriod();
+  if (myHS1IsUPeriodic)
+  {
+    const Standard_Real lmf = M_PI + M_PI; //-- myHS1->UPeriod();
     const Standard_Real f = myHS1->FirstUParameter();
     const Standard_Real l = myHS1->LastUParameter();
     GeomInt::AdjustPeriodic(u1, f, l, lmf, u1, du);
   }
-  if(myHS1IsVPeriodic) {
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS1->VPeriod(); 
+  if (myHS1IsVPeriodic)
+  {
+    const Standard_Real lmf = M_PI + M_PI; //-- myHS1->VPeriod(); 
     const Standard_Real f = myHS1->FirstVParameter();
     const Standard_Real l = myHS1->LastVParameter();
     GeomInt::AdjustPeriodic(v1, f, l, lmf, v1, dv);
   }
-  if(myHS2IsUPeriodic) { 
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS2->UPeriod();
+  if (myHS2IsUPeriodic)
+  {
+    const Standard_Real lmf = M_PI + M_PI; //-- myHS2->UPeriod();
     const Standard_Real f = myHS2->FirstUParameter();
     const Standard_Real l = myHS2->LastUParameter();
     GeomInt::AdjustPeriodic(u2, f, l, lmf, u2, du);
   }
-  if(myHS2IsVPeriodic) { 
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS2->VPeriod();
+  if (myHS2IsVPeriodic)
+  {
+    const Standard_Real lmf = M_PI + M_PI; //-- myHS2->VPeriod();
     const Standard_Real f = myHS2->FirstVParameter();
     const Standard_Real l = myHS2->LastVParameter();
     GeomInt::AdjustPeriodic(v2, f, l, lmf, v2, dv);
   }
 }
+
 //=======================================================================
 //function : Parameters
 //purpose  : 
@@ -651,6 +706,7 @@ void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
   Parameters(myHS1, Ptref, U1, V1);
   Parameters(myHS2, Ptref, U2, V2);
 }
+
 //=======================================================================
 //function : Parameter
 //purpose  : 
@@ -662,26 +718,27 @@ void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
 {
   IntSurf_Quadric quad1;
   //
-  switch (myHS1->Surface().GetType())  {
-    case GeomAbs_Plane:    
-      quad1.SetValue(myHS1->Surface().Plane()); 
+  switch (myHS1->Surface().GetType())
+  {
+    case GeomAbs_Plane:
+      quad1.SetValue(myHS1->Surface().Plane());
       break;
-    case GeomAbs_Cylinder: 
-      quad1.SetValue(myHS1->Surface().Cylinder()); 
+    case GeomAbs_Cylinder:
+      quad1.SetValue(myHS1->Surface().Cylinder());
       break;
-    case GeomAbs_Cone:     
-      quad1.SetValue(myHS1->Surface().Cone()); 
+    case GeomAbs_Cone:
+      quad1.SetValue(myHS1->Surface().Cone());
       break;
-    case GeomAbs_Sphere:   
-      quad1.SetValue(myHS1->Surface().Sphere()); 
+    case GeomAbs_Sphere:
+      quad1.SetValue(myHS1->Surface().Sphere());
       break;
     case GeomAbs_Torus:
-      quad1.SetValue(myHS1->Surface().Torus()); 
+      quad1.SetValue(myHS1->Surface().Torus());
       break;
-    default: 
+    default:
       throw Standard_ConstructionError("GeomInt_LineConstructor::Parameters");
   }
-  quad1.Parameters(Ptref,U1,V1);
+  quad1.Parameters(Ptref, U1, V1);
 }
 
 //=======================================================================
@@ -693,238 +750,28 @@ void GLinePoint(const IntPatch_IType typl,
                 const Standard_Real aT,
                 gp_Pnt& aP)
 {
-  switch (typl) {
-    case IntPatch_Lin:       
-    aP = ElCLib::Value(aT, GLine->Line()); 
-    break;
-  case IntPatch_Circle:    
-    aP = ElCLib::Value(aT, GLine->Circle()); 
-    break;
-  case IntPatch_Ellipse:   
-    aP = ElCLib::Value(aT, GLine->Ellipse()); 
-    break;
-  case IntPatch_Hyperbola: 
-    aP = ElCLib::Value(aT, GLine->Hyperbola()); 
-    break;
-  case IntPatch_Parabola:  
-    aP = ElCLib::Value(aT, GLine->Parabola()); 
-    break;
-  default:
-    throw Standard_ConstructionError("GeomInt_LineConstructor::Parameters");
+  switch (typl)
+  {
+    case IntPatch_Lin:
+      aP = ElCLib::Value(aT, GLine->Line());
+      break;
+    case IntPatch_Circle:
+      aP = ElCLib::Value(aT, GLine->Circle());
+      break;
+    case IntPatch_Ellipse:
+      aP = ElCLib::Value(aT, GLine->Ellipse());
+      break;
+    case IntPatch_Hyperbola:
+      aP = ElCLib::Value(aT, GLine->Hyperbola());
+      break;
+    case IntPatch_Parabola:
+      aP = ElCLib::Value(aT, GLine->Parabola());
+      break;
+    default:
+      throw Standard_ConstructionError("GeomInt_LineConstructor::Parameters");
   }
 }
 
-//=======================================================================
-//function : TreatCircle
-//purpose  : 
-//=======================================================================
-void GeomInt_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& aLine,
-                                           const Standard_Real aTol)
-{  
-  Standard_Boolean bRejected;
-  IntPatch_IType aType;
-  //
-  aType=aLine->ArcType();
-  Handle(IntPatch_GLine) aGLine (Handle(IntPatch_GLine)::DownCast (aLine));
-  //
-  bRejected=RejectMicroCircle(aGLine, aType, aTol);
-  if (bRejected) {
-    return;
-  }
-  //----------------------------------------
-  Standard_Boolean bFound;
-  Standard_Integer aNbVtx, aNbVtxWas, i;
-  Standard_Real aTolPC, aT, aT1, aT2, aTmid, aTwoPI, aTolPC1;
-  Standard_Real aU1, aV1, aU2, aV2;
-  TopAbs_State aIn1, aIn2;
-  GeomAbs_SurfaceType aTS1, aTS2;
-  gp_Pnt aPmid;
-  gp_Pnt2d aP2D;
-  GeomInt_RealWithFlag *pVtx;
-  //-------------------------------------1
-  aTwoPI=M_PI+M_PI;
-  aTolPC=Precision::PConfusion();
-  aNbVtxWas=GeomInt_LineTool::NbVertex(aLine);
-  
-  aNbVtx=aNbVtxWas+2;
-  //-------------------------------------2
-  aTS1=myHS1->GetType();
-  aTS2=myHS2->GetType();
-  //
-  // About the value aTolPC1=1000.*aTolPC,
-  // see IntPatch_GLine.cxx, line:398
-  // for more details;
-  aTolPC1=1000.*aTolPC; 
-  //-------------------------------------
-  //
-  pVtx=new GeomInt_RealWithFlag [aNbVtx];
-  //
-  pVtx[0].SetValue(0.);
-  pVtx[1].SetValue(aTwoPI);
-  //
-  for(i=1; i<=aNbVtxWas; ++i) {
-    aT=GeomInt_LineTool::Vertex(aLine, i).ParameterOnLine();
-    aT=AdjustOnPeriod(aT, aTwoPI);
-    pVtx[i+1].SetValue(aT);
-  }
-  //
-  SortShell(aNbVtx, pVtx);
-  //
-  RejectNearBeacons(aNbVtx, pVtx, aTolPC1, aTS1, aTS2);
-  //
-  RejectDuplicates(aNbVtx, pVtx, aTolPC);
-  //
-  if ((aType==IntPatch_Circle || aType==IntPatch_Ellipse)&& aNbVtx>2) { // zz
-    bFound=Standard_False;
-    for(i=1; i<=aNbVtxWas; ++i) {
-      aT=GeomInt_LineTool::Vertex(aLine, i).ParameterOnLine();
-      if (fabs(aT) < aTolPC1 || fabs(aT-aTwoPI) < aTolPC1) {
-        bFound=!bFound;
-        break;
-      }
-    }
-    if (!bFound) {
-      aT=pVtx[1].Value()+aTwoPI;
-      pVtx[aNbVtx-1].SetValue(aT);
-      //
-      for(i=0; i<aNbVtx - 1; ++i) { 
-        aT=pVtx[i+1].Value();
-        pVtx[i].SetValue(aT);
-      }
-      --aNbVtx;
-    }
-  }
-  //
-  for(i=0; i<aNbVtx-1; ++i) { 
-    aT1=pVtx[i].Value();
-    aT2=pVtx[i+1].Value();
-    aTmid=(aT1+aT2)*0.5;
-    GLinePoint(aType, aGLine, aTmid, aPmid);
-    //
-    Parameters(myHS1, myHS2, aPmid, aU1, aV1, aU2, aV2);
-    Recadre(myHS1, myHS2, aU1, aV1, aU2, aV2);
-    //
-    aP2D.SetCoord(aU1, aV1);
-    aIn1=myDom1->Classify(aP2D, aTol);
-    if(aIn1 !=  TopAbs_OUT) { 
-      aP2D.SetCoord(aU2, aV2);
-      aIn2=myDom2->Classify(aP2D, aTol);
-      if(aIn2 != TopAbs_OUT) { 
-        seqp.Append(aT1);
-        seqp.Append(aT2);
-      }
-    }
-  }
-  //
-  delete [] pVtx;
-}
-//=======================================================================
-//function : RejectNearBeacons
-//purpose  : Reject the thickenings near the beacon points (if exist)
-//           The gifts, made by sweep algo.  
-//           chl/930/B5 B8 C2 C5 E2 E5 E8 F2 G8 H2 H5 H8
-//=======================================================================
-void RejectNearBeacons(Standard_Integer& aNbVtx, 
-                       GeomInt_RealWithFlag *pVtx, 
-                       Standard_Real aTolPC1,
-                       const GeomAbs_SurfaceType aTS1,
-                       const GeomAbs_SurfaceType aTS2) 
-{
-  Standard_Integer i, j, iBcn;
-  Standard_Real aT, aBcn[2];
-  //
-  if (aTS1==GeomAbs_Cylinder && aTS2==GeomAbs_Cylinder) {
-    aBcn[0]=0.5*M_PI;
-    aBcn[1]=1.5*M_PI;
-    //
-    for (j=0; j<2; ++j) {
-      iBcn=-1;
-      for(i=0; i<aNbVtx; ++i) {
-        aT=pVtx[i].Value();
-        if (aT==aBcn[j]) {
-          iBcn=i;
-          break;
-        }
-      }
-      //
-      if (iBcn<0) {
-        // The beacon is not found
-        continue;
-      }
-      //  
-      for(i=0; i<aNbVtx; ++i) {
-        if (i!=iBcn) {
-          aT=pVtx[i].Value();
-          if (fabs(aT-aBcn[j]) < aTolPC1) {
-            pVtx[i].SetFlag(0);
-          }
-        }
-      }
-    }// for (j=0; j<2; ++j) {
-    //------------------------------------------
-    j=0;
-    for(i=0; i<aNbVtx; ++i) {
-      if (pVtx[i].Flag()) {
-        pVtx[j]=pVtx[i];
-        ++j;
-      }
-    }
-    aNbVtx=j;
-  }// if (aTS1==GeomAbs_Cylinder && aTS2==GeomAbs_Cylinder) {
-}
-
-//=======================================================================
-//function : RejectDuplicates
-//purpose  : 
-//=======================================================================
-void RejectDuplicates(Standard_Integer& aNbVtx, 
-                      GeomInt_RealWithFlag *pVtx, 
-                      Standard_Real aTolPC) 
-{
-  Standard_Integer i, j;
-  Standard_Real dX, aT1, aT2; 
-  //
-  for(i=0; i<aNbVtx-1; ++i) {
-    aT2=pVtx[i+1].Value();
-    aT1=pVtx[i].Value();
-    dX=aT2-aT1;
-    if (dX<aTolPC) {
-      pVtx[i+1].SetFlag(0);
-    }
-  }
-  //
-  j=0;
-  for(i=0; i<aNbVtx; ++i) {
-    if (pVtx[i].Flag()) {
-      pVtx[j]=pVtx[i];
-      ++j;
-    }
-  }
-  aNbVtx=j;
-}
-//=======================================================================
-//function : AdjustOnPeriod
-//purpose  : 
-//=======================================================================
-Standard_Real AdjustOnPeriod(const Standard_Real aTr,
-                             const Standard_Real aPeriod)
-{
-  Standard_Integer k;
-  Standard_Real aT;
-  //
-  aT=aTr;
-  if (aT<0.) {
-    k=-(Standard_Integer)(aT/aPeriod)+1;
-    aT=aT+k*aPeriod;
-  }
-  //
-  if (!(aT>=0. && aT<=aPeriod)) {
-    k=(Standard_Integer)(aT/aPeriod);
-    aT=aT-k*aPeriod;
-  }
-  //
-  return aT;
-}
 //=======================================================================
 //function : RejectMicroCrcles
 //purpose  : 
@@ -948,35 +795,67 @@ Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
   }
   return bRet;
 }
+
 //=======================================================================
-// function: SortShell
-// purpose : 
+//function : RejectDuplicates
+//purpose  : Finds two coincident IntPatch_Points (if they exist) and 
+//            sets Parameter-On-Line fore one such point to DBL_MAX
+//            (i.e. its use in the future is forbidden).
+//
+//ATTENTION!!!
+//           The source array must be sorted in ascending order.
 //=======================================================================
-void SortShell(const Standard_Integer n, 
-               GeomInt_RealWithFlag *a) 
+void RejectDuplicates(NCollection_Array1<GeomInt_Vertex>& theVtxArr)
 {
-  Standard_Integer nd, i, j, l, d=1;
-  GeomInt_RealWithFlag x;
-  //
-  while(d<=n) {
-    d*=2;
+  // About the value aTolPC=1000.*Precision::PConfusion(),
+  // see IntPatch_GLine::ComputeVertexParameters(...)
+  // for more details;
+  const Standard_Real aTolPC = 1000.*Precision::PConfusion();
+
+  //Find duplicates in a slice of the array [LowerBound, UpperBound-1].
+  //If a duplicate has been found, the element with greater index will be rejected.
+  for (Standard_Integer i = theVtxArr.Lower(); i <= theVtxArr.Upper() - 2; i++)
+  {
+    const IntPatch_Point &aVi = theVtxArr(i).Getvertex();
+    const Standard_Real aPrmi = aVi.ParameterOnLine();
+
+    if (aPrmi == RealLast())
+      continue;
+
+    for (Standard_Integer j = i + 1; j <= theVtxArr.Upper() - 1; j++)
+    {
+      const IntPatch_Point &aVj = theVtxArr(j).Getvertex();
+      const Standard_Real aPrmj = aVj.ParameterOnLine();
+
+      if (aPrmj - aPrmi < aTolPC)
+      {
+        theVtxArr(j).SetParameter(RealLast());
+      }
+      else
+      {
+        break;
+      }
+    }
+  }
+
+  //Find duplicates with the last element of the array.
+  //If a duplicate has been found, the found element will be rejected.
+  const Standard_Real aMaxPrm = theVtxArr.Last().Getvertex().ParameterOnLine();
+  for (Standard_Integer i = theVtxArr.Upper() - 1; i > theVtxArr.Lower(); i--)
+  {
+    const IntPatch_Point &aVi = theVtxArr(i).Getvertex();
+    const Standard_Real aPrmi = aVi.ParameterOnLine();
+
+    if (aPrmi == RealLast())
+      continue;
+
+    if ((aMaxPrm - aPrmi) < aTolPC)
+    {
+      theVtxArr(i).SetParameter(RealLast());
+    }
+    else
+    {
+      break;
+    }
   }
-  //
-  while (d) {
-    d=(d-1)/2;
-    //
-    nd=n-d;
-    for (i=0; i<nd; ++i) {
-      j=i;
-    m30:;
-      l=j+d;
-      if (a[l] < a[j]){
-        x=a[j];
-        a[j]=a[l];
-        a[l]=x;
-        j-=d;
-        if (j > -1) goto m30;
-      }//if (a[l] < a[j]){
-    }//for (i=0; i<nd; ++i) 
-  }//while (1)
 }

src/GeometryTest/GeometryTest.cxx

@@ -34,10 +34,15 @@ void GeometryTest::AllCommands(Draw_Interpretor& theCommands)
   GeometryTest::FairCurveCommands(theCommands);
   GeometryTest::SurfaceCommands(theCommands);
   GeometryTest::ConstraintCommands(theCommands);
+
+// See bug #0030366
 //  GeometryTest::API2dCommands(theCommands);
+
   GeometryTest::APICommands(theCommands);
   GeometryTest::ContinuityCommands(theCommands);
   GeometryTest::TestProjCommands(theCommands);
+  GeometryTest::PolyCommands(theCommands);
+
   // define the TCL variable Draw_GEOMETRY
   //char* com = "set Draw_GEOMETRY 1";
   //theCommands.Eval(com);

src/GeometryTest/GeometryTest_PolyCommands.cxx

@@ -21,6 +21,7 @@
 #include <DrawTrSurf_Polygon3D.hxx>
 #include <DrawTrSurf_Triangulation.hxx>
 #include <GeometryTest.hxx>
+#include <Poly.hxx>
 #include <Poly_Array1OfTriangle.hxx>
 #include <Poly_Polygon2D.hxx>
 #include <Poly_Polygon3D.hxx>
@@ -183,6 +184,108 @@ static Standard_Integer shtriangles(Draw_Interpretor& , Standard_Integer n, cons
   return 0;//wnt
 }
 
+//=======================================================================
+//function : AddNode
+//purpose  : 
+//=======================================================================
+template <typename Poly, typename Point, typename PointArr>
+static inline void AddNode(const Handle(Poly)& thePolygon,
+                    const Point& thePnt,
+                    PointArr& theNodes)
+{
+  for (Standard_Integer i = thePolygon->Nodes().Lower();
+       i <= thePolygon->Nodes().Upper(); i++)
+  {
+    theNodes[i] = thePolygon->Nodes()[i];
+  }
+
+  theNodes.ChangeLast() = thePnt;
+}
+
+//=======================================================================
+//function : AddNode
+//purpose  : 
+//=======================================================================
+static Standard_Integer AddNode(Draw_Interpretor& theDI,
+                                Standard_Integer theNArg,
+                                const char** theArgVal)
+{
+  if (theNArg < 4)
+  {
+    theDI << "Not enough arguments\n";
+    return 1;
+  }
+
+  if (theNArg == 4)
+  {
+    Handle(Poly_Polygon2D) aPoly2d = DrawTrSurf::GetPolygon2D(theArgVal[1]);
+    TColgp_Array1OfPnt2d aNodes(aPoly2d->Nodes().Lower(),
+                                aPoly2d->Nodes().Upper() + 1);
+    AddNode(aPoly2d, gp_Pnt2d(Draw::Atof(theArgVal[2]),
+                              Draw::Atof(theArgVal[3])), aNodes);
+    aPoly2d.Nullify();
+    aPoly2d = new Poly_Polygon2D(aNodes);
+    DrawTrSurf::Set(theArgVal[1], aPoly2d);
+  }
+  else
+  {
+    Handle(Poly_Polygon3D) aPoly3d = DrawTrSurf::GetPolygon3D(theArgVal[1]);
+    TColgp_Array1OfPnt aNodes(aPoly3d->Nodes().Lower(),
+                                aPoly3d->Nodes().Upper() + 1);
+    AddNode(aPoly3d, gp_Pnt(Draw::Atof(theArgVal[2]),
+                            Draw::Atof(theArgVal[3]),
+                            Draw::Atof(theArgVal[4])), aNodes);
+    aPoly3d.Nullify();
+    aPoly3d = new Poly_Polygon3D(aNodes);
+    DrawTrSurf::Set(theArgVal[1], aPoly3d);
+  }
+
+  return 0;
+}
+
+//=======================================================================
+//function : PolygonProps
+//purpose  : 
+//=======================================================================
+static Standard_Integer PolygonProps(Draw_Interpretor& theDI,
+                                     Standard_Integer theNArg,
+                                     const char** theArgVal)
+{
+  if (theNArg < 2)
+  {
+    theDI << "Use: polygonprops polygon2d [-area val] [-perimeter val]\n";
+    return 1;
+  }
+
+  Handle(Poly_Polygon2D) aPoly2d = DrawTrSurf::GetPolygon2D(theArgVal[1]);
+
+  Standard_Real anArea = 0.0, aPerimeter = 0.0;
+  Poly::PolygonProperties(aPoly2d->Nodes(), anArea, aPerimeter);
+
+  theDI << "Area      = " << anArea << "\n";
+  theDI << "Perimeter = " << aPerimeter << "\n";
+
+  for (Standard_Integer i = 2; i < theNArg; i++)
+  {
+    if (!strcmp(theArgVal[i], "-area"))
+    {
+      Draw::Set(theArgVal[++i], anArea);
+      continue;
+    }
+
+    if (!strcmp(theArgVal[i], "-perimeter"))
+    {
+      Draw::Set(theArgVal[++i], aPerimeter);
+      continue;
+    }
+
+    theDI << "Error: Wrong option: \"" << theArgVal[i] << "\"\n";
+    break;
+  }
+
+  return 0;
+}
+
 //=======================================================================
 //function : PolyCommands
 //purpose  : 
@@ -196,6 +299,10 @@ void GeometryTest::PolyCommands(Draw_Interpretor& theCommands)
   theCommands.Add("polytr","polytr name nbnodes nbtri x1 y1 z1 ... n1 n2 n3 ...",__FILE__,polytr,g);
   theCommands.Add("polygon3d","polygon3d name nbnodes x1 y1 z1  ...",__FILE__,polygon3d,g);
   theCommands.Add("polygon2d","polygon2d name nbnodes x1 y1  ...",__FILE__,polygon2d,g);
+  theCommands.Add("addpolygonnode","addpolygonnode polygon3d(2d) x y [z]",__FILE__, AddNode,g);
+  theCommands.Add("polygonprops","Computes area and perimeter of 2D-polygon. "
+                  "Run \"polygonprops\" w/o any arguments to read help.\n",
+                  __FILE__, PolygonProps,g);
   theCommands.Add("shnodes","shnodes name", __FILE__,shnodes, g);
   theCommands.Add("shtriangles","shtriangles name", __FILE__,shtriangles, g);
 }

src/IntAna/IntAna_Curve.cxx

@@ -37,6 +37,8 @@
 //--       pas etre mene a bien.  
 //----------------------------------------------------------------------
 
+#include <algorithm>
+
 #include <ElSLib.hxx>
 #include <gp_Cone.hxx>
 #include <gp_Cylinder.hxx>
@@ -52,7 +54,7 @@
 //function : IntAna_Curve
 //purpose  : 
 //=======================================================================
-  IntAna_Curve::IntAna_Curve()
+IntAna_Curve::IntAna_Curve()
 {
   typequadric=GeomAbs_OtherSurface;
   firstbounded=Standard_False;
@@ -62,22 +64,22 @@
 //function : SetConeQuadValues
 //purpose  : Description de l intersection Cone Quadrique
 //=======================================================================
-  void IntAna_Curve::SetConeQuadValues(const gp_Cone& Cone,
-				       const Standard_Real Qxx,
-				       const Standard_Real Qyy,
-				       const Standard_Real Qzz,
-				       const Standard_Real Qxy,
-				       const Standard_Real Qxz,
-				       const Standard_Real Qyz,
-				       const Standard_Real Qx,
-				       const Standard_Real Qy,
-				       const Standard_Real Qz,
-				       const Standard_Real Q1,
-				       const Standard_Real TOL,
-				       const Standard_Real DomInf,
-				       const Standard_Real DomSup,
-				       const Standard_Boolean twocurves,
-				       const Standard_Boolean takezpositive) 
+void IntAna_Curve::SetConeQuadValues(const gp_Cone& Cone,
+                                     const Standard_Real Qxx,
+                                     const Standard_Real Qyy,
+                                     const Standard_Real Qzz,
+                                     const Standard_Real Qxy,
+                                     const Standard_Real Qxz,
+                                     const Standard_Real Qyz,
+                                     const Standard_Real Qx,
+                                     const Standard_Real Qy,
+                                     const Standard_Real Qz,
+                                     const Standard_Real Q1,
+                                     const Standard_Real TOL,
+                                     const Standard_Real DomInf,
+                                     const Standard_Real DomSup,
+                                     const Standard_Boolean twocurves,
+                                     const Standard_Boolean takezpositive)
 {
   
   Ax3        = Cone.Position();
@@ -112,36 +114,40 @@
   Z2Cos      = (UnSurTgAngle+UnSurTgAngle)*Qxz;
   Z2CosCos   = Qxx;
   Z2SinSin   = Qyy;
-  Z2CosSin   = Qxy+Qxy;
+  Z2CosSin   = Qxy;
 
   Tolerance  = TOL;
-  DomainInf  = DomInf;
-  DomainSup  = DomSup;
+  DomainInf = DomInf;
+  DomainSup = DomSup;
   
   RestrictedInf = RestrictedSup = Standard_True;   //-- Le Domaine est Borne
   firstbounded = lastbounded = Standard_False;
+
+  myFirstParameter = DomainInf;
+  myLastParameter = (TwoCurves) ? DomainSup + DomainSup - DomainInf :
+                                  DomainSup;
 }
 
 //=======================================================================
 //function : SetCylinderQuadValues
 //purpose  : Description de l intersection Cylindre Quadrique
 //=======================================================================
-  void IntAna_Curve::SetCylinderQuadValues(const gp_Cylinder& Cyl,
-					   const Standard_Real Qxx,
-					   const Standard_Real Qyy,
-					   const Standard_Real Qzz,
-					   const Standard_Real Qxy,
-					   const Standard_Real Qxz,
-					   const Standard_Real Qyz,
-					   const Standard_Real Qx,
-					   const Standard_Real Qy,
-					   const Standard_Real Qz,
-					   const Standard_Real Q1,
-					   const Standard_Real TOL,
-					   const Standard_Real DomInf,
-					   const Standard_Real DomSup,
-					   const Standard_Boolean twocurves,
-					   const Standard_Boolean takezpositive) 
+void IntAna_Curve::SetCylinderQuadValues(const gp_Cylinder& Cyl,
+                                         const Standard_Real Qxx,
+                                         const Standard_Real Qyy,
+                                         const Standard_Real Qzz,
+                                         const Standard_Real Qxy,
+                                         const Standard_Real Qxz,
+                                         const Standard_Real Qyz,
+                                         const Standard_Real Qx,
+                                         const Standard_Real Qy,
+                                         const Standard_Real Qz,
+                                         const Standard_Real Q1,
+                                         const Standard_Real TOL,
+                                         const Standard_Real DomInf,
+                                         const Standard_Real DomSup,
+                                         const Standard_Boolean twocurves,
+                                         const Standard_Boolean takezpositive)
 {
   
   Ax3        = Cyl.Position();
@@ -157,7 +163,7 @@
   Z0Cos      = RCylmul2*Qx;
   Z0CosCos   = Qxx*RCyl*RCyl;
   Z0SinSin   = Qyy*RCyl*RCyl;
-  Z0CosSin   = RCylmul2*RCyl*Qxy;
+  Z0CosSin   = RCyl*RCyl*Qxy;
 
   Z1Cte      = Qz+Qz;
   Z1Sin      = RCylmul2*Qyz;
@@ -174,18 +180,22 @@
   Z2CosSin   = 0.0;
 
   Tolerance  = TOL;
-  DomainInf  = DomInf;
-  DomainSup  = DomSup;
+  DomainInf = DomInf;
+  DomainSup = DomSup;
   
   RestrictedInf = RestrictedSup = Standard_True;
   firstbounded = lastbounded = Standard_False;
+
+  myFirstParameter = DomainInf;
+  myLastParameter  = (TwoCurves) ? DomainSup + DomainSup - DomainInf :
+                                   DomainSup;
 }
 
 //=======================================================================
 //function : IsOpen
 //purpose  : 
 //=======================================================================
-  Standard_Boolean IntAna_Curve::IsOpen() const 
+Standard_Boolean IntAna_Curve::IsOpen() const
 {
   return(RestrictedInf && RestrictedSup);
 }
@@ -194,17 +204,16 @@
 //function : Domain
 //purpose  : 
 //=======================================================================
-  void IntAna_Curve::Domain(Standard_Real& DInf,
-			    Standard_Real& DSup) const
+void IntAna_Curve::Domain(Standard_Real& theFirst,
+                          Standard_Real& theLast) const
 {
-  if(RestrictedInf && RestrictedSup) {
-    DInf=DomainInf;
-    DSup=DomainSup;
-    if(TwoCurves) {
-      DSup+=DSup-DInf;
-    }
+  if (RestrictedInf && RestrictedSup)
+  {
+    theFirst = myFirstParameter;
+    theLast = myLastParameter;
   }
-  else {
+  else
+  {
     throw Standard_DomainError("IntAna_Curve::Domain");
   }
 }
@@ -212,7 +221,7 @@
 //function : IsConstant
 //purpose  : 
 //=======================================================================
-  Standard_Boolean IntAna_Curve::IsConstant() const 
+Standard_Boolean IntAna_Curve::IsConstant() const
 {
   //-- ???  Pas facile de decider a la seule vue des Param.
   return(Standard_False);
@@ -222,7 +231,7 @@
 //function : IsFirstOpen
 //purpose  : 
 //=======================================================================
-  Standard_Boolean IntAna_Curve::IsFirstOpen() const 
+Standard_Boolean IntAna_Curve::IsFirstOpen() const
 {
   return(firstbounded);
 }
@@ -231,7 +240,7 @@
 //function : IsLastOpen
 //purpose  : 
 //=======================================================================
-  Standard_Boolean IntAna_Curve::IsLastOpen() const 
+Standard_Boolean IntAna_Curve::IsLastOpen() const
 {
   return(lastbounded);
 }
@@ -239,7 +248,7 @@
 //function : SetIsFirstOpen
 //purpose  : 
 //=======================================================================
-  void IntAna_Curve::SetIsFirstOpen(const Standard_Boolean Flag) 
+void IntAna_Curve::SetIsFirstOpen(const Standard_Boolean Flag)
 {
   firstbounded = Flag;
 }
@@ -248,7 +257,7 @@
 //function : SetIsLastOpen
 //purpose  : 
 //=======================================================================
-  void IntAna_Curve::SetIsLastOpen(const Standard_Boolean Flag) 
+void IntAna_Curve::SetIsLastOpen(const Standard_Boolean Flag)
 {
   lastbounded = Flag;
 }
@@ -257,29 +266,40 @@
 //function : InternalUVValue
 //purpose  : 
 //=======================================================================
-  void IntAna_Curve::InternalUVValue(const Standard_Real theta,
-				     Standard_Real& Param1,
-				     Standard_Real& Param2,
-				     Standard_Real& A,
-				     Standard_Real& B,
-				     Standard_Real& C,
-				     Standard_Real& cost,
-				     Standard_Real& sint,
-				     Standard_Real& SigneSqrtDis) const 
+void IntAna_Curve::InternalUVValue(const Standard_Real theta,
+                                   Standard_Real& Param1,
+                                   Standard_Real& Param2,
+                                   Standard_Real& A,
+                                   Standard_Real& B,
+                                   Standard_Real& C,
+                                   Standard_Real& cost,
+                                   Standard_Real& sint,
+                                   Standard_Real& SigneSqrtDis) const
 {
   const Standard_Real aRelTolp = 1.0+Epsilon(1.0), aRelTolm = 1.0-Epsilon(1.0);
+  
+  // Infinitesimal step of increasing curve parameter. See comment below.
+  const Standard_Real aDT = 100.0*Epsilon(DomainSup + DomainSup - DomainInf);
+
   Standard_Real Theta=theta;
   Standard_Boolean SecondSolution=Standard_False; 
 
-  if((Theta<DomainInf*aRelTolm)  ||  
-     ((Theta>DomainSup*aRelTolp) && (!TwoCurves)) ||  
-     (Theta>(DomainSup+DomainSup-DomainInf)*aRelTolp)) {
+  if ((Theta<DomainInf*aRelTolm) ||
+      ((Theta>DomainSup*aRelTolp) && (!TwoCurves)) ||
+      (Theta>(DomainSup + DomainSup - DomainInf)*aRelTolp))
+  {
     SigneSqrtDis = 0.;
     throw Standard_DomainError("IntAna_Curve::Domain");
   }
   
-  if(Theta>DomainSup) { 
-    Theta=DomainSup+DomainSup-Theta;
+  if (Abs(Theta - DomainSup) < aDT)
+  {
+    // Point of Null-discriminant.
+    Theta = DomainSup;
+  }
+  else if (Theta>DomainSup)
+  {
+    Theta = DomainSup + DomainSup - Theta;
     SecondSolution=Standard_True; 
   }
 
@@ -291,53 +311,56 @@
   //
   cost = Cos(Theta);
   sint = Sin(Theta);
-  Standard_Real costsint = cost*sint;
+  const Standard_Real aSin2t = Sin(Theta + Theta);
+  const Standard_Real aCos2t = Cos(Theta + Theta);
   
   A=Z2Cte+sint*(Z2Sin+sint*Z2SinSin)+cost*(Z2Cos+cost*Z2CosCos)
-    +Z2CosSin*costsint;
+    + Z2CosSin*aSin2t;
   
+  const Standard_Real aDA = cost*Z2Sin - sint*Z2Cos + 
+                            aSin2t*(Z2SinSin - Z2CosCos) + 
+                            aCos2t*(Z2CosSin * Z2CosSin);
+
   B=Z1Cte+sint*(Z1Sin+sint*Z1SinSin)+cost*(Z1Cos+cost*Z1CosCos)
-    +Z1CosSin*costsint;
+    + Z1CosSin*aSin2t;
+
+  const Standard_Real aDB = Z1Sin*cost - Z1Cos*sint +
+                            aSin2t*(Z1SinSin - Z1CosCos) +
+                            aCos2t*(Z1CosSin + Z1CosSin);
   
   C=Z0Cte+sint*(Z0Sin+sint*Z0SinSin)+cost*(Z0Cos+cost*Z0CosCos)
-    +Z0CosSin*costsint;
+    + Z0CosSin*aSin2t;
   
+  const Standard_Real aDC = Z0Sin*cost - Z0Cos*sint +
+                            aSin2t*(Z0SinSin - Z0CosCos) + 
+                            aCos2t*(Z0CosSin + Z0CosSin);
 
-  const Standard_Real aDiscriminant = Max(B*B-4.0*A*C, 0.0);
+  Standard_Real aDiscriminant = B*B-4.0*A*C;
+
+  // We consider that infinitesimal dt = aDT.
+  // Error of discriminant computation is equal to
+  // (d(Disc)/dt)*dt, where 1st derivative d(Disc)/dt = 2*B*aDB - 4*(A*aDC + C*aDA).
+
+  const Standard_Real aTolD = 2.0*aDT*Abs(B*aDB - 2.0*(A*aDC + C*aDA));
   
-  if(Abs(A)<=Precision::PConfusion()) {   
-    //-- cout<<" IntAna_Curve:: Internal UV Value : A="<<A<<"  -> Abs(A)="<<Abs(A)<<endl;
-    if(Abs(B)<=Precision::PConfusion()) { 
-      //-- cout<<" Probleme :  Pas de solutions "<<endl;
-      Param2=0.0;
+  if (aDiscriminant < aTolD)
+    aDiscriminant = 0.0;
+
+  if (Abs(A) <= Precision::PConfusion())
+  {
+    if (Abs(B) <= Precision::PConfusion())
+    {
+      Param2 = 0.0;
     }
-    else {
-      //modified by NIZNHY-PKV Fri Dec  2 16:02:46 2005f
-      Param2 = -C/B;
-      /*
-      if(!SecondSolution) {   
-	//-- Cas Param2 = (-B+Sqrt(Discriminant))/(A+A);
-	//--            = (-B+Sqrt(B**2 - Eps)) / 2A
-	//--            = -C / B
-	Param2 = -C/B;
-      } 
-      else {
-	//-- Cas Param2 = (-B-Sqrt(Discriminant))/(A+A);
-	//--            = (-B-Sqrt(B**2 - Eps)) / 2A
-	if(A) { 
-	  Param2 = -B/A; 
-	}
-	else { 
-	  Param2 = -B*10000000.0;
-	}
-      }
-      */
-      //modified by NIZNHY-PKV Fri Dec  2 16:02:54 2005t
+    else
+    {
+      Param2 = -C / B;
     }
   }
-  else {
-    SigneSqrtDis = (SecondSolution)? Sqrt(aDiscriminant) : -Sqrt(aDiscriminant);
-    Param2=(-B+SigneSqrtDis)/(A+A);
+  else
+  {
+    SigneSqrtDis = (SecondSolution) ? Sqrt(aDiscriminant) : -Sqrt(aDiscriminant);
+    Param2 = (-B + SigneSqrtDis) / (A + A);
   }
 }
 
@@ -345,7 +368,7 @@
 //function : Value
 //purpose  : 
 //=======================================================================
-  gp_Pnt IntAna_Curve::Value(const Standard_Real theta)  
+gp_Pnt IntAna_Curve::Value(const Standard_Real theta)
 {
   Standard_Real A, B, C, U, V, sint, cost, SigneSqrtDis;
   //
@@ -361,9 +384,9 @@
 //function : D1u
 //purpose  : 
 //=======================================================================
-  Standard_Boolean IntAna_Curve::D1u(const Standard_Real theta,
-				     gp_Pnt& Pt,
-				     gp_Vec& Vec) 
+Standard_Boolean IntAna_Curve::D1u(const Standard_Real theta,
+                                   gp_Pnt& Pt,
+                                   gp_Vec& Vec)
 {
   //-- Pour detecter le cas ou le calcul est impossible 
   Standard_Real A, B, C, U, V, sint, cost, SigneSqrtDis;
@@ -374,14 +397,15 @@
   InternalUVValue(theta,U,V,A,B,C,cost,sint,SigneSqrtDis);
   //
   Pt = Value(theta);
-  if(Abs(A)<0.0000001 || Abs(SigneSqrtDis)<0.0000000001) return(Standard_False);
+  if (Abs(A)<1.0e-7 || Abs(SigneSqrtDis)<1.0e-10) return(Standard_False);
   
   
   //-- Approximation de la derivee (mieux que le calcul mathematique!)
-  Standard_Real dtheta = (DomainSup-DomainInf)*0.000001;
+  Standard_Real dtheta = (DomainSup - DomainInf)*1.0e-6;
   Standard_Real theta2 = theta+dtheta;
-  if((theta2<DomainInf)  ||  ((theta2>DomainSup) && (!TwoCurves))
-     ||  (theta2>(DomainSup+DomainSup-DomainInf+0.00000000000001))) {
+  if ((theta2<DomainInf) || ((theta2>DomainSup) && (!TwoCurves))
+      || (theta2>(DomainSup + DomainSup - DomainInf + 1.0e-14)))
+  {
     dtheta = -dtheta;
     theta2 = theta+dtheta;
   }
@@ -395,147 +419,93 @@
 }  
 //=======================================================================
 //function : FindParameter
-//purpose  : Para est en sortie le parametre sur la courbe 
+//purpose  : Projects P to the ALine. Returns the list of parameters as a results
+//            of projection.
+//           Sometimes aline can be self-intersected line (see bug #29807 where 
+//            ALine goes through the cone apex).
 //=======================================================================
-  Standard_Boolean IntAna_Curve::FindParameter (const gp_Pnt& P,
-						Standard_Real& Para) const
+void IntAna_Curve::FindParameter(const gp_Pnt& theP,
+                                 TColStd_ListOfReal& theParams) const
 {
-  Standard_Real theta,z, aTolPrecision=0.0001;
-  Standard_Real PIpPI = M_PI + M_PI;
+  const Standard_Real aPIpPI = M_PI + M_PI,
+                      anEpsAng = 1.e-8,
+                      aSqTolPrecision=1.0e-8;
+  Standard_Real aTheta = 0.0;
   //
-  switch (typequadric) {
-
-  case GeomAbs_Cylinder:
+  switch (typequadric)
+  {
+    case GeomAbs_Cylinder:
     {
-      ElSLib::CylinderParameters(Ax3,RCyl,P,theta,z);
+      Standard_Real aZ;
+      ElSLib::CylinderParameters(Ax3, RCyl, theP, aTheta, aZ);
     }
     break;
+
+    case GeomAbs_Cone:
+    {
+      Standard_Real aZ;
+      ElSLib::ConeParameters(Ax3, RCyl, Angle, theP, aTheta, aZ);
+    }
+    break;
+
+    default:
+      return;
+  }
+  //
+  if (!firstbounded && (DomainInf > aTheta) && ((DomainInf - aTheta) <= anEpsAng))
+  {
+    aTheta = DomainInf;
+  }
+  else if (!lastbounded && (aTheta > DomainSup) && ((aTheta - DomainSup) <= anEpsAng))
+  {
+    aTheta = DomainSup;
+  }
+  //
+  if (aTheta < DomainInf)
+  {
+    aTheta = aTheta + aPIpPI;
+  }
+  else if (aTheta > DomainSup)
+  {
+    aTheta = aTheta - aPIpPI;
+  }
+
+  const Standard_Integer aMaxPar = 5;
+  Standard_Real aParams[aMaxPar] = {DomainInf, DomainSup, aTheta,
+                                    (TwoCurves)? DomainSup + DomainSup - aTheta : RealLast(),
+                                    (TwoCurves) ? DomainSup + DomainSup - DomainInf : RealLast()};
+
+  std::sort(aParams, aParams + aMaxPar - 1);
+
+  for (Standard_Integer i = 0; i < aMaxPar; i++)
+  {
+    if (aParams[i] > myLastParameter)
+      break;
     
-  case GeomAbs_Cone :
+    if (aParams[i] < myFirstParameter)
+      continue;
+
+    if (i && (aParams[i] - aParams[i - 1]) < Precision::PConfusion())
+      continue;
+
+    Standard_Real U = 0.0, V= 0.0, 
+                  A = 0.0, B = 0.0, C = 0.0,
+                  sint = 0.0, cost = 0.0, SigneSqrtDis = 0.0;
+    InternalUVValue(aParams[i], U, V, A, B, C, 
+                    cost, sint, SigneSqrtDis);
+    const gp_Pnt aP(InternalValue(U, V));
+    if (aP.SquareDistance(theP) < aSqTolPrecision)
     {
-      ElSLib::ConeParameters(Ax3,RCyl,Angle,P,theta,z);
-    }
-    break;
-
-  default:
-    return Standard_False;
-    break;
-  }
-  //
-  Standard_Real epsAng = 1.e-8;
-  Standard_Real tmin = DomainInf;
-  Standard_Real tmax = DomainSup;
-  Standard_Real U,V,A,B,C,sint,cost,SigneSqrtDis;
-  Standard_Real z1,z2;
-
-  A=0.0;  B=0.0;   C=0.0;
-  U=0.0;  V=0.0;  
-  sint=0.0;  cost=0.0;
-  SigneSqrtDis=0.0;
-  //U=V=A=B=C=sint=cost=SigneSqrtDis=0.0;
-  //
-  if (!firstbounded && tmin > theta && (tmin-theta) <= epsAng) {
-    theta = tmin;
-  }
-  else if (!lastbounded && theta > tmax && (theta-tmax) <= epsAng) {
-    theta = tmax;
-  }
-  //
-  if (theta < tmin ) {
-    theta = theta + PIpPI;
-  }
-  else if (theta > tmax) {
-    theta = theta - PIpPI;
-  }
-  if (theta < tmin || theta > tmax) {
-    if(theta>tmax) { 
-      InternalUVValue(tmax,U,V,A,B,C,cost,sint,SigneSqrtDis); 
-      gp_Pnt PMax(InternalValue(U,V)); 
-      if(PMax.Distance(P) < aTolPrecision) { 
-	Para = tmax; 
-	return(Standard_True); 
-      }
-    }
-    if(theta<tmin) { 
-      InternalUVValue(tmin,U,V,A,B,C,cost,sint,SigneSqrtDis); 
-      gp_Pnt PMin(InternalValue(U,V));  
-      if(PMin.Distance(P) < aTolPrecision) { 
-	Para = tmin; 
-	return(Standard_True); 
-      }
-    }
-    //-- lbr le 14 Fev 96 : On teste malgre tout si le point n est pas le 
-    //-- point de debut ou de fin 
-    //-- cout<<"False 1 "<<endl;
-    //    theta = tmin;                               le 25 Nov 96
-  }
-
-  if (TwoCurves) {
-    if(theta > tmax) 
-      theta =  tmax;
-    if(theta < tmin) 
-      theta = tmin;
-    InternalUVValue(theta,U,z1,A,B,C,cost,sint,SigneSqrtDis); 
-    A = B = C = sint = cost = SigneSqrtDis = 0.0;
-    InternalUVValue(tmax+tmax - theta,U,z2,A,B,C,cost,sint,SigneSqrtDis); 
-
-    if (Abs(z-z1) <= Abs(z-z2)) {
-      Para = theta;
-    }
-    else {
-      Para = tmax+tmax - theta;
+      theParams.Append(aParams[i]);
     }
   }
-  else {
-    Para = theta;
-  }
-
-  if((Para<DomainInf)  ||  ((Para>DomainSup) && (!TwoCurves))
-     ||  (Para>(DomainSup+DomainSup-DomainInf+0.00000000000001))) {
-    return(Standard_False);
-  }
-  
-  InternalUVValue(Para,U,V,A,B,C,cost,sint,SigneSqrtDis);
-  gp_Pnt PPara = InternalValue(U,V);
-  Standard_Real Dist = PPara.Distance(P);
-  if(Dist > aTolPrecision) { 
-    //-- Il y a eu un probleme  
-    //-- On teste si le point est un point double 
-    InternalUVValue(tmin,U,V,A,B,C,cost,sint,SigneSqrtDis);
-    PPara = InternalValue(U,V);
-    Dist = PPara.Distance(P);
-    if(Dist <= aTolPrecision) {
-      Para = tmin; 
-      return(Standard_True);
-    }
-
-    InternalUVValue(tmax,U,V,A,B,C,cost,sint,SigneSqrtDis);
-    PPara = InternalValue(U,V);
-    Dist = PPara.Distance(P);
-    if(Dist <= aTolPrecision) {
-      Para = tmax; 
-      return(Standard_True);
-    }
-    if (TwoCurves) {
-      Standard_Real Theta = DomainSup+DomainSup-DomainInf;
-      InternalUVValue(Theta,U,V,A,B,C,cost,sint,SigneSqrtDis);
-      PPara = InternalValue(U,V);
-      Dist = PPara.Distance(P);
-      if(Dist <= aTolPrecision) {
-	Para = Theta; 
-	return(Standard_True);
-      } 
-    }
-    return(Standard_False);
-  }
-  return(Standard_True);
 }
 //=======================================================================
 //function : InternalValue
 //purpose  : 
 //=======================================================================
-  gp_Pnt IntAna_Curve::InternalValue(const Standard_Real U,
-				     const Standard_Real _V) const 
+gp_Pnt IntAna_Curve::InternalValue(const Standard_Real U,
+                                   const Standard_Real _V) const
 {
   //-- cout<<" ["<<U<<","<<V<<"]";
   Standard_Real V = _V;
@@ -569,13 +539,14 @@
 //function : SetDomain
 //purpose  : 
 //=======================================================================
-  void IntAna_Curve::SetDomain(const Standard_Real DInf,
-			       const Standard_Real DSup) 
+void IntAna_Curve::SetDomain(const Standard_Real theFirst,
+                             const Standard_Real theLast)
 {
-  if(DInf>=DSup) {
+  if (theLast <= theFirst)
+  {
     throw Standard_DomainError("IntAna_Curve::Domain");
   }
   //
-  DomainInf=DInf;
-  DomainSup=DSup;
+  myFirstParameter = theFirst;
+  myLastParameter = theLast;
 }

src/IntAna/IntAna_Curve.hxx

@@ -21,16 +21,9 @@
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 
-#include <Standard_Real.hxx>
-#include <Standard_Boolean.hxx>
 #include <GeomAbs_SurfaceType.hxx>
 #include <gp_Ax3.hxx>
-class Standard_DomainError;
-class gp_Cylinder;
-class gp_Cone;
-class gp_Pnt;
-class gp_Vec;
-
+#include <TColStd_ListOfReal.hxx>
 
 //! Definition of a parametric Curve which is the result
 //! of the intersection between two quadrics.
@@ -57,7 +50,7 @@ public:
   Standard_EXPORT Standard_Boolean IsOpen() const;
   
   //! Returns the paramatric domain of the curve.
-  Standard_EXPORT void Domain (Standard_Real& Theta1, Standard_Real& Theta2) const;
+  Standard_EXPORT void Domain(Standard_Real& theFirst, Standard_Real& theLast) const;
   
   //! Returns TRUE if the function is constant.
   Standard_EXPORT Standard_Boolean IsConstant() const;
@@ -77,11 +70,11 @@ public:
   
   //! Tries to find the parameter of the point P on the curve.
   //! If the method returns False, the "projection" is
-  //! impossible, and the value of Para is not significant.
-  //! If the method returns True, Para is the parameter of the
-  //! nearest intersection between the curve and the iso-theta
-  //! containing P.
-  Standard_EXPORT Standard_Boolean FindParameter (const gp_Pnt& P, Standard_Real& Para) const;
+  //! impossible.
+  //! If the method returns True at least one parameter has been found.
+  //! theParams is always sorted in ascending order.
+  Standard_EXPORT void FindParameter(const gp_Pnt& P,
+                                     TColStd_ListOfReal& theParams) const;
   
   //! If flag is True, the Curve is not defined at the
   //! first parameter of its domain.
@@ -91,10 +84,8 @@ public:
   //! first parameter of its domain.
   Standard_EXPORT void SetIsLastOpen (const Standard_Boolean Flag);
   
-  //! Protected function.
-  Standard_EXPORT void InternalUVValue (const Standard_Real Param, Standard_Real& U, Standard_Real& V, Standard_Real& A, Standard_Real& B, Standard_Real& C, Standard_Real& Co, Standard_Real& Si, Standard_Real& Di) const;
-  
-  Standard_EXPORT void SetDomain (const Standard_Real Theta1, const Standard_Real Theta2);
+  //! Trims this curve
+  Standard_EXPORT void SetDomain(const Standard_Real theFirst, const Standard_Real theLast);
 
 
 
@@ -105,6 +96,8 @@ protected:
   //! Protected function.
   Standard_EXPORT gp_Pnt InternalValue (const Standard_Real Theta1, const Standard_Real Theta2) const;
 
+  //! Protected function.
+  Standard_EXPORT void InternalUVValue (const Standard_Real Param, Standard_Real& U, Standard_Real& V, Standard_Real& A, Standard_Real& B, Standard_Real& C, Standard_Real& Co, Standard_Real& Si, Standard_Real& Di) const;
 
 
 
@@ -133,8 +126,9 @@ private:
   Standard_Boolean TwoCurves;
   Standard_Boolean TakeZPositive;
   Standard_Real Tolerance;
-  Standard_Real DomainInf;
-  Standard_Real DomainSup;
+
+  //! Internal fields defining the default domain
+  Standard_Real DomainInf, DomainSup;
   Standard_Boolean RestrictedInf;
   Standard_Boolean RestrictedSup;
   Standard_Boolean firstbounded;
@@ -144,6 +138,9 @@ private:
   Standard_Real Angle;
   gp_Ax3 Ax3;
 
+  //! Trim boundaries
+  Standard_Real myFirstParameter, myLastParameter;
+
 
 };
 

src/IntAna/IntAna_IntQuadQuad.cxx

@@ -28,6 +28,7 @@
 //==                           C Y L I N D R E   Q U A D R I Q U E
 //======================================================================
 
+#include <ElSLib.hxx>
 #include <gp_Ax2.hxx>
 #include <gp_Ax3.hxx>
 #include <gp_Cone.hxx>
@@ -41,6 +42,75 @@
 #include <Standard_OutOfRange.hxx>
 #include <StdFail_NotDone.hxx>
 
+//=======================================================================
+//function : AddSpecialPoints
+//purpose  : Sometimes the boundaries theTheta1 and theTheta2 are
+//            computed with some inaccuracy. At that, some special points
+//            (cone apex or sphere pole(s)), which are true intersection
+//            points lie out of the domain [theTheta1, theTheta2] of the ALine.
+//           This function corrects these boundaries to make them be included 
+//            in the domain of the ALine.
+//           Parameters Theta1 and Theta2 must be initialized
+//            before calling this function.
+//=======================================================================
+template <class gpSmth>
+static void AddSpecialPoints(const IntAna_Quadric& theQuad,
+                             const gpSmth& theGpObj,
+                             Standard_Real& theTheta1,
+                             Standard_Real& theTheta2)
+{
+  const Standard_Real aPeriod = M_PI + M_PI;
+  const NCollection_List<gp_Pnt> &aLSP = theQuad.SpecialPoints();
+
+  if (aLSP.IsEmpty())
+    return;
+
+  Standard_Real aU = 0.0, aV = 0.0;
+  Standard_Real aMaxDelta = 0.0;
+  for (NCollection_List<gp_Pnt>::Iterator anItr(aLSP); anItr.More(); anItr.Next())
+  {
+    const gp_Pnt &aPt = anItr.Value();
+    ElSLib::Parameters(theGpObj, aPt, aU, aV);
+    const gp_Pnt aPProj(ElSLib::Value(aU, aV, theGpObj));
+
+    if (aPt.SquareDistance(aPProj) > Precision::SquareConfusion())
+    {
+      // aPt is not an intersection point
+      continue;
+    }
+
+    Standard_Real aDelta1 = Min(aU - theTheta1, 0.0),
+                  aDelta2 = Max(aU - theTheta2, 0.0);
+
+    if (aDelta1 < -M_PI)
+    {
+      // Must be aDelta1 = Min(aU - theTheta1 + aPeriod, 0.0).
+      // But aU - theTheta1 + aPeriod >= 0 always.
+      aDelta1 = 0.0;
+    }
+
+    if (aDelta2 > M_PI)
+    {
+      // Must be aDelta2 = Max(aU - theTheta2 - aPeriod, 0.0).
+      // But aU - theTheta2 - aPeriod <= 0 always.
+      aDelta2 = 0.0;
+    }
+
+    const Standard_Real aDelta = Max(-aDelta1, aDelta2);
+    aMaxDelta = Max(aMaxDelta, aDelta);
+  }
+
+  if(aMaxDelta != 0.0)
+  {
+    theTheta1 -= aMaxDelta;
+    theTheta2 += aMaxDelta;
+    if ((theTheta2 - theTheta1) > aPeriod)
+    {
+      theTheta2 = theTheta1 + aPeriod;
+    }
+  }
+}
+
 //=======================================================================
 //class : TrigonometricRoots
 //purpose: Classe Interne (Donne des racines classees d un polynome trigo)
@@ -486,13 +556,15 @@ void IntAna_IntQuadQuad::Perform(const gp_Cylinder& Cyl,
 		//
 		qwet=MTF.Value(autrepar);
 		if(qwet>=0.) { 
+                  Standard_Real aParam = Theta1 + PIpPI;
+                  AddSpecialPoints(Quad, Cyl, Theta1, aParam);
 		  TheCurve[NbCurves].SetCylinderQuadValues(Cyl,Qxx,Qyy,Qzz,Qxy,Qxz,Qyz,Qx,Qy,Qz,Q1,
-							   myEpsilon,Theta1,Theta1+PIpPI,
+							   myEpsilon,Theta1,aParam,
 							   UN_SEUL_Z_PAR_THETA,
 							   Z_POSITIF);
 		  NbCurves++;
 		  TheCurve[NbCurves].SetCylinderQuadValues(Cyl,Qxx,Qyy,Qzz,Qxy,Qxz,Qyz,Qx,Qy,Qz,Q1,
-							   myEpsilon,Theta1,Theta1+PIpPI,
+							   myEpsilon,Theta1,aParam,
 							   UN_SEUL_Z_PAR_THETA,
 							   Z_NEGATIF);
 		  NbCurves++;
@@ -534,6 +606,7 @@ void IntAna_IntQuadQuad::Perform(const gp_Cylinder& Cyl,
 		//ft
 		if((Theta3-Theta2)<5.e-8) { 
 		//
+                  AddSpecialPoints(Quad, Cyl, Theta1, Theta2);
 		  TheCurve[NbCurves].SetCylinderQuadValues(Cyl,Qxx,Qyy,Qzz,Qxy,Qxz,Qyz,Qx,Qy,Qz,Q1,
 							   myEpsilon,Theta1,Theta2,
 							   UN_SEUL_Z_PAR_THETA,
@@ -546,6 +619,7 @@ void IntAna_IntQuadQuad::Perform(const gp_Cylinder& Cyl,
 		  NbCurves++;
 		}
 		else { 
+                  AddSpecialPoints(Quad, Cyl, Theta1, Theta2);
 		  TheCurve[NbCurves].SetCylinderQuadValues(Cyl,Qxx,Qyy,Qzz,Qxy,Qxz,Qyz,Qx,Qy,Qz,Q1,
 							   myEpsilon,Theta1,Theta2,
 							   DEUX_Z_PAR_THETA,

src/IntAna/IntAna_Quadric.cxx

@@ -28,6 +28,7 @@
 #include <gp_Trsf.hxx>
 #include <gp_Vec.hxx>
 #include <IntAna_Quadric.hxx>
+#include <ElSLib.hxx>
 
 //----------------------------------------------------------------------
 //-- 
@@ -85,22 +86,27 @@ IntAna_Quadric::IntAna_Quadric(const gp_Cylinder& Cyl) {
 //----------------------------------------------------------------------
 //-- Cone -----> Quadric
 //----------------------------------------------------------------------
-IntAna_Quadric::IntAna_Quadric(const gp_Cone& Cone) {
-  Cone.Coefficients(CXX,CYY,CZZ,CXY,CXZ,CYZ,CX,CY,CZ,CCte);  
+IntAna_Quadric::IntAna_Quadric(const gp_Cone& Cone)
+{
+  SetQuadric(Cone);
 }
 
 void IntAna_Quadric::SetQuadric(const gp_Cone& Cone) {
   Cone.Coefficients(CXX,CYY,CZZ,CXY,CXZ,CYZ,CX,CY,CZ,CCte);  
+  const Standard_Real aVParam = -Cone.RefRadius() / Sin(Cone.SemiAngle());
+  mySpecialPoints.Append(ElSLib::Value(0.0, aVParam, Cone));
 }
 //----------------------------------------------------------------------
 //-- Sphere -----> Quadric
 //----------------------------------------------------------------------
 void IntAna_Quadric::SetQuadric(const gp_Sphere& Sph) {
   Sph.Coefficients(CXX,CYY,CZZ,CXY,CXZ,CYZ,CX,CY,CZ,CCte);
+  mySpecialPoints.Append(ElSLib::Value(0.0, -M_PI_2, Sph));
+  mySpecialPoints.Append(ElSLib::Value(0.0, M_PI_2, Sph));
 }
 
 IntAna_Quadric::IntAna_Quadric(const gp_Sphere& Sph) {
-  Sph.Coefficients(CXX,CYY,CZZ,CXY,CXZ,CYZ,CX,CY,CZ,CCte);
+  SetQuadric(Sph);
 }
 //----------------------------------------------------------------------
 //-- Returns the Coefficients of the Quadric

src/IntAna/IntAna_Quadric.hxx

@@ -17,17 +17,8 @@
 #ifndef _IntAna_Quadric_HeaderFile
 #define _IntAna_Quadric_HeaderFile
 
-#include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Real.hxx>
-class gp_Pln;
-class gp_Sphere;
-class gp_Cylinder;
-class gp_Cone;
-class gp_Ax3;
-
+#include <NCollection_List.hxx>
 
 //! This class provides a description of Quadrics by their
 //! Coefficients in natural coordinate system.
@@ -78,7 +69,11 @@ public:
   //! in the local coordinates system defined by Axis
   Standard_EXPORT void NewCoefficients (Standard_Real& xCXX, Standard_Real& xCYY, Standard_Real& xCZZ, Standard_Real& xCXY, Standard_Real& xCXZ, Standard_Real& xCYZ, Standard_Real& xCX, Standard_Real& xCY, Standard_Real& xCZ, Standard_Real& xCCte, const gp_Ax3& Axis) const;
 
-
+  //! Returns the list of special points (with singularities)
+  const NCollection_List<gp_Pnt>& SpecialPoints() const
+  {
+    return mySpecialPoints;
+  }
 
 
 protected:
@@ -101,7 +96,7 @@ private:
   Standard_Real CY;
   Standard_Real CZ;
   Standard_Real CCte;
-
+  NCollection_List<gp_Pnt> mySpecialPoints;
 
 };
 

src/IntPatch/IntPatch_ALine.hxx

@@ -17,31 +17,21 @@
 #ifndef _IntPatch_ALine_HeaderFile
 #define _IntPatch_ALine_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_Type.hxx>
+#include <Standard_Handle.hxx>
 
 #include <IntAna_Curve.hxx>
-#include <Standard_Boolean.hxx>
-#include <Standard_Integer.hxx>
-#include <IntPatch_SequenceOfPoint.hxx>
 #include <IntPatch_Line.hxx>
-#include <IntSurf_TypeTrans.hxx>
-#include <IntSurf_Situation.hxx>
-#include <Standard_Real.hxx>
-#include <gp_Pnt.hxx>
-class Standard_DomainError;
-class Standard_OutOfRange;
+#include <IntPatch_SequenceOfPoint.hxx>
+#include <TColStd_ListOfReal.hxx>
+
 class IntAna_Curve;
 class IntPatch_Point;
-class gp_Pnt;
-class gp_Vec;
-
-
 class IntPatch_ALine;
+
 DEFINE_STANDARD_HANDLE(IntPatch_ALine, IntPatch_Line)
 
 //! Implementation of an intersection line described by a
-//! parametrised curve.
+//! parametrized curve.
 class IntPatch_ALine : public IntPatch_Line
 {
 
@@ -97,13 +87,13 @@ public:
   //! intersection.
     Standard_Boolean D1 (const Standard_Real U, gp_Pnt& P, gp_Vec& Du);
   
-  //! Tries to find the parameter of the point P on the curve.
+  //! Tries to find the parameters of the point P on the curve.
   //! If the method returns False, the "projection" is
-  //! impossible, and the value of Para is not significant.
-  //! If the method returns True, Para is the parameter of the
-  //! nearest intersection between the curve and the iso-theta
-  //! containing P.
-    Standard_Boolean FindParameter (const gp_Pnt& P, Standard_Real& Para) const;
+  //! impossible.
+  //! If the method returns True at least one parameter has been found.
+  //! theParams is always sorted in ascending order.
+  void FindParameter(const gp_Pnt& P,
+                     TColStd_ListOfReal& theParams) const;
   
   //! Returns True if the line has a known First point.
   //! This point is given by the method FirstPoint().
@@ -126,6 +116,12 @@ public:
   //! Returns the vertex of range Index on the line.
     const IntPatch_Point& Vertex (const Standard_Integer Index) const;
   
+  //! Allows modifying the vertex with index theIndex on the line.
+  IntPatch_Point& ChangeVertex(const Standard_Integer theIndex)
+  {
+    return svtx.ChangeValue(theIndex);
+  }
+
   //! Set the parameters of all the vertex on the line.
   //! if a vertex is already in the line,
   //! its parameter is modified

src/IntPatch/IntPatch_ALine.lxx

@@ -62,9 +62,10 @@ inline Standard_Boolean IntPatch_ALine::D1(const Standard_Real U, gp_Pnt& P, gp_
   return curv.D1u(U,P,Du); // D1u leve l exception DomainError
 }
 
-inline Standard_Boolean IntPatch_ALine::FindParameter(const gp_Pnt& P, Standard_Real& Para) const
+inline void IntPatch_ALine::FindParameter(const gp_Pnt& theP,
+                                          TColStd_ListOfReal& theParams) const
 {
-  return curv.FindParameter(P,Para);
+  curv.FindParameter(theP, theParams);
 }
 
 inline Standard_Boolean IntPatch_ALine::HasFirstPoint () const

src/IntPatch/IntPatch_ALineToWLine.cxx

@@ -62,21 +62,20 @@ static void AddVertexPoint(Handle(IntSurf_LineOn2S)& theLine,
 //function : IsPoleOrSeam
 //purpose  : Processes theVertex depending on its type
 //            (pole/apex/point on boundary etc.) and adds it in theLine.
+//           thePIsoRef is the reference point using in case when the
+//            value of correspond parameter cannot be precise.
 //           theSingularSurfaceID contains the ID of surface with
 //            special point (0 - none, 1 - theS1, 2 - theS2)
 //=======================================================================
 static IntPatch_SpecPntType IsPoleOrSeam(const Handle(Adaptor3d_HSurface)& theS1,
                                          const Handle(Adaptor3d_HSurface)& theS2,
+                                         const IntSurf_PntOn2S& thePIsoRef,
                                          Handle(IntSurf_LineOn2S)& theLine,
                                          IntPatch_Point &theVertex,
-                                         const Standard_Real* const theArrPeriods,
+                                         const Standard_Real theArrPeriods[4],
                                          const Standard_Real theTol3d,
                                          Standard_Integer& theSingularSurfaceID)
 {
-  const Standard_Integer aNbPnts = theLine->NbPoints();
-  if(aNbPnts == 0)
-    return IntPatch_SPntNone;
-
   theSingularSurfaceID = 0;
 
   for(Standard_Integer i = 0; i < 2; i++)
@@ -94,8 +93,8 @@ static IntPatch_SpecPntType IsPoleOrSeam(const Handle(Adaptor3d_HSurface)& theS1
       {
         if(IntPatch_SpecialPoints::
               AddSingularPole((isReversed? theS2 : theS1), (isReversed? theS1 : theS2),
-                               theLine->Value(aNbPnts), theTol3d, theVertex,
-                               anApexPoint, isReversed, Standard_True))
+                              thePIsoRef, theVertex, anApexPoint,
+                              isReversed, Standard_True))
         {
           anAddedPType = IntPatch_SPntPole;
           break;
@@ -107,8 +106,8 @@ static IntPatch_SpecPntType IsPoleOrSeam(const Handle(Adaptor3d_HSurface)& theS1
       {
         if(IntPatch_SpecialPoints::
             AddCrossUVIsoPoint((isReversed? theS2 : theS1), (isReversed? theS1 : theS2),
-                                          theLine->Value(aNbPnts), theTol3d,
-                                          anApexPoint, isReversed))
+                                  thePIsoRef, theTol3d,
+                                  anApexPoint, isReversed))
         {
           anAddedPType = IntPatch_SPntSeamUV;
           break;
@@ -208,7 +207,7 @@ IntPatch_ALineToWLine::IntPatch_ALineToWLine(const Handle(Adaptor3d_HSurface)& t
 //function : SetTol3D
 //purpose  : 
 //=======================================================================
-  void IntPatch_ALineToWLine::SetTol3D(const Standard_Real aTol)
+void IntPatch_ALineToWLine::SetTol3D(const Standard_Real aTol)
 {
   myTol3D = aTol;
 }
@@ -216,7 +215,7 @@ IntPatch_ALineToWLine::IntPatch_ALineToWLine(const Handle(Adaptor3d_HSurface)& t
 //function : Tol3D
 //purpose  : 
 //=======================================================================
-  Standard_Real IntPatch_ALineToWLine::Tol3D()const
+Standard_Real IntPatch_ALineToWLine::Tol3D()const
 {
   return myTol3D;
 }
@@ -224,7 +223,7 @@ IntPatch_ALineToWLine::IntPatch_ALineToWLine(const Handle(Adaptor3d_HSurface)& t
 //function : SetTolTransition
 //purpose  : 
 //=======================================================================
-  void IntPatch_ALineToWLine::SetTolTransition(const Standard_Real aTol)
+void IntPatch_ALineToWLine::SetTolTransition(const Standard_Real aTol)
 {
   myTolTransition = aTol;
 }
@@ -232,7 +231,7 @@ IntPatch_ALineToWLine::IntPatch_ALineToWLine(const Handle(Adaptor3d_HSurface)& t
 //function : TolTransition
 //purpose  : 
 //=======================================================================
-  Standard_Real IntPatch_ALineToWLine::TolTransition()const
+Standard_Real IntPatch_ALineToWLine::TolTransition()const
 {
   return myTolTransition;
 }
@@ -240,7 +239,7 @@ IntPatch_ALineToWLine::IntPatch_ALineToWLine(const Handle(Adaptor3d_HSurface)& t
 //function : SetTolOpenDomain
 //purpose  : 
 //=======================================================================
-  void IntPatch_ALineToWLine::SetTolOpenDomain(const Standard_Real aTol)
+void IntPatch_ALineToWLine::SetTolOpenDomain(const Standard_Real aTol)
 {
   myTolOpenDomain = aTol;
 }
@@ -252,6 +251,48 @@ IntPatch_ALineToWLine::IntPatch_ALineToWLine(const Handle(Adaptor3d_HSurface)& t
 {
   return myTolOpenDomain;
 }
+
+//=======================================================================
+//function : GetSectionRadius
+//purpose  : 
+//=======================================================================
+Standard_Real IntPatch_ALineToWLine::GetSectionRadius(const gp_Pnt& thePnt3d) const
+{
+  Standard_Real aRetVal = RealLast();
+  for (Standard_Integer i = 0; i < 2; i++)
+  {
+    const IntSurf_Quadric& aQuad = i ? myQuad2 : myQuad1;
+    if (aQuad.TypeQuadric() == GeomAbs_Cone)
+    {
+      const gp_Cone aCone = aQuad.Cone();
+      const gp_XYZ aRVec = thePnt3d.XYZ() - aCone.Apex().XYZ();
+      const gp_XYZ &aDir = aCone.Axis().Direction().XYZ();
+
+      aRetVal = Min(aRetVal, Abs(aRVec.Dot(aDir)*Tan(aCone.SemiAngle())));
+    }
+    else if (aQuad.TypeQuadric() == GeomAbs_Sphere)
+    {
+      const gp_Sphere aSphere = aQuad.Sphere();
+      const gp_XYZ aRVec = thePnt3d.XYZ() - aSphere.Location().XYZ();
+      const gp_XYZ &aDir = aSphere.Position().Direction().XYZ();
+      const Standard_Real aR = aSphere.Radius();
+      const Standard_Real aD = aRVec.Dot(aDir);
+      const Standard_Real aDelta = aR*aR - aD*aD;
+      if (aDelta <= 0.0)
+      {
+        aRetVal = 0.0;
+        break;
+      }
+      else
+      {
+        aRetVal = Min(aRetVal, Sqrt(aDelta));
+      }
+    }
+  }
+
+  return aRetVal;
+}
+
 //=======================================================================
 //function : MakeWLine
 //purpose  : 
@@ -282,10 +323,81 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
                                       IntPatch_SequenceOfLine& theLines) const 
 {
   const Standard_Integer aNbVert = theALine->NbVertex();
-  if (!aNbVert) {
+  if (aNbVert == 0)
+  {
     return;
   }
+
+#if 0
+  //To draw ALine as a wire DRAW-object use the following code.
+  {
+    static int zzz = 0;
+    zzz++;
+
+    bool flShow = /*(zzz == 1)*/false;
+
+    if (flShow)
+    {
+      std::cout << " +++ DUMP ALine (begin) +++++" << std::endl;
+      Standard_Integer aI = 0;
+      const Standard_Real aStep = (theLPar - theFPar) / 9999.0;
+      for (Standard_Real aPrm = theFPar; aPrm < theLPar; aPrm += aStep)
+      {
+        const gp_Pnt aPP(theALine->Value(aPrm));
+        std::cout << "vertex v" << ++aI << " " << aPP.X() << " " << aPP.Y() << " " << aPP.Z() << std::endl;
+      }
+
+      gp_Pnt aPP(theALine->Value(theLPar));
+      std::cout << "vertex v" << ++aI << " " << aPP.X() << " " << aPP.Y() << " " << aPP.Z() << std::endl;
+      std::cout << " --- DUMP ALine (end) -----" << std::endl;
+    }
+  }
+
+  //Copy all output information and apply it as a TCL-code in DRAW.
+
+  //After that, use TCL-script below:
+
+  /* ********************************* Script (begin)
+  shape ww w
+  copy v1 vprev
+  for {set i 2} {$i <= 10000} {incr i} {
+    distmini dd vprev v$i;
+
+    if { [dval dd_val] > 1.0e-7} {
+      edge ee vprev v$i;
+      add ee ww;
+      copy v$i vprev;
+    }
+  }
+  ********************************** Script (end) */
+#endif
+
+  //The same points can be marked by different vertices.
+  //The code below unifies tolerances of all vertices
+  //marking the same points.
+  for (Standard_Integer i = 1; i < aNbVert; i++)
+  {
+    IntPatch_Point &aCurVert = theALine->ChangeVertex(i);
+    const IntSurf_PntOn2S &aCurrPt = aCurVert.PntOn2S();
+    const Standard_Real aCurToler = aCurVert.Tolerance();
+    for (Standard_Integer j = i + 1; j <= aNbVert; j++)
+    {
+      IntPatch_Point &aVert = theALine->ChangeVertex(j);
+      const IntSurf_PntOn2S &aNewPt = aVert.PntOn2S();
+      const Standard_Real aToler = aVert.Tolerance();
+
+      const Standard_Real aSumTol = aCurToler + aToler;
+      if (aCurrPt.IsSame(aNewPt, aSumTol))
+      {
+        aCurVert.SetTolerance(aSumTol);
+        aVert.SetTolerance(aSumTol);
+      }
+    }
+  }
+
   const Standard_Real aTol = 2.0*myTol3D+Precision::Confusion();
+  const Standard_Real aPrmTol = Max(1.0e-4*(theLPar - theFPar), Precision::PConfusion());
+
   IntPatch_SpecPntType aPrePointExist = IntPatch_SPntNone;
   
   NCollection_Array1<Standard_Real> aVertexParams(1, aNbVert);
@@ -299,7 +411,8 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
   
   for(Standard_Integer i = aVertexParams.Lower(); i <= aVertexParams.Upper(); i++)
   {
-    const Standard_Real aPar = theALine->Vertex(i).ParameterOnLine();
+    const IntPatch_Point& aVert = theALine->Vertex(i);
+    const Standard_Real aPar = aVert.ParameterOnLine();
     aVertexParams(i) = aPar;
     hasVertexBeenChecked(i) = Standard_False;
   }
@@ -344,11 +457,24 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
         }
       }
 
+      Standard_Boolean isPointValid = Standard_False;
       Standard_Real aTgMagn = 0.0;
       {
         gp_Pnt aPnt3d;
         gp_Vec aTg;
         theALine->D1(aParameter, aPnt3d, aTg);
+        if (GetSectionRadius(aPnt3d) < 5.0e-6)
+        {
+          // We cannot compute 2D-parameters of
+          // aPOn2S correctly.
+
+          isPointValid = Standard_False;
+        }
+        else
+        {
+          isPointValid = Standard_True;
+        }
+        
         aTgMagn = aTg.Magnitude();
         Standard_Real u1 = 0.0, v1 = 0.0, u2 = 0.0, v2 = 0.0;
         myQuad1.Parameters(aPnt3d, u1, v1);
@@ -372,13 +498,25 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
         if (aPrePointExist == IntPatch_SPntPole)
         {
           Standard_Real aPrt = 0.5*(aPrevParam + theLPar);
-          for (Standard_Integer i = aVertexParams.Lower(); i <= aVertexParams.Upper(); i++)
+          for (Standard_Integer i = aVertexParams.Lower();
+               i <= aVertexParams.Upper(); i++)
           {
             const Standard_Real aParam = aVertexParams(i);
 
             if (aParam <= aPrevParam)
               continue;
 
+            if ((aParam - aPrevParam) < aPrmTol)
+            {
+              const gp_Pnt aPnt3d(theALine->Value(aParam));
+              if (aPOn2S.Value().SquareDistance(aPnt3d) < Precision::SquareConfusion())
+              {
+                // i-th vertex is the same as a Pole/Apex.
+                // So, it should be ignored.
+                continue;
+              }
+            }
+
             aPrt = 0.5*(aParam + aPrevParam);
             break;
           }
@@ -426,10 +564,17 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
         if(hasVertexBeenChecked(i))
           continue;
 
+        const IntPatch_Point &aVP = theALine->Vertex(i);
         const Standard_Real aParam = aVertexParams(i);
         if( ((aPrevParam < aParam) && (aParam <= aParameter)) ||
-            ((aPrevParam == aParameter) && (aParam == aParameter)))
+            ((aPrevParam == aParameter) && (aParam == aParameter))||
+            (aPOn2S.IsSame(aVP.PntOn2S(), aVP.Tolerance()) && 
+                    (Abs(aVP.ParameterOnLine() - aParameter) < aPrmTol)))
         {
+          //We have either jumped over the vertex or "fell" on the vertex.
+          //However, ALine can be self-interfered. Therefore, we need to check
+          //vertex parameter and 3D-distance together.
+
           aVertexNumber = i;
           break;
         }
@@ -439,10 +584,14 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
       
       if(aVertexNumber < 0)
       {
-        StepComputing(theALine, aPOn2S, theLPar, aParameter, aTgMagn,
-                              aStepMin, aStepMax, myTol3D, aStep);
-        AddPointIntoLine(aLinOn2S, anArrPeriods, aPOn2S);
-        aPrevLPoint = aPOn2S;
+        if (isPointValid)
+        {
+          StepComputing(theALine, aPOn2S, theLPar, aParameter, aTgMagn,
+                        aStepMin, aStepMax, myTol3D, aStep);
+          AddPointIntoLine(aLinOn2S, anArrPeriods, aPOn2S);
+          aPrevLPoint = aPOn2S;
+        }
+
         continue;
       }
 
@@ -453,7 +602,33 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
       // IsPoleOrSeam inserts new point in aLinOn2S if aVtx respects
       //to some special point. Otherwise, aLinOn2S is not changed.
 
-      aPrePointExist = IsPoleOrSeam(myS1, myS2, aLinOn2S, aVtx,
+      // Find a point for reference parameter. It will be used
+      // if real parameter value cannot be precise (see comment to 
+      // IsPoleOrSeam(...) function). 
+      IntSurf_PntOn2S aPrefIso = aVtx.PntOn2S();
+      if (aLinOn2S->NbPoints() < 1)
+      {
+        for (Standard_Integer i = aVertexNumber + 1; i <= aVertexParams.Upper(); i++)
+        {
+          const Standard_Real aParam = aVertexParams(i);
+          if ((aParam - aVertexParams(aVertexNumber)) > Precision::PConfusion())
+          {
+            const Standard_Real aPrm = 0.5*(aParam + aVertexParams(aVertexNumber));
+            const gp_Pnt aPnt3d(theALine->Value(aPrm));
+            Standard_Real u1 = 0.0, v1 = 0.0, u2 = 0.0, v2 = 0.0;
+            myQuad1.Parameters(aPnt3d, u1, v1);
+            myQuad2.Parameters(aPnt3d, u2, v2);
+            aPrefIso.SetValue(aPnt3d, u1, v1, u2, v2);
+            break;
+          }
+        }
+      }
+      else
+      {
+        aPrefIso = aLinOn2S->Value(aLinOn2S->NbPoints());
+      }
+
+      aPrePointExist = IsPoleOrSeam(myS1, myS2, aPrefIso, aLinOn2S, aVtx,
                                 anArrPeriods, aTol, aSingularSurfaceID);
 
       const Standard_Real aCurVertParam = aVtx.ParameterOnLine();
@@ -463,6 +638,12 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
       }
       else
       {
+        if (!isPointValid)
+        {
+          //Take a farther point of ALine (with greater parameter)
+          continue;
+        }
+
         if(aVtx.Tolerance() > aTol)
         {
           aVtx.SetValue(aPOn2S);
@@ -507,7 +688,7 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
         }
       }
 
-      if(aPrePointExist != IntPatch_SPntNone)
+      if ((aPrePointExist != IntPatch_SPntNone) && (aLinOn2S->NbPoints() > 1))
         break;
     }//for(; !isLast; aParameter += aStep)
 
@@ -586,6 +767,9 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
     if (aWLine->NbPnts() > 1)
     {
       aWLine->EnablePurging(Standard_False);
+#ifdef INTPATCH_ALINETOWLINE_DEBUG
+      aWLine->Dump(0);
+#endif
       theLines.Append(aWLine);
     }
   }//while(aParameter < theLPar)
@@ -653,6 +837,19 @@ Standard_Boolean IntPatch_ALineToWLine::
   const Standard_Real aR = IntPatch_PointLine::
                             CurvatureRadiusOfIntersLine(myS1, myS2, thePOn2S);
 
+#if 0
+  {
+    static int zzz = 0;
+    zzz++;
+    std::cout << "*** R" << zzz << " (begin)" << std::endl;
+    Standard_Real aU1, aV1, aU2, aV2;
+    thePOn2S.Parameters(aU1, aV1, aU2, aV2);
+    std::cout << "Prms: " << aU1 << ", " << aV1 << ", " << aU2 << ", " << aV2 << std::endl;
+    std::cout << "Radius = " << aR << std::endl;
+    std::cout << "*** R" << zzz << " (end)" << std::endl;
+  }
+#endif
+
   if(aR < 0.0)
   {
     return Standard_False;

src/IntPatch/IntPatch_ALineToWLine.hxx

@@ -80,11 +80,18 @@ protected:
                                                  const Standard_Real theMaxDeflection,
                                                  Standard_Real& theStep) const;
 
-
+  //! Compares distances from theMidPt to every quadrics with theMaxDeflection
+  //! (maximal distance of two ones is taken into account).
+  //! Returns the result of this comparison: -1 - small distance, +1 - big distance,
+  //! 0 - Dist == theMaxDeflection. Comparisons are done with internal tolerances.
   Standard_EXPORT Standard_Integer CheckDeflection(const gp_XYZ& theMidPt,
                                                    const Standard_Real theMaxDeflection) const;
 
-
+  //! Returns radius of a circle obtained by intersection the quadric with a plane
+  //! goes through thePnt3d perpendicular to the quadric axis. This radius is computed
+  //! for both quadrics and minimal value is returned.
+  //! This check is made for cone and sphere only.
+  Standard_EXPORT Standard_Real GetSectionRadius(const gp_Pnt& thePnt3d) const;
 
 private:
 

src/IntPatch/IntPatch_ImpImpIntersection_0.gxx

@@ -42,24 +42,26 @@ static void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
 			    const Standard_Boolean,
 			    const Standard_Real);
 
-static Standard_Boolean MultiplePoint (const IntPatch_SequenceOfPathPointOfTheSOnBounds&,
-				       const Handle(Adaptor3d_TopolTool)&,
-				       const IntSurf_Quadric&,
-		                       const gp_Vec&,
-		                       const IntPatch_SequenceOfLine&,
-                                       TColStd_Array1OfInteger&,
-                                       TColStd_Array1OfInteger&,
-                                       const Standard_Integer,
-		                       const Standard_Boolean);
+static Standard_Boolean MultiplePoint(const IntPatch_SequenceOfPathPointOfTheSOnBounds& listpnt,
+                                      const Handle(Adaptor3d_TopolTool)& Domain,
+                                      const IntSurf_Quadric& QuadSurf,
+                                      const gp_Vec&    Normale,
+                                      const IntPatch_SequenceOfLine& slin,
+                                      TColStd_Array1OfInteger& Done,
+                                      TColStd_Array1OfInteger& UsedLine,
+                                      const Standard_Integer Index,
+                                      const Standard_Boolean OnFirst,
+                                      const Standard_Real theToler);
 
-static Standard_Boolean PointOnSecondDom (const IntPatch_SequenceOfPathPointOfTheSOnBounds&,
-					  const Handle(Adaptor3d_TopolTool)&,
-					  const IntSurf_Quadric&,
-		                          const gp_Vec&,
-		                          const gp_Vec&,
-		                          const Handle(IntPatch_Line)&,
-                                          TColStd_Array1OfInteger&,
-                                          const Standard_Integer);
+static Standard_Boolean PointOnSecondDom(const IntPatch_SequenceOfPathPointOfTheSOnBounds& listpnt,
+                                         const Handle(Adaptor3d_TopolTool)& Domain,
+                                         const IntSurf_Quadric& QuadSurf,
+                                         const gp_Vec&    Normale,
+                                         const gp_Vec&    Vtgint,
+                                         const Handle(IntPatch_Line)& lin,
+                                         TColStd_Array1OfInteger& Done,
+                                         const Standard_Integer Index,
+                                         const Standard_Real theToler);
 
 static Standard_Boolean SingleLine (const gp_Pnt&,
 				    const Handle(IntPatch_Line)&,
@@ -68,17 +70,19 @@ static Standard_Boolean SingleLine (const gp_Pnt&,
 				    gp_Vec&);
 
 
-static Standard_Boolean FindLine (gp_Pnt&,
-				  const IntPatch_SequenceOfLine&,
-				  const Standard_Real,
-				  Standard_Real&,
-				  gp_Vec&,
-				  Standard_Integer&,
-				  Standard_Integer,
-				  const Handle(Adaptor2d_HCurve2d)&,
-				  Standard_Real&,
-				  gp_Pnt& pointonarc,
-				  const IntSurf_Quadric&);
+static Standard_Boolean FindLine(gp_Pnt& Psurf,
+                                 const IntPatch_SequenceOfLine& slin,
+                                 const Standard_Real Tol,
+                                 TColStd_ListOfReal& theLParams,
+                                 gp_Vec& Vtgtint,
+                                 Standard_Integer& theLineIdx,
+                                 Standard_Integer OnlyThisLine,
+                                 const Handle(Adaptor2d_HCurve2d)& thearc,
+                                 Standard_Real& theparameteronarc,
+                                 gp_Pnt& thepointonarc,
+                                 const IntSurf_Quadric& QuadSurf1,
+                                 const IntSurf_Quadric& QuadSurf2,
+                                 Standard_Real& theOutputToler);
 
 static void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds&,
 			     IntPatch_SequenceOfLine&,
@@ -102,8 +106,7 @@ Standard_Boolean IntersectionWithAnArc(gp_Pnt& PSurf,
 				       gp_Pnt& thepointonarc,
 				       const IntSurf_Quadric& QuadSurf,
 				       const Standard_Real u0alin,
-				       const Standard_Real u1alin,
-				       Standard_Real& actualdist) { 
+				       const Standard_Real u1alin) { 
   Standard_Real dtheta,theta;
 #ifdef OCCT_DEBUG
   //Standard_Real u,v,A,B,C,cost,sint,sign;
@@ -221,7 +224,6 @@ Standard_Boolean IntersectionWithAnArc(gp_Pnt& PSurf,
       thepointonarc = alin->Value(para);
       cpasok=Standard_False;
 //--      printf("\nt:%d",nbiter);
-      actualdist = bestdist;
       return(Standard_True);
     }
     else { 
@@ -249,7 +251,6 @@ Standard_Boolean IntersectionWithAnArc(gp_Pnt& PSurf,
     _theparameteronarc=bestpara;
     thepointonarc = alin->Value(para);
 //--     printf("\nT:%d",nbiter);
-    actualdist=bestdist;
     return(Standard_True);
   }
 //--   printf("\nF:%d",nbiter);
@@ -383,7 +384,7 @@ void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
   //
   Standard_Integer i,k;
   Standard_Integer linenumber;
-  Standard_Real paraint = 0.,currentparameter,tolerance;
+  Standard_Real currentparameter,tolerance;
   Standard_Real U1,V1,U2,V2;
   Standard_Boolean goon;
   
@@ -429,10 +430,10 @@ void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
 	Vtgrst.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
 #endif      
         goon = MultiplePoint(listpnt,Domain,QuadSurf,Normale,slin,Done, UsedLine,
-			     i,OnFirst);
+                             i, OnFirst, Tolarc);
       }
       if (goon) {
-	Standard_Boolean linefound;
+        Standard_Boolean linefound = Standard_False;
 	
 	for(Standard_Integer indiceline = 1; indiceline <=slin.Length(); indiceline++) { 
 	  if( UsedLine(indiceline) != 0 )
@@ -470,8 +471,11 @@ void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
 	  //  Modified by skv - Thu Jan 15 15:57:15 2004 OCC4455 End
 	  gp_Pnt pointonarc;
 	  Vtgint.SetCoord(0,0,0);
-	  linefound = FindLine(Psurf,slin,tolerance,paraint,Vtgint,linenumber,indiceline,
-			       currentarc,currentparameter,pointonarc,QuadSurf);  
+          Standard_Real aVertTol = Tolarc;
+          TColStd_ListOfReal aLParams;
+          linefound = FindLine(Psurf, slin, tolerance, aLParams, Vtgint, linenumber,
+                               indiceline, currentarc, currentparameter,
+                               pointonarc, QuadSurf, OtherQuad, aVertTol);
 	  if (linefound) {
 	    
 #if 1 
@@ -493,14 +497,14 @@ void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
 	      // deuxieme surface
 	      
 	      goon = PointOnSecondDom (listpnt, Domain, QuadSurf, Normale, 
-				       Vtgint, lin, Done, i);
+                                       Vtgint, lin, Done, i, aVertTol);
 	    }
 	    
 	    if (goon) {
 	      //-- Modification du 4 avril 97    tolerance->Tolarc
 	      //-- on replace sur le vertex la tolerance d entree et 
 	      //-- non la tolerance qui a servi au FindLine
-	      solpnt.SetValue(Psurf,Tolarc,Standard_False);
+              solpnt.SetValue(Psurf, aVertTol, Standard_False);
 	      
 	      U1 = p2d.X(); V1 = p2d.Y();
 	      OtherQuad.Parameters(Psurf,U2,V2);
@@ -513,7 +517,6 @@ void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
 		Recadre(S1,S2,U2,V2,U1,V1);
 		solpnt.SetParameters(U2,V2,U1,V1);
 	      }
-	      solpnt.SetParameter(paraint);
 	      
 	      if (! currentpointonrst.IsNew()) {
 		vtx = currentpointonrst.Vertex();
@@ -532,12 +535,21 @@ void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
 	      }
 	      solpnt.SetArc(OnFirst,currentarc, currentparameter,
 			    Transline,Transarc);
-	      if (TheType == IntPatch_Analytic) {
-		Handle(IntPatch_ALine)::DownCast (lin)->AddVertex(solpnt);
-	      }
-	      else {
-		Handle(IntPatch_GLine)::DownCast (lin)->AddVertex(solpnt);
-	      }
+
+              for (TColStd_ListIteratorOfListOfReal anItr(aLParams);
+                   anItr.More(); anItr.Next())
+              {
+                solpnt.SetParameter(anItr.Value());
+                if (TheType == IntPatch_Analytic)
+                {
+                  Handle(IntPatch_ALine)::DownCast(lin)->AddVertex(solpnt);
+                }
+                else
+                {
+                  Handle(IntPatch_GLine)::DownCast(lin)->AddVertex(solpnt);
+                }
+              }
+
 	      Done(i) = 1;
 	      
 	      if (goon) {
@@ -550,6 +562,7 @@ void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
 		      }		      
 		      else if (Domain->Identical(vtx, vtxbis)) {
 			solpnt.SetVertex(OnFirst,vtxbis);
+                        solpnt.SetTolerance(Tolarc);
 			currentarc = currentpointonrst.Arc();
 			currentparameter = currentpointonrst.Parameter();
 			
@@ -599,7 +612,8 @@ Standard_Boolean  MultiplePoint (const IntPatch_SequenceOfPathPointOfTheSOnBound
                                  TColStd_Array1OfInteger& Done,
                                  TColStd_Array1OfInteger& UsedLine,
                                  const Standard_Integer Index,
-		                 const Standard_Boolean OnFirst) {
+		                 const Standard_Boolean OnFirst,
+                                 const Standard_Real theToler) {
 
 // Traitement des points "multiples".
 
@@ -696,7 +710,7 @@ Standard_Boolean  MultiplePoint (const IntPatch_SequenceOfPathPointOfTheSOnBound
 
 	  intpt.SetArc(OnFirst,currentarc,currentparameter,
 		       Transline,Transarc);
-
+          intpt.SetTolerance(theToler);
 
 	  if (TheType == IntPatch_Analytic) {
 	    Handle(IntPatch_ALine)::DownCast (slinValueii)->Replace(jj,intpt);
@@ -728,6 +742,7 @@ Standard_Boolean  MultiplePoint (const IntPatch_SequenceOfPathPointOfTheSOnBound
 		    }
 	            intpt.SetArc(OnFirst,currentarc,currentparameter,
                                  Transline,Transarc);
+                    intpt.SetTolerance(theToler);
 	            if (TheType == IntPatch_Analytic) {
 	              Handle(IntPatch_ALine)::DownCast (slinValueii)->AddVertex(intpt);
 	            }
@@ -770,7 +785,8 @@ Standard_Boolean PointOnSecondDom (const IntPatch_SequenceOfPathPointOfTheSOnBou
 				   const gp_Vec&    Vtgint,
 				   const Handle(IntPatch_Line)& lin,
 				   TColStd_Array1OfInteger& Done,
-				   const Standard_Integer Index)
+				   const Standard_Integer Index,
+                                   const Standard_Real theToler)
      
 
 // Duplication des points sur domaine de l autre surface.
@@ -841,6 +857,8 @@ Standard_Boolean PointOnSecondDom (const IntPatch_SequenceOfPathPointOfTheSOnBou
 	}
 	intpt.SetArc(Standard_False,currentarc,currentparameter,
 	             Transline,Transarc);
+        intpt.SetTolerance(theToler);
+
 	if (TheType == IntPatch_Analytic) {
 	  Handle(IntPatch_ALine)::DownCast (lin)->Replace(jj,intpt);
 	}
@@ -871,6 +889,7 @@ Standard_Boolean PointOnSecondDom (const IntPatch_SequenceOfPathPointOfTheSOnBou
 		  }
 	          intpt.SetArc(Standard_False,currentarc,currentparameter,
                                Transline,Transarc);
+                  intpt.SetTolerance(theToler);
 	          if (TheType == IntPatch_Analytic) {
 	            Handle(IntPatch_ALine)::DownCast (lin)->AddVertex(intpt);
 	          }
@@ -905,31 +924,36 @@ Standard_Boolean PointOnSecondDom (const IntPatch_SequenceOfPathPointOfTheSOnBou
 
 
 
-Standard_Boolean FindLine (gp_Pnt& Psurf,
-			   const IntPatch_SequenceOfLine& slin,
-			   const Standard_Real Tol,
-			   Standard_Real& Paraint,
-			   gp_Vec& Vtgtint,
-			   Standard_Integer& Range,
-			   Standard_Integer OnlyThisLine,
-			   const Handle(Adaptor2d_HCurve2d)& thearc,
-			   Standard_Real& theparameteronarc,
-			   gp_Pnt& thepointonarc,
-			   const IntSurf_Quadric& QuadSurf)
-{		 
+Standard_Boolean FindLine(gp_Pnt& Psurf,
+                          const IntPatch_SequenceOfLine& slin,
+                          const Standard_Real Tol,
+                          TColStd_ListOfReal& theLParams,
+                          gp_Vec& Vtgtint,
+                          Standard_Integer& theLineIdx,
+                          Standard_Integer OnlyThisLine,
+                          const Handle(Adaptor2d_HCurve2d)& thearc,
+                          Standard_Real& theparameteronarc,
+                          gp_Pnt& thepointonarc,
+                          const IntSurf_Quadric& QuadSurf1,
+                          const IntSurf_Quadric& QuadSurf2,
+                          Standard_Real& theOutputToler)
+{
+  if ((QuadSurf1.Distance(Psurf) > Tol) || (QuadSurf2.Distance(Psurf) > Tol))
+    return Standard_False;
 
 // Traitement du point de depart ayant pour representation Psurf
 // dans l espace. On recherche la ligne d intersection contenant ce point.
 // On a en sortie la ligne, et le parametre et sa tangente du point sur
 // la ligne d intersection.
-
-  Standard_Real distmin = RealLast();
-  Standard_Real dist,para;
+  const Standard_Real aSqTol = Tol*Tol;
+  Standard_Real aSqDistMin = RealLast();
+  Standard_Real aSqDist, para;
   Standard_Real lower,upper;
   gp_Pnt pt;
   Standard_Integer i;
   IntPatch_IType typarc;
 
+  Standard_Real aParaInt = RealLast();
   Standard_Integer nblin = slin.Length();
   for (i=1; i<=nblin; i++) {
     if(OnlyThisLine) { i=OnlyThisLine; nblin=0; }
@@ -961,11 +985,12 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
 	para = ElCLib::Parameter(Handle(IntPatch_GLine)::DownCast (lin)->Line(),Psurf);
 	if (para <= upper && para >= lower) {
 	  pt = ElCLib::Value(para,Handle(IntPatch_GLine)::DownCast (lin)->Line());
-	  dist = Psurf.Distance(pt);
-	  if (dist< distmin) {
-	    distmin = dist;
-	    Paraint = para;
-	    Range = i;
+          aSqDist = Psurf.SquareDistance(pt);
+          if ((aSqDist < aSqTol) && (aSqDist < aSqDistMin))
+          {
+            aSqDistMin = aSqDist;
+            aParaInt = para;
+            theLineIdx = i;
 	  }
 	}
       }
@@ -977,11 +1002,12 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
 	    (para + 2.*M_PI <=upper && para + 2.*M_PI >= lower) ||
 	    (para - 2.*M_PI <=upper && para - 2.*M_PI >= lower)) {
 	  pt = ElCLib::Value(para,Handle(IntPatch_GLine)::DownCast (lin)->Circle());
-	  dist = Psurf.Distance(pt);
-	  if (dist< distmin) {
-	    distmin = dist;
-	    Paraint = para;
-	    Range = i;
+          aSqDist = Psurf.SquareDistance(pt);
+          if ((aSqDist < aSqTol) && (aSqDist < aSqDistMin))
+          {
+            aSqDistMin = aSqDist;
+            aParaInt = para;
+            theLineIdx = i;
 	  }
 	}
       }
@@ -993,11 +1019,12 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
 	    (para + 2.*M_PI <=upper && para + 2.*M_PI >= lower) ||
 	    (para - 2.*M_PI <=upper && para - 2.*M_PI >= lower)) {
 	  pt = ElCLib::Value(para,Handle(IntPatch_GLine)::DownCast (lin)->Ellipse());
-	  dist = Psurf.Distance(pt);
-	  if (dist< distmin) {
-	    distmin = dist;
-	    Paraint = para;
-	    Range = i;
+          aSqDist = Psurf.SquareDistance(pt);
+          if ((aSqDist < aSqTol) && (aSqDist < aSqDistMin))
+          {
+            aSqDistMin = aSqDist;
+            aParaInt = para;
+            theLineIdx = i;
 	  }
 	}
       }
@@ -1030,24 +1057,28 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
 	    Standard_Real parabis = para+0.0000001;
 	    
 	    pt = ElCLib::Value(para,Parab);
-	    dist = Psurf.Distance(pt);
+            aSqDist = Psurf.SquareDistance(pt);
 	    
-	    gp_Pnt ptbis = ElCLib::Value(parabis,Parab);
-	    Standard_Real distbis = Psurf.Distance(ptbis);
-	    
-	    Standard_Real ddist = distbis-dist;
+	    const gp_Pnt ptbis = ElCLib::Value(parabis,Parab);
+	    const Standard_Real distbis = Psurf.Distance(ptbis);
+            const Standard_Real aDist = Sqrt(aSqDist);
+            const Standard_Real ddist = distbis - aDist;
 	    
 	    //--cout<<" para: "<<para<<"    dist:"<<dist<<"   ddist:"<<ddist<<endl;
 	    
-	    if (dist< distmin) {
-	      distmin = dist;
-	      Paraint = para;
-	      Range = i;
+            if ((aSqDist < aSqTol) && (aSqDist < aSqDistMin))
+            {
+              aSqDistMin = aSqDist;
+              aParaInt = para;
+              theLineIdx = i;
 	    }
-	    if(dist<1.0e-9 && dist>-1.0e-9) { amelioration=100; } 
+            if (aSqDist < Precision::SquarePConfusion())
+            {
+              amelioration = 100;
+            }
 	      
 	    if(ddist>1.0e-9 || ddist<-1.0e-9 ) { 
-	      para=para-dist*(parabis-para)/ddist;
+              para = para - aDist*(parabis - para) / ddist;
 	    }
 	    else { 
 	      amelioration=100;
@@ -1065,11 +1096,12 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
 	para = ElCLib::Parameter(Handle(IntPatch_GLine)::DownCast (lin)->Hyperbola(),Psurf);
 	if (para <= upper && para >= lower) {
 	  pt = ElCLib::Value(para,Handle(IntPatch_GLine)::DownCast (lin)->Hyperbola());
-	  dist = Psurf.Distance(pt);
-	  if (dist< distmin) {
-	    distmin = dist;
-	    Paraint = para;
-	    Range = i;
+          aSqDist = Psurf.SquareDistance(pt);
+          if ((aSqDist < aSqTol) && (aSqDist < aSqDistMin))
+          {
+            aSqDistMin = aSqDist;
+            aParaInt = para;
+            theLineIdx = i;
 	  }
 	}
       }
@@ -1077,17 +1109,33 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
 
     case IntPatch_Analytic :
       {
-	Handle(IntPatch_ALine) alin (Handle(IntPatch_ALine)::DownCast (lin));
-	Standard_Boolean FindIsOk = alin->FindParameter(Psurf,para);
-	if (FindIsOk) {
-	  pt = alin->Value(para);
-	  dist = Psurf.Distance(pt);
-	  if (dist< distmin) {
-	    distmin = dist;
-	    Paraint = para;
-	    Range = i;
-	  }
-	}
+        Handle(IntPatch_ALine) alin(Handle(IntPatch_ALine)::DownCast(lin));
+        TColStd_ListOfReal aLParams;
+        alin->FindParameter(Psurf, aLParams);
+        if (!aLParams.IsEmpty())
+        {
+          // All found distances are already in some internal tolerance
+          // set in alin->FindParameter(...) method.
+
+          aSqDist = RealLast();
+          for (TColStd_ListIteratorOfListOfReal anItr(aLParams);
+               anItr.More(); anItr.Next())
+          {
+            pt = alin->Value(anItr.Value());
+            const Standard_Real aSqD = Psurf.SquareDistance(pt);
+            if (aSqD < aSqDist)
+            {
+              aSqDist = aSqD;
+            }
+          }
+
+          if (aSqDist < aSqDistMin)
+          {
+            aSqDistMin = aSqDist;
+            theLParams = aLParams;
+            theLineIdx = i;
+          }
+        }
 	else { 
 	  //-- le point n a pas ete trouve par bete projection.
 	  //-- on essaie l intersection avec la restriction en 2d
@@ -1096,19 +1144,20 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
 //	  Standard_Real anpara=para;
 //#endif
 	  gp_Pnt CopiePsurf=Psurf;
-	  Standard_Boolean IntersectIsOk=IntersectionWithAnArc(CopiePsurf,alin,para,thearc,theparamonarc,thepointonarc,QuadSurf,lower,upper,dist);
-
-	  //--printf("\nIntersectionWithAnArc   %d \n Psurf(%g,%g,%g)->(%g,%g,%g)  dist=%g\n para(%g)->(%g)\n paraonarc(%g)->(%g)",
-	  //--   ok,Psurf.X(),Psurf.Y(),Psurf.Z(),thepointonarc.X(),thepointonarc.Y(),thepointonarc.Z(),dist,
-	  //--    anpara,para,theparameteronarc,theparamonarc);
-	  dist = CopiePsurf.Distance(Psurf);
+          Standard_Boolean IntersectIsOk = IntersectionWithAnArc(CopiePsurf, alin, para, 
+                                                                 thearc, theparamonarc,
+                                                                 thepointonarc,
+                                                                 QuadSurf1,
+                                                                 lower, upper);
+          aSqDist = CopiePsurf.SquareDistance(Psurf);
 	  if(IntersectIsOk) {
-	    if(dist<Tol) { 
+            if (aSqDist < aSqTol)
+            {
 	      theparameteronarc = theparamonarc;
 	      Psurf = thepointonarc;
-	      distmin = dist;
-	      Paraint = para;
-	      Range = i;
+              aSqDistMin = aSqDist;
+              theLParams.Append(para);
+              theLineIdx = i;
 	    }
 	  }
 	}
@@ -1124,86 +1173,47 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
     }
   }
 
-  if (distmin > Tol) {
+  if (aSqDistMin == RealLast())
     return Standard_False;
-  }
 
-  typarc = slin.Value(Range)->ArcType();
+  theOutputToler = Max(theOutputToler, Sqrt(aSqDistMin));
 
-  // Calcul de la tangente.
+  typarc = slin.Value(theLineIdx)->ArcType();
+
+  // Computation of tangent vector
   switch (typarc) {
   case IntPatch_Lin :
-    Vtgtint = (*((Handle(IntPatch_GLine)*)&slin(Range)))->Line().Direction();
+    theLParams.Append(aParaInt);
+    Vtgtint = (*((Handle(IntPatch_GLine)*)&slin(theLineIdx)))->Line().Direction();
     break;
   case IntPatch_Circle :
-    Vtgtint = ElCLib::DN(Paraint,(*((Handle(IntPatch_GLine)*)&slin(Range)))->Circle(),1);
+    theLParams.Append(aParaInt);
+    Vtgtint = ElCLib::DN(aParaInt, (*((Handle(IntPatch_GLine)*)&slin(theLineIdx)))->Circle(), 1);
     break;
   case IntPatch_Ellipse :
-    Vtgtint = ElCLib::DN(Paraint,(*((Handle(IntPatch_GLine)*)&slin(Range)))->Ellipse(),1);
+    theLParams.Append(aParaInt);
+    Vtgtint = ElCLib::DN(aParaInt, (*((Handle(IntPatch_GLine)*)&slin(theLineIdx)))->Ellipse(), 1);
     break;
   case IntPatch_Parabola :
-    Vtgtint = ElCLib::DN(Paraint,(*((Handle(IntPatch_GLine)*)&slin(Range)))->Parabola(),1);
+    theLParams.Append(aParaInt);
+    Vtgtint = ElCLib::DN(aParaInt, (*((Handle(IntPatch_GLine)*)&slin(theLineIdx)))->Parabola(), 1);
     break;
   case IntPatch_Hyperbola :
-    Vtgtint = ElCLib::DN(Paraint,(*((Handle(IntPatch_GLine)*)&slin(Range)))->Hyperbola(),1);
+    theLParams.Append(aParaInt);
+    Vtgtint = ElCLib::DN(aParaInt, (*((Handle(IntPatch_GLine)*)&slin(theLineIdx)))->Hyperbola(), 1);
     break;
 
   case IntPatch_Analytic:
     {
-      const Handle(IntPatch_ALine)& alin = (*((Handle(IntPatch_ALine)*)&slin(Range)));
-      Standard_Boolean abid = alin->D1(Paraint,pt,Vtgtint);
-      if (!abid) { 
-	Standard_Real domaininf,domainsup,paramproche;
-	Standard_Boolean boolbid;
-	domaininf = alin->FirstParameter(boolbid);
-	domainsup = alin->LastParameter(boolbid);
-	if(Paraint>=domaininf && Paraint<=domainsup) { 
-	  Standard_Real DeltaParam = 0.001 * (domainsup-domaininf);
-	  if(Paraint-domaininf >= domainsup-Paraint) {
-	    //-- On decale le point vers le parametre le plus eloigne.
-	    DeltaParam = -DeltaParam;
-	  }
-	  Standard_Integer kountbid = 0;
-	  Standard_Boolean bornok = Standard_True;
-	  paramproche = Paraint;
-	  do { 
-	    paramproche+=DeltaParam;
-	    kountbid++;
-	    gp_Pnt ptbid;
-	    if(paramproche>=domaininf && paramproche<=domainsup) {
-	      abid = alin->D1(paramproche,ptbid,Vtgtint);   
-	    }
-	    else { 
-	      bornok = Standard_False; 
-	    } 
-	  }
-	  while(abid==Standard_False && kountbid<5 && bornok);
-	  //-- Attention aux points de tangence (croisement de 4 lignes )
-	  bornok = Standard_True;
-	  kountbid = 0;
-	  gp_Vec OVtgtint(0.0,0.0,0.0);
-	  paramproche = Paraint;
-	  do { 
-	    paramproche-=DeltaParam;
-	    kountbid++;
-	    gp_Pnt ptbid;
-	    if(paramproche>=domaininf && paramproche<=domainsup) {
-	      abid = alin->D1(paramproche,ptbid,OVtgtint);   
-	    }
-	    else { 
-	      bornok = Standard_False; 
-	    } 
-	  }
-	  while(abid==Standard_False && kountbid<5 && bornok);
-	  if(bornok) { 
-	    paramproche = Vtgtint.Dot(OVtgtint);
-	    if(paramproche<=0.0) abid = Standard_False; 
-	  }
-	}
-	if(!abid) { 
-	  //-- cout << "Pb sur Calcul de derivee 111 " << endl;
-	  Vtgtint.SetCoord(0.,0.,0.);
-	}
+      if (!Handle(IntPatch_ALine)::DownCast(slin(theLineIdx))->D1(theLParams.Last(), pt, Vtgtint))
+      {
+        //Previously (before the fix #29807) this code tried to process case
+        //when Handle(IntPatch_ALine)::D1(...) method returns FALSE and
+        //computed Vtgtint input argument value. Currently, any singularities
+        //must be processed by high-level algorithms (IntPatch_SpecialPoints class).
+        //Therefore this code has been deleted as deprecated.
+
+        Vtgtint.SetCoord(0.0, 0.0, 0.0);
       }
     }
     break;
@@ -1218,19 +1228,20 @@ Standard_Boolean FindLine (gp_Pnt& Psurf,
   return Standard_True;
 }
 
-
-Standard_Boolean  SingleLine (const gp_Pnt& Psurf,
-			      const Handle(IntPatch_Line)& lin,
-			      const Standard_Real Tol,
-			      Standard_Real& Paraint,
-			      gp_Vec& Vtgtint) {		 
-
-// Traitement du point de depart ayant pour representation Psurf
-// dans l espace. On le replace sur la ligne d intersection; On a en sortie
-// son parametre et sa tangente sur la ligne d intersection.
-// La fonction renvoie False si le point projete est a une distance
-// superieure a Tol du point a projeter.
-
+//=======================================================================
+//function : SingleLine
+//purpose  : Traitement du point de depart ayant pour representation Psurf
+//            dans l espace. On le replace sur la ligne d intersection; On a en sortie
+//            son parametre et sa tangente sur la ligne d intersection.
+//            La fonction renvoie False si le point projete est a une distance
+//            superieure a Tol du point a projeter.
+//=======================================================================
+Standard_Boolean  SingleLine(const gp_Pnt& Psurf,
+                             const Handle(IntPatch_Line)& lin,
+                             const Standard_Real Tol,
+                             Standard_Real& Paraint,
+                             gp_Vec& Vtgtint)
+{
   IntPatch_IType typarc = lin->ArcType();
 
   Standard_Real parproj = 0.;
@@ -1238,7 +1249,6 @@ Standard_Boolean  SingleLine (const gp_Pnt& Psurf,
   gp_Pnt ptproj;
   Standard_Boolean retvalue;
 
-
   switch (typarc) {
   case IntPatch_Lin :
     parproj = ElCLib::Parameter(Handle(IntPatch_GLine)::DownCast (lin)->Line(),Psurf);
@@ -1262,46 +1272,30 @@ Standard_Boolean  SingleLine (const gp_Pnt& Psurf,
     break;
   case IntPatch_Analytic :
     {
-      Handle(IntPatch_ALine) alin (Handle(IntPatch_ALine)::DownCast (lin));
-      Standard_Boolean ok = alin->FindParameter(Psurf,parproj);
-      if (ok) {
-	gp_Pnt ptbid;
-	Standard_Boolean bid = alin->D1(parproj,ptbid,tgint);
-	if (!bid) { 
-	  Standard_Real domaininf,domainsup,paramproche;
-	  Standard_Boolean boolbid;
-	  domaininf = alin->FirstParameter(boolbid);
-	  domainsup = alin->LastParameter(boolbid);
-	  if(parproj>=domaininf && parproj<=domainsup) { 
-	    Standard_Real DeltaParam = 0.001 * (domainsup-domaininf);
-	    if(parproj-domaininf >= domainsup-parproj) {
-	      //-- On decale le point vers le parametre le plus eloigne.
-	      DeltaParam = -DeltaParam;
-	    }
-	    Standard_Integer kountbid = 0;
-	    paramproche = parproj;
-	    do { 
-	      paramproche+=DeltaParam;
-	      kountbid++;
-	      bid = alin->D1(paramproche,ptbid,tgint);   
-	    }
-	    while(bid==Standard_False && kountbid<5);
-	    ptproj = Psurf; 
-	  }
-	  if(!bid) { 
-	    //-- cout << "Pb sur Calcul de derivee ALine " << endl;
-	    tgint.SetCoord(0.,0.,0.);
-	    return(Standard_False);
-	  }
-	}
-	else { 
-	  ptproj = Psurf; 
-	}
+      Handle(IntPatch_ALine) alin(Handle(IntPatch_ALine)::DownCast(lin));
+      TColStd_ListOfReal aLParams;
+      alin->FindParameter(Psurf, aLParams);
+      if (!aLParams.IsEmpty())
+      {
+        ptproj = Psurf;
+        parproj = aLParams.Last();
+        gp_Pnt aPtemp;
+        if (!alin->D1(parproj, aPtemp, tgint))
+        {
+          //Previously (before the fix #29807) this code tried to process case
+          //when Handle(IntPatch_ALine)::D1(...) method returns FALSE and
+          //computed Vtgtint input argument value. Currently, any singularities
+          //must be processed by high-level algorithms (IntPatch_SpecialPoints class).
+          //Therefore this code has been deleted as deprecated.
+
+          tgint.SetCoord(0.0, 0.0, 0.0);
+        }
       }
-      else {
-	//-- cout << "---- Pb sur ligne analytique dans SingleLine" << endl;
-	//-- cout << "     Find Parameter"<<endl;
-	return Standard_False;
+      else
+      {
+        //-- cout << "---- Pb sur ligne analytique dans SingleLine" << endl;
+        //-- cout << "     Find Parameter"<<endl;
+        return Standard_False;
       }
     }
     break;
@@ -1485,6 +1479,7 @@ void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds& listedg,
 	  if (EdgeDegenere==Standard_False && dofirst) {
 	    if (ptvtx.Value().Distance(PStartf.Value()) <=TolArc) {
 	      ptvtx.SetMultiple(Standard_True);
+              ptvtx.SetTolerance(TolArc);
 	      if (typ == IntPatch_Analytic) {
 		Handle(IntPatch_ALine)::DownCast (slinj)->Replace(k,ptvtx);
 	      }
@@ -1549,6 +1544,7 @@ void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds& listedg,
 	  if (EdgeDegenere==Standard_False && dolast) {
 	    if (ptvtx.Value().Distance(PStartl.Value()) <=TolArc) {
 	      ptvtx.SetMultiple(Standard_True);
+              ptvtx.SetTolerance(TolArc);
 	      if (typ == IntPatch_Analytic) {
 		Handle(IntPatch_ALine)::DownCast (slinj)->Replace(k,ptvtx);
 	      }
@@ -1988,6 +1984,7 @@ void ProcessRLine (IntPatch_SequenceOfLine& slin,
 	      }
 	      if (keeppoint) {
 		Ptvtx.SetMultiple(Standard_True);
+                Ptvtx.SetTolerance(_TolArc);
 		newptvtx.SetMultiple(Standard_True);
 		
 		if (typ2 == IntPatch_Analytic) {

src/IntPatch/IntPatch_ImpImpIntersection_2.gxx

@@ -307,11 +307,15 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)&  S1,
       }
       nbpt = solrst.NbPoints();
       nbseg= solrst.NbSegments();
-      for (i=1; i<= nbpt; i++) {
-        pnt1.Append(solrst.Point(i));
+      for (i = 1; i <= nbpt; i++)
+      {
+        const IntPatch_ThePathPointOfTheSOnBounds& aPt = solrst.Point(i);
+        pnt1.Append(aPt);
       }
-      for (i=1; i<= nbseg; i++) {
-        edg1.Append(solrst.Segment(i));
+      for (i = 1; i <= nbseg; i++)
+      {
+        const IntPatch_TheSegmentOfTheSOnBounds& aSegm = solrst.Segment(i);
+        edg1.Append(aSegm);
       }
       nosolonS1 = (nbpt == 0) && (nbseg == 0);
 
@@ -335,15 +339,19 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)&  S1,
       if (solrst.AllArcSolution() && typs1 == typs2) {
         all2 = Standard_True;
       }
+
       nbpt = solrst.NbPoints();
       nbseg= solrst.NbSegments();
       for (i=1; i<= nbpt; i++) {
-        pnt2.Append(solrst.Point(i));
+        const IntPatch_ThePathPointOfTheSOnBounds& aPt = solrst.Point(i);
+        pnt2.Append(aPt);
       }
     
       for (i=1; i<= nbseg; i++) {
-        edg2.Append(solrst.Segment(i));
+        const IntPatch_TheSegmentOfTheSOnBounds& aSegm = solrst.Segment(i);
+        edg2.Append(aSegm);
       }
+      
       nosolonS2 = (nbpt == 0) && (nbseg == 0);
 
       if (nosolonS2 && all2) {  // cas de face sans restrictions

src/IntPatch/IntPatch_ImpImpIntersection_4.gxx

@@ -29,12 +29,10 @@ static void ShortCosForm( const Standard_Real theCosFactor,
                           Standard_Real& theCoeff,
                           Standard_Real& theAngle);
 //
-static 
-  Standard_Boolean ExploreCurve(const gp_Cylinder& aCy,
-				const gp_Cone& aCo,
-				IntAna_Curve& aC,
-				const Standard_Real aTol,
-				IntAna_ListOfCurve& aLC);
+static Standard_Boolean ExploreCurve(const gp_Cone& theCo,
+                                     IntAna_Curve& aC,
+                                     const Standard_Real aTol,
+                                     IntAna_ListOfCurve& aLC);
 
 static Standard_Boolean InscribePoint(const Standard_Real theUfTarget,
                                       const Standard_Real theUlTarget,
@@ -511,13 +509,6 @@ private:
   const Standard_Boolean myIsReverse;
 };
 
-static 
-  Standard_Boolean ExploreCurve(const gp_Cylinder& aCy,
-				const gp_Cone& aCo,
-				IntAna_Curve& aC,
-				const Standard_Real aTol,
-				IntAna_ListOfCurve& aLC);
-
 static void SeekAdditionalPoints( const IntSurf_Quadric& theQuad1,
                                   const IntSurf_Quadric& theQuad2,
                                   const Handle(IntSurf_LineOn2S)& theLine,
@@ -840,6 +831,7 @@ void ProcessBounds(const Handle(IntPatch_ALine)& alig,          //-- ligne coura
 	if (!procf) {
 	  d=ptf.Distance(ptsol.Value());
 	  if (d <= Tol) {
+            ptsol.SetTolerance(Tol);
 	    if (!ptsol.IsMultiple()) {
 	      //-- le point ptsol (de aligold) est declare multiple sur aligold
 	      Multpoint = Standard_True;
@@ -858,6 +850,7 @@ void ProcessBounds(const Handle(IntPatch_ALine)& alig,          //-- ligne coura
 	}
 	if (!procl) {
 	  if (ptl.Distance(ptsol.Value()) <= Tol) {
+            ptsol.SetTolerance(Tol);
 	    if (!ptsol.IsMultiple()) {
 	      Multpoint = Standard_True;
 	      ptsol.SetMultiple(Standard_True);
@@ -888,6 +881,8 @@ void ProcessBounds(const Handle(IntPatch_ALine)& alig,          //-- ligne coura
       }
     }
   }
+  
+  ptsol.SetTolerance(Tol);
   if (!procf && !procl) {
     Quad1.Parameters(ptf,U1,V1);
     Quad2.Parameters(ptf,U2,V2);
@@ -4136,7 +4131,7 @@ Standard_Boolean IntCyCo(const IntSurf_Quadric& Quad1,
 	//curvsol = anaint.Curve(i);
 	aC=anaint.Curve(i);
 	aLC.Clear();
-	ExploreCurve(Cy, Co, aC, 10.*Tol, aLC);
+	ExploreCurve(Co, aC, 10.*Tol, aLC);
 	//
 	aIt.Initialize(aLC);
 	for (; aIt.More(); aIt.Next()) {
@@ -4209,61 +4204,69 @@ Standard_Boolean IntCyCo(const IntSurf_Quadric& Quad1,
 }
 //=======================================================================
 //function : ExploreCurve
-//purpose  : 
+//purpose  : Splits aC on several curves in the cone apex points.
 //=======================================================================
-Standard_Boolean ExploreCurve(const gp_Cylinder& ,//aCy,
-			      const gp_Cone& aCo,
-			      IntAna_Curve& aC,
-			      const Standard_Real aTol,
-			      IntAna_ListOfCurve& aLC)
-			      
+Standard_Boolean ExploreCurve(const gp_Cone& theCo,
+                              IntAna_Curve& theCrv,
+                              const Standard_Real theTol,
+                              IntAna_ListOfCurve& theLC)
 {
-  Standard_Boolean bFind=Standard_False;
-  Standard_Real aTheta, aT1, aT2, aDst;
-  gp_Pnt aPapx, aPx;
+  const Standard_Real aSqTol = theTol*theTol;
+  const gp_Pnt aPapx(theCo.Apex());
+
+  Standard_Real aT1, aT2;
+  theCrv.Domain(aT1, aT2);
+
+  theLC.Clear();
   //
-  //aC.Dump();
-  //
-  aLC.Clear();
-  aLC.Append(aC);
-  //
-  aPapx=aCo.Apex();
-  //
-  aC.Domain(aT1, aT2);
-  //
-  aPx=aC.Value(aT1);
-  aDst=aPx.Distance(aPapx);
-  if (aDst<aTol) {
-    return bFind;
+  TColStd_ListOfReal aLParams;
+  theCrv.FindParameter(aPapx, aLParams);
+  if (aLParams.IsEmpty())
+  {
+    theLC.Append(theCrv);
+    return Standard_False;
   }
-  aPx=aC.Value(aT2);
-  aDst=aPx.Distance(aPapx);
-  if (aDst<aTol) {
-    return bFind;
+
+  for (TColStd_ListIteratorOfListOfReal anItr(aLParams); anItr.More(); anItr.Next())
+  {
+    Standard_Real aPrm = anItr.Value();
+
+    if ((aPrm - aT1) < Precision::PConfusion())
+      continue;
+
+    Standard_Boolean isLast = Standard_False;
+    if ((aT2 - aPrm) < Precision::PConfusion())
+    {
+      aPrm = aT2;
+      isLast = Standard_True;
+    }
+
+    const gp_Pnt aP = theCrv.Value(aPrm);
+    const Standard_Real aSqD = aP.SquareDistance(aPapx);
+    if (aSqD < aSqTol)
+    {
+      IntAna_Curve aC1 = theCrv;
+      aC1.SetDomain(aT1, aPrm);
+      aT1 = aPrm;
+      theLC.Append(aC1);
+    }
+
+    if (isLast)
+      break;
   }
-  //
-  bFind=aC.FindParameter(aPapx, aTheta);
-  if (!bFind){
-    return bFind;
+
+  if (theLC.IsEmpty())
+  {
+    theLC.Append(theCrv);
+    return Standard_False;
   }
-  //
-  aPx=aC.Value(aTheta);
-  aDst=aPx.Distance(aPapx);
-  if (aDst>aTol) {
-    return !bFind;
+
+  if ((aT2 - aT1) > Precision::PConfusion())
+  {
+    IntAna_Curve aC1 = theCrv;
+    aC1.SetDomain(aT1, aT2);
+    theLC.Append(aC1);
   }
-  //
-  // need to be splitted at aTheta
-  IntAna_Curve aC1, aC2;
-  //
-  aC1=aC;
-  aC1.SetDomain(aT1, aTheta);
-  aC2=aC;
-  aC2.SetDomain(aTheta, aT2);
-  //
-  aLC.Clear();
-  aLC.Append(aC1);
-  aLC.Append(aC2);
-  //
-  return bFind;
+
+  return Standard_True;
 }

src/IntPatch/IntPatch_ImpPrmIntersection.cxx

@@ -19,6 +19,7 @@
 #include <Adaptor3d_HSurface.hxx>
 #include <Adaptor3d_TopolTool.hxx>
 #include <ElCLib.hxx>
+#include <ElSLib.hxx>
 #include <IntPatch_ArcFunction.hxx>
 #include <IntPatch_PointLine.hxx>
 #include <IntPatch_RLine.hxx>
@@ -87,6 +88,7 @@ static IntPatch_SpecPntType IsSeamOrPole(const Handle(Adaptor3d_HSurface)& theQS
                                          const Handle(IntSurf_LineOn2S)& theLine,
                                          const Standard_Boolean IsReversed,
                                          const Standard_Integer theRefIndex,
+                                         const Standard_Real theTol3D,
                                          const Standard_Real theDeltaMax)
 {
   if((theRefIndex < 1) || (theRefIndex >= theLine->NbPoints()))
@@ -96,6 +98,8 @@ static IntPatch_SpecPntType IsSeamOrPole(const Handle(Adaptor3d_HSurface)& theQS
   Standard_Real aUQRef, aVQRef, aUPRef, aVPRef;
   Standard_Real aUQNext, aVQNext, aUPNext, aVPNext;
 
+  const gp_Pnt &aP3d = theLine->Value(theRefIndex + 1).Value();
+
   if(IsReversed)
   {
     theLine->Value(theRefIndex).Parameters  (aUPRef, aVPRef, aUQRef, aVQRef);
@@ -109,6 +113,28 @@ static IntPatch_SpecPntType IsSeamOrPole(const Handle(Adaptor3d_HSurface)& theQS
 
   const GeomAbs_SurfaceType aType = theQSurf->GetType();
 
+  if ((aType == GeomAbs_Cone) && 
+      (theQSurf->Cone().Apex().SquareDistance(aP3d) < theTol3D*theTol3D))
+  {
+    return IntPatch_SPntPoleSeamU;
+  }
+  else if (aType == GeomAbs_Sphere)
+  {
+    const Standard_Real aSqTol = theTol3D*theTol3D;
+    gp_Pnt aP(ElSLib::Value(0.0, M_PI_2, theQSurf->Sphere()));
+    if (aP.SquareDistance(aP3d) < aSqTol)
+    {
+      return IntPatch_SPntPoleSeamU;
+    }
+    
+    aP = ElSLib::Value(0.0, -M_PI_2, theQSurf->Sphere());
+    if (aP.SquareDistance(aP3d) < aSqTol)
+    {
+      return IntPatch_SPntPoleSeamU;
+    }
+  }
+  
+
   const Standard_Real aDeltaU = Abs(aUQRef - aUQNext);
 
   if((aType != GeomAbs_Torus) && (aDeltaU < theDeltaMax))
@@ -2628,6 +2654,15 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
                                                               PrePoint, IsReversed))
       {
         sline->Add(PrePoint);
+
+        //Avoid adding duplicate points.
+        for (;aFindex <= aLindex; aFindex++)
+        {
+          if (!PrePoint.IsSame(aSSLine->Value(aFindex), theTolTang))
+          {
+            break;
+          }
+        }
       }
       else
       {
@@ -2658,7 +2693,8 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
       DetectOfBoundaryAchievement(theQSurf, IsReversed, aSSLine,
                                   k, aTOL2D, sline, isOnBoundary);
 
-      aPrePointExist = IsSeamOrPole(theQSurf, aSSLine, IsReversed, k - 1, aDeltaUmax);
+      aPrePointExist = IsSeamOrPole(theQSurf, aSSLine, IsReversed,
+                                    k - 1, theTolTang, aDeltaUmax);
 
       if (isOnBoundary && (aPrePointExist != IntPatch_SPntPoleSeamU))
       {
@@ -2742,7 +2778,7 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
           aSupBound(3) = theQSurf->LastUParameter();
 
           IntPatch_SpecialPoints::
-                      AddPointOnUorVIso(theQSurf, thePSurf, aRefPt, Standard_False,
+                      AddPointOnUorVIso(theQSurf, thePSurf, aRefPt, Standard_False, 0.0,
                                         aTol, aStartPoint, anInfBound, aSupBound,
                                         aNewPoint, IsReversed);
         }
@@ -2752,9 +2788,10 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
 
           IntPatch_Point aVert;
           aVert.SetValue(aRefPt);
+          aVert.SetTolerance(theTolTang);
 
           if(IntPatch_SpecialPoints::
-                      AddSingularPole(theQSurf, thePSurf, aRefPt, theTolTang,
+                      AddSingularPole(theQSurf, thePSurf, aRefPt,
                                       aVert, aNewPoint, IsReversed))
           {
             aPrePointExist = IntPatch_SPntPole;
@@ -2823,7 +2860,7 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
           aSupBound(3) = theQSurf->LastVParameter();
 
           IntPatch_SpecialPoints::
-                AddPointOnUorVIso(theQSurf, thePSurf, aRefPt, Standard_True, aTol,
+                AddPointOnUorVIso(theQSurf, thePSurf, aRefPt, Standard_True, 0.0, aTol,
                                   aStartPoint, anInfBound, aSupBound, aNewPoint,
                                   IsReversed);
         }
@@ -2878,7 +2915,9 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
     if(sline->NbPoints() == 1)
     {
       flNextLine = Standard_True;
-      aFindex = aBindex;
+      
+      if (aFindex < aBindex)
+        aFindex = aBindex;
 
       //Go to the next part of aSSLine
       //because we cannot create the line

src/IntPatch/IntPatch_Intersection.cxx

@@ -1432,8 +1432,32 @@ void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& the
                                 theS1->IsVPeriodic()? theS1->VPeriod() : 0.0,
                                 theS2->IsUPeriodic()? theS2->UPeriod() : 0.0,
                                 theS2->IsVPeriodic()? theS2->VPeriod() : 0.0};
+
+    NCollection_List<gp_Pnt> aListOfCriticalPoints;
+
+    if (theS1->GetType() == GeomAbs_Cone)
+    {
+      aListOfCriticalPoints.Append(theS1->Cone().Apex());
+    }
+    else if (theS1->GetType() == GeomAbs_Sphere)
+    {
+      aListOfCriticalPoints.Append(theS1->Value(0.0, M_PI_2));
+      aListOfCriticalPoints.Append(theS1->Value(0.0, -M_PI_2));
+    }
+
+    if (theS2->GetType() == GeomAbs_Cone)
+    {
+      aListOfCriticalPoints.Append(theS2->Cone().Apex());
+    }
+    else if (theS2->GetType() == GeomAbs_Sphere)
+    {
+      aListOfCriticalPoints.Append(theS2->Value(0.0, M_PI_2));
+      aListOfCriticalPoints.Append(theS2->Value(0.0, -M_PI_2));
+    }
+
     IntPatch_WLineTool::ExtendTwoWLines(slin, theS1, theS2, TolTang,
-                                        anArrOfPeriod, aBx1, aBx2);
+                                        anArrOfPeriod, aBx1, aBx2,
+                                        aListOfCriticalPoints);
   }
 }
 

src/IntPatch/IntPatch_Point.cxx

@@ -153,18 +153,18 @@ void IntPatch_Point::Dump() const {
   Standard_Real u1,v1,u2,v2;
   pt.Parameters(u1,v1,u2,v2);
 
-  printf("P(%15.10f,%15.10f,%15.10f) UV1(%15.10f,%15.10f)  UV2(%15.10f,%15.10f) (Para:%15.10f)\n",
+  printf("P(%+10.20f,%+10.20f,%+10.20f) UV1(%+10.20f,%+10.20f)  UV2(%+10.20f,%+10.20f) (Para:%+10.20f)\n",
 	 (double)(pt.Value().X()),
 	 (double)(pt.Value().Y()),
 	 (double)(pt.Value().Z()),
 	 (double)u1,(double)v1,(double)u2,(double)v2,(double)para);
   if(onS1)
-    printf("*OnS1*  par=%15.10f arc1=%10p", (double)prm1, (void*)arcS1.operator->());
+    printf("*OnS1*  par=%+10.20f arc1=%10p", (double)prm1, (void*)arcS1.operator->());
   if(vtxonS1)
     printf(" *Vtx1*  vtx1=%10p", (void*)vS1.operator->());
   if(onS1 || vtxonS1) printf("\n");
   if(onS2)
-    printf("*OnS2*  par=%15.10f arc2=%10p", (double)prm2, (void*)arcS2.operator->());
+    printf("*OnS2*  par=%+10.20f arc2=%10p", (double)prm2, (void*)arcS2.operator->());
   if(vtxonS2)
     printf(" *Vtx2*  vtx2=%10p", (void*)vS2.operator->());
 
@@ -184,4 +184,6 @@ void IntPatch_Point::Dump() const {
     }
     cout<<endl;
   }
+  cout << "\nToler = " << Tolerance();
+  cout << endl;
 }

src/IntPatch/IntPatch_Point.hxx

@@ -222,7 +222,10 @@ private:
   Standard_Real para;
   Standard_Real tol;
   Standard_Boolean tgt;
+
+  //TRUE if the point is in several intersection lines
   Standard_Boolean mult;
+
   Standard_Boolean onS1;
   Standard_Boolean vtxonS1;
   Handle(Adaptor3d_HVertex) vS1;

src/IntPatch/IntPatch_PointLine.cxx

@@ -119,8 +119,13 @@ Standard_Real IntPatch_PointLine::
   const gp_Vec aCTan(aN1.Crossed(aN2));
   const Standard_Real aSqMagnFDer = aCTan.SquareMagnitude();
   
-  if(aSqMagnFDer < aSqSmallValue)
+  if (aSqMagnFDer < 1.0e-8)
+  {
+    // Use 1.0e-4 (instead of aSmallValue) to provide
+    // stable computation between different platforms.
+    // See test bugs modalg_7 bug29807_sc01
     return -1.0;
+  }
 
   Standard_Real aDuS1 = 0.0, aDvS1 = 0.0, aDuS2 = 0.0, aDvS2 = 1.0;
 
@@ -160,7 +165,8 @@ Standard_Real IntPatch_PointLine::
   const Standard_Real aDetSyst = aB*aB - aA*aC;
 
   if(Abs(aDetSyst) < aSmallValue)
-  {//Indetermined system solution
+  {
+    //Undetermined system solution
     return -1.0;
   }
 

src/IntPatch/IntPatch_SpecialPoints.cxx

@@ -16,6 +16,7 @@
 #include <IntPatch_SpecialPoints.hxx>
 
 #include <Adaptor3d_HSurface.hxx>
+#include <ElCLib.hxx>
 #include <Extrema_ExtPS.hxx>
 #include <Extrema_GenLocateExtPS.hxx>
 #include <Geom_ConicalSurface.hxx>
@@ -35,10 +36,12 @@ class FuncPreciseSeam: public math_FunctionSetWithDerivatives
 public:
   FuncPreciseSeam(const Handle(Adaptor3d_HSurface)& theQSurf, // quadric
                   const Handle(Adaptor3d_HSurface)& thePSurf, // another surface
-                  const Standard_Boolean isTheUSeam): 
+                  const Standard_Boolean isTheUSeam,
+                  const Standard_Real theIsoParameter): 
         myQSurf(theQSurf),
         myPSurf(thePSurf),
-        mySeamCoordInd(isTheUSeam? 1 : 0) // Defines, U- or V-seam is used
+        mySeamCoordInd(isTheUSeam? 1 : 0), // Defines, U- or V-seam is used
+        myIsoParameter(theIsoParameter)
   {
   };
   
@@ -58,7 +61,7 @@ public:
     try
     {
       const Standard_Integer anIndX = theX.Lower(), anIndF = theF.Lower();
-      Standard_Real aUV[] = {0.0, 0.0};
+      Standard_Real aUV[] = {myIsoParameter, myIsoParameter};
       aUV[mySeamCoordInd] = theX(anIndX+2);
       const gp_Pnt aP1(myPSurf->Value(theX(anIndX), theX(anIndX+1)));
       const gp_Pnt aP2(myQSurf->Value(aUV[0], aUV[1]));
@@ -81,7 +84,7 @@ public:
       const Standard_Integer anIndX = theX.Lower(),
                              anIndRD = theD.LowerRow(),
                              anIndCD = theD.LowerCol();
-      Standard_Real aUV[] = {0.0, 0.0};
+      Standard_Real aUV[] = {myIsoParameter, myIsoParameter};
       aUV[mySeamCoordInd] = theX(anIndX+2);
 
       gp_Pnt aPt;
@@ -131,10 +134,30 @@ private:
   const Handle(Adaptor3d_HSurface)& myQSurf;
   const Handle(Adaptor3d_HSurface)& myPSurf;
 
-  // 1 for U-coordinate, 0 - for V one. 
+  //! 1 for U-coordinate, 0 - for V one. 
   const Standard_Integer mySeamCoordInd;
+
+  //! Constant parameter of iso-line
+  const Standard_Real myIsoParameter;
 };
 
+//=======================================================================
+//function : GetTangent
+//purpose  : Computes tangent having the given parameter.
+//            See calling method(s) for detailed information
+//=======================================================================
+static inline void GetTangent(const Standard_Real theConeSemiAngle,
+                              const Standard_Real theParameter,
+                              gp_XYZ& theResult)
+{
+  const Standard_Real aW2 = theParameter*theParameter;
+  const Standard_Real aCosUn = (1.0 - aW2) / (1.0 + aW2);
+  const Standard_Real aSinUn = 2.0*theParameter / (1.0 + aW2);
+
+  const Standard_Real aTanA = Tan(theConeSemiAngle);
+  theResult.SetCoord(aTanA*aCosUn, aTanA*aSinUn, 1.0);
+}
+
 //=======================================================================
 //function : IsPointOnSurface
 //purpose  : Checks if thePt is in theSurf (with given tolerance).
@@ -281,6 +304,7 @@ Standard_Boolean IntPatch_SpecialPoints::
                                         const Handle(Adaptor3d_HSurface)& thePSurf,
                                         const IntSurf_PntOn2S& theRefPt,
                                         const Standard_Boolean theIsU,
+                                        const Standard_Real theIsoParameter,
                                         const math_Vector& theToler,
                                         const math_Vector& theInitPoint,
                                         const math_Vector& theInfBound,
@@ -292,7 +316,7 @@ Standard_Boolean IntPatch_SpecialPoints::
   IntSurf::SetPeriod(theIsReversed ? thePSurf : theQSurf,
                      theIsReversed ? theQSurf : thePSurf, anArrOfPeriod);
 
-  FuncPreciseSeam aF(theQSurf, thePSurf, theIsU);
+  FuncPreciseSeam aF(theQSurf, thePSurf, theIsU, theIsoParameter);
 
   math_FunctionSetRoot aSRF(aF, theToler);
   aSRF.Perform(aF, theInitPoint, theInfBound, theSupBound);
@@ -323,6 +347,432 @@ Standard_Boolean IntPatch_SpecialPoints::
   return Standard_True;
 }
 
+//=======================================================================
+//function : ProcessSphere
+//purpose  :
+/*
+The intersection point (including the pole)
+must be satisfied to the following system:
+
+    \left\{\begin{matrix}
+    R*\cos (U_{q})*\cos (V_{q})=S_{x}(U_{s},V_{s})
+    R*\sin (U_{q})*\cos (V_{q})=S_{y}(U_{s},V_{s})
+    R*\sin (V_{q})=S_{z}(U_{s},V_{s})
+    \end{matrix}\right,
+where
+  R is the radius of the sphere;
+  @S_{x}@, @S_{y}@ and @S_{z}@ are X, Y and Z-coordinates of thePSurf;
+  @U_{s}@ and @V_{s}@ are parameters on the parametric surface;
+  @U_{q}@ and @V_{q}@ are equal to theUquad and theVquad correspondingly.
+
+Consequently (from first two equations),
+  \left\{\begin{matrix}
+  \cos (U_{q}) = \frac{S_{x}(U_{s},V_{s})}{R*\cos (V_{q})}
+  \sin (U_{q}) = \frac{S_{y}(U_{s},V_{s})}{R*\cos (V_{q})}
+  \end{matrix}\right.
+
+For pole,
+  V_{q}=\pm \pi /2 \Rightarrow \cos (V_{q}) = 0 (denominator is equal to 0).
+
+Therefore, computation U_{q} directly is impossibly.
+
+Let @V_{q}@ tends to @\pm \pi /2@.
+Then (indeterminate form is evaluated in accordance of L'Hospital rule),
+  \cos (U_{q}) = \lim_{V_{q} \to (\pi /2-0)}
+  \frac{S_{x}(U_{s},V_{s})}{R*\cos (V_{q})}=
+  -\lim_{V_{q} \to (\pi /2-0)}
+  \frac{\frac{\partial S_{x}}
+  {\partial U_{s}}*\frac{\mathrm{d} U_{s}}
+  {\mathrm{d} V_{q}}+\frac{\partial S_{x}}
+  {\partial V_{s}}*\frac{\mathrm{d} V_{s}}
+  {\mathrm{d} V_{q}}}{R*\sin (V_{q})} =
+  -\frac{1}{R}*\frac{\mathrm{d} U_{s}}
+  {\mathrm{d} V_{q}}*(\frac{\partial S_{x}}
+  {\partial U_{s}}+\frac{\partial S_{x}}
+  {\partial V_{s}}*\frac{\mathrm{d} V_{s}}
+  {\mathrm{d} U_{s}}) =
+  -\frac{1}{R}*\frac{\mathrm{d} V_{s}}
+  {\mathrm{d} V_{q}}*(\frac{\partial S_{x}}
+  {\partial U_{s}}*\frac{\mathrm{d} U_{s}}
+  {\mathrm{d} V_{s}}+\frac{\partial S_{x}}
+  {\partial V_{s}}).
+
+Analogicaly for @\sin (U_{q})@ (@S_{x}@ is substituted to @S_{y}@).
+
+Let mean, that
+  \cos (U_{q}) \left | _{V_{q} \to (-\pi /2+0)} = \cos (U_{q}) \left | _{V_{q} \to (\pi /2-0)}
+  \sin (U_{q}) \left | _{V_{q} \to (-\pi /2+0)} = \sin (U_{q}) \left | _{V_{q} \to (\pi /2-0)}
+
+From the 3rd equation of the system, we obtain
+  \frac{\mathrm{d} (R*\sin (V_{q}))}{\mathrm{d} V_{q}} =
+  \frac{\mathrm{d} S_{z}(U_{s},V_{s})}{\mathrm{d} V_{q}}
+or
+  R*\cos (V_{q}) = \frac{\partial S_{z}}{\partial U_{s}}*
+  \frac{\mathrm{d} U_{s}} {\mathrm{d} V_{q}}+\frac{\partial S_{z}}
+  {\partial V_{s}}*\frac{\mathrm{d} V_{s}}{\mathrm{d} V_{q}}.
+
+If @V_{q}=\pm \pi /2@, then
+  \frac{\partial S_{z}}{\partial U_{s}}*
+  \frac{\mathrm{d} U_{s}} {\mathrm{d} V_{q}}+\frac{\partial S_{z}}
+  {\partial V_{s}}*\frac{\mathrm{d} V_{s}}{\mathrm{d} V_{q}} = 0.
+
+Consequently, if @\frac{\partial S_{z}}{\partial U_{s}} \neq 0 @ then
+  \frac{\mathrm{d} U_{s}}{\mathrm{d} V_{s}} =
+  -\frac{\frac{\partial S_{z}}{\partial V_{s}}}
+  {\frac{\partial S_{z}}{\partial U_{s}}}.
+
+If @ \frac{\partial S_{z}}{\partial V_{s}} \neq 0 @ then
+  \frac{\mathrm{d} V_{s}}{\mathrm{d} U_{s}} =
+  -\frac{\frac{\partial S_{z}}{\partial U_{s}}}
+  {\frac{\partial S_{z}}{\partial V_{s}}}
+
+Cases, when @ \frac{\partial S_{z}}{\partial U_{s}} =
+\frac{\partial S_{z}}{\partial V_{s}} = 0 @ are not consider here.
+The reason is written below.
+*/
+//=======================================================================
+Standard_Boolean IntPatch_SpecialPoints::ProcessSphere(const IntSurf_PntOn2S& thePtIso,
+                                                       const gp_Vec& theDUofPSurf,
+                                                       const gp_Vec& theDVofPSurf,
+                                                       const Standard_Boolean theIsReversed,
+                                                       const Standard_Real theVquad,
+                                                       Standard_Real& theUquad,
+                                                       Standard_Boolean& theIsIsoChoosen)
+{
+  theIsIsoChoosen = Standard_False;
+
+  //Vector with {@ \cos (U_{q}) @, @ \sin (U_{q}) @} coordinates.
+  //Ask to pay attention to the fact that this vector is always normalized.
+  gp_Vec2d aV1;
+
+  if ((Abs(theDUofPSurf.Z()) < Precision::PConfusion()) &&
+      (Abs(theDVofPSurf.Z()) < Precision::PConfusion()))
+  {
+    //Example of this case is an intersection of a plane with a sphere
+    //when the plane tangents the sphere in some pole (i.e. only one 
+    //intersection point, not line). In this case, U-coordinate of the
+    //sphere is undefined (can be realy anything).
+    //Another reason is that we have tangent zone around the pole
+    //(see bug #26576).
+    //Computation of correct value of theUquad is impossible.
+    //Therefore, (in order to return something) we will consider
+    //the intersection line goes along some isoline in neighborhood
+    //of the pole.
+
+#ifdef INTPATCH_ADDSPECIALPOINTS_DEBUG
+    cout << "Cannot find UV-coordinate for quadric in the pole."
+      " See considered comment above. IntPatch_SpecialPoints.cxx,"
+      " ProcessSphere(...)" << endl;
+#endif
+    Standard_Real aUIso = 0.0, aVIso = 0.0;
+    if (theIsReversed)
+      thePtIso.ParametersOnS2(aUIso, aVIso);
+    else
+      thePtIso.ParametersOnS1(aUIso, aVIso);
+
+    theUquad = aUIso;
+    theIsIsoChoosen = Standard_True;
+  }
+  else
+  {
+    if (Abs(theDUofPSurf.Z()) > Abs(theDVofPSurf.Z()))
+    {
+      const Standard_Real aDusDvs = theDVofPSurf.Z() / theDUofPSurf.Z();
+      aV1.SetCoord(theDUofPSurf.X()*aDusDvs - theDVofPSurf.X(),
+                   theDUofPSurf.Y()*aDusDvs - theDVofPSurf.Y());
+    }
+    else
+    {
+      const Standard_Real aDvsDus = theDUofPSurf.Z() / theDVofPSurf.Z();
+      aV1.SetCoord(theDVofPSurf.X()*aDvsDus - theDUofPSurf.X(),
+                   theDVofPSurf.Y()*aDvsDus - theDUofPSurf.Y());
+    }
+
+    aV1.Normalize();
+
+    if (Abs(aV1.X()) > Abs(aV1.Y()))
+      theUquad = Sign(asin(aV1.Y()), theVquad);
+    else
+      theUquad = Sign(acos(aV1.X()), theVquad);
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : ProcessCone
+//purpose  : 
+/*
+The intersection point (including the pole)
+must be satisfied to the following system:
+
+  \left\{\begin {matrix}
+  (V_{q}\sin(a) + R)*\cos(U_{q})) = S_{x}(U_{s}, V_{s})\\
+  (V_{q}\sin(a) + R)*\sin(U_{q})) = S_{y}(U_{s}, V_{s})\\
+  V_{q}\cos(a) = S_{z}(U_{s}, V_{s})
+  \end {matrix}\right,
+where 
+  R is the radius of the cone;
+  a is its semi-angle;
+  @S_{x}@, @S_{y}@ and @S_{z}@ are X, Y and Z-coordinates of thePSurf;
+  @U_{s}@ and @V_{s}@ are parameters on the parametric surface;
+  @U_{q}@ and @V_{q}@ are equal to theUquad and theVquad correspondingly.
+
+Consequently (from first two equations), 
+  \left\{\begin{matrix}
+  \cos(U_{q})=\frac{S_{x}(U_{s},V_{s})}{(V_{q}\sin(a)+R)}\\
+  \sin(U_{q})=\frac{S_{y}(U_{s}, V_{s})}{(V_{q}\sin(a)+R)}
+  \end{matrix}\right.
+
+For pole, the denominator of these two equations is equal to 0.
+Therefore, computation U_{q} directly is impossibly.
+
+Let @V_{q}@ tends to @\frac{-R}{\sin(a)})@.
+Then (indeterminate form is evaluated in accordance of L'Hospital rule),
+
+  \cos (U_{q}) = 
+  \lim_{V_{q} \to (\frac{-R}{\sin(a)})}\frac{S_{x}(U_{s},V_{s})}{(V_{q}\sin(a)+R)}=
+  \frac{1}{\sin(a)}* \lim_{V_{q} \to (\frac{-R}{\sin(a)})}\frac{dU_{s}}{dV_{q}}*
+  (\frac{\partial S_{x}}{\partial U_{s}}+\frac{\partial S_{x}}{\partial V_{s}}*
+  \frac{dV_{s}}{dU_{s}})=
+  \frac{1}{\sin(a)}* \lim_{V_{q} \to (\frac{-R}{\sin(a)})}\frac{dV_{s}}{dV_{q}}*
+  (\frac{\partial S_{x}}{\partial U_{s}}*
+  \frac{dU_{s}}{dV_{s}}+\frac{\partial S_{x}}{\partial V_{s}})
+
+Analogically for @\sin (U_{q})@ (@S_{x}@ is substituted to @S_{y}@).
+
+After differentiating 3rd equation of the system, we will obtain
+  \cos(a)=\frac{dS_{z}}{dV_{q}}=\frac{dU_{s}}{dV_{q}}*
+  (\frac{\partial S_{z}}{\partial U_{s}}+\frac{\partial S_{z}}{\partial V_{s}}*
+  \frac{dV_{s}}{dU_{s}})
+or
+  \frac{dU_{s}}{dV_{q}}=\frac{\cos(a)}{\frac{\partial S_{z}}{\partial U_{s}}+
+  \frac{\partial S_{z}}{\partial V_{s}}*\frac{dV_{s}}{dU_{s}}}
+
+After substituting we will obtain
+  \cos (U_{q}) = 
+  \cot(a)*\frac{\frac{\partial S_{x}}{\partial U_{s}}+\frac{\partial S_{x}}
+  {\partial V_{s}}*\frac{dV_{s}}{dU_{s}}}{\frac{\partial S_{z}}
+  {\partial U_{s}}+\frac{\partial S_{z}}{\partial V_{s}}*\frac{dV_{s}}{dU_{s}}}
+
+  \sin (U_{q}) =
+  \cot(a)*\frac{\frac{\partial S_{y}}{\partial U_{s}}+\frac{\partial S_{y}}
+  {\partial V_{s}}*\frac{dV_{s}}{dU_{s}}}{\frac{\partial S_{z}}
+  {\partial U_{s}}+\frac{\partial S_{z}}{\partial V_{s}}*\frac{dV_{s}}{dU_{s}}}
+
+So, we have obtained vector with coordinates {@ \cos (U_{q}) @, @ \sin (U_{q}) @}.
+Ask to pay attention to the fact that this vector is always normalized.
+And after normalization this vector will have coordinates
+  {\cos (U_{q}), \sin (U_{q})} = {dS_{x}, dS_{y}}.Normalized().
+
+It means that we have to compute a tangent to the intersection curve in
+the cone apex point. After that, just take its X- and Y-coordinates.
+
+However, we have to compute derivative @\frac{dV_{s}}{dU_{s}}@ in order
+to compute this vector. In order to find this derivative, we use the
+information about direction of tangent to the intersection curve.
+This tangent will be directed along the cone generatrix obtained by intersection
+of the cone with a plane tangent to 2nd (intersected) surface.
+*/
+//=======================================================================
+Standard_Boolean IntPatch_SpecialPoints::ProcessCone(const IntSurf_PntOn2S& thePtIso,
+                                                     const gp_Vec& theDUofPSurf,
+                                                     const gp_Vec& theDVofPSurf,
+                                                     const gp_Cone& theCone,
+                                                     const Standard_Boolean theIsReversed,
+                                                     Standard_Real& theUquad,
+                                                     Standard_Boolean& theIsIsoChoosen)
+{
+  theIsIsoChoosen = Standard_False;
+
+  // A plane tangent to 2nd (intersected) surface.
+  // Its normal.
+  const gp_XYZ aTgPlaneZ(theDUofPSurf.Crossed(theDVofPSurf).XYZ());
+  const Standard_Real aSqModTg = aTgPlaneZ.SquareModulus();
+  if (aSqModTg < Precision::SquareConfusion())
+  {
+    theIsIsoChoosen = Standard_True;
+  }
+
+  gp_XYZ aTgILine[2];
+  const Standard_Integer aNbTangent = !theIsIsoChoosen? 
+                          GetTangentToIntLineForCone(theCone.SemiAngle(),
+                                                     aTgPlaneZ.Divided(Sqrt(aSqModTg)),
+                                                     aTgILine) : 0;
+
+  if (aNbTangent == 0)
+  {
+    theIsIsoChoosen = Standard_True;
+  }
+  else
+  {
+    const Standard_Real aPeriod = M_PI + M_PI;
+    Standard_Real aUIso = 0.0, aVIso = 0.0;
+    if (theIsReversed)
+      thePtIso.ParametersOnS2(aUIso, aVIso);
+    else
+      thePtIso.ParametersOnS1(aUIso, aVIso);
+
+    aUIso = ElCLib::InPeriod(aUIso, 0.0, aPeriod);
+
+    // Sought U-parameter in the apex point
+
+    // For 2 possible parameters value,
+    // one will be chosen which is nearer
+    // to aUIso. Following variables will help to chose.
+    Standard_Real aMinDelta = RealLast();
+    for (Standard_Integer anIdx = 0; anIdx < aNbTangent; anIdx++)
+    {
+      // Vector {@\cos(a), \sin(a)@}
+      gp_Vec2d aVecCS(aTgILine[anIdx].X(), aTgILine[anIdx].Y());
+      const Standard_Real aSqMod = aVecCS.SquareMagnitude();
+      if (aSqMod < Precision::SquareConfusion())
+      {
+        theIsIsoChoosen = Standard_True;
+        break;
+      }
+
+      // Normalize
+      aVecCS.Divide(Sqrt(aSqMod));
+
+      // Angle in range [0, PI/2]
+      Standard_Real anUq = (Abs(aVecCS.X()) < Abs(aVecCS.Y())) ? ACos(Abs(aVecCS.X())) : ASin(Abs(aVecCS.Y()));
+
+      // Convert angles to the range [0, 2*PI]
+      if (aVecCS.Y() < 0.0)
+      {
+        if (aVecCS.X() > 0.0)
+        {
+          anUq = -anUq;
+        }
+        else
+        {
+          anUq += M_PI;
+        }
+      }
+      else if (aVecCS.X() < 0.0)
+      {
+        anUq = M_PI - anUq;
+      }
+
+      //Select the parameter the nearest to aUIso
+      anUq = ElCLib::InPeriod(anUq, 0.0, aPeriod);
+      Standard_Real aDelta = Abs(anUq - aUIso);
+      if (aDelta > M_PI)
+        aDelta = aPeriod - aDelta;
+
+      if (aDelta < aMinDelta)
+      {
+        aMinDelta = aDelta;
+        theUquad = anUq;
+      }
+    }
+  }
+
+  if (theIsIsoChoosen)
+  {
+#ifdef INTPATCH_ADDSPECIALPOINTS_DEBUG
+    cout << "Cannot find UV-coordinate for quadric in the pole."
+      " IntPatch_AddSpecialPoints.cxx, ProcessCone(...)" << endl;
+#endif
+    theIsIsoChoosen = Standard_True;
+
+    Standard_Real aUIso = 0.0, aVIso = 0.0;
+    if (theIsReversed)
+      thePtIso.ParametersOnS2(aUIso, aVIso);
+    else
+      thePtIso.ParametersOnS1(aUIso, aVIso);
+
+    theUquad = aUIso;
+    return Standard_True;
+  }
+  else
+  {
+    return Standard_True;
+  }
+
+  //return Standard_False;
+}
+
+//=======================================================================
+//function : GetTangentToIntLineForCone
+//purpose  : The following conditions must be satisfied:
+//1. The cone is represented in its canonical form.
+//2. The plane goes through the cone apex and has the normal vector thePlnNormal.
+//3. Vector thePlnNormal has already been normalized
+/*
+Let us enter the new coordinate system where the origin will be in the cone apex
+and axes are the same as in World-Coordinate-System (WCS).
+There the horizontal plane (which is parallel XY-plane) with the origin
+(0, 0, 1) will intersect the cone by the circle with center (0, 0, 1),
+direction {0, 0, 1} and radius tg(a) where a is the cone semi-angle.
+Its equation will be
+\left\{\begin{matrix}
+x(U_{n}) = \tan(a)*\cos(U_{n}) = \tan(a)*\frac{1-\tan^{2}(U_{n}/2)}{1+\tan^{2}(U_{n}/2)}\\
+y(U_{n}) = \tan(a)*\sin (U_{n}) = \tan(a)*\frac{2*\tan(U_{n}/2)}{1+\tan^{2}(U_{n}/2)}\\
+z(U_{n}) = 1
+\end{matrix}\right.
+
+The given plane has (in this coordinate system) location (0, 0, 0) and
+the same normal thePlnNormal=={nx,ny,nz}. Its equation is:
+nx*x+ny*y+nz*z==0
+
+After substitution circle's equation to the plane's equation
+we will obtain a quadratic equation
+aA*w^2 + 2*aB*w + aC = 0.
+*/
+//=======================================================================
+Standard_Integer IntPatch_SpecialPoints::GetTangentToIntLineForCone(const Standard_Real theConeSemiAngle,
+                                                                    const gp_XYZ& thePlnNormal,
+                                                                    gp_XYZ theResult[2])
+{
+  const Standard_Real aNullTol = Epsilon(1.0);
+  const Standard_Real aTanA = Tan(theConeSemiAngle);
+  const Standard_Real aA = thePlnNormal.Z() / aTanA - thePlnNormal.X();
+  const Standard_Real aB = thePlnNormal.Y();
+  const Standard_Real aC = thePlnNormal.Z() / aTanA + thePlnNormal.X();
+
+  if (Abs(aA) < aNullTol)
+  {
+    if (Abs(aB) > aNullTol)
+    {
+      //The plane goes along the cone generatrix.
+      GetTangent(theConeSemiAngle, -aC / (aB + aB), theResult[0]);
+      return 1;
+    }
+
+    //The cone and the plane have only one common point.
+    //It is the cone apex.
+    return 0;
+  }
+
+  //Discriminant of this equation is equal to 
+  Standard_Real aDiscr = thePlnNormal.Z() / Sin(theConeSemiAngle);
+  aDiscr = 1.0 - aDiscr*aDiscr;
+
+  if (Abs(aDiscr) < aNullTol)
+  {
+    //The plane goes along the cone generatrix.
+    // Attention! Mathematically, this cond. is equivalent to 
+    // above processed one (Abs(aA) < aNullTol && (Abs(aB) > aNullTol)).
+    // However, we separate this branch in order to eliminate numerical
+    // instability.
+
+    GetTangent(theConeSemiAngle, -aB / aA, theResult[0]);
+    return 1;
+  }
+  else if (aDiscr > 0.0)
+  {
+    const Standard_Real aRD = Sqrt(aDiscr);
+    GetTangent(theConeSemiAngle, (-aB+aRD)/aA, theResult[0]);
+    GetTangent(theConeSemiAngle, (-aB-aRD)/aA, theResult[1]);
+    return 2;
+  }
+
+  // We will never come here.
+  return 0;
+}
+
 //=======================================================================
 //function : AddSingularPole
 //purpose  : theQSurf is the surface possibly containing special point, 
@@ -333,22 +783,11 @@ Standard_Boolean IntPatch_SpecialPoints::
                       AddSingularPole(const Handle(Adaptor3d_HSurface)& theQSurf,
                                       const Handle(Adaptor3d_HSurface)& thePSurf,
                                       const IntSurf_PntOn2S& thePtIso,
-                                      const Standard_Real theTol,
                                       IntPatch_Point& theVertex,
-                                      IntSurf_PntOn2S& theAddedPoint,                                      
+                                      IntSurf_PntOn2S& theAddedPoint,
                                       const Standard_Boolean theIsReversed,
                                       const Standard_Boolean theIsReqRefCheck)
 {
-  const Standard_Real aUpPeriod = thePSurf->IsUPeriodic() ? thePSurf->UPeriod() : 0.0;
-  const Standard_Real aUqPeriod = theQSurf->IsUPeriodic() ? theQSurf->UPeriod() : 0.0;
-  const Standard_Real aVpPeriod = thePSurf->IsVPeriodic() ? thePSurf->VPeriod() : 0.0;
-  const Standard_Real aVqPeriod = theQSurf->IsVPeriodic() ? theQSurf->VPeriod() : 0.0;
-
-  const Standard_Real anArrOfPeriod[4] = {theIsReversed? aUpPeriod : aUqPeriod,
-                                          theIsReversed? aVpPeriod : aVqPeriod,
-                                          theIsReversed? aUqPeriod : aUpPeriod,
-                                          theIsReversed? aVqPeriod : aVpPeriod};
-
   //On parametric
   Standard_Real aU0 = 0.0, aV0 = 0.0;
   //aPQuad is Pole
@@ -379,13 +818,13 @@ Standard_Boolean IntPatch_SpecialPoints::
   }
 
   theQSurf->D0(aUquad, aVquad, aPQuad);
-
-  if (theIsReqRefCheck && (aPQuad.SquareDistance(theVertex.Value()) >= theTol*theTol))
+  const Standard_Real aTol = theVertex.Tolerance();
+  if (theIsReqRefCheck && (aPQuad.SquareDistance(theVertex.Value()) >= aTol*aTol))
   {
     return Standard_False;
   }
 
-  if(!IsPointOnSurface(thePSurf, aPQuad, theTol, aP0, aU0, aV0))
+  if (!IsPointOnSurface(thePSurf, aPQuad, aTol, aP0, aU0, aV0))
   {
     return Standard_False;
   }
@@ -398,25 +837,20 @@ Standard_Boolean IntPatch_SpecialPoints::
   else
     theAddedPoint.SetValue(0.5*(aP0.XYZ() + aPQuad.XYZ()), aUquad, aVquad, aU0, aV0);
 
-  Standard_Boolean isSame = Standard_False;
-
-  if (theAddedPoint.IsSame(theVertex.PntOn2S(), Precision::Confusion()))
-  {
-    isSame = Standard_True;
-  }
+  const Standard_Boolean isSame = theAddedPoint.IsSame(theVertex.PntOn2S(),
+                                                       Precision::Confusion());
 
   //Found pole does not exist in the Walking-line
   //It must be added there (with correct 2D-parameters)
 
-  //2D-parameters of theparametric surface have already been found (aU0, aV0).
+  //2D-parameters of thePSurf surface have already been found (aU0, aV0).
   //Let find 2D-parameters on the quadric.
 
-  //The algorithm depends on the type of the quadric. Here we consider a Sphere only.
-  //Analogical result can be made for another types (e.g. cone, but formulas will
-  //be different) in case of need.
+  //The algorithm depends on the type of the quadric.
+  //Here we consider a Sphere and cone only.
 
-  //First of all, we need in adjusting thePSurf in the coordinate system of the Sphere
-  //(in order to make the equation of the sphere maximal simple). However, as it will be
+  //First of all, we need in adjusting thePSurf in the coordinate system of the Sphere/Cone
+  //(in order to make its equation maximal simple). However, as it will be
   //shown later, thePSurf is used in algorithm in order to get its derivatives.
   //Therefore, for improving performance, transformation of these vectors is enough
   //(there is no point in transformation of full surface).
@@ -439,146 +873,19 @@ Standard_Boolean IntPatch_SpecialPoints::
 
   if(theQSurf->GetType() == GeomAbs_Sphere)
   {
-    //The intersection point (including the pole)
-    //must be satisfied to the following system:
-    
-    //    \left\{\begin{matrix}
-    //    R*\cos (U_{q})*\cos (V_{q})=S_{x}(U_{s},V_{s})
-    //    R*\sin (U_{q})*\cos (V_{q})=S_{y}(U_{s},V_{s})
-    //    R*\sin (V_{q})=S_{z}(U_{s},V_{s})
-    //    \end{matrix}\right,
-    //where 
-    //  R is the radius of the sphere;
-    //  @S_{x}@, @S_{y}@ and @S_{z}@ are X, Y and Z-coordinates of thePSurf;
-    //  @U_{s}@ and @V_{s}@ are equal to aU0 and aV0 corespondingly;
-    //  @U_{q}@ and @V_{q}@ are equal to aUquad and aVquad corespondingly.
-
-    //Consequently (from first two equations), 
-    //  \left\{\begin{matrix}
-    //  \cos (U_{q}) = \frac{S_{x}(U_{s},V_{s})}{R*\cos (V_{q})}
-    //  \sin (U_{q}) = \frac{S_{y}(U_{s},V_{s})}{R*\cos (V_{q})}
-    //  \end{matrix}\right.
-
-    //For pole, 
-    //  V_{q}=\pm \pi /2 \Rightarrow \cos (V_{q}) = 0 (denominator is equal to 0).
-
-    //Therefore, computation U_{q} directly is impossibly.
-    //
-    //Let @V_{q}@ tends to @\pm \pi /2@.
-    //Then (indeterminate form is evaluated in accordance of L'Hospital rule),
-    //  \cos (U_{q}) = \lim_{V_{q} \to (\pi /2-0)} 
-    //  \frac{S_{x}(U_{s},V_{s})}{R*\cos (V_{q})}= 
-    //  -\lim_{V_{q} \to (\pi /2-0)}
-    //  \frac{\frac{\partial S_{x}}
-    //  {\partial U_{s}}*\frac{\mathrm{d} U_{s}} 
-    //  {\mathrm{d} V_{q}}+\frac{\partial S_{x}} 
-    //  {\partial V_{s}}*\frac{\mathrm{d} V_{s}} 
-    //  {\mathrm{d} V_{q}}}{R*\sin (V_{q})} =  
-    //  -\frac{1}{R}*\frac{\mathrm{d} U_{s}}
-    //  {\mathrm{d} V_{q}}*(\frac{\partial S_{x}} 
-    //  {\partial U_{s}}+\frac{\partial S_{x}}
-    //  {\partial V_{s}}*\frac{\mathrm{d} V_{s}}
-    //  {\mathrm{d} U_{s}}) =
-    //  -\frac{1}{R}*\frac{\mathrm{d} V_{s}}
-    //  {\mathrm{d} V_{q}}*(\frac{\partial S_{x}} 
-    //  {\partial U_{s}}*\frac{\mathrm{d} U_{s}}
-    //  {\mathrm{d} V_{s}}+\frac{\partial S_{x}}
-    //  {\partial V_{s}}).
-
-    //Analogicaly for @\sin (U_{q})@ (@S_{x}@ is substituted to @S_{y}@).
-
-    //Let mean, that
-    //  \cos (U_{q}) \left | _{V_{q} \to (-\pi /2+0)} = \cos (U_{q}) \left | _{V_{q} \to (\pi /2-0)}
-    //  \sin (U_{q}) \left | _{V_{q} \to (-\pi /2+0)} = \sin (U_{q}) \left | _{V_{q} \to (\pi /2-0)}
-
-    //From the 3rd equation of the system, we obtain
-    //  \frac{\mathrm{d} (R*\sin (V_{q}))}{\mathrm{d} V_{q}} =
-    //  \frac{\mathrm{d} S_{z}(U_{s},V_{s})}{\mathrm{d} V_{q}}
-    //or
-    //  R*\cos (V_{q}) = \frac{\partial S_{z}}{\partial U_{s}}*
-    //  \frac{\mathrm{d} U_{s}} {\mathrm{d} V_{q}}+\frac{\partial S_{z}}
-    //  {\partial V_{s}}*\frac{\mathrm{d} V_{s}}{\mathrm{d} V_{q}}.
-
-    //If @V_{q}=\pm \pi /2@, then
-    //  \frac{\partial S_{z}}{\partial U_{s}}*
-    //  \frac{\mathrm{d} U_{s}} {\mathrm{d} V_{q}}+\frac{\partial S_{z}}
-    //  {\partial V_{s}}*\frac{\mathrm{d} V_{s}}{\mathrm{d} V_{q}} = 0.
-
-    //Consequently, if @\frac{\partial S_{z}}{\partial U_{s}} \neq 0 @ then
-    //  \frac{\mathrm{d} U_{s}}{\mathrm{d} V_{s}} =
-    //  -\frac{\frac{\partial S_{z}}{\partial V_{s}}}
-    //  {\frac{\partial S_{z}}{\partial U_{s}}}.
-
-    //If @ \frac{\partial S_{z}}{\partial V_{s}} \neq 0 @ then
-    //  \frac{\mathrm{d} V_{s}}{\mathrm{d} U_{s}} =
-    //  -\frac{\frac{\partial S_{z}}{\partial U_{s}}}
-    //  {\frac{\partial S_{z}}{\partial V_{s}}}
-
-    //Cases, when @ \frac{\partial S_{z}}{\partial U_{s}} = 
-    //\frac{\partial S_{z}}{\partial V_{s}} = 0 @ are not consider here.
-    //The reason is written below.
-
-    //Vector with {@ \cos (U_{q}) @, @ \sin (U_{q}) @} coordinates.
-    //Ask to pay attention to the fact that this vector is always normalyzed.
-    gp_Vec2d aV1;
-
-    if( (Abs(aVecDu.Z()) < Precision::PConfusion()) &&
-        (Abs(aVecDv.Z()) < Precision::PConfusion()))
+    if (!ProcessSphere(thePtIso, aVecDu, aVecDv, theIsReversed, 
+                        aVquad, aUquad, isIsoChoosen))
     {
-      //Example of this case is an intersection of a plane with a sphere
-      //when the plane tangents the sphere in some pole (i.e. only one 
-      //intersection point, not line). In this case, U-coordinate of the
-      //sphere is undefined (can be realy anything).
-      //Another reason is that we have tangent zone around the pole
-      //(see bug #26576).
-      //Computation of correct value of aUquad is impossible.
-      //Therefore, (in oreder to return something) we will consider
-      //the intersection line goes along some isoline in neighbourhood
-      //of the pole.
-
-#ifdef INTPATCH_ADDSPECIALPOINTS_DEBUG
-      cout << "Cannot find UV-coordinate for quadric in the pole."
-        " See considered comment above. IntPatch_AddSpecialPoints.cxx,"
-        " AddSingularPole(...)" << endl;
-#endif
-      Standard_Real aUIso = 0.0, aVIso = 0.0;
-      if(theIsReversed)
-        thePtIso.ParametersOnS2(aUIso, aVIso);
-      else
-        thePtIso.ParametersOnS1(aUIso, aVIso);
-
-      aUquad = aUIso;
-      isIsoChoosen = Standard_True;
-    }
-    else
-    {
-      if(Abs(aVecDu.Z()) > Abs(aVecDv.Z()))
-      {
-        const Standard_Real aDusDvs = aVecDv.Z()/aVecDu.Z();
-        aV1.SetCoord( aVecDu.X()*aDusDvs - aVecDv.X(),
-                      aVecDu.Y()*aDusDvs - aVecDv.Y());
-      }
-      else
-      {
-        const Standard_Real aDvsDus = aVecDu.Z()/aVecDv.Z();
-        aV1.SetCoord( aVecDv.X()*aDvsDus - aVecDu.X(),
-                      aVecDv.Y()*aDvsDus - aVecDu.Y());
-      }
-
-      aV1.Normalize();
-
-      if(Abs(aV1.X()) > Abs(aV1.Y()))
-        aUquad = Sign(asin(aV1.Y()), aVquad);
-      else
-        aUquad = Sign(acos(aV1.X()), aVquad);
+      return Standard_False;
     }
   }
   else //if(theQSurf->GetType() == GeomAbs_Cone)
   {
-    // This case is not processed. However,
-    // it can be done using the same algorithm
-    // as for sphere (formulas will be different).
-    return Standard_False;
+    if (!ProcessCone(thePtIso, aVecDu, aVecDv, theQSurf->Cone(),
+                      theIsReversed, aUquad, isIsoChoosen))
+    {
+      return Standard_False;
+    }
   }
 
   if(theIsReversed)
@@ -594,6 +901,16 @@ Standard_Boolean IntPatch_SpecialPoints::
 
   if (!isIsoChoosen)
   {
+    Standard_Real anArrOfPeriod[4];
+    if (theIsReversed)
+    {
+      IntSurf::SetPeriod(thePSurf, theQSurf, anArrOfPeriod);
+    }
+    else
+    {
+      IntSurf::SetPeriod(theQSurf, thePSurf, anArrOfPeriod);
+    }
+
     AdjustPointAndVertex(theVertex.PntOn2S(), anArrOfPeriod, theAddedPoint);
   }
   else
@@ -606,7 +923,32 @@ Standard_Boolean IntPatch_SpecialPoints::
 
 //=======================================================================
 //function : ContinueAfterSpecialPoint
-//purpose  : 
+//purpose  : If the last point of the line is the pole of the quadric then
+//            the Walking-line has been broken in this point.
+//           However, new line must start from this point. Here we must
+//            find 2D-coordinates of "this new" point.
+/*
+The inters. line in the neighborhood of the Apex/Pole(s) can be
+approximated by the intersection result of the Cone/Sphere with
+the plane going through the Apex/Pole and being tangent to the
+2nd intersected surface. This intersection result is well known.
+
+In case of sphere, the inters. result is a circle.
+If we go along this circle and across the Pole then U-parameter of
+the sphere (@U_{q}@) will change to +/-PI.
+
+In case of cone, the inters. result is two intersected lines (which
+can be merged to one in a special case when the plane goes along
+some generatrix of the cone). The direction of these lines
+are computed by GetTangentToIntLineForCone(...) method).
+
+When the real (not lines) inters. curve goes through the cone apex then
+two variants are possible:
+a) The tangent line to the inters. curve will be left. In this case
+U-parameter of the cone (@U_{q}@) will be change to +/-PI.
+b) Another line (as inters. result of cone + plane) will tangent
+to the inters. curve. In this case @U_{q}@ must be recomputed.
+*/
 //=======================================================================
 Standard_Boolean IntPatch_SpecialPoints::
                   ContinueAfterSpecialPoint(const Handle(Adaptor3d_HSurface)& theQSurf,
@@ -620,36 +962,63 @@ Standard_Boolean IntPatch_SpecialPoints::
   if(theSPType == IntPatch_SPntNone)
     return Standard_False;
 
-  //If the last point of the line is the pole of the quadric.
-  //In this case, Walking-line has been broken in this point.
-  //However, new line must start from this point. Here we must
-  //find its 2D-coordinates.
-
-  //For sphere and cone, some intersection point is satisfied to the system
-  //  \cos(U_{q}) = S_{x}(U_{s},V_{s})/F(V_{q}) 
-  //  \sin(U_{q}) = S_{y}(U_{s},V_{s})/F(V_{q}) 
-
-  //where 
-  //  @S_{x}@, @S_{y}@ are X and Y-coordinates of thePSurf;
-  //  @U_{s}@ and @V_{s}@ are UV-parameters on thePSurf;
-  //  @U_{q}@ and @V_{q}@ are UV-parameters on theQSurf;
-  //  @F(V_{q}) @ is some function, which value independs on @U_{q}@
-  //              (form of this function depends on the type of the quadric).
-
-  //When we go through the pole/apex, the function @F(V_{q}) @ changes sign.
-  //Therefore, some cases are possible, when only @\cos(U_{q}) @ or
-  //only @ \sin(U_{q}) @ change sign.
-
-  //Consequently, when the line goes throug the pole, @U_{q}@ can be
-  //changed on @\pi /2 @ (but not less).
-    
   if(theNewPoint.IsSame(theRefPt, Precision::Confusion(), theTol2D))
   {
     return Standard_False;
   }
 
-  //Here, in case of pole/apex adding, we forbid "jumping" between two neighbor
-  //Walking-point with step greater than pi/4
+  if ((theSPType == IntPatch_SPntPole) && (theQSurf->GetType() == GeomAbs_Cone))
+  {
+    //Check if the condition b) is satisfied.
+    //Repeat the same steps as in 
+    //IntPatch_SpecialPoints::AddSingularPole(...) method.
+
+    //On parametric
+    Standard_Real aU0 = 0.0, aV0 = 0.0;
+    //On quadric
+    Standard_Real aUquad = 0.0, aVquad = 0.0;
+
+    if (theIsReversed)
+      theNewPoint.Parameters(aU0, aV0, aUquad, aVquad);
+    else
+      theNewPoint.Parameters(aUquad, aVquad, aU0, aV0);
+
+    gp_Pnt aPtemp;
+    gp_Vec aVecDu, aVecDv;
+    thePSurf->D1(aU0, aV0, aPtemp, aVecDu, aVecDv);
+
+    //Transforms parametric surface in coordinate-system of the quadric
+    gp_Trsf aTr;
+    aTr.SetTransformation(theQSurf->Cone().Position());
+
+    //Derivatives of transformed thePSurf
+    aVecDu.Transform(aTr);
+    aVecDv.Transform(aTr);
+
+    Standard_Boolean isIsoChoosen = Standard_False;
+    ProcessCone(theRefPt, aVecDu, aVecDv, theQSurf->Cone(),
+                theIsReversed, aUquad, isIsoChoosen);
+
+    theNewPoint.SetValue(!theIsReversed, aUquad, aVquad);
+  }
+
+  //As it has already been said, in case of going through the Pole/Apex,
+  //U-parameter of the quadric surface will change to +/-PI. This rule has some
+  //exceptions:
+  //1. When 2nd surface has C0-continuity in the point common with the Apex/Pole.
+  //    In this case, the tangent line to the intersection curve after the Apex/Pole
+  //    must be totally recomputed according to the new derivatives of the 2nd surface.
+  //    Currently, it is not implemented but will be able to be done after the
+  //    corresponding demand.
+  //2. The inters. curve has C1 continuity but huge curvature in the point common with 
+  //    the Apex/Pole. Existing inters. algorithm does not allow putting many points
+  //    near to the Apex/Pole in order to cover this "sharp" piece of the inters. curve.
+  //    Therefore, we use adjusting U-parameter of the quadric surface with
+  //    period PI/2 instead of 2PI. It does not have any mathematical idea
+  //    but allows creating WLine with more or less uniform distributed points.
+  //    In other words, we forbid "jumping" between two neighbor Walking-points
+  //    with step greater than PI/4.
+
   const Standard_Real aPeriod = (theSPType == IntPatch_SPntPole)? M_PI_2 : 2.0*M_PI;
 
   const Standard_Real aUpPeriod = thePSurf->IsUPeriodic() ? thePSurf->UPeriod() : 0.0;

src/IntPatch/IntPatch_SpecialPoints.hxx

@@ -24,6 +24,9 @@
 #include <Standard_Handle.hxx>
 
 class Adaptor3d_HSurface;
+class gp_Cone;
+class gp_Vec;
+class gp_XYZ;
 class IntPatch_Point;
 class IntSurf_PntOn2S;
 class math_Vector;
@@ -51,12 +54,18 @@ public:
   //! theRefPt is used to correct adjusting parameters.
   //! If theIsReversed is TRUE then theQSurf corresponds to the 
   //! second (otherwise, the first) surface while forming
-  //! intersection point IntSurf_PntOn2S.  
+  //! intersection point IntSurf_PntOn2S.
+  //! All math_Vector-objects must be filled as follows:
+  //!   [1] - U-parameter of thePSurf;
+  //!   [2] - V-parameter of thePSurf;
+  //!   [3] - U- (if V-isoline is considered) or V-parameter
+  //!         (if U-isoline is considered) of theQSurf.
   Standard_EXPORT static Standard_Boolean
                       AddPointOnUorVIso(const Handle(Adaptor3d_HSurface)& theQSurf,
                                         const Handle(Adaptor3d_HSurface)& thePSurf,
                                         const IntSurf_PntOn2S& theRefPt,
                                         const Standard_Boolean theIsU,
+                                        const Standard_Real theIsoParameter,
                                         const math_Vector& theToler,
                                         const math_Vector& theInitPoint,
                                         const math_Vector& theInfBound,
@@ -80,7 +89,6 @@ public:
                       AddSingularPole(const Handle(Adaptor3d_HSurface)& theQSurf,
                                       const Handle(Adaptor3d_HSurface)& thePSurf,
                                       const IntSurf_PntOn2S& thePtIso,
-                                      const Standard_Real theTol3d,
                                       IntPatch_Point& theVertex,
                                       IntSurf_PntOn2S& theAddedPoint,                                      
                                       const Standard_Boolean theIsReversed =
@@ -120,6 +128,39 @@ public:
                                            const Standard_Real theArrPeriods[4],
                                            IntSurf_PntOn2S &theNewPoint,
                                            IntPatch_Point* const theVertex = 0);
+
+protected:
+  //! Computes "special point" in the sphere
+  //! The parameter will be found in the range [0, 2*PI].
+  //! Therefore it must be adjusted to valid range by
+  //! the high-level algorithm
+  static Standard_EXPORT Standard_Boolean ProcessSphere(const IntSurf_PntOn2S& thePtIso,
+                                                        const gp_Vec& theDUofPSurf,
+                                                        const gp_Vec& theDVofPSurf,
+                                                        const Standard_Boolean theIsReversed,
+                                                        const Standard_Real theVquad,
+                                                        Standard_Real& theUquad,
+                                                        Standard_Boolean& theIsIsoChoosen);
+
+  //! Computes "special point" in the cone.
+  //! The parameter will be found in the range [0, 2*PI].
+  //! Therefore it must be adjusted to valid range by
+  //! the high-level algorithm.
+  static Standard_EXPORT Standard_Boolean ProcessCone(const IntSurf_PntOn2S& thePtIso,
+                                                      const gp_Vec& theDUofPSurf,
+                                                      const gp_Vec& theDVofPSurf,
+                                                      const gp_Cone& theCone,
+                                                      const Standard_Boolean theIsReversed,
+                                                      Standard_Real& theUquad,
+                                                      Standard_Boolean& theIsIsoChoosen);
+
+  //! Computes vector tangent to the intersection line in cone apex.
+  //! There exist not more than 2 tangent. They will be stores in theResult vector.
+  //! Returns the number of found tangents.
+  //! thePlnNormal is the normalized vector of the normal to the plane intersected the cone.
+  static Standard_EXPORT Standard_Integer GetTangentToIntLineForCone(const Standard_Real theConeSemiAngle,
+                                                                     const gp_XYZ& thePlnNormal,
+                                                                     gp_XYZ theResult[2]);
 };
 
 #endif // _IntPatch_AddSpecialPoints_HeaderFile

src/IntPatch/IntPatch_WLineTool.cxx

@@ -41,7 +41,8 @@ enum IntPatchWT_WLsConnectionType
 {
   IntPatchWT_NotConnected,
   IntPatchWT_Singular,
-  IntPatchWT_EachOther
+  IntPatchWT_Common,
+  IntPatchWT_ReqExtend
 };
 
 //=======================================================================
@@ -849,17 +850,23 @@ static IntPatchWT_WLsConnectionType
                                            const Standard_Real* const theArrPeriods)
 {
   const Standard_Real aSqToler = theToler3D*theToler3D;
-
+  IntPatchWT_WLsConnectionType aRetVal = IntPatchWT_NotConnected;
   if(theVec3.SquareMagnitude() <= aSqToler)
   {
-    return IntPatchWT_NotConnected;
+    if ((theVec1.Angle(theVec2) > IntPatch_WLineTool::myMaxConcatAngle))
+    {
+      return aRetVal;
+    }
+    else
+    {
+      aRetVal = IntPatchWT_Common;
+    }
   }
-
-  if((theVec1.Angle(theVec2) > IntPatch_WLineTool::myMaxConcatAngle) ||
-     (theVec1.Angle(theVec3) > IntPatch_WLineTool::myMaxConcatAngle) ||
-     (theVec2.Angle(theVec3) > IntPatch_WLineTool::myMaxConcatAngle))
+  else if((theVec1.Angle(theVec2) > IntPatch_WLineTool::myMaxConcatAngle) ||
+          (theVec1.Angle(theVec3) > IntPatch_WLineTool::myMaxConcatAngle) ||
+          (theVec2.Angle(theVec3) > IntPatch_WLineTool::myMaxConcatAngle))
   {
-    return IntPatchWT_NotConnected;
+    return aRetVal;
   }
 
   const gp_Pnt aPmid(0.5*(thePtWL1.Value().XYZ()+thePtWL2.Value().XYZ()));
@@ -973,7 +980,12 @@ static IntPatchWT_WLsConnectionType
     return IntPatchWT_Singular;
   }
 
-  return IntPatchWT_EachOther;
+  if (aRetVal == IntPatchWT_Common)
+  {
+    return IntPatchWT_Common;
+  }
+
+  return IntPatchWT_ReqExtend;
 }
 
 //=======================================================================
@@ -984,12 +996,47 @@ static IntPatchWT_WLsConnectionType
 Standard_Boolean CheckArgumentsToJoin(const Handle(Adaptor3d_HSurface)& theS1,
                                       const Handle(Adaptor3d_HSurface)& theS2,
                                       const IntSurf_PntOn2S& thePnt,
+                                      const gp_Pnt& theP1,
+                                      const gp_Pnt& theP2,
+                                      const gp_Pnt& theP3,
                                       const Standard_Real theMinRad)
 {
-  const Standard_Real aRad = 
-        IntPatch_PointLine::CurvatureRadiusOfIntersLine(theS1, theS2, thePnt);
+  const Standard_Real aRad =
+    IntPatch_PointLine::CurvatureRadiusOfIntersLine(theS1, theS2, thePnt);
 
-  return (aRad > theMinRad);
+  if (aRad > theMinRad)
+  {
+    return Standard_True;
+  }
+  else if (aRad > 0.0)
+  {
+    return Standard_False;
+  }
+
+  // Curvature radius cannot be computed.
+  // Check smoothness of polygon.
+
+  //                  theP2
+  //                    *
+  //                    |
+  //                    |
+  //       *            o         *
+  //      theP1         O       theP3
+
+  //Joining is enabled if two conditions are satisfied together:
+  //  1. Angle (theP1, theP2, theP3) is quite big;
+  //  2. Modulus of perpendicular (O->theP2) to the segment (theP1->theP3)
+  //  is less than 0.01*<modulus of this segment>.
+
+  const gp_Vec aV12f(theP1, theP2), aV12l(theP2, theP3);
+
+  if (aV12f.Angle(aV12l) > IntPatch_WLineTool::myMaxConcatAngle)
+    return Standard_False;
+
+  const gp_Vec aV13(theP1, theP3);
+  const Standard_Real aSq13 = aV13.SquareMagnitude();
+
+  return (aV12f.CrossSquareMagnitude(aV13) < 1.0e-4*aSq13*aSq13);
 }
 
 //=======================================================================
@@ -1482,18 +1529,14 @@ void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
       const Standard_Real aSqMinFDist = Min(aSqDistF, aSqDistL);
       if (aSqMinFDist < Precision::SquareConfusion())
       {
-        if (CheckArgumentsToJoin(theS1, theS2, aPntFWL1, aMinRad))
+        const Standard_Boolean isFM = (aSqDistF < aSqDistL);
+        const IntSurf_PntOn2S& aPt1 = aWLine1->Point(2);
+        const IntSurf_PntOn2S& aPt2 = isFM ? aWLine2->Point(2) :
+                                             aWLine2->Point(aNbPntsWL2 - 1);
+        if (!IsSeamOrBound(aPt1, aPt2, aPntFWL1,
+                            anArrPeriods, anArrFBonds, anArrLBonds))
         {
-          const Standard_Boolean isFM = (aSqDistF < aSqDistL);
-          const IntSurf_PntOn2S& aPt1 = aWLine1->Point(2);
-          const IntSurf_PntOn2S& aPt2 = isFM ? aWLine2->Point(2) :
-                                                      aWLine2->Point(aNbPntsWL2 - 1);
-
-          if (!IsSeamOrBound(aPt1, aPt2, aPntFWL1,
-                              anArrPeriods, anArrFBonds, anArrLBonds))
-          {
-            isFirstConnected = Standard_True;
-          }
+          isFirstConnected = Standard_True;
         }
       }
 
@@ -1503,18 +1546,14 @@ void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
       const Standard_Real aSqMinLDist = Min(aSqDistF, aSqDistL);
       if (aSqMinLDist < Precision::SquareConfusion())
       {
-        if (CheckArgumentsToJoin(theS1, theS2, aPntLWL1, aMinRad))
+        const Standard_Boolean isFM = (aSqDistF < aSqDistL);
+        const IntSurf_PntOn2S& aPt1 = aWLine1->Point(aNbPntsWL1 - 1);
+        const IntSurf_PntOn2S& aPt2 = isFM ? aWLine2->Point(2) :
+                                             aWLine2->Point(aNbPntsWL2 - 1);
+        if (!IsSeamOrBound(aPt1, aPt2, aPntLWL1,
+                           anArrPeriods, anArrFBonds, anArrLBonds))
         {
-          const Standard_Boolean isFM = (aSqDistF < aSqDistL);
-          const IntSurf_PntOn2S& aPt1 = aWLine1->Point(aNbPntsWL1 - 1);
-          const IntSurf_PntOn2S& aPt2 = isFM ? aWLine2->Point(2) :
-                                               aWLine2->Point(aNbPntsWL2 - 1);
-
-          if (!IsSeamOrBound(aPt1, aPt2, aPntLWL1,
-                              anArrPeriods, anArrFBonds, anArrLBonds))
-          {
-            isLastConnected = Standard_True;
-          }
+          isLastConnected = Standard_True;
         }
       }
 
@@ -1549,15 +1588,29 @@ void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
 
     const Standard_Integer anIndexWL2 = isFirstConnected ? aListFC.First() : aListLC.First();
     Handle(IntPatch_WLine) aWLine2(Handle(IntPatch_WLine)::DownCast(theSlin.Value(anIndexWL2)));
-    
     const Standard_Integer aNbPntsWL2 = aWLine2->NbPnts();
     const IntSurf_PntOn2S& aPntFWL2 = aWLine2->Point(1);
-
-    aWLine1->ClearVertexes();
-
+    const IntSurf_PntOn2S& aPntLWL2 = aWLine2->Point(aNbPntsWL2);
+    
     if (isFirstConnected)
     {
-      if (aPntFWL1.IsSame(aPntFWL2, Precision::Confusion()))
+      const Standard_Real aSqDistF = aPntFWL1.Value().SquareDistance(aPntFWL2.Value());
+      const Standard_Real aSqDistL = aPntFWL1.Value().SquareDistance(aPntLWL2.Value());
+      const Standard_Boolean isFM = (aSqDistF < aSqDistL);
+
+      const IntSurf_PntOn2S& aPt1 = aWLine1->Point(2);
+      const IntSurf_PntOn2S& aPt2 = isFM ? aWLine2->Point(2) : 
+                                           aWLine2->Point(aNbPntsWL2 - 1);
+
+      if (!CheckArgumentsToJoin(theS1, theS2, aPntFWL1, aPt1.Value(),
+                                aPntFWL1.Value(), aPt2.Value(), aMinRad))
+      {
+        continue;
+      }
+
+      aWLine1->ClearVertexes();
+
+      if (isFM)
       {
         //First-First-connection
         for (Standard_Integer aNPt = 1; aNPt <= aNbPntsWL2; aNPt++)
@@ -1578,10 +1631,26 @@ void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
     }
     else //if (isLastConnected)
     {
-      if (aPntLWL1.IsSame(aPntFWL2, Precision::Confusion()))
+      const Standard_Real aSqDistF = aPntLWL1.Value().SquareDistance(aPntFWL2.Value());
+      const Standard_Real aSqDistL = aPntLWL1.Value().SquareDistance(aPntLWL2.Value());
+
+      const Standard_Boolean isFM = (aSqDistF < aSqDistL);
+      const IntSurf_PntOn2S& aPt1 = aWLine1->Point(aNbPntsWL1 - 1);
+      const IntSurf_PntOn2S& aPt2 = isFM ? aWLine2->Point(2) :
+                                           aWLine2->Point(aNbPntsWL2 - 1);
+
+      if (!CheckArgumentsToJoin(theS1, theS2, aPntLWL1, aPt1.Value(),
+                                aPntFWL1.Value(), aPt2.Value(), aMinRad))
+      {
+        continue;
+      }
+      
+      aWLine1->ClearVertexes();
+      
+      if (isFM)
       {
         //Last-First connection
-        for(Standard_Integer aNPt = 1; aNPt <= aNbPntsWL2; aNPt++)
+        for (Standard_Integer aNPt = 1; aNPt <= aNbPntsWL2; aNPt++)
         {
           const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
           aWLine1->Curve()->Add(aPt);
@@ -1609,13 +1678,15 @@ void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
 //purpose  : Performs extending theWLine1 and theWLine2 through their
 //            respecting end point.
 //=======================================================================
-void IntPatch_WLineTool::ExtendTwoWLines(IntPatch_SequenceOfLine& theSlin,
-                                         const Handle(Adaptor3d_HSurface)& theS1,
-                                         const Handle(Adaptor3d_HSurface)& theS2,
-                                         const Standard_Real theToler3D,
-                                         const Standard_Real* const theArrPeriods,
-                                         const Bnd_Box2d& theBoxS1,
-                                         const Bnd_Box2d& theBoxS2)
+void IntPatch_WLineTool::
+        ExtendTwoWLines(IntPatch_SequenceOfLine& theSlin,
+                        const Handle(Adaptor3d_HSurface)& theS1,
+                        const Handle(Adaptor3d_HSurface)& theS2,
+                        const Standard_Real theToler3D,
+                        const Standard_Real* const theArrPeriods,
+                        const Bnd_Box2d& theBoxS1,
+                        const Bnd_Box2d& theBoxS2,
+                        const NCollection_List<gp_Pnt>& theListOfCriticalPoints)
 {
   if(theSlin.Length() < 2)
     return;
@@ -1677,6 +1748,46 @@ void IntPatch_WLineTool::ExtendTwoWLines(IntPatch_SequenceOfLine& theSlin,
       {
         aCheckResult |= IntPatchWT_DisLastFirst | IntPatchWT_DisLastLast;
       }
+
+      if (!theListOfCriticalPoints.IsEmpty())
+      {
+        for (NCollection_List<gp_Pnt>::Iterator anItr(theListOfCriticalPoints);
+             anItr.More(); anItr.Next())
+        {
+          const gp_Pnt &aPt = anItr.Value();
+          if (!(aCheckResult & (IntPatchWT_DisFirstFirst | IntPatchWT_DisFirstLast)))
+          {
+            if (aPt.SquareDistance(aPntFWL1.Value()) < Precision::Confusion())
+            {
+              aCheckResult |= IntPatchWT_DisFirstFirst | IntPatchWT_DisFirstLast;
+            }
+          }
+
+          if (!(aCheckResult & (IntPatchWT_DisLastFirst | IntPatchWT_DisLastLast)))
+          {
+            if (aPt.SquareDistance(aPntLWL1.Value()) < Precision::Confusion())
+            {
+              aCheckResult |= IntPatchWT_DisLastFirst | IntPatchWT_DisLastLast;
+            }
+          }
+
+          if (!(aCheckResult & (IntPatchWT_DisFirstFirst | IntPatchWT_DisLastFirst)))
+          {
+            if (aPt.SquareDistance(aPntFWL2.Value()) < Precision::Confusion())
+            {
+              aCheckResult |= IntPatchWT_DisFirstFirst | IntPatchWT_DisLastFirst;
+            }
+          }
+
+          if (!(aCheckResult & (IntPatchWT_DisFirstLast | IntPatchWT_DisLastLast)))
+          {
+            if (aPt.SquareDistance(aPntLWL2.Value()) < Precision::Confusion())
+            {
+              aCheckResult |= IntPatchWT_DisFirstLast | IntPatchWT_DisLastLast;
+            }
+          }
+        }
+      }
     }
 
     if(aCheckResult == (IntPatchWT_DisFirstFirst | IntPatchWT_DisFirstLast |

src/IntPatch/IntPatch_WLineTool.hxx

@@ -18,6 +18,7 @@
 
 #include <IntPatch_SequenceOfLine.hxx>
 #include <IntPatch_WLine.hxx>
+#include <NCollection_List.hxx>
 
 class Adaptor3d_TopolTool;
 
@@ -49,29 +50,30 @@ public:
                                               const Handle(Adaptor3d_TopolTool)  &theDom1,
                                               const Handle(Adaptor3d_TopolTool)  &theDom2);
 
-//! Joins all WLines from theSlin to one if it is possible and records 
-//! the result into theSlin again. Lines will be kept to be splitted if:
-//! a) they are separated (has no common points);
-//! b) resulted line (after joining) go through seam-edges or surface boundaries.
-//!
-//! In addition, if points in theSPnt lies at least in one of the line in theSlin,
-//! this point will be deleted.
+  //! Joins all WLines from theSlin to one if it is possible and records 
+  //! the result into theSlin again. Lines will be kept to be split if:
+  //! a) they are separated (has no common points);
+  //! b) resulted line (after joining) go through seam-edges or surface boundaries.
+  //!
+  //! In addition, if points in theSPnt lies at least in one of the line in theSlin,
+  //! this point will be deleted.
   Standard_EXPORT static void JoinWLines(IntPatch_SequenceOfLine& theSlin,
                                          IntPatch_SequenceOfPoint& theSPnt,
                                          Handle(Adaptor3d_HSurface) theS1,
                                          Handle(Adaptor3d_HSurface) theS2,
                                          const Standard_Real theTol3D);
 
-//! Extends every line from theSlin (if it is possible) to be started/finished
-//! in strictly determined point (in the place of joint of two lines).
-//! As result, some gaps between two lines will vanish.
-//! The Walking lines are supposed (algorithm will do nothing for not-Walking line)
-//! to be computed as a result of intersection. Both theS1 and theS2 
-//! must be quadrics. Other cases are not supported.
-//! theArrPeriods must be filled as follows (every value must not be negative;
-//! if the surface is not periodic the period must be equal to 0.0 strictly):
-//! {<U-period of 1st surface>, <V-period of 1st surface>,
-//!               <U-period of 2nd surface>, <V-period of 2nd surface>}.
+  //! Extends every line from theSlin (if it is possible) to be started/finished
+  //! in strictly determined point (in the place of joint of two lines).
+  //! As result, some gaps between two lines will vanish.
+  //! The Walking lines are supposed (algorithm will do nothing for not-Walking line)
+  //! to be computed as a result of intersection. Both theS1 and theS2 
+  //! must be quadrics. Other cases are not supported.
+  //! theArrPeriods must be filled as follows (every value must not be negative;
+  //! if the surface is not periodic the period must be equal to 0.0 strictly):
+  //! {<U-period of 1st surface>, <V-period of 1st surface>,
+  //!               <U-period of 2nd surface>, <V-period of 2nd surface>}.
+  //! theListOfCriticalPoints must contain 3D-points where joining is disabled.
   Standard_EXPORT static void
             ExtendTwoWLines(IntPatch_SequenceOfLine& theSlin,
                             const Handle(Adaptor3d_HSurface)& theS1,
@@ -79,7 +81,8 @@ public:
                             const Standard_Real theToler3D,
                             const Standard_Real* const theArrPeriods,
                             const Bnd_Box2d& theBoxS1,
-                            const Bnd_Box2d& theBoxS2);
+                            const Bnd_Box2d& theBoxS2,
+                            const NCollection_List<gp_Pnt>& theListOfCriticalPoints);
 
   //! Max angle to concatenate two WLines to avoid result with C0-continuity
   static const Standard_Real myMaxConcatAngle;

src/IntStart/IntStart_SearchOnBoundaries.gxx

@@ -225,14 +225,13 @@ void BoundedArc (const TheArc& A,
   // Creer l echantillonage (math_FunctionSample ou classe heritant)
   // Appel a math_FunctionAllRoots
 
-  Standard_Real EpsX = TheArcTool::Resolution(A,Precision::Confusion());
   //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
   //@@@ La Tolerance est asociee a l arc  ( Incoherence avec le cheminement )
   //@@@   ( EpsX ~ 1e-5   et ResolutionU et V ~ 1e-9 )
   //@@@   le vertex trouve ici n'est pas retrouve comme point d arret d une 
   //@@@   ligne de cheminement
   //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
-  EpsX = 0.0000000001;
+  Standard_Real EpsX = 1.e-10;
   //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
   //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
   //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

src/IntTools/IntTools_FClass2d.cxx

@@ -43,6 +43,8 @@
 #include <TopoDS_Edge.hxx>
 #include <TopoDS_Face.hxx>
 #include <TopoDS_Wire.hxx>
+#include <GeomLib.hxx>
+#include <Poly.hxx>
 
 #include <stdio.h>
 
@@ -85,7 +87,7 @@ void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
 			     const Standard_Real TolUV) 
 {
   Standard_Boolean WireIsNotEmpty, Ancienpnt3dinitialise, degenerated;
-  Standard_Integer nbpnts, firstpoint, NbEdges;
+  Standard_Integer firstpoint, NbEdges;
   Standard_Integer iX, aNbs1, nbs, Avant, BadWire;
   Standard_Real u, du, Tole, Tol, pfbid, plbid;
   Standard_Real FlecheU, FlecheV, TolVertex1, TolVertex;
@@ -128,7 +130,6 @@ void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
   for(; aExpF.More();  aExpF.Next()) {
     const TopoDS_Wire& aW=*((TopoDS_Wire*)&aExpF.Current());
     //
-    nbpnts = 0;
     firstpoint =1;
     FlecheU = 0.;
     FlecheV = 0.;
@@ -264,7 +265,7 @@ void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
       //-- and the last point saved in SeqPnt2d
       //-- To to set the first point of the current 
       //-- afar from the last saved point
-      Avant = nbpnts;
+      Avant = SeqPnt2d.Length();
       for(iX=firstpoint; iX<=aNbs1; iX++) {
         Standard_Boolean IsRealCurve3d;
         Standard_Integer ii;
@@ -282,7 +283,7 @@ void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
         aDstX=RealLast();        
         if(degenerated==Standard_False) { 
           P3d=C3d.Value(u);
-          if(nbpnts>1) {
+          if(!SeqPnt2d.IsEmpty()) {
             if(Ancienpnt3dinitialise) { 
               aDstX=P3d.SquareDistance(Ancienpnt3d);
             }
@@ -308,11 +309,10 @@ void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
             Ancienpnt3d=P3d;
             Ancienpnt3dinitialise=Standard_True;
           }
-          nbpnts++;
           SeqPnt2d.Append(P2d);
         }
         //
-        ii=nbpnts;
+        ii= SeqPnt2d.Length();
         if(ii>(Avant+4)) { 
           Standard_Real ul, dU, dV;
           gp_Pnt2d Pp;
@@ -386,107 +386,38 @@ void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
     }
     //
     else if(WireIsNotEmpty) { 
-      TColgp_Array1OfPnt2d PClass(1,nbpnts);
-      gp_Pnt2d anInitPnt(0., 0.);
-      //
-      PClass.Init(anInitPnt);
-      if(nbpnts>3) { 
-        Standard_Integer im2=nbpnts-2;
-        Standard_Integer im1=nbpnts-1;
-        Standard_Integer im0=1;
-        Standard_Real    angle = 0.0;
-        Standard_Real aX0, aY0, aX1, aY1, aS;
-        //
-        aS=0.;
-        //
-        Standard_Integer iFlag=1;
-	//
-        PClass(im2)=SeqPnt2d.Value(im2);
-        PClass(im1)=SeqPnt2d.Value(im1);
-        PClass(nbpnts)=SeqPnt2d.Value(nbpnts);
-        Standard_Real aPer = 0.;
-        for (Standard_Integer ii = 1; ii<nbpnts; ii++, im0++, im1++, im2++)
-        {
-          if(im2>=nbpnts) im2=1;
-          if(im1>=nbpnts) im1=1;
-          PClass(ii)=SeqPnt2d.Value(ii);
-          //
-          const gp_Pnt2d& aP2D1=PClass(im1);
-          const gp_Pnt2d& aP2D0=PClass(im0);
-          //aP2D0 is next to aP2D1
-          aP2D0.Coord(aX0, aY0);
-          aP2D1.Coord(aX1, aY1);
-          aS=aS+(aY0+aY1)*(aX1-aX0); 
-          aPer += aP2D1.Distance(aP2D0);
-
-          gp_Vec2d A(PClass(im2),PClass(im1));
-          gp_Vec2d B(PClass(im1),PClass(im0));
-
-          Standard_Real N = A.Magnitude() * B.Magnitude();
-          if(N>1e-16) { 
-            Standard_Real a=A.Angle(B);
-            //  
-            if (anIndexMap.IsBound(im1)) {
-              Standard_Integer  anInd  = anIndexMap.Find(im1);
-              const gp_Vec2d   &aVPrev = aD1Prev.Value(anInd);
-              const gp_Vec2d   &aVNext = aD1Next.Value(anInd);
-
-              Standard_Real aN = aVPrev.Magnitude() * aVNext.Magnitude();
-              if(aN > 1e-16) { 
-                Standard_Real aDerivAngle, aAbsDA, aProduct, aPA;
-                //ifv 23.08.06
-		aPA=Precision::Angular();
-		aDerivAngle = aVPrev.Angle(aVNext);
-		aAbsDA=Abs(aDerivAngle);
-                if(aAbsDA <= aPA) {
-		  aDerivAngle = 0.; 
-		}
-		//
-		aProduct=aDerivAngle * a;
-		//
-	        if(Abs(aAbsDA - M_PI) <= aPA) {
-		  if (aProduct > 0.) {
-		    aProduct=-aProduct; 
-		  }
-		}
-                //ifv 23.08.06 : if edges continuity > G1, |aDerivAngle| ~0,
-                //but can has wrong sign and causes condition aDerivAngle * a < 0.
-                //that is wrong in such situation
-                if (iFlag && aProduct < 0.) {
-                  iFlag=0;
-                  // Bad case.
-                  angle = 0.;
-                }
-              }
-            }
-            angle+=a;
-          }
-        }//for(ii=1; ii<nbpnts; ii++,im0++,im1++,im2++) { 
-        if (!iFlag) {
-          angle = 0.; 
-        }
+      if (SeqPnt2d.Length() > 3)
+      {
 #ifdef DEBUG_PCLASS_POLYGON
+        TColgp_Array1OfPnt2d PClass(1, nbpnts);
         TColStd_Array1OfReal aKnots(1, nbpnts);
         TColStd_Array1OfInteger aMults(1, nbpnts);
         for (int i = 1; i <= nbpnts; i++)
         {
           aKnots(i) = i;
           aMults(i) = 1;
+          PClass(ii) = SeqPnt2d.Value(ii);
         }
         aMults(1) = aMults(nbpnts) = 2;
         Handle(Geom2d_BSplineCurve) aPol = new Geom2d_BSplineCurve(PClass, aKnots, aMults, 1);
         DrawTrSurf::Set("pol", aPol);
 #endif
 
+        Standard_Real aS = 0.;
+        Standard_Real aPer = 0.;
+        Poly::PolygonProperties(SeqPnt2d, aS, aPer);
+
         Standard_Real anExpThick = Max(2. * Abs(aS) / aPer, 1e-7);
         Standard_Real aDefl = Max(FlecheU, FlecheV);
         Standard_Real aDiscrDefl = Min(aDefl*0.1, anExpThick * 10.);
+        Standard_Boolean isChanged = Standard_False;
         while (aDefl > anExpThick && aDiscrDefl > 1e-7)
         {
           // Deflection of the polygon is too much for this ratio of area and perimeter,
           // and this might lead to self-intersections.
           // Discretize the wire more tightly to eliminate the error.
           firstpoint = 1;
+          isChanged = Standard_True;
           SeqPnt2d.Clear();
           FlecheU = 0.0;
           FlecheV = 0.0;
@@ -532,41 +463,14 @@ void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
               firstpoint = 2;
             }
           }
-          nbpnts = SeqPnt2d.Length();
-          PClass.Resize(1, nbpnts, Standard_False);
-          im1 = nbpnts - 1;
-          im0 = 1;
-          PClass(im1) = SeqPnt2d.Value(im1);
-          PClass(nbpnts) = SeqPnt2d.Value(nbpnts);
-          aS = 0.;
-          aPer = 0.;
-          for (Standard_Integer ii = 1; ii<nbpnts; ii++, im0++, im1++)
-          {
-            if (im1 >= nbpnts) im1 = 1;
-            PClass(ii) = SeqPnt2d.Value(ii);
-            aS += (PClass(im1).X() - PClass(im0).X())*(PClass(im0).Y() + PClass(im1).Y())*.5;
-            aPer += (PClass(im0).XY() - PClass(im1).XY()).Modulus();
-          }
-#ifdef DEBUG_PCLASS_POLYGON
-          TColStd_Array1OfReal aKnots(1, nbpnts);
-          TColStd_Array1OfInteger aMults(1, nbpnts);
-          for (int i = 1; i <= nbpnts; i++)
-          {
-            aKnots(i) = i;
-            aMults(i) = 1;
-          }
-          aMults(1) = aMults(nbpnts) = 2;
-          Handle(Geom2d_BSplineCurve) aPol = new Geom2d_BSplineCurve(PClass, aKnots, aMults, 1);
-          DrawTrSurf::Set("pol1", aPol);
-#endif
-
           anExpThick = Max(2. * Abs(aS) / aPer, 1e-7);
           aDefl = Max(FlecheU, FlecheV);
           aDiscrDefl = Min(aDiscrDefl * 0.1, anExpThick * 10.);
         }
 
-        if(aS>0.){
-          myIsHole=Standard_False;
+        if (isChanged)
+        {
+          Poly::PolygonProperties(SeqPnt2d, aS, aPer);
         }
         //
         if(FlecheU<Toluv)
@@ -575,25 +479,35 @@ void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
         if(FlecheV<Toluv)
           FlecheV = Toluv;
 
-        TabClass.Append((void *)new CSLib_Class2d(PClass,
+        TabClass.Append((void *)new CSLib_Class2d(SeqPnt2d,
 						  FlecheU,
 						  FlecheV,
 						  Umin,Vmin,Umax,Vmax));
         //
-        if((angle<2 && angle>-2)||(angle>10)||(angle<-10)) { 
+        if(Abs(aS) < Precision::SquareConfusion()) { 
           BadWire=1;
           TabOrien.Append(-1);
         } 
-        else {         
-          TabOrien.Append((angle>0.0)? 1 : 0);
+        else
+        {
+          if (aS > 0.0)
+          {
+            myIsHole = Standard_False;
+            TabOrien.Append(1);
+          }
+          else
+          {
+            myIsHole = Standard_True;
+            TabOrien.Append(0);
+          }
         }
       } 
       else { 
         BadWire=1;
         TabOrien.Append(-1);
         TColgp_Array1OfPnt2d PPClass(1,2);
-        PPClass.Init(anInitPnt);
-        TabClass.Append((void *)new CSLib_Class2d(PPClass,
+        SeqPnt2d.Clear();
+        TabClass.Append((void *)new CSLib_Class2d(SeqPnt2d,
 						  FlecheU,
 						  FlecheV,
 						  Umin,Vmin,Umax,Vmax));

src/IntTools/IntTools_FaceFace.cxx

@@ -524,9 +524,6 @@ void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
 #ifdef INTTOOLS_FACEFACE_DEBUG
     if(!myListOfPnts.IsEmpty()) {
       char aBuff[10000];
-      const IntSurf_PntOn2S& aPt = myListOfPnts.First();
-      Standard_Real u1, v1, u2, v2;
-      aPt.Parameters(u1, v1, u2, v2);
 
       Sprintf(aBuff,"bopcurves <face1 face2> -2d");
       IntSurf_ListIteratorOfListOfPntOn2S IterLOP1(myListOfPnts);

src/NCollection/NCollection_Array1.hxx

@@ -370,6 +370,9 @@ public:
   const TheItemType& operator() (const Standard_Integer theIndex) const
   { return Value (theIndex); }
 
+  //! operator[] - alias to Value
+  const TheItemType& operator[] (Standard_Integer theIndex) const { return Value (theIndex); }
+
   //! Variable value access
   TheItemType& ChangeValue (const Standard_Integer theIndex)
   {
@@ -381,6 +384,9 @@ public:
   TheItemType& operator() (const Standard_Integer theIndex)
   { return ChangeValue (theIndex); }
 
+  //! operator[] - alias to ChangeValue
+  TheItemType& operator[] (Standard_Integer theIndex) { return ChangeValue (theIndex); }
+
   //! Set value 
   void SetValue (const Standard_Integer theIndex,
                  const TheItemType&     theItem)

src/NCollection/NCollection_Vector.hxx

@@ -238,6 +238,9 @@ public: //! @name public methods
     return Value (theIndex);
   }
 
+  //! Operator[] - query the const value
+  const TheItemType& operator[] (Standard_Integer theIndex) const { return Value (theIndex); }
+
   const TheItemType& Value (const Standard_Integer theIndex) const
   {
     return *(const TheItemType* )findV (theIndex);
@@ -273,6 +276,9 @@ public: //! @name public methods
     return ChangeValue (theIndex);
   }
 
+  //! Operator[] - query the value
+  TheItemType& operator[] ( Standard_Integer theIndex) { return ChangeValue (theIndex); }
+
   TheItemType& ChangeValue (const Standard_Integer theIndex)
   {
     return *(TheItemType* )findV (theIndex);

src/Poly/Poly.hxx

@@ -20,12 +20,13 @@
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
-
 #include <Poly_ListOfTriangulation.hxx>
 #include <Standard_OStream.hxx>
 #include <Standard_Boolean.hxx>
 #include <Standard_IStream.hxx>
 #include <Standard_Real.hxx>
+#include <TColgp_SequenceOfPnt2d.hxx>
+
 class Poly_Triangulation;
 class Poly_Polygon3D;
 class Poly_Polygon2D;
@@ -125,6 +126,48 @@ public:
   Standard_EXPORT static Standard_Real PointOnTriangle (const gp_XY& P1, const gp_XY& P2, const gp_XY& P3, const gp_XY& P, gp_XY& UV);
 
 
+  //! Returns area and perimeter of 2D-polygon given by its vertices.
+  //! theArea will be negative if the polygon is bypassed clockwise
+  //! and will be positive, otherwise. thePerimeter will always be positive.
+  //!
+  //! ATTENTION!!!
+  //! The container theSeqPnts of 2D-points gp_Pnt2d must have definition
+  //! for following methods: Length(), Lower(), Upper() and Value(Standard_Integer)
+  //! (e.g. it can be either NCollection_Sequence<gp_Pnt2d> or
+  //! NCollection_Array1<gp_Pnt2d>).
+  template <class TypeSequencePnts>
+  Standard_EXPORT static
+    Standard_Boolean PolygonProperties(const TypeSequencePnts& theSeqPnts,
+                                       Standard_Real& theArea,
+                                       Standard_Real& thePerimeter)
+  {
+    if (theSeqPnts.Length() < 2)
+    {
+      theArea = thePerimeter = 0.0;
+      return Standard_True;
+    }
+
+    Standard_Integer aStartIndex = theSeqPnts.Lower();
+    const gp_XY &aRefPnt = theSeqPnts.Value(aStartIndex++).XY();
+    gp_XY aPrevPt = theSeqPnts.Value(aStartIndex++).XY() - aRefPnt, aCurrPt;
+
+    theArea = 0.0;
+    thePerimeter = aPrevPt.Modulus();
+
+    for (Standard_Integer i = aStartIndex; i <= theSeqPnts.Upper(); i++)
+    {
+      aCurrPt = theSeqPnts.Value(i).XY() - aRefPnt;
+      const Standard_Real aDelta = aPrevPt.Crossed(aCurrPt);
+
+      theArea += aDelta;
+      thePerimeter += (aPrevPt - aCurrPt).Modulus();
+      aPrevPt = aCurrPt;
+    }
+
+    thePerimeter += aPrevPt.Modulus();
+    theArea *= 0.5;
+    return Standard_True;
+  }
 
 
 protected:

src/QABugs/QABugs_19.cxx

@@ -1534,25 +1534,6 @@ static Standard_Integer OCC24271 (Draw_Interpretor& di,
 #include <GeomInt_IntSS.hxx>
 #include <Geom_ConicalSurface.hxx>
 #include <Standard_ErrorHandler.hxx>
-//=======================================================================
-//function : OCC23972
-//purpose  : 
-//=======================================================================
-static void DoGeomIntSSTest (const Handle(Geom_Surface)& theSurf1,
-			     const Handle(Geom_Surface)& theSurf2,
-			     const Standard_Integer theNbSol,
-			     Draw_Interpretor& di)
-{
-  try {
-    OCC_CATCH_SIGNALS
-	 GeomInt_IntSS anInter;
-	 anInter.Perform (theSurf1, theSurf2, Precision::Confusion(), Standard_True);
-	 QVERIFY (anInter.IsDone());
-	 QCOMPARE (anInter.NbLines(), theNbSol);
-  } catch (...) {
-    QVERIFY (Standard_False);
-  }
-}
 
 namespace {
   static Handle(Geom_ConicalSurface) CreateCone (const gp_Pnt& theLoc,
@@ -1569,28 +1550,30 @@ namespace {
   }
 }
 
-static Standard_Integer OCC23972 (Draw_Interpretor& di,Standard_Integer n, const char**)
+static Standard_Integer OCC23972(Draw_Interpretor& /*theDI*/,
+                                 Standard_Integer theNArg, const char** theArgs)
 {
-  if (n != 1) return 1;
+  if (theNArg != 3) return 1;
 
-  //process specific cones, cannot read them from files because due to rounding the original error
-  //in math_FunctionRoots gets hidden
-  Handle(Geom_Surface) aS1 = CreateCone (
-					 gp_Pnt (123.694345356663, 789.9, 68.15),
-					 gp_Dir (-1, 3.48029791472957e-016, -8.41302743359754e-017),
-					 gp_Dir (-3.48029791472957e-016, -1, -3.17572289932207e-016),
-					 3.28206830417112,
-					 0.780868809443031,
-					 0.624695047554424);
-  Handle(Geom_Surface) aS2 = CreateCone (
-					 gp_Pnt (123.694345356663, 784.9, 68.15),
-					 gp_Dir (-1, -2.5209507537117e-016, -1.49772808948866e-016),
-					 gp_Dir (1.49772808948866e-016, 3.17572289932207e-016, -1),
-					 3.28206830417112,
-					 0.780868809443031,
-					 0.624695047554424);
+  //process specific cones, cannot read them from files because 
+  //due to rounding the original error in math_FunctionRoots gets hidden
+  const Handle(Geom_Surface) aS1 = CreateCone(
+                              gp_Pnt(123.694345356663, 789.9, 68.15),
+                              gp_Dir(-1, 3.48029791472957e-016, -8.41302743359754e-017),
+                              gp_Dir(-3.48029791472957e-016, -1, -3.17572289932207e-016),
+                              3.28206830417112,
+                              0.780868809443031,
+                              0.624695047554424);
+  const Handle(Geom_Surface) aS2 = CreateCone(
+                              gp_Pnt(123.694345356663, 784.9, 68.15),
+                              gp_Dir(-1, -2.5209507537117e-016, -1.49772808948866e-016),
+                              gp_Dir(1.49772808948866e-016, 3.17572289932207e-016, -1),
+                              3.28206830417112,
+                              0.780868809443031,
+                              0.624695047554424);
   
-  DoGeomIntSSTest (aS1, aS2, 2, di);
+  DrawTrSurf::Set(theArgs[1], aS1);
+  DrawTrSurf::Set(theArgs[2], aS2);
 
   return 0;
 }
@@ -4957,95 +4940,6 @@ static Standard_Integer OCC27048(Draw_Interpretor& theDI, Standard_Integer theAr
   return 0;
 }
 
-//========================================================================
-//function : OCC27065
-//purpose  : Tests overloaded method "Generated" of BRepOffsetAPI_MakePipe
-//========================================================================
-static Standard_Integer OCC27065(Draw_Interpretor& di,
-                                 Standard_Integer n, const char** a)
-{
-  if (n < 3) return 1;
-  BRep_Builder BB;
-
-  TopoDS_Shape SpineShape = DBRep::Get(a[1],TopAbs_WIRE);
-  if ( SpineShape.IsNull()) return 1;
-  TopoDS_Wire Spine = TopoDS::Wire(SpineShape);
-
-  TopoDS_Shape Profile = DBRep::Get(a[2]);
-  if ( Profile.IsNull()) return 1;
-
-  BRepOffsetAPI_MakePipe aPipeBuilder(Spine, Profile);
-  if (!aPipeBuilder.IsDone())
-  {
-    di << "Error: failed to create pipe\n";
-    return 1;
-  }
-
-  TopExp_Explorer Explo(Profile, TopAbs_SHELL);
-  TopoDS_Shape aShape;
-  TopTools_ListIteratorOfListOfShape itl;
-  if (Explo.More())
-  {
-    aShape = Explo.Current();
-    TopoDS_Compound res1;
-    BB.MakeCompound(res1);
-    itl.Initialize(aPipeBuilder.Generated(aShape));
-    for (; itl.More(); itl.Next())
-      BB.Add(res1, itl.Value());
-    DBRep::Set("res_shell", res1);
-  }
-
-  Explo.Init(Profile, TopAbs_FACE);
-  if (Explo.More())
-  {
-    aShape = Explo.Current();
-    TopoDS_Compound res2;
-    BB.MakeCompound(res2);
-    itl.Initialize(aPipeBuilder.Generated(aShape));
-    for (; itl.More(); itl.Next())
-      BB.Add(res2, itl.Value());
-    DBRep::Set("res_face", res2);
-  }
-  
-  Explo.Init(Profile, TopAbs_WIRE);
-  if (Explo.More())
-  {
-    aShape = Explo.Current();
-    TopoDS_Compound res3;
-    BB.MakeCompound(res3);
-    itl.Initialize(aPipeBuilder.Generated(aShape));
-    for (; itl.More(); itl.Next())
-      BB.Add(res3, itl.Value());
-    DBRep::Set("res_wire", res3);
-  }
-  
-  Explo.Init(Profile, TopAbs_EDGE);
-  if (Explo.More())
-  {
-    aShape = Explo.Current();
-    TopoDS_Compound res4;
-    BB.MakeCompound(res4);
-    itl.Initialize(aPipeBuilder.Generated(aShape));
-    for (; itl.More(); itl.Next())
-      BB.Add(res4, itl.Value());
-    DBRep::Set("res_edge", res4);
-  }
-  
-  Explo.Init(Profile, TopAbs_VERTEX);
-  if (Explo.More())
-  {
-    aShape = Explo.Current();
-    TopoDS_Compound res5;
-    BB.MakeCompound(res5);
-    itl.Initialize(aPipeBuilder.Generated(aShape));
-    for (; itl.More(); itl.Next())
-      BB.Add(res5, itl.Value());
-    DBRep::Set("res_vertex", res5);
-  }
-  
-  return 0;
-}
-
 //========================================================================
 //function : OCC27318
 //purpose  : Creates a box that is not listed in map of AIS objects of ViewerTest
@@ -5492,10 +5386,6 @@ void QABugs::Commands_19(Draw_Interpretor& theCommands) {
                    "OCC27048 surf U V N\nCalculate value of surface N times in the point (U, V)",
                    __FILE__, OCC27048, group);
   
-  theCommands.Add ("OCC27065",
-                   "OCC27065 spine profile",
-                   __FILE__, OCC27065, group);
-
   theCommands.Add ("OCC27318",
                    "OCC27318: Creates a box that is not listed in map of AIS objects of ViewerTest",
                    __FILE__, OCC27318, group);

src/QABugs/QABugs_20.cxx

@@ -2889,6 +2889,56 @@ static Standard_Integer OCC29531(Draw_Interpretor&, Standard_Integer, const char
   return 0;
 }
 
+//=======================================================================
+//function : OCC29807
+//purpose  : 
+//=======================================================================
+#include <GeomAdaptor_HSurface.hxx>
+#include <IntPatch_PointLine.hxx>
+#include <IntSurf_PntOn2S.hxx>
+static Standard_Integer OCC29807(Draw_Interpretor& theDI, Standard_Integer theNArg, const char** theArgV)
+{
+  if (theNArg != 7)
+  {
+    theDI << "Use: " << theArgV[0] << "surface1 surface2 u1 v1 u2 v2\n";
+    return 1;
+  }
+
+  const Handle(Geom_Surface) aS1 = DrawTrSurf::GetSurface(theArgV[1]);
+  const Handle(Geom_Surface) aS2 = DrawTrSurf::GetSurface(theArgV[2]);
+
+  if (aS1.IsNull() || aS2.IsNull())
+  {
+    theDI << "Error. Null surface is not supported.\n";
+    return 1;
+  }
+
+  const Standard_Real aU1 = Draw::Atof(theArgV[3]);
+  const Standard_Real aV1 = Draw::Atof(theArgV[4]);
+  const Standard_Real aU2 = Draw::Atof(theArgV[5]);
+  const Standard_Real aV2 = Draw::Atof(theArgV[6]);
+
+  const Handle(GeomAdaptor_HSurface) anAS1 = new GeomAdaptor_HSurface(aS1);
+  const Handle(GeomAdaptor_HSurface) anAS2 = new GeomAdaptor_HSurface(aS2);
+
+  const gp_Pnt aP1 = anAS1->Value(aU1, aV1);
+  const gp_Pnt aP2 = anAS2->Value(aU2, aV2);
+
+  if (aP1.SquareDistance(aP2) > Precision::SquareConfusion())
+  {
+    theDI << "Error. True intersection point must be specified. "
+             "Please check parameters: u1 v1 u2 v2.\n";
+    return 1;
+  }
+
+  IntSurf_PntOn2S aPOn2S;
+  aPOn2S.SetValue(0.5*(aP1.XYZ() + aP2.XYZ()), aU1, aV1, aU2, aV2);
+
+  const Standard_Real aCurvatureRadius = IntPatch_PointLine::CurvatureRadiusOfIntersLine(anAS1, anAS2, aPOn2S);
+  theDI << "Radius of curvature is " << aCurvatureRadius << "\n";
+  return 0;
+}
+
 void QABugs::Commands_20(Draw_Interpretor& theCommands) {
   const char *group = "QABugs";
 
@@ -2925,5 +2975,7 @@ void QABugs::Commands_20(Draw_Interpretor& theCommands) {
   theCommands.Add("OCC29531", "OCC29531 <step file name>", __FILE__, OCC29531, group);
 
   theCommands.Add ("OCC29064", "OCC29064: test memory usage by copying empty maps", __FILE__, OCC29064, group);
+  theCommands.Add("OCC29807", "OCC29807 surface1 surface2 u1 v1 u2 v2", __FILE__, OCC29807, group);
+
   return;
 }

src/ShapeUpgrade/ShapeUpgrade_UnifySameDomain.cxx

@@ -88,43 +88,6 @@ struct SubSequenceOfEdges
   TopoDS_Edge UnionEdges;
 };
 
-static Standard_Boolean IsLikeSeam(const TopoDS_Edge& anEdge,
-                                   const TopoDS_Face& aFace,
-                                   const Handle(Geom_Surface)& aBaseSurface)
-{
-  if (!aBaseSurface->IsUPeriodic() && !aBaseSurface->IsVPeriodic())
-    return Standard_False;
-
-  BRepAdaptor_Curve2d BAcurve2d(anEdge, aFace);
-  gp_Pnt2d FirstPoint, LastPoint;
-  gp_Vec2d FirstDir, LastDir;
-  BAcurve2d.D1(BAcurve2d.FirstParameter(), FirstPoint, FirstDir);
-  BAcurve2d.D1(BAcurve2d.LastParameter(),  LastPoint,  LastDir);
-  Standard_Real Length = FirstDir.Magnitude();
-  if (Length <= gp::Resolution())
-    return Standard_False;
-  else
-    FirstDir /= Length;
-  Length = LastDir.Magnitude();
-  if (Length <= gp::Resolution())
-    return Standard_False;
-  else
-    LastDir /= Length;
-  
-  Standard_Real Tol = 1.e-7;
-  if (aBaseSurface->IsUPeriodic() &&
-    (Abs(FirstDir.X()) < Tol) &&
-    (Abs(LastDir.X()) < Tol))
-    return Standard_True;
-
-  if (aBaseSurface->IsVPeriodic() &&
-    (Abs(FirstDir.Y()) < Tol) &&
-    (Abs(LastDir.Y()) < Tol))
-    return Standard_True;
-
-  return Standard_False;
-}
-
 //=======================================================================
 //function : AddOrdinaryEdges
 //purpose  : auxilary
@@ -1385,10 +1348,6 @@ void ShapeUpgrade_UnifySameDomain::IntUnifyFaces(const TopoDS_Shape& theInpShape
         //
         if (IsSameDomain(aFace,anCheckedFace, myLinTol, myAngTol)) {
 
-          // hotfix for 27271: prevent merging along periodic direction.
-          if (IsLikeSeam(edge, anCheckedFace, aBaseSurface))
-            continue;
-
           if (AddOrdinaryEdges(edges,anCheckedFace,dummy)) {
             // sequence edges is modified
             i = dummy;

src/TDataStd/TDataStd_RealArray.cxx

@@ -191,18 +191,20 @@ void TDataStd_RealArray::ChangeArray(const Handle(TColStd_HArray1OfReal)& newArr
   Standard_Boolean aDimEqual = Standard_False;
   Standard_Integer i;
 
-  if (Lower() == aLower && Upper() == anUpper ) {
-    aDimEqual = Standard_True;
-    Standard_Boolean isEqual = Standard_True;
-    if(isCheckItems) {
-      for(i = aLower; i <= anUpper; i++) {
-        if(myValue->Value(i) != newArray->Value(i)) {
-          isEqual = Standard_False;
-          break;
+  if (!myValue.IsNull()) {
+    if (Lower() == aLower && Upper() == anUpper ) {
+      aDimEqual = Standard_True;
+      Standard_Boolean isEqual = Standard_True;
+      if(isCheckItems) {
+        for(i = aLower; i <= anUpper; i++) {
+          if(myValue->Value(i) != newArray->Value(i)) {
+            isEqual = Standard_False;
+            break;
+          }
         }
+        if(isEqual)
+          return;
       }
-      if(isEqual)
-        return;
     }
   }
 

src/gp/gp_Cone.hxx

@@ -35,7 +35,7 @@ class gp_Vec;
 
 
 //! Defines an infinite conical surface.
-//! A cone is defined by its half-angle at the apex and
+//! A cone is defined by its half-angle (can be negative) at the apex and
 //! positioned in space with a coordinate system (a gp_Ax3
 //! object) and a "reference radius" where:
 //! -   the "main Axis" of the coordinate system is the axis of   revolution of the cone,
@@ -76,12 +76,13 @@ public:
 
   //! Creates an infinite conical surface. A3 locates the cone
   //! in the space and defines the reference plane of the surface.
-  //! Ang is the conical surface semi-angle between 0 and PI/2 radians.
+  //! Ang is the conical surface semi-angle. Its absolute value is in range
+  //! ]0, PI/2[.
   //! Radius is the radius of the circle in the reference plane of
   //! the cone.
   //! Raises ConstructionError
-  //! . if Radius is lower than 0.0
-  //! . Ang < Resolution from gp  or Ang >= (PI/2) - Resolution.
+  //! * if Radius is lower than 0.0
+  //! * Abs(Ang) < Resolution from gp  or Abs(Ang) >= (PI/2) - Resolution.
     gp_Cone(const gp_Ax3& A3, const Standard_Real Ang, const Standard_Real Radius);
   
   //! Changes the symmetry axis of the cone.  Raises ConstructionError
@@ -105,8 +106,9 @@ public:
   
 
   //! Changes the semi-angle of the cone.
-  //! Ang is the conical surface semi-angle  ]0,PI/2[.
-  //! Raises ConstructionError if Ang < Resolution from gp or Ang >= PI/2 - Resolution
+  //! Semi-angle can be negative. Its absolute value
+  //! Abs(Ang) is in range ]0,PI/2[.
+  //! Raises ConstructionError if Abs(Ang) < Resolution from gp or Abs(Ang) >= PI/2 - Resolution
     void SetSemiAngle (const Standard_Real Ang);
   
 
@@ -146,6 +148,7 @@ public:
     Standard_Real RefRadius() const;
   
   //! Returns the half-angle at the apex of this cone.
+  //! Attention! Semi-angle can be negative.
     Standard_Real SemiAngle() const;
   
   //! Returns the XAxis of the reference plane.

tests/boolean/removefeatures/A1

@@ -14,7 +14,7 @@ compound feature1 feature2 feature3 feature4 gap
 removefeatures res1 s feature1
 checkshape res1
 checkprops res1 -s 2387.42 -v 1060.96 -deps 1.e-7
-checknbshapes res1 -vertex 68 -edge 102 -wire 36 -face 36 -shell 1 -solid 1 -t
+checknbshapes res1 -vertex 66 -edge 99 -wire 35 -face 35 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved feature1 {v e f}
 
 removefeatures res3 s feature1 feature2
@@ -27,19 +27,19 @@ CheckIsFeatureRemoved feature2 {e f}
 removefeatures res4 s feature3
 checkshape res4
 checkprops res4 -s 2387.67 -v 1060.68 -deps 1.e-7
-checknbshapes res4 -vertex 70 -edge 105 -wire 37 -face 37 -shell 1 -solid 1 -t
+checknbshapes res4 -vertex 67 -edge 100 -wire 35 -face 35 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved feature3 {v e f}
 
 removefeatures res5 s feature4
 checkshape res5
-checkprops res5 -s 2387.67 -v 1060.68 -deps 1.e-7
-checknbshapes res5 -vertex 70 -edge 105 -wire 37 -face 37 -shell 1 -solid 1 -t
+checkprops res5 -s 2387.67 -v 1060.67 -deps 1.e-7
+checknbshapes res5 -vertex 67 -edge 100 -wire 35 -face 35 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved feature4 {v e f}
 
 removefeatures res6 s feature3 feature4
 checkshape res6
 checkprops res6 -s 2387.89 -v 1060.71 -deps 1.e-7
-checknbshapes res6 -vertex 68 -edge 102 -wire 36 -face 36 -shell 1 -solid 1 -t
+checknbshapes res6 -vertex 65 -edge 97 -wire 34 -face 34 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved feature3 {v e f}
 CheckIsFeatureRemoved feature4 {v e f}
 

tests/boolean/removefeatures/A2

@@ -12,17 +12,17 @@ compound feature1 feature2 gap
 removefeatures res1 s feature1
 checkshape res1
 checkprops res1 -s 2387.38 -v 1060.67 -deps 1.e-7
-checknbshapes res1 -vertex 62 -edge 93 -wire 33 -face 33 -shell 1 -solid 1
+checknbshapes res1 -vertex 60 -edge 89 -wire 31 -face 31 -shell 1 -solid 1
 CheckIsFeatureRemoved feature1 {v e f}
 
 removefeatures res2 s feature2
 checkshape res2
 checkprops res2 -s 2387.17 -v 1060.75 -deps 1.e-7
-checknbshapes res2 -vertex 62 -edge 93 -wire 35 -face 34 -shell 1 -solid 1
+checknbshapes res2 -vertex 60 -edge 89 -wire 33 -face 32 -shell 1 -solid 1
 CheckIsFeatureRemoved feature2 {v e f}
 
 removefeatures res3 s gap
 checkshape res3
 checkprops res3 -s 2386.99 -v 1060.79 -deps 1.e-7
-checknbshapes res3 -vertex 54 -edge 81 -wire 29 -face 29 -shell 1 -solid 1
+checknbshapes res3 -vertex 52 -edge 77 -wire 27 -face 27 -shell 1 -solid 1
 CheckIsFeatureRemoved gap {v e f}

tests/boolean/removefeatures/A3

@@ -10,5 +10,5 @@ compound s_37 s_26 s_27 s_28 gap
 removefeatures res s gap
 checkshape res
 checkprops res -s 2387.07 -v 1060.76 -deps 1.e-7
-checknbshapes res -vertex 64 -edge 96 -wire 34 -face 34 -shell 1 -solid 1
+checknbshapes res -vertex 62 -edge 92 -wire 32 -face 32 -shell 1 -solid 1
 CheckIsFeatureRemoved gap {v e f}

tests/boolean/removefeatures/A4

@@ -13,18 +13,18 @@ compound feature1 feature2 feature3 gap
 removefeatures res1 s feature1 feature2
 checkshape res1
 checkprops res1 -s 2387.88 -v 1060.71 -deps 1.e-7
-checknbshapes res1 -vertex 68 -edge 102 -wire 36 -face 36 -shell 1 -solid 1
+checknbshapes res1 -vertex 65 -edge 97 -wire 34 -face 34 -shell 1 -solid 1
 CheckIsFeatureRemoved feature1 {v e f}
 CheckIsFeatureRemoved feature2 {v e f}
 
 removefeatures res2 s feature3
 checkshape res2
 checkprops res2 -s 2391.13 -v 1064.08 -deps 1.e-7
-checknbshapes res2 -vertex 66 -edge 99 -wire 35 -face 35 -shell 1 -solid 1
+checknbshapes res2 -vertex 63 -edge 94 -wire 33 -face 33 -shell 1 -solid 1
 CheckIsFeatureRemoved feature3 {v e f}
 
 removefeatures res3 s gap
 checkshape res3
 checkprops res3 -s 2392.93 -v 1065.38 -deps 1.e-7
-checknbshapes res3 -vertex 60 -edge 90 -wire 32 -face 32 -shell 1 -solid 1
+checknbshapes res3 -vertex 57 -edge 85 -wire 30 -face 30 -shell 1 -solid 1
 CheckIsFeatureRemoved gap {v e f}

tests/boolean/removefeatures/A5

@@ -10,5 +10,5 @@ compound s_11 s_13 s_12 spike
 removefeatures res s spike
 checkshape res
 checkprops res -s 2323.49 -v 1037.57 -deps 1.e-7
-checknbshapes res -vertex 64 -edge 96 -wire 34 -face 34 -shell 1 -solid 1
+checknbshapes res -vertex 61 -edge 91 -wire 32 -face 32 -shell 1 -solid 1
 CheckIsFeatureRemoved spike {v e f}

tests/boolean/removefeatures/A6

@@ -10,7 +10,7 @@ compound s_11 s_13 s_12 spike
 removefeatures res s spike
 checkshape res
 checkprops res -s 2323.49 -v 1037.57 -deps 1.e-7
-checknbshapes res -vertex 64 -edge 96 -wire 34 -face 34 -shell 1 -solid 1
+checknbshapes res -vertex 61 -edge 91 -wire 32 -face 32 -shell 1 -solid 1
 CheckIsFeatureRemoved spike {v e f}
 
 # get history of the operation
@@ -19,7 +19,7 @@ savehistory rf_hist
 # check modification of the top face
 modified m5 rf_hist s_5
 checkprops m5 -s 1089.87
-checknbshapes m5 -vertex 31 -edge 31 -wire 1 -face 1
+checknbshapes m5 -vertex 29 -edge 29 -wire 1 -face 1
 
 # check modification of the side faces where the spike was located
 modified m10 rf_hist s_10

tests/boolean/removefeatures/A8

@@ -1,5 +1,3 @@
-puts "TODO OCC29504 ALL: Faulty shapes in variables faulty_1 to"
-
 pload XDE
 
 stepread [locate_data_file bug29481_L3.step] s *
@@ -12,6 +10,6 @@ compound s_2 s_25 s_1 s_4 feature
 
 removefeatures result s feature
 checkshape result
-checkprops result -s 2386.95 -v 1064.36 -deps 1.e-7
-checknbshapes result -vertex 62 -edge 93 -wire 35 -face 34 -shell 1 -solid 1
+checkprops result -s 2392.41 -v 1063.75 -deps 1.e-7
+checknbshapes result -vertex 61 -edge 91 -wire 34 -face 33 -shell 1 -solid 1
 CheckIsFeatureRemoved feature {e f}

tests/boolean/removefeatures/B1

@@ -5,7 +5,7 @@ explode s f
 removefeatures result s s_13
 checkshape result
 checkprops result -s 463.068 -v 194.214 -deps 1.e-7
-checknbshapes result -vertex 32 -edge 53 -wire 24 -face 21 -shell 1 -solid 1
+checknbshapes result -vertex 31 -edge 50 -wire 23 -face 20 -shell 1 -solid 1
 CheckIsFeatureRemoved s_13 {v e f}
 
 # get history of the operation

tests/boolean/removefeatures/B2

@@ -5,7 +5,7 @@ explode s f
 removefeatures result s s_14
 checkshape result
 checkprops result -s 462.33 -v 194.594 -deps 1.e-7
-checknbshapes result -vertex 34 -edge 54 -wire 24 -face 21 -shell 1 -solid 1 -t
+checknbshapes result -vertex 33 -edge 51 -wire 23 -face 20 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved s_14 {e f}
 
 # get history of the operation
@@ -14,7 +14,7 @@ savehistory rf_hist
 # check modification of the top face
 modified m1 rf_hist s_1
 checkprops m1 -s 171.478
-checknbshapes m1 -vertex 14 -edge 14 -wire 3 -face 1
+checknbshapes m1 -vertex 13 -edge 13 -wire 3 -face 1
 
 generated g1 rf_hist s_1
 checknbshapes g1 -vertex 1 -edge 1

tests/boolean/removefeatures/B3

@@ -5,7 +5,7 @@ explode s f
 removefeatures result s s_15
 checkshape result
 checkprops result -s 462.273 -v 193.127 -deps 1.e-7
-checknbshapes result -vertex 34 -edge 54 -wire 24 -face 21 -shell 1 -solid 1 -t
+checknbshapes result -vertex 33 -edge 51 -wire 23 -face 20 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved s_15 {e f}
 
 # get history of the operation
@@ -14,7 +14,7 @@ savehistory rf_hist
 # check modification of the top face
 modified m1 rf_hist s_1
 checkprops m1 -s 172.452
-checknbshapes m1 -vertex 14 -edge 14 -wire 3 -face 1
+checknbshapes m1 -vertex 13 -edge 13 -wire 3 -face 1
 
 generated g1 rf_hist s_1
 checknbshapes g1 -vertex 1 -edge 1

tests/boolean/removefeatures/B4

@@ -4,7 +4,7 @@ explode s f
 removefeatures result s s_4
 checkshape result
 checkprops result -s 462.815 -v 195.248 -deps 1.e-7
-checknbshapes result -vertex 31 -edge 50 -wire 23 -face 20 -shell 1 -solid 1
+checknbshapes result -vertex 30 -edge 47 -wire 22 -face 19 -shell 1 -solid 1
 CheckIsFeatureRemoved s_4 {v e f}
 
 # get history of the operation
@@ -13,7 +13,7 @@ savehistory rf_hist
 # check modification of the top face
 modified m1 rf_hist s_1
 checkprops m1 -s 169.122
-checknbshapes m1 -vertex 12 -edge 12 -wire 3 -face 1
+checknbshapes m1 -vertex 11 -edge 11 -wire 3 -face 1
 
 # check modification of the side faces
 modified m3 rf_hist s_3

tests/boolean/removefeatures/B5

@@ -5,7 +5,7 @@ explode s f
 removefeatures result s s_6 s_18
 checkshape result
 checkprops result -s 461.315 -v 196.178 -deps 1.e-7
-checknbshapes result -vertex 30 -edge 50 -wire 23 -face 20 -shell 1 -solid 1
+checknbshapes result -vertex 29 -edge 47 -wire 22 -face 19 -shell 1 -solid 1
 CheckIsFeatureRemoved s_6 {v e f}
 CheckIsFeatureRemoved s_18 {v e f}
 
@@ -15,7 +15,7 @@ savehistory rf_hist
 # check modification of the top face
 modified m1 rf_hist s_1
 checkprops m1 -s 172.551
-checknbshapes m1 -vertex 14 -edge 14 -wire 3 -face 1
+checknbshapes m1 -vertex 13 -edge 13 -wire 3 -face 1
 
 # check modification of the side face
 modified m19 rf_hist s_19

tests/boolean/removefeatures/B8

@@ -6,7 +6,7 @@ explode s f
 removefeatures result s s_14 s_20
 checkshape result
 checkprops result -s 462.33 -v 197.735 -deps 1.e-7
-checknbshapes result -vertex 32 -edge 51 -wire 21 -face 20 -shell 1 -solid 1
+checknbshapes result -vertex 31 -edge 48 -wire 20 -face 19 -shell 1 -solid 1
 CheckIsFeatureRemoved s_14 {v e f}
 CheckIsFeatureRemoved s_20 {v e f}
 
@@ -16,7 +16,7 @@ savehistory rf_hist
 # check modification of the top and bottom faces
 modified m1 rf_hist s_1
 checkprops m1 -s 174.62
-checknbshapes m1 -vertex 13 -edge 13 -wire 2 -face 1
+checknbshapes m1 -vertex 12 -edge 12 -wire 2 -face 1
 
 modified m16 rf_hist s_16
 checkprops m16 -s 194.429

tests/boolean/removefeatures/B9

@@ -6,7 +6,7 @@ explode s f
 removefeatures result s s_15 s_21 s_22
 checkshape result
 checkprops result -s 449.707 -v 186.844 -deps 1.e-7
-checknbshapes result -vertex 31 -edge 51 -wire 21 -face 19 -shell 1 -solid 1
+checknbshapes result -vertex 30 -edge 48 -wire 20 -face 18 -shell 1 -solid 1
 CheckIsFeatureRemoved s_15 {v e f}
 CheckIsFeatureRemoved s_21 {v e f}
 CheckIsFeatureRemoved s_22 {v e f}
@@ -17,7 +17,7 @@ savehistory rf_hist
 # check modification of the top face
 modified m1 rf_hist s_1
 checkprops m1 -s 175.593
-checknbshapes m1 -vertex 13 -edge 13 -wire 2 -face 1
+checknbshapes m1 -vertex 12 -edge 12 -wire 2 -face 1
 
 # check that no new intersections have been created
 if {![regexp "No shapes were generated" [generated g1 rf_hist s_1]]} {

tests/boolean/removefeatures/F1

@@ -10,7 +10,7 @@ compound s_115 s_112 s_116 s_114 s_111 s_113 blend
 removefeatures result s fillet blend
 checkshape result
 checkprops result -s 809750 -v 1.46451e+007 -deps 1.e-7
-checknbshapes result -vertex 258 -edge 394 -wire 164 -face 139 -shell 1 -solid 1 -t
+checknbshapes result -vertex 250 -edge 378 -wire 156 -face 131 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved fillet {e f}
 CheckIsFeatureRemoved blend {e f}
 

tests/boolean/removefeatures/F2

@@ -9,7 +9,7 @@ compound s_34 s_12 s_32 s_40 s_37 s_16 s_18 s_17 s_39 s_41 s_31 s_14 s_35 s_13 s
 removefeatures result s gaps
 checkshape result
 checkprops result -s 813251 -v 1.49885e+007 -deps 1.e-7
-checknbshapes result -vertex 230 -edge 358 -wire 156 -face 131 -shell 1 -solid 1 -t
+checknbshapes result -vertex 216 -edge 334 -wire 146 -face 121 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved gaps {v e f}
 
 checkview -display result -2d -path ${imagedir}/${test_image}.png

tests/boolean/removefeatures/F3

@@ -9,7 +9,7 @@ compound s_86 s_83 s_81 s_82 s_84 s_85 s_80 s_78 s_79 s_88 s_77 s_87 holes
 removefeatures result s holes
 checkshape result
 checkprops result -s 798285 -v 1.51114e+007 -deps 1.e-7
-checknbshapes result -vertex 246 -edge 382 -wire 160 -face 139 -shell 1 -solid 1 -t
+checknbshapes result -vertex 234 -edge 362 -wire 152 -face 131 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved holes {v e f}
 
 checkview -display result -2d -path ${imagedir}/${test_image}.png

tests/boolean/removefeatures/F4

@@ -9,7 +9,7 @@ compound s_10 s_66 s_43 s_65 s_63 s_64 s_69 s_29 s_68 s_70 s_20 s_67 fillets
 removefeatures result s fillets
 checkshape result
 checkprops result -s 811691 -v 1.46014e+007 -deps 1.e-7
-checknbshapes result -vertex 246 -edge 382 -wire 164 -face 139 -shell 1 -solid 1 -t
+checknbshapes result -vertex 234 -edge 362 -wire 156 -face 131 -shell 1 -solid 1 -t
 CheckIsFeatureRemoved fillets {v e f}
 
 checkview -display result -2d -path ${imagedir}/${test_image}.png

tests/boolean/volumemaker/C5

@@ -1,10 +1,6 @@
 # test script on make volume operation
 # cone plane
 
-puts "TODO CR28503 ALL: Error : The area of result shape is"
-puts "TODO CR28503 ALL: Error :  is WRONG because number of SOLID entities in shape"
-puts "TODO CR28503 ALL: Faulty shapes in variables faulty_"
-
 # planar face 
 plane pln_f1 27.577164466275352 -1038.2137499999999 27.577164466275359 0.70710678118654746 4.4408920985006262e-016 0.70710678118654768
 erase pln_f1
@@ -38,6 +34,6 @@ mkface f6 con_f6 0 6.2831853071795862 0 1000000
 # make volume operation 
 mkvolume result f1 f2 f3 f4 f5 f6
 
-checkprops result -s 5.19571e+006
+checkprops result -s 5.5768e+006
 
-checknbshapes result -solid 16
+checknbshapes result -solid 17

tests/boolean/volumemaker/C6

@@ -1,8 +1,6 @@
 # test script on make volume operation
 # cone plane
 
-puts "TODO CR28503 ALL: Error :  is WRONG because number of SOLID entities in shape"
-
 # planar face 
 plane pln_f1 -306.53078964627537 -1038.2137499999999 -251.37646071372467 -0.70710678118654746 4.4408920985006262e-016 0.70710678118654768
 erase pln_f1
@@ -43,4 +41,4 @@ mkvolume result f1 f2 f3 f4 f5 f6 f7
 
 checkprops result -s 6.45353e+006
 
-checknbshapes result -solid 29
+checknbshapes result -solid 30

tests/boolean/volumemaker/E7

@@ -29,5 +29,6 @@ mkface f5 con_f5 0 6.2831853071795862 0 1000000
 # make volume operation 
 mkvolume result f1 f2 f3 f4 f5
 
-checkprops result -s 5.28759e+006
+checkprops result -s 5.7053e+006
 
+checknbshapes result -solid 8

tests/bugs/caf/bug30510

@@ -0,0 +1,11 @@
+puts "============"
+puts "0030510: Application Framework - add missing NULL check within TDataStd_RealArray::ChangeArray()"
+puts "============"
+
+Open [locate_data_file bug30510_Study_Color_Field_GEOM.sgd] CC
+
+if { ![regexp {0:1} [Children CC 0]] } {
+  puts "Error: An empty document was created"
+} else {
+  puts "OK: Document was created"
+}

tests/bugs/fclasses/bug23972

@@ -1,11 +0,0 @@
-puts "=========="
-puts "OCC23972"
-puts "=========="
-puts ""
-###########################################################################
-## Exception thrown when intersecting two cones
-###########################################################################
-
-pload QAcommands
-
-OCC23972

tests/bugs/heal/bug27000_1

@@ -1,4 +1,4 @@
 restore [locate_data_file bug27000_1.brep] shape
 unifysamedom result shape
 checkshape result
-checknbshapes result -vertex 62 -edge 90 -wire 36 -face 34 -shell 2 -solid 2 -compsolid 0 -compound 1 -shape 227
+checknbshapes result -vertex 60 -edge 87 -wire 35 -face 33 -shell 2 -solid 2 -compsolid 0 -compound 1 -shape 220

tests/bugs/heal/bug27894

@@ -1,3 +1,5 @@
+puts "TODO OCC30320 ALL: Faulty shapes in variables faulty_"
+
 puts "============"
 puts "OCC27894"
 puts "============"
@@ -10,6 +12,8 @@ stepread [locate_data_file bug27894_usd_raises_Standard_NullObject.stp] a *
 renamevar a_1 a
 unifysamedom result a
 
-checknbshapes result -m UnifySameDomain -face 18 -edge 45
+checknbshapes result -m UnifySameDomain -face 9 -edge 21
+
+checkshape result
 
 checkview -display result -2d -path ${imagedir}/${test_image}.png

tests/bugs/modalg_2/bug20964_1

@@ -1,29 +1,38 @@
 puts "============"
-puts "OCC20964"
+puts "OCC20964: Wrong result of cut operation for given shapes"
 puts "============"
 puts ""
-#######################################################################
-# Wrong result of cut operation for given shapes
-#######################################################################
 
-set BugNumber OCC20964
-
-puts "Load first shape ..."
 restore [locate_data_file OCC20964_revsolid.brep] b1 
-puts "Load second shape ..."
 restore [locate_data_file OCC20964_sphere.brep] b2 
 
-puts "Prepare boolean operation ..."
-bop b1 b2
+bclearobjects
+bcleartools
+baddobjects b1
+baddtools b2
+bfillds
 
-puts "Start boolean operation ..."
-bopsection result
-puts "Finish boolean operation ..."
+# SECTION
+bbop result 4
 
-checkprops result -l 323.636 
+checkprops result -l 323.635
 checkshape result 
-checksection result
+checksection result -r 0
 
-checknbshapes result -vertex 6 -edge 6 -wire 0 -face 0 -shell 0 -solid 0 -compsolid 0 -compound 1 -shape 13
+set NbShapesRef "
+Number of shapes in .*
+ VERTEX : 6
+ EDGE : 6
+ WIRE : 0
+ FACE : 0
+ SHELL : 0
+ SOLID : 0
+ COMPSOLID : 0
+ COMPOUND : 1
+ SHAPE : 13
+"
+
+checknbshapes result -ref $NbShapesRef
+checkmaxtol result -ref 0.013928665225777443
 
 checkview -display result -2d -path ${imagedir}/${test_image}.png

tests/bugs/modalg_2/bug20964_2

@@ -1,28 +1,48 @@
 puts "============"
-puts "OCC20964"
+puts "OCC20964: Wrong result of cut operation for given shapes"
 puts "============"
 puts ""
-#######################################################################
-# Wrong result of cut operation for given shapes
-#######################################################################
 
-set BugNumber OCC20964
-
-puts "Load first shape ..."
 restore [locate_data_file OCC20964_revsolid.brep] b1 
-puts "Load second shape ..."
 restore [locate_data_file OCC20964_sphere.brep] b2 
 
-puts "Prepare boolean operation ..."
-bop b1 b2
+bclearobjects
+bcleartools
+baddobjects b1
+baddtools b2
+bfillds
 
-puts "Start boolean operation ..."
-bopcommon result
-puts "Finish boolean operation ..."
+# COMMON
+bbop result 0
 
-checkprops result -s 5164.66 
+checkprops result -s 5158.93
 checkshape result
 
-checknbshapes result -vertex 8 -edge 12 -wire 6 -face 5 -shell 1 -solid 1 -compsolid 0 -compound 1 -shape 34
+set NbShapesRef "
+Number of shapes in .*
+ VERTEX : 8
+ EDGE : 12
+ WIRE : 6
+ FACE : 5
+ SHELL : 1
+ SOLID : 1
+ COMPSOLID : 0
+ COMPOUND : 1
+ SHAPE : 34
+"
 
-checkview -display result -2d -path ${imagedir}/${test_image}.png
+checknbshapes result -ref $NbShapesRef
+
+checkmaxtol result -ref 0.013928665225777443
+
+checkview -display result -2d -path ${imagedir}/${test_image}_axo.png
+
+vdisplay result
+vsetdispmode 1
+vviewparams -scale 15.9695 -proj 0.0161244 -0.535424 0.84443 -up -0.773936 0.528029 0.349583 -at 117.532 248.227 -4.41145e-007 -eye 118.783 206.661 65.5549
+
+if { [string compare "" [tricheck result] ] } {
+  puts "Error in triangulation"
+}
+
+checkview -screenshot -3d -path ${imagedir}/${test_image}_shade.png

tests/bugs/modalg_2/bug20964_3

@@ -1,28 +1,48 @@
 puts "============"
-puts "OCC20964"
+puts "OCC20964: Wrong result of cut operation for given shapes"
 puts "============"
 puts ""
-#######################################################################
-# Wrong result of cut operation for given shapes
-#######################################################################
 
-set BugNumber OCC20964
-
-puts "Load first shape ..."
 restore [locate_data_file OCC20964_revsolid.brep] b1 
-puts "Load second shape ..."
 restore [locate_data_file OCC20964_sphere.brep] b2 
 
-puts "Prepare boolean operation ..."
-bop b1 b2
+bclearobjects
+bcleartools
+baddobjects b1
+baddtools b2
+bfillds
 
-puts "Start boolean operation ..."
-bopfuse result
-puts "Finish boolean operation ..."
+# FUSE
+bbop result 1
 
-checkprops result -s 828829 
+checkprops result -s 828808
 checkshape result
 
-checknbshapes result -vertex 20 -edge 32 -wire 18 -face 16 -shell 3 -solid 1 -compsolid 0 -compound 1 -shape 91
+set NbShapesRef "
+Number of shapes in .*
+ VERTEX : 20
+ EDGE : 32
+ WIRE : 18
+ FACE : 16
+ SHELL : 3
+ SOLID : 1
+ COMPSOLID : 0
+ COMPOUND : 1
+ SHAPE : 91
+"
 
-checkview -display result -2d -path ${imagedir}/${test_image}.png
+checknbshapes result -ref $NbShapesRef
+
+checkmaxtol result -ref 0.013928665225777443
+
+checkview -display result -2d -path ${imagedir}/${test_image}_axo.png
+
+vdisplay result
+vsetdispmode 1
+vviewparams -scale 5.62548 -proj 0.751453 0.00874872 0.659728 -up -0.600015 0.42493 0.677803 -at 99.378 322.007 8.81412 -eye 467.31 326.291 331.835
+
+if { [string compare "" [tricheck result] ] } {
+  puts "Error in triangulation"
+}
+
+checkview -screenshot -3d -path ${imagedir}/${test_image}_shade.png

tests/bugs/modalg_2/bug20964_4

@@ -1,28 +1,47 @@
 puts "============"
-puts "OCC20964"
+puts "OCC20964: Wrong result of cut operation for given shapes"
 puts "============"
 puts ""
-#######################################################################
-# Wrong result of cut operation for given shapes
-#######################################################################
 
-set BugNumber OCC20964
-
-puts "Load first shape ..."
 restore [locate_data_file OCC20964_revsolid.brep] b1 
-puts "Load second shape ..."
 restore [locate_data_file OCC20964_sphere.brep] b2 
 
-puts "Prepare boolean operation ..."
-bop b1 b2
+bclearobjects
+bcleartools
+baddobjects b1
+baddtools b2
+bfillds
 
-puts "Start boolean operation ..."
-bopcut result
-puts "Finish boolean operation ..."
+# CUT 1-2
+bbop result 2
 
-checkprops result -s 821892 
+checkprops result -s 821864
 checkshape result
 
-checknbshapes result -vertex 22 -edge 35 -wire 17 -face 14 -shell 2 -solid 1 -compsolid 0 -compound 1 -shape 92
+set NbShapesRef "
+Number of shapes in .*
+ VERTEX : 22
+ EDGE : 35
+ WIRE : 17
+ FACE : 14
+ SHELL : 2
+ SOLID : 1
+ COMPSOLID : 0
+ COMPOUND : 1
+ SHAPE : 92
+"
 
-checkview -display result -2d -path ${imagedir}/${test_image}.png
+checknbshapes result -ref $NbShapesRef
+checkmaxtol result -ref 0.013928665225777443
+
+checkview -display result -2d -path ${imagedir}/${test_image}_axo.png
+
+vdisplay result
+vsetdispmode 1
+vviewparams -scale 3.80971 -proj 0.769527 -0.23844 0.59243 -up -0.456402 0.443531 0.771348 -at 70.5761 168.919 28.0572 -eye 455.34 49.6989 324.272
+
+if { [string compare "" [tricheck result] ] } {
+  puts "Error in triangulation"
+}
+
+checkview -screenshot -3d -path ${imagedir}/${test_image}_shade.png

tests/bugs/modalg_2/bug20964_5

@@ -1,28 +1,52 @@
 puts "============"
-puts "OCC20964"
+puts "OCC20964 Wrong result of cut operation for given shapes"
 puts "============"
 puts ""
-#######################################################################
-# Wrong result of cut operation for given shapes
-#######################################################################
 
-set BugNumber OCC20964
-
-puts "Load first shape ..."
 restore [locate_data_file OCC20964_revsolid.brep] b1 
-puts "Load second shape ..."
 restore [locate_data_file OCC20964_sphere.brep] b2 
 
-puts "Prepare boolean operation ..."
-bop b1 b2
+bclearobjects
+bcleartools
+baddobjects b1
+baddtools b2
+bfillds
 
-puts "Start boolean operation ..."
-boptuc result
-puts "Finish boolean operation ..."
+# CUT 2-1
+bbop result 3
 
-checkprops result -s 12101.2 
+checkprops result -s 12102.9
 checkshape result
 
-checknbshapes result -vertex 6 -edge 9 -wire 7 -face 7 -shell 2 -solid 2 -compsolid 0 -compound 1 -shape 34
+set NbShapesRef "
+Number of shapes in .*
+ VERTEX : 6
+ EDGE : 9
+ WIRE : 7
+ FACE : 7
+ SHELL : 2
+ SOLID : 2
+ COMPSOLID : 0
+ COMPOUND : 1
+ SHAPE : 34
+"
 
-checkview -display result -2d -path ${imagedir}/${test_image}.png
+checknbshapes result -ref $NbShapesRef
+
+checkmaxtol result -ref 0.013928665225777443
+
+checkview -display result -2d -path ${imagedir}/${test_image}_axo.png
+
+vdisplay result
+vsetdispmode 1
+vsetcolor result red
+vdisplay b1
+vsettransparency b1 0.5
+
+vviewparams -scale 11.5636 -proj 0.296876 -0.306332 0.904447 -up -0.63687 0.642216 0.426562 -at 120.352 250.434 3.97104e-006 -eye 147.307 222.621 82.1187
+
+if { [string compare "" [tricheck result] ] } {
+  puts "Error in triangulation"
+}
+
+checkview -screenshot -3d -path ${imagedir}/${test_image}_shade.png

tests/bugs/modalg_6/bug27065_1

@@ -2,23 +2,52 @@ puts "============"
 puts "OCC27065"
 puts "============"
 puts ""
-###############################
+#########################################################################
 ## BRepOffsetAPI_MakePipe misses definition of virtual method Generated()
-###############################
-
-pload QAcommands
+#########################################################################
 
 restore [locate_data_file bug24840_comp.brep] sh
 explode sh
-OCC27065 sh_1 sh_2
-fit
+renamevar sh_1 path
+renamevar sh_2 base
 
-checknbshapes res_shell -vertex 56 -edge 130 -wire 99 -face 99 -shell 24 -solid 24 -compsolid 1 -compound 1 -shape 434
+pipe q path base
+savehistory pipe_hist
 
-checknbshapes res_face -vertex 8 -edge 12 -wire 6 -face 6 -shell 1 -solid 1 -compsolid 0 -compound 1 -shape 35
+explode base
 
-checknbshapes res_wire -vertex 8 -edge 12 -wire 4 -face 4 -shell 1 -solid 0 -compsolid 0 -compound 1 -shape 30
+generated r1 pipe_hist base_1
+generated r5 pipe_hist base_5
+generated r11 pipe_hist base_11
 
-checknbshapes res_edge -vertex 4 -edge 4 -wire 1 -face 1 -shell 0 -solid 0 -compsolid 0 -compound 1 -shape 11
 
-checknbshapes res_vertex -vertex 2 -edge 1 -wire 0 -face 0 -shell 0 -solid 0 -compsolid 0 -compound 1 -shape 4
+checknbshapes r1 -vertex 8 -edge 12 -wire 6 -face 6 -shell 1 -solid 1
+checknbshapes r5 -vertex 8 -edge 12 -wire 6 -face 6 -shell 1 -solid 1
+checknbshapes r11 -vertex 6 -edge 9 -wire 5 -face 5 -shell 1 -solid 1
+
+checkprops r1 -v 0.434835
+checkprops r5 -v 0.0165356
+checkprops r11 -v 4.06042e-005
+
+explode base e
+
+generated r1 pipe_hist base_1
+generated r2 pipe_hist base_2
+generated r4 pipe_hist base_4
+
+checkprops r1 -s 1.83914
+checkprops r2 -s 0.335211
+checkprops r4 -s 1.8982
+
+explode base v
+
+generated r1 pipe_hist base_1
+generated r2 pipe_hist base_2
+generated r11 pipe_hist base_11
+generated r20 pipe_hist base_20
+
+checkprops r1 -l 4.2837
+checkprops r2 -l 4.91201
+checkprops r11 -l 4.13217
+checkprops r20 -l 4.12661 -deps 1.e-7
+

tests/bugs/modalg_6/bug27065_2

@@ -2,27 +2,36 @@ puts "============"
 puts "OCC27065"
 puts "============"
 puts ""
-###############################
+#########################################################################
 ## BRepOffsetAPI_MakePipe misses definition of virtual method Generated()
-###############################
-
-pload QAcommands
+#########################################################################
 
 restore [locate_data_file bug23903_base.brep] base
-restore [locate_data_file bug23903_path.brep] sp
+restore [locate_data_file bug23903_path.brep] path
+
+pipe q path base
+savehistory pipe_hist
+
 explode base
-shape pr Sh
-add base_1 pr
-add base_2 pr
-OCC27065 sp pr
-fit
 
-checknbshapes res_shell -vertex 2 -edge 5 -wire 3 -face 3 -shell 2 -solid 2 -compsolid 1 -compound 1 -shape 19
+generated r1 pipe_hist base_1
+generated r2 pipe_hist base_2
 
-checknbshapes res_face -vertex 2 -edge 4 -wire 2 -face 2 -shell 1 -solid 1 -compsolid 0 -compound 1 -shape 13
+checknbshapes r1 -vertex 2 -edge 4 -wire 2 -face 2 -shell 1 -solid 1
+checknbshapes r2 -vertex 2 -edge 4 -wire 2 -face 2 -shell 1 -solid 1
+checkprops r1 -v 888.833
+checkprops r2 -v 888.833
 
-checknbshapes res_wire -vertex 2 -edge 4 -wire 2 -face 2 -shell 1 -solid 0 -compsolid 0 -compound 1 -shape 12
+explode base e
 
-checknbshapes res_edge -vertex 2 -edge 3 -wire 1 -face 1 -shell 0 -solid 0 -compsolid 0 -compound 1 -shape 8
+generated r1 pipe_hist base_1
+generated r2 pipe_hist base_2
+checkprops r1 -s 353.655
+checkprops r2 -s 555.521
 
-checknbshapes res_vertex -vertex 1 -edge 1 -wire 0 -face 0 -shell 0 -solid 0 -compsolid 0 -compound 1 -shape 3
+explode base v
+
+generated r1 pipe_hist base_1
+generated r2 pipe_hist base_2
+checkprops r1 -l 35.1526
+checkprops r2 -l 75.3649

tests/bugs/modalg_6/bug27269

@@ -10,6 +10,10 @@ puts ""
 restore [locate_data_file bug27267_cmpd.brep] a
 explode a f
 
+smallview
+don a_7; fit
+disp a_1
+
 #############################
 set log [bopcurves a_1 a_7 -2d]
 #############################
@@ -33,4 +37,4 @@ for {set i 1} {$i <= ${NbCurv}} {incr i} {
   }
 }
 
-
+checkview -screenshot -2d -path ${imagedir}/${test_image}.png

tests/bugs/modalg_6/bug27271

@@ -8,4 +8,13 @@ puts ""
 
 restore [locate_data_file bug27271_Shape.brep] a
 unifysamedom result a
-checkshape result
+
+checkshape result
+
+checknbshapes result -vertex 44 -edge 81 -wire 45 -face 35 -shell 3 -solid 3
+
+set tolres [checkmaxtol result]
+
+if { ${tolres} > 0.003} {
+   puts "Error: bad tolerance of result"
+}

tests/bugs/modalg_6/bug27282_2

@@ -6,7 +6,7 @@ puts ""
 ## [Regression to 6.9.1] smesh/bugs_00/A6: Cut produces an empty shape
 ###############################
 
-set MaxTol 2.1243683206633536e-006
+set MaxTol 2.9376013151287501e-006
 set GoodNbCurv 1
 
 restore [locate_data_file bug27282_cmpd.brep] a

tests/bugs/modalg_6/bug27386_1

@@ -25,10 +25,12 @@ generated r1 sweep_hist pr_1_1
 generated r2 sweep_hist pr_1_2
 generated r3 sweep_hist pr_1_3
 generated r4 sweep_hist pr_1_4
+checkprops r1 -s 9402.08
+checkprops r2 -s 10944.1
+checkprops r3 -s 9402.08
+checkprops r4 -s 10944.1
 
 explode pr_1 v
 
-generated r1 sweep_hist pr_1_1
-generated r2 sweep_hist pr_1_2
 generated r3 sweep_hist pr_1_3
-generated r4 sweep_hist pr_1_4
+checkprops r3 -l 130.036

tests/bugs/modalg_6/bug27386_2

@@ -66,3 +66,14 @@ generated r2_2 sweep_hist pr2_2
 generated r2_3 sweep_hist pr2_3
 
 generated r3_1 sweep_hist pr3_1
+
+checkprops r1_1 -l 142.176
+checkprops r1_2 -l 142.176
+checkprops r1_3 -l 163.176
+checkprops r1_4 -l 163.176
+
+checkprops r2_1 -l 142.176
+checkprops r2_2 -l 172.788
+checkprops r2_3 -l 142.176
+
+checkprops r3_1 -l 153.936

tests/bugs/modalg_6/bug27386_3

@@ -18,7 +18,6 @@ mkedge pr3 cc
 wire pr3 pr3
 donly sp pr1 pr2 pr3
 
-
 mksweep sp
 addsweep pr3
 addsweep pr1
@@ -35,11 +34,26 @@ generated r1_1 sweep_hist pr1_1
 generated r1_2 sweep_hist pr1_2
 generated r1_3 sweep_hist pr1_3
 
+checknbshapes r1_1 -face 1
+checkprops r1_1 -s 798.081
+checknbshapes r1_2 -face 2
+checkprops r1_2 -s 1653.11
+checknbshapes r1_3 -face 1
+checkprops r1_3 -s 798.081
+
 generated r2_1 sweep_hist pr2_1
 generated r2_2 sweep_hist pr2_2
 
+checknbshapes r2_1 -face 2
+checkprops r2_1 -s 1624.64
+checknbshapes r2_2 -face 2
+checkprops r2_2 -s 1624.64
+
 generated r3_1 sweep_hist pr3_1
 
+checknbshapes r3_1 -face 4
+checkprops r3_1 -s 3249.27
+
 explode pr1 v
 explode pr2 v
 explode pr3 v
@@ -49,9 +63,21 @@ generated r1_2 sweep_hist pr1_2
 generated r1_3 sweep_hist pr1_3
 generated r1_4 sweep_hist pr1_4
 
+checkprops r1_1 -l 147.049
+checkprops r1_2 -l 161.905
+checkprops r1_3 -l 161.905
+checkprops r1_4 -l 147.049
+
 generated r2_1 sweep_hist pr2_1
 generated r2_2 sweep_hist pr2_2
 generated r2_3 sweep_hist pr2_3
 
+checkprops r2_1 -l 147.049
+checkprops r2_2 -l 172.788
+checkprops r2_3 -l 147.049
+
 generated r3_1 sweep_hist pr3_1
 generated r3_2 sweep_hist pr3_2
+
+checkprops r3_1 -l 147.049
+checkprops r3_2 -l 147.049

tests/bugs/modalg_6/bug27386_4

@@ -26,11 +26,35 @@ generated r1 sweep_hist pr2_1
 generated r2 sweep_hist pr2_2
 generated r3 sweep_hist pr2_3
 
+checkprops r1 -s 1171.18
+checkprops r2 -s 1171.18
+checkprops r3 -s 965.22
+
 explode pr2 v
 
 generated r1 sweep_hist pr2_1
 generated r2 sweep_hist pr2_2
 generated r3 sweep_hist pr2_3
 
+checkprops r1 -l 147.049
+checkprops r2 -l 167.959
+checkprops r3 -l 147.049
+
 generated r4 sweep_hist sp_1
 generated r5 sweep_hist sp_2
+
+checknbshapes r4 -vertex 1 -edge 3 -face 0
+
+regexp {Mass : *([0-9\-+.eE]+)} [lprops r4] dummy len4
+
+if {$len4 > 1.e-12} {
+   puts "Error: the length of punctual section is not null"
+}
+
+checknbshapes r5 -vertex 1 -edge 3 -face 0
+
+regexp {Mass : *([0-9\-+.eE]+)} [lprops r5] dummy len5
+
+if {$len5 > 1.e-12} {
+   puts "Error: the length of punctual section is not null"
+}

tests/bugs/modalg_6/bug27386_5

@@ -28,17 +28,32 @@ savehistory sweep_hist
 
 generated r1_1 sweep_hist pr1_1
 
+checknbshapes r1_1 -face 4
+checkprops r1_1 -s 37077
+
 generated r2_1 sweep_hist pr2_1
 generated r2_2 sweep_hist pr2_2
 generated r2_3 sweep_hist pr2_3
 generated r2_4 sweep_hist pr2_4
 
+checkprops r2_1 -s 8740.38
+checkprops r2_2 -s 9798.12
+checkprops r2_3 -s 9798.12
+checkprops r2_4 -s 8740.38
+
 explode pr1 v
 explode pr2 v
 
 generated r1_1 sweep_hist pr1_1
 
+checkprops r1_1 -l 628.319
+
 generated r2_1 sweep_hist pr2_1
 generated r2_2 sweep_hist pr2_2
 generated r2_3 sweep_hist pr2_3
 generated r2_4 sweep_hist pr2_4
+
+checkprops r2_1 -l 565.487
+checkprops r2_2 -l 628.319
+checkprops r2_3 -l 691.15
+checkprops r2_4 -l 628.319

tests/bugs/modalg_6/bug27386_6

@@ -30,19 +30,42 @@ savehistory sweep_hist
 
 generated r1_1 sweep_hist pr1_1
 
+checknbshapes r1_1 -face 4
+checkprops r1_1 -s 35117.3
+
 generated r2_1 sweep_hist pr2_1
 generated r2_2 sweep_hist pr2_2
 generated r2_3 sweep_hist pr2_3
 generated r2_4 sweep_hist pr2_4
 
+checkprops r2_1 -s 8183.89
+checkprops r2_2 -s 9374.75
+checkprops r2_3 -s 9374.75
+checkprops r2_4 -s 8183.89
+
 explode pr1 v
 explode pr2 v
 
 generated r1_1 sweep_hist pr1_1
 
+checkprops r1_1 -l 628.319
+
 generated r2_1 sweep_hist pr2_1
 generated r2_2 sweep_hist pr2_2
 generated r2_3 sweep_hist pr2_3
 generated r2_4 sweep_hist pr2_4
 
+checkprops r2_1 -l 573.265
+checkprops r2_2 -l 629.072
+checkprops r2_3 -l 684.885
+checkprops r2_4 -l 629.072
+
 generated r3 sweep_hist sp_1
+
+checknbshapes r3 -vertex 1 -edge 4 -face 0
+
+regexp {Mass : *([0-9\-+.eE]+)} [lprops r3] dummy len3
+
+if {$len3 > 1.e-12} {
+   puts "Error: the length of punctual section is not null"
+}

tests/bugs/modalg_6/bug27386_7

@@ -23,9 +23,23 @@ generated r2 sweep_hist pr_2
 generated r3 sweep_hist pr_3
 generated r4 sweep_hist pr_4
 
+checknbshapes r1 -face 4
+checkprops r1 -s 256109
+checknbshapes r2 -face 4
+checkprops r2 -s 277227
+checknbshapes r3 -face 4
+checkprops r3 -s 256109
+checknbshapes r4 -face 3
+checkprops r4 -s 233971
+
 explode pr v
 
 generated r1 sweep_hist pr_1
 generated r2 sweep_hist pr_2
 generated r3 sweep_hist pr_3
 generated r4 sweep_hist pr_4
+
+checkprops r1 -l 1169.86
+checkprops r2 -l 1386.13
+checkprops r3 -l 1386.13
+checkprops r4 -l 1169.86

tests/bugs/modalg_6/bug27386_8

@@ -23,9 +23,27 @@ generated r2 sweep_hist pr_2
 generated r3 sweep_hist pr_3
 generated r4 sweep_hist pr_4
 
+checknbshapes r1 -face 12
+checkprops r1 -s 275.124
+checknbshapes r2 -face 9
+checkprops r2 -s 189.425
+checknbshapes r3 -face 9
+checkprops r3 -s 189.425
+checknbshapes r4 -face 12
+checkprops r4 -s 275.124
+
 explode pr v
 
 generated r1 sweep_hist pr_1
 generated r2 sweep_hist pr_2
 generated r3 sweep_hist pr_3
 generated r4 sweep_hist pr_4
+
+checknbshapes r1 -edge 12
+checkprops r1 -l 78.8496
+checknbshapes r2 -edge 9
+checkprops r2 -l 57.4248
+checknbshapes r3 -edge 6
+checkprops r3 -l 36
+checknbshapes r4 -edge 9
+checkprops r4 -l 57.4248

tests/bugs/modalg_6/bug28626_1

@@ -18,3 +18,8 @@ checknbshapes result -solid 1 -shell 1 -face 10 -wire 10 -edge 20 -vertex 12
 checkmaxtol result -ref 8.00001e-007
 
 checkprops result -v 1.35999e+006
+
+smallview
+don b result
+fit
+checkview -screenshot -2d -path ${imagedir}/${test_image}.png

tests/bugs/modalg_6/bug28626_2

@@ -12,8 +12,6 @@ trimv tc1 c1 0 42.4264068711929
 trimv tc2 c2 0 42.4264068711929
 mkface f1 tc1
 mkface f2 tc2
-donly f1 f2
-fit
 
 bop f1 f2
 bopsection result
@@ -25,3 +23,8 @@ checknbshapes result -edge 2 -vertex 3
 checkmaxtol result -ref 5.21731e-007
 
 checkprops result -l 88.9692
+
+smallview
+don f1 f2 result
+fit
+checkview -screenshot -2d -path ${imagedir}/${test_image}.png