src/GeomInt/GeomInt_IntSS_1.cxx

   1 // Created on: 1995-01-27
   2 // Created by: Jacques GOUSSARD
   3 // Copyright (c) 1995-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 #include <algorithm>
  18 #include <GeomInt_IntSS.hxx>
  19
  20 #include <Adaptor3d_TopolTool.hxx>
  21 #include <Approx_CurveOnSurface.hxx>
  22 #include <ElSLib.hxx>
  23 #include <Extrema_ExtPS.hxx>
  24 #include <Geom2dAdaptor.hxx>
  25 #include <Geom2dAdaptor_Curve.hxx>
  26 #include <Geom2dInt_GInter.hxx>
  27 #include <Geom2d_Curve.hxx>
  28 #include <Geom2d_Line.hxx>
  29 #include <Geom2d_TrimmedCurve.hxx>
  30 #include <GeomAdaptor.hxx>
  31 #include <GeomAdaptor_HSurface.hxx>
  32 #include <GeomInt.hxx>
  33 #include <GeomInt_LineTool.hxx>
  34 #include <GeomInt_WLApprox.hxx>
  35 #include <GeomLib_Check2dBSplineCurve.hxx>
  36 #include <GeomLib_CheckBSplineCurve.hxx>
  37 #include <GeomProjLib.hxx>
  38 #include <Geom_BSplineCurve.hxx>
  39 #include <Geom_Circle.hxx>
  40 #include <Geom_Ellipse.hxx>
  41 #include <Geom_Hyperbola.hxx>
  42 #include <Geom_Line.hxx>
  43 #include <Geom_Parabola.hxx>
  44 #include <Geom_TrimmedCurve.hxx>
  45 #include <IntPatch_ALine.hxx>
  46 #include <IntPatch_ALineToWLine.hxx>
  47 #include <IntPatch_GLine.hxx>
  48 #include <IntPatch_RLine.hxx>
  49 #include <IntPatch_WLine.hxx>
  50 #include <IntRes2d_IntersectionSegment.hxx>
  51 #include <IntSurf_Quadric.hxx>
  52 #include <Geom_Surface.hxx>
  53
  54 //=======================================================================
  55 //function : AdjustUPeriodic
  56 //purpose  :
  57 //=======================================================================
  58  static void AdjustUPeriodic (const Handle(Geom_Surface)& aS, const Handle(Geom2d_Curve)& aC2D)
  59 {
  60   if (aC2D.IsNull() || !aS->IsUPeriodic())
  61     return;
  62   //
  63   const Standard_Real aEps=Precision::PConfusion();//1.e-9
  64   const Standard_Real aEpsilon=Epsilon(10.);//1.77e-15
  65   //
  66   Standard_Real umin,umax,vmin,vmax;
  67   aS->Bounds(umin,umax,vmin,vmax);
  68   const Standard_Real aPeriod = aS->UPeriod();
  69
  70   const Standard_Real aT1=aC2D->FirstParameter();
  71   const Standard_Real aT2=aC2D->LastParameter();
  72   const Standard_Real aTx=aT1+0.467*(aT2-aT1);
  73   const gp_Pnt2d aPx=aC2D->Value(aTx);
  74   //
  75   Standard_Real aUx=aPx.X();
  76   if (fabs(aUx)<aEpsilon)
  77     aUx=0.;
  78   if (fabs(aUx-aPeriod)<aEpsilon)
  79     aUx=aPeriod;
  80   //
  81   Standard_Real dU=0.;
  82   while(aUx <(umin-aEps)) {
  83     aUx+=aPeriod;
  84     dU+=aPeriod;
  85   }
  86   while(aUx>(umax+aEps)) {
  87     aUx-=aPeriod;
  88     dU-=aPeriod;
  89   }
  90   //
  91   if (dU!=0.) {
  92     gp_Vec2d aV2D(dU, 0.);
  93     aC2D->Translate(aV2D);
  94   }
  95 }
  96
  97  //=======================================================================
  98 //function : GetQuadric
  99 //purpose  :
 100 //=======================================================================
 101  static void GetQuadric(const Handle(GeomAdaptor_HSurface)& HS1, IntSurf_Quadric& quad1)
 102 {
 103   switch (HS1->Surface().GetType())
 104   {
 105     case GeomAbs_Plane:    quad1.SetValue(HS1->Surface().Plane()); break;
 106     case GeomAbs_Cylinder: quad1.SetValue(HS1->Surface().Cylinder()); break;
 107     case GeomAbs_Cone:     quad1.SetValue(HS1->Surface().Cone()); break;
 108     case GeomAbs_Sphere:   quad1.SetValue(HS1->Surface().Sphere()); break;
 109     case GeomAbs_Torus:    quad1.SetValue(HS1->Surface().Torus()); break;
 110     default: Standard_ConstructionError::Raise("GeomInt_IntSS::MakeCurve");
 111   }
 112 }
 113
 114 //=======================================================================
 115 //function : Parameters
 116 //purpose  :
 117 //=======================================================================
 118  static void Parameters(  const Handle(GeomAdaptor_HSurface)& HS1,
 119                          const Handle(GeomAdaptor_HSurface)& HS2,
 120                          const gp_Pnt& Ptref,
 121                          Standard_Real& U1,
 122                          Standard_Real& V1,
 123                          Standard_Real& U2,
 124                          Standard_Real& V2)
 125 {
 126   IntSurf_Quadric quad1,quad2;
 127   //
 128   GetQuadric(HS1, quad1);
 129   GetQuadric(HS2, quad2);
 130   //
 131   quad1.Parameters(Ptref,U1,V1);
 132   quad2.Parameters(Ptref,U2,V2);
 133 }
 134
 135 //=======================================================================
 136 //function : ParametersOfNearestPointOnSurface
 137 //purpose  :
 138 //=======================================================================
 139 static Standard_Boolean ParametersOfNearestPointOnSurface(const Extrema_ExtPS theExtr,
 140                                                           Standard_Real& theU,
 141                                                           Standard_Real& theV)
 142 {
 143   if(!theExtr.IsDone() || !theExtr.NbExt())
 144     return Standard_False;
 145
 146   Standard_Integer anIndex = 1;
 147   Standard_Real aMinSQDist = theExtr.SquareDistance(anIndex);
 148   for(Standard_Integer i = 2; i <= theExtr.NbExt(); i++)
 149   {
 150     Standard_Real aSQD = theExtr.SquareDistance(i);
 151     if (aSQD < aMinSQDist)
 152     {
 153       aMinSQDist = aSQD;
 154       anIndex = i;
 155     }
 156   }
 157
 158   theExtr.Point(anIndex).Parameter(theU, theV);
 159
 160   return Standard_True;
 161 }
 162
 163 //=======================================================================
 164 //function : GetSegmentBoundary
 165 //purpose  :
 166 //=======================================================================
 167 static void GetSegmentBoundary( const IntRes2d_IntersectionSegment& theSegm,
 168                                 const Handle(Geom2d_Curve)& theCurve,
 169                                 GeomInt_VectorOfReal& theArrayOfParameters)
 170 {
 171   Standard_Real aU1 = theCurve->FirstParameter(), aU2 = theCurve->LastParameter();
 172
 173   if(theSegm.HasFirstPoint())
 174   {
 175     const IntRes2d_IntersectionPoint& anIPF = theSegm.FirstPoint();
 176     aU1 = anIPF.ParamOnFirst();
 177   }
 178
 179   if(theSegm.HasLastPoint())
 180   {
 181     const IntRes2d_IntersectionPoint& anIPL = theSegm.LastPoint();
 182     aU2 = anIPL.ParamOnFirst();
 183   }
 184
 185   theArrayOfParameters.Append(aU1);
 186   theArrayOfParameters.Append(aU2);
 187 }
 188
 189 //=======================================================================
 190 //function : IntersectCurveAndBoundary
 191 //purpose  :
 192 //=======================================================================
 193 static void IntersectCurveAndBoundary(const Handle(Geom2d_Curve)& theC2d,
 194                                       const Handle(Geom2d_Curve)* const theArrBounds,
 195                                       const Standard_Integer theNumberOfCurves,
 196                                       const Standard_Real theTol,
 197                                       GeomInt_VectorOfReal& theArrayOfParameters)
 198 {
 199   if(theC2d.IsNull())
 200     return;
 201
 202   Geom2dAdaptor_Curve anAC1(theC2d);
 203   for(Standard_Integer aCurID = 0; aCurID < theNumberOfCurves; aCurID++)
 204   {
 205     if(theArrBounds[aCurID].IsNull())
 206       continue;
 207
 208     Geom2dAdaptor_Curve anAC2(theArrBounds[aCurID]);
 209     Geom2dInt_GInter anIntCC2d(anAC1, anAC2, theTol, theTol);
 210
 211     if(!anIntCC2d.IsDone() || anIntCC2d.IsEmpty())
 212       continue;
 213
 214     for (Standard_Integer aPntID = 1; aPntID <= anIntCC2d.NbPoints(); aPntID++)
 215     {
 216       const Standard_Real aParam = anIntCC2d.Point(aPntID).ParamOnFirst();
 217       theArrayOfParameters.Append(aParam);
 218     }
 219
 220     for (Standard_Integer aSegmID = 1; aSegmID <= anIntCC2d.NbSegments(); aSegmID++)
 221     {
 222       GetSegmentBoundary(anIntCC2d.Segment(aSegmID), theC2d, theArrayOfParameters);
 223     }
 224   }
 225 }
 226
 227 //=======================================================================
 228 //function : MakeCurve
 229 //purpose  :
 230 //=======================================================================
 231 void GeomInt_IntSS::MakeCurve(const Standard_Integer Index,
 232                                                 const Handle(Adaptor3d_TopolTool) & dom1,
 233                                                 const Handle(Adaptor3d_TopolTool) & dom2,
 234                                                 const Standard_Real Tol,
 235                                                 const Standard_Boolean Approx,
 236                                                 const Standard_Boolean ApproxS1,
 237                                                 const Standard_Boolean ApproxS2)
 238
 239 {
 240   Standard_Boolean myApprox1, myApprox2, myApprox;
 241   Standard_Real Tolpc, myTolApprox;
 242   IntPatch_IType typl;
 243   Handle(Geom2d_BSplineCurve) H1;
 244   Handle(Geom_Surface) aS1, aS2;
 245   //
 246   Tolpc = Tol;
 247   myApprox=Approx;
 248   myApprox1=ApproxS1;
 249   myApprox2=ApproxS2;
 250   myTolApprox=0.0000001;
 251   //
 252   aS1=myHS1->ChangeSurface().Surface();
 253   aS2=myHS2->ChangeSurface().Surface();
 254   //
 255   Handle(IntPatch_Line) L = myIntersector.Line(Index);
 256   typl = L->ArcType();
 257   //
 258   if(typl==IntPatch_Walking) {
 259     Handle(IntPatch_WLine) aWLine (Handle(IntPatch_WLine)::DownCast(L));
 260     if(aWLine.IsNull()) {
 261       return;
 262     }
 263     L = aWLine;
 264   }
 265   //
 266   // Line Constructor
 267   myLConstruct.Perform(L);
 268   if (!myLConstruct.IsDone() || myLConstruct.NbParts() <= 0) {
 269     return;
 270   }
 271   // Do the Curve
 272   Standard_Boolean ok;
 273   Standard_Integer i, j,  aNbParts;
 274   Standard_Real fprm, lprm;
 275   Handle(Geom_Curve) newc;
 276
 277   switch (typl) {
 278     //########################################
 279     // Line, Parabola, Hyperbola
 280     //########################################
 281   case IntPatch_Lin:
 282   case IntPatch_Parabola:
 283   case IntPatch_Hyperbola: {
 284     if (typl == IntPatch_Lin) {
 285       newc=new Geom_Line (Handle(IntPatch_GLine)::DownCast(L)->Line());
 286     }
 287     else if (typl == IntPatch_Parabola) {
 288       newc=new Geom_Parabola(Handle(IntPatch_GLine)::DownCast(L)->Parabola());
 289     }
 290     else if (typl == IntPatch_Hyperbola) {
 291       newc=new Geom_Hyperbola (Handle(IntPatch_GLine)::DownCast(L)->Hyperbola());
 292     }
 293     //
 294     aNbParts=myLConstruct.NbParts();
 295     for (i=1; i<=aNbParts; i++) {
 296       myLConstruct.Part(i, fprm, lprm);
 297
 298       if (!Precision::IsNegativeInfinite(fprm) &&
 299         !Precision::IsPositiveInfinite(lprm)) {
 300           Handle(Geom_TrimmedCurve) aCT3D=new Geom_TrimmedCurve(newc, fprm, lprm);
 301           sline.Append(aCT3D);
 302           //
 303           if(myApprox1) {
 304             Handle (Geom2d_Curve) C2d;
 305             BuildPCurves(fprm, lprm, Tolpc, myHS1->ChangeSurface().Surface(), newc, C2d);
 306             if(Tolpc>myTolReached2d || myTolReached2d==0.) {
 307               myTolReached2d=Tolpc;
 308             }
 309             slineS1.Append(new Geom2d_TrimmedCurve(C2d,fprm,lprm));
 310           }
 311           else {
 312             slineS1.Append(H1);
 313           }
 314           //
 315           if(myApprox2) {
 316             Handle (Geom2d_Curve) C2d;
 317             BuildPCurves(fprm,lprm,Tolpc,myHS2->ChangeSurface().Surface(),newc,C2d);
 318             if(Tolpc>myTolReached2d || myTolReached2d==0.) {
 319               myTolReached2d=Tolpc;
 320             }
 321             //
 322             slineS2.Append(new Geom2d_TrimmedCurve(C2d,fprm,lprm));
 323           }
 324           else {
 325             slineS2.Append(H1);
 326           }
 327       } // if (!Precision::IsNegativeInfinite(fprm) &&  !Precision::IsPositiveInfinite(lprm))
 328
 329       else {
 330         GeomAbs_SurfaceType typS1 = myHS1->Surface().GetType();
 331         GeomAbs_SurfaceType typS2 = myHS2->Surface().GetType();
 332         if( typS1 == GeomAbs_SurfaceOfExtrusion ||
 333           typS1 == GeomAbs_OffsetSurface ||
 334           typS1 == GeomAbs_SurfaceOfRevolution ||
 335           typS2 == GeomAbs_SurfaceOfExtrusion ||
 336           typS2 == GeomAbs_OffsetSurface ||
 337           typS2 == GeomAbs_SurfaceOfRevolution) {
 338             sline.Append(newc);
 339             slineS1.Append(H1);
 340             slineS2.Append(H1);
 341             continue;
 342         }
 343         Standard_Boolean bFNIt, bLPIt;
 344         Standard_Real aTestPrm, dT=100.;
 345         Standard_Real u1, v1, u2, v2, TolX;
 346         //
 347         bFNIt=Precision::IsNegativeInfinite(fprm);
 348         bLPIt=Precision::IsPositiveInfinite(lprm);
 349
 350         aTestPrm=0.;
 351
 352         if (bFNIt && !bLPIt) {
 353           aTestPrm=lprm-dT;
 354         }
 355         else if (!bFNIt && bLPIt) {
 356           aTestPrm=fprm+dT;
 357         }
 358         //
 359         gp_Pnt ptref(newc->Value(aTestPrm));
 360         //
 361         TolX = Precision::Confusion();
 362         Parameters(myHS1, myHS2, ptref,  u1, v1, u2, v2);
 363         ok = (dom1->Classify(gp_Pnt2d(u1, v1), TolX) != TopAbs_OUT);
 364         if(ok) {
 365           ok = (dom2->Classify(gp_Pnt2d(u2,v2),TolX) != TopAbs_OUT);
 366         }
 367         if (ok) {
 368           sline.Append(newc);
 369           slineS1.Append(H1);
 370           slineS2.Append(H1);
 371         }
 372       }
 373     }// end of for (i=1; i<=myLConstruct.NbParts(); i++)
 374   }// case IntPatch_Lin:  case IntPatch_Parabola:  case IntPatch_Hyperbola:
 375   break;
 376
 377                            //########################################
 378                            // Circle and Ellipse
 379                            //########################################
 380   case IntPatch_Circle:
 381   case IntPatch_Ellipse: {
 382
 383     if (typl == IntPatch_Circle) {
 384       newc = new Geom_Circle
 385         (Handle(IntPatch_GLine)::DownCast(L)->Circle());
 386     }
 387     else {
 388       newc = new Geom_Ellipse
 389         (Handle(IntPatch_GLine)::DownCast(L)->Ellipse());
 390     }
 391     //
 392     Standard_Real aPeriod, aRealEpsilon;
 393     //
 394     aRealEpsilon=RealEpsilon();
 395     aPeriod=M_PI+M_PI;
 396     //
 397     aNbParts=myLConstruct.NbParts();
 398     //
 399     for (i=1; i<=aNbParts; i++) {
 400       myLConstruct.Part(i, fprm, lprm);
 401       //
 402       if (Abs(fprm) > aRealEpsilon || Abs(lprm-aPeriod) > aRealEpsilon) {
 403         //==============================================
 404         Handle(Geom_TrimmedCurve) aTC3D=new Geom_TrimmedCurve(newc,fprm,lprm);
 405         //
 406         sline.Append(aTC3D);
 407         //
 408         fprm=aTC3D->FirstParameter();
 409         lprm=aTC3D->LastParameter ();
 410         ////
 411         if(myApprox1) {
 412           Handle (Geom2d_Curve) C2d;
 413           BuildPCurves(fprm,lprm,Tolpc,myHS1->ChangeSurface().Surface(),newc,C2d);
 414           if(Tolpc>myTolReached2d || myTolReached2d==0.) {
 415             myTolReached2d=Tolpc;
 416           }
 417           slineS1.Append(C2d);
 418         }
 419         else { ////
 420           slineS1.Append(H1);
 421         }
 422         //
 423         if(myApprox2) {
 424           Handle (Geom2d_Curve) C2d;
 425           BuildPCurves(fprm,lprm,Tolpc,myHS2->ChangeSurface().Surface(),newc,C2d);
 426           if(Tolpc>myTolReached2d || myTolReached2d==0) {
 427             myTolReached2d=Tolpc;
 428           }
 429           slineS2.Append(C2d);
 430         }
 431         else {
 432           slineS2.Append(H1);
 433         }
 434         //==============================================
 435       } //if (Abs(fprm) > RealEpsilon() || Abs(lprm-2.*M_PI) > RealEpsilon())
 436       //
 437       else {//  on regarde si on garde
 438         //
 439         if (aNbParts==1) {
 440           if (Abs(fprm) < RealEpsilon() &&  Abs(lprm-2.*M_PI) < RealEpsilon()) {
 441             Handle(Geom_TrimmedCurve) aTC3D=new Geom_TrimmedCurve(newc,fprm,lprm);
 442             //
 443             sline.Append(aTC3D);
 444             fprm=aTC3D->FirstParameter();
 445             lprm=aTC3D->LastParameter ();
 446
 447             if(myApprox1) {
 448               Handle (Geom2d_Curve) C2d;
 449               BuildPCurves(fprm,lprm,Tolpc,myHS1->ChangeSurface().Surface(),newc,C2d);
 450               if(Tolpc>myTolReached2d || myTolReached2d==0) {
 451                 myTolReached2d=Tolpc;
 452               }
 453               slineS1.Append(C2d);
 454             }
 455             else { ////
 456               slineS1.Append(H1);
 457             }
 458
 459             if(myApprox2) {
 460               Handle (Geom2d_Curve) C2d;
 461               BuildPCurves(fprm,lprm,Tolpc,myHS2->ChangeSurface().Surface(),newc,C2d);
 462               if(Tolpc>myTolReached2d || myTolReached2d==0) {
 463                 myTolReached2d=Tolpc;
 464               }
 465               slineS2.Append(C2d);
 466             }
 467             else {
 468               slineS2.Append(H1);
 469             }
 470             break;
 471           }
 472         }
 473         //
 474         Standard_Real aTwoPIdiv17, u1, v1, u2, v2, TolX;
 475         //
 476         aTwoPIdiv17=2.*M_PI/17.;
 477         //
 478         for (j=0; j<=17; j++) {
 479           gp_Pnt ptref (newc->Value (j*aTwoPIdiv17));
 480           TolX = Precision::Confusion();
 481
 482           Parameters(myHS1, myHS2, ptref, u1, v1, u2, v2);
 483           ok = (dom1->Classify(gp_Pnt2d(u1,v1),TolX) != TopAbs_OUT);
 484           if(ok) {
 485             ok = (dom2->Classify(gp_Pnt2d(u2,v2),TolX) != TopAbs_OUT);
 486           }
 487           if (ok) {
 488             sline.Append(newc);
 489             //==============================================
 490             if(myApprox1) {
 491               Handle (Geom2d_Curve) C2d;
 492               BuildPCurves(fprm, lprm, Tolpc, myHS1->ChangeSurface().Surface(), newc, C2d);
 493               if(Tolpc>myTolReached2d || myTolReached2d==0) {
 494                 myTolReached2d=Tolpc;
 495               }
 496               slineS1.Append(C2d);
 497             }
 498             else {
 499               slineS1.Append(H1);
 500             }
 501
 502             if(myApprox2) {
 503               Handle (Geom2d_Curve) C2d;
 504               BuildPCurves(fprm, lprm, Tolpc,myHS2->ChangeSurface().Surface(), newc, C2d);
 505               if(Tolpc>myTolReached2d || myTolReached2d==0) {
 506                 myTolReached2d=Tolpc;
 507               }
 508               slineS2.Append(C2d);
 509             }
 510             else {
 511               slineS2.Append(H1);
 512             }
 513             break;
 514           }//  end of if (ok) {
 515         }//  end of for (Standard_Integer j=0; j<=17; j++)
 516       }//  end of else { on regarde si on garde
 517     }// for (i=1; i<=myLConstruct.NbParts(); i++)
 518   }// IntPatch_Circle: IntPatch_Ellipse
 519   break;
 520
 521                          //########################################
 522                          // Analytic
 523                          //########################################
 524   case IntPatch_Analytic: {
 525     IntSurf_Quadric quad1,quad2;
 526     //
 527     GetQuadric(myHS1, quad1);
 528     GetQuadric(myHS2, quad2);
 529     //=========
 530     IntPatch_ALineToWLine convert (quad1, quad2);
 531
 532     if (!myApprox) {
 533       Handle(Geom2d_BSplineCurve) aH1, aH2;
 534       //
 535       aNbParts=myLConstruct.NbParts();
 536       for (i=1; i<=aNbParts; i++) {
 537         myLConstruct.Part(i, fprm, lprm);
 538         Handle(IntPatch_WLine) WL =
 539           convert.MakeWLine(Handle(IntPatch_ALine)::DownCast(L), fprm, lprm);
 540         //
 541         if(myApprox1) {
 542           aH1 = MakeBSpline2d(WL, 1, WL->NbPnts(), Standard_True);
 543         }
 544
 545         if(myApprox2) {
 546           aH2 = MakeBSpline2d(WL, 1, WL->NbPnts(), Standard_False);
 547         }
 548         sline.Append(MakeBSpline(WL,1,WL->NbPnts()));
 549         slineS1.Append(aH1);
 550         slineS2.Append(aH2);
 551       }
 552     } // if (!myApprox)
 553
 554     else { // myApprox=TRUE
 555       GeomInt_WLApprox theapp3d;
 556       Standard_Real tol2d = myTolApprox;
 557       //
 558       theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, Standard_True);
 559
 560       aNbParts=myLConstruct.NbParts();
 561       for (i=1; i<=aNbParts; i++) {
 562         myLConstruct.Part(i, fprm, lprm);
 563         Handle(IntPatch_WLine) WL =
 564           convert.MakeWLine(Handle(IntPatch_ALine):: DownCast(L),fprm,lprm);
 565
 566         theapp3d.Perform(myHS1,myHS2,WL,Standard_True,myApprox1,myApprox2, 1, WL->NbPnts());
 567         if (!theapp3d.IsDone()) {
 568           //
 569           Handle(Geom2d_BSplineCurve) aH1, aH2;
 570
 571           if(myApprox1) {
 572             aH1 = MakeBSpline2d(WL, 1, WL->NbPnts(), Standard_True);
 573           }
 574
 575           if(myApprox2) {
 576             aH2 = MakeBSpline2d(WL, 1, WL->NbPnts(), Standard_False);
 577           }
 578           sline.Append(MakeBSpline(WL,1,WL->NbPnts()));
 579           slineS1.Append(aH1);
 580           slineS2.Append(aH1);
 581         }
 582         //
 583         else {
 584           if(myApprox1 || myApprox2) {
 585             if( theapp3d.TolReached2d()>myTolReached2d || myTolReached2d==0) {
 586               myTolReached2d = theapp3d.TolReached2d();
 587             }
 588           }
 589
 590           if( theapp3d.TolReached3d()>myTolReached3d || myTolReached3d==0) {
 591             myTolReached3d = theapp3d.TolReached3d();
 592           }
 593
 594           Standard_Integer aNbMultiCurves, nbpoles;
 595           aNbMultiCurves=theapp3d.NbMultiCurves();
 596           for (j=1; j<=aNbMultiCurves; j++) {
 597             const AppParCurves_MultiBSpCurve& mbspc = theapp3d.Value(j);
 598
 599             nbpoles = mbspc.NbPoles();
 600             TColgp_Array1OfPnt tpoles(1, nbpoles);
 601             mbspc.Curve(1, tpoles);
 602             Handle(Geom_BSplineCurve) BS=new Geom_BSplineCurve(tpoles,
 603               mbspc.Knots(),
 604               mbspc.Multiplicities(),
 605               mbspc.Degree());
 606
 607             GeomLib_CheckBSplineCurve Check(BS, myTolCheck, myTolAngCheck);
 608             Check.FixTangent(Standard_True,Standard_True);
 609             //
 610             sline.Append(BS);
 611             //
 612             if(myApprox1) {
 613               TColgp_Array1OfPnt2d tpoles2d(1,nbpoles);
 614               mbspc.Curve(2,tpoles2d);
 615               Handle(Geom2d_BSplineCurve) BS2=new Geom2d_BSplineCurve(tpoles2d,
 616                 mbspc.Knots(),
 617                 mbspc.Multiplicities(),
 618                 mbspc.Degree());
 619
 620               GeomLib_Check2dBSplineCurve newCheck(BS2,myTolCheck,myTolAngCheck);
 621               newCheck.FixTangent(Standard_True,Standard_True);
 622               slineS1.Append(BS2);
 623             }
 624             else {
 625               slineS1.Append(H1);
 626             }
 627
 628             if(myApprox2) {
 629               TColgp_Array1OfPnt2d tpoles2d(1, nbpoles);
 630               Standard_Integer TwoOrThree;
 631               TwoOrThree=myApprox1 ? 3 : 2;
 632               mbspc.Curve(TwoOrThree, tpoles2d);
 633               Handle(Geom2d_BSplineCurve) BS2 =new Geom2d_BSplineCurve(tpoles2d,
 634                 mbspc.Knots(),
 635                 mbspc.Multiplicities(),
 636                 mbspc.Degree());
 637
 638               GeomLib_Check2dBSplineCurve newCheck(BS2,myTolCheck,myTolAngCheck);
 639               newCheck.FixTangent(Standard_True,Standard_True);
 640               //
 641               slineS2.Append(BS2);
 642             }
 643             else {
 644               slineS2.Append(H1);
 645             }
 646             //
 647           }// for (j=1; j<=aNbMultiCurves; j++) {
 648         }// else from if (!theapp3d.IsDone())
 649       }// for (i=1; i<=aNbParts; i++) {
 650     }// else { // myApprox=TRUE
 651   }// case IntPatch_Analytic:
 652   break;
 653
 654   //########################################
 655   // Walking
 656   //########################################
 657   case IntPatch_Walking:{
 658     Handle(IntPatch_WLine) WL =
 659       Handle(IntPatch_WLine)::DownCast(L);
 660
 661 #ifdef OCCT_DEBUG
 662     //WL->Dump(0);
 663 #endif
 664
 665     //
 666     Standard_Integer ifprm, ilprm;
 667     //
 668     if (!myApprox) {
 669       aNbParts=myLConstruct.NbParts();
 670       for (i=1; i<=aNbParts; i++) {
 671         myLConstruct.Part(i, fprm, lprm);
 672         ifprm=(Standard_Integer)fprm;
 673         ilprm=(Standard_Integer)lprm;
 674         //
 675         Handle(Geom2d_BSplineCurve) aH1, aH2;
 676
 677         if(myApprox1) {
 678           aH1 = MakeBSpline2d(WL, ifprm, ilprm, Standard_True);
 679         }
 680         if(myApprox2) {
 681           aH2 = MakeBSpline2d(WL, ifprm, ilprm, Standard_False);
 682         }
 683         //
 684         Handle(Geom_Curve) aBSp=MakeBSpline(WL, ifprm, ilprm);
 685         //
 686         sline.Append(aBSp);
 687         slineS1.Append(aH1);
 688         slineS2.Append(aH2);
 689       }
 690     }
 691     //
 692     else {
 693       Standard_Boolean bIsDecomposited;
 694       Standard_Integer nbiter, aNbSeqOfL;
 695       GeomInt_WLApprox theapp3d;
 696       IntPatch_SequenceOfLine aSeqOfL;
 697       Standard_Real tol2d, aTolSS;
 698       //
 699       tol2d = myTolApprox;
 700       aTolSS=2.e-7;
 701       theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, myHS1 != myHS2);
 702       //
 703       bIsDecomposited =
 704         GeomInt_LineTool::DecompositionOfWLine(WL, myHS1, myHS2, aTolSS, myLConstruct, aSeqOfL);
 705       //
 706       aNbParts=myLConstruct.NbParts();
 707       aNbSeqOfL=aSeqOfL.Length();
 708       //
 709       nbiter = (bIsDecomposited) ? aNbSeqOfL : aNbParts;
 710       //
 711       for(i = 1; i <= nbiter; i++) {
 712         if(bIsDecomposited) {
 713           WL = Handle(IntPatch_WLine)::DownCast(aSeqOfL.Value(i));
 714           ifprm = 1;
 715           ilprm = WL->NbPnts();
 716         }
 717         else {
 718           myLConstruct.Part(i, fprm, lprm);
 719           ifprm = (Standard_Integer)fprm;
 720           ilprm = (Standard_Integer)lprm;
 721         }
 722         //-- lbr :
 723         //-- Si une des surfaces est un plan , on approxime en 2d
 724         //-- sur cette surface et on remonte les points 2d en 3d.
 725         GeomAbs_SurfaceType typs1, typs2;
 726         typs1 = myHS1->Surface().GetType();
 727         typs2 = myHS2->Surface().GetType();
 728         //
 729         if(typs1 == GeomAbs_Plane) {
 730           theapp3d.Perform(myHS1, myHS2, WL, Standard_False,
 731             Standard_True, myApprox2,
 732             ifprm,  ilprm);
 733         }
 734         else if(typs2 == GeomAbs_Plane) {
 735           theapp3d.Perform(myHS1,myHS2,WL,Standard_False,
 736             myApprox1,Standard_True,
 737             ifprm,  ilprm);
 738         }
 739         else {
 740           //
 741           if (myHS1 != myHS2){
 742             if ((typs1==GeomAbs_BezierSurface || typs1==GeomAbs_BSplineSurface) &&
 743               (typs2==GeomAbs_BezierSurface || typs2==GeomAbs_BSplineSurface)) {
 744
 745                 theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, Standard_True);
 746                 //Standard_Boolean bUseSurfaces;
 747                 //bUseSurfaces=NotUseSurfacesForApprox(myFace1, myFace2, WL, ifprm,  ilprm);
 748                 //if (bUseSurfaces) {
 749                 //theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, Standard_False);
 750                 //}
 751             }
 752           }
 753           //
 754           theapp3d.Perform(myHS1,myHS2,WL,Standard_True,
 755             myApprox1,myApprox2,
 756             ifprm,  ilprm);
 757         }
 758
 759         if (!theapp3d.IsDone()) {
 760           //
 761           Handle(Geom2d_BSplineCurve) aH1, aH2;
 762           //
 763           Handle(Geom_Curve) aBSp=MakeBSpline(WL, ifprm, ilprm);
 764           if(myApprox1) {
 765             aH1 = MakeBSpline2d(WL, ifprm, ilprm, Standard_True);
 766           }
 767           if(myApprox2) {
 768             aH2 = MakeBSpline2d(WL, ifprm, ilprm, Standard_False);
 769           }
 770           //
 771           sline.Append(aBSp);
 772           slineS1.Append(aH1);
 773           slineS2.Append(aH2);
 774         }//if (!theapp3d.IsDone())
 775
 776         else {
 777           if(myApprox1 || myApprox2 || (typs1==GeomAbs_Plane || typs2==GeomAbs_Plane)) {
 778             if( theapp3d.TolReached2d()>myTolReached2d || myTolReached2d==0.) {
 779               myTolReached2d = theapp3d.TolReached2d();
 780             }
 781           }
 782           if(typs1==GeomAbs_Plane || typs2==GeomAbs_Plane) {
 783             myTolReached3d = myTolReached2d;
 784           }
 785           else  if( theapp3d.TolReached3d()>myTolReached3d || myTolReached3d==0.) {
 786             myTolReached3d = theapp3d.TolReached3d();
 787           }
 788
 789           Standard_Integer aNbMultiCurves, nbpoles;
 790           //
 791           aNbMultiCurves=theapp3d.NbMultiCurves();
 792           for (j=1; j<=aNbMultiCurves; j++) {
 793             if(typs1 == GeomAbs_Plane) {
 794               const AppParCurves_MultiBSpCurve& mbspc = theapp3d.Value(j);
 795               nbpoles = mbspc.NbPoles();
 796
 797               TColgp_Array1OfPnt2d tpoles2d(1,nbpoles);
 798               TColgp_Array1OfPnt   tpoles(1,nbpoles);
 799
 800               mbspc.Curve(1,tpoles2d);
 801               const gp_Pln&  Pln = myHS1->Surface().Plane();
 802               //
 803               Standard_Integer ik;
 804               for(ik = 1; ik<= nbpoles; ik++) {
 805                 tpoles.SetValue(ik,
 806                   ElSLib::Value(tpoles2d.Value(ik).X(),
 807                   tpoles2d.Value(ik).Y(),
 808                   Pln));
 809               }
 810               //
 811               Handle(Geom_BSplineCurve) BS =
 812                 new Geom_BSplineCurve(tpoles,
 813                 mbspc.Knots(),
 814                 mbspc.Multiplicities(),
 815                 mbspc.Degree());
 816               GeomLib_CheckBSplineCurve Check(BS,myTolCheck,myTolAngCheck);
 817               Check.FixTangent(Standard_True, Standard_True);
 818               //
 819               sline.Append(BS);
 820               //
 821               if(myApprox1) {
 822                 Handle(Geom2d_BSplineCurve) BS1 =
 823                   new Geom2d_BSplineCurve(tpoles2d,
 824                   mbspc.Knots(),
 825                   mbspc.Multiplicities(),
 826                   mbspc.Degree());
 827                 GeomLib_Check2dBSplineCurve Check1(BS1,myTolCheck,myTolAngCheck);
 828                 Check1.FixTangent(Standard_True,Standard_True);
 829                 //
 830                 AdjustUPeriodic (aS1, BS1);
 831                 //
 832                 slineS1.Append(BS1);
 833               }
 834               else {
 835                 slineS1.Append(H1);
 836               }
 837
 838               if(myApprox2) {
 839                 mbspc.Curve(2, tpoles2d);
 840
 841                 Handle(Geom2d_BSplineCurve) BS2 = new Geom2d_BSplineCurve(tpoles2d,
 842                   mbspc.Knots(),
 843                   mbspc.Multiplicities(),
 844                   mbspc.Degree());
 845                 GeomLib_Check2dBSplineCurve newCheck(BS2,myTolCheck,myTolAngCheck);
 846                 newCheck.FixTangent(Standard_True,Standard_True);
 847                 //
 848                 AdjustUPeriodic (aS2, BS2);
 849                 //
 850                 slineS2.Append(BS2);
 851               }
 852               else {
 853                 slineS2.Append(H1);
 854               }
 855             }//if(typs1 == GeomAbs_Plane)
 856             //
 857             else if(typs2 == GeomAbs_Plane) {
 858               const AppParCurves_MultiBSpCurve& mbspc = theapp3d.Value(j);
 859               nbpoles = mbspc.NbPoles();
 860
 861               TColgp_Array1OfPnt2d tpoles2d(1,nbpoles);
 862               TColgp_Array1OfPnt   tpoles(1,nbpoles);
 863               mbspc.Curve((myApprox1==Standard_True)? 2 : 1,tpoles2d);
 864               const gp_Pln&  Pln = myHS2->Surface().Plane();
 865               //
 866               Standard_Integer ik;
 867               for(ik = 1; ik<= nbpoles; ik++) {
 868                 tpoles.SetValue(ik,
 869                   ElSLib::Value(tpoles2d.Value(ik).X(),
 870                   tpoles2d.Value(ik).Y(),
 871                   Pln));
 872
 873               }
 874               //
 875               Handle(Geom_BSplineCurve) BS=new Geom_BSplineCurve(tpoles,
 876                 mbspc.Knots(),
 877                 mbspc.Multiplicities(),
 878                 mbspc.Degree());
 879               GeomLib_CheckBSplineCurve Check(BS,myTolCheck,myTolAngCheck);
 880               Check.FixTangent(Standard_True,Standard_True);
 881               //
 882               sline.Append(BS);
 883               //
 884               if(myApprox2) {
 885                 Handle(Geom2d_BSplineCurve) BS1=new Geom2d_BSplineCurve(tpoles2d,
 886                   mbspc.Knots(),
 887                   mbspc.Multiplicities(),
 888                   mbspc.Degree());
 889                 GeomLib_Check2dBSplineCurve Check1(BS1,myTolCheck,myTolAngCheck);
 890                 Check1.FixTangent(Standard_True,Standard_True);
 891                 //
 892                 //
 893                 AdjustUPeriodic (aS2, BS1);
 894                 //
 895                 slineS2.Append(BS1);
 896               }
 897               else {
 898                 slineS2.Append(H1);
 899               }
 900
 901               if(myApprox1) {
 902                 mbspc.Curve(1,tpoles2d);
 903                 Handle(Geom2d_BSplineCurve) BS2=new Geom2d_BSplineCurve(tpoles2d,
 904                   mbspc.Knots(),
 905                   mbspc.Multiplicities(),
 906                   mbspc.Degree());
 907                 GeomLib_Check2dBSplineCurve Check2(BS2,myTolCheck,myTolAngCheck);
 908                 Check2.FixTangent(Standard_True,Standard_True);
 909                 //
 910                 //
 911                 AdjustUPeriodic (aS1, BS2);
 912                 //
 913                 slineS1.Append(BS2);
 914               }
 915               else {
 916                 slineS1.Append(H1);
 917               }
 918             } // else if(typs2 == GeomAbs_Plane)
 919             //
 920             else { // typs1!=GeomAbs_Plane && typs2!=GeomAbs_Plane
 921               const AppParCurves_MultiBSpCurve& mbspc = theapp3d.Value(j);
 922               nbpoles = mbspc.NbPoles();
 923               TColgp_Array1OfPnt tpoles(1,nbpoles);
 924               mbspc.Curve(1,tpoles);
 925               Handle(Geom_BSplineCurve) BS=new Geom_BSplineCurve(tpoles,
 926                 mbspc.Knots(),
 927                 mbspc.Multiplicities(),
 928                 mbspc.Degree());
 929               GeomLib_CheckBSplineCurve Check(BS,myTolCheck,myTolAngCheck);
 930               Check.FixTangent(Standard_True,Standard_True);
 931               //
 932               //Check IsClosed()
 933               Standard_Real aDist = Max(BS->StartPoint().XYZ().SquareModulus(),
 934                 BS->EndPoint().XYZ().SquareModulus());
 935               Standard_Real eps = Epsilon(aDist);
 936               if(BS->StartPoint().SquareDistance(BS->EndPoint()) < 2.*eps)
 937               {
 938                 // Avoid creating B-splines containing two coincident poles only
 939                 if (mbspc.Degree() == 1 && nbpoles == 2)
 940                   continue;
 941
 942                 if (!BS->IsClosed() && !BS->IsPeriodic())
 943                 {
 944                   //force Closed()
 945                   gp_Pnt aPm((BS->Pole(1).XYZ() + BS->Pole(BS->NbPoles()).XYZ()) / 2.);
 946                   BS->SetPole(1, aPm);
 947                   BS->SetPole(BS->NbPoles(), aPm);
 948                 }
 949               }
 950               sline.Append(BS);
 951
 952               if(myApprox1) {
 953                 TColgp_Array1OfPnt2d tpoles2d(1,nbpoles);
 954                 mbspc.Curve(2,tpoles2d);
 955                 Handle(Geom2d_BSplineCurve) BS1=new Geom2d_BSplineCurve(tpoles2d,
 956                   mbspc.Knots(),
 957                   mbspc.Multiplicities(),
 958                   mbspc.Degree());
 959                 GeomLib_Check2dBSplineCurve newCheck(BS1,myTolCheck,myTolAngCheck);
 960                 newCheck.FixTangent(Standard_True,Standard_True);
 961                 //
 962                 AdjustUPeriodic (aS1, BS1);
 963                 //
 964                 slineS1.Append(BS1);
 965               }
 966               else {
 967                 slineS1.Append(H1);
 968               }
 969               if(myApprox2) {
 970                 TColgp_Array1OfPnt2d tpoles2d(1,nbpoles);
 971                 mbspc.Curve((myApprox1==Standard_True)? 3 : 2,tpoles2d);
 972                 Handle(Geom2d_BSplineCurve) BS2=new Geom2d_BSplineCurve(tpoles2d,
 973                   mbspc.Knots(),
 974                   mbspc.Multiplicities(),
 975                   mbspc.Degree());
 976                 GeomLib_Check2dBSplineCurve newCheck(BS2,myTolCheck,myTolAngCheck);
 977                 newCheck.FixTangent(Standard_True,Standard_True);
 978                 //
 979                 AdjustUPeriodic (aS2, BS2);
 980                 //
 981                 slineS2.Append(BS2);
 982               }
 983               else {
 984                 slineS2.Append(H1);
 985               }
 986             }// else { // typs1!=GeomAbs_Plane && typs2!=GeomAbs_Plane
 987           }// for (j=1; j<=aNbMultiCurves; j++
 988         }
 989       }
 990     }
 991   }
 992   break;
 993
 994   case IntPatch_Restriction:
 995     {
 996       Handle(IntPatch_RLine) RL =
 997         Handle(IntPatch_RLine)::DownCast(L);
 998       Handle(Geom_Curve) aC3d;
 999       Handle(Geom2d_Curve) aC2d1, aC2d2;
1000       Standard_Real aTolReached;
1001       TreatRLine(RL, myHS1, myHS2, aC3d,
1002                   aC2d1, aC2d2, aTolReached);
1003
1004       if(aC3d.IsNull())
1005         break;
1006
1007       Bnd_Box2d aBox1, aBox2;
1008
1009       const Standard_Real aU1f = myHS1->FirstUParameter(),
1010                           aV1f = myHS1->FirstVParameter(),
1011                           aU1l = myHS1->LastUParameter(),
1012                           aV1l = myHS1->LastVParameter();
1013       const Standard_Real aU2f = myHS2->FirstUParameter(),
1014                           aV2f = myHS2->FirstVParameter(),
1015                           aU2l = myHS2->LastUParameter(),
1016                           aV2l = myHS2->LastVParameter();
1017
1018       aBox1.Add(gp_Pnt2d(aU1f, aV1f));
1019       aBox1.Add(gp_Pnt2d(aU1l, aV1l));
1020       aBox2.Add(gp_Pnt2d(aU2f, aV2f));
1021       aBox2.Add(gp_Pnt2d(aU2l, aV2l));
1022
1023       GeomInt_VectorOfReal anArrayOfParameters;
1024
1025       //We consider here that the intersection line is same-parameter-line
1026       anArrayOfParameters.Append(aC3d->FirstParameter());
1027       anArrayOfParameters.Append(aC3d->LastParameter());
1028
1029       TrimILineOnSurfBoundaries(aC2d1, aC2d2, aBox1, aBox2, anArrayOfParameters);
1030
1031       const Standard_Integer aNbIntersSolutionsm1 = anArrayOfParameters.Length() - 1;
1032
1033       //Trim RLine found.
1034       for(Standard_Integer anInd = 0; anInd < aNbIntersSolutionsm1; anInd++)
1035       {
1036         const Standard_Real aParF = anArrayOfParameters(anInd),
1037                             aParL = anArrayOfParameters(anInd+1);
1038
1039         if((aParL - aParF) <= Precision::PConfusion())
1040           continue;
1041
1042         const Standard_Real aPar = 0.5*(aParF + aParL);
1043         gp_Pnt2d aPt;
1044
1045         Handle(Geom2d_Curve) aCurv2d1, aCurv2d2;
1046         if(!aC2d1.IsNull())
1047         {
1048           aC2d1->D0(aPar, aPt);
1049
1050           if(aBox1.IsOut(aPt))
1051             continue;
1052
1053           if(myApprox1)
1054             aCurv2d1 = new Geom2d_TrimmedCurve(aC2d1, aParF, aParL);
1055         }
1056
1057         if(!aC2d2.IsNull())
1058         {
1059           aC2d2->D0(aPar, aPt);
1060
1061           if(aBox2.IsOut(aPt))
1062             continue;
1063
1064           if(myApprox2)
1065             aCurv2d2 = new Geom2d_TrimmedCurve(aC2d2, aParF, aParL);
1066         }
1067
1068         Handle(Geom_Curve) aCurv3d = new Geom_TrimmedCurve(aC3d, aParF, aParL);
1069
1070         sline.Append(aCurv3d);
1071         slineS1.Append(aCurv2d1);
1072         slineS2.Append(aCurv2d2);
1073       }
1074     }
1075     break;
1076   }
1077 }
1078
1079 //=======================================================================
1080 //function : TreatRLine
1081 //purpose  : Approx of Restriction line
1082 //=======================================================================
1083 void GeomInt_IntSS::TreatRLine(const Handle(IntPatch_RLine)& theRL,
1084                 const Handle(GeomAdaptor_HSurface)& theHS1,
1085                 const Handle(GeomAdaptor_HSurface)& theHS2,
1086                 Handle(Geom_Curve)& theC3d,
1087                 Handle(Geom2d_Curve)& theC2d1,
1088                 Handle(Geom2d_Curve)& theC2d2,
1089                 Standard_Real& theTolReached)
1090 {
1091   Handle(GeomAdaptor_HSurface) aGAHS;
1092   Handle(Adaptor2d_HCurve2d) anAHC2d;
1093   Standard_Real tf, tl;
1094   gp_Lin2d aL;
1095   // It is assumed that 2d curve is 2d line (rectangular surface domain)
1096   if(theRL->IsArcOnS1())
1097   {
1098     aGAHS = theHS1;
1099     anAHC2d = theRL->ArcOnS1();
1100     theRL->ParamOnS1(tf, tl);
1101     theC2d1 = Geom2dAdaptor::MakeCurve(anAHC2d->Curve2d());
1102     tf = Max(tf, theC2d1->FirstParameter());
1103     tl = Min(tl, theC2d1->LastParameter());
1104     theC2d1 = new Geom2d_TrimmedCurve(theC2d1, tf, tl);
1105   }
1106   else if (theRL->IsArcOnS2())
1107   {
1108     aGAHS = theHS2;
1109     anAHC2d = theRL->ArcOnS2();
1110     theRL->ParamOnS2(tf, tl);
1111     theC2d2 = Geom2dAdaptor::MakeCurve(anAHC2d->Curve2d());
1112     tf = Max(tf, theC2d2->FirstParameter());
1113     tl = Min(tl, theC2d2->LastParameter());
1114     theC2d2 = new Geom2d_TrimmedCurve(theC2d2, tf, tl);
1115   }
1116   else
1117   {
1118     return;
1119   }
1120   //
1121   //To provide sameparameter it is necessary to get 3d curve as
1122   //approximation of curve on surface.
1123   Standard_Integer aMaxDeg = 8;
1124   Standard_Integer aMaxSeg = 1000;
1125   Approx_CurveOnSurface anApp(anAHC2d, aGAHS, tf, tl, Precision::Confusion(),
1126                               GeomAbs_C1, aMaxDeg, aMaxSeg,
1127                               Standard_True, Standard_False);
1128   if(!anApp.HasResult())
1129     return;
1130
1131   theC3d = anApp.Curve3d();
1132   theTolReached = anApp.MaxError3d();
1133   Standard_Real aTol = Precision::Confusion();
1134   if(theRL->IsArcOnS1())
1135   {
1136     Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface(theHS2->Surface());
1137     BuildPCurves (tf, tl, aTol,
1138                   aS, theC3d, theC2d2);
1139   }
1140   if(theRL->IsArcOnS2())
1141   {
1142     Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface(theHS1->Surface());
1143     BuildPCurves (tf, tl, aTol,
1144                   aS, theC3d, theC2d1);
1145   }
1146   theTolReached = Max(theTolReached, aTol);
1147 }
1148
1149 //=======================================================================
1150 //function : BuildPCurves
1151 //purpose  :
1152 //=======================================================================
1153 void GeomInt_IntSS::BuildPCurves (Standard_Real f,
1154                                   Standard_Real l,
1155                                   Standard_Real& Tol,
1156                                   const Handle (Geom_Surface)& S,
1157                                   const Handle (Geom_Curve)&   C,
1158                                   Handle (Geom2d_Curve)& C2d)
1159 {
1160   if (!C2d.IsNull()) {
1161     return;
1162   }
1163   //
1164   Standard_Real umin,umax,vmin,vmax;
1165   //
1166   S->Bounds(umin, umax, vmin, vmax);
1167   // in class ProjLib_Function the range of parameters is shrank by 1.e-09
1168   if((l - f) > 2.e-09) {
1169     C2d = GeomProjLib::Curve2d(C,f,l,S,umin,umax,vmin,vmax,Tol);
1170     //
1171     if (C2d.IsNull()) {
1172       // proj. a circle that goes through the pole on a sphere to the sphere
1173       Tol += Precision::Confusion();
1174       C2d = GeomProjLib::Curve2d(C,f,l,S,Tol);
1175     }
1176   }
1177   else {
1178     if((l - f) > Epsilon(Abs(f)))
1179     {
1180       //The domain of C2d is [Epsilon(Abs(f)), 2.e-09]
1181       //On this small range C2d can be considered as segment
1182       //of line.
1183
1184       Standard_Real aU=0., aV=0.;
1185       GeomAdaptor_Surface anAS;
1186       anAS.Load(S);
1187       Extrema_ExtPS anExtr;
1188       const gp_Pnt aP3d1 = C->Value(f);
1189       const gp_Pnt aP3d2 = C->Value(l);
1190
1191       anExtr.SetAlgo(Extrema_ExtAlgo_Grad);
1192       anExtr.Initialize(anAS, umin, umax, vmin, vmax,
1193                                 Precision::Confusion(), Precision::Confusion());
1194       anExtr.Perform(aP3d1);
1195
1196       if(ParametersOfNearestPointOnSurface(anExtr, aU, aV))
1197       {
1198         const gp_Pnt2d aP2d1(aU, aV);
1199
1200         anExtr.Perform(aP3d2);
1201
1202         if(ParametersOfNearestPointOnSurface(anExtr, aU, aV))
1203         {
1204           const gp_Pnt2d aP2d2(aU, aV);
1205
1206           if(aP2d1.Distance(aP2d2) > gp::Resolution())
1207           {
1208             TColgp_Array1OfPnt2d poles(1,2);
1209             TColStd_Array1OfReal knots(1,2);
1210             TColStd_Array1OfInteger mults(1,2);
1211             poles(1) = aP2d1;
1212             poles(2) = aP2d2;
1213             knots(1) = f;
1214             knots(2) = l;
1215             mults(1) = mults(2) = 2;
1216
1217             C2d = new Geom2d_BSplineCurve(poles,knots,mults,1);
1218
1219             //Check same parameter in middle point .begin
1220             const gp_Pnt PMid(C->Value(0.5*(f+l)));
1221             const gp_Pnt2d pmidcurve2d(0.5*(aP2d1.XY() + aP2d2.XY()));
1222             const gp_Pnt aPC(anAS.Value(pmidcurve2d.X(), pmidcurve2d.Y()));
1223             const Standard_Real aDist = PMid.Distance(aPC);
1224             Tol = Max(aDist, Tol);
1225             //Check same parameter in middle point .end
1226           }
1227         }
1228       }
1229     }
1230   }
1231   //
1232   if (S->IsUPeriodic() && !C2d.IsNull()) {
1233     // Recadre dans le domaine UV de la face
1234     Standard_Real aTm, U0, aEps, period, du, U0x;
1235     Standard_Boolean bAdjust;
1236     //
1237     aEps = Precision::PConfusion();
1238     period = S->UPeriod();
1239     //
1240     aTm = .5*(f + l);
1241     gp_Pnt2d pm = C2d->Value(aTm);
1242     U0 = pm.X();
1243     //
1244     bAdjust =
1245       GeomInt::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps);
1246     if (bAdjust) {
1247       gp_Vec2d T1(du, 0.);
1248       C2d->Translate(T1);
1249     }
1250   }
1251 }
1252
1253 //=======================================================================
1254 //function : TrimILineOnSurfBoundaries
1255 //purpose  : This function finds intersection points of given curves with
1256 //            surface boundaries and fills theArrayOfParameters by parameters
1257 //            along the given curves corresponding of these points.
1258 //=======================================================================
1259 void GeomInt_IntSS::TrimILineOnSurfBoundaries(const Handle(Geom2d_Curve)& theC2d1,
1260                                               const Handle(Geom2d_Curve)& theC2d2,
1261                                               const Bnd_Box2d& theBound1,
1262                                               const Bnd_Box2d& theBound2,
1263                                               GeomInt_VectorOfReal& theArrayOfParameters)
1264 {
1265   //Rectangular boundaries of two surfaces: [0]:U=Ufirst, [1]:U=Ulast,
1266   //                                        [2]:V=Vfirst, [3]:V=Vlast
1267   const Standard_Integer aNumberOfCurves = 4;
1268   Handle(Geom2d_Curve) aCurS1Bounds[aNumberOfCurves];
1269   Handle(Geom2d_Curve) aCurS2Bounds[aNumberOfCurves];
1270
1271   Standard_Real aU1f=0.0, aV1f=0.0, aU1l=0.0, aV1l=0.0;
1272   Standard_Real aU2f=0.0, aV2f=0.0, aU2l=0.0, aV2l=0.0;
1273
1274   theBound1.Get(aU1f, aV1f, aU1l, aV1l);
1275   theBound2.Get(aU2f, aV2f, aU2l, aV2l);
1276
1277   Standard_Real aDelta = aV1l-aV1f;
1278   if(Abs(aDelta) > RealSmall())
1279   {
1280     if(!Precision::IsInfinite(aU1f))
1281     {
1282       aCurS1Bounds[0] = new Geom2d_Line(gp_Pnt2d(aU1f, aV1f), gp_Dir2d(0.0, 1.0));
1283
1284       if(!Precision::IsInfinite(aDelta))
1285         aCurS1Bounds[0] = new Geom2d_TrimmedCurve(aCurS1Bounds[0], 0, aDelta);
1286     }
1287
1288     if(!Precision::IsInfinite(aU1l))
1289     {
1290       aCurS1Bounds[1] = new Geom2d_Line(gp_Pnt2d(aU1l, aV1f), gp_Dir2d(0.0, 1.0));
1291       if(!Precision::IsInfinite(aDelta))
1292         aCurS1Bounds[1] = new Geom2d_TrimmedCurve(aCurS1Bounds[1], 0, aDelta);
1293     }
1294   }
1295
1296   aDelta = aU1l-aU1f;
1297   if(Abs(aDelta) > RealSmall())
1298   {
1299     if(!Precision::IsInfinite(aV1f))
1300     {
1301       aCurS1Bounds[2] = new Geom2d_Line(gp_Pnt2d(aU1f, aV1f), gp_Dir2d(1.0, 0.0));
1302       if(!Precision::IsInfinite(aDelta))
1303         aCurS1Bounds[2] = new Geom2d_TrimmedCurve(aCurS1Bounds[2], 0, aDelta);
1304     }
1305
1306     if(!Precision::IsInfinite(aV1l))
1307     {
1308       aCurS1Bounds[3] = new Geom2d_Line(gp_Pnt2d(aU1l, aV1l), gp_Dir2d(1.0, 0.0));
1309       if(!Precision::IsInfinite(aDelta))
1310         aCurS1Bounds[3] = new Geom2d_TrimmedCurve(aCurS1Bounds[3], 0, aDelta);
1311     }
1312   }
1313
1314   aDelta = aV2l-aV2f;
1315   if(Abs(aDelta) > RealSmall())
1316   {
1317     if(!Precision::IsInfinite(aU2f))
1318     {
1319       aCurS2Bounds[0] = new Geom2d_Line(gp_Pnt2d(aU2f, aV2f), gp_Dir2d(0.0, 1.0));
1320       if(!Precision::IsInfinite(aDelta))
1321         aCurS2Bounds[0] = new Geom2d_TrimmedCurve(aCurS2Bounds[0], 0, aDelta);
1322     }
1323
1324     if(!Precision::IsInfinite(aU2l))
1325     {
1326       aCurS2Bounds[1] = new Geom2d_Line(gp_Pnt2d(aU2l, aV2f), gp_Dir2d(0.0, 1.0));
1327       if(!Precision::IsInfinite(aDelta))
1328         aCurS2Bounds[1] = new Geom2d_TrimmedCurve(aCurS2Bounds[1], 0, aDelta);
1329     }
1330   }
1331
1332   aDelta = aU2l-aU2f;
1333   if(Abs(aDelta) > RealSmall())
1334   {
1335     if(!Precision::IsInfinite(aV2f))
1336     {
1337       aCurS2Bounds[2] = new Geom2d_Line(gp_Pnt2d(aU2f, aV2f), gp_Dir2d(1.0, 0.0));
1338       if(!Precision::IsInfinite(aDelta))
1339         aCurS2Bounds[2] = new Geom2d_TrimmedCurve(aCurS2Bounds[2], 0, aDelta);
1340     }
1341
1342     if(!Precision::IsInfinite(aV2l))
1343     {
1344       aCurS2Bounds[3] = new Geom2d_Line(gp_Pnt2d(aU2l, aV2l), gp_Dir2d(1.0, 0.0));
1345       if(!Precision::IsInfinite(aDelta))
1346         aCurS2Bounds[3] = new Geom2d_TrimmedCurve(aCurS2Bounds[3], 0, aDelta);
1347     }
1348   }
1349
1350   const Standard_Real anIntTol = 10.0*Precision::Confusion();
1351
1352   IntersectCurveAndBoundary(theC2d1, aCurS1Bounds,
1353                         aNumberOfCurves, anIntTol, theArrayOfParameters);
1354
1355   IntersectCurveAndBoundary(theC2d2, aCurS2Bounds,
1356                         aNumberOfCurves, anIntTol, theArrayOfParameters);
1357
1358   std::sort(theArrayOfParameters.begin(), theArrayOfParameters.end());
1359 }
1360
1361 //=======================================================================
1362 //function : MakeBSpline
1363 //purpose  :
1364 //=======================================================================
1365 Handle(Geom_Curve) GeomInt_IntSS::MakeBSpline  (const Handle(IntPatch_WLine)& WL,
1366                                                 const Standard_Integer ideb,
1367                                                 const Standard_Integer ifin)
1368 {
1369   const Standard_Integer nbpnt = ifin-ideb+1;
1370   TColgp_Array1OfPnt poles(1,nbpnt);
1371   TColStd_Array1OfReal knots(1,nbpnt);
1372   TColStd_Array1OfInteger mults(1,nbpnt);
1373   Standard_Integer i = 1, ipidebm1 = ideb;
1374   for(; i<=nbpnt; ipidebm1++, i++)
1375   {
1376     poles(i) = WL->Point(ipidebm1).Value();
1377     mults(i) = 1;
1378     knots(i) = i-1;
1379   }
1380   mults(1) = mults(nbpnt) = 2;
1381   return new Geom_BSplineCurve(poles,knots,mults,1);
1382 }
1383
1384 //=======================================================================
1385 //function : MakeBSpline2d
1386 //purpose  :
1387 //=======================================================================
1388 Handle(Geom2d_BSplineCurve) GeomInt_IntSS::
1389       MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine,
1390                     const Standard_Integer ideb,
1391                     const Standard_Integer ifin,
1392                     const Standard_Boolean onFirst)
1393 {
1394   const Standard_Integer nbpnt = ifin-ideb+1;
1395   TColgp_Array1OfPnt2d poles(1,nbpnt);
1396   TColStd_Array1OfReal knots(1,nbpnt);
1397   TColStd_Array1OfInteger mults(1,nbpnt);
1398   Standard_Integer i = 1, ipidebm1 = ideb;
1399   for(; i <= nbpnt; ipidebm1++, i++)
1400   {
1401     Standard_Real U, V;
1402     if(onFirst)
1403           theWLine->Point(ipidebm1).ParametersOnS1(U, V);
1404     else
1405           theWLine->Point(ipidebm1).ParametersOnS2(U, V);
1406     poles(i).SetCoord(U, V);
1407     mults(i) = 1;
1408     knots(i) = i-1;
1409   }
1410
1411   mults(1) = mults(nbpnt) = 2;
1412   return new Geom2d_BSplineCurve(poles,knots,mults,1);
1413 }