0029151: GCC 7.1 warnings "this statement may fall through" [-Wimplicit-fallthrough=]
[occt.git] / src / BndLib / BndLib.cxx
1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15
16 #include <Bnd_Box.hxx>
17 #include <Bnd_Box2d.hxx>
18 #include <BndLib.hxx>
19 #include <ElCLib.hxx>
20 #include <gp_Circ.hxx>
21 #include <gp_Circ2d.hxx>
22 #include <gp_Cone.hxx>
23 #include <gp_Cylinder.hxx>
24 #include <gp_Elips.hxx>
25 #include <gp_Elips2d.hxx>
26 #include <gp_Hypr.hxx>
27 #include <gp_Hypr2d.hxx>
28 #include <gp_Lin.hxx>
29 #include <gp_Lin2d.hxx>
30 #include <gp_Parab.hxx>
31 #include <gp_Parab2d.hxx>
32 #include <gp_Pnt.hxx>
33 #include <gp_Pnt2d.hxx>
34 #include <gp_Sphere.hxx>
35 #include <gp_Torus.hxx>
36 #include <gp_XY.hxx>
37 #include <gp_XYZ.hxx>
38 #include <Precision.hxx>
39 #include <Standard_Failure.hxx>
40 #include <ElSLib.hxx>
41
42 static 
43   Standard_Integer ComputeBox(const gp_Hypr& aHypr, 
44                               const Standard_Real aT1, 
45                               const Standard_Real aT2, 
46                               Bnd_Box& aBox);
47
48
49 namespace
50 {
51   //! Compute method
52   template<class PointType, class BndBoxType>
53   void Compute (const Standard_Real theP1, const Standard_Real theP2,
54                 const Standard_Real theRa ,const Standard_Real theRb,
55                 const PointType& theXd, const PointType& theYd, const PointType& theO,
56                 BndBoxType& theB)
57   {
58     Standard_Real aTeta1;
59     Standard_Real aTeta2;
60     if(theP2 < theP1)
61     { 
62       aTeta1 = theP2;
63       aTeta2 = theP1;
64     }
65     else
66     {
67       aTeta1 = theP1;
68       aTeta2 = theP2;
69     }
70
71     Standard_Real aDelta = Abs(aTeta2-aTeta1); 
72     if(aDelta > 2. * M_PI)
73     {
74       aTeta1 = 0.;
75       aTeta2 = 2. * M_PI;
76     }
77     else
78     {
79       if(aTeta1 < 0.)
80       {
81         do{ aTeta1 += 2.*M_PI; } while (aTeta1 < 0.);
82       }
83       else if (aTeta1 > 2.*M_PI)
84       {
85         do { aTeta1 -= 2.*M_PI; } while (aTeta1 > 2.*M_PI);
86       }
87       aTeta2 = aTeta1 + aDelta;
88     }
89
90     // One places already both ends
91     Standard_Real aCn1, aSn1 ,aCn2, aSn2;
92     aCn1 = Cos(aTeta1); aSn1 = Sin(aTeta1);
93     aCn2 = Cos(aTeta2); aSn2 = Sin(aTeta2);
94     theB.Add(PointType( theO.Coord() +theRa*aCn1*theXd.Coord() +theRb*aSn1*theYd.Coord()));
95     theB.Add(PointType(theO.Coord() +theRa*aCn2*theXd.Coord() +theRb*aSn2*theYd.Coord()));
96     
97     Standard_Real aRam, aRbm;
98     if (aDelta > M_PI/8.)
99     {
100       // Main radiuses to take into account only 8 points (/cos(Pi/8.))
101       aRam = theRa/0.92387953251128674;
102       aRbm = theRb/0.92387953251128674;
103     }
104     else
105     {
106       // Main radiuses to take into account the arrow
107       Standard_Real aTc = cos(aDelta/2);
108       aRam = theRa/aTc;
109       aRbm = theRb/aTc;
110     }
111     theB.Add(PointType(theO.Coord() + aRam*aCn1*theXd.Coord() + aRbm*aSn1*theYd.Coord()));
112     theB.Add(PointType(theO.Coord() + aRam*aCn2*theXd.Coord() + aRbm*aSn2*theYd.Coord()));
113
114 // cos or sin M_PI/4.
115 #define PI4 0.70710678118654746
116
117 // 8 points of the polygon
118 #define addPoint0 theB.Add(PointType(theO.Coord() +aRam*theXd.Coord()))
119 #define addPoint1 theB.Add(PointType(theO.Coord() +aRam*PI4*theXd.Coord() +aRbm*PI4*theYd.Coord()))
120 #define addPoint2 theB.Add(PointType(theO.Coord() +aRbm*theYd.Coord()))
121 #define addPoint3 theB.Add(PointType(theO.Coord() -aRam*PI4*theXd.Coord() +aRbm*PI4*theYd.Coord()))
122 #define addPoint4 theB.Add(PointType(theO.Coord() -aRam*theXd.Coord() ))
123 #define addPoint5 theB.Add(PointType(theO.Coord() -aRam*PI4*theXd.Coord() -aRbm*PI4*theYd.Coord()))
124 #define addPoint6 theB.Add(PointType(theO.Coord() -aRbm*theYd.Coord()))
125 #define addPoint7 theB.Add(PointType(theO.Coord() +aRam*PI4*theXd.Coord() -aRbm*PI4*theYd.Coord()))
126
127     Standard_Integer aDeb = (Standard_Integer )( aTeta1/(M_PI/4.));
128     Standard_Integer aFin = (Standard_Integer )( aTeta2/(M_PI/4.));
129     aDeb++;
130
131     if (aDeb > aFin) return;
132
133     switch (aDeb)
134     {
135     case 1:
136       {
137         addPoint1;
138         if (aFin <= 1) break;
139       }
140       Standard_FALLTHROUGH
141     case 2:
142       {
143         addPoint2;
144         if (aFin <= 2) break;
145       }
146       Standard_FALLTHROUGH
147     case 3:
148       {
149         addPoint3;
150         if (aFin <= 3) break;
151       }
152       Standard_FALLTHROUGH
153     case 4:
154       {
155         addPoint4;
156         if (aFin <= 4) break;
157       }
158       Standard_FALLTHROUGH
159     case 5:
160       {
161         addPoint5;
162         if (aFin <= 5) break;
163       }
164       Standard_FALLTHROUGH
165     case 6:
166       {
167         addPoint6;
168         if (aFin <= 6) break;
169       }
170       Standard_FALLTHROUGH
171     case 7:
172       {
173         addPoint7;
174         if (aFin <= 7) break;
175       }
176       Standard_FALLTHROUGH
177     case 8:
178       {
179         addPoint0;
180         if (aFin <= 8) break;
181       }
182       Standard_FALLTHROUGH
183     case 9:
184       {
185         addPoint1;
186         if (aFin <= 9) break;
187       }  
188       Standard_FALLTHROUGH
189     case 10:
190       {
191         addPoint2;
192         if (aFin <= 10) break;
193       }
194       Standard_FALLTHROUGH
195     case 11:
196       {
197         addPoint3;
198         if (aFin <= 11) break;
199       }  
200       Standard_FALLTHROUGH
201     case 12:
202       {
203         addPoint4;
204         if (aFin <= 12) break;
205       }  
206       Standard_FALLTHROUGH
207     case 13:
208       {
209         addPoint5;
210         if (aFin <= 13) break;
211       }
212       Standard_FALLTHROUGH
213     case 14:
214       {
215         addPoint6;
216         if (aFin <= 14) break;
217       }
218       Standard_FALLTHROUGH
219     case 15:
220       {
221         addPoint7;
222         if (aFin <= 15) break;
223       }
224     }
225   }
226 } // end namespace
227
228 static void OpenMin(const gp_Dir& V,Bnd_Box& B) {
229   gp_Dir OX(1.,0.,0.);
230   gp_Dir OY(0.,1.,0.);
231   gp_Dir OZ(0.,0.,1.);
232   if (V.IsParallel(OX,Precision::Angular())) 
233     B.OpenXmin();
234   else if (V.IsParallel(OY,Precision::Angular())) 
235     B.OpenYmin();
236   else if (V.IsParallel(OZ,Precision::Angular())) 
237     B.OpenZmin();
238   else {
239     B.OpenXmin();B.OpenYmin();B.OpenZmin();
240   }
241 }
242
243 static void OpenMax(const gp_Dir& V,Bnd_Box& B) {
244   gp_Dir OX(1.,0.,0.);
245   gp_Dir OY(0.,1.,0.);
246   gp_Dir OZ(0.,0.,1.);
247   if (V.IsParallel(OX,Precision::Angular())) 
248     B.OpenXmax();
249   else if (V.IsParallel(OY,Precision::Angular())) 
250     B.OpenYmax();
251   else if (V.IsParallel(OZ,Precision::Angular())) 
252     B.OpenZmax();
253   else {
254     B.OpenXmax();B.OpenYmax();B.OpenZmax();
255   }
256 }
257
258 static void OpenMinMax(const gp_Dir& V,Bnd_Box& B) {
259   gp_Dir OX(1.,0.,0.);
260   gp_Dir OY(0.,1.,0.);
261   gp_Dir OZ(0.,0.,1.);
262   if (V.IsParallel(OX,Precision::Angular())) {
263     B.OpenXmax();B.OpenXmin();
264   }
265   else if (V.IsParallel(OY,Precision::Angular())) {
266     B.OpenYmax();B.OpenYmin();
267   }
268   else if (V.IsParallel(OZ,Precision::Angular())) {
269     B.OpenZmax();B.OpenZmin();
270   }
271   else {
272     B.OpenXmin();B.OpenYmin();B.OpenZmin();
273     B.OpenXmax();B.OpenYmax();B.OpenZmax();
274   }
275 }
276
277 static void OpenMin(const gp_Dir2d& V,Bnd_Box2d& B) {
278   gp_Dir2d OX(1.,0.);
279   gp_Dir2d OY(0.,1.);
280   if (V.IsParallel(OX,Precision::Angular())) 
281     B.OpenXmin();
282   else if (V.IsParallel(OY,Precision::Angular())) 
283     B.OpenYmin();
284   else {
285     B.OpenXmin();B.OpenYmin();
286   }
287 }
288
289 static void OpenMax(const gp_Dir2d& V,Bnd_Box2d& B) {
290   gp_Dir2d OX(1.,0.);
291   gp_Dir2d OY(0.,1.);
292   if (V.IsParallel(OX,Precision::Angular())) 
293     B.OpenXmax();
294   else if (V.IsParallel(OY,Precision::Angular())) 
295     B.OpenYmax();
296   else {
297     B.OpenXmax();B.OpenYmax();
298   }
299 }
300
301 static void OpenMinMax(const gp_Dir2d& V,Bnd_Box2d& B) {
302   gp_Dir2d OX(1.,0.);
303   gp_Dir2d OY(0.,1.);
304   if (V.IsParallel(OX,Precision::Angular())) {
305     B.OpenXmax();B.OpenXmin();
306   }
307   else if (V.IsParallel(OY,Precision::Angular())) {
308     B.OpenYmax();B.OpenYmin();
309   }
310   else {
311     B.OpenXmin();B.OpenYmin();
312     B.OpenXmax();B.OpenYmax();
313   }
314 }
315
316
317 void BndLib::Add( const gp_Lin& L,const Standard_Real P1,
318                  const Standard_Real P2,
319                  const Standard_Real Tol, Bnd_Box& B) {
320
321   if (Precision::IsNegativeInfinite(P1)) {
322     if (Precision::IsNegativeInfinite(P2)) {
323       throw Standard_Failure("BndLib::bad parameter");
324     }
325     else if (Precision::IsPositiveInfinite(P2)) {
326       OpenMinMax(L.Direction(),B);
327       B.Add(ElCLib::Value(0.,L));
328     }
329     else {
330       OpenMin(L.Direction(),B);
331       B.Add(ElCLib::Value(P2,L));
332     }
333   }
334   else if (Precision::IsPositiveInfinite(P1)) {
335     if (Precision::IsNegativeInfinite(P2)) {
336       OpenMinMax(L.Direction(),B);
337       B.Add(ElCLib::Value(0.,L));
338     }
339     else if (Precision::IsPositiveInfinite(P2)) {
340       throw Standard_Failure("BndLib::bad parameter");
341     }
342     else {
343       OpenMax(L.Direction(),B);
344       B.Add(ElCLib::Value(P2,L));
345     }
346   }
347   else  {
348     B.Add(ElCLib::Value(P1,L));
349     if (Precision::IsNegativeInfinite(P2)) {
350       OpenMin(L.Direction(),B);
351     }
352     else if (Precision::IsPositiveInfinite(P2)){
353       OpenMax(L.Direction(),B);
354     }
355     else {
356       B.Add(ElCLib::Value(P2,L));
357     }
358   }
359   B.Enlarge(Tol);
360 }
361
362 void BndLib::Add( const gp_Lin2d& L,const Standard_Real P1,
363                  const Standard_Real P2,
364                  const Standard_Real Tol, Bnd_Box2d& B) {
365
366   if (Precision::IsNegativeInfinite(P1)) {
367     if (Precision::IsNegativeInfinite(P2)) {
368       throw Standard_Failure("BndLib::bad parameter");
369     }
370     else if (Precision::IsPositiveInfinite(P2)) {
371       OpenMinMax(L.Direction(),B);
372       B.Add(ElCLib::Value(0.,L));
373     }
374     else {
375       OpenMin(L.Direction(),B);
376       B.Add(ElCLib::Value(P2,L));
377     }
378   }
379   else if (Precision::IsPositiveInfinite(P1)) {
380     if (Precision::IsNegativeInfinite(P2)) {
381       OpenMinMax(L.Direction(),B);
382       B.Add(ElCLib::Value(0.,L));
383     }
384     else if (Precision::IsPositiveInfinite(P2)) {
385       throw Standard_Failure("BndLib::bad parameter");
386     }
387     else {
388       OpenMax(L.Direction(),B);
389       B.Add(ElCLib::Value(P2,L));
390     }
391   }
392   else  {
393     B.Add(ElCLib::Value(P1,L));
394     if (Precision::IsNegativeInfinite(P2)) {
395       OpenMin(L.Direction(),B);
396     }
397     else if (Precision::IsPositiveInfinite(P2)){
398       OpenMax(L.Direction(),B);
399     }
400     else {
401       B.Add(ElCLib::Value(P2,L));
402     }
403   }
404   B.Enlarge(Tol);
405 }
406
407 void BndLib::Add( const gp_Circ& C, const Standard_Real Tol, Bnd_Box& B) 
408 {
409   Standard_Real U1 = 0., U2 = 2.*M_PI;
410   Add(C, U1, U2, Tol, B);
411 }
412
413 void BndLib::Add(const gp_Circ& C,
414                  const Standard_Real U1,
415                  const Standard_Real U2,
416                  const Standard_Real Tol, 
417                  Bnd_Box& B) 
418 {
419   Standard_Real period = 2.*M_PI - Epsilon(2.*M_PI);
420
421   Standard_Real utrim1 = U1, utrim2 = U2;
422   if(U2 - U1 > period)
423   {
424     utrim1 = 0.;
425     utrim2 = 2.*M_PI;
426   }
427   else
428   {
429     Standard_Real tol = Epsilon(1.);
430     ElCLib::AdjustPeriodic(0., 2.*M_PI,
431                            tol,
432                            utrim1, utrim2);
433   }
434   Standard_Real R = C.Radius();
435   gp_XYZ O  = C.Location().XYZ();
436   gp_XYZ Xd = C.XAxis().Direction().XYZ();
437   gp_XYZ Yd = C.YAxis().Direction().XYZ();
438   const gp_Ax2& pos = C.Position();
439   //
440   Standard_Real tt;
441   Standard_Real xmin, xmax, txmin, txmax;
442   if(Abs(Xd.X()) > gp::Resolution())
443   {
444     txmin = ATan(Yd.X() / Xd.X());
445     txmin = ElCLib::InPeriod(txmin, 0., 2.*M_PI);
446   }
447   else
448   {
449     txmin = M_PI/ 2.;
450   }
451   txmax = txmin <= M_PI? txmin + M_PI : txmin - M_PI;
452   xmin = R * Cos(txmin) * Xd.X() + R * Sin(txmin) * Yd.X() + O.X();
453   xmax = R * Cos(txmax) * Xd.X() + R * Sin(txmax) * Yd.X() + O.X();
454   if(xmin > xmax)
455   {
456     tt = xmin;
457     xmin = xmax;
458     xmax = tt;
459     tt = txmin;
460     txmin = txmax;
461     txmax = tt;
462   }
463   //
464   Standard_Real ymin, ymax, tymin, tymax;
465   if(Abs(Xd.Y()) > gp::Resolution())
466   {
467     tymin = ATan(Yd.Y() / Xd.Y());
468     tymin = ElCLib::InPeriod(tymin, 0., 2.*M_PI);
469   }
470   else
471   {
472     tymin = M_PI/ 2.;
473   }
474   tymax = tymin <= M_PI? tymin + M_PI : tymin - M_PI;
475   ymin = R * Cos(tymin) * Xd.Y() + R * Sin(tymin) * Yd.Y() + O.Y();
476   ymax = R * Cos(tymax) * Xd.Y() + R * Sin(tymax) * Yd.Y() + O.Y();
477   if(ymin > ymax)
478   {
479     tt = ymin;
480     ymin = ymax;
481     ymax = tt;
482     tt = tymin;
483     tymin = tymax;
484     tymax = tt;
485   }
486   //
487   Standard_Real zmin, zmax, tzmin, tzmax;
488   if(Abs(Xd.Z()) > gp::Resolution())
489   {
490     tzmin = ATan(Yd.Z() / Xd.Z());
491     tzmin = ElCLib::InPeriod(tzmin, 0., 2.*M_PI);
492   }
493   else
494   {
495     tzmin = M_PI/ 2.;
496   }
497   tzmax = tzmin <= M_PI? tzmin + M_PI : tzmin - M_PI;
498   zmin = R * Cos(tzmin) * Xd.Z() + R * Sin(tzmin) * Yd.Z() + O.Z();
499   zmax = R * Cos(tzmax) * Xd.Z() + R * Sin(tzmax) * Yd.Z() + O.Z();
500   if(zmin > zmax)
501   {
502     tt = zmin;
503     zmin = zmax;
504     zmax = tt;
505     tt = tzmin;
506     tzmin = tzmax;
507     tzmax = tt;
508   }
509   //
510   if(utrim2 - utrim1 >= period)
511   {
512     B.Update(xmin, ymin, zmin, xmax, ymax, zmax);
513   }
514   else
515   {
516     gp_Pnt P = ElCLib::CircleValue(utrim1, pos, R);
517     B.Add(P);
518     P = ElCLib::CircleValue(utrim2, pos, R);
519     B.Add(P);
520     Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
521     B.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
522     Standard_Real gap = B.GetGap();
523     Xmin += gap;
524     Ymin += gap;
525     Zmin += gap;
526     Xmax -= gap;
527     Ymax -= gap;
528     Zmax -= gap;
529     //
530     txmin = ElCLib::InPeriod(txmin, utrim1, utrim1 + 2. * M_PI);
531     if(txmin >= utrim1 && txmin <= utrim2)
532     {
533       Xmin = Min(xmin, Xmin);
534     }
535     txmax = ElCLib::InPeriod(txmax, utrim1, utrim1 + 2. * M_PI);
536     if(txmax >= utrim1 && txmax <= utrim2)
537     {
538       Xmax = Max(xmax, Xmax);
539    }
540     //
541     tymin = ElCLib::InPeriod(tymin, utrim1, utrim1 + 2. * M_PI);
542     if(tymin >= utrim1 && tymin <= utrim2)
543     {
544       Ymin = Min(ymin, Ymin);
545     }
546     tymax = ElCLib::InPeriod(tymax, utrim1, utrim1 + 2. * M_PI);
547     if(tymax >= utrim1 && tymax <= utrim2)
548     {
549       Ymax = Max(ymax, Ymax);
550     }
551     //
552     tzmin = ElCLib::InPeriod(tzmin, utrim1, utrim1 + 2. * M_PI);
553     if(tzmin >= utrim1 && tzmin <= utrim2)
554     {
555       Zmin = Min(zmin, Zmin);
556     }
557     tzmax = ElCLib::InPeriod(tzmax, utrim1, utrim1 + 2. * M_PI);
558     if(tzmax >= utrim1 && tzmax <= utrim2)
559     {
560       Zmax = Max(zmax, Zmax);
561     }
562     //
563     B.Update(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
564   }
565   //
566   B.Enlarge(Tol);
567 }
568
569 void BndLib::Add( const gp_Circ2d& C,const Standard_Real Tol, Bnd_Box2d& B) {
570
571   Standard_Real R = C.Radius();
572   gp_XY O  = C.Location().XY();
573   gp_XY Xd = C.XAxis().Direction().XY();
574   gp_XY Yd = C.YAxis().Direction().XY();
575   B.Add(gp_Pnt2d(O -R*Xd -R*Yd));
576   B.Add(gp_Pnt2d(O -R*Xd +R*Yd));
577   B.Add(gp_Pnt2d(O +R*Xd -R*Yd));
578   B.Add(gp_Pnt2d(O +R*Xd +R*Yd));
579   B.Enlarge(Tol);
580 }
581
582 void BndLib::Add(const gp_Circ2d& C,const Standard_Real P1,
583    const Standard_Real P2,
584    const Standard_Real Tol, Bnd_Box2d& B) {
585
586        Compute(P1,P2,C.Radius(),C.Radius(),gp_Pnt2d(C.XAxis().Direction().XY()),
587          gp_Pnt2d(C.YAxis().Direction().XY()),C.Location(),B);
588   B.Enlarge(Tol);
589 }
590
591 void BndLib::Add(const gp_Elips& C, const Standard_Real Tol, Bnd_Box& B) 
592 {
593   Standard_Real U1 = 0., U2 = 2.*M_PI;
594   Add(C, U1, U2, Tol, B);
595 }
596
597 void BndLib::Add(const gp_Elips& C,
598                  const Standard_Real U1,
599                  const Standard_Real U2,
600                  const Standard_Real Tol, 
601                  Bnd_Box& B) 
602 {
603   Standard_Real period = 2.*M_PI - Epsilon(2.*M_PI);
604
605   Standard_Real utrim1 = U1, utrim2 = U2;
606   if(U2 - U1 > period)
607   {
608     utrim1 = 0.;
609     utrim2 = 2.*M_PI;
610   }
611   else
612   {
613     Standard_Real tol = Epsilon(1.);
614     ElCLib::AdjustPeriodic(0., 2.*M_PI,
615                            tol,
616                            utrim1, utrim2);
617   }
618   Standard_Real MajR = C.MajorRadius();
619   Standard_Real MinR = C.MinorRadius();
620   gp_XYZ O  = C.Location().XYZ();
621   gp_XYZ Xd = C.XAxis().Direction().XYZ();
622   gp_XYZ Yd = C.YAxis().Direction().XYZ();
623   const gp_Ax2& pos = C.Position();
624   //
625   Standard_Real tt;
626   Standard_Real xmin, xmax, txmin, txmax;
627   if(Abs(Xd.X()) > gp::Resolution())
628   {
629     txmin = ATan((MinR*Yd.X()) / (MajR*Xd.X()));
630     txmin = ElCLib::InPeriod(txmin, 0., 2.*M_PI);
631   }
632   else
633   {
634     txmin = M_PI/ 2.;
635   }
636   txmax = txmin <= M_PI? txmin + M_PI : txmin - M_PI;
637   xmin = MajR * Cos(txmin) * Xd.X() + MinR * Sin(txmin) * Yd.X() + O.X();
638   xmax = MajR * Cos(txmax) * Xd.X() + MinR * Sin(txmax) * Yd.X() + O.X();
639   if(xmin > xmax)
640   {
641     tt = xmin;
642     xmin = xmax;
643     xmax = tt;
644     tt = txmin;
645     txmin = txmax;
646     txmax = tt;
647   }
648   //
649   Standard_Real ymin, ymax, tymin, tymax;
650   if(Abs(Xd.Y()) > gp::Resolution())
651   {
652     tymin = ATan((MinR*Yd.Y()) / (MajR*Xd.Y()));
653     tymin = ElCLib::InPeriod(tymin, 0., 2.*M_PI);
654   }
655   else
656   {
657     tymin = M_PI/ 2.;
658   }
659   tymax = tymin <= M_PI? tymin + M_PI : tymin - M_PI;
660   ymin = MajR * Cos(tymin) * Xd.Y() + MinR * Sin(tymin) * Yd.Y() + O.Y();
661   ymax = MajR * Cos(tymax) * Xd.Y() + MinR * Sin(tymax) * Yd.Y() + O.Y();
662   if(ymin > ymax)
663   {
664     tt = ymin;
665     ymin = ymax;
666     ymax = tt;
667     tt = tymin;
668     tymin = tymax;
669     tymax = tt;
670   }
671   //
672   Standard_Real zmin, zmax, tzmin, tzmax;
673   if(Abs(Xd.Z()) > gp::Resolution())
674   {
675     tzmin = ATan((MinR*Yd.Z()) / (MajR*Xd.Z()));
676     tzmin = ElCLib::InPeriod(tzmin, 0., 2.*M_PI);
677   }
678   else
679   {
680     tzmin = M_PI/ 2.;
681   }
682   tzmax = tzmin <= M_PI? tzmin + M_PI : tzmin - M_PI;
683   zmin = MajR * Cos(tzmin) * Xd.Z() + MinR * Sin(tzmin) * Yd.Z() + O.Z();
684   zmax = MajR * Cos(tzmax) * Xd.Z() + MinR * Sin(tzmax) * Yd.Z() + O.Z();
685   if(zmin > zmax)
686   {
687     tt = zmin;
688     zmin = zmax;
689     zmax = tt;
690     tt = tzmin;
691     tzmin = tzmax;
692     tzmax = tt;
693   }
694   //
695   if(utrim2 - utrim1 >= period)
696   {
697     B.Update(xmin, ymin, zmin, xmax, ymax, zmax);
698   }
699   else
700   {
701     gp_Pnt P = ElCLib::EllipseValue(utrim1, pos, MajR, MinR);
702     B.Add(P);
703     P = ElCLib::EllipseValue(utrim2, pos, MajR, MinR);
704     B.Add(P);
705     Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
706     B.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
707     Standard_Real gap = B.GetGap();
708     Xmin += gap;
709     Ymin += gap;
710     Zmin += gap;
711     Xmax -= gap;
712     Ymax -= gap;
713     Zmax -= gap;
714     //
715     txmin = ElCLib::InPeriod(txmin, utrim1, utrim1 + 2. * M_PI);
716     if(txmin >= utrim1 && txmin <= utrim2)
717     {
718       Xmin = Min(xmin, Xmin);
719     }
720     txmax = ElCLib::InPeriod(txmax, utrim1, utrim1 + 2. * M_PI);
721     if(txmax >= utrim1 && txmax <= utrim2)
722     {
723       Xmax = Max(xmax, Xmax);
724     }
725     //
726     tymin = ElCLib::InPeriod(tymin, utrim1, utrim1 + 2. * M_PI);
727     if(tymin >= utrim1 && tymin <= utrim2)
728     {
729       Ymin = Min(ymin, Ymin);
730     }
731     tymax = ElCLib::InPeriod(tymax, utrim1, utrim1 + 2. * M_PI);
732     if(tymax >= utrim1 && tymax <= utrim2)
733     {
734       Ymax = Max(ymax, Ymax);
735     }
736     //
737     tzmin = ElCLib::InPeriod(tzmin, utrim1, utrim1 + 2. * M_PI);
738     if(tzmin >= utrim1 && tzmin <= utrim2)
739     {
740       Zmin = Min(zmin, Zmin);
741     }
742     tzmax = ElCLib::InPeriod(tzmax, utrim1, utrim1 + 2. * M_PI);
743     if(tzmax >= utrim1 && tzmax <= utrim2)
744     {
745       Zmax = Max(zmax, Zmax);
746     }
747     //
748     B.Update(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
749   }
750   //
751   B.Enlarge(Tol);
752 }
753
754 void BndLib::Add( const gp_Elips2d& C,const Standard_Real Tol, Bnd_Box2d& B) {
755
756   Standard_Real Ra= C.MajorRadius();
757   Standard_Real Rb= C.MinorRadius();
758   gp_XY Xd = C.XAxis().Direction().XY();
759   gp_XY Yd = C.YAxis().Direction().XY();
760   gp_XY O  = C.Location().XY();
761   B.Add(gp_Pnt2d(O +Ra*Xd +Rb*Yd));
762   B.Add(gp_Pnt2d(O -Ra*Xd +Rb*Yd));
763   B.Add(gp_Pnt2d(O -Ra*Xd -Rb*Yd));
764   B.Add(gp_Pnt2d(O +Ra*Xd -Rb*Yd));
765   B.Enlarge(Tol);
766 }
767
768 void BndLib::Add( const gp_Elips2d& C,const Standard_Real P1,
769                  const Standard_Real P2,
770                  const Standard_Real Tol, Bnd_Box2d& B) {
771
772   Compute(P1,P2,C.MajorRadius(),C.MinorRadius(),
773    gp_Pnt2d(C.XAxis().Direction().XY()),
774    gp_Pnt2d(C.YAxis().Direction().XY()),C.Location(),B);
775   B.Enlarge(Tol);
776 }
777
778 void BndLib::Add( const gp_Parab& P,const Standard_Real P1,
779                  const Standard_Real P2,
780                  const Standard_Real Tol, Bnd_Box& B) {
781
782   if (Precision::IsNegativeInfinite(P1)) {
783     if (Precision::IsNegativeInfinite(P2)) {
784       throw Standard_Failure("BndLib::bad parameter");
785     }
786     else if (Precision::IsPositiveInfinite(P2)) {
787       B.OpenXmax();B.OpenYmax();B.OpenZmax();
788     }
789     else {
790       B.Add(ElCLib::Value(P2,P));
791     }
792     B.OpenXmin();B.OpenYmin();B.OpenZmin();
793   }
794   else if (Precision::IsPositiveInfinite(P1)) {
795     if (Precision::IsNegativeInfinite(P2)) {
796       B.OpenXmin();B.OpenYmin();B.OpenZmin();
797     }
798     else if (Precision::IsPositiveInfinite(P2)) {
799       throw Standard_Failure("BndLib::bad parameter");
800     }
801     else {
802       B.Add(ElCLib::Value(P2,P));
803     }
804     B.OpenXmax();B.OpenYmax();B.OpenZmax();
805   }
806   else  {
807     B.Add(ElCLib::Value(P1,P));
808     if (Precision::IsNegativeInfinite(P2)) {
809       B.OpenXmin();B.OpenYmin();B.OpenZmin();
810     }
811     else if (Precision::IsPositiveInfinite(P2)){
812       B.OpenXmax();B.OpenYmax();B.OpenZmax();
813     }
814     else {
815       B.Add(ElCLib::Value(P2,P));
816       if (P1*P2<0) B.Add(ElCLib::Value(0.,P));
817     }
818   }
819   B.Enlarge(Tol);
820 }
821
822 void BndLib::Add( const gp_Parab2d& P,const Standard_Real P1,
823                  const Standard_Real P2,
824                  const Standard_Real Tol, Bnd_Box2d& B) {
825
826   if (Precision::IsNegativeInfinite(P1)) {
827     if (Precision::IsNegativeInfinite(P2)) {
828       throw Standard_Failure("BndLib::bad parameter");
829     }
830     else if (Precision::IsPositiveInfinite(P2)) {
831       B.OpenXmax();B.OpenYmax();
832     }
833     else {
834       B.Add(ElCLib::Value(P2,P));
835     }
836     B.OpenXmin();B.OpenYmin();
837   }
838   else if (Precision::IsPositiveInfinite(P1)) {
839     if (Precision::IsNegativeInfinite(P2)) {
840       B.OpenXmin();B.OpenYmin();
841     }
842     else if (Precision::IsPositiveInfinite(P2)) {
843       throw Standard_Failure("BndLib::bad parameter");
844     }
845     else {
846       B.Add(ElCLib::Value(P2,P));
847     }
848     B.OpenXmax();B.OpenYmax();
849   }
850   else  {
851     B.Add(ElCLib::Value(P1,P));
852     if (Precision::IsNegativeInfinite(P2)) {
853       B.OpenXmin();B.OpenYmin();
854     }
855     else if (Precision::IsPositiveInfinite(P2)){
856       B.OpenXmax();B.OpenYmax();
857     }
858     else {
859       B.Add(ElCLib::Value(P2,P));
860       if (P1*P2<0) B.Add(ElCLib::Value(0.,P));
861     }
862   }
863   B.Enlarge(Tol);
864 }
865
866 //=======================================================================
867 //function : Add
868 //purpose  : 
869 //=======================================================================
870 void BndLib::Add(const gp_Hypr& H,
871                  const Standard_Real P1,
872                  const Standard_Real P2,
873                  const Standard_Real Tol, 
874                  Bnd_Box& B) 
875 {
876   if (Precision::IsNegativeInfinite(P1)) {
877     if (Precision::IsNegativeInfinite(P2)) {
878       throw Standard_Failure("BndLib::bad parameter");
879     }
880     else if (Precision::IsPositiveInfinite(P2)) {
881       B.OpenXmax();B.OpenYmax();B.OpenZmax();
882     }
883     else {
884       B.Add(ElCLib::Value(P2,H));
885     }
886     B.OpenXmin();B.OpenYmin();B.OpenZmin();
887   }
888   else if (Precision::IsPositiveInfinite(P1)) {
889     if (Precision::IsNegativeInfinite(P2)) {
890       B.OpenXmin();B.OpenYmin();B.OpenZmin();
891     }
892     else if (Precision::IsPositiveInfinite(P2)) {
893       throw Standard_Failure("BndLib::bad parameter");
894     }
895     else {
896       B.Add(ElCLib::Value(P2,H));
897     }
898     B.OpenXmax();B.OpenYmax();B.OpenZmax();
899   }
900   else  {
901     B.Add(ElCLib::Value(P1,H));
902     if (Precision::IsNegativeInfinite(P2)) {
903       B.OpenXmin();B.OpenYmin();B.OpenZmin();
904     }
905     else if (Precision::IsPositiveInfinite(P2)){
906       B.OpenXmax();B.OpenYmax();B.OpenZmax();
907     }
908     else {
909       ComputeBox(H, P1, P2, B);
910     }
911   }
912   B.Enlarge(Tol);
913 }
914
915 void BndLib::Add(const gp_Hypr2d& H,const Standard_Real P1,
916                  const Standard_Real P2,
917                  const Standard_Real Tol, Bnd_Box2d& B) {
918   
919   if (Precision::IsNegativeInfinite(P1)) {
920     if (Precision::IsNegativeInfinite(P2)) {
921       throw Standard_Failure("BndLib::bad parameter");
922     }
923     else if (Precision::IsPositiveInfinite(P2)) {
924       B.OpenXmax();B.OpenYmax();
925     }
926     else {
927       B.Add(ElCLib::Value(P2,H));
928     }
929     B.OpenXmin();B.OpenYmin();
930   }
931   else if (Precision::IsPositiveInfinite(P1)) {
932     if (Precision::IsNegativeInfinite(P2)) {
933       B.OpenXmin();B.OpenYmin();
934     }
935     else if (Precision::IsPositiveInfinite(P2)) {
936       throw Standard_Failure("BndLib::bad parameter");
937     }
938     else {
939       B.Add(ElCLib::Value(P2,H));
940     }
941     B.OpenXmax();B.OpenYmax();
942   }
943   else  {
944     B.Add(ElCLib::Value(P1,H));
945     if (Precision::IsNegativeInfinite(P2)) {
946       B.OpenXmin();B.OpenYmin();
947     }
948     else if (Precision::IsPositiveInfinite(P2)){
949       B.OpenXmax();B.OpenYmax();
950     }
951     else {
952       B.Add(ElCLib::Value(P2,H));
953       if (P1*P2<0) B.Add(ElCLib::Value(0.,H));
954     }
955   }
956   B.Enlarge(Tol);
957 }
958
959 static void ComputeCyl(const gp_Cylinder& Cyl, 
960                        const Standard_Real UMin, const Standard_Real UMax, 
961                        const Standard_Real VMin, const Standard_Real VMax, 
962                        Bnd_Box& B)
963 {
964   gp_Circ aC = ElSLib::CylinderVIso(Cyl.Position(), Cyl.Radius(), VMin);
965   BndLib::Add(aC, UMin, UMax, 0., B);
966   //
967   gp_Vec aT = (VMax - VMin) * Cyl.Axis().Direction();
968   aC.Translate(aT);
969   BndLib::Add(aC, UMin, UMax, 0., B);
970 }
971
972 void BndLib::Add( const gp_Cylinder& S,const Standard_Real UMin,
973                  const Standard_Real UMax,const Standard_Real VMin,
974                  const Standard_Real VMax,const Standard_Real Tol, Bnd_Box& B)
975 {
976   if (Precision::IsNegativeInfinite(VMin))
977   {
978     if (Precision::IsNegativeInfinite(VMax))
979     {
980       throw Standard_Failure("BndLib::bad parameter");
981     }
982     else if (Precision::IsPositiveInfinite(VMax))
983     {
984       OpenMinMax(S.Axis().Direction(),B);
985     }
986     else
987     {
988       ComputeCyl(S, UMin, UMax, 0., VMax,B);
989       OpenMin(S.Axis().Direction(),B);
990     }
991   }
992   else if (Precision::IsPositiveInfinite(VMin)) 
993   {
994     if (Precision::IsNegativeInfinite(VMax)) 
995     {
996       OpenMinMax(S.Axis().Direction(),B);
997     }
998     else if (Precision::IsPositiveInfinite(VMax))
999     {
1000       throw Standard_Failure("BndLib::bad parameter");
1001     }
1002     else
1003     {
1004       ComputeCyl(S, UMin, UMax, 0., VMax, B);
1005       OpenMax(S.Axis().Direction(),B);
1006     }
1007   }
1008   else
1009   {
1010     if (Precision::IsNegativeInfinite(VMax))
1011     {
1012       ComputeCyl(S, UMin, UMax, VMin, 0., B);
1013       OpenMin(S.Axis().Direction(),B);
1014     }
1015     else if (Precision::IsPositiveInfinite(VMax)) 
1016     {
1017       ComputeCyl(S, UMin, UMax, VMin, 0., B);
1018       OpenMax(S.Axis().Direction(),B); 
1019     }
1020     else 
1021     {
1022       ComputeCyl(S, UMin, UMax, VMin, VMax, B);
1023     }
1024   }
1025
1026   B.Enlarge(Tol);
1027
1028 }
1029
1030 void BndLib::Add( const gp_Cylinder& S,const Standard_Real VMin,
1031                  const Standard_Real VMax,const Standard_Real Tol, Bnd_Box& B) {
1032
1033   BndLib::Add(S,0.,2.*M_PI,VMin,VMax,Tol,B);
1034 }
1035
1036 static void ComputeCone (const gp_Cone& Cone, 
1037                          const Standard_Real UMin, const Standard_Real UMax, 
1038                          const Standard_Real VMin, const Standard_Real VMax, 
1039                          Bnd_Box& B)
1040 {
1041   const gp_Ax3& aPos = Cone.Position();
1042   Standard_Real R = Cone.RefRadius();
1043   Standard_Real sang = Cone.SemiAngle();
1044   gp_Circ aC = ElSLib::ConeVIso(aPos, R, sang, VMin);
1045   if(aC.Radius() > Precision::Confusion())
1046   {
1047     BndLib::Add(aC, UMin, UMax, 0., B);
1048   }
1049   else
1050   {
1051     B.Add(aC.Location());
1052   }
1053   //
1054   aC = ElSLib::ConeVIso(aPos, R, sang, VMax);
1055   if(aC.Radius() > Precision::Confusion())
1056   {
1057     BndLib::Add(aC, UMin, UMax, 0., B);
1058   }
1059   else
1060   {
1061     B.Add(aC.Location());
1062   }
1063 }
1064
1065 void BndLib::Add(const gp_Cone& S,const Standard_Real UMin,
1066                  const Standard_Real UMax,const Standard_Real VMin,
1067                  const Standard_Real VMax,const Standard_Real Tol, Bnd_Box& B) {
1068
1069   Standard_Real A = S.SemiAngle();
1070   if (Precision::IsNegativeInfinite(VMin)) 
1071   {
1072     if (Precision::IsNegativeInfinite(VMax)) 
1073     {
1074       throw Standard_Failure("BndLib::bad parameter");
1075     }
1076     else if (Precision::IsPositiveInfinite(VMax)) 
1077     {
1078       gp_Dir D(Cos(A)*S.Axis().Direction());
1079       OpenMinMax(D,B); 
1080     }
1081     else 
1082     {
1083       ComputeCone(S, UMin, UMax, 0., VMax, B);
1084       gp_Dir D(Cos(A)*S.Axis().Direction());
1085       OpenMin(D,B);     
1086     }
1087
1088   }
1089   else if (Precision::IsPositiveInfinite(VMin)) 
1090   {
1091     if (Precision::IsNegativeInfinite(VMax))
1092     {
1093       gp_Dir D(Cos(A)*S.Axis().Direction());
1094       OpenMinMax(D,B);
1095     }
1096     else if (Precision::IsPositiveInfinite(VMax)) 
1097     {
1098       throw Standard_Failure("BndLib::bad parameter");
1099     }
1100     else 
1101     {
1102       ComputeCone(S, UMin, UMax, 0., VMax, B);
1103       gp_Dir D(Cos(A)*S.Axis().Direction());
1104       OpenMax(D,B);
1105     }
1106   }
1107   else 
1108   {
1109     if (Precision::IsNegativeInfinite(VMax)) 
1110     {
1111       ComputeCone(S, UMin, UMax, VMin, 0., B);
1112       gp_Dir D(Cos(A)*S.Axis().Direction());
1113       OpenMin(D,B);
1114     }
1115     else if (Precision::IsPositiveInfinite(VMax)) 
1116     {
1117       ComputeCone(S, UMin, UMax, VMin, 0., B);
1118       gp_Dir D(Cos(A)*S.Axis().Direction());
1119       OpenMax(D,B);
1120     }
1121     else 
1122     {
1123       ComputeCone(S, UMin, UMax, VMin, VMax, B);
1124     }
1125   }
1126
1127   B.Enlarge(Tol);
1128 }
1129
1130 void BndLib::Add( const gp_Cone& S,const Standard_Real VMin,
1131                  const Standard_Real VMax,const Standard_Real Tol, Bnd_Box& B) {
1132
1133   BndLib::Add(S,0.,2.*M_PI,VMin,VMax,Tol,B);
1134 }
1135
1136 static void ComputeSphere (const gp_Sphere& Sphere, 
1137                            const Standard_Real UMin, const Standard_Real UMax, 
1138                            const Standard_Real VMin, const Standard_Real VMax, 
1139                            Bnd_Box& B)
1140 {
1141   gp_Pnt P = Sphere.Location();
1142   Standard_Real R = Sphere.Radius();
1143   Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
1144   xmin = P.X() - R;
1145   xmax = P.X() + R;
1146   ymin = P.Y() - R;
1147   ymax = P.Y() + R;
1148   zmin = P.Z() - R;
1149   zmax = P.Z() + R;
1150   
1151   Standard_Real uper = 2. * M_PI - Precision::PConfusion();
1152   Standard_Real vper = M_PI - Precision::PConfusion();
1153   if (UMax - UMin >= uper && VMax - VMin >= vper)
1154   {
1155     // a whole sphere
1156     B.Update(xmin, ymin, zmin, xmax, ymax, zmax);
1157   }
1158   else
1159   {
1160     Standard_Real u, v;
1161     Standard_Real umax = UMin + 2. * M_PI;
1162     const gp_Ax3& Pos = Sphere.Position();
1163     gp_Pnt PExt = P;
1164     PExt.SetX(xmin);
1165     ElSLib::SphereParameters(Pos, R, PExt, u, v);
1166     u = ElCLib::InPeriod(u, UMin, umax);
1167     if(u >= UMin && u <= UMax && v >= VMin && v <= VMax)
1168     {
1169       B.Add(PExt);
1170     }
1171     //
1172     PExt.SetX(xmax);
1173     ElSLib::SphereParameters(Pos, R, PExt, u, v);
1174     u = ElCLib::InPeriod(u, UMin, umax);
1175     if(u >= UMin && u <= UMax && v >= VMin && v <= VMax)
1176     {
1177       B.Add(PExt);
1178     }
1179     PExt.SetX(P.X());
1180     //
1181     PExt.SetY(ymin);
1182     ElSLib::SphereParameters(Pos, R, PExt, u, v);
1183     u = ElCLib::InPeriod(u, UMin, umax);
1184     if(u >= UMin && u <= UMax && v >= VMin && v <= VMax)
1185     {
1186       B.Add(PExt);
1187     }
1188     //
1189     PExt.SetY(ymax);
1190     ElSLib::SphereParameters(Pos, R, PExt, u, v);
1191     u = ElCLib::InPeriod(u, UMin, umax);
1192     if(u >= UMin && u <= UMax && v >= VMin && v <= VMax)
1193     {
1194       B.Add(PExt);
1195     }
1196     PExt.SetY(P.Y());
1197     //
1198     PExt.SetZ(zmin);
1199     ElSLib::SphereParameters(Pos, R, PExt, u, v);
1200     u = ElCLib::InPeriod(u, UMin, umax);
1201     if(u >= UMin && u <= UMax && v >= VMin && v <= VMax)
1202     {
1203       B.Add(PExt);
1204     }
1205     //
1206     PExt.SetZ(zmax);
1207     ElSLib::SphereParameters(Pos, R, PExt, u, v);
1208     u = ElCLib::InPeriod(u, UMin, umax);
1209     if(u >= UMin && u <= UMax && v >= VMin && v <= VMax)
1210     {
1211       B.Add(PExt);
1212     }
1213     //
1214     // Add boundaries of patch
1215     // UMin, UMax
1216     gp_Circ aC = ElSLib::SphereUIso(Pos, R, UMin);
1217     BndLib::Add(aC, VMin, VMax, 0., B);
1218     aC = ElSLib::SphereUIso(Pos, R, UMax);
1219     BndLib::Add(aC, VMin, VMax, 0., B);
1220     // VMin, VMax
1221     aC = ElSLib::SphereVIso(Pos, R, VMin);
1222     BndLib::Add(aC, UMin, UMax, 0., B);
1223     aC = ElSLib::SphereVIso(Pos, R, VMax);
1224     BndLib::Add(aC, UMin, UMax, 0., B);
1225   }
1226 }
1227
1228 void BndLib::Add(const gp_Sphere& S,const Standard_Real UMin,
1229                  const Standard_Real UMax,const Standard_Real VMin,
1230                  const Standard_Real VMax,const Standard_Real Tol, Bnd_Box& B) 
1231 {
1232   ComputeSphere(S, UMin, UMax, VMin, VMax, B);
1233   B.Enlarge(Tol);
1234 }
1235
1236 void BndLib::Add( const gp_Sphere& S,const Standard_Real Tol, Bnd_Box& B) 
1237 {
1238   gp_Pnt P = S.Location();
1239   Standard_Real R = S.Radius();
1240   Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
1241   xmin = P.X() - R;
1242   xmax = P.X() + R;
1243   ymin = P.Y() - R;
1244   ymax = P.Y() + R;
1245   zmin = P.Z() - R;
1246   zmax = P.Z() + R;
1247   B.Update(xmin, ymin, zmin, xmax, ymax, zmax);
1248   B.Enlarge(Tol);
1249 }
1250
1251 void BndLib::Add(const gp_Torus& S,const Standard_Real UMin,
1252    const Standard_Real UMax,const Standard_Real VMin,
1253    const Standard_Real VMax,const Standard_Real Tol, Bnd_Box& B) {
1254
1255   Standard_Integer Fi1;
1256   Standard_Integer Fi2;
1257   if (VMax<VMin) {
1258     Fi1 = (Standard_Integer )( VMax/(M_PI/4.));
1259     Fi2 = (Standard_Integer )( VMin/(M_PI/4.));
1260   }
1261   else {
1262     Fi1 = (Standard_Integer )( VMin/(M_PI/4.));
1263     Fi2 = (Standard_Integer )( VMax/(M_PI/4.));
1264   }
1265   Fi2++;
1266   
1267   Standard_Real Ra = S.MajorRadius();
1268   Standard_Real Ri = S.MinorRadius();
1269
1270   if (Fi2<Fi1) return;
1271
1272 #define SC 0.71
1273 #define addP0    (Compute(UMin,UMax,Ra+Ri,Ra+Ri,gp_Pnt(S.XAxis().Direction().XYZ()),gp_Pnt(S.YAxis().Direction().XYZ()),S.Location(),B))
1274 #define addP1    (Compute(UMin,UMax,Ra+Ri*SC,Ra+Ri*SC,gp_Pnt(S.XAxis().Direction().XYZ()),gp_Pnt(S.YAxis().Direction().XYZ()),gp_Pnt(S.Location().XYZ()+(Ri*SC)*S.Axis().Direction().XYZ()),B))
1275 #define addP2    (Compute(UMin,UMax,Ra,Ra,gp_Pnt(S.XAxis().Direction().XYZ()),gp_Pnt(S.YAxis().Direction().XYZ()),gp_Pnt(S.Location().XYZ()+Ri*S.Axis().Direction().XYZ()),B))
1276 #define addP3    (Compute(UMin,UMax,Ra-Ri*SC,Ra-Ri*SC,gp_Pnt(S.XAxis().Direction().XYZ()),gp_Pnt(S.YAxis().Direction().XYZ()),gp_Pnt(S.Location().XYZ()+(Ri*SC)*S.Axis().Direction().XYZ()),B))
1277 #define addP4    (Compute(UMin,UMax,Ra-Ri,Ra-Ri,gp_Pnt(S.XAxis().Direction().XYZ()),gp_Pnt(S.YAxis().Direction().XYZ()),S.Location(),B))
1278 #define addP5    (Compute(UMin,UMax,Ra-Ri*SC,Ra-Ri*SC,gp_Pnt(S.XAxis().Direction().XYZ()),gp_Pnt(S.YAxis().Direction().XYZ()),gp_Pnt(S.Location().XYZ()-(Ri*SC)*S.Axis().Direction().XYZ()),B))
1279 #define addP6    (Compute(UMin,UMax,Ra,Ra,gp_Pnt(S.XAxis().Direction().XYZ()),gp_Pnt(S.YAxis().Direction().XYZ()),gp_Pnt(S.Location().XYZ()-Ri*S.Axis().Direction().XYZ()),B))
1280 #define addP7    (Compute(UMin,UMax,Ra+Ri*SC,Ra+Ri*SC,gp_Pnt(S.XAxis().Direction().XYZ()),gp_Pnt(S.YAxis().Direction().XYZ()),gp_Pnt(S.Location().XYZ()-(Ri*SC)*S.Axis().Direction().XYZ()),B))
1281   
1282   switch (Fi1) {
1283   case 0 : 
1284     {
1285       addP0;
1286       if (Fi2 <= 0) break;
1287     }
1288     Standard_FALLTHROUGH
1289   case 1 : 
1290     {
1291       addP1;
1292       if (Fi2 <= 1) break;
1293     }
1294     Standard_FALLTHROUGH
1295   case 2 :  
1296     {
1297       addP2;
1298       if (Fi2 <= 2) break;
1299     }
1300     Standard_FALLTHROUGH
1301   case 3 :  
1302     {
1303       addP3;
1304       if (Fi2 <= 3) break;
1305     }
1306     Standard_FALLTHROUGH
1307   case 4 :  
1308     {
1309       addP4;
1310       if (Fi2 <= 4) break;
1311     }
1312     Standard_FALLTHROUGH
1313   case 5 :  
1314     {
1315       addP5;
1316       if (Fi2 <= 5) break;
1317     }
1318     Standard_FALLTHROUGH
1319   case 6 :  
1320     {
1321       addP6;
1322       if (Fi2 <= 6) break;
1323     }
1324     Standard_FALLTHROUGH
1325   case 7 :  
1326     {
1327       addP7;
1328       if (Fi2 <= 7) break;
1329     }
1330     Standard_FALLTHROUGH
1331   case 8 :  
1332   default :
1333     {
1334       addP0;
1335       switch (Fi2) {
1336       case 15 :  
1337         addP7;
1338         Standard_FALLTHROUGH
1339       case 14 :  
1340         addP6;
1341         Standard_FALLTHROUGH
1342       case 13 :  
1343         addP5;
1344         Standard_FALLTHROUGH
1345       case 12 :  
1346         addP4;
1347         Standard_FALLTHROUGH
1348       case 11 :  
1349         addP3;
1350         Standard_FALLTHROUGH
1351       case 10 :  
1352         addP2;
1353         Standard_FALLTHROUGH
1354       case 9 : 
1355         addP1;
1356         Standard_FALLTHROUGH
1357       case 8 : 
1358         break;
1359       }    
1360     }
1361   }    
1362   B.Enlarge(Tol);
1363 }
1364
1365
1366 void BndLib::Add( const gp_Torus& S,const Standard_Real Tol, Bnd_Box& B) {
1367
1368   Standard_Real RMa = S.MajorRadius();
1369   Standard_Real Rmi = S.MinorRadius(); 
1370   gp_XYZ O = S.Location().XYZ();
1371   gp_XYZ Xd = S.XAxis().Direction().XYZ();
1372   gp_XYZ Yd = S.YAxis().Direction().XYZ();
1373   gp_XYZ Zd = S.Axis().Direction().XYZ();
1374   B.Add(gp_Pnt(O -(RMa+Rmi)*Xd -(RMa+Rmi)*Yd+ Rmi*Zd)); 
1375   B.Add(gp_Pnt(O -(RMa+Rmi)*Xd -(RMa+Rmi)*Yd- Rmi*Zd)); 
1376   B.Add(gp_Pnt(O +(RMa+Rmi)*Xd -(RMa+Rmi)*Yd+ Rmi*Zd)); 
1377   B.Add(gp_Pnt(O +(RMa+Rmi)*Xd -(RMa+Rmi)*Yd- Rmi*Zd)); 
1378   B.Add(gp_Pnt(O -(RMa+Rmi)*Xd +(RMa+Rmi)*Yd+ Rmi*Zd)); 
1379   B.Add(gp_Pnt(O -(RMa+Rmi)*Xd +(RMa+Rmi)*Yd- Rmi*Zd)); 
1380   B.Add(gp_Pnt(O +(RMa+Rmi)*Xd +(RMa+Rmi)*Yd+ Rmi*Zd)); 
1381   B.Add(gp_Pnt(O +(RMa+Rmi)*Xd +(RMa+Rmi)*Yd- Rmi*Zd)); 
1382   B.Enlarge(Tol);
1383 }
1384 //=======================================================================
1385 //function : ComputeBox
1386 //purpose  : 
1387 //=======================================================================
1388 Standard_Integer ComputeBox(const gp_Hypr& aHypr, 
1389                             const Standard_Real aT1, 
1390                             const Standard_Real aT2, 
1391                             Bnd_Box& aBox)
1392 {
1393   Standard_Integer i, iErr;
1394   Standard_Real aRmaj, aRmin, aA, aB, aABP, aBAM, aT3, aCf, aEps;
1395   gp_Pnt aP1, aP2, aP3, aP0;
1396   //
1397   //
1398   aP1=ElCLib::Value(aT1, aHypr);
1399   aP2=ElCLib::Value(aT2, aHypr);
1400   //
1401   aBox.Add(aP1);
1402   aBox.Add(aP2);
1403   //
1404   if (aT1*aT2<0.) {
1405     aP0=ElCLib::Value(0., aHypr);
1406     aBox.Add(aP0);
1407   }
1408   //
1409   aEps=Epsilon(1.);
1410   iErr=1;
1411   //
1412   const gp_Ax2& aPos=aHypr.Position();
1413   const gp_XYZ& aXDir = aPos.XDirection().XYZ();
1414   const gp_XYZ& aYDir = aPos.YDirection().XYZ();
1415   aRmaj=aHypr.MajorRadius();
1416   aRmin=aHypr.MinorRadius();
1417   //
1418   aT3=0;
1419   for (i=1; i<=3; ++i) {
1420     aA=aRmin*aYDir.Coord(i);
1421     aB=aRmaj*aXDir.Coord(i);
1422     //
1423     aABP=aA+aB;
1424     aBAM=aB-aA;
1425     //
1426     aABP=fabs(aABP);
1427     aBAM=fabs(aBAM);
1428     //
1429     if (aABP<aEps || aBAM<aEps) {
1430       continue;
1431     }
1432     //
1433     aCf=aBAM/aABP;
1434     aT3=log(sqrt(aCf));
1435     //
1436     if (aT3<aT1 || aT3>aT2) {
1437       continue;
1438     }
1439     iErr=0;
1440     break;
1441   }
1442   //
1443   if (iErr) {
1444     return iErr;
1445   }
1446   //
1447   aP3=ElCLib::Value(aT3, aHypr);
1448   aBox.Add(aP3);
1449   //
1450   return iErr;
1451 }