0025192: Unification of LineConstructor algorithms used by GeomInt_IntSS and BOP
authorjgv <jgv@opencascade.com>
Thu, 4 Sep 2014 09:49:45 +0000 (13:49 +0400)
committerbugmaster <bugmaster@opencascade.com>
Thu, 4 Sep 2014 09:50:37 +0000 (13:50 +0400)
Small correction.

Correction of test case bug/modalg_5/bug24472

16 files changed:
src/BOPTools/BOPTools_AlgoTools2D.cxx
src/GeomInt/GeomInt.cdl
src/GeomInt/GeomInt.cxx [new file with mode: 0644]
src/GeomInt/GeomInt_LineConstructor.cdl
src/GeomInt/GeomInt_LineConstructor.cxx
src/IntTools/IntTools.cdl
src/IntTools/IntTools_BeanFaceIntersector.cxx
src/IntTools/IntTools_FClass2d.cxx
src/IntTools/IntTools_FaceFace.cdl
src/IntTools/IntTools_FaceFace.cxx
src/IntTools/IntTools_LineConstructor.cdl [deleted file]
src/IntTools/IntTools_LineConstructor.cxx [deleted file]
src/IntTools/IntTools_LineConstructor.lxx [deleted file]
src/IntTools/IntTools_Tools.cdl
src/IntTools/IntTools_Tools.cxx
tests/bugs/modalg_5/bug24472

index fd0f644..4c6d976 100644 (file)
@@ -73,6 +73,7 @@
 #include <IntTools_Tools.hxx>
 #include <gp_Cylinder.hxx>
 #include <TopExp_Explorer.hxx>
+#include <GeomInt.hxx>
 
 static 
   Standard_Boolean CheckEdgeLength (const TopoDS_Edge& );
@@ -325,7 +326,7 @@ void BOPTools_AlgoTools2D::AdjustPCurveOnFace
     Standard_Real newu;
     aUPeriod = aBAS.UPeriod(); 
     //
-    IntTools_Tools::AdjustPeriodic(u2, UMin, UMax, aUPeriod, newu, du);
+    GeomInt::AdjustPeriodic(u2, UMin, UMax, aUPeriod, newu, du);
     //
     if (du==0.) {
       if (aBAS.GetType()==GeomAbs_Cylinder) {
index 7b9c80e..700e591 100644 (file)
@@ -51,10 +51,20 @@ is
         Quadric      from IntSurf,
         QuadricTool  from IntSurf,
         WLine        from IntPatch);
-
+        
     private class ParameterAndOrientation;
 
     private class SequenceOfParameterAndOrientation instantiates
        Sequence from TCollection(ParameterAndOrientation);
 
+    AdjustPeriodic(thePar    : Real from Standard;
+                  theParMin : Real from Standard;
+                  theParMax : Real from Standard;
+                  thePeriod : Real from Standard;
+                  theNewPar : out Real from Standard;
+                  theOffset : out Real from Standard;
+                  theEps    : Real from Standard = 0.0)
+    returns Boolean from Standard;        
+    ---Purpose:  Adjusts the parameter <thePar> to the range [theParMin,  theParMax]
+
 end GeomInt;
diff --git a/src/GeomInt/GeomInt.cxx b/src/GeomInt/GeomInt.cxx
new file mode 100644 (file)
index 0000000..3b88d1f
--- /dev/null
@@ -0,0 +1,39 @@
+// File:      GeomInt.cxx
+// Created:   25.08.14 17:59:59
+// Author:    jgv@VIVEX
+// Copyright: Open CASCADE 2014
+
+#include <GeomInt.hxx>
+#include <TColStd_IndexedMapOfInteger.hxx>
+
+//=======================================================================
+//function : AdjustPeriodic
+//purpose  : 
+//=======================================================================
+Standard_Boolean GeomInt::AdjustPeriodic(const Standard_Real thePar,
+                                         const Standard_Real theParMin,
+                                         const Standard_Real theParMax,
+                                         const Standard_Real thePeriod,
+                                         Standard_Real &theNewPar,
+                                         Standard_Real &theOffset,
+                                         const Standard_Real theEps)
+{
+  Standard_Boolean bMin, bMax;
+  //
+  theOffset = 0.;
+  theNewPar = thePar;
+  bMin = theParMin - thePar > theEps;
+  bMax = thePar - theParMax > theEps;
+  //
+  if (bMin || bMax) {
+    Standard_Real dp, aNbPer;
+    //
+    dp = (bMin) ? (theParMax - thePar) : (theParMin - thePar);
+    modf(dp / thePeriod, &aNbPer);
+    //
+    theOffset = aNbPer * thePeriod;
+    theNewPar += theOffset;
+  }
+  //
+  return (theOffset > 0.);
+}
index e803964..9a25b78 100644 (file)
@@ -77,8 +77,14 @@ is
        --- for given index of split
        ---
 
-    PeriodicLine(me; L: Line from IntPatch)
-       is static private;
+    TreatCircle(me:out; 
+           aLine : Line from IntPatch; 
+           aTol: Real from Standard)
+       is protected; 
+
+
+    --PeriodicLine(me; L: Line from IntPatch)
+       --is static private;
 
 fields
 
index 04e8a23..0416729 100644 (file)
 #include <ElCLib.hxx>
 #include <GeomAbs_SurfaceType.hxx>
 
-
+#include <TColStd_IndexedMapOfInteger.hxx>
+#include <GeomInt.hxx>
+
+
+static
+  void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
+                  const gp_Pnt& Ptref,
+                  Standard_Real& U1,
+                  Standard_Real& V1);
+static
+  void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
+                  const Handle(GeomAdaptor_HSurface)& myHS2,
+                  const gp_Pnt& Ptref,
+                  Standard_Real& U1,
+                  Standard_Real& V1,
+                  Standard_Real& U2,
+                  Standard_Real& V2);
+
+static 
+  void GLinePoint(const IntPatch_IType typl,
+                  const Handle(IntPatch_GLine)& GLine,
+                  const Standard_Real aT,
+                  gp_Pnt& aP);
+static
+  void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
+               const Handle(GeomAdaptor_HSurface)& myHS2,
+               Standard_Real& u1,
+               Standard_Real& v1,
+               Standard_Real& u2,
+               Standard_Real& v2);
+
+//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+//
 //=======================================================================
-//function : Recadre
+//class    : GeomInt_RealWithFlag
 //purpose  : 
 //=======================================================================
-static void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
-                    const Handle(GeomAdaptor_HSurface)& myHS2,
-                    Standard_Real& u1,
-                    Standard_Real& v1,
-                    Standard_Real& u2,
-                    Standard_Real& v2)
-{
-  Standard_Boolean myHS1IsUPeriodic,myHS1IsVPeriodic;
-  const GeomAbs_SurfaceType typs1 = myHS1->GetType();
-  switch (typs1)
+class GeomInt_RealWithFlag {
+ public:
+  GeomInt_RealWithFlag() : 
+    myValue(-99.), myFlag(1) 
   {
-    case GeomAbs_Cylinder:
-    case GeomAbs_Cone:
-    case GeomAbs_Sphere:
-    { 
-      myHS1IsUPeriodic = Standard_True;
-      myHS1IsVPeriodic = Standard_False;
-      break;
-    }
-    case GeomAbs_Torus:
-    {
-      myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_True;
-      break;
-    }
-    default:
-    {
-       //-- Le cas de biparametrees periodiques est gere en amont
-      myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_False;
-      break;
-    }
-  }
-  Standard_Boolean myHS2IsUPeriodic,myHS2IsVPeriodic;
-  const GeomAbs_SurfaceType typs2 = myHS2->GetType();
-  switch (typs2)
-  {
-    case GeomAbs_Cylinder:
-    case GeomAbs_Cone:
-    case GeomAbs_Sphere: 
-    { 
-      myHS2IsUPeriodic = Standard_True;
-      myHS2IsVPeriodic = Standard_False;
-      break;
-    }
-    case GeomAbs_Torus:
-    {
-      myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_True;
-      break;
-    }
-    default:
-    {
-      //-- Le cas de biparametrees periodiques est gere en amont
-      myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_False;
-      break;
-    }
+  };
+  //
+  ~GeomInt_RealWithFlag() {
+  };
+  //
+  void SetValue(const Standard_Real aT) {
+    myValue=aT;
+  };
+  //
+  Standard_Real Value() const {
+    return myValue;
   }
-  if(myHS1IsUPeriodic) {
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS1->UPeriod();
-    const Standard_Real f = myHS1->FirstUParameter();
-    const Standard_Real l = myHS1->LastUParameter();
-    while(u1 < f) { u1+=lmf; } 
-    while(u1 > l) { u1-=lmf; }
-  }
-  if(myHS1IsVPeriodic) {
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS1->VPeriod(); 
-    const Standard_Real f = myHS1->FirstVParameter();
-    const Standard_Real l = myHS1->LastVParameter();
-    while(v1 < f) { v1+=lmf; } 
-    while(v1 > l) { v1-=lmf; }
-  }
-  if(myHS2IsUPeriodic) { 
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS2->UPeriod();
-    const Standard_Real f = myHS2->FirstUParameter();
-    const Standard_Real l = myHS2->LastUParameter();
-    while(u2 < f) { u2+=lmf; } 
-    while(u2 > l) { u2-=lmf; }
+  //
+  void SetFlag(const Standard_Integer aFlag) {
+    myFlag=aFlag;
+  };
+  //
+  Standard_Integer Flag() const {
+    return myFlag;
   }
-  if(myHS2IsVPeriodic) { 
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS2->VPeriod();
-    const Standard_Real f = myHS2->FirstVParameter();
-    const Standard_Real l = myHS2->LastVParameter();
-    while(v2 < f) { v2+=lmf; } 
-    while(v2 > l) { v2-=lmf; }
+  //
+  Standard_Boolean operator < (const GeomInt_RealWithFlag& aOther) {
+    return myValue<aOther.myValue;
   }
-}
-
-
-//=======================================================================
-//function : Parameters
-//purpose  : 
-//=======================================================================
-static void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
-                       const Handle(GeomAdaptor_HSurface)& myHS2,
-                       const gp_Pnt& Ptref,
-                       Standard_Real& U1,
-                       Standard_Real& V1,
-                       Standard_Real& U2,
-                       Standard_Real& V2)
-{
-  IntSurf_Quadric quad1,quad2;
-  switch (myHS1->Surface().GetType())
-  {
-    case GeomAbs_Plane:    quad1.SetValue(myHS1->Surface().Plane()); break;
-    case GeomAbs_Cylinder: quad1.SetValue(myHS1->Surface().Cylinder()); break;
-    case GeomAbs_Cone:     quad1.SetValue(myHS1->Surface().Cone()); break;
-    case GeomAbs_Sphere:   quad1.SetValue(myHS1->Surface().Sphere()); break;
-    case GeomAbs_Torus:    quad1.SetValue(myHS1->Surface().Torus()); break;
-    default: Standard_ConstructionError::Raise("GeomInt_LineConstructor::Parameters");
-  }
-  switch (myHS2->Surface().GetType())
-  {
-    case GeomAbs_Plane:    quad2.SetValue(myHS2->Surface().Plane()); break;
-    case GeomAbs_Cylinder: quad2.SetValue(myHS2->Surface().Cylinder()); break;
-    case GeomAbs_Cone:     quad2.SetValue(myHS2->Surface().Cone()); break;
-    case GeomAbs_Sphere:   quad2.SetValue(myHS2->Surface().Sphere()); break;
-    case GeomAbs_Torus:    quad2.SetValue(myHS2->Surface().Torus()); break;
-    default: Standard_ConstructionError::Raise("GeomInt_LineConstructor::Parameters");
-  }
-  quad1.Parameters(Ptref,U1,V1);
-  quad2.Parameters(Ptref,U2,V2);
-}
-
+  //
+ protected:
+  Standard_Real myValue;
+  Standard_Integer myFlag;
+};
+//------------
+static 
+  void SortShell(const Standard_Integer, 
+                 GeomInt_RealWithFlag *); 
+static
+  void RejectDuplicates(Standard_Integer& aNbVtx, 
+                        GeomInt_RealWithFlag *pVtx, 
+                        Standard_Real aTolPrm);
+static
+  void RejectNearBeacons(Standard_Integer& aNbVtx, 
+                         GeomInt_RealWithFlag *pVtx, 
+                         Standard_Real aTolPC1,
+                         const GeomAbs_SurfaceType aTS1,
+                         const GeomAbs_SurfaceType aTS2); 
+static
+  Standard_Real AdjustOnPeriod(const Standard_Real aTr,
+                               const Standard_Real aPeriod);
+
+static
+  Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
+                                     const IntPatch_IType aType,
+                                     const Standard_Real aTol3D);
 
 //=======================================================================
 //function : Perform
@@ -176,36 +143,21 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
   const Standard_Real Tol = Precision::PConfusion() * 35.0;
   
   const IntPatch_IType typl = L->ArcType();
-  if(typl == IntPatch_Analytic)
-  {
+  if(typl == IntPatch_Analytic)  {
     Standard_Real u1,v1,u2,v2;
     Handle(IntPatch_ALine)& ALine =  *((Handle(IntPatch_ALine) *)&L);
     seqp.Clear();
     nbvtx = GeomInt_LineTool::NbVertex(L);
-    for(i=1;i<nbvtx;i++)
-    {
+    for(i=1;i<nbvtx;i++)   {
       firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
       lastp =  GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
-      const Standard_Real pmid = (firstp+lastp)*0.5;
-      const gp_Pnt Pmid = ALine->Value(pmid);
-
-      //Checking, if it is an "micro-curve" (can it be collapsed in one point?).
-      //If "yes" then first-, last- and midpoints are same point.
-      gp_Pnt  aP1 = ALine->Value(RealToInt(firstp)),
-              aP2 = ALine->Value(RealToInt(lastp));
-
-      Standard_Real aSQDist = aP1.SquareDistance(aP2);
-      aSQDist = Max(aSQDist, aP1.SquareDistance(Pmid));
-      aSQDist = Max(aSQDist, aP2.SquareDistance(Pmid));
-
-      Standard_Boolean isMicro = aSQDist*100.0 < Tol;
-
-      if((Abs(firstp-lastp)>Precision::PConfusion()) && !isMicro)
-      { 
+      if(firstp!=lastp)      {
+        const Standard_Real pmid = (firstp+lastp)*0.5;
+        const gp_Pnt Pmid = ALine->Value(pmid);
         Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
         Recadre(myHS1,myHS2,u1,v1,u2,v2);
         const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-        if(in1 !=  TopAbs_OUT) { 
+        if(in1 !=  TopAbs_OUT) {
           const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
           if(in2 != TopAbs_OUT) { 
             seqp.Append(firstp);
@@ -216,256 +168,176 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
     }
     done = Standard_True;
     return;
-  }
-  else if(typl == IntPatch_Walking)
-  {
+  } // if(typl == IntPatch_Analytic)  {
+  else if(typl == IntPatch_Walking)  {
     Standard_Real u1,v1,u2,v2;
     Handle(IntPatch_WLine)& WLine =  *((Handle(IntPatch_WLine) *)&L);
     seqp.Clear();
-
-    i = 1;
-    
-    {
-      firstp = GeomInt_LineTool::Vertex(L,1).ParameterOnLine();
-      const IntSurf_PntOn2S& Pf = WLine->Point(RealToInt(firstp));
-
-      Pf.Parameters(u1,v1,u2,v2);
-
-//Inscribe parameters into main period for periodic surfaces
-      Recadre(myHS1,myHS2,u1,v1,u2,v2);
-
-      const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-      const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-      if((in1 ==  TopAbs_OUT) || (in2 == TopAbs_OUT))
-      {
-        i = 2;
-      }
-    }
-    
     nbvtx = GeomInt_LineTool::NbVertex(L);
-    for(;i<nbvtx;i++)
-    {
+    for(i=1;i<nbvtx;i++)    { 
       firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
       lastp =  GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
-      const Standard_Integer pmid = RealToInt((firstp+lastp)*0.5);
-      const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
-
-      //Checking, if it is an "micro-curve" (can it be collapsed in one point?).
-      //If "yes" then first-, last- and midpoints are same point.
-      gp_Pnt  aP1 = WLine->Point(RealToInt(firstp)).Value(),
-              aP2 = WLine->Point(RealToInt(lastp)).Value();
-
-      Standard_Real aSQDist = aP1.SquareDistance(aP2);
-      aSQDist = Max(aSQDist, aP1.SquareDistance(Pmid.Value()));
-      aSQDist = Max(aSQDist, aP2.SquareDistance(Pmid.Value()));
-
-      Standard_Boolean isMicro = aSQDist*100.0 < Tol;
-
-      if(isMicro)
-      {//3D-dimension is small. Checking 2D-dimension
-        aSQDist = 0.0;
-        Standard_Real u1f, v1f, u2f, v2f;
-        Standard_Real u1l, v1l, u2l, v2l;
-        Standard_Real u1m, v1m, u2m, v2m;
-
-        WLine->Point(RealToInt(firstp)).Parameters(u1f, v1f, u2f, v2f);
-        WLine->Point(RealToInt(lastp)).Parameters(u1l, v1l, u2l, v2l);
-        WLine->Point(pmid).Parameters(u1m, v1m, u2m, v2m);
-
-        Standard_Real aDelta = u1m - u1f;
-        aSQDist += aDelta*aDelta;
-        aDelta = v1m - v1f;
-        aSQDist += aDelta*aDelta;
-        aDelta = u2m - u2f;
-        aSQDist += aDelta*aDelta;
-        aDelta = v2m - v2f;
-        aSQDist += aDelta*aDelta;
-
-        aDelta = u1m - u1l;
-        aSQDist += aDelta*aDelta;
-        aDelta = v1m - v1l;
-        aSQDist += aDelta*aDelta;
-        aDelta = u2m - u2l;
-        aSQDist += aDelta*aDelta;
-        aDelta = v2m - v2l;
-        aSQDist += aDelta*aDelta;
-
-        isMicro = aSQDist*100.0 < Tol;
-      }
-
-      if((Abs(firstp-lastp)>Precision::PConfusion()) && !isMicro)
-      {
-        Pmid.Parameters(u1,v1,u2,v2);
-//Inscribe parameters into main period for periodic surfaces
-        Recadre(myHS1,myHS2,u1,v1,u2,v2);
-
-        const TopAbs_State in1m = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-        if(in1m ==  TopAbs_OUT)
-        {
-          continue;
+      if(firstp!=lastp) { 
+        if(lastp != firstp+1)  {
+          const Standard_Integer pmid = (Standard_Integer )( (firstp+lastp)/2);
+          const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
+          Pmid.Parameters(u1,v1,u2,v2);
+          Recadre(myHS1,myHS2,u1,v1,u2,v2);
+          const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
+          if(in1 !=  TopAbs_OUT) {   
+            const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
+            if(in2 != TopAbs_OUT) {   
+              seqp.Append(firstp);
+              seqp.Append(lastp);
+            }
+          }
         }
-
-        const TopAbs_State in2m = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-        if(in2m == TopAbs_OUT)
-        {
-          continue;
+        else {
+          const IntSurf_PntOn2S& Pfirst = WLine->Point((Standard_Integer)(firstp));
+          Pfirst.Parameters(u1,v1,u2,v2);
+          Recadre(myHS1,myHS2,u1,v1,u2,v2);
+          TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
+          if(in1 !=  TopAbs_OUT) {  //-- !=ON donne Pb 
+            TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
+            if(in2 != TopAbs_OUT) { //-- !=ON  
+              const IntSurf_PntOn2S& Plast = WLine->Point((Standard_Integer)(lastp));
+              Plast.Parameters(u1,v1,u2,v2);
+              Recadre(myHS1,myHS2,u1,v1,u2,v2);
+              in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
+              if(in1 !=  TopAbs_OUT) {  //-- !=ON donne Pb 
+                in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
+                if(in2 != TopAbs_OUT) {
+                  seqp.Append(firstp);
+                  seqp.Append(lastp);
+                }
+              }
+            }
+          }
         }
-
-        const IntSurf_PntOn2S& Plast = WLine->Point(RealToInt(lastp));
-        Plast.Parameters(u1,v1,u2,v2);
-//Inscribe parameters into main period for periodic surfaces
-        Recadre(myHS1,myHS2,u1,v1,u2,v2);
-
-        const TopAbs_State in1l = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-        if(in1l ==  TopAbs_OUT)
-        {
-          continue;
+      }
+    }
+    //
+    // The One resulting curve consists of 7 segments that are 
+    // connected between each other.
+    // The aim of the block is to reject these segments and have
+    // one segment instead of 7. 
+    //     The other reason to do that is value of TolReached3D=49.
+    //     Why -? It is not known yet. 
+    //                                             PKV 22.Apr.2002
+    //
+    Standard_Integer aNbParts;
+    //
+    aNbParts = seqp.Length()/2;
+    if (aNbParts > 1) {  
+      Standard_Boolean bCond;
+      GeomAbs_SurfaceType aST1, aST2;
+      aST1 = myHS1->Surface().GetType();
+      aST2 = myHS2->Surface().GetType();
+      //
+      bCond=Standard_False;
+      if (aST1==GeomAbs_Plane) {
+        if (aST2==GeomAbs_SurfaceOfExtrusion || 
+            aST2==GeomAbs_SurfaceOfRevolution) {//+zft
+          bCond=!bCond;
         }
-
-        const TopAbs_State in2l = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-        if(in2l == TopAbs_OUT)
-        {
-          continue;
+      }
+      else if (aST2==GeomAbs_Plane) {
+        if (aST1==GeomAbs_SurfaceOfExtrusion || 
+            aST1==GeomAbs_SurfaceOfRevolution) {//+zft
+          bCond=!bCond;
         }
-
-        seqp.Append(firstp);
-        seqp.Append(lastp);
       }
+      //
+      if (bCond) {
+        Standard_Integer aNb, anIndex, aNbTmp, jx;
+        TColStd_IndexedMapOfInteger aMap;
+        TColStd_SequenceOfReal aSeqTmp;
+        //
+        aNb=seqp.Length();
+        for(i=1; i<=aNb; ++i) {
+          lastp =seqp(i);
+          anIndex=(Standard_Integer)lastp;
+          if (!aMap.Contains(anIndex)){
+            aMap.Add(anIndex);
+            aSeqTmp.Append(lastp);
+          }
+          else {
+            aNbTmp=aSeqTmp.Length();
+            aSeqTmp.Remove(aNbTmp);
+          }
+        }
+        //
+        seqp.Clear();
+        //
+        aNb=aSeqTmp.Length()/2;
+        for(i=1; i<=aNb;++i) {
+          jx=2*i;
+          firstp=aSeqTmp(jx-1);
+          lastp =aSeqTmp(jx);
+          seqp.Append(firstp);
+          seqp.Append(lastp);
+        }
+      }//if (bCond) {
     }
     done = Standard_True;
     return;
-  }
-  else if (typl != IntPatch_Restriction)
-  {
-    Standard_Real u1,v1,u2,v2;
-    Handle(IntPatch_GLine)& GLine =  *((Handle(IntPatch_GLine) *)&L);
+  }// else if(typl == IntPatch_Walking)  {
+  //
+  //-----------------------------------------------------------
+  else if (typl != IntPatch_Restriction)  {
     seqp.Clear();
+    //
+    Handle(IntPatch_GLine)& GLine =  *((Handle(IntPatch_GLine) *)&L);
+    //
+    if(typl == IntPatch_Circle || typl == IntPatch_Ellipse) { 
+      TreatCircle(L, Tol);
+      done=Standard_True;
+      return;
+    }
+    //----------------------------
+    Standard_Boolean intrvtested;
+    Standard_Real u1,v1,u2,v2;
+    //
     nbvtx = GeomInt_LineTool::NbVertex(L);
-    Standard_Boolean intrvtested = Standard_False;
-    for(i=1;i<nbvtx;i++)
-    {
+    intrvtested = Standard_False;
+    for(i=1; i<nbvtx; ++i) { 
       firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
       lastp =  GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
-
-      if((Abs(firstp-lastp)>Precision::PConfusion()))
-      {
+      if(Abs(firstp-lastp)>Precision::PConfusion()) {
         intrvtested = Standard_True;
         const Standard_Real pmid = (firstp+lastp)*0.5;
-        gp_Pnt Pmid, aP1, aP2;
-        switch (typl)
-        {
-          case IntPatch_Lin:
-            Pmid = ElCLib::Value(pmid,GLine->Line());
-            aP1 = ElCLib::Value(firstp,GLine->Line());
-            aP2 = ElCLib::Value(lastp,GLine->Line());
-            break;
-          case IntPatch_Circle:
-            Pmid = ElCLib::Value(pmid,GLine->Circle());
-            aP1 = ElCLib::Value(firstp,GLine->Circle());
-            aP2 = ElCLib::Value(lastp,GLine->Circle());
-            break;
-          case IntPatch_Ellipse:
-            Pmid = ElCLib::Value(pmid,GLine->Ellipse());
-            aP1 = ElCLib::Value(firstp,GLine->Ellipse());
-            aP2 = ElCLib::Value(lastp,GLine->Ellipse());
-            break;
-          case IntPatch_Hyperbola:
-            Pmid = ElCLib::Value(pmid,GLine->Hyperbola());
-            aP1 = ElCLib::Value(firstp,GLine->Hyperbola());
-            aP2 = ElCLib::Value(lastp,GLine->Hyperbola());
-            break;
-          case IntPatch_Parabola:
-            Pmid = ElCLib::Value(pmid,GLine->Parabola());
-            aP1 = ElCLib::Value(firstp,GLine->Parabola());
-            aP2 = ElCLib::Value(lastp,GLine->Parabola());
-            break;
-          case IntPatch_Analytic:
-          case IntPatch_Walking:
-          case IntPatch_Restriction: break; // cases Analytic, Walking and Restriction are handled above
-        }
-
-        Standard_Real aSQDist = aP1.SquareDistance(aP2);
-        aSQDist = Max(aSQDist, aP1.SquareDistance(Pmid));
-        aSQDist = Max(aSQDist, aP2.SquareDistance(Pmid));
-
-        if(aSQDist*100.0 > Tol)
-        {       //if it is not an "micro-curve" (can it be collapsed in one point?).
-                //If "yes" then first-, last- and midpoints are same point.
-          Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
-          Recadre(myHS1,myHS2,u1,v1,u2,v2);
-          const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-          if(in1 !=  TopAbs_OUT) { 
-            const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-            if(in2 != TopAbs_OUT) { 
-              seqp.Append(firstp);
-              seqp.Append(lastp);
-            }
-          }
-        }
-      }
-    }
-    if(typl == IntPatch_Circle || typl == IntPatch_Ellipse)
-    {
-      const Standard_Real aT = M_PI + M_PI;
-      firstp = GeomInt_LineTool::Vertex(L,nbvtx).ParameterOnLine();
-      lastp  = aT + GeomInt_LineTool::Vertex(L,1).ParameterOnLine();
-      const Standard_Real cadrinf = GeomInt_LineTool::FirstParameter(L);
-      const Standard_Real cadrsup = GeomInt_LineTool::LastParameter(L);
-      Standard_Real acadr = (firstp+lastp)*0.5;
-      while(acadr < cadrinf)
-      {
-        acadr+=aT;
-      }
-      
-      while(acadr > cadrsup)
-      {
-        acadr-=aT;
-      } 
-      
-      if(acadr>=cadrinf && acadr<=cadrsup)
-      { 
-        if(Abs(firstp-lastp) > Precision::PConfusion())
-        {
-          intrvtested = Standard_True;
-          const Standard_Real pmid = (firstp+lastp)*0.5;
-          gp_Pnt Pmid;
-          if (typl == IntPatch_Circle)
-            Pmid = ElCLib::Value(pmid,GLine->Circle());
-          else
-            Pmid = ElCLib::Value(pmid,GLine->Ellipse());
-          Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
-          Recadre(myHS1,myHS2,u1,v1,u2,v2);
-          const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-          if(in1 !=  TopAbs_OUT)
-          {
-            const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-            if(in2 != TopAbs_OUT)
-            { 
-              seqp.Append(firstp);
-              seqp.Append(lastp);
-            }
+        gp_Pnt Pmid;
+        GLinePoint(typl, GLine, pmid, Pmid);
+        //
+        Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
+        Recadre(myHS1,myHS2,u1,v1,u2,v2);
+        const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
+        if(in1 !=  TopAbs_OUT) { 
+          const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
+          if(in2 != TopAbs_OUT) { 
+            seqp.Append(firstp);
+            seqp.Append(lastp);
           }
         }
       }
     }
-
+    //
     if (!intrvtested) {
-      // on garde a priori. Il faudrait un point 2d sur chaque
-      // surface pour prendre la decision. Sera fait dans 
-      // l`appelant
+      // Keep a priori. A point 2d on each
+      // surface is required to make the decision. Will be done in the caller
       seqp.Append(GeomInt_LineTool::FirstParameter(L));
       seqp.Append(GeomInt_LineTool::LastParameter(L));
     }
-    done = Standard_True;
+    //
+    done =Standard_True;
     return;
-  }
+  } // else if (typl != IntPatch_Restriction)  { 
 
   done = Standard_False;
   seqp.Clear();
   nbvtx = GeomInt_LineTool::NbVertex(L);
-  if (nbvtx == 0) { // on garde a priori. Il faudrait un point 2d sur chaque
-                    // surface pour prendre la decision. Sera fait dans 
-                    // l`appelant
+  if (nbvtx == 0) { // Keep a priori. Point 2d is required on each
+                    // surface to make the decision. Will be done in the caller
     seqp.Append(GeomInt_LineTool::FirstParameter(L));
     seqp.Append(GeomInt_LineTool::LastParameter(L));
     done = Standard_True;
@@ -475,116 +347,96 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
   GeomInt_SequenceOfParameterAndOrientation seqpss;
   TopAbs_Orientation or1=TopAbs_FORWARD,or2=TopAbs_FORWARD;
 
-  for (i=1; i<=nbvtx; i++)
-  {
+  for (i=1; i<=nbvtx; i++)  {
     const IntPatch_Point& thevtx = GeomInt_LineTool::Vertex(L,i);
     const Standard_Real prm = thevtx.ParameterOnLine();
-    if (thevtx.IsOnDomS1())
-    {
-      switch (thevtx.TransitionLineArc1().TransitionType())
-      {
-        case IntSurf_In: or1 = TopAbs_FORWARD; break;  
-        case IntSurf_Out: or1 = TopAbs_REVERSED; break;  
-        case IntSurf_Touch: or1 = TopAbs_INTERNAL; break;  
+    if (thevtx.IsOnDomS1())    {
+      switch (thevtx.TransitionLineArc1().TransitionType())      {
+        case IntSurf_In:        or1 = TopAbs_FORWARD; break;  
+        case IntSurf_Out:       or1 = TopAbs_REVERSED; break;  
+        case IntSurf_Touch:     or1 = TopAbs_INTERNAL; break;  
         case IntSurf_Undecided: or1 = TopAbs_INTERNAL; break;  
       }
     }
-    else
+    else {
       or1 = TopAbs_INTERNAL;
-
-    if (thevtx.IsOnDomS2())
-    {
-      switch (thevtx.TransitionLineArc2().TransitionType())
-      {
-        case IntSurf_In: or2 = TopAbs_FORWARD; break;  
-        case IntSurf_Out: or2 = TopAbs_REVERSED; break;  
-        case IntSurf_Touch: or2 = TopAbs_INTERNAL; break;  
-        case IntSurf_Undecided: or2 = TopAbs_INTERNAL; break;  
+    }
+    
+    if (thevtx.IsOnDomS2())    {
+      switch (thevtx.TransitionLineArc2().TransitionType())      {
+        case IntSurf_In:        or2 = TopAbs_FORWARD; break;
+        case IntSurf_Out:       or2 = TopAbs_REVERSED; break;
+        case IntSurf_Touch:     or2 = TopAbs_INTERNAL; break;
+        case IntSurf_Undecided: or2 = TopAbs_INTERNAL; break;
       }
     }
-    else
+    else {
       or2 = TopAbs_INTERNAL;
-
+    }
+    //
     const Standard_Integer nbinserted = seqpss.Length();
     Standard_Boolean inserted = Standard_False;
-    for (Standard_Integer j=1; j<=nbinserted;j++)
-    {
-      if (Abs(prm-seqpss(j).Parameter()) <= Tol)
-      {
-        // on cumule
+    for (Standard_Integer j=1; j<=nbinserted;j++)    {
+      if (Abs(prm-seqpss(j).Parameter()) <= Tol)      {
+        // accumulate
         GeomInt_ParameterAndOrientation& valj = seqpss.ChangeValue(j);
-        if (or1 != TopAbs_INTERNAL)
-        {
-          if (valj.Orientation1() != TopAbs_INTERNAL)
-          {
-            if (or1 != valj.Orientation1())
-            {
+        if (or1 != TopAbs_INTERNAL) {
+          if (valj.Orientation1() != TopAbs_INTERNAL) {
+            if (or1 != valj.Orientation1()) {
               valj.SetOrientation1(TopAbs_INTERNAL);
             }
           }
-          else
-          {
+          else {
             valj.SetOrientation1(or1);
           }
         }
-       
-        if (or2 != TopAbs_INTERNAL)
-        {
-          if (valj.Orientation2() != TopAbs_INTERNAL)
-          {
-            if (or2 != valj.Orientation2())
-            {
+        
+        if (or2 != TopAbs_INTERNAL) {
+          if (valj.Orientation2() != TopAbs_INTERNAL) {
+            if (or2 != valj.Orientation2()) {
               valj.SetOrientation2(TopAbs_INTERNAL);
             }
           }
-          else
-          {
+          else {
             valj.SetOrientation2(or2);
           }
-        }
-        
+        }          
         inserted = Standard_True;
         break;
       }
       
       if (prm < seqpss(j).Parameter()-Tol ) {
-        // on insere avant la position j
+        // insert before position j
         seqpss.InsertBefore(j,GeomInt_ParameterAndOrientation(prm,or1,or2));
         inserted = Standard_True;
         break;
       }
+      
     }
-
-    if (!inserted)
-    {
+    if (!inserted) {
       seqpss.Append(GeomInt_ParameterAndOrientation(prm,or1,or2));
     }
   }
 
-  // on determine l`etat en debut de ligne
+  // determine the state at the beginning of line
   Standard_Boolean trim = Standard_False;
   Standard_Boolean dansS1 = Standard_False;
   Standard_Boolean dansS2 = Standard_False;
 
   nbvtx = seqpss.Length();
-  for (i=1; i<= nbvtx; i++)
-  {
+  for (i=1; i<= nbvtx; i++)  {
     or1 = seqpss(i).Orientation1();
-    if (or1 != TopAbs_INTERNAL)
-    {
+    if (or1 != TopAbs_INTERNAL)    {
       trim = Standard_True;
       dansS1 = (or1 != TopAbs_FORWARD);
       break;
     }
   }
-
-  if (i > nbvtx)
-  {
+  
+  if (i > nbvtx)  {
     Standard_Real U,V;
-    for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ )
-    {
-      if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS1() )
-      {
+    for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ )    {
+      if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS1() )      {
         GeomInt_LineTool::Vertex(L,i).ParametersOnS1(U,V);
         gp_Pnt2d PPCC(U,V);
         if (myDom1->Classify(PPCC,Tol) == TopAbs_OUT) {
@@ -594,27 +446,22 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
         break;
       }
     }
-    dansS1 = Standard_True; // on garde dans le doute
+    dansS1 = Standard_True; // Keep in doubt
   }
-
-  for (i=1; i<= nbvtx; i++)
-  {
+  //
+  for (i=1; i<= nbvtx; i++)  {
     or2 = seqpss(i).Orientation2();
-    if (or2 != TopAbs_INTERNAL)
-    {
+    if (or2 != TopAbs_INTERNAL)    {
       trim = Standard_True;
       dansS2 = (or2 != TopAbs_FORWARD);
       break;
     }
   }
   
-  if (i > nbvtx)
-  {
+  if (i > nbvtx)  {
     Standard_Real U,V;
-    for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ )
-    {
-      if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS2() )
-      {
+    for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ )    {
+      if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS2() )      {
         GeomInt_LineTool::Vertex(L,i).ParametersOnS2(U,V);
         if (myDom2->Classify(gp_Pnt2d(U,V),Tol) == TopAbs_OUT) {
           done = Standard_True;
@@ -623,89 +470,76 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
         break;
       }
     }
-    dansS2 = Standard_True; // on garde dans le doute
+    dansS2 = Standard_True; //  Keep in doubt
   }
 
-  if (!trim) { // on a necessairement dansS1 == dansS2 == Standard_True
+  if (!trim) { // necessarily dansS1 == dansS2 == Standard_True
     seqp.Append(GeomInt_LineTool::FirstParameter(L));
     seqp.Append(GeomInt_LineTool::LastParameter(L));
     done = Standard_True;
     return;
   }
 
-  // On epluche la sequence seqpss pour constituer les bouts valides
-  // et les stocker dans seqp(2*i+1) et seqp(2*i+2)
+  // sequence seqpss is peeled to create valid ends 
+  // and store them in seqp(2*i+1) and seqp(2*i+2)
   Standard_Real thefirst = GeomInt_LineTool::FirstParameter(L);
   Standard_Real thelast = GeomInt_LineTool::LastParameter(L);
   firstp = thefirst;
 
-  for (i=1; i<=nbvtx; i++)
-  {
+  for (i=1; i<=nbvtx; i++)  {
     or1 = seqpss(i).Orientation1(); 
     or2 = seqpss(i).Orientation2(); 
-    if (dansS1 && dansS2)
-    {
-      if (or1 == TopAbs_REVERSED)
+    if (dansS1 && dansS2)    {
+      if (or1 == TopAbs_REVERSED){
         dansS1 = Standard_False;
-      /*else if (or1 == TopAbs_FORWARD) {
-      }*/
-      if (or2 == TopAbs_REVERSED)
+      }
+      
+      if (or2 == TopAbs_REVERSED){
         dansS2 = Standard_False;
-      /*else if (or2 == TopAbs_FORWARD) {
-      }*/
-      if (!dansS1 || !dansS2)
-      {
+      }
+      if (!dansS1 || !dansS2)      {
         lastp = seqpss(i).Parameter();
         Standard_Real stofirst = Max(firstp, thefirst);
         Standard_Real stolast  = Min(lastp,  thelast) ;
-        if (stolast > stofirst)
-        {
+
+        if (stolast > stofirst) {
           seqp.Append(stofirst);
           seqp.Append(stolast);
         }
-        
-        if (lastp > thelast)
+        if (lastp > thelast) {
           break;
+        }
       }
     }
-    else
-    {
-      if (dansS1)
-      {
-        if (or1 == TopAbs_REVERSED)
+    else    {
+      if (dansS1)      {
+        if (or1 == TopAbs_REVERSED) {
           dansS1 = Standard_False;
-        /*else if (or1 == TopAbs_FORWARD) {
-        }*/
+        }
       }
-      else
-      {
-        if (or1 == TopAbs_FORWARD)
+      else      {
+        if (or1 == TopAbs_FORWARD){
           dansS1 = Standard_True;
-        /*else if (or1 == TopAbs_REVERSED) {
-        }*/
+        }
       }
-      if (dansS2)
-      {
-        if (or2 == TopAbs_REVERSED)
+      if (dansS2) {
+        if (or2 == TopAbs_REVERSED) {
           dansS2 = Standard_False;
-        /*else if (or2 == TopAbs_FORWARD) {
-        }*/
+        }
       }
-      else
-      {
-        if (or2 == TopAbs_FORWARD)
+      else {
+        if (or2 == TopAbs_FORWARD){
           dansS2 = Standard_True;
-        /*else if (or2 == TopAbs_REVERSED) {
-        }*/
+        }
       }
-      if (dansS1 && dansS2)
+      if (dansS1 && dansS2){
         firstp = seqpss(i).Parameter();
+      }
     }
   }
-
-  // le petit dernier a rajouter
-  if (dansS1 && dansS2)
-  {
+  //
+  // finally to add
+  if (dansS1 && dansS2)  {
     lastp  = thelast;
     firstp = Max(firstp,thefirst);
     if (lastp > firstp) {
@@ -718,66 +552,432 @@ void GeomInt_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
 
 
 //=======================================================================
-//function : PeriodicLine
+//function : Recadre
+//purpose  : 
+//=======================================================================
+void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
+             const Handle(GeomAdaptor_HSurface)& myHS2,
+             Standard_Real& u1,
+             Standard_Real& v1,
+             Standard_Real& u2,
+             Standard_Real& v2)
+{ 
+  Standard_Boolean myHS1IsUPeriodic,myHS1IsVPeriodic;
+  const GeomAbs_SurfaceType typs1 = myHS1->GetType();
+  switch (typs1)
+  { 
+    case GeomAbs_Cylinder:
+    case GeomAbs_Cone:
+    case GeomAbs_Sphere: 
+    { 
+      myHS1IsUPeriodic = Standard_True;
+      myHS1IsVPeriodic = Standard_False;
+      break;
+    }
+    case GeomAbs_Torus:
+    {
+      myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_True;
+      break;
+    }
+    default:
+    {
+      //-- Case of periodic biparameters is processed upstream
+      myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_False;
+      break;
+    }
+  }
+  Standard_Boolean myHS2IsUPeriodic,myHS2IsVPeriodic;
+  const GeomAbs_SurfaceType typs2 = myHS2->GetType();
+  switch (typs2)
+  { 
+    case GeomAbs_Cylinder:
+    case GeomAbs_Cone:
+    case GeomAbs_Sphere: 
+    { 
+      myHS2IsUPeriodic = Standard_True;
+      myHS2IsVPeriodic = Standard_False;
+      break;
+    }
+    case GeomAbs_Torus:
+    {
+      myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_True;
+      break;
+    }
+    default:
+    {
+      //-- Case of periodic biparameters is processed upstream
+      myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_False;
+      break;
+    }
+  }
+  Standard_Real du, dv;
+  //
+  if(myHS1IsUPeriodic) {
+    const Standard_Real lmf = M_PI+M_PI; //-- myHS1->UPeriod();
+    const Standard_Real f = myHS1->FirstUParameter();
+    const Standard_Real l = myHS1->LastUParameter();
+    GeomInt::AdjustPeriodic(u1, f, l, lmf, u1, du);
+  }
+  if(myHS1IsVPeriodic) {
+    const Standard_Real lmf = M_PI+M_PI; //-- myHS1->VPeriod(); 
+    const Standard_Real f = myHS1->FirstVParameter();
+    const Standard_Real l = myHS1->LastVParameter();
+    GeomInt::AdjustPeriodic(v1, f, l, lmf, v1, dv);
+  }
+  if(myHS2IsUPeriodic) { 
+    const Standard_Real lmf = M_PI+M_PI; //-- myHS2->UPeriod();
+    const Standard_Real f = myHS2->FirstUParameter();
+    const Standard_Real l = myHS2->LastUParameter();
+    GeomInt::AdjustPeriodic(u2, f, l, lmf, u2, du);
+  }
+  if(myHS2IsVPeriodic) { 
+    const Standard_Real lmf = M_PI+M_PI; //-- myHS2->VPeriod();
+    const Standard_Real f = myHS2->FirstVParameter();
+    const Standard_Real l = myHS2->LastVParameter();
+    GeomInt::AdjustPeriodic(v2, f, l, lmf, v2, dv);
+  }
+}
+//=======================================================================
+//function : Parameters
+//purpose  : 
+//=======================================================================
+void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
+                const Handle(GeomAdaptor_HSurface)& myHS2,
+                const gp_Pnt& Ptref,
+                Standard_Real& U1,
+                Standard_Real& V1,
+                Standard_Real& U2,
+                Standard_Real& V2)
+{
+  Parameters(myHS1, Ptref, U1, V1);
+  Parameters(myHS2, Ptref, U2, V2);
+}
+//=======================================================================
+//function : Parameter
+//purpose  : 
+//=======================================================================
+void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
+                const gp_Pnt& Ptref,
+                Standard_Real& U1,
+                Standard_Real& V1)
+{
+  IntSurf_Quadric quad1;
+  //
+  switch (myHS1->Surface().GetType())  {
+    case GeomAbs_Plane:    
+      quad1.SetValue(myHS1->Surface().Plane()); 
+      break;
+    case GeomAbs_Cylinder: 
+      quad1.SetValue(myHS1->Surface().Cylinder()); 
+      break;
+    case GeomAbs_Cone:     
+      quad1.SetValue(myHS1->Surface().Cone()); 
+      break;
+    case GeomAbs_Sphere:   
+      quad1.SetValue(myHS1->Surface().Sphere()); 
+      break;
+    case GeomAbs_Torus:
+      quad1.SetValue(myHS1->Surface().Torus()); 
+      break;
+    default: 
+      Standard_ConstructionError::Raise("GeomInt_LineConstructor::Parameters");
+  }
+  quad1.Parameters(Ptref,U1,V1);
+}
+
+//=======================================================================
+//function : GLinePoint
 //purpose  : 
 //=======================================================================
-void GeomInt_LineConstructor::PeriodicLine (const Handle(IntPatch_Line)& L) const
+void GLinePoint(const IntPatch_IType typl,
+                const Handle(IntPatch_GLine)& GLine,
+                const Standard_Real aT,
+                gp_Pnt& aP)
 {
-  const IntPatch_IType typl = L->ArcType();
-  if (typl != IntPatch_Circle && typl != IntPatch_Ellipse)
-    return;
+  switch (typl) {
+    case IntPatch_Lin:       
+    aP = ElCLib::Value(aT, GLine->Line()); 
+    break;
+  case IntPatch_Circle:    
+    aP = ElCLib::Value(aT, GLine->Circle()); 
+    break;
+  case IntPatch_Ellipse:   
+    aP = ElCLib::Value(aT, GLine->Ellipse()); 
+    break;
+  case IntPatch_Hyperbola: 
+    aP = ElCLib::Value(aT, GLine->Hyperbola()); 
+    break;
+  case IntPatch_Parabola:  
+    aP = ElCLib::Value(aT, GLine->Parabola()); 
+    break;
+  default:
+    Standard_ConstructionError::Raise("GeomInt_LineConstructor::Parameters");
+  }
+}
 
-  const Standard_Real Tol = Precision::PConfusion();
-  Handle(IntPatch_GLine) glin = Handle(IntPatch_GLine)::DownCast(L);
-  Standard_Integer i,j,nbvtx = glin->NbVertex();
-  for (i=1; i<=nbvtx; i++)
-  {
-    IntPatch_Point thevtx = glin->Vertex(i);
-    const Standard_Real prm = thevtx.ParameterOnLine();
-    Standard_Boolean changevtx = Standard_False;
-    if (thevtx.IsOnDomS1() || thevtx.IsOnDomS2())
-    {
-      for (j=1; j<=nbvtx; j++)
-      {
-        if (j!=i)
-        {
-          const IntPatch_Point& thevtxbis = glin->Vertex(j);
-          const Standard_Real prmbis = thevtxbis.ParameterOnLine();
-          if (Abs(prm-prmbis) <= Tol)
-          {
-            Standard_Real u,v;
-            gp_Pnt2d p2d;
-            if (thevtx.IsOnDomS1() && thevtxbis.IsOnDomS1() &&
-                thevtxbis.TransitionLineArc1().TransitionType()==IntSurf_In)
-            {
-              p2d = thevtx.ArcOnS1()->Value(thevtx.ParameterOnArc1());
-              u = p2d.X(); v = p2d.Y();
-              p2d = thevtxbis.ArcOnS1()->Value(thevtxbis.ParameterOnArc1());
-              if (Abs(u-p2d.X()) > Tol || Abs(v-p2d.Y()) > Tol)
-              {
-                changevtx = Standard_True;
-                break;
-              }
-            }
-            if (thevtx.IsOnDomS2() && thevtxbis.IsOnDomS2() &&
-                thevtxbis.TransitionLineArc2().TransitionType()==IntSurf_In)
-            {
-              p2d = thevtx.ArcOnS2()->Value(thevtx.ParameterOnArc2());
-              u = p2d.X(); v = p2d.Y();
-              p2d = thevtxbis.ArcOnS2()->Value(thevtxbis.ParameterOnArc2());
-              if (Abs(u-p2d.X()) > Tol || Abs(v-p2d.Y()) > Tol)
-              {
-                changevtx = Standard_True;
-                break;
-              }
-            }
+//=======================================================================
+//function : TreatCircle
+//purpose  : 
+//=======================================================================
+void GeomInt_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& aLine,
+                                           const Standard_Real aTol)
+{  
+  Standard_Boolean bRejected;
+  IntPatch_IType aType;
+  //
+  aType=aLine->ArcType();
+  Handle(IntPatch_GLine)& aGLine=*((Handle(IntPatch_GLine) *)&aLine);
+  //
+  bRejected=RejectMicroCircle(aGLine, aType, aTol);
+  if (bRejected) {
+    return;
+  }
+  //----------------------------------------
+  Standard_Boolean bFound;
+  Standard_Integer aNbVtx, aNbVtxWas, i;
+  Standard_Real aTolPC, aT, aT1, aT2, aTmid, aTwoPI, aTolPC1;
+  Standard_Real aU1, aV1, aU2, aV2;
+  TopAbs_State aIn1, aIn2;
+  GeomAbs_SurfaceType aTS1, aTS2;
+  gp_Pnt aPmid;
+  gp_Pnt2d aP2D;
+  GeomInt_RealWithFlag *pVtx;
+  //-------------------------------------1
+  aTwoPI=M_PI+M_PI;
+  aTolPC=Precision::PConfusion();
+  aNbVtxWas=GeomInt_LineTool::NbVertex(aLine);
+  
+  aNbVtx=aNbVtxWas+2;
+  //-------------------------------------2
+  aTS1=myHS1->GetType();
+  aTS2=myHS2->GetType();
+  //
+  // About the value aTolPC1=1000.*aTolPC,
+  // see IntPatch_GLine.cxx, line:398
+  // for more details;
+  aTolPC1=1000.*aTolPC; 
+  //-------------------------------------
+  //
+  pVtx=new GeomInt_RealWithFlag [aNbVtx];
+  //
+  pVtx[0].SetValue(0.);
+  pVtx[1].SetValue(aTwoPI);
+  //
+  for(i=1; i<=aNbVtxWas; ++i) {
+    aT=GeomInt_LineTool::Vertex(aLine, i).ParameterOnLine();
+    aT=AdjustOnPeriod(aT, aTwoPI);
+    pVtx[i+1].SetValue(aT);
+  }
+  //
+  SortShell(aNbVtx, pVtx);
+  //
+  RejectNearBeacons(aNbVtx, pVtx, aTolPC1, aTS1, aTS2);
+  //
+  RejectDuplicates(aNbVtx, pVtx, aTolPC);
+  //
+  if ((aType==IntPatch_Circle || aType==IntPatch_Ellipse)&& aNbVtx>2) { // zz
+    bFound=Standard_False;
+    for(i=1; i<=aNbVtxWas; ++i) {
+      aT=GeomInt_LineTool::Vertex(aLine, i).ParameterOnLine();
+      if (fabs(aT) < aTolPC1 || fabs(aT-aTwoPI) < aTolPC1) {
+        bFound=!bFound;
+        break;
+      }
+    }
+    if (!bFound) {
+      aT=pVtx[1].Value()+aTwoPI;
+      pVtx[aNbVtx-1].SetValue(aT);
+      //
+      for(i=0; i<aNbVtx; ++i) { 
+        aT=pVtx[i+1].Value();
+        pVtx[i].SetValue(aT);
+      }
+      --aNbVtx;
+    }
+  }
+  //
+  for(i=0; i<aNbVtx-1; ++i) { 
+    aT1=pVtx[i].Value();
+    aT2=pVtx[i+1].Value();
+    aTmid=(aT1+aT2)*0.5;
+    GLinePoint(aType, aGLine, aTmid, aPmid);
+    //
+    Parameters(myHS1, myHS2, aPmid, aU1, aV1, aU2, aV2);
+    Recadre(myHS1, myHS2, aU1, aV1, aU2, aV2);
+    //
+    aP2D.SetCoord(aU1, aV1);
+    aIn1=myDom1->Classify(aP2D, aTol);
+    if(aIn1 !=  TopAbs_OUT) { 
+      aP2D.SetCoord(aU2, aV2);
+      aIn2=myDom2->Classify(aP2D, aTol);
+      if(aIn2 != TopAbs_OUT) { 
+        seqp.Append(aT1);
+        seqp.Append(aT2);
+      }
+    }
+  }
+  //
+  delete [] pVtx;
+}
+//=======================================================================
+//function : RejectNearBeacons
+//purpose  : Reject the thickenings near the beacon points (if exist)
+//           The gifts, made by sweep algo.  
+//           chl/930/B5 B8 C2 C5 E2 E5 E8 F2 G8 H2 H5 H8
+//=======================================================================
+void RejectNearBeacons(Standard_Integer& aNbVtx, 
+                       GeomInt_RealWithFlag *pVtx, 
+                       Standard_Real aTolPC1,
+                       const GeomAbs_SurfaceType aTS1,
+                       const GeomAbs_SurfaceType aTS2) 
+{
+  Standard_Integer i, j, iBcn;
+  Standard_Real aT, aBcn[2];
+  //
+  if (aTS1==GeomAbs_Cylinder && aTS2==GeomAbs_Cylinder) {
+    aBcn[0]=0.5*M_PI;
+    aBcn[1]=1.5*M_PI;
+    //
+    for (j=0; j<2; ++j) {
+      iBcn=-1;
+      for(i=0; i<aNbVtx; ++i) {
+        aT=pVtx[i].Value();
+        if (aT==aBcn[j]) {
+          iBcn=i;
+          break;
+        }
+      }
+      //
+      if (iBcn<0) {
+        // The beacon is not found
+        continue;
+      }
+      //  
+      for(i=0; i<aNbVtx; ++i) {
+        if (i!=iBcn) {
+          aT=pVtx[i].Value();
+          if (fabs(aT-aBcn[j]) < aTolPC1) {
+            pVtx[i].SetFlag(0);
           }
         }
       }
+    }// for (j=0; j<2; ++j) {
+    //------------------------------------------
+    j=0;
+    for(i=0; i<aNbVtx; ++i) {
+      if (pVtx[i].Flag()) {
+        pVtx[j]=pVtx[i];
+        ++j;
+      }
+    }
+    aNbVtx=j;
+  }// if (aTS1==GeomAbs_Cylinder && aTS2==GeomAbs_Cylinder) {
+}
+
+//=======================================================================
+//function : RejectDuplicates
+//purpose  : 
+//=======================================================================
+void RejectDuplicates(Standard_Integer& aNbVtx, 
+                      GeomInt_RealWithFlag *pVtx, 
+                      Standard_Real aTolPC) 
+{
+  Standard_Integer i, j;
+  Standard_Real dX, aT1, aT2; 
+  //
+  for(i=0; i<aNbVtx-1; ++i) {
+    aT2=pVtx[i+1].Value();
+    aT1=pVtx[i].Value();
+    dX=aT2-aT1;
+    if (dX<aTolPC) {
+      pVtx[i+1].SetFlag(0);
     }
-    if (changevtx) {
-      thevtx.SetParameter(prm + 2.*M_PI);
-      glin->Replace(i,thevtx);
+  }
+  //
+  j=0;
+  for(i=0; i<aNbVtx; ++i) {
+    if (pVtx[i].Flag()) {
+      pVtx[j]=pVtx[i];
+      ++j;
     }
   }
+  aNbVtx=j;
+}
+//=======================================================================
+//function : AdjustOnPeriod
+//purpose  : 
+//=======================================================================
+Standard_Real AdjustOnPeriod(const Standard_Real aTr,
+                             const Standard_Real aPeriod)
+{
+  Standard_Integer k;
+  Standard_Real aT;
+  //
+  aT=aTr;
+  if (aT<0.) {
+    k=-(Standard_Integer)(aT/aPeriod)+1;
+    aT=aT+k*aPeriod;
+  }
+  //
+  if (!(aT>=0. && aT<=aPeriod)) {
+    k=(Standard_Integer)(aT/aPeriod);
+    aT=aT-k*aPeriod;
+  }
+  //
+  return aT;
+}
+//=======================================================================
+//function : RejectMicroCrcles
+//purpose  : 
+//=======================================================================
+Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
+                                   const IntPatch_IType aType,
+                                   const Standard_Real aTol3D)
+{
+  Standard_Boolean bRet;
+  Standard_Real aR;
+  //
+  bRet=Standard_False;
+  //
+  if (aType==IntPatch_Circle) {
+    aR=aGLine->Circle().Radius();
+    bRet=(aR<aTol3D);
+  }
+  else if (aType==IntPatch_Ellipse) {
+    aR=aGLine->Ellipse().MajorRadius();
+    bRet=(aR<aTol3D);
+  }
+  return bRet;
+}
+//=======================================================================
+// function: SortShell
+// purpose : 
+//=======================================================================
+void SortShell(const Standard_Integer n, 
+               GeomInt_RealWithFlag *a) 
+{
+  Standard_Integer nd, i, j, l, d=1;
+  GeomInt_RealWithFlag x;
+  //
+  while(d<=n) {
+    d*=2;
+  }
+  //
+  while (d) {
+    d=(d-1)/2;
+    //
+    nd=n-d;
+    for (i=0; i<nd; ++i) {
+      j=i;
+    m30:;
+      l=j+d;
+      if (a[l] < a[j]){
+        x=a[j];
+        a[j]=a[l];
+        a[l]=x;
+        j-=d;
+        if (j > -1) goto m30;
+      }//if (a[l] < a[j]){
+    }//for (i=0; i<nd; ++i) 
+  }//while (1)
 }
index aacf176..1f04f67 100644 (file)
@@ -63,7 +63,7 @@ is
 
     class  FClass2d;
 
-    class  LineConstructor;
+    --class  LineConstructor;
 
     -----
     class MarkedRangeSet;
index e90c382..16527e7 100644 (file)
@@ -57,6 +57,7 @@
 #include <BndLib_Add3dCurve.hxx>
 #include <ElCLib.hxx>
 #include <ElSLib.hxx>
+#include <GeomInt.hxx>
 
 static Standard_Boolean SetEmptyResultRange(const Standard_Real      theParameter, 
                                             IntTools_MarkedRangeSet& theMarkedRange);
@@ -651,7 +652,7 @@ void IntTools_BeanFaceIntersector::ComputeAroundExactIntersection()
               aUPeriod = mySurface.UPeriod();
               aEps = Epsilon(aUPeriod);
               //
-              IntTools_Tools::AdjustPeriodic(U, myUMinParameter, myUMaxParameter, 
+              GeomInt::AdjustPeriodic(U, myUMinParameter, myUMaxParameter, 
                                              aUPeriod, aNewU, du, aEps);
               solutionIsValid = Standard_True;
               bUCorrected = Standard_True;
@@ -668,7 +669,7 @@ void IntTools_BeanFaceIntersector::ComputeAroundExactIntersection()
               aVPeriod = mySurface.VPeriod();
               aEps = Epsilon(aVPeriod);
               //
-              IntTools_Tools::AdjustPeriodic(V, myVMinParameter, myVMaxParameter, 
+              GeomInt::AdjustPeriodic(V, myVMinParameter, myVMaxParameter, 
                                              aVPeriod, aNewV, dv, aEps);
               solutionIsValid = Standard_True;
               V = aNewV;
index c677d2b..a08e077 100644 (file)
@@ -45,6 +45,7 @@
 #include <TColStd_DataMapOfIntegerInteger.hxx>
 #include <TColgp_SequenceOfVec2d.hxx>
 #include <IntTools_Tools.hxx>
+#include <GeomInt.hxx>
 
 //=======================================================================
 //function : IntTools_FClass2d:IntTools:_FClass2d
@@ -554,11 +555,11 @@ IntTools_FClass2d::IntTools_FClass2d()
   if (RecadreOnPeriodic) {
     Standard_Real du, dv;
     if (IsUPer) {
-      IntTools_Tools::AdjustPeriodic(uu, Umin, Umax, uperiod, uu, du);
+      GeomInt::AdjustPeriodic(uu, Umin, Umax, uperiod, uu, du);
     }// if (IsUPer) {
     //
     if (IsVPer) {
-      IntTools_Tools::AdjustPeriodic(vv, Vmin, Vmax, vperiod, vv, dv);
+      GeomInt::AdjustPeriodic(vv, Vmin, Vmax, vperiod, vv, dv);
     }//if (IsVPer) {
   }
   //
@@ -685,11 +686,11 @@ IntTools_FClass2d::IntTools_FClass2d()
   if (RecadreOnPeriodic) {
     Standard_Real du, dv;
     if (IsUPer) {
-      IntTools_Tools::AdjustPeriodic(uu, Umin, Umax, uperiod, uu, du);
+      GeomInt::AdjustPeriodic(uu, Umin, Umax, uperiod, uu, du);
     }// if (IsUPer) {
     //
     if (IsVPer) {
-      IntTools_Tools::AdjustPeriodic(vv, Vmin, Vmax, vperiod, vv, dv);
+      GeomInt::AdjustPeriodic(vv, Vmin, Vmax, vperiod, vv, dv);
     }//if (IsVPer) {
   }
   //
index 129b587..ef9573c 100644 (file)
@@ -26,7 +26,7 @@ uses
     Intersection          from IntPatch,
     Face                  from TopoDS,
     SequenceOfCurves      from IntTools,
-    LineConstructor       from IntTools,
+    LineConstructor       from GeomInt,
     SequenceOfPntOn2Faces from IntTools, 
     Context from IntTools
     
@@ -148,7 +148,7 @@ fields
  
     myIsDone       : Boolean         from Standard;
     myIntersector  : Intersection    from IntPatch;
-    myLConstruct   : LineConstructor from IntTools;
+    myLConstruct   : LineConstructor from GeomInt;
     myHS1          : HSurface        from GeomAdaptor;
     myHS2          : HSurface        from GeomAdaptor;
     myNbrestr      : Integer         from Standard;
index dc358b7..d31012b 100644 (file)
 #include <IntTools_PntOn2Faces.hxx>
 #include <IntTools_Context.hxx>
 #include <IntSurf_ListIteratorOfListOfPntOn2S.hxx>
+#include <GeomInt.hxx>
 
 static
   void RefineVector(gp_Vec2d& aV2D);
@@ -175,7 +176,7 @@ static
                                         const Handle(GeomAdaptor_HSurface)&            theSurface2,
                                         const TopoDS_Face&                             theFace1,
                                         const TopoDS_Face&                             theFace2,
-                                        const IntTools_LineConstructor&                theLConstructor,
+                                        const GeomInt_LineConstructor&                 theLConstructor,
                                         const Standard_Boolean                         theAvoidLConstructor,
                                         IntPatch_SequenceOfLine&                       theNewLines,
                                         Standard_Real&                                 theReachedTol3d,
@@ -2407,7 +2408,7 @@ void BuildPCurves (Standard_Real f,
     U0 = pm.X();
     //
     bAdjust = 
-      IntTools_Tools::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps);
+      GeomInt::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps);
     if (bAdjust) {
       gp_Vec2d T1(du, 0.);
       C2d->Translate(T1);
@@ -3561,7 +3562,7 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
                                       const Handle(GeomAdaptor_HSurface)&            theSurface2,
                                       const TopoDS_Face&                             theFace1,
                                       const TopoDS_Face&                             theFace2,
-                                      const IntTools_LineConstructor&                theLConstructor,
+                                      const GeomInt_LineConstructor&                 theLConstructor,
                                       const Standard_Boolean                         theAvoidLConstructor,
                                       IntPatch_SequenceOfLine&                       theNewLines,
                                       Standard_Real&                                 theReachedTol3d,
@@ -3649,7 +3650,7 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
           aParameter=V;
         }
         
-        IntTools_Tools::AdjustPeriodic(aParameter, 
+        GeomInt::AdjustPeriodic(aParameter, 
                                        alowerboundary, 
                                        aupperboundary, 
                                        aPeriod,
@@ -3791,7 +3792,7 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
           else {
             Standard_Real aPeriod     = (parit == 0) ? aGASurface->UPeriod() : aGASurface->VPeriod();
             Standard_Real anoffset, anAdjustPar;
-            IntTools_Tools::AdjustPeriodic(aParameter, alowerboundary, aupperboundary,
+            GeomInt::AdjustPeriodic(aParameter, alowerboundary, aupperboundary,
                                            aPeriod, anAdjustPar, anoffset);
 
             bIsPointOnBoundary=
@@ -3856,7 +3857,7 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
             Standard_Real aPeriod     = (bIsUBoundary) ? aGASurface->UPeriod() : aGASurface->VPeriod();
             Standard_Real aParameter = (bIsUBoundary) ? U : V;
             Standard_Real anoffset, anAdjustPar;
-            IntTools_Tools::AdjustPeriodic(aParameter, alowerboundary, aupperboundary, 
+            GeomInt::AdjustPeriodic(aParameter, alowerboundary, aupperboundary, 
                                            aPeriod, anAdjustPar, anoffset);
 
             Standard_Real adist = (bIsFirstBoundary) ? fabs(anAdjustPar - alowerboundary) : fabs(anAdjustPar - aupperboundary);
diff --git a/src/IntTools/IntTools_LineConstructor.cdl b/src/IntTools/IntTools_LineConstructor.cdl
deleted file mode 100644 (file)
index 4157b4b..0000000
+++ /dev/null
@@ -1,100 +0,0 @@
--- Created on: 1995-02-07
--- Created by: Jacques GOUSSARD
--- Copyright (c) 1995-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
-class LineConstructor from IntTools
-
-        ---Purpose: Splits given Line.
-        --          Class provides post-processing of results of
-        --          surfaces intersection
-
-uses Line           from IntPatch,
-     TopolTool      from Adaptor3d,
-     HSurface       from GeomAdaptor,
-     SequenceOfReal from TColStd
-
-
-raises NotDone    from StdFail,
-       OutOfRange from Standard
-
-is
-
-    Create
-       returns LineConstructor from IntTools;
-       ---C++: inline
-       ---Purpose: 
-       --- Empty constructor
-       ---
-
-    Load(me: in out; D1,D2: TopolTool from Adaptor3d;
-                     S1,S2: HSurface  from GeomAdaptor)
-       is static;
-       ---C++: inline
-       ---Purpose:
-       --- Initializes me by two surfaces and corresponding
-       --- tools which represent boundaries of surfaces
-       ---
-
-    Perform(me: in out; L: Line from IntPatch)
-       is static;
-       ---Purpose:
-       --- Splits line
-       ---
-
-    IsDone(me)
-       returns Boolean from Standard
-       is static;
-       ---C++: inline
-       ---Purpose:
-       --- Returns True if splitting was successful
-       ---
-
-    NbParts(me)
-       returns Integer from Standard
-       raises NotDone from StdFail
-       is static;
-       ---C++: inline
-       ---Purpose:
-       --- Returns number of splits
-       ---
-
-    Part(me; I: Integer from Standard; WFirst,WLast: out Real from Standard) 
-       raises NotDone    from StdFail,
-               OutOfRange from Standard
-       is static;
-       ---C++: inline
-       ---Purpose:
-       --- Return first and last parameters 
-       --- for given index of split
-       ---
-
-    ---PeriodicLine(me; L: Line from IntPatch)
-    ---        is protected;
-    TreatCircle(me:out; 
-           aLine : Line from IntPatch; 
-           aTol: Real from Standard)
-       is protected; 
-       
-fields
-    
-    done  : Boolean        from Standard;
-    seqp  : SequenceOfReal from TColStd;
-    myDom1: TopolTool      from Adaptor3d;
-    myDom2: TopolTool      from Adaptor3d;
-    myHS1 : HSurface       from GeomAdaptor;
-    myHS2 : HSurface       from GeomAdaptor;    
-
-end LineConstructor;
diff --git a/src/IntTools/IntTools_LineConstructor.cxx b/src/IntTools/IntTools_LineConstructor.cxx
deleted file mode 100644 (file)
index 690c3bf..0000000
+++ /dev/null
@@ -1,982 +0,0 @@
-// Created on: 1995-02-07
-// Created by: Jacques GOUSSARD
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <IntTools_LineConstructor.ixx>
-
-#include <GeomInt_LineTool.hxx>
-#include <GeomInt_SequenceOfParameterAndOrientation.hxx>
-#include <GeomInt_ParameterAndOrientation.hxx>
-
-#include <IntPatch_Point.hxx>
-#include <IntPatch_GLine.hxx>
-#include <IntPatch_WLine.hxx>
-#include <IntPatch_ALine.hxx>
-#include <IntSurf_Transition.hxx>
-#include <TopAbs_Orientation.hxx>
-
-
-#include <Precision.hxx>
-
-#include <gp_Pnt2d.hxx>
-
-#include <Adaptor2d_HCurve2d.hxx>
-
-#include <GeomAdaptor_HSurface.hxx>
-#include <Standard_ConstructionError.hxx>
-#include <IntSurf_Quadric.hxx>
-#include <IntSurf_PntOn2S.hxx>
-#include <ElCLib.hxx>
-#include <GeomAbs_SurfaceType.hxx>
-#include <TColStd_IndexedMapOfInteger.hxx>
-#include <IntTools_Tools.hxx>
-
-static
-  void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
-                  const gp_Pnt& Ptref,
-                  Standard_Real& U1,
-                  Standard_Real& V1);
-static
-  void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
-                  const Handle(GeomAdaptor_HSurface)& myHS2,
-                  const gp_Pnt& Ptref,
-                  Standard_Real& U1,
-                  Standard_Real& V1,
-                  Standard_Real& U2,
-                  Standard_Real& V2);
-
-static 
-  void GLinePoint(const IntPatch_IType typl,
-                  const Handle(IntPatch_GLine)& GLine,
-                  const Standard_Real aT,
-                  gp_Pnt& aP);
-static
-  void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
-               const Handle(GeomAdaptor_HSurface)& myHS2,
-               Standard_Real& u1,
-               Standard_Real& v1,
-               Standard_Real& u2,
-               Standard_Real& v2);
-
-//=======================================================================
-//function : Perform
-//purpose  : 
-//=======================================================================
-void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
-{
-  Standard_Integer i,nbvtx;
-  Standard_Real firstp,lastp;
-  const Standard_Real Tol = Precision::PConfusion() * 35.0;
-  
-  const IntPatch_IType typl = L->ArcType();
-  if(typl == IntPatch_Analytic)  {
-    Standard_Real u1,v1,u2,v2;
-    Handle(IntPatch_ALine)& ALine =  *((Handle(IntPatch_ALine) *)&L);
-    seqp.Clear();
-    nbvtx = GeomInt_LineTool::NbVertex(L);
-    for(i=1;i<nbvtx;i++)   {
-      firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
-      lastp =  GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
-      if(firstp!=lastp)      {
-        const Standard_Real pmid = (firstp+lastp)*0.5;
-        const gp_Pnt Pmid = ALine->Value(pmid);
-        Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
-        Recadre(myHS1,myHS2,u1,v1,u2,v2);
-        const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-        if(in1 !=  TopAbs_OUT) {
-          const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-          if(in2 != TopAbs_OUT) { 
-            seqp.Append(firstp);
-            seqp.Append(lastp);
-          }
-        }
-      }
-    }
-    done = Standard_True;
-    return;
-  } // if(typl == IntPatch_Analytic)  {
-  else if(typl == IntPatch_Walking)  {
-    Standard_Real u1,v1,u2,v2;
-    Handle(IntPatch_WLine)& WLine =  *((Handle(IntPatch_WLine) *)&L);
-    seqp.Clear();
-    nbvtx = GeomInt_LineTool::NbVertex(L);
-    for(i=1;i<nbvtx;i++)    { 
-      firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
-      lastp =  GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
-      if(firstp!=lastp) { 
-        if(lastp != firstp+1)  {
-          const Standard_Integer pmid = (Standard_Integer )( (firstp+lastp)/2);
-          const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
-          Pmid.Parameters(u1,v1,u2,v2);
-          Recadre(myHS1,myHS2,u1,v1,u2,v2);
-          const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-          if(in1 !=  TopAbs_OUT) {   
-            const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-            if(in2 != TopAbs_OUT) {   
-              seqp.Append(firstp);
-              seqp.Append(lastp);
-            }
-          }
-        }
-        else {
-          const IntSurf_PntOn2S& Pfirst = WLine->Point((Standard_Integer)(firstp));
-          Pfirst.Parameters(u1,v1,u2,v2);
-          Recadre(myHS1,myHS2,u1,v1,u2,v2);
-          TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-          if(in1 !=  TopAbs_OUT) {  //-- !=ON donne Pb 
-            TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-            if(in2 != TopAbs_OUT) { //-- !=ON  
-              const IntSurf_PntOn2S& Plast = WLine->Point((Standard_Integer)(lastp));
-              Plast.Parameters(u1,v1,u2,v2);
-              Recadre(myHS1,myHS2,u1,v1,u2,v2);
-              in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-              if(in1 !=  TopAbs_OUT) {  //-- !=ON donne Pb 
-                in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-                if(in2 != TopAbs_OUT) {
-                  seqp.Append(firstp);
-                  seqp.Append(lastp);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    //
-    // The One resulting curve consists of 7 segments that are 
-    // connected between each other.
-    // The aim of the block is to reject these segments and have
-    // one segment instead of 7. 
-    //     The other reason to do that is value of TolReached3D=49.
-    //     Why -? It is not known yet. 
-    //                                             PKV 22.Apr.2002
-    //
-    Standard_Integer aNbParts;
-    //
-    aNbParts = seqp.Length()/2;
-    if (aNbParts > 1) {  
-      Standard_Boolean bCond;
-      GeomAbs_SurfaceType aST1, aST2;
-      aST1 = myHS1->Surface().GetType();
-      aST2 = myHS2->Surface().GetType();
-      //
-      bCond=Standard_False;
-      if (aST1==GeomAbs_Plane) {
-        if (aST2==GeomAbs_SurfaceOfExtrusion || 
-            aST2==GeomAbs_SurfaceOfRevolution) {//+zft
-          bCond=!bCond;
-        }
-      }
-      else if (aST2==GeomAbs_Plane) {
-        if (aST1==GeomAbs_SurfaceOfExtrusion || 
-            aST1==GeomAbs_SurfaceOfRevolution) {//+zft
-          bCond=!bCond;
-        }
-      }
-      //
-      if (bCond) {
-        Standard_Integer aNb, anIndex, aNbTmp, jx;
-        TColStd_IndexedMapOfInteger aMap;
-        TColStd_SequenceOfReal aSeqTmp;
-        //
-        aNb=seqp.Length();
-        for(i=1; i<=aNb; ++i) {
-          lastp =seqp(i);
-          anIndex=(Standard_Integer)lastp;
-          if (!aMap.Contains(anIndex)){
-            aMap.Add(anIndex);
-            aSeqTmp.Append(lastp);
-          }
-          else {
-            aNbTmp=aSeqTmp.Length();
-            aSeqTmp.Remove(aNbTmp);
-          }
-        }
-        //
-        seqp.Clear();
-        //
-        aNb=aSeqTmp.Length()/2;
-        for(i=1; i<=aNb;++i) {
-          jx=2*i;
-          firstp=aSeqTmp(jx-1);
-          lastp =aSeqTmp(jx);
-          seqp.Append(firstp);
-          seqp.Append(lastp);
-        }
-      }//if (bCond) {
-    }
-    done = Standard_True;
-    return;
-  }// else if(typl == IntPatch_Walking)  {
-  //
-  //-----------------------------------------------------------
-  else if (typl != IntPatch_Restriction)  {
-    seqp.Clear();
-    //
-    Handle(IntPatch_GLine)& GLine =  *((Handle(IntPatch_GLine) *)&L);
-    //
-    if(typl == IntPatch_Circle || typl == IntPatch_Ellipse) { 
-      TreatCircle(L, Tol);
-      done=Standard_True;
-      return;
-    }
-    //----------------------------
-    Standard_Boolean intrvtested;
-    Standard_Real u1,v1,u2,v2;
-    //
-    nbvtx = GeomInt_LineTool::NbVertex(L);
-    intrvtested = Standard_False;
-    for(i=1; i<nbvtx; ++i) { 
-      firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
-      lastp =  GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
-      if(Abs(firstp-lastp)>Precision::PConfusion()) {
-        intrvtested = Standard_True;
-        const Standard_Real pmid = (firstp+lastp)*0.5;
-        gp_Pnt Pmid;
-        GLinePoint(typl, GLine, pmid, Pmid);
-        //
-        Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
-        Recadre(myHS1,myHS2,u1,v1,u2,v2);
-        const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
-        if(in1 !=  TopAbs_OUT) { 
-          const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
-          if(in2 != TopAbs_OUT) { 
-            seqp.Append(firstp);
-            seqp.Append(lastp);
-          }
-        }
-      }
-    }
-    //
-    if (!intrvtested) {
-      // Keep a priori. A point 2d on each
-      // surface is required to make the decision. Will be done in the caller
-      seqp.Append(GeomInt_LineTool::FirstParameter(L));
-      seqp.Append(GeomInt_LineTool::LastParameter(L));
-    }
-    //
-    done =Standard_True;
-    return;
-  } // else if (typl != IntPatch_Restriction)  { 
-
-  done = Standard_False;
-  seqp.Clear();
-  nbvtx = GeomInt_LineTool::NbVertex(L);
-  if (nbvtx == 0) { // Keep a priori. Point 2d is required on each
-                    // surface to make the decision. Will be done in the caller
-    seqp.Append(GeomInt_LineTool::FirstParameter(L));
-    seqp.Append(GeomInt_LineTool::LastParameter(L));
-    done = Standard_True;
-    return;
-  }
-
-  GeomInt_SequenceOfParameterAndOrientation seqpss;
-  TopAbs_Orientation or1=TopAbs_FORWARD,or2=TopAbs_FORWARD;
-
-  for (i=1; i<=nbvtx; i++)  {
-    const IntPatch_Point& thevtx = GeomInt_LineTool::Vertex(L,i);
-    const Standard_Real prm = thevtx.ParameterOnLine();
-    if (thevtx.IsOnDomS1())    {
-      switch (thevtx.TransitionLineArc1().TransitionType())      {
-        case IntSurf_In:        or1 = TopAbs_FORWARD; break;  
-        case IntSurf_Out:       or1 = TopAbs_REVERSED; break;  
-        case IntSurf_Touch:     or1 = TopAbs_INTERNAL; break;  
-        case IntSurf_Undecided: or1 = TopAbs_INTERNAL; break;  
-      }
-    }
-    else {
-      or1 = TopAbs_INTERNAL;
-    }
-    
-    if (thevtx.IsOnDomS2())    {
-      switch (thevtx.TransitionLineArc2().TransitionType())      {
-        case IntSurf_In:        or2 = TopAbs_FORWARD; break;
-        case IntSurf_Out:       or2 = TopAbs_REVERSED; break;
-        case IntSurf_Touch:     or2 = TopAbs_INTERNAL; break;
-        case IntSurf_Undecided: or2 = TopAbs_INTERNAL; break;
-      }
-    }
-    else {
-      or2 = TopAbs_INTERNAL;
-    }
-    //
-    const Standard_Integer nbinserted = seqpss.Length();
-    Standard_Boolean inserted = Standard_False;
-    for (Standard_Integer j=1; j<=nbinserted;j++)    {
-      if (Abs(prm-seqpss(j).Parameter()) <= Tol)      {
-        // accumulate
-        GeomInt_ParameterAndOrientation& valj = seqpss.ChangeValue(j);
-        if (or1 != TopAbs_INTERNAL) {
-          if (valj.Orientation1() != TopAbs_INTERNAL) {
-            if (or1 != valj.Orientation1()) {
-              valj.SetOrientation1(TopAbs_INTERNAL);
-            }
-          }
-          else {
-            valj.SetOrientation1(or1);
-          }
-        }
-        
-        if (or2 != TopAbs_INTERNAL) {
-          if (valj.Orientation2() != TopAbs_INTERNAL) {
-            if (or2 != valj.Orientation2()) {
-              valj.SetOrientation2(TopAbs_INTERNAL);
-            }
-          }
-          else {
-            valj.SetOrientation2(or2);
-          }
-        }          
-        inserted = Standard_True;
-        break;
-      }
-      
-      if (prm < seqpss(j).Parameter()-Tol ) {
-        // insert before position j
-        seqpss.InsertBefore(j,GeomInt_ParameterAndOrientation(prm,or1,or2));
-        inserted = Standard_True;
-        break;
-      }
-      
-    }
-    if (!inserted) {
-      seqpss.Append(GeomInt_ParameterAndOrientation(prm,or1,or2));
-    }
-  }
-
-  // determine the state at the beginning of line
-  Standard_Boolean trim = Standard_False;
-  Standard_Boolean dansS1 = Standard_False;
-  Standard_Boolean dansS2 = Standard_False;
-
-  nbvtx = seqpss.Length();
-  for (i=1; i<= nbvtx; i++)  {
-    or1 = seqpss(i).Orientation1();
-    if (or1 != TopAbs_INTERNAL)    {
-      trim = Standard_True;
-      dansS1 = (or1 != TopAbs_FORWARD);
-      break;
-    }
-  }
-  
-  if (i > nbvtx)  {
-    Standard_Real U,V;
-    for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ )    {
-      if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS1() )      {
-        GeomInt_LineTool::Vertex(L,i).ParametersOnS1(U,V);
-        gp_Pnt2d PPCC(U,V);
-        if (myDom1->Classify(PPCC,Tol) == TopAbs_OUT) {
-          done = Standard_True;
-          return;
-        }
-        break;
-      }
-    }
-    dansS1 = Standard_True; // Keep in doubt
-  }
-  //
-  for (i=1; i<= nbvtx; i++)  {
-    or2 = seqpss(i).Orientation2();
-    if (or2 != TopAbs_INTERNAL)    {
-      trim = Standard_True;
-      dansS2 = (or2 != TopAbs_FORWARD);
-      break;
-    }
-  }
-  
-  if (i > nbvtx)  {
-    Standard_Real U,V;
-    for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ )    {
-      if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS2() )      {
-        GeomInt_LineTool::Vertex(L,i).ParametersOnS2(U,V);
-        if (myDom2->Classify(gp_Pnt2d(U,V),Tol) == TopAbs_OUT) {
-          done = Standard_True;
-          return;
-        }
-        break;
-      }
-    }
-    dansS2 = Standard_True; //  Keep in doubt
-  }
-
-  if (!trim) { // necessarily dansS1 == dansS2 == Standard_True
-    seqp.Append(GeomInt_LineTool::FirstParameter(L));
-    seqp.Append(GeomInt_LineTool::LastParameter(L));
-    done = Standard_True;
-    return;
-  }
-
-  // sequence seqpss is peeled to create valid ends 
-  // and store them in seqp(2*i+1) and seqp(2*i+2)
-  Standard_Real thefirst = GeomInt_LineTool::FirstParameter(L);
-  Standard_Real thelast = GeomInt_LineTool::LastParameter(L);
-  firstp = thefirst;
-
-  for (i=1; i<=nbvtx; i++)  {
-    or1 = seqpss(i).Orientation1(); 
-    or2 = seqpss(i).Orientation2(); 
-    if (dansS1 && dansS2)    {
-      if (or1 == TopAbs_REVERSED){
-        dansS1 = Standard_False;
-      }
-      
-      if (or2 == TopAbs_REVERSED){
-        dansS2 = Standard_False;
-      }
-      if (!dansS1 || !dansS2)      {
-        lastp = seqpss(i).Parameter();
-        Standard_Real stofirst = Max(firstp, thefirst);
-        Standard_Real stolast  = Min(lastp,  thelast) ;
-
-        if (stolast > stofirst) {
-          seqp.Append(stofirst);
-          seqp.Append(stolast);
-        }
-        if (lastp > thelast) {
-          break;
-        }
-      }
-    }
-    else    {
-      if (dansS1)      {
-        if (or1 == TopAbs_REVERSED) {
-          dansS1 = Standard_False;
-        }
-      }
-      else      {
-        if (or1 == TopAbs_FORWARD){
-          dansS1 = Standard_True;
-        }
-      }
-      if (dansS2) {
-        if (or2 == TopAbs_REVERSED) {
-          dansS2 = Standard_False;
-        }
-      }
-      else {
-        if (or2 == TopAbs_FORWARD){
-          dansS2 = Standard_True;
-        }
-      }
-      if (dansS1 && dansS2){
-        firstp = seqpss(i).Parameter();
-      }
-    }
-  }
-  //
-  // finally to add
-  if (dansS1 && dansS2)  {
-    lastp  = thelast;
-    firstp = Max(firstp,thefirst);
-    if (lastp > firstp) {
-      seqp.Append(firstp);
-      seqp.Append(lastp);
-    }
-  }
-  done = Standard_True;
-}
-//=======================================================================
-//function : Recadre
-//purpose  : 
-//=======================================================================
-void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
-             const Handle(GeomAdaptor_HSurface)& myHS2,
-             Standard_Real& u1,
-             Standard_Real& v1,
-             Standard_Real& u2,
-             Standard_Real& v2)
-{ 
-  Standard_Boolean myHS1IsUPeriodic,myHS1IsVPeriodic;
-  const GeomAbs_SurfaceType typs1 = myHS1->GetType();
-  switch (typs1)
-  { 
-    case GeomAbs_Cylinder:
-    case GeomAbs_Cone:
-    case GeomAbs_Sphere: 
-    { 
-      myHS1IsUPeriodic = Standard_True;
-      myHS1IsVPeriodic = Standard_False;
-      break;
-    }
-    case GeomAbs_Torus:
-    {
-      myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_True;
-      break;
-    }
-    default:
-    {
-      //-- Case of periodic biparameters is processed upstream
-      myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_False;
-      break;
-    }
-  }
-  Standard_Boolean myHS2IsUPeriodic,myHS2IsVPeriodic;
-  const GeomAbs_SurfaceType typs2 = myHS2->GetType();
-  switch (typs2)
-  { 
-    case GeomAbs_Cylinder:
-    case GeomAbs_Cone:
-    case GeomAbs_Sphere: 
-    { 
-      myHS2IsUPeriodic = Standard_True;
-      myHS2IsVPeriodic = Standard_False;
-      break;
-    }
-    case GeomAbs_Torus:
-    {
-      myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_True;
-      break;
-    }
-    default:
-    {
-      //-- Case of periodic biparameters is processed upstream
-      myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_False;
-      break;
-    }
-  }
-  Standard_Real du, dv;
-  //
-  if(myHS1IsUPeriodic) {
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS1->UPeriod();
-    const Standard_Real f = myHS1->FirstUParameter();
-    const Standard_Real l = myHS1->LastUParameter();
-    IntTools_Tools::AdjustPeriodic(u1, f, l, lmf, u1, du);
-  }
-  if(myHS1IsVPeriodic) {
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS1->VPeriod(); 
-    const Standard_Real f = myHS1->FirstVParameter();
-    const Standard_Real l = myHS1->LastVParameter();
-    IntTools_Tools::AdjustPeriodic(v1, f, l, lmf, v1, dv);
-  }
-  if(myHS2IsUPeriodic) { 
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS2->UPeriod();
-    const Standard_Real f = myHS2->FirstUParameter();
-    const Standard_Real l = myHS2->LastUParameter();
-    IntTools_Tools::AdjustPeriodic(u2, f, l, lmf, u2, du);
-  }
-  if(myHS2IsVPeriodic) { 
-    const Standard_Real lmf = M_PI+M_PI; //-- myHS2->VPeriod();
-    const Standard_Real f = myHS2->FirstVParameter();
-    const Standard_Real l = myHS2->LastVParameter();
-    IntTools_Tools::AdjustPeriodic(v2, f, l, lmf, v2, dv);
-  }
-}
-//=======================================================================
-//function : Parameters
-//purpose  : 
-//=======================================================================
-void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
-                const Handle(GeomAdaptor_HSurface)& myHS2,
-                const gp_Pnt& Ptref,
-                Standard_Real& U1,
-                Standard_Real& V1,
-                Standard_Real& U2,
-                Standard_Real& V2)
-{
-  Parameters(myHS1, Ptref, U1, V1);
-  Parameters(myHS2, Ptref, U2, V2);
-}
-//=======================================================================
-//function : Parameter
-//purpose  : 
-//=======================================================================
-void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
-                const gp_Pnt& Ptref,
-                Standard_Real& U1,
-                Standard_Real& V1)
-{
-  IntSurf_Quadric quad1;
-  //
-  switch (myHS1->Surface().GetType())  {
-    case GeomAbs_Plane:    
-      quad1.SetValue(myHS1->Surface().Plane()); 
-      break;
-    case GeomAbs_Cylinder: 
-      quad1.SetValue(myHS1->Surface().Cylinder()); 
-      break;
-    case GeomAbs_Cone:     
-      quad1.SetValue(myHS1->Surface().Cone()); 
-      break;
-    case GeomAbs_Sphere:   
-      quad1.SetValue(myHS1->Surface().Sphere()); 
-      break;
-    case GeomAbs_Torus:
-      quad1.SetValue(myHS1->Surface().Torus()); 
-      break;
-    default: 
-      Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
-  }
-  quad1.Parameters(Ptref,U1,V1);
-}
-
-//=======================================================================
-//function : GLinePoint
-//purpose  : 
-//=======================================================================
-void GLinePoint(const IntPatch_IType typl,
-                const Handle(IntPatch_GLine)& GLine,
-                const Standard_Real aT,
-                gp_Pnt& aP)
-{
-  switch (typl) {
-    case IntPatch_Lin:       
-    aP = ElCLib::Value(aT, GLine->Line()); 
-    break;
-  case IntPatch_Circle:    
-    aP = ElCLib::Value(aT, GLine->Circle()); 
-    break;
-  case IntPatch_Ellipse:   
-    aP = ElCLib::Value(aT, GLine->Ellipse()); 
-    break;
-  case IntPatch_Hyperbola: 
-    aP = ElCLib::Value(aT, GLine->Hyperbola()); 
-    break;
-  case IntPatch_Parabola:  
-    aP = ElCLib::Value(aT, GLine->Parabola()); 
-    break;
-  default:
-    Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
-  }
-}
-
-//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-//
-//=======================================================================
-//class    : IntTools_RealWithFlag
-//purpose  : 
-//=======================================================================
-class IntTools_RealWithFlag {
- public:
-  IntTools_RealWithFlag() : 
-    myValue(-99.), myFlag(1) 
-  {
-  };
-  //
-  ~IntTools_RealWithFlag() {
-  };
-  //
-  void SetValue(const Standard_Real aT) {
-    myValue=aT;
-  };
-  //
-  Standard_Real Value() const {
-    return myValue;
-  }
-  //
-  void SetFlag(const Standard_Integer aFlag) {
-    myFlag=aFlag;
-  };
-  //
-  Standard_Integer Flag() const {
-    return myFlag;
-  }
-  //
-  Standard_Boolean operator < (const IntTools_RealWithFlag& aOther) {
-    return myValue<aOther.myValue;
-  }
-  //
- protected:
-  Standard_Real myValue;
-  Standard_Integer myFlag;
-};
-//------------
-static 
-  void SortShell(const Standard_Integer, 
-                 IntTools_RealWithFlag *); 
-static
-  void RejectDuplicates(Standard_Integer& aNbVtx, 
-                        IntTools_RealWithFlag *pVtx, 
-                        Standard_Real aTolPrm);
-static
-  void RejectNearBeacons(Standard_Integer& aNbVtx, 
-                         IntTools_RealWithFlag *pVtx, 
-                         Standard_Real aTolPC1,
-                         const GeomAbs_SurfaceType aTS1,
-                         const GeomAbs_SurfaceType aTS2); 
-static
-  Standard_Real AdjustOnPeriod(const Standard_Real aTr,
-                               const Standard_Real aPeriod);
-
-static
-  Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
-                                     const IntPatch_IType aType,
-                                     const Standard_Real aTol3D);
-//
-//=======================================================================
-//function : TreatCircle
-//purpose  : 
-//=======================================================================
-void IntTools_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& aLine,
-                                           const Standard_Real aTol)
-{  
-  Standard_Boolean bRejected;
-  IntPatch_IType aType;
-  //
-  aType=aLine->ArcType();
-  Handle(IntPatch_GLine)& aGLine=*((Handle(IntPatch_GLine) *)&aLine);
-  //
-  bRejected=RejectMicroCircle(aGLine, aType, aTol);
-  if (bRejected) {
-    return;
-  }
-  //----------------------------------------
-  Standard_Boolean bFound;
-  Standard_Integer aNbVtx, aNbVtxWas, i;
-  Standard_Real aTolPC, aT, aT1, aT2, aTmid, aTwoPI, aTolPC1;
-  Standard_Real aU1, aV1, aU2, aV2;
-  TopAbs_State aIn1, aIn2;
-  GeomAbs_SurfaceType aTS1, aTS2;
-  gp_Pnt aPmid;
-  gp_Pnt2d aP2D;
-  IntTools_RealWithFlag *pVtx;
-  //-------------------------------------1
-  aTwoPI=M_PI+M_PI;
-  aTolPC=Precision::PConfusion();
-  aNbVtxWas=GeomInt_LineTool::NbVertex(aLine);
-  
-  aNbVtx=aNbVtxWas+2;
-  //-------------------------------------2
-  aTS1=myHS1->GetType();
-  aTS2=myHS2->GetType();
-  //
-  // About the value aTolPC1=1000.*aTolPC,
-  // see IntPatch_GLine.cxx, line:398
-  // for more details;
-  aTolPC1=1000.*aTolPC; 
-  //-------------------------------------
-  //
-  pVtx=new IntTools_RealWithFlag [aNbVtx];
-  //
-  pVtx[0].SetValue(0.);
-  pVtx[1].SetValue(aTwoPI);
-  //
-  for(i=1; i<=aNbVtxWas; ++i) {
-    aT=GeomInt_LineTool::Vertex(aLine, i).ParameterOnLine();
-    aT=AdjustOnPeriod(aT, aTwoPI);
-    pVtx[i+1].SetValue(aT);
-  }
-  //
-  SortShell(aNbVtx, pVtx);
-  //
-  RejectNearBeacons(aNbVtx, pVtx, aTolPC1, aTS1, aTS2);
-  //
-  RejectDuplicates(aNbVtx, pVtx, aTolPC);
-  //
-  if ((aType==IntPatch_Circle || aType==IntPatch_Ellipse)&& aNbVtx>2) { // zz
-    bFound=Standard_False;
-    for(i=1; i<=aNbVtxWas; ++i) {
-      aT=GeomInt_LineTool::Vertex(aLine, i).ParameterOnLine();
-      if (fabs(aT) < aTolPC1 || fabs(aT-aTwoPI) < aTolPC1) {
-        bFound=!bFound;
-        break;
-      }
-    }
-    if (!bFound) {
-      aT=pVtx[1].Value()+aTwoPI;
-      pVtx[aNbVtx-1].SetValue(aT);
-      //
-      for(i=0; i<aNbVtx; ++i) { 
-        aT=pVtx[i+1].Value();
-        pVtx[i].SetValue(aT);
-      }
-      --aNbVtx;
-    }
-  }
-  //
-  for(i=0; i<aNbVtx-1; ++i) { 
-    aT1=pVtx[i].Value();
-    aT2=pVtx[i+1].Value();
-    aTmid=(aT1+aT2)*0.5;
-    GLinePoint(aType, aGLine, aTmid, aPmid);
-    //
-    Parameters(myHS1, myHS2, aPmid, aU1, aV1, aU2, aV2);
-    Recadre(myHS1, myHS2, aU1, aV1, aU2, aV2);
-    //
-    aP2D.SetCoord(aU1, aV1);
-    aIn1=myDom1->Classify(aP2D, aTol);
-    if(aIn1 !=  TopAbs_OUT) { 
-      aP2D.SetCoord(aU2, aV2);
-      aIn2=myDom2->Classify(aP2D, aTol);
-      if(aIn2 != TopAbs_OUT) { 
-        seqp.Append(aT1);
-        seqp.Append(aT2);
-      }
-    }
-  }
-  //
-  delete [] pVtx;
-}
-//=======================================================================
-//function : RejectNearBeacons
-//purpose  : Reject the thickenings near the beacon points (if exist)
-//           The gifts, made by sweep algo.  
-//           chl/930/B5 B8 C2 C5 E2 E5 E8 F2 G8 H2 H5 H8
-//=======================================================================
-void RejectNearBeacons(Standard_Integer& aNbVtx, 
-                       IntTools_RealWithFlag *pVtx, 
-                       Standard_Real aTolPC1,
-                       const GeomAbs_SurfaceType aTS1,
-                       const GeomAbs_SurfaceType aTS2) 
-{
-  Standard_Integer i, j, iBcn;
-  Standard_Real aT, aBcn[2];
-  //
-  if (aTS1==GeomAbs_Cylinder && aTS2==GeomAbs_Cylinder) {
-    aBcn[0]=0.5*M_PI;
-    aBcn[1]=1.5*M_PI;
-    //
-    for (j=0; j<2; ++j) {
-      iBcn=-1;
-      for(i=0; i<aNbVtx; ++i) {
-        aT=pVtx[i].Value();
-        if (aT==aBcn[j]) {
-          iBcn=i;
-          break;
-        }
-      }
-      //
-      if (iBcn<0) {
-        // The beacon is not found
-        continue;
-      }
-      //  
-      for(i=0; i<aNbVtx; ++i) {
-        if (i!=iBcn) {
-          aT=pVtx[i].Value();
-          if (fabs(aT-aBcn[j]) < aTolPC1) {
-            pVtx[i].SetFlag(0);
-          }
-        }
-      }
-    }// for (j=0; j<2; ++j) {
-    //------------------------------------------
-    j=0;
-    for(i=0; i<aNbVtx; ++i) {
-      if (pVtx[i].Flag()) {
-        pVtx[j]=pVtx[i];
-        ++j;
-      }
-    }
-    aNbVtx=j;
-  }// if (aTS1==GeomAbs_Cylinder && aTS2==GeomAbs_Cylinder) {
-}
-
-//=======================================================================
-//function : RejectDuplicates
-//purpose  : 
-//=======================================================================
-void RejectDuplicates(Standard_Integer& aNbVtx, 
-                      IntTools_RealWithFlag *pVtx, 
-                      Standard_Real aTolPC) 
-{
-  Standard_Integer i, j;
-  Standard_Real dX, aT1, aT2; 
-  //
-  for(i=0; i<aNbVtx-1; ++i) {
-    aT2=pVtx[i+1].Value();
-    aT1=pVtx[i].Value();
-    dX=aT2-aT1;
-    if (dX<aTolPC) {
-      pVtx[i+1].SetFlag(0);
-    }
-  }
-  //
-  j=0;
-  for(i=0; i<aNbVtx; ++i) {
-    if (pVtx[i].Flag()) {
-      pVtx[j]=pVtx[i];
-      ++j;
-    }
-  }
-  aNbVtx=j;
-}
-//=======================================================================
-//function : AdjustOnPeriod
-//purpose  : 
-//=======================================================================
-Standard_Real AdjustOnPeriod(const Standard_Real aTr,
-                             const Standard_Real aPeriod)
-{
-  Standard_Integer k;
-  Standard_Real aT;
-  //
-  aT=aTr;
-  if (aT<0.) {
-    k=-(Standard_Integer)(aT/aPeriod)+1;
-    aT=aT+k*aPeriod;
-  }
-  //
-  if (!(aT>=0. && aT<=aPeriod)) {
-    k=(Standard_Integer)(aT/aPeriod);
-    aT=aT-k*aPeriod;
-  }
-  //
-  return aT;
-}
-//=======================================================================
-//function : RejectMicroCrcles
-//purpose  : 
-//=======================================================================
-Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
-                                   const IntPatch_IType aType,
-                                   const Standard_Real aTol3D)
-{
-  Standard_Boolean bRet;
-  Standard_Real aR;
-  //
-  bRet=Standard_False;
-  //
-  if (aType==IntPatch_Circle) {
-    aR=aGLine->Circle().Radius();
-    bRet=(aR<aTol3D);
-  }
-  else if (aType==IntPatch_Ellipse) {
-    aR=aGLine->Ellipse().MajorRadius();
-    bRet=(aR<aTol3D);
-  }
-  return bRet;
-}
-//=======================================================================
-// function: SortShell
-// purpose : 
-//=======================================================================
-void SortShell(const Standard_Integer n, 
-               IntTools_RealWithFlag *a) 
-{
-  Standard_Integer nd, i, j, l, d=1;
-  IntTools_RealWithFlag x;
-  //
-  while(d<=n) {
-    d*=2;
-  }
-  //
-  while (d) {
-    d=(d-1)/2;
-    //
-    nd=n-d;
-    for (i=0; i<nd; ++i) {
-      j=i;
-    m30:;
-      l=j+d;
-      if (a[l] < a[j]){
-        x=a[j];
-        a[j]=a[l];
-        a[l]=x;
-        j-=d;
-        if (j > -1) goto m30;
-      }//if (a[l] < a[j]){
-    }//for (i=0; i<nd; ++i) 
-  }//while (1)
-}
diff --git a/src/IntTools/IntTools_LineConstructor.lxx b/src/IntTools/IntTools_LineConstructor.lxx
deleted file mode 100644 (file)
index 4a57511..0000000
+++ /dev/null
@@ -1,82 +0,0 @@
-// Created on: 1995-02-07
-// Created by: Jacques GOUSSARD
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <StdFail_NotDone.hxx>
-
-//=======================================================================
-//function : GeomInt_LineConstructor
-//purpose  : 
-//=======================================================================
-
-inline IntTools_LineConstructor::IntTools_LineConstructor ()
- : done(Standard_False)
-{
-}
-
-
-//=======================================================================
-//function : Load
-//purpose  : 
-//=======================================================================
-
-inline void IntTools_LineConstructor::Load(const Handle(Adaptor3d_TopolTool)& D1,
-                                           const Handle(Adaptor3d_TopolTool)& D2,
-                                           const Handle(GeomAdaptor_HSurface)& S1,
-                                           const Handle(GeomAdaptor_HSurface)& S2)
-{
-  myDom1 = D1;
-  myDom2 = D2;
-  myHS1  = S1;
-  myHS2  = S2;
-}
-
-
-//=======================================================================
-//function : IsDone
-//purpose  : 
-//=======================================================================
-
-inline Standard_Boolean IntTools_LineConstructor::IsDone () const
-{
-  return done;
-}
-
-
-//=======================================================================
-//function : NbParts
-//purpose  : 
-//=======================================================================
-
-inline Standard_Integer IntTools_LineConstructor::NbParts () const
-{
-  if (!done) { StdFail_NotDone::Raise(); }
-  return (seqp.Length() / 2);
-}
-
-
-//=======================================================================
-//function : Part
-//purpose  : 
-//=======================================================================
-
-inline void IntTools_LineConstructor::Part (const Standard_Integer I,
-                                            Standard_Real& WFirst,
-                                            Standard_Real& WLast) const
-{
-  if (!done) { StdFail_NotDone::Raise(); }
-  WFirst = seqp(2*I-1);
-  WLast  = seqp(2*I);
-}
index 7763165..1c5bcf7 100644 (file)
@@ -237,15 +237,4 @@ is
         theTmax  :out Real from Standard) 
     returns Integer from Standard;  
  
-    AdjustPeriodic(myclass;
-        thePar    : Real from Standard;
-        theParMin : Real from Standard;
-        theParMax : Real from Standard;
-        thePeriod : Real from Standard;
-        theNewPar : out Real from Standard;
-        theOffset : out Real from Standard;
-        theEps    : Real from Standard = 0.0)
-    returns Boolean from Standard;        
-    ---Purpose:  Adjusts the parameter <thePar> to the range [theParMin,  theParMax]
-
 end Tools;
index 38a6ed1..f9c005a 100644 (file)
@@ -777,36 +777,3 @@ Standard_Integer IntTools_Tools::SegPln(const gp_Lin& theLin,
   iRet=0; // intersection point
   return iRet;
 }
-
-//=======================================================================
-//function : AdjustPeriodic
-//purpose  : 
-//=======================================================================
-Standard_Boolean IntTools_Tools::AdjustPeriodic(const Standard_Real thePar,
-                                                const Standard_Real theParMin,
-                                                const Standard_Real theParMax,
-                                                const Standard_Real thePeriod,
-                                                Standard_Real &theNewPar,
-                                                Standard_Real &theOffset,
-                                                const Standard_Real theEps)
-{
-  Standard_Boolean bMin, bMax;
-  //
-  theOffset = 0.;
-  theNewPar = thePar;
-  bMin = theParMin - thePar > theEps;
-  bMax = thePar - theParMax > theEps;
-  //
-  if (bMin || bMax) {
-    Standard_Real dp, aNbPer;
-    //
-    dp = (bMin) ? (theParMax - thePar) : (theParMin - thePar);
-    modf(dp / thePeriod, &aNbPer);
-    //
-    theOffset = aNbPer * thePeriod;
-    theNewPar += theOffset;
-  }
-  //
-  return (theOffset > 0.);
-}
-
index 255e723..b140618 100755 (executable)
@@ -46,7 +46,7 @@ xdistcs i_22 s1 0 1 10
 set Log1 [dlog get]
 
 set List1 [split ${Log1} {TD= \t\n}]
-set Tolerance 1.0e-12
+set Tolerance 1.0e-7
 set D_good 0.
 checkList ${List1} ${Tolerance} ${D_good}