src/IntPatch/IntPatch_LineConstructor.cxx

   1 // Created on: 1996-11-07
   2 // Created by: Laurent BUCHARD
   3 // Copyright (c) 1996-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 #include <Adaptor2d_HCurve2d.hxx>
  19 #include <Adaptor3d_HSurface.hxx>
  20 #include <Adaptor3d_TopolTool.hxx>
  21 #include <IntPatch_ALine.hxx>
  22 #include <IntPatch_GLine.hxx>
  23 #include <IntPatch_Line.hxx>
  24 #include <IntPatch_LineConstructor.hxx>
  25 #include <IntPatch_RLine.hxx>
  26 #include <IntPatch_WLine.hxx>
  27
  28 #define XPU1009 1
  29
  30 #include <gp_Pnt.hxx>
  31 #include <gp_Vec.hxx>
  32 #include <IntSurf_Quadric.hxx>
  33 #include <IntSurf_PntOn2S.hxx>
  34 #include <Standard_ConstructionError.hxx>
  35 #include <GeomAbs_SurfaceType.hxx>
  36 #include <ElCLib.hxx>
  37 #include <Geom2dInt_TheProjPCurOfGInter.hxx>
  38 #include <TColStd_SequenceOfInteger.hxx>
  39 #include <TColStd_IndexedMapOfTransient.hxx>
  40 #include <TColStd_Array1OfTransient.hxx>
  41 #include <TColStd_Array1OfReal.hxx>
  42
  43
  44 //=======================================================================
  45 //function : Recadre
  46 //purpose  :
  47 //=======================================================================
  48
  49 static void Recadre(const Handle(Adaptor3d_HSurface)& myHS1,
  50                     const Handle(Adaptor3d_HSurface)& myHS2,
  51                     Standard_Real& u1,
  52                     Standard_Real& v1,
  53                     Standard_Real& u2,
  54                     Standard_Real& v2) {
  55   Standard_Real f,l,lmf;
  56   GeomAbs_SurfaceType typs1 = myHS1->GetType();
  57   GeomAbs_SurfaceType typs2 = myHS2->GetType();
  58
  59   Standard_Boolean myHS1IsUPeriodic,myHS1IsVPeriodic;
  60   switch (typs1) {
  61   case GeomAbs_Cylinder:
  62   case GeomAbs_Cone:
  63   case GeomAbs_Sphere:
  64     {
  65       myHS1IsUPeriodic = Standard_True;
  66       myHS1IsVPeriodic = Standard_False;
  67       break;
  68     }
  69   case GeomAbs_Torus:
  70     {
  71       myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_True;
  72       break;
  73     }
  74   default:
  75      {
  76        //-- Le cas de biparametrees periodiques est gere en amont
  77        myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_False;
  78        break;
  79      }
  80   }
  81
  82   Standard_Boolean myHS2IsUPeriodic,myHS2IsVPeriodic;
  83   switch (typs2) {
  84   case GeomAbs_Cylinder:
  85   case GeomAbs_Cone:
  86   case GeomAbs_Sphere:
  87     {
  88       myHS2IsUPeriodic = Standard_True;
  89       myHS2IsVPeriodic = Standard_False;
  90       break;
  91     }
  92   case GeomAbs_Torus:
  93     {
  94       myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_True;
  95       break;
  96     }
  97   default:
  98      {
  99        //-- Le cas de biparametrees periodiques est gere en amont
 100        myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_False;
 101        break;
 102      }
 103   }
 104   if(myHS1IsUPeriodic) {
 105     lmf = M_PI+M_PI; //-- myHS1->UPeriod();
 106     f = myHS1->FirstUParameter();
 107     l = myHS1->LastUParameter();
 108     while(u1 < f) { u1+=lmf; }
 109     while(u1 > l) { u1-=lmf; }
 110   }
 111   if(myHS1IsVPeriodic) {
 112     lmf = M_PI+M_PI; //-- myHS1->VPeriod();
 113     f = myHS1->FirstVParameter();
 114     l = myHS1->LastVParameter();
 115     while(v1 < f) { v1+=lmf; }
 116     while(v1 > l) { v1-=lmf; }
 117   }
 118   if(myHS2IsUPeriodic) {
 119     lmf = M_PI+M_PI; //-- myHS2->UPeriod();
 120     f = myHS2->FirstUParameter();
 121     l = myHS2->LastUParameter();
 122     while(u2 < f) { u2+=lmf; }
 123     while(u2 > l) { u2-=lmf; }
 124   }
 125   if(myHS2IsVPeriodic) {
 126     lmf = M_PI+M_PI; //-- myHS2->VPeriod();
 127     f = myHS2->FirstVParameter();
 128     l = myHS2->LastVParameter();
 129     while(v2 < f) { v2+=lmf; }
 130     while(v2 > l) { v2-=lmf; }
 131   }
 132 }
 133
 134 //=======================================================================
 135 //function : Parameters
 136 //purpose  :
 137 //=======================================================================
 138
 139 static void Parameters(const Handle(Adaptor3d_HSurface)& myHS1,
 140                        const Handle(Adaptor3d_HSurface)& myHS2,
 141                        const gp_Pnt& Ptref,
 142                        Standard_Real& U1,
 143                        Standard_Real& V1,
 144                        Standard_Real& U2,
 145                        Standard_Real& V2)
 146 {
 147   IntSurf_Quadric quad1,quad2;
 148   GeomAbs_SurfaceType typs = myHS1->Surface().GetType();
 149   switch (typs) {
 150   case GeomAbs_Plane:
 151     quad1.SetValue(myHS1->Surface().Plane());
 152     break;
 153   case GeomAbs_Cylinder:
 154     quad1.SetValue(myHS1->Surface().Cylinder());
 155     break;
 156   case GeomAbs_Cone:
 157     quad1.SetValue(myHS1->Surface().Cone());
 158     break;
 159   case GeomAbs_Sphere:
 160     quad1.SetValue(myHS1->Surface().Sphere());
 161     break;
 162   case GeomAbs_Torus:
 163     quad1.SetValue(myHS1->Surface().Torus());
 164     break;
 165   default:
 166     throw Standard_ConstructionError("IntPatch_IntSS::MakeCurve");
 167   }
 168
 169   typs = myHS2->Surface().GetType();
 170   switch (typs) {
 171   case GeomAbs_Plane:
 172     quad2.SetValue(myHS2->Surface().Plane());
 173     break;
 174   case GeomAbs_Cylinder:
 175     quad2.SetValue(myHS2->Surface().Cylinder());
 176     break;
 177   case GeomAbs_Cone:
 178     quad2.SetValue(myHS2->Surface().Cone());
 179     break;
 180   case GeomAbs_Sphere:
 181     quad2.SetValue(myHS2->Surface().Sphere());
 182     break;
 183   case GeomAbs_Torus:
 184     quad2.SetValue(myHS2->Surface().Torus());
 185     break;
 186   default:
 187     throw Standard_ConstructionError("IntPatch_IntSS::MakeCurve");
 188   }
 189   quad1.Parameters(Ptref,U1,V1);
 190   quad2.Parameters(Ptref,U2,V2);
 191 }
 192
 193 //=======================================================================
 194 //function : LocalFirstParameter
 195 //purpose  :
 196 //=======================================================================
 197
 198 static Standard_Real LocalFirstParameter (const Handle(IntPatch_Line)& L)
 199 {
 200   Standard_Real firstp =0.;
 201   IntPatch_IType typl = L->ArcType();
 202   switch (typl) {
 203   case IntPatch_Analytic:
 204     {
 205       Handle(IntPatch_ALine) alin (Handle(IntPatch_ALine)::DownCast (L));
 206       if (alin->HasFirstPoint()) {
 207         firstp = alin->FirstPoint().ParameterOnLine();
 208       }
 209       else {
 210         Standard_Boolean included;
 211         firstp = alin->FirstParameter(included);
 212         if (!included) {
 213           firstp +=Epsilon(firstp);
 214         }
 215       }
 216       return firstp;
 217     }
 218
 219   case IntPatch_Restriction:
 220     {
 221       Handle(IntPatch_RLine) rlin (Handle(IntPatch_RLine)::DownCast (L));
 222       if (rlin->HasFirstPoint()) {
 223         firstp = rlin->FirstPoint().ParameterOnLine();
 224       }
 225       else {
 226         firstp = -Precision::Infinite(); // a voir selon le type de la ligne 2d
 227       }
 228       return firstp;
 229     }
 230    case IntPatch_Walking:
 231     {
 232
 233       Handle(IntPatch_WLine) wlin (Handle(IntPatch_WLine)::DownCast (L));
 234       if (wlin->HasFirstPoint()) {
 235         firstp = wlin->FirstPoint().ParameterOnLine();
 236       }
 237       else {
 238         firstp = 1.;
 239       }
 240       return firstp;
 241     }
 242
 243   default:
 244     {
 245       Handle(IntPatch_GLine) glin (Handle(IntPatch_GLine)::DownCast (L));
 246       if (glin->HasFirstPoint()) {
 247         firstp = glin->FirstPoint().ParameterOnLine();
 248       }
 249       else {
 250         switch (typl) {
 251         case IntPatch_Lin:
 252         case IntPatch_Parabola:
 253         case IntPatch_Hyperbola:
 254           firstp = -Precision::Infinite();
 255           break;
 256
 257         case IntPatch_Circle:
 258         case IntPatch_Ellipse:
 259           firstp = 0.;
 260           break;
 261         default:
 262           {
 263           }
 264         }
 265       }
 266       return firstp;
 267     }
 268   }
 269 //  return firstp;
 270 }
 271
 272 //=======================================================================
 273 //function : LocalLastParameter
 274 //purpose  :
 275 //=======================================================================
 276
 277 static Standard_Real LocalLastParameter (const Handle(IntPatch_Line)& L)
 278 {
 279   Standard_Real lastp =0.;
 280   IntPatch_IType typl = L->ArcType();
 281   switch (typl) {
 282   case IntPatch_Analytic:
 283     {
 284       Handle(IntPatch_ALine) alin (Handle(IntPatch_ALine)::DownCast (L));
 285
 286       if (alin->HasLastPoint()) {
 287         lastp = alin->LastPoint().ParameterOnLine();
 288       }
 289       else {
 290         Standard_Boolean included;
 291         lastp = alin->LastParameter(included);
 292         if (!included) {
 293           lastp -=Epsilon(lastp);
 294         }
 295       }
 296       return lastp;
 297     }
 298
 299   case IntPatch_Restriction:
 300     {
 301       Handle(IntPatch_RLine) rlin (Handle(IntPatch_RLine)::DownCast (L));
 302
 303       if (rlin->HasLastPoint()) {
 304         lastp = rlin->LastPoint().ParameterOnLine();
 305       }
 306       else {
 307         lastp = Precision::Infinite(); // a voir selon le type de la ligne 2d
 308       }
 309       return lastp;
 310     }
 311    case IntPatch_Walking:
 312     {
 313       Handle(IntPatch_WLine) wlin (Handle(IntPatch_WLine)::DownCast (L));
 314
 315       if (wlin->HasLastPoint()) {
 316         lastp = wlin->LastPoint().ParameterOnLine();
 317       }
 318       else {
 319         lastp = wlin->NbPnts();
 320       }
 321       return lastp;
 322     }
 323
 324   default:
 325     {
 326       Handle(IntPatch_GLine) glin (Handle(IntPatch_GLine)::DownCast (L));
 327
 328       if (glin->HasLastPoint()) {
 329         lastp = glin->LastPoint().ParameterOnLine();
 330       }
 331       else {
 332         switch (typl) {
 333         case IntPatch_Lin:
 334         case IntPatch_Parabola:
 335         case IntPatch_Hyperbola:
 336           lastp = Precision::Infinite();
 337           break;
 338
 339         case IntPatch_Circle:
 340         case IntPatch_Ellipse:
 341           lastp = M_PI+M_PI;
 342           break;
 343         default:
 344           {
 345           }
 346         }
 347       }
 348       return lastp;
 349     }
 350   }
 351 }
 352
 353
 354 // modified by NIZHNY-MKK  Tue Apr  3 15:03:06 2001.BEGIN
 355 //=======================================================================
 356 //function : ComputeParametricTolerance
 357 //purpose  :
 358 //=======================================================================
 359
 360 static Standard_Real ComputeParametricTolerance(const Standard_Real theTol3d,
 361                                                 const gp_Vec&       theD1u,
 362                                                 const gp_Vec&       theD1v) {
 363   Standard_Real nad1u = theD1u.Magnitude();
 364   Standard_Real nad1v = theD1v.Magnitude();
 365   Standard_Real tolu = 0., tolv = 0.;
 366   if(nad1u > 1e-12)
 367     tolu = theTol3d/nad1u;
 368   else tolu = 0.1;
 369   if(nad1v > 1e-12)
 370     tolv = theTol3d/nad1v;
 371   else tolv = 0.1;
 372   Standard_Real aTolerance = (tolu > tolv) ? tolu : tolv;
 373   return aTolerance;
 374 }
 375 // modified by NIZHNY-MKK  Tue Apr  3 15:03:11 2001.END
 376
 377
 378 //=======================================================================
 379 //function : IntPatch_LineConstructor
 380 //purpose  :
 381 //=======================================================================
 382
 383 IntPatch_LineConstructor::IntPatch_LineConstructor(const Standard_Integer )
 384 {
 385 }
 386
 387 //=======================================================================
 388 //function : AppendSameVertexA
 389 //purpose  :
 390 //=======================================================================
 391
 392 static Standard_Integer AppendSameVertexA(Handle(IntPatch_ALine)&alig,
 393                                   const Handle(IntPatch_ALine)& L,
 394                                   const Standard_Integer index,
 395                                   Standard_Integer *TabIndex) {
 396   Standard_Integer i,a,n;
 397   a=0;
 398   n=L->NbVertex();
 399   const IntPatch_Point& Vtxindex = L->Vertex(index);
 400   Standard_Real thetol1=Vtxindex.Tolerance();
 401   for(i=1;i<=n;i++) {
 402     if(i!=index) {
 403       const IntPatch_Point& Vtxi = L->Vertex(i);
 404       Standard_Real thetol2=Vtxi.Tolerance();
 405       if(thetol2<thetol1)
 406         thetol2=thetol1;
 407       Standard_Real d_4=Vtxindex.Value().Distance(Vtxi.Value());
 408       if(d_4 <= thetol2) {
 409         alig->AddVertex(Vtxi);
 410         a++;
 411         TabIndex[i]=TabIndex[index];
 412       }
 413     }
 414   }
 415   return(a);
 416 }
 417
 418 //=======================================================================
 419 //function : AppendSameVertexG
 420 //purpose  :
 421 //=======================================================================
 422
 423 static Standard_Integer AppendSameVertexG(Handle(IntPatch_GLine)& glig,const Handle(IntPatch_GLine)&L,
 424                                   const Standard_Integer index,
 425                                   const Standard_Real decal,
 426                                   Standard_Integer *TabIndex) {
 427   Standard_Integer i,a,n;
 428   Standard_Real p1,p2,d; //,tol
 429   Standard_Boolean aajouter;
 430   a=0;
 431   n=L->NbVertex();
 432   const IntPatch_Point& Vtxindex = L->Vertex(index);
 433   Standard_Real thetol1=Vtxindex.Tolerance();
 434   for(i=1;i<=n;i++) {
 435     if(i!=index) {
 436       const IntPatch_Point& Vtxi = L->Vertex(i);
 437       aajouter=Standard_False;
 438       Standard_Real thetol2=Vtxi.Tolerance();
 439       if(thetol2<thetol1)
 440         thetol2=thetol1;
 441       d=Vtxindex.Value().Distance(Vtxi.Value());
 442       if(d <= thetol2) {
 443         aajouter=Standard_True;
 444       }
 445
 446
 447       //-- Le test suivant a ete ajoute le 20 aout 98 (??? mefiance ???)
 448       else {
 449         p1=Vtxindex.ParameterOnLine();
 450         p2=Vtxi.ParameterOnLine();
 451         if(Abs(p1-p2)<Precision::PConfusion()) {
 452           aajouter=Standard_True;
 453         }
 454       }
 455       if(aajouter) {
 456         p1= Vtxindex.ParameterOnLine();
 457         IntPatch_Point aVtx = Vtxi;
 458         aVtx.SetParameter(p1+decal);
 459         glig->AddVertex(aVtx);
 460         a++;
 461         TabIndex[i]=TabIndex[index];
 462       }
 463     }
 464   }
 465   return(a);
 466 }
 467
 468 //=======================================================================
 469 //function : AppendSameVertexW
 470 //purpose  :
 471 //=======================================================================
 472
 473 static Standard_Integer AppendSameVertexW(Handle(IntPatch_WLine)& wlig,
 474                                   const Handle(IntPatch_WLine)&L,
 475                                   const Standard_Integer index,
 476                                   const Standard_Real par,
 477                                   Standard_Integer *TabIndex) {
 478   Standard_Integer i,a,n;
 479   a=0;
 480   n=L->NbVertex();
 481   const IntPatch_Point& Vtxindex = L->Vertex(index);
 482   const gp_Pnt& Pntindex = Vtxindex.Value();
 483   Standard_Real thetol1=Vtxindex.Tolerance();
 484   for(i=1;i<=n;i++) {
 485     if(i!=index) {
 486       IntPatch_Point Vtxi = L->Vertex(i);
 487       Standard_Real d_2 = Pntindex.Distance(Vtxi.Value());
 488       Standard_Real thetol2=Vtxi.Tolerance();
 489       if(thetol2<thetol1)
 490         thetol2=thetol1;
 491       //-- le debugger voit 2 fois la variable d ici. ???? -> d_2
 492       if(d_2 <= thetol2) {
 493         Vtxi.SetParameter(par);
 494         Standard_Real u1,v1,u2,v2;
 495         Vtxindex.ParametersOnS1(u1,v1);
 496         Vtxindex.ParametersOnS2(u2,v2);
 497         Vtxi.SetParameters(u1,v1,u2,v2);
 498         Vtxi.SetValue(Pntindex);
 499         wlig->AddVertex(Vtxi);
 500         a++;
 501         TabIndex[i]=TabIndex[index];
 502       }
 503     }
 504   }
 505   return(a);
 506 }
 507
 508 //=======================================================================
 509 //function : AppendSameVertexR
 510 //purpose  :
 511 //=======================================================================
 512
 513 static Standard_Integer AppendSameVertexR(Handle(IntPatch_RLine)&rlig,
 514                                   const Handle(IntPatch_RLine)& L,
 515                                   const Standard_Integer index,
 516                                   Standard_Integer *TabIndex) {
 517   Standard_Integer i,a,n;
 518   a=0;
 519   n=L->NbVertex();
 520   const IntPatch_Point& Vtxindex = L->Vertex(index);
 521   Standard_Real thetol1=Vtxindex.Tolerance();
 522   for(i=1;i<=n;i++) {
 523     if(i!=index) {
 524       const IntPatch_Point& Vtxi = L->Vertex(i);
 525       Standard_Real d_3=Vtxindex.Value().Distance(Vtxi.Value());
 526       Standard_Real thetol2=Vtxi.Tolerance();
 527       if(thetol2<thetol1)
 528         thetol2=thetol1;
 529       if(d_3<thetol2) {
 530         if(Vtxi.ParameterOnLine() != Vtxindex.ParameterOnLine()) {
 531           IntPatch_Point Vtxicop = L->Vertex(i);
 532           Vtxicop.SetParameter(Vtxindex.ParameterOnLine());
 533           rlig->AddVertex(Vtxicop);
 534         }
 535         else {
 536           rlig->AddVertex(Vtxi);
 537         }
 538         a++;
 539         TabIndex[i]=TabIndex[index];
 540       }
 541     }
 542   }
 543   return(a);
 544 }
 545
 546 //=======================================================================
 547 //function : AddLine
 548 //purpose  :
 549 //=======================================================================
 550
 551 static void AddLine(const Handle(IntPatch_Line)& L,
 552              const Standard_Integer i,
 553              const Standard_Integer j,
 554 //           const GeomAbs_SurfaceType TypeS1,
 555              const GeomAbs_SurfaceType ,
 556 //           const GeomAbs_SurfaceType TypeS2,
 557              const GeomAbs_SurfaceType ,
 558              Standard_Integer *TabIndex,
 559              IntPatch_SequenceOfLine& slin) {
 560   Standard_Integer IndexFirstVertex = 1;
 561   Standard_Integer IndexLastVertex  = 2;
 562   if(i==j) {
 563     IndexLastVertex  = 1;
 564   }
 565   IntPatch_IType typl = L->ArcType();
 566   switch (typl) {
 567     case IntPatch_Analytic: {
 568       Handle(IntPatch_ALine) ALine (Handle(IntPatch_ALine)::DownCast (L));
 569       Handle(IntPatch_ALine) alig;
 570       if(L->TransitionOnS1() == IntSurf_Undecided)
 571         alig = new IntPatch_ALine(ALine->Curve(),L->IsTangent());
 572       else if(L->TransitionOnS1() == IntSurf_Touch)
 573         alig = new IntPatch_ALine(ALine->Curve(),L->IsTangent(),L->SituationS1(),L->SituationS2());
 574       else
 575         alig = new IntPatch_ALine(ALine->Curve(),L->IsTangent(),L->TransitionOnS1(),L->TransitionOnS2());
 576       alig->AddVertex(ALine->Vertex(i));
 577       IndexLastVertex+=AppendSameVertexA(alig,ALine,i,TabIndex);
 578       if(i!=j) {
 579         alig->AddVertex(ALine->Vertex(j));
 580         IndexLastVertex+=AppendSameVertexA(alig,ALine,j,TabIndex);
 581       }
 582       alig->SetFirstPoint(IndexFirstVertex);
 583       alig->SetLastPoint(IndexLastVertex);
 584       slin.Append(alig);
 585       break;
 586     }
 587     case IntPatch_Walking: {  //-- ****************************************
 588       Handle(IntPatch_WLine) WLine (Handle(IntPatch_WLine)::DownCast (L));
 589       const Handle(IntSurf_LineOn2S)& Lori = WLine->Curve();
 590       Handle(IntSurf_LineOn2S) LineOn2S = new IntSurf_LineOn2S();
 591       Standard_Integer ParamMinOnLine = (Standard_Integer) WLine->Vertex(i).ParameterOnLine();
 592       Standard_Integer ParamMaxOnLine = (Standard_Integer) WLine->Vertex(j).ParameterOnLine();
 593       for(Standard_Integer k=ParamMinOnLine; k<=ParamMaxOnLine; k++) {
 594         LineOn2S->Add(Lori->Value(k));
 595       }
 596       Handle(IntPatch_WLine) wlig;
 597       if(L->TransitionOnS1() == IntSurf_Undecided)
 598         wlig = new IntPatch_WLine(LineOn2S,L->IsTangent());
 599       else if(L->TransitionOnS1() == IntSurf_Touch)
 600         wlig = new IntPatch_WLine(LineOn2S,L->IsTangent(),L->SituationS1(),L->SituationS2());
 601       else
 602         wlig = new IntPatch_WLine(LineOn2S,L->IsTangent(),L->TransitionOnS1(),L->TransitionOnS2());
 603       if(WLine->HasArcOnS1()) {
 604         wlig->SetArcOnS1(WLine->GetArcOnS1());
 605       }
 606       if(WLine->HasArcOnS2()) {
 607         wlig->SetArcOnS2(WLine->GetArcOnS2());
 608       }
 609       IntPatch_Point Vtx=WLine->Vertex(i);
 610       Vtx.SetParameter(1);
 611       wlig->AddVertex(Vtx);
 612       IndexLastVertex+=AppendSameVertexW(wlig,WLine,i,1,TabIndex);
 613       if(i!=j) {
 614         Vtx=WLine->Vertex(j);
 615         Vtx.SetParameter(LineOn2S->NbPoints());
 616         wlig->AddVertex(Vtx);
 617         IndexLastVertex+=AppendSameVertexW(wlig,WLine,j,LineOn2S->NbPoints(),TabIndex);
 618       }
 619       wlig->SetFirstPoint(IndexFirstVertex);
 620       wlig->SetLastPoint(IndexLastVertex);
 621       wlig->SetPeriod(WLine->U1Period(),WLine->V1Period(),WLine->U2Period(),WLine->V2Period());
 622       wlig->ComputeVertexParameters(Precision::Confusion());
 623       slin.Append(wlig);
 624       //-- **********************************************************************
 625
 626       break;
 627     }
 628     case IntPatch_Restriction: {
 629       Handle(IntPatch_RLine) RLine (Handle(IntPatch_RLine)::DownCast (L));
 630       IndexLastVertex=2;
 631       IndexFirstVertex=1;
 632       Handle(IntPatch_RLine) rlig;
 633       if(L->TransitionOnS1() == IntSurf_Undecided)
 634         rlig = new IntPatch_RLine(L->IsTangent());
 635       else if(L->TransitionOnS1() == IntSurf_Touch)
 636         rlig = new IntPatch_RLine(L->IsTangent(),L->SituationS1(),L->SituationS2());
 637       else
 638         rlig = new IntPatch_RLine(L->IsTangent(),L->TransitionOnS1(),L->TransitionOnS2());
 639       if(RLine->IsArcOnS1()) { rlig->SetArcOnS1(RLine->ArcOnS1()); }
 640       if(RLine->IsArcOnS2()) { rlig->SetArcOnS2(RLine->ArcOnS2()); }
 641
 642       rlig->AddVertex(RLine->Vertex(i));
 643 #if XPU1009
 644       IndexLastVertex+=AppendSameVertexR(rlig,RLine,i,TabIndex);
 645 #endif
 646       for(Standard_Integer k=i+1; k<j;k++) {
 647         rlig->AddVertex(RLine->Vertex(k));
 648         IndexLastVertex++;
 649       }
 650       if(i!=j) {
 651         rlig->AddVertex(RLine->Vertex(j));
 652 #if XPU1009
 653         IndexLastVertex+=AppendSameVertexR(rlig,RLine,j,TabIndex);
 654 #endif
 655       }
 656       rlig->SetFirstPoint(IndexFirstVertex);
 657       rlig->SetLastPoint(IndexLastVertex);
 658       rlig->ComputeVertexParameters(Precision::Confusion());
 659       slin.Append(rlig);
 660       break;
 661     }
 662     case IntPatch_Lin:
 663     case IntPatch_Parabola:
 664     case IntPatch_Hyperbola:
 665     case IntPatch_Circle:
 666     case IntPatch_Ellipse: {
 667       Handle(IntPatch_GLine) GLine (Handle(IntPatch_GLine)::DownCast (L));
 668       Handle(IntPatch_GLine) glig;
 669       switch (typl) {
 670       case IntPatch_Lin:
 671         if(L->TransitionOnS1() == IntSurf_Undecided)
 672           glig = new IntPatch_GLine(GLine->Line(),L->IsTangent());
 673         else if(L->TransitionOnS1() == IntSurf_Touch)
 674           glig = new IntPatch_GLine(GLine->Line(),L->IsTangent(),L->SituationS1(),L->SituationS2());
 675         else
 676           glig = new IntPatch_GLine(GLine->Line(),L->IsTangent(),L->TransitionOnS1(),L->TransitionOnS2());
 677         break;
 678       case IntPatch_Parabola:
 679         if(L->TransitionOnS1() == IntSurf_Undecided)
 680           glig = new IntPatch_GLine(GLine->Parabola(),L->IsTangent());
 681         else if(L->TransitionOnS1() == IntSurf_Touch)
 682           glig = new IntPatch_GLine(GLine->Parabola(),L->IsTangent(),L->SituationS1(),L->SituationS2());
 683         else
 684           glig = new IntPatch_GLine(GLine->Parabola(),L->IsTangent(),L->TransitionOnS1(),L->TransitionOnS2());
 685         break;
 686       case IntPatch_Hyperbola:
 687         if(L->TransitionOnS1() == IntSurf_Undecided)
 688           glig = new IntPatch_GLine(GLine->Hyperbola(),L->IsTangent());
 689         else if(L->TransitionOnS1() == IntSurf_Touch)
 690           glig = new IntPatch_GLine(GLine->Hyperbola(),L->IsTangent(),L->SituationS1(),L->SituationS2());
 691         else
 692           glig = new IntPatch_GLine(GLine->Hyperbola(),L->IsTangent(),L->TransitionOnS1(),L->TransitionOnS2());
 693         break;
 694       case IntPatch_Circle:
 695         if(L->TransitionOnS1() == IntSurf_Undecided)
 696           glig = new IntPatch_GLine(GLine->Circle(),L->IsTangent());
 697         else if(L->TransitionOnS1() == IntSurf_Touch)
 698           glig = new IntPatch_GLine(GLine->Circle(),L->IsTangent(),L->SituationS1(),L->SituationS2());
 699         else
 700           glig = new IntPatch_GLine(GLine->Circle(),L->IsTangent(),L->TransitionOnS1(),L->TransitionOnS2());
 701         break;
 702       case IntPatch_Ellipse: default:
 703         if(L->TransitionOnS1() == IntSurf_Undecided)
 704           glig = new IntPatch_GLine(GLine->Ellipse(),L->IsTangent());
 705         else if(L->TransitionOnS1() == IntSurf_Touch)
 706           glig = new IntPatch_GLine(GLine->Ellipse(),L->IsTangent(),L->SituationS1(),L->SituationS2());
 707         else
 708           glig = new IntPatch_GLine(GLine->Ellipse(),L->IsTangent(),L->TransitionOnS1(),L->TransitionOnS2());
 709         break;
 710       }
 711       glig->AddVertex(GLine->Vertex(i));
 712       IndexLastVertex+=AppendSameVertexG(glig,GLine,i,0,TabIndex);
 713       if(i!=j) {
 714         if ((typl == IntPatch_Circle || typl == IntPatch_Ellipse) && i>j) {
 715           IntPatch_Point Vtx=GLine->Vertex(j);
 716           Vtx.SetParameter(GLine->Vertex(j).ParameterOnLine()+M_PI+M_PI);
 717           glig->AddVertex(Vtx);
 718           IndexLastVertex+=AppendSameVertexG(glig,GLine,j,M_PI+M_PI,TabIndex);
 719         }
 720         else {
 721           glig->AddVertex(GLine->Vertex(j));
 722           IndexLastVertex+=AppendSameVertexG(glig,GLine,j,0,TabIndex);
 723         }
 724       }
 725       glig->SetFirstPoint(IndexFirstVertex);
 726       glig->SetLastPoint(IndexLastVertex);
 727       slin.Append(glig);
 728       break;
 729     }
 730     default: {
 731       throw Standard_ConstructionError("IntPatch_LineConstructor::AddLine");
 732     }
 733       break;
 734     }
 735 }
 736
 737 //=======================================================================
 738 //function : Line
 739 //purpose  :
 740 //=======================================================================
 741
 742 Handle(IntPatch_Line) IntPatch_LineConstructor::Line(const Standard_Integer l) const {
 743   return(slin.Value(l));
 744 }
 745
 746 //=======================================================================
 747 //function : NbLines
 748 //purpose  :
 749 //=======================================================================
 750
 751 Standard_Integer IntPatch_LineConstructor::NbLines() const {
 752   return(slin.Length());
 753 }
 754
 755 //=======================================================================
 756 //function : GetVertexTolerance
 757 //purpose  :
 758 //=======================================================================
 759
 760 static Standard_Real GetVertexTolerance(const IntPatch_Point& vtx/*,
 761                                         const Handle(Adaptor3d_TopolTool)& aDomain1,
 762                                         const Handle(Adaptor3d_TopolTool)& aDomain2*/)
 763 {
 764   Standard_Real tol = vtx.Tolerance();
 765 //    if (aDomain1->Has3d() && vtx.IsVertexOnS1()) {
 766 //      Standard_Real tolv = aDomain1->Tol3d(vtx.VertexOnS1());
 767 //      if (tolv > tol) tol = tolv;
 768 //    }
 769 //    if (aDomain2->Has3d() && vtx.IsVertexOnS2()) {
 770 //      Standard_Real tolv = aDomain2->Tol3d(vtx.VertexOnS2());
 771 //      if (tolv > tol) tol = tolv;
 772 //    }
 773   return tol;
 774 }
 775
 776 //=======================================================================
 777 //function : IsSegmentSmall
 778 //purpose  :
 779 //=======================================================================
 780
 781 static Standard_Boolean IsSegmentSmall(const Handle(IntPatch_WLine)& WLine,
 782                                        const Standard_Integer ivFirst,
 783                                        const Standard_Integer ivLast/*,
 784                                        const Standard_Real TolArc*/)
 785 {
 786   const IntPatch_Point& vtxF = WLine->Vertex(ivFirst);
 787   const IntPatch_Point& vtxL = WLine->Vertex(ivLast);
 788   Standard_Integer ipF = (Standard_Integer) vtxF.ParameterOnLine();
 789   Standard_Integer ipL = (Standard_Integer) vtxL.ParameterOnLine();
 790   if (ipF >= ipL) return Standard_True;
 791
 792   Standard_Real tolF = GetVertexTolerance(vtxF);
 793   Standard_Real tolL = GetVertexTolerance(vtxL);
 794   Standard_Real tol = Max (tolF, tolL);
 795
 796   Standard_Real len = 0.;
 797   gp_Pnt p1 = WLine->Point(ipF).Value();
 798   for (Standard_Integer i=ipF+1; i <= ipL; i++) {
 799     const gp_Pnt& p2 = WLine->Point(i).Value();
 800     len += p1.Distance(p2);
 801     if (len > tol) break;
 802     p1 = p2;
 803   }
 804   return len <= tol;
 805 }
 806
 807 //=======================================================================
 808 //function : TestWLineIsARLine
 809 //purpose  :
 810 //=======================================================================
 811
 812 static Standard_Boolean TestWLineIsARLine(const IntPatch_SequenceOfLine& slinref,
 813                                           const Handle(IntPatch_WLine)& wlin,
 814                                           const Standard_Real tol2d) {
 815   int nbpnt=wlin->NbPnts();
 816   int indicepnt=nbpnt/2;
 817   if(indicepnt<1) return(Standard_False);
 818   const IntSurf_PntOn2S& POn2S=wlin->Point(indicepnt);
 819   const IntSurf_PntOn2S& POn2S1=wlin->Point(indicepnt+1);
 820   Standard_Integer lastl=slinref.Length();
 821   for(int i=1;i<=lastl;i++) {
 822     if(slinref.Value(i)->ArcType()==IntPatch_Restriction) {
 823       Handle(IntPatch_RLine)& rlin = *((Handle(IntPatch_RLine) *)&(slinref(i)));
 824       for (Standard_Integer is=0; is<2; is++) {
 825         Standard_Boolean onFirst = is==0;
 826         if((onFirst && rlin->IsArcOnS1()) || (!onFirst && rlin->IsArcOnS2())) {
 827           Handle(Adaptor2d_HCurve2d) arc;
 828           Standard_Real u,v,u1,v1;
 829           if (onFirst) {
 830             arc = rlin->ArcOnS1();
 831             POn2S.ParametersOnS1(u,v);
 832             POn2S1.ParametersOnS1(u1,v1);
 833           }
 834           else {
 835             arc = rlin->ArcOnS2();
 836             POn2S.ParametersOnS2(u,v);
 837             POn2S1.ParametersOnS2(u1,v1);
 838           }
 839           if (indicepnt == 1) {
 840             u = (u+u1)*0.5;
 841             v = (v+v1)*0.5;
 842           }
 843           const Adaptor2d_Curve2d& C2d=arc->Curve2d();
 844           gp_Pnt2d PObt,P2d(u,v);
 845           Standard_Real par= Geom2dInt_TheProjPCurOfGInter::FindParameter(C2d,P2d,1e-7);
 846           PObt=C2d.Value(par);
 847           if(PObt.Distance(P2d) < tol2d) {
 848             return Standard_True;
 849           }
 850         }
 851       }
 852     }
 853   }
 854   return Standard_False;
 855 }
 856
 857 //=======================================================================
 858 //function : TestIfWLineIsRestriction
 859 //purpose  :
 860 //=======================================================================
 861
 862 static Standard_Boolean TestIfWLineIsRestriction(const IntPatch_SequenceOfLine& slinref,
 863                                           const Handle(IntPatch_WLine)& wlin,
 864                                           const Handle(Adaptor3d_HSurface)& S1,
 865                                           const Handle(Adaptor3d_TopolTool)&D1,
 866                                           const Handle(Adaptor3d_HSurface)& S2,
 867                                           const Handle(Adaptor3d_TopolTool)&D2,
 868                                           Standard_Real TolArc) {
 869
 870   Standard_Integer NbPnts = wlin->NbPnts();
 871   Standard_Integer allon1=0,allon2=0,i;
 872   Standard_Real tol2d1=0., tol2d2=0.;
 873   for(i=1;i<=NbPnts;i++) {
 874     const IntSurf_PntOn2S& Pmid = wlin->Point(i);
 875     Standard_Real u1,v1,u2,v2;
 876     Pmid.Parameters(u1,v1,u2,v2);
 877     //-- Estimation d un majorant de Toluv a partir de Tol
 878     gp_Pnt ap;
 879     gp_Vec ad1u,ad1v;
 880     Standard_Real tol;
 881     //------------------------------------------
 882     S1->D1(u1,v1,ap,ad1u,ad1v);
 883     tol = ComputeParametricTolerance(TolArc,ad1u,ad1v);
 884     if (tol > tol2d1) tol2d1 = tol;
 885     //--
 886     if(allon1+1 == i && D1->IsThePointOn(gp_Pnt2d(u1,v1),tol)) {
 887       allon1++;
 888     }
 889     //------------------------------------------
 890     S2->D1(u2,v2,ap,ad1u,ad1v);
 891     tol = ComputeParametricTolerance(TolArc,ad1u,ad1v);
 892     if (tol > tol2d2) tol2d2 = tol;
 893     //--
 894     if(allon2+1 == i && D2->IsThePointOn(gp_Pnt2d(u2,v2),tol)) {
 895       allon2++;
 896     }
 897     if(allon1!=i && allon2!=i)
 898       break;
 899   }
 900   if(allon1==NbPnts || allon2==NbPnts) {
 901 #ifdef OCCT_DEBUG
 902     cout<<" IntPatch_LineConstructor.gxx :  CC**ONS"<<(allon1==NbPnts?1:2)<<"** Traitement WLIne + ARC CLASS "<<endl;
 903 #endif
 904     Standard_Real tol2d = Max(tol2d1,tol2d2);
 905     return TestWLineIsARLine(slinref,wlin,tol2d);
 906   }
 907   return Standard_False;
 908 }
 909
 910 //=======================================================================
 911 //function : ProjectOnArc
 912 //purpose  :
 913 //=======================================================================
 914
 915 static Standard_Boolean ProjectOnArc(const Standard_Real u,
 916                                      const Standard_Real v,
 917                                      const Handle(Adaptor2d_HCurve2d)& arc,
 918                                      const Handle(Adaptor3d_HSurface)& surf,
 919                                      const Standard_Real TolArc,
 920                                      Standard_Real& par,
 921                                      Standard_Real& dist)
 922 {
 923   gp_Pnt aPbid;
 924   gp_Vec ad1u, ad1v;
 925   surf->D1(u,v,aPbid,ad1u,ad1v);
 926   Standard_Real tol2d = ComputeParametricTolerance(TolArc,ad1u,ad1v);
 927   const Adaptor2d_Curve2d& C2d=arc->Curve2d();
 928   gp_Pnt2d aP(u,v),aPprj;
 929   par=Geom2dInt_TheProjPCurOfGInter::FindParameter(C2d,aP,1e-7);
 930   aPprj=C2d.Value(par);
 931   dist = aPprj.Distance(aP);
 932   return dist <= tol2d;
 933 }
 934
 935 //=======================================================================
 936 //function : TestWLineToRLine
 937 //purpose  :
 938 //=======================================================================
 939
 940 static void TestWLineToRLine(const IntPatch_SequenceOfLine& slinref,
 941                       IntPatch_SequenceOfLine& slin,
 942                       const Handle(Adaptor3d_HSurface)& mySurf1,
 943                       const Handle(Adaptor3d_TopolTool)& myDom1,
 944                       const Handle(Adaptor3d_HSurface)& mySurf2,
 945                       const Handle(Adaptor3d_TopolTool)& myDom2,
 946                       const Standard_Real TolArc) {
 947
 948   Standard_Integer lastwline=slin.Length();
 949   Handle(IntPatch_WLine)& WLine = *((Handle(IntPatch_WLine) *)& (slin.Value(lastwline)));
 950
 951   Standard_Integer nbvtx=WLine->NbVertex();
 952   if (nbvtx < 2) return;
 953   Standard_Integer ParamMinOnLine = (Standard_Integer) WLine->Vertex(1).ParameterOnLine();
 954   Standard_Integer ParamMaxOnLine = (Standard_Integer) WLine->Vertex(nbvtx).ParameterOnLine();
 955   if (ParamMinOnLine >= ParamMaxOnLine) return;
 956   Standard_Integer midInd = (ParamMaxOnLine + ParamMinOnLine) / 2;
 957
 958   TColStd_SequenceOfInteger indicesV1,indicesV2;
 959   Standard_Integer iv;
 960   for (iv=1; iv <= nbvtx; iv++) {
 961     Standard_Integer plin = (Standard_Integer) WLine->Vertex(iv).ParameterOnLine();
 962     if (plin == ParamMinOnLine) indicesV1.Append(iv);
 963     else if (plin == ParamMaxOnLine) indicesV2.Append(iv);
 964   }
 965
 966   Standard_Boolean isRLine = Standard_False;
 967
 968   typedef void (IntSurf_PntOn2S::* PiParOnS)(Standard_Real&,Standard_Real&) const;
 969   typedef Standard_Boolean (IntPatch_Point::* PQuery)() const;
 970   typedef const Handle(Adaptor2d_HCurve2d)& (IntPatch_Point::* PArcOnS)() const;
 971   typedef Standard_Real (IntPatch_Point::* PParOnArc)() const;
 972
 973   // cycle for both surfaces
 974   Standard_Integer is;
 975   for (is=0; is<2; is++) {
 976     Standard_Boolean onFirst = is==0;
 977     if(( onFirst && WLine->HasArcOnS1()) ||
 978        (!onFirst && WLine->HasArcOnS2())) {
 979       PiParOnS piParOnS;
 980       PQuery pIsOnDomS;
 981       PArcOnS pArcOnS;
 982       PParOnArc pParOnArc;
 983       Handle(Adaptor3d_HSurface) surf;
 984       Handle(Adaptor3d_TopolTool) aDomain;
 985       if (onFirst) {
 986         piParOnS = &IntSurf_PntOn2S::ParametersOnS1;
 987         pIsOnDomS = &IntPatch_Point::IsOnDomS1;
 988         pArcOnS = &IntPatch_Point::ArcOnS1;
 989         pParOnArc = &IntPatch_Point::ParameterOnArc1;
 990         surf = mySurf1;
 991         aDomain = myDom1;
 992       }
 993       else {
 994         piParOnS = &IntSurf_PntOn2S::ParametersOnS2;
 995         pIsOnDomS = &IntPatch_Point::IsOnDomS2;
 996         pArcOnS = &IntPatch_Point::ArcOnS2;
 997         pParOnArc = &IntPatch_Point::ParameterOnArc2;
 998         surf = mySurf2;
 999         aDomain = myDom2;
1000       }
1001
1002       // resolve arcs for vertices not having a link to an arc
1003       Standard_Real utst,vtst;
1004       TColStd_Array1OfReal paramsResolved(1,nbvtx);
1005       TColStd_Array1OfTransient arcsResolved(1,nbvtx);
1006       arcsResolved.Init(Handle(Adaptor2d_HCurve2d)());
1007       for (iv=1; iv <= nbvtx; iv++) {
1008         if (!(WLine->Vertex(iv).*pIsOnDomS)()) {
1009           Standard_Integer ip = (Standard_Integer) WLine->Vertex(iv).ParameterOnLine();
1010           (WLine->Point(ip).*piParOnS)(utst,vtst);
1011           Standard_Real distmin=RealLast();
1012           for (aDomain->Init(); aDomain->More(); aDomain->Next()) {
1013             const Handle(Adaptor2d_HCurve2d)& arc = aDomain->Value();
1014             Standard_Real par,dist;
1015             if (ProjectOnArc(utst,vtst,arc,surf,TolArc,par,dist) && dist < distmin) {
1016               arcsResolved(iv) = arc;
1017               paramsResolved(iv) = par;
1018               distmin = dist;
1019             }
1020           }
1021         }
1022       }
1023
1024       // prepare list of common arcs for both ends of wline
1025       TColStd_IndexedMapOfTransient mapArcsV1,mapArcs;
1026       Standard_Integer i;
1027       for (i=1; i <= indicesV1.Length(); i++) {
1028         iv = indicesV1(i);
1029         Handle(Adaptor2d_HCurve2d) arc;
1030         if ((WLine->Vertex(iv).*pIsOnDomS)()) arc = (WLine->Vertex(iv).*pArcOnS)();
1031         else arc = Handle(Adaptor2d_HCurve2d)::DownCast (arcsResolved(iv));
1032         if (!arc.IsNull()) mapArcsV1.Add(arc);
1033       }
1034       for (i=1; i <= indicesV2.Length(); i++) {
1035         iv = indicesV2(i);
1036         Handle(Adaptor2d_HCurve2d) arc;
1037         if ((WLine->Vertex(iv).*pIsOnDomS)()) arc = (WLine->Vertex(iv).*pArcOnS)();
1038         else arc = Handle(Adaptor2d_HCurve2d)::DownCast (arcsResolved(iv));
1039         if (!arc.IsNull() && mapArcsV1.Contains(arc)) mapArcs.Add(arc);
1040       }
1041
1042       // for each common arc
1043       for (Standard_Integer ia=1; ia <= mapArcs.Extent(); ia++) {
1044         const Handle(Adaptor2d_HCurve2d) arc (Handle(Adaptor2d_HCurve2d)::DownCast (mapArcs(ia)));
1045         // get end vertices of wline linked with this arc
1046         Standard_Integer iv1=0,iv2=0;
1047         for (i=1; i <= indicesV1.Length() && iv1==0; i++) {
1048           iv = indicesV1(i);
1049           Handle(Adaptor2d_HCurve2d) arc1;
1050           if ((WLine->Vertex(iv).*pIsOnDomS)()) arc1 = (WLine->Vertex(iv).*pArcOnS)();
1051           else arc1 = Handle(Adaptor2d_HCurve2d)::DownCast (arcsResolved(iv));
1052           if (!arc1.IsNull() && arc1 == arc) iv1 = iv;
1053         }
1054         for (i=1; i <= indicesV2.Length() && iv2==0; i++) {
1055           iv = indicesV2(i);
1056           Handle(Adaptor2d_HCurve2d) arc1;
1057           if ((WLine->Vertex(iv).*pIsOnDomS)()) arc1 = (WLine->Vertex(iv).*pArcOnS)();
1058           else arc1 = Handle(Adaptor2d_HCurve2d)::DownCast (arcsResolved(iv));
1059           if (!arc1.IsNull() && arc1 == arc) iv2 = iv;
1060         }
1061         if (!iv1 || !iv2) {
1062 #ifdef OCCT_DEBUG
1063           cout<<" Pb getting vertices linked with arc"<<endl;
1064 #endif
1065           continue;
1066         }
1067         Standard_Real par1 = (arcsResolved(iv1).IsNull()
1068                               ? (WLine->Vertex(iv1).*pParOnArc)()
1069                               : paramsResolved(iv1));
1070         Standard_Real par2 = (arcsResolved(iv2).IsNull()
1071                               ? (WLine->Vertex(iv2).*pParOnArc)()
1072                               : paramsResolved(iv2));
1073 #ifdef OCCT_DEBUG
1074         cout<<"****** Parameters on arc on S"<<is+1<<": "<<par1<<" "<<par2<<endl;
1075 #endif
1076
1077         // check that the middle point is on arc
1078         (WLine->Point(midInd).*piParOnS)(utst,vtst);
1079         if (midInd == ParamMinOnLine) {
1080           Standard_Real utst1=0.0,vtst1=0.0;
1081           (WLine->Point(midInd+1).*piParOnS)(utst1,vtst1);
1082           utst = (utst+utst1)*0.5;
1083           vtst = (vtst+vtst1)*0.5;
1084         }
1085         Standard_Real par,dist;
1086         if (!ProjectOnArc(utst,vtst,arc,surf,TolArc,par,dist)) {
1087 #ifdef OCCT_DEBUG
1088           cout<<" Pb en projection ds IntPatch_LineConstructor"<<endl;
1089 #endif
1090           continue;
1091         }
1092
1093         //-- codage de la WLine en RLine
1094         Handle(IntPatch_RLine) rlig = new IntPatch_RLine(Standard_True,IntSurf_Unknown,IntSurf_Unknown);
1095         if (onFirst) rlig->SetArcOnS1(arc);
1096         else         rlig->SetArcOnS2(arc);
1097
1098         Handle(IntSurf_LineOn2S) LineOn2S = new IntSurf_LineOn2S();
1099         const Handle(IntSurf_LineOn2S)& Lori = WLine->Curve();
1100         Standard_Integer ivmin,ivmax;
1101         Standard_Real parmin, parmax;
1102         Standard_Boolean reverse = Standard_False;
1103         TColStd_SequenceOfInteger *pIndVmin, *pIndVmax;
1104         if (par1<par2) {
1105           for(i=ParamMinOnLine; i<=ParamMaxOnLine; i++) {
1106             LineOn2S->Add(Lori->Value(i));
1107           }
1108           ivmin = iv1; ivmax = iv2;
1109           parmin = par1; parmax = par2;
1110           pIndVmin = &indicesV1; pIndVmax = &indicesV2;
1111         }
1112         else {
1113           for(i=ParamMaxOnLine; i>=ParamMinOnLine; i--) {
1114             LineOn2S->Add(Lori->Value(i));
1115           }
1116           ivmin = iv2; ivmax = iv1;
1117           parmin = par2; parmax = par1;
1118           pIndVmin = &indicesV2; pIndVmax = &indicesV1;
1119           reverse = Standard_True;
1120         }
1121         rlig->Add(LineOn2S);
1122         IntSurf_Transition TransitionUndecided;
1123         IntPatch_Point VtxFirst = WLine->Vertex(ivmin);
1124         VtxFirst.SetParameter(parmin);
1125         if (!arcsResolved(ivmin).IsNull())
1126           VtxFirst.SetArc(onFirst,arc,parmin,TransitionUndecided,TransitionUndecided);
1127         if (reverse)
1128           VtxFirst.ReverseTransition();  //-- inversion des transitions
1129         rlig->AddVertex(VtxFirst);
1130         for (i=1; i <= pIndVmin->Length(); i++) {
1131           iv = pIndVmin->Value(i);
1132           if (iv != ivmin) {
1133             IntPatch_Point Vtx=WLine->Vertex(iv);
1134             Vtx.SetParameter(parmin);
1135             if (!arcsResolved(iv).IsNull())
1136               Vtx.SetArc(onFirst,arc,parmin,TransitionUndecided,TransitionUndecided);
1137             if (reverse)
1138               Vtx.ReverseTransition();
1139             rlig->AddVertex(Vtx);
1140           }
1141         }
1142         for (i=1; i <= pIndVmax->Length(); i++) {
1143           iv = pIndVmax->Value(i);
1144           if (iv != ivmax) {
1145             IntPatch_Point Vtx=WLine->Vertex(iv);
1146             Vtx.SetParameter(parmax);
1147             if (!arcsResolved(iv).IsNull())
1148               Vtx.SetArc(onFirst,arc,parmax,TransitionUndecided,TransitionUndecided);
1149             if (reverse)
1150               Vtx.ReverseTransition();
1151             rlig->AddVertex(Vtx);
1152           }
1153         }
1154         IntPatch_Point VtxLast=WLine->Vertex(ivmax);
1155         VtxLast.SetParameter(parmax);
1156         if (!arcsResolved(ivmax).IsNull())
1157           VtxLast.SetArc(onFirst,arc,parmax,TransitionUndecided,TransitionUndecided);
1158         if (reverse)
1159           VtxLast.ReverseTransition();
1160         rlig->AddVertex(VtxLast);
1161         rlig->SetFirstPoint(1);
1162         rlig->SetLastPoint(indicesV1.Length()+indicesV2.Length());
1163         slin.Append(rlig);
1164         isRLine = Standard_True;
1165       }
1166     }
1167   }
1168
1169   if(isRLine ||
1170      TestIfWLineIsRestriction(slinref,WLine,
1171                               mySurf1,myDom1,
1172                               mySurf2,myDom2,
1173                               TolArc)) {
1174     slin.Remove(lastwline);
1175   }
1176 }
1177
1178 //=======================================================================
1179 //function : Perform
1180 //purpose  :
1181 //=======================================================================
1182
1183 void IntPatch_LineConstructor::Perform(const IntPatch_SequenceOfLine& slinref,
1184                                        const Handle(IntPatch_Line)& L,
1185                                        const Handle(Adaptor3d_HSurface)& mySurf1,
1186                                        const Handle(Adaptor3d_TopolTool)& myDom1,
1187                                        const Handle(Adaptor3d_HSurface)& mySurf2,
1188                                        const Handle(Adaptor3d_TopolTool)& myDom2,
1189                                        const Standard_Real TolArc)  {
1190
1191   Standard_Integer i=1,nbvtx;
1192   Standard_Real firstp,lastp;
1193   Standard_Real Tol = Precision::PConfusion()*100.; // JMB le 13 Jan 2000. Report de la correction du PRO19653
1194   GeomAbs_SurfaceType typs1 = mySurf1->GetType();
1195   GeomAbs_SurfaceType typs2 = mySurf2->GetType();
1196
1197   IntPatch_IType typl = L->ArcType();
1198   if(typl == IntPatch_Analytic) {
1199     Standard_Real u1,v1,u2,v2;
1200     Handle(IntPatch_ALine) ALine (Handle(IntPatch_ALine)::DownCast (L));
1201     slin.Clear();
1202     nbvtx = ALine->NbVertex();
1203     //-- -------------------------------------------------------------------
1204     Standard_Integer *TabIndex=new Standard_Integer [nbvtx+2];
1205     Standard_Integer numline=0;
1206     for(i=1;i<=nbvtx;i++) {
1207     //for(Standard_Integer i=1;i<=nbvtx;i++) {
1208       TabIndex[i]=0;
1209     }
1210     //-- -------------------------------------------------------------------
1211     for(i=1;i<nbvtx;i++) {
1212       const IntPatch_Point& ALine_Vertex_i  =ALine->Vertex(i);
1213       const IntPatch_Point& ALine_Vertex_ip1=ALine->Vertex(i+1);
1214       firstp = ALine_Vertex_i.ParameterOnLine();
1215       lastp =  ALine_Vertex_ip1.ParameterOnLine();
1216       if(firstp!=lastp) {
1217         Standard_Real pmid = (firstp+lastp)*0.5;
1218         gp_Pnt Pmid = ALine->Value(pmid);
1219         Parameters(mySurf1,mySurf2,Pmid,u1,v1,u2,v2);
1220         Recadre(mySurf1,mySurf2,u1,v1,u2,v2);
1221         TopAbs_State in1,in2;
1222         in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol,Standard_False);
1223         in2 = (in1!=TopAbs_OUT)? myDom2->Classify(gp_Pnt2d(u2,v2),Tol,Standard_False) : TopAbs_OUT;
1224         if(in1 == TopAbs_OUT || in2 == TopAbs_OUT) {
1225         }
1226         else {
1227           //-- cout<<"Analytic   : firtsp="<<firstp<<" lastp="<<lastp<<" Vtx:"<<i<<","<<i+1<<endl;
1228           TabIndex[i]=TabIndex[i+1]=++numline;
1229           AddLine(L,i,i+1,typs1,typs2,TabIndex,slin);
1230         }
1231       }
1232     }
1233     //-- -------------------------------------------------------------------
1234     //-- On recherche les vertex interference Edge Edge Externe
1235     //-- Ces vertex ne figurent sur aucune ligne et sont Restriction
1236     //-- sur les 2 edges
1237     for(i=1;i<=nbvtx;i++) {
1238       if(TabIndex[i]==0) {
1239         const IntPatch_Point& ALine_Vertex_i  =ALine->Vertex(i);
1240         if(ALine_Vertex_i.IsOnDomS1() && ALine_Vertex_i.IsOnDomS2()) {
1241           TabIndex[i]=++numline;
1242           AddLine(L,i,i,typs1,typs2,TabIndex,slin);
1243         }
1244       }
1245     }
1246     delete [] TabIndex;
1247     //-- -------------------------------------------------------------------
1248     return;
1249   }
1250   else if(typl == IntPatch_Walking) {
1251     Standard_Real u1,v1,u2,v2;
1252     Handle(IntPatch_WLine) WLine (Handle(IntPatch_WLine)::DownCast (L));
1253     slin.Clear();
1254     nbvtx = WLine->NbVertex();
1255     //-- -------------------------------------------------------------------
1256     Standard_Integer *TabIndex=new Standard_Integer [nbvtx+2];
1257     Standard_Integer numline=0;
1258     for(i=1;i<=nbvtx;i++)  {
1259     //for(Standard_Integer i=1;i<=nbvtx;i++)  {
1260       TabIndex[i]=0;
1261     }
1262     //-- -------------------------------------------------------------------
1263     for(i=1;i<nbvtx;i++) {
1264       const IntPatch_Point& WLineVertex_i   =  WLine->Vertex(i);
1265       const IntPatch_Point& WLineVertex_ip1 =  WLine->Vertex(i+1);
1266       firstp = WLineVertex_i.ParameterOnLine();
1267       lastp =  WLineVertex_ip1.ParameterOnLine();
1268       if(firstp!=lastp && !IsSegmentSmall(WLine,i,i+1/*,TolArc*/)) {
1269         Standard_Integer pmid;
1270         pmid = (Standard_Integer)((firstp+lastp)/2);
1271         Standard_Integer int_lastp = (Standard_Integer)lastp;
1272         Standard_Integer int_firstp = (Standard_Integer)firstp;
1273         if(pmid==int_lastp) pmid=int_firstp;
1274         const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
1275         Pmid.Parameters(u1,v1,u2,v2);
1276         Recadre(mySurf1,mySurf2,u1,v1,u2,v2);
1277
1278         // modified by NIZHNY-MKK  Tue Apr  3 15:03:40 2001.BEGIN
1279         //------------------------------------------
1280         gp_Pnt ap;
1281         gp_Vec ad1u,ad1v;
1282         mySurf1->D1(u1,v1,ap,ad1u,ad1v);
1283         Standard_Real aTolerance = ComputeParametricTolerance(TolArc, ad1u, ad1v);
1284         //------------------------------------------
1285
1286         //TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol,Standard_False);
1287         TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1), aTolerance, Standard_False);
1288         //TopAbs_State in2 = (in1!=TopAbs_OUT)? myDom2->Classify(gp_Pnt2d(u2,v2),Tol,Standard_False) : TopAbs_OUT;
1289         TopAbs_State in2 = TopAbs_OUT;
1290         if (in1!=TopAbs_OUT) {
1291           //------------------------------------------
1292           mySurf2->D1(u2,v2,ap,ad1u,ad1v);
1293           aTolerance = ComputeParametricTolerance(TolArc, ad1u, ad1v);
1294           //------------------------------------------
1295           in2 = myDom2->Classify(gp_Pnt2d(u2,v2), aTolerance, Standard_False);
1296         }
1297         // modified by NIZHNY-MKK  Tue Apr  3 15:06:31 2001.END
1298
1299         // modified by NIZHNY-OFV  Wed Jun 13 17:31:23 2001
1300         // --purpose: If on a face (lastp-firstp) == 1,
1301         //            sometimes it could mean a bad parametrisation of WLine.
1302         //            In this case we try to classify the "virtual" WLine point:
1303         //            the geometrical point between two vertexes. This emulates
1304         //            situation when (lastp-firstp) != 1.
1305         if(Abs(int_lastp-int_firstp) == 1)
1306           {
1307             Standard_Real vFu1,vFv1,vFu2,vFv2,vLu1,vLv1,vLu2,vLv2;
1308             const IntSurf_PntOn2S& vF = WLineVertex_i. PntOn2S();
1309             const IntSurf_PntOn2S& vL = WLineVertex_ip1. PntOn2S();
1310             vF.Parameters(vFu1,vFv1,vFu2,vFv2);
1311             Recadre(mySurf1,mySurf2,vFu1,vFv1,vFu2,vFv2);
1312             vL.Parameters(vLu1,vLv1,vLu2,vLv2);
1313             Recadre(mySurf1,mySurf2,vLu1,vLv1,vLu2,vLv2);
1314             if(in1 != TopAbs_IN)
1315               {
1316                 Standard_Real du,dv;
1317                 gp_Pnt2d pvF(vFu1,vFv1);
1318                 gp_Pnt2d pvL(vLu1,vLv1);
1319                 gp_Pnt2d pPm(u1,v1);
1320                 Standard_Real dpvFpPm = pvF.Distance(pPm);
1321                 Standard_Real dpvLpPm = pvL.Distance(pPm);
1322                 if(dpvFpPm > dpvLpPm)
1323                   {
1324                     du = (vFu1 + u1) * 0.5;
1325                     dv = (vFv1 + v1) * 0.5;
1326                   }
1327                 else
1328                   {
1329                     du = (vLu1 + u1) * 0.5;
1330                     dv = (vLv1 + v1) * 0.5;
1331                   }
1332                 mySurf1->D1(du,dv,ap,ad1u,ad1v);
1333                 aTolerance = ComputeParametricTolerance(TolArc, ad1u, ad1v);
1334                 in1 = myDom1->Classify(gp_Pnt2d(du,dv), aTolerance, Standard_False);
1335               }
1336             if(in2 != TopAbs_IN)
1337               {
1338                 Standard_Real du,dv;
1339                 gp_Pnt2d pvF(vFu2,vFv2);
1340                 gp_Pnt2d pvL(vLu2,vLv2);
1341                 gp_Pnt2d pPm(u2,v2);
1342                 Standard_Real dpvFpPm = pvF.Distance(pPm);
1343                 Standard_Real dpvLpPm = pvL.Distance(pPm);
1344                 if(dpvFpPm > dpvLpPm)
1345                   {
1346                     du = (vFu2 + u2) * 0.5;
1347                     dv = (vFv2 + v2) * 0.5;
1348                   }
1349                 else
1350                   {
1351                     du = (vLu2 + u2) * 0.5;
1352                     dv = (vLv2 + v2) * 0.5;
1353                   }
1354                 mySurf2->D1(du,dv,ap,ad1u,ad1v);
1355                 aTolerance = ComputeParametricTolerance(TolArc, ad1u, ad1v);
1356                 in2 = myDom2->Classify(gp_Pnt2d(du,dv), aTolerance, Standard_False);
1357               }
1358           } //end of if(Abs(int_lastp-int_firstp) == 1)
1359
1360         if (in1 != TopAbs_OUT && in2 != TopAbs_OUT)
1361           {
1362             Standard_Boolean   LignetropPetite=Standard_False;
1363             Standard_Real u1a,v1a,u2a,v2a;
1364             const IntSurf_PntOn2S& Pmid1 = WLine->Point((Standard_Integer)firstp);
1365             Pmid1.Parameters(u1a,v1a,u2a,v2a);
1366             Recadre(mySurf1,mySurf2,u1a,v1a,u2a,v2a);
1367
1368             const IntSurf_PntOn2S& Pmid2 = WLine->Point((Standard_Integer)lastp);
1369             Standard_Real u1b,v1b,u2b,v2b;
1370             Pmid2.Parameters(u1b,v1b,u2b,v2b);
1371             Recadre(mySurf1,mySurf2,u1b,v1b,u2b,v2b);
1372
1373             Standard_Real dd12_u=Abs(u1a-u1b);
1374             Standard_Real dd12_v=Abs(v1a-v1b);
1375             if(dd12_u+dd12_v < 1e-12) {
1376               dd12_u=Abs(u1-u1b);
1377               dd12_v=Abs(v1-v1b);
1378               if(dd12_u+dd12_v < 1e-12) {
1379                 LignetropPetite=Standard_True;
1380               }
1381             }
1382             if(LignetropPetite==Standard_False) {
1383               //-- cout<<"WLine      : firtsp="<<firstp<<" lastp="<<lastp<<" Vtx:"<<i<<","<<i+1<<endl;
1384               TabIndex[i]=TabIndex[i+1]=++numline;
1385               AddLine(L,i,i+1,typs1,typs2,TabIndex,slin);
1386               TestWLineToRLine(slinref,slin,mySurf1,myDom1,mySurf2,myDom2,TolArc); //-- on teste la derniere entree de slin
1387             }
1388           } //end of if (in1 != TopAbs_OUT && in2 != TopAbs_OUT)
1389       } //end of if(firstp!=lastp && !IsSegmentSmall(WLine,i,i+1/*,TolArc*/))
1390     } //end of for(i=1;i<nbvtx;i++)
1391
1392     //-- -------------------------------------------------------------------
1393     //-- On recherche les vertex interference Edge Edge Externe
1394     //-- Ces vertex ne figurent sur aucune ligne et sont Restriction
1395     //-- sur les 2 edges
1396     for(i=1;i<=nbvtx;i++) {
1397       if(TabIndex[i]==0) {
1398         const IntPatch_Point& WLine_Vertex_i  =WLine->Vertex(i);
1399         if(WLine_Vertex_i.IsOnDomS1() && WLine_Vertex_i.IsOnDomS2()) {
1400           TabIndex[i]=++numline;
1401           AddLine(L,i,i,typs1,typs2,TabIndex,slin);
1402         }
1403       }
1404     }
1405     delete [] TabIndex;
1406     //-- -------------------------------------------------------------------
1407     return;
1408   }
1409   else if (typl != IntPatch_Restriction) { // JAG 01.07.96
1410     Standard_Real u1,v1,u2,v2;
1411     Handle(IntPatch_GLine) GLine (Handle(IntPatch_GLine)::DownCast (L));
1412     slin.Clear();
1413     nbvtx = GLine->NbVertex();
1414     //-- -------------------------------------------------------------------
1415     Standard_Integer *TabIndex=new Standard_Integer [nbvtx+2];
1416     Standard_Integer numline=0;
1417 //    for(Standard_Integer i=1;i<=nbvtx;i++) {
1418     for(i=1;i<=nbvtx;i++) {
1419      TabIndex[i]=0;
1420     }
1421     //-- -------------------------------------------------------------------
1422     Standard_Boolean intrvtested = Standard_False;
1423     for(i=1;i<nbvtx;i++) {
1424       firstp = GLine->Vertex(i).ParameterOnLine();
1425       lastp =  GLine->Vertex(i+1).ParameterOnLine();
1426       if(Abs(firstp-lastp)>Precision::PConfusion()) {
1427         intrvtested = Standard_True;
1428         Standard_Real pmid = (firstp+lastp)*0.5;
1429         gp_Pnt Pmid;
1430         if (typl == IntPatch_Lin) {
1431           Pmid = ElCLib::Value(pmid,GLine->Line());
1432         }
1433         else if (typl == IntPatch_Circle) {
1434           Pmid = ElCLib::Value(pmid,GLine->Circle());
1435         }
1436         else if (typl == IntPatch_Ellipse) {
1437           Pmid = ElCLib::Value(pmid,GLine->Ellipse());
1438         }
1439         else if (typl == IntPatch_Hyperbola) {
1440           Pmid = ElCLib::Value(pmid,GLine->Hyperbola());
1441         }
1442         else if (typl == IntPatch_Parabola) {
1443           Pmid = ElCLib::Value(pmid,GLine->Parabola());
1444         }
1445         Parameters(mySurf1,mySurf2,Pmid,u1,v1,u2,v2);
1446         Recadre(mySurf1,mySurf2,u1,v1,u2,v2);
1447
1448         gp_Vec Du,Dv;
1449         gp_Pnt P;
1450         myDom1->Init();
1451         if (myDom2->More()) {
1452           mySurf1->D1(u1,v1,P,Du,Dv);
1453           Tol = ComputeParametricTolerance( myDom1->Tol3d(myDom1->Value()) ,Du,Dv);
1454         }
1455         TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol,Standard_False);
1456
1457         myDom2->Init();
1458         if (in1 != TopAbs_OUT  &&  myDom2->More() ) {
1459           mySurf2->D1(u2,v2,P,Du,Dv);
1460           Tol = ComputeParametricTolerance( myDom2->Tol3d(myDom2->Value()) ,Du,Dv);
1461         }
1462         TopAbs_State in2 = (in1!=TopAbs_OUT)? myDom2->Classify(gp_Pnt2d(u2,v2),Tol,Standard_False) : TopAbs_OUT;
1463         // modified by NIZHNY-OFV  Wed May 30 17:04:08 2001.BEGIN
1464         // --purpose: section algo with infinite prism works now!!!
1465         if(in1 == TopAbs_UNKNOWN) in1 = TopAbs_OUT;
1466         if(in2 == TopAbs_UNKNOWN) in2 = TopAbs_OUT;
1467         // modified by NIZHNY-OFV  Wed May 30 17:05:47 2001.END
1468         if(in1 == TopAbs_OUT || in2 == TopAbs_OUT) {
1469         }
1470         else {
1471           //-- cout<<"GLine      : firtsp="<<firstp<<" lastp="<<lastp<<" Vtx:"<<i<<","<<i+1<<endl;
1472           TabIndex[i]=TabIndex[i+1]=++numline;
1473           AddLine(L,i,i+1,typs1,typs2,TabIndex,slin);
1474         }
1475       }
1476     }
1477     if(typl == IntPatch_Circle || typl == IntPatch_Ellipse) {
1478       firstp = GLine->Vertex(nbvtx).ParameterOnLine();
1479       lastp  = M_PI + M_PI + GLine->Vertex(1).ParameterOnLine();
1480       Standard_Real cadrinf = LocalFirstParameter(L);
1481       Standard_Real cadrsup = LocalLastParameter(L);
1482       Standard_Real acadr = (firstp+lastp)*0.5;
1483       while(acadr < cadrinf) { acadr+=M_PI+M_PI; }
1484       while(acadr > cadrsup) { acadr-=M_PI+M_PI; }
1485       if(acadr>=cadrinf && acadr<=cadrsup) {
1486         if(Abs(firstp-lastp)>Precision::PConfusion()) {
1487           intrvtested = Standard_True;
1488           Standard_Real pmid = (firstp+lastp)*0.5;
1489           gp_Pnt Pmid;
1490           if (typl == IntPatch_Circle) {
1491             Pmid = ElCLib::Value(pmid,GLine->Circle());
1492           }
1493           else {
1494             Pmid = ElCLib::Value(pmid,GLine->Ellipse());
1495           }
1496           Parameters(mySurf1,mySurf2,Pmid,u1,v1,u2,v2);
1497           Recadre(mySurf1,mySurf2,u1,v1,u2,v2);
1498           TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol,Standard_False);
1499           TopAbs_State in2 = (in1!=TopAbs_OUT)?  myDom2->Classify(gp_Pnt2d(u2,v2),Tol,Standard_False) : TopAbs_OUT;
1500           // modified by NIZHNY-OFV  Wed May 30 17:04:08 2001.BEGIN
1501           // --purpose: section algo with infinite prism works now!!!
1502           if(in1 == TopAbs_UNKNOWN) in1 = TopAbs_OUT;
1503           if(in2 == TopAbs_UNKNOWN) in2 = TopAbs_OUT;
1504           // modified by NIZHNY-OFV  Wed May 30 17:05:47 2001.END
1505           if(in1 == TopAbs_OUT || in2 == TopAbs_OUT) {
1506           }
1507           else {
1508             //-- cout<<"GLine  bis : firtsp="<<firstp<<" lastp="<<lastp<<" Vtx:"<<i<<","<<i+1<<endl;
1509             TabIndex[nbvtx]=TabIndex[1]=++numline;
1510             AddLine(L,nbvtx,1,typs1,typs2,TabIndex,slin);
1511           }
1512         }
1513       }
1514     }
1515     if (!intrvtested) {
1516       // on garde a priori. Il faudrait un point 2d sur chaque
1517       // surface pour prendre la decision. Sera fait dans
1518       // l`appelant
1519       //if(nbvtx) {
1520       //        TabIndex[nbvtx]=TabIndex[1]=++numline;
1521       //        AddLine(L,1,nbvtx,typs1,typs2,TabIndex,slin);
1522       //}
1523     }
1524     //-- -------------------------------------------------------------------
1525     //-- On recherche les vertex interference Edge Edge Externe
1526     //-- Ces vertex ne figurent sur aucune ligne et sont Restriction
1527     //-- sur les 2 edges
1528     for(i=1;i<=nbvtx;i++) {
1529       if(TabIndex[i]==0) {
1530         const IntPatch_Point& GLine_Vertex_i  =GLine->Vertex(i);
1531         if(GLine_Vertex_i.IsOnDomS1() && GLine_Vertex_i.IsOnDomS2()) {
1532           TabIndex[i]=++numline;
1533           AddLine(L,i,i,typs1,typs2,TabIndex,slin);
1534         }
1535       }
1536     }
1537     delete [] TabIndex;
1538     //-- -------------------------------------------------------------------
1539     return;
1540   }
1541   else {  //-- Restriction
1542     Handle(IntPatch_RLine) RLine (Handle(IntPatch_RLine)::DownCast (L));
1543     slin.Clear();
1544     Standard_Integer NbVtx    = RLine->NbVertex();
1545     Standard_Boolean RestOnS1 = RLine->IsArcOnS1();
1546     Standard_Boolean RestOnS2 = RLine->IsArcOnS2();
1547     //-- -------------------------------------------------------------------
1548     Standard_Integer *TabIndex=new Standard_Integer [NbVtx+2];
1549     //Standard_Integer numline=0;
1550     for(i=1; i<=NbVtx; i++) {
1551       TabIndex[i]=0;
1552     }
1553     //-- -------------------------------------------------------------------
1554     for(i=1; i<NbVtx; i++) {
1555       const IntPatch_Point&  Vtx1=RLine->Vertex(i);
1556       const IntPatch_Point&  Vtx2=RLine->Vertex(i+1);
1557       if(RestOnS1 && RestOnS2) {
1558         AddLine(L,i,i+1,typs1,typs2,TabIndex,slin);
1559       }
1560       else if(RestOnS1) { //-- On na classifie pas sur 1
1561         Standard_Real u0 = Vtx1.ParameterOnLine();
1562         Standard_Real u1 = Vtx2.ParameterOnLine();
1563         if(Abs(u1-u0)>Precision::PConfusion()) {
1564           Standard_Real u  = (999.0*u0+u1)*0.001;
1565
1566           gp_Pnt P0=Vtx1.Value();
1567           gp_Pnt2d Px2d=RLine->ArcOnS1()->Value(u);
1568           gp_Pnt   Px = mySurf1->Value(Px2d.X(),Px2d.Y());
1569           gp_Vec P0Px=gp_Vec(P0,Px);
1570
1571           Standard_Real U1,V1,U2,V2;
1572           Vtx1.PntOn2S().Parameters(U1,V1,U2,V2);
1573
1574           gp_Vec D1u,D1v;
1575           gp_Pnt P;
1576           mySurf2->D1(U2,V2,P,D1u,D1v);
1577           myDom2->Init();
1578           if (myDom2->More())
1579             Tol = ComputeParametricTolerance( myDom2->Tol3d(myDom2->Value()), D1u,D1v);
1580
1581           //-- le 23 mars 1999
1582           TopAbs_State bornin = myDom2->Classify(gp_Pnt2d(U2,V2),Tol,Standard_False);
1583           if(bornin!=TopAbs_OUT) {
1584             Standard_Real U1t,V1t,U2t,V2t;
1585             Vtx2.PntOn2S().Parameters(U1t,V1t,U2t,V2t);
1586             bornin = myDom2->Classify(gp_Pnt2d(U2t,V2t),Tol,Standard_False);
1587           }
1588           if (bornin==TopAbs_OUT) continue;
1589
1590
1591           //-- Attention , on faisait  une estimatoin de deltau et deltav
1592           //-- Maintenant :
1593           //-- POPx . D1u = deltau * D1u.D1u  + deltav * D1u.D1v
1594           //-- POPx . D1v = deltau * D1u.D1v  + deltav * D1v.D1v
1595           //--
1596           //-- deltau=
1597           Standard_Real D1uD1v,TgD1u,TgD1v,D1uD1u,D1vD1v,DIS;
1598           //Standard_Real DeltaU,DeltaV;
1599           D1uD1u = D1u.Dot(D1u);
1600           D1vD1v = D1v.Dot(D1v);
1601           D1uD1v = D1u.Dot(D1v);
1602           TgD1u = P0Px.Dot(D1u);
1603           TgD1v = P0Px.Dot(D1v);
1604           DIS  = D1uD1u * D1vD1v - D1uD1v * D1uD1v;
1605
1606           Standard_Real deltau=1e-10;
1607           Standard_Real deltav=1e-10;
1608           if(DIS<-1e-10 || DIS>1e-10) {
1609             deltau=(TgD1u*D1vD1v-TgD1v*D1uD1v)/DIS;
1610             deltav=(TgD1v*D1uD1u-TgD1u*D1uD1v)/DIS;
1611           }
1612
1613           U2+=deltau;
1614           V2+=deltav;
1615           if(bornin!=TopAbs_OUT) {
1616             TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(U2,V2),Tol,Standard_False);
1617             deltau*=0.05;
1618             deltav*=0.05;
1619             if(in2==TopAbs_OUT) {
1620               in2 = myDom2->Classify(gp_Pnt2d(U2+deltau,V2),Tol,Standard_False);
1621             }
1622             if(in2==TopAbs_OUT) {
1623               in2 = myDom2->Classify(gp_Pnt2d(U2-deltau,V2),Tol,Standard_False);
1624             }
1625             if(in2==TopAbs_OUT) {
1626               in2 = myDom2->Classify(gp_Pnt2d(U2,V2+deltav),Tol,Standard_False);
1627             }
1628             if(in2==TopAbs_OUT) {
1629               in2 = myDom2->Classify(gp_Pnt2d(U2,V2-deltav),Tol,Standard_False);
1630             }
1631
1632             if(in2!=TopAbs_OUT) {
1633               //-- cout<<"RLine ons1 : u0    ="<<u0<<" u1   ="<<u1<<" Vtx:"<<i<<","<<i+1<<endl;
1634               AddLine(L,i,i+1,typs1,typs2,TabIndex,slin);
1635             }
1636           }
1637         }
1638       }
1639       else {
1640         Standard_Real u0 = Vtx1.ParameterOnLine();
1641         Standard_Real u1 = Vtx2.ParameterOnLine();
1642         if(Abs(u1-u0)>Precision::PConfusion()) {
1643           Standard_Real u  = (999.0*u0+u1)*0.001;
1644
1645           gp_Pnt P0=Vtx1.Value();
1646           gp_Pnt2d Px2d=RLine->ArcOnS2()->Value(u);
1647           gp_Pnt   Px = mySurf2->Value(Px2d.X(),Px2d.Y());
1648           gp_Vec P0Px=gp_Vec(P0,Px);
1649
1650           Standard_Real U1,V1,U2,V2;
1651           Vtx1.PntOn2S().Parameters(U1,V1,U2,V2);
1652
1653           gp_Vec D1u,D1v;
1654           gp_Pnt P;
1655           mySurf1->D1(U1,V1,P,D1u,D1v);
1656           myDom1->Init();
1657           if (myDom2->More())
1658             Tol = ComputeParametricTolerance( myDom1->Tol3d(myDom1->Value()) ,D1u,D1v);
1659
1660           //-- le 23 mars 1999
1661           TopAbs_State bornin = myDom1->Classify(gp_Pnt2d(U1,V1),Tol,Standard_False);
1662           if(bornin!=TopAbs_OUT) {
1663             Standard_Real U1t,V1t,U2t,V2t;
1664             Vtx2.PntOn2S().Parameters(U1t,V1t,U2t,V2t);
1665             bornin = myDom1->Classify(gp_Pnt2d(U1t,V1t),Tol,Standard_False);
1666           }
1667           if (bornin==TopAbs_OUT) continue;
1668
1669
1670           //-- Attention , on faisait  une estimatoin de deltau et deltav
1671           //-- Maintenant :
1672           //-- POPx . D1u = deltau * D1u.D1u  + deltav * D1u.D1v
1673           //-- POPx . D1v = deltau * D1u.D1v  + deltav * D1v.D1v
1674           //--
1675           //-- deltau=
1676           Standard_Real D1uD1v,TgD1u,TgD1v,D1uD1u,D1vD1v,DIS;
1677           //Standard_Real DeltaU,DeltaV;
1678           D1uD1u = D1u.Dot(D1u);
1679           D1vD1v = D1v.Dot(D1v);
1680           D1uD1v = D1u.Dot(D1v);
1681           TgD1u = P0Px.Dot(D1u);
1682           TgD1v = P0Px.Dot(D1v);
1683           DIS  = D1uD1u * D1vD1v - D1uD1v * D1uD1v;
1684
1685           Standard_Real deltau=1e-10;
1686           Standard_Real deltav=1e-10;
1687           if(DIS<-1e-10 || DIS>1e-10) {
1688             deltau=(TgD1u*D1vD1v-TgD1v*D1uD1v)/DIS;
1689             deltav=(TgD1v*D1uD1u-TgD1u*D1uD1v)/DIS;
1690           }
1691
1692           U1+=deltau;
1693           V1+=deltav;
1694
1695           if(bornin!=TopAbs_OUT) {
1696             TopAbs_State in2 = myDom1->Classify(gp_Pnt2d(U1,V1),Tol,Standard_False);
1697             deltau*=0.05;
1698             deltav*=0.05;
1699             if(in2==TopAbs_OUT) {
1700               in2 = myDom1->Classify(gp_Pnt2d(U1+deltau,V1),Tol,Standard_False);
1701             }
1702             if(in2==TopAbs_OUT) {
1703               in2 = myDom1->Classify(gp_Pnt2d(U1-deltau,V1),Tol,Standard_False);
1704             }
1705             if(in2==TopAbs_OUT) {
1706               in2 = myDom1->Classify(gp_Pnt2d(U1,V1+deltav),Tol,Standard_False);
1707             }
1708             if(in2==TopAbs_OUT) {
1709               in2 = myDom1->Classify(gp_Pnt2d(U1,V1-deltav),Tol,Standard_False);
1710             }
1711
1712             if(in2!=TopAbs_OUT) {
1713               //-- cout<<"RLine ons2 : u0    ="<<u0<<" u1   ="<<u1<<" Vtx:"<<i<<","<<i+1<<endl;
1714
1715               AddLine(L,i,i+1,typs1,typs2,TabIndex,slin);
1716             }
1717           }
1718         }
1719       }
1720     }
1721     delete [] TabIndex;
1722   }
1723 }