src/IntCurve/IntCurve_IntConicConic_1.cxx

   1 // Created on: 1992-05-06
   2 // Created by: Laurent BUCHARD
   3 // Copyright (c) 1992-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 // a modifier le cas de 2 points confondus ( Insert a la place d'append ? )
  18
  19 #include <ElCLib.hxx>
  20 #include <gp.hxx>
  21 #include <gp_Circ2d.hxx>
  22 #include <gp_Elips2d.hxx>
  23 #include <gp_Hypr2d.hxx>
  24 #include <gp_Lin2d.hxx>
  25 #include <gp_Parab2d.hxx>
  26 #include <gp_Pnt2d.hxx>
  27 #include <gp_Vec2d.hxx>
  28 #include <IntCurve_IConicTool.hxx>
  29 #include <IntCurve_IntConicConic.hxx>
  30 #include <IntCurve_IntConicConic_1.hxx>
  31 #include <IntCurve_IntConicConic_Tool.hxx>
  32 #include <IntCurve_PConic.hxx>
  33 #include <IntImpParGen.hxx>
  34 #include <IntRes2d_Domain.hxx>
  35 #include <IntRes2d_IntersectionPoint.hxx>
  36 #include <IntRes2d_IntersectionSegment.hxx>
  37 #include <IntRes2d_TypeTrans.hxx>
  38 #include <Precision.hxx>
  39 #include <Standard_ConstructionError.hxx>
  40
  41 Standard_Boolean Affichage=Standard_False;
  42 Standard_Boolean AffichageGraph=Standard_True;
  43
  44 //modified by NIZHNY-MKK  Tue Feb 15 10:53:34 2000.BEGIN
  45 // #define TOLERANCE_ANGULAIRE 0.00000001
  46 #define TOLERANCE_ANGULAIRE 1.e-15 //the reason is at least to make an accordance between transition and position computation.
  47 //modified by NIZHNY-MKK  Tue Feb 15 10:53:45 2000.END
  48
  49 const Standard_Real PIsur2 = 0.5*M_PI;
  50
  51 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  52 IntRes2d_Position FindPositionLL(Standard_Real&,const IntRes2d_Domain&);
  53 const IntRes2d_IntersectionPoint SegmentToPoint( const IntRes2d_IntersectionPoint& Pa
  54                                                 ,const IntRes2d_Transition& T1a
  55                                                 ,const IntRes2d_Transition& T2a
  56                                                 ,const IntRes2d_IntersectionPoint& Pb
  57                                                 ,const IntRes2d_Transition& T1b
  58                                                 ,const IntRes2d_Transition& T2b);
  59 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  60 void ProjectOnC2AndIntersectWithC2Domain(const gp_Circ2d& Circle1
  61                                          ,const gp_Circ2d& Circle2
  62                                          ,PeriodicInterval& C1DomainAndRes
  63                                          ,PeriodicInterval& DomainC2
  64                                          ,PeriodicInterval* SolutionC1
  65                                          ,PeriodicInterval* SolutionC2
  66                                          ,Standard_Integer &NbSolTotal
  67                                          ,const Standard_Boolean IdentCircles)
  68 {
  69
  70   if(C1DomainAndRes.IsNull()) return;
  71   //-------------------------------------------------------------------------
  72   //--  On cherche l intervalle correspondant sur C2
  73   //--  Puis on intersecte l intervalle avec le domaine de C2
  74   //--  Enfin, on cherche l intervalle correspondant sur C1
  75   //--
  76   Standard_Real C2inf =
  77     ElCLib::CircleParameter(Circle2.Axis()
  78                             ,ElCLib::CircleValue(C1DomainAndRes.Binf
  79                                                  ,Circle1.Axis(),Circle1.Radius()));
  80   Standard_Real C2sup =
  81     ElCLib::CircleParameter(Circle2.Axis()
  82                             ,ElCLib::CircleValue(C1DomainAndRes.Bsup
  83                                                  ,Circle1.Axis(),Circle1.Radius()));
  84
  85   PeriodicInterval C2Inter(C2inf,C2sup);
  86
  87   if(!IdentCircles) {
  88     if(C2Inter.Length() > M_PI)
  89       C2Inter.Complement();
  90   }
  91   else {
  92     if(C2sup<=C2inf) C2sup+=PIpPI;
  93     if(C2inf>=PIpPI) {
  94       C2sup-=PIpPI;
  95       C2inf-=PIpPI;
  96     }
  97     C2Inter.Binf=C2inf;
  98     C2Inter.Bsup=C2sup; //--- Verifier la longueur de l'intervalle sur C2
  99     C2Inter.Bsup=C2inf+C1DomainAndRes.Bsup-C1DomainAndRes.Binf;
 100   }
 101
 102   PeriodicInterval C2InterAndDomain[2];
 103
 104   for(Standard_Integer i=0; i<2 ; i++) {
 105     C2InterAndDomain[i]=(i==0)?  DomainC2.FirstIntersection(C2Inter)
 106                                : DomainC2.SecondIntersection(C2Inter);
 107
 108     if(!C2InterAndDomain[i].IsNull()) {
 109
 110       Standard_Real C1inf =
 111         ElCLib::CircleParameter(Circle1.Axis()
 112                                 ,ElCLib::CircleValue(C2InterAndDomain[i].Binf
 113                                         ,Circle2.Axis(),Circle2.Radius()));
 114       Standard_Real C1sup =
 115         ElCLib::CircleParameter(Circle1.Axis()
 116                                 ,ElCLib::CircleValue(C2InterAndDomain[i].Bsup
 117                                         ,Circle2.Axis(),Circle2.Radius()));
 118
 119       SolutionC1[NbSolTotal]=PeriodicInterval(C1inf,C1sup);
 120       if(!IdentCircles) {
 121         if(SolutionC1[NbSolTotal].Length() > M_PI)
 122           SolutionC1[NbSolTotal].Complement();
 123       }
 124       else {
 125         if(SolutionC1[NbSolTotal].Bsup <= SolutionC1[NbSolTotal].Binf) {
 126           SolutionC1[NbSolTotal].Bsup+=PIpPI;
 127         }
 128         if(SolutionC1[NbSolTotal].Binf>=PIpPI) {
 129           SolutionC1[NbSolTotal].Binf-=PIpPI;
 130           SolutionC1[NbSolTotal].Bsup-=PIpPI;
 131         }
 132       }
 133       SolutionC2[NbSolTotal]=C2InterAndDomain[i];
 134       NbSolTotal++;
 135     }
 136   }
 137 }
 138 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 139 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 140 void CircleCircleGeometricIntersection(const gp_Circ2d& C1
 141                                        ,const gp_Circ2d& C2
 142                                        ,const Standard_Real Tol
 143                                        ,const Standard_Real TolTang
 144                                        ,PeriodicInterval& C1_Res1
 145                                        ,PeriodicInterval& C1_Res2
 146                                        ,Standard_Integer& nbsol) {
 147
 148   Standard_Real C1_binf1,C1_binf2=0,C1_bsup1,C1_bsup2=0;
 149   Standard_Real dO1O2=(C1.Location()).Distance(C2.Location());
 150   Standard_Real R1=C1.Radius();
 151   Standard_Real R2=C2.Radius();
 152   Standard_Real AbsR1mR2=Abs(R1-R2);
 153   //----------------------------------------------------------------
 154   if(dO1O2 > (R1+R2+Tol)) {
 155     if(dO1O2 > (R1+R2+TolTang)) {
 156       nbsol=0;
 157       return;
 158     }
 159     else {
 160       C1_binf1 = 0.0;
 161       C1_bsup1 = 0.0;
 162       nbsol = 1;
 163     }
 164   }
 165   //----------------------------------------------------------------
 166   else if(dO1O2 <= Tol  &&  AbsR1mR2<=Tol)  {
 167     nbsol=3;
 168     return;
 169   }
 170   else {
 171     //----------------------------------------------------------------
 172     Standard_Real R1pR2=R1+R2;
 173     Standard_Real R1pTol=R1+Tol;
 174     Standard_Real R1mTol=R1-Tol;
 175 //    Standard_Real R1R1=R1*R1;
 176     Standard_Real R2R2=R2*R2;
 177     Standard_Real R1pTolR1pTol=R1pTol*R1pTol;
 178     Standard_Real R1mTolR1mTol=R1mTol*R1mTol;
 179     Standard_Real dO1O2dO1O2=dO1O2*dO1O2;
 180     Standard_Real dAlpha1;
 181     //--------------------------------------------------------------- Cas
 182     //-- C2 coupe le cercle C1+ (=C(x1,y1,R1+Tol))
 183     //--            1 seul segment donne par Inter C2 C1+
 184     //--
 185     if(dO1O2 > R1pR2-Tol) {
 186       Standard_Real dx=(R1pTolR1pTol+dO1O2dO1O2-R2R2)/(dO1O2+dO1O2);
 187       Standard_Real dy=(R1pTolR1pTol-dx*dx);
 188       dy=(dy>=0.0)? Sqrt(dy) : 0.0;
 189       dAlpha1=ATan2(dy,dx);
 190
 191       C1_binf1=-dAlpha1;
 192       C1_bsup1=dAlpha1;
 193       nbsol=1;
 194     }
 195     //--------------------------------------------------------------------
 196     //--           2 segments donnes par Inter C2 avec C1- C1 C1+
 197     //-- Seul le signe de dx change si dO1O2 < Max(R1,R2)
 198     //--
 199     else if(dO1O2 > AbsR1mR2-Tol) {  // -- +
 200       //------------------- Intersection C2 C1+ --------------------------
 201       Standard_Real dx=(R1pTolR1pTol+dO1O2dO1O2-R2R2)/(dO1O2+dO1O2);
 202       Standard_Real dy=(R1pTolR1pTol-dx*dx);
 203       dy=(dy>=0.0)? Sqrt(dy) : 0.0;
 204
 205       dAlpha1=ATan2(dy,dx);
 206       C1_binf1=-dAlpha1;  C1_bsup2=dAlpha1;  //--  |...?     ?...|   Sur C1
 207
 208       //------------------ Intersection C2 C1- -------------------------
 209       dx=(R1mTolR1mTol+dO1O2dO1O2-R2R2)/(dO1O2+dO1O2);
 210       dy=(R1mTolR1mTol-dx*dx);
 211       dy=(dy>=0.0)? Sqrt(dy) : 0.0;
 212       dAlpha1=ATan2(dy,dx);
 213
 214       C1_binf2=dAlpha1;  C1_bsup1=-dAlpha1;  //--  |...x     x...|   Sur C1
 215       nbsol=2;
 216       //------------------------------
 217       //-- Les 2 intervalles sont ils
 218       //-- en fait un seul inter ?
 219       //--
 220       if(dy==0) {    //-- Les 2 bornes internes sont identiques
 221         C1_bsup1 = C1_bsup2;
 222         nbsol = 1;
 223       }
 224       else {
 225         if(C1_binf1>C1_bsup1) {
 226           dAlpha1 = C1_binf1; C1_binf1 = C1_bsup1; C1_bsup1 = dAlpha1;
 227         }
 228         if(C1_binf2>C1_bsup2) {
 229           dAlpha1 = C1_binf2; C1_binf2 = C1_bsup2; C1_bsup2 = dAlpha1;
 230         }
 231         if(   ((C1_binf1<=C1_bsup2) && (C1_binf1>=C1_binf2))
 232            || ((C1_bsup1<=C1_bsup2) && (C1_bsup1>=C1_binf2))) {
 233           if(C1_binf1 > C1_binf2) C1_binf1 = C1_binf2;
 234           if(C1_binf1 > C1_bsup2) C1_binf1 = C1_bsup2;
 235           if(C1_bsup1 < C1_binf2) C1_bsup1 = C1_binf2;
 236           if(C1_bsup1 < C1_bsup2) C1_bsup1 = C1_bsup2;
 237           nbsol=1;
 238         }
 239       }
 240     }
 241     //--------------------------------------------------------------
 242     else {
 243       if((dO1O2 > AbsR1mR2-TolTang) && (AbsR1mR2-TolTang)>0.0) {
 244         C1_binf1=0.0;
 245         C1_bsup1=0.0;
 246         nbsol = 1;
 247       }
 248       else {
 249         nbsol=0; return ;
 250       }
 251     }
 252   }
 253
 254   //-- cout<<" C1_binf1:"<<C1_binf1;
 255   //-- cout<<" C1_bsup1:"<<C1_bsup1;
 256   //-- cout<<" C1_binf2:"<<C1_binf2;
 257   //-- cout<<" C1_bsup2:"<<C1_bsup2<<endl;
 258   //----------------------------------------------------------------
 259   //-- Mise en forme des resultats :
 260   //--    Les calculs ont ete fait dans le repere x1,y1, (O1,O2)
 261   //--    On se ramene au repere propre a C1
 262
 263   gp_Vec2d Axe1=C1.XAxis().Direction();
 264   gp_Vec2d AxeO1O2=gp_Vec2d(C1.Location(),C2.Location());
 265
 266   Standard_Real dAngle1;
 267   if(AxeO1O2.Magnitude() <= gp::Resolution())
 268     dAngle1=Axe1.Angle(C2.XAxis().Direction());
 269   else
 270     dAngle1=Axe1.Angle(AxeO1O2);
 271
 272   if(C1.IsDirect() == Standard_False) {
 273     dAngle1 = -dAngle1;
 274   }
 275
 276
 277   C1_binf1+=dAngle1;  C1_bsup1+=dAngle1;
 278
 279   //-- par construction aucun des segments ne peut exceder PI
 280   //-- (permet de ne pas gerer trop de cas differents)
 281
 282   C1_Res1.SetValues(C1_binf1,C1_bsup1);
 283   if(C1_Res1.Length() > M_PI) C1_Res1.Complement();
 284
 285   if(nbsol==2) {
 286     C1_binf2+=dAngle1;  C1_bsup2+=dAngle1;
 287     C1_Res2.SetValues(C1_binf2,C1_bsup2);
 288     if(C1_Res2.Length() > M_PI) C1_Res2.Complement();
 289   }
 290   else {
 291     C1_Res2.SetNull();
 292   }
 293 }
 294 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 295 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 296 void ProjectOnLAndIntersectWithLDomain(const gp_Circ2d& Circle
 297                                        ,const gp_Lin2d& Line
 298                                        ,PeriodicInterval& CDomainAndRes
 299                                        ,Interval& LDomain
 300                                        ,PeriodicInterval* CircleSolution
 301                                        ,Interval* LineSolution
 302                                        ,Standard_Integer &NbSolTotal
 303                                        ,const IntRes2d_Domain& RefLineDomain
 304 //                                     ,const IntRes2d_Domain& )
 305                                        ,const IntRes2d_Domain& )
 306 {
 307
 308
 309   if(CDomainAndRes.IsNull()) return;
 310   //-------------------------------------------------------------------------
 311   //--  On cherche l intervalle correspondant sur C2
 312   //--  Puis on intersecte l intervalle avec le domaine de C2
 313   //--  Enfin, on cherche l intervalle correspondant sur C1
 314   //--
 315
 316   Standard_Real Linf=ElCLib::Parameter(Line
 317                              ,ElCLib::CircleValue(CDomainAndRes.Binf
 318                                                  ,Circle.Axis()
 319                                                  ,Circle.Radius()));
 320   Standard_Real Lsup=ElCLib::Parameter(Line
 321                              ,ElCLib::CircleValue(CDomainAndRes.Bsup
 322                                                  ,Circle.Axis()
 323                                                  ,Circle.Radius()));
 324
 325   Interval LInter(Linf,Lsup);   //-- Necessairement Borne
 326
 327   Interval LInterAndDomain=LDomain.IntersectionWithBounded(LInter);
 328
 329   if(!LInterAndDomain.IsNull) {
 330
 331     Standard_Real DomLinf = (RefLineDomain.HasFirstPoint())? RefLineDomain.FirstParameter() : -Precision::Infinite();
 332     Standard_Real DomLsup = (RefLineDomain.HasLastPoint())? RefLineDomain.LastParameter() : Precision::Infinite();
 333
 334     Linf = LInterAndDomain.Binf;
 335     Lsup = LInterAndDomain.Bsup;
 336
 337     if(Linf<DomLinf) {
 338       Linf = DomLinf;
 339     }
 340     if(Lsup<DomLinf) {
 341       Lsup = DomLinf;
 342     }
 343
 344     if(Linf>DomLsup) {
 345       Linf = DomLsup;
 346     }
 347     if(Lsup>DomLsup) {
 348       Lsup = DomLsup;
 349     }
 350
 351     LInterAndDomain.Binf = Linf;
 352     LInterAndDomain.Bsup = Lsup;
 353
 354 #if 0
 355     Standard_Real Cinf =
 356       ElCLib::CircleParameter(Circle.Axis()
 357                               ,ElCLib::LineValue(LInterAndDomain.Binf,
 358                                         Line.Position()));
 359     Standard_Real Csup =
 360       ElCLib::CircleParameter(Circle.Axis()
 361                               ,ElCLib::LineValue(LInterAndDomain.Bsup
 362                                         ,Line.Position()));
 363
 364     if(Cinf<CDomainAndRes.Binf) Cinf = CDomainAndRes.Binf;
 365     if(Csup>CDomainAndRes.Bsup) Csup = CDomainAndRes.Bsup;
 366 #else
 367     Standard_Real Cinf=CDomainAndRes.Binf;
 368     Standard_Real Csup=CDomainAndRes.Bsup;
 369 #endif
 370     if(Cinf>=Csup) { Cinf = CDomainAndRes.Binf; Csup = CDomainAndRes.Bsup; }
 371     CircleSolution[NbSolTotal]=PeriodicInterval(Cinf,Csup);
 372     if(CircleSolution[NbSolTotal].Length() > M_PI)
 373       CircleSolution[NbSolTotal].Complement();
 374
 375     LineSolution[NbSolTotal]=LInterAndDomain;
 376     NbSolTotal++;
 377   }
 378 }
 379
 380 //=======================================================================
 381 //function : LineCircleGeometricIntersection
 382 //purpose  :
 383 //~~ On cherche des segments d intersection dans le `tuyau`
 384 //~~   R+Tol   R-Tol  ( Tol est TolConf : Tolerance de confusion d arc)
 385 //~~ On Cherche un point d intersection a une distance TolTang du cercle.
 386 //=======================================================================
 387 void LineCircleGeometricIntersection(const gp_Lin2d& Line,
 388                                      const gp_Circ2d& Circle,
 389                                      const Standard_Real Tol,
 390                                      const Standard_Real TolTang,
 391                                      PeriodicInterval& CInt1,
 392                                      PeriodicInterval& CInt2,
 393                                      Standard_Integer& nbsol)
 394 {
 395
 396
 397   Standard_Real dO1O2=Line.Distance(Circle.Location());
 398   Standard_Real R=Circle.Radius();
 399   Standard_Real RmTol=R-Tol;
 400   Standard_Real binf1,binf2=0,bsup1,bsup2=0;
 401
 402   //----------------------------------------------------------------
 403   if(dO1O2 > (R+Tol))  {  //-- pas d intersection avec le 'tuyau'
 404     if(dO1O2 > (R+TolTang)) {
 405       nbsol=0;
 406       return;
 407     }
 408     else {
 409       binf1=0.0;
 410       bsup1=0.0;
 411       nbsol=1;
 412     }
 413   }
 414   else {
 415     //----------------------------------------------------------------
 416     Standard_Boolean b2Sol;
 417     Standard_Real dAlpha1;
 418     //---------------------------------------------------------------
 419     //-- Line coupe le cercle Circle+ (=C(x1,y1,R1+Tol))
 420     b2Sol=Standard_False;
 421     if (R>dO1O2+TolTang) {
 422       Standard_Real aX2, aTol2;
 423       //
 424       aTol2=Tol*Tol;
 425       aX2=4.*(R*R-dO1O2*dO1O2);
 426       if (aX2>aTol2) {
 427         b2Sol=!b2Sol;
 428       }
 429     }
 430     if(dO1O2 > RmTol && !b2Sol) {
 431     //if(dO1O2 > RmTol) {
 432       Standard_Real dx=dO1O2;
 433       Standard_Real dy=0.0;     //(RpTol*RpTol-dx*dx); //Patch !!!
 434       dy=(dy>=0.0)? Sqrt(dy) : 0.0;
 435       dAlpha1=ATan2(dy,dx);
 436
 437       binf1=-dAlpha1;
 438       bsup1=dAlpha1;
 439       nbsol=1;
 440     }
 441     //--------------------------------------------------------------------
 442     //--           2 segments donnes par Inter Line avec Circle-  Circle+
 443     //--
 444     else {
 445       //------------------- Intersection Line Circle+ --------------------------
 446       Standard_Real dx=dO1O2;
 447       Standard_Real dy=R*R-dx*dx;    //(RpTol*RpTol-dx*dx); //Patch !!!
 448       dy=(dy>=0.0)? Sqrt(dy) : 0.0;
 449
 450       dAlpha1=ATan2(dy,dx);
 451       binf1=-dAlpha1;  bsup2=dAlpha1;  //--  |...?     ?...|   Sur C1
 452
 453       //------------------ Intersection Line Circle-  -------------------------
 454       dy=R*R-dx*dx;                  //(RmTol*RmTol-dx*dx); //Patch !!!
 455       dy=(dy>=0.0)? Sqrt(dy) : 0.0;
 456       dAlpha1=ATan2(dy,dx);
 457
 458       binf2=dAlpha1;  bsup1=-dAlpha1;  //--  |...x     x...|   Sur C1
 459
 460       if((dAlpha1*R)<(Max(Tol,TolTang))) {
 461         bsup1 = bsup2;
 462         nbsol = 1;
 463       }
 464       else {
 465         nbsol=2;
 466       }
 467     }
 468   }
 469   //--------------------------------------------------------------
 470   //-- Mise en forme des resultats :
 471   //--    Les calculs ont ete fait dans le repere x1,y1, (O1,O2)
 472   //--    On se ramene au repere propre a C1
 473
 474   Standard_Real dAngle1=(Circle.XAxis().Direction()).Angle(Line.Direction());
 475
 476 #if 0
 477   //---------------------------------------------
 478   //-- Si le cercle est indirect alors l origine
 479   //-- est vue en -dAngle1.
 480   //--
 481   if(Circle.IsDirect() == Standard_False) {
 482     dAngle1 = -dAngle1;
 483   }
 484 #endif
 485
 486
 487   Standard_Real a,b,c,d;
 488   Line.Coefficients(a,b,c);
 489
 490   d = a*Circle.Location().X() + b*Circle.Location().Y() + c;
 491
 492   if(d>0.0)  dAngle1+= PIsur2;
 493   else       dAngle1-= PIsur2;
 494
 495
 496   if(dAngle1<0.0) dAngle1+=PIpPI;
 497   else if(dAngle1>PIpPI) dAngle1-=PIpPI;
 498
 499
 500   binf1+=dAngle1;  bsup1+=dAngle1;
 501
 502   //-- par construction aucun des segments ne peut exceder PI
 503   //-- (permet de ne pas gerer trop de cas differents)
 504
 505   if(Circle.IsDirect() == Standard_False) {
 506     Standard_Real t=binf1; binf1=bsup1; bsup1=t;
 507     binf1 = -binf1;
 508     bsup1 = -bsup1;
 509   }
 510
 511
 512   CInt1.SetValues(binf1,bsup1);
 513   if(CInt1.Length() > M_PI) CInt1.Complement();
 514
 515
 516   if(nbsol==2) {
 517     binf2+=dAngle1;  bsup2+=dAngle1;
 518
 519     if(Circle.IsDirect() == Standard_False) {
 520       Standard_Real t=binf2; binf2=bsup2; bsup2=t;
 521       binf2 = -binf2;
 522       bsup2 = -bsup2;
 523     }
 524
 525     CInt2.SetValues(binf2,bsup2);
 526     if(CInt2.Length() > M_PI) CInt2.Complement();
 527   }
 528 //  Modified by Sergey KHROMOV - Thu Oct 26 17:51:05 2000 Begin
 529   else {
 530     if (CInt1.Bsup > PIpPI && CInt1.Binf < PIpPI) {
 531       nbsol = 2;
 532       binf2 = CInt1.Binf;
 533       bsup2 = PIpPI;
 534       binf1 = 0.;
 535       CInt1.SetValues(binf1,CInt1.Bsup - PIpPI);
 536       if(CInt1.Length() > M_PI) CInt1.Complement();
 537       CInt2.SetValues(binf2,bsup2);
 538       if(CInt2.Length() > M_PI) CInt2.Complement();
 539     }
 540   }
 541 //  Modified by Sergey KHROMOV - Thu Oct 26 17:51:13 2000 End
 542 }
 543 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 544 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 545 void DomainIntersection(const IntRes2d_Domain& Domain
 546                         ,const Standard_Real U1inf
 547                         ,const Standard_Real U1sup
 548                         ,Standard_Real& Res1inf
 549                         ,Standard_Real& Res1sup
 550                         ,IntRes2d_Position& PosInf
 551                         ,IntRes2d_Position& PosSup) {
 552
 553   if(Domain.HasFirstPoint()) {
 554     if(U1sup < (Domain.FirstParameter()-Domain.FirstTolerance())) {
 555       Res1inf=1; Res1sup=-1;
 556       return;
 557     }
 558     if(U1inf>(Domain.FirstParameter()+Domain.FirstTolerance())) {
 559       Res1inf=U1inf;
 560       PosInf=IntRes2d_Middle;
 561     }
 562     else {
 563       Res1inf=Domain.FirstParameter();
 564       PosInf=IntRes2d_Head;
 565     }
 566   }
 567   else {
 568     Res1inf=U1inf;
 569     PosInf=IntRes2d_Middle;
 570   }
 571
 572   if(Domain.HasLastPoint()) {
 573     if(U1inf >(Domain.LastParameter()+Domain.LastTolerance())) {
 574       Res1inf=1; Res1sup=-1;
 575       return;
 576     }
 577     if(U1sup<(Domain.LastParameter()-Domain.LastTolerance())) {
 578       Res1sup=U1sup;
 579       PosSup=IntRes2d_Middle;
 580     }
 581     else {
 582       Res1sup=Domain.LastParameter();
 583       PosSup=IntRes2d_End;
 584     }
 585   }
 586   else {
 587     Res1sup=U1sup;
 588     PosSup=IntRes2d_Middle;
 589   }
 590   //-- Si un des points est en bout ,
 591   //-- on s assure que les parametres sont corrects
 592   if(Res1inf>Res1sup) {
 593     if(PosSup==IntRes2d_Middle) {
 594       Res1sup=Res1inf;
 595     }
 596     else {
 597       Res1inf=Res1sup;
 598     }
 599   }
 600   //--- Traitement des cas ou une intersection vraie est dans la tolerance
 601   //--  d un des bouts
 602   /*if(PosInf==IntRes2d_Head) {
 603     if(Res1sup <= (Res1inf+Domain.FirstTolerance())) {
 604       Res1sup=Res1inf;
 605       PosSup=IntRes2d_Head;
 606     }
 607   }
 608   if(PosSup==IntRes2d_End) {
 609     if(Res1inf >= (Res1sup-Domain.LastTolerance())) {
 610       Res1inf=Res1sup;
 611       PosInf=IntRes2d_End;
 612     }
 613   }*/
 614 }
 615 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 616 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 617 void LineLineGeometricIntersection(const gp_Lin2d& L1
 618                                    ,const gp_Lin2d& L2
 619                                    ,const Standard_Real Tol
 620                                    ,Standard_Real& U1
 621                                    ,Standard_Real& U2
 622                                    ,Standard_Real& SinDemiAngle
 623                                    ,Standard_Integer& nbsol) {
 624
 625   Standard_Real U1x=L1.Direction().X();
 626   Standard_Real U1y=L1.Direction().Y();
 627   Standard_Real U2x=L2.Direction().X();
 628   Standard_Real U2y=L2.Direction().Y();
 629   Standard_Real Uo21x = L2.Location().X() - L1.Location().X();
 630   Standard_Real Uo21y = L2.Location().Y() - L1.Location().Y();
 631
 632   Standard_Real D=U1y*U2x-U1x*U2y;
 633
 634 //modified by NIZHNY-MKK  Tue Feb 15 10:54:04 2000.BEGIN
 635 //   if(Abs(D)<1e-15) { //-- Droites //
 636   if(Abs(D) < TOLERANCE_ANGULAIRE) {
 637 //modified by NIZHNY-MKK  Tue Feb 15 10:54:11 2000.END
 638     D=U1y*Uo21x - U1x*Uo21y;
 639     nbsol=(Abs(D)<=Tol)? 2 : 0;
 640   }
 641   else {
 642     U1=(Uo21y * U2x - Uo21x * U2y)/D;
 643     U2=(Uo21y * U1x - Uo21x * U1y)/D;
 644
 645     //------------------- Calcul du Sin du demi angle  entre L1 et L2
 646     //----
 647     if(D<0.0) D=-D;
 648     if(D>1.0) D=1.0;                      //-- Deja vu !
 649     SinDemiAngle=Sin(0.5*ASin(D));
 650     nbsol=1;
 651   }
 652 }
 653 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 654 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 655 /*IntCurve_IntConicConic::IntCurve_IntConicConic(const gp_Lin2d& L1
 656                                                ,const IntRes2d_Domain& D1
 657                                                ,const gp_Lin2d& L2
 658                                                ,const IntRes2d_Domain& D2
 659                                                ,const Standard_Real TolConf
 660                                                ,const Standard_Real Tol)  {
 661   Perform(L1,D1,L2,D2,TolConf,Tol);
 662 }
 663
 664
 665 IntCurve_IntConicConic::IntCurve_IntConicConic(const gp_Lin2d& L1
 666                                                ,const IntRes2d_Domain& D1
 667                                                ,const gp_Circ2d& C2
 668                                                ,const IntRes2d_Domain& D2
 669                                                ,const Standard_Real TolConf
 670                                                ,const Standard_Real Tol) {
 671
 672   Perform(L1,D1,C2,D2,TolConf,Tol);
 673 }
 674
 675
 676 IntCurve_IntConicConic::IntCurve_IntConicConic(const gp_Circ2d& C1
 677                                               ,const IntRes2d_Domain& D1
 678                                               ,const gp_Circ2d& C2
 679                                               ,const IntRes2d_Domain& D2
 680                                               ,const Standard_Real TolConf
 681                                               ,const Standard_Real Tol) {
 682   SetReversedParameters(Standard_False);
 683   Perform(C1,D1,C2,D2,TolConf,Tol);
 684 }*/ //amv OCC12547
 685 //----------------------------------------------------------------------
 686 void IntCurve_IntConicConic::Perform(const gp_Circ2d& Circle1
 687                                 ,const IntRes2d_Domain& DomainCirc1
 688                                 ,const gp_Circ2d& _Circle2
 689                                 ,const IntRes2d_Domain& _DomainCirc2
 690                                 ,const Standard_Real TolConf,const Standard_Real Tol) {
 691
 692
 693 //-- TRES TRES MAL FAIT    A REPRENDRE UN JOUR ....   (lbr Octobre 98)
 694   gp_Circ2d Circle2=_Circle2;
 695   IntRes2d_Domain  DomainCirc2=_DomainCirc2;
 696   Standard_Boolean IndirectCircles=Standard_False;
 697   if(Circle1.IsDirect() != _Circle2.IsDirect())
 698   {
 699     IndirectCircles=Standard_True;
 700     Circle2=_Circle2.Reversed();
 701     DomainCirc2.SetValues(_DomainCirc2.LastPoint(),
 702       PIpPI-_DomainCirc2.LastParameter(),
 703       _DomainCirc2.LastTolerance(),
 704       _DomainCirc2.FirstPoint(),
 705       PIpPI-_DomainCirc2.FirstParameter(),
 706       _DomainCirc2.FirstTolerance());
 707     DomainCirc2.SetEquivalentParameters(0.0,PIpPI);
 708   }
 709
 710   this->ResetFields();
 711   Standard_Integer nbsol=0;
 712   PeriodicInterval C1_Int1,C1_Int2;
 713
 714   //------- Intersection sans tenir compte du domaine  ----> nbsol=0,1,2,3
 715   CircleCircleGeometricIntersection(Circle1,Circle2,TolConf,Tol,C1_Int1,C1_Int2,nbsol);
 716   done=Standard_True;
 717
 718   if(nbsol==0) { //-- Pas de solutions
 719     return;
 720   }
 721
 722   PeriodicInterval C1Domain(DomainCirc1);
 723   //-- On se ramene entre 0 et 2PI
 724   Standard_Real deltat = C1Domain.Bsup-C1Domain.Binf;
 725   if(deltat>=PIpPI)
 726   {
 727     // make deltat not including the upper limit
 728     deltat=NextAfter(PIpPI, 0.);
 729   }
 730
 731   while(C1Domain.Binf >= PIpPI)
 732     C1Domain.Binf-=PIpPI;
 733   while(C1Domain.Binf <  0.0)
 734     C1Domain.Binf+=PIpPI;
 735
 736   C1Domain.Bsup=C1Domain.Binf+deltat;
 737
 738   PeriodicInterval C2Domain(DomainCirc2);
 739   deltat = C2Domain.Bsup-C2Domain.Binf;
 740   if(deltat>=PIpPI)
 741   {
 742     deltat=NextAfter(PIpPI, 0.);
 743   }
 744
 745   while(C2Domain.Binf >= PIpPI)
 746     C2Domain.Binf-=PIpPI;
 747   while(C2Domain.Binf <  0.0)
 748     C2Domain.Binf+=PIpPI;
 749
 750   C2Domain.Bsup=C2Domain.Binf+deltat;
 751
 752   Standard_Boolean IdentCircles=Standard_False;
 753
 754   if(nbsol>2)
 755   {
 756     //-- Les 2 cercles sont confondus a Tol pres
 757     C1_Int1.SetValues(0,PIpPI);
 758     C1_Int2.SetNull();
 759     //---------------------------------------------------------------
 760     //-- Flag utilise pour specifier que les intervalles manipules
 761     //--   peuvent etre de longueur superieure a pi.
 762     //-- Pour des cercles non identiques, on a necessairement cette
 763     //--   condition sur les resultats de l intersection geometrique
 764     //--   ce qui permet de normaliser rapidement les intervalles.
 765     //--   ex: -1 4 -> longueur > PI
 766     //--        donc -1 4 devient  4 , 2*pi-1
 767     //---------------------------------------------------------------
 768     IdentCircles=Standard_True;
 769   }
 770
 771   Standard_Integer NbSolTotal=0;
 772   PeriodicInterval SolutionC1[4];
 773   PeriodicInterval SolutionC2[4];
 774
 775   //----------------------------------------------------------------------
 776   //----------- Traitement du premier intervalle Geometrique  C1_Int1 ----
 777   //----------------------------------------------------------------------
 778   //-- NbSolTotal est incremente a chaque Intervalle solution.
 779   //-- On stocke les intervalles dans les tableaux : SolutionC1(C2)
 780   //-- Dimensionnes a 4 elements.
 781   //-- des Exemples faciles donnent 3 Intersections
 782   //-- des Problemes numeriques peuvent en donner 4 ??????
 783   //--
 784   PeriodicInterval C1DomainAndRes=C1Domain.FirstIntersection(C1_Int1);
 785
 786   ProjectOnC2AndIntersectWithC2Domain(Circle1,Circle2
 787                                       ,C1DomainAndRes
 788                                       ,C2Domain
 789                                       ,SolutionC1,SolutionC2
 790                                       ,NbSolTotal
 791                                       ,IdentCircles);
 792   //----------------------------------------------------------------------
 793   //-- Seconde Intersection :  Par exemple :     2*PI-1  2*PI+1
 794   //--                         Intersecte avec     0.5   2*PI-0.5
 795   //--     Donne les intervalles : 0.5,1    et  2*PI-1,2*PI-0.5
 796   //--
 797   C1DomainAndRes=C1Domain.SecondIntersection(C1_Int1);
 798
 799   ProjectOnC2AndIntersectWithC2Domain(Circle1,Circle2
 800                                       ,C1DomainAndRes
 801                                       ,C2Domain
 802                                       ,SolutionC1,SolutionC2
 803                                       ,NbSolTotal
 804                                       ,IdentCircles);
 805
 806   //----------------------------------------------------------------------
 807   //----------- Traitement du second intervalle Geometrique   C1_Int2 ----
 808   //----------------------------------------------------------------------
 809   if(nbsol==2)
 810   {
 811     C1DomainAndRes=C1Domain.FirstIntersection(C1_Int2);
 812
 813     ProjectOnC2AndIntersectWithC2Domain(Circle1,Circle2
 814                                         ,C1DomainAndRes
 815                                         ,C2Domain
 816                                         ,SolutionC1,SolutionC2
 817                                         ,NbSolTotal
 818                                         ,IdentCircles);
 819     //--------------------------------------------------------------------
 820     C1DomainAndRes=C1Domain.SecondIntersection(C1_Int2);
 821
 822     ProjectOnC2AndIntersectWithC2Domain(Circle1,Circle2
 823                                         ,C1DomainAndRes
 824                                         ,C2Domain
 825                                         ,SolutionC1,SolutionC2
 826                                         ,NbSolTotal
 827                                         ,IdentCircles);
 828   }
 829   //----------------------------------------------------------------------
 830   //-- Calcul de toutes les transitions et Positions.
 831   //--
 832   //----------------------------------------------------------------------
 833   //-- On determine si des intervalles sont reduit a des points
 834   //--      ( Rayon * Intervalle.Length()    <    Tol   )
 835   //--
 836   Standard_Real R1=Circle1.Radius();
 837   Standard_Real R2=Circle2.Radius();
 838   Standard_Real Tol2=Tol+Tol;     //---- Pour eviter de toujours retourner
 839                                   //des segments
 840   Standard_Integer i ;
 841   if(Tol < (1e-10))
 842     Tol2 = 1e-10;
 843
 844   for( i=0; i<NbSolTotal ; i++)
 845   {
 846     if(((R1 * SolutionC1[i].Length()) <=Tol2) &&
 847               ((R2 * SolutionC2[i].Length())<=Tol2))
 848     {
 849       Standard_Real t=(SolutionC1[i].Binf+SolutionC1[i].Bsup)*0.5;
 850       SolutionC1[i].Binf=SolutionC1[i].Bsup=t;
 851
 852       t=(SolutionC2[i].Binf+SolutionC2[i].Bsup)*0.5;
 853       SolutionC2[i].Binf=SolutionC2[i].Bsup=t;
 854     }
 855   }
 856
 857   //----------------------------------------------------------------------
 858   //-- Traitement des intervalles (ou des points obtenus)
 859   //--
 860   gp_Ax22d Axis2C1=Circle1.Axis();
 861   gp_Ax22d Axis2C2=Circle2.Axis();
 862   gp_Pnt2d P1a,P1b,P2a,P2b;
 863   gp_Vec2d Tan1,Tan2,Norm1,Norm2;
 864   IntRes2d_Transition T1a,T1b,T2a,T2b;
 865   IntRes2d_Position Pos1a,Pos1b,Pos2a,Pos2b;
 866
 867   Standard_Boolean Opposite =
 868     ((Circle1.Location().SquareDistance(Circle2.Location())) > (R1*R1+R2*R2)) ?
 869           Standard_True : Standard_False;
 870
 871   //if(Circle1.IsDirect()) { cout<<" C1 Direct"<<endl; } else { cout<<" C1 INDirect"<<endl; }
 872   //if(Circle2.IsDirect()) { cout<<" C2 Direct"<<endl; } else { cout<<" C2 INDirect"<<endl; }
 873
 874   for(i=0; i<NbSolTotal; i++)
 875   {
 876     Standard_Real C2inf=(Opposite)? SolutionC2[i].Bsup : SolutionC2[i].Binf;
 877     Standard_Real C2sup=(Opposite)? SolutionC2[i].Binf : SolutionC2[i].Bsup;
 878     Standard_Real C1tinf = SolutionC1[i].Binf, C2tinf = C2inf;
 879     Standard_Real C1inf=NormalizeOnCircleDomain(C1tinf,DomainCirc1);
 880                   C2inf=NormalizeOnCircleDomain(C2tinf,DomainCirc2);
 881
 882     Standard_Boolean isOutOfRange = Standard_False;
 883     if(C1inf < DomainCirc1.FirstParameter())
 884     {
 885       if(C1tinf < DomainCirc1.FirstParameter())
 886       {
 887         C1inf = DomainCirc1.FirstParameter();
 888         isOutOfRange = Standard_True;
 889       }
 890       else
 891       {
 892         C1inf = C1tinf;
 893       }
 894     }
 895
 896     if(C1inf > DomainCirc1.LastParameter())
 897     {
 898       if(C1tinf > DomainCirc1.LastParameter())
 899       {
 900         C1inf = DomainCirc1.LastParameter();
 901         isOutOfRange = Standard_True;
 902       }
 903       else
 904       {
 905         C1inf = C1tinf;
 906       }
 907     }
 908
 909     if(C2inf < DomainCirc2.FirstParameter())
 910     {
 911       if(C2tinf < DomainCirc2.FirstParameter())
 912       {
 913         C2inf = DomainCirc2.FirstParameter();
 914         isOutOfRange = Standard_True;
 915       }
 916       else
 917       {
 918         C2inf = C2tinf;
 919       }
 920     }
 921
 922     if(C2inf > DomainCirc2.LastParameter())
 923     {
 924       if(C2tinf > DomainCirc2.LastParameter())
 925       {
 926         C2inf = DomainCirc2.LastParameter();
 927         isOutOfRange = Standard_True;
 928       }
 929       else
 930       {
 931         C2inf = C2tinf;
 932       }
 933     }
 934
 935     if(isOutOfRange)
 936     {
 937       gp_Pnt2d aP1, aP2;
 938       gp_Vec2d aV11, aV12;
 939       gp_Vec2d aV21, aV22;
 940
 941       ElCLib::CircleD2(C1inf,Axis2C1,R1,aP1,aV11,aV12);
 942       ElCLib::CircleD2(C2inf,Axis2C2,R2,aP2,aV21,aV22);
 943
 944       if(aP1.SquareDistance(aP2) > Tol2*Tol2)
 945       {//there are not any solutions in given parametric range.
 946         continue;
 947       }
 948     }
 949
 950     if(IndirectCircles)
 951     {
 952       ElCLib::CircleD2(C1inf,Axis2C1,R1,P1a,Tan1,Norm1);
 953       ElCLib::CircleD2(C2inf,Axis2C2,R2,P2a,Tan2,Norm2);
 954       Tan2.Reverse();
 955
 956       IntImpParGen::DeterminePosition(Pos1a,DomainCirc1,P1a,C1inf);
 957       IntImpParGen::DeterminePosition(Pos2a,_DomainCirc2,P2a,PIpPI-C2inf);
 958       Determine_Transition_LC(Pos1a,Tan1,Norm1,T1a , Pos2a,Tan2,Norm2,T2a, Tol);
 959
 960
 961       IntRes2d_IntersectionPoint NewPoint1(P1a,C1inf,PIpPI-C2inf,T1a,T2a,Standard_False);
 962
 963       if((SolutionC1[i].Length()>0.0 ) || (SolutionC2[i].Length() >0.0))
 964       {
 965         //-- On traite un intervalle non reduit a un point
 966         Standard_Real C1sup=NormalizeOnCircleDomain(SolutionC1[i].Bsup,DomainCirc1);
 967         if(C1sup<C1inf) C1sup+=PIpPI;
 968         C2sup=NormalizeOnCircleDomain(C2sup,DomainCirc2);
 969
 970         ElCLib::CircleD2(C1sup,Axis2C1,R1,P1b,Tan1,Norm1);
 971         ElCLib::CircleD2(C2sup,Axis2C2,R2,P2b,Tan2,Norm2);
 972         Tan2.Reverse();
 973
 974         IntImpParGen::DeterminePosition(Pos1b,DomainCirc1,P1b,C1sup);
 975         IntImpParGen::DeterminePosition(Pos2b,_DomainCirc2,P2b,PIpPI-C2sup);
 976         Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
 977
 978         //--------------------------------------------------
 979
 980         if(Opposite)
 981         {
 982           if(nbsol!=3)
 983           {
 984             if(C2inf<C2sup)
 985               C2inf+=PIpPI;
 986           }
 987         }
 988         else
 989         {
 990           if(nbsol!=3)
 991           {
 992             if(C2sup<C2inf) C2sup+=PIpPI;
 993           }
 994         }
 995
 996         IntRes2d_IntersectionPoint NewPoint2(P1b,C1sup,PIpPI-C2sup,T1b,T2b,Standard_False);
 997         IntRes2d_IntersectionSegment NewSeg(NewPoint1,NewPoint2,
 998           (Opposite==Standard_True)? Standard_False : Standard_True,
 999           Standard_False);
1000         Append(NewSeg);
1001       }
1002       else
1003       {
1004         Append(NewPoint1);
1005       }
1006     }
1007     else
1008     {
1009       ElCLib::CircleD2(C1inf,Axis2C1,R1,P1a,Tan1,Norm1);
1010       ElCLib::CircleD2(C2inf,Axis2C2,R2,P2a,Tan2,Norm2);
1011
1012       IntImpParGen::DeterminePosition(Pos1a,DomainCirc1,P1a,C1inf);
1013       IntImpParGen::DeterminePosition(Pos2a,DomainCirc2,P2a,C2inf);
1014       Determine_Transition_LC(Pos1a,Tan1,Norm1,T1a , Pos2a,Tan2,Norm2,T2a, Tol);
1015
1016
1017       IntRes2d_IntersectionPoint NewPoint1(P1a,C1inf,C2inf,T1a,T2a,Standard_False);
1018
1019       if((SolutionC1[i].Length()>0.0 ) || (SolutionC2[i].Length() >0.0))
1020       {
1021         //-- On traite un intervalle non reduit a un point
1022         Standard_Real C1sup=NormalizeOnCircleDomain(SolutionC1[i].Bsup,DomainCirc1);
1023         if(C1sup<C1inf) C1sup+=PIpPI;
1024         C2sup=NormalizeOnCircleDomain(C2sup,DomainCirc2);
1025
1026         ElCLib::CircleD2(C1sup,Axis2C1,R1,P1b,Tan1,Norm1);
1027         ElCLib::CircleD2(C2sup,Axis2C2,R2,P2b,Tan2,Norm2);
1028
1029         IntImpParGen::DeterminePosition(Pos1b,DomainCirc1,P1b,C1sup);
1030         IntImpParGen::DeterminePosition(Pos2b,DomainCirc2,P2b,C2sup);
1031         Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
1032
1033         //--------------------------------------------------
1034
1035         if(Opposite)
1036         {
1037             if(C2inf<C2sup)
1038               C2inf+=PIpPI;
1039         }
1040         else
1041         {
1042             if(C2sup<C2inf)
1043               C2sup+=PIpPI;
1044         }
1045
1046         IntRes2d_IntersectionPoint NewPoint2(P1b,C1sup,C2sup,T1b,T2b,Standard_False);
1047         IntRes2d_IntersectionSegment NewSeg(NewPoint1,NewPoint2,Opposite,Standard_False);
1048         Append(NewSeg);
1049       }
1050       else
1051       {
1052         Append(NewPoint1);
1053       }
1054     }
1055   }
1056 }
1057 //----------------------------------------------------------------------
1058 IntRes2d_Position FindPositionLL(Standard_Real &Param
1059                                  ,const IntRes2d_Domain& Domain)
1060 {
1061   Standard_Real aDPar = Precision::Infinite();
1062   IntRes2d_Position aPos = IntRes2d_Middle;
1063   Standard_Real aResPar = Param;
1064   if(Domain.HasFirstPoint()) {
1065     aDPar = Abs(Param-Domain.FirstParameter());
1066     if( aDPar <= Domain.FirstTolerance()) {
1067       aResPar=Domain.FirstParameter();
1068       aPos = IntRes2d_Head;
1069
1070     }
1071   }
1072   if(Domain.HasLastPoint()) {
1073     Standard_Real aD2 = Abs(Param-Domain.LastParameter());
1074     if( aD2 <= Domain.LastTolerance() && (aPos == IntRes2d_Middle || aD2 < aDPar ))
1075     {
1076       aResPar=Domain.LastParameter();
1077       aPos = IntRes2d_End;
1078     }
1079   }
1080   Param = aResPar;
1081   return aPos;
1082 }
1083 //--------------------------------------------------------------------
1084 //gka 0022833
1085 // Method to compute of point of intersection for case
1086 //when specified domain less than specified tolerance for intersection
1087 static inline void getDomainParametrs(const IntRes2d_Domain& theDomain,
1088                                       Standard_Real& theFirst,
1089                                       Standard_Real& theLast,
1090                                       Standard_Real& theTol1,
1091                                       Standard_Real& theTol2)
1092 {
1093   theFirst = (theDomain.HasFirstPoint() ? theDomain.FirstParameter() : -Precision::Infinite());
1094   theLast = (theDomain.HasLastPoint() ? theDomain.LastParameter() : Precision::Infinite());
1095   theTol1 = (theDomain.HasFirstPoint() ? theDomain.FirstTolerance() : 0.);
1096   theTol2 = (theDomain.HasLastPoint() ? theDomain.LastTolerance() : 0.);
1097 }
1098
1099
1100 //=======================================================================
1101 //function : computeIntPoint
1102 //purpose  :
1103 //=======================================================================
1104 static Standard_Boolean computeIntPoint(const IntRes2d_Domain& theCurDomain,
1105                                         const IntRes2d_Domain& theDomainOther,
1106                                         const gp_Lin2d& theCurLin,
1107                                         const gp_Lin2d& theOtherLin,
1108                                         Standard_Real theCosT1T2,
1109                                         Standard_Real theParCur, Standard_Real theParOther,
1110                                         Standard_Real& theResInf, Standard_Real& theResSup,
1111                                         Standard_Integer theNum,
1112                                         IntRes2d_TypeTrans theCurTrans,
1113                                         IntRes2d_IntersectionPoint& theNewPoint)
1114 {
1115   if(fabs(theResSup-theParCur) > fabs(theResInf-theParCur))
1116     theResSup = theResInf;
1117
1118   Standard_Real aRes2 = theParOther + (theResSup - theParCur) * theCosT1T2;
1119
1120   Standard_Real aFirst2, aLast2, aTol21, aTol22, aTol11, aTol12 ;
1121
1122   getDomainParametrs(theDomainOther,aFirst2, aLast2, aTol21, aTol22);
1123
1124   if( aRes2  < aFirst2 - aTol21 || aRes2  > aLast2 + aTol22 ) {
1125     return Standard_False;
1126   }
1127
1128   //------ compute parameters of intersection point --
1129   IntRes2d_Transition aT1,aT2;
1130   IntRes2d_Position aPos1a = FindPositionLL(theResSup,theCurDomain);
1131   IntRes2d_Position aPos2a = FindPositionLL(aRes2,theDomainOther);
1132   IntRes2d_TypeTrans anOtherTrans = ( theCurTrans == IntRes2d_Out ?
1133       IntRes2d_In : ( theCurTrans == IntRes2d_In ? IntRes2d_Out : IntRes2d_Undecided ) );
1134
1135   if( theCurTrans != IntRes2d_Undecided )
1136   {
1137     aT1.SetValue(Standard_False, aPos1a, theCurTrans);
1138     aT2.SetValue(Standard_False,  aPos2a, anOtherTrans);
1139   }
1140   else
1141   {
1142     Standard_Boolean anOpposite = theCosT1T2 < 0.;
1143     aT1.SetValue(Standard_False,aPos1a,IntRes2d_Unknown,anOpposite);
1144     aT2.SetValue(Standard_False,aPos2a,IntRes2d_Unknown,anOpposite);
1145   }
1146   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1147   //--------------------------------------------------
1148   //gka bug 0022833
1149   Standard_Real aResU1 = theParCur;
1150   Standard_Real aResU2 = theParOther;
1151
1152   Standard_Real aFirst1, aLast1;
1153   getDomainParametrs(theCurDomain,aFirst1, aLast1, aTol11, aTol12);
1154
1155   Standard_Boolean isInside1 = (theParCur >= aFirst1 && theParCur <= aLast1);
1156   Standard_Boolean isInside2 = (theParOther >= aFirst2 && theParOther <= aLast2);
1157
1158   if(!isInside1 || !isInside2)
1159   {
1160     if(isInside1)
1161     {
1162       gp_Pnt2d Pt1=ElCLib::Value(aRes2,theOtherLin);
1163       aResU2 = aRes2;
1164       Standard_Real aPar1 = ElCLib::Parameter(theCurLin,Pt1);
1165       aResU1 =((aPar1 >= aFirst1 && aPar1<= aLast1) ?  aPar1 : theResSup);
1166
1167     }
1168     else if(isInside2)
1169     {
1170       gp_Pnt2d aPt1=ElCLib::Value(theResSup,theCurLin);
1171       aResU1 = theResSup;
1172       Standard_Real aPar2 = ElCLib::Parameter(theOtherLin,aPt1);
1173       aResU2= ((aPar2 >= aFirst2 && aPar2<= aLast2) ? aPar2 : aRes2);
1174     }
1175     else
1176     {
1177       //PKVf
1178       // check that parameters are within range on both curves
1179       if ( theParCur < aFirst1-aTol11 || theParCur > aLast1+aTol12 ||
1180            theParOther < aFirst2-aTol21 || theParOther > aLast2+aTol22) {
1181         return Standard_False;
1182       }
1183       //PKVt
1184       aResU1 = theResSup;
1185       aResU2= aRes2;
1186     }
1187   }
1188   gp_Pnt2d aPres((ElCLib::Value(aResU1,theCurLin).XY() + ElCLib::Value(aResU2,theOtherLin).XY()) * 0.5 );
1189   if(theNum == 1 )
1190     theNewPoint.SetValues(aPres, aResU1, aResU2 ,aT1, aT2, Standard_False);
1191   else
1192     theNewPoint.SetValues(aPres, aResU2, aResU1 ,aT2, aT1, Standard_False);
1193   return Standard_True;
1194 }
1195
1196 //=======================================================================
1197 //function : CheckLLCoincidence
1198 //purpose  : Returns true if input are trimmed curves and they coincide
1199 //           within tolerance
1200 //=======================================================================
1201 static Standard_Boolean CheckLLCoincidence(const gp_Lin2d& L1,
1202                                            const gp_Lin2d& L2,
1203                                            const IntRes2d_Domain& Domain1,
1204                                            const IntRes2d_Domain& Domain2,
1205                                            const Standard_Real theTol)
1206 {
1207   Standard_Boolean isFirst1 = (Domain1.HasFirstPoint() &&
1208     L2.Distance(Domain1.FirstPoint()) < theTol);
1209   Standard_Boolean isLast1 = (Domain1.HasLastPoint() &&
1210     L2.Distance(Domain1.LastPoint()) < theTol);
1211   if (isFirst1 && isLast1)
1212     return Standard_True;
1213   Standard_Boolean isFirst2 = (Domain2.HasFirstPoint() &&
1214     L1.Distance(Domain2.FirstPoint()) < theTol);
1215   Standard_Boolean isLast2 = (Domain2.HasLastPoint() &&
1216     L1.Distance(Domain2.LastPoint()) < theTol);
1217   return isFirst2 && isLast2;
1218 }
1219
1220 //----------------------------------------------------------------------
1221 void IntCurve_IntConicConic::Perform(const gp_Lin2d& L1
1222                                       ,const IntRes2d_Domain& Domain1
1223                                      ,const gp_Lin2d& L2
1224                                      ,const IntRes2d_Domain& Domain2
1225                                      ,const Standard_Real,const Standard_Real TolR) {
1226   this->ResetFields();
1227
1228   //-- Coordonnees du point d intersection sur chacune des 2 droites
1229   Standard_Real U1,U2;
1230   //-- Nombre de points solution : 1 : Intersection
1231   //--                             0 : Non Confondues
1232   //--                             2 : Confondues a la tolerance pres
1233   Standard_Integer nbsol;
1234   IntRes2d_IntersectionPoint PtSeg1,PtSeg2;
1235   Standard_Real aHalfSinL1L2;
1236   Standard_Real Tol = TolR;
1237   if(Tol < Precision::PConfusion())
1238     Tol = Precision::PConfusion();
1239
1240   LineLineGeometricIntersection(L1,L2,Tol,U1,U2,aHalfSinL1L2,nbsol);
1241
1242   gp_Vec2d Tan1=L1.Direction();
1243   gp_Vec2d Tan2=L2.Direction();
1244
1245   Standard_Real aCosT1T2 = Tan1.Dot(Tan2);
1246   Standard_Boolean Opposite=(aCosT1T2 < 0.0)? Standard_True : Standard_False;
1247
1248   done=Standard_True;
1249
1250   if(nbsol==1 && CheckLLCoincidence(L1, L2, Domain1, Domain2, Tol))
1251     nbsol = 2;
1252
1253   if(nbsol==1) {
1254     //---------------------------------------------------
1255     //-- d: distance du point I a partir de laquelle  les
1256     //--  points de parametre U1+d et U2+-d sont ecartes
1257     //--  d une distance superieure a Tol.
1258     //---------------------------------------------------
1259     IntRes2d_Position Pos1a,Pos2a,Pos1b,Pos2b;
1260     Standard_Real d = 0.5 * Tol / aHalfSinL1L2;
1261     Standard_Real U1inf=U1-d;
1262     Standard_Real U1sup=U1+d;
1263     Standard_Real U1mU2=U1-U2;
1264     Standard_Real U1pU2=U1+U2;
1265     Standard_Real Res1inf,Res1sup;
1266     Standard_Real ProdVectTan;
1267
1268
1269     //---------------------------------------------------
1270     //-- On agrandit la zone U1inf U1sup pour tenir compte
1271     //-- des tolerances des points en bout
1272     //--
1273     if(Domain1.HasFirstPoint()) {
1274       if(L2.Distance(Domain1.FirstPoint()) < Domain1.FirstTolerance()) {
1275         if(U1inf > Domain1.FirstParameter()) {
1276           U1inf = Domain1.FirstParameter();
1277         }
1278         if(U1sup < Domain1.FirstParameter()) {
1279           U1sup = Domain1.FirstParameter();
1280         }
1281       }
1282     }
1283     if(Domain1.HasLastPoint()) {
1284       if(L2.Distance(Domain1.LastPoint()) < Domain1.LastTolerance()) {
1285         if(U1inf > Domain1.LastParameter()) {
1286           U1inf = Domain1.LastParameter();
1287         }
1288         if(U1sup < Domain1.LastParameter()) {
1289           U1sup = Domain1.LastParameter();
1290         }
1291       }
1292     }
1293     if(Domain2.HasFirstPoint()) {
1294       if(L1.Distance(Domain2.FirstPoint()) < Domain2.FirstTolerance()) {
1295         Standard_Real p = ElCLib::Parameter(L1,Domain2.FirstPoint());
1296         if(U1inf > p) {
1297           U1inf = p;
1298         }
1299         if(U1sup < p) {
1300           U1sup = p;
1301         }
1302       }
1303     }
1304     if(Domain2.HasLastPoint()) {
1305       if(L1.Distance(Domain2.LastPoint()) < Domain2.LastTolerance()) {
1306         Standard_Real p = ElCLib::Parameter(L1,Domain2.LastPoint());
1307         if(U1inf > p) {
1308           U1inf = p;
1309         }
1310         if(U1sup < p) {
1311           U1sup = p;
1312         }
1313       }
1314     }
1315     //-----------------------------------------------------------------
1316
1317     DomainIntersection(Domain1,U1inf,U1sup,Res1inf,Res1sup,Pos1a,Pos1b);
1318
1319     if((Res1sup-Res1inf)<0.0) {
1320       //-- Si l intersection est vide
1321       //--
1322     }
1323     else { //-- (Domain1  INTER   Zone Intersection)    non vide
1324
1325       ProdVectTan=Tan1.Crossed(Tan2);
1326
1327       //#####################################################################
1328       //##  Longueur Minimale d un segment    Sur Courbe 1
1329       //#####################################################################
1330
1331       Standard_Real LongMiniSeg=Tol;
1332
1333
1334       if(((Res1sup-Res1inf)<=LongMiniSeg)
1335         || ((Pos1a==Pos1b)&&(Pos1a!=IntRes2d_Middle)))
1336       {
1337         //-------------------------------  Un seul Point -------------------
1338         //--- lorsque la longueur du segment est inferieure a ??
1339         //--- ou si deux points designent le meme bout
1340         //gka #0022833
1341         IntRes2d_TypeTrans aCurTrans = ( ProdVectTan >= TOLERANCE_ANGULAIRE ?
1342              IntRes2d_Out : ( ProdVectTan <= -TOLERANCE_ANGULAIRE ? IntRes2d_In : IntRes2d_Undecided ) );
1343
1344         IntRes2d_IntersectionPoint NewPoint1;
1345         if( computeIntPoint(Domain1, Domain2, L1, L2, aCosT1T2, U1, U2, Res1inf, Res1sup, 1, aCurTrans, NewPoint1 ) )
1346           Append(NewPoint1);
1347
1348         //------------------------------------------------------
1349
1350
1351       }  //---------------   Fin du cas  :   1 seul point --------------------
1352
1353       else {
1354         //-- Intersection AND Domain1  --------> Segment ---------------------
1355         Standard_Real U2inf,U2sup;
1356         Standard_Real Res2inf,Res2sup;
1357
1358         if(Opposite) { U2inf = U1pU2 -Res1sup;  U2sup= U1pU2-Res1inf;  }
1359         else         { U2inf = Res1inf-U1mU2;   U2sup= Res1sup-U1mU2;  }
1360
1361         DomainIntersection(Domain2,U2inf,U2sup,Res2inf,Res2sup,Pos2a,Pos2b);
1362
1363         //####################################################################
1364         //##  Test sur la longueur minimale d un segment sur Ligne2
1365         //####################################################################
1366         Standard_Real Res2sup_m_Res2inf = Res2sup-Res2inf;
1367         if(Res2sup_m_Res2inf < 0.0) {
1368           //-- Pas de solutions On retourne Vide
1369         }
1370         else if((Res2sup_m_Res2inf > LongMiniSeg)
1371                 || ((Pos2a==Pos2b)&&(Pos2a!=IntRes2d_Middle)))     {
1372           //----------- Calcul des attributs du segment --------------
1373           //-- Attention, les bornes Res1inf(sup) bougent donc il faut
1374           //--  eventuellement recalculer les attributs
1375
1376           if(Opposite) { Res1inf=U1pU2-Res2sup; Res1sup=U1pU2-Res2inf;
1377                          Standard_Real Tampon=Res2inf; Res2inf=Res2sup; Res2sup=Tampon;
1378                          IntRes2d_Position Pos=Pos2a; Pos2a=Pos2b; Pos2b=Pos;
1379                        }
1380           else         { Res1inf=U1mU2+Res2inf; Res1sup=U1mU2+Res2sup; }
1381
1382           Pos1a=FindPositionLL(Res1inf,Domain1);
1383           Pos1b=FindPositionLL(Res1sup,Domain1);
1384
1385           IntRes2d_Transition T1a,T2a,T1b,T2b;
1386
1387           if(ProdVectTan>=TOLERANCE_ANGULAIRE) {  // &&&&&&&&&&&&&&&
1388             T1a.SetValue(Standard_False,Pos1a,IntRes2d_Out);
1389             T2a.SetValue(Standard_False,Pos2a,IntRes2d_In);
1390           }
1391           else if(ProdVectTan<=-TOLERANCE_ANGULAIRE) {
1392             T1a.SetValue(Standard_False,Pos1a,IntRes2d_In);
1393             T2a.SetValue(Standard_False,Pos2a,IntRes2d_Out);
1394           }
1395           else {
1396             T1a.SetValue(Standard_False,Pos1a,IntRes2d_Unknown,Opposite);
1397             T2a.SetValue(Standard_False,Pos2a,IntRes2d_Unknown,Opposite);
1398           }
1399
1400
1401           //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1402           //~~~~~~~  C O N V E N T I O N    -    S E G M E N T     ~~~~~~~
1403           //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1404           //~~ On Renvoie un segment dans les cas suivants :            ~~
1405           //~~   (1) Extremite L1 L2   ------>    Extremite L1 L2       ~~
1406           //~~   (2) Extremite L1 L2   ------>    Intersection          ~~
1407           //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1408
1409           Standard_Boolean ResultIsAPoint=Standard_False;
1410
1411           if(((Res1sup-Res1inf)<=LongMiniSeg)
1412              || (Abs(Res2sup-Res2inf)<=LongMiniSeg)) {
1413             //-- On force la creation d un point
1414             ResultIsAPoint=Standard_True;
1415           }
1416           else {
1417             //------------------------------------------------------------
1418             //-- On traite les cas ou l intersection est situee du
1419             //-- Mauvais cote du domaine
1420             //-- Attention : Res2inf <-> Pos2a        Res2sup <-> Pos2b
1421             //--  et         Res1inf <-> Pos1a        Res1sup <-> Pos1b
1422             //--             avec Res1inf <= Res1sup
1423             //------------------------------------------------------------
1424             //-- Le point sera : Res1inf,Res2inf,T1a(Pos1a),T2a(Pos2a)
1425             //------------------------------------------------------------
1426
1427             if(Pos1a==IntRes2d_Head) {
1428               if(Pos1b!=IntRes2d_End && U1<Res1inf)    { ResultIsAPoint=Standard_True; U1=Res1inf; U2=Res2inf; }
1429             }
1430             if(Pos1b==IntRes2d_End)  {
1431               if(Pos1a!=IntRes2d_Head && U1>Res1sup)   { ResultIsAPoint=Standard_True; U1=Res1sup; U2=Res2sup; }
1432             }
1433
1434             if(Pos2a==IntRes2d_Head) {
1435               if(Pos2b!=IntRes2d_End && U2<Res2inf)    { ResultIsAPoint=Standard_True; U2=Res2inf; U1=Res1inf; }
1436             }
1437             else {
1438               if(Pos2a==IntRes2d_End)  {
1439                 if(Pos2b!=IntRes2d_Head && U2>Res2inf) { ResultIsAPoint=Standard_True; U2=Res2inf; U1=Res1inf; }
1440               }
1441             }
1442             if(Pos2b==IntRes2d_Head) {
1443               if(Pos2a!=IntRes2d_End && U2<Res2sup)    { ResultIsAPoint=Standard_True; U2=Res2sup; U1=Res1sup; }
1444             }
1445             else {
1446               if(Pos2b==IntRes2d_End) {
1447                 if(Pos2a!=IntRes2d_Head && U2>Res2sup) { ResultIsAPoint=Standard_True; U2=Res2sup; U1=Res1sup; }
1448               }
1449             }
1450           }
1451
1452
1453
1454           if((!ResultIsAPoint) && (Pos1a!=IntRes2d_Middle || Pos2a!=IntRes2d_Middle)) {
1455             if(ProdVectTan>=TOLERANCE_ANGULAIRE) { //&&&&&&&&&&&&&&
1456               T1b.SetValue(Standard_False,Pos1b,IntRes2d_Out);
1457               T2b.SetValue(Standard_False,Pos2b,IntRes2d_In);
1458             }
1459             else if(ProdVectTan<=-TOLERANCE_ANGULAIRE) { //&&&&&&&&&&&&&&
1460               T1b.SetValue(Standard_False,Pos1b,IntRes2d_In);
1461               T2b.SetValue(Standard_False,Pos2b,IntRes2d_Out);
1462             }
1463             else {
1464               T1b.SetValue(Standard_False,Pos1b,IntRes2d_Unknown,Opposite);
1465               T2b.SetValue(Standard_False,Pos2b,IntRes2d_Unknown,Opposite);
1466             }
1467             gp_Pnt2d Ptdebut;
1468             if(Pos1a==IntRes2d_Middle) {
1469               Standard_Real t3;
1470               if(Opposite) {
1471                 t3 = (Pos2a == IntRes2d_Head)? Res2sup : Res2inf;
1472               }
1473               else {
1474                 t3 = (Pos2a == IntRes2d_Head)? Res2inf : Res2sup;
1475               }
1476               Ptdebut=ElCLib::Value(t3,L2);
1477               Res1inf=ElCLib::Parameter(L1,Ptdebut);
1478             }
1479             else {
1480               Standard_Real t4 = (Pos1a == IntRes2d_Head)? Res1inf : Res1sup;
1481               Ptdebut=ElCLib::Value(t4,L1);
1482               Res2inf=ElCLib::Parameter(L2,Ptdebut);
1483             }
1484             PtSeg1.SetValues(Ptdebut,Res1inf,Res2inf,T1a,T2a,Standard_False);
1485             if(Pos1b!=IntRes2d_Middle || Pos2b!=IntRes2d_Middle) {
1486               //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1487               //~~ Ajustement des parametres et du point renvoye
1488               gp_Pnt2d Ptfin;
1489               if(Pos1b==IntRes2d_Middle) {
1490                 Ptfin=ElCLib::Value(Res2sup,L2);
1491                 Res1sup=ElCLib::Parameter(L1,Ptfin);
1492               }
1493               else {
1494                 Ptfin=ElCLib::Value(Res1sup,L1);
1495                 Res2sup=ElCLib::Parameter(L2,Ptfin);
1496               }
1497               PtSeg2.SetValues(Ptfin,Res1sup,Res2sup,T1b,T2b,Standard_False);
1498               IntRes2d_IntersectionSegment Segment(PtSeg1,PtSeg2
1499                                                    ,Opposite,Standard_False);
1500               Append(Segment);
1501             }
1502             else { //-- Extremite(L1 ou L2)  ------>   Point Middle(L1 et L2)
1503
1504               Pos1b=FindPositionLL(U1,Domain1);
1505               Pos2b=FindPositionLL(U2,Domain2);
1506               if(ProdVectTan>=TOLERANCE_ANGULAIRE) {
1507                 T1b.SetValue(Standard_False,Pos1b,IntRes2d_Out);
1508                 T2b.SetValue(Standard_False,Pos2b,IntRes2d_In);
1509               }
1510               else if(ProdVectTan<=-TOLERANCE_ANGULAIRE) {
1511                 T1b.SetValue(Standard_False,Pos1b,IntRes2d_In);
1512                 T2b.SetValue(Standard_False,Pos2b,IntRes2d_Out);
1513               }
1514               else {
1515                 T1b.SetValue(Standard_False,Pos1b,IntRes2d_Unknown,Opposite);
1516                 T2b.SetValue(Standard_False,Pos2b,IntRes2d_Unknown,Opposite);
1517               }
1518
1519               PtSeg2.SetValues(ElCLib::Value(U2,L2),U1,U2,T1b,T2b,Standard_False);
1520
1521               if((Abs(Res1inf-U1) >LongMiniSeg) && (Abs(Res2inf-U2) >LongMiniSeg)) {
1522                 IntRes2d_IntersectionSegment Segment(PtSeg1,PtSeg2,Opposite,Standard_False);
1523                 Append(Segment);
1524               }
1525               else {
1526                 Append(SegmentToPoint(PtSeg1,T1a,T2a,PtSeg2,T1b,T2b));
1527               }
1528             }
1529
1530           } //-- (Pos1a!=IntRes2d_Middle || Pos2a!=IntRes2d_Middle) --
1531           else {  //-- Pos1a == Pos2a == Middle
1532             if(Pos1b==IntRes2d_Middle) Pos1b=Pos1a;
1533             if(Pos2b==IntRes2d_Middle) Pos2b=Pos2a;
1534             if(ResultIsAPoint) {
1535               //-- Middle sur le segment A
1536               //--
1537               if(Pos1b!=IntRes2d_Middle || Pos2b!=IntRes2d_Middle) {
1538                 gp_Pnt2d Ptfin;
1539                 if(Pos1b==IntRes2d_Middle) {
1540                   Standard_Real t2;
1541                   if(Opposite) {
1542                     t2 = (Pos2b == IntRes2d_Head)? Res2sup : Res2inf;
1543                   }
1544                   else {
1545                     t2 = (Pos2b == IntRes2d_Head)? Res2inf : Res2sup;
1546                   }
1547                   Ptfin=ElCLib::Value(t2,L2);
1548                   Res1sup=ElCLib::Parameter(L1,Ptfin);
1549 //modified by NIZHNY-MKK  Tue Feb 15 10:54:51 2000.BEGIN
1550                   Pos1b=FindPositionLL(Res1sup,Domain1);
1551 //modified by NIZHNY-MKK  Tue Feb 15 10:54:55 2000.END
1552
1553                 }
1554                 else {
1555                   Standard_Real t1 = (Pos1b == IntRes2d_Head)? Res1inf : Res1sup;
1556                   Ptfin=ElCLib::Value(t1,L1);
1557                   Res2sup=ElCLib::Parameter(L2,Ptfin);
1558 //modified by NIZHNY-MKK  Tue Feb 15 10:55:08 2000.BEGIN
1559                   Pos2b=FindPositionLL(Res2sup,Domain2);
1560 //modified by NIZHNY-MKK  Tue Feb 15 10:55:11 2000.END
1561                 }
1562                 if(ProdVectTan>=TOLERANCE_ANGULAIRE) {
1563                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_Out);
1564                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_In);
1565                 }
1566                 else if(ProdVectTan<=-TOLERANCE_ANGULAIRE) {
1567                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_In);
1568                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_Out);
1569                 }
1570                 else {
1571                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_Unknown,Opposite);
1572                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_Unknown,Opposite);
1573                 }
1574                 PtSeg2.SetValues(Ptfin,Res1sup,Res2sup,T1b,T2b,Standard_False);
1575                 Append(PtSeg2);
1576               }
1577               else {
1578                 Pos1b=FindPositionLL(U1,Domain1);
1579                 Pos2b=FindPositionLL(U2,Domain2);
1580
1581                 if(ProdVectTan>=TOLERANCE_ANGULAIRE) {
1582                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_Out);
1583                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_In);
1584                 }
1585                 else if(ProdVectTan<=-TOLERANCE_ANGULAIRE) {
1586                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_In);
1587                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_Out);
1588                 }
1589                 else {
1590                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_Unknown,Opposite);
1591                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_Unknown,Opposite);
1592                 }
1593                 PtSeg1.SetValues(ElCLib::Value(U2,L2),U1,U2,T1b,T2b,Standard_False);
1594                 Append(PtSeg1);
1595               }
1596             }
1597             else {
1598               PtSeg1.SetValues(ElCLib::Value(U2,L2),U1,U2,T1a,T2a,Standard_False);
1599
1600               if((Pos1b!=IntRes2d_Middle || Pos2b!=IntRes2d_Middle)) {
1601                 if(ProdVectTan>=TOLERANCE_ANGULAIRE) {
1602                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_Out);
1603                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_In);
1604                 }
1605                 else if(ProdVectTan<=-TOLERANCE_ANGULAIRE) {
1606                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_In);
1607                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_Out);
1608                 }
1609                 else {
1610                   T1b.SetValue(Standard_False,Pos1b,IntRes2d_Unknown,Opposite);
1611                   T2b.SetValue(Standard_False,Pos2b,IntRes2d_Unknown,Opposite);
1612                 }
1613                 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1614                 //~~ Ajustement des parametres et du point renvoye
1615                 gp_Pnt2d Ptfin;
1616                 if(Pos1b==IntRes2d_Middle) {
1617                   Ptfin=ElCLib::Value(Res2sup,L2);
1618                   Res1sup=ElCLib::Parameter(L1,Ptfin);
1619                 }
1620                 else {
1621                   Ptfin=ElCLib::Value(Res1sup,L1);
1622                   Res2sup=ElCLib::Parameter(L2,Ptfin);
1623                 }
1624
1625                 PtSeg2.SetValues(Ptfin,Res1sup,Res2sup,T1b,T2b,Standard_False);
1626
1627                 if((Abs(U1-Res1sup)>LongMiniSeg)
1628                    ||(Abs(U2-Res2sup)>LongMiniSeg)) {
1629                   //-- Modif du 1er Octobre 92 (Pour Composites)
1630
1631                   IntRes2d_IntersectionSegment Segment(PtSeg1,PtSeg2
1632                                                        ,Opposite,Standard_False);
1633                   Append(Segment);
1634                 }
1635                 else {
1636                   Append(SegmentToPoint(PtSeg1,T1a,T2a,PtSeg2,T1b,T2b));
1637                 }
1638               }
1639               else {
1640                 Append(PtSeg1);
1641               }
1642             }
1643           }
1644         } //----- Fin Creation Segment ----(Res2sup-Res2inf>Tol)-------------
1645         else {
1646           //------ (Intersection And Domain1)  AND  Domain2  --> Point ------
1647           //-- Attention Res1sup peut etre  different de  U2
1648           //--   Mais on a Res1sup-Res1inf < Tol
1649
1650           //gka #0022833
1651     IntRes2d_TypeTrans aCurTrans = ( ProdVectTan >= TOLERANCE_ANGULAIRE ?
1652            IntRes2d_In : ( ProdVectTan <= -TOLERANCE_ANGULAIRE ? IntRes2d_Out : IntRes2d_Undecided ) );
1653
1654           IntRes2d_IntersectionPoint NewPoint1;
1655     if( computeIntPoint(Domain2, Domain1, L2, L1, aCosT1T2, U2, U1, Res2inf, Res2sup, 2, aCurTrans, NewPoint1 ) )
1656             Append(NewPoint1);
1657
1658         }
1659       }
1660     }
1661
1662 //#ifdef OCCT_DEBUG
1663 //  if (NbPoints() || NbSegments())
1664 //  {
1665 //    static int cnt = 0; cnt++;
1666 //
1667 //    printf("line l1_%03d %.15g %.15g %.15g %.15g\n", cnt, L1.Location().X(), L1.Location().Y(), L1.Direction().X(), L1.Direction().Y());
1668 //
1669 //    if (Domain1.HasFirstPoint() && Domain1.HasLastPoint())
1670 //      printf("trim l1_%03d l1_%03d %.15g %.15g\n", cnt, cnt, Domain1.FirstParameter(), Domain1.LastParameter());
1671 //
1672 //    printf("line l2_%03d %.15g %.15g %.15g %.15g\n", cnt, L2.Location().X(), L2.Location().Y(), L2.Direction().X(), L2.Direction().Y());
1673 //
1674 //    if (Domain2.HasFirstPoint() && Domain2.HasLastPoint())
1675 //      printf("trim l2_%03d l2_%03d %.15g %.15g\n", cnt, cnt, Domain2.FirstParameter(), Domain2.LastParameter());
1676 //
1677 //    for (int i=1; i <= NbPoints(); i++)
1678 //      printf("point p%d_%03d %.15g %.15g\n", i, cnt, Point(i).Value().X(), Point(i).Value().Y());
1679 //
1680 //    for (int i=1; i <= NbSegments(); i++)
1681 //      printf("point s1_%d_%03d %.15g %.15g; point s2_%d_%03d %.15g %.15g\n", i, cnt, Segment(i).FirstPoint().Value().X(), Segment(i).FirstPoint().Value().Y(), i, cnt, Segment(i).LastPoint().Value().X(), Segment(i).LastPoint().Value().Y());
1682 //  }
1683 //#endif
1684
1685   }
1686   else {
1687     if(nbsol==2) {  //== Droites confondues a la tolerance pres
1688       //--On traite ici le cas de segments resultats non neccess. bornes
1689       //--
1690       //--On prend la droite D1 comme reference ( pour le sens positif )
1691       //--
1692       Standard_Integer ResHasFirstPoint=0;
1693       Standard_Integer ResHasLastPoint=0;
1694       Standard_Real ParamStart = 0.,ParamStart2,ParamEnd = 0.,ParamEnd2;
1695       Standard_Real Org2SurL1=ElCLib::Parameter(L1,L2.Location());
1696       //== 3 : L1 et L2 bornent
1697       //== 2 :       L2 borne
1698       //== 1 : L1 borne
1699       if(Domain1.HasFirstPoint()) ResHasFirstPoint=1;
1700       if(Domain1.HasLastPoint())   ResHasLastPoint=1;
1701       if(Opposite) {
1702         if(Domain2.HasLastPoint())     ResHasFirstPoint+=2;
1703         if(Domain2.HasFirstPoint())   ResHasLastPoint+=2;
1704       }
1705       else {
1706         if(Domain2.HasLastPoint())     ResHasLastPoint+=2;
1707         if(Domain2.HasFirstPoint())   ResHasFirstPoint+=2;
1708       }
1709       if(ResHasFirstPoint==0 && ResHasLastPoint==0) {
1710         //~~~~ Creation d un segment infini avec Opposite
1711         Append(IntRes2d_IntersectionSegment(Opposite));
1712       }
1713       else {  //-- On obtient au pire une demi-droite
1714         switch(ResHasFirstPoint) {
1715         case 1:
1716           ParamStart=Domain1.FirstParameter();
1717           ParamStart2=(Opposite)? (Org2SurL1-ParamStart)
1718                                  :(ParamStart-Org2SurL1);
1719           break;
1720         case 2:
1721           if(Opposite) {
1722             ParamStart2=Domain2.LastParameter();
1723             ParamStart=Org2SurL1 - ParamStart2;
1724           }
1725           else {
1726             ParamStart2=Domain2.FirstParameter();
1727             ParamStart=Org2SurL1 + ParamStart2;
1728           }
1729           break;
1730         case 3:
1731           if(Opposite) {
1732             ParamStart2=Domain2.LastParameter();
1733             ParamStart=Org2SurL1 - ParamStart2;
1734             if(ParamStart < Domain1.FirstParameter()) {
1735               ParamStart=Domain1.FirstParameter();
1736               ParamStart2=Org2SurL1 -  ParamStart;
1737             }
1738           }
1739           else {
1740             ParamStart2=Domain2.FirstParameter();
1741             ParamStart=Org2SurL1 + ParamStart2;
1742             if(ParamStart < Domain1.FirstParameter()) {
1743               ParamStart=Domain1.FirstParameter();
1744               ParamStart2=ParamStart - Org2SurL1;
1745             }
1746           }
1747           break;
1748         default:  //~~~ Segment Infini a gauche
1749           break;
1750         }
1751
1752         switch(ResHasLastPoint) {
1753         case 1:
1754           ParamEnd=Domain1.LastParameter();
1755           ParamEnd2=(Opposite)? (Org2SurL1-ParamEnd)
1756                                  :(ParamEnd-Org2SurL1);
1757           break;
1758         case 2:
1759           if(Opposite) {
1760             ParamEnd2=Domain2.FirstParameter();
1761             ParamEnd=Org2SurL1 - ParamEnd2;
1762           }
1763           else {
1764             ParamEnd2=Domain2.LastParameter();
1765             ParamEnd=Org2SurL1 + ParamEnd2;
1766           }
1767           break;
1768         case 3:
1769           if(Opposite) {
1770             ParamEnd2=Domain2.FirstParameter();
1771             ParamEnd=Org2SurL1 - ParamEnd2;
1772             if(ParamEnd > Domain1.LastParameter()) {
1773               ParamEnd=Domain1.LastParameter();
1774               ParamEnd2=Org2SurL1 -  ParamEnd;
1775             }
1776           }
1777           else {
1778             ParamEnd2=Domain2.LastParameter();
1779             ParamEnd=Org2SurL1 + ParamEnd2;
1780             if(ParamEnd > Domain1.LastParameter()) {
1781               ParamEnd=Domain1.LastParameter();
1782               ParamEnd2=ParamEnd - Org2SurL1;
1783             }
1784           }
1785         default:  //~~~ Segment Infini a droite
1786           break;
1787         }
1788
1789         IntRes2d_Transition Tinf,Tsup;
1790
1791         if(ResHasFirstPoint) {
1792           if(ResHasLastPoint) {
1793             //~~~ Creation de la borne superieure
1794             //~~~ L1 :     |------------->       ou          |-------------->
1795             //~~~ L2 : <------------|            ou  <----|
1796             if(ParamEnd >= (ParamStart-Tol)) {
1797               //~~~ Creation d un segment
1798               IntRes2d_Position Pos1,Pos2;
1799               Pos1=FindPositionLL(ParamStart,Domain1);
1800               Pos2=FindPositionLL(ParamStart2,Domain2);
1801               Tinf.SetValue(Standard_True,Pos1,IntRes2d_Unknown,Opposite);
1802               Tsup.SetValue(Standard_True,Pos2,IntRes2d_Unknown,Opposite);
1803               IntRes2d_IntersectionPoint P1(ElCLib::Value(ParamStart,L1)
1804                                             ,ParamStart,ParamStart2
1805                                             ,Tinf,Tsup,Standard_False);
1806               if(ParamEnd > (ParamStart+Tol)) {
1807                 //~~~ Le segment est assez long
1808                 Pos1=FindPositionLL(ParamEnd,Domain1);
1809                 Pos2=FindPositionLL(ParamEnd2,Domain2);
1810                 Tinf.SetValue(Standard_True,Pos1,IntRes2d_Unknown,Opposite);
1811                 Tsup.SetValue(Standard_True,Pos2,IntRes2d_Unknown,Opposite);
1812
1813                 IntRes2d_IntersectionPoint P2(ElCLib::Value(ParamEnd,L1)
1814                                               ,ParamEnd,ParamEnd2
1815                                               ,Tinf,Tsup,Standard_False);
1816                 IntRes2d_IntersectionSegment Seg(P1,P2,Opposite,Standard_False);
1817                 Append(Seg);
1818               }
1819               else {   //~~~~ le segment est de longueur inferieure a Tol
1820                 Append(P1);
1821               }
1822             } //-- if( ParamEnd >= ...)
1823           }   //-- if(ResHasLastPoint)
1824           else {
1825             //~~~ Creation de la demi droite   |----------->
1826             IntRes2d_Position Pos1=FindPositionLL(ParamStart,Domain1);
1827             IntRes2d_Position Pos2=FindPositionLL(ParamStart2,Domain2);
1828             Tinf.SetValue(Standard_True,Pos1,IntRes2d_Unknown,Opposite);
1829             Tsup.SetValue(Standard_True,Pos2,IntRes2d_Unknown,Opposite);
1830
1831             IntRes2d_IntersectionPoint P(ElCLib::Value(ParamStart,L1)
1832                                           ,ParamStart,ParamStart2
1833                                           ,Tinf,Tsup,Standard_False);
1834             IntRes2d_IntersectionSegment Seg(P,Standard_True,Opposite,Standard_False);
1835             Append(Seg);
1836           }
1837         }
1838         else {
1839           IntRes2d_Position Pos1=FindPositionLL(ParamEnd,Domain1);
1840           IntRes2d_Position Pos2=FindPositionLL(ParamEnd2,Domain2);
1841           Tinf.SetValue(Standard_True,Pos1,IntRes2d_Unknown,Opposite);
1842           Tsup.SetValue(Standard_True,Pos2,IntRes2d_Unknown,Opposite);
1843
1844           IntRes2d_IntersectionPoint P2(ElCLib::Value(ParamEnd,L1)
1845                                         ,ParamEnd,ParamEnd2
1846                                         ,Tinf,Tsup,Standard_False);
1847           IntRes2d_IntersectionSegment Seg(P2,Standard_False,Opposite,Standard_False);
1848           Append(Seg);
1849           //~~~ Creation de la demi droite   <-----------|
1850         }
1851       }
1852     }
1853   }
1854 }
1855
1856
1857 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1858 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1859 void IntCurve_IntConicConic::Perform(const gp_Lin2d& Line
1860                                      ,const IntRes2d_Domain& LIG_Domain
1861                                      ,const gp_Circ2d& Circle
1862                                      ,const IntRes2d_Domain& CIRC_Domain
1863                                      ,const Standard_Real TolConf,const Standard_Real Tol) {
1864
1865 //--  if(! CIRC_Domain.IsClosed()) {
1866 //--    throw Standard_ConstructionError("Domaine incorrect");
1867 //--  }
1868
1869   Standard_Boolean TheReversedParameters=ReversedParameters();
1870   this->ResetFields();
1871   this->SetReversedParameters(TheReversedParameters);
1872
1873   Standard_Integer nbsol=0;
1874   PeriodicInterval CInt1,CInt2;
1875
1876   LineCircleGeometricIntersection(Line,Circle,TolConf,Tol
1877                                   ,CInt1,CInt2
1878                                   ,nbsol);
1879
1880   done=Standard_True;
1881
1882   if(nbsol==0) { //-- Pas de solutions
1883     return;
1884   }
1885
1886 //  Modified by Sergey KHROMOV - Mon Dec 18 11:13:18 2000 Begin
1887   if (nbsol == 2 && CInt2.Bsup == CInt1.Binf + PIpPI) {
1888     Standard_Real FirstBound = CIRC_Domain.FirstParameter();
1889     Standard_Real LastBound = CIRC_Domain.LastParameter();
1890     Standard_Real FirstTol = CIRC_Domain.FirstTolerance();
1891     Standard_Real LastTol = CIRC_Domain.LastTolerance();
1892     if (CInt1.Binf == 0 && FirstBound - FirstTol > CInt1.Bsup) {
1893       nbsol = 1;
1894       CInt1.SetValues(CInt2.Binf, CInt2.Bsup);
1895     } else if (CInt2.Bsup == PIpPI && LastBound + LastTol < CInt2.Binf)
1896       nbsol = 1;
1897   }
1898 //  Modified by Sergey KHROMOV - Mon Dec 18 11:13:20 2000 End
1899
1900   PeriodicInterval CDomain(CIRC_Domain);
1901   Standard_Real deltat = CDomain.Bsup-CDomain.Binf;
1902   while(CDomain.Binf >= PIpPI) CDomain.Binf-=PIpPI;
1903   while(CDomain.Binf <  0.0)   CDomain.Binf+=PIpPI;
1904   CDomain.Bsup=CDomain.Binf+deltat;
1905
1906   //------------------------------------------------------------
1907   //-- Ajout : Jeudi 28 mars 96
1908   //-- On agrandit artificiellement les domaines
1909   Standard_Real BinfModif = CDomain.Binf;
1910   Standard_Real BsupModif = CDomain.Bsup;
1911   BinfModif-=CIRC_Domain.FirstTolerance() / Circle.Radius();
1912   BsupModif+=CIRC_Domain.LastTolerance() / Circle.Radius();
1913   deltat = BsupModif-BinfModif;
1914   if(deltat<=PIpPI) {
1915     CDomain.Binf = BinfModif;
1916     CDomain.Bsup = BsupModif;
1917   }
1918   else {
1919     Standard_Real t=PIpPI-deltat;
1920     t*=0.5;
1921     CDomain.Binf = BinfModif+t;
1922     CDomain.Bsup = BsupModif-t;
1923   }
1924   deltat = CDomain.Bsup-CDomain.Binf;
1925   while(CDomain.Binf >= PIpPI) CDomain.Binf-=PIpPI;
1926   while(CDomain.Binf <  0.0)   CDomain.Binf+=PIpPI;
1927   CDomain.Bsup=CDomain.Binf+deltat;
1928   //-- ------------------------------------------------------------
1929
1930   Interval LDomain(LIG_Domain);
1931
1932   Standard_Integer NbSolTotal=0;
1933
1934   PeriodicInterval SolutionCircle[4];
1935   Interval SolutionLine[4];
1936
1937   //----------------------------------------------------------------------
1938   //----------- Traitement du premier intervalle Geometrique  CInt1   ----
1939   //----------------------------------------------------------------------
1940   //-- NbSolTotal est incremente a chaque Intervalle solution.
1941   //-- On stocke les intervalles dans les tableaux : SolutionCircle[4]
1942   //--                                            et SolutionLine[4]
1943   //-- des Exemples faciles donnent 3 Intersections
1944   //-- des Problemes numeriques peuvent peut etre en donner 4 ??????
1945   //--
1946   PeriodicInterval CDomainAndRes=CDomain.FirstIntersection(CInt1);
1947
1948   ProjectOnLAndIntersectWithLDomain(Circle,Line
1949                                     ,CDomainAndRes
1950                                     ,LDomain
1951                                     ,SolutionCircle
1952                                     ,SolutionLine
1953                                     ,NbSolTotal
1954                                     ,LIG_Domain
1955                                     ,CIRC_Domain);
1956
1957   CDomainAndRes=CDomain.SecondIntersection(CInt1);
1958
1959   ProjectOnLAndIntersectWithLDomain(Circle,Line
1960                                     ,CDomainAndRes
1961                                     ,LDomain
1962                                     ,SolutionCircle
1963                                     ,SolutionLine
1964                                     ,NbSolTotal
1965                                     ,LIG_Domain
1966                                     ,CIRC_Domain);
1967
1968   //----------------------------------------------------------------------
1969   //----------- Traitement du second intervalle Geometrique   C1_Int2 ----
1970   //----------------------------------------------------------------------
1971   if(nbsol==2) {
1972     CDomainAndRes=CDomain.FirstIntersection(CInt2);
1973
1974     ProjectOnLAndIntersectWithLDomain(Circle,Line
1975                                       ,CDomainAndRes
1976                                       ,LDomain
1977                                       ,SolutionCircle
1978                                       ,SolutionLine
1979                                       ,NbSolTotal
1980                                       ,LIG_Domain
1981                                       ,CIRC_Domain);
1982
1983     //--------------------------------------------------------------------
1984     CDomainAndRes=CDomain.SecondIntersection(CInt2);
1985
1986
1987     ProjectOnLAndIntersectWithLDomain(Circle,Line
1988                                       ,CDomainAndRes
1989                                       ,LDomain
1990                                       ,SolutionCircle
1991                                       ,SolutionLine
1992                                       ,NbSolTotal
1993                                       ,LIG_Domain
1994                                       ,CIRC_Domain);
1995   }
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005   //----------------------------------------------------------------------
2006   //-- Calcul de toutes les transitions et Positions.
2007   //--
2008   //-- On determine si des intervalles sont reduit a des points
2009   //--      ( Rayon * Intervalle.Length()    <    TolConf   )   ### Modif 19 Nov Tol-->TolConf
2010   //--
2011   Standard_Real R=Circle.Radius();
2012   Standard_Integer i ;
2013   Standard_Real MaxTol = TolConf;
2014   if(MaxTol<Tol) MaxTol = Tol;
2015   if(MaxTol<1.0e-10) MaxTol = 1.0e-10;
2016
2017   for( i=0; i<NbSolTotal ; i++) {
2018     if((R * SolutionCircle[i].Length())<MaxTol
2019        && (SolutionLine[i].Length())<MaxTol) {
2020
2021       Standard_Real t=(SolutionCircle[i].Binf+SolutionCircle[i].Bsup)*0.5;
2022       SolutionCircle[i].Binf=SolutionCircle[i].Bsup=t;
2023
2024       t=(SolutionLine[i].Binf+SolutionLine[i].Bsup)*0.5;
2025       SolutionLine[i].Binf=SolutionLine[i].Bsup=t;
2026     }
2027   }
2028 #if 0
2029   if(NbSolTotal == 2) {
2030     if(SolutionLine[0].Binf==SolutionLine[0].BSup) {
2031       if(SolutionLine[1].Binf==SolutionLine[1].BSup) {
2032         if(Abs(SolutionLine[0].Binf-SolutionLine[1].Binf)<TolConf) {
2033           SolutionLine[0].Binf=0.5*(SolutionLine[0].BSup+SolutionLine[1].BSup);
2034           SolutionLine[0].BSup=SolutionLine[0].Binf;
2035           NbSolTotal = 1;
2036         }
2037       }
2038     }
2039   }
2040 #endif
2041   //----------------------------------------------------------------------
2042   //-- Traitement des intervalles (ou des points obtenus)
2043   //--
2044   if(NbSolTotal) {
2045     gp_Ax22d CircleAxis=Circle.Axis();
2046     gp_Ax2d LineAxis=Line.Position();
2047     gp_Pnt2d P1a,P2a,P1b,P2b;
2048     gp_Vec2d Tan1,Tan2,Norm1;
2049     gp_Vec2d Norm2(0.0,0.0);
2050     IntRes2d_Transition T1a,T2a,T1b,T2b;
2051     IntRes2d_Position Pos1a,Pos1b,Pos2a,Pos2b;
2052
2053     ElCLib::CircleD1(SolutionCircle[0].Binf,CircleAxis,R,P1a,Tan1);
2054     ElCLib::LineD1(SolutionLine[0].Binf,LineAxis,P2a,Tan2);
2055
2056     Standard_Boolean Opposite=((Tan1.Dot(Tan2))<0.0)? Standard_True : Standard_False;
2057
2058
2059     for(i=0; i<NbSolTotal; i++ ) {
2060
2061
2062       //-- 7 aout 97
2063       //-- On recentre Bin et Bsup de facon a avoir une portion commune avec CIRC_Domain
2064       Standard_Real p1=SolutionCircle[i].Binf;
2065       Standard_Real p2=SolutionCircle[i].Bsup;
2066       Standard_Real q1=CIRC_Domain.FirstParameter();
2067       Standard_Real q2=CIRC_Domain.LastParameter();
2068       //--          |------ CircDomain ------|   [-- Sol --]
2069       if(p1>q2) {
2070         do {
2071           p1-=PIpPI;
2072           p2-=PIpPI;
2073         }
2074         while( (p1>q2) );
2075       }
2076       else if(p2<q1) {
2077         do {
2078           p1+=PIpPI;
2079           p2+=PIpPI;
2080         }
2081         while( (p2<q1) );
2082       }
2083       if(p1<q1 && p2>q1) {
2084         p1=q1;
2085       }
2086       if(p1<q2 && p2>q2) {
2087         p2=q2;
2088       }
2089
2090 #if 0
2091       if(SolutionCircle[i].Binf!=p1 || SolutionCircle[i].Bsup!=p2) {
2092         printf("\n IntCurve_IntConicConic_1.cxx : (%g , %g) --> (%g , %g)\n",
2093                SolutionCircle[i].Binf,SolutionCircle[i].Bsup,p1,p2);
2094       }
2095 #endif
2096       SolutionCircle[i].Binf=p1;
2097       SolutionCircle[i].Bsup=p2;
2098
2099 //-- Fin 7 aout 97
2100
2101
2102       Standard_Real Linf=(Opposite)? SolutionLine[i].Bsup : SolutionLine[i].Binf;
2103       Standard_Real Lsup=(Opposite)? SolutionLine[i].Binf : SolutionLine[i].Bsup;
2104
2105       //---------------------------------------------------------------
2106       //-- Si les parametres sur le cercle sont en premier
2107       //-- On doit retourner ces parametres dans l ordre croissant
2108       //---------------------------------------------------------------
2109       if(Linf > Lsup) {
2110         Standard_Real T=SolutionCircle[i].Binf;
2111         SolutionCircle[i].Binf=SolutionCircle[i].Bsup;
2112         SolutionCircle[i].Bsup=T;
2113
2114         T=Linf; Linf=Lsup; Lsup=T;
2115       }
2116
2117
2118       ElCLib::CircleD2(SolutionCircle[i].Binf,CircleAxis,R,P1a,Tan1,Norm1);
2119       ElCLib::LineD1(Linf,LineAxis,P2a,Tan2);
2120
2121       IntImpParGen::DeterminePosition(Pos1a,CIRC_Domain,P1a,SolutionCircle[i].Binf);
2122       IntImpParGen::DeterminePosition(Pos2a,LIG_Domain,P2a,Linf);
2123       Determine_Transition_LC(Pos1a,Tan1,Norm1,T1a , Pos2a,Tan2,Norm2,T2a, Tol);
2124       Standard_Real Cinf;
2125       if(Pos1a==IntRes2d_End) {
2126         Cinf = CIRC_Domain.LastParameter();
2127         P1a  = CIRC_Domain.LastPoint();
2128         Linf = ElCLib::Parameter(Line,P1a);
2129
2130         ElCLib::CircleD2(Cinf,CircleAxis,R,P1a,Tan1,Norm1);
2131         ElCLib::LineD1(Linf,LineAxis,P2a,Tan2);
2132         IntImpParGen::DeterminePosition(Pos1a,CIRC_Domain,P1a,Cinf);
2133         IntImpParGen::DeterminePosition(Pos2a,LIG_Domain,P2a,Linf);
2134         Determine_Transition_LC(Pos1a,Tan1,Norm1,T1a , Pos2a,Tan2,Norm2,T2a, Tol);
2135       }
2136       else if(Pos1a==IntRes2d_Head) {
2137         Cinf = CIRC_Domain.FirstParameter();
2138         P1a  = CIRC_Domain.FirstPoint();
2139         Linf = ElCLib::Parameter(Line,P1a);
2140
2141         ElCLib::CircleD2(Cinf,CircleAxis,R,P1a,Tan1,Norm1);
2142         ElCLib::LineD1(Linf,LineAxis,P2a,Tan2);
2143         IntImpParGen::DeterminePosition(Pos1a,CIRC_Domain,P1a,Cinf);
2144         IntImpParGen::DeterminePosition(Pos2a,LIG_Domain,P2a,Linf);
2145         Determine_Transition_LC(Pos1a,Tan1,Norm1,T1a , Pos2a,Tan2,Norm2,T2a, Tol);
2146       }
2147       else {
2148         Cinf=NormalizeOnCircleDomain(SolutionCircle[i].Binf,CIRC_Domain);
2149       }
2150
2151       IntRes2d_IntersectionPoint NewPoint1(P1a,Linf,Cinf,T2a,T1a,ReversedParameters());
2152
2153       if((SolutionLine[i].Length()+SolutionCircle[i].Length()) >0.0) {
2154
2155         ElCLib::CircleD2(SolutionCircle[i].Bsup,CircleAxis,R,P1b,Tan1,Norm1);
2156         ElCLib::LineD1(Lsup,LineAxis,P2b,Tan2);
2157
2158         IntImpParGen::DeterminePosition(Pos1b,CIRC_Domain,P1b,SolutionCircle[i].Bsup);
2159         IntImpParGen::DeterminePosition(Pos2b,LIG_Domain,P2b,Lsup);
2160         Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
2161         Standard_Real Csup;
2162         if(Pos1b==IntRes2d_End) {
2163           Csup = CIRC_Domain.LastParameter();
2164           P1b  = CIRC_Domain.LastPoint();
2165           Lsup = ElCLib::Parameter(Line,P1b);
2166           ElCLib::CircleD2(Csup,CircleAxis,R,P1b,Tan1,Norm1);
2167           ElCLib::LineD1(Lsup,LineAxis,P2b,Tan2);
2168
2169           IntImpParGen::DeterminePosition(Pos1b,CIRC_Domain,P1b,Csup);
2170           IntImpParGen::DeterminePosition(Pos2b,LIG_Domain,P2b,Lsup);
2171           Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
2172         }
2173         else if(Pos1b==IntRes2d_Head) {
2174           Csup = CIRC_Domain.FirstParameter();
2175           P1b  = CIRC_Domain.FirstPoint();
2176           Lsup = ElCLib::Parameter(Line,P1b);
2177           ElCLib::CircleD2(Csup,CircleAxis,R,P1b,Tan1,Norm1);
2178           ElCLib::LineD1(Lsup,LineAxis,P2b,Tan2);
2179
2180           IntImpParGen::DeterminePosition(Pos1b,CIRC_Domain,P1b,Csup);
2181           IntImpParGen::DeterminePosition(Pos2b,LIG_Domain,P2b,Lsup);
2182           Determine_Transition_LC(Pos1b,Tan1,Norm1,T1b , Pos2b,Tan2,Norm2,T2b, Tol);
2183         }
2184         else {
2185           Csup=NormalizeOnCircleDomain(SolutionCircle[i].Bsup,CIRC_Domain);
2186         }
2187
2188         IntRes2d_IntersectionPoint NewPoint2(P1b,Lsup,Csup,T2b,T1b,ReversedParameters());
2189
2190         if(((Abs(Csup-Cinf)*R >  MaxTol) && (Abs(Lsup-Linf) > MaxTol))
2191            || (T1a.TransitionType() != T2a.TransitionType())) {
2192           //-- Verifier egalement les transitions
2193
2194           IntRes2d_IntersectionSegment NewSeg(NewPoint1,NewPoint2
2195                                               ,Opposite,ReversedParameters());
2196           Append(NewSeg);
2197         }
2198         else {
2199           if(Pos1a!=IntRes2d_Middle ||  Pos2a!=IntRes2d_Middle) {
2200             Insert(NewPoint1);
2201           }
2202           if(Pos1b!=IntRes2d_Middle ||  Pos2b!=IntRes2d_Middle) {
2203             Insert(NewPoint2);
2204           }
2205
2206         }
2207       }
2208       else {
2209         //--Standard_Real Cmid=NormalizeOnCircleDomain(0.5*(SolutionCircle[i].Bsup+SolutionCircle[i].Binf)
2210         //--                                       ,CIRC_Domain);
2211         //--IntRes2d_IntersectionPoint NewPoint(P2a,0.5*(Linf+Lsup)
2212         //--                                ,Cmid
2213         //--                                ,T2a,T1a,ReversedParameters());
2214         Insert(NewPoint1);
2215       }
2216     }
2217   }
2218 }
2219
2220
2221
2222
2223 const IntRes2d_IntersectionPoint SegmentToPoint( const IntRes2d_IntersectionPoint& Pa
2224                                                 ,const IntRes2d_Transition& T1a
2225                                                 ,const IntRes2d_Transition& T2a
2226                                                 ,const IntRes2d_IntersectionPoint& Pb
2227                                                 ,const IntRes2d_Transition& T1b
2228                                                 ,const IntRes2d_Transition& T2b) {
2229
2230   if((T1b.PositionOnCurve() == IntRes2d_Middle)
2231      && (T2b.PositionOnCurve() == IntRes2d_Middle)) {
2232     return(Pa);
2233   }
2234   if((T1a.PositionOnCurve() == IntRes2d_Middle)
2235      && (T2a.PositionOnCurve() == IntRes2d_Middle)) {
2236     return(Pb);
2237   }
2238
2239   IntRes2d_Transition t1 = T1a;
2240   IntRes2d_Transition t2 = T2a;
2241   Standard_Real u1 = Pa.ParamOnFirst();
2242   Standard_Real u2 = Pa.ParamOnSecond();
2243
2244
2245   if(t1.PositionOnCurve() == IntRes2d_Middle) {
2246     t1.SetPosition(T1b.PositionOnCurve());
2247     u1 = Pb.ParamOnFirst();
2248   }
2249   if(t2.PositionOnCurve() == IntRes2d_Middle) {
2250     t2.SetPosition(T2b.PositionOnCurve());
2251     u2 = Pb.ParamOnSecond();
2252   }
2253   return(IntRes2d_IntersectionPoint(Pa.Value(),u1,u2,t1,t2,Standard_False));
2254 }