Increment service pack version to 5

BRepLib_MakeFace::BRepLib_MakeFace: deleted degenerative edges from the input wire;
add test tests\mkface\mkplane\bug33156.

dox/user_guides/modeling_algos/modeling_algos.md

@@ -1356,9 +1356,7 @@ MF.Add(W);
 TopoDS_Face F = MF; 
 ~~~~~
 
-More than one wire can  be added to a face, provided that they do not cross each other and they define  only one area on the surface. (Note that this is not checked). The edges on a Face must have a parametric curve description. 
-
-If there is no  parametric curve for an edge of the wire on the Face it is computed by  projection. 
+More than one wire can  be added to a face, provided that they do not cross each other and they define  only one area on the surface. (Note that this is not checked).  
 
 For one wire, a simple  syntax is provided to construct the face from the surface and the wire. The  above lines could be written: 
 
@@ -1366,6 +1364,8 @@ For one wire, a simple  syntax is provided to construct the face from the surfac
 TopoDS_Face F = BRepBuilderAPI_MakeFace(C,W); 
 ~~~~~
 
+The edges on a face must have a parametric curve description. If there is no parametric curve for an edge of the wire on the face it is computed by projection, moreover, the calculation is possible only for the planar face.
+
 A planar face can be  created from only a wire, provided this wire defines a plane. For example, to  create a planar face from a set of points you can use *BRepBuilderAPI_MakePolygon* and *BRepBuilderAPI_MakeFace*.
 
 ~~~~~

dox/user_guides/modeling_data/modeling_data.md

@@ -343,6 +343,7 @@ The <i> GeomConvert</i> package also provides the following:
   * global functions to construct BSpline surfaces created by this splitting algorithm, or by other types of BSpline surface segmentation,
   * an algorithm, which converts a BSpline surface into a series of adjacent Bezier surfaces,
   * an algorithm, which converts a grid of adjacent Bezier surfaces into a BSpline surface.
+  * algorithms that converts NURBS, Bezier and other general parametrized curves and surface into anaytical curves and surfaces.
 
 @subsection occt_modat_1_4 Points on Curves
 

dox/user_guides/shape_healing/shape_healing.md

@@ -877,6 +877,24 @@ Standard_Integer NbOffsetSurfaces = safc.NbOffsetSurf();
 Handle(TopTools_HSequenceOfShape) seqFaces = safc.OffsetSurfaceSec(); 
 ~~~~~
 
+@subsubsection occt_shg_3_2_4 Analysis of shape underlined geometry
+
+Class *ShapeAnalysis_CanonicalRecognition* provides tools that analyze geometry of shape and explore the possibility of converting geometry into a canonical form.
+Canonical forms for curves are lines, circles and ellipses.
+Canonical forms for surfaces are planar, cylindrical, conical and spherical surfaces.
+
+Recognition and converting into canonical form is performed according to maximal deviation criterium: maximal distance between initial and canonical geometrical objects must be less, than given value.
+
+Analysis of curves is allowed for following shapes:
+  * edge - algorithm checks 3d curve of edge
+  * wire - algorithm checks 3d curves of all edges in order to convert them in the same analytical curve
+
+Analysis of surfaces is allowed for following shapes:
+  * face - algorithm checks surface of face
+  * shell - algorithm checks surfaces of all faces in order to convert them in the same analytical surface
+  * edge - algorithm checks all surfaces that are shared by given edge in order convert one of them in analytical surface, which most close to the input sample surface.
+  * wire - the same as for edge, but algorithm checks all edges of wire in order to find analytical surface, which most close to the input sample surface.
+
 @section occt_shg_4 Upgrading
 
 Upgrading tools are intended for adaptation of shapes for better use by Open CASCADE Technology or for customization to particular needs, i.e. for export to another system. This means that not only it corrects and upgrades but also changes the definition of a shape with regard to its geometry, size and other aspects. Convenient API allows you to create your own tools to perform specific upgrading. Additional tools for particular cases provide an ability to divide shapes and surfaces according to certain criteria. 

src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx

@@ -655,6 +655,12 @@ void BOPAlgo_PaveFiller::FillShrunkData(Handle(BOPDS_PaveBlock)& thePB)
   // Vertices
   Standard_Integer nV1, nV2;
   thePB->Indices(nV1, nV2);
+
+  if (nV1 < 0 || nV2 < 0)
+  {
+    return;
+  }
+
   const TopoDS_Vertex& aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1))); 
   const TopoDS_Vertex& aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2))); 
   // Get the edge

src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx

@@ -648,8 +648,8 @@ void BOPAlgo_PaveFiller::MakeBlocks()
         // check if the pave block has a valid range
         Standard_Real aFirst, aLast;
         if (!BRepLib::FindValidRange(GeomAdaptor_Curve(aIC.Curve()), aTolR3D,
-                                     aT1, BRep_Tool::Pnt(aV1), BRep_Tool::Tolerance(aV1),
-                                     aT2, BRep_Tool::Pnt(aV2), BRep_Tool::Tolerance(aV2),
+                                     aT1, BRep_Tool::Pnt(aV1), Max (aTolR3D, BRep_Tool::Tolerance(aV1)),
+                                     aT2, BRep_Tool::Pnt(aV2), Max (aTolR3D, BRep_Tool::Tolerance(aV2)),
                                      aFirst, aLast))
         {
           // If the pave block does not have valid range, i.e. it is completely
@@ -3035,9 +3035,21 @@ void BOPAlgo_PaveFiller::PutClosingPaveOnCurve(BOPDS_Curve& aNC)
     return;
   }
 
-  if (aDistVP > aTolV)
+  // Check if there will be valid range on the curve
+  Standard_Real aFirst, aLast;
+  Standard_Real aNewTolV = Max(aTolV, aDistVP + BOPTools_AlgoTools::DTolerance());
+  if (!BRepLib::FindValidRange(GeomAdaptor_Curve(aIC.Curve()), aIC.Tolerance(),
+                               aT[0], aP[0], aNewTolV,
+                               aT[1], aP[1], aNewTolV,
+                               aFirst, aLast))
   {
-    Standard_Integer nVn = UpdateVertex(nV, aDistVP + BOPTools_AlgoTools::DTolerance());
+    // No valid range
+    return;
+  }
+
+  if (aNewTolV > aTolV)
+  {
+    Standard_Integer nVn = UpdateVertex(nV, aNewTolV);
     if (nVn != nV)
     {
       aPave.SetIndex(nVn);
@@ -3046,17 +3058,6 @@ void BOPAlgo_PaveFiller::PutClosingPaveOnCurve(BOPDS_Curve& aNC)
     aTolV = BRep_Tool::Tolerance(TopoDS::Vertex(myDS->Shape(nV)));
   }
 
-  // Check if there will be valid range on the curve
-  Standard_Real aFirst, aLast;
-  if (!BRepLib::FindValidRange(GeomAdaptor_Curve(aIC.Curve()), aIC.Tolerance(),
-                               aT[0], aP[0], aTolV,
-                               aT[1], aP[1], aTolV,
-                               aFirst, aLast))
-  {
-    // No valid range
-    return;
-  }
-
   // Add closing pave to the curve
   BOPDS_Pave aNewPave;
   aNewPave.SetIndex(nV);

src/BOPTools/BOPTools_AlgoTools3D.cxx

@@ -77,7 +77,8 @@ Standard_Boolean BOPTools_AlgoTools3D::DoSplitSEAMOnFace (const TopoDS_Edge& aSp
                                                           const TopoDS_Face& aF)
 {
   Standard_Boolean bIsUPeriodic, bIsVPeriodic, bIsLeft;
-  Standard_Real aTol, a, b, anUPeriod, anVPeriod, aT, anU, dU, anU1;
+  Standard_Real anUPeriod = 0., anVPeriod = 0.;
+  Standard_Real aTol, a, b, aT, anU, dU, anU1;
   Standard_Real aScPr, anV, dV, anV1;
   Standard_Real aUmin, aUmax, aVmin, aVmax;
   gp_Pnt2d aP2D;
@@ -98,58 +99,64 @@ Standard_Boolean BOPTools_AlgoTools3D::DoSplitSEAMOnFace (const TopoDS_Edge& aSp
   //
   aS->Bounds(aUmin, aUmax, aVmin, aVmax);
   //
-  bIsUPeriodic=aS->IsUPeriodic();
-  bIsVPeriodic=aS->IsVPeriodic();
-  //
-  anUPeriod = bIsUPeriodic ? aS->UPeriod() : 0.;
-  anVPeriod = bIsVPeriodic ? aS->VPeriod() : 0.;
+
+  bIsUPeriodic = aS->IsUClosed();
+  bIsVPeriodic = aS->IsVClosed();
+
+  if (bIsUPeriodic)
+    anUPeriod = aUmax - aUmin;
+  if (bIsVPeriodic)
+    anVPeriod = aVmax - aVmin;
+  
   //
   if (!bIsUPeriodic && !bIsVPeriodic) {
-    Standard_Boolean bIsUClosed, bIsVClosed;
-    Handle(Geom_BSplineSurface) aBS;
-    Handle(Geom_BezierSurface) aBZ;
+    
     Handle(Geom_RectangularTrimmedSurface) aRTS;
+    aRTS = Handle(Geom_RectangularTrimmedSurface)::DownCast(aS);
     //
-    bIsUClosed=Standard_False;
-    bIsVClosed=Standard_False;
-    aBS=Handle(Geom_BSplineSurface)::DownCast(aS);
-    aBZ=Handle(Geom_BezierSurface) ::DownCast(aS);
-    aRTS=Handle(Geom_RectangularTrimmedSurface)::DownCast(aS);
-    //
-    if (!aBS.IsNull()) {
-      bIsUClosed=aBS->IsUClosed();
-      bIsVClosed=aBS->IsVClosed();
-    }
-    else if (!aBZ.IsNull()) {
-      bIsUClosed=aBZ->IsUClosed();
-      bIsVClosed=aBZ->IsVClosed();
-    }
-    else if (!aRTS.IsNull()) {
+    if (aRTS.IsNull())
+      return Standard_False;
+    
+    else {
       Handle(Geom_Surface) aSB;
       //
-      aSB=aRTS->BasisSurface();
-      bIsUPeriodic=aSB->IsUPeriodic();
-      bIsVPeriodic=aSB->IsVPeriodic();
+      aSB = aRTS->BasisSurface();
+      bIsUPeriodic = aSB->IsUPeriodic();
+      bIsVPeriodic = aSB->IsVPeriodic();
       //
+
+      if (bIsUPeriodic || bIsVPeriodic)
+      {
+        anUPeriod = bIsUPeriodic ? aSB->UPeriod() : 0.;
+        anVPeriod = bIsVPeriodic ? aSB->VPeriod() : 0.;
+      }
+      else
+      {
+        Standard_Boolean bIsUClosed = aSB->IsUClosed();
+        Standard_Boolean bIsVClosed = aSB->IsVClosed();
+        Standard_Real aGlobalUmin, aGlobalUmax, aGlobalVmin, aGlobalVmax;
+        aSB->Bounds(aGlobalUmin, aGlobalUmax, aGlobalVmin, aGlobalVmax);
+
+        if (bIsUClosed &&
+            Abs(aUmin - aGlobalUmin) < aTol &&
+            Abs(aUmax - aGlobalUmax) < aTol)
+        {
+          bIsUPeriodic = Standard_True;
+          anUPeriod = aUmax - aUmin;
+        }
+        if (bIsVClosed &&
+            Abs(aVmin - aGlobalVmin) < aTol &&
+            Abs(aVmax - aGlobalVmax) < aTol)
+        {
+          bIsVPeriodic = Standard_True;
+          anVPeriod = aVmax - aVmin;
+        }
+      }
+      
       if (!(bIsUPeriodic || bIsVPeriodic)) {
         return Standard_False;
       }
-      anUPeriod = bIsUPeriodic ? aSB->UPeriod() : 0.;
-      anVPeriod = bIsVPeriodic ? aSB->VPeriod() : 0.;
-    }
-    //
-    if (aRTS.IsNull()) {
-      if (!bIsUClosed && !bIsVClosed) {
-        return Standard_False;
-      }
-      //
-      if (bIsUClosed) {
-        anUPeriod=aUmax-aUmin;
-      }
-      if (bIsVClosed) {
-        anVPeriod=aVmax-aVmin;
-      }
-    }
+    } //if !RTS.IsNull
   }
   //
   //---------------------------------------------------

src/BRepAlgo/BRepAlgo.cxx

@@ -15,8 +15,13 @@
 // commercial license or contractual agreement.
 
 
+#include <BRep_Builder.hxx>
 #include <BRep_Tool.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
 #include <BRepAdaptor_Curve.hxx>
+#include <BRepAdaptor_Curve2d.hxx>
 #include <BRepAlgo.hxx>
 #include <BRepLib.hxx>
 #include <BRepLib_MakeEdge.hxx>
@@ -25,10 +30,13 @@
 #include <ElCLib.hxx>
 #include <Geom_Curve.hxx>
 #include <Geom_TrimmedCurve.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
+#include <Geom2dConvert_ApproxArcsSegments.hxx>
 #include <GeomAbs_CurveType.hxx>
 #include <GeomConvert.hxx>
 #include <GeomConvert_CompCurveToBSplineCurve.hxx>
 #include <GeomLProp.hxx>
+#include <NCollection_Vector.hxx>
 #include <gp_Pnt.hxx>
 #include <Precision.hxx>
 #include <ShapeFix_Shape.hxx>
@@ -41,6 +49,7 @@
 #include <TColStd_SequenceOfBoolean.hxx>
 #include <TColStd_SequenceOfReal.hxx>
 #include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
 #include <TopLoc_Location.hxx>
 #include <TopoDS.hxx>
 #include <TopoDS_Edge.hxx>
@@ -53,6 +62,166 @@
 #//include <DrawTrSurf.hxx>
 
 
+// The minimal tolerance of approximation (edges can be defined with yet smaller tolerance)
+static const Standard_Real MINIMAL_TOLERANCE = 0.0001;
+
+namespace {
+
+struct OrientedCurve
+{
+  Handle(Geom2d_TrimmedCurve) Curve;
+  Standard_Boolean           IsReverse;
+  inline gp_Pnt2d Point (const Standard_Boolean isEnd) const
+  {
+    if (isEnd == IsReverse)
+      return Curve->StartPoint();
+    return Curve->EndPoint();
+  }  
+};
+
+}
+
+//=======================================================================
+//function : ConvertWire
+//purpose  : 
+//=======================================================================
+
+TopoDS_Wire BRepAlgo::ConvertWire(const TopoDS_Wire&          theWire,
+                                  const Standard_Real         theAngleTol,
+                                  const TopoDS_Face&          theFace)
+{
+  TopoDS_Wire aResult;
+  Standard_Real aMaxTol(0.);
+  const Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theFace);
+  NCollection_Vector<OrientedCurve> vecCurve;
+
+  BRepTools_WireExplorer anExpE(theWire, theFace);
+  // Explore the edges in the current wire, in their connection order
+  for (; anExpE.More(); anExpE.Next()) {
+    const TopoDS_Edge& anEdge = anExpE.Current();
+    BRepAdaptor_Curve2d aCurve(anEdge, theFace);
+    Standard_Real aTol = BRep_Tool::Tolerance(anEdge);
+    if (aTol < MINIMAL_TOLERANCE)
+      aTol = MINIMAL_TOLERANCE;
+    if (aTol > aMaxTol)
+      aMaxTol = aTol;
+    Geom2dConvert_ApproxArcsSegments anAlgo(aCurve, aTol, theAngleTol);
+    const TColGeom2d_SequenceOfCurve& aResultApprox = anAlgo.GetResult();
+
+    // Form the array of approximated elementary curves
+    if (anEdge.Orientation() == TopAbs_REVERSED) {
+      for (Standard_Integer iCrv = aResultApprox.Length(); iCrv > 0 ; iCrv--) {
+        const Handle(Geom2d_Curve)& aCrv = aResultApprox(iCrv);
+        if (aCrv.IsNull() == Standard_False) {
+          OrientedCurve& anOCurve = vecCurve.Append(OrientedCurve());
+          anOCurve.Curve = Handle(Geom2d_TrimmedCurve)::DownCast(aCrv);
+          anOCurve.IsReverse = Standard_True;
+        }
+      }
+    } else {
+      for (Standard_Integer iCrv = 1; iCrv <= aResultApprox.Length(); iCrv++) {
+        const Handle(Geom2d_Curve)& aCrv = aResultApprox(iCrv);
+        if (aCrv.IsNull() == Standard_False) {
+          OrientedCurve& anOCurve = vecCurve.Append(OrientedCurve());
+          anOCurve.Curve = Handle(Geom2d_TrimmedCurve)::DownCast(aCrv);
+          anOCurve.IsReverse = Standard_False;
+        }
+      }
+    }
+  }
+
+  if (vecCurve.Length() > 0)
+  {
+    // Build the first vertex
+    BRep_Builder aVBuilder;
+    gp_Pnt2d aPnt[2] = {
+      vecCurve(0).Point(Standard_False),
+      vecCurve(vecCurve.Length() - 1).Point(Standard_True)
+    };
+    Standard_Real aDist = aPnt[0].Distance(aPnt[1]);
+    if (aDist > aMaxTol + Precision::Confusion())
+      aDist = Precision::Confusion();
+    else {
+      aDist = 0.5 * aDist + Precision::Confusion();
+      aPnt[0] = 0.5 * (aPnt[0].XY() + aPnt[1].XY());
+    }
+    gp_Pnt aPnt3d;
+    aSurf->D0(aPnt[0].X(), aPnt[0].Y(), aPnt3d);
+    TopoDS_Vertex aFirstVertex;
+    aVBuilder.MakeVertex(aFirstVertex, aPnt3d, aDist);
+
+    // Loop creating edges
+    BRepBuilderAPI_MakeWire aMkWire;
+    TopoDS_Edge anEdgeRes;
+    TopoDS_Vertex aVertex = aFirstVertex;
+    for (Standard_Integer iCrv = 0; iCrv < vecCurve.Length(); iCrv++) {
+      const OrientedCurve& anOCurve = vecCurve(iCrv);
+      TopoDS_Vertex aNextVertex;
+      aPnt[0] = anOCurve.Point(Standard_True);
+      if (iCrv == vecCurve.Length() - 1) {
+        aPnt[1] = vecCurve(0).Point(Standard_False);
+        aDist = aPnt[0].Distance(aPnt[1]);
+        if (aDist > aMaxTol + Precision::Confusion()) {
+          aSurf->D0(aPnt[0].X(), aPnt[0].Y(), aPnt3d);
+          aVBuilder.MakeVertex(aNextVertex, aPnt3d, Precision::Confusion());
+        } else {
+          aNextVertex = aFirstVertex;
+        }
+      } else {
+        aPnt[1] = vecCurve(iCrv + 1).Point(Standard_False);
+        aDist = 0.5 * (aPnt[0].Distance(aPnt[1])) + Precision::Confusion();
+        aPnt[0] = 0.5 * (aPnt[0].XY() + aPnt[1].XY());
+        aSurf->D0(aPnt[0].X(), aPnt[0].Y(), aPnt3d);
+        aVBuilder.MakeVertex(aNextVertex, aPnt3d, aDist);
+      }
+      const Standard_Real aParam[2] = {
+        anOCurve.Curve->FirstParameter(),
+        anOCurve.Curve->LastParameter()
+      };
+      if (anOCurve.IsReverse) {
+        BRepBuilderAPI_MakeEdge aMkEdge(anOCurve.Curve, aSurf, aNextVertex,
+                                        aVertex, aParam[0], aParam[1]);
+        anEdgeRes = aMkEdge.Edge();
+        anEdgeRes.Orientation(TopAbs_REVERSED);
+      } else {
+        BRepBuilderAPI_MakeEdge aMkEdge(anOCurve.Curve, aSurf, aVertex,
+                                        aNextVertex, aParam[0], aParam[1]);
+        anEdgeRes = aMkEdge.Edge();
+      }
+      aVertex = aNextVertex;
+      aMkWire.Add(anEdgeRes);
+    }
+
+    if (aMkWire.IsDone())
+      aResult = aMkWire.Wire();
+  }
+  return aResult;
+}
+
+//=======================================================================
+//function : ConvertFace
+//purpose  : 
+//=======================================================================
+
+TopoDS_Face BRepAlgo::ConvertFace (const TopoDS_Face&  theFace,
+                                   const Standard_Real theAngleTolerance)
+{
+  TopoDS_Face aResult;
+  const Handle(Geom_Surface) aSurf = BRep_Tool::Surface(theFace);
+  BRepBuilderAPI_MakeFace aMkFace(aSurf,Precision::Confusion());
+
+  TopExp_Explorer anExp(theFace, TopAbs_WIRE);
+  for (; anExp.More(); anExp.Next()) {
+    const TopoDS_Wire& aWire = TopoDS::Wire(anExp.Current());
+    const TopoDS_Wire aNewWire = ConvertWire(aWire, theAngleTolerance, theFace);
+    aMkFace.Add(aNewWire);
+  }
+  if (aMkFace.IsDone()) {
+    aResult = aMkFace.Face();
+  }
+  return aResult;
+}
+
 //=======================================================================
 //function : ConcatenateWire
 //purpose  : 

src/BRepAlgo/BRepAlgo.hxx

@@ -27,6 +27,7 @@
 #include <TopTools_ListOfShape.hxx>
 class TopoDS_Wire;
 class TopoDS_Edge;
+class TopoDS_Face;
 class TopoDS_Shape;
 class BRepAlgo_BooleanOperation;
 class BRepAlgo_Fuse;
@@ -65,6 +66,28 @@ public:
   //! Junction points between edges of wire may be sharp,
   //! resulting curve of the resulting edge may be C0.
   Standard_EXPORT static TopoDS_Edge ConcatenateWireC0 (const TopoDS_Wire& Wire);
+
+  //! Method of wire conversion, calls BRepAlgo_Approx internally.
+  //! @param theWire
+  //!   Input Wire object.
+  //! @param theAngleTolerance
+  //!   Angle (in radians) defining the continuity of the wire: if two vectors
+  //!   differ by less than this angle, the result will be smooth (zero angle of
+  //!   tangent lines between curve elements).
+  //! @return
+  //!   The new TopoDS_Wire object consisting of edges each representing an arc
+  //!   of circle or a linear segment. The accuracy of conversion is defined
+  //!   as the maximal tolerance of edges in theWire.
+  static Standard_EXPORT TopoDS_Wire ConvertWire
+                                (const TopoDS_Wire&  theWire,
+                                 const Standard_Real theAngleTolerance,
+                                 const TopoDS_Face&  theFace);
+
+  //! Method of face conversion. The API corresponds to the method ConvertWire.
+  //! This is a shortcut for calling ConvertWire() for each wire in theFace.
+  static Standard_EXPORT TopoDS_Face ConvertFace
+                                (const TopoDS_Face&  theFace,
+                                 const Standard_Real theAngleTolerance);
   
   //! Checks if the  shape is "correct". If not, returns
   //! <Standard_False>, else returns <Standard_True>.

src/BRepAlgo/BRepAlgo_Loop.cxx

@@ -23,8 +23,10 @@
 #include <BRepAlgo_Loop.hxx>
 #include <Geom2d_Curve.hxx>
 #include <Geom_Surface.hxx>
+#include <GeomLib.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Pnt2d.hxx>
+#include <gp_Ax2.hxx>
 #include <Precision.hxx>
 #include <TopExp.hxx>
 #include <TopExp_Explorer.hxx>
@@ -160,6 +162,15 @@ void BRepAlgo_Loop::AddConstEdges(const TopTools_ListOfShape& LE)
   }
 }
 
+//=======================================================================
+//function : SetImageVV
+//purpose  : 
+//=======================================================================
+
+void BRepAlgo_Loop::SetImageVV (const BRepAlgo_Image& theImageVV)
+{
+  myImageVV = theImageVV;
+}
 
 //=======================================================================
 //function : UpdateClosedEdge
@@ -606,6 +617,8 @@ void BRepAlgo_Loop::Perform()
   TopoDS_Wire      NW;
   Standard_Boolean End;
 
+  UpdateVEmap (MVE);
+
   TopTools_MapOfShape UsedEdges;
 
   while (MVE.Extent() > 0) {
@@ -924,6 +937,7 @@ void  BRepAlgo_Loop::GetVerticesForSubstitute( TopTools_DataMapOfShapeShape& Ver
 {
   VerVerMap = myVerticesForSubstitute;
 }
+
 //=======================================================================
 //function : VerticesForSubstitute
 //purpose  : 
@@ -933,3 +947,123 @@ void  BRepAlgo_Loop::VerticesForSubstitute( TopTools_DataMapOfShapeShape& VerVer
 {
   myVerticesForSubstitute = VerVerMap;
 }
+
+//=======================================================================
+//function : UpdateVEmap
+//purpose  : 
+//=======================================================================
+
+void  BRepAlgo_Loop::UpdateVEmap (TopTools_IndexedDataMapOfShapeListOfShape& theVEmap)
+{
+  TopTools_IndexedDataMapOfShapeListOfShape VerLver;
+
+  for (Standard_Integer ii = 1; ii <= theVEmap.Extent(); ii++)
+  {
+    const TopoDS_Vertex& aVertex = TopoDS::Vertex (theVEmap.FindKey(ii));
+    const TopTools_ListOfShape& aElist = theVEmap(ii);
+    if (aElist.Extent() == 1 && myImageVV.IsImage(aVertex))
+    {
+      const TopoDS_Vertex& aProVertex = TopoDS::Vertex (myImageVV.ImageFrom(aVertex));
+      if (VerLver.Contains(aProVertex))
+      {
+        TopTools_ListOfShape& aVlist = VerLver.ChangeFromKey(aProVertex);
+        aVlist.Append (aVertex.Oriented(TopAbs_FORWARD));
+      }
+      else
+      {
+        TopTools_ListOfShape aVlist;
+        aVlist.Append (aVertex.Oriented(TopAbs_FORWARD));
+        VerLver.Add (aProVertex,  aVlist);
+      }
+    }
+  }
+
+  if (VerLver.IsEmpty())
+    return;
+
+  BRep_Builder aBB;
+  for (Standard_Integer ii = 1; ii <= VerLver.Extent(); ii++)
+  {
+    const TopTools_ListOfShape& aVlist = VerLver(ii);
+    if (aVlist.Extent() == 1)
+      continue;
+    
+    Standard_Real aMaxTol = 0.;
+    TColgp_Array1OfPnt Points (1, aVlist.Extent());
+
+    TopTools_ListIteratorOfListOfShape itl (aVlist);
+    Standard_Integer jj = 0;
+    for (; itl.More(); itl.Next())
+    {
+      const TopoDS_Vertex& aVertex = TopoDS::Vertex (itl.Value());
+      Standard_Real aTol = BRep_Tool::Tolerance(aVertex);
+      aMaxTol = Max (aMaxTol, aTol);
+      gp_Pnt aPnt = BRep_Tool::Pnt(aVertex);
+      Points(++jj) = aPnt;
+    }
+
+    gp_Ax2 anAxis;
+    Standard_Boolean IsSingular;
+    GeomLib::AxeOfInertia (Points, anAxis, IsSingular);
+    gp_Pnt aCentre = anAxis.Location();
+    Standard_Real aMaxDist = 0.;
+    for (jj = 1; jj <= Points.Upper(); jj++)
+    {
+      Standard_Real aSqDist = aCentre.SquareDistance (Points(jj));
+      aMaxDist = Max (aMaxDist, aSqDist);
+    }
+    aMaxDist = Sqrt(aMaxDist);
+    aMaxTol = Max (aMaxTol, aMaxDist);
+
+    //Find constant vertex
+    TopoDS_Vertex aConstVertex;
+    for (itl.Initialize(aVlist); itl.More(); itl.Next())
+    {
+      const TopoDS_Vertex& aVertex = TopoDS::Vertex (itl.Value());
+      const TopTools_ListOfShape& aElist = theVEmap.FindFromKey(aVertex);
+      const TopoDS_Shape& anEdge = aElist.First();
+      TopTools_ListIteratorOfListOfShape itcedges (myConstEdges);
+      for (; itcedges.More(); itcedges.Next())
+        if (anEdge.IsSame (itcedges.Value()))
+        {
+          aConstVertex = aVertex;
+          break;
+        }
+      if (!aConstVertex.IsNull())
+        break;
+    }
+    if (aConstVertex.IsNull())
+      aConstVertex = TopoDS::Vertex(aVlist.First());
+    aBB.UpdateVertex (aConstVertex, aCentre, aMaxTol);
+
+    for (itl.Initialize(aVlist); itl.More(); itl.Next())
+    {
+      const TopoDS_Vertex& aVertex = TopoDS::Vertex (itl.Value());
+      if (aVertex.IsSame(aConstVertex))
+        continue;
+      
+      const TopTools_ListOfShape& aElist = theVEmap.FindFromKey (aVertex);
+      TopoDS_Edge anEdge = TopoDS::Edge (aElist.First());
+      anEdge.Orientation(TopAbs_FORWARD);
+      TopoDS_Vertex aV1, aV2;
+      TopExp::Vertices (anEdge, aV1, aV2);
+      TopoDS_Vertex aVertexToRemove = (aV1.IsSame(aVertex))? aV1 : aV2;
+      anEdge.Free(Standard_True);
+      aBB.Remove (anEdge, aVertexToRemove);
+      aBB.Add (anEdge, aConstVertex.Oriented (aVertexToRemove.Orientation()));
+    }
+  }
+
+  TopTools_IndexedMapOfShape Emap;
+  for (Standard_Integer ii = 1; ii <= theVEmap.Extent(); ii++)
+  {
+    const TopTools_ListOfShape& aElist = theVEmap(ii);
+    TopTools_ListIteratorOfListOfShape itl (aElist);
+    for (; itl.More(); itl.Next())
+      Emap.Add (itl.Value());
+  }
+
+  theVEmap.Clear();
+  for (Standard_Integer ii = 1; ii <= Emap.Extent(); ii++)
+    TopExp::MapShapesAndAncestors (Emap(ii), TopAbs_VERTEX, TopAbs_EDGE, theVEmap);
+}

src/BRepAlgo/BRepAlgo_Loop.hxx

@@ -25,6 +25,8 @@
 #include <TopTools_ListOfShape.hxx>
 #include <TopTools_DataMapOfShapeListOfShape.hxx>
 #include <TopTools_DataMapOfShapeShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <BRepAlgo_Image.hxx>
 class TopoDS_Face;
 class TopoDS_Edge;
 
@@ -53,9 +55,15 @@ public:
   //! Add <LE> as a set of const edges.
   Standard_EXPORT void AddConstEdges (const TopTools_ListOfShape& LE);
   
+  //! Sets the Image Vertex - Vertex
+  Standard_EXPORT void SetImageVV (const BRepAlgo_Image& theImageVV);
+  
   //! Make loops.
   Standard_EXPORT void Perform();
   
+  //! Update VE map according to Image Vertex - Vertex
+  Standard_EXPORT void UpdateVEmap (TopTools_IndexedDataMapOfShapeListOfShape& theVEmap);
+  
   //! Cut the  edge <E>  in  several edges  <NE> on the
   //! vertices<VonE>.
   Standard_EXPORT void CutEdge (const TopoDS_Edge& E, const TopTools_ListOfShape& VonE, TopTools_ListOfShape& NE) const;
@@ -102,6 +110,7 @@ private:
   TopTools_ListOfShape myNewFaces;
   TopTools_DataMapOfShapeListOfShape myCutEdges;
   TopTools_DataMapOfShapeShape myVerticesForSubstitute;
+  BRepAlgo_Image myImageVV;
 
 
 };

src/BRepAlgo/BRepAlgo_NormalProjection.cxx

@@ -350,7 +350,7 @@ void BRepAlgo_NormalProjection::SetDefaultParams()
 	  
 	  if(Only2d && Only3d) {
 	    BRepLib_MakeEdge MKed(GeomAdaptor::MakeCurve(hcur->Curve()), 
-				  Ufin, Udeb);
+				  Udeb, Ufin);
 	    prj = MKed.Edge();
 	    BB.UpdateEdge(TopoDS::Edge(prj), 
 			  PCur2d, 

src/BRepBuilderAPI/BRepBuilderAPI_MakeFace.hxx

@@ -135,6 +135,9 @@ public:
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Torus& C, const TopoDS_Wire& W, const Standard_Boolean Inside = Standard_True);
   
   //! Make a face from a Surface and a wire.
+  //! If the surface S is not plane,
+  //! it must contain pcurves for all edges in W,
+  //! otherwise the wrong shape will be created.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const Handle(Geom_Surface)& S, const TopoDS_Wire& W, const Standard_Boolean Inside = Standard_True);
   
   //! Adds the wire <W> in the face <F>

src/BRepExtrema/BRepExtrema_DistanceSS.cxx

@@ -468,8 +468,15 @@ static void PERFORM_C0(const TopoDS_Edge &S1, const TopoDS_Edge &S2,
             {
               if (fabs(Dstmin-sqrt(Ext.SquareDistance(ii)))<Eps)
               {
-                Pt=Ext.Point(ii);
-                if (TRI_SOLUTION(SeqSol2,Pt))
+                Pt = Ext.Point(ii);
+                // Pt - point on the curve pCurvOther/Eother, but
+                // if iE == 0 -> Eother correspond to edge S2
+                // and to edge S1 in the opposite case.
+                // Therefore we should search Pt through previous solution points on Other curve (edge):
+                // if iE == 0 - on edge S2, namely through SeqSol2,
+                // else       - on edge S1, namely through SeqSol1.
+                const bool triSolutionResult = (iE == 0) ? TRI_SOLUTION(SeqSol2, Pt) : TRI_SOLUTION(SeqSol1, Pt);
+                if (triSolutionResult)
                 {
                   // Check if the parameter does not correspond to a vertex
                   const Standard_Real t = Ext.Parameter(ii);
@@ -954,9 +961,19 @@ void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1, const TopoDS_Edge& S
      
     if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
     {
-      SeqSolShape1.Append(seqSol1);
-      SeqSolShape2.Append(seqSol2);	
-      myModif = Standard_True;
+      BRepExtrema_SeqOfSolution::iterator anIt1 = seqSol1.begin();
+      BRepExtrema_SeqOfSolution::iterator anIt2 = seqSol2.begin();
+      for (; anIt1 != seqSol1.end() && anIt2 != seqSol2.end(); anIt1++, anIt2++)
+      {
+        gp_Pnt Pt1 = anIt1->Point();
+        gp_Pnt Pt2 = anIt2->Point();
+        if (TRI_SOLUTION(SeqSolShape1, Pt1) || TRI_SOLUTION(SeqSolShape2, Pt2))
+        {
+          SeqSolShape1.Append(*anIt1);
+          SeqSolShape2.Append(*anIt2);
+          myModif = Standard_True;
+        }
+      }
     }
   }
 }

src/BRepExtrema/BRepExtrema_ProximityDistTool.cxx

@@ -0,0 +1,517 @@
+// Created on: 2022-08-08
+// Created by: Kseniya NOSULKO
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <BRepExtrema_ProximityDistTool.hxx>
+
+#include <BRepAdaptor_Surface.hxx>
+#include <BRep_Tool.hxx>
+#include <gp_Pln.hxx>
+#include <Precision.hxx>
+#include <Poly_Connect.hxx>
+#include <Standard_NullValue.hxx>
+#include <TopoDS.hxx>
+
+//=======================================================================
+//function : BRepExtrema_ProximityDistTool
+//purpose  : Creates new unitialized tool
+//=======================================================================
+BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool()
+: myMinDistance (std::numeric_limits<Standard_Real>::max()),
+  myProxDist (-1.),
+  myPntStatus1 (ProxPnt_Status_UNKNOWN),
+  myPntStatus2 (ProxPnt_Status_UNKNOWN),
+  myNbSamples1 (0),
+  myProxVtxIdx1 (-1)
+{
+}
+
+//=======================================================================
+//function : BRepExtrema_ProximityDistTool
+//purpose  : Creates new tool for the given element sets
+//=======================================================================
+BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                              const Standard_Integer theNbSamples1,
+                                                              const BVH_Array3d& theAddVertices1,
+                                                              const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
+                                                              const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                              const BRepExtrema_ShapeList& theShapeList1,
+                                                              const BRepExtrema_ShapeList& theShapeList2)
+: myMinDistance (std::numeric_limits<Standard_Real>::max()),
+  myProxDist (-1.),
+  myPntStatus1 (ProxPnt_Status_UNKNOWN),
+  myPntStatus2 (ProxPnt_Status_UNKNOWN),
+  myNbSamples1 (theNbSamples1),
+  myProxVtxIdx1 (-1)
+{
+  LoadTriangleSets (theSet1, theSet2);
+  LoadShapeLists (theShapeList1, theShapeList2);
+  LoadAdditionalPointsFirstSet (theAddVertices1, theAddStatus1);
+}
+
+//=======================================================================
+//function : LoadTriangleSets
+//purpose  : Loads the given element sets into the tool
+//=======================================================================
+void BRepExtrema_ProximityDistTool::LoadTriangleSets (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                      const Handle(BRepExtrema_TriangleSet)& theSet2)
+{
+  mySet1 = theSet1;
+  mySet2 = theSet2;
+}
+
+//=======================================================================
+//function : LoadShapeLists
+//purpose  : Loads the given list of subshapes into the proximity tool
+//=======================================================================
+void BRepExtrema_ProximityDistTool::LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
+                                                    const BRepExtrema_ShapeList& theShapeList2)
+{
+  myShapeList1 = theShapeList1;
+  myShapeList2 = theShapeList2;
+}
+
+//=======================================================================
+//function : LoadAdditionalPointsFirstSet
+//purpose  : Loads given additional vertices and their statuses
+//=======================================================================
+void BRepExtrema_ProximityDistTool::LoadAdditionalPointsFirstSet (const BVH_Array3d& theAddVertices1,
+                                                                  const NCollection_Vector<ProxPnt_Status>& theAddStatus1)
+{
+  myAddVertices1 = theAddVertices1;
+  myAddStatus1 = theAddStatus1;
+}
+
+//=======================================================================
+//function : goThroughtSet1
+//purpose  : Goes throught vertices from the 1st set
+//=======================================================================
+void BRepExtrema_ProximityDistTool::goThroughtSet1 (const BVH_Array3d& theVertices1,
+                                                    const Standard_Boolean theIsAdditionalSet)
+{
+  Standard_Integer aVtxSize = (Standard_Integer)theVertices1.size();
+  Standard_Integer aVtxStep = Max (myNbSamples1 <= 0 ? 1 : aVtxSize / myNbSamples1, 1);
+  for (Standard_Integer aVtxIdx = 0; aVtxIdx < aVtxSize; aVtxIdx += aVtxStep)
+  {
+    myDistance = std::numeric_limits<Standard_Real>::max();
+    myMinDistance = std::numeric_limits<Standard_Real>::max();
+    myIsDone = Standard_False;
+    SetObject (theVertices1[aVtxIdx]);
+
+    ComputeDistance();
+
+    if (!IsDone() && myProxDist < 0.) return;
+
+    if (IsDone() && myDistance > myProxDist)
+    {
+      myPnt1 = theVertices1[aVtxIdx];
+      myPnt2 = myExtremaPoint;
+      myProxDist = myDistance;
+      myProxVtxIdx1 = aVtxIdx;
+      myIsProxVtx1FromAddSet = theIsAdditionalSet;
+      myProxPrjState = myExtPrjState;
+    }
+  }
+}
+
+//=======================================================================
+//function : Perform
+//purpose  : Performs searching of the proximity distance
+//=======================================================================
+void BRepExtrema_ProximityDistTool::Perform()
+{
+  SetBVHSet (mySet2.get());
+  goThroughtSet1 (mySet1->GetVertices(), Standard_False);
+  goThroughtSet1 (myAddVertices1, Standard_True);
+
+  myIsDone = myProxDist > -1.;
+  if (myIsDone)
+  {
+    DefineStatusProxPnt();
+  }
+}
+
+static Standard_Real pointBoxSquareMaxDistance (const BVH_Vec3d& thePoint,
+                                                const BVH_Vec3d& theCMin,
+                                                const BVH_Vec3d& theCMax)
+{
+  Standard_Real aDist = 0;
+  for (int i = 0; i < 3; ++i)
+  {
+    if (thePoint[i] <= 0.5 * (theCMax[i] + theCMin[i])) { Standard_Real d = theCMax[i] - thePoint[i]; d *= d; aDist += d; }
+    else { Standard_Real d = thePoint[i] - theCMin[i]; d *= d; aDist += d; }
+  }
+  return aDist;
+}
+
+//=======================================================================
+//function : Branch rejection
+//purpose  : Defines the rules for node rejection by bounding box
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::RejectNode (const BVH_Vec3d& theCornerMin,
+                                                            const BVH_Vec3d& theCornerMax,
+                                                            Standard_Real& theMetric) const
+{
+  theMetric = sqrt (BVH_Tools<Standard_Real, 3>::PointBoxSquareDistance (myObject,
+                                                                         theCornerMin,
+                                                                         theCornerMax));
+
+  Standard_Real aMaxMetric = sqrt (pointBoxSquareMaxDistance (myObject,
+                                                              theCornerMin,
+                                                              theCornerMax));
+
+  return theMetric > myDistance || aMaxMetric < myProxDist;
+}
+
+//=======================================================================
+//function : Leaf acceptance
+//purpose  : Defines the rules for leaf acceptance
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::Accept (const Standard_Integer theTrgIdx,
+                                                        const Standard_Real&)
+{
+  BVH_Vec3d aTrgVert1;
+  BVH_Vec3d aTrgVert2;
+  BVH_Vec3d aTrgVert3;
+
+  BVH_PrjState aBVH_PrjState;
+  Standard_Integer aNumberOfFirstNode = -1;
+  Standard_Integer aNumberOfLastNode = -1;
+
+  mySet2->GetVertices (theTrgIdx, aTrgVert1, aTrgVert2, aTrgVert3);
+
+  BVH_Vec3d aNearestPnt = BVH_Tools<Standard_Real, 3>::PointTriangleProjection (myObject,
+                                                                                aTrgVert1, aTrgVert2, aTrgVert3,
+                                                                                &aBVH_PrjState,
+                                                                                &aNumberOfFirstNode, &aNumberOfLastNode);
+
+  PrjState aPrjState (theTrgIdx, aBVH_PrjState, aNumberOfFirstNode, aNumberOfLastNode);
+  BVH_Vec3d aDirect = myObject - aNearestPnt;
+  Standard_Real aSqDistance = aDirect.Dot(aDirect);
+
+  if (aSqDistance > Precision::SquareConfusion()) // point belongs to triangle
+  {
+    const BVH_Vec3d aAB = aTrgVert2 - aTrgVert1;
+
+    BVH_Vec3d aNorm;
+    if (aTrgVert2.IsEqual (aTrgVert3)) // is this degenerate triangle (= segment)
+    {
+      const BVH_Vec3d aAP = myObject - aTrgVert1;
+      aNorm = BVH_Vec3d::Cross (BVH_Vec3d::Cross (aAP, aAB), aAB);
+    }
+    else
+    {
+      const BVH_Vec3d aAC = aTrgVert3 - aTrgVert1;
+      aNorm = BVH_Vec3d::Cross (aAB, aAC);
+    }
+
+    Standard_Real aNormSqLen = aNorm.Dot (aNorm);
+
+    // check if the distance is under perpendicular
+    const BVH_Vec3d aCrossCross = BVH_Vec3d::Cross (aDirect, aNorm);
+    Standard_Real aCrossCrossSqLen = aCrossCross.Dot (aCrossCross);
+    if (aCrossCrossSqLen > Precision::SquareConfusion() * aSqDistance * aNormSqLen)
+    {
+      // the distance is not under perpendicular
+      if (myMinDistance - sqrt (aSqDistance) > Precision::Confusion())
+      {
+        myMinDistance = sqrt (aSqDistance);
+        myMinDistPoint = aNearestPnt;
+        myMinPrjState = aPrjState;
+      }
+
+      return Standard_False;
+    }
+  }
+
+  // the distance is under perpendicular
+  if (myDistance - sqrt (aSqDistance) > Precision::Confusion())
+  {
+    myDistance = sqrt (aSqDistance);
+    myExtremaPoint = aNearestPnt;
+    myExtPrjState = aPrjState;
+
+    return Standard_True;
+  }
+
+  return Standard_False;
+}
+
+//=======================================================================
+//function : ComputeDistance
+//purpose  : Computes the distance between object and BVH tree
+//=======================================================================
+Standard_Real BRepExtrema_ProximityDistTool::ComputeDistance()
+{
+  myIsDone = this->Select() > 0;
+
+  if (!myIsDone)
+  {
+    if (myMinDistance < std::numeric_limits<Standard_Real>::max())
+    {
+      myExtremaPoint = myMinDistPoint;
+      myExtPrjState = myMinPrjState;
+      myIsDone = true;
+    }
+
+    myDistance = myMinDistance;
+  }
+
+  return myDistance;
+}
+
+//=======================================================================
+//function : IsNodeOnBorder
+//purpose  : Returns true if the node is on the boarder
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::IsNodeOnBorder (const Standard_Integer theNodeIdx,
+                                                                const Handle(Poly_Triangulation)& theTr)
+{
+  Poly_Connect aPolyConnect (theTr);
+
+  Standard_Integer aContTrg; //index of triangle containing exploring node
+  for (aPolyConnect.Initialize (theNodeIdx); aPolyConnect.More(); aPolyConnect.Next())
+  {
+    aContTrg = aPolyConnect.Value();
+
+    Standard_Integer aContTrgNodes[3];
+    theTr->Triangle (aContTrg).Get (aContTrgNodes[0], aContTrgNodes[1], aContTrgNodes[2]); //indices of nodes of the triangle
+
+    Standard_Integer aAdjTrg[3];
+    aPolyConnect.Triangles (aContTrg, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
+  
+    for (Standard_Integer j = 0; j < 3; j++)
+    {
+      Standard_Integer k = (j + 1) % 3;
+      if (aAdjTrg[j] == 0) //free segment of triangle
+      {
+        //aContTrgNodes[j], aContTrgNodes[k] are ends of free segment and it is a part of border
+        if (aContTrgNodes[j] == theNodeIdx || aContTrgNodes[k] == theNodeIdx)
+        {
+          return Standard_True;
+        }
+      }
+    }
+  }
+
+  return Standard_False;
+}
+
+//=======================================================================
+//function : IsEdgeOnBorder
+//purpose  : Returns true if the edge is on the boarder
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::IsEdgeOnBorder (const Standard_Integer theTrgIdx,
+                                                                const Standard_Integer theFirstEdgeNodeIdx,
+                                                                const Standard_Integer theSecondEdgeNodeIdx,
+                                                                const Handle(Poly_Triangulation)& theTr)
+{
+  Poly_Connect aPolyConnect (theTr);
+
+  Standard_Integer aAdjTrg[3];
+  aPolyConnect.Triangles (theTrgIdx, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
+
+  for (Standard_Integer j = 0; j < 3; j++)
+  {
+    Standard_Integer k = (j + 1) % 3;
+    if (aAdjTrg[j] == 0) //free segment of triangle
+    {
+      //are ends of free segment and it is a part of border
+      if (j == theFirstEdgeNodeIdx &&
+          k == theSecondEdgeNodeIdx)
+      {
+        return Standard_True;
+      }
+    }
+  }
+
+  return Standard_False;
+}
+
+//=======================================================================
+//function : defineStatusProxPnt1
+//purpose  : Defines the status of proximity point from 1st BVH
+//=======================================================================
+void BRepExtrema_ProximityDistTool::defineStatusProxPnt1()
+{
+  if (myIsProxVtx1FromAddSet)
+  {
+    myPntStatus1 = myAddStatus1[myProxVtxIdx1];
+    return;
+  }
+
+  Standard_Integer aFaceID1 = mySet1->GetShapeIDOfVtx (myProxVtxIdx1);
+
+  if (myShapeList1 (aFaceID1).ShapeType() == TopAbs_EDGE)
+  {
+    const BVH_Array3d& aVertices1 = mySet1->GetVertices();
+    Standard_Integer aVtxSize = (Standard_Integer)aVertices1.size();
+    Standard_Integer aLastIdx = aVtxSize - 1;
+
+    if ((aVertices1[0] - aVertices1[aLastIdx]).Modulus() < Precision::Confusion()) // if closed
+    {
+      myPntStatus1 = ProxPnt_Status_MIDDLE;
+      return;
+    }
+
+    if (myProxVtxIdx1 == 0 || myProxVtxIdx1 == aLastIdx)
+    {
+      myPntStatus1 = ProxPnt_Status_BORDER;
+    }
+    else
+    {
+      myPntStatus1 = ProxPnt_Status_MIDDLE;
+    }
+  }
+  else if (myShapeList1 (aFaceID1).ShapeType() == TopAbs_FACE)
+  {
+    Standard_Integer aNodeIdx = mySet1->GetVtxIdxInShape (myProxVtxIdx1) + 1;
+
+    TopLoc_Location aLocation;
+    const TopoDS_Face& aF = TopoDS::Face (myShapeList1 (aFaceID1));
+    Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
+
+    if (IsNodeOnBorder (aNodeIdx, aTr))
+    {
+      myPntStatus1 = ProxPnt_Status_BORDER;
+    }
+    else
+    {
+      myPntStatus1 = ProxPnt_Status_MIDDLE;
+    }
+  }
+}
+
+//=======================================================================
+//function : defineStatusProxPnt2
+//purpose  : Defines the status of proximity point from 2nd BVH
+//=======================================================================
+void BRepExtrema_ProximityDistTool::defineStatusProxPnt2()
+{
+  Standard_Integer aTrgIdx = myProxPrjState.GetTrgIdx();
+  Standard_Integer aFaceID2 = mySet2->GetFaceID (aTrgIdx);
+
+  if (myShapeList2 (aFaceID2).ShapeType() == TopAbs_EDGE)
+  {
+    if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_INNER)
+    {
+      return;
+    }
+    else
+    {
+      const BVH_Array3d& aVertices2 = mySet2->GetVertices();
+      Standard_Integer aVtxSize = (Standard_Integer)aVertices2.size();
+      Standard_Integer aLastIdx = aVtxSize - 1;
+
+      if ((aVertices2[0] - aVertices2[aLastIdx]).Modulus() < Precision::Confusion()) // if closed
+      {
+        myPntStatus2 = ProxPnt_Status_MIDDLE;
+        return;
+      }
+
+      NCollection_Array1<Standard_Integer> aVtxIndicesOfTrg;
+      mySet2->GetVtxIndices (aTrgIdx, aVtxIndicesOfTrg);
+
+      Standard_Integer aFirstNodeNum = myProxPrjState.GetNumberOfFirstNode();
+      Standard_Integer aFirstVtxIdx = aVtxIndicesOfTrg[aFirstNodeNum];
+
+      if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_VERTEX)
+      {
+        if (aFirstVtxIdx == 0 || aFirstVtxIdx == aLastIdx)
+        {
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
+        }
+      }
+      else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
+      {
+        Standard_Integer aLastNodeNum = myProxPrjState.GetNumberOfLastNode();
+        Standard_Integer aLastVtxIdx = aVtxIndicesOfTrg[aLastNodeNum];
+
+        // it could be border only in case projection is on a degenerated edge
+        if (aFirstVtxIdx == aLastVtxIdx && (aFirstVtxIdx == 0 || aFirstVtxIdx == aLastIdx))
+        {
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
+        }
+      }
+    }
+  }
+  else if (myShapeList2 (aFaceID2).ShapeType() == TopAbs_FACE)
+  {
+    if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_INNER)
+    {
+      myPntStatus2 = ProxPnt_Status_MIDDLE;
+    }
+    else
+    {
+      TopLoc_Location aLocation;
+      const TopoDS_Face& aF = TopoDS::Face (myShapeList2 (aFaceID2));
+      Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
+
+      NCollection_Array1<Standard_Integer> aVtxIndicesOfTrg;
+      mySet2->GetVtxIndices (aTrgIdx, aVtxIndicesOfTrg);
+
+      if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_VERTEX)
+      {
+        Standard_Integer aNodeNum = myProxPrjState.GetNumberOfFirstNode();
+        Standard_Integer aNodeIdx = mySet2->GetVtxIdxInShape (aVtxIndicesOfTrg[aNodeNum]) + 1;
+
+        if (IsNodeOnBorder (aNodeIdx, aTr))
+        {
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
+        }
+      }
+      else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
+      {
+        Standard_Integer aTrgIdxInShape = mySet2->GetTrgIdxInShape (aTrgIdx) + 1;
+
+        if (IsEdgeOnBorder (aTrgIdxInShape,
+                            myProxPrjState.GetNumberOfFirstNode(),
+                            myProxPrjState.GetNumberOfLastNode(),
+                            aTr))
+        {
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
+        }
+      } //else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
+    }
+  } //else if (myShapeList1 (aFaceID1).ShapeType() == TopAbs_FACE)
+}
+
+//=======================================================================
+//function : DefineStatusProxPnt
+//purpose  : Defines the status of proximity points
+//=======================================================================
+void BRepExtrema_ProximityDistTool::DefineStatusProxPnt()
+{
+  // define the status of proximity point from 1st BVH
+  defineStatusProxPnt1();
+
+  // define the status of proximity point from 2nd BVH
+  defineStatusProxPnt2();
+}

src/BRepExtrema/BRepExtrema_ProximityDistTool.hxx

@@ -0,0 +1,230 @@
+// Created on: 2022-08-08
+// Created by: Kseniya NOSULKO
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _BRepExtrema_ProximityDistTool_HeaderFile
+#define _BRepExtrema_ProximityDistTool_HeaderFile
+
+#include <BRepExtrema_ElementFilter.hxx>
+#include <BRepExtrema_MapOfIntegerPackedMapOfInteger.hxx>
+#include <BRepExtrema_TriangleSet.hxx>
+#include <BVH_Distance.hxx>
+#include <BVH_Tools.hxx>
+#include <Poly_Triangulation.hxx>
+
+//! Tool class for computation the proximity distance from first 
+//! primitive set to second one that is the maximal from minimum 
+//! perpendicular distances. If no perpendicular distance is found, the 
+//! minimum distance will be returned.
+//! This tool is not intended to be used independently, and is integrated
+//! in other classes, implementing algorithms based on shape tessellation
+//! (BRepExtrema_ProximityValueTool).
+//! 
+//! Please note that algorithm results are approximate and depend greatly
+//! on the quality of input tessellation(s).
+class BRepExtrema_ProximityDistTool : public BVH_Distance <Standard_Real, 3, BVH_Vec3d, 
+                                                           BRepExtrema_TriangleSet>
+{
+public:
+
+  typedef typename BVH_Tools<Standard_Real, 3>::BVH_PrjStateInTriangle BVH_PrjState;
+
+  enum ProxPnt_Status
+  {
+    ProxPnt_Status_BORDER,
+    ProxPnt_Status_MIDDLE,
+    ProxPnt_Status_UNKNOWN
+  };
+
+public:
+
+  //! Struct with information about projection point state from 2nd BVH,
+  //! providing proximity point of 2nd shape
+  struct PrjState
+  {
+    PrjState()
+    : myTrgIdx (0),
+      myPrjState (BVH_PrjState::BVH_PrjStateInTriangle_INNER),
+      myNumberOfFirstNode (0),
+      myNumberOfLastNode (0)
+    {}
+
+    PrjState (const Standard_Integer theTrgIdx,
+              const BVH_PrjState     thePrjState,
+              const Standard_Integer theNumberOfFirstNode,
+              const Standard_Integer theNumberOfLastNode)
+    : myTrgIdx (theTrgIdx),
+      myPrjState (thePrjState),
+      myNumberOfFirstNode (theNumberOfFirstNode),
+      myNumberOfLastNode (theNumberOfLastNode)
+    {}
+
+    Standard_Integer GetTrgIdx() const { return myTrgIdx; }
+
+    BVH_PrjState GetPrjState() const { return myPrjState; }
+
+    Standard_Integer GetNumberOfFirstNode() const { return myNumberOfFirstNode; }
+
+    Standard_Integer GetNumberOfLastNode() const { return myNumberOfLastNode; }
+
+  private:
+
+    Standard_Integer myTrgIdx; //!< Index of triangle on which the projection is located
+    BVH_PrjState myPrjState; //!< Position of a projection on the triangle (vertex, edge, inner)
+    Standard_Integer myNumberOfFirstNode; //!< The 1st vtx of the triangle edge on which the projection is located
+    Standard_Integer myNumberOfLastNode; //!< The 2nd vtx of the triangle edge on which the projection is located
+  };
+
+public:
+
+  //! Creates new unitialized tool.
+  Standard_EXPORT BRepExtrema_ProximityDistTool();
+
+  //! Creates new tool for the given element sets.
+  Standard_EXPORT BRepExtrema_ProximityDistTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                 const Standard_Integer theNbSamples1,
+                                                 const BVH_Array3d& theAddVertices1,
+                                                 const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
+                                                 const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                 const BRepExtrema_ShapeList& theShapeList1,
+                                                 const BRepExtrema_ShapeList& theShapeList2);
+
+public:
+
+  //! Loads the given element sets into the tool.
+  Standard_EXPORT void LoadTriangleSets (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                         const Handle(BRepExtrema_TriangleSet)& theSet2);
+
+  //! Loads the given list of subshapes into the tool.
+  Standard_EXPORT void LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
+                                       const BRepExtrema_ShapeList& theShapeList2);
+
+  //! Loads given additional vertices and their statuses.
+  void LoadAdditionalPointsFirstSet (const BVH_Array3d& theAddVertices1,
+                                     const NCollection_Vector<ProxPnt_Status>& theAddStatus1);
+
+  //! Performs searching of the proximity distance.
+  Standard_EXPORT void Perform();
+
+public: //! @name Reject/Accept implementations
+
+  //! Defines the rules for node rejection by bounding box.
+  Standard_EXPORT virtual Standard_Boolean RejectNode (const BVH_Vec3d& theCornerMin,
+                                                       const BVH_Vec3d& theCornerMax,
+                                                       Standard_Real& theMetric) const Standard_OVERRIDE;
+
+  //! Defines the rules for leaf acceptance.
+  Standard_EXPORT virtual Standard_Boolean Accept (const Standard_Integer theSgmIdx,
+                                                   const Standard_Real&) Standard_OVERRIDE;
+
+public:
+
+  //! Returns true if the node is on the boarder.
+  Standard_EXPORT static Standard_Boolean IsNodeOnBorder (const Standard_Integer theNodeIdx,
+                                                          const Handle (Poly_Triangulation)& theTr);
+
+  //! Returns true if the edge is on the boarder.
+  Standard_EXPORT static Standard_Boolean IsEdgeOnBorder (const Standard_Integer theTrgIdx,
+                                                          const Standard_Integer theFirstEdgeNodeIdx,
+                                                          const Standard_Integer theSecondEdgeNodeIdx,
+                                                          const Handle (Poly_Triangulation)& theTr);
+
+public:
+
+  //! Returns points on triangles sets, which provide the proximity distance.
+  void ProximityPoints (BVH_Vec3d& thePoint1, BVH_Vec3d& thePoint2) const
+  {
+    thePoint1 = myPnt1;
+    thePoint2 = myPnt2;
+  }
+
+  //! Returns status of points on triangles sets, which provide the proximity distance.
+  void ProximityPointsStatus (ProxPnt_Status& thePointStatus1, ProxPnt_Status& thePointStatus2) const
+  {
+    thePointStatus1 = myPntStatus1;
+    thePointStatus2 = myPntStatus2;
+  }
+
+  //! Returns the computed distance
+  Standard_Real ProximityDistance() const { return myProxDist; }
+
+protected:
+
+  //! Computes the distance between object and BVH tree.
+  Standard_EXPORT Standard_Real ComputeDistance();
+
+  //! Defines the status of proximity points.
+  Standard_EXPORT void DefineStatusProxPnt();
+
+private:
+
+  //! Goes throught vertices from the 1st set.
+  void goThroughtSet1 (const BVH_Array3d& aVertices1,
+                       const Standard_Boolean theIsAdditionalSet);
+
+  //! Defines the status of proximity point from 1st BVH.
+  void defineStatusProxPnt1();
+
+  //! Defines the status of proximity point from 2nd BVH.
+  void defineStatusProxPnt2();
+
+protected:
+
+  Standard_Real myMinDistance; //!< Minimal distance from point to BVH, could be not equal to myDistance
+  BVH_Vec3d myMinDistPoint; //!< Point on BVH providing the minimal distance
+
+  BVH_Vec3d myExtremaPoint; //!< Point on BVH providing the extrema
+
+  Standard_Real myProxDist; //!< Proximity distance
+
+  //! Proximity points
+  BVH_Vec3d myPnt1, myPnt2;
+
+  //! Proximity points' status
+  ProxPnt_Status myPntStatus1, myPntStatus2;
+
+private:
+
+  //! Set of all mesh elements (triangles) of the 1st shape.
+  Handle(BRepExtrema_TriangleSet) mySet1;
+  //! Set of all mesh elements (triangles) of the 2nd shape.
+  Handle(BRepExtrema_TriangleSet) mySet2;
+
+  //! List of subshapes of the 1st shape.
+  BRepExtrema_ShapeList myShapeList1;
+  //! List of subshapes of the 2nd shape.
+  BRepExtrema_ShapeList myShapeList2;
+
+  Standard_Integer myNbSamples1; //!< Number of samples points on the first shape
+
+  //! Is vertex corresponding to proximity point of 1st shape from additional set
+  Standard_Integer myIsProxVtx1FromAddSet;
+  BVH_Array3d myAddVertices1; //!< Additional vertices on the 1st shape
+  NCollection_Vector<ProxPnt_Status> myAddStatus1; //!< Status of additional vertices on the 1st shape
+
+  //! Vertex index from 1st BVH corresponding to proximity point of 1st shape
+  Standard_Integer myProxVtxIdx1;
+
+  //! Information of projection point state from 2nd BVH providing proximity point of 2nd shape
+  PrjState myProxPrjState;
+
+  //! Information of projection point state from 2nd BVH providing the extrema
+  PrjState myExtPrjState;
+
+  //! Information of projection point state from 2nd BVH providing the minimal distance
+  PrjState myMinPrjState;
+
+};
+
+#endif // _BRepExtrema_ProximityDistTool_HeaderFile

src/BRepExtrema/BRepExtrema_ProximityValueTool.cxx

@@ -0,0 +1,561 @@
+// Created on: 2022-08-08
+// Created by: Kseniya NOSULKO
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <BRepExtrema_ProximityValueTool.hxx>
+#include <BRepExtrema_ProximityDistTool.hxx>
+
+#include <BRep_Tool.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <BRepGProp.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <GCPnts_QuasiUniformAbscissa.hxx>
+#include <GProp_GProps.hxx> 
+#include <Poly_Connect.hxx>
+#include <TopoDS.hxx>
+
+//=======================================================================
+//function : BRepExtrema_ProximityValueTool
+//purpose  : Creates new unitialized proximity tool
+//=======================================================================
+BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool()
+: myIsRefinementRequired1 (Standard_False),
+  myIsRefinementRequired2 (Standard_False),
+  myDistance (std::numeric_limits<Standard_Real>::max()),
+  myIsDone (Standard_False),
+  myNbSamples1(0),
+  myNbSamples2(0)
+{
+  // Should be initialized later
+  myIsInitS1 = myIsInitS2 = Standard_False;
+}
+
+//=======================================================================
+//function : BRepExtrema_ProximityValueTool
+//purpose  : Creates new proximity tool for the given element sets
+//=======================================================================
+BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                                const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                                const BRepExtrema_ShapeList& theShapeList1,
+                                                                const BRepExtrema_ShapeList& theShapeList2)
+: myIsRefinementRequired1 (Standard_False),
+  myIsRefinementRequired2 (Standard_False),
+  myDistance (std::numeric_limits<Standard_Real>::max()),
+  myIsDone (Standard_False),
+  myNbSamples1 (0),
+  myNbSamples2 (0)
+{
+  LoadShapeLists (theShapeList1, theShapeList2);
+  LoadTriangleSets (theSet1, theSet2);
+}
+
+//=======================================================================
+//function : LoadTriangleSets
+//purpose  : Loads the given element sets into the proximity tool
+//=======================================================================
+void BRepExtrema_ProximityValueTool::LoadTriangleSets (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                       const Handle(BRepExtrema_TriangleSet)& theSet2)
+{
+  mySet1 = theSet1;
+  mySet2 = theSet2;
+
+  MarkDirty();
+}
+
+//=======================================================================
+//function : calcEdgeRefinementStep
+//purpose  : Calculates the edge refinement step
+//=======================================================================
+static Standard_Real calcEdgeRefinementStep (const TopoDS_Edge& theEdge,
+                                             const Standard_Integer theNbNodes)
+{
+  if (theNbNodes < 2)
+    return 0;
+
+  BRepAdaptor_Curve aBAC (theEdge);
+  Standard_Real aLen = GCPnts_AbscissaPoint::Length (aBAC);
+  return aLen / (Standard_Real)(theNbNodes - 1);
+}
+
+//=======================================================================
+//function : calcFaceRefinementStep
+//purpose  : Calculates the face refinement step as an approximate square
+// (Shape area / number triangles) * 2
+//=======================================================================
+static Standard_Real calcFaceRefinementStep (const TopoDS_Face& theFace,
+                                             const Standard_Integer theNbTrg)
+{
+  if (theNbTrg < 1)
+    return 0;
+
+  GProp_GProps props;
+  BRepGProp::SurfaceProperties (theFace, props);
+  Standard_Real aArea = props.Mass();
+  return 2 * (aArea / (Standard_Real)theNbTrg);
+}
+
+//=======================================================================
+//function : getInfoForRefinement
+//purpose  : Gets shape data for further refinement
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getInfoForRefinement (const TopoDS_Shape& theShape,
+                                                                       TopAbs_ShapeEnum& theShapeType,
+                                                                       Standard_Integer& theNbNodes,
+                                                                       Standard_Real& theStep)
+{
+  if (theShape.ShapeType() == TopAbs_FACE)
+  {
+    theShapeType = TopAbs_FACE;
+    TopoDS_Face aF = TopoDS::Face (theShape);
+
+    TopLoc_Location aLocation;
+    Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aF, aLocation);
+
+    if (aTriangulation.IsNull())
+    {
+      return Standard_False;
+    }
+
+    theNbNodes = aTriangulation->NbNodes();
+    Standard_Integer aNbTrg = aTriangulation->NbTriangles();
+    theStep = calcFaceRefinementStep (aF, aNbTrg);
+  }
+  else if (theShape.ShapeType() == TopAbs_EDGE)
+  {
+    theShapeType = TopAbs_EDGE;
+    TopoDS_Edge aE = TopoDS::Edge (theShape);
+
+    TopLoc_Location aLocation;
+    Handle(Poly_Polygon3D) aPolygon = BRep_Tool::Polygon3D (aE, aLocation);
+
+    if (aPolygon.IsNull())
+    {
+      return Standard_False;
+    }
+
+    theNbNodes = aPolygon->NbNodes();
+    theStep = calcEdgeRefinementStep (aE, theNbNodes);
+  }
+  else
+  {
+    return Standard_False;
+  }
+
+  if (theStep < Precision::Confusion())
+  {
+    return Standard_False;
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : LoadTriangleSets
+//purpose  : Loads the given list of subshapes into the proximity tool
+//=======================================================================
+void BRepExtrema_ProximityValueTool::LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
+                                                     const BRepExtrema_ShapeList& theShapeList2)
+{
+  myShapeList1 = theShapeList1;
+  myShapeList2 = theShapeList2;
+
+  myShape1 = theShapeList1 (0);
+  myIsInitS1 = getInfoForRefinement (myShape1, myShapeType1, myNbNodes1, myStep1);
+
+  myShape2 = theShapeList2 (0);
+  myIsInitS2 = getInfoForRefinement (myShape2, myShapeType2, myNbNodes2, myStep2);
+
+  MarkDirty();
+}
+
+//=======================================================================
+//function : SetNbSamplePoints
+//purpose  : Sets number of sample points used for proximity calculation for each shape
+//=======================================================================
+void BRepExtrema_ProximityValueTool::SetNbSamplePoints(const Standard_Integer theSamples1,
+                                                       const Standard_Integer theSamples2)
+{
+  myNbSamples1 = theSamples1;
+  myNbSamples2 = theSamples2;
+
+  MarkDirty();
+}
+
+//=======================================================================
+//function : computeProximityValue
+//purpose  : Returns the computed proximity value from first BVH to another one
+//=======================================================================
+Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                                    const Standard_Integer theNbSamples1,
+                                                                    const BVH_Array3d& theAddVertices1,
+                                                                    const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
+                                                                    const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                                    const BRepExtrema_ShapeList& theShapeList1,
+                                                                    const BRepExtrema_ShapeList& theShapeList2,
+                                                                    BVH_Vec3d& thePoint1,
+                                                                    BVH_Vec3d& thePoint2,
+                                                                    ProxPnt_Status& thePointStatus1,
+                                                                    ProxPnt_Status& thePointStatus2) const
+{
+  BRepExtrema_ProximityDistTool aProxDistTool (theSet1, theNbSamples1, theAddVertices1, theAddStatus1,
+                                               theSet2, theShapeList1, theShapeList2);
+  aProxDistTool.Perform();
+
+  if (!aProxDistTool.IsDone())
+    return -1.;
+
+  aProxDistTool.ProximityPoints (thePoint1, thePoint2);
+  aProxDistTool.ProximityPointsStatus (thePointStatus1, thePointStatus2);
+
+  return aProxDistTool.ProximityDistance();
+}
+
+//=======================================================================
+//function : getEdgeAdditionalVertices
+//purpose  : Gets additional vertices and their statuses on the edge with the input step
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getEdgeAdditionalVertices (
+  const TopoDS_Edge& theEdge,
+  const Standard_Real theStep,
+  BVH_Array3d& theAddVertices,
+  NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  BRepAdaptor_Curve aBAC (theEdge);
+  
+  if (!aBAC.Is3DCurve() || theStep < Precision::Confusion())
+  {
+    return Standard_False;
+  }
+
+  Standard_Real aLen = GCPnts_AbscissaPoint::Length (aBAC);
+  Standard_Integer aNbSamplePoints = (Standard_Integer) (aLen / theStep) + 1;
+
+  GCPnts_QuasiUniformAbscissa aGCPnts (aBAC, Max (3, aNbSamplePoints));
+
+  if (!aGCPnts.IsDone())
+    return Standard_False;
+
+  Standard_Integer aNbNodes = aGCPnts.NbPoints();
+  for (Standard_Integer aVertIdx = 2; aVertIdx < aNbNodes; ++aVertIdx) //don't add extreme points
+  {
+    Standard_Real aPar = aGCPnts.Parameter (aVertIdx);
+    gp_Pnt aP = aBAC.Value (aPar);
+
+    theAddVertices.push_back (BVH_Vec3d (aP.X(), aP.Y(), aP.Z()));
+    theAddStatuses.Append (ProxPnt_Status::ProxPnt_Status_MIDDLE);
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : doRecurTrgSplit
+//purpose  : Splits the triangle into two ones recursively, halving the longest side
+//           untill the area of ​​the current triangle > input step
+//! @param theTrg points of the triangle to be splitted
+//! @param theEdgesStatus status of triangle edges - on the border or middle of the face
+//! @param theTol telerance used in search of coincidence points
+//! @param theStep minimum area of ​​the resulting triangle
+//! @param theAddVertices vertices obtained halving sides
+//! @param theAddStatuses status of obtained vertices - on the border or middle of the face,
+//! from triangulation of which the input triangle is
+//=======================================================================
+void BRepExtrema_ProximityValueTool::doRecurTrgSplit (const gp_Pnt (&theTrg)[3],
+                                                      const ProxPnt_Status (&theEdgesStatus)[3],
+                                                      const Standard_Real theTol,
+                                                      const Standard_Real theStep,
+                                                      BVH_Array3d& theAddVertices,
+                                                      NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  gp_XYZ aTrgSide1 = theTrg[1].Coord() - theTrg[0].Coord();
+  gp_XYZ aTrgSide2 = theTrg[2].Coord() - theTrg[0].Coord();
+  Standard_Real aTrgArea = 0.5 * aTrgSide1.CrossMagnitude (aTrgSide2);
+
+  if (aTrgArea - theStep < Precision::SquareConfusion())
+    return;
+
+  Standard_Real aD[3] { theTrg[0].Distance (theTrg[1]),
+                        theTrg[1].Distance (theTrg[2]),
+                        theTrg[2].Distance (theTrg[0]) };
+  Standard_Integer aBisectedEdgeIdx = aD[0] > aD[1] ? (aD[0] > aD[2] ? 0 : 2) : (aD[1] > aD[2] ? 1 : 2);
+  gp_Pnt aCenterOfMaxSide (theTrg[aBisectedEdgeIdx].Coord());
+  aCenterOfMaxSide.BaryCenter (0.5, theTrg[(aBisectedEdgeIdx + 1) % 3], 0.5);
+
+  Bnd_Box aBox;
+  aBox.Add (aCenterOfMaxSide);
+  aBox.Enlarge (theTol);
+  myInspector.SetCurrent (aCenterOfMaxSide.Coord());
+  myCells.Inspect (aBox.CornerMin().XYZ(), aBox.CornerMax().XYZ(), myInspector);
+  
+  if (myInspector.IsNeedAdd()) //is point aCenterOfMaxSide unique
+  {
+    BVH_Vec3d aBisectingPnt (aCenterOfMaxSide.X(), aCenterOfMaxSide.Y(), aCenterOfMaxSide.Z());
+    theAddVertices.push_back (aBisectingPnt);
+    theAddStatuses.Append (theEdgesStatus[aBisectedEdgeIdx]);
+    myInspector.Add (aCenterOfMaxSide.Coord());
+    myCells.Add (static_cast<BRepExtrema_VertexInspector::Target>(theAddVertices.size()),
+                 aBox.CornerMin().XYZ(), aBox.CornerMax().XYZ());
+  }
+
+  gp_Pnt aTrg1[3] = { theTrg[0], theTrg[1], theTrg[2] };
+  gp_Pnt aTrg2[3] = { theTrg[0], theTrg[1], theTrg[2] };
+  ProxPnt_Status aEdgesStatus1[3] = { theEdgesStatus[0], theEdgesStatus[1], theEdgesStatus[2] };
+  ProxPnt_Status aEdgesStatus2[3] = { theEdgesStatus[0], theEdgesStatus[1], theEdgesStatus[2] };
+  switch (aBisectedEdgeIdx)
+  {
+  case 0:
+    aTrg1[0] = aTrg2[1] = aCenterOfMaxSide;
+    aEdgesStatus1[2] = aEdgesStatus2[1] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  case 1:
+    aTrg1[1] = aTrg2[2] = aCenterOfMaxSide;
+    aEdgesStatus1[0] = aEdgesStatus2[2] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  case 2:
+    aTrg1[2] = aTrg2[0] = aCenterOfMaxSide;
+    aEdgesStatus1[1] = aEdgesStatus2[0] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  }
+
+  doRecurTrgSplit (aTrg1, aEdgesStatus1, theTol, theStep, theAddVertices, theAddStatuses);
+  doRecurTrgSplit (aTrg2, aEdgesStatus2, theTol, theStep, theAddVertices, theAddStatuses);
+}
+
+static Standard_Real getModelRange (const TopLoc_Location& theLocation,
+                                    const Handle(Poly_Triangulation)& theTr)
+{
+  Bnd_Box aBox;
+  theTr->MinMax (aBox, theLocation.Transformation());
+  Standard_Real aXm = 0.0, aYm = 0.0, aZm = 0.0, aXM = 0.0, aYM = 0.0, aZM = 0.0;
+  aBox.Get (aXm, aYm, aZm, aXM, aYM, aZM);
+  Standard_Real aRange = aXM - aXm;
+  aRange = Max (aRange, aYM - aYm);
+  aRange = Max (aRange, aZM - aZm);
+
+  return aRange;
+}
+
+static void getNodesOfTrg (const Standard_Integer theTriIdx,
+                           const TopLoc_Location& theLocation,
+                           const Handle (Poly_Triangulation)& theTr,
+                           gp_Pnt (&theTrg)[3])
+{
+  Standard_Integer aVtxIdx1;
+  Standard_Integer aVtxIdx2;
+  Standard_Integer aVtxIdx3;
+
+  theTr->Triangle (theTriIdx).Get (aVtxIdx1, aVtxIdx2, aVtxIdx3);
+
+  gp_Pnt aVtx1 = theTr->Node (aVtxIdx1);
+  aVtx1.Transform (theLocation);
+  theTrg[0] = aVtx1;
+
+  gp_Pnt aVtx2 = theTr->Node (aVtxIdx2);
+  aVtx2.Transform (theLocation);
+  theTrg[1] = aVtx2;
+
+  gp_Pnt aVtx3 = theTr->Node (aVtxIdx3);
+  aVtx3.Transform (theLocation);
+  theTrg[2] = aVtx3;
+}
+
+// Gets status of triangle edges - on the border or middle of the face
+static void getEdgesStatus(const Standard_Integer theTriIdx,
+                           const Handle(Poly_Triangulation)& theTr,
+                           ProxPnt_Status (&theEdgesStatus1)[3])
+{
+  for (Standard_Integer j = 0; j < 3; j++)
+  {
+    Standard_Integer k = (j + 1) % 3;
+
+    if (BRepExtrema_ProximityDistTool::IsEdgeOnBorder (theTriIdx, j, k, theTr))
+    {
+      theEdgesStatus1[j] = ProxPnt_Status::ProxPnt_Status_BORDER;
+    }
+    else
+    {
+      theEdgesStatus1[j] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    }
+  }
+}
+
+//=======================================================================
+//function : getFaceAdditionalVertices
+//purpose  : Gets additional vertices and their statuses on the face with the input step (triangle square)
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getFaceAdditionalVertices (
+  const TopoDS_Face& theFace,
+  const Standard_Real theStep,
+  BVH_Array3d& theAddVertices,
+  NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  Standard_Real aTol = Precision::Confusion();
+
+  TopLoc_Location aLocation;
+  Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (theFace, aLocation);
+
+  if (aTr.IsNull())
+  {
+    return Standard_False;
+  }
+
+  myCells.Reset (Max (aTol, getModelRange (aLocation, aTr) / IntegerLast()));
+
+  for (Standard_Integer aTriIdx = 1; aTriIdx <= aTr->NbTriangles(); ++aTriIdx)
+  {
+    gp_Pnt aTrg[3];
+    ProxPnt_Status aEdgesStatus[3];
+    getNodesOfTrg (aTriIdx, aLocation, aTr, aTrg);
+    getEdgesStatus (aTriIdx, aTr, aEdgesStatus);
+    doRecurTrgSplit (aTrg, aEdgesStatus, aTol, theStep, theAddVertices, theAddStatuses);
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : getShapesVertices
+//purpose  : Gets additional vertices on shapes with refining a coarser one if it's needed
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getShapesAdditionalVertices()
+{
+  // estimate the density of meshes of shapes to add points to a coarcer one
+  // target steps for refinement
+  Standard_Real aStep1 = myStep1;
+  Standard_Real aStep2 = myStep2;
+
+  if ((myShapeType1 == TopAbs_EDGE) && (myShapeType2 == TopAbs_EDGE))
+  {
+    if (myNbSamples1 > myNbNodes1) // 1st edge needs refinement
+    {
+      aStep1 = calcEdgeRefinementStep (TopoDS::Edge (myShape1), myNbSamples1);
+      myIsRefinementRequired1 = Standard_True;
+    }
+
+    if (myNbSamples2 > myNbNodes2) // 2nd edge needs refinement
+    {
+      aStep2 = calcEdgeRefinementStep (TopoDS::Edge (myShape2), myNbSamples2);
+      myIsRefinementRequired2 = Standard_True;
+    }
+
+    if (aStep1 / aStep2 > 2.) // 1st edge needs refinement
+    {
+      myIsRefinementRequired1 = Standard_True;
+      aStep1 = aStep2;
+    }
+    else if (aStep2 / aStep1 > 2.) // 2nd edge needs refinement
+    {
+      myIsRefinementRequired2 = Standard_True;
+      aStep2 = aStep1;
+    }
+
+    if (myIsRefinementRequired1)
+    {
+      if (!getEdgeAdditionalVertices (TopoDS::Edge (myShape1), aStep1, myAddVertices1, myAddStatus1))
+      {
+        return Standard_False;
+      }
+    }
+
+    if (myIsRefinementRequired2)
+    {
+      if (!getEdgeAdditionalVertices (TopoDS::Edge (myShape2), aStep2, myAddVertices2, myAddStatus2))
+      {
+        return Standard_False;
+      }
+    }
+  }
+  else if ((myShapeType1 == TopAbs_FACE) && (myShapeType2 == TopAbs_FACE))
+  {
+    if (aStep1 / aStep2 > 2) // 1st face needs refinement
+    {
+      myIsRefinementRequired1 = Standard_True;
+      aStep1 = myStep2;
+    }
+    else if (aStep2 / aStep1 > 2.) // 2nd face needs refinement
+    {
+      myIsRefinementRequired2 = Standard_True;
+      aStep2 = myStep1;
+    }
+
+    if (myIsRefinementRequired1)
+    {
+      return getFaceAdditionalVertices (TopoDS::Face (myShape1), aStep1, myAddVertices1, myAddStatus1);
+    }
+
+    if (myIsRefinementRequired2)
+    {
+      return getFaceAdditionalVertices (TopoDS::Face (myShape2), aStep2, myAddVertices2, myAddStatus2);
+    }
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Perform
+//purpose  : Performs the computation of the proximity value
+//=======================================================================
+void BRepExtrema_ProximityValueTool::Perform (Standard_Real& theTolerance)
+{
+  if (!myIsInitS1 || !myIsInitS2 || (myShapeType1 != myShapeType2))
+    return;
+
+  // get vertices on shapes with refining a coarser mesh if it's needed
+  if (!getShapesAdditionalVertices())
+    return;
+
+  // max(min) dist from the 1st shape to the 2nd one
+  BVH_Vec3d aP1_1, aP1_2;
+  ProxPnt_Status aPointStatus1_1 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
+  ProxPnt_Status aPointStatus1_2 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
+
+  Standard_Real aProximityDist1 = computeProximityDist (mySet1, myNbSamples1, myAddVertices1, myAddStatus1,
+                                                        mySet2,
+                                                        myShapeList1, myShapeList2,
+                                                        aP1_1, aP1_2,
+                                                        aPointStatus1_1, aPointStatus1_2);
+
+  if (aProximityDist1 < 0.)
+    return;
+
+  myDistance = aProximityDist1;
+  myPnt1.SetCoord(aP1_1.x(), aP1_1.y(), aP1_1.z());
+  myPnt2.SetCoord(aP1_2.x(), aP1_2.y(), aP1_2.z());
+  myPntStatus1 = aPointStatus1_1;
+  myPntStatus2 = aPointStatus1_2;
+
+  myIsDone = Standard_True;
+  theTolerance = myDistance;
+}
+
+//=======================================================================
+//function : Inspect
+//purpose  : Used for selection and storage of coinciding nodes
+//=======================================================================
+NCollection_CellFilter_Action BRepExtrema_VertexInspector::Inspect (const Standard_Integer theTarget)
+{
+  myIsNeedAdd = Standard_True;
+
+  const gp_XYZ& aPnt = myPoints.Value (theTarget - 1);
+  Standard_Real aDx, aDy, aDz;
+  aDx = myCurrent.X() - aPnt.X();
+  aDy = myCurrent.Y() - aPnt.Y();
+  aDz = myCurrent.Z() - aPnt.Z();
+
+  if ((aDx * aDx <= myTol) && (aDy * aDy <= myTol) && (aDz * aDz <= myTol))
+    myIsNeedAdd = Standard_False;
+
+  return CellFilter_Keep;
+}

src/BRepExtrema/BRepExtrema_ProximityValueTool.hxx

@@ -0,0 +1,242 @@
+// Created on: 2022-08-08
+// Created by: Kseniya NOSULKO
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _BRepExtrema_ProximityValueTool_HeaderFile
+#define _BRepExtrema_ProximityValueTool_HeaderFile
+
+#include <BRepExtrema_ProximityDistTool.hxx>
+#include <BRepExtrema_TriangleSet.hxx>
+#include <NCollection_CellFilter.hxx>
+#include <Precision.hxx>
+
+typedef NCollection_Vector<gp_XYZ> VectorOfPoint;
+
+//! Class BRepExtrema_VertexInspector
+//!   derived from NCollection_CellFilter_InspectorXYZ
+//!   This class define the Inspector interface for CellFilter algorithm,
+//!   working with gp_XYZ points in 3d space.
+//!   Used in search of coincidence points with a certain tolerance.
+class BRepExtrema_VertexInspector : public NCollection_CellFilter_InspectorXYZ
+{
+public:
+  typedef Standard_Integer Target;
+
+  //! Constructor; remembers the tolerance
+  BRepExtrema_VertexInspector()
+  : myTol (Precision::SquareConfusion()),
+    myIsNeedAdd (Standard_True)
+  {}
+
+  //! Keep the points used for comparison
+  void Add (const gp_XYZ& thePnt)
+  {
+    myPoints.Append (thePnt);
+  }
+
+  //! Set tolerance for comparison of point coordinates
+  void SetTol (const Standard_Real theTol)
+  {
+    myTol = theTol;
+  }
+
+  //! Set current point to search for coincidence
+  void SetCurrent (const gp_XYZ& theCurPnt)
+  {
+    myCurrent = theCurPnt;
+    myIsNeedAdd = Standard_True;
+  }
+
+  Standard_Boolean IsNeedAdd()
+  {
+    return myIsNeedAdd;
+  }
+
+  //! Implementation of inspection method
+  Standard_EXPORT NCollection_CellFilter_Action Inspect (const Standard_Integer theTarget);
+
+private:
+  Standard_Real myTol;
+  Standard_Boolean myIsNeedAdd;
+  VectorOfPoint myPoints;
+  gp_XYZ myCurrent;
+};
+
+typedef NCollection_CellFilter<BRepExtrema_VertexInspector> BRepExtrema_CellFilter;
+typedef typename BRepExtrema_ProximityDistTool::ProxPnt_Status ProxPnt_Status;
+
+//! Tool class for computation of the proximity value from one BVH
+//! primitive set to another, solving max(min) problem.
+//! Handles only edge/edge or face/face cases.
+//! This tool is not intended to be used independently, and is integrated
+//! in other classes, implementing algorithms based on shape tessellation
+//! (BRepExtrema_ShapeProximity and BRepExtrema_SelfIntersection).
+//! 
+//! Please note that algorithm results are approximate and depend greatly
+//! on the quality of input tessellation(s).
+class BRepExtrema_ProximityValueTool
+{
+
+public:
+
+  //! Creates new unitialized proximity tool.
+  Standard_EXPORT BRepExtrema_ProximityValueTool();
+
+  //! Creates new proximity tool for the given element sets.
+  Standard_EXPORT BRepExtrema_ProximityValueTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                                  const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                                  const BRepExtrema_ShapeList& theShapeList1,
+                                                  const BRepExtrema_ShapeList& theShapeList2);
+
+public:
+
+  //! Loads the given element sets into the proximity tool.
+  Standard_EXPORT void LoadTriangleSets (const Handle (BRepExtrema_TriangleSet)& theSet1,
+                                         const Handle (BRepExtrema_TriangleSet)& theSet2);
+
+  //! Loads the given list of subshapes into the proximity tool.
+  Standard_EXPORT void LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
+                                       const BRepExtrema_ShapeList& theShapeList2);
+
+  //! Sets number of sample points used for proximity calculation for each shape.
+  //! If number is less or equal zero, all triangulation nodes are used.
+  Standard_EXPORT void SetNbSamplePoints (const Standard_Integer theSamples1 = 0,
+                                          const Standard_Integer theSamples2 = 0);
+
+  //! Performs the computation of the proximity value.
+  Standard_EXPORT void Perform (Standard_Real& theTolerance);
+
+  //! Is proximity test completed?
+  Standard_Boolean IsDone() const { return myIsDone; }
+
+  //! Marks test results as outdated.
+  void MarkDirty() { myIsDone = Standard_False; }
+
+  //! Returns the computed distance.
+  Standard_Real Distance() const { return myDistance; }
+
+  //! Returns points on triangles sets, which provide the proximity distance.
+  void ProximityPoints(gp_Pnt& thePoint1, gp_Pnt& thePoint2) const
+  {
+    thePoint1 = myPnt1;
+    thePoint2 = myPnt2;
+  }
+
+  //! Returns status of points on triangles sets, which provide the proximity distance.
+  void ProximityPointsStatus (ProxPnt_Status& thePointStatus1, ProxPnt_Status& thePointStatus2) const
+  {
+    thePointStatus1 = myPntStatus1;
+    thePointStatus2 = myPntStatus2;
+  }
+
+private:
+
+  //! Gets shape data for further refinement.
+  Standard_Boolean getInfoForRefinement (const TopoDS_Shape& theShapes,
+                                         TopAbs_ShapeEnum& theShapeType,
+                                         Standard_Integer& theNbNodes,
+                                         Standard_Real& theStep);
+
+  //! Returns the computed proximity value from first BVH to another one.
+  Standard_Real computeProximityDist (const Handle(BRepExtrema_TriangleSet)& theSet1,
+                                      const Standard_Integer theNbSamples1,
+                                      const BVH_Array3d& theAddVertices1,
+                                      const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
+                                      const Handle(BRepExtrema_TriangleSet)& theSet2,
+                                      const BRepExtrema_ShapeList& theShapeList1,
+                                      const BRepExtrema_ShapeList& theShapeList2,
+                                      BVH_Vec3d& thePoint1,
+                                      BVH_Vec3d& thePoint2,
+                                      ProxPnt_Status& thePointStatus1,
+                                      ProxPnt_Status& thePointStatus2) const;
+
+  //! Gets additional vertices on shapes with refining a coarser one if it's needed.
+  Standard_Boolean getShapesAdditionalVertices();
+
+  //! Gets additional vertices and their statuses on the edge with the input step.
+  Standard_Boolean getEdgeAdditionalVertices (const TopoDS_Edge& theEdge,
+                                              const Standard_Real theStep,
+                                              BVH_Array3d& theAddVertices,
+                                              NCollection_Vector<ProxPnt_Status>& theAddStatuses);
+
+  //! Gets additional vertices and their statuses on the face with the input step (triangle square).
+  Standard_Boolean getFaceAdditionalVertices (const TopoDS_Face& theFace,
+                                              const Standard_Real theStep,
+                                              BVH_Array3d& theAddVertices,
+                                              NCollection_Vector<ProxPnt_Status>& theAddStatuses);
+
+  //! Splits the triangle recursively, halving the longest side
+  //! to the area of ​​the current triangle > input step
+  void doRecurTrgSplit (const gp_Pnt (&theTrg)[3],
+                        const ProxPnt_Status (&theEdgesStatus)[3],
+                        const Standard_Real theTol,
+                        const Standard_Real theStep,
+                        BVH_Array3d& theAddVertices,
+                        NCollection_Vector<ProxPnt_Status>& theAddStatuses);
+private:
+
+  //! Set of all mesh primitives of the 1st shape.
+  Handle(BRepExtrema_TriangleSet) mySet1;
+  //! Set of all mesh primitives of the 2nd shape.
+  Handle(BRepExtrema_TriangleSet) mySet2;
+
+  //! List of subshapes of the 1st shape.
+  BRepExtrema_ShapeList myShapeList1;
+  //! List of subshapes of the 2nd shape.
+  BRepExtrema_ShapeList myShapeList2;
+
+  //! The 1st shape.
+  TopoDS_Shape myShape1;
+  //! The 2nd shape.
+  TopoDS_Shape myShape2;
+
+  BVH_Array3d myAddVertices1; //!< Additional vertices on the 1st shape if its mesh is coarser.
+  BVH_Array3d myAddVertices2; //!< Additional vertices on the 2nd shape if its mesh is coarser.
+
+  NCollection_Vector<ProxPnt_Status> myAddStatus1; //!< Status of additional vertices on the 1st shape.
+  NCollection_Vector<ProxPnt_Status> myAddStatus2; //!< Status of additional vertices on the 2nd shape.
+
+  Standard_Boolean myIsInitS1; //!< Is the 1st shape initialized?
+  Standard_Boolean myIsInitS2; //!< Is the 2nd shape initialized?
+
+  Standard_Boolean myIsRefinementRequired1; //!< Flag about the need to refine the 1st shape.
+  Standard_Boolean myIsRefinementRequired2; //!< Flag about the need to refine the 2nd shape.
+
+  Standard_Integer myNbNodes1; //!< Number of nodes in triangulation of the 1st shape.
+  Standard_Integer myNbNodes2; //!< Number of nodes in triangulation of the 2nd shape.
+
+  Standard_Real myStep1; //!< Step for getting vertices on the 1st shape.
+  Standard_Real myStep2; //!< Step for getting vertices on the 2nd shape.
+
+  BRepExtrema_CellFilter myCells;
+  BRepExtrema_VertexInspector myInspector;
+
+  TopAbs_ShapeEnum myShapeType1; //!< 1st shape type.
+  TopAbs_ShapeEnum myShapeType2; //!< 2nd shape type.
+
+  Standard_Real myDistance;  //!< Distance
+  Standard_Boolean myIsDone; //!< State of the algorithm
+
+  Standard_Integer myNbSamples1; //!< Number of samples points on the first shape
+  Standard_Integer myNbSamples2; //!< Number of samples points on the second shape
+
+  //! Proximity points
+  gp_Pnt myPnt1, myPnt2;
+
+  //! Proximity points' status
+  ProxPnt_Status myPntStatus1, myPntStatus2;
+
+};
+
+#endif // _BRepExtrema_ProximityValueTool_HeaderFile

src/BRepExtrema/BRepExtrema_SelfIntersection.hxx

@@ -18,6 +18,8 @@
 
 #include <BRepExtrema_OverlapTool.hxx>
 
+#include <TopoDS.hxx>
+
 //! Tool class for detection of self-sections in the given shape.
 //! This class is based on BRepExtrema_OverlapTool and thus uses
 //! shape tessellation to detect incorrect mesh fragments (pairs
@@ -76,7 +78,7 @@ public:
   //! Returns sub-shape from the shape for the given index (started from 0).
   const TopoDS_Face& GetSubShape (const Standard_Integer theID) const
   {
-    return myFaceList.Value (theID);
+    return TopoDS::Face(myFaceList.Value(theID));
   }
 
   //! Returns set of all the face triangles of the shape.

src/BRepExtrema/BRepExtrema_ShapeProximity.cxx

@@ -18,6 +18,28 @@
 #include <Precision.hxx>
 #include <TopExp_Explorer.hxx>
 
+// Assign a map of sub-shapes (edges/faces) of a given shape
+static Standard_Boolean initSubShapes(const TopoDS_Shape&              theShape,
+                                      BRepExtrema_ShapeList&           theSubshapesList,
+                                      Handle(BRepExtrema_TriangleSet)& theTriangleSet)
+{
+  theSubshapesList.Clear();
+
+  for (TopExp_Explorer anIter(theShape, TopAbs_FACE); anIter.More(); anIter.Next())
+  {
+    theSubshapesList.Append(anIter.Current());
+  }
+
+  for (TopExp_Explorer anIter(theShape, TopAbs_EDGE); anIter.More(); anIter.Next())
+  {
+    theSubshapesList.Append(anIter.Current());
+  }
+
+  if (theTriangleSet.IsNull())
+    theTriangleSet = new BRepExtrema_TriangleSet;
+  return theTriangleSet->Init(theSubshapesList);
+}
+
 //=======================================================================
 //function : BRepExtrema_ShapeProximity
 //purpose  : Creates uninitialized proximity tool
@@ -25,7 +47,9 @@
 BRepExtrema_ShapeProximity::BRepExtrema_ShapeProximity (const Standard_Real theTolerance)
 : myTolerance   (theTolerance),
   myElementSet1 (new BRepExtrema_TriangleSet),
-  myElementSet2 (new BRepExtrema_TriangleSet)
+  myElementSet2 (new BRepExtrema_TriangleSet),
+  myNbSamples1  (0),
+  myNbSamples2  (0)
 {
   // Should be initialized later
   myIsInitS1 = myIsInitS2 = Standard_False;
@@ -40,7 +64,9 @@ BRepExtrema_ShapeProximity::BRepExtrema_ShapeProximity (const TopoDS_Shape& theS
                                                         const Standard_Real theTolerance)
 : myTolerance   (theTolerance),
   myElementSet1 (new BRepExtrema_TriangleSet),
-  myElementSet2 (new BRepExtrema_TriangleSet)
+  myElementSet2 (new BRepExtrema_TriangleSet),
+  myNbSamples1  (0),
+  myNbSamples2  (0)
 {
   LoadShape1 (theShape1);
   LoadShape2 (theShape2);
@@ -52,16 +78,18 @@ BRepExtrema_ShapeProximity::BRepExtrema_ShapeProximity (const TopoDS_Shape& theS
 //=======================================================================
 Standard_Boolean BRepExtrema_ShapeProximity::LoadShape1 (const TopoDS_Shape& theShape1)
 {
-  myFaceList1.Clear();
+  myIsInitS1 = initSubShapes(theShape1, myShapeList1, myElementSet1);
 
-  for (TopExp_Explorer anIter (theShape1, TopAbs_FACE); anIter.More(); anIter.Next())
+  if (myTolerance == Precision::Infinite())
   {
-    myFaceList1.Append (static_cast<const TopoDS_Face&> (anIter.Current()));
+    myProxValTool.MarkDirty();
+  }
+  else
+  {
+    myOverlapTool.MarkDirty();
   }
 
-  myOverlapTool.MarkDirty();
-
-  return myIsInitS1 = myElementSet1->Init (myFaceList1);
+  return myIsInitS1;
 }
 
 //=======================================================================
@@ -70,16 +98,18 @@ Standard_Boolean BRepExtrema_ShapeProximity::LoadShape1 (const TopoDS_Shape& the
 //=======================================================================
 Standard_Boolean BRepExtrema_ShapeProximity::LoadShape2 (const TopoDS_Shape& theShape2)
 {
-  myFaceList2.Clear();
+  myIsInitS2 = initSubShapes(theShape2, myShapeList2, myElementSet2);
 
-  for (TopExp_Explorer anIter (theShape2, TopAbs_FACE); anIter.More(); anIter.Next())
+  if (myTolerance == Precision::Infinite())
   {
-    myFaceList2.Append (static_cast<const TopoDS_Face&> (anIter.Current()));
+    myProxValTool.MarkDirty();
+  }
+  else
+  {
+    myOverlapTool.MarkDirty();
   }
 
-  myOverlapTool.MarkDirty();
-
-  return myIsInitS2 = myElementSet2->Init (myFaceList2);
+  return myIsInitS2;
 }
 
 //=======================================================================
@@ -88,13 +118,33 @@ Standard_Boolean BRepExtrema_ShapeProximity::LoadShape2 (const TopoDS_Shape& the
 //=======================================================================
 void BRepExtrema_ShapeProximity::Perform()
 {
-  if (!myIsInitS1 || !myIsInitS2 || myOverlapTool.IsDone())
+  if (myTolerance == Precision::Infinite())
   {
-    return;
+    if (!myIsInitS1 || !myIsInitS2 || myProxValTool.IsDone())
+    {
+      return;
+    }
+
+    myProxValTool.LoadTriangleSets (myElementSet1,
+                                    myElementSet2);
+    myProxValTool.LoadShapeLists (myShapeList1,
+                                  myShapeList2);
+    myProxValTool.SetNbSamplePoints (myNbSamples1, myNbSamples2);
+
+    myProxValTool.Perform (myTolerance);
+    myProxValTool.ProximityPoints(myProxPoint1, myProxPoint2);
+    myProxValTool.ProximityPointsStatus (myProxPntStatus1, myProxPntStatus2);
   }
+  else
+  {
+    if (!myIsInitS1 || !myIsInitS2 || myOverlapTool.IsDone())
+    {
+      return;
+    }
 
-  myOverlapTool.LoadTriangleSets (myElementSet1,
-                                  myElementSet2);
+    myOverlapTool.LoadTriangleSets (myElementSet1,
+                                    myElementSet2);
 
-  myOverlapTool.Perform (myTolerance);
+    myOverlapTool.Perform (myTolerance);
+  }
 }

src/BRepExtrema/BRepExtrema_ShapeProximity.hxx

@@ -17,34 +17,46 @@
 #define _BRepExtrema_ShapeProximity_HeaderFile
 
 #include <NCollection_DataMap.hxx>
+#include <Precision.hxx>
 #include <TColStd_PackedMapOfInteger.hxx>
 
+#include <BRepExtrema_ProximityValueTool.hxx>
 #include <BRepExtrema_TriangleSet.hxx>
 #include <BRepExtrema_OverlapTool.hxx>
 
-//! Tool class for shape proximity detection.
+//! @brief Tool class for shape proximity detection.
+//!
+//! First approach:
 //! For two given shapes and given tolerance (offset from the mesh) the algorithm allows
 //! to determine whether or not they are overlapped. The algorithm input consists of any
 //! shapes which can be decomposed into individual faces (used as basic shape elements).
-//! High performance is achieved through the use of existing triangulation of faces. So
-//! poly triangulation (with the desired deflection) should already be built. Note that
-//! solution is approximate (and corresponds to the deflection used for triangulation).
 //!
 //! The algorithm can be run in two modes. If tolerance is set to zero, the algorithm
 //! will detect only intersecting faces (containing triangles with common points). If
 //! tolerance is set to positive value, the algorithm will also detect faces located
 //! on distance less than the given tolerance from each other.
+//!
+//! Second approach:
+//! Compute the proximity value between two shapes (handles only edge/edge or face/face cases)
+//! if the tolerance is not defined (Precision::Infinite()).
+//! In this case the proximity value is a minimal thickness of a layer containing both shapes.
+//!
+//! For the both approaches the high performance is achieved through the use of existing
+//! triangulation of faces. So, poly triangulation (with the desired deflection) should already
+//! be built. Note that solution is approximate (and corresponds to the deflection used for
+//! triangulation).
 class BRepExtrema_ShapeProximity
 {
+
 public:
 
   //! Creates empty proximity tool.
-  Standard_EXPORT BRepExtrema_ShapeProximity (const Standard_Real theTolerance = 0.0);
+  Standard_EXPORT BRepExtrema_ShapeProximity (const Standard_Real theTolerance = Precision::Infinite());
 
   //! Creates proximity tool for the given two shapes.
   Standard_EXPORT BRepExtrema_ShapeProximity (const TopoDS_Shape& theShape1,
                                               const TopoDS_Shape& theShape2,
-                                              const Standard_Real theTolerance = 0.0);
+                                              const Standard_Real theTolerance = Precision::Infinite());
 
 public:
 
@@ -60,19 +72,33 @@ public:
     myTolerance = theTolerance;
   }
 
+  //! Returns proximity value calculated for the whole input shapes.
+  Standard_Real Proximity() const
+  {
+    return Tolerance();
+  }
+
   //! Loads 1st shape into proximity tool.
   Standard_EXPORT Standard_Boolean LoadShape1 (const TopoDS_Shape& theShape1);
 
   //! Loads 2nd shape into proximity tool.
   Standard_EXPORT Standard_Boolean LoadShape2 (const TopoDS_Shape& theShape2);
 
+  //! Set number of sample points on the 1st shape used to compute the proximity value.
+  //! In case of 0, all triangulation nodes will be used.
+  void SetNbSamples1(const Standard_Integer theNbSamples) { myNbSamples1 = theNbSamples; }
+
+  //! Set number of sample points on the 2nd shape used to compute the proximity value.
+  //! In case of 0, all triangulation nodes will be used.
+  void SetNbSamples2(const Standard_Integer theNbSamples) { myNbSamples2 = theNbSamples; }
+
   //! Performs search of overlapped faces.
   Standard_EXPORT void Perform();
 
   //! True if the search is completed.
   Standard_Boolean IsDone() const
   { 
-    return myOverlapTool.IsDone();
+    return myOverlapTool.IsDone() || myProxValTool.IsDone();
   }
 
   //! Returns set of IDs of overlapped faces of 1st shape (started from 0).
@@ -88,15 +114,15 @@ public:
   }
 
   //! Returns sub-shape from 1st shape with the given index (started from 0).
-  const TopoDS_Face& GetSubShape1 (const Standard_Integer theID) const
+  const TopoDS_Shape& GetSubShape1 (const Standard_Integer theID) const
   {
-    return myFaceList1.Value (theID);
+    return myShapeList1.Value (theID);
   }
 
   //! Returns sub-shape from 1st shape with the given index (started from 0).
-  const TopoDS_Face& GetSubShape2 (const Standard_Integer theID) const
+  const TopoDS_Shape& GetSubShape2 (const Standard_Integer theID) const
   {
-    return myFaceList2.Value (theID);
+    return myShapeList2.Value (theID);
   }
 
   //! Returns set of all the face triangles of the 1st shape.
@@ -111,6 +137,34 @@ public:
     return myElementSet2;
   }
 
+  //! Returns the point on the 1st shape, which could be used as a reference point
+  //! for the value of the proximity.
+  const gp_Pnt& ProximityPoint1() const
+  {
+    return myProxPoint1;
+  }
+
+  //! Returns the point on the 2nd shape, which could be used as a reference point
+  //! for the value of the proximity.
+  const gp_Pnt& ProximityPoint2() const
+  {
+    return myProxPoint2;
+  }
+
+  //! Returns the status of point on the 1st shape, which could be used as a reference point
+  //! for the value of the proximity.
+  const ProxPnt_Status& ProxPntStatus1() const
+  {
+    return myProxPntStatus1;
+  }
+
+  //! Returns the status of point on the 2nd shape, which could be used as a reference point
+  //! for the value of the proximity.
+  const ProxPnt_Status& ProxPntStatus2() const
+  {
+    return myProxPntStatus2;
+  }
+
 private:
 
   //! Maximum overlapping distance.
@@ -121,19 +175,39 @@ private:
   //! Is the 2nd shape initialized?
   Standard_Boolean myIsInitS2;
 
-  //! List of faces of the 1st shape.
-  BRepExtrema_ShapeList myFaceList1;
-  //! List of faces of the 2nd shape.
-  BRepExtrema_ShapeList myFaceList2;
+  //! List of subshapes of the 1st shape.
+  BRepExtrema_ShapeList myShapeList1;
+  //! List of subshapes of the 2nd shape.
+  BRepExtrema_ShapeList myShapeList2;
 
   //! Set of all the face triangles of the 1st shape.
   Handle(BRepExtrema_TriangleSet) myElementSet1;
   //! Set of all the face triangles of the 2nd shape.
   Handle(BRepExtrema_TriangleSet) myElementSet2;
 
+  //! Number of sample points on the 1st shape used to compute the proximity value
+  //! (if zero (default), all triangulation nodes will be used).
+  Standard_Integer myNbSamples1;
+  //! Number of sample points on the 2nd shape used to compute the proximity value
+  //! (if zero (default), all triangulation nodes will be used).
+  Standard_Integer myNbSamples2;
+
+  //! Reference point of the proximity value on the 1st shape.
+  gp_Pnt myProxPoint1;
+  //! Reference point of the proximity value on the 2st shape.
+  gp_Pnt myProxPoint2;
+
+  //! Status of reference points of the proximity value.
+  ProxPnt_Status myProxPntStatus1, myProxPntStatus2;
+
   //! Overlap tool used for intersection/overlap test.
   BRepExtrema_OverlapTool myOverlapTool;
 
+  //! Shape-shape proximity tool used for computation of
+  //! the minimal diameter of a tube containing both edges or
+  //! the minimal thickness of a shell containing both faces.
+  BRepExtrema_ProximityValueTool myProxValTool;
+
 };
 
 #endif // _BRepExtrema_ShapeProximity_HeaderFile

src/BRepExtrema/BRepExtrema_TriangleSet.cxx

@@ -18,6 +18,7 @@
 #include <BRep_Tool.hxx>
 #include <BVH_LinearBuilder.hxx>
 #include <Poly_Triangulation.hxx>
+#include <TopoDS.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(BRepExtrema_TriangleSet, BVH_PrimitiveSet3d)
 
@@ -114,17 +115,67 @@ void BRepExtrema_TriangleSet::Swap (const Standard_Integer theIndex1, const Stan
 {
   std::swap (myTriangles[theIndex1],
              myTriangles[theIndex2]);
+
+  Standard_Integer anItem1 = myTrgIdxMap (theIndex1);
+  Standard_Integer anItem2 = myTrgIdxMap (theIndex2);
+  myTrgIdxMap (theIndex1) = anItem2;
+  myTrgIdxMap (theIndex2) = anItem1;
 }
 
 //=======================================================================
 //function : GetFaceID
-//purpose  : Returns face ID of the given triangle
+//purpose  : Returns face ID of the given vertex
 //=======================================================================
 Standard_Integer BRepExtrema_TriangleSet::GetFaceID (const Standard_Integer theIndex) const
 {
   return myTriangles[theIndex].w();
 }
 
+//=======================================================================
+//function : GetShapeIDOfVtx
+//purpose  : Returns shape ID of the given vertex index
+//=======================================================================
+Standard_Integer BRepExtrema_TriangleSet::GetShapeIDOfVtx (const Standard_Integer theIndex) const
+{
+  return myShapeIdxOfVtxVec.Value (theIndex);
+}
+
+//=======================================================================
+//function : GetVtxIdxInShape
+//purpose  : Returns vertex index in tringulation of the shape, which vertex belongs,
+//           with the given vtx ID in whole set
+//=======================================================================
+Standard_Integer BRepExtrema_TriangleSet::GetVtxIdxInShape (const Standard_Integer theIndex) const
+{
+  Standard_Integer aShID = myShapeIdxOfVtxVec.Value (theIndex);
+  Standard_Integer aNumVertices = 0;
+
+  for (Standard_Integer aSIdx = 0; aSIdx < aShID; aSIdx++)
+  {
+    aNumVertices += myNumVtxInShapeVec.Value (aSIdx);
+  }
+
+  return theIndex - aNumVertices;
+}
+
+//=======================================================================
+//function : GetTrgIdxInShape
+//purpose  :  Returns triangle index (before swapping) in tringulation of the shape, which triangle belongs,
+//            with the given trg ID in whole set (after swapping)
+//=======================================================================
+Standard_Integer BRepExtrema_TriangleSet::GetTrgIdxInShape (const Standard_Integer theIndex) const
+{
+  Standard_Integer aShID = GetFaceID (theIndex);
+  Standard_Integer aNumTriangles = 0;
+
+  for (Standard_Integer aSIdx = 0; aSIdx < aShID; aSIdx++)
+  {
+    aNumTriangles += myNumTrgInShapeVec.Value (aSIdx);
+  }
+
+  return myTrgIdxMap (theIndex) - aNumTriangles;
+}
+
 //=======================================================================
 //function : GetVertices
 //purpose  : Returns vertices of the given triangle
@@ -141,6 +192,21 @@ void BRepExtrema_TriangleSet::GetVertices (const Standard_Integer theIndex,
   theVertex3 = myVertexArray[aTriangle.z()];
 }
 
+//=======================================================================
+//function : GetVertices
+//purpose  : Returns vertices of the given triangle
+//=======================================================================
+void BRepExtrema_TriangleSet::GetVtxIndices (const Standard_Integer theIndex,
+                                             NCollection_Array1<Standard_Integer>& theVtxIndices) const
+{
+  BVH_Vec4i aTriangle = myTriangles[theIndex];
+
+  theVtxIndices = NCollection_Array1<Standard_Integer> (0, 2);
+  theVtxIndices.SetValue (0, aTriangle.x());
+  theVtxIndices.SetValue (1, aTriangle.y());
+  theVtxIndices.SetValue (2, aTriangle.z());
+}
+
 //=======================================================================
 //function : Clear
 //purpose  : Clears triangle set data
@@ -158,51 +224,26 @@ void BRepExtrema_TriangleSet::Clear()
 //function : Init
 //purpose  : Initializes triangle set
 //=======================================================================
-Standard_Boolean BRepExtrema_TriangleSet::Init (const BRepExtrema_ShapeList& theFaces)
+Standard_Boolean BRepExtrema_TriangleSet::Init (const BRepExtrema_ShapeList& theShapes)
 {
   Clear();
 
-  for (Standard_Integer aFaceIdx = 0; aFaceIdx < theFaces.Size(); ++aFaceIdx)
+  Standard_Boolean isOK = Standard_True;
+  for (Standard_Integer aShapeIdx = 0; aShapeIdx < theShapes.Size() && isOK; ++aShapeIdx)
   {
-    TopLoc_Location aLocation;
+    if (theShapes (aShapeIdx).ShapeType() == TopAbs_FACE)
+      isOK = initFace (TopoDS::Face (theShapes(aShapeIdx)), aShapeIdx);
+    else if (theShapes (aShapeIdx).ShapeType() == TopAbs_EDGE)
+      isOK = initEdge (TopoDS::Edge (theShapes(aShapeIdx)), aShapeIdx);
+  }
 
-    Handle(Poly_Triangulation) aTriangulation =
-      BRep_Tool::Triangulation (theFaces (aFaceIdx), aLocation);
+  Standard_Integer aNumTrg = static_cast<Standard_Integer> (myTriangles.size());
+  myTrgIdxMap.Clear();
+  myTrgIdxMap.ReSize (aNumTrg);
 
-    if (aTriangulation.IsNull())
-    {
-      return Standard_False;
-    }
-
-    const Standard_Integer aVertOffset =
-      static_cast<Standard_Integer> (myVertexArray.size()) - 1;
-
-    for (Standard_Integer aVertIdx = 1; aVertIdx <= aTriangulation->NbNodes(); ++aVertIdx)
-    {
-      gp_Pnt aVertex = aTriangulation->Nodes().Value (aVertIdx);
-
-      aVertex.Transform (aLocation.Transformation());
-
-      myVertexArray.push_back (BVH_Vec3d (aVertex.X(),
-                                          aVertex.Y(),
-                                          aVertex.Z()));
-    }
-
-    for (Standard_Integer aTriIdx = 1; aTriIdx <= aTriangulation->NbTriangles(); ++aTriIdx)
-    {
-      Standard_Integer aVertex1;
-      Standard_Integer aVertex2;
-      Standard_Integer aVertex3;
-
-      aTriangulation->Triangles().Value (aTriIdx).Get (aVertex1,
-                                                       aVertex2,
-                                                       aVertex3);
-
-      myTriangles.push_back (BVH_Vec4i (aVertex1 + aVertOffset,
-                                        aVertex2 + aVertOffset,
-                                        aVertex3 + aVertOffset,
-                                        aFaceIdx));
-    }
+  for (Standard_Integer aTrgIdx = 0; aTrgIdx < aNumTrg; ++aTrgIdx)
+  {
+    myTrgIdxMap.Bind (aTrgIdx, aTrgIdx);
   }
 
   MarkDirty(); // needs BVH rebuilding
@@ -213,3 +254,95 @@ Standard_Boolean BRepExtrema_TriangleSet::Init (const BRepExtrema_ShapeList& the
   return Standard_True;
 }
 
+//=======================================================================
+//function : initFace
+//purpose  : Initializes triangle set
+//=======================================================================
+Standard_Boolean BRepExtrema_TriangleSet::initFace (const TopoDS_Face& theFace, const Standard_Integer theIndex)
+{
+  TopLoc_Location aLocation;
+
+  Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (theFace, aLocation);
+  if (aTriangulation.IsNull())
+  {
+    return Standard_False;
+  }
+
+  const Standard_Integer aVertOffset =
+    static_cast<Standard_Integer> (myVertexArray.size()) - 1;
+
+  initNodes (aTriangulation->Nodes(), aLocation.Transformation(), theIndex);
+
+  for (Standard_Integer aTriIdx = 1; aTriIdx <= aTriangulation->NbTriangles(); ++aTriIdx)
+  {
+    Standard_Integer aVertex1;
+    Standard_Integer aVertex2;
+    Standard_Integer aVertex3;
+
+    aTriangulation->Triangle (aTriIdx).Get (aVertex1,
+                                            aVertex2,
+                                            aVertex3);
+
+    myTriangles.push_back (BVH_Vec4i (aVertex1 + aVertOffset,
+                                      aVertex2 + aVertOffset,
+                                      aVertex3 + aVertOffset,
+                                      theIndex));
+  }
+
+  myNumTrgInShapeVec.SetValue (theIndex, aTriangulation->NbTriangles());
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : initEdge
+//purpose  : Initializes triangle set
+//=======================================================================
+Standard_Boolean BRepExtrema_TriangleSet::initEdge (const TopoDS_Edge& theEdge, const Standard_Integer theIndex)
+{
+  TopLoc_Location aLocation;
+
+  Handle(Poly_Polygon3D) aPolygon = BRep_Tool::Polygon3D (theEdge, aLocation);
+  if (aPolygon.IsNull())
+  {
+    return Standard_False;
+  }
+
+  const Standard_Integer aVertOffset =
+    static_cast<Standard_Integer> (myVertexArray.size()) - 1;
+
+  initNodes (aPolygon->Nodes(), aLocation.Transformation(), theIndex);
+
+  for (Standard_Integer aVertIdx = 1; aVertIdx < aPolygon->NbNodes(); ++aVertIdx)
+  {
+    // segment as degenerate triangle
+    myTriangles.push_back (BVH_Vec4i (aVertIdx + aVertOffset,
+                                      aVertIdx + aVertOffset + 1,
+                                      aVertIdx + aVertOffset + 1,
+                                      theIndex));
+  }
+  return Standard_True;
+}
+
+//=======================================================================
+//function : initNodes
+//purpose  : Initializes nodes
+//=======================================================================
+void BRepExtrema_TriangleSet::initNodes (const TColgp_Array1OfPnt& theNodes,
+                                         const gp_Trsf& theTrsf,
+                                         const Standard_Integer theIndex)
+{
+  for (Standard_Integer aVertIdx = 1; aVertIdx <= theNodes.Size(); ++aVertIdx)
+  {
+    gp_Pnt aVertex = theNodes.Value (aVertIdx);
+
+    aVertex.Transform (theTrsf);
+
+    myVertexArray.push_back (BVH_Vec3d (aVertex.X(),
+                                        aVertex.Y(),
+                                        aVertex.Z()));
+    myShapeIdxOfVtxVec.Append (theIndex);
+  }
+
+  myNumVtxInShapeVec.SetValue (theIndex, theNodes.Size());
+}

src/BRepExtrema/BRepExtrema_TriangleSet.hxx

@@ -16,11 +16,14 @@
 #ifndef _BRepExtrema_TriangleSet_HeaderFile
 #define _BRepExtrema_TriangleSet_HeaderFile
 
-#include <TopoDS_Face.hxx>
 #include <BVH_PrimitiveSet3d.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColStd_DataMapOfIntegerInteger.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
 
 //! List of shapes and their IDs for collision detection.
-typedef NCollection_Vector<TopoDS_Face> BRepExtrema_ShapeList;
+typedef NCollection_Vector<TopoDS_Shape> BRepExtrema_ShapeList;
 
 //! Triangle set corresponding to specific face.
 class BRepExtrema_TriangleSet : public BVH_PrimitiveSet3d
@@ -59,7 +62,10 @@ public:
   Standard_EXPORT void Clear();
 
   //! Initializes triangle set.
-  Standard_EXPORT Standard_Boolean Init (const BRepExtrema_ShapeList& theFaces);
+  Standard_EXPORT Standard_Boolean Init (const BRepExtrema_ShapeList& theShapes);
+
+  //! Returns all vertices.
+  Standard_EXPORT const BVH_Array3d& GetVertices() const { return myVertexArray; }
 
   //! Returns vertices of the given triangle.
   Standard_EXPORT void GetVertices (const Standard_Integer theIndex,
@@ -67,9 +73,37 @@ public:
                                     BVH_Vec3d&             theVertex2,
                                     BVH_Vec3d&             theVertex3) const;
 
+  //! Returns vertex indices of the given triangle.
+  Standard_EXPORT void GetVtxIndices (const Standard_Integer theIndex,
+                                      NCollection_Array1<Standard_Integer>& theVtxIndices) const;
+
   //! Returns face ID of the given triangle.
   Standard_EXPORT Standard_Integer GetFaceID (const Standard_Integer theIndex) const;
 
+  //! Returns shape ID of the given vertex index.
+  Standard_EXPORT Standard_Integer GetShapeIDOfVtx (const Standard_Integer theIndex) const;
+
+  //! Returns vertex index in tringulation of the shape, which vertex belongs,
+  //! with the given vtx ID in whole set.
+  Standard_EXPORT Standard_Integer GetVtxIdxInShape (const Standard_Integer theIndex) const;
+
+  //! Returns triangle index (before swapping) in tringulation of the shape, which triangle belongs,
+  //! with the given trg ID in whole set (after swapping).
+  Standard_EXPORT Standard_Integer GetTrgIdxInShape (const Standard_Integer theIndex) const;
+
+private:
+
+  //! Initializes triangle set from the face
+  Standard_Boolean initFace (const TopoDS_Face& theFace, const Standard_Integer theIndex);
+
+  //! Initializes polygon from the edge
+  Standard_Boolean initEdge (const TopoDS_Edge& theEdge, const Standard_Integer theIndex);
+
+  //! Initializes nodes
+  void initNodes (const TColgp_Array1OfPnt& theNodes,
+                  const gp_Trsf& theTrsf,
+                  const Standard_Integer theIndex);
+
 protected:
 
   //! Array of vertex indices.
@@ -78,6 +112,19 @@ protected:
   //! Array of vertex coordinates.
   BVH_Array3d myVertexArray;
 
+  //! Vector of shapes' indices where index of item corresponds to index of vertex,
+  //! belonging to this shape.
+  NCollection_Vector<Standard_Integer> myShapeIdxOfVtxVec;
+
+  //! Vector of vertexes' number belonging to shape which index corresponds item's index.
+  NCollection_Vector<Standard_Integer> myNumVtxInShapeVec;
+
+  //! Vector of triangles' number belonging to shape which index corresponds item's index.
+  NCollection_Vector<Standard_Integer> myNumTrgInShapeVec;
+
+  //! Map of triangles' indices after (key) and before (value) swapping.
+  TColStd_DataMapOfIntegerInteger myTrgIdxMap;
+
 public:
 
   DEFINE_STANDARD_RTTIEXT(BRepExtrema_TriangleSet, BVH_PrimitiveSet3d)

src/BRepExtrema/FILES

@@ -18,6 +18,10 @@ BRepExtrema_OverlapTool.cxx
 BRepExtrema_OverlapTool.hxx
 BRepExtrema_Poly.cxx
 BRepExtrema_Poly.hxx
+BRepExtrema_ProximityValueTool.cxx
+BRepExtrema_ProximityValueTool.hxx
+BRepExtrema_ProximityDistTool.cxx
+BRepExtrema_ProximityDistTool.hxx
 BRepExtrema_SelfIntersection.cxx
 BRepExtrema_SelfIntersection.hxx
 BRepExtrema_SeqOfSolution.hxx

src/BRepFill/BRepFill_PipeShell.cxx

@@ -1450,6 +1450,10 @@ void BRepFill_PipeShell::BuildHistory(const BRepFill_Sweep& theSweep)
     for (Standard_Integer i = 1; i <= aVEdges->UpperRow(); i++)
     {
       const TopoDS_Shape& aVshape = aVEdges->Value(i, inde);
+      if (aVshape.IsNull())
+      {
+        continue;
+      }
       if (aVshape.ShapeType() == TopAbs_EDGE ||
           aVshape.ShapeType() == TopAbs_FACE)
         ListVshapes->Append(aVshape);

src/BRepFill/BRepFill_Sweep.cxx

@@ -2969,13 +2969,25 @@ void BRepFill_Sweep::Build(TopTools_MapOfShape& ReversedEdges,
     // Construction of the shell
     TopoDS_Shell shell;
     B.MakeShell(shell);
+    Standard_Integer aNbFaces = 0;
     for (ipath=1; ipath<=NbPath; ipath++) 
-      for (isec=1; isec <=NbLaw; isec++) {
-      const TopoDS_Shape& face = myFaces->Value(isec, ipath);
+      for (isec=1; isec <=NbLaw; isec++)
+      {
+        const TopoDS_Shape& face = myFaces->Value(isec, ipath);
 	if (!face.IsNull() && 
-	    (face.ShapeType() == TopAbs_FACE) ) B.Add(shell, face);
+	    (face.ShapeType() == TopAbs_FACE) )
+        {
+          B.Add(shell, face);
+          aNbFaces++;
+        }
       }
 
+    if (aNbFaces == 0)
+    {
+      isDone = Standard_False;
+      return;
+    }
+
     TopTools_ListIteratorOfListOfShape It(myAuxShape);
     for (; It.More(); It.Next()) {
        const TopoDS_Shape& face = It.Value();

src/BRepLib/BRepLib.cxx

@@ -987,6 +987,9 @@ static void InternalSameParameter(const TopoDS_Shape& theSh, BRepTools_ReShape&
     TopExp_Explorer ex2;
     for(ex2.Init(curface,TopAbs_EDGE); ex2.More(); ex2.Next()){
       const TopoDS_Edge& E = TopoDS::Edge(ex2.Current());
+      if (BRep_Tool::Degenerated(E))
+        continue;
+
       TopoDS_Shape aNe = theReshaper.Value(E);
       Standard_Real aNewEtol = -1;
       GetEdgeTol(TopoDS::Edge(aNe), curface, aNewEtol);
@@ -1982,6 +1985,12 @@ public:
     return aDeriv.Transformed(mySurfaceTrsf);
   }
 
+  gp_Dir Normal()
+  {
+    gp_Dir aNormal = mySurfaceProps.Normal();
+    return aNormal.Transformed(mySurfaceTrsf);
+  }
+
   // Calculate principal curvatures, which consist of minimal and maximal normal curvatures and
   // the directions on the tangent plane (principal direction) where the extremums are reached
   void Curvature(gp_Dir& thePrincipalDir1, Standard_Real& theCurvature1,
@@ -2014,32 +2023,63 @@ private:
 //purpose  : check the angle at the border between two squares.
 //           Two shares should have a shared front edge.
 //=======================================================================
-static GeomAbs_Shape tgtfaces(const TopoDS_Edge& Ed,
-                              const TopoDS_Face& F1,
-                              const TopoDS_Face& F2,
-                              const Standard_Real theAngleTol)
+GeomAbs_Shape BRepLib::ContinuityOfFaces(const TopoDS_Edge&  theEdge,
+                                         const TopoDS_Face&  theFace1,
+                                         const TopoDS_Face&  theFace2,
+                                         const Standard_Real theAngleTol)
 {
-  Standard_Boolean isSeam = F1.IsEqual(F2);
+  Standard_Boolean isSeam = theFace1.IsEqual(theFace2);
 
-  TopoDS_Edge E = Ed;
+  TopoDS_Edge anEdgeInFace1, anEdgeInFace2;
+  Handle(Geom2d_Curve) aCurve1, aCurve2;
+  
+  Standard_Real aFirst, aLast;
+  
+  if (!theFace1.IsSame (theFace2) &&
+      BRep_Tool::IsClosed (theEdge, theFace1) &&
+      BRep_Tool::IsClosed (theEdge, theFace2))
+  {
+    //Find the edge in the face 1: this edge will have correct orientation
+    TopoDS_Face aFace1 = theFace1;
+    aFace1.Orientation (TopAbs_FORWARD);
+    TopExp_Explorer anExplo (aFace1, TopAbs_EDGE);
+    for (; anExplo.More(); anExplo.Next())
+    {
+      const TopoDS_Edge& anEdge = TopoDS::Edge (anExplo.Current());
+      if (anEdge.IsSame (theEdge))
+      {
+        anEdgeInFace1 = anEdge;
+        break;
+      }
+    }
+    if (anEdgeInFace1.IsNull())
+      return GeomAbs_C0;
+    
+    aCurve1 = BRep_Tool::CurveOnSurface (anEdgeInFace1, aFace1, aFirst, aLast);
+    TopoDS_Face aFace2 = theFace2;
+    aFace2.Orientation (TopAbs_FORWARD);
+    anEdgeInFace2 = anEdgeInFace1;
+    anEdgeInFace2.Reverse();
+    aCurve2 = BRep_Tool::CurveOnSurface (anEdgeInFace2, aFace2, aFirst, aLast);
+  }
+  else
+  {
+    // Obtaining of pcurves of edge on two faces.
+    anEdgeInFace1 = anEdgeInFace2 = theEdge;
+    aCurve1 = BRep_Tool::CurveOnSurface (anEdgeInFace1, theFace1, aFirst, aLast);
+    //For the case of seam edge
+    if (theFace1.IsSame(theFace2))
+      anEdgeInFace2.Reverse();
+    aCurve2 = BRep_Tool::CurveOnSurface (anEdgeInFace2, theFace2, aFirst, aLast);
+  }
 
-  // Check if pcurves exist on both faces of edge
-  Standard_Real aFirst,aLast;
-  E.Orientation(TopAbs_FORWARD);
-  Handle(Geom2d_Curve) aCurve1 = BRep_Tool::CurveOnSurface(E, F1, aFirst, aLast);
-  if(aCurve1.IsNull())
-    return GeomAbs_C0;
-
-  if (isSeam)
-    E.Orientation(TopAbs_REVERSED);
-  Handle(Geom2d_Curve) aCurve2 = BRep_Tool::CurveOnSurface(E, F2, aFirst, aLast);
-  if(aCurve2.IsNull())
+  if (aCurve1.IsNull() || aCurve2.IsNull())
     return GeomAbs_C0;
 
   TopLoc_Location aLoc1, aLoc2;
-  Handle(Geom_Surface) aSurface1 = BRep_Tool::Surface(F1, aLoc1);
+  Handle(Geom_Surface) aSurface1 = BRep_Tool::Surface (theFace1, aLoc1);
   const gp_Trsf& aSurf1Trsf = aLoc1.Transformation();
-  Handle(Geom_Surface) aSurface2 = BRep_Tool::Surface(F2, aLoc2);
+  Handle(Geom_Surface) aSurface2 = BRep_Tool::Surface (theFace2, aLoc2);
   const gp_Trsf& aSurf2Trsf = aLoc2.Transformation();
 
   if (aSurface1->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
@@ -2056,11 +2096,11 @@ static GeomAbs_Shape tgtfaces(const TopoDS_Edge& Ed,
     return GeomAbs_CN;
   }
 
-  SurfaceProperties aSP1(aSurface1, aSurf1Trsf, aCurve1, F1.Orientation() == TopAbs_REVERSED);
-  SurfaceProperties aSP2(aSurface2, aSurf2Trsf, aCurve2, F2.Orientation() == TopAbs_REVERSED);
+  SurfaceProperties aSP1(aSurface1, aSurf1Trsf, aCurve1, theFace1.Orientation() == TopAbs_REVERSED);
+  SurfaceProperties aSP2(aSurface2, aSurf2Trsf, aCurve2, theFace2.Orientation() == TopAbs_REVERSED);
 
   Standard_Real f, l, eps;
-  BRep_Tool::Range(E,f,l);
+  BRep_Tool::Range (theEdge,f,l);
   Extrema_LocateExtPC ext;
   Handle(BRepAdaptor_HCurve) aHC2;
 
@@ -2071,7 +2111,6 @@ static GeomAbs_Shape tgtfaces(const TopoDS_Edge& Ed,
   const Standard_Real anAngleTol2 = theAngleTol * theAngleTol;
 
   gp_Vec aDer1, aDer2;
-  gp_Vec aNorm1;
   Standard_Real aSqLen1, aSqLen2;
   gp_Dir aCrvDir1[2], aCrvDir2[2];
   Standard_Real aCrvLen1[2], aCrvLen2[2];
@@ -2099,13 +2138,26 @@ static GeomAbs_Shape tgtfaces(const TopoDS_Edge& Ed,
     aDer2 = aSP2.Derivative();
     aSqLen2 = aDer2.SquareMagnitude();
     Standard_Boolean isSmoothSuspect = (aDer1.CrossSquareMagnitude(aDer2) <= anAngleTol2 * aSqLen1 * aSqLen2);
+    if (isSmoothSuspect)
+    {
+      gp_Dir aNormal1 = aSP1.Normal();
+      if (theFace1.Orientation() == TopAbs_REVERSED)
+        aNormal1.Reverse();
+      gp_Dir aNormal2 = aSP2.Normal();
+      if (theFace2.Orientation() == TopAbs_REVERSED)
+        aNormal2.Reverse();
+      
+      if (aNormal1 * aNormal2 < 0.)
+        return GeomAbs_C0;
+    }
+    
     if (!isSmoothSuspect)
     {
       // Refine by projection
       if (aHC2.IsNull())
       {
         // adaptor for pcurve on the second surface
-        aHC2 = new BRepAdaptor_HCurve(BRepAdaptor_Curve(E, F2));
+        aHC2 = new BRepAdaptor_HCurve(BRepAdaptor_Curve(anEdgeInFace2, theFace2));
         ext.Initialize(aHC2->Curve(), f, l, Precision::PConfusion());
       }
       ext.Perform(aSP1.Value(), u);
@@ -2301,9 +2353,8 @@ void BRepLib::EncodeRegularity(TopoDS_Edge& E,
   BRep_Builder B;
   if(BRep_Tool::Continuity(E,F1,F2)<=GeomAbs_C0){
     try {
-      GeomAbs_Shape aCont = tgtfaces(E, F1, F2, TolAng);
+      GeomAbs_Shape aCont = ContinuityOfFaces(E, F1, F2, TolAng);
       B.Continuity(E,F1,F2,aCont);
-      
     }
     catch(Standard_Failure const&)
     {

src/BRepLib/BRepLib.hxx

@@ -215,7 +215,14 @@ public:
   //! orientation to have  matter in the solid. Returns
   //! False if the solid is unOrientable (open or incoherent)
   Standard_EXPORT static Standard_Boolean OrientClosedSolid (TopoDS_Solid& solid);
-  
+
+  //! Returns the order of continuity between two faces
+  //! connected by an edge
+  Standard_EXPORT static GeomAbs_Shape ContinuityOfFaces(const TopoDS_Edge&  theEdge,
+                                                         const TopoDS_Face&  theFace1,
+                                                         const TopoDS_Face&  theFace2,
+                                                         const Standard_Real theAngleTol);
+
   //! Encodes the Regularity of edges on a Shape.
   //! Warning: <TolAng> is an angular tolerance, expressed in Rad.
   //! Warning: If the edges's regularity are coded before, nothing

src/BRepLib/BRepLib_MakeFace.cxx

@@ -256,7 +256,7 @@ BRepLib_MakeFace::BRepLib_MakeFace(const TopoDS_Wire& W,
     myError = BRepLib_NotPlanar;
     return;
   }
- 
+
   // build the face and add the wire
   BRep_Builder B;
   myError = BRepLib_FaceDone;
@@ -264,13 +264,48 @@ BRepLib_MakeFace::BRepLib_MakeFace(const TopoDS_Wire& W,
   Standard_Real tol = Max(1.2*FS.ToleranceReached(), FS.Tolerance());
 
   B.MakeFace(TopoDS::Face(myShape),FS.Surface(),FS.Location(),tol);
-  Add(W);
+
+  TopoDS_Wire aW;
+  if (OnlyPlane)
+  {
+    // get rid of degenerative edges in the input wire
+    BRep_Builder aB;
+    aB.MakeWire (aW);
+
+    TopoDS_Wire aWForw = W;
+    Standard_Boolean hasDegenerated = Standard_False;
+    aWForw.Orientation (TopAbs_FORWARD);
+    TopoDS_Iterator anIter (aWForw);
+    for (; anIter.More(); anIter.Next())
+    {
+      const TopoDS_Edge& aE = TopoDS::Edge (anIter.Value());
+
+      if (BRep_Tool::Degenerated (aE))
+        hasDegenerated = Standard_True;
+      else
+        aB.Add (aW, aE);
+    }
+
+    if (hasDegenerated) {
+      aW.Orientation (W.Orientation()); // return to original orient
+      aW.Closed (W.Closed());
+    }
+    else {
+      aW = W;
+    }
+  }
+  else
+  {
+    aW = W;
+  }
+
+  Add (aW);
   //
   BRepLib::UpdateTolerances(myShape);
   //
   BRepLib::SameParameter(myShape, tol, Standard_True);
   //
-  if (BRep_Tool::IsClosed(W))
+  if (BRep_Tool::IsClosed(aW))
     CheckInside();
 }
 

src/BRepMesh/BRepMesh_DelaunayDeflectionControlMeshAlgo.hxx

@@ -34,6 +34,7 @@ public:
   //! Constructor.
   BRepMesh_DelaunayDeflectionControlMeshAlgo()
     : myMaxSqDeflection(-1.),
+      mySqMinSize(-1.),
       myIsAllDegenerated(Standard_False),
       myCircles(NULL)
   {
@@ -77,10 +78,11 @@ protected:
     Handle(NCollection_IncAllocator) aTmpAlloc =
       new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE);
 
+    mySqMinSize    = this->getParameters().MinSize * this->getParameters().MinSize;
     myCouplesMap   = new IMeshData::MapOfOrientedEdges(3 * this->getStructure()->ElementsOfDomain().Extent(), aTmpAlloc);
     myControlNodes = new IMeshData::ListOfPnt2d(aTmpAlloc);
     myCircles      = &theMesher.Circles();
-
+    
     const Standard_Integer aIterationsNb = 11;
     Standard_Boolean isInserted = Standard_True;
     Message_ProgressScope aPS(theRange, "Iteration", aIterationsNb);
@@ -339,22 +341,38 @@ private:
         if (!usePoint (aMidPnt2d, LineDeviation (theNodesInfo[i].Point, 
                                                  theNodesInfo[j].Point)))
         {
-          if (!checkLinkEndsForAngularDeviation(theNodesInfo[i], 
-                                                theNodesInfo[j],
-                                                aMidPnt2d))
+          if (!rejectSplitLinksForMinSize (theNodesInfo[i],
+                                           theNodesInfo[j],
+                                           aMidPnt2d))
           {
-            myControlNodes->Append(aMidPnt2d);
+            if (!checkLinkEndsForAngularDeviation (theNodesInfo[i],
+                                                   theNodesInfo[j],
+                                                   aMidPnt2d))
+            {
+              myControlNodes->Append(aMidPnt2d);
+            }
           }
         }
       }
     }
   }
 
+  //! Checks that two links produced as the result of a split of 
+  //! the given link by the middle point fit MinSize requirement.
+  Standard_Boolean rejectSplitLinksForMinSize (const TriangleNodeInfo& theNodeInfo1,
+                                               const TriangleNodeInfo& theNodeInfo2,
+                                               const gp_XY&            theMidPoint)
+  {
+    const gp_Pnt aPnt = getPoint3d (theMidPoint);
+    return ((theNodeInfo1.Point - aPnt.XYZ()).SquareModulus() < mySqMinSize ||
+            (theNodeInfo2.Point - aPnt.XYZ()).SquareModulus() < mySqMinSize);
+  }
+
   //! Checks the given point (located between the given nodes)
   //! for specified angular deviation.
   Standard_Boolean checkLinkEndsForAngularDeviation(const TriangleNodeInfo& theNodeInfo1,
                                                     const TriangleNodeInfo& theNodeInfo2,
-                                                    const gp_XY& /*theMidPoint*/)
+                                                    const gp_XY&          /*theMidPoint*/)
   {
     gp_Dir aNorm1, aNorm2;
     const Handle(Geom_Surface)& aSurf = 
@@ -365,7 +383,9 @@ private:
     {
       Standard_Real anAngle = aNorm1.Angle(aNorm2);
       if (anAngle > this->getParameters().AngleInterior)
+      {
         return Standard_False;
+      }
     }
 #if 0
     else if (GeomLib::NormEstim(aSurf, theMidPoint, Precision::Confusion(), aNorm1) != 0)
@@ -381,6 +401,14 @@ private:
     return Standard_True;
   }
 
+  //! Returns 3d point corresponding to the given one in 2d space.
+  gp_Pnt getPoint3d (const gp_XY& thePnt2d)
+  {
+    gp_Pnt aPnt;
+    this->getDFace()->GetSurface()->D0(thePnt2d.X(), thePnt2d.Y(), aPnt);
+    return aPnt;
+  }
+
   //! Computes deflection of the given point and caches it for
   //! insertion in case if it overflows deflection.
   //! @return True if point has been cached for insertion.
@@ -389,8 +417,7 @@ private:
     const gp_XY&             thePnt2d,
     const DeflectionFunctor& theDeflectionFunctor)
   {
-    gp_Pnt aPnt;
-    this->getDFace()->GetSurface()->D0(thePnt2d.X(), thePnt2d.Y(), aPnt);
+    const gp_Pnt aPnt = getPoint3d (thePnt2d);
     if (!checkDeflectionOfPointAndUpdateCache(thePnt2d, aPnt, theDeflectionFunctor.SquareDeviation(aPnt)))
     {
       myControlNodes->Append(thePnt2d);
@@ -422,14 +449,14 @@ private:
     return rejectByMinSize(thePnt2d, thePnt3d);
   }
 
-  //! Checks the given node for 
+  //! Checks distance between the given node and nodes of triangles 
+  //! shot by it for MinSize criteria.
+  //! This check is expected to roughly estimate and prevent 
+  //! generation of triangles with sides smaller than MinSize.
   Standard_Boolean rejectByMinSize(
     const gp_XY&  thePnt2d,
     const gp_Pnt& thePnt3d)
   {
-    const Standard_Real aSqMinSize = 
-      this->getParameters().MinSize * this->getParameters().MinSize;
-
     IMeshData::MapOfInteger aUsedNodes;
     IMeshData::ListOfInteger& aCirclesList =
       const_cast<BRepMesh_CircleTool&>(*myCircles).Select(
@@ -451,7 +478,7 @@ private:
           const BRepMesh_Vertex& aVertex = this->getStructure()->GetNode(aNodes[i]);
           const gp_Pnt& aPoint = this->getNodesMap()->Value(aVertex.Location3d());
 
-          if (thePnt3d.SquareDistance(aPoint) < aSqMinSize)
+          if (thePnt3d.SquareDistance(aPoint) < mySqMinSize)
           {
             return Standard_True;
           }
@@ -464,6 +491,7 @@ private:
 
 private:
   Standard_Real                         myMaxSqDeflection;
+  Standard_Real                         mySqMinSize;
   Standard_Boolean                      myIsAllDegenerated;
   Handle(IMeshData::MapOfOrientedEdges) myCouplesMap;
   Handle(IMeshData::ListOfPnt2d)        myControlNodes;

src/BRepOffset/BRepOffset_Inter2d.cxx

@@ -32,6 +32,7 @@
 #include <BRepAdaptor_Curve2d.hxx>
 #include <BRepAdaptor_Surface.hxx>
 #include <BRepAlgo_AsDes.hxx>
+#include <BRepAlgo_Image.hxx>
 #include <BRepLib.hxx>
 #include <BRepLib_MakeVertex.hxx>
 #include <BRepOffset_Analyse.hxx>
@@ -63,6 +64,7 @@
 #include <gp_Pnt.hxx>
 #include <IntRes2d_IntersectionPoint.hxx>
 #include <IntRes2d_IntersectionSegment.hxx>
+#include <IntTools_Tools.hxx>
 #include <Precision.hxx>
 #include <TColGeom2d_SequenceOfCurve.hxx>
 #include <TColgp_Array1OfPnt2d.hxx>
@@ -78,6 +80,7 @@
 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 #include <TopTools_ListOfShape.hxx>
+#include <TopTools_SequenceOfShape.hxx>
 
 #include <stdio.h>
 #ifdef DRAW 
@@ -113,27 +116,153 @@ static TopoDS_Vertex CommonVertex(TopoDS_Edge& E1,
   return V;
 }
 
-static Standard_Boolean IsOrientationChanged(TopTools_IndexedMapOfShape& theMap,
-                                             const TopoDS_Edge& theEdge)
+static Standard_Integer DefineClosedness(const TopoDS_Face& theFace)
 {
-  Standard_Boolean IsOrChanged = Standard_False;
-  
-  if (!theMap.Contains(theEdge))
-    theMap.Add(theEdge);
-  else
+  TopExp_Explorer anExplo (theFace, TopAbs_EDGE);
+  for (; anExplo.More(); anExplo.Next())
   {
-    Standard_Integer anInd = theMap.FindIndex(theEdge);
-    const TopoDS_Shape& anEdge = theMap(anInd);
-    if (theEdge.Orientation() != anEdge.Orientation())
+    const TopoDS_Edge& anEdge = TopoDS::Edge (anExplo.Current());
+    if (BRepTools::IsReallyClosed(anEdge, theFace))
     {
-      theMap.Substitute( anInd, theEdge );
-      IsOrChanged = Standard_True;
+      Standard_Real fpar, lpar;
+      Handle(Geom2d_Curve) aPCurve = BRep_Tool::CurveOnSurface(anEdge, theFace, fpar, lpar);
+      gp_Vec2d aTangent = aPCurve->DN(fpar, 1);
+      Standard_Real aCrossProd1 = aTangent ^ gp::DX2d();
+      Standard_Real aCrossProd2 = aTangent ^ gp::DY2d();
+      if (Abs(aCrossProd2) < Abs(aCrossProd1)) //pcurve is parallel to OY
+        return 1;
+      else
+        return 2;
     }
   }
 
-  return IsOrChanged;
+  return 0;
 }
 
+static void GetEdgesOrientedInFace(const TopoDS_Shape& theShape,
+                                   const TopoDS_Face&  theFace,
+                                   const Handle(BRepAlgo_AsDes)& theAsDes,
+                                   TopTools_SequenceOfShape&     theSeqEdges)
+{
+  const TopTools_ListOfShape& aEdges = theAsDes->Descendant (theFace);
+
+  TopExp_Explorer anExplo (theShape, TopAbs_EDGE);
+  for (; anExplo.More(); anExplo.Next())
+  {
+    const TopoDS_Shape& anEdge = anExplo.Current();
+    TopTools_ListIteratorOfListOfShape itl (aEdges);
+    for (; itl.More(); itl.Next())
+    {
+      const TopoDS_Shape& anEdgeInFace = itl.Value();
+      if (anEdgeInFace.IsSame(anEdge))
+      {
+        theSeqEdges.Append (anEdgeInFace);
+        break;
+      }
+    }
+  }
+
+  if (theSeqEdges.Length() == 1)
+    return;
+
+  TopTools_IndexedDataMapOfShapeListOfShape aVEmap;
+  for (Standard_Integer ii = 1; ii <= theSeqEdges.Length(); ii++)
+    TopExp::MapShapesAndAncestors (theSeqEdges(ii), TopAbs_VERTEX, TopAbs_EDGE, aVEmap);
+
+  TopoDS_Vertex aFirstVertex;
+  TopoDS_Edge aFirstEdge;
+  for (Standard_Integer ii = 1; ii <= aVEmap.Extent(); ii++)
+  {
+    const TopoDS_Vertex& aVertex = TopoDS::Vertex (aVEmap.FindKey(ii));
+    const TopTools_ListOfShape& aElist = aVEmap(ii);
+    if (aElist.Extent() == 1)
+    {
+      const TopoDS_Edge& anEdge = TopoDS::Edge(aElist.First());
+      TopoDS_Vertex aV1, aV2;
+      TopExp::Vertices(anEdge, aV1, aV2, Standard_True); //with orientation
+      if (aV1.IsSame(aVertex))
+      {
+        aFirstVertex = aVertex;
+        aFirstEdge = anEdge;
+        break;
+      }
+    }
+  }
+
+  if (aFirstEdge.IsNull()) //closed set of edges
+  {
+    //Standard_Real aPeriod = 0.;
+    Standard_Integer IndCoord = DefineClosedness (theFace);
+    /*
+    BRepAdaptor_Surface aBAsurf (theFace, Standard_False);
+    if (IndCoord == 1)
+      aPeriod = aBAsurf.LastUParameter() - aBAsurf.FirstUParameter();
+    else if (IndCoord == 2)
+      aPeriod = aBAsurf.LastVParameter() - aBAsurf.FirstVParameter();
+    */
+    
+    if (IndCoord != 0)
+    {
+      Standard_Real aMaxDelta = 0.;
+      for (Standard_Integer ii = 1; ii <= aVEmap.Extent(); ii++)
+      {
+        const TopoDS_Vertex& aVertex = TopoDS::Vertex (aVEmap.FindKey(ii));
+        const TopTools_ListOfShape& aElist = aVEmap(ii);
+        const TopoDS_Edge& anEdge1 = TopoDS::Edge(aElist.First());
+        const TopoDS_Edge& anEdge2 = TopoDS::Edge(aElist.Last());
+        Standard_Real aParam1 = BRep_Tool::Parameter(aVertex, anEdge1);
+        Standard_Real aParam2 = BRep_Tool::Parameter(aVertex, anEdge2);
+        BRepAdaptor_Curve2d aBAcurve1 (anEdge1, theFace);
+        BRepAdaptor_Curve2d aBAcurve2 (anEdge2, theFace);
+        gp_Pnt2d aPnt1 = aBAcurve1.Value(aParam1);
+        gp_Pnt2d aPnt2 = aBAcurve2.Value(aParam2);
+        Standard_Real aDelta = Abs(aPnt1.Coord(IndCoord) - aPnt2.Coord(IndCoord));
+        if (aDelta > aMaxDelta)
+        {
+          aMaxDelta = aDelta;
+          aFirstVertex = aVertex;
+        }
+      }
+      const TopTools_ListOfShape& aElist = aVEmap.FindFromKey(aFirstVertex);
+      TopTools_ListIteratorOfListOfShape itl (aElist);
+      for (; itl.More(); itl.Next())
+      {
+        const TopoDS_Edge& anEdge = TopoDS::Edge(itl.Value());
+        TopoDS_Vertex aV1, aV2;
+        TopExp::Vertices(anEdge, aV1, aV2, Standard_True); //with orientation
+        if (aV1.IsSame(aFirstVertex))
+        {
+          aFirstEdge = anEdge;
+          break;
+        }
+      }
+    }
+  }
+
+  Standard_Integer aNbEdges = theSeqEdges.Length();
+  theSeqEdges.Clear();
+  theSeqEdges.Append (aFirstEdge);
+  TopoDS_Edge anEdge = aFirstEdge;
+  for (;;)
+  {
+    TopoDS_Vertex aLastVertex = TopExp::LastVertex (anEdge, Standard_True); //with orientation
+    if (aLastVertex.IsSame(aFirstVertex))
+      break;
+    
+    const TopTools_ListOfShape& aElist = aVEmap.FindFromKey(aLastVertex);
+    if (aElist.Extent() == 1)
+      break;
+    
+    if (aElist.First().IsSame(anEdge))
+      anEdge = TopoDS::Edge(aElist.Last());
+    else
+      anEdge = TopoDS::Edge(aElist.First());
+
+    theSeqEdges.Append (anEdge);
+    if (theSeqEdges.Length() == aNbEdges)
+      break;
+  }
+}
 
 //=======================================================================
 //function : Store
@@ -150,6 +279,14 @@ static void Store(const TopoDS_Edge& theEdge,
                   Handle(BRepAlgo_AsDes) theAsDes2d,
                   TopTools_IndexedDataMapOfShapeListOfShape& theDMVV)
 {
+  // Update vertices
+  TopTools_ListIteratorOfListOfShape aIt(theLV);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Vertex& aV = TopoDS::Vertex(aIt.Value());
+    BRep_Builder().UpdateVertex(aV, theTol);
+  }
+
+  // Get vertices already added to the edge and check the distances to the new ones
   const TopTools_ListOfShape& aLVEx = theAsDes2d->Descendant(theEdge);
   if (!IsToUpdate && aLVEx.IsEmpty()) {
     if (theLV.Extent()) theAsDes2d->Add(theEdge, theLV);
@@ -157,21 +294,23 @@ static void Store(const TopoDS_Edge& theEdge,
   }
   //
   GeomAPI_ProjectPointOnCurve aProjPC;
+  Standard_Real aTolE = 0.0;
   if (IsToUpdate) {
     Standard_Real aT1, aT2;
     const Handle(Geom_Curve)& aC = BRep_Tool::Curve(theEdge, aT1, aT2);
     aProjPC.Init(aC, aT1, aT2);
+    aTolE = BRep_Tool::Tolerance(theEdge);
   }
   //
   TopTools_MapOfShape aMV;
-  TopTools_ListIteratorOfListOfShape aIt(theLV);
-  for (; aIt.More(); aIt.Next()) {
+  for (aIt.Init(theLV); aIt.More(); aIt.Next()) {
     const TopoDS_Vertex& aV = TopoDS::Vertex(aIt.Value());
     if (!aMV.Add(aV)) {
       continue;
     }
     //
     const gp_Pnt& aP = BRep_Tool::Pnt(aV);
+    const Standard_Real aTol = BRep_Tool::Tolerance(aV);
     //
     TopTools_ListOfShape aLVC;
     TopTools_ListIteratorOfListOfShape aItEx(aLVEx);
@@ -181,7 +320,8 @@ static void Store(const TopoDS_Edge& theEdge,
         break;
       }
       const gp_Pnt& aPEx = BRep_Tool::Pnt(aVEx);
-      if (aP.IsEqual(aPEx, theTol)) {
+      const Standard_Real aTolVEx = BRep_Tool::Tolerance(aVEx);
+      if (aP.IsEqual(aPEx, aTol + aTolVEx)) {
         aLVC.Append(aVEx);
       }
     }
@@ -197,16 +337,13 @@ static void Store(const TopoDS_Edge& theEdge,
         continue;
       }
       //
-      if (aProjPC.LowerDistance() > theTol) {
+      if (aProjPC.LowerDistance() > aTol + aTolE) {
         continue;
       }
       //
       Standard_Real aT = aProjPC.LowerDistanceParameter();
       TopoDS_Shape aLocalShape = aV.Oriented(TopAbs_INTERNAL);
-      BRep_Builder().UpdateVertex(TopoDS::Vertex(aLocalShape), aT, theEdge, theTol);
-    }
-    else {
-      BRep_Builder().UpdateVertex(aV, theTol);
+      BRep_Builder().UpdateVertex(TopoDS::Vertex(aLocalShape), aT, theEdge, aTol);
     }
     //
     if (aLVC.Extent()) {
@@ -505,7 +642,7 @@ static void EdgeInter(const TopoDS_Face&              F,
     // Vertex storage in DS.
     //---------------------------------
     Standard_Real TolStore = BRep_Tool::Tolerance(E1) + BRep_Tool::Tolerance(E2);
-    TolStore = Max(TolStore, 10.*Tol);
+    TolStore = Max (TolStore, Tol);
     Store (E1,E2,LV1,LV2,TolStore,AsDes, aDMVV);
   }
 }
@@ -518,10 +655,13 @@ static void RefEdgeInter(const TopoDS_Face&              F,
                          const BRepAdaptor_Surface&      BAsurf,
                          const TopoDS_Edge&              E1,
                          const TopoDS_Edge&              E2,
+                         const TopAbs_Orientation        theOr1,
+                         const TopAbs_Orientation        theOr2,
                          const Handle(BRepAlgo_AsDes)&   AsDes,
                          Standard_Real                   Tol,
                          Standard_Boolean                WithOri,
-                         gp_Pnt&                         Pref,
+                         const TopoDS_Vertex&            theVref,
+                         BRepAlgo_Image&                 theImageVV,
                          TopTools_IndexedDataMapOfShapeListOfShape& aDMVV,
                          Standard_Boolean&               theCoincide)
 {
@@ -541,7 +681,7 @@ static void RefEdgeInter(const TopoDS_Face&              F,
     return;
 
   Standard_Real f[3],l[3];
-  Standard_Real TolDub = 1.e-7;
+  Standard_Real TolDub = 1.e-7, TolLL = 0.0;
   Standard_Integer i;
 
   //BRep_Tool::Range(E1, f[1], l[1]);
@@ -558,29 +698,26 @@ static void RefEdgeInter(const TopoDS_Face&              F,
   BRepLib::BuildCurve3d(E1);
   BRepLib::BuildCurve3d(E2);
 
-  Standard_Real TolSum = BRep_Tool::Tolerance(E1) + BRep_Tool::Tolerance(E2);
-  TolSum = Max( TolSum, 1.e-5 );
-
   TColgp_SequenceOfPnt   ResPoints;
   TColStd_SequenceOfReal ResParamsOnE1, ResParamsOnE2;
   gp_Pnt DegPoint;
   Standard_Boolean WithDegen = BRep_Tool::Degenerated(E1) || BRep_Tool::Degenerated(E2);
   
   if (WithDegen)
+  {
+    Standard_Integer ideg = (BRep_Tool::Degenerated(E1))? 1 : 2;
+    TopoDS_Iterator iter( EI[ideg] );
+    if (iter.More())
     {
-      Standard_Integer ideg = (BRep_Tool::Degenerated(E1))? 1 : 2;
-      TopoDS_Iterator iter( EI[ideg] );
-      if (iter.More())
-        {
-          const TopoDS_Vertex& vdeg = TopoDS::Vertex(iter.Value());
-          DegPoint = BRep_Tool::Pnt(vdeg);
-        }
-      else
-        {
-          BRepAdaptor_Curve CEdeg( EI[ideg], F );
-          DegPoint = CEdeg.Value( CEdeg.FirstParameter() );
-        }
+      const TopoDS_Vertex& vdeg = TopoDS::Vertex(iter.Value());
+      DegPoint = BRep_Tool::Pnt(vdeg);
     }
+    else
+    {
+      BRepAdaptor_Curve CEdeg( EI[ideg], F );
+      DegPoint = CEdeg.Value( CEdeg.FirstParameter() );
+    }
+  }
   //
   Handle(Geom2d_Curve) pcurve1 = BRep_Tool::CurveOnSurface(E1, F, f[1], l[1]);
   Handle(Geom2d_Curve) pcurve2 = BRep_Tool::CurveOnSurface(E2, F, f[2], l[2]);
@@ -590,113 +727,127 @@ static void RefEdgeInter(const TopoDS_Face&              F,
       (GAC2.GetType() == GeomAbs_Line))
   {
     // Just quickly check if lines coincide
-    if (GAC1.Line().Direction().IsParallel (GAC2.Line().Direction(), 1.e-8))
+    Standard_Real anAngle = Abs(GAC1.Line().Direction().Angle(GAC2.Line().Direction()));
+    if (anAngle <= 1.e-8 || M_PI - anAngle <= 1.e-8)
     {
       theCoincide = Standard_True;
       return;
     }
+    else
+    {
+      // Take into account the intersection range of line-line intersection
+      // (the smaller angle between curves, the bigger range)
+      TolLL = IntTools_Tools::ComputeIntRange(TolDub, TolDub, anAngle);
+      TolLL = Min (TolLL, 1.e-5);
+    }
   }
-
+  
   Geom2dInt_GInter Inter2d( GAC1, GAC2, TolDub, TolDub );
   //
   if (!Inter2d.IsDone() || !Inter2d.NbPoints()) {
     theCoincide = (Inter2d.NbSegments() &&
-                  (GAC1.GetType() == GeomAbs_Line) &&
-                  (GAC2.GetType() == GeomAbs_Line));
+                   (GAC1.GetType() == GeomAbs_Line) &&
+                   (GAC2.GetType() == GeomAbs_Line));
     return;
   }
   //
   for (i = 1; i <= Inter2d.NbPoints(); i++)
+  {
+    gp_Pnt P3d;
+    if (WithDegen)
+      P3d = DegPoint;
+    else
     {
-      gp_Pnt P3d;
-      if (WithDegen)
-        P3d = DegPoint;
-      else
-        {
-          gp_Pnt2d P2d = Inter2d.Point(i).Value();
-          P3d = BAsurf.Value( P2d.X(), P2d.Y() );
-        }
-      ResPoints.Append( P3d );
-      ResParamsOnE1.Append( Inter2d.Point(i).ParamOnFirst() );
-      ResParamsOnE2.Append( Inter2d.Point(i).ParamOnSecond() );
+      gp_Pnt2d P2d = Inter2d.Point(i).Value();
+      P3d = BAsurf.Value( P2d.X(), P2d.Y() );
     }
+    ResPoints.Append( P3d );
+    ResParamsOnE1.Append( Inter2d.Point(i).ParamOnFirst() );
+    ResParamsOnE2.Append( Inter2d.Point(i).ParamOnSecond() );
+  }
   
   for (i = 1; i <= ResPoints.Length(); i++)
+  {
+    Standard_Real aT1 = ResParamsOnE1(i); //ponc1.Parameter();
+    Standard_Real aT2 = ResParamsOnE2(i); //ponc2.Parameter();
+    if (Precision::IsInfinite(aT1) || Precision::IsInfinite(aT2))
     {
-      Standard_Real aT1 = ResParamsOnE1(i); //ponc1.Parameter();
-      Standard_Real aT2 = ResParamsOnE2(i); //ponc2.Parameter();
-      if (Precision::IsInfinite(aT1) || Precision::IsInfinite(aT2))
-        {
 #ifdef OCCT_DEBUG
-          std::cout << "Inter2d : Solution rejected due to infinite parameter"<<std::endl;
+      std::cout << "Inter2d : Solution rejected due to infinite parameter"<<std::endl;
 #endif
-          continue;
-        }
-      
-      gp_Pnt P = ResPoints(i); //ponc1.Value();
-      TopoDS_Vertex aNewVertex = BRepLib_MakeVertex(P);
-      aNewVertex.Orientation(TopAbs_INTERNAL);
-      B.UpdateVertex( aNewVertex, aT1, E1, Tol );
-      B.UpdateVertex( aNewVertex, aT2, E2, Tol );
-      gp_Pnt P1 = CE1.Value(aT1);
-      gp_Pnt P2 = CE2.Value(aT2);
-      Standard_Real dist1, dist2, dist3;
-      dist1 = P1.Distance(P);
-      dist2 = P2.Distance(P);
-      dist3 = P1.Distance(P2);
-      dist1 = Max( dist1, dist2 );
-      dist1 = Max( dist1, dist3 );
-      B.UpdateVertex( aNewVertex, dist1 );
-      
-#ifdef OCCT_DEBUG
-      if (aT1 < f[1]-Tol  || aT1 > l[1]+Tol)
-        {
-          std::cout << "out of limit"<<std::endl;
-          std::cout<<"aT1 = "<<aT1<<", f[1] = "<<f[1]<<", l[1] = "<<l[1]<<std::endl;
-        }
-      if (aT2 < f[2]-Tol  || aT2 > l[2]+Tol)
-        {
-          std::cout << "out of limit"<<std::endl;
-          std::cout<<"aT2 = "<<aT2<<", f[2] = "<<f[2]<<", l[2] = "<<l[2]<<std::endl;
-        }
-      Standard_Real MilTol2 = 1000*Tol*Tol;
-      if (P1.SquareDistance(P) >  MilTol2 || P2.SquareDistance(P) > MilTol2 || P1.Distance(P2) > 2.*Tol)
-        {
-          std::cout << "Inter2d : Solution rejected"<<std::endl;
-          std::cout<<"P  = "<<P.X()<<" "<<P.Y()<<" "<<P.Z()<<std::endl;
-          std::cout<<"P1 = "<<P1.X()<<" "<<P1.Y()<<" "<<P1.Z()<<std::endl;
-          std::cout<<"P2 = "<<P2.X()<<" "<<P2.Y()<<" "<<P2.Z()<<std::endl;
-          std::cout<<"MaxDist = "<<dist1<<std::endl;
-        }
-#endif
-      //define the orientation of a new vertex
-      TopAbs_Orientation OO1 = TopAbs_REVERSED;
-      TopAbs_Orientation OO2 = TopAbs_REVERSED;
-      if (WithOri)
-        {
-          BRepAdaptor_Curve2d PCE1( E1, F );
-          BRepAdaptor_Curve2d PCE2( E2, F );
-          gp_Pnt2d P2d1, P2d2;
-          gp_Vec2d V1, V2, V1or, V2or;
-          PCE1.D1( aT1, P2d1, V1 );
-          PCE2.D1( aT2, P2d2, V2 );
-          V1or = V1; V2or = V2;
-          if (E1.Orientation() == TopAbs_REVERSED) V1or.Reverse();
-          if (E2.Orientation() == TopAbs_REVERSED) V2or.Reverse();
-          Standard_Real CrossProd = V2or ^ V1;
-#ifdef OCCT_DEBUG
-          if (Abs(CrossProd) <= gp::Resolution())
-            std::cout<<std::endl<<"CrossProd = "<<CrossProd<<std::endl;
-#endif
-          if (CrossProd > 0.)
-            OO1 = TopAbs_FORWARD;
-          CrossProd = V1or ^ V2;
-          if (CrossProd > 0.)
-            OO2 = TopAbs_FORWARD;
-        }
-      LV1.Append( aNewVertex.Oriented(OO1) );
-      LV2.Append( aNewVertex.Oriented(OO2) );
+      continue;
     }
+    
+    gp_Pnt P = ResPoints(i); //ponc1.Value();
+    TopoDS_Vertex aNewVertex = BRepLib_MakeVertex(P);
+    aNewVertex.Orientation(TopAbs_INTERNAL);
+    B.UpdateVertex( aNewVertex, aT1, E1, Tol );
+    B.UpdateVertex( aNewVertex, aT2, E2, Tol );
+    gp_Pnt P1 = CE1.Value(aT1);
+    gp_Pnt P2 = CE2.Value(aT2);
+    Standard_Real dist1, dist2, dist3;
+    dist1 = P1.Distance(P);
+    dist2 = P2.Distance(P);
+    dist3 = P1.Distance(P2);
+    dist1 = Max( dist1, dist2 );
+    dist1 = Max( dist1, dist3 );
+    B.UpdateVertex( aNewVertex, dist1 );
+    
+#ifdef OCCT_DEBUG
+    if (aT1 < f[1]-Tol  || aT1 > l[1]+Tol)
+    {
+      std::cout << "out of limit"<<std::endl;
+      std::cout<<"aT1 = "<<aT1<<", f[1] = "<<f[1]<<", l[1] = "<<l[1]<<std::endl;
+    }
+    if (aT2 < f[2]-Tol  || aT2 > l[2]+Tol)
+    {
+      std::cout << "out of limit"<<std::endl;
+      std::cout<<"aT2 = "<<aT2<<", f[2] = "<<f[2]<<", l[2] = "<<l[2]<<std::endl;
+    }
+    Standard_Real MilTol2 = 1000*Tol*Tol;
+    if (P1.SquareDistance(P) >  MilTol2 || P2.SquareDistance(P) > MilTol2 || P1.Distance(P2) > 2.*Tol)
+    {
+      std::cout << "Inter2d : Solution rejected"<<std::endl;
+      std::cout<<"P  = "<<P.X()<<" "<<P.Y()<<" "<<P.Z()<<std::endl;
+      std::cout<<"P1 = "<<P1.X()<<" "<<P1.Y()<<" "<<P1.Z()<<std::endl;
+      std::cout<<"P2 = "<<P2.X()<<" "<<P2.Y()<<" "<<P2.Z()<<std::endl;
+      std::cout<<"MaxDist = "<<dist1<<std::endl;
+    }
+#endif
+    //define the orientation of a new vertex
+    TopAbs_Orientation OO1 = TopAbs_REVERSED;
+    TopAbs_Orientation OO2 = TopAbs_REVERSED;
+    if (WithOri)
+    {
+      BRepAdaptor_Curve2d PCE1( E1, F );
+      BRepAdaptor_Curve2d PCE2( E2, F );
+      gp_Pnt2d P2d1, P2d2;
+      gp_Vec2d V1, V2, V1or, V2or;
+      PCE1.D1( aT1, P2d1, V1 );
+      PCE2.D1( aT2, P2d2, V2 );
+      V1or = V1; V2or = V2;
+      if (E1.Orientation() == TopAbs_REVERSED) V1or.Reverse();
+      if (E2.Orientation() == TopAbs_REVERSED) V2or.Reverse();
+      Standard_Real CrossProd = V2or ^ V1;
+#ifdef OCCT_DEBUG
+      if (Abs(CrossProd) <= gp::Resolution())
+        std::cout<<std::endl<<"CrossProd = "<<CrossProd<<std::endl;
+#endif
+      if (CrossProd > 0.)
+        OO1 = TopAbs_FORWARD;
+      CrossProd = V1or ^ V2;
+      if (CrossProd > 0.)
+        OO2 = TopAbs_FORWARD;
+    }
+
+    if (theOr1 != TopAbs_EXTERNAL)
+      OO1 = theOr1;
+    if (theOr2 != TopAbs_EXTERNAL)
+      OO2 = theOr2;
+    
+    LV1.Append( aNewVertex.Oriented(OO1) );
+    LV2.Append( aNewVertex.Oriented(OO2) );
+  }
   
   //----------------------------------
   // Test at end.
@@ -755,7 +906,7 @@ static void RefEdgeInter(const TopoDS_Face&              F,
         while (j < i) {      
           P1 = BRep_Tool::Pnt(TopoDS::Vertex(it1LV1.Value()));
           P2 = BRep_Tool::Pnt(TopoDS::Vertex(it2LV1.Value()));
-          if (P1.IsEqual(P2,10*Tol)) {
+          if (P1.IsEqual(P2, Tol)) {
             LV1.Remove(it1LV1);
             LV2.Remove(it1LV2);
             if (AffichPurge) std::cout <<"Doubles removed in EdgeInter."<<std::endl;
@@ -775,6 +926,7 @@ static void RefEdgeInter(const TopoDS_Face&              F,
 ////-----------------------------------------------------
     if(LV1.Extent() > 1) {
       //std::cout << "IFV - RefEdgeInter: remove vertex" << std::endl;
+      gp_Pnt Pref = BRep_Tool::Pnt(theVref);
       Standard_Real dmin = RealLast();
       TopoDS_Vertex Vmin;
       for (it1LV1.Initialize(LV1); it1LV1.More(); it1LV1.Next()) {
@@ -794,10 +946,23 @@ static void RefEdgeInter(const TopoDS_Face&              F,
         }
       }
     }
-      
+
+    TopTools_ListIteratorOfListOfShape itl (LV1);
+    for (; itl.More(); itl.Next())
+    {
+      TopoDS_Shape aNewVertex = itl.Value();
+      aNewVertex.Orientation(TopAbs_FORWARD);
+      if (theImageVV.HasImage (theVref))
+        theImageVV.Add (theVref.Oriented(TopAbs_FORWARD), aNewVertex);
+      else
+        theImageVV.Bind (theVref.Oriented(TopAbs_FORWARD), aNewVertex);
+    }
+
 ////-----------------------------------------------------
     Standard_Real TolStore = BRep_Tool::Tolerance(E1) + BRep_Tool::Tolerance(E2);
-    TolStore = Max(TolStore, 10.*Tol);
+    TolStore = Max (TolStore, Tol);
+    // Compare to Line-Line tolerance
+    TolStore = Max (TolStore, TolLL);
     Store (E1,E2,LV1,LV2,TolStore,AsDes, aDMVV);
   }
 }
@@ -1406,6 +1571,7 @@ void BRepOffset_Inter2d::Compute (const Handle(BRepAlgo_AsDes)&     AsDes,
                                   const TopoDS_Face&                F,
                                   const TopTools_IndexedMapOfShape& NewEdges,
                                   const Standard_Real               Tol,
+                                  const TopTools_DataMapOfShapeListOfShape& theEdgeIntEdges,
                                   TopTools_IndexedDataMapOfShapeListOfShape& theDMVV)
 {
 #ifdef DRAW
@@ -1441,12 +1607,41 @@ void BRepOffset_Inter2d::Compute (const Handle(BRepAlgo_AsDes)&     AsDes,
     
     while (j < i && it2LE.More()) {
       const TopoDS_Edge& E2 = TopoDS::Edge(it2LE.Value());
+
+      Standard_Boolean ToIntersect = Standard_True;
+      if (theEdgeIntEdges.IsBound(E1))
+      {
+        const TopTools_ListOfShape& aElist = theEdgeIntEdges(E1);
+        TopTools_ListIteratorOfListOfShape itedges (aElist);
+        for (; itedges.More(); itedges.Next())
+          if (E2.IsSame (itedges.Value()))
+            ToIntersect = Standard_False;
+        
+        if (ToIntersect)
+        {
+          for (itedges.Initialize(aElist); itedges.More(); itedges.Next())
+          {
+            const TopoDS_Shape& anEdge = itedges.Value();
+            if (theEdgeIntEdges.IsBound(anEdge))
+            {
+              const TopTools_ListOfShape& aElist2 = theEdgeIntEdges(anEdge);
+              TopTools_ListIteratorOfListOfShape itedges2 (aElist2);
+              for (; itedges2.More(); itedges2.Next())
+                if (E2.IsSame (itedges2.Value()))
+                  ToIntersect = Standard_False;
+            }
+          }
+        }
+      }
+      
       //--------------------------------------------------------------
       // Intersections of New edges obtained by intersection
       // between them and with edges of restrictions
       //------------------------------------------------------
-      if ( (!EdgesOfFace.Contains(E1) || !EdgesOfFace.Contains(E2)) &&
-           (NewEdges.Contains(E1) || NewEdges.Contains(E2)) ) {
+      if (ToIntersect &&
+          (!EdgesOfFace.Contains(E1) || !EdgesOfFace.Contains(E2)) &&
+          (NewEdges.Contains(E1) || NewEdges.Contains(E2)) ) {
+        
         TopoDS_Shape aLocalShape = F.Oriented(TopAbs_FORWARD);
         EdgeInter(TopoDS::Face(aLocalShape),BAsurf,E1,E2,AsDes,Tol,Standard_True, theDMVV);
 //          EdgeInter(TopoDS::Face(F.Oriented(TopAbs_FORWARD)),E1,E2,AsDes,Tol,Standard_True);
@@ -1467,11 +1662,14 @@ Standard_Boolean BRepOffset_Inter2d::ConnexIntByInt
   BRepOffset_Offset&            OFI,
   TopTools_DataMapOfShapeShape& MES,
   const TopTools_DataMapOfShapeShape& Build,
+  const Handle(BRepAlgo_AsDes)& theAsDes,
   const Handle(BRepAlgo_AsDes)& AsDes2d,
   const Standard_Real           Offset,
   const Standard_Real           Tol,
   const BRepOffset_Analyse&     Analyse,
   TopTools_IndexedMapOfShape&   FacesWithVerts,
+  BRepAlgo_Image&               theImageVV,
+  TopTools_DataMapOfShapeListOfShape& theEdgeIntEdges,
   TopTools_IndexedDataMapOfShapeListOfShape& theDMVV)
 {  
 
@@ -1529,8 +1727,7 @@ Standard_Boolean BRepOffset_Inter2d::ConnexIntByInt
       continue; // Protection from case when explorer does not contain edges.
     CurE = FirstE  = wexp.Current();
     TopTools_IndexedMapOfShape Edges;
-    Standard_Boolean ToReverse1, ToReverse2;
-    ToReverse1 = IsOrientationChanged(Edges, CurE);
+    
     while (!end) {
       wexp.Next();
       if (wexp.More()) {
@@ -1541,10 +1738,7 @@ Standard_Boolean BRepOffset_Inter2d::ConnexIntByInt
       }
       if (CurE.IsSame(NextE)) continue;
 
-      ToReverse2 = IsOrientationChanged(Edges, NextE);
-
       TopoDS_Vertex Vref = CommonVertex(CurE, NextE); 
-      gp_Pnt Pref = BRep_Tool::Pnt(Vref);
 
       CurE = Analyse.EdgeReplacement (FI, CurE);
       NextE = Analyse.EdgeReplacement (FI, NextE);
@@ -1559,21 +1753,38 @@ Standard_Boolean BRepOffset_Inter2d::ConnexIntByInt
       TopTools_ListOfShape LV1,LV2;
       Standard_Boolean     DoInter = 1;
       TopoDS_Shape         NE1,NE2;
+      TopTools_SequenceOfShape NE1seq, NE2seq;
+      TopAbs_Orientation   anOr1 = TopAbs_EXTERNAL, anOr2 = TopAbs_EXTERNAL;
       
+      Standard_Integer aChoice = 0;
       if (Build.IsBound(CurE) && Build.IsBound(NextE)) {
+        aChoice = 1;
         NE1 = Build(CurE );
         NE2 = Build(NextE);
+        GetEdgesOrientedInFace (NE1, FIO, theAsDes, NE1seq);
+        GetEdgesOrientedInFace (NE2, FIO, theAsDes, NE2seq);
+        anOr1 = TopAbs_REVERSED;
+        anOr2 = TopAbs_FORWARD;
       }
       else if (Build.IsBound(CurE) && MES.IsBound(NEO)) {
+        aChoice = 2;
         NE1 = Build(CurE);
         NE2 = MES  (NEO);
+        NE2.Orientation (NextE.Orientation());
+        GetEdgesOrientedInFace (NE1, FIO, theAsDes, NE1seq);
+        NE2seq.Append (NE2);
+        anOr1 = TopAbs_REVERSED;
+        anOr2 = TopAbs_FORWARD;
       }
       else if (Build.IsBound(NextE) && MES.IsBound(CEO)) {
+        aChoice = 3;
         NE1 = Build(NextE);
         NE2 = MES(CEO);
-        Standard_Boolean Tmp = ToReverse1;
-        ToReverse1 = ToReverse2;
-        ToReverse2 = Tmp;
+        NE2.Orientation (CurE.Orientation());
+        GetEdgesOrientedInFace (NE1, FIO, theAsDes, NE1seq);
+        NE2seq.Append (NE2);
+        anOr1 = TopAbs_FORWARD;
+        anOr2 = TopAbs_REVERSED;
       }
       else {
         DoInter = 0;
@@ -1583,23 +1794,43 @@ Standard_Boolean BRepOffset_Inter2d::ConnexIntByInt
         // NE1,NE2 can be a compound of Edges.
         //------------------------------------
         Standard_Boolean bCoincide;
-        TopExp_Explorer Exp1, Exp2;
-        for (Exp1.Init(NE1, TopAbs_EDGE); Exp1.More(); Exp1.Next()) {
-          TopoDS_Edge aE1 = TopoDS::Edge(Exp1.Current());
-          for (Exp2.Init(NE2, TopAbs_EDGE); Exp2.More(); Exp2.Next()) {
-            TopoDS_Edge aE2 = TopoDS::Edge(Exp2.Current());
-
-            //Correct orientation of edges
-            if (ToReverse1)
-              aE1.Reverse();
-            if (ToReverse2)
-              aE2.Reverse();
-            //////////////////////////////
-            
-            RefEdgeInter(FIO, BAsurf, aE1, aE2, AsDes2d,
-                         Tol, Standard_True, Pref, theDMVV, bCoincide);
-          }
+        TopoDS_Edge aE1, aE2;
+        if (aChoice == 1 || aChoice == 2)
+        {
+          aE1 = TopoDS::Edge (NE1seq.Last());
+          aE2 = TopoDS::Edge (NE2seq.First());
         }
+        else // aChoice == 3
+        {
+          aE1 = TopoDS::Edge (NE1seq.First());
+          aE2 = TopoDS::Edge (NE2seq.Last());
+        }
+
+        if (aE1.Orientation() == TopAbs_REVERSED)
+          anOr1 = TopAbs::Reverse(anOr1);
+        if (aE2.Orientation() == TopAbs_REVERSED)
+          anOr2 = TopAbs::Reverse(anOr2);
+
+        RefEdgeInter(FIO, BAsurf, aE1, aE2, anOr1, anOr2, AsDes2d,
+                     Tol, Standard_True, Vref, theImageVV, theDMVV, bCoincide);
+
+        if (theEdgeIntEdges.IsBound(aE1))
+          theEdgeIntEdges(aE1).Append(aE2);
+        else
+        {
+          TopTools_ListOfShape aElist;
+          aElist.Append(aE2);
+          theEdgeIntEdges.Bind (aE1, aElist);
+        }
+        if (theEdgeIntEdges.IsBound(aE2))
+          theEdgeIntEdges(aE2).Append(aE1);
+        else
+        {
+          TopTools_ListOfShape aElist;
+          aElist.Append(aE1);
+          theEdgeIntEdges.Bind (aE2, aElist);
+        }
+        
         //
         // check if some of the offset edges have been
         // generated out of the common vertex
@@ -1622,7 +1853,6 @@ Standard_Boolean BRepOffset_Inter2d::ConnexIntByInt
         }
       }
       CurE = wexp.Current();
-      ToReverse1 = ToReverse2;
     }
   }
   return Standard_True;
@@ -1682,7 +1912,6 @@ void BRepOffset_Inter2d::ConnexIntByIntInVert
       if (CurE.IsSame(NextE)) continue;
       //
       TopoDS_Vertex Vref = CommonVertex(CurE, NextE); 
-      gp_Pnt Pref = BRep_Tool::Pnt(Vref);
       if (!Build.IsBound(Vref)) {
         CurE = NextE;
         continue;
@@ -1697,6 +1926,7 @@ void BRepOffset_Inter2d::ConnexIntByIntInVert
       TopoDS_Edge NEO = TopoDS::Edge(aLocalShape);
       //
       TopoDS_Shape         NE1,NE2;
+      TopAbs_Orientation   anOr1 = TopAbs_EXTERNAL, anOr2 = TopAbs_EXTERNAL;
       
       if (Build.IsBound(CurE) && Build.IsBound(NextE)) {
         NE1 = Build(CurE );
@@ -1729,8 +1959,9 @@ void BRepOffset_Inter2d::ConnexIntByIntInVert
         // intersection with first edge
         for (Exp1.Init(NE1, TopAbs_EDGE); Exp1.More(); Exp1.Next()) {
           const TopoDS_Edge& aE1 = TopoDS::Edge(Exp1.Current());
-          RefEdgeInter(FIO, BAsurf, aE1, aE3, AsDes2d,
-            Tol, Standard_True, Pref, theDMVV, bCoincide);
+          BRepAlgo_Image anEmptyImage;
+          RefEdgeInter(FIO, BAsurf, aE1, aE3, anOr1, anOr2, AsDes2d,
+                       Tol, Standard_True, Vref, anEmptyImage, theDMVV, bCoincide);
           if (bCoincide) {
             // in case of coincidence trim the edge E3 the same way as E1
             Store(aE3, AsDes2d->Descendant(aE1), Tol, Standard_True, AsDes2d, theDMVV);
@@ -1740,8 +1971,9 @@ void BRepOffset_Inter2d::ConnexIntByIntInVert
         // intersection with second edge
         for (Exp1.Init(NE2, TopAbs_EDGE); Exp1.More(); Exp1.Next()) {
           const TopoDS_Edge& aE2 = TopoDS::Edge(Exp1.Current());
-          RefEdgeInter(FIO, BAsurf, aE2, aE3, AsDes2d,
-            Tol, Standard_True, Pref, theDMVV, bCoincide);
+          BRepAlgo_Image anEmptyImage;
+          RefEdgeInter(FIO, BAsurf, aE2, aE3, anOr1, anOr2, AsDes2d,
+                       Tol, Standard_True, Vref, anEmptyImage, theDMVV, bCoincide);
           if (bCoincide) {
             // in case of coincidence trim the edge E3 the same way as E2
             Store(aE3, AsDes2d->Descendant(aE2), Tol, Standard_True, AsDes2d, theDMVV);
@@ -1759,8 +1991,9 @@ void BRepOffset_Inter2d::ConnexIntByIntInVert
         for (Exp1.Next(); Exp1.More(); Exp1.Next()) {
           const TopoDS_Edge& aE3Next = TopoDS::Edge(Exp1.Current());
           if (aME.Contains(aE3Next)) {
-            RefEdgeInter(FIO, BAsurf, aE3Next, aE3, AsDes2d,
-              Tol, Standard_True, Pref, theDMVV, bCoincide);
+            BRepAlgo_Image anEmptyImage;
+            RefEdgeInter(FIO, BAsurf, aE3Next, aE3, anOr1, anOr2, AsDes2d,
+                         Tol, Standard_True, Vref, anEmptyImage, theDMVV, bCoincide);
           }
         }
       }
@@ -1795,7 +2028,8 @@ static void MakeChain(const TopoDS_Shape& theV,
 //purpose  : 
 //=======================================================================
 Standard_Boolean BRepOffset_Inter2d::FuseVertices (const TopTools_IndexedDataMapOfShapeListOfShape& theDMVV,
-                                                   const Handle(BRepAlgo_AsDes)& theAsDes)
+                                                   const Handle(BRepAlgo_AsDes)& theAsDes,
+                                                   BRepAlgo_Image&               theImageVV)
 {
   BRep_Builder aBB;
   TopTools_MapOfShape aMVDone;
@@ -1837,6 +2071,11 @@ Standard_Boolean BRepOffset_Inter2d::FuseVertices (const TopTools_IndexedDataMap
       }
       // and replace the vertex
       theAsDes->Replace(aVOld, aVNew);
+      if (theImageVV.IsImage(aVOld))
+      {
+        const TopoDS_Vertex& aProVertex = TopoDS::Vertex (theImageVV.ImageFrom(aVOld));
+        theImageVV.Add (aProVertex, aVNew.Oriented(TopAbs_FORWARD));
+      }
     }
   }
   return Standard_True;

src/BRepOffset/BRepOffset_Inter2d.hxx

@@ -24,14 +24,17 @@
 #include <TopTools_IndexedMapOfShape.hxx>
 #include <Standard_Real.hxx>
 #include <TopTools_DataMapOfShapeShape.hxx>
+#include <TopTools_DataMapOfShapeListOfShape.hxx>
 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
 class BRepAlgo_AsDes;
-class TopoDS_Face;
+class BRepAlgo_Image;
 class BRepOffset_Analyse;
 class BRepOffset_Offset;
+class TopoDS_Edge;
+class TopoDS_Face;
 
 
-//! Computes the intersections betwwen edges on a face
+//! Computes the intersections between edges on a face
 //! stores result is SD as AsDes from BRepOffset.
 class BRepOffset_Inter2d 
 {
@@ -50,6 +53,7 @@ public:
                                        const TopoDS_Face& F, 
                                        const TopTools_IndexedMapOfShape& NewEdges, 
                                        const Standard_Real Tol,
+                                       const TopTools_DataMapOfShapeListOfShape& theEdgeIntEdges,
                                        TopTools_IndexedDataMapOfShapeListOfShape& theDMVV);
 
   //! Computes the intersection between the offset edges of the <FI>.
@@ -58,15 +62,18 @@ public:
   //! have to be fused using the FuseVertices method.
   //! theDMVV contains the vertices that should be fused.
   Standard_EXPORT static Standard_Boolean ConnexIntByInt (const TopoDS_Face& FI,
-                                              BRepOffset_Offset& OFI,
-                                              TopTools_DataMapOfShapeShape& MES,
-                                              const TopTools_DataMapOfShapeShape& Build,
-                                              const Handle(BRepAlgo_AsDes)& AsDes2d,
-                                              const Standard_Real Offset,
-                                              const Standard_Real Tol,
-                                              const BRepOffset_Analyse& Analyse,
-                                              TopTools_IndexedMapOfShape& FacesWithVerts,
-                                              TopTools_IndexedDataMapOfShapeListOfShape& theDMVV);
+                                                          BRepOffset_Offset& OFI,
+                                                          TopTools_DataMapOfShapeShape& MES,
+                                                          const TopTools_DataMapOfShapeShape& Build,
+                                                          const Handle(BRepAlgo_AsDes)& theAsDes,
+                                                          const Handle(BRepAlgo_AsDes)& AsDes2d,
+                                                          const Standard_Real Offset,
+                                                          const Standard_Real Tol,
+                                                          const BRepOffset_Analyse& Analyse,
+                                                          TopTools_IndexedMapOfShape& FacesWithVerts,
+                                                          BRepAlgo_Image& theImageVV,
+                                                          TopTools_DataMapOfShapeListOfShape& theEdgeIntEdges,
+                                                          TopTools_IndexedDataMapOfShapeListOfShape& theDMVV);
 
   //! Computes the intersection between the offset edges generated
   //! from vertices and stored into AsDes as descendants of the <FI>.
@@ -88,7 +95,9 @@ public:
   //! and updates AsDes by replacing the old vertices
   //! with the new ones.
   Standard_EXPORT static Standard_Boolean FuseVertices (const TopTools_IndexedDataMapOfShapeListOfShape& theDMVV,
-                                                        const Handle(BRepAlgo_AsDes)& theAsDes);
+                                                        const Handle(BRepAlgo_AsDes)& theAsDes,
+                                                        BRepAlgo_Image&               theImageVV);
+                                                        
   //! extents the edge
   Standard_EXPORT static Standard_Boolean ExtentEdge (const TopoDS_Edge& E,
                                                       TopoDS_Edge& NE,

src/BRepOffset/BRepOffset_Inter3d.cxx

@@ -169,6 +169,7 @@ void BRepOffset_Inter3d::FaceInter(const TopoDS_Face& F1,
 {
   TopTools_ListOfShape LInt1, LInt2;
   TopoDS_Edge NullEdge;
+  TopoDS_Face NullFace;
 
   if (F1.IsSame(F2)) return;
   if (IsDone(F1,F2)) return;
@@ -221,11 +222,11 @@ void BRepOffset_Inter3d::FaceInter(const TopoDS_Face& F1,
           if (BRepOffset_Tool::FindCommonShapes(TopoDS::Face(InitF1),
                                                 TopoDS::Face(InitF2),LE,LV)) {
             if (!LE.IsEmpty()) {
-              BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,NullEdge);
+              BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,NullEdge,NullFace,NullFace);
             }
           }
           else {
-            BRepOffset_Tool::Inter3D(F1,F2,LInt1,LInt2,mySide,NullEdge);
+            BRepOffset_Tool::Inter3D(F1,F2,LInt1,LInt2,mySide,NullEdge,NullFace,NullFace);
           }
         }
       }
@@ -236,7 +237,7 @@ void BRepOffset_Inter3d::FaceInter(const TopoDS_Face& F1,
       BRepOffset_Tool::PipeInter(F1,F2,LInt1,LInt2,mySide);
     }
     else {
-      BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,NullEdge);
+      BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,NullEdge,NullFace,NullFace);
     }
   }
   Store (F1,F2,LInt1,LInt2);
@@ -259,6 +260,7 @@ void BRepOffset_Inter3d::ConnexIntByArc(const TopTools_ListOfShape& /*SetOfFaces
   TopTools_ListOfShape           LInt1,LInt2;
   TopoDS_Face                    F1,F2;
   TopoDS_Edge                    NullEdge;
+  TopoDS_Face                    NullFace;
 
   //---------------------------------------------------------------------
   // etape 1 : Intersection of faces // corresponding to the initial faces 
@@ -273,10 +275,13 @@ void BRepOffset_Inter3d::ConnexIntByArc(const TopTools_ListOfShape& /*SetOfFaces
       //-----------------------------------------------------------
       const TopTools_ListOfShape& Anc = Analyse.Ancestors(E);
       if (Anc.Extent() == 2) {
-        F1 = TopoDS::Face(InitOffsetFace.Image(Anc.First()).First());
-        F2 = TopoDS::Face(InitOffsetFace.Image(Anc.Last ()).First());
+        
+        const TopoDS_Face& InitF1 = TopoDS::Face(Anc.First());
+        const TopoDS_Face& InitF2 = TopoDS::Face(Anc.Last());
+        F1 = TopoDS::Face(InitOffsetFace.Image(InitF1).First());
+        F2 = TopoDS::Face(InitOffsetFace.Image(InitF2).First());
         if (!IsDone(F1,F2)) {
-          BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,E,Standard_True);
+          BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,E,InitF1,InitF2);
           Store (F1,F2,LInt1,LInt2);
         }
       }          
@@ -361,7 +366,7 @@ void BRepOffset_Inter3d::ConnexIntByArc(const TopTools_ListOfShape& /*SetOfFaces
                 if (!TangentFaces) {
                   F2 = TopoDS::Face(InitOffsetFace.Image(InitF2).First());
                   if (!IsDone(F1,F2)) {
-                    BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,NullEdge);
+                    BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,NullEdge,NullFace,NullFace);
                     Store (F1,F2,LInt1,LInt2);
                   }
                 }
@@ -371,7 +376,7 @@ void BRepOffset_Inter3d::ConnexIntByArc(const TopTools_ListOfShape& /*SetOfFaces
                 if (!TangentFaces) {
                   F2 = TopoDS::Face(InitOffsetFace.Image(InitF2).First());
                   if (!IsDone(F1,F2)) {
-                    BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,NullEdge);
+                    BRepOffset_Tool::Inter3D (F1,F2,LInt1,LInt2,mySide,NullEdge,NullFace,NullFace);
                     Store (F1,F2,LInt1,LInt2);
                   }
                 }
@@ -635,7 +640,7 @@ void BRepOffset_Inter3d::ConnexIntByInt
       //
       if (!IsDone(NF1,NF2)) {
         TopTools_ListOfShape LInt1,LInt2;
-        BRepOffset_Tool::Inter3D (NF1,NF2,LInt1,LInt2,CurSide,E,bEdge);
+        BRepOffset_Tool::Inter3D (NF1,NF2,LInt1,LInt2,CurSide,E,F1,F2);
         SetDone(NF1,NF2);
         if (!LInt1.IsEmpty()) {
           Store (NF1,NF2,LInt1,LInt2);
@@ -1034,7 +1039,7 @@ void BRepOffset_Inter3d::ContextIntByInt
           TopTools_ListOfShape LInt1,LInt2;
           TopTools_ListOfShape LOE;
           LOE.Append(OE);
-          BRepOffset_Tool::Inter3D (WCF,NF,LInt1,LInt2,Side,E,bEdge);
+          BRepOffset_Tool::Inter3D (WCF,NF,LInt1,LInt2,Side,E,CF,F);
           SetDone(NF,CF);
           if (!LInt1.IsEmpty()) {
             Store (CF,NF,LInt1,LInt2);
@@ -1086,6 +1091,7 @@ void BRepOffset_Inter3d::ContextIntByArc(const TopTools_IndexedMapOfShape& Conte
   TopoDS_Edge                               OE;
   BRep_Builder                              B;  
   TopoDS_Edge                               NullEdge;
+  TopoDS_Face                               NullFace;                  
   Standard_Integer j;
 
   for (j = 1; j <= ContextFaces.Extent(); j++) {
@@ -1255,7 +1261,7 @@ void BRepOffset_Inter3d::ContextIntByArc(const TopTools_IndexedMapOfShape& Conte
             // If no trace try intersection.
             //-------------------------------------------------------
             if (LInt1.IsEmpty()) {
-              BRepOffset_Tool::Inter3D (CF,OF1,LInt1,LInt2,mySide,NullEdge);
+              BRepOffset_Tool::Inter3D (CF,OF1,LInt1,LInt2,mySide,NullEdge,NullFace,NullFace);
             }
             Store (CF,OF1,LInt1,LInt2);
           }

src/BRepOffset/BRepOffset_MakeLoops.cxx

@@ -51,12 +51,14 @@ BRepOffset_MakeLoops::BRepOffset_MakeLoops()
 
 void BRepOffset_MakeLoops::Build(const TopTools_ListOfShape&   LF, 
 				 const Handle(BRepAlgo_AsDes)& AsDes, 
-				 BRepAlgo_Image&               Image)
+				 BRepAlgo_Image&               Image,
+                                 BRepAlgo_Image&               theImageVV)
 {
   TopTools_ListIteratorOfListOfShape    it(LF);
   TopTools_ListIteratorOfListOfShape    itl,itLCE;
   BRepAlgo_Loop                       Loops;
   Loops.VerticesForSubstitute( myVerVerMap );
+  Loops.SetImageVV (theImageVV);
 
   for (; it.More(); it.Next()) {
     const TopoDS_Face& F = TopoDS::Face(it.Value());

src/BRepOffset/BRepOffset_MakeLoops.hxx

@@ -39,11 +39,20 @@ public:
   
   Standard_EXPORT BRepOffset_MakeLoops();
   
-  Standard_EXPORT void Build (const TopTools_ListOfShape& LF, const Handle(BRepAlgo_AsDes)& AsDes, BRepAlgo_Image& Image);
+  Standard_EXPORT void Build (const TopTools_ListOfShape& LF,
+                              const Handle(BRepAlgo_AsDes)& AsDes,
+                              BRepAlgo_Image& Image,
+                              BRepAlgo_Image& theImageVV);
   
-  Standard_EXPORT void BuildOnContext (const TopTools_ListOfShape& LContext, const BRepOffset_Analyse& Analyse, const Handle(BRepAlgo_AsDes)& AsDes, BRepAlgo_Image& Image, const Standard_Boolean InSide);
+  Standard_EXPORT void BuildOnContext (const TopTools_ListOfShape& LContext,
+                                       const BRepOffset_Analyse& Analyse,
+                                       const Handle(BRepAlgo_AsDes)& AsDes,
+                                       BRepAlgo_Image& Image,
+                                       const Standard_Boolean InSide);
   
-  Standard_EXPORT void BuildFaces (const TopTools_ListOfShape& LF, const Handle(BRepAlgo_AsDes)& AsDes, BRepAlgo_Image& Image);
+  Standard_EXPORT void BuildFaces (const TopTools_ListOfShape& LF,
+                                   const Handle(BRepAlgo_AsDes)& AsDes,
+                                   BRepAlgo_Image& Image);
 
 
 

src/BRepOffset/BRepOffset_MakeOffset.cxx

@@ -591,6 +591,7 @@ BRepOffset_MakeOffset::BRepOffset_MakeOffset(const TopoDS_Shape&    S,
 : 
 myOffset     (Offset),
 myTol        (Tol),
+myInitialShape (S),
 myShape      (S),
 myMode       (Mode),
 myInter      (Inter),
@@ -623,6 +624,7 @@ void BRepOffset_MakeOffset::Initialize(const TopoDS_Shape&    S,
                                        const Standard_Boolean RemoveIntEdges)
 {
   myOffset     = Offset;
+  myInitialShape = S;
   myShape      = S;
   myTol        = Tol;
   myMode       = Mode;
@@ -650,9 +652,11 @@ void BRepOffset_MakeOffset::Clear()
   myInitOffsetFace .Clear();
   myInitOffsetEdge .Clear();
   myImageOffset    .Clear();
+  myImageVV        .Clear();
   myFaces          .Clear();  
   myOriginalFaces  .Clear();  
   myFaceOffset     .Clear();
+  myEdgeIntEdges   .Clear();
   myAsDes          ->Clear();
   myDone     = Standard_False;
   myGenerated.Clear();
@@ -1256,7 +1260,7 @@ void BRepOffset_MakeOffset::BuildOffsetByInter()
   {
     const TopoDS_Face& NEF = TopoDS::Face(itLFE.Value());
     Standard_Real aCurrFaceTol = BRep_Tool::Tolerance(NEF);
-    BRepOffset_Inter2d::Compute(AsDes, NEF, NewEdges, aCurrFaceTol, aDMVV);
+    BRepOffset_Inter2d::Compute(AsDes, NEF, NewEdges, aCurrFaceTol, myEdgeIntEdges, aDMVV);
   }
   //----------------------------------------------
   // Intersections 2d on caps.
@@ -1266,10 +1270,10 @@ void BRepOffset_MakeOffset::BuildOffsetByInter()
   {
     const TopoDS_Face& Cork = TopoDS::Face(myFaces(i));
     Standard_Real aCurrFaceTol = BRep_Tool::Tolerance(Cork);
-    BRepOffset_Inter2d::Compute(AsDes, Cork, NewEdges, aCurrFaceTol, aDMVV);
+    BRepOffset_Inter2d::Compute(AsDes, Cork, NewEdges, aCurrFaceTol, myEdgeIntEdges, aDMVV);
   }
   //
-  BRepOffset_Inter2d::FuseVertices(aDMVV, AsDes);
+  BRepOffset_Inter2d::FuseVertices(aDMVV, AsDes, myImageVV);
   //-------------------------------
   // Unwinding of extended Faces.
   //-------------------------------
@@ -1286,7 +1290,7 @@ void BRepOffset_MakeOffset::BuildOffsetByInter()
     }
   }
   else {
-    myMakeLoops.Build(LFE, AsDes, IMOE);
+    myMakeLoops.Build(LFE, AsDes, IMOE, myImageVV);
   }
   //
 #ifdef OCCT_DEBUG
@@ -2526,10 +2530,10 @@ void BRepOffset_MakeOffset::Intersection2D(const TopTools_IndexedMapOfShape& Mod
   Standard_Integer i;
   for (i = 1; i <= Modif.Extent(); i++) {
     const TopoDS_Face& F  = TopoDS::Face(Modif(i));
-    BRepOffset_Inter2d::Compute(myAsDes,F,NewEdges,myTol, aDMVV);
+    BRepOffset_Inter2d::Compute(myAsDes, F, NewEdges, myTol, myEdgeIntEdges, aDMVV);
   }
   //
-  BRepOffset_Inter2d::FuseVertices(aDMVV, myAsDes);
+  BRepOffset_Inter2d::FuseVertices(aDMVV, myAsDes, myImageVV);
   //
 #ifdef OCCT_DEBUG
   if (AffichInt2d) {
@@ -2569,7 +2573,7 @@ void BRepOffset_MakeOffset::MakeLoops(TopTools_IndexedMapOfShape& Modif)
     BuildSplitsOfTrimmedFaces(LF, myAsDes, myImageOffset);
   }
   else {
-    myMakeLoops.Build(LF,myAsDes,myImageOffset);
+    myMakeLoops.Build(LF,myAsDes,myImageOffset,myImageVV);
   }
 
   //-----------------------------------------
@@ -3345,7 +3349,7 @@ const BRepAlgo_Image& BRepOffset_MakeOffset::OffsetEdgesFromShapes() const
 
 const TopTools_IndexedMapOfShape& BRepOffset_MakeOffset::ClosingFaces () const
 {
-  return myFaces;
+  return myOriginalFaces;
 }
 
 
@@ -3998,8 +4002,8 @@ void BRepOffset_MakeOffset::IntersectEdges(const TopTools_ListOfShape& theFaces,
   {
     const TopoDS_Face& aF  = TopoDS::Face (it.Value());
     aTolF = BRep_Tool::Tolerance (aF);
-    if (!BRepOffset_Inter2d::ConnexIntByInt(aF, theMapSF(aF), theMES, theBuild, theAsDes2d,
-                                            myOffset, aTolF, myAnalyse, aMFV, aDMVV))
+    if (!BRepOffset_Inter2d::ConnexIntByInt(aF, theMapSF(aF), theMES, theBuild, theAsDes, theAsDes2d,
+                                            myOffset, aTolF, myAnalyse, aMFV, myImageVV, myEdgeIntEdges, aDMVV))
     {
       myError = BRepOffset_CannotExtentEdge;
       return;
@@ -4015,7 +4019,7 @@ void BRepOffset_MakeOffset::IntersectEdges(const TopTools_ListOfShape& theFaces,
   }
   //
   // fuse vertices on edges
-  if (!BRepOffset_Inter2d::FuseVertices(aDMVV, theAsDes2d))
+  if (!BRepOffset_Inter2d::FuseVertices(aDMVV, theAsDes2d, myImageVV))
   {
     myError = BRepOffset_CannotFuseVertices;
     return;
@@ -4490,9 +4494,24 @@ const TopTools_ListOfShape& BRepOffset_MakeOffset::Generated (const TopoDS_Shape
     Standard_FALLTHROUGH
     case TopAbs_FACE:
     {
-      if (myInitOffsetFace.HasImage (theS))
+      TopoDS_Shape aS = theS;
+      const TopoDS_Shape* aPlanface = myFacePlanfaceMap.Seek(aS);
+      if (aPlanface)
+        aS = TopoDS::Face(*aPlanface);
+      
+      if (!myFaces.Contains (aS) &&
+          myInitOffsetFace.HasImage (aS))
       {
-        myInitOffsetFace.LastImage (theS, myGenerated);
+        myInitOffsetFace.LastImage (aS, myGenerated);
+
+        if (!myFaces.IsEmpty())
+        {
+          // Reverse generated shapes in case of small solids.
+          // Useful only for faces without influence on others.
+          TopTools_ListIteratorOfListOfShape it(myGenerated);
+          for (; it.More(); it.Next())
+            it.Value().Reverse();
+        }
       }
       break;
     }
@@ -4524,9 +4543,33 @@ const TopTools_ListOfShape& BRepOffset_MakeOffset::Generated (const TopoDS_Shape
 //function : Modified
 //purpose  : 
 //=======================================================================
-const TopTools_ListOfShape& BRepOffset_MakeOffset::Modified (const TopoDS_Shape&)
+const TopTools_ListOfShape& BRepOffset_MakeOffset::Modified (const TopoDS_Shape& theShape)
 {
   myGenerated.Clear();
+
+  if (theShape.ShapeType() == TopAbs_FACE)
+  {
+    TopoDS_Shape aS = theShape;
+    const TopoDS_Shape* aPlanface = myFacePlanfaceMap.Seek(aS);
+    if (aPlanface)
+      aS = TopoDS::Face(*aPlanface);
+    
+    if (myFaces.Contains (aS) &&
+        myInitOffsetFace.HasImage (aS))
+    {
+      myInitOffsetFace.LastImage (aS, myGenerated);
+      
+      if (!myFaces.IsEmpty())
+      {
+        // Reverse generated shapes in case of small solids.
+        // Useful only for faces without influence on others.
+        TopTools_ListIteratorOfListOfShape it(myGenerated);
+        for (; it.More(); it.Next())
+          it.Value().Reverse();
+      }
+    }
+  }
+  
   return myGenerated;
 }
 
@@ -4598,6 +4641,53 @@ Standard_Boolean BRepOffset_MakeOffset::IsPlanar()
       if (aPlanarityChecker.IsPlanar())
       {
         gp_Pln aPln = aPlanarityChecker.Plan();
+        Standard_Real u1, u2, v1, v2, um, vm;
+        aSurf->Bounds(u1, u2, v1, v2);
+        Standard_Boolean isInf1 = Precision::IsInfinite(u1), isInf2 = Precision::IsInfinite(u2);
+        if (!isInf1 && !isInf2)
+        {
+          um = (u1 + u2) / 2.;
+        }
+        else if(isInf1 && !isInf2)
+        {
+          um = u2 - 1.;
+        }
+        else if(!isInf1 && isInf2)
+        {
+          um = u1 + 1.;
+        }
+        else //isInf1 && isInf2
+        {
+          um = 0.;
+        }
+        isInf1 = Precision::IsInfinite(v1), isInf2 = Precision::IsInfinite(v2);
+        if (!isInf1 && !isInf2)
+        {
+          vm = (v1 + v2) / 2.;
+        }
+        else if (isInf1 && !isInf2)
+        {
+          vm = v2 - 1.;
+        }
+        else if(!isInf1 && isInf2)
+        {
+          vm = v1 + 1.;
+        }
+        else //isInf1 && isInf2
+        {
+          vm = 0.;
+        }
+        gp_Pnt aP;
+        gp_Vec aD1, aD2;
+        aBAS.D1(um, vm, aP, aD1, aD2);
+        gp_Vec aNorm = aD1.Crossed(aD2);
+        gp_Dir aPlnNorm = aPln.Position().Direction();
+        if (aNorm.Dot(aPlnNorm) < 0.)
+        {
+          aPlnNorm.Reverse();
+          gp_Ax1 anAx(aPln.Position().Location(), aPlnNorm);
+          aPln.SetAxis(anAx);
+        }
         Handle(Geom_Plane) aPlane = new Geom_Plane(aPln);
         TopoDS_Face aPlanarFace;
         aBB.MakeFace(aPlanarFace, aPlane, aTolForFace);

src/BRepOffset/BRepOffset_MakeOffset.hxx

@@ -97,7 +97,7 @@ public:
   
   const TopoDS_Shape& InitShape() const
   {
-    return myShape;
+    return myInitialShape;
   }
 
   //! returns information about offset state.
@@ -231,6 +231,7 @@ private:
 
   Standard_Real myOffset;
   Standard_Real myTol;
+  TopoDS_Shape myInitialShape;
   TopoDS_Shape myShape;
   TopoDS_Compound myFaceComp;
   BRepOffset_Mode myMode;
@@ -248,8 +249,10 @@ private:
   BRepAlgo_Image myInitOffsetFace;
   BRepAlgo_Image myInitOffsetEdge;
   BRepAlgo_Image myImageOffset;
+  BRepAlgo_Image myImageVV;
   TopTools_ListOfShape myWalls;
   Handle(BRepAlgo_AsDes) myAsDes;
+  TopTools_DataMapOfShapeListOfShape myEdgeIntEdges;
   Standard_Boolean myDone;
   BRepOffset_Error myError;
   BRepOffset_MakeLoops myMakeLoops;

src/BRepOffset/BRepOffset_MakeOffset_1.cxx

@@ -195,6 +195,12 @@ static
                          BRepOffset_DataMapOfShapeMapOfShape& theLocValidEdges,
                          BRepOffset_DataMapOfShapeMapOfShape& theNeutralEdges);
 
+static
+  void  MakeInvertedEdgesInvalid(const TopTools_ListOfShape& theLFOffset,
+                                 const TopTools_IndexedDataMapOfShapeListOfShape& theFImages,
+                                 const TopTools_MapOfShape& theInvertedEdges,
+                                 TopTools_IndexedMapOfShape& theInvEdges);
+
 static
   void FindInvalidFaces(TopTools_ListOfShape& theLFImages,
                         const TopTools_IndexedMapOfShape& theInvEdges,
@@ -1030,6 +1036,10 @@ void BuildSplitsOfFaces(const TopTools_ListOfShape& theLF,
   FindInvalidEdges (aLFDone, theFImages, theFacesOrigins, theAnalyse,
                     theInvEdges, theValidEdges, aDMFMIE, aDMFMVE, aDMFMNE);
 
+  // Additional step to mark inverted edges located inside loops
+  // of invalid edges as invalid as well
+  MakeInvertedEdgesInvalid(aLFDone, theFImages, theInvertedEdges, theInvEdges);
+
 #ifdef OFFSET_DEBUG
   // show invalid edges
   TopoDS_Compound aCEInv1;
@@ -2180,6 +2190,82 @@ void FindInvalidEdges (const TopTools_ListOfShape& theLFOffset,
   }
 }
 
+//=======================================================================
+//function : MakeInvertedEdgesInvalid
+//purpose  : Makes inverted edges located inside loop of invalid edges, invalid as well
+//=======================================================================
+void MakeInvertedEdgesInvalid(const TopTools_ListOfShape& theLFOffset,
+                              const TopTools_IndexedDataMapOfShapeListOfShape& theFImages,
+                              const TopTools_MapOfShape& theInvertedEdges,
+                              TopTools_IndexedMapOfShape& theInvEdges)
+{
+  if (theInvEdges.IsEmpty() || theInvertedEdges.IsEmpty())
+    return;
+
+  // Map all invalid edges
+  TopoDS_Compound aCBEInv;
+  BRep_Builder().MakeCompound(aCBEInv);
+  for (Standard_Integer i = 1; i <= theInvEdges.Extent(); ++i)
+  {
+    BRep_Builder().Add(aCBEInv, theInvEdges(i));
+  }
+
+  // Make loops of invalid edges
+  TopTools_ListOfShape aLCB;
+  BOPTools_AlgoTools::MakeConnexityBlocks(aCBEInv, TopAbs_VERTEX, TopAbs_EDGE, aLCB);
+
+  // Analyze each loop on closeness and use only closed ones
+  TopTools_DataMapOfShapeShape aDMVCB;
+
+  for (TopTools_ListOfShape::Iterator itLCB(aLCB); itLCB.More(); itLCB.Next())
+  {
+    const TopoDS_Shape& aCB = itLCB.Value();
+
+    TopTools_IndexedDataMapOfShapeListOfShape aDMVE;
+    TopExp::MapShapesAndAncestors(aCB, TopAbs_VERTEX, TopAbs_EDGE, aDMVE);
+    Standard_Boolean isClosed = Standard_True;
+    for (Standard_Integer iV = 1; iV <= aDMVE.Extent(); ++iV)
+    {
+      if (aDMVE(iV).Extent() != 2)
+      {
+        isClosed = Standard_False;
+        break;
+      }
+    }
+    if (!isClosed)
+      continue;
+
+    // Bind loop to each vertex of the loop
+    for (Standard_Integer iV = 1; iV <= aDMVE.Extent(); ++iV)
+    {
+      aDMVCB.Bind(aDMVE.FindKey(iV), aCB);
+    }
+  }
+
+  // Check if any inverted edges of offset faces are locked inside the loops of invalid edges.
+  // Make such edges invalid as well.
+  for (TopTools_ListOfShape::Iterator itLF(theLFOffset); itLF.More(); itLF.Next())
+  {
+    const TopTools_ListOfShape& aLFIm = theFImages.FindFromKey(itLF.Value());
+    for (TopTools_ListOfShape::Iterator itLFIm(aLFIm); itLFIm.More(); itLFIm.Next())
+    {
+      for (TopExp_Explorer expE(itLFIm.Value(), TopAbs_EDGE); expE.More(); expE.Next())
+      {
+        const TopoDS_Edge& aE = TopoDS::Edge(expE.Current());
+        if (!theInvEdges.Contains(aE) && theInvertedEdges.Contains(aE))
+        {
+          const TopoDS_Shape* pCB1 = aDMVCB.Seek (TopExp::FirstVertex(aE));
+          const TopoDS_Shape* pCB2 = aDMVCB.Seek (TopExp::LastVertex(aE));
+          if (pCB1 && pCB2 && pCB1->IsSame(*pCB2))
+          {
+            theInvEdges.Add(aE);
+          }
+        }
+      }
+    }
+  }
+}
+
 //=======================================================================
 //function : FindInvalidFaces
 //purpose  : Looking for the invalid faces by analyzing their invalid edges
@@ -5678,7 +5764,9 @@ void IntersectFaces(const TopoDS_Shape& theFInv,
   TopAbs_State aSide = TopAbs_OUT;
   TopTools_ListOfShape aLInt1, aLInt2;
   TopoDS_Edge aNullEdge;
-  BRepOffset_Tool::Inter3D(TopoDS::Face(theFi), TopoDS::Face(theFj), aLInt1, aLInt2, aSide, aNullEdge);
+  TopoDS_Face aNullFace;
+  BRepOffset_Tool::Inter3D(TopoDS::Face(theFi), TopoDS::Face(theFj), aLInt1, aLInt2, aSide,
+                           aNullEdge, aNullFace, aNullFace);
   //
   if (aLInt1.IsEmpty()) {
     return;

src/BRepOffset/BRepOffset_Tool.cxx

@@ -1401,8 +1401,9 @@ void BRepOffset_Tool::Inter3D(const TopoDS_Face& F1,
 			      TopTools_ListOfShape& L1,
 			      TopTools_ListOfShape& L2,
 			      const TopAbs_State    Side,
-			      const TopoDS_Edge&     RefEdge,
-			      const Standard_Boolean IsRefEdgeDefined)
+			      const TopoDS_Edge&    RefEdge,
+                              const TopoDS_Face&    theRefFace1,
+                              const TopoDS_Face&    theRefFace2)
 {
 #ifdef DRAW
   if (AffichInter) {
@@ -1445,7 +1446,7 @@ void BRepOffset_Tool::Inter3D(const TopoDS_Face& F1,
   aPF.Perform();
   
   TopTools_IndexedMapOfShape TrueEdges;
-  if (IsRefEdgeDefined)
+  if (!RefEdge.IsNull())
     CheckIntersFF( aPF.PDS(), RefEdge, TrueEdges );
 
   Standard_Boolean addPCurve1 = 1;
@@ -1494,33 +1495,33 @@ void BRepOffset_Tool::Inter3D(const TopoDS_Face& F1,
         if (!BOPTools_AlgoTools2D::HasCurveOnSurface(anEdge, F1)) {
           Handle(Geom2d_Curve) aC2d = aBC.Curve().FirstCurve2d();
           if(!aC3DETrim.IsNull()) {
-		Handle(Geom2d_Curve) aC2dNew;
-		
-		if(aC3DE->IsPeriodic()) {
-                  BOPTools_AlgoTools2D::AdjustPCurveOnFace(F1, f, l,  aC2d, aC2dNew, aContext);
-		  }
-		else {
-                  BOPTools_AlgoTools2D::AdjustPCurveOnFace(F1, aC3DETrim, aC2d, aC2dNew, aContext); 
-		  }
-		aC2d = aC2dNew;
-	      }
-	      BB.UpdateEdge(anEdge, aC2d, F1, aTolEdge);
+            Handle(Geom2d_Curve) aC2dNew;
+            
+            if(aC3DE->IsPeriodic()) {
+              BOPTools_AlgoTools2D::AdjustPCurveOnFace(F1, f, l,  aC2d, aC2dNew, aContext);
+            }
+            else {
+              BOPTools_AlgoTools2D::AdjustPCurveOnFace(F1, aC3DETrim, aC2d, aC2dNew, aContext); 
+            }
+            aC2d = aC2dNew;
+          }
+          BB.UpdateEdge(anEdge, aC2d, F1, aTolEdge);
         }
         
         if (!BOPTools_AlgoTools2D::HasCurveOnSurface(anEdge, F2)) {
           Handle(Geom2d_Curve) aC2d = aBC.Curve().SecondCurve2d();
           if(!aC3DETrim.IsNull()) {
-		Handle(Geom2d_Curve) aC2dNew;
-		
-		if(aC3DE->IsPeriodic()) {
-                  BOPTools_AlgoTools2D::AdjustPCurveOnFace(F2, f, l,  aC2d, aC2dNew, aContext);
-		  }
-		else {
-                  BOPTools_AlgoTools2D::AdjustPCurveOnFace(F2, aC3DETrim, aC2d, aC2dNew, aContext); 
-		  }
-		aC2d = aC2dNew;
-	      }
-	      BB.UpdateEdge(anEdge, aC2d, F2, aTolEdge);
+            Handle(Geom2d_Curve) aC2dNew;
+            
+            if(aC3DE->IsPeriodic()) {
+              BOPTools_AlgoTools2D::AdjustPCurveOnFace(F2, f, l,  aC2d, aC2dNew, aContext);
+            }
+            else {
+              BOPTools_AlgoTools2D::AdjustPCurveOnFace(F2, aC3DETrim, aC2d, aC2dNew, aContext); 
+            }
+            aC2d = aC2dNew;
+          }
+          BB.UpdateEdge(anEdge, aC2d, F2, aTolEdge);
         }
          
         OrientSection (anEdge, F1, F2, O1, O2);
@@ -1563,6 +1564,84 @@ void BRepOffset_Tool::Inter3D(const TopoDS_Face& F1,
   else if (aSurf->IsKind(STANDARD_TYPE(Geom_ElementarySurface)))
     isEl2 = Standard_True;
 
+  if (L1.Extent() > 1 && (!isEl1 || !isEl2) && !theRefFace1.IsNull())
+  {
+    //remove excess edges that are out of range
+    TopoDS_Vertex aV1, aV2;
+    TopExp::Vertices (RefEdge, aV1, aV2);
+    if (!aV1.IsSame(aV2)) //only if RefEdge is open
+    {
+      Handle(Geom_Surface) aRefSurf1 = BRep_Tool::Surface (theRefFace1);
+      Handle(Geom_Surface) aRefSurf2 = BRep_Tool::Surface (theRefFace2);
+      if (aRefSurf1->IsUClosed() || aRefSurf1->IsVClosed() ||
+          aRefSurf2->IsUClosed() || aRefSurf2->IsVClosed())
+      {
+        TopoDS_Edge MinAngleEdge;
+        Standard_Real MinAngle = Precision::Infinite();
+        BRepAdaptor_Curve aRefBAcurve (RefEdge);
+        gp_Pnt aRefPnt = aRefBAcurve.Value ((aRefBAcurve.FirstParameter() + aRefBAcurve.LastParameter())/2);
+        
+        TopTools_ListIteratorOfListOfShape itl (L1);
+        for (; itl.More(); itl.Next())
+        {
+          const TopoDS_Edge& anEdge = TopoDS::Edge (itl.Value());
+          
+          BRepAdaptor_Curve aBAcurve (anEdge);
+          gp_Pnt aMidPntOnEdge = aBAcurve.Value ((aBAcurve.FirstParameter() + aBAcurve.LastParameter())/2);
+          gp_Vec RefToMid (aRefPnt, aMidPntOnEdge);
+          
+          Extrema_ExtPC aProjector (aRefPnt, aBAcurve);
+          if (aProjector.IsDone())
+          {
+            Standard_Integer imin = 0;
+            Standard_Real MinSqDist = Precision::Infinite();
+            for (Standard_Integer ind = 1; ind <= aProjector.NbExt(); ind++)
+            {
+              Standard_Real aSqDist = aProjector.SquareDistance(ind);
+              if (aSqDist < MinSqDist)
+              {
+                MinSqDist = aSqDist;
+                imin = ind;
+              }
+            }
+            if (imin != 0)
+            {
+              gp_Pnt aProjectionOnEdge = aProjector.Point(imin).Value();
+              gp_Vec RefToProj (aRefPnt, aProjectionOnEdge);
+              Standard_Real anAngle = RefToProj.Angle(RefToMid);
+              if (anAngle < MinAngle)
+              {
+                MinAngle = anAngle;
+                MinAngleEdge = anEdge;
+              }
+            }
+          }
+        }
+
+        if (!MinAngleEdge.IsNull())
+        {
+          TopTools_ListIteratorOfListOfShape itlist1 (L1);
+          TopTools_ListIteratorOfListOfShape itlist2 (L2);
+          
+          while (itlist1.More())
+          {
+            const TopoDS_Shape& anEdge = itlist1.Value();
+            if (anEdge.IsSame(MinAngleEdge))
+            {
+              itlist1.Next();
+              itlist2.Next();
+            }
+            else
+            {
+              L1.Remove(itlist1);
+              L2.Remove(itlist2);
+            }
+          }
+        }
+      } //if closed
+    } //if (!aV1.IsSame(aV2))
+  } //if (L1.Extent() > 1 && (!isEl1 || !isEl2) && !theRefFace1.IsNull())
+
   if (L1.Extent() > 1 && (!isEl1 || !isEl2)) {
     TopTools_SequenceOfShape eseq;
     TopTools_SequenceOfShape EdgesForConcat;
@@ -1724,7 +1803,7 @@ void BRepOffset_Tool::Inter3D(const TopoDS_Face& F1,
             eseq.Append( aLocalEdgesForConcat(j) );
         else
           eseq.Append( AssembledEdge );
-      }
+      } //for (i = 1; i <= wseq.Length(); i++)
     } //end of else (when TrueEdges is empty)
     
     if (eseq.Length() < L1.Extent())
@@ -3468,7 +3547,8 @@ void BRepOffset_Tool::ExtentFace (const TopoDS_Face&            F,
       if (ConstShapes.IsBound(E)) ToBuild.UnBind(E);
       if (ToBuild.IsBound(E)) {
         EnLargeFace(TopoDS::Face(ToBuild(E)),StopFace,Standard_False);
-        BRepOffset_Tool::Inter3D (EF,StopFace,LInt1,LInt2,Side,E,Standard_True);
+        TopoDS_Face NullFace;
+        BRepOffset_Tool::Inter3D (EF,StopFace,LInt1,LInt2,Side,E,NullFace,NullFace);
         // No intersection, it may happen for example for a chosen (non-offseted) planar face and 
         // its neighbour offseted cylindrical face, if the offset is directed so that 
         // the radius of the cylinder becomes smaller.

src/BRepOffset/BRepOffset_Tool.hxx

@@ -87,9 +87,10 @@ public:
                                        const TopoDS_Face& F2,
                                        TopTools_ListOfShape& LInt1,
                                        TopTools_ListOfShape& LInt2,
-                                       const TopAbs_State Side,
-                                       const TopoDS_Edge& RefEdge,
-                                       const Standard_Boolean IsRefEdgeDefined = Standard_False);
+                                       const TopAbs_State    Side,
+                                       const TopoDS_Edge&    RefEdge,
+                                       const TopoDS_Face&    RefFace1,
+                                       const TopoDS_Face&    RefFace2);
   
   //! Find if the edges <Edges> of the face <F2> are on
   //! the face <F1>.

src/BRepOffsetAPI/BRepOffsetAPI_MakeOffset.cxx

@@ -17,11 +17,14 @@
 
 #include <BRep_Builder.hxx>
 #include <BRep_Tool.hxx>
+#include <BRepAdaptor_Curve.hxx>
 #include <BRepAdaptor_Surface.hxx>
+#include <BRepAlgo.hxx>
 #include <BRepAlgo_FaceRestrictor.hxx>
 #include <BRepBuilderAPI_MakeFace.hxx>
 #include <BRepFill_ListIteratorOfListOfOffsetWire.hxx>
 #include <BRepFill_OffsetWire.hxx>
+#include <BRepLib.hxx>
 #include <BRepOffsetAPI_MakeOffset.hxx>
 #include <BRepTopAdaptor_FClass2d.hxx>
 #include <Extrema_ExtPS.hxx>
@@ -44,6 +47,50 @@
 static Standard_Boolean AffichSpine = Standard_False;
 #endif
 
+static Standard_Boolean NeedsConvertion (const TopoDS_Wire& theWire)
+{
+  TopoDS_Iterator anIter (theWire);
+  for (; anIter.More(); anIter.Next())
+  {
+    const TopoDS_Edge& anEdge = TopoDS::Edge (anIter.Value());
+    BRepAdaptor_Curve aBAcurve (anEdge);
+    GeomAbs_CurveType aType = aBAcurve.GetType();
+    if (aType != GeomAbs_Line &&
+        aType != GeomAbs_Circle)
+      return Standard_True;
+  }
+
+  return Standard_False;
+}
+
+TopoDS_Face BRepOffsetAPI_MakeOffset::ConvertFace (const TopoDS_Face&  theFace,
+                                                   const Standard_Real theAngleTolerance)
+{
+  TopAbs_Orientation anOr = theFace.Orientation();
+  TopoDS_Face aFace = theFace;
+  aFace.Orientation (TopAbs_FORWARD);
+
+  TopoDS_Face aNewFace = TopoDS::Face (aFace.EmptyCopied());
+  BRep_Builder aBB;
+  TopoDS_Iterator anIter (aFace);
+  for (; anIter.More(); anIter.Next())
+  {
+    TopoDS_Wire aWire = TopoDS::Wire (anIter.Value());
+    if (NeedsConvertion (aWire))
+    {
+      TopAbs_Orientation anOrOfWire = aWire.Orientation();
+      aWire.Orientation (TopAbs_FORWARD);
+      aWire = BRepAlgo::ConvertWire (aWire, theAngleTolerance, aFace);
+      BRepLib::BuildCurves3d (aWire);
+      aWire.Orientation (anOrOfWire);
+    }
+    aBB.Add (aNewFace, aWire);
+  }
+  aNewFace.Orientation (anOr);
+
+  return aNewFace;
+}
+
 //=======================================================================
 //function : BRepOffsetAPI_MakeOffset
 //purpose  : 
@@ -52,7 +99,8 @@ static Standard_Boolean AffichSpine = Standard_False;
 BRepOffsetAPI_MakeOffset::BRepOffsetAPI_MakeOffset()
   : myIsInitialized( Standard_False),
     myJoin(GeomAbs_Arc),
-    myIsOpenResult(Standard_False)
+    myIsOpenResult(Standard_False),
+    myIsToApprox(Standard_False)
 {
 }
 
@@ -83,6 +131,7 @@ void BRepOffsetAPI_MakeOffset::Init(const TopoDS_Face&     Spine,
   myIsInitialized = Standard_True;
   myJoin          = Join;
   myIsOpenResult  = IsOpenResult;
+  myIsToApprox = Standard_False;
   TopExp_Explorer exp;
   for (exp.Init(myFace,TopAbs_WIRE); exp.More();exp.Next()) {
     myWires.Append(exp.Current());
@@ -102,6 +151,7 @@ BRepOffsetAPI_MakeOffset::BRepOffsetAPI_MakeOffset(const TopoDS_Wire& Spine,
   myIsInitialized = Standard_True;
   myJoin = Join;
   myIsOpenResult  = IsOpenResult;
+  myIsToApprox = Standard_False;
 }
 
 //=======================================================================
@@ -116,6 +166,18 @@ void BRepOffsetAPI_MakeOffset::Init(const GeomAbs_JoinType Join,
   myIsOpenResult  = IsOpenResult;
 }
 
+//=======================================================================
+//function : SetApprox
+//purpose  : Set approximation flag
+//           for convertion input contours into ones consisting of
+//           2D circular arcs and 2D linear segments only
+//=======================================================================
+
+void BRepOffsetAPI_MakeOffset::SetApprox(const Standard_Boolean ToApprox)
+{
+  myIsToApprox = ToApprox;
+}
+
 //=======================================================================
 //function : BRepOffsetAPI_MakeOffset
 //purpose  : 
@@ -290,6 +352,46 @@ void BRepOffsetAPI_MakeOffset::Perform(const Standard_Real Offset,
 
   try
   {
+    if (myIsToApprox)
+    {
+      Standard_Real aTol = 0.1;
+      if (myFace.IsNull())
+      {
+        TopoDS_Face aFace;
+        Standard_Boolean OnlyPlane = Standard_True;
+        TopTools_ListIteratorOfListOfShape anItl (myWires);
+        for (; anItl.More(); anItl.Next())
+        {
+          BRepBuilderAPI_MakeFace aFaceMaker (TopoDS::Wire(anItl.Value()), OnlyPlane);
+          if (aFaceMaker.Error() == BRepBuilderAPI_FaceDone)
+          {
+            aFace = aFaceMaker.Face();
+            break;
+          }
+        }
+        for (anItl.Initialize(myWires); anItl.More(); anItl.Next())
+        {
+          const TopoDS_Wire& aWire = TopoDS::Wire(anItl.Value());
+          if (NeedsConvertion (aWire))
+          {
+            TopoDS_Wire aNewWire = BRepAlgo::ConvertWire (aWire, aTol, aFace);
+            BRepLib::BuildCurves3d (aNewWire);
+            aNewWire.Orientation (aWire.Orientation());
+            anItl.ChangeValue() = aNewWire;
+          }
+        }
+      }
+      else
+      {
+        myFace = ConvertFace (myFace, aTol);
+        BRepLib::BuildCurves3d (myFace);
+        myWires.Clear();
+        TopoDS_Iterator anIter (myFace);
+        for (; anIter.More(); anIter.Next())
+          myWires.Append (anIter.Value());
+      }
+    }
+    
     Standard_Integer i = 1;
     BRepFill_ListIteratorOfListOfOffsetWire itOW;
     TopoDS_Compound Res;

src/BRepOffsetAPI/BRepOffsetAPI_MakeOffset.hxx

@@ -69,6 +69,11 @@ public:
   //! Initialize the evaluation of Offseting.
   Standard_EXPORT void Init (const GeomAbs_JoinType Join = GeomAbs_Arc, const Standard_Boolean IsOpenResult = Standard_False);
   
+  //! Set approximation flag
+  //! for convertion input contours into ones consisting of
+  //! 2D circular arcs and 2D linear segments only.
+  Standard_EXPORT void SetApprox (const Standard_Boolean ToApprox);
+  
   //! Initializes the algorithm to construct parallels to the wire Spine.
   Standard_EXPORT void AddWire (const TopoDS_Wire& Spine);
   
@@ -85,7 +90,10 @@ public:
   //! from the shape <S>.
   Standard_EXPORT virtual const TopTools_ListOfShape& Generated (const TopoDS_Shape& S) Standard_OVERRIDE;
 
-
+  //! Converts each wire of the face into contour consisting only of
+  //! arcs and segments. New 3D curves are built too.
+  Standard_EXPORT static TopoDS_Face ConvertFace (const TopoDS_Face& theFace,
+                                                  const Standard_Real theAngleTolerance);
 
 
 protected:
@@ -102,6 +110,7 @@ private:
   Standard_Boolean myLastIsLeft;
   GeomAbs_JoinType myJoin;
   Standard_Boolean myIsOpenResult;
+  Standard_Boolean myIsToApprox;
   TopoDS_Face myFace;
   TopTools_ListOfShape myWires;
   BRepFill_ListOfOffsetWire myLeft;

src/BRepTest/BRepTest_CurveCommands.cxx

@@ -1536,10 +1536,23 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
   char name[100];
 
   BRepOffsetAPI_MakeOffset Paral;
+
+  Standard_Boolean ToApprox = Standard_False;
   GeomAbs_JoinType theJoinType = GeomAbs_Arc;
-  if (n >= 6 && strcmp(a[5], "i") == 0)
-    theJoinType = GeomAbs_Intersection;
-  Paral.Init(theJoinType);
+  
+  Standard_Integer anIndArg = 6;
+  if (n >= 6)
+  {
+    if (strcmp(a[5], "-approx") == 0)
+    {
+      ToApprox = Standard_True;
+      anIndArg++;
+    }
+  
+    if (n >= anIndArg && strcmp(a[anIndArg-1], "i") == 0)
+      theJoinType = GeomAbs_Intersection;
+  }
+  
   TopoDS_Shape Base = DBRep::Get(a[2],TopAbs_FACE);
 
   if ( Base.IsNull())
@@ -1559,6 +1572,7 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
     Base.Orientation(TopAbs_FORWARD);
     Paral.Init(TopoDS::Face(Base), theJoinType);
   }
+  Paral.SetApprox (ToApprox);
 
   Standard_Real U, dU;
   Standard_Integer Nb;
@@ -1566,8 +1580,8 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
   Nb = Draw::Atoi(a[3]);
 
   Standard_Real Alt = 0.;
-  if ( n == 7)
-    Alt = Draw::Atof(a[6]);
+  if (n > anIndArg)
+    Alt = Draw::Atof(a[anIndArg]);
 
   Standard_Integer Compt = 1;
 
@@ -1604,16 +1618,30 @@ Standard_Integer openoffset(Draw_Interpretor& di,
   char name[100];
 
   BRepOffsetAPI_MakeOffset Paral;
+  
+  Standard_Boolean ToApprox = Standard_False;
   GeomAbs_JoinType theJoinType = GeomAbs_Arc;
-  if (n == 6 && strcmp(a[5], "i") == 0)
-    theJoinType = GeomAbs_Intersection;
-  Paral.Init(theJoinType, Standard_True);
+  
+  Standard_Integer anIndArg = 6;
+  if (n >= 6)
+  {
+    if (strcmp(a[5], "-approx") == 0)
+    {
+      ToApprox = Standard_True;
+      anIndArg++;
+    }
+  
+    if (n >= anIndArg && strcmp(a[anIndArg-1], "i") == 0)
+      theJoinType = GeomAbs_Intersection;
+  }
+  
   TopoDS_Shape Base = DBRep::Get(a[2] ,TopAbs_FACE);
 
   if ( Base.IsNull())
   {
     Base = DBRep::Get(a[2], TopAbs_WIRE);
     if (Base.IsNull()) return 1;
+    Paral.Init(theJoinType, Standard_True);
     Paral.AddWire(TopoDS::Wire(Base));
   }
   else
@@ -1621,6 +1649,7 @@ Standard_Integer openoffset(Draw_Interpretor& di,
     Base.Orientation(TopAbs_FORWARD);
     Paral.Init(TopoDS::Face(Base), theJoinType, Standard_True);
   }
+  Paral.SetApprox (ToApprox);
 
   Standard_Real U, dU;
   Standard_Integer Nb;
@@ -1761,6 +1790,72 @@ Standard_Integer edgeintersector(Draw_Interpretor& di,
 
 }
 
+//=================================================================================
+//function : arclinconvert
+//purpose  : Convert a single face to a face with contour made of arcs and segments
+//=================================================================================
+
+static Standard_Integer arclinconvert (Draw_Interpretor& /*dout*/, Standard_Integer n, const char** a)
+{
+  // Check the command arguments
+  if (n < 3) {
+    std::cout<<"Error: "<<a[0]<<" - invalid number of arguments"<<std::endl;
+    std::cout<<"Usage: type help "<<a[0]<<std::endl;
+    return 1; //TCL_ERROR
+  }
+
+  //read shape
+  const TopoDS_Shape aShape = DBRep::Get(a[2]);
+  if (aShape.IsNull()) {
+    std::cout<<"Error: "<<a[2]<<" is null"<<std::endl;
+    return 1; //TCL_ERROR
+  }
+
+  TopAbs_ShapeEnum aType = aShape.ShapeType();
+  if (aType != TopAbs_WIRE &&
+      aType != TopAbs_FACE)
+  {
+    std::cout<<"Error: "<<a[2]<<" is neither wire no face"<<std::endl;
+    return 1; //TCL_ERROR
+  }
+
+  //read tolerance
+  Standard_Real aTol = 0.01;
+  if (n > 3)
+    aTol = Draw::Atof(a[3]);
+  std::cout<<"Info: tolerance is set to "<<aTol<<std::endl;
+
+  TopoDS_Shape aResult;
+  
+  if (aType == TopAbs_WIRE)
+  {
+    Standard_Boolean OnlyPlane = Standard_False;
+    BRepBuilderAPI_MakeFace aFaceMaker (TopoDS::Wire(aShape), OnlyPlane);
+    if (aFaceMaker.Error() != BRepBuilderAPI_FaceDone)
+    {
+      std::cout<<"Error: failed to find a face for the wire "<<a[2]<<std::endl;
+      return 1; //TCL_ERROR
+    }
+    TopoDS_Face aFace = aFaceMaker.Face();
+    TopoDS_Iterator anIter (aFace);
+    TopoDS_Wire aWire = TopoDS::Wire (anIter.Value());
+    aResult = BRepAlgo::ConvertWire (aWire, aTol, aFace);
+  }
+  else if (aType == TopAbs_FACE)
+  {
+    TopoDS_Face aFace = TopoDS::Face(aShape);
+    aResult = BRepAlgo::ConvertFace (aFace, aTol);
+  }
+
+  if (aResult.IsNull()) {
+    std::cout<<"Error: could not convert "<<a[2]<<std::endl;
+    return 1; //TCL_ERROR
+  }
+
+  DBRep::Set(a[1], aResult);
+  return 0; //TCL_OK
+}
+
 //=======================================================================
 //function : concatC0wire
 //purpose  : 
@@ -1914,12 +2009,12 @@ void  BRepTest::CurveCommands(Draw_Interpretor& theCommands)
     profile2d,g);
 
   theCommands.Add("mkoffset",
-    "mkoffset result face/compound of wires  nboffset stepoffset [jointype(a/i) [alt]]",__FILE__,
-    mkoffset);
+    "mkoffset result face/compound of wires  nboffset stepoffset [-approx] [jointype(a/i) [alt]]",__FILE__,
+    mkoffset,g);
 
   theCommands.Add("openoffset",
-    "openoffset result face/wire nboffset stepoffset [jointype(a/i)]",__FILE__,
-    openoffset);
+    "openoffset result face/wire nboffset stepoffset [-approx] [jointype(a/i)]",__FILE__,
+    openoffset,g);
 
   theCommands.Add("mkedge",
     "mkedge edge curve [surface] [pfirst plast] [vfirst [pfirst] vlast [plast]] ",__FILE__,
@@ -1974,6 +2069,12 @@ void  BRepTest::CurveCommands(Draw_Interpretor& theCommands)
     "reducepcurves shape1 shape2 ...",
     reducepcurves, g);
 
+  theCommands.Add("arclinconvert",
+    "arclinconvert result wire/face [tol]",
+    __FILE__,
+    arclinconvert,
+    g);
+
   theCommands.Add("concatC0wire",
     "concatC0wire result wire",
     __FILE__,

src/BRepTest/BRepTest_ExtremaCommands.cxx

@@ -146,7 +146,7 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
 {
   if (theNbArgs < 3 || theNbArgs > 6)
   {
-    Message::SendFail() << "Usage: " << theArgs[0] << " Shape1 Shape2 [-tol <value>] [-profile]";
+    Message::SendFail() << "Usage: " << theArgs[0] << " Shape1 Shape2 [-tol <value> | -value] [-profile]";
     return 1;
   }
 
@@ -159,9 +159,11 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
     return 1;
   }
 
-  BRepExtrema_ShapeProximity aTool;
+  BRepExtrema_ShapeProximity aTool(0.0);
 
   Standard_Boolean aProfile = Standard_False;
+  Standard_Boolean isTolerance = Standard_False;
+  Standard_Boolean isValue = Standard_False;
 
   for (Standard_Integer anArgIdx = 3; anArgIdx < theNbArgs; ++anArgIdx)
   {
@@ -170,6 +172,7 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
 
     if (aFlag == "-tol")
     {
+      isTolerance = Standard_True;
       if (++anArgIdx >= theNbArgs)
       {
         Message::SendFail() << "Error: wrong syntax at argument '" << aFlag;
@@ -187,13 +190,23 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
         aTool.SetTolerance (aTolerance);
       }
     }
-
-    if (aFlag == "-profile")
+    else if (aFlag == "-value")
+    {
+      isValue = Standard_True;
+      aTool.SetTolerance(Precision::Infinite());
+    }
+    else if (aFlag == "-profile")
     {
       aProfile = Standard_True;
     }
   }
 
+  if (isTolerance && isValue)
+  {
+    Message::SendFail() << "Error: Proximity value could not be computed if the tolerance is set";
+    return 1;
+  }
+
   Standard_Real aInitTime = 0.0;
   Standard_Real aWorkTime = 0.0;
 
@@ -237,39 +250,74 @@ static int ShapeProximity (Draw_Interpretor& theDI, Standard_Integer theNbArgs,
     theDI << "Executing proximity test: " << aWorkTime << "\n";
   }
 
-  TopoDS_Builder aCompBuilder;
-
-  TopoDS_Compound aFaceCompound1;
-  aCompBuilder.MakeCompound (aFaceCompound1);
-
-  for (BRepExtrema_MapOfIntegerPackedMapOfInteger::Iterator anIt1 (aTool.OverlapSubShapes1()); anIt1.More(); anIt1.Next())
+  if (isValue)
   {
-    TCollection_AsciiString aStr = TCollection_AsciiString (theArgs[1]) + "_" + (anIt1.Key() + 1);
+    theDI << "Proximity value: " << aTool.Proximity() << "\n";
 
-    const TopoDS_Face& aFace = aTool.GetSubShape1 (anIt1.Key());
-    aCompBuilder.Add (aFaceCompound1, aFace);
-    DBRep::Set (aStr.ToCString(), aFace);
+    // proximity points
+    TopoDS_Vertex aProxVtx1 = BRepLib_MakeVertex (aTool.ProximityPoint1());
+    TopoDS_Vertex aProxVtx2 = BRepLib_MakeVertex (aTool.ProximityPoint2());
 
-    theDI << aStr << " \n";
+    DBRep::Set ("ProxPnt1", aProxVtx1);
+    DBRep::Set ("ProxPnt2", aProxVtx2);
+
+    // proximity points' status
+    TCollection_AsciiString ProxPntStatus1;
+    TCollection_AsciiString ProxPntStatus2;
+
+    switch (aTool.ProxPntStatus1()) 
+    {
+      case 0: ProxPntStatus1 = "Border"; break;
+      case 1: ProxPntStatus1 = "Middle"; break;
+      default: ProxPntStatus1 = "Unknown";
+    }
+
+    switch (aTool.ProxPntStatus2())
+    {
+    case 0: ProxPntStatus2 = "Border"; break;
+    case 1: ProxPntStatus2 = "Middle"; break;
+    default: ProxPntStatus2 = "Unknown";
+    }
+
+    theDI << " Status of ProxPnt1 on " << theArgs[1] << " : " << ProxPntStatus1 << "\n";
+    theDI << " Status of ProxPnt2 on " << theArgs[2] << " : " << ProxPntStatus2 << "\n";
   }
-
-  TopoDS_Compound aFaceCompound2;
-  aCompBuilder.MakeCompound (aFaceCompound2);
-
-  for (BRepExtrema_MapOfIntegerPackedMapOfInteger::Iterator anIt2 (aTool.OverlapSubShapes2()); anIt2.More(); anIt2.Next())
+  else
   {
-    TCollection_AsciiString aStr = TCollection_AsciiString (theArgs[2]) + "_" + (anIt2.Key() + 1);
+    TopoDS_Builder aCompBuilder;
 
-    const TopoDS_Face& aFace = aTool.GetSubShape2 (anIt2.Key());
-    aCompBuilder.Add (aFaceCompound2, aFace);
-    DBRep::Set (aStr.ToCString(), aFace);
+    TopoDS_Compound aFaceCompound1;
+    aCompBuilder.MakeCompound(aFaceCompound1);
 
-    theDI << aStr << " \n";
+    for (BRepExtrema_MapOfIntegerPackedMapOfInteger::Iterator anIt1(aTool.OverlapSubShapes1()); anIt1.More(); anIt1.Next())
+    {
+      TCollection_AsciiString aStr = TCollection_AsciiString(theArgs[1]) + "_" + (anIt1.Key() + 1);
+
+      const TopoDS_Shape& aShape = aTool.GetSubShape1(anIt1.Key());
+      aCompBuilder.Add(aFaceCompound1, aShape);
+      DBRep::Set(aStr.ToCString(), aShape);
+
+      theDI << aStr << " \n";
+    }
+
+    TopoDS_Compound aFaceCompound2;
+    aCompBuilder.MakeCompound(aFaceCompound2);
+
+    for (BRepExtrema_MapOfIntegerPackedMapOfInteger::Iterator anIt2(aTool.OverlapSubShapes2()); anIt2.More(); anIt2.Next())
+    {
+      TCollection_AsciiString aStr = TCollection_AsciiString(theArgs[2]) + "_" + (anIt2.Key() + 1);
+
+      const TopoDS_Shape& aShape = aTool.GetSubShape2(anIt2.Key());
+      aCompBuilder.Add(aFaceCompound2, aShape);
+      DBRep::Set(aStr.ToCString(), aShape);
+
+      theDI << aStr << " \n";
+    }
+
+    DBRep::Set((TCollection_AsciiString(theArgs[1]) + "_" + "overlapped").ToCString(), aFaceCompound1);
+    DBRep::Set((TCollection_AsciiString(theArgs[2]) + "_" + "overlapped").ToCString(), aFaceCompound2);
   }
 
-  DBRep::Set ((TCollection_AsciiString (theArgs[1]) + "_" + "overlapped").ToCString(), aFaceCompound1);
-  DBRep::Set ((TCollection_AsciiString (theArgs[2]) + "_" + "overlapped").ToCString(), aFaceCompound2);
-
   return 0;
 }
 
@@ -415,12 +463,14 @@ void BRepTest::ExtremaCommands (Draw_Interpretor& theCommands)
                    aGroup);
 
   theCommands.Add ("proximity",
-                   "proximity Shape1 Shape2 [-tol <value>] [-profile]"
+                   "proximity Shape1 Shape2 [-tol <value> | -value] [-profile]"
                    "\n\t\t: Searches for pairs of overlapping faces of the given shapes."
                    "\n\t\t: The options are:"
                    "\n\t\t:   -tol     : non-negative tolerance value used for overlapping"
                    "\n\t\t:              test (for zero tolerance, the strict intersection"
                    "\n\t\t:              test will be performed)"
+                   "\n\t\t:   -value   : compute the proximity value (minimal value which"
+                   "\n\t\t:              shows both shapes fully overlapped)"
                    "\n\t\t:   -profile : outputs execution time for main algorithm stages",
                    __FILE__,
                    ShapeProximity,

src/BRepTest/BRepTest_MatCommands.cxx

@@ -40,6 +40,7 @@
 #include <Bisector_Curve.hxx>
 #include <Precision.hxx>
 
+#include <BRepOffsetAPI_MakeOffset.hxx>
 #include <BRepMAT2d_Explorer.hxx>
 #include <BRepMAT2d_BisectingLocus.hxx>
 #include <BRepMAT2d_LinkTopoBilo.hxx>
@@ -49,6 +50,7 @@
 
 #include <DBRep.hxx>
 #include <TopoDS.hxx>
+#include <TopoDS_Face.hxx>
 
 #ifdef _WIN32
 Standard_IMPORT Draw_Viewer dout;
@@ -75,7 +77,16 @@ static Standard_Integer topoload (Draw_Interpretor& , Standard_Integer argc, con
 
   if (C1.IsNull()) return 1;
 
-  anExplo.Perform (TopoDS::Face(C1));
+  TopoDS_Face aFace = TopoDS::Face(C1);
+  
+  if (argc >= 3 &&
+      (strcmp(argv[2], "-approx") == 0))
+  {
+    Standard_Real aTol = 0.1;
+    aFace = BRepOffsetAPI_MakeOffset::ConvertFace (aFace, aTol);
+  }
+
+  anExplo.Perform (aFace);
   return 0;
 }
 
@@ -272,7 +283,7 @@ void DrawCurve(const Handle(Geom2d_Curve)& aCurve,
 
 void BRepTest::MatCommands (Draw_Interpretor& theCommands)
 {
-  theCommands.Add("topoload","load face",__FILE__,topoload);
+  theCommands.Add("topoload","load face: topoload face [-approx]",__FILE__,topoload);
   theCommands.Add("drawcont","display current contour",__FILE__,drawcont);
   theCommands.Add("mat","computes the mat: mat [a/i [o]]",__FILE__,mat);
   theCommands.Add("side","side left/right",__FILE__,side);

src/BRepTest/BRepTest_SweepCommands.cxx

@@ -560,6 +560,10 @@ static Standard_Integer setsweep(Draw_Interpretor& di,
     di << "   -CN dx dy dz : BiNormal is given by dx dy dz\n";
     di << "   -FX Tx Ty TZ [Nx Ny Nz] : Tangent and Normal are fixed\n";
     di << "   -G guide  0|1(Plan|ACR)  0|1|2(no contact|contact|contact on border) : with guide\n";
+    di << "   -SM : Set the maximum degree of approximation\n";
+    di << "         paramvalue more then 0 (100 by default)\n";
+    di << "   -DM : Set the maximum number of span of approximation\n";
+    di << "         paramvalue [1; 14] (11 by default)\n";
     return 0;
   }
 
@@ -630,6 +634,42 @@ static Standard_Integer setsweep(Draw_Interpretor& di,
         (BRepFill_TypeOfContact)KeepContact);
     }
   }
+  else if (!strcmp(a[1], "-DM"))
+  {
+    if (n != 3)
+    {
+      di << "bad arguments !\n";
+      return 1;
+    }
+
+    if (Draw::Atoi(a[2]) > 0 && Draw::Atoi(a[2]) < 15)
+    {
+      Sweep->SetMaxDegree(Draw::Atoi(a[2]));
+    }
+    else
+    {
+      di << " -DM paramvalue must be [1; 14]\n";
+      return 1;
+    }
+  }
+  else if (!strcmp(a[1], "-SM"))
+  {
+    if (n != 3)
+    {
+      di << "bad arguments !\n";
+      return 1;
+    }
+
+    if (Draw::Atoi(a[2]) > 0)
+    {
+      Sweep->SetMaxSegments(Draw::Atoi(a[2]));
+    }
+    else
+    {
+      di << " -SM paramvalue must be more then 0\n";
+      return 1;
+    }
+  }
 
   else {
     di << "The option " << a[1] << " is unknown !\n";
@@ -638,7 +678,6 @@ static Standard_Integer setsweep(Draw_Interpretor& di,
   return 0;
 }
 
-
 //=======================================================================
 //  addsweep
 //=======================================================================
@@ -985,9 +1024,9 @@ void  BRepTest::SweepCommands(Draw_Interpretor& theCommands)
   theCommands.Add("errorsweep", "errorsweep: returns the summary error on resulting surfaces reached by Sweep",
     __FILE__, errorsweep, g);
 
-  theCommands.Add("simulsweep", "simulsweep r [n] [option]"
+  theCommands.Add("simulsweep", "simulsweep r [n] [option]",
     __FILE__, simulsweep, g);
-  theCommands.Add("geompipe", "geompipe r spineedge profileedge radius [byACR [byrotate]]"
+  theCommands.Add("geompipe", "geompipe r spineedge profileedge radius [byACR [byrotate]]",
     __FILE__, geompipe, g);
 
   theCommands.Add("middlepath", "middlepath res shape startshape endshape",

src/BVH/BVH_Tools.hxx

@@ -30,6 +30,15 @@ public: //! @name public types
 
   typedef typename BVH::VectorType<T, N>::Type BVH_VecNt;
 
+public:
+
+  enum BVH_PrjStateInTriangle
+  {
+    BVH_PrjStateInTriangle_VERTEX,
+    BVH_PrjStateInTriangle_EDGE,
+    BVH_PrjStateInTriangle_INNER
+  };
+
 public: //! @name Box-Box Square distance
 
   //! Computes Square distance between Axis aligned bounding boxes
@@ -113,11 +122,14 @@ public: //! @name Point-Box projection
 
 public: //! @name Point-Triangle Square distance
 
-  //! Computes square distance between point and triangle
-  static T PointTriangleSquareDistance (const BVH_VecNt& thePoint,
-                                        const BVH_VecNt& theNode0,
-                                        const BVH_VecNt& theNode1,
-                                        const BVH_VecNt& theNode2)
+  //! Find nearest point on a triangle for the given point
+  static BVH_VecNt PointTriangleProjection (const BVH_VecNt& thePoint,
+                                            const BVH_VecNt& theNode0,
+                                            const BVH_VecNt& theNode1,
+                                            const BVH_VecNt& theNode2,
+                                            BVH_PrjStateInTriangle* thePrjState = nullptr,
+                                            Standard_Integer* theNumberOfFirstNode = nullptr,
+                                            Standard_Integer* theNumberOfLastNode = nullptr)
   {
     const BVH_VecNt aAB = theNode1 - theNode0;
     const BVH_VecNt aAC = theNode2 - theNode0;
@@ -128,68 +140,110 @@ public: //! @name Point-Triangle Square distance
   
     if (aABdotAP <= 0. && aACdotAP <= 0.)
     {
-      return aAP.Dot(aAP);
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_VERTEX;
+        *theNumberOfFirstNode = 0;
+        *theNumberOfLastNode = 0;
+      }
+      return theNode0;
     }
-  
+
     const BVH_VecNt aBC = theNode2 - theNode1;
     const BVH_VecNt aBP = thePoint - theNode1;
-  
-    T aBAdotBP = -(aAB.Dot(aBP));
-    T aBCdotBP =  (aBC.Dot(aBP));
-  
+
+    T aBAdotBP = -(aAB.Dot (aBP));
+    T aBCdotBP = (aBC.Dot (aBP));
+
     if (aBAdotBP <= 0. && aBCdotBP <= 0.)
     {
-      return (aBP.Dot(aBP));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_VERTEX;
+        *theNumberOfFirstNode = 1;
+        *theNumberOfLastNode = 1;
+      }
+      return theNode1;
     }
-  
+
     const BVH_VecNt aCP = thePoint - theNode2;
-  
-    T aCBdotCP = -(aBC.Dot(aCP));
-    T aCAdotCP = -(aAC.Dot(aCP));
-  
+
+    T aCBdotCP = -(aBC.Dot (aCP));
+    T aCAdotCP = -(aAC.Dot (aCP));
+
     if (aCAdotCP <= 0. && aCBdotCP <= 0.)
     {
-      return (aCP.Dot(aCP));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_VERTEX;
+        *theNumberOfFirstNode = 2;
+        *theNumberOfLastNode = 2;
+      }
+      return theNode2;
     }
-  
-    T aACdotBP = (aAC.Dot(aBP));
-  
+
+    T aACdotBP = (aAC.Dot (aBP));
+
     T aVC = aABdotAP * aACdotBP + aBAdotBP * aACdotAP;
-  
+
     if (aVC <= 0. && aABdotAP > 0. && aBAdotBP > 0.)
     {
-      const BVH_VecNt aDirect = aAP - aAB * (aABdotAP / (aABdotAP + aBAdotBP));
-  
-      return (aDirect.Dot(aDirect));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_EDGE;
+        *theNumberOfFirstNode = 0;
+        *theNumberOfLastNode = 1;
+      }
+      return theNode0 + aAB * (aABdotAP / (aABdotAP + aBAdotBP));
     }
-  
-    T aABdotCP = (aAB.Dot(aCP));
-  
+
+    T aABdotCP = (aAB.Dot (aCP));
+
     T aVA = aBAdotBP * aCAdotCP - aABdotCP * aACdotBP;
-  
+
     if (aVA <= 0. && aBCdotBP > 0. && aCBdotCP > 0.)
     {
-      const BVH_VecNt aDirect = aBP - aBC * (aBCdotBP / (aBCdotBP + aCBdotCP));
-  
-      return (aDirect.Dot(aDirect));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_EDGE;
+        *theNumberOfFirstNode = 1;
+        *theNumberOfLastNode = 2;
+      }
+      return theNode1 + aBC * (aBCdotBP / (aBCdotBP + aCBdotCP));
     }
-  
+
     T aVB = aABdotCP * aACdotAP + aABdotAP * aCAdotCP;
-  
+
     if (aVB <= 0. && aACdotAP > 0. && aCAdotCP > 0.)
     {
-      const BVH_VecNt aDirect = aAP - aAC * (aACdotAP / (aACdotAP + aCAdotCP));
-  
-      return (aDirect.Dot(aDirect));
+      if (thePrjState != nullptr)
+      {
+        *thePrjState = BVH_PrjStateInTriangle_EDGE;
+        *theNumberOfFirstNode = 2;
+        *theNumberOfLastNode = 0;
+      }
+      return theNode0 + aAC * (aACdotAP / (aACdotAP + aCAdotCP));
     }
-  
+
     T aNorm = aVA + aVB + aVC;
-  
-    const BVH_VecNt& aDirect = thePoint - (theNode0 * aVA +
-                                           theNode1 * aVB +
-                                           theNode2 * aVC) / aNorm;
-  
-    return (aDirect.Dot(aDirect));
+
+    if (thePrjState != nullptr)
+    {
+      *thePrjState = BVH_PrjStateInTriangle_INNER;
+    }
+
+    return (theNode0 * aVA + theNode1 * aVB + theNode2 * aVC) / aNorm;
+  }
+
+  //! Computes square distance between point and triangle
+  static T PointTriangleSquareDistance (const BVH_VecNt& thePoint,
+                                        const BVH_VecNt& theNode0,
+                                        const BVH_VecNt& theNode1,
+                                        const BVH_VecNt& theNode2)
+  {
+    const BVH_VecNt aProj = PointTriangleProjection(thePoint, theNode0, theNode1, theNode2);
+    const BVH_VecNt aPP = aProj - thePoint;
+    return aPP.Dot(aPP);
   }
 
 public: //! @name Ray-Box Intersection

src/BiTgte/BiTgte_Blend.cxx

@@ -1780,10 +1780,12 @@ void BiTgte_Blend::ComputeCenters()
 	  }
 	}
       }
+      TopTools_DataMapOfShapeListOfShape anEmptyMap;
       BRepOffset_Inter2d::Compute(myAsDes,
 				  CurOF,
 				  myEdges,
 				  myTol,
+                                  anEmptyMap,
 				  aDMVV);
     }
   }
@@ -1813,20 +1815,23 @@ void BiTgte_Blend::ComputeCenters()
       myAsDes->Add(CurOF,CurOE);
     }
 
+    TopTools_DataMapOfShapeListOfShape anEmptyMap;
     BRepOffset_Inter2d::Compute(myAsDes,
 				CurOF,
 				myEdges,
 				myTol,
+                                anEmptyMap,
 				aDMVV);
   }
   //
   // fuse vertices on edges stored in AsDes
-  BRepOffset_Inter2d::FuseVertices(aDMVV, myAsDes);
+  BRepAlgo_Image anEmptyImage;
+  BRepOffset_Inter2d::FuseVertices(aDMVV, myAsDes, anEmptyImage);
   // ------------
   // unwinding 
   // ------------
   BRepOffset_MakeLoops MakeLoops;
-  MakeLoops.Build( LOF, myAsDes, myImageOffset );
+  MakeLoops.Build (LOF, myAsDes, myImageOffset, anEmptyImage);
 
   // ------------------------------------------------------------
   // It is possible to unwind edges at least one ancestor which of 

src/ChFi3d/ChFi3d.cxx

@@ -139,12 +139,12 @@ ChFiDS_TypeOfConcavity ChFi3d::DefineConnectType(const TopoDS_Edge&     E,
 //function : IsTangentFaces
 //purpose  : 
 //=======================================================================
-Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge& theEdge,
-                                        const TopoDS_Face& theFace1,
-                                        const TopoDS_Face& theFace2,
-                                        const GeomAbs_Shape Order)
+Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge&  theEdge,
+                                        const TopoDS_Face&  theFace1,
+                                        const TopoDS_Face&  theFace2,
+                                        const GeomAbs_Shape theOrder)
 {
-  if (Order == GeomAbs_G1 && BRep_Tool::Continuity(theEdge, theFace1, theFace2) != GeomAbs_C0)
+  if (theOrder == GeomAbs_G1 && BRep_Tool::Continuity(theEdge, theFace1, theFace2) != GeomAbs_C0)
     return Standard_True;
 
   Standard_Real TolC0 = Max(0.001, 1.5*BRep_Tool::Tolerance(theEdge));
@@ -152,15 +152,46 @@ Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge& theEdge,
   Standard_Real aFirst;
   Standard_Real aLast;
 
-  // Obtaining of pcurves of edge on two faces.
-  const Handle(Geom2d_Curve) aC2d1 = BRep_Tool::CurveOnSurface
-    (theEdge, theFace1, aFirst, aLast);
-  //For the case of seam edge
-  TopoDS_Edge EE = theEdge;
-  if (theFace1.IsSame(theFace2))
-    EE.Reverse();
-  const Handle(Geom2d_Curve) aC2d2 = BRep_Tool::CurveOnSurface
-    (EE, theFace2, aFirst, aLast);
+  Handle(Geom2d_Curve) aC2d1, aC2d2;
+  
+  if (!theFace1.IsSame (theFace2) &&
+      BRep_Tool::IsClosed (theEdge, theFace1) &&
+      BRep_Tool::IsClosed (theEdge, theFace2))
+  {
+    //Find the edge in the face 1: this edge will have correct orientation
+    TopoDS_Edge anEdgeInFace1;
+    TopoDS_Face aFace1 = theFace1;
+    aFace1.Orientation (TopAbs_FORWARD);
+    TopExp_Explorer anExplo (aFace1, TopAbs_EDGE);
+    for (; anExplo.More(); anExplo.Next())
+    {
+      const TopoDS_Edge& anEdge = TopoDS::Edge (anExplo.Current());
+      if (anEdge.IsSame (theEdge))
+      {
+        anEdgeInFace1 = anEdge;
+        break;
+      }
+    }
+    if (anEdgeInFace1.IsNull())
+      return Standard_False;
+    
+    aC2d1 = BRep_Tool::CurveOnSurface (anEdgeInFace1, aFace1, aFirst, aLast);
+    TopoDS_Face aFace2 = theFace2;
+    aFace2.Orientation (TopAbs_FORWARD);
+    anEdgeInFace1.Reverse();
+    aC2d2 = BRep_Tool::CurveOnSurface (anEdgeInFace1, aFace2, aFirst, aLast);
+  }
+  else
+  {
+    // Obtaining of pcurves of edge on two faces.
+    aC2d1 = BRep_Tool::CurveOnSurface (theEdge, theFace1, aFirst, aLast);
+    //For the case of seam edge
+    TopoDS_Edge EE = theEdge;
+    if (theFace1.IsSame(theFace2))
+      EE.Reverse();
+    aC2d2 = BRep_Tool::CurveOnSurface (EE, theFace2, aFirst, aLast);
+  }
+  
   if (aC2d1.IsNull() || aC2d2.IsNull())
     return Standard_False;
 
@@ -191,15 +222,19 @@ Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge& theEdge,
     if (i == aNbSamples) aPar = aLast;
 
     LocalAnalysis_SurfaceContinuity aCont(aC2d1, aC2d2, aPar,
-      aSurf1, aSurf2, Order,
+      aSurf1, aSurf2, theOrder,
       0.001, TolC0, 0.1, 0.1, 0.1);
     if (!aCont.IsDone())
     {
+      if (theOrder == GeomAbs_C2 &&
+          aCont.StatusError() == LocalAnalysis_NullSecondDerivative)
+        continue;
+      
       nbNotDone++;
       continue;
     }
 
-    if (Order == GeomAbs_G1)
+    if (theOrder == GeomAbs_G1)
     {
       if (!aCont.IsG1())
         return Standard_False;

src/Extrema/Extrema_FuncExtCS.cxx

@@ -208,12 +208,13 @@ Standard_Integer Extrema_FuncExtCS::GetStateNumber()
   std::cout <<"F(1)= "<<Sol(1)<<" F(2)= "<<Sol(2)<<" F(3)= "<<Sol(3)<<std::endl;
 #endif
   //comparison of solution with previous solutions
-  Standard_Real tol2d = Precision::PConfusion() * Precision::PConfusion();
+  Standard_Real tol2d = Precision::SquarePConfusion();
   Standard_Integer i = 1, nbSol = mySqDist.Length();
   for( ; i <=  nbSol; i++)
   {
     Standard_Real aT = myPoint1(i).Parameter();
-    if( (myt - aT) * (myt - aT) <= tol2d )
+    aT -= myt; aT *= aT;
+    if( aT <= tol2d )
       break;
   }
   if (i <= nbSol)

src/Extrema/Extrema_FuncExtCS.hxx

@@ -84,14 +84,21 @@ public:
   //! Return the Nth extremum on S.
   Standard_EXPORT const Extrema_POnSurf& PointOnSurface (const Standard_Integer N) const;
 
-
-
-
-protected:
-
-
-
-
+  //! Change Sequence of SquareDistance
+  TColStd_SequenceOfReal& SquareDistances()
+  {
+    return mySqDist;
+  }
+  //! Change Sequence of PointOnCurv
+  Extrema_SequenceOfPOnCurv& PointsOnCurve()
+  {
+    return myPoint1;
+  }
+  //! Change Sequence of PointOnSurf
+  Extrema_SequenceOfPOnSurf& PointsOnSurf()
+  {
+    return myPoint2;
+  }
 
 private:
 

src/Extrema/Extrema_GenExtCS.cxx

@@ -38,6 +38,8 @@
 #include <TColgp_Array1OfPnt.hxx>
 #include <Geom_TrimmedCurve.hxx>
 #include <ElCLib.hxx>
+#include <Extrema_GenLocateExtPS.hxx>
+
 
 const Standard_Real MaxParamVal = 1.0e+10;
 const Standard_Real aBorderDivisor = 1.0e+4;
@@ -304,35 +306,85 @@ void Extrema_GenExtCS::Perform (const Adaptor3d_Curve& C,
   Tol(2) = mytol2;
   Tol(3) = mytol2;
   //
-  TUVinf(1) = mytmin;
-  TUVinf(2) = trimumin;
-  TUVinf(3) = trimvmin;
-  //
-  TUVsup(1) = mytsup;
-  TUVsup(2) = trimusup;
-  TUVsup(3) = trimvsup;
-  //
   // Number of particles used in PSO algorithm (particle swarm optimization).
   const Standard_Integer aNbParticles = 48;
-  //
-  if (aNbVar == 3)
+
+  Standard_Integer aNbIntC = 1;
+  if (C.IsClosed() || C.IsPeriodic())
   {
-    GlobMinGenCS(C, aNbParticles, TUVinf, TUVsup, TUV);
-  }
-  else if (aNbVar == 2)
-  {
-    GlobMinConicS(C, aNbParticles, TUVinf, TUVsup, TUV);
-  }
-  else
-  {
-    GlobMinCQuadric(C, aNbParticles, TUVinf, TUVsup, TUV);
+    Standard_Real aPeriod = C.Period();
+    if (C.LastParameter() - C.FirstParameter() > 2. * aPeriod / 3.)
+    {
+      aNbIntC = 2;
+    }
   }
 
-  // Find min approximation
-  math_FunctionSetRoot anA(myF, Tol);
-  anA.Perform(myF, TUV, TUVinf, TUVsup);
+  Standard_Integer anInt;
+  Standard_Real dT = (mytsup - mytmin) / aNbIntC;
+  for (anInt = 1; anInt <= aNbIntC; anInt++)
+  {
+    TUVinf(1) = mytmin + (anInt - 1) * dT;
+    TUVinf(2) = trimumin;
+    TUVinf(3) = trimvmin;
+    //
+    TUVsup(1) = TUVinf(1) + dT; // mytsup;
+    TUVsup(2) = trimusup;
+    TUVsup(3) = trimvsup;
+    //
+    if (aNbVar == 3)
+    {
+      GlobMinGenCS(C, aNbParticles, TUVinf, TUVsup, TUV);
+    }
+    else if (aNbVar == 2)
+    {
+      GlobMinConicS(C, aNbParticles, TUVinf, TUVsup, TUV);
+    }
+    else
+    {
+      GlobMinCQuadric(C, aNbParticles, TUVinf, TUVsup, TUV);
+    }
 
+    // Find min approximation
+    math_FunctionSetRoot anA(myF, Tol);
+    anA.Perform(myF, TUV, TUVinf, TUVsup);
+  }
+  if (aNbIntC > 1 && myF.NbExt() > 1)
+  {
+    //Try to remove "false" extrema caused by dividing curve interval
+    TColStd_SequenceOfReal& aSqDists = myF.SquareDistances();
+    Extrema_SequenceOfPOnCurv& aPntsOnCrv = myF.PointsOnCurve();
+    Extrema_SequenceOfPOnSurf& aPntsOnSurf = myF.PointsOnSurf();
+    TColStd_SequenceOfReal aSqDists1(aSqDists);
+    Extrema_SequenceOfPOnCurv aPntsOnCrv1(aPntsOnCrv);
+    Extrema_SequenceOfPOnSurf aPntsOnSurf1(aPntsOnSurf);
+
+    Standard_Real aMinDist = aSqDists(1);
+    Standard_Integer i;
+    for (i = 2; i <= aSqDists.Length(); ++i)
+    {
+      Standard_Real aDist = aSqDists(i);
+      if (aDist < aMinDist)
+      {
+        aMinDist = aDist;
+      }
+    }
+    aSqDists.Clear();
+    aPntsOnCrv.Clear();
+    aPntsOnSurf.Clear();
+    Standard_Real aTol = Precision::SquareConfusion();
+    for (i = 1; i <= aSqDists1.Length(); ++i)
+    {
+      Standard_Real aDist = aSqDists1(i);
+      if (Abs(aDist - aMinDist) <= aTol)
+      {
+        aSqDists.Append(aDist);
+        aPntsOnCrv.Append(aPntsOnCrv1(i));
+        aPntsOnSurf.Append(aPntsOnSurf1(i));
+      }
+    }
+  }
   myDone = Standard_True;
+
 }
 //=======================================================================
 //function : GlobMinGenCS
@@ -447,6 +499,7 @@ void Extrema_GenExtCS::GlobMinConicS(const Adaptor3d_Curve& theC,
     anUVsup(i) = theTUVsup(i + 1);
   }
   //
+  //
   math_PSOParticlesPool aParticles(theNbParticles, aNbVar);
 
   math_Vector aMinUV(1, aNbVar);
@@ -517,10 +570,103 @@ void Extrema_GenExtCS::GlobMinConicS(const Adaptor3d_Curve& theC,
       aCT = ElCLib::InPeriod(aCT, theTUVinf(1), theTUVinf(1) + 2. * M_PI);
     }
   }
+
   theTUV(1) = aCT;
   theTUV(2) = anUV(1);
   theTUV(3) = anUV(2);
 
+  Standard_Boolean isBadSol = Standard_False;
+  gp_Vec aDU, aDV, aDT;
+  gp_Pnt aPOnS, aPOnC;
+  myS->D1(anUV(1), anUV(2), aPOnS, aDU, aDV);
+  theC.D1(aCT, aPOnC, aDT);
+  Standard_Real aSqDist = aPOnC.SquareDistance(aPOnS);
+  if (aSqDist <= Precision::SquareConfusion())
+    return;
+
+  gp_Vec aN = aDU.Crossed(aDV);
+  if (aN.SquareMagnitude() < Precision::SquareConfusion())
+    return;
+
+  gp_Vec PcPs(aPOnC, aPOnS);
+
+  Standard_Real anAngMin = M_PI_2 - M_PI_2 / 10.;
+  Standard_Real anAngMax = M_PI_2 + M_PI_2 / 10.;
+
+  Standard_Real anAngN = PcPs.Angle(aN);
+  if (anAngN >= anAngMin && anAngN <= anAngMax)
+  {
+    // PcPs is perpendicular to surface normal, it means that
+    // aPOnC can be on surface, but far from aPOnS
+    isBadSol = Standard_True;
+    Standard_Integer iu, iv;
+    for (iu = -1; iu <= 1; ++iu)
+    {
+      Standard_Real u = anUV(1) + iu * aStepSU;
+      u = Max(anUVinf(1), u);
+      u = Min(anUVsup(1), u);
+      for (iv = -1; iv <= 1; ++iv)
+      {
+        Standard_Real v = anUV(2) + iv * aStepSV;
+        v = Max(anUVinf(2), v);
+        v = Min(anUVsup(2), v);
+        myS->D1(u, v, aPOnS, aDU, aDV);
+        if (aPOnC.SquareDistance(aPOnS) < Precision::SquareConfusion())
+        {
+          isBadSol = Standard_False;
+          break;
+        }
+        aN = aDU.Crossed(aDV);
+        if (aN.SquareMagnitude() < Precision::SquareConfusion())
+        {
+          isBadSol = Standard_False;
+          break;
+        }
+        PcPs.SetXYZ(aPOnS.XYZ() - aPOnC.XYZ());
+        anAngN = PcPs.Angle(aN);
+        if (anAngN < anAngMin || anAngN > anAngMax)
+        {
+          isBadSol = Standard_False;
+          break;
+        }
+      }
+      if (!isBadSol)
+      {
+        break;
+      }
+    }
+  }
+
+  if (isBadSol)
+  {
+    //Try to precise solution with help of Extrema PS
+
+    math_Vector aF(1, 3);
+    aF(1) = PcPs.Dot(aDT);
+    aF(2) = PcPs.Dot(aDU);
+    aF(3) = PcPs.Dot(aDV);
+    Standard_Real aFF = aF.Norm2();
+
+    Extrema_GenLocateExtPS anExtPS(*myS, mytol2, mytol2);
+    anExtPS.Perform(aPOnC, anUV(1), anUV(2), Standard_False);
+    if (anExtPS.IsDone())
+    {
+      const Extrema_POnSurf& aPmin = anExtPS.Point();
+      aPmin.Parameter(anUV(1), anUV(2));
+      math_Vector aTUV = theTUV;
+      aTUV(2) = anUV(1);
+      aTUV(3) = anUV(2);
+      myF.Value(aTUV, aF);
+      Standard_Real aFF1 = aF.Norm2();
+
+      if (anExtPS.SquareDistance() < aSqDist && aFF1 <= 1.1 * aFF)
+      {
+        theTUV(2) = aTUV(2);
+        theTUV(3) = aTUV(3);
+      }
+    }
+  }
+ 
 }
 //=======================================================================
 //function : GlobMinCQuadric

src/Geom2dConvert/FILES

@@ -1,5 +1,7 @@
 Geom2dConvert.cxx
 Geom2dConvert.hxx
+Geom2dConvert_ApproxArcsSegments.cxx
+Geom2dConvert_ApproxArcsSegments.hxx
 Geom2dConvert_ApproxCurve.cxx
 Geom2dConvert_ApproxCurve.hxx
 Geom2dConvert_BSplineCurveKnotSplitting.cxx
@@ -8,3 +10,6 @@ Geom2dConvert_BSplineCurveToBezierCurve.cxx
 Geom2dConvert_BSplineCurveToBezierCurve.hxx
 Geom2dConvert_CompCurveToBSplineCurve.cxx
 Geom2dConvert_CompCurveToBSplineCurve.hxx
+Geom2dConvert_PPoint.cxx
+Geom2dConvert_PPoint.hxx
+Geom2dConvert_SequenceOfPPoint.hxx

src/Geom2dConvert/Geom2dConvert_ApproxArcsSegments.cxx

@@ -0,0 +1,911 @@
+// Created: 2009-01-21
+// 
+// Copyright (c) 2009-2013 OPEN CASCADE SAS
+// 
+// This file is part of commercial software by OPEN CASCADE SAS, 
+// furnished in accordance with the terms and conditions of the contract 
+// and with the inclusion of this copyright notice. 
+// This file or any part thereof may not be provided or otherwise 
+// made available to any third party. 
+// 
+// No ownership title to the software is transferred hereby. 
+// 
+// OPEN CASCADE SAS makes no representation or warranties with respect to the 
+// performance of this software, and specifically disclaims any responsibility 
+// for any damages, special or consequential, connected with its use. 
+
+#include <Geom2dConvert_ApproxArcsSegments.hxx>
+
+#include <Adaptor2d_Curve2d.hxx>
+#include <ElCLib.hxx>
+#include <GCE2d_MakeArcOfCircle.hxx>
+#include <GCE2d_MakeSegment.hxx>
+#include <GCPnts_QuasiUniformDeflection.hxx>
+#include <Geom2d_Circle.hxx>
+#include <Geom2d_Line.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
+#include <NCollection_IncAllocator.hxx>
+#include <Precision.hxx>
+#include <Standard_Version.hxx>
+#include <gp.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp_Lin2d.hxx>
+
+static const Standard_Integer MAXPOINTS         = 100;
+static const Standard_Real MyCurvatureTolerance = 0.0001;
+
+static Standard_Boolean checkContinuity   (const Handle(Geom2d_Curve)& theCurve1,
+                                           const Handle(Geom2d_Curve)& theCurve2,
+                                           const Standard_Real      theAnglTol);
+
+static Geom2dConvert_PPoint getParameter  (const gp_XY&             theXY1,
+                                           const Standard_Real      theFirstPar,
+                                           const Standard_Real      theLastPar,
+                                           const Adaptor2d_Curve2d& theCurve);
+
+static Standard_Boolean isInflectionPoint (const Standard_Real      theParam,
+                                           const Adaptor2d_Curve2d& theCurve);
+
+static Standard_Boolean isInflectionPoint (const Standard_Real         theParam,
+                                           const Geom2dConvert_PPoint& theFirstInf,
+                                           const Adaptor2d_Curve2d&    theCurve,
+                                           const Standard_Real         theAnglTol);
+
+
+//=======================================================================
+//function : Geom2dConvert_ApproxArcsSegments()
+//purpose  : Constructor
+//=======================================================================
+
+Geom2dConvert_ApproxArcsSegments::Geom2dConvert_ApproxArcsSegments
+                        (const Adaptor2d_Curve2d&                theCurve,
+                         const Standard_Real                     theTolerance,
+                         const Standard_Real                     theAngleTol)
+  : myCurve             (theCurve),
+    myAlloc             (new NCollection_IncAllocator(4000)),
+    myTolerance         (theTolerance),
+    myAngleTolerance    (theAngleTol),
+    mySeqParams         (myAlloc),
+    myStatus            (StatusNotDone)
+{
+  myExt[0] = Geom2dConvert_PPoint(myCurve.FirstParameter(), myCurve);
+  myExt[1] = Geom2dConvert_PPoint(myCurve.LastParameter(), myCurve);
+
+  switch (myCurve.GetType())
+  {
+    case GeomAbs_Line:
+    {
+      // Create a single line segment. 
+      const Standard_Real aDist = myExt[0].Dist(myExt[1]);
+      if (aDist > Precision::Confusion()) {
+        const gp_Ax2d anAx2d(myExt[0].Point(), gp_Vec2d(myExt[0].Point(),
+                                                        myExt[1].Point()));
+        const Handle(Geom2d_Line) aLine = new Geom2d_Line(anAx2d);
+        mySeqCurves.Append(new Geom2d_TrimmedCurve(aLine, 0., aDist));
+        myStatus = StatusOK;
+      }
+    }
+    break;
+    case GeomAbs_Circle:
+    {
+      // Create a couple of arcs of equal size.
+      const Geom2dConvert_PPoint aPP(.5 *(myExt[0].Parameter() +
+                                          myExt[1].Parameter()), myCurve);
+      Handle(Geom2d_Curve) aCurve = makeCircle (myExt[0], aPP);
+      if (aCurve.IsNull() == Standard_False) {
+        mySeqCurves.Append(aCurve);
+        aCurve = makeCircle (aPP, myExt[1]);
+        if (aCurve.IsNull() == Standard_False)
+          mySeqCurves.Append(aCurve);
+      }
+    }
+    break;
+    default:
+      makeFreeform();
+  }
+
+  // Check status of the calculation
+  if (myStatus == StatusNotDone) {
+    if (mySeqCurves.IsEmpty() == Standard_False)
+      myStatus = StatusOK;
+    else {
+      //std::cout << "GeomConv2d_Approx: no geometry converted." << std::endl;
+      myStatus = StatusError;
+    }
+  }
+}
+
+//=======================================================================
+//function : makeCircle
+//purpose  : method for creation of circle
+//=======================================================================
+
+Handle(Geom2d_Curve) Geom2dConvert_ApproxArcsSegments::makeCircle
+                                (const Geom2dConvert_PPoint& theFirst,
+                                 const Geom2dConvert_PPoint& theLast) const
+{
+  Handle(Geom2d_Curve) aResult;
+  gp_Pnt2d aPointM (0.0,0.0);
+  const Standard_Real aParaM = (theFirst.Parameter() + theLast.Parameter()) *.5;
+  myCurve.D0(aParaM, aPointM);
+  GCE2d_MakeArcOfCircle aMakeArc1(theFirst.Point(), aPointM, theLast.Point());
+
+  if (aMakeArc1.IsDone())
+    aResult = aMakeArc1.Value();
+  //else
+    //std::cout << "makeCircle(): Circle not built" << std::endl;
+  return aResult;
+}
+
+//=======================================================================
+//function : makeArc
+//purpose  : creation arcs by two points and derivative in the first point
+///        : parameter isFirst specified direction of the arc.
+//=======================================================================
+
+Standard_Boolean Geom2dConvert_ApproxArcsSegments::makeArc
+                (const Geom2dConvert_PPoint&    theParam1,
+                 Geom2dConvert_PPoint&          theParam2,
+                 const Standard_Boolean         isFirst,
+                 Handle(Geom2d_TrimmedCurve)&   theCurve) const
+{
+  const gp_XY aP1  (theParam1.Point());
+  const gp_XY aP2  (theParam2.Point());
+  const gp_XY aVec (isFirst? theParam1.D1() : -theParam1.D1());
+
+  // Detect the sense (CCW means positive)
+  const gp_XY aDelta = aP2 - aP1;
+  Standard_Real aSense = aVec ^ aDelta;
+  if (aSense > Precision::Angular())
+    aSense = 1.;
+  else if (aSense < -Precision::Angular())
+    aSense = -1.;
+  else {
+    //std::cout << "makeArc(): Arc Not Built" << std::endl;
+    return Standard_False;
+  }
+
+  // Find the centre of the circle
+  const gp_XY         aMiddle = (aP2 + aP1) * 0.5;
+  const Standard_Real prodP1V = aP1 * aVec;
+  const Standard_Real prodDeM = aDelta * aMiddle;
+  const Standard_Real vprodVD = aVec ^ aDelta;
+  const Standard_Real aResolution = gp::Resolution();
+
+  if (vprodVD < -aResolution || vprodVD > aResolution) {
+    const gp_Pnt2d aCenter((prodP1V * aDelta.Y() - prodDeM * aVec.Y())/vprodVD,
+                           (prodDeM * aVec.X() - prodP1V * aDelta.X())/vprodVD);
+    const Standard_Real aRad =
+        (aCenter.Distance(aP1) + aCenter.Distance(aP2)) * 0.5;
+    const gp_Ax22d ax22d (aCenter, gp_Dir2d(1., 0.), gp_Dir2d(0., 1.));
+    const gp_Circ2d aCir (ax22d, aRad);
+    const Handle(Geom2d_Circle) Circ = new Geom2d_Circle(aCir);
+
+      //calculation parameters first and last points of arc.
+    Standard_Real anAlpha1, anAlpha2;
+    if (isFirst) {
+      anAlpha1 = ElCLib::Parameter(aCir, aP1);
+      anAlpha2 = ElCLib::Parameter(aCir, aP2);
+    } else {
+      anAlpha1 = ElCLib::Parameter(aCir, aP2);
+      anAlpha2 = ElCLib::Parameter(aCir, aP1);
+      aSense = -aSense;
+    }
+
+    if (fabs (anAlpha1 - anAlpha2) < 1e-100)
+      // very small value, just to avoid exact match
+      return Standard_False;
+
+    // Reverse the circle if the sense is negative
+    if (aSense < 0.) {
+      anAlpha1 = Circ->ReversedParameter(anAlpha1);
+      anAlpha2 = Circ->ReversedParameter(anAlpha2);
+      Circ->Reverse();
+    }
+    theCurve = new Geom2d_TrimmedCurve(Circ, anAlpha1, anAlpha2);
+    // Correct the direction in the opposite point
+    const gp_XY aRadV = theParam2.Point() - aCenter.XY();
+    theParam2.SetD1(gp_XY(- aRadV.Y() * aSense, aRadV.X() * aSense));
+    return Standard_True;
+  }
+
+  // Algorithm failed, possibly because aVec is normal to the chorde
+  return Standard_False;
+}
+
+//=======================================================================
+//function : makeLine
+//purpose  : method for creation of line
+//=======================================================================
+
+Handle(Geom2d_TrimmedCurve) Geom2dConvert_ApproxArcsSegments::makeLine
+                                (Geom2dConvert_PPoint&     theFirst,
+                                 Geom2dConvert_PPoint&     theLast,
+                                 const Standard_Boolean isCheck) const
+{
+  Handle(Geom2d_TrimmedCurve) aResult;
+
+  gp_XY aSlope = theLast.Point() - theFirst.Point();
+  if (fabs(aSlope.SquareModulus()) < gp::Resolution())
+     return aResult;
+  gp_Dir2d aDirLine(aSlope);
+
+  if (isCheck) {
+    if (theFirst.D1().SquareModulus() < gp::Resolution() ||
+        theLast.D1().SquareModulus() < gp::Resolution())
+      return aResult;
+
+    // Angular continuity (G1) is only checked when the end of the line is not
+    // on the extremity of the curve
+    Standard_Real absAngle[2] = { 0., 0. };
+    if (theFirst != myExt[0]) {
+      const Standard_Real anAng = aDirLine.Angle(theFirst.D1());
+      absAngle[0] = (anAng > 0. ? anAng : -anAng);
+    }
+    if (theLast != myExt[1]) {
+      const Standard_Real anAng = aDirLine.Angle(theLast.D1());
+      absAngle[1] = (anAng > 0. ? anAng : -anAng);
+    }
+
+    // if the derivatives in the end points differ from the derivative line
+    // more than value of the specified continuity tolerance
+    // then a biarc should be build instead of a line.
+    const Standard_Real aContTolerance = ::Max(myAngleTolerance, 0.01);
+    if (absAngle[0] > aContTolerance || absAngle[1] > aContTolerance) {
+      //std::cout << "makeLine(): Line not built" << std::endl;
+      return aResult;
+    }
+  } // end if (isCheck)
+
+  //bulding segment of line
+  GCE2d_MakeSegment aMakeSeg (theFirst.Point(), theLast.Point());
+  if (aMakeSeg.IsDone()) {
+    Handle(Geom2d_TrimmedCurve) aCurve = aMakeSeg.Value();
+    if (checkCurve (aCurve, theFirst.Parameter(), theLast.Parameter())) {
+      aResult = aCurve;
+      // correct the derivatives fields in both arguments
+      const gp_XY aNewD1 (theLast.Point() - theFirst.Point());
+      theFirst.SetD1(aNewD1);
+      theLast.SetD1(aNewD1);
+    }
+  }
+  //else
+    //std::cout << "makeLine(): Line not built" << std::endl;
+  return aResult;
+}
+
+//=======================================================================
+//function : makeFreeform
+//purpose  : get a sequence of Geom curves from one curve
+//=======================================================================
+
+Standard_Boolean Geom2dConvert_ApproxArcsSegments::makeFreeform()
+{
+  Geom2dConvert_SequenceOfPPoint seqParamPoints(myAlloc);
+  Geom2dConvert_PPoint*  aPrevParam = &myExt[0];
+
+  //calculation of the inflection points.
+  getLinearParts(seqParamPoints);
+  const Standard_Boolean isNoInfPoints = seqParamPoints.IsEmpty();
+
+  TColGeom2d_SequenceOfCurve aSeqLinearParts;
+  Standard_Boolean isDone (Standard_True);
+  Standard_Integer i;
+  for (i = 1; i < seqParamPoints.Length(); i += 2)
+  {
+    Handle(Geom2d_Curve) aLineCurve;
+    Geom2dConvert_PPoint& aParam0 = seqParamPoints.ChangeValue(i);
+    Geom2dConvert_PPoint& aParam1 = seqParamPoints.ChangeValue(i+1);
+    if (aParam0 != aParam1)
+      //linear part of the curve lies between odd and even values of i.
+      //parameters from parameter's sequence.
+      aLineCurve = makeLine (aParam0, aParam1, Standard_False);
+    aSeqLinearParts.Append(aLineCurve);
+  }
+
+  for (i = 1; i < seqParamPoints.Length(); i += 2)
+  {
+    //approximation for non-linear part preceding the linear part
+    if (seqParamPoints(i) != * aPrevParam) {
+      const Standard_Integer aLastInd = mySeqCurves.Length();
+      isDone = makeApproximation (* aPrevParam, seqParamPoints(i));
+      if (isDone && aLastInd && mySeqCurves.Length() > aLastInd)
+        isDone = checkContinuity(mySeqCurves.Value(aLastInd),
+                                 mySeqCurves.Value(aLastInd+1),
+                                 myAngleTolerance);
+      if (!isDone) {
+        myStatus = StatusError;
+        break;
+      }
+    }
+
+    const Handle(Geom2d_Curve)& aCurve = aSeqLinearParts.Value((i+1)/2);
+    if (aCurve.IsNull() == Standard_False)
+      mySeqCurves.Append(aCurve);
+    else {
+      Geom2dConvert_PPoint& aParam0 = seqParamPoints.ChangeValue(i);
+      Geom2dConvert_PPoint& aParam1 = seqParamPoints.ChangeValue(i+1);
+      const Standard_Integer aLastInd = mySeqCurves.Length();
+      isDone = makeApproximation (aParam0, aParam1);
+      if (isDone && aLastInd && mySeqCurves.Length() > aLastInd)
+        isDone = checkContinuity(mySeqCurves.Value(aLastInd),
+                                 mySeqCurves.Value(aLastInd+1),
+                                 myAngleTolerance);
+
+      if (!isDone) {
+        myStatus = StatusError;
+        //std::cout << "makeOther: Line not built" << std::endl;
+        break;
+      }
+    }
+    aPrevParam = &seqParamPoints(i+1);
+  }
+
+  //approximation for non-linear part following the last linear part
+  if (isDone && (* aPrevParam != myExt[1]))
+  {
+    // Case of a closed edge like an ellipse
+    if (isNoInfPoints &&
+        (myExt[0].Point() - myExt[1].Point()).Modulus() < myTolerance)
+    {
+      Geom2dConvert_PPoint aPPoint(0.5 * (myExt[0].Parameter() +
+                                          myExt[1].Parameter()), myCurve);
+      isDone = makeApproximation (myExt[0], aPPoint);
+      if (isDone)
+        isDone = makeApproximation (aPPoint, myExt[1]);
+    } else {
+      isDone = makeApproximation (* aPrevParam, myExt[1]);
+    }
+    if (!isDone) {
+      myStatus = StatusError;
+      //std::cout << "makeOther: Line not built" << std::endl;
+    }
+  }
+
+  return (mySeqCurves.Length() && myStatus != StatusError);
+}
+
+//=======================================================================
+//function : getLinearParts
+//purpose  : method for geting inflection points
+//=======================================================================
+
+void Geom2dConvert_ApproxArcsSegments::getLinearParts (Geom2dConvert_SequenceOfPPoint& theSeqPar)
+{
+  Standard_Integer i;
+  // Fill the sequences with values along the curve
+  mySeqParams.Clear();
+  Adaptor2d_Curve2d& myCurveMut = const_cast<Adaptor2d_Curve2d&>(myCurve);
+  GCPnts_QuasiUniformDeflection aQUDefAlgo (myCurveMut, myTolerance * 0.5);
+  Standard_Boolean isUniformDone = aQUDefAlgo.IsDone();
+
+  gp_XY aLastPnt(myExt[0].Point());
+  if (isUniformDone) {
+    for (i = 1; i <= aQUDefAlgo.NbPoints(); i++) {
+      const Geom2dConvert_PPoint aPP (aQUDefAlgo.Parameter(i), myCurve);
+      mySeqParams.Append(aPP);
+      aLastPnt = aPP.Point();
+    }
+  } else {
+    const Standard_Real aParamStep =
+      (myExt[1].Parameter() - myExt[0].Parameter()) / MAXPOINTS;
+    for (i = 1; i <= MAXPOINTS; i++) {
+      const Standard_Real aParam = myExt[0].Parameter() + aParamStep * i;
+      const Geom2dConvert_PPoint aPP (aParam, myCurve);
+      mySeqParams.Append(aPP);
+      aLastPnt = aPP.Point();
+    }
+  }
+
+  //check if the curve may be linearised
+  gp_XY aDir = myExt[1].Point() - myExt[0].Point();
+  const Standard_Real aMod2 = aDir.SquareModulus();
+  if (aMod2 > Precision::Confusion())
+  {
+    Standard_Boolean isLinear = Standard_True;
+    aDir /= sqrt(aMod2);
+    for (i = 1; i <= mySeqParams.Length(); i++) {
+      // Distance from point "i" to the segment between two extremities
+      const Standard_Real aDist = aDir ^ (mySeqParams(i).Point() -
+                                          myExt[0].Point());
+      if (aDist > myTolerance * 0.5 || aDist < -myTolerance * 0.5) {
+        isLinear = Standard_False;
+        break;
+      }
+    }
+    if (isLinear) {
+      theSeqPar.Append(myExt[0]);
+      theSeqPar.Append(myExt[1]);
+      return;
+    }
+  }
+
+  //check if point for First Parameter is inflection point.
+  Standard_Integer indStartLinear (0);
+  Geom2dConvert_PPoint aLastInflParam  = myExt[0];
+  Geom2dConvert_PPoint aFirstInflParam = myExt[0];
+
+  // Getting further inflection points with step by parameter.
+  // The point with index 1 is the same as myExt[0]
+  for (i = 1; i <= mySeqParams.Length(); i++)
+  {
+    const Geom2dConvert_PPoint& aCurParam = mySeqParams(i);
+    if (indStartLinear) {
+      Standard_Boolean isStillInflectionFirst =
+        isInflectionPoint (aFirstInflParam.Parameter(), aCurParam,
+                           myCurve, myAngleTolerance);
+      if (isInflectionPoint (aCurParam.Parameter(), aFirstInflParam,
+                             myCurve, myAngleTolerance))
+      {
+        aLastInflParam = mySeqParams(i);
+        while (isStillInflectionFirst == Standard_False) {
+          if (++indStartLinear >= i) {
+            indStartLinear = 0;
+            break;
+          }
+          aFirstInflParam = mySeqParams(indStartLinear);
+          isStillInflectionFirst =
+            isInflectionPoint (aFirstInflParam.Parameter(), aCurParam,
+                               myCurve, myAngleTolerance);
+        }
+      } else {
+        // Add the interval in the output sequence
+        // The interval is added only if it is more than 10 times the tolerance
+        aLastInflParam = findInflection (aLastInflParam, aCurParam);
+        if (!isInflectionPoint (aFirstInflParam.Parameter(), aLastInflParam,
+                                myCurve, myAngleTolerance))
+        {
+          aFirstInflParam = findInflection (aLastInflParam, aFirstInflParam);
+        }
+        const Standard_Real aDist((aFirstInflParam.Point() -
+                                   aLastInflParam.Point()).Modulus());
+        if (aFirstInflParam.Parameter() < aLastInflParam.Parameter() &&
+            aDist > 10 * myTolerance)
+        {
+          theSeqPar.Append(aFirstInflParam);
+          theSeqPar.Append(aLastInflParam);
+        }
+        indStartLinear = 0;
+      }
+    } else
+      if (isInflectionPoint (aCurParam.Parameter(), myCurve)) {
+        aLastInflParam = aCurParam;
+        if (i > 1)
+          aFirstInflParam = findInflection (aCurParam, mySeqParams(i-1));
+        indStartLinear = i;
+      }
+  }
+
+  const Standard_Real aDist((aFirstInflParam.Point() -
+                             myExt[1].Point()).Modulus());
+  if (indStartLinear && aDist > 10 * myTolerance)
+  {
+    theSeqPar.Append(aFirstInflParam);
+    theSeqPar.Append(myExt[1]);
+  }
+}
+
+//=======================================================================
+//function : findInflection
+//purpose  : Dichotomic search of the boundary of inflection interval, between
+//           two parameters on the Curve
+//=======================================================================
+
+Geom2dConvert_PPoint Geom2dConvert_ApproxArcsSegments::findInflection
+                                (const Geom2dConvert_PPoint& theParamIsInfl,
+                                 const Geom2dConvert_PPoint& theParamNoInfl) const
+{
+  Standard_Real aLower  (theParamIsInfl.Parameter());
+  Standard_Real anUpper (theParamNoInfl.Parameter());
+  Standard_Real aTest(0.);
+  for (Standard_Integer i = 0; i < 3; i++) {    // 3 iterations
+    aTest = (aLower + anUpper) * 0.5;
+    if (isInflectionPoint (aTest, theParamIsInfl, myCurve, myAngleTolerance))
+      aLower = aTest;
+    else
+      anUpper = aTest;
+  }
+  return Geom2dConvert_PPoint(aTest, myCurve);
+}
+
+//=======================================================================
+//function : makeApproximation
+//purpose  : make approximation non-linear part of the other curve
+//=======================================================================
+
+Standard_Boolean Geom2dConvert_ApproxArcsSegments::makeApproximation
+                                (Geom2dConvert_PPoint& theFirstParam,
+                                 Geom2dConvert_PPoint& theLastParam)
+{
+  // if difference between parameters is less than Precision::PConfusion
+  //approximation was not made.
+  Standard_Boolean isDone = Standard_False;
+  if (theLastParam != theFirstParam) {
+    const Standard_Real aDistance =
+      (theFirstParam.Point() - theLastParam.Point()).Modulus();
+    if (aDistance < myTolerance)
+    {
+      const Handle(Geom2d_Curve) aCurve = makeLine(theFirstParam, theLastParam,
+                                                   Standard_True);
+      isDone = !aCurve.IsNull();
+      if (isDone && mySeqCurves.Length())
+        isDone = checkContinuity(mySeqCurves.Last(), aCurve, myAngleTolerance);
+      if (isDone || aDistance < Precision::Confusion()) {
+        mySeqCurves.Append(aCurve);
+        return isDone;
+      }
+    }
+    //calculate biarc
+    isDone = calculateBiArcs (theFirstParam, theLastParam);
+
+    // if biarc was not calculated calculation is repeated on half the interval.
+    if (!isDone)
+    {
+      Geom2dConvert_PPoint aParaM
+        (theFirstParam.Parameter() +
+         (theLastParam.Parameter() - theFirstParam.Parameter()) * 0.55,
+         myCurve);
+      isDone = makeApproximation (theFirstParam, aParaM);
+      if (isDone)
+        isDone = makeApproximation (aParaM, theLastParam);
+    }
+  }
+  return isDone;
+}
+
+//=======================================================================
+//function : calculateBiArcs
+//purpose  : method for calculation of the biarcs.
+//=======================================================================
+
+Standard_Boolean Geom2dConvert_ApproxArcsSegments::calculateBiArcs
+                                        (Geom2dConvert_PPoint& theFirstParam,
+                                         Geom2dConvert_PPoint& theLastParam)
+{
+  const Standard_Real aResolution = gp::Resolution();
+
+  if (theFirstParam.D1().SquareModulus() < aResolution ||
+      theLastParam.D1().SquareModulus()  < aResolution)
+  {
+    //std::cout << "calculateBiArcs(): bad initial data" << std::endl;
+    return Standard_False;
+  }
+  const gp_XY aPnt[2] = {
+    theFirstParam.Point(),
+    theLastParam.Point()
+  };
+  gp_Dir2d aDir[2] = {
+    theFirstParam.D1(),
+    theLastParam.D1()
+  };
+
+  // Try to approximate the curve by a single arc. The criterion for that is
+  // more rigid if the curve is the entire input curve
+  // (possible pb. connecting with other boundaries)
+  const gp_Vec2d aDelta (aPnt[1] - aPnt[0]);
+  Standard_Real anAngle1 = aDelta.Angle(gp_Vec2d(aDir[0]));
+  if (anAngle1 < 0.)
+    anAngle1 = -anAngle1;
+  Standard_Real anAngle2 = aDelta.Angle(gp_Vec2d(aDir[1]));
+  if (anAngle2 < 0.)
+    anAngle2 = -anAngle2;
+
+  //in the case when two angles are equal one arc can be built.
+  Standard_Real anAngleThreshold (Precision::Angular() * 10.);
+  if (theFirstParam != myExt[0] || theLastParam != myExt[1])
+    anAngleThreshold = myAngleTolerance * 0.1;
+  if (fabs(anAngle1 - anAngle2) < anAngleThreshold)
+  {
+    Handle(Geom2d_TrimmedCurve) aCurve;
+    // protect the theLastParam from modification of D1, when
+    // the created arc is rejected.
+    Geom2dConvert_PPoint aLastParam (theLastParam);
+    if (!makeArc (theFirstParam, aLastParam, Standard_True, aCurve))
+      return Standard_False;
+    if (checkCurve(aCurve, theFirstParam.Parameter(), aLastParam.Parameter()))
+    {
+      theLastParam = aLastParam;
+      mySeqCurves.Append(aCurve);
+      return Standard_True;
+    }
+  }
+
+  // if one arc was not built or for other cases biarc will be built
+  // method for building biarc was taken from article Ahmad H. Nasri et al.
+  // "A Recursive Subdivision Algorithm for Piecewise Circular Spline",
+  // Computer Graphics Forum, 2001.
+
+  // definition of point of intersection two tangent directions in the points
+  // corresponding FirstParameter and LastParameter.
+  aDir[1].Reverse();
+
+  // Direct calculation of intersection point, replaces a class call below
+  const Standard_Real aProd [3] = {
+    aPnt[0] ^ aDir[0].XY(),
+    aPnt[1] ^ aDir[1].XY(),
+    aDir[1] ^ aDir[0].XY()
+  };
+  gp_XY aIntPoint((aProd[0] * aDir[1].X() - aProd[1] * aDir[0].X()) / aProd[2],
+                  (aProd[0] * aDir[1].Y() - aProd[1] * aDir[0].Y()) / aProd[2]);
+  const gp_XY aDiff[2] = {
+    aIntPoint - aPnt[0],
+    aIntPoint - aPnt[1]
+  };
+  if (aDiff[0] * aDir[0].XY() < 0. || aDiff[1] * aDir[1].XY() < 0.)
+  {
+    return Standard_False;
+  }
+
+  //calculation middle point for building biarc.
+  const Standard_Real ad1 = aDiff[0].Modulus();
+  const Standard_Real ad2 = aDiff[1].Modulus();
+  const Standard_Real ad12 = aDelta.Magnitude();
+
+  const Standard_Real aB1 = ad1 / (ad1 + ad2);
+  if (fabs(aB1 - 0.5) < 0.0001)
+    return Standard_False;
+
+  gp_XY aXY[2] = {
+    aPnt[0] + aDir[0].XY() * ad12 * ad1 / (ad12 + ad1 + ad2),
+    aPnt[1] + aDir[1].XY() * ad12 * ad2 / (ad12 + ad1 + ad2)
+  };
+
+  const gp_XY aXYmidArc  (aXY[0] + aB1*(aXY[1]  - aXY[0]));
+  Geom2dConvert_PPoint aParamMidArc =
+    getParameter (aXYmidArc, theFirstParam.Parameter(),
+                  theLastParam.Parameter(), myCurve);
+
+  //building first arc from biarc.
+  Handle(Geom2d_TrimmedCurve) aCurve1, aCurve2;
+  if (!makeArc (theFirstParam, aParamMidArc, Standard_True, aCurve1))
+    return Standard_False;
+
+  if (!checkCurve (aCurve1, theFirstParam.Parameter(),
+                   aParamMidArc.Parameter()))
+    return Standard_False;
+
+  //building second arc from biarc.
+  if (makeArc (theLastParam, aParamMidArc, Standard_False, aCurve2)) {
+    if (checkCurve (aCurve2, aParamMidArc.Parameter(),
+                    theLastParam.Parameter())) {
+      mySeqCurves.Append(aCurve1);
+      mySeqCurves.Append(aCurve2);
+      return Standard_True;
+    }
+  }
+  return Standard_False;
+}
+
+//=======================================================================
+//function : calculateLines
+//purpose  : method for calculation of the linear interpolation.
+//=======================================================================
+
+Standard_Boolean Geom2dConvert_ApproxArcsSegments::calculateLines
+                                        (Geom2dConvert_PPoint& theFirstParam,
+                                         Geom2dConvert_PPoint& theLastParam)
+{
+  Geom2dConvert_PPoint* aPrevParam = &theFirstParam;
+  for (int i = 1; i <= mySeqParams.Length(); i++) 
+  {
+    Geom2dConvert_PPoint& aCurParam = mySeqParams.ChangeValue(i);
+    if (aCurParam.Parameter() < (*aPrevParam).Parameter()) {
+      continue;
+    }
+    if (aCurParam.Parameter() > theLastParam.Parameter()) {
+      break;
+    }
+
+    // build line segment
+    if (aCurParam != *aPrevParam)
+    {
+      const Standard_Real aDistance = 
+        (aCurParam.Point() - (*aPrevParam).Point()).Modulus();
+      if (aDistance > myTolerance)
+      {
+        const Handle(Geom2d_Curve) aCurve = 
+          makeLine(*aPrevParam, aCurParam, Standard_False);
+        if (aCurve.IsNull()) {
+          return Standard_False;
+        }
+
+        mySeqCurves.Append(aCurve);
+        aPrevParam = &mySeqParams(i);
+      }
+    }
+  }
+  return Standard_True;
+}
+
+//=======================================================================
+//function : checkCurve
+//purpose  : method for checking max deflection Geom curve from Adaptor Curve
+//=======================================================================
+
+Standard_Boolean Geom2dConvert_ApproxArcsSegments::checkCurve
+                        (const Handle(Geom2d_Curve)&    aCurve,
+                         const Standard_Real            theFirstParam,
+                         const Standard_Real            theLastParam) const
+{
+  if (aCurve.IsNull())
+    return Standard_False;              // check fails on empty input
+  Standard_Boolean isUniformDone = !mySeqParams.IsEmpty();
+  //calcualtion sequence of the parameters or step by parameter.
+  Standard_Integer aNbPnts = (isUniformDone ? mySeqParams.Length() :MAXPOINTS);
+  Standard_Real aParamStep = (theLastParam - theFirstParam)/MAXPOINTS;
+
+  Handle(Geom2d_Curve) aCurve1 = aCurve;
+  Handle(Geom2d_TrimmedCurve) aTrCurve =
+    Handle(Geom2d_TrimmedCurve)::DownCast(aCurve);
+  if (!aTrCurve.IsNull())
+    aCurve1 = aTrCurve->BasisCurve();
+  gp_Lin2d aLin2d;
+  gp_Circ2d aCirc2d;
+  Handle(Geom2d_Line) aGeomLine = Handle(Geom2d_Line)::DownCast(aCurve1);
+  Standard_Boolean isLine = (!aGeomLine.IsNull());
+  Standard_Boolean isCircle = (!isLine);
+  if (isLine)
+    aLin2d = aGeomLine->Lin2d();
+
+  else {
+    Handle(Geom2d_Circle) aGeomCircle =
+      Handle(Geom2d_Circle)::DownCast(aCurve1);
+    isCircle = (!aGeomCircle.IsNull());
+    if (isCircle)
+      aCirc2d = aGeomCircle->Circ2d();
+    else
+      return Standard_False;
+  }
+
+  //calculation of the max deflection points from CurveAdaptor from Geom curve.
+  Standard_Boolean isLess = Standard_True;
+  Standard_Integer i = 1;
+  for (; i <= aNbPnts && isLess; i++)
+  {
+
+    Standard_Real aParam = (isUniformDone ? mySeqParams.Value(i).Parameter() :
+                             (theFirstParam + i*aParamStep));
+    if (aParam < (theFirstParam - Precision::PConfusion()) ||
+        aParam > (theLastParam + Precision::PConfusion())) continue;
+
+    //getting point from adaptor curve by specified parameter.
+    gp_Pnt2d aPointAdaptor(0., 0.);
+    gp_Pnt2d aProjPoint(0., 0.);
+    myCurve.D0(aParam, aPointAdaptor);
+    Standard_Real aParameterCurve = 0.0;
+
+    //getting point from geom curve by specified parameter.
+    if (isLine)
+    {
+      aParameterCurve = ElCLib::Parameter(aLin2d, aPointAdaptor);
+      aProjPoint = ElCLib::Value(aParameterCurve, aLin2d);
+    }
+    else if (isCircle)
+    {
+
+      aParameterCurve = ElCLib::Parameter(aCirc2d, aPointAdaptor);
+      aProjPoint = ElCLib::Value(aParameterCurve, aCirc2d);
+    }
+    else isLess = Standard_False;
+
+    isLess = (aProjPoint.Distance(aPointAdaptor) <
+              myTolerance + Precision::PConfusion());
+  }
+  return isLess;
+}
+
+//=======================================================================
+//function : checkContinuity
+//purpose  : check continuty first derivative between two curves.
+//=======================================================================
+
+Standard_Boolean checkContinuity (const Handle(Geom2d_Curve)& theCurve1,
+                                  const Handle(Geom2d_Curve)& theCurve2,
+                                  const Standard_Real         theAngleTol)
+{
+  gp_Vec2d v11,v21;
+  gp_Pnt2d p1, p2;
+  theCurve1->D1(theCurve1->LastParameter(),  p1, v11);
+  theCurve2->D1(theCurve2->FirstParameter(), p2, v21);
+
+  //check continuity with the specified tolerance.
+  return (v11.IsParallel(v21, theAngleTol));
+}
+
+//=======================================================================
+//function : getParameter
+//purpose  : getting the nearest point on AdaptorCurve to the specified point.
+//=======================================================================
+
+Geom2dConvert_PPoint getParameter (const gp_XY&             theXY1,
+                                   const Standard_Real      theFirstParam,
+                                   const Standard_Real      theLastParam,
+                                   const Adaptor2d_Curve2d& theCurve)
+{
+  Geom2dConvert_PPoint aResult;
+  Standard_Real prevParam = theFirstParam;
+  Standard_Real af1 = theFirstParam;
+  Standard_Real af2 = theLastParam;
+
+  // for finding nearest point use method half division.
+  Standard_Real aMinDist = RealLast();
+  Standard_Integer i = 1;
+  for (; i <= MAXPOINTS; i++)
+  {
+    aResult = Geom2dConvert_PPoint(af1, theCurve);
+    Standard_Real adist1 = (theXY1 - aResult.Point()).Modulus();
+    if (adist1 < Precision::Confusion())
+    {
+      return aResult;
+    }
+
+    aResult = Geom2dConvert_PPoint(af2, theCurve);
+    Standard_Real adist2 = (theXY1 - aResult.Point()).Modulus();
+    if (adist2 < Precision::Confusion())
+    {
+      return aResult;
+    }
+
+    if (aMinDist <= adist2 -Precision::Confusion() &&
+        aMinDist <= adist1 -Precision::Confusion())
+    {
+      break;
+    }
+
+    if (adist1 < adist2 -Precision::Confusion())
+    {
+      prevParam = af1;
+      aMinDist = adist1;
+      af2 = (af1 + af2) * 0.5;
+    }
+    else
+    {
+      prevParam = af2;
+      aMinDist = adist2;
+      af1 = (af1 + af2) * 0.5;
+    }
+  }
+  aResult = Geom2dConvert_PPoint(prevParam, theCurve);
+  return aResult;
+}
+
+//=======================================================================
+//function : isInflectionPoint
+//purpose  : method calculating that point specified by parameter
+//           is inflection point
+//=======================================================================
+
+Standard_Boolean isInflectionPoint (const Standard_Real      theParam,
+                                    const Adaptor2d_Curve2d& theCurve)
+{
+  gp_Pnt2d aP1;
+  gp_Vec2d aD1, aD2;
+  theCurve.D2(theParam, aP1, aD1, aD2);
+  const Standard_Real aSqMod = aD1.XY().SquareModulus();
+  const Standard_Real aCurvature = 
+    fabs (aD1.XY() ^ aD2.XY()) / (aSqMod * sqrt(aSqMod));
+  return (aCurvature < MyCurvatureTolerance);
+}
+
+//=======================================================================
+//function : isInflectionPoint
+//purpose  : method calculating that point specified by parameter
+//           is inflection point
+//=======================================================================
+
+Standard_Boolean isInflectionPoint (const Standard_Real         theParam,
+                                    const Geom2dConvert_PPoint& theFirstInfl,
+                                    const Adaptor2d_Curve2d&    theCurve,
+                                    const Standard_Real         theAngleTol)
+{
+  gp_Pnt2d aP1;
+  gp_Vec2d aD1, aD2;
+  theCurve.D2(theParam, aP1, aD1, aD2);
+  const Standard_Real aSqMod = aD1.XY().SquareModulus();
+  const Standard_Real aCurvature = 
+    fabs (aD1.XY() ^ aD2.XY()) / (aSqMod * sqrt(aSqMod));
+  Standard_Real aContAngle =
+    fabs(gp_Vec2d(aP1.XY() - theFirstInfl.Point()).Angle(aD1));
+  aContAngle = ::Min(aContAngle, fabs(M_PI - aContAngle));
+  return (aCurvature < MyCurvatureTolerance && aContAngle < theAngleTol);
+}

src/Geom2dConvert/Geom2dConvert_ApproxArcsSegments.hxx

@@ -0,0 +1,113 @@
+// Created: 2009-01-20
+// 
+// Copyright (c) 2009-2013 OPEN CASCADE SAS
+// 
+// This file is part of commercial software by OPEN CASCADE SAS, 
+// furnished in accordance with the terms and conditions of the contract 
+// and with the inclusion of this copyright notice. 
+// This file or any part thereof may not be provided or otherwise 
+// made available to any third party. 
+// 
+// No ownership title to the software is transferred hereby. 
+// 
+// OPEN CASCADE SAS makes no representation or warranties with respect to the 
+// performance of this software, and specifically disclaims any responsibility 
+// for any damages, special or consequential, connected with its use. 
+
+#ifndef _Geom2dConvert_ApproxArcsSegments_HeaderFile
+#define _Geom2dConvert_ApproxArcsSegments_HeaderFile
+
+#include <TColGeom2d_SequenceOfCurve.hxx>
+#include <Geom2dConvert_PPoint.hxx>
+#include <Geom2dConvert_SequenceOfPPoint.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
+
+//! Approximation of a free-form curve by a sequence of arcs+segments.
+class Geom2dConvert_ApproxArcsSegments
+{
+ public:
+  // ---------- PUBLIC METHODS ----------
+
+  enum Status {
+    StatusOK = 0,
+    StatusNotDone,
+    StatusError
+  };
+
+  //! Constructor.
+  Standard_EXPORT Geom2dConvert_ApproxArcsSegments (const Adaptor2d_Curve2d&  theCurve,
+                                                    const Standard_Real       theTolerance,
+                                                    const Standard_Real       theAngleTol);
+
+  //! Get the result curve after approximation.
+  const TColGeom2d_SequenceOfCurve& GetResult() const
+  { return mySeqCurves; }
+
+private:
+
+  //! Create arc of circle by three points (knowing that myCurve is circle).
+  Handle(Geom2d_Curve)
+                   makeCircle     (const Geom2dConvert_PPoint& theFirst,
+                                   const Geom2dConvert_PPoint& theLast) const;
+
+  //! Create an arc of circle using 2 points and a derivative in the first point.
+  Standard_Boolean makeArc        (const Geom2dConvert_PPoint&  theParam1,
+                                   Geom2dConvert_PPoint&        theParam2,
+                                   const Standard_Boolean       isFirst,
+                                   Handle(Geom2d_TrimmedCurve)& theCurve) const;
+
+  //! Make a line from myCurve in the limits by parameter from theFirst to theLast
+  Handle(Geom2d_TrimmedCurve)
+                   makeLine       (Geom2dConvert_PPoint&  theFirst,
+                                   Geom2dConvert_PPoint&  theLast,
+                                   const Standard_Boolean isCheck) const;
+
+  //! Create a sequence of elementary curves from a free-form adaptor curve.
+  Standard_Boolean makeFreeform   ();
+
+  //! Obtain the linear intervals on the curve using as criteria
+  //! curvature tolerance (indicating either linear part or inflection)
+  void             getLinearParts (Geom2dConvert_SequenceOfPPoint& theSeqParam);
+
+  //! Dichotomic search of the boundary of inflection interval, between
+  //! two parameters on the Curve
+  Geom2dConvert_PPoint findInflection(const Geom2dConvert_PPoint& theParamIsIn,
+                                      const Geom2dConvert_PPoint& theParamNoIn) const;
+
+  //! Make approximation non-linear part of the other curve.
+  Standard_Boolean makeApproximation
+                                  (Geom2dConvert_PPoint& theFirstParam,
+                                   Geom2dConvert_PPoint& theLastParam);
+
+  //! Method for calculation of a biarc.
+  Standard_Boolean calculateBiArcs(Geom2dConvert_PPoint& theFirstParam,
+                                   Geom2dConvert_PPoint& theLastParam);
+
+  //! Method for calculation of a linear interpolation.
+  Standard_Boolean calculateLines(Geom2dConvert_PPoint& theFirstParam,
+                                  Geom2dConvert_PPoint& theLastParam);
+
+  //! Checking max deflection Geom curve from Adaptor Curve
+  Standard_Boolean checkCurve     (const Handle(Geom2d_Curve)& aCurve,
+                                   const Standard_Real    theFirstParam,
+                                   const Standard_Real    theLastParam) const;
+
+ private:
+  // ---------- PRIVATE FIELDS ----------
+
+  const Adaptor2d_Curve2d&              myCurve;
+  Geom2dConvert_PPoint                  myExt[2];
+
+  Handle(NCollection_BaseAllocator)     myAlloc;
+  Standard_Real                         myTolerance;
+  Standard_Real                         myAngleTolerance;
+
+  Geom2dConvert_SequenceOfPPoint        mySeqParams;
+  TColGeom2d_SequenceOfCurve            mySeqCurves;
+  Status                                myStatus;
+
+  //! Protection against compiler warning
+  void operator= (const Geom2dConvert_ApproxArcsSegments&);
+};
+
+#endif

src/Geom2dConvert/Geom2dConvert_PPoint.cxx

@@ -0,0 +1,54 @@
+// Created: 2009-02-02
+// 
+// Copyright (c) 2009-2013 OPEN CASCADE SAS
+// 
+// This file is part of commercial software by OPEN CASCADE SAS, 
+// furnished in accordance with the terms and conditions of the contract 
+// and with the inclusion of this copyright notice. 
+// This file or any part thereof may not be provided or otherwise 
+// made available to any third party. 
+// 
+// No ownership title to the software is transferred hereby. 
+// 
+// OPEN CASCADE SAS makes no representation or warranties with respect to the 
+// performance of this software, and specifically disclaims any responsibility 
+// for any damages, special or consequential, connected with its use. 
+
+#include <Geom2dConvert_PPoint.hxx>
+
+#include <Adaptor2d_Curve2d.hxx>
+#include <Precision.hxx>
+
+//=======================================================================
+//function : Geom2dConvert_PPoint
+//purpose  : Constructor
+//=======================================================================
+
+Geom2dConvert_PPoint::Geom2dConvert_PPoint (const Standard_Real      theParameter,
+                                            const Adaptor2d_Curve2d& theAdaptor)
+  : myParameter (theParameter)
+{
+  theAdaptor.D1(theParameter, myPoint, myD1);
+}
+
+//=======================================================================
+//function : Geom2dConvert_PPoint::operator ==
+//purpose  : Compare two values of this type.
+//=======================================================================
+
+Standard_Boolean Geom2dConvert_PPoint::operator ==
+                (const Geom2dConvert_PPoint& theOther) const
+{
+  return (fabs(myParameter - theOther.Parameter()) <= Precision::PConfusion());
+}
+
+//=======================================================================
+//function : Geom2dConvert_PPoint::operator !=
+//purpose  : Compare two values of this type.
+//=======================================================================
+
+Standard_Boolean Geom2dConvert_PPoint::operator !=
+                (const Geom2dConvert_PPoint& theOther) const
+{
+  return (fabs(myParameter - theOther.Parameter()) > Precision::PConfusion());
+}

src/Geom2dConvert/Geom2dConvert_PPoint.hxx

@@ -0,0 +1,76 @@
+// Created: 2009-01-21
+// 
+// Copyright (c) 2009-2013 OPEN CASCADE SAS
+// 
+// This file is part of commercial software by OPEN CASCADE SAS, 
+// furnished in accordance with the terms and conditions of the contract 
+// and with the inclusion of this copyright notice. 
+// This file or any part thereof may not be provided or otherwise 
+// made available to any third party. 
+// 
+// No ownership title to the software is transferred hereby. 
+// 
+// OPEN CASCADE SAS makes no representation or warranties with respect to the 
+// performance of this software, and specifically disclaims any responsibility 
+// for any damages, special or consequential, connected with its use. 
+
+#ifndef _Geom2dConvert_PPoint_HeaderFile
+#define _Geom2dConvert_PPoint_HeaderFile
+
+#include <gp_Pnt2d.hxx>
+#include <gp_Vec2d.hxx>
+
+class Adaptor2d_Curve2d;
+
+//! Class representing a point on curve, with 2D coordinate and the tangent
+class Geom2dConvert_PPoint
+{
+public:
+  //! Empty constructor.
+  Standard_EXPORT inline Geom2dConvert_PPoint ()
+    : myParameter (::RealLast()),
+      myPoint     (0., 0.),
+      myD1        (0., 0.) {}
+
+  //! Constructor.
+  Standard_EXPORT inline Geom2dConvert_PPoint (const Standard_Real theParameter,
+                                               const gp_XY&        thePoint,
+                                               const gp_XY&        theD1)
+    : myParameter (theParameter),
+      myPoint     (thePoint),
+      myD1        (theD1) {}
+
+  //! Constructor.
+  Standard_EXPORT Geom2dConvert_PPoint (const Standard_Real      theParameter,
+                                        const Adaptor2d_Curve2d& theAdaptor);
+
+  //! Compute the distance betwwen two 2d points.
+  inline Standard_Real        Dist      (const Geom2dConvert_PPoint& theOth) const
+  { return myPoint.Distance(theOth.myPoint); }
+
+  //! Query the parmeter value.
+  inline Standard_Real        Parameter () const { return myParameter; }
+
+  //! Query the point location.
+  inline const gp_XY&         Point     () const { return myPoint.XY(); }
+
+  //! Query the first derivatives.
+  inline const gp_XY&         D1        () const { return myD1.XY(); }
+    
+  //! Change the value of the derivative at the point.
+  inline void                 SetD1     (const gp_XY& theD1)
+  { myD1.SetXY (theD1); }
+
+  //! Compare two values of this type.
+  Standard_EXPORT Standard_Boolean operator == (const Geom2dConvert_PPoint&) const;
+
+  //! Compare two values of this type.
+  Standard_EXPORT Standard_Boolean operator != (const Geom2dConvert_PPoint&) const;
+
+private:
+  Standard_Real    myParameter; //! Parameter value
+  gp_Pnt2d  myPoint; //! Point location
+  gp_Vec2d  myD1;    //! derivatives by parameter (components of the tangent).
+};
+
+#endif

src/Geom2dConvert/Geom2dConvert_SequenceOfPPoint.hxx

@@ -0,0 +1,25 @@
+// Created: 2009-01-09
+// 
+// Copyright (c) 2009-2013 OPEN CASCADE SAS
+// 
+// This file is part of commercial software by OPEN CASCADE SAS, 
+// furnished in accordance with the terms and conditions of the contract 
+// and with the inclusion of this copyright notice. 
+// This file or any part thereof may not be provided or otherwise 
+// made available to any third party. 
+// 
+// No ownership title to the software is transferred hereby. 
+// 
+// OPEN CASCADE SAS makes no representation or warranties with respect to the 
+// performance of this software, and specifically disclaims any responsibility 
+// for any damages, special or consequential, connected with its use. 
+
+#ifndef _Geom2dConvert_SequenceOfPPoint_HeaderFile
+#define _Geom2dConvert_SequenceOfPPoint_HeaderFile
+
+#include <NCollection_Sequence.hxx>
+class Geom2dConvert_PPoint;
+
+typedef NCollection_Sequence<Geom2dConvert_PPoint> Geom2dConvert_SequenceOfPPoint;
+
+#endif

src/GeomConvert/FILES

@@ -18,3 +18,14 @@ GeomConvert_CompBezierSurfacesToBSplineSurface.hxx
 GeomConvert_CompBezierSurfacesToBSplineSurface.lxx
 GeomConvert_CompCurveToBSplineCurve.cxx
 GeomConvert_CompCurveToBSplineCurve.hxx
+GeomConvert_CurveToAnaCurve.cxx
+GeomConvert_CurveToAnaCurve.hxx
+GeomConvert_SurfToAnaSurf.cxx
+GeomConvert_SurfToAnaSurf.hxx
+GeomConvert_ConvType.hxx
+GeomConvert_FuncSphereLSDist.cxx
+GeomConvert_FuncSphereLSDist.hxx
+GeomConvert_FuncCylinderLSDist.cxx
+GeomConvert_FuncCylinderLSDist.hxx
+GeomConvert_FuncConeLSDist.cxx
+GeomConvert_FuncConeLSDist.hxx

src/GeomConvert/GeomConvert_ConvType.hxx

@@ -0,0 +1,23 @@
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _GeomConvert_ConvType_HeaderFile
+#define _GeomConvert_ConvType_HeaderFile
+enum GeomConvert_ConvType
+{
+  GeomConvert_Target,
+  GeomConvert_Simplest,
+  GeomConvert_MinGap
+};
+
+#endif // _GeomConvert_ConvType_HeaderFile

src/GeomConvert/GeomConvert_CurveToAnaCurve.cxx

@@ -0,0 +1,768 @@
+// Created: 2001-05-21 
+// 
+// Copyright (c) 2001-2013 OPEN CASCADE SAS 
+// 
+// This file is part of commercial software by OPEN CASCADE SAS, 
+// furnished in accordance with the terms and conditions of the contract 
+// and with the inclusion of this copyright notice. 
+// This file or any part thereof may not be provided or otherwise 
+// made available to any third party. 
+// 
+// No ownership title to the software is transferred hereby. 
+// 
+// OPEN CASCADE SAS makes no representation or warranties with respect to the 
+// performance of this software, and specifically disclaims any responsibility 
+// for any damages, special or consequential, connected with its use. 
+
+
+#include <ElCLib.hxx>
+#include <gce_MakeCirc.hxx>
+#include <Geom_BezierCurve.hxx>
+#include <Geom_BSplineCurve.hxx>
+#include <Geom_Circle.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom_Ellipse.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <gp_Ax2.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Circ.hxx>
+#include <gp_Lin.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <Precision.hxx>
+#include <GeomConvert_CurveToAnaCurve.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_HArray1OfPnt.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_Array2OfReal.hxx>
+#include <GeomAbs_CurveType.hxx>
+#include <math_Vector.hxx>
+#include <math_Matrix.hxx>
+#include <math_Gauss.hxx>
+
+
+GeomConvert_CurveToAnaCurve::GeomConvert_CurveToAnaCurve():
+  myGap(Precision::Infinite()),
+  myConvType(GeomConvert_MinGap),
+  myTarget(GeomAbs_Line)
+{
+}
+
+GeomConvert_CurveToAnaCurve::GeomConvert_CurveToAnaCurve(const Handle(Geom_Curve)& C) :
+  myGap(Precision::Infinite()),
+  myConvType(GeomConvert_MinGap),
+  myTarget(GeomAbs_Line)
+{
+  myCurve = C;
+}
+
+void GeomConvert_CurveToAnaCurve::Init(const Handle(Geom_Curve)& C) 
+{
+  myCurve = C;
+  myGap = Precision::Infinite();
+}
+
+//=======================================================================
+//function : ConvertToAnalytical
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean GeomConvert_CurveToAnaCurve::ConvertToAnalytical(const Standard_Real tol, 
+                                                         Handle(Geom_Curve)& theResultCurve, 
+                                                         const Standard_Real F, const Standard_Real L,
+                                                         Standard_Real& NewF, Standard_Real& NewL)
+{
+  if(myCurve.IsNull())
+    return Standard_False;
+  
+  Handle(Geom_Curve) aCurve = myCurve;
+  while (aCurve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
+    Handle(Geom_TrimmedCurve) aTrimmed = Handle(Geom_TrimmedCurve)::
+      DownCast(aCurve);
+    aCurve = aTrimmed->BasisCurve();
+  }
+  
+  Handle(Geom_Curve) C = ComputeCurve(aCurve,tol,F, L, NewF, NewL, myGap, myConvType, myTarget);
+
+  if(C.IsNull()) return Standard_False;
+  theResultCurve = C; 
+  return Standard_True;
+}
+
+//=======================================================================
+//function : IsLinear
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean GeomConvert_CurveToAnaCurve::IsLinear(const TColgp_Array1OfPnt& aPoles,
+                                              const Standard_Real tolerance,
+                                              Standard_Real& Deviation)
+{
+  Standard_Integer nbPoles = aPoles.Length();
+  if(nbPoles < 2)
+    return Standard_False;
+  
+  Standard_Real dMax = 0;
+  Standard_Integer iMax1=0,iMax2=0;
+  
+  Standard_Integer i;
+  for(i = 1; i < nbPoles; i++)
+    for(Standard_Integer j = i+1; j <= nbPoles; j++) {
+      Standard_Real dist = aPoles(i).SquareDistance(aPoles(j));
+      if(dist > dMax) {
+        dMax = dist;
+        iMax1 = i;
+        iMax2 = j;
+      }
+    }
+  
+  if (dMax < Precision::SquareConfusion())
+    return Standard_False;
+  
+  Standard_Real tol2 = tolerance*tolerance;
+  gp_Vec avec (aPoles(iMax1),aPoles(iMax2));  gp_Dir adir (avec);  gp_Lin alin (aPoles(iMax1),adir);
+  
+  Standard_Real aMax = 0.;
+  for(i = 1; i <= nbPoles; i++) {
+    Standard_Real dist = alin.SquareDistance(aPoles(i));
+    if(dist > tol2)
+      return Standard_False;
+    if(dist > aMax)
+      aMax = dist;
+  }
+  Deviation = sqrt(aMax);
+  
+  return Standard_True;
+}
+
+//=======================================================================
+//function : GetLine
+//purpose  : 
+//=======================================================================
+
+gp_Lin GeomConvert_CurveToAnaCurve::GetLine(const gp_Pnt& P1, const gp_Pnt& P2,
+                                             Standard_Real& cf, Standard_Real& cl)
+{
+  gp_Vec avec(P1, P2);  gp_Dir adir(avec);  gp_Lin alin(P1, adir);
+  cf = ElCLib::Parameter(alin, P1);
+  cl = ElCLib::Parameter(alin, P2);
+  return alin;
+}
+//=======================================================================
+//function : ComputeLine
+//purpose  : 
+//=======================================================================
+
+Handle(Geom_Line) GeomConvert_CurveToAnaCurve::ComputeLine (const Handle(Geom_Curve)& curve,
+                                                   const Standard_Real tolerance,
+                                                   const Standard_Real c1, const Standard_Real c2,
+                                                   Standard_Real& cf, Standard_Real& cl,
+                                                   Standard_Real& Deviation)
+{
+  Handle(Geom_Line) line;
+  if (curve.IsNull()) return line;
+  line = Handle(Geom_Line)::DownCast(curve);  // qui sait
+  if (!line.IsNull()) {
+    cf = c1;
+    cl = c2;
+    Deviation = 0.;
+    return line;
+  }
+
+  gp_Pnt P1 = curve->Value (c1);
+  gp_Pnt P2 = curve->Value (c2);
+  if(P1.SquareDistance(P2) < Precision::SquareConfusion())
+    return line;
+  cf = c1;  cl = c2;
+  
+  Handle(TColgp_HArray1OfPnt) Poles;
+  Standard_Integer nbPoles;
+  Handle(Geom_BSplineCurve) bsc = Handle(Geom_BSplineCurve)::DownCast(curve);
+  if (!bsc.IsNull()) {
+    nbPoles = bsc->NbPoles();
+    Poles = new TColgp_HArray1OfPnt(1, nbPoles);
+    bsc->Poles(Poles->ChangeArray1());
+  }
+  else
+  {
+    Handle(Geom_BezierCurve) bzc = Handle(Geom_BezierCurve)::DownCast(curve);
+    if (!bzc.IsNull()) {
+      nbPoles = bzc->NbPoles();
+      Poles = new TColgp_HArray1OfPnt(1, nbPoles);
+      bzc->Poles(Poles->ChangeArray1());
+    }
+    else
+    {
+      nbPoles = 23;
+      Poles = new TColgp_HArray1OfPnt(1, nbPoles);
+      Standard_Real dt = (c2 - c1) / (nbPoles - 1);
+      Poles->SetValue(1, P1);
+      Poles->SetValue(nbPoles, P2);
+      Standard_Integer i;
+      for (i = 2; i < nbPoles; ++i)
+      {
+        Poles->SetValue(i, curve->Value(c1 + (i - 1) * dt));
+      }
+    }
+  }
+  if(!IsLinear(Poles->Array1(),tolerance,Deviation)) return line;  // non
+  gp_Lin alin = GetLine (P1, P2, cf, cl);
+  line = new Geom_Line (alin);
+  return line;
+}
+
+//=======================================================================
+//function : GetCircle
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean GeomConvert_CurveToAnaCurve::GetCircle (gp_Circ& crc,   
+                                                const gp_Pnt& P0,const gp_Pnt& P1, const gp_Pnt& P2) 
+{
+//  Control if points are not aligned (should be done by MakeCirc 
+  Standard_Real aMaxCoord = Sqrt(Precision::Infinite());
+  if (Abs(P0.X()) > aMaxCoord || Abs(P0.Y()) > aMaxCoord || Abs(P0.Z()) > aMaxCoord)
+    return Standard_False;
+  if (Abs(P1.X()) > aMaxCoord || Abs(P1.Y()) > aMaxCoord || Abs(P1.Z()) > aMaxCoord)
+    return Standard_False;
+  if (Abs(P2.X()) > aMaxCoord || Abs(P2.Y()) > aMaxCoord || Abs(P2.Z()) > aMaxCoord)
+    return Standard_False;
+
+//  Building the circle
+  gce_MakeCirc mkc (P0,P1,P2);
+  if (!mkc.IsDone()) return Standard_False;
+  crc = mkc.Value();
+  if (crc.Radius() < gp::Resolution()) return Standard_False;
+  //  Recalage sur P0
+  gp_Pnt PC = crc.Location();
+  gp_Ax2 axe = crc.Position();
+  gp_Vec VX (PC,P0);
+  axe.SetXDirection (VX);
+  crc.SetPosition (axe);
+  return Standard_True;
+}
+
+//=======================================================================
+//function : ComputeCircle
+//purpose  : 
+//=======================================================================
+
+Handle(Geom_Curve) GeomConvert_CurveToAnaCurve::ComputeCircle (const Handle(Geom_Curve)& c3d, 
+                                                      const Standard_Real tol,
+                                                      const Standard_Real c1, const Standard_Real c2,
+                                                      Standard_Real& cf, Standard_Real& cl,
+                                                      Standard_Real& Deviation)
+{
+  if (c3d->IsKind (STANDARD_TYPE(Geom_Circle))) {
+    cf = c1;
+    cl = c2;
+    Deviation = 0.;
+    Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(c3d);
+    return aCirc;
+  }
+  
+  Handle(Geom_Circle) circ;
+  gp_Pnt P0,P1,P2;
+  Standard_Real ca = (c1+c1+c2) / 3;  Standard_Real cb = (c1+c2+c2) / 3;
+  P0 = c3d->Value(c1);
+  P1 = c3d->Value(ca);
+  P2 = c3d->Value(cb);
+  
+  gp_Circ crc;
+  if (!GetCircle (crc,P0,P1,P2)) return circ;
+  
+  //  Reste a controler que c est bien un cercle : prendre 20 points
+  Standard_Real du = (c2-c1)/20;
+  Standard_Integer i;
+  Standard_Real aMax = 0.;
+  for (i = 0; i <= 20; i ++) {
+    Standard_Real u = c1+(du*i);
+    gp_Pnt PP = c3d->Value(u);
+    Standard_Real dist = crc.Distance(PP);
+    if (dist > tol) return circ;  // not done
+    if (dist > aMax)
+      aMax = dist;
+  }
+  Deviation = aMax;
+  
+  // defining the parameters
+  Standard_Real PI2 = 2 * M_PI;
+  
+  cf = ElCLib::Parameter (crc,c3d->Value (c1));
+  cf = ElCLib::InPeriod(cf, 0., PI2);
+
+  //first parameter should be closed to zero
+  
+  if(Abs(cf) < Precision::PConfusion() || Abs(PI2-cf) < Precision::PConfusion())
+    cf = 0.;
+
+  Standard_Real cm = ElCLib::Parameter (crc,c3d->Value ((c1+c2)/2.));
+  cm = ElCLib::InPeriod(cm, cf, cf + PI2);
+
+  cl = ElCLib::Parameter (crc,c3d->Value (c2));
+  cl = ElCLib::InPeriod(cl, cm, cm + PI2);
+
+  circ = new Geom_Circle (crc);
+  return circ;
+}
+
+//=======================================================================
+//              Compute Ellipse
+//=======================================================================
+
+//=======================================================================
+//function : IsArrayPntPlanar
+//purpose  : 
+//=======================================================================
+
+static Standard_Boolean IsArrayPntPlanar(const Handle(TColgp_HArray1OfPnt)& HAP,
+                                         gp_Dir& Norm, const Standard_Real prec)
+{
+  Standard_Integer size = HAP->Length();
+  if(size<3)
+    return Standard_False;
+  gp_Pnt P1 = HAP->Value(1);
+  gp_Pnt P2 = HAP->Value(2);
+  gp_Pnt P3 = HAP->Value(3);
+  Standard_Real dist1 = P1.Distance(P2);
+  Standard_Real dist2 = P1.Distance(P3);
+  if( dist1<prec || dist2<prec )
+    return Standard_False;
+  gp_Vec V1(P1,P2);
+  gp_Vec V2(P1,P3);
+  if(V1.IsParallel(V2,prec))
+    return Standard_False;
+  gp_Vec NV = V1.Crossed(V2);
+
+  Standard_Integer i;
+  for (i = 1; i <= 3; ++i)
+  {
+    if (Precision::IsInfinite(NV.Coord(i)))
+      return Standard_False;
+  }
+
+  if(NV.Magnitude() < gp::Resolution())
+    return Standard_False;
+
+  if(size>3) {
+    for(i=4; i<=size; i++) {
+      gp_Pnt PN = HAP->Value(i);
+      dist1 = P1.Distance(PN);
+      if (dist1 < prec || Precision::IsInfinite(dist1))
+      {
+        return Standard_False;
+      }
+      gp_Vec VN(P1,PN);
+      if(!NV.IsNormal(VN,prec))
+        return Standard_False;
+    }
+  }
+  Norm = NV;
+  return Standard_True;
+}
+
+//=======================================================================
+//function : ConicdDefinition
+//purpose  : 
+//=======================================================================
+
+static Standard_Boolean ConicDefinition
+       ( const Standard_Real a, const Standard_Real b1, const Standard_Real c,
+         const Standard_Real d1, const Standard_Real e1, const Standard_Real f,
+         const Standard_Boolean IsParab, const Standard_Boolean IsEllip,
+         gp_Pnt& Center, gp_Dir& MainAxis, Standard_Real& Rmin, Standard_Real& Rmax )
+{
+  Standard_Real Xcen = 0.,Ycen = 0., Xax = 0.,Yax = 0.;
+  Standard_Real b,d,e;
+  //  conic : a*x2 + 2*b*x*y + c*y2 + 2*d*x + 2*e*y + f = 0.
+  //Equation (a,b,c,d,e,f);
+  b = b1/2.;  d = d1/2.;  e = e1/2.;    // chgt de variable
+
+  Standard_Real eps = 1.E-08;  // ?? comme ComputedForm
+
+  if (IsParab) {
+
+  } 
+  else {
+    //   -> Conique a centre, cas general
+    //  On utilise les Determinants des matrices :
+    //               | a b d |
+    //  gdet (3x3) = | b c e |  et pdet (2X2) = | a b |
+    //               | d e f |                  | b c |
+    
+    Standard_Real gdet = a*c*f + 2*b*d*e - c*d*d - a*e*e - b*b*f;
+    Standard_Real pdet = a*c - b*b;
+    
+    Xcen = (b*e - c*d) / pdet;
+    Ycen = (b*d - a*e) / pdet;
+
+    Standard_Real term1 = a-c;
+    Standard_Real term2 = 2*b;
+    Standard_Real cos2t;
+    Standard_Real auxil;
+
+    if (Abs(term2) <= eps && Abs(term1) <= eps) {
+      cos2t = 1.;
+      auxil = 0.;
+    }
+    else {
+      if (Abs(term1) < eps)
+      {
+        return Standard_False;
+      }
+      Standard_Real t2d = term2/term1; //skl 21.11.2001
+      cos2t = 1./sqrt(1+t2d*t2d);
+      auxil = sqrt (term1*term1 + term2*term2);
+    }
+    
+    Standard_Real cost = sqrt ( (1+cos2t)/2. );
+    Standard_Real sint = sqrt ( (1-cos2t)/2. );
+
+    Standard_Real aprim = (a+c+auxil)/2.;
+    Standard_Real cprim = (a+c-auxil)/2.;
+
+    if (Abs(aprim) < gp::Resolution() || Abs(cprim) < gp::Resolution())
+      return Standard_False;
+    
+    term1 = -gdet/(aprim*pdet);
+    term2 = -gdet/(cprim*pdet);
+      
+    if (IsEllip) {
+      Xax = cost;
+      Yax = sint;
+      Rmin = sqrt ( term1);
+      Rmax = sqrt ( term2);
+      if(Rmax<Rmin){
+        Rmax = sqrt ( term1);
+        Rmin = sqrt ( term2);
+      }
+    }
+    else if (term1 <= eps){
+      Xax  = -sint;
+      Yax  =  cost;
+      Rmin = sqrt (-term1);
+      Rmax = sqrt (term2);
+    } 
+    else {
+      Xax  =  cost;
+      Yax  =  sint;
+      Rmin = sqrt (-term2);
+      Rmax = sqrt (term1);
+    }
+  }
+  Center.SetCoord (Xcen,Ycen,0.);
+  MainAxis.SetCoord (Xax,Yax,0.);
+  return Standard_True;
+}
+
+//=======================================================================
+//function : ComputeEllipse
+//purpose  : 
+//=======================================================================
+Handle(Geom_Curve) GeomConvert_CurveToAnaCurve::ComputeEllipse(const Handle(Geom_Curve)& c3d,
+                                                       const Standard_Real tol,
+                                                       const Standard_Real c1, const Standard_Real c2,
+                                                       Standard_Real& cf, Standard_Real& cl,
+                                                       Standard_Real& Deviation)
+{
+  if (c3d->IsKind (STANDARD_TYPE(Geom_Ellipse))) {
+    cf = c1;
+    cl = c2;
+    Deviation = 0.;
+    Handle(Geom_Ellipse) anElips = Handle(Geom_Ellipse)::DownCast(c3d);
+    return anElips;
+  }
+
+  Handle(Geom_Curve) res;
+  Standard_Real prec = Precision::PConfusion();
+  
+  Standard_Real AF,BF,CF,DF,EF,Q1,Q2,Q3,c2n;
+  Standard_Integer i;
+  
+  gp_Pnt PStart = c3d->Value(c1);
+  gp_Pnt PEnd = c3d->Value(c2);
+
+  const Standard_Boolean IsClos = PStart.Distance(PEnd) < prec;
+  if (IsClos)
+  {
+    c2n=c2-(c2-c1)/5;
+  }
+  else
+    c2n=c2;
+  //
+  gp_XYZ aBC;
+  Handle(TColgp_HArray1OfPnt) AP = new TColgp_HArray1OfPnt(1,5);
+  AP->SetValue(1,PStart);
+  aBC += PStart.XYZ();
+  Standard_Real dc=(c2n-c1)/4;
+  for (i = 1; i < 5; i++)
+  {
+    gp_Pnt aP = c3d->Value(c1 + dc*i);
+    AP->SetValue(i + 1, aP);
+    aBC += aP.XYZ();
+  }
+  aBC /= 5;
+  aBC *= -1;
+  gp_Vec aTrans(aBC);
+  for (i = 1; i <= 5; ++i)
+  {
+    AP->ChangeValue(i).Translate(aTrans);
+  }
+  gp_Dir ndir;
+  if(!IsArrayPntPlanar(AP,ndir,prec))
+    return res;
+
+  if (Abs(ndir.X()) < gp::Resolution() && Abs(ndir.Y()) < gp::Resolution()
+    && Abs(ndir.Z()) < gp::Resolution())
+    return res;
+
+  gp_Ax3 AX(gp_Pnt(0,0,0),ndir);
+  gp_Trsf Tr;
+  Tr.SetTransformation(AX);
+  gp_Trsf Tr2 = Tr.Inverted();
+  
+  math_Matrix Dt(1, 5, 1, 5);
+  math_Vector F(1, 5), Sl(1, 5);
+
+  Standard_Real XN,YN,ZN = 0.;
+  gp_Pnt PT,PP;
+  for(i=1; i<=5; i++) {
+    PT = AP->Value(i).Transformed(Tr);
+    PT.Coord(XN,YN,ZN);
+    Dt(i, 1) = XN*XN;
+    Dt(i, 2) = XN*YN;
+    Dt(i, 3) = YN*YN;
+    Dt(i, 4) = XN;
+    Dt(i, 5) = YN;
+    F(i) = -1.;
+  }
+
+  math_Gauss aSolver(Dt);
+  if (!aSolver.IsDone())
+    return res;
+
+  aSolver.Solve(F, Sl);
+  
+  AF=Sl(1);
+  BF=Sl(2);
+  CF=Sl(3);
+  DF=Sl(4);
+  EF=Sl(5);
+
+  Q1=AF*CF+BF*EF*DF/4-CF*DF*DF/4-BF*BF/4-AF*EF*EF/4;
+  Q2=AF*CF-BF*BF/4;
+  Q3=AF+CF;
+
+  Standard_Real Rmax, Rmin;
+  gp_Pnt Center;
+  gp_Dir MainAxis;
+  Standard_Boolean IsParab = Standard_False, IsEllip = Standard_False;
+
+if (Q2 > 0 && Q1*Q3 < 0) {
+  // ellipse
+  IsEllip = Standard_True;
+  if (ConicDefinition(AF, BF, CF, DF, EF, 1., IsParab, IsEllip,
+    Center, MainAxis, Rmin, Rmax)) {
+    // create ellipse
+    if (Rmax - Rmin < Precision::Confusion())
+    {
+      return res; //really it is circle, which must be recognized in other method
+    }
+    aTrans *= -1;
+    Center.SetZ(ZN);
+    gp_Pnt NewCenter = Center.Transformed(Tr2);
+    gp_Pnt Ptmp(Center.X() + MainAxis.X() * 10,
+      Center.Y() + MainAxis.Y() * 10,
+      Center.Z() + MainAxis.Z() * 10);
+    gp_Pnt NewPtmp = Ptmp.Transformed(Tr2);
+    gp_Dir NewMainAxis(NewPtmp.X() - NewCenter.X(),
+      NewPtmp.Y() - NewCenter.Y(),
+      NewPtmp.Z() - NewCenter.Z());
+    gp_Ax2 ax2(NewCenter, ndir, NewMainAxis);
+
+    gp_Elips anEllipse(ax2, Rmax, Rmin);
+    anEllipse.Translate(aTrans);
+    Handle(Geom_Ellipse) gell = new Geom_Ellipse(anEllipse);
+
+    // test for 20 points
+    Standard_Real param2 = 0;
+    dc = (c2 - c1) / 20;
+    for (i = 1; i <= 20; i++) {
+      PP = c3d->Value(c1 + i*dc);
+      Standard_Real aPar = ElCLib::Parameter(anEllipse, PP);
+      Standard_Real dist = gell->Value(aPar).Distance(PP);
+      if (dist > tol) return res;  // not done
+      if (dist > param2)
+        param2 = dist;
+    }
+
+
+    Deviation = param2;
+
+    Standard_Real PI2 = 2 * M_PI;
+    cf = ElCLib::Parameter(anEllipse, c3d->Value(c1));
+    cf = ElCLib::InPeriod(cf, 0., PI2);
+
+    //first parameter should be closed to zero
+
+    if (Abs(cf) < Precision::PConfusion() || Abs(PI2 - cf) < Precision::PConfusion())
+      cf = 0.;
+
+    Standard_Real cm = ElCLib::Parameter(anEllipse, c3d->Value((c1 + c2) / 2.));
+    cm = ElCLib::InPeriod(cm, cf, cf + PI2);
+
+    cl = ElCLib::Parameter(anEllipse, c3d->Value(c2));
+    cl = ElCLib::InPeriod(cl, cm, cm + PI2);
+
+    res = gell;
+  }
+}
+/*
+if (Q2 < 0 && Q1 != 0) {
+  // hyberbola
+}
+
+if (Q2 == 0 && Q1 != 0) {
+  // parabola
+}
+*/
+return res;
+}
+
+
+//=======================================================================
+//function : ComputeCurve
+//purpose  : 
+//=======================================================================
+
+Handle(Geom_Curve) GeomConvert_CurveToAnaCurve::ComputeCurve(const Handle(Geom_Curve)& theC3d,
+  const Standard_Real tolerance,
+  const Standard_Real c1, const Standard_Real c2,
+  Standard_Real& cf, Standard_Real& cl,
+  Standard_Real& theGap,
+  const GeomConvert_ConvType theConvType, const GeomAbs_CurveType theTarget)
+{
+  cf = c1;  cl = c2;
+  Handle(Geom_Curve) c3d, newc3d[3];
+  Standard_Integer i, imin = -1;
+  c3d = theC3d;
+  if (c3d.IsNull()) return newc3d[imin];
+  gp_Pnt P1 = c3d->Value(c1);
+  gp_Pnt P2 = c3d->Value(c2);
+  gp_Pnt P3 = c3d->Value(c1 + (c2 - c1) / 2);
+  Standard_Real d[3] = { RealLast(), RealLast(), RealLast() };
+  Standard_Real fp[3], lp[3];
+
+  if (c3d->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
+    Handle(Geom_TrimmedCurve) aTc = Handle(Geom_TrimmedCurve)::DownCast(c3d);
+    c3d = aTc->BasisCurve();
+  }
+
+  if (theConvType == GeomConvert_Target)
+  {
+    theGap = RealLast();
+    if (theTarget == GeomAbs_Line)
+    {
+      newc3d[0] = ComputeLine(c3d, tolerance, c1, c2, fp[0], lp[0], theGap);
+      cf = fp[0];
+      cl = lp[0];
+      return  newc3d[0];
+    }
+    if (theTarget == GeomAbs_Circle)
+    {
+      newc3d[1] = ComputeCircle(c3d, tolerance, c1, c2, fp[1], lp[1], theGap);
+      cf = fp[1];
+      cl = lp[1];
+      return  newc3d[1];
+    }
+    if (theTarget == GeomAbs_Ellipse)
+    {
+      newc3d[2] = ComputeEllipse(c3d, tolerance, c1, c2, fp[2], lp[2], theGap);
+      cf = fp[2];
+      cl = lp[2];
+      return  newc3d[2];
+    }
+  }
+  //
+  if (theConvType == GeomConvert_Simplest)
+  {
+    theGap = RealLast();
+    newc3d[0] = ComputeLine(c3d, tolerance, c1, c2, fp[0], lp[0], theGap);
+    if (!newc3d[0].IsNull())
+    {
+      cf = fp[0];
+      cl = lp[0];
+      return  newc3d[0];
+    }
+    theGap = RealLast();
+    newc3d[1] = ComputeCircle(c3d, tolerance, c1, c2, fp[1], lp[1], theGap);
+    if (!newc3d[1].IsNull())
+    {
+      cf = fp[1];
+      cl = lp[1];
+      return  newc3d[1];
+    }
+    theGap = RealLast();
+    newc3d[2] = ComputeEllipse(c3d, tolerance, c1, c2, fp[2], lp[2], theGap);
+    if (!newc3d[2].IsNull())
+    {
+      cf = fp[2];
+      cl = lp[2];
+      return  newc3d[2];
+    }
+    // Conversion failed, returns null curve
+    return newc3d[0];
+  }
+
+  //  theConvType == GeomConvert_MinGap
+  // recognition in case of small curve
+  imin = -1;
+  if((P1.Distance(P2) < 2*tolerance) && (P1.Distance(P3) < 2*tolerance)) {
+    newc3d[1] = ComputeCircle(c3d, tolerance, c1, c2, fp[1], lp[1], d[1]);  
+    newc3d[0] = ComputeLine(c3d, tolerance, c1, c2, fp[0], lp[0], d[0]);
+    imin = 1;
+    if (newc3d[1].IsNull() || d[0] < d[1])
+    {
+      imin = 0;
+    }
+  }
+  else {
+    d[0] = RealLast();
+    newc3d[0] = ComputeLine (c3d,tolerance,c1,c2,fp[0],lp[0],d[0]);  
+    Standard_Real tol = Min(tolerance, d[0]);
+    if (!Precision::IsInfinite(c1) && !Precision::IsInfinite(c2))
+    {
+      d[1] = RealLast();
+      newc3d[1] = ComputeCircle(c3d, tol, c1, c2, fp[1], lp[1], d[1]);
+      tol = Min(tol, d[1]);
+      d[2] = RealLast();
+      newc3d[2] = ComputeEllipse(c3d, tol, c1, c2, fp[2], lp[2], d[2]);
+    }
+    Standard_Real dd = RealLast();
+    for (i = 0; i < 3; ++i)
+    {
+      if (newc3d[i].IsNull()) continue;
+      if (d[i] < dd)
+      {
+        dd = d[i];
+        imin = i;
+      }
+    }
+  }
+
+  if (imin >= 0)
+  {
+    cf = fp[imin];
+    cl = lp[imin];
+    theGap = d[imin];
+    return newc3d[imin];
+  }
+  else
+  {
+    cf = c1;
+    cl = c2;
+    theGap = -1.;
+    return newc3d[0]; // must be null curve; 
+  }
+}

src/GeomConvert/GeomConvert_CurveToAnaCurve.hxx

@@ -0,0 +1,133 @@
+// Created: 2001-05-21 
+// 
+// Copyright (c) 2001-2013 OPEN CASCADE SAS 
+// 
+// This file is part of commercial software by OPEN CASCADE SAS, 
+// furnished in accordance with the terms and conditions of the contract 
+// and with the inclusion of this copyright notice. 
+// This file or any part thereof may not be provided or otherwise 
+// made available to any third party. 
+// 
+// No ownership title to the software is transferred hereby. 
+// 
+// OPEN CASCADE SAS makes no representation or warranties with respect to the 
+// performance of this software, and specifically disclaims any responsibility 
+// for any damages, special or consequential, connected with its use. 
+
+#ifndef _GeomConvert_CurveToAnaCurve_HeaderFile
+#define _GeomConvert_CurveToAnaCurve_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <GeomConvert_ConvType.hxx>
+#include <GeomAbs_CurveType.hxx>
+
+class Geom_Curve;
+class Geom_Line;
+class gp_Lin;
+class gp_Pnt;
+class gp_Circ;
+
+
+
+class GeomConvert_CurveToAnaCurve 
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+ 
+  Standard_EXPORT GeomConvert_CurveToAnaCurve();
+  
+  Standard_EXPORT GeomConvert_CurveToAnaCurve(const Handle(Geom_Curve)& C);
+  
+  Standard_EXPORT void Init (const Handle(Geom_Curve)& C);
+  
+  //! Converts me to analytical if possible with given
+  //! tolerance. The new first and last parameters are
+  //! returned to newF, newL
+  Standard_EXPORT Standard_Boolean ConvertToAnalytical (const Standard_Real theTol, Handle(Geom_Curve)& theResultCurve, const Standard_Real F, const Standard_Real L, Standard_Real& newF, Standard_Real& newL);
+  
+  Standard_EXPORT static Handle(Geom_Curve) ComputeCurve (const Handle(Geom_Curve)& curve, const Standard_Real tolerance, 
+    const Standard_Real c1, const Standard_Real c2, Standard_Real& cf, Standard_Real& cl, 
+    Standard_Real& theGap, const GeomConvert_ConvType theCurvType = GeomConvert_MinGap, const GeomAbs_CurveType theTarget = GeomAbs_Line);
+  
+  //! Tries to convert the given curve to circle with given
+  //! tolerance. Returns NULL curve if conversion is
+  //! not possible.
+  Standard_EXPORT static Handle(Geom_Curve) ComputeCircle (const Handle(Geom_Curve)& curve, const Standard_Real tolerance, const Standard_Real c1, const Standard_Real c2, Standard_Real& cf, Standard_Real& cl, Standard_Real& Deviation);
+  
+  //! Tries to convert the given curve to ellipse with given
+  //! tolerance. Returns NULL curve if conversion is
+  //! not possible.
+  Standard_EXPORT static Handle(Geom_Curve) ComputeEllipse (const Handle(Geom_Curve)& curve, const Standard_Real tolerance, const Standard_Real c1, const Standard_Real c2, Standard_Real& cf, Standard_Real& cl, Standard_Real& Deviation);
+  
+  //! Tries to convert the given curve to line with given
+  //! tolerance. Returns NULL curve if conversion is
+  //! not possible.
+  Standard_EXPORT static Handle(Geom_Line) ComputeLine (const Handle(Geom_Curve)& curve, const Standard_Real tolerance, const Standard_Real c1, const Standard_Real c2, Standard_Real& cf, Standard_Real& cl, Standard_Real& Deviation);
+  
+  //! Returns true if the set of points is linear with given
+  //! tolerance
+  Standard_EXPORT static Standard_Boolean IsLinear (const TColgp_Array1OfPnt& aPoints, const Standard_Real tolerance, Standard_Real& Deviation);
+   
+  //! Creates line on two points.
+  //! Resulting parameters returned
+  Standard_EXPORT static gp_Lin GetLine(const gp_Pnt& P1, const gp_Pnt& P2, Standard_Real& cf, Standard_Real& cl);
+
+  //! Creates circle on points. Returns true if OK.
+  Standard_EXPORT static Standard_Boolean GetCircle(gp_Circ& Circ, const gp_Pnt& P0, const gp_Pnt& P1, const gp_Pnt& P2); 
+
+  //! Returns maximal deviation of converted surface from the original
+  //! one computed by last call to ConvertToAnalytical
+  Standard_Real Gap() const
+  {
+    return myGap;
+  }
+
+  //! Returns conversion type 
+  GeomConvert_ConvType GetConvType() const
+  {
+    return myConvType;
+  }
+
+  //! Sets type of convertion
+  void SetConvType(const GeomConvert_ConvType theConvType)
+  {
+    myConvType = theConvType;
+  }
+
+  //! Returns target curve type 
+  GeomAbs_CurveType GetTarget() const
+  {
+    return myTarget;
+  }
+
+  //! Sets target curve type
+  void SetTarget(const GeomAbs_CurveType theTarget)
+  {
+    myTarget = theTarget;
+  }
+
+
+protected:
+
+
+
+
+
+private:
+
+  Handle(Geom_Curve) myCurve;
+  Standard_Real myGap;
+  GeomConvert_ConvType myConvType;
+  GeomAbs_CurveType myTarget;
+
+};
+
+
+
+#endif // _GeomConvert_CurveToAnaCurve_HeaderFile

src/GeomConvert/GeomConvert_FuncConeLSDist.cxx

@@ -0,0 +1,68 @@
+// Copyright (c) 1995-1999 Matra Datavision
+// Copyright (c) 1999-2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+
+#include <GeomConvert_FuncConeLSDist.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Ax3.hxx>
+#include <math_Vector.hxx>
+#include <ElSLib.hxx>
+
+//=======================================================================
+//function : GeomConvert_FuncConeLSDist
+//purpose  : 
+//=======================================================================
+GeomConvert_FuncConeLSDist::GeomConvert_FuncConeLSDist(
+                                  const Handle(TColgp_HArray1OfXYZ)& thePoints,
+                                  const gp_Dir& theDir):
+  myPoints(thePoints), myDir(theDir)
+{
+}
+
+//=======================================================================
+//function : NbVariables
+//purpose  : 
+//=======================================================================
+Standard_Integer GeomConvert_FuncConeLSDist::NbVariables () const
+{
+  return 5;
+}
+
+//=======================================================================
+//function : Value
+//purpose  : 
+//=======================================================================
+Standard_Boolean GeomConvert_FuncConeLSDist::Value(const math_Vector& X, Standard_Real& F)
+{
+  gp_Pnt aLoc(X(1), X(2), X(3));
+  Standard_Real aSemiAngle = X(4), anR = X(5);
+  gp_Ax3 aPos(aLoc, myDir);
+
+  F = 0.;
+  Standard_Integer i;
+  for (i = myPoints->Lower(); i <= myPoints->Upper(); ++i)
+  {
+    Standard_Real u, v;
+    gp_Pnt aPi(myPoints->Value(i));
+    ElSLib::ConeParameters(aPos, anR, aSemiAngle, aPi, u, v);
+    gp_Pnt aPp;
+    ElSLib::ConeD0(u, v, aPos, anR, aSemiAngle, aPp);
+    F += aPi.SquareDistance(aPp);
+  }
+
+  return Standard_True;
+}
+
+

src/GeomConvert/GeomConvert_FuncConeLSDist.hxx

@@ -0,0 +1,66 @@
+// Copyright (c) 1991-1999 Matra Datavision
+// Copyright (c) 1999-2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _GeomConvert_FuncConeLSDist_HeaderFile
+#define _GeomConvert_FuncConeLSDist_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+
+#include <math_MultipleVarFunction.hxx>
+#include <TColgp_HArray1OfXYZ.hxx>
+#include <math_Vector.hxx>
+#include <gp_Dir.hxx>
+
+//! Function for search of Cone canonic parameters: coordinates of center local coordinate system, 
+//! direction of axis, radius and semi-angle from set of points
+//! by least square method.
+//! 
+//!
+class GeomConvert_FuncConeLSDist : public math_MultipleVarFunction
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  //! Constructor.
+  Standard_EXPORT GeomConvert_FuncConeLSDist() {};
+  
+  Standard_EXPORT GeomConvert_FuncConeLSDist(const Handle(TColgp_HArray1OfXYZ)& thePoints,
+                                                   const gp_Dir& theDir);
+
+  void SetPoints(const Handle(TColgp_HArray1OfXYZ)& thePoints)
+  {
+    myPoints = thePoints;
+  }
+
+  void SetDir(const gp_Dir& theDir)
+  {
+    myDir = theDir;
+  }
+
+  //! Number of variables.
+  Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
+
+  //! Value.
+  Standard_EXPORT Standard_Boolean Value(const math_Vector& X,Standard_Real& F) Standard_OVERRIDE;
+
+
+private:
+
+  Handle(TColgp_HArray1OfXYZ) myPoints;
+  gp_Dir myDir;
+  
+};
+#endif // _GeomConvert_FuncConeLSDist_HeaderFile

src/GeomConvert/GeomConvert_FuncCylinderLSDist.cxx

@@ -0,0 +1,140 @@
+// Copyright (c) 1995-1999 Matra Datavision
+// Copyright (c) 1999-2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+
+#include <GeomConvert_FuncCylinderLSDist.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <math_Vector.hxx>
+
+//=======================================================================
+//function : GeomConvert_FuncCylinderLSDist
+//purpose  : 
+//=======================================================================
+GeomConvert_FuncCylinderLSDist::GeomConvert_FuncCylinderLSDist(
+                                  const Handle(TColgp_HArray1OfXYZ)& thePoints,
+                                  const gp_Dir& theDir):
+  myPoints(thePoints), myDir(theDir)
+{
+}
+
+//=======================================================================
+//function : NbVariables
+//purpose  : 
+//=======================================================================
+Standard_Integer GeomConvert_FuncCylinderLSDist::NbVariables () const
+{
+  return 4;
+}
+
+//=======================================================================
+//function : Value
+//purpose  : 
+//=======================================================================
+Standard_Boolean GeomConvert_FuncCylinderLSDist::Value(const math_Vector& X,Standard_Real& F)
+{
+  gp_XYZ aLoc(X(1), X(2), X(3));
+  Standard_Real anR2 = X(4)*X(4);
+
+  F = 0.;
+  Standard_Integer i;
+  for (i = myPoints->Lower(); i <= myPoints->Upper(); ++i)
+  {
+    gp_Vec aV(myPoints->Value(i) - aLoc);
+    Standard_Real aD2 = aV.CrossSquareMagnitude(myDir);
+    Standard_Real d = aD2 - anR2;
+    F += d * d;
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Gradient
+//purpose  : 
+//=======================================================================
+Standard_Boolean GeomConvert_FuncCylinderLSDist::Gradient(const math_Vector& X,math_Vector& G)
+
+{
+  gp_XYZ aLoc(X(1), X(2), X(3));
+  Standard_Real anR = X(4), anR2 = anR * anR;
+  Standard_Real x = myDir.X(), y = myDir.Y(), z = myDir.Z();
+  G.Init(0.);
+
+  Standard_Integer i;
+  for (i = myPoints->Lower(); i <= myPoints->Upper(); ++i)
+  {
+    gp_Vec aV(myPoints->Value(i) - aLoc);
+    Standard_Real aD2 = aV.CrossSquareMagnitude(myDir);
+    Standard_Real d = aD2 - anR2;
+    Standard_Real Dx0 =  2.*(aV.Z()*x - aV.X()*z)*z
+                        -2.*(aV.X()*y - aV.Y()*x)*y;
+    Standard_Real Dy0 = -2.*(aV.Y()*z - aV.Z()*y)*z
+                        +2.*(aV.X()*y - aV.Y()*x)*x;
+    Standard_Real Dz0 =  2.*(aV.Y()*z - aV.Z()*y)*y
+                        -2.*(aV.Z()*x - aV.X()*z)*x;
+
+    G(1) += d * Dx0;
+    G(2) += d * Dy0;
+    G(3) += d * Dz0;
+    //
+    G(4) += d;
+  }
+
+  G *= 2;
+  G(6) *= -2.*anR;
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Values
+//purpose  : 
+//=======================================================================
+Standard_Boolean GeomConvert_FuncCylinderLSDist::Values(const math_Vector& X,Standard_Real& F,math_Vector& G)
+{
+  gp_XYZ aLoc(X(1), X(2), X(3));
+  Standard_Real anR = X(4), anR2 = anR * anR;
+  Standard_Real x = myDir.X(), y = myDir.Y(), z = myDir.Z();
+
+  F = 0.;
+  G.Init(0.);
+  Standard_Integer i;
+  for (i = myPoints->Lower(); i <= myPoints->Upper(); ++i)
+  {
+    gp_Vec aV(myPoints->Value(i) - aLoc);
+    Standard_Real aD2 = aV.CrossSquareMagnitude(myDir);
+    Standard_Real d = aD2 - anR2;
+    Standard_Real Dx0 = 2.*(aV.Z()*x - aV.X()*z)*z
+      - 2.*(aV.X()*y - aV.Y()*x)*y;
+    Standard_Real Dy0 = -2.*(aV.Y()*z - aV.Z()*y)*z
+      + 2.*(aV.X()*y - aV.Y()*x)*x;
+    Standard_Real Dz0 = 2.*(aV.Y()*z - aV.Z()*y)*y
+      - 2.*(aV.Z()*x - aV.X()*z)*x;
+
+    G(1) += d * Dx0;
+    G(2) += d * Dy0;
+    G(3) += d * Dz0;
+    //
+    G(4) += d;
+    //
+    F += d * d;
+  }
+
+  G *= 2;
+  G(4) *= -2.*anR;
+
+  return true;
+}
+

src/GeomConvert/GeomConvert_FuncCylinderLSDist.hxx

@@ -0,0 +1,100 @@
+// Copyright (c) 1991-1999 Matra Datavision
+// Copyright (c) 1999-2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _GeomConvert_FuncCylinderLSDist_HeaderFile
+#define _GeomConvert_FuncCylinderLSDist_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+
+#include <math_MultipleVarFunctionWithGradient.hxx>
+#include <TColgp_HArray1OfXYZ.hxx>
+#include <math_Vector.hxx>
+#include <gp_Dir.hxx>
+
+//! Function for search of cylinder canonic parameters: coordinates of center local coordinate system, 
+//! direction of axis and radius from set of points
+//! by least square method.
+//! 
+//! The class inherits math_MultipleVarFunctionWithGradient and thus is intended
+//! for use in math_BFGS algorithm.
+//!
+//! Parametrisation:
+//! Cylinder is defined by its axis and radius. Axis is defined by 3 cartesian coordinats it location x0, y0, z0 
+//! and direction, which is constant and set by user: 
+//! dir.x, dir.y, dir.z
+//! The criteria is:
+//! F(x0, y0, z0, theta, phi, R) = Sum[|(P(i) - Loc)^dir|^2 - R^2]^2 => min
+//! P(i) is i-th sample point, Loc, dir - axis location and direction, R - radius
+//!
+//! The square vector product |(P(i) - Loc)^dir|^2 is:
+//!
+//! [(y - y0)*dir.z - (z - z0)*dir.y]^2 +
+//! [(z - z0)*dir.x - (x - x0)*dir.z]^2 +
+//! [(x - x0)*dir.y - (y - y0)*dir.x]^2
+//!
+//! First derivative of square vector product are:
+//! Dx0 =  2*[(z - z0)*dir.x - (x - x0)*dir.z]*dir.z 
+//!       -2*[(x - x0)*dir.y - (y - y0)*dir.x]*dir.y
+//! Dy0 = -2*[(y - y0)*dir.z - (z - z0)*dir.y]*dir.z
+//!       +2*[(x - x0)*dir.y - (y - y0)*dir.x]*dir.x
+//! Dz0 =  2*[(y - y0)*dir.z - (z - z0)*dir.y]*dir.y
+//!       -2*[(z - z0)*dir.x - (x - x0)*dir.z]*dir.x
+//!
+//! dF/dx0 : G1(...) = 2*Sum{[...]*Dx0}
+//! dF/dy0 : G2(...) = 2*Sum{[...]*Dy0}
+//! dF/dz0 : G3(...) = 2*Sum{[...]*Dz0}
+//! dF/dR : G4(...) = -4*R*Sum[...]
+//! [...] = [|(P(i) - Loc)^dir|^2 - R^2]
+class GeomConvert_FuncCylinderLSDist : public math_MultipleVarFunctionWithGradient
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  //! Constructor.
+  Standard_EXPORT GeomConvert_FuncCylinderLSDist() {};
+  
+  Standard_EXPORT GeomConvert_FuncCylinderLSDist(const Handle(TColgp_HArray1OfXYZ)& thePoints,
+                                                   const gp_Dir& theDir);
+
+  void SetPoints(const Handle(TColgp_HArray1OfXYZ)& thePoints)
+  {
+    myPoints = thePoints;
+  }
+
+  void SetDir(const gp_Dir& theDir)
+  {
+    myDir = theDir;
+  }
+
+  //! Number of variables.
+  Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
+
+  //! Value.
+  Standard_EXPORT Standard_Boolean Value(const math_Vector& X,Standard_Real& F) Standard_OVERRIDE;
+
+  //! Gradient.
+  Standard_EXPORT Standard_Boolean Gradient(const math_Vector& X,math_Vector& G) Standard_OVERRIDE;
+
+  //! Value and gradient.
+  Standard_EXPORT Standard_Boolean Values(const math_Vector& X,Standard_Real& F,math_Vector& G) Standard_OVERRIDE;
+
+private:
+
+  Handle(TColgp_HArray1OfXYZ) myPoints;
+  gp_Dir myDir;
+  
+};
+#endif // _GeomConvert_FuncCylinderLSDist_HeaderFile

src/GeomConvert/GeomConvert_FuncSphereLSDist.cxx

@@ -0,0 +1,115 @@
+// Created on: 2016-05-10
+// Created by: Alexander MALYSHEV
+// Copyright (c) 1995-1999 Matra Datavision
+// Copyright (c) 1999-2016 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+
+#include <GeomConvert_FuncSphereLSDist.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <math_Vector.hxx>
+
+//=======================================================================
+//function : GeomConvert_FuncSphereLSDist
+//purpose  : 
+//=======================================================================
+GeomConvert_FuncSphereLSDist::GeomConvert_FuncSphereLSDist(const Handle(TColgp_HArray1OfXYZ)& thePoints):
+  myPoints(thePoints)
+{
+}
+
+//=======================================================================
+//function : NbVariables
+//purpose  : 
+//=======================================================================
+Standard_Integer GeomConvert_FuncSphereLSDist::NbVariables () const
+{
+  return 4;
+}
+
+//=======================================================================
+//function : Value
+//purpose  : 
+//=======================================================================
+Standard_Boolean GeomConvert_FuncSphereLSDist::Value(const math_Vector& X,Standard_Real& F)
+{
+  gp_XYZ aLoc(X(1), X(2), X(3));
+  Standard_Real anR2 = X(4)*X(4);
+
+  F = 0.;
+  Standard_Integer i;
+  for (i = myPoints->Lower(); i <= myPoints->Upper(); ++i)
+  {
+    Standard_Real d = (myPoints->Value(i) - aLoc).SquareModulus() - anR2;
+    F += d * d;
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Gradient
+//purpose  : 
+//=======================================================================
+Standard_Boolean GeomConvert_FuncSphereLSDist::Gradient(const math_Vector& X,math_Vector& G)
+
+{
+  gp_XYZ aLoc(X(1), X(2), X(3));
+  Standard_Real anR = X(4), anR2 = anR * anR;
+
+  G.Init(0.);
+  Standard_Integer i;
+  for (i = myPoints->Lower(); i <= myPoints->Upper(); ++i)
+  {
+    gp_XYZ dLoc = myPoints->Value(i) - aLoc;
+    Standard_Real d = dLoc.SquareModulus() - anR2;
+    G(1) += d * dLoc.X();
+    G(2) += d * dLoc.Y();
+    G(3) += d * dLoc.Z();
+    G(4) += d;
+  }
+  G *= -4;
+  G(4) *= anR;
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Values
+//purpose  : 
+//=======================================================================
+Standard_Boolean GeomConvert_FuncSphereLSDist::Values(const math_Vector& X,Standard_Real& F,math_Vector& G)
+{
+  gp_XYZ aLoc(X(1), X(2), X(3));
+  Standard_Real anR = X(4), anR2 = anR * anR;
+
+  G.Init(0.);
+  F = 0.;
+  Standard_Integer i;
+  for (i = myPoints->Lower(); i <= myPoints->Upper(); ++i)
+  {
+    gp_XYZ dLoc = myPoints->Value(i) - aLoc;
+    Standard_Real d = dLoc.SquareModulus() - anR2;
+    G(1) += d * dLoc.X();
+    G(2) += d * dLoc.Y();
+    G(3) += d * dLoc.Z();
+    G(4) += d;
+    F += d * d;
+  }
+  G *= -4;
+  G(4) *= anR;
+
+  return true;
+}
+

src/GeomConvert/GeomConvert_FuncSphereLSDist.hxx

@@ -0,0 +1,77 @@
+
+// Copyright (c) 1991-1999 Matra Datavision
+// Copyright (c) 1999-2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _GeomConvert_FuncSphereLSDist_HeaderFile
+#define _GeomConvert_FuncSphereLSDist_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+
+#include <math_MultipleVarFunctionWithGradient.hxx>
+#include <TColgp_HArray1OfXYZ.hxx>
+#include <math_Vector.hxx>
+
+//! Function for search of sphere canonic parameters: coordinates of center and radius from set of moints
+//! by least square method.
+//! //!
+//! The class inherits math_MultipleVarFunctionWithGradient and thus is intended
+//! for use in math_BFGS algorithm.
+//!
+//! The criteria is:
+//! F(x0, y0, z0, R) = Sum[(x(i) - x0)^2 + (y(i) - y0)^2 + (z(i) - z0)^2 - R^2]^2 => min,
+//! x(i), y(i), z(i) - coordinates of sample points, x0, y0, z0, R - coordinates of center and radius of sphere,
+//! which must be defined
+//!
+//! The first derivative are:
+//! dF/dx0 : G1(x0, y0, z0, R) = -4*Sum{[...]*(x(i) - x0)} 
+//! dF/dy0 : G2(x0, y0, z0, R) = -4*Sum{[...]*(y(i) - y0)}
+//! dF/dz0 : G3(x0, y0, z0, R) = -4*Sum{[...]*(z(i) - z0)}
+//! dF/dR : G4(x0, y0, z0, R) = -4*R*Sum[...]
+//! [...] = [(x(i) - x0)^2 + (y(i) - y0)^2 + (z(i) - z0)^2 - R^2]
+//!
+class GeomConvert_FuncSphereLSDist : public math_MultipleVarFunctionWithGradient
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  //! Constructor.
+  Standard_EXPORT GeomConvert_FuncSphereLSDist() {};
+  
+  Standard_EXPORT GeomConvert_FuncSphereLSDist(const Handle(TColgp_HArray1OfXYZ)& thePoints);
+
+  void SetPoints(const Handle(TColgp_HArray1OfXYZ)& thePoints)
+  {
+    myPoints = thePoints;
+  }
+
+  //! Number of variables.
+  Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
+
+  //! Value.
+  Standard_EXPORT Standard_Boolean Value(const math_Vector& X,Standard_Real& F) Standard_OVERRIDE;
+
+  //! Gradient.
+  Standard_EXPORT Standard_Boolean Gradient(const math_Vector& X,math_Vector& G) Standard_OVERRIDE;
+
+  //! Value and gradient.
+  Standard_EXPORT Standard_Boolean Values(const math_Vector& X,Standard_Real& F,math_Vector& G) Standard_OVERRIDE;
+
+private:
+
+  Handle(TColgp_HArray1OfXYZ) myPoints;
+  
+};
+#endif // _GeomConvert_FuncSphereLSDist_HeaderFile

src/GeomConvert/GeomConvert_SurfToAnaSurf.hxx

@@ -0,0 +1,135 @@
+// Created: 1998-06-03 
+// 
+// Copyright (c) 1999-2013 OPEN CASCADE SAS 
+// 
+// This file is part of commercial software by OPEN CASCADE SAS, 
+// furnished in accordance with the terms and conditions of the contract 
+// and with the inclusion of this copyright notice. 
+// This file or any part thereof may not be provided or otherwise 
+// made available to any third party. 
+// 
+// No ownership title to the software is transferred hereby. 
+// 
+// OPEN CASCADE SAS makes no representation or warranties with respect to the 
+// performance of this software, and specifically disclaims any responsibility 
+// for any damages, special or consequential, connected with its use. 
+
+#ifndef _GeomConvert_SurfToAnaSurf_HeaderFile
+#define _GeomConvert_SurfToAnaSurf_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Real.hxx>
+#include <Standard_Boolean.hxx>
+#include <GeomConvert_ConvType.hxx>
+#include <GeomAbs_SurfaceType.hxx>
+#include <TColgp_HArray1OfXYZ.hxx>
+class Geom_Surface;
+class Geom_SurfaceOfRevolution;
+class Geom_Circle;
+
+//! Converts a surface to the analitical form with given
+//! precision. Conversion is done only the surface is bspline
+//! of bezier and this can be approximed by some analytical
+//! surface with that precision.
+class GeomConvert_SurfToAnaSurf 
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  Standard_EXPORT GeomConvert_SurfToAnaSurf();
+  
+  Standard_EXPORT GeomConvert_SurfToAnaSurf(const Handle(Geom_Surface)& S);
+  
+  Standard_EXPORT void Init (const Handle(Geom_Surface)& S);
+
+  void SetConvType(const GeomConvert_ConvType theConvType = GeomConvert_Simplest)
+  {
+    myConvType = theConvType;
+  }
+  void SetTarget(const GeomAbs_SurfaceType theSurfType = GeomAbs_Plane)
+  {
+    myTarget = theSurfType;
+  }
+
+  //! Returns maximal deviation of converted surface from the original
+  //! one computed by last call to ConvertToAnalytical
+  Standard_Real Gap() const
+  {
+    return myGap;
+  }
+  
+  //! Tries to convert the Surface to an Analytic form
+  //! Returns the result
+  //! In case of failure, returns a Null Handle
+  //!
+  Standard_EXPORT Handle(Geom_Surface) ConvertToAnalytical (const Standard_Real InitialToler);
+  Standard_EXPORT Handle(Geom_Surface) ConvertToAnalytical (const Standard_Real InitialToler,
+                                                            const Standard_Real Umin, const Standard_Real Umax,
+                                                            const Standard_Real Vmin, const Standard_Real Vmax);
+ 
+  //! Returns true if surfaces is same with the given tolerance
+  Standard_EXPORT static Standard_Boolean IsSame (const Handle(Geom_Surface)& S1, const Handle(Geom_Surface)& S2, const Standard_Real tol);
+  
+  //! Returns true, if surface is canonical
+  Standard_EXPORT static Standard_Boolean IsCanonical (const Handle(Geom_Surface)& S);
+
+private:
+  //!static method for checking surface of revolution
+  //!To avoid two-parts cone-like surface
+  static void CheckVTrimForRevSurf(const Handle(Geom_SurfaceOfRevolution)& aRevSurf,
+    Standard_Real& V1, Standard_Real& V2);
+
+  //!static method to try create cylindrical or conical surface
+  static Handle(Geom_Surface) TryCylinerCone(const Handle(Geom_Surface)& theSurf, const Standard_Boolean theVCase,
+    const Handle(Geom_Curve)& theUmidiso, const Handle(Geom_Curve)& theVmidiso,
+    const Standard_Real theU1, const Standard_Real theU2, const Standard_Real theV1, const Standard_Real theV2,
+    const Standard_Real theToler);
+
+  //!static method to try create cylinrical surface using least square method
+  static Standard_Boolean GetCylByLS(const Handle(TColgp_HArray1OfXYZ)& thePoints,
+    const Standard_Real theTol,
+    gp_Ax3& thePos, Standard_Real& theR,
+    Standard_Real& theGap);
+
+  //!static method to try create cylinrical surface based on its Gauss field
+  static Handle(Geom_Surface) TryCylinderByGaussField(const Handle(Geom_Surface)& theSurf,
+    const Standard_Real theU1, const Standard_Real theU2, const Standard_Real theV1, const Standard_Real theV2,
+    const Standard_Real theToler, const Standard_Integer theNbU = 20, const Standard_Integer theNbV = 20,
+    const Standard_Boolean theLeastSquare = Standard_False);
+
+  //! static method to try create toroidal surface.
+  //! In case <isTryUMajor> = Standard_True try to use V isoline radius as minor radaius.
+  static Handle(Geom_Surface) TryTorusSphere(const Handle(Geom_Surface)& theSurf,
+    const Handle(Geom_Circle)& circle,
+    const Handle(Geom_Circle)& otherCircle,
+    const Standard_Real Param1,
+    const Standard_Real Param2,
+    const Standard_Real aParam1ToCrv,
+    const Standard_Real aParam2ToCrv,
+    const Standard_Real toler,
+    const Standard_Boolean isTryUMajor);
+
+  static Standard_Real ComputeGap(const Handle(Geom_Surface)& theSurf,
+    const Standard_Real theU1, const Standard_Real theU2, const Standard_Real theV1, const Standard_Real theV2,
+    const Handle(Geom_Surface) theNewSurf, const Standard_Real theTol = RealLast());
+
+
+
+
+protected:
+
+private:
+
+  Handle(Geom_Surface) mySurf;
+  Standard_Real myGap;
+  GeomConvert_ConvType myConvType;
+  GeomAbs_SurfaceType myTarget;
+
+};
+
+
+#endif // _GeomConvert_SurfToAnaSurf_HeaderFile

src/GeomFill/GeomFill_CorrectedFrenet.cxx

@@ -882,7 +882,7 @@ Standard_Real GeomFill_CorrectedFrenet::GetAngleAT(const Standard_Real Param) co
 
   frenet->Intervals(FrenetInt, S);
   EvolAroundT->Intervals(LawInt, S);
-  GeomLib::FuseIntervals(FrenetInt, LawInt, Fusion);
+  GeomLib::FuseIntervals(FrenetInt, LawInt, Fusion, Precision::PConfusion(), Standard_True);
 
   return Fusion.Length()-1;
 }
@@ -913,7 +913,7 @@ Standard_Real GeomFill_CorrectedFrenet::GetAngleAT(const Standard_Real Param) co
   
   frenet->Intervals(FrenetInt, S);
   EvolAroundT->Intervals(LawInt, S);
-  GeomLib::FuseIntervals(FrenetInt, LawInt, Fusion);
+  GeomLib::FuseIntervals(FrenetInt, LawInt, Fusion, Precision::PConfusion(), Standard_True);
 
   for(Standard_Integer i = 1; i <= Fusion.Length(); i++)
     T.ChangeValue(i) = Fusion.Value(i);

src/GeomFill/GeomFill_Frenet.cxx

@@ -692,7 +692,7 @@ Standard_Boolean
   myCurve->Intervals(TrimInt, tmpS);
 
   TColStd_SequenceOfReal Fusion;
-  GeomLib::FuseIntervals(TrimInt, mySngl->Array1(), Fusion);
+  GeomLib::FuseIntervals(TrimInt, mySngl->Array1(), Fusion, Precision::PConfusion(), Standard_True);
 
   return Fusion.Length() - 1;
 }
@@ -726,7 +726,7 @@ Standard_Boolean
   myCurve->Intervals(TrimInt, tmpS);
 
   TColStd_SequenceOfReal Fusion;
-  GeomLib::FuseIntervals(TrimInt, mySngl->Array1(), Fusion);
+  GeomLib::FuseIntervals(TrimInt, mySngl->Array1(), Fusion, Precision::PConfusion(), Standard_True);
 
   for (Standard_Integer i = 1; i <= Fusion.Length(); i++)
     T.ChangeValue(i) = Fusion.Value(i);

src/GeomLib/GeomLib.cxx

@@ -415,7 +415,8 @@ void GeomLib::DensifyArray1OfReal(const Standard_Integer MinNumPoints,
 void GeomLib::FuseIntervals(const  TColStd_Array1OfReal& I1,
 			    const  TColStd_Array1OfReal& I2,
 			    TColStd_SequenceOfReal&  Seq,
-			    const Standard_Real  Epspar) 
+			    const Standard_Real  Epspar,
+                            const Standard_Boolean IsAdjustToFirstInterval)
 {
  Standard_Integer ind1=1, ind2=1;
  Standard_Real    v1, v2;
@@ -432,7 +433,14 @@ void GeomLib::FuseIntervals(const  TColStd_Array1OfReal& I1,
       v2 = I2(ind2);
       if (Abs(v1-v2)<= Epspar) {
 // Ici les elements de I1 et I2 conviennent .
-         Seq.Append((v1+v2)/2);
+        if (IsAdjustToFirstInterval)
+        {
+          Seq.Append(v1);
+        }
+        else
+        {
+          Seq.Append((v1 + v2) / 2);
+        }
 	 ind1++;
          ind2++;
        }

src/GeomLib/GeomLib.hxx

@@ -170,7 +170,19 @@ public:
   //! non decreasing
   Standard_EXPORT static void DensifyArray1OfReal (const Standard_Integer MinNumPoints, const TColStd_Array1OfReal& InParameters, Handle(TColStd_HArray1OfReal)& OutParameters);
   
-  Standard_EXPORT static void FuseIntervals (const TColStd_Array1OfReal& Interval1, const TColStd_Array1OfReal& Interval2, TColStd_SequenceOfReal& Fusion, const Standard_Real Confusion = 1.0e-9);
+  //! This method fuse intervals Interval1 and Interval2 with specified Confusion
+  //! @param Interval1 [in] first interval to fuse 
+  //! @param Interval2 [in] second interval to fuse
+  //! @param Confision [in] tolerance to compare intervals
+  //! @param IsAdjustToFirstInterval [in] flag to set method of fusion, if intervals are close
+  //!                               if false, intervals are fusing by half-division methdod
+  //!                               if true, intervals are fusing by selecting value from Interval1
+  //! @param Fusion [out] output interval 
+  Standard_EXPORT static void FuseIntervals (const TColStd_Array1OfReal& Interval1, 
+                                             const TColStd_Array1OfReal& Interval2, 
+                                             TColStd_SequenceOfReal& Fusion,
+                                             const Standard_Real Confusion = 1.0e-9, 
+                                             const Standard_Boolean IsAdjustToFirstInterval = Standard_False);
   
   //! this  will compute   the   maximum distance  at  the
   //! parameters  given    in   the Parameters  array    by

src/GeomLib/GeomLib_IsPlanarSurface.cxx

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

src/GeomliteTest/GeomliteTest_SurfaceCommands.cxx

@@ -72,7 +72,9 @@
 #include <Geom2dConvert.hxx>
 #include <Geom2dConvert_BSplineCurveToBezierCurve.hxx>
 #include <GeomLProp_SLProps.hxx>
-
+#include <GeomConvert_SurfToAnaSurf.hxx>
+#include <GeomConvert_CurveToAnaCurve.hxx>
+#include <GeomConvert_ConvType.hxx>
 
 #include <DrawTrSurf_BezierSurface.hxx>
 #include <DrawTrSurf_BSplineSurface.hxx>
@@ -517,6 +519,111 @@ static Standard_Integer converting(Draw_Interpretor& , Standard_Integer n, const
   return 0;
 }
 
+//=======================================================================
+//function : converting to canonical
+//purpose  : 
+//=======================================================================
+
+static Standard_Integer tocanon(Draw_Interpretor& di, Standard_Integer n, const char ** a)
+{
+  if (n < 3) return 1;
+
+  GeomConvert_ConvType aConvType = GeomConvert_Simplest;
+  GeomAbs_CurveType aCurv = GeomAbs_Line;
+  GeomAbs_SurfaceType aSurf = GeomAbs_Plane;
+  if (n > 4)
+  {
+    if (strcmp(a[4], "sim") == 0) {
+      aConvType = GeomConvert_Simplest;
+    }
+    else if (strcmp(a[4], "gap") == 0) {
+      aConvType = GeomConvert_MinGap;
+    }
+    else if (strcmp(a[4], "lin") == 0) {
+      aConvType = GeomConvert_Target;
+      aCurv = GeomAbs_Line;
+    }
+    else if (strcmp(a[4], "cir") == 0) {
+      aConvType = GeomConvert_Target;
+      aCurv = GeomAbs_Circle;
+    }
+    else if (strcmp(a[4], "ell") == 0) {
+      aConvType = GeomConvert_Target;
+      aCurv = GeomAbs_Ellipse;
+    }
+    else if (strcmp(a[4], "pln") == 0) {
+      aConvType = GeomConvert_Target;
+      aSurf = GeomAbs_Plane;
+    }
+    else if (strcmp(a[4], "cyl") == 0) {
+      aConvType = GeomConvert_Target;
+      aSurf = GeomAbs_Cylinder;
+    }
+    else if (strcmp(a[4], "con") == 0) {
+      aConvType = GeomConvert_Target;
+      aSurf = GeomAbs_Cone;
+    }
+    else if (strcmp(a[4], "sph") == 0) {
+      aConvType = GeomConvert_Target;
+      aSurf = GeomAbs_Sphere;
+    }
+    else if (strcmp(a[4], "tor") == 0) {
+      aConvType = GeomConvert_Target;
+      aSurf = GeomAbs_Torus;
+    }
+  }
+
+  Standard_Real tol = Precision::Confusion();
+  if (n > 3)
+  {
+    tol = Draw::Atof(a[3]);
+  }
+
+  Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[2]);
+  if (GC.IsNull()) {
+    Handle(Geom_Surface) GS = DrawTrSurf::GetSurface(a[2]);
+    if (GS.IsNull()) {
+      return 1;
+    }
+    else {
+      GeomConvert_SurfToAnaSurf aSurfToAna(GS);
+      aSurfToAna.SetConvType(aConvType);
+      if(aConvType == GeomConvert_Target)
+        aSurfToAna.SetTarget(aSurf);
+      Handle(Geom_Surface) anAnaSurf = aSurfToAna.ConvertToAnalytical(tol);
+      if (!anAnaSurf.IsNull())
+      {
+        DrawTrSurf::Set(a[1], anAnaSurf);
+        Standard_Real aGap = aSurfToAna.Gap();
+        di << "Gap = " << aGap << "\n";
+      }
+      else
+        di << "Conversion failed" << "\n";
+    }
+  }
+  else {
+    GeomConvert_CurveToAnaCurve aCurvToAna(GC);
+    aCurvToAna.SetConvType(aConvType);
+    if (aConvType == GeomConvert_Target)
+      aCurvToAna.SetTarget(aCurv);
+
+    Handle(Geom_Curve) anAnaCurv;
+    Standard_Real tf = GC->FirstParameter(), tl = GC->LastParameter(), ntf, ntl;
+    Standard_Boolean isdone = aCurvToAna.ConvertToAnalytical(tol, anAnaCurv, tf, tl, ntf, ntl);
+    if (isdone)
+    {
+      anAnaCurv = new Geom_TrimmedCurve(anAnaCurv, ntf, ntl);
+      DrawTrSurf::Set(a[1], anAnaCurv);
+      Standard_Real aGap = aCurvToAna.Gap();
+      di << "Gap = " << aGap << "\n";
+    }
+    else
+      di << "Conversion failed" << "\n";
+  }
+
+  return 0;
+}
+
 
 //=======================================================================
 //function : tobezier
@@ -1661,6 +1768,11 @@ void  GeomliteTest::SurfaceCommands(Draw_Interpretor& theCommands)
 		  __FILE__,
 		  converting,g);
 
+  theCommands.Add("tocanon",
+    "tocanon result c3d/surf [tol [sim gap lin cir ell pln cyl con sph tor]]",
+    __FILE__,
+    tocanon, g);
+
   theCommands.Add("tobezier",
 		  "tobezier result c2d/c3d/surf [ufirst, ulast / ufirst, ulast, vfirst, vlast]",
 		  __FILE__,

src/IntPatch/IntPatch_ALineToWLine.cxx

@@ -29,7 +29,7 @@
 //function : AddPointIntoLine
 //purpose  : 
 //=======================================================================
-static inline void AddPointIntoLine(Handle(IntSurf_LineOn2S) theLine,
+static inline void AddPointIntoLine(Handle(IntSurf_LineOn2S)& theLine,
                                     const Standard_Real* const theArrPeriods,
                                     IntSurf_PntOn2S &thePoint,
                                     IntPatch_Point* theVertex = 0)
@@ -252,6 +252,69 @@ void IntPatch_ALineToWLine::SetTolOpenDomain(const Standard_Real aTol)
   return myTolOpenDomain;
 }
 
+//=======================================================================
+//function : CorrectEndPoint
+//purpose  : 
+//=======================================================================
+void IntPatch_ALineToWLine::CorrectEndPoint(Handle(IntSurf_LineOn2S)& theLine,
+                                            const Standard_Integer    theIndex) const
+{
+  const Standard_Real aTol = 1.e-5;
+  const Standard_Real aSqTol = 1.e-10;
+
+  //Perform linear extrapolation from two previous points
+  Standard_Integer anIndFirst, anIndSecond;
+  if (theIndex == 1)
+  {
+    anIndFirst  = 3;
+    anIndSecond = 2;
+  }
+  else
+  {
+    anIndFirst  = theIndex - 2;
+    anIndSecond = theIndex - 1;
+  }
+  IntSurf_PntOn2S aPntOn2S = theLine->Value(theIndex);
+  
+  for (Standard_Integer ii = 1; ii <= 2; ii++)
+  {
+    Standard_Boolean anIsOnFirst = (ii == 1);
+    
+    const IntSurf_Quadric& aQuad = (ii == 1)? myQuad1 : myQuad2;
+    if (aQuad.TypeQuadric() == GeomAbs_Cone)
+    {
+      const gp_Cone aCone = aQuad.Cone();
+      const gp_Pnt anApex = aCone.Apex();
+      if (anApex.SquareDistance (aPntOn2S.Value()) > aSqTol)
+        continue;
+    }
+    else if (aQuad.TypeQuadric() == GeomAbs_Sphere)
+    {
+      Standard_Real aU, aV;
+      aPntOn2S.ParametersOnSurface(anIsOnFirst, aU, aV);
+      if (Abs(aV - M_PI/2) > aTol &&
+          Abs(aV + M_PI/2) > aTol)
+        continue;
+    }
+    else
+      continue;
+    
+    gp_Pnt2d PrevPrevP2d = theLine->Value(anIndFirst).ValueOnSurface(anIsOnFirst);
+    gp_Pnt2d PrevP2d     = theLine->Value (anIndSecond).ValueOnSurface(anIsOnFirst);
+    gp_Dir2d aDir = gp_Vec2d(PrevPrevP2d, PrevP2d);
+    Standard_Real aX0 = PrevPrevP2d.X(), aY0 = PrevPrevP2d.Y();
+    Standard_Real aXend, aYend;
+    aPntOn2S.ParametersOnSurface(anIsOnFirst, aXend, aYend);
+
+    if (Abs(aDir.Y()) < gp::Resolution())
+      continue;
+    
+    Standard_Real aNewXend = aDir.X()/aDir.Y() * (aYend - aY0) + aX0;
+
+    theLine->SetUV (theIndex, anIsOnFirst, aNewXend, aYend);
+  }
+}
+
 //=======================================================================
 //function : GetSectionRadius
 //purpose  : 
@@ -331,24 +394,27 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
 #if 0
   //To draw ALine as a wire DRAW-object use the following code.
   {
-    static int zzz = 0;
-    zzz++;
+    static int ind = 0;
+    ind++;
 
-    bool flShow = /*(zzz == 1)*/false;
+    bool flShow = true;
 
     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 Standard_Integer NbSamples = 20;
+      const Standard_Real aStep = (theLPar - theFPar) / NbSamples;
+      char* name = new char[100];
+      
+      for (Standard_Integer ii = 0; ii <= NbSamples; ii++)
       {
+        Standard_Real aPrm = theFPar + ii * aStep;
         const gp_Pnt aPP(theALine->Value(aPrm));
-        std::cout << "vertex v" << ++aI << " " << aPP.X() << " " << aPP.Y() << " " << aPP.Z() << std::endl;
-      }
+        std::cout << "vertex v" << ii << " " << 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;
+        sprintf(name, "p%d_%d", ii, ind);
+        Draw::Set(name, aPP);
+      }
       std::cout << " --- DUMP ALine (end) -----" << std::endl;
     }
   }
@@ -435,6 +501,8 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
 
     Standard_Integer aNewVertID = 0;
     aLinOn2S = new IntSurf_LineOn2S;
+    Standard_Boolean anIsFirstDegenerated = Standard_False,
+      anIsLastDegenerated = Standard_False;
     
     const Standard_Real aStepMin = 0.1*aStep, aStepMax = 10.0*aStep;
 
@@ -467,6 +535,9 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
         {
           // We cannot compute 2D-parameters of
           // aPOn2S correctly.
+          
+          if (anIsLastDegenerated) //the current last point is wrong
+            aLinOn2S->RemovePoint (aLinOn2S->NbPoints());
 
           isPointValid = Standard_False;
         }
@@ -591,6 +662,27 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
           AddPointIntoLine(aLinOn2S, anArrPeriods, aPOn2S);
           aPrevLPoint = aPOn2S;
         }
+        else
+        {
+          //add point, set correxponding status: to be corrected later
+          Standard_Boolean ToAdd = Standard_False;
+          if (aLinOn2S->NbPoints() == 0)
+          {
+            anIsFirstDegenerated = Standard_True;
+            ToAdd = Standard_True;
+          }
+          else if (aLinOn2S->NbPoints() > 1)
+          {
+            anIsLastDegenerated = Standard_True;
+            ToAdd = Standard_True;
+          }
+
+          if (ToAdd)
+          {
+            AddPointIntoLine(aLinOn2S, anArrPeriods, aPOn2S);
+            aPrevLPoint = aPOn2S;
+          }
+        }
 
         continue;
       }
@@ -630,6 +722,15 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
 
       aPrePointExist = IsPoleOrSeam(myS1, myS2, aPrefIso, aLinOn2S, aVtx,
                                 anArrPeriods, aTol, aSingularSurfaceID);
+      if (aPrePointExist == IntPatch_SPntPole ||
+          aPrePointExist == IntPatch_SPntPoleSeamU)
+      {
+        //set correxponding status: to be corrected later
+        if (aLinOn2S->NbPoints() == 1)
+          anIsFirstDegenerated = Standard_True;
+        else
+          anIsLastDegenerated  = Standard_True;
+      }
 
       const Standard_Real aCurVertParam = aVtx.ParameterOnLine();
       if(aPrePointExist != IntPatch_SPntNone)
@@ -676,7 +777,11 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
             IntPatch_Point aLVtx = theALine->Vertex(i);
             aLVtx.SetValue(aVertP2S);
             aLVtx.SetTolerance(aVertToler);
-            aLVtx.SetParameter(aNewVertexParam);
+            Standard_Real aParam = aLVtx.ParameterOnLine();
+            if (Abs(aParam - theLPar) <= Precision::PConfusion()) //in the case of closed curve,
+              aLVtx.SetParameter(-1); //we don't know yet the number of points in the curve
+            else
+              aLVtx.SetParameter(aNewVertexParam);
             aSeqVertex(++aNewVertID) = aLVtx;
             hasVertexBeenChecked(i) = Standard_True;
             isFound = Standard_True;
@@ -698,6 +803,15 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
       continue;
     }
 
+    //Correct first and last points if needed
+    if (aLinOn2S->NbPoints() >= 3)
+    {
+      if (anIsFirstDegenerated)
+        CorrectEndPoint (aLinOn2S, 1);
+      if (anIsLastDegenerated)
+        CorrectEndPoint (aLinOn2S, aLinOn2S->NbPoints());
+    }
+
     //-----------------------------------------------------------------
     //--              W  L  i  n  e     c  r  e  a  t  i  o  n      ---
     //-----------------------------------------------------------------
@@ -748,7 +862,9 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
 
     for(Standard_Integer i = aSeqVertex.Lower(); i <= aNewVertID; i++)
     {
-      const IntPatch_Point& aVtx = aSeqVertex(i);
+      IntPatch_Point aVtx = aSeqVertex(i);
+      if (aVtx.ParameterOnLine() == -1) //in the case of closed curve,
+        aVtx.SetParameter (aWLine->NbPnts()); //we set the last parameter
       aWLine->AddVertex(aVtx);
     }
 
@@ -756,7 +872,7 @@ void IntPatch_ALineToWLine::MakeWLine(const Handle(IntPatch_ALine)& theALine,
 
     //the method ComputeVertexParameters can reduce the number of points in <aWLine>
     aWLine->ComputeVertexParameters(myTol3D);
-
+    
     if (aWLine->NbPnts() > 1)
     {
       aWLine->EnablePurging(Standard_False);

src/IntPatch/IntPatch_ALineToWLine.hxx

@@ -19,6 +19,8 @@
 
 #include <IntPatch_SequenceOfLine.hxx>
 #include <IntSurf_Quadric.hxx>
+#include <IntSurf_LineOn2S.hxx>
+
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 #include <Standard_Macro.hxx>
@@ -93,6 +95,13 @@ protected:
   //! This check is made for cone and sphere only.
   Standard_EXPORT Standard_Real GetSectionRadius(const gp_Pnt& thePnt3d) const;
 
+  //! Corrects the U-parameter of an end point (first or last) of the line
+  //! if this end point is a pole.
+  //! The line must contain at least 3 points.
+  //! This is made for cone and sphere only.
+  Standard_EXPORT void CorrectEndPoint(Handle(IntSurf_LineOn2S)& theLine,
+                                       const Standard_Integer    theIndex) const;
+
 private:
 
 

src/IntPatch/IntPatch_WLine.cxx

@@ -471,8 +471,7 @@ void IntPatch_WLine::ComputeVertexParameters( const Standard_Real RTol)
   
   //----------------------------------------------------
   //-- On detecte les points confondus dans la LineOn2S
-  Standard_Real dmini = Precision::Confusion();
-  dmini*=dmini;
+  Standard_Real dmini = Precision::SquareConfusion();
   for(i=2; (i<=nbponline) && (nbponline > 2); i++) { 
     const IntSurf_PntOn2S& aPnt1=curv->Value(i-1);
     const IntSurf_PntOn2S& aPnt2=curv->Value(i);
@@ -516,7 +515,20 @@ void IntPatch_WLine::ComputeVertexParameters( const Standard_Real RTol)
 	
 	IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S();
 	RecadreMemePeriode(POn2S,curv->Value(1),U1Period(),V1Period(),U2Period(),V2Period());
-	curv->Value(1,POn2S);
+        if (myCreationWay == IntPatch_WLImpImp)
+        {
+          //Adjust first point of curve to corresponding vertex the following way:
+          //set 3D point as the point of the vertex and 2D points as the points of the point on curve.
+          curv->SetPoint (1, POn2S.Value());
+          Standard_Real mu1,mv1,mu2,mv2;
+          curv->Value(1).Parameters(mu1,mv1,mu2,mv2);
+          svtx.ChangeValue(i).SetParameter(1);
+          svtx.ChangeValue(i).SetParameters(mu1,mv1,mu2,mv2);
+        }
+        else
+        {
+          curv->Value(1,POn2S);
+        }
 
 	//--curv->Value(1,svtx.Value(i).PntOn2S());
 	svtx.ChangeValue(i).SetParameter(1.0);
@@ -551,6 +563,9 @@ void IntPatch_WLine::ComputeVertexParameters( const Standard_Real RTol)
       //---------------------------------------------------------
       Standard_Boolean Substitution = Standard_False;
       //-- for(k=indicevertexonline+1; !Substitution && k>=indicevertexonline-1;k--) {   avant le 9 oct 97 
+      Standard_Real mu1,mv1,mu2,mv2;
+      curv->Value(indicevertexonline).Parameters(mu1,mv1,mu2,mv2);
+      
       for(k=indicevertexonline+1; k>=indicevertexonline-1;k--) { 
 	if(k>0 && k<=nbponline) { 
 	  if(CompareVertexAndPoint(P,curv->Value(k).Value(),vTol)) {
@@ -560,9 +575,21 @@ void IntPatch_WLine::ComputeVertexParameters( const Standard_Real RTol)
 	    //-------------------------------------------------------
 	    IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S();
 	    RecadreMemePeriode(POn2S,curv->Value(k),U1Period(),V1Period(),U2Period(),V2Period());
-	    curv->Value(k,POn2S);
-	    Standard_Real mu1,mv1,mu2,mv2;
-	    POn2S.Parameters(mu1,mv1,mu2,mv2);
+
+            if (myCreationWay == IntPatch_WLImpImp)
+            {
+              //Adjust a point of curve to corresponding vertex the following way:
+              //set 3D point as the point of the vertex and 2D points as the points
+              //of the point on curve with index <indicevertexonline>
+              curv->SetPoint (k, POn2S.Value());
+              curv->SetUV (k, Standard_True,  mu1, mv1);
+              curv->SetUV (k, Standard_False, mu2, mv2);
+            }
+            else
+            {
+              curv->Value(k,POn2S);
+              POn2S.Parameters(mu1,mv1,mu2,mv2);
+            }
 	    svtx.ChangeValue(i).SetParameter(k);
 	    svtx.ChangeValue(i).SetParameters(mu1,mv1,mu2,mv2);
 	    Substitution = Standard_True;

src/IntSurf/IntSurf_LineOn2S.hxx

@@ -63,9 +63,14 @@ public:
   //! Replaces the point of range Index in the line.
     void Value (const Standard_Integer Index, const IntSurf_PntOn2S& P);
   
+  //! Sets the 3D point of the Index-th PntOn2S
+  Standard_EXPORT void SetPoint(const Standard_Integer Index, const gp_Pnt& thePnt);
+  
   //! Sets the parametric coordinates on one of the surfaces
   //! of the point of range Index in the line.
-  Standard_EXPORT void SetUV(const Standard_Integer Index, const Standard_Boolean OnFirst, const Standard_Real U, const Standard_Real V);
+  Standard_EXPORT void SetUV(const Standard_Integer Index,
+                             const Standard_Boolean OnFirst,
+                             const Standard_Real U, const Standard_Real V);
   
     void Clear();
   

src/IntSurf/IntSurf_LineOn2S.lxx

@@ -38,6 +38,12 @@ inline void IntSurf_LineOn2S::Value(const Standard_Integer Index,
   mySeq(Index) = P;
 }
 
+inline void IntSurf_LineOn2S::SetPoint(const Standard_Integer Index,
+                                       const gp_Pnt& thePnt)
+{
+  mySeq(Index).SetValue (thePnt);
+}
+
 inline void IntSurf_LineOn2S::Clear ()
 {
   mySeq.Clear();

src/IntWalk/IntWalk_IWalking_4.gxx

@@ -178,7 +178,8 @@ void IntWalk_IWalking::ComputeCloseLine(const TColStd_SequenceOfReal& Umult,
 #ifdef CHRONO
         Chronrsnld.Stop();
 #endif
-
+        Standard_Boolean isOnDegeneratedBorder = Standard_False;
+        
         if (Cadre) { // update of limits.
           BornInf(1) = Um;BornSup(1) = UM;BornInf(2) = Vm;BornSup(2) = VM;
         }
@@ -262,6 +263,7 @@ void IntWalk_IWalking::ComputeCloseLine(const TColStd_SequenceOfReal& Umult,
                                       /  (uv[aCoordIdx - 1] - uvprev[aCoordIdx - 1]) );
                     Standard_Integer aFixIdx =  aCoordIdx == 1? 2 : 1; // Fixing index;
                     Uvap(aFixIdx) = uv[aFixIdx - 1] + (uv[aFixIdx - 1] - uvprev[aFixIdx - 1]) * aScaleCoeff;
+                    isOnDegeneratedBorder = Standard_True;
                   }
                 }
               }
@@ -307,6 +309,8 @@ void IntWalk_IWalking::ComputeCloseLine(const TColStd_SequenceOfReal& Umult,
                 if (N <= 0) { // jag 941017
                   MakeWalkingPoint(2,Uvap(1),Uvap(2),Func,Psol);
                   Tgtend = Func.IsTangent(); // jag 940616
+                  if (isOnDegeneratedBorder)
+                    Tgtend = Standard_True;
                   N = -N;
                 }
                 Arrive = (wd2[I].etat == 12); // the line is open
@@ -315,6 +319,9 @@ void IntWalk_IWalking::ComputeCloseLine(const TColStd_SequenceOfReal& Umult,
             aStatus = TestDeflection(Func, Arrive,Uvap,StatusPrecedent,
                                                 NbDivision,PasC,StepSign);
 
+            if (isOnDegeneratedBorder && Tgtend)
+              aStatus = IntWalk_ArretSurPoint;
+            
             StatusPrecedent = aStatus;
             if (aStatus == IntWalk_PasTropGrand) {// division of the step
               Arrive = Standard_False;
@@ -379,12 +386,16 @@ void IntWalk_IWalking::ComputeCloseLine(const TColStd_SequenceOfReal& Umult,
                 StepSign = -1;
                 StatusPrecedent = IntWalk_OK;
                 PasC = PasSav;
-                if (aStatus == IntWalk_ArretSurPointPrecedent) {
-                  CurrentLine->AddPoint(Psol);
-                  OpenLine(0,Psol,Pnts1,Func,CurrentLine);
-                }
-                else {
-                  OpenLine(-lines.Length()-1,Psol,Pnts1,Func,CurrentLine);
+                //Check if <Psol> has been really updated
+                if (Arrive || Rajout || (!ArretAjout && Cadre && SaveN <= 0))
+                {
+                  if (aStatus == IntWalk_ArretSurPointPrecedent) {
+                    CurrentLine->AddPoint(Psol);
+                    OpenLine(0,Psol,Pnts1,Func,CurrentLine);
+                  }
+                  else {
+                    OpenLine(-lines.Length()-1,Psol,Pnts1,Func,CurrentLine);
+                  }
                 }
                 //Remove <SaveN> from <seqAlone> and, if it is first found point,
                 //from <seqAjout> too

src/MAT2d/MAT2d_Tool2d.cxx

@@ -27,10 +27,8 @@
 #include <Draw_Appli.hxx>
 #include <DrawTrSurf_Curve2d.hxx>
 #include <GCE2d_MakeSegment.hxx>
-#include <DrawTrSurf.hxx>
 #endif
 
-
 #include <Bisector_Bisec.hxx>
 #include <Bisector_BisecAna.hxx>
 #include <Bisector_BisecCC.hxx>
@@ -233,10 +231,22 @@ Standard_Integer MAT2d_Tool2d::TangentBefore(const Standard_Integer anitem,
   type = theCircuit->Value(anitem)->DynamicType();
   if ( type != STANDARD_TYPE(Geom2d_CartesianPoint)){
     curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(anitem));
+#ifdef DRAW
+    char  *name = new char[100];
+    sprintf(name, "c%d", anitem);
+    DrawTrSurf::Set(name, curve);
+    delete [] name;
+#endif
     theGeomVecs.Bind(theNumberOfVecs,curve->DN(curve->LastParameter(),1));
   }
   else {
     curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(item));
+#ifdef DRAW
+    char  *name = new char[100];
+    sprintf(name, "c%d", item);
+    DrawTrSurf::Set(name, curve);
+    delete [] name;
+#endif
     Standard_Real param = (IsOpenResult && anitem == theCircuit->NumberOfItems())?
       curve->LastParameter() : curve->FirstParameter();
     theGeomVecs.Bind(theNumberOfVecs,curve->DN(param,1));
@@ -269,6 +279,12 @@ Standard_Integer MAT2d_Tool2d::TangentAfter(const Standard_Integer anitem,
   type = theCircuit->Value(anitem)->DynamicType();
   if ( type != STANDARD_TYPE(Geom2d_CartesianPoint)){
     curve     = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(anitem));
+#ifdef DRAW
+    char  *name = new char[100];
+    sprintf(name, "c%d", anitem);
+    DrawTrSurf::Set(name, curve);
+    delete [] name;
+#endif
     thevector = curve->DN(curve->FirstParameter(),1);
   }
   else {
@@ -276,7 +292,14 @@ Standard_Integer MAT2d_Tool2d::TangentAfter(const Standard_Integer anitem,
     item      = (anitem == 1) ? theCircuit->NumberOfItems() : (anitem - 1);
     else
       item = (anitem == 1) ? 2 : (anitem - 1);
+    
     curve     = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(item));
+#ifdef DRAW
+    char  *name = new char[100];
+    sprintf(name, "c%d", item);
+    DrawTrSurf::Set(name, curve);
+    delete [] name;
+#endif
     Standard_Real param = (IsOpenResult && anitem == 1)?
       curve->FirstParameter() : curve->LastParameter();
     thevector = curve->DN(param,1);
@@ -401,6 +424,14 @@ void MAT2d_Tool2d::CreateBisector(const Handle(MAT_Bisector)& abisector)
   abisector->BisectorNumber(theNumberOfBisectors);
   abisector->Sense(1);
 
+#ifdef DRAW
+  char  *name = new char[100];
+  sprintf(name, "b%d", theNumberOfBisectors);
+  DrawTrSurf::Set(name, bisector.Value());
+  Dump(abisector->BisectorNumber(),1);
+  delete [] name;
+#endif
+
 #ifdef OCCT_DEBUG
   Standard_Boolean AffichDraw = Standard_False;
   if (AffichDraw) Dump(abisector->BisectorNumber(),1);

src/Poly/Poly_Triangulation.cxx

@@ -29,26 +29,59 @@ IMPLEMENT_STANDARD_RTTIEXT (Poly_Triangulation, Standard_Transient)
 //function : Poly_Triangulation
 //purpose  : 
 //=======================================================================
-Poly_Triangulation::Poly_Triangulation(const Standard_Integer theNbNodes,
-                                       const Standard_Integer theNbTriangles,
-                                       const Standard_Boolean theHasUVNodes)
-: myDeflection(0),
-  myNodes     (1, theNbNodes),
-  myTriangles (1, theNbTriangles)
+Poly_Triangulation::Poly_Triangulation()
+: myCachedMinMax (NULL),
+  myDeflection   (0)
 {
-  if (theHasUVNodes) myUVNodes = new TColgp_HArray1OfPnt2d(1, theNbNodes);
 }
 
 //=======================================================================
 //function : Poly_Triangulation
 //purpose  : 
 //=======================================================================
+Poly_Triangulation::Poly_Triangulation(const Standard_Integer theNbNodes,
+                                       const Standard_Integer theNbTriangles,
+                                       const Standard_Boolean theHasUVNodes)
+: myCachedMinMax (NULL),
+  myDeflection   (0),
+  myNodes        (1, theNbNodes),
+  myTriangles    (1, theNbTriangles)
+{
+  if (theHasUVNodes) myUVNodes = new TColgp_HArray1OfPnt2d(1, theNbNodes);
+}
 
+//=======================================================================
+//function : Poly_Triangulation
+//purpose  :
+//=======================================================================
+Poly_Triangulation::Poly_Triangulation(const Standard_Integer theNbNodes,
+                                       const Standard_Integer theNbTriangles,
+                                       const Standard_Boolean theHasUVNodes,
+                                       const Standard_Boolean theHasNormals)
+: myDeflection(0),
+  myNodes     (1, theNbNodes),
+  myTriangles (1, theNbTriangles)
+{
+  if (theHasUVNodes)
+  {
+    myUVNodes = new TColgp_HArray1OfPnt2d(1, theNbNodes);
+  }
+  if (theHasNormals)
+  {
+    myNormals = new TShort_HArray1OfShortReal(1, theNbNodes * 3);
+  }
+}
+
+//=======================================================================
+//function : Poly_Triangulation
+//purpose  :
+//=======================================================================
 Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    theNodes,
                                        const Poly_Array1OfTriangle& theTriangles)
-: myDeflection(0),
-  myNodes     (1, theNodes.Length()),
-  myTriangles (1, theTriangles.Length())
+: myCachedMinMax (NULL),
+  myDeflection   (0),
+  myNodes        (1, theNodes.Length()),
+  myTriangles    (1, theTriangles.Length())
 {
   myNodes = theNodes;
   myTriangles = theTriangles;
@@ -62,9 +95,10 @@ Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    theNodes,
 Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    theNodes,
                                        const TColgp_Array1OfPnt2d&  theUVNodes,
                                        const Poly_Array1OfTriangle& theTriangles)
-: myDeflection(0),
-  myNodes     (1, theNodes.Length()),
-  myTriangles (1, theTriangles.Length())
+: myCachedMinMax (NULL),
+  myDeflection   (0),
+  myNodes        (1, theNodes.Length()),
+  myTriangles    (1, theTriangles.Length())
 {
   myNodes = theNodes;
   myTriangles = theTriangles;
@@ -72,6 +106,15 @@ Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    theNodes,
   myUVNodes->ChangeArray1() = theUVNodes;
 }
 
+//=======================================================================
+//function : ~Poly_Triangulation
+//purpose  :
+//=======================================================================
+Poly_Triangulation::~Poly_Triangulation()
+{
+  delete myCachedMinMax;
+}
+
 //=======================================================================
 //function : Copy
 //purpose  : 
@@ -79,16 +122,7 @@ Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    theNodes,
 
 Handle(Poly_Triangulation) Poly_Triangulation::Copy() const
 {
-  Handle(Poly_Triangulation) aCopy;
-  if (HasUVNodes())
-    aCopy = new Poly_Triangulation(Nodes(), UVNodes(), Triangles());
-  else
-    aCopy = new Poly_Triangulation(Nodes(), Triangles());
-  aCopy->Deflection(myDeflection);
-  if (HasNormals())
-    aCopy->myNormals = new TShort_HArray1OfShortReal(myNormals->Array1());
-
-  return aCopy;
+  return new Poly_Triangulation (this);
 }
 
 //=======================================================================
@@ -97,10 +131,12 @@ Handle(Poly_Triangulation) Poly_Triangulation::Copy() const
 //=======================================================================
 
 Poly_Triangulation::Poly_Triangulation (const Handle(Poly_Triangulation)& theTriangulation)
-: myDeflection ( theTriangulation->myDeflection ),
+: myCachedMinMax(NULL),
+  myDeflection(theTriangulation->myDeflection),
   myNodes(theTriangulation->Nodes()),
   myTriangles(theTriangulation->Triangles())
 {
+  SetCachedMinMax (theTriangulation->CachedMinMax());
   if (theTriangulation->HasUVNodes())
   {
     myUVNodes = new TColgp_HArray1OfPnt2d(theTriangulation->myUVNodes->Array1());
@@ -328,3 +364,94 @@ void Poly_Triangulation::DumpJson (Standard_OStream& theOStream, Standard_Intege
     OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myNormals->Size())
   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myTriangles.Size())
 }
+
+// =======================================================================
+// function : CachedMinMax
+// purpose  :
+// =======================================================================
+const Bnd_Box& Poly_Triangulation::CachedMinMax() const
+{
+  static const Bnd_Box anEmptyBox;
+  return (myCachedMinMax == NULL) ? anEmptyBox : *myCachedMinMax;
+}
+
+// =======================================================================
+// function : SetCachedMinMax
+// purpose  :
+// =======================================================================
+void Poly_Triangulation::SetCachedMinMax (const Bnd_Box& theBox)
+{
+  if (theBox.IsVoid())
+  {
+    unsetCachedMinMax();
+    return;
+  }
+  if (myCachedMinMax == NULL)
+  {
+    myCachedMinMax = new Bnd_Box();
+  }
+  *myCachedMinMax = theBox;
+}
+
+// =======================================================================
+// function : unsetCachedMinMax
+// purpose  :
+// =======================================================================
+void Poly_Triangulation::unsetCachedMinMax()
+{
+  if (myCachedMinMax != NULL)
+  {
+    delete myCachedMinMax;
+    myCachedMinMax = NULL;
+  }
+}
+
+// =======================================================================
+// function : MinMax
+// purpose  :
+// =======================================================================
+Standard_Boolean Poly_Triangulation::MinMax (Bnd_Box& theBox, const gp_Trsf& theTrsf, const bool theIsAccurate) const
+{
+  Bnd_Box aBox;
+  if (HasCachedMinMax() &&
+      (!HasGeometry() || !theIsAccurate ||
+       theTrsf.Form() == gp_Identity || theTrsf.Form() == gp_Translation ||
+       theTrsf.Form() == gp_PntMirror || theTrsf.Form() == gp_Scale))
+  {
+    aBox = myCachedMinMax->Transformed (theTrsf);
+  }
+  else
+  {
+    aBox = computeBoundingBox (theTrsf);
+  }
+  if (aBox.IsVoid())
+  {
+    return Standard_False;
+  }
+  theBox.Add (aBox);
+  return Standard_True;
+}
+
+// =======================================================================
+// function : computeBoundingBox
+// purpose  :
+// =======================================================================
+Bnd_Box Poly_Triangulation::computeBoundingBox (const gp_Trsf& theTrsf) const
+{
+  Bnd_Box aBox;
+  if (theTrsf.Form() == gp_Identity)
+  {
+    for (Standard_Integer aNodeIdx = 1; aNodeIdx <= NbNodes(); aNodeIdx++)
+    {
+      aBox.Add (myNodes[aNodeIdx]);
+    }
+  }
+  else
+  {
+    for (Standard_Integer aNodeIdx = 1; aNodeIdx <= NbNodes(); aNodeIdx++)
+    {
+      aBox.Add (myNodes[aNodeIdx].Transformed (theTrsf));
+    }
+  }
+  return aBox;
+}

src/Poly/Poly_Triangulation.hxx

@@ -17,6 +17,7 @@
 #ifndef _Poly_Triangulation_HeaderFile
 #define _Poly_Triangulation_HeaderFile
 
+#include <Bnd_Box.hxx>
 #include <Standard.hxx>
 #include <Standard_DefineHandle.hxx>
 #include <Standard_Real.hxx>
@@ -68,6 +69,9 @@ public:
 
   DEFINE_STANDARD_RTTIEXT(Poly_Triangulation, Standard_Transient)
 
+  //! Constructs an empty triangulation.
+  Standard_EXPORT Poly_Triangulation();
+
   //! Constructs a triangulation from a set of triangles. The
   //! triangulation is initialized without a triangle or a node, but capable of
   //! containing nbNodes nodes, and nbTriangles
@@ -76,6 +80,17 @@ public:
   //! enable a 2D representation).
   Standard_EXPORT Poly_Triangulation(const Standard_Integer nbNodes, const Standard_Integer nbTriangles, const Standard_Boolean UVNodes);
 
+  //! Constructs a triangulation from a set of triangles.
+  //! The triangulation is initialized without a triangle or a node,
+  //! but capable of containing nbNodes nodes, and nbTriangles triangles.
+  //! Here the UVNodes flag indicates whether 2D nodes will be associated with 3D ones,
+  //! (i.e. to enable a 2D representation).
+  //! Here the hasNormals flag indicates whether normals will be given and associated with nodes.
+  Standard_EXPORT Poly_Triangulation(const Standard_Integer nbNodes,
+                                     const Standard_Integer nbTriangles,
+                                     const Standard_Boolean UVNodes,
+                                     const Standard_Boolean hasNormals);
+
   //! Constructs a triangulation from a set of triangles. The
   //! triangulation is initialized with 3D points from Nodes and triangles
   //! from Triangles.
@@ -90,6 +105,9 @@ public:
   //! constructed triangulation.
   Standard_EXPORT Poly_Triangulation(const TColgp_Array1OfPnt& Nodes, const TColgp_Array1OfPnt2d& UVNodes, const Poly_Array1OfTriangle& Triangles);
 
+  //! Destructor
+  Standard_EXPORT virtual ~Poly_Triangulation();
+
   //! Creates full copy of current triangulation
   Standard_EXPORT virtual Handle(Poly_Triangulation) Copy() const;
 
@@ -106,6 +124,9 @@ public:
   //! Deallocates the UV nodes.
   Standard_EXPORT void RemoveUVNodes();
 
+  //! Returns TRUE if triangulation has some geometry.
+  virtual Standard_Boolean HasGeometry() const { return !myNodes.IsEmpty() && !myTriangles.IsEmpty(); }
+
   //! Returns the number of nodes for this triangulation.
   Standard_Integer NbNodes() const { return myNodes.Length(); }
 
@@ -196,11 +217,54 @@ public:
   Standard_EXPORT void SetNormal (const Standard_Integer theIndex,
                                   const gp_Dir&          theNormal);
 
+  //! Returns cached min - max range of triangulation data,
+  //! which is VOID by default (e.g, no cached information).
+  Standard_EXPORT const Bnd_Box& CachedMinMax() const;
+
+  //! Sets a cached min - max range of this triangulation.
+  //! The bounding box should exactly match actual range of triangulation data
+  //! without a gap or transformation, or otherwise undefined behavior will be observed.
+  //! Passing a VOID range invalidates the cache.
+  Standard_EXPORT void SetCachedMinMax (const Bnd_Box& theBox);
+
+  //! Returns TRUE if there is some cached min - max range of this triangulation.
+  Standard_EXPORT Standard_Boolean HasCachedMinMax() const { return myCachedMinMax != NULL; }
+
+  //! Updates cached min - max range of this triangulation with bounding box of nodal data.
+  void UpdateCachedMinMax()
+  {
+    Bnd_Box aBox;
+    MinMax (aBox, gp_Trsf(), true);
+    SetCachedMinMax (aBox);
+  }
+
+  //! Extends the passed box with bounding box of this triangulation.
+  //! Uses cached min - max range when available and:
+  //! - input transformation theTrsf has no rotation part;
+  //! - theIsAccurate is set to FALSE;
+  //! - no triangulation data available (e.g. it is deferred and not loaded).
+  //! @param theBox [in] [out] bounding box to extend by this triangulation
+  //! @param theTrsf [in] optional transformation
+  //! @param theIsAccurate [in] when FALSE, allows using a cached min - max range of this triangulation
+  //!                           even for non-identity transformation.
+  //! @return FALSE if there is no any data to extend the passed box (no both triangulation and cached min - max range).
+  Standard_EXPORT Standard_Boolean MinMax (Bnd_Box& theBox, const gp_Trsf& theTrsf, const bool theIsAccurate = false) const;
+
   //! Dumps the content of me into the stream
   Standard_EXPORT virtual void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
 
 protected:
 
+  //! Clears cached min - max range saved previously.
+  Standard_EXPORT void unsetCachedMinMax();
+
+  //! Calculates bounding box of nodal data.
+  //! @param theTrsf [in] optional transformation.
+  Standard_EXPORT virtual Bnd_Box computeBoundingBox (const gp_Trsf& theTrsf) const;
+
+protected:
+
+  Bnd_Box*                           myCachedMinMax;
   Standard_Real                      myDeflection;
   TColgp_Array1OfPnt                 myNodes;
   Handle(TColgp_HArray1OfPnt2d)      myUVNodes;

src/ProjLib/ProjLib_ComputeApprox.cxx

@@ -1246,7 +1246,9 @@ void ProjLib_ComputeApprox::Perform
 
     //Return curve home
     Standard_Real UFirst = F.FirstParameter();
-    gp_Pnt P3d = C->Value( UFirst );
+    Standard_Real ULast = F.LastParameter();
+    Standard_Real Umid = (UFirst + ULast)/2;
+    gp_Pnt P3d = C->Value (Umid);
     Standard_Real u = 0., v = 0.;
     switch (SType)
     {
@@ -1301,7 +1303,7 @@ void ProjLib_ComputeApprox::Perform
     if (F.UCouture || (F.VCouture && SType == GeomAbs_Sphere))
     {
       Standard_Real aNbPer;
-      gp_Pnt2d P2d = F.Value(UFirst);
+      gp_Pnt2d P2d = F.Value (Umid);
       du = u - P2d.X();
       du = (du < 0) ? (du - Precision::PConfusion()) : 
         (du + Precision::PConfusion());

src/STEPControl/STEPControl_ActorWrite.cxx

@@ -1241,8 +1241,8 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
       Handle(StepRepr_HArray1OfRepresentationItem) newItems = 
         new StepRepr_HArray1OfRepresentationItem(1, oldItems->Length() + 1);
       Standard_Integer el = 1;
-      for (Standard_Integer i = 1; i <= oldItems->Length(); i++)
-        newItems->SetValue( el++, oldItems->Value(i) );
+        for (Standard_Integer i = 1; i <= oldItems->Length(); i++)
+          newItems->SetValue(el++, oldItems->Value(i));
       newItems->SetValue( el, items->Value( items->Length() ) );
       shapeRep->SetItems(newItems);
     }
@@ -1276,7 +1276,7 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
     return resbind;
   } else return FP->Find(start);
 
-}
+  }
 
 //=======================================================================
 //function : TransferCompound
@@ -1381,11 +1381,7 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferCompound
       Handle(Transfer_SimpleBinderOfTransient) bx = 
         Handle(Transfer_SimpleBinderOfTransient)::DownCast(bnd);
       if ( !bx.IsNull() ) {
-        // Single SDR is created for a non-manifold group (ssv: 12.11.2010)
-        if (!isManifold && i > 1)
-          break;
-        else
-          binder->AddResult( TransientResult( bx->Result() ) );
+        binder->AddResult( TransientResult( bx->Result() ) );
       }
       bnd = bnd->NextResult();
     }
@@ -1465,7 +1461,10 @@ Handle(Transfer_Binder)  STEPControl_ActorWrite::TransferSubShape
   //:abv 20.05.02: see comment in TransferShape(): added "! iasdr ||"
   Handle(Transfer_Binder) resprod = TransientResult(sdr);  //KA - OCC7141(skl 10.11.2004)
   if ( ! iasdr || resbind.IsNull() ) {
-    resbind = TransferShape(mapper, sdr, FP, shapeGroup, isManifold, theProgress);
+    Handle(Transfer_Binder) resbind1 = TransferShape(mapper, sdr, FP, shapeGroup, isManifold, theProgress);
+    if (resbind1.IsNull() || sdr->UsedRepresentation().IsNull())
+      return Handle(Transfer_Binder)();
+    resbind = resbind1;
     Handle(Transfer_Binder) oldbind = FP->Find ( mapper );
     if ( ! oldbind.IsNull() && !resbind.IsNull()) resbind->AddResult ( oldbind );
     FP->Bind (mapper,resbind);

src/SWDRAW/SWDRAW_ShapeAnalysis.cxx

@@ -31,6 +31,7 @@
 #include <GeomAPI_ProjectPointOnSurf.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Pnt2d.hxx>
+#include <gp_Elips.hxx>
 #include <GProp_GProps.hxx>
 #include <Precision.hxx>
 #include <ShapeAnalysis.hxx>
@@ -63,6 +64,14 @@
 #include <Adaptor3d_CurveOnSurface.hxx>
 #include <BRepAdaptor_HCurve2d.hxx>
 #include <BRepAdaptor_HSurface.hxx>
+#include <Geom_Plane.hxx>
+#include <Geom_CylindricalSurface.hxx>
+#include <Geom_ConicalSurface.hxx>
+#include <Geom_SphericalSurface.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_Circle.hxx>
+#include <Geom_Ellipse.hxx>
+#include <ShapeAnalysis_CanonicalRecognition.hxx>
 
 #include <stdio.h>
 static Standard_Integer tolerance
@@ -978,6 +987,203 @@ static Standard_Integer checkedge(Draw_Interpretor& di, Standard_Integer argc, c
 
   return 0;
 }
+//=======================================================================
+// getanasurf
+//=======================================================================
+static Standard_Integer getanasurf(Draw_Interpretor& di,
+  Standard_Integer n, const char** a)
+
+{
+  if (n < 3) {
+    di << "Usage: \n";
+    di << "getanasurf res shape [target [tol [sample]]] \n";
+    di << "target is reqired type of surface and can be: pln, cyl, con sph \n";
+    di << "sample is surface of required type, which parameters are used as starting \n";
+    di << "point for seaching parametrs of surface by Least Square method when input shape \n";
+    di << "is edge or wire \n";
+      return 1;
+  }
+  TopoDS_Shape sh = DBRep::Get(a[2]);
+  if (sh.IsNull()) return 1;
+  TopAbs_ShapeEnum aShType = sh.ShapeType();
+  if (!(aShType == TopAbs_SHELL || aShType == TopAbs_FACE || aShType == TopAbs_EDGE || aShType == TopAbs_WIRE))
+  {
+    di << "Wrong shape type, shape can be shell or face or edge or wire\n";
+    return 1;
+  }
+
+  GeomAbs_SurfaceType aTargets[] = { GeomAbs_Plane, GeomAbs_Cylinder, GeomAbs_Cone, GeomAbs_Sphere };
+  Standard_Integer isurf = 0;
+  if (n > 3)
+  {
+    if (strcmp(a[3], "pln") == 0)
+      isurf = 0;
+    else if (strcmp(a[3], "cyl") == 0)
+      isurf = 1;
+    else if (strcmp(a[3], "con") == 0)
+      isurf = 2;
+    else if (strcmp(a[3], "sph") == 0)
+      isurf = 3;
+  }
+
+  Standard_Real tol = 1.e-7;
+  if (n > 4)
+    tol = Draw::Atof(a[4]);
+
+  // get sample  target for edge and wire
+  GeomAdaptor_Surface aSampleSurf;
+  if (n > 5 && (sh.ShapeType() == TopAbs_EDGE || sh.ShapeType() == TopAbs_WIRE ))
+  {
+    Handle(Geom_Surface) aGSurf = DrawTrSurf::GetSurface(a[5]);
+    if (aGSurf.IsNull())
+    {
+      di << "Sample surface is null" << "\n";
+      return 1;
+    }
+    aSampleSurf.Load(aGSurf);
+    GeomAbs_SurfaceType aSType = aSampleSurf.GetType();
+    if (aSType != aTargets[isurf])
+    {
+      di << "Sample surface has wrong type" << "\n";
+      return 1;
+    }
+  }
+
+  ShapeAnalysis_CanonicalRecognition aCanonRec(sh);
+  Handle(Geom_Surface) aRes;
+  switch (aTargets[isurf])
+  {
+  case GeomAbs_Plane:
+  {
+    gp_Pln aPln;
+    if (aSampleSurf.GetType() == GeomAbs_Plane)
+      aPln = aSampleSurf.Plane();
+    if (aCanonRec.IsPlane(tol, aPln))
+      aRes = new Geom_Plane(aPln);
+    break;
+  }
+  case GeomAbs_Cylinder:
+  {
+    gp_Cylinder aCyl;
+    if (aSampleSurf.GetType() == GeomAbs_Cylinder)
+      aCyl = aSampleSurf.Cylinder();
+    if (aCanonRec.IsCylinder(tol, aCyl))
+      aRes = new Geom_CylindricalSurface(aCyl);
+    break;
+  }
+  case GeomAbs_Cone:
+  {
+    gp_Cone aCon;
+    if (aSampleSurf.GetType() == GeomAbs_Cone)
+      aCon = aSampleSurf.Cone();
+    if (aCanonRec.IsCone(tol, aCon))
+      aRes = new Geom_ConicalSurface(aCon);
+    break;
+  }
+  case GeomAbs_Sphere:
+  {
+    gp_Sphere aSph;
+    if (aSampleSurf.GetType() == GeomAbs_Sphere)
+      aSph = aSampleSurf.Sphere();
+    if (aCanonRec.IsSphere(tol, aSph))
+      aRes = new Geom_SphericalSurface(aSph);
+    break;
+  }
+  default:
+    break;
+  }
+
+  if (!aRes.IsNull())
+  {
+    DrawTrSurf::Set(a[1], aRes);
+    di << "Gap = " << aCanonRec.GetGap() << "\n";
+  }
+  else
+  {
+    di << "Cannot get required surface" << "\n";
+  }
+  return 0;
+}
+//=======================================================================
+//function : getanacurve
+//purpose  : 
+//=======================================================================
+
+Standard_Integer getanacurve(Draw_Interpretor& di,
+  Standard_Integer n, const char** a)
+{
+  if (n < 3) {
+    di << "Usage: \n";
+    di << "getanacurve res shape [target [tol]] \n";
+    di << "target is reqired type of curve and can be: lin, cir, ell  \n";
+    return 1;
+  }
+  TopoDS_Shape sh = DBRep::Get(a[2]);
+  if (sh.IsNull()) return 1;
+  TopAbs_ShapeEnum aShType = sh.ShapeType();
+  if (!(aShType == TopAbs_WIRE || aShType == TopAbs_EDGE))
+  {
+    di << "Wrong shape type, shape can be wire or or edge \n";
+    return 1;
+  }
+
+  GeomAbs_CurveType aTargets[] = { GeomAbs_Line, GeomAbs_Circle, GeomAbs_Ellipse };
+  Standard_Integer icurv = 0;
+  if (n > 3)
+  {
+    if (strcmp(a[3],"lin") == 0)
+      icurv = 0;
+    else if (strcmp(a[3], "cir") == 0)
+      icurv = 1;
+    else if (strcmp(a[3], "ell") == 0)
+      icurv = 2;
+  }
+
+  Standard_Real tol = Precision::Confusion();
+  if (n > 4)
+      tol = Draw::Atof(a[4]);
+
+  ShapeAnalysis_CanonicalRecognition aCanonRec(sh);
+  Handle(Geom_Curve) aRes;
+  switch (aTargets[icurv])
+  {
+  case GeomAbs_Line:
+  {
+    gp_Lin aLin;
+    if (aCanonRec.IsLine(tol, aLin))
+      aRes = new Geom_Line(aLin);
+    break;
+  }
+  case GeomAbs_Circle:
+  {
+    gp_Circ aCirc;
+    if (aCanonRec.IsCircle(tol, aCirc))
+      aRes = new Geom_Circle(aCirc);
+    break;
+  }
+  case GeomAbs_Ellipse:
+  {
+    gp_Elips anElips;
+    if (aCanonRec.IsEllipse(tol, anElips))
+      aRes = new Geom_Ellipse(anElips);
+    break;
+  }
+  default:
+    break;
+  }
+
+  if (!aRes.IsNull())
+  {
+    DrawTrSurf::Set(a[1], aRes);
+    di << "Gap = " << aCanonRec.GetGap() << "\n";
+  }
+  else
+  {
+    di << "Cannot get required curve" << "\n";
+  }
+  return 0;
+
+}
 
 //=======================================================================
 //function : InitCommands
@@ -1020,4 +1226,8 @@ static Standard_Integer checkedge(Draw_Interpretor& di, Standard_Integer argc, c
   theCommands.Add("getareacontour","wire ",__FILE__, getareacontour, groupold);
   theCommands.Add ("checkselfintersection","wire [face]", __FILE__,checkselfintersection,g);
   theCommands.Add ("checkedge","edge [face]", __FILE__,checkedge,g);
+  theCommands.Add("getanasurf", "getanasurf res shape [target [tol [sample]]] ", __FILE__, getanasurf, g);
+  theCommands.Add("getanacurve", "getanacurve res shape [target [tol]]", __FILE__, getanacurve, g);
+
+
 }

src/SWDRAW/SWDRAW_ShapeUpgrade.cxx

@@ -1190,6 +1190,52 @@ static Standard_Integer splitarea (Draw_Interpretor& di,
   return 0;
 }
 
+static Standard_Integer splitbynumber (Draw_Interpretor& di, 
+                                       Standard_Integer argc, 
+                                       const char** argv)
+{
+  if (argc < 4) {
+    di << "bad number of arguments\n";
+    return 1;
+  }
+  
+  TopoDS_Shape inputShape=DBRep::Get(argv[2], TopAbs_FACE);
+  if (inputShape.IsNull()) {
+    di << "Unknown face\n";
+    return 1;
+  }
+  
+  Standard_Integer aNbParts, aNumber1 = 0, aNumber2 = 0;
+  aNbParts = aNumber1 = Draw::Atoi (argv[3]);
+  if (argc > 4)
+    aNumber2 = Draw::Atoi (argv[4]);
+  
+  if (argc == 4 && aNbParts <= 0)
+  {
+    di << "Incorrect number of parts\n";
+    return 1;
+  }
+  if (argc == 5 &&
+      (aNumber1 <= 0 || aNumber2 <= 0))
+  {
+    di << "Incorrect numbers in U or V\n";
+    return 1;
+  }
+    
+  ShapeUpgrade_ShapeDivideArea tool (inputShape);
+  tool.SetSplittingByNumber (Standard_True);
+  if (argc == 4)
+    tool.NbParts() = aNbParts;
+  else
+    tool.SetNumbersUVSplits (aNumber1, aNumber2);
+  tool.Perform();
+  TopoDS_Shape res = tool.Result();
+  
+  ShapeFix::SameParameter ( res, Standard_False );
+  DBRep::Set ( argv[1], res );
+  return 0;
+}
+
 static Standard_Integer removeinternalwires (Draw_Interpretor& di, 
                                              Standard_Integer argc, 
                                              const char** argv)
@@ -1624,6 +1670,8 @@ static Standard_Integer reshape(Draw_Interpretor& /*theDI*/,
 		   __FILE__,splitclosed,g);
   theCommands.Add ("DT_SplitByArea","result shape maxarea [preci]",
 		   __FILE__,splitarea,g);
+  theCommands.Add ("DT_SplitByNumber","result face number [number2]",
+                   __FILE__,splitbynumber,g);
   
   theCommands.Add ("RemoveIntWires","result minarea wholeshape [faces or wires] [moderemoveface ]",
                    __FILE__,removeinternalwires,g);

src/ShapeAnalysis/FILES

@@ -45,3 +45,5 @@ ShapeAnalysis_WireOrder.cxx
 ShapeAnalysis_WireOrder.hxx
 ShapeAnalysis_WireVertex.cxx
 ShapeAnalysis_WireVertex.hxx
+ShapeAnalysis_CanonicalRecognition.cxx
+ShapeAnalysis_CanonicalRecognition.hxx

src/ShapeAnalysis/ShapeAnalysis_CanonicalRecognition.hxx

@@ -0,0 +1,169 @@
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _ShapeAnalysis_CanonicalRecognition_HeaderFile
+#define _ShapeAnalysis_CanonicalRecognition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Boolean.hxx>
+#include <Standard_Integer.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Shell.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Edge.hxx>
+#include <GeomAbs_SurfaceType.hxx>
+#include <GeomAbs_CurveType.hxx>
+#include <GeomConvert_ConvType.hxx>
+#include <TColStd_Array1OfReal.hxx>
+
+class gp_Pln;
+class gp_Cone;
+class gp_Cylinder;
+class gp_Sphere;
+class gp_Lin;
+class gp_Circ;
+class gp_Elips;
+class Geom_Curve;
+class Geom_Surface;
+
+//! This class provides operators for analysis surfaces and curves of shapes
+//! in order to find out more simple geometry entities, which could replace
+//! existing complex (for exampe, BSpline) geometry objects with given tolerance.
+class ShapeAnalysis_CanonicalRecognition  
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+
+  //! Empty constructor
+  Standard_EXPORT ShapeAnalysis_CanonicalRecognition();
+  
+  //! constructor with shape initialisation
+  Standard_EXPORT ShapeAnalysis_CanonicalRecognition(const TopoDS_Shape& theShape);
+
+  //! Sets shape
+  Standard_EXPORT void SetShape(const TopoDS_Shape& theShape);
+  
+  //! Returns input shape
+  const TopoDS_Shape& GetShape() const
+  {
+    return myShape;
+  }
+
+  //! Returns deviation between input geometry entity and analytical entity
+  Standard_Real GetGap() const
+  {
+    return myGap;
+  }
+
+  //! Returns status of operation.
+  //! Current meaning of possible values of status:
+  //! -1 - algorithm is not initalazed by shape
+  //!  0 - no errors
+  //!  1 - error during any operation (usually - because of wrong input data)
+  //! Any operation (calling any methods like IsPlane(...), ...) can be performed 
+  //! when current staue is equal 0. 
+  //! If after any operation status != 0, it is necessary to set it 0 by method ClearStatus()
+  //! before calling other operation.
+  Standard_Integer GetStatus() const
+  {
+    return myStatus;
+  }
+
+  //! Returns status to be equal 0.
+  void ClearStatus() 
+  {
+    myStatus = 0;
+  }
+
+  //! Returns true if the underlined surface can be represent by plane with tolerance theTol
+  //! and sets in thePln the result plane.  
+  Standard_EXPORT Standard_Boolean IsPlane(const Standard_Real theTol, gp_Pln& thePln);
+
+  //! Returns true if the underlined surface can be represent by cylindrical one with tolerance theTol
+  //! and sets in theCyl the result cylinrical surface.  
+  Standard_EXPORT Standard_Boolean IsCylinder(const Standard_Real theTol, gp_Cylinder& theCyl);
+
+  //! Returns true if the underlined surface can be represent by conical one with tolerance theTol
+  //! and sets in theCone the result conical surface.  
+  Standard_EXPORT Standard_Boolean IsCone(const Standard_Real theTol, gp_Cone& theCone);
+
+  //! Returns true if the underlined surface can be represent by spherical one with tolerance theTol
+  //! and sets in theSphere the result spherical surface.  
+  Standard_EXPORT Standard_Boolean IsSphere(const Standard_Real theTol, gp_Sphere& theSphere);
+
+  //! Returns true if the underlined curve can be represent by line with tolerance theTol
+  //! and sets in theLin the result line.  
+  Standard_EXPORT Standard_Boolean IsLine(const Standard_Real theTol, gp_Lin& theLin);
+
+  //! Returns true if the underlined curve can be represent by circle with tolerance theTol
+  //! and sets in theCirc the result circle.  
+  Standard_EXPORT Standard_Boolean IsCircle(const Standard_Real theTol, gp_Circ& theCirc);
+
+  //! Returns true if the underlined curve can be represent by ellipse with tolerance theTol
+  //! and sets in theCirc the result ellipse.  
+  Standard_EXPORT Standard_Boolean IsEllipse(const Standard_Real theTol, gp_Elips& theElips);
+
+
+private:
+  Standard_Boolean IsElementarySurf(const GeomAbs_SurfaceType theTarget, const Standard_Real theTol,
+    gp_Ax3& thePos, TColStd_Array1OfReal& theParams);
+
+  Standard_Boolean IsConic(const GeomAbs_CurveType theTarget, const Standard_Real theTol,
+    gp_Ax2& thePos, TColStd_Array1OfReal& theParams);
+
+  static Handle(Geom_Surface) GetSurface(const TopoDS_Face& theFace, const Standard_Real theTol,
+    const GeomConvert_ConvType theType, const GeomAbs_SurfaceType theTarget,
+    Standard_Real& theGap, Standard_Integer& theStatus);
+
+  static Handle(Geom_Surface) GetSurface(const TopoDS_Shell& theShell, const Standard_Real theTol,
+    const GeomConvert_ConvType theType, const GeomAbs_SurfaceType theTarget,
+    Standard_Real& theGap, Standard_Integer& theStatus);
+
+  static Handle(Geom_Surface) GetSurface(const TopoDS_Edge& theEdge, const Standard_Real theTol,
+    const GeomConvert_ConvType theType, const GeomAbs_SurfaceType theTarget, 
+    gp_Ax3& thePos, TColStd_Array1OfReal& theParams, 
+    Standard_Real& theGap, Standard_Integer& theStatus);
+
+  static Handle(Geom_Surface) GetSurface(const TopoDS_Wire& theWire, const Standard_Real theTol,
+    const GeomConvert_ConvType theType, const GeomAbs_SurfaceType theTarget,
+    gp_Ax3& thePos, TColStd_Array1OfReal& theParams,
+    Standard_Real& theGap, Standard_Integer& theStatus);
+
+  static Handle(Geom_Curve) GetCurve(const TopoDS_Edge& theEdge, const Standard_Real theTol,
+    const GeomConvert_ConvType theType, const GeomAbs_CurveType theTarget,
+    Standard_Real& theGap, Standard_Integer& theStatus);
+
+  static Standard_Boolean GetSurfaceByLS(const TopoDS_Wire& theWire, const Standard_Real theTol,
+    const GeomAbs_SurfaceType theTarget,
+    gp_Ax3& thePos, TColStd_Array1OfReal& theParams,
+    Standard_Real& theGap, Standard_Integer& theStatus);
+
+  void Init(const TopoDS_Shape& theShape);
+
+private:
+
+  TopoDS_Shape myShape;
+  TopAbs_ShapeEnum mySType;
+  Standard_Real myGap;
+  Standard_Integer myStatus;
+
+};
+
+#endif // _ShapeAnalysis_CanonicalRecognition_HeaderFile

src/ShapeUpgrade/ShapeUpgrade_ClosedFaceDivide.cxx

@@ -68,7 +68,7 @@ ShapeUpgrade_ClosedFaceDivide::ShapeUpgrade_ClosedFaceDivide(const TopoDS_Face&
 //purpose  : 
 //=======================================================================
 
-Standard_Boolean ShapeUpgrade_ClosedFaceDivide::SplitSurface()
+Standard_Boolean ShapeUpgrade_ClosedFaceDivide::SplitSurface(const Standard_Real)
 {
   Handle(ShapeUpgrade_SplitSurface) SplitSurf = GetSplitSurfaceTool();
   if ( SplitSurf.IsNull() ) return Standard_False;

src/ShapeUpgrade/ShapeUpgrade_ClosedFaceDivide.hxx

@@ -46,7 +46,7 @@ public:
   
   //! Performs splitting of surface and computes the shell
   //! from source face.
-  Standard_EXPORT virtual Standard_Boolean SplitSurface() Standard_OVERRIDE;
+  Standard_EXPORT virtual Standard_Boolean SplitSurface(const Standard_Real theArea = 0.) Standard_OVERRIDE;
   
   //! Sets the number of cutting lines by which closed face
   //! will be splitted. The resulting faces will be num+1.

src/ShapeUpgrade/ShapeUpgrade_FaceDivide.cxx

@@ -95,12 +95,12 @@ void ShapeUpgrade_FaceDivide::SetSurfaceSegmentMode(const Standard_Boolean Segme
 //purpose  : 
 //=======================================================================
 
-Standard_Boolean ShapeUpgrade_FaceDivide::Perform ()
+Standard_Boolean ShapeUpgrade_FaceDivide::Perform (const Standard_Real theArea)
 {
   myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_OK );
   if ( myFace.IsNull() ) return Standard_False;
   myResult = myFace;
-  SplitSurface();
+  SplitSurface (theArea);
   SplitCurves();
   return Status ( ShapeExtend_DONE );
  } 
@@ -110,7 +110,7 @@ Standard_Boolean ShapeUpgrade_FaceDivide::Perform ()
 //purpose  : 
 //=======================================================================
 
-Standard_Boolean ShapeUpgrade_FaceDivide::SplitSurface ()  
+Standard_Boolean ShapeUpgrade_FaceDivide::SplitSurface (const Standard_Real theArea)
 {  
   Handle(ShapeUpgrade_SplitSurface) SplitSurf = GetSplitSurfaceTool();
   if ( SplitSurf.IsNull() ) return Standard_False;
@@ -147,7 +147,7 @@ Standard_Boolean ShapeUpgrade_FaceDivide::SplitSurface ()
     if (Vl < aSVl) Vl += Min(dV, aSVl - Vl);
   }
 
-  SplitSurf->Init ( surf, Uf, Ul, Vf, Vl );
+  SplitSurf->Init (surf, Uf, Ul, Vf, Vl, theArea);
   SplitSurf->Perform(mySegmentMode);
 
   // If surface was neither splitted nor modified, do nothing

src/ShapeUpgrade/ShapeUpgrade_FaceDivide.hxx

@@ -73,11 +73,17 @@ public:
   //! The context is used to keep track of former splittings
   //! in order to keep sharings. It is updated according to
   //! modifications made.
-  Standard_EXPORT virtual Standard_Boolean Perform();
+  //! The optional argument <theArea> is used to initialize
+  //! the tool for splitting surface in the case of
+  //! splitting into N parts where N is user-defined.
+  Standard_EXPORT virtual Standard_Boolean Perform(const Standard_Real theArea = 0.);
   
   //! Performs splitting of surface and computes the shell
   //! from source face.
-  Standard_EXPORT virtual Standard_Boolean SplitSurface();
+  //! The optional argument <theArea> is used to initialize
+  //! the tool for splitting surface in the case of
+  //! splitting into N parts where N is user-defined.
+  Standard_EXPORT virtual Standard_Boolean SplitSurface(const Standard_Real theArea = 0.);
   
   //! Performs splitting of curves of all the edges in the
   //! shape and divides these edges.

src/ShapeUpgrade/ShapeUpgrade_FaceDivideArea.cxx

@@ -35,6 +35,9 @@ IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_FaceDivideArea,ShapeUpgrade_FaceDivide)
 ShapeUpgrade_FaceDivideArea::ShapeUpgrade_FaceDivideArea()
 {
   myMaxArea = Precision::Infinite();
+  myNbParts = 0;
+  myUnbSplit = myVnbSplit = -1;
+  myIsSplittingByNumber = Standard_False;
   SetPrecision(1.e-5);
   SetSplitSurfaceTool (new ShapeUpgrade_SplitSurfaceArea);
 }
@@ -47,6 +50,9 @@ ShapeUpgrade_FaceDivideArea::ShapeUpgrade_FaceDivideArea()
 ShapeUpgrade_FaceDivideArea::ShapeUpgrade_FaceDivideArea(const TopoDS_Face& F)
 {
   myMaxArea = Precision::Infinite();
+  myNbParts = 0;
+  myUnbSplit = myVnbSplit = -1;
+  myIsSplittingByNumber = Standard_False;
   SetPrecision(1.e-5);
   SetSplitSurfaceTool (new ShapeUpgrade_SplitSurfaceArea);
   Init(F);
@@ -57,54 +63,74 @@ ShapeUpgrade_FaceDivideArea::ShapeUpgrade_FaceDivideArea(const TopoDS_Face& F)
 //purpose  : 
 //=======================================================================
 
- Standard_Boolean ShapeUpgrade_FaceDivideArea::Perform() 
+ Standard_Boolean ShapeUpgrade_FaceDivideArea::Perform(const Standard_Real) 
 {
   myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_OK );
   GProp_GProps aGprop;
-  
+
   BRepGProp::SurfaceProperties(myFace,aGprop,Precision());
   Standard_Real anArea = aGprop.Mass();
+
+  Standard_Integer anbParts = 0;
+  if (myMaxArea == -1)
+  {
+    anbParts = myNbParts;
+    myMaxArea = anArea / anbParts;
+  }
+  
   if((anArea - myMaxArea) < Precision::Confusion())
     return Standard_False;
- 
-  Standard_Integer anbParts = RealToInt(ceil(anArea/myMaxArea));
+
+  if (anbParts == 0)
+    anbParts = RealToInt(ceil(anArea/myMaxArea));
+  
   Handle(ShapeUpgrade_SplitSurfaceArea) aSurfTool= Handle(ShapeUpgrade_SplitSurfaceArea)::
     DownCast(GetSplitSurfaceTool ());
   if(aSurfTool.IsNull())
     return Standard_False;
   aSurfTool->NbParts() = anbParts;
-  if(!ShapeUpgrade_FaceDivide::Perform())
+  if (myIsSplittingByNumber)
+  {
+    aSurfTool->SetSplittingIntoSquares(Standard_True);
+    aSurfTool->SetNumbersUVSplits (myUnbSplit, myVnbSplit);
+  }
+  if (!ShapeUpgrade_FaceDivide::Perform (anArea))
     return Standard_False;
   
   TopoDS_Shape aResult = Result();
   if(aResult.ShapeType() == TopAbs_FACE)
     return Standard_False;
   Standard_Integer aStatus = myStatus;
-  TopExp_Explorer aExpF(aResult,TopAbs_FACE);
-  TopoDS_Shape aCopyRes = aResult.EmptyCopied();
-  
-  Standard_Boolean isModified = Standard_False;
-  for( ; aExpF.More() ; aExpF.Next()) {
-    TopoDS_Shape aSh = Context()->Apply(aExpF.Current());
-    TopoDS_Face aFace = TopoDS::Face(aSh);
-    Init(aFace);
-    BRep_Builder aB;
-    if(Perform()) {
-      isModified = Standard_True;
-      TopoDS_Shape aRes = Result();
-      TopExp_Explorer aExpR(aRes,TopAbs_FACE);
-      for( ; aExpR.More(); aExpR.Next())
-        aB.Add(aCopyRes,aExpR.Current());
-    }
-    else
-      aB.Add(aCopyRes,aFace);
-  }
-  if(isModified)
+
+  if (!myIsSplittingByNumber)
   {
-    if (aCopyRes.ShapeType() == TopAbs_WIRE || aCopyRes.ShapeType() == TopAbs_SHELL)
-      aCopyRes.Closed (BRep_Tool::IsClosed (aCopyRes));
-    Context()->Replace(aResult,aCopyRes);
+    TopExp_Explorer aExpF(aResult,TopAbs_FACE);
+    TopoDS_Shape aCopyRes = aResult.EmptyCopied();
+    
+    Standard_Boolean isModified = Standard_False;
+    for( ; aExpF.More() ; aExpF.Next()) {
+      TopoDS_Shape aSh = Context()->Apply(aExpF.Current());
+      TopoDS_Face aFace = TopoDS::Face(aSh);
+      Init(aFace);
+      BRep_Builder aB;
+      if(Perform()) {
+        isModified = Standard_True;
+        TopoDS_Shape aRes = Result();
+        TopExp_Explorer aExpR(aRes,TopAbs_FACE);
+        for( ; aExpR.More(); aExpR.Next())
+          aB.Add(aCopyRes,aExpR.Current());
+      }
+      else
+        aB.Add(aCopyRes,aFace);
+    }
+    if(isModified)
+    {
+      if (aCopyRes.ShapeType() == TopAbs_WIRE || aCopyRes.ShapeType() == TopAbs_SHELL)
+        aCopyRes.Closed (BRep_Tool::IsClosed (aCopyRes));
+      Context()->Replace(aResult,aCopyRes);
+    }
   }
+  
   myStatus |= aStatus;  
   myResult = Context()->Apply ( aResult );
   return Status ( ShapeExtend_DONE ); 

src/ShapeUpgrade/ShapeUpgrade_FaceDivideArea.hxx

@@ -42,12 +42,24 @@ public:
   
   //! Performs splitting and computes the resulting shell
   //! The context is used to keep track of former splittings
-  Standard_EXPORT virtual Standard_Boolean Perform() Standard_OVERRIDE;
+  Standard_EXPORT virtual Standard_Boolean Perform(const Standard_Real theArea = 0.) Standard_OVERRIDE;
   
   //! Set max area allowed for faces
     Standard_Real& MaxArea();
 
+  //! Set number of parts expected
+    Standard_Integer& NbParts();
 
+  //! Set fixed numbers of splits in U and V directions.
+  //! Only for "Splitting By Numbers" mode
+    void SetNumbersUVSplits(const Standard_Integer theNbUsplits,
+                            const Standard_Integer theNbVsplits);
+  
+  //! Set splitting mode
+  //! If the mode is "splitting by number",
+  //! the face is splitted approximately into <myNbParts> parts,
+  //! the parts are similar to squares in 2D.
+    void SetSplittingByNumber(const Standard_Boolean theIsSplittingByNumber);
 
 
   DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_FaceDivideArea,ShapeUpgrade_FaceDivide)
@@ -61,7 +73,10 @@ private:
 
 
   Standard_Real myMaxArea;
-
+  Standard_Integer myNbParts;
+  Standard_Integer myUnbSplit;
+  Standard_Integer myVnbSplit;
+  Standard_Boolean myIsSplittingByNumber;
 
 };
 

src/ShapeUpgrade/ShapeUpgrade_FaceDivideArea.lxx

@@ -17,3 +17,21 @@ inline Standard_Real& ShapeUpgrade_FaceDivideArea::MaxArea()
 }
 
  
+inline Standard_Integer& ShapeUpgrade_FaceDivideArea::NbParts() 
+{
+  return myNbParts;
+}
+
+inline void ShapeUpgrade_FaceDivideArea::SetSplittingByNumber(const Standard_Boolean theIsSplittingByNumber)
+{
+  myIsSplittingByNumber = theIsSplittingByNumber;
+}
+
+inline void ShapeUpgrade_FaceDivideArea::SetNumbersUVSplits(const Standard_Integer theNbUsplits,
+                                                            const Standard_Integer theNbVsplits)
+{
+  myUnbSplit = theNbUsplits;
+  myVnbSplit = theNbVsplits;
+  if (myUnbSplit > 0 && myVnbSplit > 0)
+    myNbParts  = myUnbSplit * myVnbSplit;
+}

src/ShapeUpgrade/ShapeUpgrade_ShapeDivideArea.cxx

@@ -26,6 +26,9 @@ ShapeUpgrade_ShapeDivideArea::ShapeUpgrade_ShapeDivideArea():
        ShapeUpgrade_ShapeDivide()
 {
   myMaxArea = Precision::Infinite();
+  myNbParts = 0;
+  myUnbSplit = myVnbSplit = -1;
+  myIsSplittingByNumber = Standard_False;
 }
 
 //=======================================================================
@@ -38,6 +41,9 @@ ShapeUpgrade_ShapeDivideArea::ShapeUpgrade_ShapeDivideArea(const TopoDS_Shape& S
        
 {
   myMaxArea = Precision::Infinite();
+  myNbParts = 0;
+  myUnbSplit = myVnbSplit = -1;
+  myIsSplittingByNumber = Standard_False;
 }
 
 //=======================================================================
@@ -49,6 +55,9 @@ ShapeUpgrade_ShapeDivideArea::ShapeUpgrade_ShapeDivideArea(const TopoDS_Shape& S
 {
   Handle(ShapeUpgrade_FaceDivideArea) aFaceTool = new ShapeUpgrade_FaceDivideArea;
   aFaceTool->MaxArea() = myMaxArea;
+  aFaceTool->NbParts() = myNbParts;
+  aFaceTool->SetNumbersUVSplits (myUnbSplit, myVnbSplit);
+  aFaceTool->SetSplittingByNumber (myIsSplittingByNumber);
   return aFaceTool;
 }
 

src/ShapeUpgrade/ShapeUpgrade_ShapeDivideArea.hxx

@@ -42,7 +42,20 @@ public:
   //! Set max area allowed for faces
     Standard_Real& MaxArea();
 
+  //! Set number of parts expected
+  //! for the case of splitting by number
+    Standard_Integer& NbParts();
 
+  //! Set fixed numbers of splits in U and V directions.
+  //! Only for "Splitting By Numbers" mode
+    void SetNumbersUVSplits(const Standard_Integer theNbUsplits,
+                            const Standard_Integer theNbVsplits);
+  
+  //! Set splitting mode
+  //! If the mode is "splitting by number",
+  //! the face is splitted approximately into <myNbParts> parts,
+  //! the parts are similar to squares in 2D.
+    void SetSplittingByNumber(const Standard_Boolean theIsSplittingByNumber);
 
 
 protected:
@@ -58,8 +71,11 @@ private:
 
 
 
-  Standard_Real myMaxArea;
-
+  Standard_Real    myMaxArea;
+  Standard_Integer myNbParts;
+  Standard_Integer myUnbSplit;
+  Standard_Integer myVnbSplit;
+  Standard_Boolean myIsSplittingByNumber;
 
 };