0027772: Foundation Classes - define Standard_Boolean using C++ type "bool" instead...
[occt.git] / src / Bnd / Bnd_Box.cxx
1 // Created on: 1991-03-08
2 // Created by: Christophe MARION
3 // Copyright (c) 1991-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <Bnd_Box.hxx>
18 #include <gp_Dir.hxx>
19 #include <gp_Lin.hxx>
20 #include <gp_Pln.hxx>
21 #include <gp_Pnt.hxx>
22 #include <gp_Trsf.hxx>
23 #include <Standard_ConstructionError.hxx>
24
25 // set the flag to one
26 #define ClearVoidFlag() ( Flags &= ~VoidMask )
27
28 #include <Standard_Stream.hxx>
29 #include <gp.hxx>
30 // #include <Precision.hxx>
31 #define Bnd_Precision_Infinite 1e+100
32
33 //=======================================================================
34 //function : Bnd_Box
35 //purpose  : 
36 //=======================================================================
37
38 Bnd_Box::Bnd_Box()
39      : Xmin(0.), Xmax(0.), Ymin(0.), Ymax(0.),  Zmin(0.), Zmax(0.), Gap(0.)
40 {
41   SetVoid();
42 }
43
44 //=======================================================================
45 //function : Set
46 //purpose  : 
47 //=======================================================================
48
49 void Bnd_Box::Set(const gp_Pnt& P)
50 {
51   SetVoid();
52   Add(P);
53 }
54
55 //=======================================================================
56 //function : Set
57 //purpose  : 
58 //=======================================================================
59
60 void Bnd_Box::Set(const gp_Pnt& P, const gp_Dir& D)
61 {
62   SetVoid();
63   Add(P,D);
64 }
65
66
67 //=======================================================================
68 //function : Update
69 //purpose  : 
70 //=======================================================================
71
72 void Bnd_Box::Update (const Standard_Real x,
73                       const Standard_Real y, 
74                       const Standard_Real z, 
75                       const Standard_Real X,
76                       const Standard_Real Y, 
77                       const Standard_Real Z)
78 {
79   if (IsVoid())
80   {
81     Xmin = x;
82     Ymin = y;
83     Zmin = z;
84     Xmax = X;
85     Ymax = Y;
86     Zmax = Z;
87     ClearVoidFlag();
88   }
89   else {
90     if (!IsOpenXmin() && (x < Xmin)) Xmin = x;
91     if (!IsOpenXmax() && (X > Xmax)) Xmax = X;
92     if (!IsOpenYmin() && (y < Ymin)) Ymin = y;
93     if (!IsOpenYmax() && (Y > Ymax)) Ymax = Y;
94     if (!IsOpenZmin() && (z < Zmin)) Zmin = z;
95     if (!IsOpenZmax() && (Z > Zmax)) Zmax = Z;
96   }
97 }
98
99 //=======================================================================
100 //function : Update
101 //purpose  : 
102 //=======================================================================
103
104 void Bnd_Box::Update (const Standard_Real X,
105                       const Standard_Real Y,
106                       const Standard_Real Z)
107 {
108   if (IsVoid())
109   {
110     Xmin = X;
111     Ymin = Y;
112     Zmin = Z;
113     Xmax = X;
114     Ymax = Y;
115     Zmax = Z;
116     ClearVoidFlag();
117   }
118   else {
119     if      (!IsOpenXmin() && (X < Xmin)) Xmin = X;
120     else if (!IsOpenXmax() && (X > Xmax)) Xmax = X;
121     if      (!IsOpenYmin() && (Y < Ymin)) Ymin = Y;
122     else if (!IsOpenYmax() && (Y > Ymax)) Ymax = Y;
123     if      (!IsOpenZmin() && (Z < Zmin)) Zmin = Z;
124     else if (!IsOpenZmax() && (Z > Zmax)) Zmax = Z;
125   }
126 }
127
128 //=======================================================================
129 //function : GetGap
130 //purpose  : 
131 //=======================================================================
132
133 Standard_Real Bnd_Box::GetGap () const
134 {
135   return Gap;
136 }
137
138 //=======================================================================
139 //function : SetGap
140 //purpose  : 
141 //=======================================================================
142
143 void Bnd_Box::SetGap (const Standard_Real Tol)
144 {
145   Gap = Tol;
146 }
147
148 //=======================================================================
149 //function : Enlarge
150 //purpose  : 
151 //=======================================================================
152
153 void Bnd_Box::Enlarge (const Standard_Real Tol)
154 {
155   Gap=Max(Gap, Abs(Tol));
156 }
157
158 //=======================================================================
159 //function : Get
160 //purpose  : 
161 //=======================================================================
162
163 void Bnd_Box::Get (Standard_Real& theXmin,
164                    Standard_Real& theYmin,
165                    Standard_Real& theZmin,
166                    Standard_Real& theXmax,
167                    Standard_Real& theYmax,
168                    Standard_Real& theZmax) const
169 {
170   if (IsVoid())
171   {
172     Standard_ConstructionError::Raise ("Bnd_Box is void");
173   }
174
175   if (IsOpenXmin()) theXmin = -Bnd_Precision_Infinite;
176   else              theXmin = Xmin - Gap;
177   if (IsOpenXmax()) theXmax = Bnd_Precision_Infinite;
178   else              theXmax = Xmax + Gap;
179   if (IsOpenYmin()) theYmin = -Bnd_Precision_Infinite;
180   else              theYmin = Ymin - Gap;
181   if (IsOpenYmax()) theYmax = Bnd_Precision_Infinite;
182   else              theYmax = Ymax + Gap;
183   if (IsOpenZmin()) theZmin = -Bnd_Precision_Infinite;
184   else              theZmin = Zmin - Gap;
185   if (IsOpenZmax()) theZmax = Bnd_Precision_Infinite;
186   else              theZmax = Zmax + Gap;
187 }
188
189 //=======================================================================
190 //function : CornerMin
191 //purpose  :
192 //=======================================================================
193
194 gp_Pnt Bnd_Box::CornerMin() const
195 {
196   gp_Pnt aCornerMin;
197   if (IsVoid())
198   {
199     Standard_ConstructionError::Raise ("Bnd_Box is void");
200     return aCornerMin;
201   }
202   if (IsOpenXmin()) aCornerMin.SetX (-Bnd_Precision_Infinite);
203   else              aCornerMin.SetX (Xmin - Gap);
204   if (IsOpenYmin()) aCornerMin.SetY (-Bnd_Precision_Infinite);
205   else              aCornerMin.SetY (Ymin - Gap);
206   if (IsOpenZmin()) aCornerMin.SetZ (-Bnd_Precision_Infinite);
207   else              aCornerMin.SetZ (Zmin - Gap);
208   return aCornerMin;
209 }
210
211 //=======================================================================
212 //function : CornerMax
213 //purpose  :
214 //=======================================================================
215
216 gp_Pnt Bnd_Box::CornerMax() const
217 {
218   gp_Pnt aCornerMax;
219   if (IsVoid())
220   {
221     Standard_ConstructionError::Raise ("Bnd_Box is void");
222     return aCornerMax;
223   }
224   if (IsOpenXmax()) aCornerMax.SetX (Bnd_Precision_Infinite);
225   else              aCornerMax.SetX (Xmax + Gap);
226   if (IsOpenYmin()) aCornerMax.SetY (Bnd_Precision_Infinite);
227   else              aCornerMax.SetY (Ymax + Gap);
228   if (IsOpenZmin()) aCornerMax.SetZ (Bnd_Precision_Infinite);
229   else              aCornerMax.SetZ (Zmax + Gap);
230   return aCornerMax;
231 }
232
233 //=======================================================================
234 //function : IsXThin
235 //purpose  : 
236 //=======================================================================
237
238 Standard_Boolean Bnd_Box::IsXThin (const Standard_Real tol) const
239 {
240   if (IsWhole())       return Standard_False;
241   if (IsVoid())        return Standard_True;
242   if (IsOpenXmin())    return Standard_False;
243   if (IsOpenXmax())    return Standard_False;
244   if (Xmax-Xmin < tol) return Standard_True;
245   return Standard_False;
246 }
247
248 //=======================================================================
249 //function : IsYThin
250 //purpose  : 
251 //=======================================================================
252
253 Standard_Boolean Bnd_Box::IsYThin (const Standard_Real tol) const
254 {
255   if (IsWhole())       return Standard_False;
256   if (IsVoid())        return Standard_True;
257   if (IsOpenYmin())    return Standard_False;
258   if (IsOpenYmax())    return Standard_False;
259   if (Ymax-Ymin < tol) return Standard_True;
260   return Standard_False;
261 }
262
263 //=======================================================================
264 //function : IsZThin
265 //purpose  : 
266 //=======================================================================
267
268 Standard_Boolean Bnd_Box::IsZThin (const Standard_Real tol) const
269 {
270   if (IsWhole())       return Standard_False;
271   if (IsVoid())        return Standard_True;
272   if (IsOpenZmin())    return Standard_False;
273   if (IsOpenZmax())    return Standard_False;
274   if (Zmax-Zmin < tol) return Standard_True;
275   return Standard_False;
276 }
277
278 //=======================================================================
279 //function : IsThin
280 //purpose  : 
281 //=======================================================================
282
283 Standard_Boolean Bnd_Box::IsThin (const Standard_Real tol) const
284 {
285   if (!IsXThin(tol)) return Standard_False;
286   if (!IsYThin(tol)) return Standard_False;
287   if (!IsZThin(tol)) return Standard_False;
288   return Standard_True;
289 }
290
291 //=======================================================================
292 //function : Transformed
293 //purpose  : 
294 //=======================================================================
295
296 Bnd_Box Bnd_Box::Transformed (const gp_Trsf& T) const
297 {
298   gp_TrsfForm F = T.Form();
299   Bnd_Box newb(*this);
300   if ( IsVoid() ) return newb;
301
302   if      (F == gp_Identity) {}
303   else if (F == gp_Translation) {
304     Standard_Real DX,DY,DZ;
305     (T.TranslationPart()).Coord(DX,DY,DZ);
306     if (!IsOpenXmin()) newb.Xmin += DX;
307     if (!IsOpenXmax()) newb.Xmax += DX;
308     if (!IsOpenYmin()) newb.Ymin += DY;
309     if (!IsOpenYmax()) newb.Ymax += DY;
310     if (!IsOpenZmin()) newb.Zmin += DZ;
311     if (!IsOpenZmax()) newb.Zmax += DZ;
312   }
313   else {
314     gp_Pnt P[8];
315     Standard_Boolean Vertex[8];
316     Standard_Integer i;
317     for (i=0;i<8;i++) Vertex[i] = Standard_True;
318     gp_Dir D[6];
319 //    Standard_Integer vertices = 0;
320     Standard_Integer directions = 0;
321
322     if (IsOpenXmin())
323     {
324       directions++;
325       D[directions-1].SetCoord(-1., 0., 0.);
326       Vertex[0] = Vertex[2] = Vertex[4] = Vertex[6] = Standard_False;
327     }
328     if (IsOpenXmax())
329     {
330       directions++;
331       D[directions-1].SetCoord( 1., 0., 0.);
332       Vertex[1] = Vertex[3] = Vertex[5] = Vertex[7] = Standard_False;
333     }
334     if (IsOpenYmin())
335     {
336       directions++;
337       D[directions-1].SetCoord( 0.,-1., 0.);
338       Vertex[0] = Vertex[1] = Vertex[4] = Vertex[5] = Standard_False;
339     }
340     if (IsOpenYmax())
341     {
342       directions++;
343       D[directions-1].SetCoord( 0., 1., 0.);
344       Vertex[2] = Vertex[3] = Vertex[6] = Vertex[7] = Standard_False;
345     }
346     if (IsOpenZmin())
347     {
348       directions++;
349       D[directions-1].SetCoord( 0., 0.,-1.);
350       Vertex[0] = Vertex[1] = Vertex[2] = Vertex[3] = Standard_False;
351     }
352     if (IsOpenZmax())
353     {
354       directions++;
355       D[directions-1].SetCoord( 0., 0., 1.);
356       Vertex[4] = Vertex[5] = Vertex[6] = Vertex[7] = Standard_False;
357     }
358
359     newb.SetVoid();
360     for (i=0;i<directions;i++) {
361       D[i].Transform(T);
362       newb.Add(D[i]);
363     }
364     P[0].SetCoord(Xmin,Ymin,Zmin);
365     P[1].SetCoord(Xmax,Ymin,Zmin);
366     P[2].SetCoord(Xmin,Ymax,Zmin);
367     P[3].SetCoord(Xmax,Ymax,Zmin);
368     P[4].SetCoord(Xmin,Ymin,Zmax);
369     P[5].SetCoord(Xmax,Ymin,Zmax);
370     P[6].SetCoord(Xmin,Ymax,Zmax);
371     P[7].SetCoord(Xmax,Ymax,Zmax);
372     for (i=0;i<8;i++) {
373       if (Vertex[i]) {
374         P[i].Transform(T);
375         newb.Add(P[i]);
376       }
377     }
378     newb.Gap=Gap;
379   }
380   return newb;
381 }
382
383 //=======================================================================
384 //function : Add
385 //purpose  : 
386 //=======================================================================
387
388 void Bnd_Box::Add (const Bnd_Box& Other)
389 {
390   if (IsWhole()) return;
391   else if (Other.IsVoid()) return; 
392   else if (Other.IsWhole()) SetWhole();
393   else if (IsVoid()) (*this) = Other;
394   else
395   {
396     if ( ! IsOpenXmin() )
397     {
398       if (Other.IsOpenXmin()) OpenXmin();
399       else if (Xmin > Other.Xmin) Xmin = Other.Xmin;
400     }
401     if ( ! IsOpenXmax() )
402     {
403       if (Other.IsOpenXmax()) OpenXmax();
404       else if (Xmax < Other.Xmax) Xmax = Other.Xmax;
405     }
406     if ( ! IsOpenYmin() )
407     {
408       if (Other.IsOpenYmin()) OpenYmin();
409       else if (Ymin > Other.Ymin) Ymin = Other.Ymin;
410     }
411     if ( ! IsOpenYmax() )
412     {
413       if (Other.IsOpenYmax()) OpenYmax();
414       else if (Ymax < Other.Ymax) Ymax = Other.Ymax;
415     }
416     if ( ! IsOpenZmin() )
417     {
418       if (Other.IsOpenZmin()) OpenZmin();
419       else if (Zmin > Other.Zmin) Zmin = Other.Zmin;
420     }
421     if ( ! IsOpenZmax() )
422     {
423       if (Other.IsOpenZmax()) OpenZmax();
424       else if (Zmax < Other.Zmax) Zmax = Other.Zmax;
425     }
426     Gap = Max (Gap, Other.Gap);
427   }
428 }
429
430 //=======================================================================
431 //function : Add
432 //purpose  : 
433 //=======================================================================
434
435 void Bnd_Box::Add (const gp_Pnt& P)
436 {
437   Standard_Real X,Y,Z;
438   P.Coord(X,Y,Z);
439   Update(X,Y,Z);
440 }
441
442 //=======================================================================
443 //function : Add
444 //purpose  : 
445 //=======================================================================
446
447 void Bnd_Box::Add (const gp_Pnt& P, const gp_Dir& D)
448 {
449   Add(P);
450   Add(D);
451 }
452
453
454 //=======================================================================
455 //function : Add
456 //purpose  : 
457 //=======================================================================
458
459 void Bnd_Box::Add (const gp_Dir& D)
460 {
461   Standard_Real DX,DY,DZ;
462   D.Coord(DX,DY,DZ);
463
464   if (DX < -RealEpsilon()) 
465     OpenXmin();
466   else if (DX > RealEpsilon()) 
467     OpenXmax();
468
469   if (DY < -RealEpsilon())
470     OpenYmin();
471   else if (DY > RealEpsilon())
472     OpenYmax();
473
474   if (DZ < -RealEpsilon())
475     OpenZmin();
476   else if (DZ > RealEpsilon())
477     OpenZmax();
478 }
479
480 //=======================================================================
481 //function : IsOut
482 //purpose  : 
483 //=======================================================================
484
485 Standard_Boolean Bnd_Box::IsOut (const gp_Pnt& P) const
486 {
487   if        (IsWhole())  return Standard_False;
488   else if   (IsVoid())   return Standard_True;
489   else {
490     Standard_Real X,Y,Z;
491     P.Coord(X,Y,Z);
492     if      (!IsOpenXmin() && (X < (Xmin-Gap))) return Standard_True;
493     else if (!IsOpenXmax() && (X > (Xmax+Gap))) return Standard_True;
494     else if (!IsOpenYmin() && (Y < (Ymin-Gap))) return Standard_True;
495     else if (!IsOpenYmax() && (Y > (Ymax+Gap))) return Standard_True;
496     else if (!IsOpenZmin() && (Z < (Zmin-Gap))) return Standard_True;
497     else if (!IsOpenZmax() && (Z > (Zmax+Gap))) return Standard_True;
498     else return Standard_False;
499   }
500 }
501
502
503 //=======================================================================
504 //function : IsOut
505 //purpose  : 
506 //=======================================================================
507
508 Standard_Boolean Bnd_Box::IsOut (const gp_Pln& P) const
509 {
510   if        (IsWhole())  return Standard_False;
511   else if   (IsVoid())   return Standard_True;
512   else {
513     Standard_Real A,B,C,D;
514     P.Coefficients (A, B ,C ,D);
515     Standard_Real d = A * (Xmin-Gap) + B * (Ymin-Gap) + C * (Zmin-Gap) + D;
516 //    Standard_Boolean plus = d > 0;
517     Standard_Integer plus = d > 0;
518     if (plus != ((A*(Xmin-Gap) + B*(Ymin-Gap) + C*(Zmax+Gap) + D) > 0))
519       return Standard_False;
520     if (plus != ((A*(Xmin-Gap) + B*(Ymax+Gap) + C*(Zmin-Gap) + D) > 0))
521       return Standard_False;
522     if (plus != ((A*(Xmin-Gap) + B*(Ymax+Gap) + C*(Zmax+Gap) + D) > 0))
523       return Standard_False;
524     if (plus != ((A*(Xmax+Gap) + B*(Ymin-Gap) + C*(Zmin-Gap) + D) > 0))
525       return Standard_False;
526     if (plus != ((A*(Xmax+Gap) + B*(Ymin-Gap) + C*(Zmax+Gap) + D) > 0))
527       return Standard_False;
528     if (plus != ((A*(Xmax+Gap) + B*(Ymax+Gap) + C*(Zmin-Gap) + D) > 0))
529       return Standard_False;
530     if (plus != ((A*(Xmax+Gap) + B*(Ymax+Gap) + C*(Zmax+Gap) + D) > 0))
531       return Standard_False;
532     else return Standard_True;
533   }
534 }
535
536 //=======================================================================
537 //function : IsOut
538 //purpose  : 
539 //=======================================================================
540
541 Standard_Boolean Bnd_Box::IsOut (const gp_Lin& L) const
542 {
543   if        (IsWhole())  return Standard_False;
544   else if   (IsVoid())   return Standard_True;
545   else {
546     Standard_Real xmin = 0, xmax = 0, ymin = 0, ymax = 0, zmin, zmax;
547     Standard_Real parmin, parmax, par1, par2;
548     Standard_Boolean xToSet, yToSet;
549     Standard_Real myXmin, myYmin, myZmin, myXmax, myYmax, myZmax;
550     Get (myXmin, myYmin, myZmin, myXmax, myYmax, myZmax);
551
552     if (Abs(L.Direction().XYZ().X())>0.) {
553       par1=(myXmin-L.Location().XYZ().X())/L.Direction().XYZ().X();
554       par2=(myXmax-L.Location().XYZ().X())/L.Direction().XYZ().X();
555       parmin=Min(par1, par2);
556       parmax=Max(par1, par2);
557       xToSet=Standard_True;
558     }
559     else {
560       if (L.Location().XYZ().X()<myXmin || myXmax<L.Location().XYZ().X()) {
561         return Standard_True;
562       }
563       xmin=L.Location().XYZ().X();
564       xmax=L.Location().XYZ().X();
565       parmin=-Bnd_Precision_Infinite;
566       parmax=Bnd_Precision_Infinite;
567       xToSet=Standard_False;
568     }
569
570     if (Abs(L.Direction().XYZ().Y())>0.) {
571       par1=(myYmin-L.Location().XYZ().Y())/L.Direction().XYZ().Y();
572       par2=(myYmax-L.Location().XYZ().Y())/L.Direction().XYZ().Y();
573       //=================DET change 06/03/01====================
574       if(parmax < Min(par1,par2) || parmin > Max(par1,par2))
575         return Standard_True;
576       //========================================================
577       parmin=Max(parmin, Min(par1,par2));
578       parmax=Min(parmax, Max(par1,par2));
579       yToSet=Standard_True;
580     }
581     else {
582       if (L.Location().XYZ().Y()<myYmin || myYmax<L.Location().XYZ().Y()) {
583         return Standard_True;
584       }
585       ymin=L.Location().XYZ().Y();
586       ymax=L.Location().XYZ().Y();
587       yToSet=Standard_False;
588     }
589
590     if (Abs(L.Direction().XYZ().Z())>0.) {
591       par1=(myZmin-L.Location().XYZ().Z())/L.Direction().XYZ().Z();
592       par2=(myZmax-L.Location().XYZ().Z())/L.Direction().XYZ().Z();
593       //=================DET change 06/03/01====================
594       if(parmax < Min(par1,par2) || parmin > Max(par1,par2))
595         return Standard_True;
596       //========================================================
597       parmin=Max(parmin, Min(par1,par2));
598       parmax=Min(parmax, Max(par1,par2));
599       par1=L.Location().XYZ().Z()+parmin*L.Direction().XYZ().Z();
600       par2=L.Location().XYZ().Z()+parmax*L.Direction().XYZ().Z();
601       zmin=Min(par1, par2);
602       zmax=Max(par1, par2);
603     }
604     else {
605       if (L.Location().XYZ().Z()<myZmin || myZmax<L.Location().XYZ().Z())
606         return Standard_True;
607       zmin=L.Location().XYZ().Z();
608       zmax=L.Location().XYZ().Z();
609     }
610     if (zmax<myZmin || myZmax<zmin) return Standard_True;
611
612     if (xToSet) {
613       par1=L.Location().XYZ().X()+parmin*L.Direction().XYZ().X();
614       par2=L.Location().XYZ().X()+parmax*L.Direction().XYZ().X();
615       xmin=Min(par1, par2);
616       xmax=Max(par1, par2);
617     }
618     if (xmax<myXmin || myXmax<xmin) return Standard_True;
619
620     if (yToSet) {
621       par1=L.Location().XYZ().Y()+parmin*L.Direction().XYZ().Y();
622       par2=L.Location().XYZ().Y()+parmax*L.Direction().XYZ().Y();
623       ymin=Min(par1, par2);
624       ymax=Max(par1, par2);
625     }
626     if (ymax<myYmin || myYmax<ymin) return Standard_True;
627   }
628   return Standard_False;
629 }
630
631 //=======================================================================
632 //function : IsOut
633 //purpose  : 
634 //=======================================================================
635
636 Standard_Boolean Bnd_Box::IsOut (const Bnd_Box& Other) const
637
638   //modified by NIZNHY-PKV Fri Jul 08 11:03:43 2011f
639   if (!Flags && !Other.Flags) {
640     Standard_Boolean bRet;
641     Standard_Real delta;
642     //
643     delta = Other.Gap + Gap;
644     bRet=((Xmin - Other.Xmax > delta) ||
645           (Other.Xmin - Xmax > delta) ||
646           (Ymin - Other.Ymax > delta) ||
647           (Other.Ymin - Ymax > delta) ||
648           (Zmin - Other.Zmax > delta) ||
649           (Other.Zmin - Zmax > delta));
650     return bRet;
651   }
652   //modified by NIZNHY-PKV Fri Jul 08 11:03:46 2011t
653   if   (IsVoid())         return Standard_True;
654   if   (Other.IsVoid())   return Standard_True;
655   if   (IsWhole())        return Standard_False;
656   if   (Other.IsWhole())  return Standard_False;
657
658   Standard_Real delta = Other.Gap + Gap;
659
660   if (!IsOpenXmin() && !Other.IsOpenXmax())
661     if (Xmin - Other.Xmax > delta) return Standard_True;
662   if (!IsOpenXmax() && !Other.IsOpenXmin())
663     if (Other.Xmin - Xmax > delta) return Standard_True;
664   
665   if (!IsOpenYmin() && !Other.IsOpenYmax())
666     if (Ymin - Other.Ymax > delta) return Standard_True;
667   if (!IsOpenYmax() && !Other.IsOpenYmin())
668     if (Other.Ymin - Ymax > delta) return Standard_True;
669   
670   if (!IsOpenZmin() && !Other.IsOpenZmax())
671     if (Zmin - Other.Zmax > delta) return Standard_True;
672   if (!IsOpenZmax() && !Other.IsOpenZmin())
673     if (Other.Zmin - Zmax > delta) return Standard_True;
674
675   return Standard_False;
676 }
677
678 //=======================================================================
679 //function : IsOut
680 //purpose  : 
681 //=======================================================================
682
683 Standard_Boolean Bnd_Box::IsOut (const Bnd_Box& Other, 
684                                  const gp_Trsf& T) const
685 {
686   return IsOut(Other.Transformed(T));
687 }
688
689 //=======================================================================
690 //function : IsOut
691 //purpose  : 
692 //=======================================================================
693
694 Standard_Boolean Bnd_Box::IsOut (const gp_Trsf& T1,
695                                  const Bnd_Box& Other, 
696                                  const gp_Trsf& T2) const
697 {
698   return Transformed(T1).IsOut(Other.Transformed(T2));
699 }
700
701
702 //=======================================================================
703 //function : IsSegmentOut
704 //purpose  : 
705 //=======================================================================
706
707 static Standard_Boolean IsSegmentOut(Standard_Real x1,Standard_Real y1,
708                                      Standard_Real x2,Standard_Real y2,
709                                      Standard_Real xs1,Standard_Real ys1,
710                                      Standard_Real xs2,Standard_Real ys2)
711 {
712   Standard_Real eps = RealSmall();
713   Standard_Real xsmin = Min (xs1, xs2);
714   Standard_Real xsmax = Max (xs1, xs2);
715   Standard_Real ysmin = Min (ys1, ys2);
716   Standard_Real ysmax = Max (ys1, ys2);
717
718   if (ysmax-ysmin < eps && (y1-ys1 < eps && ys1-y2 < eps) &&
719       ((xsmin-x1 < eps && x1-xsmax < eps) || 
720        (xsmin-x2 < eps && x2-xsmax < eps) || 
721        (x1-xs1 < eps && xs1-x2 < eps)))
722     return Standard_False;
723   if (xsmax-xsmin < eps && (x1-xs1 < eps && xs1-x2 < eps) &&
724       ((ysmin-y1 < eps && y1-ysmax < eps) ||
725        (ysmin-y2 < eps && y2-ysmax < eps) ||
726        (y1-ys1 < eps && ys1-y2 < eps)))
727     return Standard_False;
728
729   if ((xs1 < x1 && xs2 < x1) || (xs1 > x2 && xs2 > x2) ||
730       (ys1 < y1 && ys2 < y1) || (ys1 > y2 && ys2 > y2) )
731     return Standard_True;
732
733   if (Abs(xs2-xs1) > eps)
734   {
735     Standard_Real ya = ( Min(x1, x2) - xs1 ) * ( ys2 - ys1 ) / ( xs2 - xs1 ) + ys1;
736     Standard_Real yb = ( Max(x1, x2) - xs1 ) * ( ys2 - ys1 ) / ( xs2 - xs1 ) + ys1;
737     if ( (ya < y1 && yb < y1) || (ya > y2 && yb > y2) ) return Standard_True;
738   }
739   else if (Abs(ys2-ys1) > eps)
740   {
741     Standard_Real xa = ( Min(y1, y2) - ys1 ) * ( xs2 - xs1 ) / ( ys2 - ys1 ) + xs1;
742     Standard_Real xb = ( Max(y1, y2) - ys1 ) * ( xs2 - xs1 ) / ( ys2 - ys1 ) + xs1;
743     if ( (xa < x1 && xb < x1) || (xa > x2 && xb > x2) ) return Standard_True;
744   }
745   else 
746     return Standard_True;
747
748   return Standard_False;
749 }
750
751 Standard_Boolean Bnd_Box::IsOut(const gp_Pnt& P1, const gp_Pnt& P2, const gp_Dir& D) const
752 {
753
754   if        (IsWhole())  return Standard_False;
755   else if   (IsVoid())   return Standard_True;
756
757   Standard_Real eps = RealSmall();
758   Standard_Real myXmin, myYmin, myZmin, myXmax, myYmax, myZmax;
759   Get (myXmin, myYmin, myZmin, myXmax, myYmax, myZmax);
760
761   if(Abs(D.X()) < eps && Abs(D.Y()) < eps)
762     return IsSegmentOut(myXmin, myYmin, myXmax, myYmax, P1.X(), P1.Y(), P2.X(), P2.Y());
763
764   if(Abs(D.X()) < eps && Abs(D.Z()) < eps)
765     return IsSegmentOut(myXmin, myZmin, myXmax, myZmax, P1.X(), P1.Z(), P2.X(), P2.Z());
766
767   if(Abs(D.Y()) < eps && Abs(D.Z()) < eps)
768     return IsSegmentOut(myYmin, myZmin, myYmax, myZmax, P1.Y(), P1.Z(), P2.Y(), P2.Z());
769
770   if(Abs(D.X()) < eps)
771   {
772     if(!IsSegmentOut(myXmin, myZmin, myXmax, myZmax,
773                      P1.X(),(myYmin-P1.Y())*D.Z()/D.Y()+P1.Z(), 
774                      P2.X(),(myYmin-P2.Y())*D.Z()/D.Y()+P2.Z()))
775       return Standard_False;
776
777     if(!IsSegmentOut(myXmin, myZmin, myXmax, myZmax,
778                      P1.X(),(myYmax-P1.Y())*D.Z()/D.Y()+P1.Z(), 
779                      P2.X(),(myYmax-P2.Y())*D.Z()/D.Y()+P2.Z()))
780       return Standard_False;
781
782     if(!IsSegmentOut(myXmin, myYmin, myXmax, myYmax,
783                      P1.X(),(myZmin-P1.Z())*D.Y()/D.Z()+P1.Y(), 
784                      P2.X(),(myZmin-P2.Z())*D.Y()/D.Z()+P2.Y()))
785       return Standard_False;
786
787     if(!IsSegmentOut(myXmin, myYmin, myXmax, myYmax,
788                      P1.X(),(myZmax-P1.Z())*D.Y()/D.Z()+P1.Y(), 
789                      P2.X(),(myZmax-P2.Z())*D.Y()/D.Z()+P2.Y()))
790       return Standard_False;
791
792     return Standard_True;
793   }//if(D.X() == 0) 
794
795   if(Abs(D.Y()) < eps)
796   {
797     if(!IsSegmentOut(myYmin, myZmin, myYmax, myZmax,
798                      P1.Y(),(myXmin-P1.X())*D.Z()/D.X()+P1.Z(), 
799                      P2.Y(),(myXmin-P2.X())*D.Z()/D.X()+P2.Z()))
800       return Standard_False;
801
802     if(!IsSegmentOut(myYmin, myZmin, myYmax, myZmax,
803                      P1.Y(),(myXmax-P1.X())*D.Z()/D.X()+P1.Z(), 
804                      P2.Y(),(myXmax-P2.X())*D.Z()/D.X()+P2.Z()))
805       return Standard_False;
806
807     if(!IsSegmentOut(myYmin, myXmin, myYmax, myXmax,
808                      P1.Y(),(myZmin-P1.Z())*D.X()/D.Z()+P1.X(), 
809                      P2.Y(),(myZmin-P2.Z())*D.X()/D.Z()+P2.X()))
810       return Standard_False;
811
812     if(!IsSegmentOut(myYmin, myXmin, myYmax, myXmax,
813                      P1.Y(),(myZmax-P1.Z())*D.X()/D.Z()+P1.X(), 
814                      P2.Y(),(myZmax-P2.Z())*D.X()/D.Z()+P2.X()))
815       return Standard_False;
816
817     return Standard_True;
818   }//if(D.Y() == 0) 
819
820   if(Abs(D.Z()) < eps)
821   {
822     if(!IsSegmentOut(myZmin, myXmin, myZmax, myXmax,
823                      P1.Z(),(myYmax-P1.Y())*D.X()/D.Y()+P1.X(), 
824                      P2.Z(),(myYmax-P2.Y())*D.X()/D.Y()+P2.X()))
825       return Standard_False;
826
827     if(!IsSegmentOut(myZmin, myXmin, myZmax, myXmax,
828                      P1.Z(),(myYmin-P1.Y())*D.X()/D.Y()+P1.X(), 
829                      P2.Z(),(myYmin-P2.Y())*D.X()/D.Y()+P2.X()))
830       return Standard_False;
831
832     if(!IsSegmentOut(myZmin, myYmin, myZmax, myYmax,
833                      P1.Z(),(myXmax-P1.X())*D.Y()/D.X()+P1.Y(), 
834                      P2.Z(),(myXmax-P2.X())*D.Y()/D.X()+P2.Y()))
835       return Standard_False;
836
837     if(!IsSegmentOut(myZmin, myYmin, myZmax, myYmax,
838                      P1.Z(),(myXmin-P1.X())*D.Y()/D.X()+P1.Y(), 
839                      P2.Z(),(myXmin-P2.X())*D.Y()/D.X()+P2.Y()))
840       return Standard_False;
841
842     return Standard_True;
843   }//if(D.Z() == 0) 
844
845   if(!IsSegmentOut(myXmin,myZmin,myXmax,myZmax,
846                    (myYmin - P1.Y())/D.Y()*D.X() + P1.X(),
847                    (myYmin - P1.Y())/D.Y()*D.Z() + P1.Z(),
848                    (myYmin - P2.Y())/D.Y()*D.X() + P2.X(),
849                    (myYmin - P2.Y())/D.Y()*D.Z() + P2.Z()))
850     return Standard_False;
851
852   if(!IsSegmentOut(myXmin,myZmin,myXmax,myZmax,
853                    (myYmax - P1.Y())/D.Y()*D.X() + P1.X(),
854                    (myYmax - P1.Y())/D.Y()*D.Z() + P1.Z(),
855                    (myYmax - P2.Y())/D.Y()*D.X() + P2.X(),
856                    (myYmax - P2.Y())/D.Y()*D.Z() + P2.Z()))
857     return Standard_False;
858
859   if(!IsSegmentOut(myXmin,myYmin,myXmax,myYmax,
860                    (myZmin - P1.Z())/D.Z()*D.X() + P1.X(),
861                    (myZmin - P1.Z())/D.Z()*D.Y() + P1.Y(),
862                    (myZmin - P2.Z())/D.Z()*D.X() + P2.X(),
863                    (myZmin - P2.Z())/D.Z()*D.Y() + P2.Y()))
864     return Standard_False;
865
866   if(!IsSegmentOut(myXmin,myYmin,myXmax,myYmax,
867                    (myZmax - P1.Z())/D.Z()*D.X() + P1.X(),
868                    (myZmax - P1.Z())/D.Z()*D.Y() + P1.Y(),
869                    (myZmax - P2.Z())/D.Z()*D.X() + P2.X(),
870                    (myZmax - P2.Z())/D.Z()*D.Y() + P2.Y()))
871     return Standard_False;
872
873   if(!IsSegmentOut(myZmin,myYmin,myZmax,myYmax,
874                    (myXmin - P1.X())/D.X()*D.Z() + P1.Z(),
875                    (myXmin - P1.X())/D.X()*D.Y() + P1.Y(),
876                    (myXmin - P2.X())/D.X()*D.Z() + P2.Z(),
877                    (myXmin - P2.X())/D.X()*D.Y() + P2.Y()))
878     return Standard_False;
879
880   if(!IsSegmentOut(myZmin,myYmin,myZmax,myYmax,
881                    (myXmax - P1.X())/D.X()*D.Z() + P1.Z(),
882                    (myXmax - P1.X())/D.X()*D.Y() + P1.Y(),
883                    (myXmax - P2.X())/D.X()*D.Z() + P2.Z(),
884                    (myXmax - P2.X())/D.X()*D.Y() + P2.Y()))
885     return Standard_False;
886
887   return Standard_True; 
888
889 }
890
891 //=======================================================================
892 //function : Distance
893 //purpose  : computes the minimum distance between two boxes 
894 //=======================================================================
895
896 static Standard_Real DistMini2Box( const Standard_Real r1min, const  Standard_Real r1max,  const Standard_Real r2min, const  Standard_Real r2max)
897 {  Standard_Real   r1, r2;
898
899    r1 = Square(r1min - r2max);
900    r2 = Square(r1max - r2min);
901    return (Min( r1, r2 ));   
902 }
903
904
905
906 Standard_Real Bnd_Box::Distance(const Bnd_Box& Other) const 
907 {  Standard_Real   xminB1, yminB1, zminB1, xmaxB1, ymaxB1, zmaxB1;
908    Standard_Real   xminB2, yminB2, zminB2, xmaxB2, ymaxB2, zmaxB2;
909    Standard_Real   dist_x, dist_y, dist_z, dist_t;
910
911    Get( xminB1, yminB1, zminB1, xmaxB1, ymaxB1, zmaxB1);
912    Other.Get( xminB2, yminB2, zminB2, xmaxB2, ymaxB2, zmaxB2);
913
914    if ( ((xminB1<= xminB2)&&( xminB2 <= xmaxB1)) || ((xminB2<= xminB1)&&( xminB1 <= xmaxB2)) )
915       { dist_x=0; }
916       else { dist_x= DistMini2Box(xminB1, xmaxB1, xminB2, xmaxB2);}
917    if ( ((yminB1<= yminB2)&&( yminB2 <= ymaxB1)) || ((yminB2<= yminB1)&&( yminB1 <= ymaxB2)) )
918       { dist_y=0; }
919       else { dist_y= DistMini2Box(yminB1, ymaxB1, yminB2, ymaxB2);}  
920    if ( ((zminB1<= zminB2)&&( zminB2 <= zmaxB1)) || ((zminB2<= zminB1)&&( zminB1 <= zmaxB2)) )
921       { dist_z=0; }
922       else { dist_z= DistMini2Box(zminB1, zmaxB1, zminB2, zmaxB2);}
923    dist_t = dist_x+ dist_y+ dist_z;
924    return( Sqrt ( dist_t));
925 }
926
927 //=======================================================================
928 //function : Dump
929 //purpose  : 
930 //=======================================================================
931
932 void Bnd_Box::Dump () const
933 {
934   cout << "Box3D : ";
935   if      (IsVoid())  cout << "Void";
936   else if (IsWhole()) cout << "Whole";
937   else {
938     cout << "\n Xmin : ";
939     if (IsOpenXmin()) cout << "Infinite";
940     else              cout << Xmin;
941     cout << "\n Xmax : ";
942     if (IsOpenXmax()) cout << "Infinite";
943     else              cout << Xmax;
944     cout << "\n Ymin : ";
945     if (IsOpenYmin()) cout << "Infinite";
946     else              cout << Ymin;
947     cout << "\n Ymax : ";
948     if (IsOpenYmax()) cout << "Infinite";
949     else              cout << Ymax;
950     cout << "\n Zmin : ";
951     if (IsOpenZmin()) cout << "Infinite";
952     else              cout << Zmin;
953     cout << "\n Zmax : ";
954     if (IsOpenZmax()) cout << "Infinite";
955     else              cout << Zmax;
956   }
957   cout << "\n Gap : " << Gap;
958   cout << "\n";
959 }