src/Graphic3d/Graphic3d_Camera.cxx

   1 // Created on: 2013-05-29
   2 // Created by: Anton POLETAEV
   3 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 #include <Graphic3d_Camera.hxx>
  17
  18 #include <gp_Pln.hxx>
  19 #include <gp_QuaternionNLerp.hxx>
  20 #include <gp_QuaternionSLerp.hxx>
  21 #include <Graphic3d_Vec4.hxx>
  22 #include <Graphic3d_WorldViewProjState.hxx>
  23 #include <NCollection_Sequence.hxx>
  24 #include <Standard_ShortReal.hxx>
  25 #include <Standard_Atomic.hxx>
  26 #include <Standard_Assert.hxx>
  27
  28 IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Camera,Standard_Transient)
  29
  30 namespace
  31 {
  32   // (degrees -> radians) * 0.5
  33   static const Standard_Real DTR_HALF = 0.5 * 0.0174532925;
  34
  35   // default property values
  36   static const Standard_Real DEFAULT_ZNEAR = 0.001;
  37   static const Standard_Real DEFAULT_ZFAR  = 3000.0;
  38
  39   // atomic state counter
  40   static volatile Standard_Integer THE_STATE_COUNTER = 0;
  41
  42   // minimum camera distance
  43   static const Standard_Real MIN_DISTANCE = Pow (0.1, ShortRealDigits() - 2);
  44
  45   // z-range tolerance compatible with for floating point.
  46   static Standard_Real zEpsilon()
  47   {
  48     return FLT_EPSILON;
  49   }
  50
  51   // relative z-range tolerance compatible with for floating point.
  52   static Standard_Real zEpsilon (const Standard_Real theValue)
  53   {
  54     Standard_Real anAbsValue = Abs (theValue);
  55     if (anAbsValue <= (double)FLT_MIN)
  56     {
  57       return FLT_MIN;
  58     }
  59     Standard_Real aLogRadix = Log10 (anAbsValue) / Log10 (FLT_RADIX);
  60     Standard_Real aExp = Floor (aLogRadix);
  61     return FLT_EPSILON * Pow (FLT_RADIX, aExp);
  62   }
  63
  64   //! Convert camera definition to Ax3
  65   gp_Ax3 cameraToAx3 (const Graphic3d_Camera& theCamera)
  66   {
  67     const gp_Dir aBackDir(gp_Vec(theCamera.Center(), theCamera.Eye()));
  68     const gp_Dir anXAxis (theCamera.Up().Crossed (aBackDir));
  69     const gp_Dir anYAxis (aBackDir      .Crossed (anXAxis));
  70     const gp_Dir aZAxis  (anXAxis       .Crossed (anYAxis));
  71     return gp_Ax3 (gp_Pnt (0.0, 0.0, 0.0), aZAxis, anXAxis);
  72   }
  73 }
  74
  75 // =======================================================================
  76 // function : Graphic3d_Camera
  77 // purpose  :
  78 // =======================================================================
  79 Graphic3d_Camera::Graphic3d_Camera()
  80 : myUp (0.0, 1.0, 0.0),
  81   myEye (0.0, 0.0, -1500.0),
  82   myCenter (0.0, 0.0, 0.0),
  83   myAxialScale (1.0, 1.0, 1.0),
  84   myProjType (Projection_Orthographic),
  85   myFOVy (45.0),
  86   myFOVyTan (Tan (DTR_HALF * 45.0)),
  87   myZNear (DEFAULT_ZNEAR),
  88   myZFar (DEFAULT_ZFAR),
  89   myAspect (1.0),
  90   myScale (1000.0),
  91   myZFocus (1.0),
  92   myZFocusType (FocusType_Relative),
  93   myIOD (0.05),
  94   myIODType (IODType_Relative)
  95 {
  96   myWorldViewProjState.Initialize ((Standard_Size)Standard_Atomic_Increment (&THE_STATE_COUNTER),
  97                                    (Standard_Size)Standard_Atomic_Increment (&THE_STATE_COUNTER),
  98                                    this);
  99 }
 100
 101 // =======================================================================
 102 // function : Graphic3d_Camera
 103 // purpose  :
 104 // =======================================================================
 105 Graphic3d_Camera::Graphic3d_Camera (const Handle(Graphic3d_Camera)& theOther)
 106 {
 107   myWorldViewProjState.Initialize (this);
 108
 109   Copy (theOther);
 110 }
 111
 112 // =======================================================================
 113 // function : CopyMappingData
 114 // purpose  :
 115 // =======================================================================
 116 void Graphic3d_Camera::CopyMappingData (const Handle(Graphic3d_Camera)& theOtherCamera)
 117 {
 118   SetFOVy           (theOtherCamera->FOVy());
 119   SetZRange         (theOtherCamera->ZNear(), theOtherCamera->ZFar());
 120   SetAspect         (theOtherCamera->Aspect());
 121   SetScale          (theOtherCamera->Scale());
 122   SetZFocus         (theOtherCamera->ZFocusType(), theOtherCamera->ZFocus());
 123   SetIOD            (theOtherCamera->GetIODType(), theOtherCamera->IOD());
 124   SetProjectionType (theOtherCamera->ProjectionType());
 125   SetTile           (theOtherCamera->myTile);
 126 }
 127
 128 // =======================================================================
 129 // function : CopyOrientationData
 130 // purpose  :
 131 // =======================================================================
 132 void Graphic3d_Camera::CopyOrientationData (const Handle(Graphic3d_Camera)& theOtherCamera)
 133 {
 134   SetUp         (theOtherCamera->Up());
 135   SetEye        (theOtherCamera->Eye());
 136   SetCenter     (theOtherCamera->Center());
 137   SetAxialScale (theOtherCamera->AxialScale());
 138 }
 139
 140 // =======================================================================
 141 // function : Copy
 142 // purpose  :
 143 // =======================================================================
 144 void Graphic3d_Camera::Copy (const Handle(Graphic3d_Camera)& theOther)
 145 {
 146   CopyMappingData (theOther);
 147   CopyOrientationData (theOther);
 148 }
 149
 150 // =======================================================================
 151 // function : SetEye
 152 // purpose  :
 153 // =======================================================================
 154 void Graphic3d_Camera::SetEye (const gp_Pnt& theEye)
 155 {
 156   if (Eye().IsEqual (theEye, 0.0))
 157   {
 158     return;
 159   }
 160
 161   myEye = theEye;
 162   InvalidateOrientation();
 163 }
 164
 165 // =======================================================================
 166 // function : SetCenter
 167 // purpose  :
 168 // =======================================================================
 169 void Graphic3d_Camera::SetCenter (const gp_Pnt& theCenter)
 170 {
 171   if (Center().IsEqual (theCenter, 0.0))
 172   {
 173     return;
 174   }
 175
 176   myCenter = theCenter;
 177   InvalidateOrientation();
 178 }
 179
 180 // =======================================================================
 181 // function : SetUp
 182 // purpose  :
 183 // =======================================================================
 184 void Graphic3d_Camera::SetUp (const gp_Dir& theUp)
 185 {
 186   if (Up().IsEqual (theUp, 0.0))
 187   {
 188     return;
 189   }
 190
 191   myUp = theUp;
 192   InvalidateOrientation();
 193 }
 194
 195 // =======================================================================
 196 // function : SetAxialScale
 197 // purpose  :
 198 // =======================================================================
 199 void Graphic3d_Camera::SetAxialScale (const gp_XYZ& theAxialScale)
 200 {
 201   if (AxialScale().IsEqual (theAxialScale, 0.0))
 202   {
 203     return;
 204   }
 205
 206   myAxialScale = theAxialScale;
 207   InvalidateOrientation();
 208 }
 209
 210 // =======================================================================
 211 // function : SetDistance
 212 // purpose  :
 213 // =======================================================================
 214 void Graphic3d_Camera::SetDistance (const Standard_Real theDistance)
 215 {
 216   if (Distance() == theDistance)
 217   {
 218     return;
 219   }
 220
 221   gp_Vec aCenter2Eye (Direction());
 222   aCenter2Eye.Reverse();
 223
 224   // Camera should have non-zero distance.
 225   aCenter2Eye.Scale (Max (theDistance, MIN_DISTANCE));
 226   SetEye (Center().Translated (aCenter2Eye));
 227 }
 228
 229 // =======================================================================
 230 // function : Distance
 231 // purpose  :
 232 // =======================================================================
 233 Standard_Real Graphic3d_Camera::Distance() const
 234 {
 235   return myEye.Distance (myCenter);
 236 }
 237
 238 // =======================================================================
 239 // function : SetDirection
 240 // purpose  :
 241 // =======================================================================
 242 void Graphic3d_Camera::SetDirection (const gp_Dir& theDir)
 243 {
 244   if (Direction().IsEqual (theDir, 0.0))
 245   {
 246     return;
 247   }
 248
 249   gp_Vec aScaledDir (theDir);
 250   aScaledDir.Scale (Distance());
 251   aScaledDir.Reverse();
 252   SetEye (Center().Translated (aScaledDir));
 253 }
 254
 255 // =======================================================================
 256 // function : Direction
 257 // purpose  :
 258 // =======================================================================
 259 gp_Dir Graphic3d_Camera::Direction() const
 260 {
 261   return gp_Dir (gp_Vec (myEye, myCenter));
 262 }
 263
 264 // =======================================================================
 265 // function : SetScale
 266 // purpose  :
 267 // =======================================================================
 268 void Graphic3d_Camera::SetScale (const Standard_Real theScale)
 269 {
 270   if (Scale() == theScale)
 271   {
 272     return;
 273   }
 274
 275   myScale = theScale;
 276
 277   switch (myProjType)
 278   {
 279     case Projection_Perspective  :
 280     case Projection_Stereo       :
 281     case Projection_MonoLeftEye  :
 282     case Projection_MonoRightEye :
 283     {
 284       Standard_Real aDistance = theScale * 0.5 / myFOVyTan;
 285       SetDistance (aDistance);
 286     }
 287
 288     default :
 289       break;
 290   }
 291
 292   InvalidateProjection();
 293 }
 294
 295 // =======================================================================
 296 // function : Scale
 297 // purpose  :
 298 // =======================================================================
 299 Standard_Real Graphic3d_Camera::Scale() const
 300 {
 301   switch (myProjType)
 302   {
 303     case Projection_Orthographic :
 304       return myScale;
 305
 306     // case Projection_Perspective  :
 307     // case Projection_Stereo       :
 308     // case Projection_MonoLeftEye  :
 309     // case Projection_MonoRightEye :
 310     default :
 311       return Distance() * 2.0 * myFOVyTan;
 312   }
 313 }
 314
 315 // =======================================================================
 316 // function : SetProjectionType
 317 // purpose  :
 318 // =======================================================================
 319 void Graphic3d_Camera::SetProjectionType (const Projection theProjectionType)
 320 {
 321   Projection anOldType = ProjectionType();
 322
 323   if (anOldType == theProjectionType)
 324   {
 325     return;
 326   }
 327
 328   if (anOldType == Projection_Orthographic)
 329   {
 330     if (myZNear <= RealEpsilon())
 331     {
 332       myZNear = DEFAULT_ZNEAR;
 333     }
 334     if (myZFar <= RealEpsilon())
 335     {
 336       myZFar = DEFAULT_ZFAR;
 337     }
 338   }
 339
 340   myProjType = theProjectionType;
 341
 342   InvalidateProjection();
 343 }
 344
 345 // =======================================================================
 346 // function : SetFOVy
 347 // purpose  :
 348 // =======================================================================
 349 void Graphic3d_Camera::SetFOVy (const Standard_Real theFOVy)
 350 {
 351   if (FOVy() == theFOVy)
 352   {
 353     return;
 354   }
 355
 356   myFOVy = theFOVy;
 357   myFOVyTan = Tan(DTR_HALF * myFOVy);
 358
 359   InvalidateProjection();
 360 }
 361
 362 // =======================================================================
 363 // function : SetZRange
 364 // purpose  :
 365 // =======================================================================
 366 void Graphic3d_Camera::SetZRange (const Standard_Real theZNear,
 367                                   const Standard_Real theZFar)
 368 {
 369   Standard_ASSERT_RAISE (theZFar > theZNear, "ZFar should be greater than ZNear");
 370   if (!IsOrthographic())
 371   {
 372     Standard_ASSERT_RAISE (theZNear > 0.0, "Only positive Z-Near is allowed for perspective camera");
 373     Standard_ASSERT_RAISE (theZFar  > 0.0, "Only positive Z-Far is allowed for perspective camera");
 374   }
 375
 376   if (ZNear() == theZNear
 377    && ZFar () == theZFar)
 378   {
 379     return;
 380   }
 381
 382   myZNear = theZNear;
 383   myZFar  = theZFar;
 384
 385   InvalidateProjection();
 386 }
 387
 388 // =======================================================================
 389 // function : SetAspect
 390 // purpose  :
 391 // =======================================================================
 392 void Graphic3d_Camera::SetAspect (const Standard_Real theAspect)
 393 {
 394   if (Aspect() == theAspect)
 395   {
 396     return;
 397   }
 398
 399   myAspect = theAspect;
 400
 401   InvalidateProjection();
 402 }
 403
 404 // =======================================================================
 405 // function : SetZFocus
 406 // purpose  :
 407 // =======================================================================
 408 void Graphic3d_Camera::SetZFocus(const FocusType theType, const Standard_Real theZFocus)
 409 {
 410   if (ZFocusType() == theType
 411    && ZFocus    () == theZFocus)
 412   {
 413     return;
 414   }
 415
 416   myZFocusType = theType;
 417   myZFocus     = theZFocus;
 418
 419   InvalidateProjection();
 420 }
 421
 422 // =======================================================================
 423 // function : SetIOD
 424 // purpose  :
 425 // =======================================================================
 426 void Graphic3d_Camera::SetIOD (const IODType theType, const Standard_Real theIOD)
 427 {
 428   if (GetIODType() == theType
 429    && IOD       () == theIOD)
 430   {
 431     return;
 432   }
 433
 434   myIODType = theType;
 435   myIOD     = theIOD;
 436
 437   InvalidateProjection();
 438 }
 439
 440 // =======================================================================
 441 // function : SetTile
 442 // purpose  :
 443 // =======================================================================
 444 void Graphic3d_Camera::SetTile (const Graphic3d_CameraTile& theTile)
 445 {
 446   if (myTile == theTile)
 447   {
 448     return;
 449   }
 450
 451   myTile = theTile;
 452   InvalidateProjection();
 453 }
 454
 455 // =======================================================================
 456 // function : OrthogonalizeUp
 457 // purpose  :
 458 // =======================================================================
 459 void Graphic3d_Camera::OrthogonalizeUp()
 460 {
 461   SetUp (OrthogonalizedUp());
 462 }
 463
 464 // =======================================================================
 465 // function : OrthogonalizedUp
 466 // purpose  :
 467 // =======================================================================
 468 gp_Dir Graphic3d_Camera::OrthogonalizedUp() const
 469 {
 470   gp_Dir aDir  = Direction();
 471   gp_Dir aLeft = aDir.Crossed (Up());
 472
 473   // recompute up as: up = left x direction
 474   return aLeft.Crossed (aDir);
 475 }
 476
 477 // =======================================================================
 478 // function : Transform
 479 // purpose  :
 480 // =======================================================================
 481 void Graphic3d_Camera::Transform (const gp_Trsf& theTrsf)
 482 {
 483   if (theTrsf.Form() == gp_Identity)
 484   {
 485     return;
 486   }
 487
 488   SetUp     (myUp.Transformed (theTrsf));
 489   SetEye    (myEye.Transformed (theTrsf));
 490   SetCenter (myCenter.Transformed (theTrsf));
 491 }
 492
 493 // =======================================================================
 494 // function : safePointCast
 495 // purpose  :
 496 // =======================================================================
 497 static Graphic3d_Vec4d safePointCast (const gp_Pnt& thePnt)
 498 {
 499   Standard_Real aLim = 1e15f;
 500
 501   // have to deal with values greater then max float
 502   gp_Pnt aSafePoint = thePnt;
 503   const Standard_Real aBigFloat = aLim * 0.1f;
 504   if (Abs (aSafePoint.X()) > aLim)
 505     aSafePoint.SetX (aSafePoint.X() >= 0 ? aBigFloat : -aBigFloat);
 506   if (Abs (aSafePoint.Y()) > aLim)
 507     aSafePoint.SetY (aSafePoint.Y() >= 0 ? aBigFloat : -aBigFloat);
 508   if (Abs (aSafePoint.Z()) > aLim)
 509     aSafePoint.SetZ (aSafePoint.Z() >= 0 ? aBigFloat : -aBigFloat);
 510
 511   // convert point
 512   Graphic3d_Vec4d aPnt (aSafePoint.X(), aSafePoint.Y(), aSafePoint.Z(), 1.0);
 513
 514   return aPnt;
 515 }
 516
 517 // =======================================================================
 518 // function : Project
 519 // purpose  :
 520 // =======================================================================
 521 gp_Pnt Graphic3d_Camera::Project (const gp_Pnt& thePnt) const
 522 {
 523   const Graphic3d_Mat4d& aViewMx = OrientationMatrix();
 524   const Graphic3d_Mat4d& aProjMx = ProjectionMatrix();
 525
 526   // use compatible type of point
 527   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 528
 529   aPnt = aViewMx * aPnt; // convert to view coordinate space
 530   aPnt = aProjMx * aPnt; // convert to projection coordinate space
 531
 532   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 533
 534   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 535 }
 536
 537 // =======================================================================
 538 // function : UnProject
 539 // purpose  :
 540 // =======================================================================
 541 gp_Pnt Graphic3d_Camera::UnProject (const gp_Pnt& thePnt) const
 542 {
 543   const Graphic3d_Mat4d& aViewMx = OrientationMatrix();
 544   const Graphic3d_Mat4d& aProjMx = ProjectionMatrix();
 545
 546   Graphic3d_Mat4d aInvView;
 547   Graphic3d_Mat4d aInvProj;
 548
 549   // this case should never happen
 550   if (!aViewMx.Inverted (aInvView) || !aProjMx.Inverted (aInvProj))
 551   {
 552     return gp_Pnt (0.0, 0.0, 0.0);
 553   }
 554
 555   // use compatible type of point
 556   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 557
 558   aPnt = aInvProj * aPnt; // convert to view coordinate space
 559   aPnt = aInvView * aPnt; // convert to world coordinate space
 560
 561   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 562
 563   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 564 }
 565
 566 // =======================================================================
 567 // function : ConvertView2Proj
 568 // purpose  :
 569 // =======================================================================
 570 gp_Pnt Graphic3d_Camera::ConvertView2Proj (const gp_Pnt& thePnt) const
 571 {
 572   const Graphic3d_Mat4d& aProjMx = ProjectionMatrix();
 573
 574   // use compatible type of point
 575   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 576
 577   aPnt = aProjMx * aPnt; // convert to projection coordinate space
 578
 579   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 580
 581   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 582 }
 583
 584 // =======================================================================
 585 // function : ConvertProj2View
 586 // purpose  :
 587 // =======================================================================
 588 gp_Pnt Graphic3d_Camera::ConvertProj2View (const gp_Pnt& thePnt) const
 589 {
 590   const Graphic3d_Mat4d& aProjMx = ProjectionMatrix();
 591
 592   Graphic3d_Mat4d aInvProj;
 593
 594   // this case should never happen, but...
 595   if (!aProjMx.Inverted (aInvProj))
 596   {
 597     return gp_Pnt (0, 0, 0);
 598   }
 599
 600   // use compatible type of point
 601   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 602
 603   aPnt = aInvProj * aPnt; // convert to view coordinate space
 604
 605   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 606
 607   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 608 }
 609
 610 // =======================================================================
 611 // function : ConvertWorld2View
 612 // purpose  :
 613 // =======================================================================
 614 gp_Pnt Graphic3d_Camera::ConvertWorld2View (const gp_Pnt& thePnt) const
 615 {
 616   const Graphic3d_Mat4d& aViewMx = OrientationMatrix();
 617
 618   // use compatible type of point
 619   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 620
 621   aPnt = aViewMx * aPnt; // convert to view coordinate space
 622
 623   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 624
 625   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 626 }
 627
 628 // =======================================================================
 629 // function : ConvertView2World
 630 // purpose  :
 631 // =======================================================================
 632 gp_Pnt Graphic3d_Camera::ConvertView2World (const gp_Pnt& thePnt) const
 633 {
 634   const Graphic3d_Mat4d& aViewMx = OrientationMatrix();
 635
 636   Graphic3d_Mat4d aInvView;
 637
 638   if (!aViewMx.Inverted (aInvView))
 639   {
 640     return gp_Pnt(0, 0, 0);
 641   }
 642
 643   // use compatible type of point
 644   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 645
 646   aPnt = aInvView * aPnt; // convert to world coordinate space
 647
 648   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 649
 650   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 651 }
 652
 653 // =======================================================================
 654 // function : ViewDimensions
 655 // purpose  :
 656 // =======================================================================
 657 gp_XYZ Graphic3d_Camera::ViewDimensions (const Standard_Real theZValue) const
 658 {
 659   // view plane dimensions
 660   Standard_Real aSize = IsOrthographic() ? myScale : (2.0 * theZValue * myFOVyTan);
 661   Standard_Real aSizeX, aSizeY;
 662   if (myAspect > 1.0)
 663   {
 664     aSizeX = aSize * myAspect;
 665     aSizeY = aSize;
 666   }
 667   else
 668   {
 669     aSizeX = aSize;
 670     aSizeY = aSize / myAspect;
 671   }
 672
 673   // and frustum depth
 674   return gp_XYZ (aSizeX, aSizeY, myZFar - myZNear);
 675 }
 676
 677 // =======================================================================
 678 // function : Frustum
 679 // purpose  :
 680 // =======================================================================
 681 void Graphic3d_Camera::Frustum (gp_Pln& theLeft,
 682                                 gp_Pln& theRight,
 683                                 gp_Pln& theBottom,
 684                                 gp_Pln& theTop,
 685                                 gp_Pln& theNear,
 686                                 gp_Pln& theFar) const
 687 {
 688   gp_Vec aProjection = gp_Vec (Direction());
 689   gp_Vec anUp        = OrthogonalizedUp();
 690   gp_Vec aSide       = aProjection ^ anUp;
 691
 692   Standard_ASSERT_RAISE (
 693     !aProjection.IsParallel (anUp, Precision::Angular()),
 694      "Can not derive SIDE = PROJ x UP - directions are parallel");
 695
 696   theNear = gp_Pln (Eye().Translated (aProjection * ZNear()), aProjection);
 697   theFar  = gp_Pln (Eye().Translated (aProjection * ZFar()), -aProjection);
 698
 699   Standard_Real aHScaleHor = 0.0, aHScaleVer = 0.0;
 700   if (Aspect() >= 1.0)
 701   {
 702     aHScaleHor = Scale() * 0.5 * Aspect();
 703     aHScaleVer = Scale() * 0.5;
 704   }
 705   else
 706   {
 707     aHScaleHor = Scale() * 0.5;
 708     aHScaleVer = Scale() * 0.5 / Aspect();
 709   }
 710
 711   gp_Pnt aPntLeft   = Center().Translated (aHScaleHor * -aSide);
 712   gp_Pnt aPntRight  = Center().Translated (aHScaleHor *  aSide);
 713   gp_Pnt aPntBottom = Center().Translated (aHScaleVer * -anUp);
 714   gp_Pnt aPntTop    = Center().Translated (aHScaleVer *  anUp);
 715
 716   gp_Vec aDirLeft   =  aSide;
 717   gp_Vec aDirRight  = -aSide;
 718   gp_Vec aDirBottom =  anUp;
 719   gp_Vec aDirTop    = -anUp;
 720   if (!IsOrthographic())
 721   {
 722     Standard_Real aHFOVHor = ATan (Tan (DTR_HALF * FOVy()) * Aspect());
 723     Standard_Real aHFOVVer = DTR_HALF * FOVy();
 724     aDirLeft.Rotate   (gp_Ax1 (gp::Origin(), anUp),   aHFOVHor);
 725     aDirRight.Rotate  (gp_Ax1 (gp::Origin(), anUp),  -aHFOVHor);
 726     aDirBottom.Rotate (gp_Ax1 (gp::Origin(), aSide), -aHFOVVer);
 727     aDirTop.Rotate    (gp_Ax1 (gp::Origin(), aSide),  aHFOVVer);
 728   }
 729
 730   theLeft   = gp_Pln (aPntLeft,   aDirLeft);
 731   theRight  = gp_Pln (aPntRight,  aDirRight);
 732   theBottom = gp_Pln (aPntBottom, aDirBottom);
 733   theTop    = gp_Pln (aPntTop,    aDirTop);
 734 }
 735
 736 // =======================================================================
 737 // function : OrientationMatrix
 738 // purpose  :
 739 // =======================================================================
 740 const Graphic3d_Mat4d& Graphic3d_Camera::OrientationMatrix() const
 741 {
 742   return UpdateOrientation (myMatricesD).Orientation;
 743 }
 744
 745 // =======================================================================
 746 // function : OrientationMatrixF
 747 // purpose  :
 748 // =======================================================================
 749 const Graphic3d_Mat4& Graphic3d_Camera::OrientationMatrixF() const
 750 {
 751   return UpdateOrientation (myMatricesF).Orientation;
 752 }
 753
 754 // =======================================================================
 755 // function : ProjectionMatrix
 756 // purpose  :
 757 // =======================================================================
 758 const Graphic3d_Mat4d& Graphic3d_Camera::ProjectionMatrix() const
 759 {
 760   return UpdateProjection (myMatricesD).MProjection;
 761 }
 762
 763 // =======================================================================
 764 // function : ProjectionMatrixF
 765 // purpose  :
 766 // =======================================================================
 767 const Graphic3d_Mat4& Graphic3d_Camera::ProjectionMatrixF() const
 768 {
 769   return UpdateProjection (myMatricesF).MProjection;
 770 }
 771
 772 // =======================================================================
 773 // function : ProjectionStereoLeft
 774 // purpose  :
 775 // =======================================================================
 776 const Graphic3d_Mat4d& Graphic3d_Camera::ProjectionStereoLeft() const
 777 {
 778   return UpdateProjection (myMatricesD).LProjection;
 779 }
 780
 781 // =======================================================================
 782 // function : ProjectionStereoLeftF
 783 // purpose  :
 784 // =======================================================================
 785 const Graphic3d_Mat4& Graphic3d_Camera::ProjectionStereoLeftF() const
 786 {
 787   return UpdateProjection (myMatricesF).LProjection;
 788 }
 789
 790 // =======================================================================
 791 // function : ProjectionStereoRight
 792 // purpose  :
 793 // =======================================================================
 794 const Graphic3d_Mat4d& Graphic3d_Camera::ProjectionStereoRight() const
 795 {
 796   return UpdateProjection (myMatricesD).RProjection;
 797 }
 798
 799 // =======================================================================
 800 // function : ProjectionStereoRightF
 801 // purpose  :
 802 // =======================================================================
 803 const Graphic3d_Mat4& Graphic3d_Camera::ProjectionStereoRightF() const
 804 {
 805   return UpdateProjection (myMatricesF).RProjection;
 806 }
 807
 808 // =======================================================================
 809 // function : UpdateProjection
 810 // purpose  :
 811 // =======================================================================
 812 template <typename Elem_t>
 813 Graphic3d_Camera::TransformMatrices<Elem_t>&
 814   Graphic3d_Camera::UpdateProjection (TransformMatrices<Elem_t>& theMatrices) const
 815 {
 816   if (theMatrices.IsProjectionValid())
 817   {
 818     return theMatrices; // for inline accessors
 819   }
 820
 821   theMatrices.InitProjection();
 822
 823   // sets top of frustum based on FOVy and near clipping plane
 824   Elem_t aScale   = static_cast<Elem_t> (myScale);
 825   Elem_t aZNear   = static_cast<Elem_t> (myZNear);
 826   Elem_t aZFar    = static_cast<Elem_t> (myZFar);
 827   Elem_t anAspect = static_cast<Elem_t> (myAspect);
 828   Elem_t aDXHalf = 0.0, aDYHalf = 0.0;
 829   if (IsOrthographic())
 830   {
 831     aDXHalf = aScale * Elem_t (0.5);
 832     aDYHalf = aScale * Elem_t (0.5);
 833   }
 834   else
 835   {
 836     aDXHalf = aZNear * Elem_t (myFOVyTan);
 837     aDYHalf = aZNear * Elem_t (myFOVyTan);
 838   }
 839
 840   if (anAspect > 1.0)
 841   {
 842     aDXHalf *= anAspect;
 843   }
 844   else
 845   {
 846     aDYHalf /= anAspect;
 847   }
 848
 849   // sets right of frustum based on aspect ratio
 850   Elem_t aLeft   = -aDXHalf;
 851   Elem_t aRight  =  aDXHalf;
 852   Elem_t aBot    = -aDYHalf;
 853   Elem_t aTop    =  aDYHalf;
 854
 855   Elem_t aIOD  = myIODType == IODType_Relative
 856     ? static_cast<Elem_t> (myIOD * Distance())
 857     : static_cast<Elem_t> (myIOD);
 858
 859   Elem_t aFocus = myZFocusType == FocusType_Relative
 860     ? static_cast<Elem_t> (myZFocus * Distance())
 861     : static_cast<Elem_t> (myZFocus);
 862
 863   if (myTile.IsValid())
 864   {
 865     const Elem_t aDXFull = Elem_t(2) * aDXHalf;
 866     const Elem_t aDYFull = Elem_t(2) * aDYHalf;
 867     const Graphic3d_Vec2i anOffset = myTile.OffsetLowerLeft();
 868     aLeft  = -aDXHalf + aDXFull * static_cast<Elem_t> (anOffset.x())                       / static_cast<Elem_t> (myTile.TotalSize.x());
 869     aRight = -aDXHalf + aDXFull * static_cast<Elem_t> (anOffset.x() + myTile.TileSize.x()) / static_cast<Elem_t> (myTile.TotalSize.x());
 870     aBot   = -aDYHalf + aDYFull * static_cast<Elem_t> (anOffset.y())                       / static_cast<Elem_t> (myTile.TotalSize.y());
 871     aTop   = -aDYHalf + aDYFull * static_cast<Elem_t> (anOffset.y() + myTile.TileSize.y()) / static_cast<Elem_t> (myTile.TotalSize.y());
 872   }
 873
 874   switch (myProjType)
 875   {
 876     case Projection_Orthographic :
 877       OrthoProj (aLeft, aRight, aBot, aTop, aZNear, aZFar, theMatrices.MProjection);
 878       break;
 879
 880     case Projection_Perspective :
 881       PerspectiveProj (aLeft, aRight, aBot, aTop, aZNear, aZFar, theMatrices.MProjection);
 882       break;
 883
 884     case Projection_MonoLeftEye :
 885     {
 886       StereoEyeProj (aLeft, aRight, aBot, aTop,
 887                      aZNear, aZFar, aIOD, aFocus,
 888                      Standard_True, theMatrices.MProjection);
 889       theMatrices.LProjection = theMatrices.MProjection;
 890       break;
 891     }
 892
 893     case Projection_MonoRightEye :
 894     {
 895       StereoEyeProj (aLeft, aRight, aBot, aTop,
 896                      aZNear, aZFar, aIOD, aFocus,
 897                      Standard_False, theMatrices.MProjection);
 898       theMatrices.RProjection = theMatrices.MProjection;
 899       break;
 900     }
 901
 902     case Projection_Stereo :
 903     {
 904       PerspectiveProj (aLeft, aRight, aBot, aTop, aZNear, aZFar, theMatrices.MProjection);
 905
 906       StereoEyeProj (aLeft, aRight, aBot, aTop,
 907                      aZNear, aZFar, aIOD, aFocus,
 908                      Standard_True,
 909                      theMatrices.LProjection);
 910
 911       StereoEyeProj (aLeft, aRight, aBot, aTop,
 912                      aZNear, aZFar, aIOD, aFocus,
 913                      Standard_False,
 914                      theMatrices.RProjection);
 915       break;
 916     }
 917   }
 918
 919   return theMatrices; // for inline accessors
 920 }
 921
 922 // =======================================================================
 923 // function : UpdateOrientation
 924 // purpose  :
 925 // =======================================================================
 926 template <typename Elem_t>
 927 Graphic3d_Camera::TransformMatrices<Elem_t>&
 928   Graphic3d_Camera::UpdateOrientation (TransformMatrices<Elem_t>& theMatrices) const
 929 {
 930   if (theMatrices.IsOrientationValid())
 931   {
 932     return theMatrices; // for inline accessors
 933   }
 934
 935   theMatrices.InitOrientation();
 936
 937   NCollection_Vec3<Elem_t> anEye (static_cast<Elem_t> (myEye.X()),
 938                                   static_cast<Elem_t> (myEye.Y()),
 939                                   static_cast<Elem_t> (myEye.Z()));
 940
 941   NCollection_Vec3<Elem_t> aCenter (static_cast<Elem_t> (myCenter.X()),
 942                                     static_cast<Elem_t> (myCenter.Y()),
 943                                     static_cast<Elem_t> (myCenter.Z()));
 944
 945   NCollection_Vec3<Elem_t> anUp (static_cast<Elem_t> (myUp.X()),
 946                                  static_cast<Elem_t> (myUp.Y()),
 947                                  static_cast<Elem_t> (myUp.Z()));
 948
 949   NCollection_Vec3<Elem_t> anAxialScale (static_cast<Elem_t> (myAxialScale.X()),
 950                                          static_cast<Elem_t> (myAxialScale.Y()),
 951                                          static_cast<Elem_t> (myAxialScale.Z()));
 952
 953   LookOrientation (anEye, aCenter, anUp, anAxialScale, theMatrices.Orientation);
 954
 955   return theMatrices; // for inline accessors
 956 }
 957
 958 // =======================================================================
 959 // function : InvalidateProjection
 960 // purpose  :
 961 // =======================================================================
 962 void Graphic3d_Camera::InvalidateProjection()
 963 {
 964   myMatricesD.ResetProjection();
 965   myMatricesF.ResetProjection();
 966   myWorldViewProjState.ProjectionState() = (Standard_Size)Standard_Atomic_Increment (&THE_STATE_COUNTER);
 967 }
 968
 969 // =======================================================================
 970 // function : InvalidateOrientation
 971 // purpose  :
 972 // =======================================================================
 973 void Graphic3d_Camera::InvalidateOrientation()
 974 {
 975   myMatricesD.ResetOrientation();
 976   myMatricesF.ResetOrientation();
 977   myWorldViewProjState.WorldViewState() = (Standard_Size)Standard_Atomic_Increment (&THE_STATE_COUNTER);
 978 }
 979
 980 // =======================================================================
 981 // function : OrthoProj
 982 // purpose  :
 983 // =======================================================================
 984 template <typename Elem_t>
 985 void Graphic3d_Camera::OrthoProj (const Elem_t theLeft,
 986                                   const Elem_t theRight,
 987                                   const Elem_t theBottom,
 988                                   const Elem_t theTop,
 989                                   const Elem_t theNear,
 990                                   const Elem_t theFar,
 991                                   NCollection_Mat4<Elem_t>& theOutMx)
 992 {
 993   // row 0
 994   theOutMx.ChangeValue (0, 0) = Elem_t (2.0) / (theRight - theLeft);
 995   theOutMx.ChangeValue (0, 1) = Elem_t (0.0);
 996   theOutMx.ChangeValue (0, 2) = Elem_t (0.0);
 997   theOutMx.ChangeValue (0, 3) = - (theRight + theLeft) / (theRight - theLeft);
 998
 999   // row 1
1000   theOutMx.ChangeValue (1, 0) = Elem_t (0.0);
1001   theOutMx.ChangeValue (1, 1) = Elem_t (2.0) / (theTop - theBottom);
1002   theOutMx.ChangeValue (1, 2) = Elem_t (0.0);
1003   theOutMx.ChangeValue (1, 3) = - (theTop + theBottom) / (theTop - theBottom);
1004
1005   // row 2
1006   theOutMx.ChangeValue (2, 0) = Elem_t (0.0);
1007   theOutMx.ChangeValue (2, 1) = Elem_t (0.0);
1008   theOutMx.ChangeValue (2, 2) = Elem_t (-2.0) / (theFar - theNear);
1009   theOutMx.ChangeValue (2, 3) = - (theFar + theNear) / (theFar - theNear);
1010
1011   // row 3
1012   theOutMx.ChangeValue (3, 0) = Elem_t (0.0);
1013   theOutMx.ChangeValue (3, 1) = Elem_t (0.0);
1014   theOutMx.ChangeValue (3, 2) = Elem_t (0.0);
1015   theOutMx.ChangeValue (3, 3) = Elem_t (1.0);
1016 }
1017
1018 // =======================================================================
1019 // function : PerspectiveProj
1020 // purpose  :
1021 // =======================================================================
1022 template <typename Elem_t>
1023 void Graphic3d_Camera::PerspectiveProj (const Elem_t theLeft,
1024                                         const Elem_t theRight,
1025                                         const Elem_t theBottom,
1026                                         const Elem_t theTop,
1027                                         const Elem_t theNear,
1028                                         const Elem_t theFar,
1029                                         NCollection_Mat4<Elem_t>& theOutMx)
1030 {
1031   // column 0
1032   theOutMx.ChangeValue (0, 0) = (Elem_t (2.0) * theNear) / (theRight - theLeft);
1033   theOutMx.ChangeValue (1, 0) = Elem_t (0.0);
1034   theOutMx.ChangeValue (2, 0) = Elem_t (0.0);
1035   theOutMx.ChangeValue (3, 0) = Elem_t (0.0);
1036
1037   // column 1
1038   theOutMx.ChangeValue (0, 1) = Elem_t (0.0);
1039   theOutMx.ChangeValue (1, 1) = (Elem_t (2.0) * theNear) / (theTop - theBottom);
1040   theOutMx.ChangeValue (2, 1) = Elem_t (0.0);
1041   theOutMx.ChangeValue (3, 1) = Elem_t (0.0);
1042
1043   // column 2
1044   theOutMx.ChangeValue (0, 2) = (theRight + theLeft) / (theRight - theLeft);
1045   theOutMx.ChangeValue (1, 2) = (theTop + theBottom) / (theTop - theBottom);
1046   theOutMx.ChangeValue (2, 2) = -(theFar + theNear) / (theFar - theNear);
1047   theOutMx.ChangeValue (3, 2) = Elem_t (-1.0);
1048
1049   // column 3
1050   theOutMx.ChangeValue (0, 3) = Elem_t (0.0);
1051   theOutMx.ChangeValue (1, 3) = Elem_t (0.0);
1052   theOutMx.ChangeValue (2, 3) = -(Elem_t (2.0) * theFar * theNear) / (theFar - theNear);
1053   theOutMx.ChangeValue (3, 3) = Elem_t (0.0);
1054 }
1055
1056 // =======================================================================
1057 // function : StereoEyeProj
1058 // purpose  :
1059 // =======================================================================
1060 template <typename Elem_t>
1061 void Graphic3d_Camera::StereoEyeProj (const Elem_t theLeft,
1062                                       const Elem_t theRight,
1063                                       const Elem_t theBottom,
1064                                       const Elem_t theTop,
1065                                       const Elem_t theNear,
1066                                       const Elem_t theFar,
1067                                       const Elem_t theIOD,
1068                                       const Elem_t theZFocus,
1069                                       const Standard_Boolean theIsLeft,
1070                                       NCollection_Mat4<Elem_t>& theOutMx)
1071 {
1072   Elem_t aDx = theIsLeft ? Elem_t (0.5) * theIOD : Elem_t (-0.5) * theIOD;
1073   Elem_t aDXStereoShift = aDx * theNear / theZFocus;
1074
1075   // construct eye projection matrix
1076   PerspectiveProj (theLeft  + aDXStereoShift,
1077                    theRight + aDXStereoShift,
1078                    theBottom, theTop, theNear, theFar,
1079                    theOutMx);
1080
1081   if (theIOD != Elem_t (0.0))
1082   {
1083     // X translation to cancel parallax
1084     theOutMx.Translate (NCollection_Vec3<Elem_t> (aDx, Elem_t (0.0), Elem_t (0.0)));
1085   }
1086 }
1087
1088 // =======================================================================
1089 // function : LookOrientation
1090 // purpose  :
1091 // =======================================================================
1092 template <typename Elem_t>
1093 void Graphic3d_Camera::LookOrientation (const NCollection_Vec3<Elem_t>& theEye,
1094                                         const NCollection_Vec3<Elem_t>& theLookAt,
1095                                         const NCollection_Vec3<Elem_t>& theUpDir,
1096                                         const NCollection_Vec3<Elem_t>& theAxialScale,
1097                                         NCollection_Mat4<Elem_t>& theOutMx)
1098 {
1099   NCollection_Vec3<Elem_t> aForward = theLookAt - theEye;
1100   aForward.Normalize();
1101
1102   // side = forward x up
1103   NCollection_Vec3<Elem_t> aSide = NCollection_Vec3<Elem_t>::Cross (aForward, theUpDir);
1104   aSide.Normalize();
1105
1106   // recompute up as: up = side x forward
1107   NCollection_Vec3<Elem_t> anUp = NCollection_Vec3<Elem_t>::Cross (aSide, aForward);
1108
1109   NCollection_Mat4<Elem_t> aLookMx;
1110   aLookMx.SetRow (0, aSide);
1111   aLookMx.SetRow (1, anUp);
1112   aLookMx.SetRow (2, -aForward);
1113
1114   theOutMx.InitIdentity();
1115   theOutMx.Multiply (aLookMx);
1116   theOutMx.Translate (-theEye);
1117
1118   NCollection_Mat4<Elem_t> anAxialScaleMx;
1119   anAxialScaleMx.ChangeValue (0, 0) = theAxialScale.x();
1120   anAxialScaleMx.ChangeValue (1, 1) = theAxialScale.y();
1121   anAxialScaleMx.ChangeValue (2, 2) = theAxialScale.z();
1122
1123   theOutMx.Multiply (anAxialScaleMx);
1124 }
1125
1126 //=============================================================================
1127 //function : ZFitAll
1128 //purpose  :
1129 //=============================================================================
1130 bool Graphic3d_Camera::ZFitAll (const Standard_Real theScaleFactor,
1131                                 const Bnd_Box&      theMinMax,
1132                                 const Bnd_Box&      theGraphicBB,
1133                                 Standard_Real&      theZNear,
1134                                 Standard_Real&      theZFar) const
1135 {
1136   Standard_ASSERT_RAISE (theScaleFactor > 0.0, "Zero or negative scale factor is not allowed.");
1137
1138   // Method changes zNear and zFar parameters of camera so as to fit graphical structures
1139   // by their graphical boundaries. It precisely fits min max boundaries of primary application
1140   // objects (second argument), while it can sacrifice the real graphical boundaries of the
1141   // scene with infinite or helper objects (third argument) for the sake of perspective projection.
1142   if (theGraphicBB.IsVoid())
1143   {
1144     theZNear = DEFAULT_ZNEAR;
1145     theZFar  = DEFAULT_ZFAR;
1146     return false;
1147   }
1148
1149   // Measure depth of boundary points from camera eye.
1150   NCollection_Sequence<gp_Pnt> aPntsToMeasure;
1151
1152   Standard_Real aGraphicBB[6];
1153   theGraphicBB.Get (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2], aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]);
1154
1155   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2]));
1156   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[1], aGraphicBB[5]));
1157   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[4], aGraphicBB[2]));
1158   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[4], aGraphicBB[5]));
1159   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[1], aGraphicBB[2]));
1160   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[1], aGraphicBB[5]));
1161   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[4], aGraphicBB[2]));
1162   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]));
1163
1164   Standard_Boolean isFiniteMinMax = !theMinMax.IsVoid() && !theMinMax.IsWhole();
1165
1166   if (isFiniteMinMax)
1167   {
1168     Standard_Real aMinMax[6];
1169     theMinMax.Get (aMinMax[0], aMinMax[1], aMinMax[2], aMinMax[3], aMinMax[4], aMinMax[5]);
1170
1171     aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[1], aMinMax[2]));
1172     aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[1], aMinMax[5]));
1173     aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[4], aMinMax[2]));
1174     aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[4], aMinMax[5]));
1175     aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[1], aMinMax[2]));
1176     aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[1], aMinMax[5]));
1177     aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[4], aMinMax[2]));
1178     aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[4], aMinMax[5]));
1179   }
1180
1181   // Camera eye plane.
1182   gp_Dir aCamDir = Direction();
1183   gp_Pnt aCamEye = myEye;
1184   gp_Pln aCamPln (aCamEye, aCamDir);
1185
1186   Standard_Real aModelMinDist = RealLast();
1187   Standard_Real aModelMaxDist = RealFirst();
1188   Standard_Real aGraphMinDist = RealLast();
1189   Standard_Real aGraphMaxDist = RealFirst();
1190
1191   const gp_XYZ& anAxialScale = myAxialScale;
1192
1193   // Get minimum and maximum distances to the eye plane.
1194   Standard_Integer aCounter = 0;
1195   NCollection_Sequence<gp_Pnt>::Iterator aPntIt(aPntsToMeasure);
1196   for (; aPntIt.More(); aPntIt.Next())
1197   {
1198     gp_Pnt aMeasurePnt = aPntIt.Value();
1199
1200     aMeasurePnt = gp_Pnt (aMeasurePnt.X() * anAxialScale.X(),
1201                           aMeasurePnt.Y() * anAxialScale.Y(),
1202                           aMeasurePnt.Z() * anAxialScale.Z());
1203
1204     Standard_Real aDistance = aCamPln.Distance (aMeasurePnt);
1205
1206     // Check if the camera is intruded into the scene.
1207     if (aCamDir.IsOpposite (gp_Vec (aCamEye, aMeasurePnt), M_PI * 0.5))
1208     {
1209       aDistance *= -1;
1210     }
1211
1212     // The first eight points are from theGraphicBB, the last eight points are from theMinMax (can be absent).
1213     Standard_Real& aChangeMinDist = aCounter >= 8 ? aModelMinDist : aGraphMinDist;
1214     Standard_Real& aChangeMaxDist = aCounter >= 8 ? aModelMaxDist : aGraphMaxDist;
1215     aChangeMinDist = Min (aDistance, aChangeMinDist);
1216     aChangeMaxDist = Max (aDistance, aChangeMaxDist);
1217     aCounter++;
1218   }
1219
1220   // Compute depth of bounding box center.
1221   Standard_Real aMidDepth  = (aGraphMinDist + aGraphMaxDist) * 0.5;
1222   Standard_Real aHalfDepth = (aGraphMaxDist - aGraphMinDist) * 0.5;
1223
1224   // Compute enlarged or shrank near and far z ranges.
1225   Standard_Real aZNear  = aMidDepth - aHalfDepth * theScaleFactor;
1226   Standard_Real aZFar   = aMidDepth + aHalfDepth * theScaleFactor;
1227
1228   if (!IsOrthographic())
1229   {
1230     // Everything is behind the perspective camera.
1231     if (aZFar < zEpsilon())
1232     {
1233       theZNear = DEFAULT_ZNEAR;
1234       theZFar  = DEFAULT_ZFAR;
1235       return false;
1236     }
1237   }
1238
1239   //
1240   // Consider clipping errors due to double to single precision floating-point conversion.
1241   //
1242
1243   // Model to view transformation performs translation of points against eye position
1244   // in three dimensions. Both point coordinate and eye position values are converted from
1245   // double to single precision floating point numbers producing conversion errors.
1246   // Epsilon (Mod) * 3.0 should safely compensate precision error for z coordinate after
1247   // translation assuming that the:
1248   // Epsilon (Eye.Mod()) * 3.0 > Epsilon (Eye.X()) + Epsilon (Eye.Y()) + Epsilon (Eye.Z()).
1249   Standard_Real aEyeConf = 3.0 * zEpsilon (myEye.XYZ().Modulus());
1250
1251   // Model to view transformation performs rotation of points according to view direction.
1252   // New z coordinate is computed as a multiplication of point's x, y, z coordinates by the
1253   // "forward" direction vector's x, y, z coordinates. Both point's and "z" direction vector's
1254   // values are converted from double to single precision floating point numbers producing
1255   // conversion errors.
1256   // Epsilon (Mod) * 6.0 should safely compensate the precision errors for the multiplication
1257   // of point coordinates by direction vector.
1258   gp_Pnt aGraphicMin = theGraphicBB.CornerMin();
1259   gp_Pnt aGraphicMax = theGraphicBB.CornerMax();
1260
1261   Standard_Real aModelConf = 6.0 * zEpsilon (aGraphicMin.XYZ().Modulus()) +
1262                              6.0 * zEpsilon (aGraphicMax.XYZ().Modulus());
1263
1264   // Compensate floating point conversion errors by increasing zNear, zFar to avoid clipping.
1265   aZNear -= zEpsilon (aZNear) + aEyeConf + aModelConf;
1266   aZFar  += zEpsilon (aZFar)  + aEyeConf + aModelConf;
1267
1268   if (!IsOrthographic())
1269   {
1270     // For perspective projection, the value of z in normalized device coordinates is non-linear
1271     // function of eye z coordinate. For fixed-point depth representation resolution of z in
1272     // model-view space will grow towards zFar plane and its scale depends mostly on how far is zNear
1273     // against camera's eye. The purpose of the code below is to select most appropriate zNear distance
1274     // to balance between clipping (less zNear, more chances to observe closely small models without clipping)
1275     // and resolution of depth. A well applicable criteria to this is a ratio between resolution of z at center
1276     // of model boundaries and the distance to that center point. The ratio is chosen empirically and validated
1277     // by tests database. It is considered to be ~0.001 (0.1%) for 24 bit depth buffer, for less depth bitness
1278     // the zNear will be placed similarly giving lower resolution.
1279     // Approximation of the formula for respectively large z range is:
1280     // zNear = [z * (1 + k) / (k * c)],
1281     // where:
1282     // z - distance to center of model boundaries;
1283     // k - chosen ratio, c - capacity of depth buffer;
1284     // k = 0.001, k * c = 1677.216, (1 + k) / (k * c) ~ 5.97E-4
1285     //
1286     // The function uses center of model boundaries computed from "theMinMax" boundaries (instead of using real
1287     // graphical boundaries of all displayed objects). That means that it can sacrifice resolution of presentation
1288     // of non primary ("infinite") application graphical objects in favor of better perspective projection of the
1289     // small applicative objects measured with "theMinMax" values.
1290     Standard_Real aZRange   = isFiniteMinMax ? aModelMaxDist - aModelMinDist : aGraphMaxDist - aGraphMinDist;
1291     Standard_Real aZMin     = isFiniteMinMax ? aModelMinDist : aGraphMinDist;
1292     Standard_Real aZ        = aZMin < 0 ? aZRange / 2.0 : aZRange / 2.0 + aZMin;
1293     Standard_Real aZNearMin = aZ * 5.97E-4;
1294     if (aZNear < aZNearMin)
1295     {
1296       // Clip zNear according to the minimum value matching the quality.
1297       aZNear = aZNearMin;
1298     }
1299     else
1300     {
1301       // Compensate zNear conversion errors for perspective projection.
1302       aZNear -= aZFar * zEpsilon (aZNear) / (aZFar - zEpsilon (aZNear));
1303     }
1304
1305     // Compensate zFar conversion errors for perspective projection.
1306     aZFar += zEpsilon (aZFar);
1307
1308     // Ensure that after all the zNear is not a negative value.
1309     if (aZNear < zEpsilon())
1310     {
1311       aZNear = zEpsilon();
1312     }
1313   }
1314
1315   theZNear = aZNear;
1316   theZFar  = aZFar;
1317   return true;
1318 }
1319
1320 //=============================================================================
1321 //function : Interpolate
1322 //purpose  :
1323 //=============================================================================
1324 template<>
1325 Standard_EXPORT void NCollection_Lerp<Handle(Graphic3d_Camera)>::Interpolate (const double theT,
1326                                                                               Handle(Graphic3d_Camera)& theCamera) const
1327 {
1328   if (Abs (theT - 1.0) < Precision::Confusion())
1329   {
1330     // just copy end-point transformation
1331     theCamera->Copy (myEnd);
1332     return;
1333   }
1334
1335   theCamera->Copy (myStart);
1336   if (Abs (theT - 0.0) < Precision::Confusion())
1337   {
1338     return;
1339   }
1340
1341   // apply rotation
1342   {
1343     gp_Ax3 aCamStart = cameraToAx3 (*myStart);
1344     gp_Ax3 aCamEnd   = cameraToAx3 (*myEnd);
1345     gp_Trsf aTrsfStart, aTrsfEnd;
1346     aTrsfStart.SetTransformation (aCamStart, gp::XOY());
1347     aTrsfEnd  .SetTransformation (aCamEnd,   gp::XOY());
1348
1349     gp_Quaternion aRotStart = aTrsfStart.GetRotation();
1350     gp_Quaternion aRotEnd   = aTrsfEnd  .GetRotation();
1351     gp_Quaternion aRotDelta = aRotEnd * aRotStart.Inverted();
1352     gp_Quaternion aRot = gp_QuaternionNLerp::Interpolate (gp_Quaternion(), aRotDelta, theT);
1353     gp_Trsf aTrsfRot;
1354     aTrsfRot.SetRotation (aRot);
1355     theCamera->Transform (aTrsfRot);
1356   }
1357
1358   // apply translation
1359   {
1360     gp_XYZ aCenter  = NCollection_Lerp<gp_XYZ>::Interpolate (myStart->Center().XYZ(), myEnd->Center().XYZ(), theT);
1361     gp_XYZ anEye    = NCollection_Lerp<gp_XYZ>::Interpolate (myStart->Eye().XYZ(),    myEnd->Eye().XYZ(),    theT);
1362     gp_XYZ anAnchor = aCenter;
1363     Standard_Real aKc = 0.0;
1364
1365     const Standard_Real aDeltaCenter = myStart->Center().Distance (myEnd->Center());
1366     const Standard_Real aDeltaEye    = myStart->Eye()   .Distance (myEnd->Eye());
1367     if (aDeltaEye <= gp::Resolution())
1368     {
1369       anAnchor = anEye;
1370       aKc = 1.0;
1371     }
1372     else if (aDeltaCenter > gp::Resolution())
1373     {
1374       aKc = aDeltaCenter / (aDeltaCenter + aDeltaEye);
1375
1376       const gp_XYZ anAnchorStart = NCollection_Lerp<gp_XYZ>::Interpolate (myStart->Center().XYZ(), myStart->Eye().XYZ(), aKc);
1377       const gp_XYZ anAnchorEnd   = NCollection_Lerp<gp_XYZ>::Interpolate (myEnd  ->Center().XYZ(), myEnd  ->Eye().XYZ(), aKc);
1378       anAnchor = NCollection_Lerp<gp_XYZ>::Interpolate (anAnchorStart, anAnchorEnd, theT);
1379     }
1380
1381     const gp_Vec        aDirEyeToCenter     = theCamera->Direction();
1382     const Standard_Real aDistEyeCenterStart = myStart->Eye().Distance (myStart->Center());
1383     const Standard_Real aDistEyeCenterEnd   = myEnd  ->Eye().Distance (myEnd  ->Center());
1384     const Standard_Real aDistEyeCenter      = NCollection_Lerp<Standard_Real>::Interpolate (aDistEyeCenterStart, aDistEyeCenterEnd, theT);
1385     aCenter = anAnchor + aDirEyeToCenter.XYZ() * aDistEyeCenter * aKc;
1386     anEye   = anAnchor - aDirEyeToCenter.XYZ() * aDistEyeCenter * (1.0 - aKc);
1387
1388     theCamera->SetCenter (aCenter);
1389     theCamera->SetEye    (anEye);
1390   }
1391
1392   // apply scaling
1393   if (Abs(myStart->Scale() - myEnd->Scale()) > Precision::Confusion()
1394    && myStart->IsOrthographic())
1395   {
1396     const Standard_Real aScale = NCollection_Lerp<Standard_Real>::Interpolate (myStart->Scale(), myEnd->Scale(), theT);
1397     theCamera->SetScale (aScale);
1398   }
1399 }
1400
1401 //=======================================================================
1402 //function : FrustumPoints
1403 //purpose  :
1404 //=======================================================================
1405 void Graphic3d_Camera::FrustumPoints (NCollection_Array1<Graphic3d_Vec3d>& thePoints) const
1406 {
1407   if (thePoints.Length() != FrustumVerticesNB)
1408   {
1409     thePoints.Resize (0, FrustumVerticesNB, Standard_False);
1410   }
1411
1412   const Graphic3d_Mat4d& aProjectionMat = ProjectionMatrix();
1413   const Graphic3d_Mat4d& aWorldViewMat  = OrientationMatrix();
1414
1415   Standard_Real nLeft = 0.0, nRight = 0.0, nTop = 0.0, nBottom = 0.0;
1416   Standard_Real fLeft = 0.0, fRight = 0.0, fTop = 0.0, fBottom = 0.0;
1417   Standard_Real aNear = 0.0, aFar = 0.0;
1418   if (!IsOrthographic())
1419   {
1420     // handle perspective projection
1421     aNear = aProjectionMat.GetValue (2, 3) / (-1.0 + aProjectionMat.GetValue (2, 2));
1422     aFar  = aProjectionMat.GetValue (2, 3) / ( 1.0 + aProjectionMat.GetValue (2, 2));
1423     // Near plane
1424     nLeft   = aNear * (aProjectionMat.GetValue (0, 2) - 1.0) / aProjectionMat.GetValue (0, 0);
1425     nRight  = aNear * (aProjectionMat.GetValue (0, 2) + 1.0) / aProjectionMat.GetValue (0, 0);
1426     nTop    = aNear * (aProjectionMat.GetValue (1, 2) + 1.0) / aProjectionMat.GetValue (1, 1);
1427     nBottom = aNear * (aProjectionMat.GetValue (1, 2) - 1.0) / aProjectionMat.GetValue (1, 1);
1428     // Far plane
1429     fLeft   = aFar  * (aProjectionMat.GetValue (0, 2) - 1.0) / aProjectionMat.GetValue (0, 0);
1430     fRight  = aFar  * (aProjectionMat.GetValue (0, 2) + 1.0) / aProjectionMat.GetValue (0, 0);
1431     fTop    = aFar  * (aProjectionMat.GetValue (1, 2) + 1.0) / aProjectionMat.GetValue (1, 1);
1432     fBottom = aFar  * (aProjectionMat.GetValue (1, 2) - 1.0) / aProjectionMat.GetValue (1, 1);
1433   }
1434   else
1435   {
1436     // handle orthographic projection
1437     aNear = (1.0 / aProjectionMat.GetValue (2, 2)) * (aProjectionMat.GetValue (2, 3) + 1.0);
1438     aFar  = (1.0 / aProjectionMat.GetValue (2, 2)) * (aProjectionMat.GetValue (2, 3) - 1.0);
1439     // Near plane
1440     nLeft   = ( 1.0 + aProjectionMat.GetValue (0, 3)) / (-aProjectionMat.GetValue (0, 0));
1441     fLeft   = nLeft;
1442     nRight  = ( 1.0 - aProjectionMat.GetValue (0, 3)) /   aProjectionMat.GetValue (0, 0);
1443     fRight  = nRight;
1444     nTop    = ( 1.0 - aProjectionMat.GetValue (1, 3)) /   aProjectionMat.GetValue (1, 1);
1445     fTop    = nTop;
1446     nBottom = (-1.0 - aProjectionMat.GetValue (1, 3)) /   aProjectionMat.GetValue (1, 1);
1447     fBottom = nBottom;
1448   }
1449
1450   Graphic3d_Vec4d aLeftTopNear     (nLeft,  nTop,    -aNear, 1.0), aRightBottomFar (fRight, fBottom, -aFar, 1.0);
1451   Graphic3d_Vec4d aLeftBottomNear  (nLeft,  nBottom, -aNear, 1.0), aRightTopFar    (fRight, fTop,    -aFar, 1.0);
1452   Graphic3d_Vec4d aRightBottomNear (nRight, nBottom, -aNear, 1.0), aLeftTopFar     (fLeft,  fTop,    -aFar, 1.0);
1453   Graphic3d_Vec4d aRightTopNear    (nRight, nTop,    -aNear, 1.0), aLeftBottomFar  (fLeft,  fBottom, -aFar, 1.0);
1454
1455   Graphic3d_Mat4d anInvWorldView;
1456   aWorldViewMat.Inverted (anInvWorldView);
1457
1458   Graphic3d_Vec4d aTmpPnt;
1459   aTmpPnt = anInvWorldView * aLeftTopNear;
1460   thePoints.SetValue (FrustumVert_LeftTopNear,     aTmpPnt.xyz() / aTmpPnt.w());
1461   aTmpPnt = anInvWorldView * aRightBottomFar;
1462   thePoints.SetValue (FrustumVert_RightBottomFar,  aTmpPnt.xyz() / aTmpPnt.w());
1463   aTmpPnt = anInvWorldView * aLeftBottomNear;
1464   thePoints.SetValue (FrustumVert_LeftBottomNear,  aTmpPnt.xyz() / aTmpPnt.w());
1465   aTmpPnt = anInvWorldView * aRightTopFar;
1466   thePoints.SetValue (FrustumVert_RightTopFar,     aTmpPnt.xyz() / aTmpPnt.w());
1467   aTmpPnt = anInvWorldView * aRightBottomNear;
1468   thePoints.SetValue (FrustumVert_RightBottomNear, aTmpPnt.xyz() / aTmpPnt.w());
1469   aTmpPnt = anInvWorldView * aLeftTopFar;
1470   thePoints.SetValue (FrustumVert_LeftTopFar,      aTmpPnt.xyz() / aTmpPnt.w());
1471   aTmpPnt = anInvWorldView * aRightTopNear;
1472   thePoints.SetValue (FrustumVert_RightTopNear,    aTmpPnt.xyz() / aTmpPnt.w());
1473   aTmpPnt = anInvWorldView * aLeftBottomFar;
1474   thePoints.SetValue (FrustumVert_LeftBottomFar,   aTmpPnt.xyz() / aTmpPnt.w());
1475 }