src/IntWalk/IntWalk_PWalking_1.gxx

   1 // Copyright (c) 1995-1999 Matra Datavision
   2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   3 //
   4 // The content of this file is subject to the Open CASCADE Technology Public
   5 // License Version 6.5 (the "License"). You may not use the content of this file
   6 // except in compliance with the License. Please obtain a copy of the License
   7 // at http://www.opencascade.org and read it completely before using this file.
   8 //
   9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  11 //
  12 // The Original Code and all software distributed under the License is
  13 // distributed on an "AS IS" basis, without warranty of any kind, and the
  14 // Initial Developer hereby disclaims all such warranties, including without
  15 // limitation, any warranties of merchantability, fitness for a particular
  16 // purpose or non-infringement. Please see the License for the specific terms
  17 // and conditions governing the rights and limitations under the License.
  18
  19 //-----------------------------
  20 //--  IntWalk_PWalking_1.gxx
  21 //--
  22
  23 #include <Precision.hxx>
  24 #include <math_FunctionSetRoot.hxx>
  25
  26 //#define KELARG 20.0
  27
  28 //==================================================================================
  29 // function : IntWalk_PWalking::IntWalk_PWalking
  30 // purpose  :
  31 // estimation des max pas : Pour eviter des changenets
  32 // trop brusques lors des changements d isos
  33 //==================================================================================
  34 void ComputePasInit(Standard_Real *pasuv,
  35                     Standard_Real Um1,Standard_Real UM1,
  36                     Standard_Real Vm1,Standard_Real VM1,
  37                     Standard_Real Um2,Standard_Real UM2,
  38                     Standard_Real Vm2,Standard_Real VM2,
  39                     Standard_Real _Um1,Standard_Real _UM1,
  40                     Standard_Real _Vm1,Standard_Real _VM1,
  41                     Standard_Real _Um2,Standard_Real _UM2,
  42                     Standard_Real _Vm2,Standard_Real _VM2,
  43                     const ThePSurface& ,
  44                     const ThePSurface& ,
  45                     const Standard_Real Increment)
  46 {
  47   Standard_Real du1=Abs(UM1-Um1);
  48   Standard_Real dv1=Abs(VM1-Vm1);
  49   Standard_Real du2=Abs(UM2-Um2);
  50   Standard_Real dv2=Abs(VM2-Vm2);
  51
  52   Standard_Real _du1=Abs(_UM1-_Um1);
  53   Standard_Real _dv1=Abs(_VM1-_Vm1);
  54   Standard_Real _du2=Abs(_UM2-_Um2);
  55   Standard_Real _dv2=Abs(_VM2-_Vm2);
  56
  57   //-- On limite la reduction de l estimation de la boite uv a 0.01 la boite naturelle
  58   //--  du1 : Sur boite des Inter
  59   //-- _du1 : Sur espace parametrique
  60   if(_du1<1e50 && du1<0.01*_du1) du1=0.01*_du1;
  61   if(_dv1<1e50 && dv1<0.01*_dv1) dv1=0.01*_dv1;
  62   if(_du2<1e50 && du2<0.01*_du2) du2=0.01*_du2;
  63   if(_dv2<1e50 && dv2<0.01*_dv2) dv2=0.01*_dv2;
  64
  65   pasuv[0]=Increment*du1;
  66   pasuv[1]=Increment*dv1;
  67   pasuv[2]=Increment*du2;
  68   pasuv[3]=Increment*dv2;
  69 }
  70 //==================================================================================
  71 // function : IntWalk_PWalking::IntWalk_PWalking
  72 // purpose  :
  73 //==================================================================================
  74 IntWalk_PWalking::IntWalk_PWalking(const ThePSurface& Caro1,
  75                                    const ThePSurface& Caro2,
  76                                    const Standard_Real TolTangency,
  77                                    const Standard_Real Epsilon,
  78                                    const Standard_Real Deflection,
  79                                    const Standard_Real Increment )
  80      :
  81
  82        done(Standard_True),
  83        close(Standard_False),
  84        fleche(Deflection),
  85        tolconf(Epsilon),
  86        sensCheminement(1),
  87        myIntersectionOn2S(Caro1,Caro2,TolTangency)
  88 {
  89   Standard_Real KELARG=20.;
  90   //
  91   pasMax=Increment*0.2; //-- le 25 juin 99 suite a des pbs de precision
  92   Um1 = ThePSurfaceTool::FirstUParameter(Caro1);
  93   Vm1 = ThePSurfaceTool::FirstVParameter(Caro1);
  94   UM1 = ThePSurfaceTool::LastUParameter(Caro1);
  95   VM1 = ThePSurfaceTool::LastVParameter(Caro1);
  96
  97   Um2 = ThePSurfaceTool::FirstUParameter(Caro2);
  98   Vm2 = ThePSurfaceTool::FirstVParameter(Caro2);
  99   UM2 = ThePSurfaceTool::LastUParameter(Caro2);
 100   VM2 = ThePSurfaceTool::LastVParameter(Caro2);
 101
 102   ResoU1 = ThePSurfaceTool::UResolution(Caro1,Precision::Confusion());
 103   ResoV1 = ThePSurfaceTool::VResolution(Caro1,Precision::Confusion());
 104
 105   ResoU2 = ThePSurfaceTool::UResolution(Caro2,Precision::Confusion());
 106   ResoV2 = ThePSurfaceTool::VResolution(Caro2,Precision::Confusion());
 107
 108   Standard_Real NEWRESO;
 109   Standard_Real MAXVAL;
 110   Standard_Real MAXVAL2;
 111   //
 112   MAXVAL  = Abs(Um1);  MAXVAL2 = Abs(UM1);
 113   if(MAXVAL2 > MAXVAL) MAXVAL = MAXVAL2;
 114   NEWRESO = ResoU1 * MAXVAL ;
 115   if(NEWRESO > ResoU1 &&NEWRESO<10) {    ResoU1 = NEWRESO;  }
 116
 117
 118   MAXVAL  = Abs(Um2);   MAXVAL2 = Abs(UM2);
 119   if(MAXVAL2 > MAXVAL) MAXVAL = MAXVAL2;
 120   NEWRESO = ResoU2 * MAXVAL ;
 121   if(NEWRESO > ResoU2 && NEWRESO<10) {     ResoU2 = NEWRESO;  }
 122
 123
 124   MAXVAL  = Abs(Vm1);  MAXVAL2 = Abs(VM1);
 125   if(MAXVAL2 > MAXVAL) MAXVAL = MAXVAL2;
 126   NEWRESO = ResoV1 * MAXVAL ;
 127   if(NEWRESO > ResoV1 && NEWRESO<10) {     ResoV1 = NEWRESO;  }
 128
 129
 130   MAXVAL  = Abs(Vm2);  MAXVAL2 = Abs(VM2);
 131   if(MAXVAL2 > MAXVAL) MAXVAL = MAXVAL2;
 132   NEWRESO = ResoV2 * MAXVAL ;
 133   if(NEWRESO > ResoV2 && NEWRESO<10) {     ResoV2 = NEWRESO;  }
 134
 135   pasuv[0]=pasMax*Abs(UM1-Um1);
 136   pasuv[1]=pasMax*Abs(VM1-Vm1);
 137   pasuv[2]=pasMax*Abs(UM2-Um2);
 138   pasuv[3]=pasMax*Abs(VM2-Vm2);
 139
 140   if(ResoU1>0.0001*pasuv[0]) ResoU1=0.00001*pasuv[0];
 141   if(ResoV1>0.0001*pasuv[1]) ResoV1=0.00001*pasuv[1];
 142   if(ResoU2>0.0001*pasuv[2]) ResoU2=0.00001*pasuv[2];
 143   if(ResoV2>0.0001*pasuv[3]) ResoV2=0.00001*pasuv[3];
 144
 145
 146   if(ThePSurfaceTool::IsUPeriodic(Caro1)==Standard_False) {
 147     //UM1+=KELARG*pasuv[0];  Um1-=KELARG*pasuv[0];
 148   }
 149   else {
 150     Standard_Real t = UM1-Um1;
 151     if(t<ThePSurfaceTool::UPeriod(Caro1)) {
 152       t=0.5*(ThePSurfaceTool::UPeriod(Caro1)-t);
 153       t=(t>KELARG*pasuv[0])? KELARG*pasuv[0] : t;
 154       UM1+=t;  Um1-=t;
 155     }
 156   }
 157
 158   if(ThePSurfaceTool::IsVPeriodic(Caro1)==Standard_False) {
 159     //VM1+=KELARG*pasuv[1];  Vm1-=KELARG*pasuv[1];
 160   }
 161   else {
 162     Standard_Real t = VM1-Vm1;
 163     if(t<ThePSurfaceTool::VPeriod(Caro1)) {
 164       t=0.5*(ThePSurfaceTool::VPeriod(Caro1)-t);
 165       t=(t>KELARG*pasuv[1])? KELARG*pasuv[1] : t;
 166       VM1+=t;  Vm1-=t;
 167     }
 168   }
 169
 170   if(ThePSurfaceTool::IsUPeriodic(Caro2)==Standard_False) {
 171     //UM2+=KELARG*pasuv[2];  Um2-=KELARG*pasuv[2];
 172   }
 173   else {
 174     Standard_Real t = UM2-Um2;
 175     if(t<ThePSurfaceTool::UPeriod(Caro2)) {
 176       t=0.5*(ThePSurfaceTool::UPeriod(Caro2)-t);
 177       t=(t>KELARG*pasuv[2])? KELARG*pasuv[2] : t;
 178       UM2+=t;  Um2-=t;
 179     }
 180   }
 181
 182   if(ThePSurfaceTool::IsVPeriodic(Caro2)==Standard_False) {
 183     //VM2+=KELARG*pasuv[3];  Vm2-=KELARG*pasuv[3];
 184   }
 185   else {
 186     Standard_Real t = VM2-Vm2;
 187     if(t<ThePSurfaceTool::VPeriod(Caro2)) {
 188       t=0.5*(ThePSurfaceTool::VPeriod(Caro2)-t);
 189       t=(t>KELARG*pasuv[3])? KELARG*pasuv[3] : t;
 190       VM2+=t;  Vm2-=t;
 191     }
 192   }
 193
 194   //-- ComputePasInit(pasuv,Um1,UM1,Vm1,VM1,Um2,UM2,Vm2,VM2,Caro1,Caro2);
 195
 196   for (Standard_Integer i = 0; i<=3;i++) {
 197     if(pasuv[i]>10)
 198       pasuv[i] = 10;
 199     pasInit[i] = pasSav[i] = pasuv[i];
 200   }
 201
 202
 203 }
 204 //==================================================================================
 205 // function : IntWalk_PWalking
 206 // purpose  :
 207 //==================================================================================
 208 IntWalk_PWalking::IntWalk_PWalking(const ThePSurface& Caro1,
 209                                    const ThePSurface& Caro2,
 210                                    const Standard_Real TolTangency,
 211                                    const Standard_Real Epsilon,
 212                                    const Standard_Real Deflection,
 213                                    const Standard_Real Increment,
 214                                    const Standard_Real U1,
 215                                    const Standard_Real V1,
 216                                    const Standard_Real U2,
 217                                    const Standard_Real V2)
 218      :
 219
 220        done(Standard_True),
 221        close(Standard_False),
 222        fleche(Deflection),
 223        tolconf(Epsilon),
 224        sensCheminement(1),
 225        myIntersectionOn2S(Caro1,Caro2,TolTangency)
 226 {
 227   Standard_Real KELARG=20.;
 228   //
 229   pasMax=Increment*0.2; //-- le 25 juin 99 suite a des pbs de precision
 230   //
 231   Um1 = ThePSurfaceTool::FirstUParameter(Caro1);
 232   Vm1 = ThePSurfaceTool::FirstVParameter(Caro1);
 233   UM1 = ThePSurfaceTool::LastUParameter(Caro1);
 234   VM1 = ThePSurfaceTool::LastVParameter(Caro1);
 235
 236   Um2 = ThePSurfaceTool::FirstUParameter(Caro2);
 237   Vm2 = ThePSurfaceTool::FirstVParameter(Caro2);
 238   UM2 = ThePSurfaceTool::LastUParameter(Caro2);
 239   VM2 = ThePSurfaceTool::LastVParameter(Caro2);
 240
 241   ResoU1 = ThePSurfaceTool::UResolution(Caro1,Precision::Confusion());
 242   ResoV1 = ThePSurfaceTool::VResolution(Caro1,Precision::Confusion());
 243
 244   ResoU2 = ThePSurfaceTool::UResolution(Caro2,Precision::Confusion());
 245   ResoV2 = ThePSurfaceTool::VResolution(Caro2,Precision::Confusion());
 246   //
 247   Standard_Real NEWRESO, MAXVAL, MAXVAL2;
 248   //
 249   MAXVAL  = Abs(Um1);
 250   MAXVAL2 = Abs(UM1);
 251   if(MAXVAL2 > MAXVAL) {
 252     MAXVAL = MAXVAL2;
 253   }
 254   NEWRESO = ResoU1 * MAXVAL ;
 255   if(NEWRESO > ResoU1) {
 256     ResoU1 = NEWRESO;
 257   }
 258   //
 259   MAXVAL  = Abs(Um2);
 260   MAXVAL2 = Abs(UM2);
 261   if(MAXVAL2 > MAXVAL){
 262     MAXVAL = MAXVAL2;
 263   }
 264   NEWRESO = ResoU2 * MAXVAL ;
 265   if(NEWRESO > ResoU2) {
 266     ResoU2 = NEWRESO;
 267   }
 268   //
 269   MAXVAL  = Abs(Vm1);
 270   MAXVAL2 = Abs(VM1);
 271   if(MAXVAL2 > MAXVAL) {
 272     MAXVAL = MAXVAL2;
 273   }
 274   NEWRESO = ResoV1 * MAXVAL ;
 275   if(NEWRESO > ResoV1) {
 276     ResoV1 = NEWRESO;
 277   }
 278   //
 279   MAXVAL  = Abs(Vm2);
 280   MAXVAL2 = Abs(VM2);
 281   if(MAXVAL2 > MAXVAL){
 282     MAXVAL = MAXVAL2;
 283   }
 284   NEWRESO = ResoV2 * MAXVAL ;
 285   if(NEWRESO > ResoV2) {
 286     ResoV2 = NEWRESO;
 287   }
 288   //
 289   pasuv[0]=pasMax*Abs(UM1-Um1);
 290   pasuv[1]=pasMax*Abs(VM1-Vm1);
 291   pasuv[2]=pasMax*Abs(UM2-Um2);
 292   pasuv[3]=pasMax*Abs(VM2-Vm2);
 293   //
 294   if(ThePSurfaceTool::IsUPeriodic(Caro1)==Standard_False) {
 295     UM1+=KELARG*pasuv[0];
 296     Um1-=KELARG*pasuv[0];
 297   }
 298   else {
 299     Standard_Real t = UM1-Um1;
 300     if(t<ThePSurfaceTool::UPeriod(Caro1)) {
 301       t=0.5*(ThePSurfaceTool::UPeriod(Caro1)-t);
 302       t=(t>KELARG*pasuv[0])? KELARG*pasuv[0] : t;
 303       UM1+=t;
 304       Um1-=t;
 305     }
 306   }
 307   //
 308   if(ThePSurfaceTool::IsVPeriodic(Caro1)==Standard_False) {
 309     VM1+=KELARG*pasuv[1];
 310     Vm1-=KELARG*pasuv[1];
 311   }
 312   else {
 313     Standard_Real t = VM1-Vm1;
 314     if(t<ThePSurfaceTool::VPeriod(Caro1)) {
 315       t=0.5*(ThePSurfaceTool::VPeriod(Caro1)-t);
 316       t=(t>KELARG*pasuv[1])? KELARG*pasuv[1] : t;
 317       VM1+=t;  Vm1-=t;
 318     }
 319   }
 320   //
 321   if(ThePSurfaceTool::IsUPeriodic(Caro2)==Standard_False) {
 322     UM2+=KELARG*pasuv[2];
 323     Um2-=KELARG*pasuv[2];
 324   }
 325   else {
 326     Standard_Real t = UM2-Um2;
 327     if(t<ThePSurfaceTool::UPeriod(Caro2)) {
 328       t=0.5*(ThePSurfaceTool::UPeriod(Caro2)-t);
 329       t=(t>KELARG*pasuv[2])? KELARG*pasuv[2] : t;
 330       UM2+=t;
 331       Um2-=t;
 332     }
 333   }
 334
 335   if(ThePSurfaceTool::IsVPeriodic(Caro2)==Standard_False) {
 336     VM2+=KELARG*pasuv[3];
 337     Vm2-=KELARG*pasuv[3];
 338   }
 339   else {
 340     Standard_Real t = VM2-Vm2;
 341     if(t<ThePSurfaceTool::UPeriod(Caro2)) {
 342       t=0.5*(ThePSurfaceTool::VPeriod(Caro2)-t);
 343       t=(t>KELARG*pasuv[3])? KELARG*pasuv[3] : t;
 344       VM2+=t;
 345       Vm2-=t;
 346     }
 347   }
 348   //-- ComputePasInit(pasuv,Um1,UM1,Vm1,VM1,Um2,UM2,Vm2,VM2,Caro1,Caro2);
 349
 350   for (Standard_Integer i = 0; i<=3;i++) {
 351     pasInit[i] = pasSav[i] = pasuv[i];
 352   }
 353
 354   if(ResoU1>0.0001*pasuv[0]) ResoU1=0.00001*pasuv[0];
 355   if(ResoV1>0.0001*pasuv[1]) ResoV1=0.00001*pasuv[1];
 356   if(ResoU2>0.0001*pasuv[2]) ResoU2=0.00001*pasuv[2];
 357   if(ResoV2>0.0001*pasuv[3]) ResoV2=0.00001*pasuv[3];
 358   //
 359   TColStd_Array1OfReal Par(1,4);
 360   Par(1) = U1;
 361   Par(2) = V1;
 362   Par(3) = U2;
 363   Par(4) = V2;
 364   Perform(Par);
 365 }
 366
 367 //==================================================================================
 368 // function : PerformFirstPoint
 369 // purpose  :
 370 //==================================================================================
 371 Standard_Boolean IntWalk_PWalking::PerformFirstPoint  (const TColStd_Array1OfReal& ParDep,
 372                                                        IntSurf_PntOn2S& FirstPoint)
 373 {
 374   sensCheminement = 1;
 375   close = Standard_False;
 376   //
 377   Standard_Integer i;
 378   Standard_Real aTmp;
 379   TColStd_Array1OfReal Param(1,4);
 380   //
 381   for (i=1; i<=4; ++i) {
 382     aTmp = ParDep(i);
 383     Param(i) = ParDep(i);
 384   }
 385   //-- calcul du premier point solution
 386   math_FunctionSetRoot  Rsnld(myIntersectionOn2S.Function());
 387   //
 388   myIntersectionOn2S.Perform(Param,Rsnld);
 389   if (!myIntersectionOn2S.IsDone())  {
 390     return Standard_False;
 391   }
 392   if (myIntersectionOn2S.IsEmpty()) {
 393     return Standard_False;
 394   }
 395   FirstPoint = myIntersectionOn2S.Point();
 396   return Standard_True;
 397 }
 398 //==================================================================================
 399 // function : Perform
 400 // purpose  :
 401 //==================================================================================
 402 void IntWalk_PWalking::Perform(const TColStd_Array1OfReal& ParDep)
 403 {
 404   Perform(ParDep,Um1,Vm1,Um2,Vm2,UM1,VM1,UM2,VM2);
 405 }
 406 //==================================================================================
 407 // function : Perform
 408 // purpose  :
 409 //==================================================================================
 410 void IntWalk_PWalking::Perform(const TColStd_Array1OfReal& ParDep,
 411                                const Standard_Real u1min,
 412                                const Standard_Real v1min,
 413                                const Standard_Real u2min,
 414                                const Standard_Real v2min,
 415                                const Standard_Real u1max,
 416                                const Standard_Real v1max,
 417                                const Standard_Real u2max,
 418                                const Standard_Real v2max)
 419 {
 420   //xf
 421   Standard_Integer i, NbPasOKConseq;
 422   Standard_Real UFirst1, VFirst1, ULast1, VLast1, UFirst2, VFirst2, ULast2, VLast2;
 423   Standard_Real pasMaxSV[4], aTmp;
 424   TColStd_Array1OfReal Param(1,4);
 425   IntImp_ConstIsoparametric ChoixIso;
 426   //xt
 427   //
 428   done = Standard_False;
 429   NbPasOKConseq=0;
 430   //
 431   // Caro1 and Caro2
 432   const ThePSurface& Caro1 =myIntersectionOn2S.Function().AuxillarSurface1();
 433   const ThePSurface& Caro2 =myIntersectionOn2S.Function().AuxillarSurface2();
 434   //
 435   UFirst1 = ThePSurfaceTool::FirstUParameter(Caro1);
 436   VFirst1 = ThePSurfaceTool::FirstVParameter(Caro1);
 437   ULast1  = ThePSurfaceTool::LastUParameter (Caro1);
 438   VLast1  = ThePSurfaceTool::LastVParameter (Caro1);
 439   //
 440   UFirst2 = ThePSurfaceTool::FirstUParameter(Caro2);
 441   VFirst2 = ThePSurfaceTool::FirstVParameter(Caro2);
 442   ULast2  = ThePSurfaceTool::LastUParameter (Caro2);
 443   VLast2  = ThePSurfaceTool::LastVParameter (Caro2);
 444   //
 445   ComputePasInit(pasuv,u1min,u1max,v1min,v1max,u2min,u2max,v2min,v2max,
 446                  Um1,UM1,Vm1,VM1,Um2,UM2,Vm2,VM2,Caro1,Caro2,pasMax+pasMax);
 447   //
 448   if(pasuv[0]<100*ResoU1) {
 449     pasuv[0]=100*ResoU1;
 450   }
 451   if(pasuv[1]<100*ResoV1) {
 452     pasuv[1]=100*ResoV1;
 453   }
 454   if(pasuv[2]<100*ResoU2) {
 455     pasuv[2]=100*ResoU2;
 456   }
 457   if(pasuv[3]<100*ResoV2) {
 458     pasuv[3]=100*ResoV2;
 459   }
 460   //
 461   for (i=0; i<4; ++i) {
 462     if(pasuv[i]>10) {
 463       pasuv[i] = 10;
 464     }
 465     pasInit[i] = pasSav[i] = pasuv[i];
 466   }
 467   //
 468   line = new IntSurf_LineOn2S ();
 469   //
 470   for (i=1; i<=4; ++i) {
 471     aTmp=ParDep(i);
 472     Param(i)=ParDep(i);
 473   }
 474   //-- reprise des pas uv lies aux surfaces Caro1 et Caro2
 475   //-- pasuv[] et pasSav[] sont modifies lors du cheminement
 476   for(i = 0; i < 4; ++i) {
 477     pasMaxSV[i] = pasSav[i] = pasuv[i] = pasInit[i];
 478   }
 479
 480   //-- calcul du premier point solution
 481   math_FunctionSetRoot  Rsnld(myIntersectionOn2S.Function());
 482   //
 483   ChoixIso = myIntersectionOn2S.Perform(Param,Rsnld);
 484   if (!myIntersectionOn2S.IsDone())   {
 485     return;
 486   }
 487   //
 488   if (myIntersectionOn2S.IsEmpty()) {
 489     return;
 490   }
 491   //
 492   if(myIntersectionOn2S.IsTangent()) {
 493     return;
 494   }
 495   //
 496   Standard_Boolean Arrive, DejaReparti;
 497   Standard_Integer IncKey, RejectIndex;
 498   gp_Pnt pf,pl;
 499   //
 500   DejaReparti = Standard_False;
 501   IncKey = 0;
 502   RejectIndex = 0;
 503   //
 504   previousPoint = myIntersectionOn2S.Point();
 505   previoustg = Standard_False;
 506   previousd  = myIntersectionOn2S.Direction();
 507   previousd1 = myIntersectionOn2S.DirectionOnS1();
 508   previousd2 = myIntersectionOn2S.DirectionOnS2();
 509   indextg = 1;
 510   tgdir   = previousd;
 511   firstd1 = previousd1;
 512   firstd2 = previousd2;
 513   tgfirst = tglast = Standard_False;
 514   choixIsoSav  =  ChoixIso;
 515   //------------------------------------------------------------
 516   //-- On Teste si le premier point de cheminement correspond
 517   //-- a un point sur frontiere.
 518   //-- Dans ce cas, DejaReparti est initialise a True
 519   //--
 520   pf = previousPoint.Value();
 521   Standard_Boolean bTestFirstPoint = Standard_True;
 522
 523   previousPoint.Parameters(Param(1),Param(2),Param(3),Param(4));
 524   AddAPoint(line,previousPoint);
 525   //
 526   IntWalk_StatusDeflection Status = IntWalk_OK;
 527   Standard_Boolean NoTestDeflection = Standard_False;
 528   Standard_Real SvParam[4], f;
 529   Standard_Integer LevelOfEmptyInmyIntersectionOn2S=0;
 530   Standard_Integer LevelOfPointConfondu = 0;
 531   Standard_Integer LevelOfIterWithoutAppend = -1;
 532   //
 533   Arrive = Standard_False;
 534   while(!Arrive) {//010
 535     LevelOfIterWithoutAppend++;
 536     if(LevelOfIterWithoutAppend>20) {
 537       Arrive = Standard_True;
 538       if(DejaReparti) {
 539         break;
 540       }
 541       RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
 542       LevelOfIterWithoutAppend = 0;
 543     }
 544     //
 545     // compute f
 546     f = 0.;
 547     switch (ChoixIso) {
 548       case IntImp_UIsoparametricOnCaro1: f = Abs(previousd1.X()); break;
 549       case IntImp_VIsoparametricOnCaro1: f = Abs(previousd1.Y()); break;
 550       case IntImp_UIsoparametricOnCaro2: f = Abs(previousd2.X()); break;
 551       case IntImp_VIsoparametricOnCaro2: f = Abs(previousd2.Y()); break;
 552       default:break;
 553     }
 554     //
 555     if(f<0.1) {
 556       f=0.1;
 557     }
 558     //
 559     previousPoint.Parameters(Param(1),Param(2),Param(3),Param(4));
 560     //
 561     //--ofv.begin
 562     Standard_Real aIncKey, aEps, dP1, dP2, dP3, dP4;
 563     //
 564     dP1 = sensCheminement * pasuv[0] * previousd1.X() /f;
 565     dP2 = sensCheminement * pasuv[1] * previousd1.Y() /f;
 566     dP3 = sensCheminement * pasuv[2] * previousd2.X() /f;
 567     dP4 = sensCheminement * pasuv[3] * previousd2.Y() /f;
 568     //
 569     aIncKey=5.*(Standard_Real)IncKey;
 570     aEps=1.e-7;
 571     if(ChoixIso == IntImp_UIsoparametricOnCaro1 && Abs(dP1) < aEps) {
 572       dP1 *= aIncKey;
 573     }
 574     if(ChoixIso == IntImp_VIsoparametricOnCaro1 && Abs(dP2) < aEps) {
 575       dP2 *= aIncKey;
 576     }
 577     if(ChoixIso == IntImp_UIsoparametricOnCaro2 && Abs(dP3) < aEps) {
 578       dP3 *= aIncKey;
 579     }
 580     if(ChoixIso == IntImp_VIsoparametricOnCaro2 && Abs(dP4) < aEps) {
 581       dP4 *= aIncKey;
 582     }
 583     //--ofv.end
 584     //
 585     Param(1) += dP1;
 586     Param(2) += dP2;
 587     Param(3) += dP3;
 588     Param(4) += dP4;
 589     //==========================
 590     SvParam[0]=Param(1);
 591     SvParam[1]=Param(2);
 592     SvParam[2]=Param(3);
 593     SvParam[3]=Param(4);
 594     //
 595     ChoixIso= myIntersectionOn2S.Perform(Param, Rsnld, ChoixIso);
 596     //
 597     if (!myIntersectionOn2S.IsDone())   {
 598       //arret de la ligne,division
 599       Arrive = Standard_False;
 600       Param(1)=SvParam[0];
 601       Param(2)=SvParam[1];
 602       Param(3)=SvParam[2];
 603       Param(4)=SvParam[3];
 604       RepartirOuDiviser(DejaReparti, ChoixIso, Arrive);
 605     }
 606     else  {//009
 607       //== Le calcul du point exact a partir de Param(.) est possible
 608       if (myIntersectionOn2S.IsEmpty()) {
 609         Standard_Real u1,v1,u2,v2;
 610         previousPoint.Parameters(u1,v1,u2,v2);
 611         //
 612         Arrive = Standard_False;
 613         if(u1<UFirst1 || u1>ULast1) {
 614           Arrive=Standard_True;
 615         }
 616         if(u2<UFirst2 || u2>ULast2) {
 617           Arrive=Standard_True;
 618         }
 619         if(v1<VFirst1 || v1>VLast1) {
 620           Arrive=Standard_True;
 621         }
 622         if(v2<VFirst2 || v2>VLast2) {
 623           Arrive=Standard_True;
 624         }
 625         RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
 626         LevelOfEmptyInmyIntersectionOn2S++;
 627         //
 628         if(LevelOfEmptyInmyIntersectionOn2S>10)    {
 629           pasuv[0]=pasSav[0];
 630           pasuv[1]=pasSav[1];
 631           pasuv[2]=pasSav[2];
 632           pasuv[3]=pasSav[3];
 633         }
 634       }
 635       else {//008
 636         //============================================================
 637         //== Un point a ete trouve :  T E S T   D E F L E C T I O N
 638         //============================================================
 639         if(NoTestDeflection) {
 640           NoTestDeflection = Standard_False;
 641         }
 642         else {
 643           if(--LevelOfEmptyInmyIntersectionOn2S<=0)     {
 644             LevelOfEmptyInmyIntersectionOn2S=0;
 645             if(LevelOfIterWithoutAppend < 10) {
 646               Status = TestDeflection();
 647             }
 648             else   {
 649               pasuv[0]*=0.5;
 650               pasuv[1]*=0.5;
 651               pasuv[2]*=0.5;
 652               pasuv[3]*=0.5;
 653             }
 654           }
 655         }
 656         //============================================================
 657         //==       T r a i t e m e n t   s u r   S t a t u s        ==
 658         //============================================================
 659         if(LevelOfPointConfondu > 5) {
 660           Status = IntWalk_ArretSurPoint;
 661           LevelOfPointConfondu = 0;
 662         }
 663         //
 664         if(Status==IntWalk_OK) {
 665           NbPasOKConseq++;
 666           if(NbPasOKConseq >= 5) {
 667             NbPasOKConseq=0;
 668             Standard_Boolean pastroppetit;
 669             Standard_Real t;
 670             //
 671             do {
 672               pastroppetit=Standard_True;
 673               //
 674               if(pasuv[0]<pasInit[0])     {
 675                 t = (pasInit[0]-pasuv[0])*0.25;
 676                 if(t>0.1*pasInit[0]) {
 677                   t=0.1*pasuv[0];
 678                 }
 679                 pasuv[0]+=t;
 680                 pastroppetit=Standard_False;
 681               }
 682               if(pasuv[1]<pasInit[1])   {
 683                 t = (pasInit[1]-pasuv[1])*0.25;
 684                 if(t>0.1*pasInit[1]) {
 685                   t=0.1*pasuv[1];
 686                 }
 687                 pasuv[1]+=t;
 688                 pastroppetit=Standard_False;
 689               }
 690               if(pasuv[2]<pasInit[2]){
 691                 t = (pasInit[2]-pasuv[2])*0.25;
 692                 if(t>0.1*pasInit[2]) {
 693                   t=0.1*pasuv[2];
 694                 }
 695                 pasuv[2]+=t;
 696                 pastroppetit=Standard_False;
 697               }
 698               if(pasuv[3]<pasInit[3])   {
 699                 t = (pasInit[3]-pasuv[3])*0.25;
 700                 if(t>0.1*pasInit[3]) {
 701                   t=0.1*pasuv[3];
 702                 }
 703                 pasuv[3]+=t;
 704                 pastroppetit=Standard_False;
 705               }
 706               if(pastroppetit) {
 707                 if(pasMax<0.1){
 708                   pasMax*=1.1;
 709                   pasInit[0]*=1.1;
 710                   pasInit[1]*=1.1;
 711                   pasInit[2]*=1.1;
 712                   pasInit[3]*=1.1;
 713                 }
 714                 else {
 715                   pastroppetit=Standard_False;
 716                 }
 717               }
 718             } while(pastroppetit);
 719           }
 720         }//Status==IntWalk_OK
 721         else NbPasOKConseq=0;
 722         //
 723         switch(Status) {//007
 724           case IntWalk_ArretSurPointPrecedent:  {
 725             Arrive = Standard_False;
 726             RepartirOuDiviser(DejaReparti, ChoixIso, Arrive);
 727             break;
 728           }
 729           case IntWalk_PasTropGrand:  {
 730             Param(1)=SvParam[0];
 731             Param(2)=SvParam[1];
 732             Param(3)=SvParam[2];
 733             Param(4)=SvParam[3];
 734             if(LevelOfIterWithoutAppend > 5) {
 735               if(pasSav[0]<pasInit[0]) {
 736                 pasInit[0]-=(pasInit[0]-pasSav[0])*0.25;
 737                 LevelOfIterWithoutAppend=0;
 738               }
 739               if(pasSav[1]<pasInit[1]) {
 740                 pasInit[1]-=(pasInit[1]-pasSav[1])*0.25;
 741                 LevelOfIterWithoutAppend=0;
 742               }
 743               if(pasSav[2]<pasInit[2]) {
 744                 pasInit[2]-=(pasInit[2]-pasSav[2])*0.25;
 745                 LevelOfIterWithoutAppend=0;
 746               }
 747               if(pasSav[3]<pasInit[3]) {
 748                 pasInit[3]-=(pasInit[3]-pasSav[3])*0.25;
 749                 LevelOfIterWithoutAppend=0;
 750               }
 751             }
 752             break;
 753           }
 754           case IntWalk_PointConfondu:   {
 755             LevelOfPointConfondu++;
 756             if(LevelOfPointConfondu>5)   {
 757               Standard_Boolean pastroppetit;
 758               //
 759               do {
 760                 pastroppetit=Standard_True;
 761                 if(pasuv[0]<pasInit[0]) {
 762                   pasuv[0]+=(pasInit[0]-pasuv[0])*0.25;
 763                   pastroppetit=Standard_False;
 764                 }
 765                 if(pasuv[1]<pasInit[1]) {
 766                   pasuv[1]+=(pasInit[1]-pasuv[1])*0.25;
 767                   pastroppetit=Standard_False;
 768                 }
 769                 if(pasuv[2]<pasInit[2]) {
 770                   pasuv[2]+=(pasInit[2]-pasuv[2])*0.25;
 771                   pastroppetit=Standard_False;
 772                 }
 773                 if(pasuv[3]<pasInit[3]) {
 774                   pasuv[3]+=(pasInit[3]-pasuv[3])*0.25;
 775                   pastroppetit=Standard_False;
 776                 }
 777                 if(pastroppetit)  {
 778                   if(pasMax<0.1){
 779                     pasMax*=1.1;
 780                     pasInit[0]*=1.1;
 781                     pasInit[1]*=1.1;
 782                     pasInit[2]*=1.1;
 783                     pasInit[3]*=1.1;
 784                   }
 785                   else{
 786                     pastroppetit=Standard_False;
 787                   }
 788                 }
 789               } while(pastroppetit);
 790             }
 791             break;
 792           }
 793           case IntWalk_OK:
 794           case IntWalk_ArretSurPoint:  {//006
 795             //=======================================================
 796             //== T e s t   A r r e t   :  Cadrage sur Param(.)     ==
 797             //=======================================================
 798             //xft arrive here
 799             Arrive = TestArret(DejaReparti,Param,ChoixIso);
 800             // JMB 30th December 1999.
 801             // Some statement below should not be put in comment because they are useful.
 802             // See grid CTO 909 A1 which infinitely loops
 803             if(Arrive==Standard_False && Status==IntWalk_ArretSurPoint) {
 804               Arrive=Standard_True;
 805 #ifdef DEB
 806               cout << "Compile avec option DEB :Si Pb d intersection : ";
 807               cout << "IntWalk_PWalking_1.gxx (lbr le 1erdec98)"<<endl;
 808 #endif
 809             }
 810             if(Arrive) {
 811               NbPasOKConseq = -10;
 812             }
 813             if(!Arrive)  {//005
 814               //=====================================================
 815               //== Param(.)  est dans les bornes                   ==
 816               //==  et ne finit pas une ligne fermee               ==
 817               //=====================================================
 818               //== Verification sur Le Point Courant de myInters
 819               Standard_Boolean pointisvalid = Standard_False;
 820               {
 821                 Standard_Real u1,v1,u2,v2;
 822                 myIntersectionOn2S.Point().Parameters(u1,v1,u2,v2);
 823                 //
 824                 if(u1 <= UM1  && u2 <= UM2 && v1 <= VM1 &&
 825                    v2 <= VM2  && u1 >= Um1 && u2 >= Um2 &&
 826                    v1 >= Vm1  && v2 >= Vm2) {
 827                   pointisvalid=Standard_True;
 828                 }
 829               }
 830               //
 831               if(pointisvalid) {
 832                 previousPoint = myIntersectionOn2S.Point();
 833                 previoustg = myIntersectionOn2S.IsTangent();
 834                 if(!previoustg) {
 835                   previousd  = myIntersectionOn2S.Direction();
 836                   previousd1 = myIntersectionOn2S.DirectionOnS1();
 837                   previousd2 = myIntersectionOn2S.DirectionOnS2();
 838                 }
 839                 //=====================================================
 840                 //== Verification sur Previous Point
 841                 {
 842                   Standard_Real u1,v1,u2,v2;
 843                   previousPoint.Parameters(u1,v1,u2,v2);
 844                   if( u1 <= UM1  && u2 <= UM2 && v1 <= VM1 &&
 845                       v2 <= VM2  && u1 >= Um1 && u2 >= Um2 &&
 846                       v1 >= Vm1  && v2 >= Vm2) {
 847                     pl = previousPoint.Value();
 848                     if(bTestFirstPoint) {
 849                       if(pf.Distance(pl) < 1.e-7){
 850                         IncKey++;
 851                         if(IncKey == 5000)
 852                           return;
 853                         else
 854                           continue;
 855                       }
 856                       else {
 857                         bTestFirstPoint = Standard_False;
 858                       }
 859                     }
 860                     //
 861                     AddAPoint(line,previousPoint);
 862                     RejectIndex++;
 863                     if(RejectIndex >= 250000) {
 864                       break;
 865                     };
 866                     //
 867                     LevelOfIterWithoutAppend = 0;
 868                   }
 869                 }
 870               }//pointisvalid
 871               //====================================================
 872               if(Status == IntWalk_ArretSurPoint)  {
 873                 RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
 874               }
 875               else{
 876                 if (line->NbPoints() == 2) {
 877                   pasSav[0] = pasuv[0];
 878                   pasSav[1] = pasuv[1];
 879                   pasSav[2] = pasuv[2];
 880                   pasSav[3] = pasuv[3];
 881                 }
 882               }
 883             }//005 if(!Arrive)
 884             //
 885             else {//004
 886               if(close) {
 887                 //================= la ligne est fermee ===============
 888                 AddAPoint(line,line->Value(1)); //ligne fermee
 889                 LevelOfIterWithoutAppend=0;
 890               }
 891               else {//$$$
 892                 //====================================================
 893                 //== Param n etait pas dans les bornes (a ete recadre)
 894                 //====================================================
 895                 Standard_Boolean bPrevNotTangent = !previoustg || !myIntersectionOn2S.IsTangent();
 896
 897                 IntImp_ConstIsoparametric SauvChoixIso = ChoixIso;
 898                 ChoixIso = myIntersectionOn2S.Perform(Param,Rsnld,ChoixIso);
 899                 //
 900                 if(!myIntersectionOn2S.IsEmpty()) { //002
 901                   // debordement sur le carreau reciproque ou intersection en coin
 902                   if(TestArret(Standard_True,Param,ChoixIso))  {
 903                     NbPasOKConseq = -10;
 904                     ChoixIso = myIntersectionOn2S.Perform(Param,Rsnld,ChoixIso);
 905                     if(!myIntersectionOn2S.IsEmpty())     {
 906                       previousPoint = myIntersectionOn2S.Point();
 907                       previoustg = myIntersectionOn2S.IsTangent();
 908                       if (!previoustg)     {
 909                         previousd  = myIntersectionOn2S.Direction();
 910                         previousd1 = myIntersectionOn2S.DirectionOnS1();
 911                         previousd2 = myIntersectionOn2S.DirectionOnS2();
 912                       }
 913                       pl = previousPoint.Value();
 914                       if(bTestFirstPoint) {
 915                         if(pf.Distance(pl) < 1.e-7){
 916                           IncKey++;
 917                           if(IncKey == 5000)
 918                             return;
 919                           else
 920                             continue;
 921                         }
 922                         else {
 923                           bTestFirstPoint = Standard_False;
 924                         }
 925                       }
 926                       //
 927                       AddAPoint(line,previousPoint);
 928                       RejectIndex++;
 929                       if(RejectIndex >= 250000) {
 930                         break;
 931                       };
 932                       //
 933                       LevelOfIterWithoutAppend=0;
 934                       RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
 935                     }
 936                     else  {
 937                       //echec cadrage diviser le pas
 938                       Arrive = Standard_False;
 939                       RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
 940                       NoTestDeflection = Standard_True;
 941                       ChoixIso = SauvChoixIso;
 942                     }
 943                   }//if(TestArret())
 944                   else {
 945                     // save the last point
 946                     // to revert to it if the current point is out of bounds
 947                     IntSurf_PntOn2S previousPointSave = previousPoint;
 948                     Standard_Boolean previoustgSave   = previoustg;
 949                     gp_Dir previousdSave              = previousd;
 950                     gp_Dir2d previousd1Save           = previousd1;
 951                     gp_Dir2d previousd2Save           = previousd2;
 952
 953                     previousPoint = myIntersectionOn2S.Point();
 954                     previoustg = myIntersectionOn2S.IsTangent();
 955                     Arrive = Standard_False;
 956                     if(!previoustg)  {
 957                       previousd  = myIntersectionOn2S.Direction();
 958                       previousd1 = myIntersectionOn2S.DirectionOnS1();
 959                       previousd2 = myIntersectionOn2S.DirectionOnS2();
 960                     }
 961                     //========================================
 962                     //== Verification sur PreviousPoint @@
 963                     {
 964                       Standard_Real u1,v1,u2,v2;
 965                       previousPoint.Parameters(u1,v1,u2,v2);
 966                       Param(1) = u1;
 967                       Param(2) = v1;
 968                       Param(3) = u2;
 969                       Param(4) = v2;
 970                       //
 971                       //xf
 972                       Standard_Boolean bFlag1, bFlag2;
 973                       Standard_Real aTol2D=1.e-11;
 974                       //
 975                       bFlag1=u1 >= Um1-aTol2D && v1 >= Vm1-aTol2D && u1 <= UM1+aTol2D && v1 <= VM1+aTol2D;
 976                       bFlag2=u2 >= Um2-aTol2D && v2 >= Vm2-aTol2D && u2 <= UM2+aTol2D && v2 <= VM2+aTol2D;
 977                       if (bFlag1 && bFlag2) {
 978                       /*
 979                       if(u1 <= UM1  && u2 <= UM2 && v1 <= VM1 &&
 980                          v2 <= VM2  && u1 >= Um1 && u2 >= Um2 &&
 981                          v1 >= Vm1  && v2 >= Vm2)  {
 982                          */
 983                       //xt
 984                         pl = previousPoint.Value();
 985                         if(bTestFirstPoint) {
 986                           if(pf.Distance(pl) < 1.e-7) {
 987                             IncKey++;
 988                             if(IncKey == 5000)
 989                               return;
 990                             else
 991                               continue;
 992                           }
 993                           else {
 994                             bTestFirstPoint = Standard_False;
 995                           }
 996                         }
 997                         AddAPoint(line,previousPoint);
 998                         RejectIndex++;
 999                         if(RejectIndex >= 250000) {
1000                           break;
1001                         }
1002                         //
1003                         LevelOfIterWithoutAppend=0;
1004                         Arrive = Standard_True;
1005                       }
1006                       else {
1007                         // revert to the last correctly calculated point
1008                         previousPoint = previousPointSave;
1009                         previoustg    = previoustgSave;
1010                         previousd     = previousdSave;
1011                         previousd1    = previousd1Save;
1012                         previousd2    = previousd2Save;
1013                       }
1014                     }
1015                     //
1016                     Standard_Boolean wasExtended = Standard_False;
1017
1018                     if(Arrive && myIntersectionOn2S.IsTangent() && bPrevNotTangent) {
1019                       if(ExtendLineInCommonZone(SauvChoixIso, DejaReparti)) {
1020                         wasExtended = Standard_True;
1021                         Arrive = Standard_False;
1022                         ChoixIso = SauvChoixIso;
1023                       }
1024                     }
1025
1026                     RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
1027                     if(Arrive &&
1028                        myIntersectionOn2S.IsDone() && !myIntersectionOn2S.IsEmpty() &&
1029                        myIntersectionOn2S.IsTangent() && bPrevNotTangent &&
1030                        !wasExtended) {
1031
1032                       if(ExtendLineInCommonZone(SauvChoixIso, DejaReparti)) {
1033                         wasExtended = Standard_True;
1034                         Arrive = Standard_False;
1035                         ChoixIso = SauvChoixIso;
1036                       }
1037                     }
1038                   }//else !TestArret() $
1039                 } //$$ fin succes cadrage sur frontiere (!myIntersectionOn2S.IsEmpty())
1040                 else  {
1041                   //echec cadrage  sur frontiere;division du pas
1042                   Arrive = Standard_False;
1043                   NoTestDeflection = Standard_True;
1044                   RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
1045                 }
1046               }//$$$ fin cadrage sur frontiere (!close)
1047             } //004 fin TestArret retourne Arrive = True
1048           } // 006case IntWalk_ArretSurPoint:  fin Traitement Status = OK  ou ArretSurPoint
1049         } //007  switch(Status)
1050       } //008 fin traitement point en court (TEST DEFLECTION)
1051     } //009 fin traitement ligne (else if myIntersectionOn2S.IsDone())
1052   }  //010 fin si premier point de depart a permis un cheminement while(!Arrive)
1053   done = Standard_True;
1054 }
1055 // ===========================================================================================================
1056 // function: ExtendLineInCommonZone
1057 // purpose:  Extends already computed line inside tangent zone in the direction given by theChoixIso.
1058 //           Returns Standard_True if the line was extended through tangent zone and the last computed point
1059 //           is outside the tangent zone (but it is not put into the line). Otherwise returns Standard_False.
1060 // ===========================================================================================================
1061 Standard_Boolean IntWalk_PWalking::ExtendLineInCommonZone(const IntImp_ConstIsoparametric theChoixIso,
1062                                                           const Standard_Boolean          theDirectionFlag)
1063 {
1064   Standard_Boolean bOutOfTangentZone = Standard_False;
1065   Standard_Boolean bStop = !myIntersectionOn2S.IsTangent();
1066   Standard_Integer dIncKey = 1;
1067   TColStd_Array1OfReal Param(1,4);
1068   IntWalk_StatusDeflection Status = IntWalk_OK;
1069   Standard_Integer nbIterWithoutAppend = 0;
1070   Standard_Integer nbEqualPoints = 0;
1071   Standard_Integer parit = 0;
1072   Standard_Integer uvit = 0;
1073   IntSurf_SequenceOfPntOn2S aSeqOfNewPoint;
1074
1075   while (!bStop) {
1076     nbIterWithoutAppend++;
1077
1078     if((nbIterWithoutAppend > 20) || (nbEqualPoints > 20)) {
1079 #ifdef DEB
1080       cout<<"Compile with option DEB:";
1081       cout<<"Infinite loop has detected. Stop iterations (IntWalk_PWalking_1.gxx)" << endl;
1082 #endif
1083       bStop = Standard_True;
1084       break;
1085     }
1086     Standard_Real f = 0.;
1087
1088     switch (theChoixIso)
1089       {
1090       case IntImp_UIsoparametricOnCaro1: f = Abs(previousd1.X()); break;
1091       case IntImp_VIsoparametricOnCaro1: f = Abs(previousd1.Y()); break;
1092       case IntImp_UIsoparametricOnCaro2: f = Abs(previousd2.X()); break;
1093       case IntImp_VIsoparametricOnCaro2: f = Abs(previousd2.Y()); break;
1094       }
1095
1096     if(f<0.1) f=0.1;
1097
1098     previousPoint.Parameters(Param(1),Param(2),Param(3),Param(4));
1099
1100     Standard_Real dP1 = sensCheminement * pasuv[0] * previousd1.X() /f;
1101     Standard_Real dP2 = sensCheminement * pasuv[1] * previousd1.Y() /f;
1102     Standard_Real dP3 = sensCheminement * pasuv[2] * previousd2.X() /f;
1103     Standard_Real dP4 = sensCheminement * pasuv[3] * previousd2.Y() /f;
1104
1105     if(theChoixIso == IntImp_UIsoparametricOnCaro1 && Abs(dP1) < 1.e-7) dP1 *= (5. * (Standard_Real)dIncKey);
1106     if(theChoixIso == IntImp_VIsoparametricOnCaro1 && Abs(dP2) < 1.e-7) dP2 *= (5. * (Standard_Real)dIncKey);
1107     if(theChoixIso == IntImp_UIsoparametricOnCaro2 && Abs(dP3) < 1.e-7) dP3 *= (5. * (Standard_Real)dIncKey);
1108     if(theChoixIso == IntImp_VIsoparametricOnCaro2 && Abs(dP4) < 1.e-7) dP4 *= (5. * (Standard_Real)dIncKey);
1109
1110     Param(1) += dP1;
1111     Param(2) += dP2;
1112     Param(3) += dP3;
1113     Param(4) += dP4;
1114     Standard_Real SvParam[4];
1115     IntImp_ConstIsoparametric ChoixIso = theChoixIso;
1116
1117     for(parit = 0; parit < 4; parit++) {
1118       SvParam[parit] = Param(parit+1);
1119     }
1120     math_FunctionSetRoot  Rsnld(myIntersectionOn2S.Function());
1121     ChoixIso = myIntersectionOn2S.Perform(Param,Rsnld, theChoixIso);
1122
1123     if (!myIntersectionOn2S.IsDone()) {
1124       return bOutOfTangentZone;
1125     }
1126     else {
1127       if (myIntersectionOn2S.IsEmpty()) {
1128         return bOutOfTangentZone;
1129       }
1130
1131       Status = TestDeflection();
1132
1133       if(Status == IntWalk_OK) {
1134
1135         for(uvit = 0; uvit < 4; uvit++) {
1136           if(pasuv[uvit] < pasInit[uvit]) {
1137             pasuv[uvit] = pasInit[uvit];
1138           }
1139         }
1140       }
1141
1142       switch(Status) {
1143       case  IntWalk_ArretSurPointPrecedent:
1144         {
1145           bStop = Standard_True;
1146           bOutOfTangentZone = !myIntersectionOn2S.IsTangent();
1147           break;
1148         }
1149       case IntWalk_PasTropGrand:
1150         {
1151           for(parit = 0; parit < 4; parit++) {
1152             Param(parit+1) = SvParam[parit];
1153           }
1154           Standard_Boolean bDecrease = Standard_False;
1155
1156           for(uvit = 0; uvit < 4; uvit++) {
1157             if(pasSav[uvit] < pasInit[uvit]) {
1158               pasInit[uvit] -= (pasInit[uvit] - pasSav[uvit]) * 0.1;
1159               bDecrease = Standard_True;
1160             }
1161           }
1162
1163           if(bDecrease) nbIterWithoutAppend--;
1164           break;
1165         }
1166       case IntWalk_PointConfondu:
1167         {
1168           for(uvit = 0; uvit < 4; uvit++) {
1169             if(pasuv[uvit] < pasInit[uvit]) {
1170               pasuv[uvit] += (pasInit[uvit] - pasuv[uvit]) * 0.1;
1171             }
1172           }
1173           break;
1174         }
1175       case IntWalk_OK:
1176       case IntWalk_ArretSurPoint:
1177         {
1178           //
1179           bStop = TestArret(theDirectionFlag, Param, ChoixIso);
1180           //
1181
1182           //
1183           if(!bStop) {
1184             Standard_Real u11,v11,u12,v12;
1185             myIntersectionOn2S.Point().Parameters(u11,v11,u12,v12);
1186             Standard_Real u21,v21,u22,v22;
1187             previousPoint.Parameters(u21,v21,u22,v22);
1188
1189             if(((fabs(u11-u21) < ResoU1) && (fabs(v11-v21) < ResoV1)) ||
1190                ((fabs(u12-u22) < ResoU2) && (fabs(v12-v22) < ResoV2))) {
1191               nbEqualPoints++;
1192             }
1193             else {
1194               nbEqualPoints = 0;
1195             }
1196           }
1197           //
1198
1199           bStop = bStop || !myIntersectionOn2S.IsTangent();
1200           bOutOfTangentZone = !myIntersectionOn2S.IsTangent();
1201
1202           if(!bStop) {
1203             Standard_Boolean pointisvalid = Standard_False;
1204             Standard_Real u1,v1,u2,v2;
1205             myIntersectionOn2S.Point().Parameters(u1,v1,u2,v2);
1206
1207             if(u1 <= UM1  && u2 <= UM2 && v1 <= VM1 &&
1208                v2 <= VM2  && u1 >= Um1 && u2 >= Um2 &&
1209                v1 >= Vm1  && v2 >= Vm2)
1210               pointisvalid = Standard_True;
1211
1212             if(pointisvalid) {
1213               previousPoint = myIntersectionOn2S.Point();
1214               previoustg = myIntersectionOn2S.IsTangent();
1215
1216               if(!previoustg) {
1217                 previousd  = myIntersectionOn2S.Direction();
1218                 previousd1 = myIntersectionOn2S.DirectionOnS1();
1219                 previousd2 = myIntersectionOn2S.DirectionOnS2();
1220               }
1221               Standard_Boolean bAddPoint = Standard_True;
1222
1223               if(line->NbPoints() >= 1) {
1224                 gp_Pnt pf = line->Value(1).Value();
1225                 gp_Pnt pl = previousPoint.Value();
1226
1227                 if(pf.Distance(pl) < Precision::Confusion()) {
1228                   dIncKey++;
1229                   if(dIncKey == 5000) return bOutOfTangentZone;
1230                   else bAddPoint = Standard_False;
1231                 }
1232               }
1233
1234               if(bAddPoint) {
1235                 aSeqOfNewPoint.Append(previousPoint);
1236                 nbIterWithoutAppend = 0;
1237               }
1238             }
1239
1240             if (line->NbPoints() == 2) {
1241               for(uvit = 0; uvit < 4; uvit++) {
1242                 pasSav[uvit] = pasuv[uvit];
1243               }
1244             }
1245
1246             if ( !pointisvalid ) {
1247               // decrease step if out of bounds
1248               // otherwise the same calculations will be
1249               // repeated several times
1250               if ( ( u1 > UM1 ) || ( u1 < Um1 ) )
1251                 pasuv[0] *= 0.5;
1252
1253               if ( ( v1 > VM1 ) || ( v1 < Vm1 ) )
1254                 pasuv[1] *= 0.5;
1255
1256               if ( ( u2 > UM2 ) || ( u2 < Um2 ) )
1257                 pasuv[2] *= 0.5;
1258
1259               if ( ( v2 > VM2 ) || ( v2 < Vm2 ) )
1260                 pasuv[3] *= 0.5;
1261             }
1262           } // end if(!bStop)
1263           else { //if(bStop)
1264             if(close && (line->NbPoints() >= 1)) {
1265
1266               if(!bOutOfTangentZone) {
1267                 aSeqOfNewPoint.Append(line->Value(1)); // line end
1268               }
1269               nbIterWithoutAppend = 0;
1270             }
1271             else {
1272               ChoixIso = myIntersectionOn2S.Perform(Param, Rsnld, theChoixIso);
1273
1274               if(myIntersectionOn2S.IsEmpty()) {
1275                 bStop = !myIntersectionOn2S.IsTangent();
1276                 bOutOfTangentZone = !myIntersectionOn2S.IsTangent();
1277               }
1278               else {
1279                 Standard_Boolean bAddPoint = Standard_True;
1280                 Standard_Boolean pointisvalid = Standard_False;
1281
1282                 previousPoint = myIntersectionOn2S.Point();
1283                 Standard_Real u1,v1,u2,v2;
1284                 previousPoint.Parameters(u1,v1,u2,v2);
1285
1286                 if(u1 <= UM1  && u2 <= UM2 && v1 <= VM1 &&
1287                    v2 <= VM2  && u1 >= Um1 && u2 >= Um2 &&
1288                    v1 >= Vm1  && v2 >= Vm2)
1289                   pointisvalid = Standard_True;
1290
1291                 if(pointisvalid) {
1292
1293                   if(line->NbPoints() >= 1) {
1294                     gp_Pnt pf = line->Value(1).Value();
1295                     gp_Pnt pl = previousPoint.Value();
1296
1297                     if(pf.Distance(pl) < Precision::Confusion()) {
1298                       dIncKey++;
1299                       if(dIncKey == 5000) return bOutOfTangentZone;
1300                       else bAddPoint = Standard_False;
1301                     }
1302                   }
1303
1304                   if(bAddPoint && !bOutOfTangentZone) {
1305                     aSeqOfNewPoint.Append(previousPoint);
1306                     nbIterWithoutAppend = 0;
1307                   }
1308                 }
1309               }
1310             }
1311           }
1312           break;
1313         }
1314       default:
1315         {
1316           break;
1317         }
1318       }
1319     }
1320   }
1321   Standard_Boolean bExtendLine = Standard_False;
1322   Standard_Real u1 = 0., v1 = 0., u2 = 0., v2 = 0.;
1323
1324   Standard_Integer pit = 0;
1325
1326   for(pit = 0; !bExtendLine && (pit < 2); pit++) {
1327     if(pit == 0)
1328       previousPoint.Parameters(u1,v1,u2,v2);
1329     else {
1330       if(aSeqOfNewPoint.Length() > 0)
1331         aSeqOfNewPoint.Value(aSeqOfNewPoint.Length()).Parameters(u1,v1,u2,v2);
1332       else
1333         break;
1334     }
1335
1336     if(((u1 - Um1) < ResoU1) ||
1337        ((UM1 - u1) < ResoU1) ||
1338        ((u2 - Um2) < ResoU2) ||
1339        ((UM2 - u2) < ResoU2) ||
1340        ((v1 - Vm1) < ResoV1) ||
1341        ((VM1 - v1) < ResoV1) ||
1342        ((v2 - Vm2) < ResoV2) ||
1343        ((VM2 - v2) < ResoV2))
1344       bExtendLine = Standard_True;
1345   }
1346
1347   if(!bExtendLine) {
1348     //    if(Status == IntWalk_OK || Status == IntWalk_ArretSurPoint) {
1349     if(Status == IntWalk_OK) {
1350       bExtendLine = Standard_True;
1351
1352       if(aSeqOfNewPoint.Length() > 1) {
1353         TColStd_Array1OfReal FirstParams(0, 3), LastParams(0, 3), Resolutions(0, 3);
1354         Resolutions(0) = ResoU1; Resolutions(1) = ResoV1; Resolutions(2) = ResoU2; Resolutions(3) = ResoV2;
1355
1356         aSeqOfNewPoint(1).Parameters(FirstParams.ChangeValue(0), FirstParams.ChangeValue(1),
1357                                      FirstParams.ChangeValue(2), FirstParams.ChangeValue(3));
1358         aSeqOfNewPoint(aSeqOfNewPoint.Length()).Parameters(LastParams.ChangeValue(0),
1359                                                            LastParams.ChangeValue(1),
1360                                                            LastParams.ChangeValue(2),
1361                                                            LastParams.ChangeValue(3));
1362         Standard_Integer indexofiso = 0;
1363
1364         if(theChoixIso == IntImp_UIsoparametricOnCaro1) indexofiso = 0;
1365         if(theChoixIso == IntImp_VIsoparametricOnCaro1) indexofiso = 1;
1366         if(theChoixIso == IntImp_UIsoparametricOnCaro2) indexofiso = 2;
1367         if(theChoixIso == IntImp_VIsoparametricOnCaro2) indexofiso = 3;
1368
1369         Standard_Integer afirstindex = (indexofiso < 2) ? 0 : 2;
1370         gp_Vec2d aTangentZoneDir(gp_Pnt2d(FirstParams.Value(afirstindex), FirstParams.Value(afirstindex + 1)),
1371                                  gp_Pnt2d(LastParams.Value(afirstindex), LastParams.Value(afirstindex + 1)));
1372
1373         gp_Dir2d anIsoDir(0, 1);
1374
1375         if((indexofiso == 1) || (indexofiso == 3))
1376           anIsoDir = gp_Dir2d(1, 0);
1377
1378         if(aTangentZoneDir.SquareMagnitude() > gp::Resolution()) {
1379           Standard_Real piquota = M_PI*0.25;
1380
1381           if(fabs(aTangentZoneDir.Angle(anIsoDir)) > piquota) {
1382             Standard_Integer ii = 1, nextii = 2;
1383             gp_Vec2d d1(0, 0);
1384             Standard_Real asqresol = gp::Resolution();
1385             asqresol *= asqresol;
1386
1387             do {
1388               aSeqOfNewPoint(ii).Parameters(FirstParams.ChangeValue(0), FirstParams.ChangeValue(1),
1389                                             FirstParams.ChangeValue(2), FirstParams.ChangeValue(3));
1390               aSeqOfNewPoint(ii + 1).Parameters(LastParams.ChangeValue(0), LastParams.ChangeValue(1),
1391                                                   LastParams.ChangeValue(2), LastParams.ChangeValue(3));
1392               d1 = gp_Vec2d(gp_Pnt2d(FirstParams.Value(afirstindex),
1393                                      FirstParams.Value(afirstindex + 1)),
1394                             gp_Pnt2d(LastParams.Value(afirstindex),
1395                                      LastParams.Value(afirstindex + 1)));
1396               ii++;
1397             }
1398             while((d1.SquareMagnitude() < asqresol) &&
1399                   (ii < aSeqOfNewPoint.Length()));
1400
1401             nextii = ii;
1402
1403             while(nextii < aSeqOfNewPoint.Length()) {
1404
1405               gp_Vec2d nextd1(0, 0);
1406               Standard_Integer jj = nextii;
1407
1408               do {
1409                 aSeqOfNewPoint(jj).Parameters(FirstParams.ChangeValue(0), FirstParams.ChangeValue(1),
1410                                               FirstParams.ChangeValue(2), FirstParams.ChangeValue(3));
1411                 aSeqOfNewPoint(jj + 1).Parameters(LastParams.ChangeValue(0), LastParams.ChangeValue(1),
1412                                                   LastParams.ChangeValue(2), LastParams.ChangeValue(3));
1413                 nextd1 = gp_Vec2d(gp_Pnt2d(FirstParams.Value(afirstindex),
1414                                            FirstParams.Value(afirstindex + 1)),
1415                                   gp_Pnt2d(LastParams.Value(afirstindex),
1416                                            LastParams.Value(afirstindex + 1)));
1417                 jj++;
1418
1419               }
1420               while((nextd1.SquareMagnitude() < asqresol) &&
1421                     (jj < aSeqOfNewPoint.Length()));
1422               nextii = jj;
1423
1424               if(fabs(d1.Angle(nextd1)) > piquota) {
1425                 bExtendLine = Standard_False;
1426                 break;
1427               }
1428               d1 = nextd1;
1429             }
1430           }
1431           // end if(fabs(aTangentZoneDir.Angle(anIsoDir)
1432         }
1433       }
1434     }
1435   }
1436
1437   if(!bExtendLine) {
1438     return Standard_False;
1439   }
1440   Standard_Integer i = 0;
1441
1442   for(i = 1; i <= aSeqOfNewPoint.Length(); i++) {
1443     AddAPoint(line, aSeqOfNewPoint.Value(i));
1444   }
1445
1446   return bOutOfTangentZone;
1447 }