1 // Created on: 1992-04-27
2 // Created by: Laurent BUCHARD
3 // Copyright (c) 1992-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
17 // Modified: OFV Thu Nov 6 17:03:52 2003
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 <IntAna2d_AnaIntersection.hxx>
27 #include <IntAna2d_Conic.hxx>
28 #include <IntAna2d_IntPoint.hxx>
29 #include <IntCurve_IConicTool.hxx>
30 #include <IntCurve_IntConicConic.hxx>
31 #include <IntCurve_IntConicConic_1.hxx>
32 #include <IntCurve_PConic.hxx>
33 #include <IntRes2d_Domain.hxx>
34 #include <Precision.hxx>
35 #include <Standard_ConstructionError.hxx>
37 //=======================================================================
45 // Parabola - Parabola
47 // Parabola - Hyperbola
50 // Hyperbola - Hyperbola
51 //=======================================================================
52 static const Standard_Real PARAM_MAX_ON_PARABOLA = 100000000.0;
53 static const Standard_Real PARAM_MAX_ON_HYPERBOLA = 10000.0;
54 static const Standard_Real TOL_EXACT_INTER = 1.e-7;
56 static inline Standard_Boolean BOUNDED_DOMAIN(const IntRes2d_Domain& domain)
58 return (domain.HasFirstPoint() && domain.HasLastPoint());
61 static Standard_Boolean SET_BOUNDED_DOMAIN(const IntRes2d_Domain domain,
63 Standard_Real& tolinf,
66 Standard_Real& tolsup,
69 if(domain.HasFirstPoint()) {
70 if(binf<domain.FirstParameter()) {
71 Pntinf = domain.FirstPoint();
72 binf = domain.FirstParameter();
73 tolinf = domain.FirstTolerance();
76 if(domain.HasLastPoint()) {
77 if(bsup>domain.FirstParameter()) {
78 Pntsup = domain.LastPoint();
79 bsup = domain.LastParameter();
80 tolsup = domain.LastTolerance();
83 Standard_Boolean result = (bsup <= binf) ? Standard_False : Standard_True;
84 // if(bsup<=binf) return(Standard_False);
85 // return(Standard_True);
89 void SetBinfBsupFromIntAna2d(const IntAna2d_AnaIntersection& theIntAna2d,
92 Standard_Real& bsup,gp_Pnt2d& pntsup,
94 const Standard_Real maxtol,
95 const Standard_Real LIMITE);
97 void SetBinfBsupFromIntAna2d(const IntAna2d_AnaIntersection &theIntAna2d,
98 Standard_Real& binf,gp_Pnt2d& pntinf,
99 Standard_Real& bsup,gp_Pnt2d& pntsup,
100 const gp_Parab2d& PR,
101 const Standard_Real maxtol,
102 const Standard_Real LIMITE);
104 //=======================================================================
106 //purpose : Line - Parabola
107 //=======================================================================
108 void IntCurve_IntConicConic::Perform(const gp_Lin2d& L,
109 const IntRes2d_Domain& DL,
111 const IntRes2d_Domain& DP,
112 const Standard_Real TolConf,
113 const Standard_Real Tol)
117 IntCurve_IConicTool ITool(L);
118 IntCurve_PConic PCurve(P);
120 PCurve.SetAccuracy(20);
121 Inter.SetReversedParameters(ReversedParameters());
123 Standard_Real binf = Precision::Infinite();
124 Standard_Real bsup = -Precision::Infinite();
125 Standard_Real maxtol = (Tol > TolConf) ? Tol : TolConf;
126 if( maxtol< 1.e-7 ) maxtol = 1.e-7;
127 Standard_Boolean wasSet = Standard_False;
129 gp_Pnt2d Pntinf,Pntsup;
130 IntAna2d_AnaIntersection theIntAna2d;
133 // if(maxtol<0.000001) maxtol = 0.000001;
135 gp_Vec2d Offset(maxtol*L.Direction().Y(),maxtol*L.Direction().X());
136 gp_Lin2d Lp(L.Translated(Offset));
137 theIntAna2d.Perform(P,Lp);
138 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,P,maxtol,PARAM_MAX_ON_PARABOLA);
141 gp_Lin2d Lm(L.Translated(Offset));
142 theIntAna2d.Perform(P,Lm);
143 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,P,maxtol,PARAM_MAX_ON_PARABOLA);
146 if(!BOUNDED_DOMAIN(DP)) {
147 Standard_Real tolinf = 0.0;
148 Standard_Real tolsup = 0.0;
149 if(SET_BOUNDED_DOMAIN(DP,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
150 IntRes2d_Domain DPModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
151 Inter.Perform(ITool,DL,PCurve,DPModif,TolConf,Tol);
154 done = Standard_True; return;
158 Standard_Real ft=0.0,lt=0.0;
159 if(binf< DP.FirstParameter()) {
160 binf = DP.FirstParameter();
161 Pntinf = DP.FirstPoint();
162 ft = DP.FirstTolerance();
163 if(bsup < DP.FirstParameter()) {
164 done=Standard_True; return;
167 if(bsup> DP.LastParameter()) {
168 bsup = DP.LastParameter();
169 Pntsup = DP.LastPoint();
170 lt = DP.LastTolerance();
171 if(binf>DP.LastParameter()) {
172 done=Standard_True; return;
175 IntRes2d_Domain DPModif(Pntinf,binf,ft,Pntsup,bsup,lt);
176 // Inter.Perform(ITool,DL,PCurve,DPModif,TolConf,Tol);
177 Inter.Perform(ITool,DL,PCurve,DPModif,TOL_EXACT_INTER,TOL_EXACT_INTER);
178 this->SetValues(Inter);
179 wasSet = Standard_True;
180 if( this->IsDone() && this->NbPoints() == 0 ) {
182 Inter.Perform(ITool,DL,PCurve,DPModif,TolConf,Tol);
183 wasSet = Standard_False;
186 if( !wasSet ) this->SetValues(Inter);
189 done = Standard_True;
193 //=======================================================================
195 //purpose : Line - Elipse
196 //=======================================================================
197 void IntCurve_IntConicConic::Perform(const gp_Lin2d& L,
198 const IntRes2d_Domain& DL,
200 const IntRes2d_Domain& DE,
201 const Standard_Real TolConf,
202 const Standard_Real Tol)
206 IntCurve_IConicTool ITool(L);
207 IntCurve_PConic PCurve(E);
208 PCurve.SetAccuracy(20);
210 Inter.SetReversedParameters(ReversedParameters());
211 if(! DE.IsClosed()) {
212 IntRes2d_Domain D(DE);
213 D.SetEquivalentParameters(DE.FirstParameter(),DE.FirstParameter()+M_PI+M_PI);
214 Inter.Perform(ITool,DL,PCurve,D,TolConf,Tol);
217 Inter.Perform(ITool,DL,PCurve,DE,TolConf,Tol);
219 this->SetValues(Inter);
222 //=======================================================================
224 //purpose : Line - Hyperbola
225 //=======================================================================
226 void IntCurve_IntConicConic::Perform(const gp_Lin2d& L,
227 const IntRes2d_Domain& DL,
229 const IntRes2d_Domain& DH,
230 const Standard_Real TolConf,
231 const Standard_Real Tol)
234 IntCurve_IConicTool ITool(L);
235 IntCurve_PConic PCurve(H);
236 PCurve.SetAccuracy(20);
239 Inter.SetReversedParameters(ReversedParameters());
241 Standard_Real binf = Precision::Infinite(),bsup = -Precision::Infinite(),maxtol;
242 gp_Pnt2d Pntinf,Pntsup;
243 if(Tol > TolConf) maxtol = Tol; else maxtol = TolConf;
245 if(maxtol<0.000001) maxtol = 0.000001;
246 gp_Vec2d Offset(maxtol*H.XAxis().Direction().X(),
247 maxtol*H.XAxis().Direction().Y());
248 gp_Hypr2d Hp(H.Translated(Offset));
249 IntAna2d_AnaIntersection theIntAna2d;
250 theIntAna2d.Perform(Hp,L);
251 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H,maxtol,PARAM_MAX_ON_HYPERBOLA);
253 gp_Hypr2d Hm(H.Translated(Offset));
254 theIntAna2d.Perform(Hm,L);
255 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H,maxtol,PARAM_MAX_ON_HYPERBOLA);
257 if(!BOUNDED_DOMAIN(DH)) {
258 Standard_Real tolinf = 0.0;
259 Standard_Real tolsup = 0.0;
260 if(SET_BOUNDED_DOMAIN(DH,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
261 IntRes2d_Domain DHModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
262 Inter.Perform(ITool,DL,PCurve,DHModif,TolConf,Tol);
265 done = Standard_True; return;
269 Standard_Real ft=0.0,lt=0.0;
270 if(binf< DH.FirstParameter()) {
271 binf = DH.FirstParameter();
272 Pntinf = DH.FirstPoint();
273 ft = DH.FirstTolerance();
274 if(bsup < DH.FirstParameter()) {
275 done=Standard_True; return;
278 if(bsup> DH.LastParameter()) {
279 bsup = DH.LastParameter();
280 Pntsup = DH.LastPoint();
281 lt = DH.LastTolerance();
282 if(binf>DH.LastParameter()) {
283 done=Standard_True; return;
286 IntRes2d_Domain DHModif(Pntinf,binf,ft,Pntsup,bsup,lt);
287 Inter.Perform(ITool,DL,PCurve,DHModif,TolConf,Tol);
289 this->SetValues(Inter);
292 done = Standard_True;
296 //=======================================================================
298 //purpose : Circle - Parabola
299 //=======================================================================
300 void IntCurve_IntConicConic::Perform(const gp_Circ2d& C,
301 const IntRes2d_Domain& DC,
303 const IntRes2d_Domain& DP,
304 const Standard_Real TolConf,
305 const Standard_Real Tol)
308 IntCurve_IConicTool ITool(C);
309 IntCurve_PConic PCurve(P);
310 PCurve.SetAccuracy(20);
311 Inter.SetReversedParameters(ReversedParameters());
313 IntRes2d_Domain D(DC);
314 if(! DC.IsClosed()) {
315 D.SetEquivalentParameters(DC.FirstParameter(),DC.FirstParameter()+M_PI+M_PI);
318 Standard_Real binf = Precision::Infinite(),bsup = -Precision::Infinite(),maxtol;
319 gp_Pnt2d Pntinf,Pntsup;
320 maxtol = C.Radius() / 10.0;
322 Cp.SetRadius(C.Radius()+maxtol);
323 IntAna2d_AnaIntersection theIntAna2d;
324 theIntAna2d.Perform(P,Cp);
325 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,P,maxtol,PARAM_MAX_ON_PARABOLA);
326 if(C.Radius() > maxtol) {
327 Cp.SetRadius(C.Radius() - maxtol);
328 theIntAna2d.Perform(P,Cp);
329 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,P,maxtol,PARAM_MAX_ON_PARABOLA);
332 if(!BOUNDED_DOMAIN(DP)) {
333 Standard_Real tolinf = 0.0;
334 Standard_Real tolsup = 0.0;
335 if(SET_BOUNDED_DOMAIN(DP,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
336 IntRes2d_Domain DPModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
337 Inter.Perform(ITool,D,PCurve,DPModif,TolConf,Tol);
340 done = Standard_True; return;
344 Standard_Real ft=0.0,lt=0.0;
345 if(binf< DP.FirstParameter()) {
346 binf = DP.FirstParameter();
347 Pntinf = DP.FirstPoint();
348 ft = DP.FirstTolerance();
349 if(bsup < DP.FirstParameter()) {
350 done=Standard_True; return;
353 if(bsup> DP.LastParameter()) {
354 bsup = DP.LastParameter();
355 Pntsup = DP.LastPoint();
356 lt = DP.LastTolerance();
357 if(binf>DP.LastParameter()) {
358 done=Standard_True; return;
361 IntRes2d_Domain DPModif(Pntinf,binf,ft,Pntsup,bsup,lt);
362 Inter.Perform(ITool,D,PCurve,DPModif,TolConf,Tol);
364 this->SetValues(Inter);
367 done = Standard_True;
371 //=======================================================================
373 //purpose : Circle - Elipse
374 //=======================================================================
375 void IntCurve_IntConicConic::Perform(const gp_Circ2d& C,
376 const IntRes2d_Domain& DC,
378 const IntRes2d_Domain& DE,
379 const Standard_Real TolConf,
380 const Standard_Real Tol)
383 IntCurve_IConicTool ITool(C);
384 IntCurve_PConic PCurve(E);
385 PCurve.SetAccuracy(20);
387 Inter.SetReversedParameters(ReversedParameters());
389 if(! DC.IsClosed()) {
390 IntRes2d_Domain D1(DC);
391 D1.SetEquivalentParameters(DC.FirstParameter(),DC.FirstParameter()+M_PI+M_PI);
392 if(! DE.IsClosed()) {
393 IntRes2d_Domain D2(DE);
394 D2.SetEquivalentParameters(DE.FirstParameter(),DE.FirstParameter()+M_PI+M_PI);
395 Inter.Perform(ITool,D1,PCurve,D2,TolConf,Tol);
398 Inter.Perform(ITool,D1,PCurve,DE,TolConf,Tol);
402 if(! DE.IsClosed()) {
403 IntRes2d_Domain D2(DE);
404 D2.SetEquivalentParameters(DE.FirstParameter(),DE.FirstParameter()+M_PI+M_PI);
405 Inter.Perform(ITool,DC,PCurve,D2,TolConf,Tol);
408 Inter.Perform(ITool,DC,PCurve,DE,TolConf,Tol);
411 this->SetValues(Inter);
414 //=======================================================================
416 //purpose : Circle - Hyperbola
417 //=======================================================================
418 void IntCurve_IntConicConic::Perform(const gp_Circ2d& C,
419 const IntRes2d_Domain& DC,
421 const IntRes2d_Domain& DH,
422 const Standard_Real TolConf,
423 const Standard_Real Tol)
426 IntCurve_IConicTool ITool(C);
427 IntCurve_PConic PCurve(H);
428 PCurve.SetAccuracy(20);
429 Inter.SetReversedParameters(ReversedParameters());
430 IntRes2d_Domain D(DC);
432 if(! DC.IsClosed()) {
433 D.SetEquivalentParameters(DC.FirstParameter(),DC.FirstParameter()+M_PI+M_PI);
435 Standard_Real binf = Precision::Infinite(),bsup = -Precision::Infinite(),maxtol;
436 gp_Pnt2d Pntinf,Pntsup;
437 maxtol = C.Radius() / 10.0;
438 gp_Vec2d Offset(maxtol*H.XAxis().Direction().X(),
439 maxtol*H.XAxis().Direction().Y());
440 gp_Hypr2d Hp(H.Translated(Offset));
441 IntAna2d_AnaIntersection theIntAna2d;
442 theIntAna2d.Perform(Hp,C);
443 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H,maxtol,PARAM_MAX_ON_HYPERBOLA);
445 gp_Hypr2d Hm(H.Translated(Offset));
446 theIntAna2d.Perform(Hm,C);
447 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H,maxtol,PARAM_MAX_ON_HYPERBOLA);
449 if(!BOUNDED_DOMAIN(DH)) {
450 Standard_Real tolinf = 0.0;
451 Standard_Real tolsup = 0.0;
452 if(SET_BOUNDED_DOMAIN(DH,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
453 IntRes2d_Domain DHModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
454 Inter.Perform(ITool,D,PCurve,DHModif,TolConf,Tol);
457 done = Standard_True; return;
461 Standard_Real ft=0.0,lt=0.0;
462 if(binf< DH.FirstParameter()) {
463 binf = DH.FirstParameter();
464 Pntinf = DH.FirstPoint();
465 ft = DH.FirstTolerance();
466 if(bsup < DH.FirstParameter()) {
467 done=Standard_True; return;
470 if(bsup> DH.LastParameter()) {
471 bsup = DH.LastParameter();
472 Pntsup = DH.LastPoint();
473 lt = DH.LastTolerance();
474 if(binf>DH.LastParameter()) {
475 done=Standard_True; return;
478 IntRes2d_Domain DHModif(Pntinf,binf,ft,Pntsup,bsup,lt);
479 Inter.Perform(ITool,D,PCurve,DHModif,TolConf,Tol);
481 this->SetValues(Inter);
484 done = Standard_True;
488 //=======================================================================
490 //purpose : Parabola - Parabola
491 //=======================================================================
492 void IntCurve_IntConicConic::Perform(const gp_Parab2d& P1,
493 const IntRes2d_Domain& DP1,
494 const gp_Parab2d& P2,
495 const IntRes2d_Domain& DP2,
496 const Standard_Real TolConf,
497 const Standard_Real Tol)
500 IntCurve_IConicTool ITool(P1);
501 IntCurve_PConic PCurve(P2);
502 PCurve.SetAccuracy(20);
503 Inter.SetReversedParameters(ReversedParameters());
505 Standard_Real binf = Precision::Infinite(),bsup = -Precision::Infinite(),maxtol;
506 gp_Pnt2d Pntinf,Pntsup;
507 if(Tol > TolConf) maxtol = Tol; else maxtol = TolConf;
509 if(maxtol<0.000001) maxtol = 0.000001;
510 gp_Vec2d Offset(maxtol*P2.MirrorAxis().Direction().X(),
511 maxtol*P2.MirrorAxis().Direction().Y());
512 gp_Parab2d Pp(P2.Translated(Offset));
513 IntAna2d_AnaIntersection theIntAna2d;
514 theIntAna2d.Perform(Pp,P1);
515 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,P2,maxtol,PARAM_MAX_ON_PARABOLA);
517 gp_Parab2d Pm(P2.Translated(Offset));
518 theIntAna2d.Perform(Pm,P1);
519 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,P2,maxtol,PARAM_MAX_ON_PARABOLA);
521 if(!BOUNDED_DOMAIN(DP2)) {
522 Standard_Real tolinf = 0.0;
523 Standard_Real tolsup = 0.0;
524 if(SET_BOUNDED_DOMAIN(DP2,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
525 IntRes2d_Domain DPModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
526 Inter.Perform(ITool,DP1,PCurve,DPModif,TolConf,Tol);
529 done = Standard_True; return;
533 Standard_Real ft=0.0,lt=0.0;
534 if(binf< DP2.FirstParameter()) {
535 binf = DP2.FirstParameter();
536 Pntinf = DP2.FirstPoint();
537 ft = DP2.FirstTolerance();
538 if(bsup < DP2.FirstParameter()) {
539 done=Standard_True; return;
542 if(bsup> DP2.LastParameter()) {
543 bsup = DP2.LastParameter();
544 Pntsup = DP2.LastPoint();
545 lt = DP2.LastTolerance();
546 if(binf>DP2.LastParameter()) {
547 done=Standard_True; return;
550 IntRes2d_Domain DPModif(Pntinf,binf,ft,Pntsup,bsup,lt);
551 Inter.Perform(ITool,DP1,PCurve,DPModif,TolConf,Tol);
553 this->SetValues(Inter);
556 done = Standard_True;
560 //=======================================================================
562 //purpose : Elipse - Parabola
563 //=======================================================================
564 void IntCurve_IntConicConic::Perform(const gp_Elips2d& E,
565 const IntRes2d_Domain& DE,
567 const IntRes2d_Domain& DP,
568 const Standard_Real TolConf,
569 const Standard_Real Tol)
572 IntCurve_IConicTool ITool(E);
573 IntCurve_PConic PCurve(P);
574 PCurve.SetAccuracy(20);
575 Inter.SetReversedParameters(ReversedParameters());
577 IntRes2d_Domain D(DE);
578 if(! DE.IsClosed()) {
579 D.SetEquivalentParameters(DE.FirstParameter(),DE.FirstParameter()+M_PI+M_PI);
582 //-- cout<<" Parab Elips "<<endl;
584 Standard_Real binf = Precision::Infinite(),bsup = -Precision::Infinite(),maxtol;
585 gp_Pnt2d Pntinf,Pntsup;
586 if(Tol > TolConf) maxtol = Tol; else maxtol = TolConf;
588 maxtol = E.MinorRadius() / 10.0;
590 Ep.SetMajorRadius(E.MajorRadius()+maxtol);
591 Ep.SetMinorRadius(E.MinorRadius()+maxtol);
592 IntAna2d_AnaIntersection theIntAna2d;
593 theIntAna2d.Perform(P,Ep);
594 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,P,maxtol,PARAM_MAX_ON_PARABOLA);
595 if(E.MinorRadius() > maxtol) {
596 Ep.SetMinorRadius(E.MinorRadius() - maxtol);
597 Ep.SetMajorRadius(E.MajorRadius() - maxtol);
598 theIntAna2d.Perform(P,Ep);
599 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,P,maxtol,PARAM_MAX_ON_PARABOLA);
601 //-- cout<<" binf,bsup "<<binf<<" "<<bsup<<endl;
603 if(!BOUNDED_DOMAIN(DP)) {
604 Standard_Real tolinf = 0.0;
605 Standard_Real tolsup = 0.0;
606 if(SET_BOUNDED_DOMAIN(DP,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
607 IntRes2d_Domain DPModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
608 Inter.Perform(ITool,D,PCurve,DPModif,TolConf,Tol);
611 done = Standard_True; return;
615 Standard_Real ft=0.0,lt=0.0;
616 if(binf< DP.FirstParameter()) {
617 binf = DP.FirstParameter();
618 Pntinf = DP.FirstPoint();
619 ft = DP.FirstTolerance();
620 if(bsup < DP.FirstParameter()) {
621 done=Standard_True; return;
624 if(bsup> DP.LastParameter()) {
625 bsup = DP.LastParameter();
626 Pntsup = DP.LastPoint();
627 lt = DP.LastTolerance();
628 if(binf>DP.LastParameter()) {
629 done=Standard_True; return;
632 //-- cout<<"BOUNDED binf,bsup "<<binf<<" "<<bsup<<endl;
633 //-- cout<<"Domain "<<DP.FirstParameter()<<" "<<DP.LastParameter()<<endl;
634 IntRes2d_Domain DPModif(Pntinf,binf,ft,Pntsup,bsup,lt);
635 Inter.Perform(ITool,D,PCurve,DPModif,TolConf,Tol);
637 this->SetValues(Inter);
640 done = Standard_True;
644 //=======================================================================
646 //purpose : Parabola - Hyperbola
647 //=======================================================================
648 void IntCurve_IntConicConic::Perform(const gp_Parab2d& P,
649 const IntRes2d_Domain& DP,
651 const IntRes2d_Domain& DH,
652 const Standard_Real TolConf,
653 const Standard_Real Tol)
656 IntCurve_IConicTool ITool(P);
657 IntCurve_PConic PCurve(H);
658 Inter.SetReversedParameters(ReversedParameters());
660 Standard_Real binf = Precision::Infinite(),bsup = -Precision::Infinite(),maxtol;
661 gp_Pnt2d Pntinf,Pntsup;
662 if(Tol > TolConf) maxtol = Tol; else maxtol = TolConf;
664 if(maxtol<0.000001) maxtol = 0.000001;
665 gp_Vec2d Offset(maxtol*H.XAxis().Direction().X(),
666 maxtol*H.XAxis().Direction().Y());
667 gp_Hypr2d Hp(H.Translated(Offset));
668 IntAna2d_AnaIntersection theIntAna2d;
669 theIntAna2d.Perform(Hp,P);
670 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H,maxtol,PARAM_MAX_ON_HYPERBOLA);
672 gp_Hypr2d Hm(H.Translated(Offset));
673 theIntAna2d.Perform(Hm,P);
674 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H,maxtol,PARAM_MAX_ON_HYPERBOLA);
676 if(!BOUNDED_DOMAIN(DH)) {
677 Standard_Real tolinf = 0.0;
678 Standard_Real tolsup = 0.0;
679 if(SET_BOUNDED_DOMAIN(DH,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
680 IntRes2d_Domain DHModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
681 Inter.Perform(ITool,DP,PCurve,DHModif,TolConf,Tol);
684 done = Standard_True; return;
688 Standard_Real ft=0.0,lt=0.0;
689 if(binf< DH.FirstParameter()) {
690 binf = DH.FirstParameter();
691 Pntinf = DH.FirstPoint();
692 ft = DH.FirstTolerance();
693 if(bsup < DH.FirstParameter()) {
694 done=Standard_True; return;
697 if(bsup> DH.LastParameter()) {
698 bsup = DH.LastParameter();
699 Pntsup = DH.LastPoint();
700 lt = DH.LastTolerance();
701 if(binf>DH.LastParameter()) {
702 done=Standard_True; return;
705 IntRes2d_Domain DHModif(Pntinf,binf,ft,Pntsup,bsup,lt);
706 Inter.Perform(ITool,DP,PCurve,DHModif,TolConf,Tol);
708 this->SetValues(Inter);
711 done = Standard_True;
715 //=======================================================================
717 //purpose : Elipse - Elipse
718 //=======================================================================
720 void IntCurve_IntConicConic::Perform(const gp_Elips2d& E1,
721 const IntRes2d_Domain& DE1,
722 const gp_Elips2d& E2,
723 const IntRes2d_Domain& DE2,
724 const Standard_Real TolConf,
725 const Standard_Real Tol)
728 IntCurve_IConicTool ITool(E1);
729 IntCurve_PConic PCurve(E2);
730 PCurve.SetAccuracy(20);
733 Inter.SetReversedParameters(ReversedParameters());
735 if(! DE1.IsClosed()) {
736 IntRes2d_Domain D1(DE1);
737 D1.SetEquivalentParameters(DE1.FirstParameter(),DE1.FirstParameter()+M_PI+M_PI);
738 if(! DE2.IsClosed()) {
739 IntRes2d_Domain D2(DE2);
740 D2.SetEquivalentParameters(DE2.FirstParameter(),DE2.FirstParameter()+M_PI+M_PI);
741 Inter.Perform(ITool,D1,PCurve,D2,TolConf,Tol);
744 Inter.Perform(ITool,D1,PCurve,DE2,TolConf,Tol);
748 if(! DE2.IsClosed()) {
749 IntRes2d_Domain D2(DE2);
750 D2.SetEquivalentParameters(DE2.FirstParameter(),DE2.FirstParameter()+M_PI+M_PI);
751 Inter.Perform(ITool,DE1,PCurve,D2,TolConf,Tol);
754 Inter.Perform(ITool,DE1,PCurve,DE2,TolConf,Tol);
757 this->SetValues(Inter);
760 //=======================================================================
762 //purpose : Elipse - Hyperbola
763 //=======================================================================
764 void IntCurve_IntConicConic::Perform(const gp_Elips2d& E,
765 const IntRes2d_Domain& DE,
767 const IntRes2d_Domain& DH,
768 const Standard_Real TolConf,
769 const Standard_Real Tol)
772 IntCurve_IConicTool ITool(E);
773 IntCurve_PConic PCurve(H);
774 PCurve.SetAccuracy(20);
775 Inter.SetReversedParameters(ReversedParameters());
776 IntRes2d_Domain DEModif(DE);
778 if(! DE.IsClosed()) {
779 DEModif.SetEquivalentParameters(DE.FirstParameter(),DE.FirstParameter()+M_PI+M_PI);
782 Standard_Real binf = Precision::Infinite(),bsup = -Precision::Infinite(),maxtol;
783 gp_Pnt2d Pntinf,Pntsup;
784 maxtol = E.MinorRadius() / 10.0;
785 gp_Vec2d Offset(maxtol*H.XAxis().Direction().X(),
786 maxtol*H.XAxis().Direction().Y());
787 gp_Hypr2d Hp(H.Translated(Offset));
788 IntAna2d_AnaIntersection theIntAna2d;
789 theIntAna2d.Perform(Hp,E);
790 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H,maxtol,PARAM_MAX_ON_HYPERBOLA);
792 gp_Hypr2d Hm(H.Translated(Offset));
793 theIntAna2d.Perform(Hm,E);
794 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H,maxtol,PARAM_MAX_ON_HYPERBOLA);
796 if(!BOUNDED_DOMAIN(DH)) {
797 Standard_Real tolinf = 0.0;
798 Standard_Real tolsup = 0.0;
799 if(SET_BOUNDED_DOMAIN(DH,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
800 IntRes2d_Domain DHModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
801 Inter.Perform(ITool,DEModif,PCurve,DHModif,TolConf,Tol);
804 done = Standard_True; return;
808 Standard_Real ft=0.0,lt=0.0;
809 if(binf< DH.FirstParameter()) {
810 binf = DH.FirstParameter();
811 Pntinf = DH.FirstPoint();
812 ft = DH.FirstTolerance();
813 if(bsup < DH.FirstParameter()) {
814 done=Standard_True; return;
817 if(bsup> DH.LastParameter()) {
818 bsup = DH.LastParameter();
819 Pntsup = DH.LastPoint();
820 lt = DH.LastTolerance();
821 if(binf>DH.LastParameter()) {
822 done=Standard_True; return;
826 done = Standard_True; return;
828 IntRes2d_Domain DHModif(Pntinf,binf,ft,Pntsup,bsup,lt);
829 Inter.Perform(ITool,DEModif,PCurve,DHModif,TolConf,Tol);
831 this->SetValues(Inter);
834 done = Standard_True;
838 //=======================================================================
840 //purpose : Hyperbola - Hyperbola
841 //=======================================================================
843 void IntCurve_IntConicConic::Perform(const gp_Hypr2d& H1,
844 const IntRes2d_Domain& DH1,
846 const IntRes2d_Domain& DH2,
847 const Standard_Real TolConf,
848 const Standard_Real Tol)
851 IntCurve_IConicTool ITool(H1);
852 IntCurve_PConic PCurve(H2);
853 PCurve.SetAccuracy(20);
855 Inter.SetReversedParameters(ReversedParameters());
857 Standard_Real binf = Precision::Infinite(),bsup = -Precision::Infinite(),maxtol;
858 gp_Pnt2d Pntinf,Pntsup;
859 if(Tol > TolConf) maxtol = Tol; else maxtol = TolConf;
861 if(maxtol<0.000001) maxtol = 0.000001;
862 gp_Vec2d Offset(maxtol*H2.XAxis().Direction().X(),
863 maxtol*H2.XAxis().Direction().Y());
864 gp_Hypr2d Hp(H2.Translated(Offset));
865 IntAna2d_AnaIntersection theIntAna2d;
866 theIntAna2d.Perform(Hp,H1);
867 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H2,maxtol,PARAM_MAX_ON_HYPERBOLA);
869 gp_Hypr2d Hm(H2.Translated(Offset));
870 theIntAna2d.Perform(Hm,H1);
871 SetBinfBsupFromIntAna2d(theIntAna2d,binf,Pntinf,bsup,Pntsup,H2,maxtol,PARAM_MAX_ON_HYPERBOLA);
873 if(!BOUNDED_DOMAIN(DH2)) {
874 Standard_Real tolinf = 0.0;
875 Standard_Real tolsup = 0.0;
876 if(SET_BOUNDED_DOMAIN(DH2,binf,tolinf,Pntinf,bsup,tolsup,Pntsup)) {
877 IntRes2d_Domain DHModif(Pntinf,binf,tolinf,Pntsup,bsup,tolsup);
878 Inter.Perform(ITool,DH1,PCurve,DHModif,TolConf,Tol);
881 done = Standard_True; return;
885 Standard_Real ft=0.0,lt=0.0;
886 if(binf< DH2.FirstParameter()) {
887 binf = DH2.FirstParameter();
888 Pntinf = DH2.FirstPoint();
889 ft = DH2.FirstTolerance();
891 if(bsup> DH2.LastParameter()) {
892 bsup = DH2.LastParameter();
893 Pntsup = DH2.LastPoint();
894 lt = DH2.LastTolerance();
897 //-- lbr le 22 sept 97
898 //-- binf=-5.6 bsup=-5.3 DH2=(5.6,5.7) -> binf=+5.6 bsup=-5.3
900 done = Standard_True; return;
902 IntRes2d_Domain DHModif(Pntinf,binf,ft,Pntsup,bsup,lt);
903 Inter.Perform(ITool,DH1,PCurve,DHModif,TolConf,Tol);
905 this->SetValues(Inter);
908 done = Standard_True;
911 //----------------------------------------------------------------------
914 void SetBinfBsupFromIntAna2d(const IntAna2d_AnaIntersection &theIntAna2d,
915 Standard_Real& binf,gp_Pnt2d& Pntinf,
916 Standard_Real& bsup,gp_Pnt2d& Pntsup,
917 const gp_Parab2d& PR,
918 const Standard_Real maxtol,
919 const Standard_Real LIMITE) {
922 if(theIntAna2d.IsDone()) {
923 if(!theIntAna2d.IsEmpty()) {
924 for(Standard_Integer p=1; p<=theIntAna2d.NbPoints(); p++) {
925 Standard_Real param = theIntAna2d.Point(p).ParamOnFirst();
927 if(Abs(param) < LIMITE) {
930 ElCLib::D1(param,PR,P,V);
931 Standard_Real NormeD1 = V.Magnitude();
932 Standard_Real dparam = 100.0*maxtol/NormeD1;
933 if(dparam<1e-3) dparam = 1e-3;
938 Pntinf=ElCLib::Value(param,PR);
940 param+=dparam+dparam;
943 Pntsup=ElCLib::Value(param,PR);
950 void SetBinfBsupFromIntAna2d(const IntAna2d_AnaIntersection &theIntAna2d,
951 Standard_Real& binf,gp_Pnt2d& Pntinf,
952 Standard_Real& bsup,gp_Pnt2d& Pntsup,
954 const Standard_Real maxtol,
955 const Standard_Real LIMITE) {
958 if(theIntAna2d.IsDone()) {
959 if(!theIntAna2d.IsEmpty()) {
960 for(Standard_Integer p=1; p<=theIntAna2d.NbPoints(); p++) {
961 Standard_Real param = theIntAna2d.Point(p).ParamOnFirst();
963 if(Abs(param) < LIMITE) {
966 ElCLib::D1(param,H,P,V);
967 Standard_Real NormeD1 = V.Magnitude();
968 Standard_Real dparam = 100.0*maxtol/NormeD1;
969 if(dparam<1e-3) dparam = 1e-3;
974 Pntinf=ElCLib::Value(param,H);
976 param+=dparam+dparam;
979 Pntsup=ElCLib::Value(param,H);