src/Bnd/Bnd_Box.cxx

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