2 // Created: Wed Jun 23 18:38:51 1993
3 // Author: Didier PIFFAULT
6 #include <Intf_Tool.ixx>
9 #include <IntAna2d_Conic.hxx>
10 #include <IntAna2d_IntPoint.hxx>
11 #include <IntAna2d_AnaIntersection.hxx>
12 #include <IntAna_IntConicQuad.hxx>
14 #include <Precision.hxx>
16 //=======================================================================
17 //function : Intf_Tool
19 //=======================================================================
21 Intf_Tool::Intf_Tool()
25 //=======================================================================
28 //=======================================================================
30 void Intf_Tool::Lin2dBox(const gp_Lin2d& L2d,
31 const Bnd_Box2d& domain,
36 if (domain.IsWhole()) {
37 boxLin.Set(L2d.Location(), L2d.Direction());
38 boxLin.Add(L2d.Direction().Reversed());
40 beginOnCurve[0]=-Precision::Infinite();
41 endOnCurve[0]=Precision::Infinite();
44 else if (domain.IsVoid()) return;
46 Standard_Real xmin, xmax, ymin, ymax;
47 Standard_Real Xmin=0, Xmax=0, Ymin=0, Ymax=0;
48 Standard_Real parmin=-Precision::Infinite();
49 Standard_Real parmax=Precision::Infinite();
50 Standard_Real parcur, par1,par2;
51 Standard_Boolean xToSet, yToSet;
53 domain.Get(xmin,ymin,xmax,ymax);
56 if (L2d.Direction().XY().X()>0.) {
57 if (domain.IsOpenXmin()) parmin=-Precision::Infinite();
58 else parmin=(xmin-L2d.Location().XY().X())/L2d.Direction().XY().X();
59 if (domain.IsOpenXmax()) parmax=Precision::Infinite();
60 else parmax=(xmax-L2d.Location().XY().X())/L2d.Direction().XY().X();
63 else if (L2d.Direction().XY().X()<0.) {
64 if (domain.IsOpenXmax()) parmin=-Precision::Infinite();
65 else parmin=(xmax-L2d.Location().XY().X())/L2d.Direction().XY().X();
66 if (domain.IsOpenXmin()) parmax=Precision::Infinite();
67 else parmax=(xmin-L2d.Location().XY().X())/L2d.Direction().XY().X();
70 else { // Parallel to axis X
71 if (L2d.Location().XY().X()<xmin || xmax<L2d.Location().XY().X())
73 Xmin=L2d.Location().XY().X();
74 Xmax=L2d.Location().XY().X();
75 xToSet=Standard_False;
78 if (L2d.Direction().XY().Y()>0.) {
79 if (domain.IsOpenYmin()) parcur=-Precision::Infinite();
80 else parcur=(ymin-L2d.Location().XY().Y())/L2d.Direction().XY().Y();
81 parmin=Max(parmin, parcur);
82 if (domain.IsOpenYmax()) parcur=Precision::Infinite();
83 else parcur=(ymax-L2d.Location().XY().Y())/L2d.Direction().XY().Y();
84 parmax=Min(parmax, parcur);
87 else if (L2d.Direction().XY().Y()<0.) {
88 if (domain.IsOpenYmax()) parcur=-Precision::Infinite();
89 else parcur=(ymax-L2d.Location().XY().Y())/L2d.Direction().XY().Y();
90 parmin=Max(parmin, parcur);
91 if (domain.IsOpenYmin()) parcur=Precision::Infinite();
92 else parcur=(ymin-L2d.Location().XY().Y())/L2d.Direction().XY().Y();
93 parmax=Min(parmax, parcur);
96 else { // Parallel to axis Y
97 if (L2d.Location().XY().Y()<ymin || ymax<L2d.Location().XY().Y())
99 Ymin=L2d.Location().XY().Y();
100 Ymax=L2d.Location().XY().Y();
101 yToSet=Standard_False;
105 beginOnCurve[0]=parmin;
106 endOnCurve[0]=parmax;
109 par1=L2d.Location().XY().X()+parmin*L2d.Direction().XY().X();
110 par2=L2d.Location().XY().X()+parmax*L2d.Direction().XY().X();
111 Xmin=Min(par1, par2);
112 Xmax=Max(par1, par2);
116 par1=L2d.Location().XY().Y()+parmin*L2d.Direction().XY().Y();
117 par2=L2d.Location().XY().Y()+parmax*L2d.Direction().XY().Y();
118 Ymin=Min(par1, par2);
119 Ymax=Max(par1, par2);
122 boxLin.Update(Xmin, Ymin, Xmax, Ymax);
125 //=======================================================================
126 //function : Hypr2dBox
128 //=======================================================================
129 static Standard_Integer bord[12];
130 static Standard_Real xint[12];
131 static Standard_Real yint[12];
132 static Standard_Real zint[12];
133 static Standard_Real parint[12];
135 void Intf_Tool::Hypr2dBox(const gp_Hypr2d& theHypr2d,
136 const Bnd_Box2d& domain,
137 Bnd_Box2d& boxHypr2d)
141 if (domain.IsWhole()) {
142 boxHypr2d.SetWhole();
144 beginOnCurve[0]=-Precision::Infinite();
145 endOnCurve[0]=Precision::Infinite();
148 else if (domain.IsVoid()) return;
150 Standard_Integer nbPi=Inters2d(theHypr2d, domain);
153 Standard_Real Xmin, Xmax, Ymin, Ymax;
155 domain.Get(Xmax, Ymax, Xmin, Ymin);
157 Standard_Integer npi;
158 for (npi=0; npi<nbPi; npi++) {
159 Xmin=Min(Xmin, xint[npi]);
160 Xmax=Max(Xmax, xint[npi]);
161 Ymin=Min(Ymin, yint[npi]);
162 Ymax=Max(Ymax, yint[npi]);
164 boxHypr2d.Update(Xmin, Ymin, Xmax, Ymax);
166 Standard_Integer npj, npk;
167 Standard_Real parmin;
168 for (npi=0; npi<nbPi; npi++) {
170 for (npj=npi+1; npj<nbPi; npj++)
171 if (parint[npj]<parint[npk]) npk=npj;
174 parint[npk]=parint[npi];
184 Standard_Real sinan=0;
185 Standard_Boolean out=Standard_True;
187 for (npi=0; npi<nbPi; npi++) {
188 ElCLib::D1(parint[npi], theHypr2d, Pn, Tan);
191 sinan=gp_XY(-1.,0.)^Tan.XY();
194 sinan=gp_XY(0.,-1.)^Tan.XY();
197 sinan=gp_XY(1.,0.)^Tan.XY();
200 sinan=gp_XY(0.,1.)^Tan.XY();
203 if (Abs(sinan)>Precision::Angular()) {
206 beginOnCurve[nbSeg]=parint[npi];
211 beginOnCurve[nbSeg]=-Precision::Infinite();
214 endOnCurve[nbSeg-1]=parint[npi];
217 Standard_Integer ipmin;
218 if(beginOnCurve[nbSeg-1] < -10.) ipmin = -10;
219 else ipmin = (Standard_Integer)(beginOnCurve[nbSeg-1]);
221 Standard_Integer ipmax;
222 if(endOnCurve[nbSeg-1] > 10.) ipmax = 10;
223 else ipmax = (Standard_Integer)(endOnCurve[nbSeg-1]);
225 //Standard_Integer ipmin=Max((Standard_Integer)(beginOnCurve[nbSeg-1]),
227 //Standard_Integer ipmax=Min((Standard_Integer)(endOnCurve[nbSeg-1]),
231 Standard_Integer ip, pas=1;
232 for (ip=ipmin; ip<=ipmax; ip+=pas) {
233 boxHypr2d.Add(ElCLib::Value(Standard_Real(ip)/10., theHypr2d));
234 if (Abs(ip)<=10) pas=1;
241 else if (!domain.IsOut(ElCLib::Value(0., theHypr2d))) {
243 beginOnCurve[0]=-Precision::Infinite();
244 endOnCurve[0]=Precision::Infinite();
249 //=======================================================================
250 //function : Inters2d
252 //=======================================================================
254 Standard_Integer Intf_Tool::Inters2d(const gp_Hypr2d& theCurv,
255 const Bnd_Box2d& Domain)
257 Standard_Integer nbpi=0;
258 Standard_Integer npi;
259 Standard_Real xmin, xmax, ymin, ymax;
261 Domain.Get(xmin,ymin,xmax,ymax);
263 if (!Domain.IsOpenYmax()) {
264 gp_Lin2d L1(gp_Pnt2d(0., ymax), gp_Dir2d(-1., 0.));
265 IntAna2d_AnaIntersection Inters1(theCurv, IntAna2d_Conic(L1));
266 if (Inters1.IsDone()) {
267 if (!Inters1.IsEmpty()) {
268 for (npi=1; npi<=Inters1.NbPoints(); npi++) {
269 xint[nbpi]=Inters1.Point(npi).Value().X();
270 if (xmin < xint[nbpi] && xint[nbpi] <=xmax) {
272 parint[nbpi]=Inters1.Point(npi).ParamOnFirst();
281 if (!Domain.IsOpenXmin()) {
282 gp_Lin2d L2(gp_Pnt2d(xmin, 0.), gp_Dir2d(0., -1.));
283 IntAna2d_AnaIntersection Inters2(theCurv, IntAna2d_Conic(L2));
284 if (Inters2.IsDone()) {
285 if (!Inters2.IsEmpty()) {
286 for (npi=1; npi<=Inters2.NbPoints(); npi++) {
287 yint[nbpi]=Inters2.Point(npi).Value().Y();
288 if (ymin < yint[nbpi] && yint[nbpi] <=ymax) {
290 parint[nbpi]=Inters2.Point(npi).ParamOnFirst();
299 if (!Domain.IsOpenYmin()) {
300 gp_Lin2d L3(gp_Pnt2d(0., ymin), gp_Dir2d(1., 0.));
301 IntAna2d_AnaIntersection Inters3(theCurv, IntAna2d_Conic(L3));
302 if (Inters3.IsDone()) {
303 if (!Inters3.IsEmpty()) {
304 for (npi=1; npi<=Inters3.NbPoints(); npi++) {
305 xint[nbpi]=Inters3.Point(npi).Value().X();
306 if (xmin <=xint[nbpi] && xint[nbpi] <xmax) {
308 parint[nbpi]=Inters3.Point(npi).ParamOnFirst();
317 if (!Domain.IsOpenXmax()) {
318 gp_Lin2d L4(gp_Pnt2d(xmax, 0.), gp_Dir2d(0., 1.));
319 IntAna2d_AnaIntersection Inters4(theCurv, IntAna2d_Conic(L4));
320 if (Inters4.IsDone()) {
321 if (!Inters4.IsEmpty()) {
322 for (npi=1; npi<=Inters4.NbPoints(); npi++) {
323 yint[nbpi]=Inters4.Point(npi).Value().Y();
324 if (ymin <= yint[nbpi] && yint[nbpi] < ymax) {
326 parint[nbpi]=Inters4.Point(npi).ParamOnFirst();
337 //=======================================================================
338 //function : Parab2dBox
340 //=======================================================================
342 void Intf_Tool::Parab2dBox(const gp_Parab2d& theParab2d,
343 const Bnd_Box2d& domain,
344 Bnd_Box2d& boxParab2d)
347 boxParab2d.SetVoid();
348 if (domain.IsWhole()) {
349 boxParab2d.SetWhole();
351 beginOnCurve[0]=-Precision::Infinite();
352 endOnCurve[0]=Precision::Infinite();
355 else if (domain.IsVoid()) return;
357 Standard_Integer nbPi=Inters2d(theParab2d, domain);
360 Standard_Real Xmin, Xmax, Ymin, Ymax;
362 domain.Get(Xmax, Ymax, Xmin, Ymin);
364 Standard_Integer npi;
365 for (npi=0; npi<nbPi; npi++) {
366 Xmin=Min(Xmin, xint[npi]);
367 Xmax=Max(Xmax, xint[npi]);
368 Ymin=Min(Ymin, yint[npi]);
369 Ymax=Max(Ymax, yint[npi]);
371 boxParab2d.Update(Xmin, Ymin, Xmax, Ymax);
373 Standard_Integer npj, npk;
374 Standard_Real parmin;
375 for (npi=0; npi<nbPi; npi++) {
377 for (npj=npi+1; npj<nbPi; npj++)
378 if (parint[npj]<parint[npk]) npk=npj;
381 parint[npk]=parint[npi];
391 Standard_Real sinan=0;
392 Standard_Boolean out=Standard_True;
394 for (npi=0; npi<nbPi; npi++) {
395 ElCLib::D1(parint[npi], theParab2d, Pn, Tan);
398 sinan=gp_XY(-1.,0.)^Tan.XY();
401 sinan=gp_XY(0.,-1.)^Tan.XY();
404 sinan=gp_XY(1.,0.)^Tan.XY();
407 sinan=gp_XY(0.,1.)^Tan.XY();
410 if (Abs(sinan)>Precision::Angular()) {
413 beginOnCurve[nbSeg]=parint[npi];
418 beginOnCurve[nbSeg]=-Precision::Infinite();
421 endOnCurve[nbSeg-1]=parint[npi];
424 Standard_Integer ipmin;
425 if(beginOnCurve[nbSeg-1] < -10.) ipmin = -10;
426 else ipmin = (Standard_Integer)(beginOnCurve[nbSeg-1]);
428 Standard_Integer ipmax;
429 if(endOnCurve[nbSeg-1] > 10.) ipmax = 10;
430 else ipmax = (Standard_Integer)(endOnCurve[nbSeg-1]);
432 //Standard_Integer ipmin=Max((Standard_Integer)(beginOnCurve[nbSeg-1]),
434 //Standard_Integer ipmax=Min((Standard_Integer)(endOnCurve[nbSeg-1]),
438 Standard_Integer ip, pas=1;
439 for (ip=ipmin; ip<=ipmax; ip+=pas) {
440 boxParab2d.Add(ElCLib::Value(Standard_Real(ip)/10., theParab2d));
441 if (Abs(ip)<=10) pas=1;
448 else if (!domain.IsOut(ElCLib::Value(0., theParab2d))) {
450 beginOnCurve[0]=-Precision::Infinite();
451 endOnCurve[0]=Precision::Infinite();
456 //=======================================================================
457 //function : Inters2d
459 //=======================================================================
461 Standard_Integer Intf_Tool::Inters2d(const gp_Parab2d& theCurv,
462 const Bnd_Box2d& Domain)
464 Standard_Integer nbpi=0;
465 Standard_Integer npi;
466 Standard_Real xmin, xmax, ymin, ymax;
468 Domain.Get(xmin,ymin,xmax,ymax);
470 if (!Domain.IsOpenYmax()) {
471 gp_Lin2d L1(gp_Pnt2d(0., ymax), gp_Dir2d(-1., 0.));
472 IntAna2d_AnaIntersection Inters1(theCurv, IntAna2d_Conic(L1));
473 if (Inters1.IsDone()) {
474 if (!Inters1.IsEmpty()) {
475 for (npi=1; npi<=Inters1.NbPoints(); npi++) {
476 xint[nbpi]=Inters1.Point(npi).Value().X();
477 if (xmin < xint[nbpi] && xint[nbpi] <=xmax) {
479 parint[nbpi]=Inters1.Point(npi).ParamOnFirst();
488 if (!Domain.IsOpenXmin()) {
489 gp_Lin2d L2(gp_Pnt2d(xmin, 0.), gp_Dir2d(0., -1.));
490 IntAna2d_AnaIntersection Inters2(theCurv, IntAna2d_Conic(L2));
491 if (Inters2.IsDone()) {
492 if (!Inters2.IsEmpty()) {
493 for (npi=1; npi<=Inters2.NbPoints(); npi++) {
494 yint[nbpi]=Inters2.Point(npi).Value().Y();
495 if (ymin < yint[nbpi] && yint[nbpi] <=ymax) {
497 parint[nbpi]=Inters2.Point(npi).ParamOnFirst();
506 if (!Domain.IsOpenYmin()) {
507 gp_Lin2d L3(gp_Pnt2d(0., ymin), gp_Dir2d(1., 0.));
508 IntAna2d_AnaIntersection Inters3(theCurv, IntAna2d_Conic(L3));
509 if (Inters3.IsDone()) {
510 if (!Inters3.IsEmpty()) {
511 for (npi=1; npi<=Inters3.NbPoints(); npi++) {
512 xint[nbpi]=Inters3.Point(npi).Value().X();
513 if (xmin <=xint[nbpi] && xint[nbpi] <xmax) {
515 parint[nbpi]=Inters3.Point(npi).ParamOnFirst();
524 if (!Domain.IsOpenXmax()) {
525 gp_Lin2d L4(gp_Pnt2d(xmax, 0.), gp_Dir2d(0., 1.));
526 IntAna2d_AnaIntersection Inters4(theCurv, IntAna2d_Conic(L4));
527 if (Inters4.IsDone()) {
528 if (!Inters4.IsEmpty()) {
529 for (npi=1; npi<=Inters4.NbPoints(); npi++) {
530 yint[nbpi]=Inters4.Point(npi).Value().Y();
531 if (ymin <= yint[nbpi] && yint[nbpi] < ymax) {
533 parint[nbpi]=Inters4.Point(npi).ParamOnFirst();
547 //=======================================================================
550 //=======================================================================
552 void Intf_Tool::LinBox(const gp_Lin& L,
553 const Bnd_Box& domain,
558 if (domain.IsWhole()) {
559 boxLin.Set(L.Location(), L.Direction());
560 boxLin.Add(L.Direction().Reversed());
562 beginOnCurve[0]=-Precision::Infinite();
563 endOnCurve[0]=Precision::Infinite();
566 else if (domain.IsVoid()) return;
568 Standard_Real xmin, xmax, ymin, ymax, zmin, zmax;
569 Standard_Real Xmin=0, Xmax=0, Ymin=0, Ymax=0, Zmin=0, Zmax=0;
570 Standard_Real parmin=-Precision::Infinite();
571 Standard_Real parmax=Precision::Infinite();
572 Standard_Real parcur, par1,par2;
573 Standard_Boolean xToSet, yToSet, zToSet;
575 domain.Get(xmin,ymin,zmin,xmax,ymax,zmax);
578 if (L.Direction().XYZ().X()>0.) {
579 if (domain.IsOpenXmin()) parmin=-Precision::Infinite();
580 else parmin=(xmin-L.Location().XYZ().X())/L.Direction().XYZ().X();
581 if (domain.IsOpenXmax()) parmax=Precision::Infinite();
582 else parmax=(xmax-L.Location().XYZ().X())/L.Direction().XYZ().X();
583 xToSet=Standard_True;
585 else if (L.Direction().XYZ().X()<0.) {
586 if (domain.IsOpenXmax()) parmin=-Precision::Infinite();
587 else parmin=(xmax-L.Location().XYZ().X())/L.Direction().XYZ().X();
588 if (domain.IsOpenXmin()) parmax=Precision::Infinite();
589 else parmax=(xmin-L.Location().XYZ().X())/L.Direction().XYZ().X();
590 xToSet=Standard_True;
592 else { // Perpendiculaire a l axe X
593 if (L.Location().XYZ().X()<xmin || xmax<L.Location().XYZ().X())
595 Xmin=L.Location().XYZ().X();
596 Xmax=L.Location().XYZ().X();
597 xToSet=Standard_False;
600 if (L.Direction().XYZ().Y()>0.) {
601 if (domain.IsOpenYmin()) parcur=-Precision::Infinite();
602 else parcur=(ymin-L.Location().XYZ().Y())/L.Direction().XYZ().Y();
603 parmin=Max(parmin, parcur);
604 if (domain.IsOpenYmax()) parcur=Precision::Infinite();
605 else parcur=(ymax-L.Location().XYZ().Y())/L.Direction().XYZ().Y();
606 parmax=Min(parmax, parcur);
607 yToSet=Standard_True;
609 else if (L.Direction().XYZ().Y()<0.) {
610 if (domain.IsOpenYmax()) parcur=-Precision::Infinite();
611 else parcur=(ymax-L.Location().XYZ().Y())/L.Direction().XYZ().Y();
612 parmin=Max(parmin, parcur);
613 if (domain.IsOpenYmin()) parcur=Precision::Infinite();
614 else parcur=(ymin-L.Location().XYZ().Y())/L.Direction().XYZ().Y();
615 parmax=Min(parmax, parcur);
616 yToSet=Standard_True;
618 else { // Perpendiculaire a l axe Y
619 if (L.Location().XYZ().Y()<ymin || ymax<L.Location().XYZ().Y())
621 Ymin=L.Location().XYZ().Y();
622 Ymax=L.Location().XYZ().Y();
623 yToSet=Standard_False;
626 if (L.Direction().XYZ().Z()>0.) {
627 if (domain.IsOpenZmin()) parcur=-Precision::Infinite();
628 else parcur=(zmin-L.Location().XYZ().Z())/L.Direction().XYZ().Z();
629 parmin=Max(parmin, parcur);
630 if (domain.IsOpenZmax()) parcur=Precision::Infinite();
631 else parcur=(zmax-L.Location().XYZ().Z())/L.Direction().XYZ().Z();
632 parmax=Min(parmax, parcur);
633 zToSet=Standard_True;
635 else if (L.Direction().XYZ().Z()<0.) {
636 if (domain.IsOpenZmax()) parcur=-Precision::Infinite();
637 else parcur=(zmax-L.Location().XYZ().Z())/L.Direction().XYZ().Z();
638 parmin=Max(parmin, parcur);
639 if (domain.IsOpenZmin()) parcur=Precision::Infinite();
640 else parcur=(zmin-L.Location().XYZ().Z())/L.Direction().XYZ().Z();
641 parmax=Min(parmax, parcur);
642 zToSet=Standard_True;
644 else { // Perpendicular to axis Z
645 if (L.Location().XYZ().Z()<zmin || zmax<L.Location().XYZ().Z())
647 Zmin=L.Location().XYZ().Z();
648 Zmax=L.Location().XYZ().Z();
649 zToSet=Standard_False;
653 beginOnCurve[0]=parmin;
654 endOnCurve[0]=parmax;
657 par1=L.Location().XYZ().X()+parmin*L.Direction().XYZ().X();
658 par2=L.Location().XYZ().X()+parmax*L.Direction().XYZ().X();
659 Xmin=Min(par1, par2);
660 Xmax=Max(par1, par2);
664 par1=L.Location().XYZ().Y()+parmin*L.Direction().XYZ().Y();
665 par2=L.Location().XYZ().Y()+parmax*L.Direction().XYZ().Y();
666 Ymin=Min(par1, par2);
667 Ymax=Max(par1, par2);
671 par1=L.Location().XYZ().Z()+parmin*L.Direction().XYZ().Z();
672 par2=L.Location().XYZ().Z()+parmax*L.Direction().XYZ().Z();
673 Zmin=Min(par1, par2);
674 Zmax=Max(par1, par2);
677 boxLin.Update(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
680 //=======================================================================
683 //=======================================================================
684 void Intf_Tool::HyprBox(const gp_Hypr& theHypr,
685 const Bnd_Box& domain,
691 if (domain.IsWhole()) {
694 //beginOnCurve[0]=-Precision::Infinite();
695 //endOnCurve[0]=Precision::Infinite();
696 beginOnCurve[0]=-100.;
700 else if (domain.IsVoid()) {
704 Standard_Integer nbPi;
706 nbPi=Inters3d(theHypr, domain);
708 Standard_Integer npi;
709 Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
711 domain.Get(Xmax, Ymax, Zmax, Xmin, Ymin, Zmin);
713 for (npi=0; npi<nbPi; npi++) {
714 Xmin=Min(Xmin, xint[npi]);
715 Xmax=Max(Xmax, xint[npi]);
716 Ymin=Min(Ymin, yint[npi]);
717 Ymax=Max(Ymax, yint[npi]);
718 Zmin=Min(Zmin, zint[npi]);
719 Zmax=Max(Zmax, yint[npi]);
721 boxHypr.Update(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
723 Standard_Integer npj, npk;
724 Standard_Real parmin;
725 for (npi=0; npi<nbPi; npi++) {
727 for (npj=npi+1; npj<nbPi; npj++) {
728 if (parint[npj]<parint[npk]) {
734 parint[npk]=parint[npi];
744 Standard_Real sinan=0;
745 Standard_Boolean out=Standard_True;
747 for (npi=0; npi<nbPi; npi++) {
748 ElCLib::D1(parint[npi], theHypr, Pn, Tan);
750 case 1 : sinan=gp_XYZ( 1., 0., 0.)*Tan.XYZ(); break;
751 case 2 : sinan=gp_XYZ( 0., 1., 0.)*Tan.XYZ(); break;
752 case 3 : sinan=gp_XYZ( 0., 0., 1.)*Tan.XYZ(); break;
753 case 4 : sinan=gp_XYZ(-1., 0., 0.)*Tan.XYZ(); break;
754 case 5 : sinan=gp_XYZ( 0.,-1., 0.)*Tan.XYZ(); break;
755 case 6 : sinan=gp_XYZ( 0., 0.,-1.)*Tan.XYZ(); break;
757 if (Abs(sinan)>Precision::Angular()) {
760 beginOnCurve[nbSeg]=parint[npi];
761 //// modified by jgv, 10.11.2009 /////
762 endOnCurve[nbSeg] = 10.;
763 //////////////////////////////////////
768 //modified by NIZNHY-PKV Fri Jul 11 13:59:10 2008f
769 beginOnCurve[nbSeg]=-10.;
770 //beginOnCurve[nbSeg]=-Precision::Infinite();
771 //modified by NIZNHY-PKV Fri Jul 11 13:59:13 2008t
774 endOnCurve[nbSeg-1]=parint[npi];
777 //modified by NIZNHY-PKV Fri Jul 11 13:54:54 2008f
778 Standard_Real ipmin, ipmax, ip, pas;
781 if (beginOnCurve[nbSeg-1]>ipmin) {
782 ipmin=beginOnCurve[nbSeg-1];
785 if (endOnCurve[nbSeg-1]<ipmax) {
786 ipmax=endOnCurve[nbSeg-1];
792 for (ip=ipmin; ip<=ipmax; ip+=pas) {
793 boxHypr.Add(ElCLib::Value(ip/10., theHypr));
800 Standard_Integer ipmin=Max((Standard_Integer)(beginOnCurve[nbSeg-1]), -10);
801 Standard_Integer ipmax=Min((Standard_Integer)(endOnCurve[nbSeg-1]), 10);
805 Standard_Integer ip, pas=1;
806 for (ip=ipmin; ip<=ipmax; ip+=pas) {
807 boxHypr.Add(ElCLib::Value(Standard_Real(ip)/10., theHypr));
817 //modified by NIZNHY-PKV Fri Jul 11 13:55:04 2008t
822 else if (!domain.IsOut(ElCLib::Value(0., theHypr))) {
824 //beginOnCurve[0]=-Precision::Infinite();
825 //endOnCurve[0]=Precision::Infinite();
826 beginOnCurve[0]=-100.;
832 //=======================================================================
833 //function : Inters3d
835 //=======================================================================
837 Standard_Integer Intf_Tool::Inters3d(const gp_Hypr& theCurv,
838 const Bnd_Box& Domain)
840 Standard_Integer nbpi=0;
841 Standard_Integer npi;
842 Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
844 Domain.Get(xmin, ymin, zmin, xmax, ymax, zmax);
846 if (!Domain.IsOpenXmin()) {
847 IntAna_IntConicQuad Inters1(theCurv,
848 gp_Pln(1., 0., 0., xmin),
849 Precision::Angular());
850 if (Inters1.IsDone()) {
851 if (!Inters1.IsInQuadric()) {
852 for (npi=1; npi<=Inters1.NbPoints(); npi++) {
853 yint[nbpi]=Inters1.Point(npi).Y();
854 zint[nbpi]=Inters1.Point(npi).Z();
855 if (ymin <=yint[nbpi] && yint[nbpi] < ymax &&
856 zmin <=zint[nbpi] && zint[nbpi] < zmax) {
858 parint[nbpi]=Inters1.ParamOnConic(npi);
867 if (!Domain.IsOpenYmin()) {
868 IntAna_IntConicQuad Inters1(theCurv,
869 gp_Pln( 0., 1., 0., ymin),
870 Precision::Angular());
871 if (Inters1.IsDone()) {
872 if (!Inters1.IsInQuadric()) {
873 for (npi=1; npi<=Inters1.NbPoints(); npi++) {
874 xint[nbpi]=Inters1.Point(npi).X();
875 zint[nbpi]=Inters1.Point(npi).Z();
876 if (xmin < xint[nbpi] && xint[nbpi] <=xmax &&
877 zmin <=zint[nbpi] && zint[nbpi] < zmax) {
879 parint[nbpi]=Inters1.ParamOnConic(npi);
888 if (!Domain.IsOpenZmin()) {
889 IntAna_IntConicQuad Inters1(theCurv,
890 gp_Pln( 0., 0., 1., zmin),
891 Precision::Angular());
892 if (Inters1.IsDone()) {
893 if (!Inters1.IsInQuadric()) {
894 for (npi=1; npi<=Inters1.NbPoints(); npi++) {
895 xint[nbpi]=Inters1.Point(npi).X();
896 yint[nbpi]=Inters1.Point(npi).Y();
897 if (xmin < xint[nbpi] && xint[nbpi] <=xmax &&
898 ymin < yint[nbpi] && yint[nbpi] <=ymax) {
900 parint[nbpi]=Inters1.ParamOnConic(npi);
909 if (!Domain.IsOpenXmax()) {
910 IntAna_IntConicQuad Inters1(theCurv,
911 gp_Pln(-1., 0., 0., xmax),
912 Precision::Angular());
913 if (Inters1.IsDone()) {
914 if (!Inters1.IsInQuadric()) {
915 for (npi=1; npi<=Inters1.NbPoints(); npi++) {
916 yint[nbpi]=Inters1.Point(npi).Y();
917 zint[nbpi]=Inters1.Point(npi).Z();
918 if (ymin < yint[nbpi] && yint[nbpi] <=ymax &&
919 zmin < zint[nbpi] && zint[nbpi] <=zmax) {
921 parint[nbpi]=Inters1.ParamOnConic(npi);
930 if (!Domain.IsOpenYmax()) {
931 IntAna_IntConicQuad Inters1(theCurv,
932 gp_Pln( 0.,-1., 0., ymax),
933 Precision::Angular());
934 if (Inters1.IsDone()) {
935 if (!Inters1.IsInQuadric()) {
936 for (npi=1; npi<=Inters1.NbPoints(); npi++) {
937 xint[nbpi]=Inters1.Point(npi).X();
938 zint[nbpi]=Inters1.Point(npi).Z();
939 if (xmin <=xint[nbpi] && xint[nbpi] < xmax &&
940 zmin < zint[nbpi] && zint[nbpi] <=zmax) {
942 parint[nbpi]=Inters1.ParamOnConic(npi);
951 if (!Domain.IsOpenZmax()) {
952 IntAna_IntConicQuad Inters1(theCurv,
953 gp_Pln( 0., 0.,-1., zmax),
954 Precision::Angular());
955 if (Inters1.IsDone()) {
956 if (!Inters1.IsInQuadric()) {
957 for (npi=1; npi<=Inters1.NbPoints(); npi++) {
958 xint[nbpi]=Inters1.Point(npi).X();
959 yint[nbpi]=Inters1.Point(npi).Y();
960 if (xmin <=xint[nbpi] && xint[nbpi] < xmax &&
961 ymin <=yint[nbpi] && yint[nbpi] < ymax) {
963 parint[nbpi]=Inters1.ParamOnConic(npi);
975 //=======================================================================
976 //function : ParabBox
978 //=======================================================================
980 void Intf_Tool::ParabBox(const gp_Parab&,
981 const Bnd_Box& domain,
986 if (domain.IsWhole()) {
989 beginOnCurve[0]=-Precision::Infinite();
990 endOnCurve[0]=Precision::Infinite();
993 else if (domain.IsVoid()) return;
999 //=======================================================================
1000 //function : NbSegments
1002 //=======================================================================
1004 Standard_Integer Intf_Tool::NbSegments() const
1009 //=======================================================================
1010 //function : BeginParam
1012 //=======================================================================
1014 Standard_Real Intf_Tool::BeginParam(const Standard_Integer SegmentNum) const
1016 Standard_OutOfRange_Raise_if(SegmentNum<1 || SegmentNum>nbSeg ,
1017 "Intf_Tool::BeginParam");
1018 return beginOnCurve[SegmentNum-1];
1021 //=======================================================================
1022 //function : EndParam
1024 //=======================================================================
1026 Standard_Real Intf_Tool::EndParam(const Standard_Integer SegmentNum) const
1028 Standard_OutOfRange_Raise_if(SegmentNum<1 || SegmentNum>nbSeg ,
1029 "Intf_Tool::EndParam");
1030 return endOnCurve[SegmentNum-1];