0023884: Boolean Fuse between two faces fails
authorpkv <pkv@opencascade.com>
Thu, 6 Feb 2014 07:18:55 +0000 (11:18 +0400)
committerapn <apn@opencascade.com>
Fri, 7 Feb 2014 07:15:28 +0000 (11:15 +0400)
fix for the bug v1
fix for the bug v1.1
Test case for issue CR23884

src/IntTools/IntTools_FaceFace.cxx
tests/bugs/modalg_5/bug23884 [changed mode: 0644->0755]

index 36bec81..2315953 100644 (file)
@@ -123,157 +123,157 @@ static
 //
 static
   void TolR3d(const TopoDS_Face& ,
-             const TopoDS_Face& ,
-             Standard_Real& );
+              const TopoDS_Face& ,
+              Standard_Real& );
 static 
   Handle(Geom_Curve) MakeBSpline (const Handle(IntPatch_WLine)&,
-                                 const Standard_Integer,
-                                 const Standard_Integer);
+                                  const Standard_Integer,
+                                  const Standard_Integer);
 
 static 
   void Parameters(const Handle(GeomAdaptor_HSurface)&,
-                 const Handle(GeomAdaptor_HSurface)&,
-                 const gp_Pnt&,
-                 Standard_Real&,
-                 Standard_Real&,
-                 Standard_Real&,
-                 Standard_Real&);
+                  const Handle(GeomAdaptor_HSurface)&,
+                  const gp_Pnt&,
+                  Standard_Real&,
+                  Standard_Real&,
+                  Standard_Real&,
+                  Standard_Real&);
 
 static 
   void BuildPCurves (Standard_Real f,Standard_Real l,Standard_Real& Tol,
-                    const Handle (Geom_Surface)& S,
-                    const Handle (Geom_Curve)&   C,
-                    Handle (Geom2d_Curve)& C2d);
+                     const Handle (Geom_Surface)& S,
+                     const Handle (Geom_Curve)&   C,
+                     Handle (Geom2d_Curve)& C2d);
 
 static 
   void CorrectSurfaceBoundaries(const TopoDS_Face&  theFace,
-                               const Standard_Real theTolerance,
-                               Standard_Real&      theumin,
-                               Standard_Real&      theumax, 
-                               Standard_Real&      thevmin, 
-                               Standard_Real&      thevmax);
+                                const Standard_Real theTolerance,
+                                Standard_Real&      theumin,
+                                Standard_Real&      theumax, 
+                                Standard_Real&      thevmin, 
+                                Standard_Real&      thevmax);
 static
   Standard_Boolean NotUseSurfacesForApprox
           (const TopoDS_Face& aF1,
-          const TopoDS_Face& aF2,
-          const Handle(IntPatch_WLine)& WL,
-          const Standard_Integer ifprm,
-          const Standard_Integer ilprm);
+           const TopoDS_Face& aF2,
+           const Handle(IntPatch_WLine)& WL,
+           const Standard_Integer ifprm,
+           const Standard_Integer ilprm);
 
 static 
   Handle(IntPatch_WLine) ComputePurgedWLine(const Handle(IntPatch_WLine)& theWLine);
 
 static 
   Standard_Real AdjustPeriodic(const Standard_Real theParameter,
-                              const Standard_Real parmin,
-                              const Standard_Real parmax,
-                              const Standard_Real thePeriod,
-                              Standard_Real&      theOffset);
+                               const Standard_Real parmin,
+                               const Standard_Real parmax,
+                               const Standard_Real thePeriod,
+                               Standard_Real&      theOffset);
 
 static 
   Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine,
-                                           const Standard_Integer                         ideb,
-                                           const Standard_Integer                         ifin,
-                                           const Standard_Boolean                         onFirst);
+                                            const Standard_Integer                         ideb,
+                                            const Standard_Integer                         ifin,
+                                            const Standard_Boolean                         onFirst);
 
 static 
   Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
-                                       const Handle(GeomAdaptor_HSurface)&            theSurface1, 
-                                       const Handle(GeomAdaptor_HSurface)&            theSurface2,
-                                       const TopoDS_Face&                             theFace1,
-                                       const TopoDS_Face&                             theFace2,
-                                       const IntTools_LineConstructor&                theLConstructor,
-                                       const Standard_Boolean                         theAvoidLConstructor,
-                                       IntPatch_SequenceOfLine&                       theNewLines,
-                                       Standard_Real&                                 theReachedTol3d,
-                                       const Handle(BOPInt_Context)& );
+                                        const Handle(GeomAdaptor_HSurface)&            theSurface1, 
+                                        const Handle(GeomAdaptor_HSurface)&            theSurface2,
+                                        const TopoDS_Face&                             theFace1,
+                                        const TopoDS_Face&                             theFace2,
+                                        const IntTools_LineConstructor&                theLConstructor,
+                                        const Standard_Boolean                         theAvoidLConstructor,
+                                        IntPatch_SequenceOfLine&                       theNewLines,
+                                        Standard_Real&                                 theReachedTol3d,
+                                        const Handle(BOPInt_Context)& );
 
 static 
   Standard_Boolean ParameterOutOfBoundary(const Standard_Real       theParameter, 
-                                         const Handle(Geom_Curve)& theCurve, 
-                                         const TopoDS_Face&        theFace1, 
-                                         const TopoDS_Face&        theFace2,
-                                         const Standard_Real       theOtherParameter,
-                                         const Standard_Boolean    bIncreasePar,
-                                         Standard_Real&            theNewParameter,
-                                         const Handle(BOPInt_Context)& );
+                                          const Handle(Geom_Curve)& theCurve, 
+                                          const TopoDS_Face&        theFace1, 
+                                          const TopoDS_Face&        theFace2,
+                                          const Standard_Real       theOtherParameter,
+                                          const Standard_Boolean    bIncreasePar,
+                                          Standard_Real&            theNewParameter,
+                                          const Handle(BOPInt_Context)& );
 
 static 
   Standard_Boolean IsCurveValid(Handle(Geom2d_Curve)& thePCurve);
 
 static 
   Standard_Boolean IsPointOnBoundary(const Standard_Real theParameter,
-                                    const Standard_Real theFirstBoundary,
-                                    const Standard_Real theSecondBoundary,
-                                    const Standard_Real theResolution,
-                                    Standard_Boolean&   IsOnFirstBoundary);
+                                     const Standard_Real theFirstBoundary,
+                                     const Standard_Real theSecondBoundary,
+                                     const Standard_Real theResolution,
+                                     Standard_Boolean&   IsOnFirstBoundary);
 static
   Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
-                            const gp_Pnt2d&     theLastPoint,
-                            const Standard_Real theUmin, 
-                            const Standard_Real theUmax,
-                            const Standard_Real theVmin,
-                            const Standard_Real theVmax,
-                            gp_Pnt2d&           theNewPoint);
+                             const gp_Pnt2d&     theLastPoint,
+                             const Standard_Real theUmin, 
+                             const Standard_Real theUmax,
+                             const Standard_Real theVmin,
+                             const Standard_Real theVmax,
+                             gp_Pnt2d&           theNewPoint);
 
 
 static 
   Standard_Integer ComputeTangentZones( const Handle(GeomAdaptor_HSurface)& theSurface1,
-                                      const Handle(GeomAdaptor_HSurface)&  theSurface2,
-                                      const TopoDS_Face&                   theFace1,
-                                      const TopoDS_Face&                   theFace2,
-                                      Handle(TColgp_HArray1OfPnt2d)&       theResultOnS1,
-                                      Handle(TColgp_HArray1OfPnt2d)&       theResultOnS2,
-                                      Handle(TColStd_HArray1OfReal)&       theResultRadius,
-                                      const Handle(BOPInt_Context)& );
+                                       const Handle(GeomAdaptor_HSurface)&  theSurface2,
+                                       const TopoDS_Face&                   theFace1,
+                                       const TopoDS_Face&                   theFace2,
+                                       Handle(TColgp_HArray1OfPnt2d)&       theResultOnS1,
+                                       Handle(TColgp_HArray1OfPnt2d)&       theResultOnS2,
+                                       Handle(TColStd_HArray1OfReal)&       theResultRadius,
+                                       const Handle(BOPInt_Context)& );
 
 static
   Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
-                            const gp_Pnt2d&     theLastPoint,
-                            const Standard_Real theUmin, 
-                            const Standard_Real theUmax,
-                            const Standard_Real theVmin,
-                            const Standard_Real theVmax,
-                            const gp_Pnt2d&     theTanZoneCenter,
-                            const Standard_Real theZoneRadius,
-                            Handle(GeomAdaptor_HSurface) theGASurface,
-                            gp_Pnt2d&           theNewPoint);
+                             const gp_Pnt2d&     theLastPoint,
+                             const Standard_Real theUmin, 
+                             const Standard_Real theUmax,
+                             const Standard_Real theVmin,
+                             const Standard_Real theVmax,
+                             const gp_Pnt2d&     theTanZoneCenter,
+                             const Standard_Real theZoneRadius,
+                             Handle(GeomAdaptor_HSurface) theGASurface,
+                             gp_Pnt2d&           theNewPoint);
 
 static
   Standard_Boolean IsInsideTanZone(const gp_Pnt2d&     thePoint,
-                                  const gp_Pnt2d&     theTanZoneCenter,
-                                  const Standard_Real theZoneRadius,
-                                  Handle(GeomAdaptor_HSurface) theGASurface);
+                                   const gp_Pnt2d&     theTanZoneCenter,
+                                   const Standard_Real theZoneRadius,
+                                   Handle(GeomAdaptor_HSurface) theGASurface);
 
 static
   gp_Pnt2d AdjustByNeighbour(const gp_Pnt2d&     theaNeighbourPoint,
-                            const gp_Pnt2d&     theOriginalPoint,
-                            Handle(GeomAdaptor_HSurface) theGASurface);
+                             const gp_Pnt2d&     theOriginalPoint,
+                             Handle(GeomAdaptor_HSurface) theGASurface);
 static
   Standard_Boolean  ApproxWithPCurves(const gp_Cylinder& theCyl, 
-                                     const gp_Sphere& theSph);
+                                      const gp_Sphere& theSph);
 
 static void  PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1, 
-                          const Handle(GeomAdaptor_HSurface)& theS2, 
-                          const Standard_Real TolAng, 
-                          const Standard_Real TolTang, 
-                          const Standard_Boolean theApprox1,
-                          const Standard_Boolean theApprox2,
+                           const Handle(GeomAdaptor_HSurface)& theS2, 
+                           const Standard_Real TolAng, 
+                           const Standard_Real TolTang, 
+                           const Standard_Boolean theApprox1,
+                           const Standard_Boolean theApprox2,
                            IntTools_SequenceOfCurves& theSeqOfCurve, 
-                          Standard_Boolean& theTangentFaces);
+                           Standard_Boolean& theTangentFaces);
 
 static Standard_Boolean ClassifyLin2d(const Handle(GeomAdaptor_HSurface)& theS, 
-                                     const gp_Lin2d& theLin2d, 
-                                     const Standard_Real theTol,
-                                     Standard_Real& theP1, 
-                                     Standard_Real& theP2);
+                                      const gp_Lin2d& theLin2d, 
+                                      const Standard_Real theTol,
+                                      Standard_Real& theP1, 
+                                      Standard_Real& theP2);
 //
 static
   void ApproxParameters(const Handle(GeomAdaptor_HSurface)& aHS1,
-                       const Handle(GeomAdaptor_HSurface)& aHS2,
-                       Standard_Integer& iDegMin,
-                       Standard_Integer& iNbIter,
-                       Standard_Integer& iDegMax);
+                        const Handle(GeomAdaptor_HSurface)& aHS2,
+                        Standard_Integer& iDegMin,
+                        Standard_Integer& iNbIter,
+                        Standard_Integer& iDegMax);
 
 static
   void Tolerances(const Handle(GeomAdaptor_HSurface)& aHS1,
@@ -282,21 +282,21 @@ static
 
 static
   Standard_Boolean SortTypes(const GeomAbs_SurfaceType aType1,
-                            const GeomAbs_SurfaceType aType2);
+                             const GeomAbs_SurfaceType aType2);
 static
   Standard_Integer IndexType(const GeomAbs_SurfaceType aType);
 
 //
 static
   Standard_Real MaxSquareDistance (const Standard_Real aT,
-                                  const Handle(Geom_Curve)& aC3D,
-                                  const Handle(Geom2d_Curve)& aC2D1,
-                                  const Handle(Geom2d_Curve)& aC2D2,
-                                  const Handle(GeomAdaptor_HSurface) myHS1,
-                                  const Handle(GeomAdaptor_HSurface) myHS2,
-                                  const TopoDS_Face& aF1,
-                                  const TopoDS_Face& aF2,
-                                  const Handle(BOPInt_Context)& aCtx);
+                                   const Handle(Geom_Curve)& aC3D,
+                                   const Handle(Geom2d_Curve)& aC2D1,
+                                   const Handle(Geom2d_Curve)& aC2D2,
+                                   const Handle(GeomAdaptor_HSurface) myHS1,
+                                   const Handle(GeomAdaptor_HSurface) myHS2,
+                                   const TopoDS_Face& aF1,
+                                   const TopoDS_Face& aF2,
+                                   const Handle(BOPInt_Context)& aCtx);
 
 static
   Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC, 
@@ -305,16 +305,16 @@ static
 //
 static
   Standard_Real FindMaxSquareDistance (const Standard_Real aA,
-                                      const Standard_Real aB,
-                                      const Standard_Real aEps,
-                                      const Handle(Geom_Curve)& aC3D,
-                                      const Handle(Geom2d_Curve)& aC2D1,
-                                      const Handle(Geom2d_Curve)& aC2D2,
-                                      const Handle(GeomAdaptor_HSurface)& myHS1,
-                                      const Handle(GeomAdaptor_HSurface)& myHS2,
-                                      const TopoDS_Face& aF1,
-                                      const TopoDS_Face& aF2,
-                                      const Handle(BOPInt_Context)& aCtx);
+                                       const Standard_Real aB,
+                                       const Standard_Real aEps,
+                                       const Handle(Geom_Curve)& aC3D,
+                                       const Handle(Geom2d_Curve)& aC2D1,
+                                       const Handle(Geom2d_Curve)& aC2D2,
+                                       const Handle(GeomAdaptor_HSurface)& myHS1,
+                                       const Handle(GeomAdaptor_HSurface)& myHS2,
+                                       const TopoDS_Face& aF1,
+                                       const TopoDS_Face& aF2,
+                                       const Handle(BOPInt_Context)& aCtx);
 
 //=======================================================================
 //function : 
@@ -420,9 +420,9 @@ Standard_Real IntTools_FaceFace::TolReached2d() const
 //
 // =======================================================================
 void IntTools_FaceFace::SetParameters(const Standard_Boolean ToApproxC3d,
-                                     const Standard_Boolean ToApproxC2dOnS1,
-                                     const Standard_Boolean ToApproxC2dOnS2,
-                                     const Standard_Real ApproximationTolerance) 
+                                      const Standard_Boolean ToApproxC2dOnS1,
+                                      const Standard_Boolean ToApproxC2dOnS2,
+                                      const Standard_Real ApproximationTolerance) 
 {
   myApprox = ToApproxC3d;
   myApprox1 = ToApproxC2dOnS1;
@@ -838,7 +838,7 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
   aType2=myHS2->Surface().GetType();
   //
   bCase1=((aType1==GeomAbs_Plane && aType2==GeomAbs_SurfaceOfExtrusion) ||
-         (aType2==GeomAbs_Plane && aType1==GeomAbs_SurfaceOfExtrusion));
+          (aType2==GeomAbs_Plane && aType1==GeomAbs_SurfaceOfExtrusion));
   //
   if (aType1==GeomAbs_Cylinder && aType2==GeomAbs_Cylinder) {
     if (aNbLin==2){ 
@@ -850,20 +850,20 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
       aTL1=aIL1->ArcType();
       aTL2=aIL2->ArcType();
       if (aTL1==IntPatch_Lin && aTL2==IntPatch_Lin) {
-       Standard_Real aD, aDTresh, dTol;
-       gp_Lin aL1, aL2;
-       //
-       dTol=1.e-8;
-       aDTresh=1.5e-6;
-       //
-       aL1=Handle(IntPatch_GLine)::DownCast(aIL1)->Line();
-       aL2=Handle(IntPatch_GLine)::DownCast(aIL2)->Line();
-       aD=aL1.Distance(aL2);
-       aD=0.5*aD;
-       if (aD<aDTresh) {
-         myTolReached3d=aD+dTol;
-       }
-       return;
+        Standard_Real aD, aDTresh, dTol;
+        gp_Lin aL1, aL2;
+        //
+        dTol=1.e-8;
+        aDTresh=1.5e-6;
+        //
+        aL1=Handle(IntPatch_GLine)::DownCast(aIL1)->Line();
+        aL2=Handle(IntPatch_GLine)::DownCast(aIL2)->Line();
+        aD=aL1.Distance(aL2);
+        aD=0.5*aD;
+        if (aD<aDTresh) {
+          myTolReached3d=aD+dTol;
+        }
+        return;
       }
     }
     //ZZ
@@ -876,34 +876,34 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
       aNbLin=mySeqOfCurve.Length();
       //
       for (i=1; i<=aNbLin; ++i) {
-       const IntTools_Curve& aIC=mySeqOfCurve(i);
-       const Handle(Geom_Curve)& aC3D=aIC.Curve();
-       const Handle(Geom2d_Curve)& aC2D1=aIC.FirstCurve2d();
-       const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
-       //
-       if (aC3D.IsNull()) {
-         continue;
-       }
-       const Handle(Geom_BSplineCurve)& aBC=
-         Handle(Geom_BSplineCurve)::DownCast(aC3D);
-       if (aBC.IsNull()) {
-         continue;
-       }
-       //
-       aT1=aBC->FirstParameter();
-       aT2=aBC->LastParameter();
-       //
-       aEps=0.01*(aT2-aT1);
-       dT=(aT2-aT1)/aNbP;
-       for (j=1; j<aNbP; ++j) {
-         aT11=aT1+j*dT;
-         aT12=aT11+dT;
-         aD2=FindMaxSquareDistance(aT11, aT12, aEps, aC3D, aC2D1, aC2D2,
-                                   myHS1, myHS2, myFace1, myFace2, myContext);
-         if (aD2>aD2Max) {
-           aD2Max=aD2;
-         }
-       }
+        const IntTools_Curve& aIC=mySeqOfCurve(i);
+        const Handle(Geom_Curve)& aC3D=aIC.Curve();
+        const Handle(Geom2d_Curve)& aC2D1=aIC.FirstCurve2d();
+        const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
+        //
+        if (aC3D.IsNull()) {
+          continue;
+        }
+        const Handle(Geom_BSplineCurve)& aBC=
+          Handle(Geom_BSplineCurve)::DownCast(aC3D);
+        if (aBC.IsNull()) {
+          continue;
+        }
+        //
+        aT1=aBC->FirstParameter();
+        aT2=aBC->LastParameter();
+        //
+        aEps=0.01*(aT2-aT1);
+        dT=(aT2-aT1)/aNbP;
+        for (j=1; j<aNbP; ++j) {
+          aT11=aT1+j*dT;
+          aT12=aT11+dT;
+          aD2=FindMaxSquareDistance(aT11, aT12, aEps, aC3D, aC2D1, aC2D2,
+                                    myHS1, myHS2, myFace1, myFace2, myContext);
+          if (aD2>aD2Max) {
+            aD2Max=aD2;
+          }
+        }
       }//for (i=1; i<=aNbLin; ++i) {
       //
       myTolReached3d=sqrt(aD2Max);
@@ -927,40 +927,40 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
   //t
   //IFV Bug OCC20297 
   else if((aType1 == GeomAbs_Cylinder && aType2 == GeomAbs_Plane) ||
-         (aType2 == GeomAbs_Cylinder && aType1 == GeomAbs_Plane)) {
+          (aType2 == GeomAbs_Cylinder && aType1 == GeomAbs_Plane)) {
     if(aNbLin == 1) {
       const Handle(IntPatch_Line)& aIL1 = myIntersector.Line(1);
       if(aIL1->ArcType() == IntPatch_Circle) {
-       gp_Circ aCir = Handle(IntPatch_GLine)::DownCast(aIL1)->Circle();
-       gp_XYZ aCirDir = aCir.Axis().Direction().XYZ();
-       gp_XYZ aPlDir;
-       gp_Pln aPln;
-       if(aType1 == GeomAbs_Plane) {
-         aPln = myHS1->Surface().Plane();
-       }
-       else {
-         aPln = myHS2->Surface().Plane();
-       }
-       aPlDir = aPln.Axis().Direction().XYZ();
-       Standard_Real cs = aCirDir*aPlDir;
-       if(cs < 0.) aPlDir.Reverse();
-       Standard_Real eps = 1.e-14;
-       if(!aPlDir.IsEqual(aCirDir, eps)) {
-         Standard_Integer aNbP = 11;
-         Standard_Real dt = 2.*M_PI / (aNbP - 1), t;
-         for(t = 0.; t < 2.*M_PI; t += dt) {
-           Standard_Real d = aPln.Distance(ElCLib::Value(t, aCir)); 
-           if(myTolReached3d < d) myTolReached3d = d;
-         }
-         myTolReached3d *= 1.1;
-       }
+        gp_Circ aCir = Handle(IntPatch_GLine)::DownCast(aIL1)->Circle();
+        gp_XYZ aCirDir = aCir.Axis().Direction().XYZ();
+        gp_XYZ aPlDir;
+        gp_Pln aPln;
+        if(aType1 == GeomAbs_Plane) {
+          aPln = myHS1->Surface().Plane();
+        }
+        else {
+          aPln = myHS2->Surface().Plane();
+        }
+        aPlDir = aPln.Axis().Direction().XYZ();
+        Standard_Real cs = aCirDir*aPlDir;
+        if(cs < 0.) aPlDir.Reverse();
+        Standard_Real eps = 1.e-14;
+        if(!aPlDir.IsEqual(aCirDir, eps)) {
+          Standard_Integer aNbP = 11;
+          Standard_Real dt = 2.*M_PI / (aNbP - 1), t;
+          for(t = 0.; t < 2.*M_PI; t += dt) {
+            Standard_Real d = aPln.Distance(ElCLib::Value(t, aCir)); 
+            if(myTolReached3d < d) myTolReached3d = d;
+          }
+          myTolReached3d *= 1.1;
+        }
       } //aIL1->ArcType() == IntPatch_Circle
     } //aNbLin == 1
   } // aType1 == GeomAbs_Cylinder && aType2 == GeomAbs_Plane) 
   //End IFV Bug OCC20297
   //
   else if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Torus) ||
-          (aType2==GeomAbs_Plane && aType1==GeomAbs_Torus)) {
+           (aType2==GeomAbs_Plane && aType1==GeomAbs_Torus)) {
     aNbLin=mySeqOfCurve.Length();
     if (aNbLin!=1) {
       return;
@@ -993,7 +993,7 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
     for (i=0; i<aNbP; ++i) {
       aT=aT1+i*dT;
       if (i==aNbP-1) {
-       aT=aT2;
+        aT=aT2;
       }
       //
       aC3D->D0(aT, aP);
@@ -1002,14 +1002,14 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
       aPP=ElSLib::Value(aUP, aVP, aPln);
       aDP=aP.SquareDistance(aPP);
       if (aDP>aDmax) {
-       aDmax=aDP;
+        aDmax=aDP;
       }
       //
       ElSLib::Parameters(aTorus, aP, aUT, aVT);
       aPT=ElSLib::Value(aUT, aVT, aTorus);
       aDT=aP.SquareDistance(aPT);
       if (aDT>aDmax) {
-       aDmax=aDT;
+        aDmax=aDT;
       }
     }
     //
@@ -1020,7 +1020,7 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
   }// if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Torus) ||
   //
   else if ((aType1==GeomAbs_SurfaceOfRevolution && aType2==GeomAbs_Cylinder) ||
-          (aType2==GeomAbs_SurfaceOfRevolution && aType1==GeomAbs_Cylinder)) {
+           (aType2==GeomAbs_SurfaceOfRevolution && aType1==GeomAbs_Cylinder)) {
     Standard_Integer j, aNbP;
     Standard_Real aT, aT1, aT2, dT, aD2max, aD2;
     //
@@ -1035,12 +1035,12 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
       const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
       //
       if (aC3D.IsNull()) {
-       continue;
+        continue;
       }
       const Handle(Geom_BSplineCurve)& aBC=
-       Handle(Geom_BSplineCurve)::DownCast(aC3D);
+        Handle(Geom_BSplineCurve)::DownCast(aC3D);
       if (aBC.IsNull()) {
-       return;
+        return;
       }
       //
       aT1=aBC->FirstParameter();
@@ -1048,16 +1048,16 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
       //
       dT=(aT2-aT1)/(aNbP-1);
       for (j=0; j<aNbP; ++j) {
-       aT=aT1+j*dT;
-       if (j==aNbP-1) {
-         aT=aT2;
-       }
-       //
-       aD2=MaxSquareDistance(aT, aC3D, aC2D1, aC2D2,
-                             myHS1, myHS2, myFace1, myFace2, myContext);
-       if (aD2>aD2max) {
-         aD2max=aD2;
-       }
+        aT=aT1+j*dT;
+        if (j==aNbP-1) {
+          aT=aT2;
+        }
+        //
+        aD2=MaxSquareDistance(aT, aC3D, aC2D1, aC2D2,
+                              myHS1, myHS2, myFace1, myFace2, myContext);
+        if (aD2>aD2max) {
+          aD2max=aD2;
+        }
       }//for (j=0; j<aNbP; ++j) {
      
     }//for (i=1; i<=aNbLin; ++i) {
@@ -1138,12 +1138,12 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
       const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
       //
       if (aC3D.IsNull()) {
-       continue;
+        continue;
       }
       const Handle(Geom_BSplineCurve)& aBC=
-       Handle(Geom_BSplineCurve)::DownCast(aC3D);
+        Handle(Geom_BSplineCurve)::DownCast(aC3D);
       if (aBC.IsNull()) {
-       continue;
+        continue;
       }
       //
       aT1=aBC->FirstParameter();
@@ -1153,13 +1153,13 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
       aNbP=11;
       dT=(aT2-aT1)/aNbP;
       for (j=1; j<aNbP-1; ++j) {
-       aT11=aT1+j*dT;
-       aT12=aT11+dT;
-       aD2=FindMaxSquareDistance(aT11, aT12, aEps, aC3D, aC2D1, aC2D2,
-                                 myHS1, myHS2, myFace1, myFace2, myContext);
-       if (aD2>aD2Max) {
-         aD2Max=aD2;
-       }
+        aT11=aT1+j*dT;
+        aT12=aT11+dT;
+        aD2=FindMaxSquareDistance(aT11, aT12, aEps, aC3D, aC2D1, aC2D2,
+                                  myHS1, myHS2, myFace1, myFace2, myContext);
+        if (aD2>aD2Max) {
+          aD2Max=aD2;
+        }
       }
     }//for (i=1; i<=aNbLin; ++i) {
     myTolReached3d=sqrt(aD2Max);
@@ -1170,12 +1170,11 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
 //purpose  : 
 //=======================================================================
   void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
-                                   const Handle(Adaptor3d_TopolTool)& dom1,
-                                   const Handle(Adaptor3d_TopolTool)& dom2) 
+                                    const Handle(Adaptor3d_TopolTool)& dom1,
+                                    const Handle(Adaptor3d_TopolTool)& dom2) 
 {
-  Standard_Boolean bDone, rejectSurface, reApprox, bAvoidLineConstructor,
-    bPCurvesOk;
-  Standard_Boolean ok;
+  Standard_Boolean bDone, rejectSurface, reApprox, bAvoidLineConstructor;
+  Standard_Boolean ok, bPCurvesOk;
   Standard_Integer i, j, aNbParts;
   Standard_Real fprm, lprm;
   Standard_Real Tolpc;
@@ -1203,18 +1202,17 @@ reapprox:;
     //
     const Handle(IntPatch_WLine)& aWLine=
       Handle(IntPatch_WLine)::DownCast(L);
-#ifdef DEB_DUMPWLINE
-    DumpWLine(aWLine);
-#endif
+    //DumpWLine(aWLine);
+
     anewL = ComputePurgedWLine(aWLine);
     if(anewL.IsNull()) {
       return;
     }
     L = anewL;
-#ifdef DEB_DUMPWLINE
-    const Handle(IntPatch_WLine)& aWLineX = Handle(IntPatch_WLine)::DownCast(L);
-    DumpWLine(aWLineX);
-#endif
+    
+    //const Handle(IntPatch_WLine)& aWLineX = Handle(IntPatch_WLine)::DownCast(L);
+    //DumpWLine(aWLineX);
+
     //
     if(!myListOfPnts.IsEmpty()) {
       bAvoidLineConstructor = Standard_True;
@@ -1230,7 +1228,6 @@ reapprox:;
     if(P1.SquareDistance(P2) < 1.e-14) {
       bAvoidLineConstructor = Standard_False;
     }
-
   }
   //
   // Line Constructor
@@ -1301,7 +1298,7 @@ reapprox:;
           if(Tolpc>myTolReached2d || myTolReached2d==0.) { 
             myTolReached2d=Tolpc;
           }
-          //      
+          //            
           aCurve.SetFirstCurve2d(new Geom2d_TrimmedCurve(C2d,fprm,lprm));
         }
         else { 
@@ -1377,9 +1374,9 @@ reapprox:;
   }// case IntPatch_Lin:  case IntPatch_Parabola:  case IntPatch_Hyperbola:
   break;
 
-                           //########################################  
-                           // Circle and Ellipse
-                           //########################################  
+    //########################################  
+    // Circle and Ellipse
+    //########################################  
   case IntPatch_Circle: 
   case IntPatch_Ellipse: {
 
@@ -1424,7 +1421,8 @@ reapprox:;
           if(P1.Distance(P2) > aTolDist) {
             Standard_Real anewpar = fprm;
 
-            if(ParameterOutOfBoundary(fprm, newc, myFace1, myFace2, lprm, Standard_False, anewpar, myContext)) {
+            if(ParameterOutOfBoundary(fprm, newc, myFace1, myFace2, 
+                                      lprm, Standard_False, anewpar, myContext)) {
               fprm = anewpar;
             }
             aSeqFprm.Append(fprm);
@@ -1446,7 +1444,8 @@ reapprox:;
           if(P1.Distance(P2) > aTolDist) {
             Standard_Real anewpar = lprm;
 
-            if(ParameterOutOfBoundary(lprm, newc, myFace1, myFace2, fprm, Standard_True, anewpar, myContext)) {
+            if(ParameterOutOfBoundary(lprm, newc, myFace1, myFace2, 
+                                      fprm, Standard_True, anewpar, myContext)) {
               lprm = anewpar;
             }
             aSeqFprm.Append(aNul);
@@ -1476,7 +1475,7 @@ reapprox:;
         aCurve.SetCurve(aTC3D);
         fprm=aTC3D->FirstParameter();
         lprm=aTC3D->LastParameter ();
-        ////   
+        ////         
         if (typl == IntPatch_Circle || typl == IntPatch_Ellipse) {//// 
           if(myApprox1) { 
             Handle (Geom2d_Curve) C2d;
@@ -1514,14 +1513,14 @@ reapprox:;
           aCurve.SetSecondCurve2d(H1);
         }
         mySeqOfCurve.Append(aCurve);
-        //==============================================       
+        //==============================================        
       } //if (Abs(fprm) > RealEpsilon() || Abs(lprm-2.*M_PI) > RealEpsilon())
 
       else {
         //  on regarde si on garde
         //
         if (aNbParts==1) {
-          //     if (Abs(fprm) < RealEpsilon() &&  Abs(lprm-2.*M_PI) < RealEpsilon()) {
+          //           if (Abs(fprm) < RealEpsilon() &&  Abs(lprm-2.*M_PI) < RealEpsilon()) {
           if (Abs(fprm) <= aRealEpsilon && Abs(lprm-2.*M_PI) <= aRealEpsilon) {
             IntTools_Curve aCurve;
             Handle(Geom_TrimmedCurve) aTC3D=new Geom_TrimmedCurve(newc,fprm,lprm);
@@ -1600,7 +1599,7 @@ reapprox:;
                 if(Tolpc>myTolReached2d || myTolReached2d==0) { 
                   myTolReached2d=Tolpc;
                 }
-                //             
+                //                 
                 aCurve.SetSecondCurve2d(C2d);
               }
 
@@ -1612,11 +1611,11 @@ reapprox:;
 
             else { 
               Handle(Geom2d_BSplineCurve) H1;
-              //       
+              //         
               aCurve.SetFirstCurve2d(H1);
               aCurve.SetSecondCurve2d(H1);
             }
-            //==============================================   
+            //==============================================        
             //
             mySeqOfCurve.Append(aCurve);
             break;
@@ -1694,7 +1693,7 @@ reapprox:;
         if(myApprox2) {
           H2 = MakeBSpline2d(WL, 1, WL->NbPnts(), Standard_False);
         }
-        //      
+        //          
         mySeqOfCurve.Append(IntTools_Curve(MakeBSpline(WL,1,WL->NbPnts()), H1, H2));
       }
     } // if (!myApprox)
@@ -1703,7 +1702,7 @@ reapprox:;
       GeomInt_WLApprox theapp3d;
       // 
       Standard_Real tol2d = myTolApprox;
-      //       
+      //         
       theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, Standard_True);
 
       aNbParts=myLConstruct.NbParts();
@@ -1726,7 +1725,7 @@ reapprox:;
           if(myApprox2) {
             H2 = MakeBSpline2d(WL, 1, WL->NbPnts(), Standard_False);
           }
-          //    
+          //          
           mySeqOfCurve.Append(IntTools_Curve(MakeBSpline(WL,1,WL->NbPnts()), H1, H2));
         }
 
@@ -1770,7 +1769,7 @@ reapprox:;
 
               GeomLib_Check2dBSplineCurve newCheck(BS2,TOLCHECK,TOLANGCHECK);
               newCheck.FixTangent(Standard_True,Standard_True);
-              //               
+              //                 
               aCurve.SetFirstCurve2d(BS2);
             }
             else {
@@ -1790,7 +1789,7 @@ reapprox:;
 
               GeomLib_Check2dBSplineCurve newCheck(BS2,TOLCHECK,TOLANGCHECK);
               newCheck.FixTangent(Standard_True,Standard_True);
-              //       
+              //         
               aCurve.SetSecondCurve2d(BS2);
             }
             else { 
@@ -1807,7 +1806,7 @@ reapprox:;
   }// case IntPatch_Analytic:
   break;
 
-  case IntPatch_Walking:{
+  case IntPatch_Walking: {
     Handle(IntPatch_WLine) WL = 
       Handle(IntPatch_WLine)::DownCast(L);
     //
@@ -1839,7 +1838,7 @@ reapprox:;
         if(myApprox2) {
           H2 = MakeBSpline2d(WL, ifprm, ilprm, Standard_False);
         }
-        //       
+        //           
         aBSp=MakeBSpline(WL, ifprm, ilprm);
         IntTools_Curve aIC(aBSp, H1, H2);
         mySeqOfCurve.Append(aIC);
@@ -1849,14 +1848,15 @@ reapprox:;
     else { // X
       Standard_Boolean bIsDecomposited;
       Standard_Integer nbiter, aNbSeqOfL;
-      Standard_Real tol2d;
+      Standard_Real tol2d, aTolApproxImp;
       IntPatch_SequenceOfLine aSeqOfL;
       GeomInt_WLApprox theapp3d;
       Approx_ParametrizationType aParType = Approx_ChordLength;
       //
       Standard_Boolean anApprox1 = myApprox1;
       Standard_Boolean anApprox2 = myApprox2;
-
+      //
+      aTolApproxImp=1.e-5;
       tol2d = myTolApprox;
 
       GeomAbs_SurfaceType typs1, typs2;
@@ -1872,17 +1872,16 @@ reapprox:;
         anWithPC = 
           ApproxWithPCurves(myHS2->Surface().Cylinder(), myHS1->Surface().Sphere());
       }
+      //
       if(!anWithPC) {
-        //aParType = Approx_Centripetal; 
-        myTolApprox = 1.e-5; 
+        myTolApprox = aTolApproxImp;//1.e-5; 
         anApprox1 = Standard_False;
         anApprox2 = Standard_False;
-        //     
+        //         
         tol2d = myTolApprox;
       }
 
       if(myHS1 == myHS2) { 
-        //
         theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, Standard_False, aParType);
         rejectSurface = Standard_True;
       }
@@ -1894,24 +1893,23 @@ reapprox:;
           //
           ApproxParameters(myHS1, myHS2, iDegMin, iDegMax, iNbIter);
           theapp3d.SetParameters(myTolApprox, tol2d, iDegMin, iDegMax, iNbIter, Standard_True, aParType);
-          //
         }
       }
       //
       Standard_Real aReachedTol = Precision::Confusion();
       bIsDecomposited=DecompositionOfWLine(WL,
-        myHS1, 
-        myHS2, 
-        myFace1, 
-        myFace2, 
-        myLConstruct, 
-        bAvoidLineConstructor, 
-        aSeqOfL, 
-        aReachedTol,
-        myContext);
-      if ( bIsDecomposited && ( myTolReached3d < aReachedTol ) )
+                                           myHS1, 
+                                           myHS2, 
+                                           myFace1, 
+                                           myFace2, 
+                                           myLConstruct, 
+                                           bAvoidLineConstructor, 
+                                           aSeqOfL, 
+                                           aReachedTol,
+                                           myContext);
+      if ( bIsDecomposited && ( myTolReached3d < aReachedTol ) ) {
         myTolReached3d = aReachedTol;
-
+      }
       //
       aNbSeqOfL=aSeqOfL.Length();
       //
@@ -1927,9 +1925,6 @@ reapprox:;
         }
       }
       //
-      // nbiter=(bIsDecomposited) ? aSeqOfL.Length() :
-      //   ((bAvoidLineConstructor) ? 1 :aNbParts);
-      //
       for(i = 1; i <= nbiter; ++i) {
         if(bIsDecomposited) {
           WL = Handle(IntPatch_WLine)::DownCast(aSeqOfL.Value(i));
@@ -1952,7 +1947,7 @@ reapprox:;
         //-- sur cette surface et on remonte les points 2d en 3d.
         if(typs1 == GeomAbs_Plane) { 
           theapp3d.Perform(myHS1, myHS2, WL, Standard_False,Standard_True, myApprox2,ifprm,ilprm);
-        }        
+        }          
         else if(typs2 == GeomAbs_Plane) { 
           theapp3d.Perform(myHS1,myHS2,WL,Standard_False,myApprox1,Standard_True,ifprm,ilprm);
         }
@@ -1977,22 +1972,21 @@ reapprox:;
           //
           theapp3d.Perform(myHS1,myHS2,WL,Standard_True,anApprox1,anApprox2,ifprm,ilprm);
         }
-
+        //
         if (!theapp3d.IsDone()) {
-          //     
           Handle(Geom2d_BSplineCurve) H1;
-          //     
-          Handle(Geom_Curve) aBSp=MakeBSpline(WL,ifprm, ilprm);
           Handle(Geom2d_BSplineCurve) H2;
-
+          //           
+          Handle(Geom_Curve) aBSp=MakeBSpline(WL,ifprm, ilprm);
+          //
           if(myApprox1) {
             H1 = MakeBSpline2d(WL, ifprm, ilprm, Standard_True);
           }
-
+          //
           if(myApprox2) {
             H2 = MakeBSpline2d(WL, ifprm, ilprm, Standard_False);
           }
-          //     
+          //           
           IntTools_Curve aIC(aBSp, H1, H2);
           mySeqOfCurve.Append(aIC);
         }
@@ -2012,7 +2006,6 @@ reapprox:;
                 myTolReached3d=1.e-6;
               }
             }
-            //
           }
           else  if( theapp3d.TolReached3d()>myTolReached3d || myTolReached3d==0.) { 
             myTolReached3d = theapp3d.TolReached3d();
@@ -2046,7 +2039,7 @@ reapprox:;
                 mbspc.Degree());
               GeomLib_CheckBSplineCurve Check(BS,TOLCHECK,TOLANGCHECK);
               Check.FixTangent(Standard_True, Standard_True);
-              //       
+              //         
               IntTools_Curve aCurve;
               aCurve.SetCurve(BS);
 
@@ -2099,12 +2092,12 @@ reapprox:;
               }
               else { 
                 Handle(Geom2d_BSplineCurve) H2;
-                //             
+                //                 
                 aCurve.SetSecondCurve2d(H2);
               }
               //
               mySeqOfCurve.Append(aCurve);
-            }
+            }//if(typs1 == GeomAbs_Plane) {
 
             else if(typs2 == GeomAbs_Plane) { 
               const AppParCurves_MultiBSpCurve& mbspc = theapp3d.Value(j);
@@ -2130,7 +2123,7 @@ reapprox:;
                 mbspc.Degree());
               GeomLib_CheckBSplineCurve Check(BS,TOLCHECK,TOLANGCHECK);
               Check.FixTangent(Standard_True,Standard_True);
-              //       
+              //         
               IntTools_Curve aCurve;
               aCurve.SetCurve(BS);
 
@@ -2141,7 +2134,7 @@ reapprox:;
                   mbspc.Degree());
                 GeomLib_Check2dBSplineCurve Check1(BS1,TOLCHECK,TOLANGCHECK);
                 Check1.FixTangent(Standard_True,Standard_True);
-                //     
+                //         
                 // ###########################################
                 if(!rejectSurface && !reApprox) {
                   Standard_Boolean isValid = IsCurveValid(BS1);
@@ -2182,7 +2175,7 @@ reapprox:;
               }
               else { 
                 Handle(Geom2d_BSplineCurve) H1;
-                //             
+                //                 
                 aCurve.SetFirstCurve2d(H1);
               }
               //
@@ -2191,7 +2184,7 @@ reapprox:;
               if (!bPCurvesOk) {
                 Handle(Geom2d_BSplineCurve) H1, H2;
                 bPCurvesOk = Standard_True;
-                //       
+                //           
                 Handle(Geom_Curve) aBSp=MakeBSpline(WL,ifprm, ilprm);
 
                 if(myApprox1) {
@@ -2215,33 +2208,49 @@ reapprox:;
               } else {
                 mySeqOfCurve.Append(aCurve);
               }
-            }
-            else { 
+            }// else if(typs2 == GeomAbs_Plane)
+            //
+            else { //typs2 != GeomAbs_Plane && typs1 != GeomAbs_Plane
+              Standard_Boolean bIsValid1, bIsValid2;
+              Handle(Geom_BSplineCurve) BS;
+              Handle(Geom2d_BSplineCurve) aH2D;        
+              IntTools_Curve aCurve; 
+              //
+              bIsValid1=Standard_True;
+              bIsValid2=Standard_True;
+              //
               const AppParCurves_MultiBSpCurve& mbspc = theapp3d.Value(j);
               nbpoles = mbspc.NbPoles();
               TColgp_Array1OfPnt tpoles(1,nbpoles);
               mbspc.Curve(1,tpoles);
-              Handle(Geom_BSplineCurve) BS=new Geom_BSplineCurve(tpoles,
-                mbspc.Knots(),
-                mbspc.Multiplicities(),
-                mbspc.Degree());
+              BS=new Geom_BSplineCurve(tpoles,
+                                       mbspc.Knots(),
+                                       mbspc.Multiplicities(),
+                                       mbspc.Degree());
               GeomLib_CheckBSplineCurve Check(BS,TOLCHECK,TOLANGCHECK);
               Check.FixTangent(Standard_True,Standard_True);
-              //               
-              IntTools_Curve aCurve;
+              //
               aCurve.SetCurve(BS);
-
+              aCurve.SetFirstCurve2d(aH2D);
+              aCurve.SetSecondCurve2d(aH2D);
+              //
               if(myApprox1) { 
                 if(anApprox1) {
+                  Handle(Geom2d_BSplineCurve) BS1;
                   TColgp_Array1OfPnt2d tpoles2d(1,nbpoles);
                   mbspc.Curve(2,tpoles2d);
-                  Handle(Geom2d_BSplineCurve) BS1=new Geom2d_BSplineCurve(tpoles2d,
-                    mbspc.Knots(),
-                    mbspc.Multiplicities(),
-                    mbspc.Degree());
+                  //
+                  BS1=new Geom2d_BSplineCurve(tpoles2d,
+                                              mbspc.Knots(),
+                                              mbspc.Multiplicities(),
+                                              mbspc.Degree());
                   GeomLib_Check2dBSplineCurve newCheck(BS1,TOLCHECK,TOLANGCHECK);
                   newCheck.FixTangent(Standard_True,Standard_True);
-                  //   
+                  // 
+                  if (!reApprox) {
+                    bIsValid1=CheckPCurve(BS1, myFace1);
+                  }
+                  //
                   aCurve.SetFirstCurve2d(BS1);
                 }
                 else {
@@ -2255,24 +2264,23 @@ reapprox:;
                   BS1 = Handle(Geom2d_BSplineCurve)::DownCast(C2d);
                   aCurve.SetFirstCurve2d(BS1);
                 }
-
-              }
-              else {
-                Handle(Geom2d_BSplineCurve) H1;
-                //             
-                aCurve.SetFirstCurve2d(H1);
-              }
+              } // if(myApprox1) { 
+              //
               if(myApprox2) { 
                 if(anApprox2) {
+                  Handle(Geom2d_BSplineCurve) BS2;
                   TColgp_Array1OfPnt2d tpoles2d(1,nbpoles);
                   mbspc.Curve((myApprox1==Standard_True)? 3 : 2,tpoles2d);
-                  Handle(Geom2d_BSplineCurve) BS2=new Geom2d_BSplineCurve(tpoles2d,
-                    mbspc.Knots(),
-                    mbspc.Multiplicities(),
-                    mbspc.Degree());
+                  BS2=new Geom2d_BSplineCurve(tpoles2d,
+                                              mbspc.Knots(),
+                                              mbspc.Multiplicities(),
+                                              mbspc.Degree());
                   GeomLib_Check2dBSplineCurve newCheck(BS2,TOLCHECK,TOLANGCHECK);
                   newCheck.FixTangent(Standard_True,Standard_True);
-                  //           
+                  // 
+                  if (!reApprox) {
+                    bIsValid2=CheckPCurve(BS2, myFace2);        
+                  }
                   aCurve.SetSecondCurve2d(BS2);
                 }
                 else {
@@ -2286,12 +2294,12 @@ reapprox:;
                   BS2 = Handle(Geom2d_BSplineCurve)::DownCast(C2d);
                   aCurve.SetSecondCurve2d(BS2);
                 }
-
-              }
-              else { 
-                Handle(Geom2d_BSplineCurve) H2;
-                //             
-                aCurve.SetSecondCurve2d(H2);
+              } //if(myApprox2) { 
+              if (!bIsValid1 || !bIsValid2) {
+                myTolApprox=aTolApproxImp;//1.e-5;
+                tol2d = myTolApprox;
+                reApprox = Standard_True;
+                goto reapprox;
               }
               //
               mySeqOfCurve.Append(aCurve);
@@ -2305,6 +2313,8 @@ reapprox:;
 
   case IntPatch_Restriction: 
     break;
+  default:
+    break;
 
   }
 }
@@ -2314,11 +2324,11 @@ reapprox:;
 //purpose  : 
 //=======================================================================
  void BuildPCurves (Standard_Real f,
-                   Standard_Real l,
-                   Standard_Real& Tol,
-                   const Handle (Geom_Surface)& S,
-                   const Handle (Geom_Curve)&   C,
-                   Handle (Geom2d_Curve)& C2d)
+                    Standard_Real l,
+                    Standard_Real& Tol,
+                    const Handle (Geom_Surface)& S,
+                    const Handle (Geom_Curve)&   C,
+                    Handle (Geom2d_Curve)& C2d)
 {
 
   Standard_Real umin,umax,vmin,vmax;
@@ -2331,53 +2341,53 @@ reapprox:;
       C2d = GeomProjLib::Curve2d(C,f,l,S,Tol);
       //
       if (C2d.IsNull()) {
-       // proj. a circle that goes through the pole on a sphere to the sphere     
-       Tol=Tol+1.e-7;
-       C2d = GeomProjLib::Curve2d(C,f,l,S,Tol);
+        // proj. a circle that goes through the pole on a sphere to the sphere     
+        Tol=Tol+1.e-7;
+        C2d = GeomProjLib::Curve2d(C,f,l,S,Tol);
       }
     }
     else {
       if((l - f) > Epsilon(Abs(f))) {
-       GeomAPI_ProjectPointOnSurf aProjector1, aProjector2;
-       gp_Pnt P1 = C->Value(f);
-       gp_Pnt P2 = C->Value(l);
-       aProjector1.Init(P1, S);
-       aProjector2.Init(P2, S);
-
-       if(aProjector1.IsDone() && aProjector2.IsDone()) {
-         Standard_Real U=0., V=0.;
-         aProjector1.LowerDistanceParameters(U, V);
-         gp_Pnt2d p1(U, V);
-
-         aProjector2.LowerDistanceParameters(U, V);
-         gp_Pnt2d p2(U, V);
-
-         if(p1.Distance(p2) > gp::Resolution()) {
-           TColgp_Array1OfPnt2d poles(1,2);
-           TColStd_Array1OfReal knots(1,2);
-           TColStd_Array1OfInteger mults(1,2);
-           poles(1) = p1;
-           poles(2) = p2;
-           knots(1) = f;
-           knots(2) = l;
-           mults(1) = mults(2) = 2;
-
-           C2d = new Geom2d_BSplineCurve(poles,knots,mults,1);
-
-           // compute reached tolerance.begin
-           gp_Pnt PMid = C->Value((f + l) * 0.5);
-           aProjector1.Perform(PMid);
-
-           if(aProjector1.IsDone()) {
-             aProjector1.LowerDistanceParameters(U, V);
-             gp_Pnt2d pmidproj(U, V);
-             gp_Pnt2d pmidcurve2d = C2d->Value((f + l) * 0.5);
-             Standard_Real adist = pmidcurve2d.Distance(pmidproj);
-             Tol = (adist > Tol) ? adist : Tol;
-           }
-           // compute reached tolerance.end
-         }
-       }
+        GeomAPI_ProjectPointOnSurf aProjector1, aProjector2;
+        gp_Pnt P1 = C->Value(f);
+        gp_Pnt P2 = C->Value(l);
+        aProjector1.Init(P1, S);
+        aProjector2.Init(P2, S);
+
+        if(aProjector1.IsDone() && aProjector2.IsDone()) {
+          Standard_Real U=0., V=0.;
+          aProjector1.LowerDistanceParameters(U, V);
+          gp_Pnt2d p1(U, V);
+
+          aProjector2.LowerDistanceParameters(U, V);
+          gp_Pnt2d p2(U, V);
+
+          if(p1.Distance(p2) > gp::Resolution()) {
+            TColgp_Array1OfPnt2d poles(1,2);
+            TColStd_Array1OfReal knots(1,2);
+            TColStd_Array1OfInteger mults(1,2);
+            poles(1) = p1;
+            poles(2) = p2;
+            knots(1) = f;
+            knots(2) = l;
+            mults(1) = mults(2) = 2;
+
+            C2d = new Geom2d_BSplineCurve(poles,knots,mults,1);
+
+            // compute reached tolerance.begin
+            gp_Pnt PMid = C->Value((f + l) * 0.5);
+            aProjector1.Perform(PMid);
+
+            if(aProjector1.IsDone()) {
+              aProjector1.LowerDistanceParameters(U, V);
+              gp_Pnt2d pmidproj(U, V);
+              gp_Pnt2d pmidcurve2d = C2d->Value((f + l) * 0.5);
+              Standard_Real adist = pmidcurve2d.Distance(pmidproj);
+              Tol = (adist > Tol) ? adist : Tol;
+            }
+            // compute reached tolerance.end
+          }
+        }
       }
     }
     //
@@ -2398,17 +2408,17 @@ reapprox:;
       U0 = Min(Pl.X(), U0);
 //       while(U0-umin<aEps) { 
       while(U0-umin<-aEps) { 
-       U0+=period;
-       du+=period;
+        U0+=period;
+        du+=period;
       }
       //
       while(U0-umax>aEps) { 
-       U0-=period;
-       du-=period;
+        U0-=period;
+        du-=period;
       }
       if (du != 0) {
-       gp_Vec2d T1(du,0.);
-       C2d->Translate(T1);
+        gp_Vec2d T1(du,0.);
+        C2d->Translate(T1);
       }
     }
   }
@@ -2419,12 +2429,12 @@ reapprox:;
 //purpose  : 
 //=======================================================================
  void Parameters(const Handle(GeomAdaptor_HSurface)& HS1,
-                const Handle(GeomAdaptor_HSurface)& HS2,
-                const gp_Pnt& Ptref,
-                Standard_Real& U1,
-                Standard_Real& V1,
-                Standard_Real& U2,
-                Standard_Real& V2)
+                 const Handle(GeomAdaptor_HSurface)& HS2,
+                 const gp_Pnt& Ptref,
+                 Standard_Real& U1,
+                 Standard_Real& V1,
+                 Standard_Real& U2,
+                 Standard_Real& V2)
 {
 
   IntSurf_Quadric quad1,quad2;
@@ -2480,8 +2490,8 @@ reapprox:;
 //purpose  : 
 //=======================================================================
 Handle(Geom_Curve) MakeBSpline  (const Handle(IntPatch_WLine)& WL,
-                                const Standard_Integer ideb,
-                                const Standard_Integer ifin)
+                                 const Standard_Integer ideb,
+                                 const Standard_Integer ifin)
 {
   Standard_Integer i,nbpnt = ifin-ideb+1;
   TColgp_Array1OfPnt poles(1,nbpnt);
@@ -2504,9 +2514,9 @@ Handle(Geom_Curve) MakeBSpline  (const Handle(IntPatch_WLine)& WL,
 //purpose  : 
 //=======================================================================
 Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine,
-                                         const Standard_Integer ideb,
-                                         const Standard_Integer ifin,
-                                         const Standard_Boolean onFirst)
+                                          const Standard_Integer ideb,
+                                          const Standard_Integer ifin,
+                                          const Standard_Boolean onFirst)
 {
   Standard_Integer i, nbpnt = ifin-ideb+1;
   TColgp_Array1OfPnt2d poles(1,nbpnt);
@@ -2517,9 +2527,9 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
   for(i = 1, ipidebm1 = i+ideb-1; i <= nbpnt; ipidebm1++, i++) {
       Standard_Real U, V;
       if(onFirst)
-       theWLine->Point(ipidebm1).ParametersOnS1(U, V);
+        theWLine->Point(ipidebm1).ParametersOnS1(U, V);
       else
-       theWLine->Point(ipidebm1).ParametersOnS2(U, V);
+        theWLine->Point(ipidebm1).ParametersOnS2(U, V);
       poles(i).SetCoord(U, V);
       mults(i) = 1;
       knots(i) = i-1;
@@ -2549,13 +2559,13 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
       //
       aNbC=IntTools_Tools::SplitCurve(aIC, aSeqCvs);
       if (aNbC) {
-       for (j=1; j<=aNbC; ++j) {
-         const IntTools_Curve& aICNew=aSeqCvs(j);
-         aNewCvs.Append(aICNew);
-       }
+        for (j=1; j<=aNbC; ++j) {
+          const IntTools_Curve& aICNew=aSeqCvs(j);
+          aNewCvs.Append(aICNew);
+        }
       }
       else {
-       aNewCvs.Append(aIC);
+        aNewCvs.Append(aIC);
       }
     }
     else {
@@ -2575,21 +2585,21 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
       //
       aCType1=aNewCvs(1).Type();
       if (aCType1==GeomAbs_Line) {
-       IntTools_SequenceOfCurves aSeqIn, aSeqOut;
-       //
-       for (i=1; i<=aNbCurves; ++i) {
-         const IntTools_Curve& aIC=aNewCvs(i);
-         aSeqIn.Append(aIC);
-       }
-       //
-       IntTools_Tools::RejectLines(aSeqIn, aSeqOut);
-       //
-       aNewCvs.Clear();
-       aNbCurves=aSeqOut.Length(); 
-       for (i=1; i<=aNbCurves; ++i) {
-         const IntTools_Curve& aIC=aSeqOut(i);
-         aNewCvs.Append(aIC);
-       }
+        IntTools_SequenceOfCurves aSeqIn, aSeqOut;
+        //
+        for (i=1; i<=aNbCurves; ++i) {
+          const IntTools_Curve& aIC=aNewCvs(i);
+          aSeqIn.Append(aIC);
+        }
+        //
+        IntTools_Tools::RejectLines(aSeqIn, aSeqOut);
+        //
+        aNewCvs.Clear();
+        aNbCurves=aSeqOut.Length(); 
+        for (i=1; i<=aNbCurves; ++i) {
+          const IntTools_Curve& aIC=aSeqOut(i);
+          aNewCvs.Append(aIC);
+        }
       }
     }
   }// if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Cone)...
@@ -2607,11 +2617,11 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
 //purpose  : 
 //=======================================================================
  void CorrectSurfaceBoundaries(const TopoDS_Face&  theFace,
-                              const Standard_Real theTolerance,
-                              Standard_Real&      theumin,
-                              Standard_Real&      theumax, 
-                              Standard_Real&      thevmin, 
-                              Standard_Real&      thevmax) 
+                               const Standard_Real theTolerance,
+                               Standard_Real&      theumin,
+                               Standard_Real&      theumax, 
+                               Standard_Real&      thevmin, 
+                               Standard_Real&      thevmax) 
 {
   Standard_Boolean enlarge, isuperiodic, isvperiodic;
   Standard_Real uinf, usup, vinf, vsup, delta;
@@ -2695,22 +2705,22 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
       aXP=anAdaptorSurface.UPeriod();
       dXfact=theumax-theumin;
       if (dXfact-aTolPA>aXP) {
-       aXmid=0.5*(theumax+theumin);
-       aNbP=RealToInt(aXmid/aXP);
-       if (aXmid<0.) {
-         aNbP=aNbP-1;
-       }
-       aX1=aNbP*aXP;
-       if (theumin>aTolPA) {
-         aX1=theumin+aNbP*aXP;
-       }
-       aX2=aX1+aXP;
-       if (theumin<aX1) {
-         theumin=aX1;
-       }
-       if (theumax>aX2) {
-         theumax=aX2;
-       }
+        aXmid=0.5*(theumax+theumin);
+        aNbP=RealToInt(aXmid/aXP);
+        if (aXmid<0.) {
+          aNbP=aNbP-1;
+        }
+        aX1=aNbP*aXP;
+        if (theumin>aTolPA) {
+          aX1=theumin+aNbP*aXP;
+        }
+        aX2=aX1+aXP;
+        if (theumin<aX1) {
+          theumin=aX1;
+        }
+        if (theumax>aX2) {
+          theumax=aX2;
+        }
       }
     }
     // V
@@ -2718,22 +2728,22 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
       aXP=anAdaptorSurface.VPeriod();
       dXfact=thevmax-thevmin;
       if (dXfact-aTolPA>aXP) {
-       aXmid=0.5*(thevmax+thevmin);
-       aNbP=RealToInt(aXmid/aXP);
-       if (aXmid<0.) {
-         aNbP=aNbP-1;
-       }
-       aX1=aNbP*aXP;
-       if (thevmin>aTolPA) {
-         aX1=thevmin+aNbP*aXP;
-       }
-       aX2=aX1+aXP;
-       if (thevmin<aX1) {
-         thevmin=aX1;
-       }
-       if (thevmax>aX2) {
-         thevmax=aX2;
-       }
+        aXmid=0.5*(thevmax+thevmin);
+        aNbP=RealToInt(aXmid/aXP);
+        if (aXmid<0.) {
+          aNbP=aNbP-1;
+        }
+        aX1=aNbP*aXP;
+        if (thevmin>aTolPA) {
+          aX1=thevmin+aNbP*aXP;
+        }
+        aX2=aX1+aXP;
+        if (thevmin<aX1) {
+          thevmin=aX1;
+        }
+        if (thevmax>aX2) {
+          thevmax=aX2;
+        }
       }
     }
   }
@@ -2747,43 +2757,43 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
 
     for(anExp.Init(theFace, TopAbs_EDGE); anExp.More(); anExp.Next()) {
       if(BRep_Tool::IsClosed(TopoDS::Edge(anExp.Current()), theFace)) {
-       correct = Standard_True;
-       Standard_Real f, l;
-       TopoDS_Edge anEdge = TopoDS::Edge(anExp.Current());
-       
-       for(Standard_Integer i = 0; i < 2; i++) {
-         if(i==0) {
-           anEdge.Orientation(TopAbs_FORWARD);
-         }
-         else {
-           anEdge.Orientation(TopAbs_REVERSED);
-         }
-         Handle(Geom2d_Curve) aCurve = BRep_Tool::CurveOnSurface(anEdge, theFace, f, l);
-         
-         if(aCurve.IsNull()) {
-           correct = Standard_False;
-           break;
-         }
-         Handle(Geom2d_Line) aLine = Handle(Geom2d_Line)::DownCast(aCurve);
-
-         if(aLine.IsNull()) {
-           correct = Standard_False;
-           break;
-         }
-         gp_Dir2d anUDir(1., 0.);
-         gp_Dir2d aVDir(0., 1.);
-         Standard_Real anAngularTolerance = Precision::Angular();
-
-         correctU = correctU || aLine->Position().Direction().IsParallel(aVDir, anAngularTolerance);
-         correctV = correctV || aLine->Position().Direction().IsParallel(anUDir, anAngularTolerance);
-         
-         gp_Pnt2d pp1 = aCurve->Value(f);
-         aBox.Add(pp1);
-         gp_Pnt2d pp2 = aCurve->Value(l);
-         aBox.Add(pp2);
-       }
-       if(!correct)
-         break;
+        correct = Standard_True;
+        Standard_Real f, l;
+        TopoDS_Edge anEdge = TopoDS::Edge(anExp.Current());
+        
+        for(Standard_Integer i = 0; i < 2; i++) {
+          if(i==0) {
+            anEdge.Orientation(TopAbs_FORWARD);
+          }
+          else {
+            anEdge.Orientation(TopAbs_REVERSED);
+          }
+          Handle(Geom2d_Curve) aCurve = BRep_Tool::CurveOnSurface(anEdge, theFace, f, l);
+          
+          if(aCurve.IsNull()) {
+            correct = Standard_False;
+            break;
+          }
+          Handle(Geom2d_Line) aLine = Handle(Geom2d_Line)::DownCast(aCurve);
+
+          if(aLine.IsNull()) {
+            correct = Standard_False;
+            break;
+          }
+          gp_Dir2d anUDir(1., 0.);
+          gp_Dir2d aVDir(0., 1.);
+          Standard_Real anAngularTolerance = Precision::Angular();
+
+          correctU = correctU || aLine->Position().Direction().IsParallel(aVDir, anAngularTolerance);
+          correctV = correctV || aLine->Position().Direction().IsParallel(anUDir, anAngularTolerance);
+          
+          gp_Pnt2d pp1 = aCurve->Value(f);
+          aBox.Add(pp1);
+          gp_Pnt2d pp2 = aCurve->Value(l);
+          aBox.Add(pp2);
+        }
+        if(!correct)
+          break;
       }
     }
 
@@ -2792,20 +2802,20 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
       aBox.Get(umin, vmin, umax, vmax);
 
       if(isuperiodic && correctU) {
-       
-       if(theumin < umin)
-         theumin = umin;
-       
-       if(theumax > umax) {
-         theumax = umax;
-       }
+        
+        if(theumin < umin)
+          theumin = umin;
+        
+        if(theumax > umax) {
+          theumax = umax;
+        }
       }
       if(isvperiodic && correctV) {
-       
-       if(thevmin < vmin)
-         thevmin = vmin;
-       if(thevmax > vmax)
-         thevmax = vmax;
+        
+        if(thevmin < vmin)
+          thevmin = vmin;
+        if(thevmax > vmax)
+          thevmax = vmax;
       }
     }
   }
@@ -2823,21 +2833,21 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
 
 static
   Standard_Boolean IsDegeneratedZone(const gp_Pnt2d& aP2d,
-                                    const Handle(Geom_Surface)& aS,
-                                    const Standard_Integer iDir);
+                                     const Handle(Geom_Surface)& aS,
+                                     const Standard_Integer iDir);
 static
   Standard_Boolean IsPointInDegeneratedZone(const IntSurf_PntOn2S& aP2S,
-                                           const TopoDS_Face& aF1,
-                                           const TopoDS_Face& aF2);
+                                            const TopoDS_Face& aF1,
+                                            const TopoDS_Face& aF2);
 //=======================================================================
 //function :  NotUseSurfacesForApprox
 //purpose  : 
 //=======================================================================
 Standard_Boolean NotUseSurfacesForApprox(const TopoDS_Face& aF1,
-                                        const TopoDS_Face& aF2,
-                                        const Handle(IntPatch_WLine)& WL,
-                                        const Standard_Integer ifprm,
-                                        const Standard_Integer ilprm)
+                                         const TopoDS_Face& aF2,
+                                         const Handle(IntPatch_WLine)& WL,
+                                         const Standard_Integer ifprm,
+                                         const Standard_Integer ilprm)
 {
   Standard_Boolean bPInDZ;
 
@@ -2859,9 +2869,9 @@ Standard_Boolean NotUseSurfacesForApprox(const TopoDS_Face& aF1,
 //purpose  : 
 //=======================================================================
 Standard_Boolean IsPointInDegeneratedZone(const IntSurf_PntOn2S& aP2S,
-                                         const TopoDS_Face& aF1,
-                                         const TopoDS_Face& aF2)
-                                         
+                                          const TopoDS_Face& aF1,
+                                          const TopoDS_Face& aF2)
+                                          
 {
   Standard_Boolean bFlag=Standard_True;
   Standard_Real US11, US12, VS11, VS12, US21, US22, VS21, VS22;
@@ -2944,8 +2954,8 @@ Standard_Boolean IsPointInDegeneratedZone(const IntSurf_PntOn2S& aP2S,
 //purpose  : 
 //=======================================================================
 Standard_Boolean IsDegeneratedZone(const gp_Pnt2d& aP2d,
-                                  const Handle(Geom_Surface)& aS,
-                                  const Standard_Integer iDir)
+                                   const Handle(Geom_Surface)& aS,
+                                   const Standard_Integer iDir)
 {
   Standard_Boolean bFlag=Standard_True;
   Standard_Real US1, US2, VS1, VS2, dY, dX, d1, d2, dD;
@@ -3056,26 +3066,26 @@ Handle(IntPatch_WLine) ComputePurgedWLine(const Handle(IntPatch_WLine)& theWLine
     while(k <= anEndIndex) {
       
       if(i != k) {
-       IntSurf_PntOn2S p1 = aLineOn2S->Value(i);
-       IntSurf_PntOn2S p2 = aLineOn2S->Value(k);
-       
-       if(p1.Value().IsEqual(p2.Value(), gp::Resolution())) {
-         aTmpWLine = aLocalWLine;
-         aLocalWLine = new IntPatch_WLine(aLineOn2S, Standard_False);
-
-         for(v = 1; v <= aTmpWLine->NbVertex(); v++) {
-           IntPatch_Point aVertex = aTmpWLine->Vertex(v);
-           Standard_Integer avertexindex = (Standard_Integer)aVertex.ParameterOnLine();
-
-           if(avertexindex >= k) {
-             aVertex.SetParameter(aVertex.ParameterOnLine() - 1.);
-           }
-           aLocalWLine->AddVertex(aVertex);
-         }
-         aLineOn2S->RemovePoint(k);
-         anEndIndex--;
-         continue;
-       }
+        IntSurf_PntOn2S p1 = aLineOn2S->Value(i);
+        IntSurf_PntOn2S p2 = aLineOn2S->Value(k);
+        
+        if(p1.Value().IsEqual(p2.Value(), gp::Resolution())) {
+          aTmpWLine = aLocalWLine;
+          aLocalWLine = new IntPatch_WLine(aLineOn2S, Standard_False);
+
+          for(v = 1; v <= aTmpWLine->NbVertex(); v++) {
+            IntPatch_Point aVertex = aTmpWLine->Vertex(v);
+            Standard_Integer avertexindex = (Standard_Integer)aVertex.ParameterOnLine();
+
+            if(avertexindex >= k) {
+              aVertex.SetParameter(aVertex.ParameterOnLine() - 1.);
+            }
+            aLocalWLine->AddVertex(aVertex);
+          }
+          aLineOn2S->RemovePoint(k);
+          anEndIndex--;
+          continue;
+        }
       }
       k++;
     }
@@ -3092,8 +3102,8 @@ Handle(IntPatch_WLine) ComputePurgedWLine(const Handle(IntPatch_WLine)& theWLine
 //purpose  : 
 //=======================================================================
 void TolR3d(const TopoDS_Face& aF1,
-           const TopoDS_Face& aF2,
-           Standard_Real& myTolReached3d)
+            const TopoDS_Face& aF2,
+            Standard_Real& myTolReached3d)
 {
   Standard_Real aTolF1, aTolF2, aTolFMax, aTolTresh;
       
@@ -3111,10 +3121,10 @@ void TolR3d(const TopoDS_Face& aF1,
 //purpose  : 
 //=======================================================================
 Standard_Real AdjustPeriodic(const Standard_Real theParameter,
-                            const Standard_Real parmin,
-                            const Standard_Real parmax,
-                            const Standard_Real thePeriod,
-                            Standard_Real&      theOffset) 
+                             const Standard_Real parmin,
+                             const Standard_Real parmax,
+                             const Standard_Real thePeriod,
+                             Standard_Real&      theOffset) 
 {
   Standard_Real aresult;
   //
@@ -3136,10 +3146,10 @@ Standard_Real AdjustPeriodic(const Standard_Real theParameter,
 //purpose  : 
 //=======================================================================
 Standard_Boolean IsPointOnBoundary(const Standard_Real theParameter,
-                                  const Standard_Real theFirstBoundary,
-                                  const Standard_Real theSecondBoundary,
-                                  const Standard_Real theResolution,
-                                  Standard_Boolean&   IsOnFirstBoundary) 
+                                   const Standard_Real theFirstBoundary,
+                                   const Standard_Real theSecondBoundary,
+                                   const Standard_Real theResolution,
+                                   Standard_Boolean&   IsOnFirstBoundary) 
 {
   Standard_Boolean bRet;
   Standard_Integer i;
@@ -3165,12 +3175,12 @@ Standard_Boolean IsPointOnBoundary(const Standard_Real theParameter,
 // purpose:
 // ------------------------------------------------------------------------------------------------
 Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
-                          const gp_Pnt2d&     theLastPoint,
-                          const Standard_Real theUmin, 
-                          const Standard_Real theUmax,
-                          const Standard_Real theVmin,
-                          const Standard_Real theVmax,
-                          gp_Pnt2d&           theNewPoint) {
+                           const gp_Pnt2d&     theLastPoint,
+                           const Standard_Real theUmin, 
+                           const Standard_Real theUmax,
+                           const Standard_Real theVmin,
+                           const Standard_Real theVmax,
+                           gp_Pnt2d&           theNewPoint) {
   
   gp_Vec2d aVec(theFirstPoint, theLastPoint);
   Standard_Integer i = 0, j = 0;
@@ -3187,9 +3197,9 @@ Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
       anOtherVecNormal.SetY(0.);
 
       if(i < 2)
-       aprojpoint.SetX(theUmin);
+        aprojpoint.SetX(theUmin);
       else
-       aprojpoint.SetX(theUmax);
+        aprojpoint.SetX(theUmax);
     }
     else {
       anOtherVec.SetX(1.);
@@ -3198,9 +3208,9 @@ Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
       anOtherVecNormal.SetY(1.);
 
       if(i < 2)
-       aprojpoint.SetY(theVmin);
+        aprojpoint.SetY(theVmin);
       else
-       aprojpoint.SetY(theVmax);
+        aprojpoint.SetY(theVmax);
     }
     gp_Vec2d anormvec = aVec;
     anormvec.Normalize();
@@ -3227,7 +3237,7 @@ Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
       gp_Pnt2d acurpoint(aprojpoint.XY() + (anOtherVec.XY()*anoffset));
       gp_Vec2d acurvec(theLastPoint, acurpoint);
       if ( bIsOut )
-       acurvec.Reverse();
+        acurvec.Reverse();
 
       Standard_Real aDotX, anAngleX;
       //
@@ -3235,20 +3245,20 @@ Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
       anAngleX = aVec.Angle(acurvec);
       //
       if(aDotX > 0. && fabs(anAngleX) < Precision::PConfusion()) {
-       if((i % 2) == 0) {
-         if((acurpoint.Y() >= theVmin) &&
-            (acurpoint.Y() <= theVmax)) {
-           theNewPoint = acurpoint;
-           return Standard_True;
-         }
-       }
-       else {
-         if((acurpoint.X() >= theUmin) &&
-            (acurpoint.X() <= theUmax)) {
-           theNewPoint = acurpoint;
-           return Standard_True;
-         }
-       }
+        if((i % 2) == 0) {
+          if((acurpoint.Y() >= theVmin) &&
+             (acurpoint.Y() <= theVmax)) {
+            theNewPoint = acurpoint;
+            return Standard_True;
+          }
+        }
+        else {
+          if((acurpoint.X() >= theUmin) &&
+             (acurpoint.X() <= theUmax)) {
+            theNewPoint = acurpoint;
+            return Standard_True;
+          }
+        }
       }
     }
   }
@@ -3261,15 +3271,15 @@ Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
 // purpose: Find point on the boundary of radial tangent zone
 // ------------------------------------------------------------------------------------------------
 Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
-                          const gp_Pnt2d&     theLastPoint,
-                          const Standard_Real theUmin, 
-                          const Standard_Real theUmax,
-                          const Standard_Real theVmin,
-                          const Standard_Real theVmax,
-                          const gp_Pnt2d&     theTanZoneCenter,
-                          const Standard_Real theZoneRadius,
-                          Handle(GeomAdaptor_HSurface) theGASurface,
-                          gp_Pnt2d&           theNewPoint) {
+                           const gp_Pnt2d&     theLastPoint,
+                           const Standard_Real theUmin, 
+                           const Standard_Real theUmax,
+                           const Standard_Real theVmin,
+                           const Standard_Real theVmax,
+                           const gp_Pnt2d&     theTanZoneCenter,
+                           const Standard_Real theZoneRadius,
+                           Handle(GeomAdaptor_HSurface) theGASurface,
+                           gp_Pnt2d&           theNewPoint) {
   theNewPoint = theLastPoint;
 
   if ( !IsInsideTanZone( theLastPoint, theTanZoneCenter, theZoneRadius, theGASurface) )
@@ -3310,9 +3320,9 @@ Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
     gp_Pnt2d aPInt = anIntersector.Point( i );
     if ( aPInt.SquareDistance( theFirstPoint ) < aMinDist ) {
       if ( ( aPInt.X() >= theUmin ) && ( aPInt.X() <= theUmax ) &&
-          ( aPInt.Y() >= theVmin ) && ( aPInt.Y() <= theVmax ) ) {
-       theNewPoint = aPInt;
-       aFound = Standard_True;
+           ( aPInt.Y() >= theVmin ) && ( aPInt.Y() <= theVmax ) ) {
+        theNewPoint = aPInt;
+        aFound = Standard_True;
       }
     }
   }
@@ -3325,9 +3335,9 @@ Standard_Boolean FindPoint(const gp_Pnt2d&     theFirstPoint,
 // purpose: Check if point is inside a radial tangent zone
 // ------------------------------------------------------------------------------------------------
 Standard_Boolean IsInsideTanZone(const gp_Pnt2d&     thePoint,
-                                const gp_Pnt2d&     theTanZoneCenter,
-                                const Standard_Real theZoneRadius,
-                                Handle(GeomAdaptor_HSurface) theGASurface) {
+                                 const gp_Pnt2d&     theTanZoneCenter,
+                                 const Standard_Real theZoneRadius,
+                                 Handle(GeomAdaptor_HSurface) theGASurface) {
 
   Standard_Real aUResolution = theGASurface->UResolution( theZoneRadius );
   Standard_Real aVResolution = theGASurface->VResolution( theZoneRadius );
@@ -3343,7 +3353,7 @@ Standard_Boolean IsInsideTanZone(const gp_Pnt2d&     thePoint,
 // purpose: Check if tangent zone exists
 // ------------------------------------------------------------------------------------------------
 Standard_Boolean CheckTangentZonesExist( const Handle(GeomAdaptor_HSurface)& theSurface1,
-                                       const Handle(GeomAdaptor_HSurface)&  theSurface2 ) 
+                                        const Handle(GeomAdaptor_HSurface)&  theSurface2 ) 
 {
   if ( ( theSurface1->GetType() != GeomAbs_Torus ) ||
       ( theSurface2->GetType() != GeomAbs_Torus ) )
@@ -3370,13 +3380,13 @@ Standard_Boolean CheckTangentZonesExist( const Handle(GeomAdaptor_HSurface)& the
 // purpose: 
 // ------------------------------------------------------------------------------------------------
 Standard_Integer ComputeTangentZones( const Handle(GeomAdaptor_HSurface)& theSurface1,
-                                    const Handle(GeomAdaptor_HSurface)&  theSurface2,
-                                    const TopoDS_Face&                   theFace1,
-                                    const TopoDS_Face&                   theFace2,
-                                    Handle(TColgp_HArray1OfPnt2d)&       theResultOnS1,
-                                    Handle(TColgp_HArray1OfPnt2d)&       theResultOnS2,
-                                    Handle(TColStd_HArray1OfReal)&       theResultRadius,
-                                    const Handle(BOPInt_Context)& aContext)
+                                     const Handle(GeomAdaptor_HSurface)&  theSurface2,
+                                     const TopoDS_Face&                   theFace1,
+                                     const TopoDS_Face&                   theFace2,
+                                     Handle(TColgp_HArray1OfPnt2d)&       theResultOnS1,
+                                     Handle(TColgp_HArray1OfPnt2d)&       theResultOnS2,
+                                     Handle(TColStd_HArray1OfReal)&       theResultRadius,
+                                     const Handle(BOPInt_Context)& aContext)
 {
   Standard_Integer aResult = 0;
   if ( !CheckTangentZonesExist( theSurface1, theSurface2 ) )
@@ -3438,80 +3448,80 @@ Standard_Integer ComputeTangentZones( const Handle(GeomAdaptor_HSurface)& theSur
     GeomAdaptor_Curve aC1( new Geom_Circle(aCircle1) );
     GeomAdaptor_Curve aC2( new Geom_Circle(aCircle2) );
     Extrema_ExtCC anExtrema(aC1, aC2, 0, 2. * M_PI, 0, 2. * M_PI, 
-                           Precision::PConfusion(), Precision::PConfusion());
-       
+                            Precision::PConfusion(), Precision::PConfusion());
+            
     if ( anExtrema.IsDone() ) {
 
       Standard_Integer i = 0;
       for ( i = 1; i <= anExtrema.NbExt(); i++ ) {
-       if ( anExtrema.SquareDistance(i) > aCriteria * aCriteria )
-         continue;
-
-       Extrema_POnCurv P1, P2;
-       anExtrema.Points( i, P1, P2 );
-
-       Standard_Boolean bFoundResult = Standard_True;
-       gp_Pnt2d pr1, pr2;
-
-       Standard_Integer surfit = 0;
-       for ( surfit = 0; surfit < 2; surfit++ ) {
-         GeomAPI_ProjectPointOnSurf& aProjector = 
-           (surfit == 0) ? aContext->ProjPS(theFace1) : aContext->ProjPS(theFace2);
-
-         gp_Pnt aP3d = (surfit == 0) ? P1.Value() : P2.Value();
-         aProjector.Perform(aP3d);
-
-         if(!aProjector.IsDone())
-           bFoundResult = Standard_False;
-         else {
-           if(aProjector.LowerDistance() > aCriteria) {
-             bFoundResult = Standard_False;
-           }
-           else {
-             Standard_Real foundU = 0, foundV = 0;
-             aProjector.LowerDistanceParameters(foundU, foundV);
-             if ( surfit == 0 )
-               pr1 = gp_Pnt2d( foundU, foundV );
-             else
-               pr2 = gp_Pnt2d( foundU, foundV );
-           }
-         }
-       }
-       if ( bFoundResult ) {
-         aSeqResultS1.Append( pr1 );
-         aSeqResultS2.Append( pr2 );
-         aSeqResultRad.Append( aCriteria );
-
-         // torus is u and v periodic
-         const Standard_Real twoPI = M_PI + M_PI;
-         Standard_Real arr1tmp[2] = {pr1.X(), pr1.Y()};
-         Standard_Real arr2tmp[2] = {pr2.X(), pr2.Y()};
-
-         // iteration on period bounds
-         for ( Standard_Integer k1 = 0; k1 < 2; k1++ ) {
-           Standard_Real aBound = ( k1 == 0 ) ? 0 : twoPI;
-           Standard_Real aShift = ( k1 == 0 ) ? twoPI : -twoPI;
-
-           // iteration on surfaces
-           for ( Standard_Integer k2 = 0; k2 < 2; k2++ ) {
-             Standard_Real* arr1 = ( k2 == 0 ) ? arr1tmp : arr2tmp;
-             Standard_Real* arr2 = ( k2 != 0 ) ? arr1tmp : arr2tmp;
-             TColgp_SequenceOfPnt2d& aSeqS1 = ( k2 == 0 ) ? aSeqResultS1 : aSeqResultS2; 
-             TColgp_SequenceOfPnt2d& aSeqS2 = ( k2 != 0 ) ? aSeqResultS1 : aSeqResultS2; 
-
-             if (fabs(arr1[0] - aBound) < Precision::PConfusion()) {
-               aSeqS1.Append( gp_Pnt2d( arr1[0] + aShift, arr1[1] ) );
-               aSeqS2.Append( gp_Pnt2d( arr2[0], arr2[1] ) );
-               aSeqResultRad.Append( aCriteria );
-             }
-             if (fabs(arr1[1] - aBound) < Precision::PConfusion()) {
-               aSeqS1.Append( gp_Pnt2d( arr1[0], arr1[1] + aShift) );
-               aSeqS2.Append( gp_Pnt2d( arr2[0], arr2[1] ) );
-               aSeqResultRad.Append( aCriteria );
-             }
-           }
-         } //
-       }
+        if ( anExtrema.SquareDistance(i) > aCriteria * aCriteria )
+          continue;
+
+        Extrema_POnCurv P1, P2;
+        anExtrema.Points( i, P1, P2 );
+
+        Standard_Boolean bFoundResult = Standard_True;
+        gp_Pnt2d pr1, pr2;
+
+        Standard_Integer surfit = 0;
+        for ( surfit = 0; surfit < 2; surfit++ ) {
+          GeomAPI_ProjectPointOnSurf& aProjector = 
+            (surfit == 0) ? aContext->ProjPS(theFace1) : aContext->ProjPS(theFace2);
+
+          gp_Pnt aP3d = (surfit == 0) ? P1.Value() : P2.Value();
+          aProjector.Perform(aP3d);
+
+          if(!aProjector.IsDone())
+            bFoundResult = Standard_False;
+          else {
+            if(aProjector.LowerDistance() > aCriteria) {
+              bFoundResult = Standard_False;
+            }
+            else {
+              Standard_Real foundU = 0, foundV = 0;
+              aProjector.LowerDistanceParameters(foundU, foundV);
+              if ( surfit == 0 )
+                pr1 = gp_Pnt2d( foundU, foundV );
+              else
+                pr2 = gp_Pnt2d( foundU, foundV );
+            }
+          }
+        }
+        if ( bFoundResult ) {
+          aSeqResultS1.Append( pr1 );
+          aSeqResultS2.Append( pr2 );
+          aSeqResultRad.Append( aCriteria );
+
+          // torus is u and v periodic
+          const Standard_Real twoPI = M_PI + M_PI;
+          Standard_Real arr1tmp[2] = {pr1.X(), pr1.Y()};
+          Standard_Real arr2tmp[2] = {pr2.X(), pr2.Y()};
+
+          // iteration on period bounds
+          for ( Standard_Integer k1 = 0; k1 < 2; k1++ ) {
+            Standard_Real aBound = ( k1 == 0 ) ? 0 : twoPI;
+            Standard_Real aShift = ( k1 == 0 ) ? twoPI : -twoPI;
+
+            // iteration on surfaces
+            for ( Standard_Integer k2 = 0; k2 < 2; k2++ ) {
+              Standard_Real* arr1 = ( k2 == 0 ) ? arr1tmp : arr2tmp;
+              Standard_Real* arr2 = ( k2 != 0 ) ? arr1tmp : arr2tmp;
+              TColgp_SequenceOfPnt2d& aSeqS1 = ( k2 == 0 ) ? aSeqResultS1 : aSeqResultS2; 
+              TColgp_SequenceOfPnt2d& aSeqS2 = ( k2 != 0 ) ? aSeqResultS1 : aSeqResultS2; 
+
+              if (fabs(arr1[0] - aBound) < Precision::PConfusion()) {
+                aSeqS1.Append( gp_Pnt2d( arr1[0] + aShift, arr1[1] ) );
+                aSeqS2.Append( gp_Pnt2d( arr2[0], arr2[1] ) );
+                aSeqResultRad.Append( aCriteria );
+              }
+              if (fabs(arr1[1] - aBound) < Precision::PConfusion()) {
+                aSeqS1.Append( gp_Pnt2d( arr1[0], arr1[1] + aShift) );
+                aSeqS2.Append( gp_Pnt2d( arr2[0], arr2[1] ) );
+                aSeqResultRad.Append( aCriteria );
+              }
+            }
+          } //
+        }
       }
     }
   }
@@ -3536,8 +3546,8 @@ Standard_Integer ComputeTangentZones( const Handle(GeomAdaptor_HSurface)& theSur
 // purpose:
 // ------------------------------------------------------------------------------------------------
 gp_Pnt2d AdjustByNeighbour(const gp_Pnt2d&     theaNeighbourPoint,
-                          const gp_Pnt2d&     theOriginalPoint,
-                          Handle(GeomAdaptor_HSurface) theGASurface) {
+                           const gp_Pnt2d&     theOriginalPoint,
+                           Handle(GeomAdaptor_HSurface) theGASurface) {
   
   gp_Pnt2d ap1 = theaNeighbourPoint;
   gp_Pnt2d ap2 = theOriginalPoint;
@@ -3552,8 +3562,8 @@ gp_Pnt2d AdjustByNeighbour(const gp_Pnt2d&     theaNeighbourPoint,
       Standard_Real dd = ap1.SquareDistance( aPTest );
 
       if ( dd < aSqDistMin ) {
-       ap2 = aPTest;
-       aSqDistMin = dd;
+        ap2 = aPTest;
+        aSqDistMin = dd;
       }
     }
   }
@@ -3567,8 +3577,8 @@ gp_Pnt2d AdjustByNeighbour(const gp_Pnt2d&     theaNeighbourPoint,
       Standard_Real dd = ap1.SquareDistance( aPTest );
 
       if ( dd < aSqDistMin ) {
-       ap2 = aPTest;
-       aSqDistMin = dd;
+        ap2 = aPTest;
+        aSqDistMin = dd;
       }
     }
   }
@@ -3580,15 +3590,15 @@ gp_Pnt2d AdjustByNeighbour(const gp_Pnt2d&     theaNeighbourPoint,
 // purpose:
 // ------------------------------------------------------------------------------------------------
 Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
-                                     const Handle(GeomAdaptor_HSurface)&            theSurface1, 
-                                     const Handle(GeomAdaptor_HSurface)&            theSurface2,
-                                     const TopoDS_Face&                             theFace1,
-                                     const TopoDS_Face&                             theFace2,
-                                     const IntTools_LineConstructor&                theLConstructor,
-                                     const Standard_Boolean                         theAvoidLConstructor,
-                                     IntPatch_SequenceOfLine&                       theNewLines,
-                                     Standard_Real&                                 theReachedTol3d,
-                                     const Handle(BOPInt_Context)& aContext) 
+                                      const Handle(GeomAdaptor_HSurface)&            theSurface1, 
+                                      const Handle(GeomAdaptor_HSurface)&            theSurface2,
+                                      const TopoDS_Face&                             theFace1,
+                                      const TopoDS_Face&                             theFace2,
+                                      const IntTools_LineConstructor&                theLConstructor,
+                                      const Standard_Boolean                         theAvoidLConstructor,
+                                      IntPatch_SequenceOfLine&                       theNewLines,
+                                      Standard_Real&                                 theReachedTol3d,
+                                      const Handle(BOPInt_Context)& aContext) 
 {
 
   Standard_Boolean bRet, bAvoidLineConstructor;
@@ -3619,7 +3629,7 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
   Handle(TColgp_HArray1OfPnt2d) aTanZoneS2;
   Handle(TColStd_HArray1OfReal) aTanZoneRadius;
   Standard_Integer aNbZone = ComputeTangentZones( theSurface1, theSurface2, theFace1, theFace2,
-                                                aTanZoneS1, aTanZoneS2, aTanZoneRadius, aContext);
+                                                 aTanZoneS1, aTanZoneS2, aTanZoneRadius, aContext);
   
   //
   nblines=0;
@@ -3645,83 +3655,83 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
       Handle(GeomAdaptor_HSurface) aGASurface = (!i) ? theSurface1 : theSurface2;
       aGASurface->ChangeSurface().Surface()->Bounds(umin, umax, vmin, vmax);
       if(!i) {
-       aPoint.ParametersOnS1(U, V);
+        aPoint.ParametersOnS1(U, V);
       }
       else {
-       aPoint.ParametersOnS2(U, V);
+        aPoint.ParametersOnS2(U, V);
       }
       // U, V
       for(j = 0; j < 2; j++) {
-       isperiodic = (!j) ? aGASurface->IsUPeriodic() : aGASurface->IsVPeriodic();
-       if(!isperiodic){
-         continue;
-       }
-       //
-       if (!j) {
-         aResolution=aGASurface->UResolution(aTol);
-         aPeriod=aGASurface->UPeriod();
-         alowerboundary=umin;
-         aupperboundary=umax;
-         aParameter=U;
-       }
-       else {
-         aResolution=aGASurface->VResolution(aTol);
-         aPeriod=aGASurface->VPeriod();
-         alowerboundary=vmin;
-         aupperboundary=vmax;
-         aParameter=V;
-       }
-       
-       anoffset = 0.;
-       anAdjustPar = AdjustPeriodic(aParameter, 
-                                    alowerboundary, 
-                                    aupperboundary, 
-                                    aPeriod, 
-                                    anoffset);
-       //
-       bIsOnFirstBoundary = Standard_True;// ?
-       bIsPointOnBoundary=
-         IsPointOnBoundary(anAdjustPar, 
-                           alowerboundary, 
-                           aupperboundary,
-                           aResolution, 
-                           bIsOnFirstBoundary);
-       //
-       if(bIsPointOnBoundary) {
-         bIsCurrentPointOnBoundary = Standard_True;
-         break;
-       }
-       else {
-         // check if a point belong to a tangent zone. Begin
-         Standard_Integer zIt = 0;
-         for ( zIt = 1; zIt <= aNbZone; zIt++ ) {
-           gp_Pnt2d aPZone = (i == 0) ? aTanZoneS1->Value(zIt) : aTanZoneS2->Value(zIt);
-           Standard_Real aZoneRadius = aTanZoneRadius->Value(zIt);
-
-           if ( IsInsideTanZone(gp_Pnt2d( U, V ), aPZone, aZoneRadius, aGASurface ) ) {
-             // set boundary flag to split the curve by a tangent zone
-             bIsPointOnBoundary = Standard_True;
-             bIsCurrentPointOnBoundary = Standard_True;
-             if ( theReachedTol3d < aZoneRadius ) {
-               theReachedTol3d = aZoneRadius;
-             }
-             break;
-           }
-         }
-       }
+        isperiodic = (!j) ? aGASurface->IsUPeriodic() : aGASurface->IsVPeriodic();
+        if(!isperiodic){
+          continue;
+        }
+        //
+        if (!j) {
+          aResolution=aGASurface->UResolution(aTol);
+          aPeriod=aGASurface->UPeriod();
+          alowerboundary=umin;
+          aupperboundary=umax;
+          aParameter=U;
+        }
+        else {
+          aResolution=aGASurface->VResolution(aTol);
+          aPeriod=aGASurface->VPeriod();
+          alowerboundary=vmin;
+          aupperboundary=vmax;
+          aParameter=V;
+        }
+        
+        anoffset = 0.;
+        anAdjustPar = AdjustPeriodic(aParameter, 
+                                     alowerboundary, 
+                                     aupperboundary, 
+                                     aPeriod, 
+                                     anoffset);
+        //
+        bIsOnFirstBoundary = Standard_True;// ?
+        bIsPointOnBoundary=
+          IsPointOnBoundary(anAdjustPar, 
+                            alowerboundary, 
+                            aupperboundary,
+                            aResolution, 
+                            bIsOnFirstBoundary);
+        //
+        if(bIsPointOnBoundary) {
+          bIsCurrentPointOnBoundary = Standard_True;
+          break;
+        }
+        else {
+          // check if a point belong to a tangent zone. Begin
+          Standard_Integer zIt = 0;
+          for ( zIt = 1; zIt <= aNbZone; zIt++ ) {
+            gp_Pnt2d aPZone = (i == 0) ? aTanZoneS1->Value(zIt) : aTanZoneS2->Value(zIt);
+            Standard_Real aZoneRadius = aTanZoneRadius->Value(zIt);
+
+            if ( IsInsideTanZone(gp_Pnt2d( U, V ), aPZone, aZoneRadius, aGASurface ) ) {
+              // set boundary flag to split the curve by a tangent zone
+              bIsPointOnBoundary = Standard_True;
+              bIsCurrentPointOnBoundary = Standard_True;
+              if ( theReachedTol3d < aZoneRadius ) {
+                theReachedTol3d = aZoneRadius;
+              }
+              break;
+            }
+          }
+        }
       }//for(j = 0; j < 2; j++) {
 
       if(bIsCurrentPointOnBoundary){
-       break;
+        break;
       }
     }//for(i = 0; i < 2; ++i) {
     //
     if((bIsCurrentPointOnBoundary != bIsPrevPointOnBoundary)) {
       if(!aListOfPointIndex.IsEmpty()) {
-       nblines++;
-       anArrayOfLines.SetValue(nblines, aListOfPointIndex);
-       anArrayOfLineType.SetValue(nblines, bIsPrevPointOnBoundary);
-       aListOfPointIndex.Clear();
+        nblines++;
+        anArrayOfLines.SetValue(nblines, aListOfPointIndex);
+        anArrayOfLineType.SetValue(nblines, bIsPrevPointOnBoundary);
+        aListOfPointIndex.Clear();
       }
       bIsPrevPointOnBoundary = bIsCurrentPointOnBoundary;
     }
@@ -3758,10 +3768,10 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
       Standard_Integer aneighbourindex = (j == 0) ? (i - 1) : (i + 1);
 
       if((aneighbourindex < 1) || (aneighbourindex > nblines))
-       continue;
+        continue;
 
       if(anArrayOfLineType.Value(aneighbourindex) == 0)
-       continue;
+        continue;
       const TColStd_ListOfInteger& aNeighbour = anArrayOfLines.Value(aneighbourindex);
       Standard_Integer anIndex = (j == 0) ? aNeighbour.Last() : aNeighbour.First();
       const IntSurf_PntOn2S& aPoint = theWLine->Point(anIndex);
@@ -3770,355 +3780,355 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
       
       for(Standard_Integer surfit = 0; surfit < 2; surfit++) {
 
-       Handle(GeomAdaptor_HSurface) aGASurface = (surfit == 0) ? theSurface1 : theSurface2;
-       Standard_Real umin=0., umax=0., vmin=0., vmax=0.;
-       aGASurface->ChangeSurface().Surface()->Bounds(umin, umax, vmin, vmax);
-       Standard_Real U=0., V=0.;
+        Handle(GeomAdaptor_HSurface) aGASurface = (surfit == 0) ? theSurface1 : theSurface2;
+        Standard_Real umin=0., umax=0., vmin=0., vmax=0.;
+        aGASurface->ChangeSurface().Surface()->Bounds(umin, umax, vmin, vmax);
+        Standard_Real U=0., V=0.;
 
-       if(surfit == 0)
-         aNewP.ParametersOnS1(U, V);
-       else
-         aNewP.ParametersOnS2(U, V);
-       Standard_Integer nbboundaries = 0;
+        if(surfit == 0)
+          aNewP.ParametersOnS1(U, V);
+        else
+          aNewP.ParametersOnS2(U, V);
+        Standard_Integer nbboundaries = 0;
 
-       Standard_Boolean bIsNearBoundary = Standard_False;
-       Standard_Integer aZoneIndex = 0;
-       Standard_Integer bIsUBoundary = Standard_False; // use if nbboundaries == 1
-       Standard_Integer bIsFirstBoundary = Standard_False; // use if nbboundaries == 1
-       
+        Standard_Boolean bIsNearBoundary = Standard_False;
+        Standard_Integer aZoneIndex = 0;
+        Standard_Integer bIsUBoundary = Standard_False; // use if nbboundaries == 1
+        Standard_Integer bIsFirstBoundary = Standard_False; // use if nbboundaries == 1
+        
 
-       for(Standard_Integer parit = 0; parit < 2; parit++) {
-         Standard_Boolean isperiodic = (parit == 0) ? aGASurface->IsUPeriodic() : aGASurface->IsVPeriodic();
+        for(Standard_Integer parit = 0; parit < 2; parit++) {
+          Standard_Boolean isperiodic = (parit == 0) ? aGASurface->IsUPeriodic() : aGASurface->IsVPeriodic();
 
-         Standard_Real aResolution = (parit == 0) ? aGASurface->UResolution(aTol) : aGASurface->VResolution(aTol);
-         Standard_Real alowerboundary = (parit == 0) ? umin : vmin;
-         Standard_Real aupperboundary = (parit == 0) ? umax : vmax;
+          Standard_Real aResolution = (parit == 0) ? aGASurface->UResolution(aTol) : aGASurface->VResolution(aTol);
+          Standard_Real alowerboundary = (parit == 0) ? umin : vmin;
+          Standard_Real aupperboundary = (parit == 0) ? umax : vmax;
 
-         Standard_Real aParameter = (parit == 0) ? U : V;
-         Standard_Boolean bIsOnFirstBoundary = Standard_True;
+          Standard_Real aParameter = (parit == 0) ? U : V;
+          Standard_Boolean bIsOnFirstBoundary = Standard_True;
   
-         if(!isperiodic) {
-           bIsPointOnBoundary=
-             IsPointOnBoundary(aParameter, alowerboundary, aupperboundary, aResolution, bIsOnFirstBoundary);
-           if(bIsPointOnBoundary) {
-             bIsUBoundary = (parit == 0);
-             bIsFirstBoundary = bIsOnFirstBoundary;
-             nbboundaries++;
-           }
-         }
-         else {
-           Standard_Real aPeriod     = (parit == 0) ? aGASurface->UPeriod() : aGASurface->VPeriod();
-           Standard_Real anoffset = 0.;
-           Standard_Real anAdjustPar = AdjustPeriodic(aParameter, alowerboundary, aupperboundary, aPeriod, anoffset);
-
-           bIsPointOnBoundary=
-             IsPointOnBoundary(anAdjustPar, alowerboundary, aupperboundary, aResolution, bIsOnFirstBoundary);
-           if(bIsPointOnBoundary) {
-             bIsUBoundary = (parit == 0);
-             bIsFirstBoundary = bIsOnFirstBoundary;
-             nbboundaries++;
-           }
-           else {
-             //check neighbourhood of boundary
-             Standard_Real anEpsilon = aResolution * 100.;
-             Standard_Real aPart = ( aupperboundary - alowerboundary ) * 0.1;
-             anEpsilon = ( anEpsilon > aPart ) ? aPart : anEpsilon;
-               
-             bIsNearBoundary = IsPointOnBoundary(anAdjustPar, alowerboundary, aupperboundary, 
-                                                 anEpsilon, bIsOnFirstBoundary);
-
-           }
-         }
-       }
-
-       // check if a point belong to a tangent zone. Begin
-       for ( Standard_Integer zIt = 1; zIt <= aNbZone; zIt++ ) {
-         gp_Pnt2d aPZone = (surfit == 0) ? aTanZoneS1->Value(zIt) : aTanZoneS2->Value(zIt);
-         Standard_Real aZoneRadius = aTanZoneRadius->Value(zIt);
-
-         Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
-         const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
-         Standard_Real nU1, nV1;
-           
-         if(surfit == 0)
-           aNeighbourPoint.ParametersOnS1(nU1, nV1);
-         else
-           aNeighbourPoint.ParametersOnS2(nU1, nV1);
-         gp_Pnt2d ap1(nU1, nV1);
-         gp_Pnt2d ap2 = AdjustByNeighbour( ap1, gp_Pnt2d( U, V ), aGASurface );
-
-
-         if ( IsInsideTanZone( ap2, aPZone, aZoneRadius, aGASurface ) ) {
-           aZoneIndex = zIt;
-           bIsNearBoundary = Standard_True;
-           if ( theReachedTol3d < aZoneRadius ) {
-             theReachedTol3d = aZoneRadius;
-           }
-         }
-       }
-       // check if a point belong to a tangent zone. End
-       Standard_Boolean bComputeLineEnd = Standard_False;
-
-       if(nbboundaries == 2) {
-         //xf
-         bComputeLineEnd = Standard_True;
-         //xt
-       }
-       else if(nbboundaries == 1) {
-         Standard_Boolean isperiodic = (bIsUBoundary) ? aGASurface->IsUPeriodic() : aGASurface->IsVPeriodic();
-
-         if(isperiodic) {
-           Standard_Real alowerboundary = (bIsUBoundary) ? umin : vmin;
-           Standard_Real aupperboundary = (bIsUBoundary) ? umax : vmax;
-           Standard_Real aPeriod     = (bIsUBoundary) ? aGASurface->UPeriod() : aGASurface->VPeriod();
-           Standard_Real aParameter = (bIsUBoundary) ? U : V;
-           Standard_Real anoffset = 0.;
-           Standard_Real anAdjustPar = AdjustPeriodic(aParameter, alowerboundary, aupperboundary, aPeriod, anoffset);
-
-           Standard_Real adist = (bIsFirstBoundary) ? fabs(anAdjustPar - alowerboundary) : fabs(anAdjustPar - aupperboundary);
-           Standard_Real anotherPar = (bIsFirstBoundary) ? (aupperboundary - adist) : (alowerboundary + adist);
-           anotherPar += anoffset;
-           Standard_Integer aneighbourpointindex = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
-           const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex);
-           Standard_Real nU1, nV1;
-
-           if(surfit == 0)
-             aNeighbourPoint.ParametersOnS1(nU1, nV1);
-           else
-             aNeighbourPoint.ParametersOnS2(nU1, nV1);
-           
-           Standard_Real adist1 = (bIsUBoundary) ? fabs(nU1 - U) : fabs(nV1 - V);
-           Standard_Real adist2 = (bIsUBoundary) ? fabs(nU1 - anotherPar) : fabs(nV1 - anotherPar);
-           bComputeLineEnd = Standard_True;
-           Standard_Boolean bCheckAngle1 = Standard_False;
-           Standard_Boolean bCheckAngle2 = Standard_False;
-           gp_Vec2d aNewVec;
-           Standard_Real anewU = (bIsUBoundary) ? anotherPar : U;
-           Standard_Real anewV = (bIsUBoundary) ? V : anotherPar;
-
-           if(((adist1 - adist2) > Precision::PConfusion()) && 
-              (adist2 < (aPeriod / 4.))) {
-             bCheckAngle1 = Standard_True;
-             aNewVec = gp_Vec2d(gp_Pnt2d(nU1, nV1), gp_Pnt2d(anewU, anewV));
-
-             if(aNewVec.SquareMagnitude() < (gp::Resolution() * gp::Resolution())) {
-               aNewP.SetValue((surfit == 0), anewU, anewV);
-               bCheckAngle1 = Standard_False;
-             }
-           }
-           else if(adist1 < (aPeriod / 4.)) {
-             bCheckAngle2 = Standard_True;
-             aNewVec = gp_Vec2d(gp_Pnt2d(nU1, nV1), gp_Pnt2d(U, V));
-
-             if(aNewVec.SquareMagnitude() < (gp::Resolution() * gp::Resolution())) {
-               bCheckAngle2 = Standard_False;
-             }
-           }
-
-           if(bCheckAngle1 || bCheckAngle2) {
-             // assume there are at least two points in line (see "if" above)
-             Standard_Integer anindexother = aneighbourpointindex;
-
-             while((anindexother <= aListOfIndex.Last()) && (anindexother >= aListOfIndex.First())) {
-               anindexother = (j == 0) ? (anindexother + 1) : (anindexother - 1);
-               const IntSurf_PntOn2S& aPrevNeighbourPoint = theWLine->Point(anindexother);
-               Standard_Real nU2, nV2;
-               
-               if(surfit == 0)
-                 aPrevNeighbourPoint.ParametersOnS1(nU2, nV2);
-               else
-                 aPrevNeighbourPoint.ParametersOnS2(nU2, nV2);
-               gp_Vec2d aVecOld(gp_Pnt2d(nU2, nV2), gp_Pnt2d(nU1, nV1));
-
-               if(aVecOld.SquareMagnitude() <= (gp::Resolution() * gp::Resolution())) {
-                 continue;
-               }
-               else {
-                 Standard_Real anAngle = aNewVec.Angle(aVecOld);
-
-                 if((fabs(anAngle) < (M_PI * 0.25)) && (aNewVec.Dot(aVecOld) > 0.)) {
-
-                   if(bCheckAngle1) {
-                     Standard_Real U1, U2, V1, V2;
-                     IntSurf_PntOn2S atmppoint = aNewP;
-                     atmppoint.SetValue((surfit == 0), anewU, anewV);
-                     atmppoint.Parameters(U1, V1, U2, V2);
-                     gp_Pnt P1 = theSurface1->Value(U1, V1);
-                     gp_Pnt P2 = theSurface2->Value(U2, V2);
-                     gp_Pnt P0 = aPoint.Value();
-
-                     if(P0.IsEqual(P1, aTol) &&
-                        P0.IsEqual(P2, aTol) &&
-                        P1.IsEqual(P2, aTol)) {
-                       bComputeLineEnd = Standard_False;
-                       aNewP.SetValue((surfit == 0), anewU, anewV);
-                     }
-                   }
-
-                   if(bCheckAngle2) {
-                     bComputeLineEnd = Standard_False;
-                   }
-                 }
-                 break;
-               }
-             } // end while(anindexother...)
-           }
-         }
-       }
-       else if ( bIsNearBoundary ) {
-         bComputeLineEnd = Standard_True;
-       }
-
-       if(bComputeLineEnd) {
-
-         gp_Pnt2d anewpoint;
-         Standard_Boolean found = Standard_False;
-
-         if ( bIsNearBoundary ) {
-           // re-compute point near natural boundary or near tangent zone
-           Standard_Real u1, v1, u2, v2;
-           aNewP.Parameters( u1, v1, u2, v2 );
-           if(surfit == 0)
-             anewpoint = gp_Pnt2d( u1, v1 );
-           else
-             anewpoint = gp_Pnt2d( u2, v2 );
-           
-           Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
-           const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
-           Standard_Real nU1, nV1;
-           
-           if(surfit == 0)
-             aNeighbourPoint.ParametersOnS1(nU1, nV1);
-           else
-             aNeighbourPoint.ParametersOnS2(nU1, nV1);
-           gp_Pnt2d ap1(nU1, nV1);
-           gp_Pnt2d ap2;
-
-
-           if ( aZoneIndex ) {
-             // exclude point from a tangent zone
-             anewpoint = AdjustByNeighbour( ap1, anewpoint, aGASurface );
-             gp_Pnt2d aPZone = (surfit == 0) ? aTanZoneS1->Value(aZoneIndex) : aTanZoneS2->Value(aZoneIndex);
-             Standard_Real aZoneRadius = aTanZoneRadius->Value(aZoneIndex);
-
-             if ( FindPoint(ap1, anewpoint, umin, umax, vmin, vmax, 
-                            aPZone, aZoneRadius, aGASurface, ap2) ) {
-               anewpoint = ap2;
-               found = Standard_True;
-             }
-           }
-           else if ( aGASurface->IsUPeriodic() || aGASurface->IsVPeriodic() ) {
-             // re-compute point near boundary if shifted on a period
-             ap2 = AdjustByNeighbour( ap1, anewpoint, aGASurface );
-
-             if ( ( ap2.X() < umin ) || ( ap2.X() > umax ) ||
-                 ( ap2.Y() < vmin ) || ( ap2.Y() > vmax ) ) {
-               found = FindPoint(ap1, ap2, umin, umax, vmin, vmax, anewpoint);
-             }
-             else {
-               anewpoint = ap2;
-               aNewP.SetValue( (surfit == 0), anewpoint.X(), anewpoint.Y() );
-             }
-           }
-         }
-         else {
-
-           Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
-           const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
-           Standard_Real nU1, nV1;
-
-           if(surfit == 0)
-             aNeighbourPoint.ParametersOnS1(nU1, nV1);
-           else
-             aNeighbourPoint.ParametersOnS2(nU1, nV1);
-           gp_Pnt2d ap1(nU1, nV1);
-           gp_Pnt2d ap2(nU1, nV1);
-           Standard_Integer aneighbourpointindex2 = aneighbourpointindex1;
-
-           while((aneighbourpointindex2 <= aListOfIndex.Last()) && (aneighbourpointindex2 >= aListOfIndex.First())) {
-             aneighbourpointindex2 = (j == 0) ? (aneighbourpointindex2 + 1) : (aneighbourpointindex2 - 1);
-             const IntSurf_PntOn2S& aPrevNeighbourPoint = theWLine->Point(aneighbourpointindex2);
-             Standard_Real nU2, nV2;
-
-             if(surfit == 0)
-               aPrevNeighbourPoint.ParametersOnS1(nU2, nV2);
-             else
-               aPrevNeighbourPoint.ParametersOnS2(nU2, nV2);
-             ap2.SetX(nU2);
-             ap2.SetY(nV2);
-
-             if(ap1.SquareDistance(ap2) > (gp::Resolution() * gp::Resolution())) {
-               break;
-             }
-           }  
-           found = FindPoint(ap2, ap1, umin, umax, vmin, vmax, anewpoint);
-         }
-
-         if(found) {
-           // check point
-           Standard_Real aCriteria = BRep_Tool::Tolerance(theFace1) + BRep_Tool::Tolerance(theFace2);
-           GeomAPI_ProjectPointOnSurf& aProjector = 
-             (surfit == 0) ? aContext->ProjPS(theFace2) : aContext->ProjPS(theFace1);
-           Handle(GeomAdaptor_HSurface) aSurface = (surfit == 0) ? theSurface1 : theSurface2;
-
-           Handle(GeomAdaptor_HSurface) aSurfaceOther = (surfit == 0) ? theSurface2 : theSurface1;
-
-           gp_Pnt aP3d = aSurface->Value(anewpoint.X(), anewpoint.Y());
-           aProjector.Perform(aP3d);
-
-           if(aProjector.IsDone()) {
-             if(aProjector.LowerDistance() < aCriteria) {
-               Standard_Real foundU = U, foundV = V;
-               aProjector.LowerDistanceParameters(foundU, foundV);
-
-               //Correction of projected coordinates. Begin
-               //Note, it may be shifted on a period
-               Standard_Integer aneindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
-               const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneindex1);
-               Standard_Real nUn, nVn;
-               
-               if(surfit == 0)
-                 aNeighbourPoint.ParametersOnS2(nUn, nVn);
-               else
-                 aNeighbourPoint.ParametersOnS1(nUn, nVn);
-               gp_Pnt2d aNeighbour2d(nUn, nVn);
-               gp_Pnt2d anAdjustedPoint = AdjustByNeighbour( aNeighbour2d, gp_Pnt2d(foundU, foundV), aSurfaceOther );
-               foundU = anAdjustedPoint.X();
-               foundV = anAdjustedPoint.Y();
-
-               if ( ( anAdjustedPoint.X() < umin ) && ( anAdjustedPoint.X() > umax ) &&
-                   ( anAdjustedPoint.Y() < vmin ) && ( anAdjustedPoint.Y() > vmax ) ) {
-                 // attempt to roughly re-compute point
-                 foundU = ( foundU < umin ) ? umin : foundU;
-                 foundU = ( foundU > umax ) ? umax : foundU;
-                 foundV = ( foundV < vmin ) ? vmin : foundV;
-                 foundV = ( foundV > vmax ) ? vmax : foundV;
-
-                 GeomAPI_ProjectPointOnSurf& aProjector2 = 
-                   (surfit == 0) ? aContext->ProjPS(theFace1) : aContext->ProjPS(theFace2);
-
-                 aP3d = aSurfaceOther->Value(foundU, foundV);
-                 aProjector2.Perform(aP3d);
-                 
-                 if(aProjector2.IsDone()) {
-                   if(aProjector2.LowerDistance() < aCriteria) {
-                     Standard_Real foundU2 = anewpoint.X(), foundV2 = anewpoint.Y();
-                     aProjector2.LowerDistanceParameters(foundU2, foundV2);
-                     anewpoint.SetX(foundU2);
-                     anewpoint.SetY(foundV2);
-                   }
-                 }
-               }
-               //Correction of projected coordinates. End
-
-               if(surfit == 0)
-                 aNewP.SetValue(aP3d, anewpoint.X(), anewpoint.Y(), foundU, foundV);
-               else
-                 aNewP.SetValue(aP3d, foundU, foundV, anewpoint.X(), anewpoint.Y());
-             }
-           }
-         }
-       }
+          if(!isperiodic) {
+            bIsPointOnBoundary=
+              IsPointOnBoundary(aParameter, alowerboundary, aupperboundary, aResolution, bIsOnFirstBoundary);
+            if(bIsPointOnBoundary) {
+              bIsUBoundary = (parit == 0);
+              bIsFirstBoundary = bIsOnFirstBoundary;
+              nbboundaries++;
+            }
+          }
+          else {
+            Standard_Real aPeriod     = (parit == 0) ? aGASurface->UPeriod() : aGASurface->VPeriod();
+            Standard_Real anoffset = 0.;
+            Standard_Real anAdjustPar = AdjustPeriodic(aParameter, alowerboundary, aupperboundary, aPeriod, anoffset);
+
+            bIsPointOnBoundary=
+              IsPointOnBoundary(anAdjustPar, alowerboundary, aupperboundary, aResolution, bIsOnFirstBoundary);
+            if(bIsPointOnBoundary) {
+              bIsUBoundary = (parit == 0);
+              bIsFirstBoundary = bIsOnFirstBoundary;
+              nbboundaries++;
+            }
+            else {
+              //check neighbourhood of boundary
+              Standard_Real anEpsilon = aResolution * 100.;
+              Standard_Real aPart = ( aupperboundary - alowerboundary ) * 0.1;
+              anEpsilon = ( anEpsilon > aPart ) ? aPart : anEpsilon;
+                
+              bIsNearBoundary = IsPointOnBoundary(anAdjustPar, alowerboundary, aupperboundary, 
+                                                  anEpsilon, bIsOnFirstBoundary);
+
+            }
+          }
+        }
+
+        // check if a point belong to a tangent zone. Begin
+        for ( Standard_Integer zIt = 1; zIt <= aNbZone; zIt++ ) {
+          gp_Pnt2d aPZone = (surfit == 0) ? aTanZoneS1->Value(zIt) : aTanZoneS2->Value(zIt);
+          Standard_Real aZoneRadius = aTanZoneRadius->Value(zIt);
+
+          Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+          const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
+          Standard_Real nU1, nV1;
+            
+          if(surfit == 0)
+            aNeighbourPoint.ParametersOnS1(nU1, nV1);
+          else
+            aNeighbourPoint.ParametersOnS2(nU1, nV1);
+          gp_Pnt2d ap1(nU1, nV1);
+          gp_Pnt2d ap2 = AdjustByNeighbour( ap1, gp_Pnt2d( U, V ), aGASurface );
+
+
+          if ( IsInsideTanZone( ap2, aPZone, aZoneRadius, aGASurface ) ) {
+            aZoneIndex = zIt;
+            bIsNearBoundary = Standard_True;
+            if ( theReachedTol3d < aZoneRadius ) {
+              theReachedTol3d = aZoneRadius;
+            }
+          }
+        }
+        // check if a point belong to a tangent zone. End
+        Standard_Boolean bComputeLineEnd = Standard_False;
+
+        if(nbboundaries == 2) {
+          //xf
+          bComputeLineEnd = Standard_True;
+          //xt
+        }
+        else if(nbboundaries == 1) {
+          Standard_Boolean isperiodic = (bIsUBoundary) ? aGASurface->IsUPeriodic() : aGASurface->IsVPeriodic();
+
+          if(isperiodic) {
+            Standard_Real alowerboundary = (bIsUBoundary) ? umin : vmin;
+            Standard_Real aupperboundary = (bIsUBoundary) ? umax : vmax;
+            Standard_Real aPeriod     = (bIsUBoundary) ? aGASurface->UPeriod() : aGASurface->VPeriod();
+            Standard_Real aParameter = (bIsUBoundary) ? U : V;
+            Standard_Real anoffset = 0.;
+            Standard_Real anAdjustPar = AdjustPeriodic(aParameter, alowerboundary, aupperboundary, aPeriod, anoffset);
+
+            Standard_Real adist = (bIsFirstBoundary) ? fabs(anAdjustPar - alowerboundary) : fabs(anAdjustPar - aupperboundary);
+            Standard_Real anotherPar = (bIsFirstBoundary) ? (aupperboundary - adist) : (alowerboundary + adist);
+            anotherPar += anoffset;
+            Standard_Integer aneighbourpointindex = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+            const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex);
+            Standard_Real nU1, nV1;
+
+            if(surfit == 0)
+              aNeighbourPoint.ParametersOnS1(nU1, nV1);
+            else
+              aNeighbourPoint.ParametersOnS2(nU1, nV1);
+            
+            Standard_Real adist1 = (bIsUBoundary) ? fabs(nU1 - U) : fabs(nV1 - V);
+            Standard_Real adist2 = (bIsUBoundary) ? fabs(nU1 - anotherPar) : fabs(nV1 - anotherPar);
+            bComputeLineEnd = Standard_True;
+            Standard_Boolean bCheckAngle1 = Standard_False;
+            Standard_Boolean bCheckAngle2 = Standard_False;
+            gp_Vec2d aNewVec;
+            Standard_Real anewU = (bIsUBoundary) ? anotherPar : U;
+            Standard_Real anewV = (bIsUBoundary) ? V : anotherPar;
+
+            if(((adist1 - adist2) > Precision::PConfusion()) && 
+               (adist2 < (aPeriod / 4.))) {
+              bCheckAngle1 = Standard_True;
+              aNewVec = gp_Vec2d(gp_Pnt2d(nU1, nV1), gp_Pnt2d(anewU, anewV));
+
+              if(aNewVec.SquareMagnitude() < (gp::Resolution() * gp::Resolution())) {
+                aNewP.SetValue((surfit == 0), anewU, anewV);
+                bCheckAngle1 = Standard_False;
+              }
+            }
+            else if(adist1 < (aPeriod / 4.)) {
+              bCheckAngle2 = Standard_True;
+              aNewVec = gp_Vec2d(gp_Pnt2d(nU1, nV1), gp_Pnt2d(U, V));
+
+              if(aNewVec.SquareMagnitude() < (gp::Resolution() * gp::Resolution())) {
+                bCheckAngle2 = Standard_False;
+              }
+            }
+
+            if(bCheckAngle1 || bCheckAngle2) {
+              // assume there are at least two points in line (see "if" above)
+              Standard_Integer anindexother = aneighbourpointindex;
+
+              while((anindexother <= aListOfIndex.Last()) && (anindexother >= aListOfIndex.First())) {
+                anindexother = (j == 0) ? (anindexother + 1) : (anindexother - 1);
+                const IntSurf_PntOn2S& aPrevNeighbourPoint = theWLine->Point(anindexother);
+                Standard_Real nU2, nV2;
+                
+                if(surfit == 0)
+                  aPrevNeighbourPoint.ParametersOnS1(nU2, nV2);
+                else
+                  aPrevNeighbourPoint.ParametersOnS2(nU2, nV2);
+                gp_Vec2d aVecOld(gp_Pnt2d(nU2, nV2), gp_Pnt2d(nU1, nV1));
+
+                if(aVecOld.SquareMagnitude() <= (gp::Resolution() * gp::Resolution())) {
+                  continue;
+                }
+                else {
+                  Standard_Real anAngle = aNewVec.Angle(aVecOld);
+
+                  if((fabs(anAngle) < (M_PI * 0.25)) && (aNewVec.Dot(aVecOld) > 0.)) {
+
+                    if(bCheckAngle1) {
+                      Standard_Real U1, U2, V1, V2;
+                      IntSurf_PntOn2S atmppoint = aNewP;
+                      atmppoint.SetValue((surfit == 0), anewU, anewV);
+                      atmppoint.Parameters(U1, V1, U2, V2);
+                      gp_Pnt P1 = theSurface1->Value(U1, V1);
+                      gp_Pnt P2 = theSurface2->Value(U2, V2);
+                      gp_Pnt P0 = aPoint.Value();
+
+                      if(P0.IsEqual(P1, aTol) &&
+                         P0.IsEqual(P2, aTol) &&
+                         P1.IsEqual(P2, aTol)) {
+                        bComputeLineEnd = Standard_False;
+                        aNewP.SetValue((surfit == 0), anewU, anewV);
+                      }
+                    }
+
+                    if(bCheckAngle2) {
+                      bComputeLineEnd = Standard_False;
+                    }
+                  }
+                  break;
+                }
+              } // end while(anindexother...)
+            }
+          }
+        }
+        else if ( bIsNearBoundary ) {
+          bComputeLineEnd = Standard_True;
+        }
+
+        if(bComputeLineEnd) {
+
+          gp_Pnt2d anewpoint;
+          Standard_Boolean found = Standard_False;
+
+          if ( bIsNearBoundary ) {
+            // re-compute point near natural boundary or near tangent zone
+            Standard_Real u1, v1, u2, v2;
+            aNewP.Parameters( u1, v1, u2, v2 );
+            if(surfit == 0)
+              anewpoint = gp_Pnt2d( u1, v1 );
+            else
+              anewpoint = gp_Pnt2d( u2, v2 );
+            
+            Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+            const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
+            Standard_Real nU1, nV1;
+            
+            if(surfit == 0)
+              aNeighbourPoint.ParametersOnS1(nU1, nV1);
+            else
+              aNeighbourPoint.ParametersOnS2(nU1, nV1);
+            gp_Pnt2d ap1(nU1, nV1);
+            gp_Pnt2d ap2;
+
+
+            if ( aZoneIndex ) {
+              // exclude point from a tangent zone
+              anewpoint = AdjustByNeighbour( ap1, anewpoint, aGASurface );
+              gp_Pnt2d aPZone = (surfit == 0) ? aTanZoneS1->Value(aZoneIndex) : aTanZoneS2->Value(aZoneIndex);
+              Standard_Real aZoneRadius = aTanZoneRadius->Value(aZoneIndex);
+
+              if ( FindPoint(ap1, anewpoint, umin, umax, vmin, vmax, 
+                             aPZone, aZoneRadius, aGASurface, ap2) ) {
+                anewpoint = ap2;
+                found = Standard_True;
+              }
+            }
+            else if ( aGASurface->IsUPeriodic() || aGASurface->IsVPeriodic() ) {
+              // re-compute point near boundary if shifted on a period
+              ap2 = AdjustByNeighbour( ap1, anewpoint, aGASurface );
+
+              if ( ( ap2.X() < umin ) || ( ap2.X() > umax ) ||
+                  ( ap2.Y() < vmin ) || ( ap2.Y() > vmax ) ) {
+                found = FindPoint(ap1, ap2, umin, umax, vmin, vmax, anewpoint);
+              }
+              else {
+                anewpoint = ap2;
+                aNewP.SetValue( (surfit == 0), anewpoint.X(), anewpoint.Y() );
+              }
+            }
+          }
+          else {
+
+            Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+            const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
+            Standard_Real nU1, nV1;
+
+            if(surfit == 0)
+              aNeighbourPoint.ParametersOnS1(nU1, nV1);
+            else
+              aNeighbourPoint.ParametersOnS2(nU1, nV1);
+            gp_Pnt2d ap1(nU1, nV1);
+            gp_Pnt2d ap2(nU1, nV1);
+            Standard_Integer aneighbourpointindex2 = aneighbourpointindex1;
+
+            while((aneighbourpointindex2 <= aListOfIndex.Last()) && (aneighbourpointindex2 >= aListOfIndex.First())) {
+              aneighbourpointindex2 = (j == 0) ? (aneighbourpointindex2 + 1) : (aneighbourpointindex2 - 1);
+              const IntSurf_PntOn2S& aPrevNeighbourPoint = theWLine->Point(aneighbourpointindex2);
+              Standard_Real nU2, nV2;
+
+              if(surfit == 0)
+                aPrevNeighbourPoint.ParametersOnS1(nU2, nV2);
+              else
+                aPrevNeighbourPoint.ParametersOnS2(nU2, nV2);
+              ap2.SetX(nU2);
+              ap2.SetY(nV2);
+
+              if(ap1.SquareDistance(ap2) > (gp::Resolution() * gp::Resolution())) {
+                break;
+              }
+            }  
+            found = FindPoint(ap2, ap1, umin, umax, vmin, vmax, anewpoint);
+          }
+
+          if(found) {
+            // check point
+            Standard_Real aCriteria = BRep_Tool::Tolerance(theFace1) + BRep_Tool::Tolerance(theFace2);
+            GeomAPI_ProjectPointOnSurf& aProjector = 
+              (surfit == 0) ? aContext->ProjPS(theFace2) : aContext->ProjPS(theFace1);
+            Handle(GeomAdaptor_HSurface) aSurface = (surfit == 0) ? theSurface1 : theSurface2;
+
+            Handle(GeomAdaptor_HSurface) aSurfaceOther = (surfit == 0) ? theSurface2 : theSurface1;
+
+            gp_Pnt aP3d = aSurface->Value(anewpoint.X(), anewpoint.Y());
+            aProjector.Perform(aP3d);
+
+            if(aProjector.IsDone()) {
+              if(aProjector.LowerDistance() < aCriteria) {
+                Standard_Real foundU = U, foundV = V;
+                aProjector.LowerDistanceParameters(foundU, foundV);
+
+                //Correction of projected coordinates. Begin
+                //Note, it may be shifted on a period
+                Standard_Integer aneindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+                const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneindex1);
+                Standard_Real nUn, nVn;
+                
+                if(surfit == 0)
+                  aNeighbourPoint.ParametersOnS2(nUn, nVn);
+                else
+                  aNeighbourPoint.ParametersOnS1(nUn, nVn);
+                gp_Pnt2d aNeighbour2d(nUn, nVn);
+                gp_Pnt2d anAdjustedPoint = AdjustByNeighbour( aNeighbour2d, gp_Pnt2d(foundU, foundV), aSurfaceOther );
+                foundU = anAdjustedPoint.X();
+                foundV = anAdjustedPoint.Y();
+
+                if ( ( anAdjustedPoint.X() < umin ) && ( anAdjustedPoint.X() > umax ) &&
+                    ( anAdjustedPoint.Y() < vmin ) && ( anAdjustedPoint.Y() > vmax ) ) {
+                  // attempt to roughly re-compute point
+                  foundU = ( foundU < umin ) ? umin : foundU;
+                  foundU = ( foundU > umax ) ? umax : foundU;
+                  foundV = ( foundV < vmin ) ? vmin : foundV;
+                  foundV = ( foundV > vmax ) ? vmax : foundV;
+
+                  GeomAPI_ProjectPointOnSurf& aProjector2 = 
+                    (surfit == 0) ? aContext->ProjPS(theFace1) : aContext->ProjPS(theFace2);
+
+                  aP3d = aSurfaceOther->Value(foundU, foundV);
+                  aProjector2.Perform(aP3d);
+                  
+                  if(aProjector2.IsDone()) {
+                    if(aProjector2.LowerDistance() < aCriteria) {
+                      Standard_Real foundU2 = anewpoint.X(), foundV2 = anewpoint.Y();
+                      aProjector2.LowerDistanceParameters(foundU2, foundV2);
+                      anewpoint.SetX(foundU2);
+                      anewpoint.SetY(foundV2);
+                    }
+                  }
+                }
+                //Correction of projected coordinates. End
+
+                if(surfit == 0)
+                  aNewP.SetValue(aP3d, anewpoint.X(), anewpoint.Y(), foundU, foundV);
+                else
+                  aNewP.SetValue(aP3d, foundU, foundV, anewpoint.X(), anewpoint.Y());
+              }
+            }
+          }
+        }
       }
       aSeqOfPntOn2S->Add(aNewP);
       aListOfFLIndex.Append(aSeqOfPntOn2S->NbPoints());
@@ -4153,146 +4163,146 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
     //
     for(i = 1; i <= nblines; i++) {
       if(anArrayOfLineType.Value(i) != 0) {
-       continue;
+        continue;
       }
       const TColStd_ListOfInteger& aListOfIndex = anArrayOfLines.Value(i);
 
       if(aListOfIndex.Extent() < 2) {
-       continue;
+        continue;
       }
       const TColStd_ListOfInteger& aListOfFLIndex = anArrayOfLineEnds.Value(i);
       Standard_Boolean bhasfirstpoint = (aListOfFLIndex.Extent() == 2);
       Standard_Boolean bhaslastpoint = (aListOfFLIndex.Extent() == 2);
 
       if(!bhasfirstpoint && !aListOfFLIndex.IsEmpty()) {
-       bhasfirstpoint = (i != 1);
+        bhasfirstpoint = (i != 1);
       }
 
       if(!bhaslastpoint && !aListOfFLIndex.IsEmpty()) {
-       bhaslastpoint = (i != nblines);
+        bhaslastpoint = (i != nblines);
       }
       Standard_Boolean bIsFirstInside = ((ifprm >= aListOfIndex.First()) && (ifprm <= aListOfIndex.Last()));
       Standard_Boolean bIsLastInside =  ((ilprm >= aListOfIndex.First()) && (ilprm <= aListOfIndex.Last()));
 
       if(!bIsFirstInside && !bIsLastInside) {
-       if((ifprm < aListOfIndex.First()) && (ilprm > aListOfIndex.Last())) {
-         // append whole line, and boundaries if neccesary
-         if(bhasfirstpoint) {
-           const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.First());
-           aLineOn2S->Add(aP);
-         }
-         TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
-
-         for(; anIt.More(); anIt.Next()) {
-           const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
-           aLineOn2S->Add(aP);
-         }
-
-         if(bhaslastpoint) {
-           const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.Last());
-           aLineOn2S->Add(aP);
-         }
-
-         // check end of split line (end is almost always)
-         Standard_Integer aneighbour = i + 1;
-         Standard_Boolean bIsEndOfLine = Standard_True;
-
-         if(aneighbour <= nblines) {
-           const TColStd_ListOfInteger& aListOfNeighbourIndex = anArrayOfLines.Value(aneighbour);
-
-           if((anArrayOfLineType.Value(aneighbour) != 0) &&
-              (aListOfNeighbourIndex.IsEmpty())) {
-             bIsEndOfLine = Standard_False;
-           }
-         }
-
-         if(bIsEndOfLine) {
-           if(aLineOn2S->NbPoints() > 1) {
-             Handle(IntPatch_WLine) aNewWLine = 
-               new IntPatch_WLine(aLineOn2S, Standard_False);
-             theNewLines.Append(aNewWLine);
-           }
-           aLineOn2S = new IntSurf_LineOn2S();
-         }
-       }
-       continue;
+        if((ifprm < aListOfIndex.First()) && (ilprm > aListOfIndex.Last())) {
+          // append whole line, and boundaries if neccesary
+          if(bhasfirstpoint) {
+            const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.First());
+            aLineOn2S->Add(aP);
+          }
+          TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
+
+          for(; anIt.More(); anIt.Next()) {
+            const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
+            aLineOn2S->Add(aP);
+          }
+
+          if(bhaslastpoint) {
+            const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.Last());
+            aLineOn2S->Add(aP);
+          }
+
+          // check end of split line (end is almost always)
+          Standard_Integer aneighbour = i + 1;
+          Standard_Boolean bIsEndOfLine = Standard_True;
+
+          if(aneighbour <= nblines) {
+            const TColStd_ListOfInteger& aListOfNeighbourIndex = anArrayOfLines.Value(aneighbour);
+
+            if((anArrayOfLineType.Value(aneighbour) != 0) &&
+               (aListOfNeighbourIndex.IsEmpty())) {
+              bIsEndOfLine = Standard_False;
+            }
+          }
+
+          if(bIsEndOfLine) {
+            if(aLineOn2S->NbPoints() > 1) {
+              Handle(IntPatch_WLine) aNewWLine = 
+                new IntPatch_WLine(aLineOn2S, Standard_False);
+              theNewLines.Append(aNewWLine);
+            }
+            aLineOn2S = new IntSurf_LineOn2S();
+          }
+        }
+        continue;
       }
       // end if(!bIsFirstInside && !bIsLastInside)
 
       if(bIsFirstInside && bIsLastInside) {
-       // append inside points between ifprm and ilprm
-       TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
-
-       for(; anIt.More(); anIt.Next()) {
-         if((anIt.Value() < ifprm) || (anIt.Value() > ilprm))
-           continue;
-         const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
-         aLineOn2S->Add(aP);
-       }
+        // append inside points between ifprm and ilprm
+        TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
+
+        for(; anIt.More(); anIt.Next()) {
+          if((anIt.Value() < ifprm) || (anIt.Value() > ilprm))
+            continue;
+          const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
+          aLineOn2S->Add(aP);
+        }
       }
       else {
 
-       if(bIsFirstInside) {
-         // append points from ifprm to last point + boundary point
-         TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
-
-         for(; anIt.More(); anIt.Next()) {
-           if(anIt.Value() < ifprm)
-             continue;
-           const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
-           aLineOn2S->Add(aP);
-         }
-
-         if(bhaslastpoint) {
-           const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.Last());
-           aLineOn2S->Add(aP);
-         }
-         // check end of split line (end is almost always)
-         Standard_Integer aneighbour = i + 1;
-         Standard_Boolean bIsEndOfLine = Standard_True;
-
-         if(aneighbour <= nblines) {
-           const TColStd_ListOfInteger& aListOfNeighbourIndex = anArrayOfLines.Value(aneighbour);
-
-           if((anArrayOfLineType.Value(aneighbour) != 0) &&
-              (aListOfNeighbourIndex.IsEmpty())) {
-             bIsEndOfLine = Standard_False;
-           }
-         }
-
-         if(bIsEndOfLine) {
-           if(aLineOn2S->NbPoints() > 1) {
-             Handle(IntPatch_WLine) aNewWLine = 
-               new IntPatch_WLine(aLineOn2S, Standard_False);
-             theNewLines.Append(aNewWLine);
-           }
-           aLineOn2S = new IntSurf_LineOn2S();
-         }
-       }
-       // end if(bIsFirstInside)
-
-       if(bIsLastInside) {
-         // append points from first boundary point to ilprm
-         if(bhasfirstpoint) {
-           const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.First());
-           aLineOn2S->Add(aP);
-         }
-         TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
-
-         for(; anIt.More(); anIt.Next()) {
-           if(anIt.Value() > ilprm)
-             continue;
-           const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
-           aLineOn2S->Add(aP);
-         }
-       }
-       //end if(bIsLastInside)
+        if(bIsFirstInside) {
+          // append points from ifprm to last point + boundary point
+          TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
+
+          for(; anIt.More(); anIt.Next()) {
+            if(anIt.Value() < ifprm)
+              continue;
+            const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
+            aLineOn2S->Add(aP);
+          }
+
+          if(bhaslastpoint) {
+            const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.Last());
+            aLineOn2S->Add(aP);
+          }
+          // check end of split line (end is almost always)
+          Standard_Integer aneighbour = i + 1;
+          Standard_Boolean bIsEndOfLine = Standard_True;
+
+          if(aneighbour <= nblines) {
+            const TColStd_ListOfInteger& aListOfNeighbourIndex = anArrayOfLines.Value(aneighbour);
+
+            if((anArrayOfLineType.Value(aneighbour) != 0) &&
+               (aListOfNeighbourIndex.IsEmpty())) {
+              bIsEndOfLine = Standard_False;
+            }
+          }
+
+          if(bIsEndOfLine) {
+            if(aLineOn2S->NbPoints() > 1) {
+              Handle(IntPatch_WLine) aNewWLine = 
+                new IntPatch_WLine(aLineOn2S, Standard_False);
+              theNewLines.Append(aNewWLine);
+            }
+            aLineOn2S = new IntSurf_LineOn2S();
+          }
+        }
+        // end if(bIsFirstInside)
+
+        if(bIsLastInside) {
+          // append points from first boundary point to ilprm
+          if(bhasfirstpoint) {
+            const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.First());
+            aLineOn2S->Add(aP);
+          }
+          TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
+
+          for(; anIt.More(); anIt.Next()) {
+            if(anIt.Value() > ilprm)
+              continue;
+            const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
+            aLineOn2S->Add(aP);
+          }
+        }
+        //end if(bIsLastInside)
       }
     }
 
     if(aLineOn2S->NbPoints() > 1) {
       Handle(IntPatch_WLine) aNewWLine = 
-       new IntPatch_WLine(aLineOn2S, Standard_False);
+        new IntPatch_WLine(aLineOn2S, Standard_False);
       theNewLines.Append(aNewWLine);
     }
   }
@@ -4307,13 +4317,13 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
 //                  does not lay on any boundary of given faces
 // ------------------------------------------------------------------------------------------------
 Standard_Boolean ParameterOutOfBoundary(const Standard_Real       theParameter, 
-                                       const Handle(Geom_Curve)& theCurve, 
-                                       const TopoDS_Face&        theFace1, 
-                                       const TopoDS_Face&        theFace2,
-                                       const Standard_Real       theOtherParameter,
-                                       const Standard_Boolean    bIncreasePar,
-                                       Standard_Real&            theNewParameter,
-                                       const Handle(BOPInt_Context)& aContext)
+                                        const Handle(Geom_Curve)& theCurve, 
+                                        const TopoDS_Face&        theFace1, 
+                                        const TopoDS_Face&        theFace2,
+                                        const Standard_Real       theOtherParameter,
+                                        const Standard_Boolean    bIncreasePar,
+                                        Standard_Real&            theNewParameter,
+                                        const Handle(BOPInt_Context)& aContext)
 {
   Standard_Boolean bIsComputed = Standard_False;
   theNewParameter = theParameter;
@@ -4353,10 +4363,10 @@ Standard_Boolean ParameterOutOfBoundary(const Standard_Real       theParameter,
 
     if(aState != TopAbs_ON) {
       aPrj2.Perform(aPCurrent);
-               
+                
       if(aPrj2.IsDone()) {
-       aPrj2.LowerDistanceParameters(U, V);
-       aState = aContext->StatePointFace(theFace2, gp_Pnt2d(U, V));
+        aPrj2.LowerDistanceParameters(U, V);
+        aState = aContext->StatePointFace(theFace2, gp_Pnt2d(U, V));
       }
     }
 
@@ -4372,11 +4382,11 @@ Standard_Boolean ParameterOutOfBoundary(const Standard_Real       theParameter,
 
     if(bIncreasePar) {
       if(acurpar >= theOtherParameter)
-       theNewParameter = theOtherParameter;
+        theNewParameter = theOtherParameter;
     }
     else {
       if(acurpar <= theOtherParameter)
-       theNewParameter = theOtherParameter;
+        theNewParameter = theOtherParameter;
     }
   }
   return bIsComputed;
@@ -4425,7 +4435,7 @@ Standard_Boolean IsCurveValid(Handle(Geom2d_Curve)& thePCurve)
 //purpose  : for bug 20964 only
 //=======================================================================
 Standard_Boolean ApproxWithPCurves(const gp_Cylinder& theCyl, 
-                                  const gp_Sphere& theSph)
+                                   const gp_Sphere& theSph)
 {
   Standard_Boolean bRes = Standard_True;
   Standard_Real R1 = theCyl.Radius(), R2 = theSph.Radius();
@@ -4456,13 +4466,13 @@ Standard_Boolean ApproxWithPCurves(const gp_Cylinder& theCyl,
 //purpose  : 
 //=======================================================================
 void  PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1, 
-                   const Handle(GeomAdaptor_HSurface)& theS2, 
-                   const Standard_Real TolAng, 
-                   const Standard_Real TolTang, 
-                   const Standard_Boolean theApprox1,
-                   const Standard_Boolean theApprox2,
-                   IntTools_SequenceOfCurves& theSeqOfCurve, 
-                   Standard_Boolean& theTangentFaces)
+                    const Handle(GeomAdaptor_HSurface)& theS2, 
+                    const Standard_Real TolAng, 
+                    const Standard_Real TolTang, 
+                    const Standard_Boolean theApprox1,
+                    const Standard_Boolean theApprox2,
+                    IntTools_SequenceOfCurves& theSeqOfCurve, 
+                    Standard_Boolean& theTangentFaces)
 {
 
   gp_Pln aPln1 = theS1->Surface().Plane();
@@ -4553,8 +4563,8 @@ void  PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1,
 //purpose  : 
 //=======================================================================
 static inline Standard_Boolean INTER(const Standard_Real d1, 
-                                    const Standard_Real d2, 
-                                    const Standard_Real tol) 
+                                     const Standard_Real d2, 
+                                     const Standard_Real tol) 
 {
   return (d1 > tol && d2 < -tol) || 
          (d1 < -tol && d2 > tol) ||
@@ -4562,16 +4572,16 @@ static inline Standard_Boolean INTER(const Standard_Real d1,
          ((d2 <= tol && d2 >= -tol) && (d1 > tol || d1 < -tol));
 }
 static inline Standard_Boolean COINC(const Standard_Real d1, 
-                                    const Standard_Real d2, 
-                                    const Standard_Real tol) 
+                                     const Standard_Real d2, 
+                                     const Standard_Real tol) 
 {
   return (d1 <= tol && d1 >= -tol) && (d2 <= tol && d2 >= -tol);
 }
 Standard_Boolean ClassifyLin2d(const Handle(GeomAdaptor_HSurface)& theS, 
-                              const gp_Lin2d& theLin2d, 
-                              const Standard_Real theTol,
-                              Standard_Real& theP1, 
-                              Standard_Real& theP2)
+                               const gp_Lin2d& theLin2d, 
+                               const Standard_Real theTol,
+                               Standard_Real& theP1, 
+                               Standard_Real& theP2)
 
 {
   Standard_Real xmin, xmax, ymin, ymax, d1, d2, A, B, C;
@@ -4703,10 +4713,10 @@ Standard_Boolean ClassifyLin2d(const Handle(GeomAdaptor_HSurface)& theS,
 //purpose  : 
 //=======================================================================
 void ApproxParameters(const Handle(GeomAdaptor_HSurface)& aHS1,
-                     const Handle(GeomAdaptor_HSurface)& aHS2,
-                     Standard_Integer& iDegMin,
-                     Standard_Integer& iDegMax,
-                     Standard_Integer& iNbIter)
+                      const Handle(GeomAdaptor_HSurface)& aHS2,
+                      Standard_Integer& iDegMin,
+                      Standard_Integer& iDegMax,
+                      Standard_Integer& iNbIter)
 
 {
   GeomAbs_SurfaceType aTS1, aTS2;
@@ -4788,7 +4798,7 @@ void Tolerances(const Handle(GeomAdaptor_HSurface)& aHS1,
 //purpose  : 
 //=======================================================================
 Standard_Boolean SortTypes(const GeomAbs_SurfaceType aType1,
-                          const GeomAbs_SurfaceType aType2)
+                           const GeomAbs_SurfaceType aType2)
 {
   Standard_Boolean bRet;
   Standard_Integer aI1, aI2;
@@ -4867,7 +4877,7 @@ void DumpWLine(const Handle(IntPatch_WLine)& aWLine)
     //
     printf("point p_%d %lf %lf %lf\n", i, aX, aY, aZ);
     //printf("point p_%d %20.15lf %20.15lf %20.15lf %20.15lf %20.15lf %20.15lf %20.15lf\n",
-       //   i, aX, aY, aZ, aU1, aV1, aU2, aV2);
+        //   i, aX, aY, aZ, aU1, aV1, aU2, aV2);
   }
 }
 #endif
@@ -4891,10 +4901,10 @@ void RefineVector(gp_Vec2d& aV2D)
     aNum=fabs(aC[k]);
     if (aNum>aR1 && aNum<aR2) {
       if (aC[k]<0.) {
-       aC[k]=-1.;
-      }          
+        aC[k]=-1.;
+      }          
       else {
-       aC[k]=1.;
+        aC[k]=1.;
       }
       aC[m]=0.;
       break;
@@ -4907,16 +4917,16 @@ void RefineVector(gp_Vec2d& aV2D)
 //purpose  : 
 //=======================================================================
 Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
-                                    const Standard_Real aT2,
-                                    const Standard_Real aEps,
-                                    const Handle(Geom_Curve)& aC3D,
-                                    const Handle(Geom2d_Curve)& aC2D1,
-                                    const Handle(Geom2d_Curve)& aC2D2,
-                                    const Handle(GeomAdaptor_HSurface)& myHS1,
-                                    const Handle(GeomAdaptor_HSurface)& myHS2,
-                                    const TopoDS_Face& myFace1,
-                                    const TopoDS_Face& myFace2,
-                                    const Handle(BOPInt_Context)& myContext)
+                                     const Standard_Real aT2,
+                                     const Standard_Real aEps,
+                                     const Handle(Geom_Curve)& aC3D,
+                                     const Handle(Geom2d_Curve)& aC2D1,
+                                     const Handle(Geom2d_Curve)& aC2D2,
+                                     const Handle(GeomAdaptor_HSurface)& myHS1,
+                                     const Handle(GeomAdaptor_HSurface)& myHS2,
+                                     const TopoDS_Face& myFace1,
+                                     const TopoDS_Face& myFace2,
+                                     const Handle(BOPInt_Context)& myContext)
 {
   Standard_Real aA, aB, aCf, aX1, aX2, aF1, aF2, aX, aF;
   //
@@ -4925,17 +4935,17 @@ Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
   aB=aT2;
   aX1=aB-(aB-aA)/aCf;  
   aF1=MaxSquareDistance(aX1, 
-                       aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+                        aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
   aX2=aA+(aB-aA)/aCf;
   aF2=MaxSquareDistance(aX2, 
-                       aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+                        aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
   //
   for(;;) {
     //
     if (fabs(aA-aB)<aEps) {
       aX=0.5*(aA+aB);
       aF=MaxSquareDistance(aX, 
-                       aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+                        aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
       break;
     }
     if (aF1<aF2){
@@ -4944,7 +4954,7 @@ Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
       aF1=aF2;
       aX2=aA+(aB-aA)/aCf;
       aF2=MaxSquareDistance(aX2, 
-                           aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+                            aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
       
     }
     else {
@@ -4953,7 +4963,7 @@ Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
       aF2=aF1;
       aX1=aB-(aB-aA)/aCf; 
       aF1=MaxSquareDistance(aX1, 
-                           aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+                            aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
     }
   }
   return aF;
@@ -4963,14 +4973,14 @@ Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
 //purpose  : 
 //=======================================================================
 Standard_Real MaxSquareDistance (const Standard_Real aT,
-                                const Handle(Geom_Curve)& aC3D,
-                                const Handle(Geom2d_Curve)& aC2D1,
-                                const Handle(Geom2d_Curve)& aC2D2,
-                                const Handle(GeomAdaptor_HSurface) myHS1,
-                                const Handle(GeomAdaptor_HSurface) myHS2,
-                                const TopoDS_Face& aF1,
-                                const TopoDS_Face& aF2,
-                                const Handle(BOPInt_Context)& aCtx)
+                                 const Handle(Geom_Curve)& aC3D,
+                                 const Handle(Geom2d_Curve)& aC2D1,
+                                 const Handle(Geom2d_Curve)& aC2D2,
+                                 const Handle(GeomAdaptor_HSurface) myHS1,
+                                 const Handle(GeomAdaptor_HSurface) myHS2,
+                                 const TopoDS_Face& aF1,
+                                 const TopoDS_Face& aF2,
+                                 const Handle(BOPInt_Context)& aCtx)
 {
   Standard_Boolean bIsDone;
   Standard_Integer i;
@@ -4996,7 +5006,7 @@ Standard_Real MaxSquareDistance (const Standard_Real aT,
       aGHS->D0(aU, aV, aPS);
       aD2=aP.SquareDistance(aPS);
       if (aD2>aD2Max) {
-       aD2Max=aD2;
+        aD2Max=aD2;
       }
     }
     //
@@ -5009,7 +5019,7 @@ Standard_Real MaxSquareDistance (const Standard_Real aT,
       aGHS->D0(aU, aV, aPS);
       aD2=aP.SquareDistance(aPS);
       if (aD2>aD2Max) {
-       aD2Max=aD2;
+        aD2Max=aD2;
       }
     }
   }
@@ -5021,10 +5031,11 @@ Standard_Real MaxSquareDistance (const Standard_Real aT,
 //function : CheckPCurve
 //purpose  : Checks if points of the pcurve are out of the face bounds.
 //=======================================================================
-  Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC, 
-                               const TopoDS_Face& aFace) 
+Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC, 
+                             const TopoDS_Face& aFace) 
 {
   const Standard_Integer NPoints = 23;
+  Standard_Integer i;
   Standard_Real umin,umax,vmin,vmax;
 
   BRepTools::UVBounds(aFace, umin, umax, vmin, vmax);
@@ -5032,18 +5043,18 @@ Standard_Real MaxSquareDistance (const Standard_Real aT,
   Standard_Real tolV = Max ((vmax-vmin)*0.01, Precision::Confusion());
   Standard_Real fp = aPC->FirstParameter();
   Standard_Real lp = aPC->LastParameter();
-  Standard_Real step = (lp-fp)/(NPoints+1);
+  
 
   // adjust domain for periodic surfaces
   TopLoc_Location aLoc;
   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace, aLoc);
-  if (aSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
+  if (aSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
     aSurf = (Handle(Geom_RectangularTrimmedSurface)::DownCast(aSurf))->BasisSurface();
-
+  }
   gp_Pnt2d pnt = aPC->Value((fp+lp)/2);
   Standard_Real u,v;
   pnt.Coord(u,v);
-
+  //
   if (aSurf->IsUPeriodic()) {
     Standard_Real aPer = aSurf->UPeriod();
     Standard_Integer nshift = (Standard_Integer) ((u-umin)/aPer);
@@ -5058,16 +5069,34 @@ Standard_Real MaxSquareDistance (const Standard_Real aT,
     vmin += aPer*nshift;
     vmax += aPer*nshift;
   }
-
-  Standard_Integer i;
-  for (i=1; i <= NPoints; i++) {
-    Standard_Real p = fp + i * step;
-    pnt = aPC->Value(p);
-    pnt.Coord(u,v);
-    if (umin-u > tolU || u-umax > tolU ||
-        vmin-v > tolV || v-vmax > tolV)
-      return Standard_False;
+  //
+  //--------------------------------------------------------
+  Standard_Boolean bRet;
+  Standard_Integer j, aNbIntervals;
+  Standard_Real aT, dT;
+  gp_Pnt2d aP2D; 
+  //
+  Geom2dAdaptor_Curve aGAC(aPC);
+  aNbIntervals=aGAC.NbIntervals(GeomAbs_CN);
+  //
+  TColStd_Array1OfReal aTI(1, aNbIntervals+1);
+  aGAC.Intervals(aTI,GeomAbs_CN);
+  //
+  bRet=Standard_False;
+  //
+  aT=aGAC.FirstParameter();
+  for (j=1; j<=aNbIntervals; ++j) {
+    dT=(aTI(j+1)-aTI(j))/NPoints;
+    //
+    for (i=1; i<NPoints; i++) {
+      aT=aT+dT;
+      aGAC.D0(aT, aP2D);
+      aP2D.Coord(u,v);
+      if (umin-u > tolU || u-umax > tolU ||
+          vmin-v > tolV || v-vmax > tolV) {
+        return bRet;
+      }
+    }
   }
-  return Standard_True;
-
+  return !bRet;
 }
old mode 100644 (file)
new mode 100755 (executable)
index 2be1f1a..35c0bad
@@ -1,23 +1,21 @@
-puts "TODO OCC23884 ALL: Faulty shapes in variables faulty_1 to faulty_"
-puts "TODO OCC23884 ALL: Error : The square of result shape is"
-puts "============"
-puts "OCC23884"
-puts "============"
-puts ""
-######################################################
-# Boolean Fuse between two faces fails
-######################################################
-
-restore [locate_data_file bug23884_fz72] b1
-restore [locate_data_file bug23884_fz124] b2
-
-bop b1 b2
-bopfuse result
-
-set square 2333.14
-set 2dviewer 0
-
-
-
-
-
+puts "============"\r
+puts "OCC23884"\r
+puts "============"\r
+puts ""\r
+######################################################\r
+# Boolean Fuse between two faces fails\r
+######################################################\r
+\r
+restore [locate_data_file bug23884_fz72] b1\r
+restore [locate_data_file bug23884_fz124] b2\r
+\r
+bop b1 b2\r
+bopfuse result\r
+\r
+set square 2415.65\r
+set 2dviewer 0\r
+\r
+\r
+\r
+\r
+\r