src/IntPatch/IntPatch_RstInt.cxx

   1 // Created on: 1993-05-07
   2 // Created by: Jacques GOUSSARD
   3 // Copyright (c) 1993-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 // ----------------------------------------------------------------------
  18 //-- lbr: Modifs importantes du 16-17 Nov 95
  19 //--      - Chercher APointOnRstStillExist et OnDifferentRst
  20 //--      On veut pouvoir creer un Vtx (A1 sur S1, A2    sur S2)
  21 //--                         et le Vtx (A1 sur S1, A2bis sur S2)
  22 //--      ce qui revient a distinguer un point deja pose sur une
  23 //--      restriction de S avec un point pose sur une nouvelle
  24 //--       restriction de S.
  25 //--      - Pour rester coherent avec cette facon de faire,
  26 //--      Chercher(Nbvtx++).
  27
  28 #include <Adaptor2d_HCurve2d.hxx>
  29 #include <Adaptor3d_HSurface.hxx>
  30 #include <Adaptor3d_TopolTool.hxx>
  31 #include <gp_Pnt2d.hxx>
  32 #include <Intf_SectionPoint.hxx>
  33 #include <Intf_TangentZone.hxx>
  34 #include <IntPatch_CSFunction.hxx>
  35 #include <IntPatch_CurvIntSurf.hxx>
  36 #include <IntPatch_HInterTool.hxx>
  37 #include <IntPatch_Line.hxx>
  38 #include <IntPatch_PolyArc.hxx>
  39 #include <IntPatch_PolyLine.hxx>
  40 #include <IntPatch_RLine.hxx>
  41 #include <IntPatch_RstInt.hxx>
  42 #include <IntPatch_SearchPnt.hxx>
  43 #include <IntPatch_WLine.hxx>
  44 #include <IntSurf.hxx>
  45 #include <Precision.hxx>
  46 #include <Standard_DomainError.hxx>
  47 #include <TColgp_SequenceOfPnt.hxx>
  48 #include <TColgp_SequenceOfPnt2d.hxx>
  49
  50 #define myInfinite 1.e15 // the same as was in Adaptor3d_TopolTool
  51
  52 static void Recadre(GeomAbs_SurfaceType typeS1,
  53                     GeomAbs_SurfaceType typeS2,
  54                     const Handle(IntPatch_WLine)& wlin,
  55                     Standard_Integer Param,
  56                     Standard_Real& U1,
  57                     Standard_Real& V1,
  58                     Standard_Real& U2,
  59                     Standard_Real& V2)
  60 {
  61   Standard_Integer nbpnts = wlin->NbPnts();
  62   if(Param<1) Param=1; else if(Param>nbpnts) Param=nbpnts;
  63   Standard_Real U1p,V1p,U2p,V2p;
  64
  65   wlin->Point(Param).Parameters(U1p,V1p,U2p,V2p);
  66   switch(typeS1) {
  67   case GeomAbs_Cylinder:
  68   case GeomAbs_Cone:
  69   case GeomAbs_Sphere:
  70   case GeomAbs_Torus:
  71     while(U1<(U1p-1.5*M_PI)) U1+=M_PI+M_PI;
  72     while(U1>(U1p+1.5*M_PI)) U1-=M_PI+M_PI;
  73     break;
  74   default:
  75     break;
  76   }
  77   if(typeS1==GeomAbs_Torus) {
  78     while(V1<(V1p-1.5*M_PI)) V1+=M_PI+M_PI;
  79     while(V1>(V1p+1.5*M_PI)) V1-=M_PI+M_PI;
  80   }
  81
  82   switch(typeS2) {
  83   case GeomAbs_Cylinder:
  84   case GeomAbs_Cone:
  85   case GeomAbs_Sphere:
  86   case GeomAbs_Torus:
  87     while(U2<(U2p-1.5*M_PI)) U2+=M_PI+M_PI;
  88     while(U2>(U2p+1.5*M_PI)) U2-=M_PI+M_PI;
  89     break;
  90   default:
  91     break;
  92   }
  93   if(typeS2==GeomAbs_Torus) {
  94     while(V2<(V1p-1.5*M_PI)) V2+=M_PI+M_PI;
  95     while(V2>(V2p+1.5*M_PI)) V2-=M_PI+M_PI;
  96   }
  97 }
  98
  99 const Standard_Real Confusion = Precision::Confusion();
 100
 101 inline Standard_Real Tol3d (const Handle(Adaptor3d_HVertex)& vtx,
 102                             const Handle(Adaptor3d_TopolTool)& Domain,
 103                             const Standard_Real tolDef = 0.)
 104 {
 105   return (Domain->Has3d() ? Domain->Tol3d(vtx)
 106           : tolDef < Confusion ? Confusion
 107           : tolDef);
 108 }
 109
 110 inline Standard_Real Tol3d (const Handle(Adaptor2d_HCurve2d)& arc,
 111                             const Handle(Adaptor3d_TopolTool)& Domain,
 112                             const Standard_Real tolDef = 0.)
 113 {
 114   return (Domain->Has3d() ? Domain->Tol3d(arc)
 115           : tolDef < Confusion ? Confusion
 116           : tolDef);
 117 }
 118
 119 static Standard_Boolean CoincideOnArc(const gp_Pnt& Ptsommet,
 120                                       const Handle(Adaptor2d_HCurve2d)& A,
 121                                       const Handle(Adaptor3d_HSurface)& Surf,
 122                                       const Standard_Real Toler,
 123                                       const Handle(Adaptor3d_TopolTool)& Domain,
 124                                       Handle(Adaptor3d_HVertex)& Vtx)
 125 {
 126   Standard_Real distmin = RealLast();
 127   Standard_Real tolarc = Max(Toler,Tol3d(A,Domain));
 128
 129   Domain->Initialize(A);
 130   Domain->InitVertexIterator();
 131   while (Domain->MoreVertex()) {
 132     Handle(Adaptor3d_HVertex) vtx1 = Domain->Vertex();
 133     Standard_Real prm = IntPatch_HInterTool::Parameter(vtx1,A);
 134     gp_Pnt2d p2d = A->Value(prm);
 135     gp_Pnt point = Surf->Value(p2d.X(),p2d.Y());
 136     const Standard_Real dist = point.Distance(Ptsommet);
 137     Standard_Real tol = Max (tolarc, Tol3d(vtx1,Domain));
 138
 139     if (dist <= tol && dist <= distmin) { // the best coincidence
 140       distmin = dist;
 141       Vtx = vtx1;
 142     }
 143     Domain->NextVertex();
 144   }
 145   return distmin < RealLast();
 146 }
 147
 148
 149 static void VerifyTgline(const Handle(IntPatch_WLine)& wlin,
 150                          const Standard_Integer param,
 151                          const Standard_Real Tol,
 152                          gp_Vec& Tgl) {
 153
 154   if(   Abs(Tgl.X())<Tol
 155      && Abs(Tgl.Y())<Tol
 156      && Abs(Tgl.Z())<Tol) {
 157     //-- On construit une tangente plus grande
 158     //-- (Eviter des points tres proches ds Walking)
 159     Standard_Integer i, n, nbpt=wlin->NbPnts();
 160     Standard_Boolean forward = (nbpt-param) >= (param-1);
 161     for (n = 2; n > 0; n--, forward = !forward) {
 162       if (forward) {
 163         for(i=param+1; i<=nbpt; i++) {
 164           gp_Vec T(wlin->Point(param).Value(),wlin->Point(i).Value());
 165           if(   Abs(T.X())>=Tol
 166              || Abs(T.Y())>=Tol
 167              || Abs(T.Z())>=Tol) {
 168             Tgl = T ;
 169             return;
 170           }
 171         }
 172       }
 173       else {
 174         for(i=param-1; i>=1; i--) {
 175           gp_Vec T(wlin->Point(i).Value(),wlin->Point(param).Value());
 176           if(   Abs(T.X())>=Tol
 177              || Abs(T.Y())>=Tol
 178              || Abs(T.Z())>=Tol) {
 179             Tgl = T ;
 180             return;
 181           }
 182         }
 183       }
 184     }
 185   }
 186 }
 187
 188 static void GetLinePoint2d (const Handle(IntPatch_Line)& L,
 189                             const Standard_Real param,
 190                             const Standard_Boolean OnFirst,
 191                             Standard_Real& U, Standard_Real& V)
 192 {
 193   Handle(IntPatch_WLine) wlin = Handle(IntPatch_WLine)::DownCast(L);
 194   Handle(IntPatch_RLine) rlin = Handle(IntPatch_RLine)::DownCast(L);
 195   IntPatch_IType typL = L->ArcType();
 196   Standard_Integer Nbptlin = (typL == IntPatch_Walking
 197                               ? wlin->NbPnts()
 198                               : rlin->NbPnts());
 199
 200   Standard_Real par = IntegerPart(param);
 201   Standard_Integer Irang = Standard_Integer(par);
 202   if (Irang == Nbptlin) {
 203     Irang--;
 204     par = 1.0;
 205   }
 206   else
 207     par = Abs(param-par);
 208
 209   Standard_Real us1,vs1,us2,vs2;
 210   if (typL == IntPatch_Walking) {
 211     if (OnFirst) {
 212       wlin->Point(Irang).ParametersOnS1(us1,vs1);
 213       wlin->Point(Irang+1).ParametersOnS1(us2,vs2);
 214     }
 215     else {
 216       wlin->Point(Irang).ParametersOnS2(us1,vs1);
 217       wlin->Point(Irang+1).ParametersOnS2(us2,vs2);
 218     }
 219   }
 220   else {
 221     if (OnFirst) {
 222       rlin->Point(Irang).ParametersOnS1(us1,vs1);
 223       rlin->Point(Irang+1).ParametersOnS1(us2,vs2);
 224     }
 225     else {
 226       rlin->Point(Irang).ParametersOnS2(us1,vs1);
 227       rlin->Point(Irang+1).ParametersOnS2(us2,vs2);
 228     }
 229   }
 230
 231   U = (1.-par)*us1+par*us2;
 232   V = (1.-par)*vs1+par*vs2;
 233 }
 234
 235 static void GetWLinePoint (const Handle(IntPatch_WLine)& wlin,
 236                           const Standard_Real param,
 237                           Standard_Real& U1, Standard_Real& V1,
 238                           Standard_Real& U2, Standard_Real& V2,
 239                           gp_Pnt& P)
 240 {
 241   Standard_Integer Nbptlin = wlin->NbPnts();
 242   Standard_Real par = IntegerPart(param);
 243   Standard_Integer Irang = Standard_Integer(par);
 244   if (Irang == Nbptlin) {
 245     Irang--;
 246     par = 1.0;
 247   }
 248   else
 249     par = Abs(param-par);
 250
 251   const IntSurf_PntOn2S& p2s1 = wlin->Point(Irang);
 252   const IntSurf_PntOn2S& p2s2 = wlin->Point(Irang+1);
 253   const gp_Pnt& p1 = p2s1.Value();
 254   const gp_Pnt& p2 = p2s2.Value();
 255   P.ChangeCoord().SetLinearForm(1.-par, p1.XYZ(), par, p2.XYZ());
 256
 257   Standard_Real us1,vs1,us2,vs2;
 258   p2s1.ParametersOnS1(us1,vs1);
 259   p2s2.ParametersOnS1(us2,vs2);
 260   U1 = (1.-par)*us1+par*us2;
 261   V1 = (1.-par)*vs1+par*vs2;
 262
 263   p2s1.ParametersOnS2(us1,vs1);
 264   p2s2.ParametersOnS2(us2,vs2);
 265   U2 = (1.-par)*us1+par*us2;
 266   V2 = (1.-par)*vs1+par*vs2;
 267 }
 268
 269 static Standard_Boolean FindParameter(const Handle(IntPatch_Line)& L,
 270                                       const Handle(Adaptor3d_HSurface)& OtherSurf,
 271                                       const Standard_Real Tol,
 272                                       const gp_Pnt& Ptsom,
 273                                       const gp_Pnt2d& Ptsom2d,
 274                                       Standard_Real& Param,
 275                                       gp_Vec& Tgl,
 276                                       const Standard_Integer ParamApproche,
 277                                       const Standard_Boolean OnFirst)
 278
 279 {
 280   // MSV 28.03.2002: find parameter on WLine in 2d space
 281
 282   //Si la ligne est de type restriction, c est qu on provient necessairement
 283   // du cas implicite/parametree, et que la ligne est restriction de
 284   // la surface bi-parametree. Cette surface bi-parametree est necessairement
 285   // passee en argument a PutVertexOnline dans la variable OtherSurf.
 286
 287   // Dans le cas d une ligne de cheminement, il faudrait voir la projection
 288   // et le calcul de la tangente.
 289
 290   Handle(IntPatch_RLine) rlin (Handle(IntPatch_RLine)::DownCast (L)); //-- aucune verification n est
 291   Handle(IntPatch_WLine) wlin (Handle(IntPatch_WLine)::DownCast (L)); //-- faite au cast.
 292   gp_Pnt ptbid;
 293   gp_Vec d1u,d1v;
 294   gp_Pnt2d p2d;
 295   gp_Vec2d d2d;
 296   Standard_Real Tol2 = Tol*Tol;
 297   IntPatch_IType typL = L->ArcType();
 298   Tgl.SetCoord(0.0,0.0,0.0);
 299
 300   if ( typL == IntPatch_Restriction) {
 301     if     (!OnFirst && rlin->IsArcOnS1()) {
 302       IntPatch_HInterTool::Project(rlin->ArcOnS1(),Ptsom2d,Param,p2d);
 303       rlin->ArcOnS1()->D1(Param,p2d,d2d);
 304     }
 305     else if (OnFirst && rlin->IsArcOnS2()) {
 306       IntPatch_HInterTool::Project(rlin->ArcOnS2(),Ptsom2d,Param,p2d);
 307       rlin->ArcOnS2()->D1(Param,p2d,d2d);
 308     }
 309     else {
 310       return(Standard_False);
 311     }
 312     OtherSurf->D1(p2d.X(),p2d.Y(),ptbid,d1u,d1v);
 313     if (ptbid.SquareDistance(Ptsom) > Tol2) {
 314       return Standard_False;
 315     }
 316     Tgl.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
 317     return(Standard_True);
 318   }
 319
 320   else if (typL == IntPatch_Walking) {
 321     Standard_Integer i, is, nbpt=wlin->NbPnts();
 322     Standard_Real norm1,norm2;
 323     Standard_Integer ParamSearchInf=1;
 324     Standard_Integer ParamSearchSup=nbpt;
 325
 326     if((ParamApproche-2) > ParamSearchInf) {
 327       ParamSearchInf = ParamApproche-2;
 328     }
 329     if((ParamApproche+2) < ParamSearchSup) {
 330       ParamSearchSup = ParamApproche+2;
 331     }
 332
 333     Standard_Integer inf[3],sup[3];
 334     // first search inside close bounding around ParamApproche;
 335     // then search to the nearest end of line;
 336     // and then search to the farest end of line.
 337     inf[0] = ParamSearchInf; sup[0] = ParamSearchSup;
 338     if (ParamSearchInf-1 < nbpt-ParamSearchSup) {
 339       inf[1] = 1;              sup[1] = ParamSearchInf;
 340       inf[2] = ParamSearchSup; sup[2] = nbpt;
 341     }
 342     else {
 343       inf[1] = ParamSearchSup; sup[1] = nbpt;
 344       inf[2] = 1;              sup[2] = ParamSearchInf;
 345     }
 346
 347     Standard_Boolean found = Standard_False;
 348     for (is=0; is < 3 && !found; is++) {
 349       gp_Vec v1,v2;
 350       gp_Pnt p1,p2;
 351       p1 = wlin->Point(inf[is]).Value();
 352       v1 = gp_Vec (Ptsom,p1);
 353       norm1 = v1.SquareMagnitude();
 354       Standard_Real normmin = Tol2;
 355       Standard_Integer ibest = 0;
 356       if (norm1 <= normmin) {
 357         normmin = norm1;
 358         ibest = inf[is];
 359       }
 360       for (i=inf[is]+1; i <= sup[is] && !found; i++) {
 361         p2 = wlin->Point(i).Value();
 362         v2 = gp_Vec (Ptsom,p2);
 363         norm2 = v2.SquareMagnitude();
 364         if (v1.Dot(v2) < 0.) {
 365           Param = (Standard_Real)(i-1) + 1./(1.+Sqrt(norm2/norm1));
 366           Tgl = gp_Vec (p1,p2);
 367           found = Standard_True;
 368         }
 369         else if (norm2 < normmin) {
 370           normmin = norm2;
 371           ibest = i;
 372         }
 373         v1 = v2; p1 = p2; norm1 = norm2;
 374       }
 375       if (!found && ibest) {
 376         Param = (Standard_Real)ibest;
 377         found = Standard_True;
 378       }
 379     }
 380     if (found) return Standard_True;
 381   }
 382   else {
 383     Standard_DomainError::Raise();
 384   }
 385   return Standard_False;
 386 }
 387
 388 inline Standard_Boolean ArePnt2dEqual(const gp_Pnt2d& p1, const gp_Pnt2d& p2,
 389                                       const Standard_Real tolU,
 390                                       const Standard_Real tolV)
 391 {
 392   return Abs(p1.X()-p2.X()) < tolU && Abs(p1.Y()-p2.Y()) < tolV;
 393 }
 394
 395 static gp_Pnt2d GetPointOnPolygo(const IntPatch_Polygo& Pol,
 396                                  const Standard_Real param)
 397 {
 398   Standard_Real par = IntegerPart(param);
 399   Standard_Integer irang = Standard_Integer(par) + 1;
 400   if (irang == Pol.NbPoints()) {
 401     irang--;
 402     par = 1.;
 403   }
 404   else {
 405     par = Abs(param-par);
 406   }
 407   gp_Pnt2d p1 = Pol.Point(irang);
 408   gp_Pnt2d p2 = Pol.Point(irang+1);
 409   gp_Pnt2d p;
 410   p.ChangeCoord().SetLinearForm(1.-par,p1.XY(),par,p2.XY());
 411   return p;
 412 }
 413
 414 static Standard_Boolean IsSegment2dSmall(const IntPatch_Polygo& Pol,
 415                                          const Standard_Real parmin,
 416                                          const Standard_Real parmax,
 417                                          const Standard_Real URes,
 418                                          const Standard_Real VRes)
 419 {
 420   Standard_Integer irang1 = Standard_Integer(IntegerPart(parmin)) + 2;
 421   Standard_Integer irang2 = Standard_Integer(IntegerPart(parmax)) + 1;
 422   gp_Pnt2d p1,p2;
 423   Standard_Real du=0.,dv=0.;
 424   p1 = GetPointOnPolygo(Pol,parmin);
 425   for (Standard_Integer i=irang1; i <= irang2 && du <= URes && dv <= VRes; i++) {
 426     p2 = Pol.Point(i);
 427     du += Abs(p2.X()-p1.X());
 428     dv += Abs(p2.Y()-p1.Y());
 429     p1 = p2;
 430   }
 431   if (du <= URes && dv <= VRes) {
 432     p2 = GetPointOnPolygo(Pol,parmax);
 433     du += Abs(p2.X()-p1.X());
 434     dv += Abs(p2.Y()-p1.Y());
 435   }
 436   return du <= URes && dv <= VRes;
 437 }
 438
 439 //=======================================================================
 440 //function : PutVertexOnLine
 441 //purpose  :
 442 //=======================================================================
 443
 444 void IntPatch_RstInt::PutVertexOnLine (const Handle(IntPatch_Line)& L,
 445                                        const Handle(Adaptor3d_HSurface)& Surf,
 446                                        const Handle(Adaptor3d_TopolTool)& Domain,
 447                                        const Handle(Adaptor3d_HSurface)& OtherSurf,
 448                                        const Standard_Boolean OnFirst,
 449                                        const Standard_Real Tol)
 450  {
 451
 452 // Domain est le domaine de restriction de la surface Surf.
 453 // On intersectera un arc de Surf avec la surface OtherSurf.
 454 // Si OnFirst = True, c est que la surface Surf correspond a la 1ere
 455 // surface donnee aux algo d intersection.
 456
 457   IntPatch_SearchPnt Commun;
 458
 459   Standard_Real U,V,W;
 460   Standard_Real U1,V1,U2 = 0.,V2 = 0.;
 461   Standard_Real paramarc=0.,paramline=0.;
 462   Standard_Integer i,j,k;
 463   TColgp_SequenceOfPnt locpt;
 464   TColgp_SequenceOfPnt2d locpt2;
 465   Handle(IntPatch_RLine) rlin (Handle(IntPatch_RLine)::DownCast (L)); //-- aucune verification n est
 466   Handle(IntPatch_WLine) wlin (Handle(IntPatch_WLine)::DownCast (L)); //-- faite au cast.
 467   Standard_Integer Nbvtx =0;
 468   Standard_Integer Nbptlin =0;
 469   Standard_Real tolPLin = Surf->UResolution(Precision::Confusion());
 470   tolPLin = Max (tolPLin, Surf->VResolution(Precision::Confusion()));
 471   tolPLin = Min (tolPLin, Precision::Confusion());
 472   IntPatch_PolyLine PLin(tolPLin);
 473
 474   Standard_Real PFirst,PLast;
 475   Standard_Integer NbEchant;
 476   gp_Pnt ptsommet, ptbid;
 477   gp_Vec tgline, tgrst, d1u, d1v, normsurf;
 478
 479   gp_Pnt2d p2d;
 480   gp_Vec2d d2d;
 481
 482   IntPatch_Point Sommet, ptline;
 483   Handle(Adaptor3d_HVertex) vtxarc,vtxline;
 484   Handle(Adaptor2d_HCurve2d) arc;
 485   Standard_Boolean VtxOnArc, duplicate, found;
 486   IntSurf_Transition transarc,transline;
 487
 488   IntPatch_IType typL = L->ArcType();
 489   if (typL == IntPatch_Walking) {
 490     Nbvtx = wlin->NbVertex();
 491     PLin.SetWLine(OnFirst,wlin);
 492     Nbptlin = wlin->NbPnts();
 493   }
 494   else if ( typL == IntPatch_Restriction) {
 495     Nbvtx = rlin->NbVertex();
 496     PLin.SetRLine(OnFirst,rlin);
 497     Nbptlin = rlin->NbPnts();
 498   }
 499   else {
 500     Standard_DomainError::Raise();
 501   }
 502   if (!Domain->Has3d())
 503     // don't use computed deflection in the mode of pure geometric intersection
 504     PLin.ResetError();
 505
 506   const Standard_Boolean SurfaceIsUClosed = Surf->IsUClosed();
 507   const Standard_Boolean SurfaceIsVClosed = Surf->IsVClosed();
 508   const Standard_Boolean OSurfaceIsUClosed = OtherSurf->IsUClosed();
 509   const Standard_Boolean OSurfaceIsVClosed = OtherSurf->IsVClosed();
 510   const Standard_Boolean possiblyClosed = (SurfaceIsUClosed || SurfaceIsVClosed ||
 511                                            OSurfaceIsUClosed || OSurfaceIsVClosed);
 512   Standard_Real tolUClosed=0., tolVClosed=0., tolOUClosed=0., tolOVClosed=0.;
 513   if (possiblyClosed) {
 514     if (SurfaceIsUClosed)
 515       tolUClosed = (Surf->LastUParameter() - Surf->FirstUParameter()) * 0.01;
 516     if (SurfaceIsVClosed)
 517       tolVClosed = (Surf->LastVParameter() - Surf->FirstVParameter()) * 0.01;
 518     if (OSurfaceIsUClosed)
 519       tolOUClosed = (OtherSurf->LastUParameter() - OtherSurf->FirstUParameter()) * 0.01;
 520     if (OSurfaceIsVClosed)
 521       tolOVClosed = (OtherSurf->LastVParameter() - OtherSurf->FirstVParameter()) * 0.01;
 522   }
 523
 524   //------------------------------------------------------------------------
 525   //-- On traite le cas ou la surface est periodique                      --
 526   //-- il faut dans ce cas considerer la restriction                      --
 527   //--                                la restriction decalee de +-2PI     --
 528   //------------------------------------------------------------------------
 529   const Handle(Adaptor3d_HSurface)& Surf1 = (OnFirst ? Surf : OtherSurf);
 530   const Handle(Adaptor3d_HSurface)& Surf2 = (OnFirst ? OtherSurf : Surf);
 531   GeomAbs_SurfaceType TypeS1 = Surf1->GetType();
 532   GeomAbs_SurfaceType TypeS2 = Surf2->GetType();
 533   Standard_Boolean SurfaceIsPeriodic   = Standard_False;
 534   Standard_Boolean SurfaceIsBiPeriodic = Standard_False;
 535   GeomAbs_SurfaceType surfacetype = (OnFirst ? TypeS1 : TypeS2);
 536   if(   surfacetype == GeomAbs_Cylinder
 537      || surfacetype == GeomAbs_Cone
 538      || surfacetype == GeomAbs_Torus
 539      || surfacetype == GeomAbs_Sphere) {
 540     SurfaceIsPeriodic = Standard_True;
 541     if(surfacetype == GeomAbs_Torus) {
 542       SurfaceIsBiPeriodic = Standard_True;
 543     }
 544   }
 545
 546   Standard_Integer NumeroEdge=0;
 547   Domain->Init();
 548   while (Domain->More()) {
 549     NumeroEdge++;
 550     arc = Domain->Value();
 551
 552     // MSV Oct 15, 2001: use tolerance of this edge if possible
 553     Standard_Real edgeTol = Tol3d(arc,Domain,Tol);
 554     Standard_Real URes = Surf->UResolution(edgeTol);
 555     Standard_Real VRes = Surf->VResolution(edgeTol);
 556
 557     IntPatch_HInterTool::Bounds(arc,PFirst,PLast);
 558     if(Precision::IsNegativeInfinite(PFirst))
 559       PFirst = -myInfinite;
 560     if(Precision::IsPositiveInfinite(PLast))
 561       PLast = myInfinite;
 562     //if (Precision::IsNegativeInfinite(PFirst) ||
 563            // Precision::IsPositiveInfinite(PLast)) {
 564     //  //-- cout<<" IntPatch_RstInt::PutVertexOnLine  ---> Restrictions Infinies :"<<endl;
 565     //  return;
 566     //}
 567
 568     Standard_Boolean isVFirst = Standard_False, isVLast = Standard_False;
 569     gp_Pnt2d p2dFirst,p2dLast;
 570     Standard_Real tolUFirst=0.,tolVFirst=0.,tolULast=0.,tolVLast=0.;
 571     Domain->Initialize(arc);
 572     for (Domain->InitVertexIterator(); Domain->MoreVertex(); Domain->NextVertex()) {
 573       Handle(Adaptor3d_HVertex) vtx = Domain->Vertex();
 574       Standard_Real prm = IntPatch_HInterTool::Parameter(vtx,arc);
 575       if (Abs(prm - PFirst) < Precision::PConfusion()) {
 576         arc->D0(PFirst,p2dFirst);
 577         Standard_Real tol3d = Max (Tol3d(vtx,Domain), edgeTol);
 578         tolUFirst = Surf->UResolution(tol3d);
 579         tolVFirst = Surf->VResolution(tol3d);
 580         isVFirst = Standard_True;
 581       }
 582       else if (Abs(prm - PLast) < Precision::PConfusion()) {
 583         arc->D0(PLast,p2dLast);
 584         Standard_Real tol3d = Max (edgeTol, Tol3d(vtx,Domain));
 585         tolULast = Surf->UResolution(tol3d);
 586         tolVLast = Surf->VResolution(tol3d);
 587         isVLast = Standard_True;
 588       }
 589     }
 590
 591     Bnd_Box2d BPLin = PLin.Bounding();
 592
 593     if(SurfaceIsPeriodic) {
 594       Standard_Real xmin,ymin,xmax,ymax,g;
 595       BPLin.Get(xmin,ymin,xmax,ymax);
 596       g = BPLin.GetGap();
 597       BPLin.SetVoid();
 598       BPLin.Update(xmin-M_PI-M_PI,ymin,
 599                    xmax+M_PI+M_PI,ymax);
 600       BPLin.SetGap(g);
 601     }
 602     if(SurfaceIsBiPeriodic) {
 603       Standard_Real xmin,ymin,xmax,ymax,g;
 604       BPLin.Get(xmin,ymin,xmax,ymax);
 605       g = BPLin.GetGap();
 606       BPLin.SetVoid();
 607       BPLin.Update(xmin,ymin-M_PI-M_PI,
 608                    xmax,ymax+M_PI+M_PI);
 609       BPLin.SetGap(g);
 610     }
 611
 612     switch(arc->GetType())
 613     {
 614       case GeomAbs_Line: NbEchant=10; break;
 615       case GeomAbs_BezierCurve:
 616       {
 617         NbEchant = (3 + arc->NbPoles());
 618             if(NbEchant<10) NbEchant=10;
 619         else if(NbEchant>50) NbEchant=50;
 620       }
 621           break;
 622       case GeomAbs_BSplineCurve:
 623       {
 624         //szv:const Standard_Real nbs = (arc->NbKnots() * arc->Degree())*(arc->LastParameter() - arc->FirstParameter())/(PLast-PFirst);
 625         const Standard_Real nbs = (arc->NbKnots() * arc->Degree())*(PLast-PFirst)/(arc->LastParameter() - arc->FirstParameter());
 626                 NbEchant = (nbs < 2.0 ? 2 : (Standard_Integer)nbs);
 627             if(NbEchant<10) NbEchant=10;
 628         else if (NbEchant>50) NbEchant=50;
 629       }
 630       break;
 631       default:
 632       {
 633             NbEchant = 25;
 634       }
 635     }
 636
 637     IntPatch_PolyArc Brise(arc,NbEchant,PFirst,PLast,BPLin);
 638
 639     Standard_Integer IndiceOffsetBiPeriodic = 0;
 640     Standard_Integer IndiceOffsetPeriodic   = 0;
 641     Standard_Real OffsetV = 0.0;
 642     Standard_Real OffsetU = 0.0;
 643
 644     do {
 645       if(IndiceOffsetBiPeriodic == 1)
 646         OffsetV = -M_PI-M_PI;
 647       else if(IndiceOffsetBiPeriodic == 2)
 648         OffsetV = M_PI+M_PI;
 649
 650       do {
 651         if(IndiceOffsetPeriodic == 1)
 652           OffsetU = -M_PI-M_PI;
 653         else if(IndiceOffsetPeriodic == 2)
 654           OffsetU = M_PI+M_PI;
 655
 656         Brise.SetOffset(OffsetU,OffsetV);
 657
 658         static int debug_polygon2d =0;
 659         if(debug_polygon2d) {
 660           cout<<" ***** Numero Restriction : "<<NumeroEdge<<" *****"<<endl;
 661           PLin.Dump();
 662           Brise.Dump();
 663         }
 664
 665         Commun.Perform(PLin,Brise);
 666         locpt.Clear();
 667         locpt2.Clear();
 668         Standard_Integer Commun_NbSectionPoints = Commun.NbSectionPoints();
 669         Standard_Integer Commun_NbTangentZones  = Commun.NbTangentZones();
 670         Standard_Integer Commun_Section_Tangent = Commun_NbSectionPoints
 671           + Commun_NbTangentZones;
 672         for (i=1;i<=Commun_Section_Tangent;i++) {
 673           Standard_Real W1[2],W2[2];
 674           Standard_Boolean refine[2],useWL[2];
 675           Standard_Integer nbpt = 1;
 676           if(i<=Commun_NbSectionPoints) {
 677             // intersection point
 678             W1[0] = Commun.PntValue(i).ParamOnFirst();
 679             W2[0] = Commun.PntValue(i).ParamOnSecond();
 680             refine[0] = Standard_True;
 681           }
 682           else {
 683             // tangent zone
 684             Standard_Real UMinCh,UMaxCh;  //-- ligne de cheminement 0..(Nbptlin-1)
 685             Standard_Real UMinAr,UMaxAr;  //-- polyline of arc 0..(NbEchant-1)
 686             Commun.ZoneValue(i-Commun_NbSectionPoints).ParamOnFirst(UMinCh,UMaxCh);
 687             Commun.ZoneValue(i-Commun_NbSectionPoints).ParamOnSecond(UMinAr,UMaxAr);
 688             gp_Pnt2d p1Ar = GetPointOnPolygo(Brise,UMinAr);
 689             gp_Pnt2d p2Ar = GetPointOnPolygo(Brise,UMaxAr);
 690             Standard_Real tolU = URes*2.;
 691             Standard_Real tolV = VRes*2.;
 692             if (isVFirst && ArePnt2dEqual(p1Ar,p2dFirst,tolUFirst,tolVFirst)) {
 693               tolU = Max(tolUFirst,tolU); tolV = Max(tolVFirst,tolV);
 694             }
 695             if (isVLast && ArePnt2dEqual(p2Ar,p2dLast,tolULast,tolVLast)) {
 696               tolU = Max(tolULast,tolU); tolV = Max(tolVLast,tolV);
 697             }
 698             Standard_Real nptCh = UMaxCh-UMinCh;
 699             Standard_Boolean isNptLow = (nptCh < 10. && nptCh < Nbptlin/100.) ||
 700               (!Domain->Has3d() && Standard_Integer(nptCh)+1 < Nbptlin);
 701             if (!isNptLow && !IsSegment2dSmall(Brise,UMinAr,UMaxAr,tolU,tolV)) {
 702               // treat both ends
 703               Standard_Real UMinChP,UMinArP,UMaxArP;
 704               UMinChP = IntegerPart(UMinCh);
 705               UMinArP = IntegerPart(UMinAr);
 706               UMaxArP = IntegerPart(UMaxAr);
 707               Standard_Integer irangAr1,irangAr2;
 708               irangAr1 = Standard_Integer(UMinArP)+1;
 709               irangAr2 = Standard_Integer(UMaxArP)+1;
 710               UMinChP = UMinCh - UMinChP;
 711               UMinArP = UMinAr - UMinArP;
 712               //UMaxChP = UMaxCh - UMaxChP; UMaxArP = UMaxAr - UMaxArP;
 713               const Standard_Real eps = 1e-10;
 714 //            Standard_Boolean isChExtr1 = irangCh1==1 && UMinChP<eps;
 715 //            Standard_Boolean isChExtr2 = irangCh2==Nbptlin;
 716               Standard_Boolean isArExtr1 = irangAr1==1 && UMinArP<eps;
 717               Standard_Boolean isArExtr2 = irangAr2==NbEchant;
 718               // detect orientation
 719               gp_Pnt2d p1Ch = GetPointOnPolygo(PLin,UMinCh);
 720               Standard_Real d11 = p1Ch.SquareDistance(p1Ar);
 721               Standard_Real d12 = p1Ch.SquareDistance(p2Ar);
 722               Standard_Boolean sameOri = d11 < d12;
 723               if (!sameOri) {
 724                 Standard_Boolean itmp=isArExtr1; isArExtr1=isArExtr2; isArExtr2=itmp;
 725                 Standard_Real dtmp=UMinAr; UMinAr=UMaxAr; UMaxAr=dtmp;
 726               }
 727               W1[0] = UMinCh; W1[1] = UMaxCh;
 728               W2[0] = UMinAr; W2[1] = UMaxAr;
 729               //refine[0] = ! (isChExtr1 || isArExtr1);
 730               //refine[1] = ! (isChExtr2 || isArExtr2);
 731               refine[0] = refine[1] = Standard_False;
 732               useWL[0] = !isArExtr1;
 733               useWL[1] = !isArExtr2;
 734               nbpt = 2;
 735             }
 736             else {
 737               // treat the middle point as an intersection point
 738               W1[0] = 0.5*(UMinCh+UMaxCh);
 739               W2[0] = 0.5*(UMinAr+UMaxAr);
 740               refine[0] = Standard_True;
 741             }
 742           }
 743
 744           Standard_Boolean nbTreated = 0;
 745           for (Standard_Integer ip=0; ip < nbpt; ip++) {
 746             GetLinePoint2d (L, W1[ip]+1, !OnFirst, U,V);
 747
 748             if (!refine[ip] && useWL[ip]) {
 749               Standard_Real aU1,aV1;
 750               GetLinePoint2d (L, W1[ip]+1, OnFirst, aU1,aV1);
 751               p2d.SetCoord(aU1,aV1);
 752               Standard_Real paramProj;
 753               if (!IntPatch_HInterTool::Project(arc,p2d,paramProj,p2d)) continue;
 754               W = paramProj;
 755             }
 756             else {
 757               Standard_Real par = IntegerPart(W2[ip]);
 758               Standard_Integer Irang = Standard_Integer(par) + 1;
 759               if (Irang == Brise.NbPoints()) {
 760                 Irang--;
 761                 par = 1.;
 762               }
 763               else {
 764                 par =Abs(W2[ip]-par);
 765               }
 766               W = (1.-par)*Brise.Parameter(Irang) + par*Brise.Parameter(Irang+1);
 767             }
 768
 769             Standard_Boolean refined = Standard_False;
 770             if (refine[ip])
 771             {
 772               //------------------------------------------------------------------------
 773               //-- On a trouve un point 2d approche Ua,Va  intersection de la ligne
 774               //-- de cheminement et de la restriction.
 775               //--
 776               //-- On injecte ce point ds les intersections Courbe-Surface
 777               //--
 778               IntPatch_CSFunction thefunc(OtherSurf,arc,Surf);
 779               // MSV: extend UV bounds to not miss solution near the boundary
 780               Standard_Real margCoef = 0.004;
 781               IntPatch_CurvIntSurf IntCS(U,V,W,thefunc,edgeTol,margCoef);
 782               if (IntCS.IsDone())
 783               {
 784                 if (!IntCS.IsEmpty())
 785                 {
 786                   ptsommet = IntCS.Point();
 787                   IntCS.ParameterOnSurface(U2,V2);
 788                   gp_Pnt anOldPnt, aNewPnt;
 789                   OtherSurf->D0(U,V, anOldPnt);
 790                   OtherSurf->D0(U2,V2, aNewPnt);
 791                   if (anOldPnt.SquareDistance(aNewPnt) < Precision::Confusion()
 792                     * Precision::Confusion())
 793                   {
 794                     U2 = U;
 795                     V2 = V;
 796                   }
 797                   paramarc = IntCS.ParameterOnCurve();
 798                   refined = Standard_True;
 799                 }
 800               }
 801             }
 802             else {
 803               U2 = U; V2 = V;
 804               paramarc = W;
 805               arc->D0(paramarc,p2d);
 806               Surf->D0(p2d.X(),p2d.Y(),ptsommet);
 807             }
 808
 809             if (!refine[ip] || refined) {
 810               duplicate = Standard_False;
 811               for (j=1; j<=locpt.Length();j++) {
 812                 if (ptsommet.Distance(locpt(j)) <= edgeTol) {
 813                   if (possiblyClosed) {
 814                     locpt2(j).Coord(U,V);
 815                     if ((OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed) ||
 816                         (OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed))
 817                       continue;
 818                   }
 819                   duplicate = Standard_True;
 820                   break;
 821                 }
 822               }
 823
 824               if (!duplicate) {
 825                 Standard_Integer ParamApproxOnLine = Standard_Integer(W1[ip])+1;
 826
 827                 arc->D1(paramarc,p2d,d2d);
 828                 U1 = p2d.X(); V1 = p2d.Y();
 829                 if (typL == IntPatch_Walking && SurfaceIsPeriodic) {
 830                   if (OnFirst)
 831                     Recadre(TypeS1,TypeS2,wlin,ParamApproxOnLine,U1,V1,U2,V2);
 832                   else
 833                     Recadre(TypeS1,TypeS2,wlin,ParamApproxOnLine,U2,V2,U1,V1);
 834                 }
 835                 locpt.Append(ptsommet);
 836                 locpt2.Append(gp_Pnt2d(U2,V2));
 837
 838                 found = FindParameter(L,OtherSurf,edgeTol,ptsommet,gp_Pnt2d(U2,V2),
 839                                       paramline,tgline,ParamApproxOnLine,OnFirst);
 840
 841                 if (typL == IntPatch_Walking && found && possiblyClosed) {
 842                   // check in 2d
 843                   if (SurfaceIsUClosed || SurfaceIsVClosed) {
 844                     GetLinePoint2d (L, paramline, OnFirst, U,V);
 845                     if ((SurfaceIsUClosed && Abs(U-U1) > tolUClosed) ||
 846                         (SurfaceIsVClosed && Abs(V-V1) > tolVClosed))
 847                       found = Standard_False;
 848                   }
 849                   if (found && (OSurfaceIsUClosed || OSurfaceIsVClosed)) {
 850                     GetLinePoint2d (L, paramline, !OnFirst, U,V);
 851                     if ((OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed) ||
 852                         (OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed))
 853                       found = Standard_False;
 854                   }
 855                 }
 856                 if (!found) {
 857                   continue;
 858                 }
 859
 860                 VtxOnArc = CoincideOnArc(ptsommet,arc,Surf,edgeTol,Domain,vtxarc);
 861                 Standard_Real vtxTol;
 862                 if (VtxOnArc) {
 863                   vtxTol = Tol3d(vtxarc,Domain);
 864                   if (edgeTol > vtxTol) vtxTol = edgeTol;
 865                 }
 866                 else vtxTol = edgeTol;
 867
 868                 //-- It is necessary to test that the point does not already exist
 869                 //--   - It can be already a point on arc
 870                 //--        BUT on a different arc
 871                 // MSV 27.03.2002: find the nearest point; add check in 2d
 872                 Standard_Integer ivtx = 0;
 873                 Standard_Real dmin = RealLast();
 874                 for (j=1; j<=Nbvtx; j++) {
 875                   const IntPatch_Point& Rptline = (typL == IntPatch_Walking
 876                                              ? wlin->Vertex(j)
 877                                              : rlin->Vertex(j));
 878                   Standard_Boolean APointOnRstStillExist =
 879                     ((OnFirst  && Rptline.IsOnDomS1() && Rptline.ArcOnS1() == arc) ||
 880                      (!OnFirst && Rptline.IsOnDomS2() && Rptline.ArcOnS2() == arc));
 881                   if(!APointOnRstStillExist) {
 882                     if (possiblyClosed) {
 883                       if (SurfaceIsUClosed || SurfaceIsVClosed) {
 884                         if (OnFirst) Rptline.ParametersOnS1(U,V);
 885                         else         Rptline.ParametersOnS2(U,V);
 886                         if ((SurfaceIsUClosed && Abs(U-U1) > tolUClosed) ||
 887                             (SurfaceIsVClosed && Abs(V-V1) > tolVClosed))
 888                           continue;
 889                       }
 890                       if (OSurfaceIsUClosed || OSurfaceIsVClosed) {
 891                         if (OnFirst) Rptline.ParametersOnS2(U,V);
 892                         else         Rptline.ParametersOnS1(U,V);
 893                         if ((OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed) ||
 894                             (OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed))
 895                           continue;
 896                       }
 897                     }
 898                     Standard_Real dist = ptsommet.Distance(Rptline.Value());
 899                     Standard_Real dt = Max(vtxTol, Rptline.Tolerance());
 900                     if (dist < dmin) {
 901                       if (dist <= dt) {
 902                         ptline = Rptline;
 903                         ivtx = j;
 904                         if( surfacetype == GeomAbs_Cone ) {
 905                           ivtx = 0;
 906                         }
 907                       }
 908                       else {
 909                         // cancel previous solution because this point is better
 910                         // but its tolerance is not large enough
 911                         ivtx = 0;
 912                       }
 913                       dmin = dist;
 914                     }
 915                   }
 916                 }
 917                 if (ivtx) {
 918                   if (ptline.Tolerance() > vtxTol) {
 919                     vtxTol = ptline.Tolerance();
 920                     if (!VtxOnArc) {
 921                       // now we should repeat attempt to coincide on a bound of arc
 922                       VtxOnArc = CoincideOnArc(ptsommet,arc,Surf,vtxTol,Domain,vtxarc);
 923                       if (VtxOnArc) {
 924                         Standard_Real tol = Tol3d(vtxarc,Domain);
 925                         if (tol > vtxTol) vtxTol = tol;
 926                       }
 927                     }
 928                   }
 929                 }
 930
 931                 if (typL == IntPatch_Walking)
 932                   VerifyTgline(wlin,(Standard_Integer)paramline,edgeTol,tgline);
 933
 934                 Surf->D1(U1,V1,ptbid,d1u,d1v);
 935                 tgrst.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
 936
 937                 normsurf = d1u.Crossed(d1v);
 938                 if (normsurf.Magnitude() < gp::Resolution()) {
 939                   transline.SetValue(Standard_True,IntSurf_Undecided);
 940                   transarc.SetValue(Standard_True,IntSurf_Undecided);
 941                 }
 942                 else
 943                   IntSurf::MakeTransition(tgline,tgrst,normsurf,transline,transarc);
 944
 945                 if (typL == IntPatch_Walking && !refine[ip]) {
 946                   // for new vertex use coordinates from Line
 947                   if (OnFirst)
 948                     GetWLinePoint (wlin, paramline, U1,V1,U2,V2,ptsommet);
 949                   else
 950                     GetWLinePoint (wlin, paramline, U2,V2,U1,V1,ptsommet);
 951                 }
 952
 953                 nbTreated++;
 954                 if (!ivtx) {
 955                   Sommet.SetValue(ptsommet,vtxTol,Standard_False); // pour tangence
 956                   if (OnFirst)
 957                     Sommet.SetParameters(U1,V1,U2,V2);
 958                   else
 959                     Sommet.SetParameters(U2,V2,U1,V1);
 960
 961                   if (VtxOnArc)
 962                     Sommet.SetVertex(OnFirst,vtxarc);
 963
 964                   //---------------------------------------------------------
 965                   //-- lbr : On remplace le point d indice paramline sur la -
 966                   //-- ligne par le vertex .                                -
 967                   //---------------------------------------------------------
 968                   Sommet.SetParameter(paramline); // sur ligne d intersection
 969                   Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc);
 970
 971                   if (typL == IntPatch_Walking) {
 972                     wlin->AddVertex(Sommet);
 973                     Nbvtx++;
 974                   }
 975                   else {
 976                     rlin->AddVertex(Sommet);
 977                     Nbvtx++;
 978                   }
 979                 }
 980                 else {
 981                   // CAS DE FIGURE : en appelant s1 la surf sur laquelle on
 982                   //   connait les pts sur restriction, et s2 celle sur laquelle
 983                   //   on les cherche. Le point trouve verifie necessairement
 984                   //   IsOnDomS1 = True.
 985                   //  Pas vtxS1, pas vtxS2 :
 986                   //   on recupere le point et on applique SetArcOnS2 et
 987                   //   eventuellement SetVertexOnS2. Si on a deja IsOnDomS2,
 988                   //   on considere que le point est deja traite, mais ne devrait
 989                   //   pas se produire.
 990                   //  vtxS1, pas vtxS2     :
 991                   //   si pas IsOnDomS2 : pour chaque occurrence, faire SetArcOnS2,
 992                   //   et eventuellement SetVertexOnS2.
 993                   //   si IsOnDomS2 : impossible, on doit avoir IsVtxOnS2.
 994                   //  vtxS1,vtxS2          :
 995                   //   on doit avoir VtxOnArc = True. On duplique chaque occurrence
 996                   //   "sur S1" du point en changeant ArcOnS2.
 997                   //  pas vtxS1, vtxS2     :
 998                   //   on doit avoir VtxOnArc = True. On duplique le point sur S1
 999                   //   en changeant ArcOnS2.
1000                   Standard_Boolean OnDifferentRst =
1001                     ((OnFirst  && ptline.IsOnDomS1() && ptline.ArcOnS1() != arc) ||
1002                      (!OnFirst && ptline.IsOnDomS2() && ptline.ArcOnS2() != arc));
1003                   ptline.SetTolerance(vtxTol);
1004                   if (   (!ptline.IsVertexOnS1() &&  OnFirst)
1005                       || (!ptline.IsVertexOnS2() && !OnFirst)
1006                       || (OnDifferentRst))  {
1007                     if (  (!ptline.IsOnDomS2() && !OnFirst)
1008                         ||(!ptline.IsOnDomS1() &&  OnFirst)
1009                         ||(OnDifferentRst)) {
1010                       ptline.SetArc(OnFirst,arc,paramarc,transline,transarc);
1011                       //ptline.SetParameter(paramline); //-- rajout lbr le 20 nov 97
1012                       if (VtxOnArc)
1013                         ptline.SetVertex(OnFirst,vtxarc);
1014                       if (typL == IntPatch_Walking) {
1015                         if(OnDifferentRst) {
1016                           wlin->AddVertex(ptline);
1017                           Nbvtx++;
1018                         }
1019                         else {
1020                           wlin->Replace(ivtx,ptline);
1021                         }
1022                       }
1023                       else {
1024                         if(OnDifferentRst) {
1025                           rlin->AddVertex(ptline);
1026                           Nbvtx++;
1027                         }
1028                         else {
1029                           rlin->Replace(ivtx,ptline);
1030                         }
1031                       }
1032                     }
1033                     else if (  ( OnFirst && ptline.IsVertexOnS2())
1034                              ||(!OnFirst && ptline.IsVertexOnS1())) {
1035                       Sommet = ptline;
1036                       Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc);
1037                       if (VtxOnArc)
1038                         Sommet.SetVertex(OnFirst,vtxarc);
1039                       if (typL == IntPatch_Walking) {
1040                         wlin->AddVertex(Sommet);
1041                         Nbvtx++;
1042                       }
1043                       else {
1044                         rlin->AddVertex(Sommet);
1045                         Nbvtx++;
1046                       }
1047                     }
1048                     else {
1049                       //-- cout << "pb dans RstInt  Type 1 " << endl;
1050                     }
1051                   }
1052                   else {
1053                     Handle(Adaptor3d_HVertex) vtxref = (OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()) ;
1054                     if (  ( OnFirst && !ptline.IsOnDomS2())
1055                         ||(!OnFirst && !ptline.IsOnDomS1())) {
1056                       ptline.SetArc(OnFirst,arc,paramarc,transline,transarc);
1057                       if (VtxOnArc)
1058                         ptline.SetVertex(OnFirst,vtxarc);
1059                       if (typL == IntPatch_Walking) {
1060                         wlin->Replace(ivtx,ptline);
1061                       }
1062                       else {
1063                         rlin->Replace(ivtx,ptline);
1064                       }
1065
1066                       for (k=1; k<=Nbvtx; k++) if (k != ivtx) {
1067                         if (typL == IntPatch_Walking) {
1068                           ptline = wlin->Vertex(k);
1069                         }
1070                         else {
1071                           ptline = rlin->Vertex(k);
1072                         }
1073                         if (   ( OnFirst && ptline.IsVertexOnS1())
1074                             || (!OnFirst && ptline.IsVertexOnS2())) {
1075                           if (Domain->Identical(vtxref, (OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()))) {
1076                             if (ptline.Tolerance() < vtxTol) ptline.SetTolerance(vtxTol);
1077                             ptline.SetArc(OnFirst,arc,paramarc,transline,transarc);
1078                             if (VtxOnArc)
1079                               ptline.SetVertex(OnFirst,vtxarc);
1080                             if (typL == IntPatch_Walking) {
1081                               wlin->Replace(k,ptline);
1082                             }
1083                             else {
1084                               rlin->Replace(k,ptline);
1085                             }
1086                           }
1087                         }
1088                       }
1089                     }
1090                     else if(   ( OnFirst && ptline.IsVertexOnS2())
1091                             || (!OnFirst && ptline.IsVertexOnS1())) {
1092                       //                on doit avoir vtxons2 = vtxarc... pas de verif...
1093                       Sommet = ptline;
1094                       Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc);
1095                       if (typL == IntPatch_Walking) {
1096                         wlin->AddVertex(Sommet);
1097                         Nbvtx++;
1098                       }
1099                       else {
1100                         rlin->AddVertex(Sommet);
1101                         Nbvtx++;
1102                       }
1103                       for (k=1; k<=Nbvtx; k++) if (k != ivtx) {
1104                         if (typL == IntPatch_Walking) {
1105                           ptline = wlin->Vertex(k);
1106                         }
1107                         else {
1108                           ptline = rlin->Vertex(k);
1109                         }
1110                         if (  ( OnFirst && ptline.IsVertexOnS1())
1111                             ||(!OnFirst && ptline.IsVertexOnS2())) {
1112                           if (Domain->Identical(vtxref,(OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()))) {
1113                             if (ptline.Tolerance() < vtxTol) ptline.SetTolerance(vtxTol);
1114                             Sommet = ptline;
1115                             Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc);
1116                             if (typL == IntPatch_Walking) {
1117                               wlin->Replace(k,ptline);
1118                               wlin->AddVertex(Sommet);
1119                               Nbvtx++;
1120                             }
1121                             else {
1122                               rlin->Replace(k,ptline);
1123                               rlin->AddVertex(Sommet);
1124                               Nbvtx++;
1125                             }
1126                           }
1127                         }
1128                       }
1129
1130                     }
1131                     else {
1132                       //-- cout << "pb dans RstInt  Type 2 " << endl;
1133                     }
1134                   }
1135                 }
1136               }
1137             }
1138           }
1139           if (nbTreated == 2 && typL == IntPatch_Walking) {
1140             // We processed a tangent zone, and both ends have been treated.
1141             // So mark WLine as having arc
1142             if(OnFirst) wlin->SetArcOnS1(arc);
1143             else        wlin->SetArcOnS2(arc);
1144           }
1145         }
1146
1147         IndiceOffsetPeriodic++;
1148       }
1149       while(SurfaceIsPeriodic && IndiceOffsetPeriodic<=2);
1150
1151       IndiceOffsetBiPeriodic++;
1152     }
1153     while(SurfaceIsBiPeriodic && IndiceOffsetBiPeriodic<=2);
1154     Domain->Next();
1155   }
1156
1157   //--------------------------------------------------------------------------------
1158   //-- On reprend la ligne et on recale les parametres des vertex.
1159   //--
1160   if (typL == IntPatch_Walking) {
1161     Standard_Real pu1,pv1,pu2,pv2;
1162     pu1=pv1=pu2=pv2=0.0;
1163     switch(TypeS1) {
1164     case GeomAbs_Cylinder:
1165     case GeomAbs_Cone:
1166     case GeomAbs_Sphere:
1167       pu1=M_PI+M_PI;
1168       break;
1169     case GeomAbs_Torus:
1170       pu1=pv1=M_PI+M_PI;
1171       break;
1172     default:
1173       {
1174         if(   Surf1->IsUPeriodic())  {
1175           pu1=Surf1->UPeriod();
1176         }
1177         else if(Surf1->IsUClosed()) {
1178           pu1=Surf1->LastUParameter() - Surf1->FirstUParameter();
1179           //cout<<" UClosed1 "<<pu1<<endl;
1180         }
1181         if(   Surf1->IsVPeriodic()) {
1182           pv1=Surf1->VPeriod();
1183         }
1184         else if(Surf1->IsVClosed()) {
1185           pv1=Surf1->LastVParameter() - Surf1->FirstVParameter();
1186           //cout<<" VClosed1 "<<pv1<<endl;
1187         }
1188
1189         break;
1190       }
1191     }
1192
1193     switch(TypeS2) {
1194     case GeomAbs_Cylinder:
1195     case GeomAbs_Cone:
1196     case GeomAbs_Sphere:
1197
1198       pu2=M_PI+M_PI;
1199       break;
1200     case GeomAbs_Torus:
1201       pu2=pv2=M_PI+M_PI;
1202       break;
1203     default:
1204       {
1205         if(   Surf2->IsUPeriodic()) {
1206           pu2=Surf2->UPeriod();
1207         }
1208         else if(Surf2->IsUClosed()) {
1209           pu2=Surf2->LastUParameter() - Surf2->FirstUParameter();
1210           //cout<<" UClosed2 "<<pu2<<endl;
1211         }
1212
1213         if(   Surf2->IsVPeriodic())  {
1214           pv2=Surf2->VPeriod();
1215         }
1216         else if(Surf2->IsVClosed()) {
1217           pv2=Surf2->LastVParameter() - Surf2->FirstVParameter();
1218           //cout<<" VClosed2 "<<pv2<<endl;
1219         }
1220
1221         break;
1222       }
1223     }
1224
1225 /*
1226     if(pu1==0) {
1227       pu1=Surf1->LastUParameter() - Surf1->FirstUParameter();
1228       pu1+=pu1;
1229     }
1230     if(pu2==0) {
1231       pu2=Surf2->LastUParameter() - Surf2->FirstUParameter();
1232       pu2+=pu2;
1233     }
1234     if(pv1==0) {
1235       pv1=Surf1->LastVParameter() - Surf1->FirstVParameter();
1236       pv1+=pv1;
1237     }
1238     if(pv2==0) {
1239       pv2=Surf2->LastVParameter() - Surf2->FirstVParameter();
1240       pv2+=pv2;
1241     }
1242 */
1243
1244     wlin->SetPeriod(pu1,pv1,pu2,pv2);
1245     wlin->ComputeVertexParameters(Tol);
1246   }
1247   else {
1248     rlin->ComputeVertexParameters(Tol);
1249   }
1250 }