+++ /dev/null
-///////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
-// Digital Ltd. LLC
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Industrial Light & Magic nor the names of
-// its contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-///////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef INCLUDED_IMATHFRUSTUM_H
-#define INCLUDED_IMATHFRUSTUM_H
-
-
-#include "ImathVec.h"
-#include "ImathPlane.h"
-#include "ImathLine.h"
-#include "ImathMatrix.h"
-#include "ImathLimits.h"
-#include "ImathFun.h"
-#include "IexMathExc.h"
-
-#if defined _WIN32 || defined _WIN64
- #ifdef near
- #undef near
- #endif
- #ifdef far
- #undef far
- #endif
-#endif
-
-namespace Imath {
-
-//
-// template class Frustum<T>
-//
-// The frustum is always located with the eye point at the
-// origin facing down -Z. This makes the Frustum class
-// compatable with OpenGL (or anything that assumes a camera
-// looks down -Z, hence with a right-handed coordinate system)
-// but not with RenderMan which assumes the camera looks down
-// +Z. Additional functions are provided for conversion from
-// and from various camera coordinate spaces.
-//
-
-
-template<class T>
-class Frustum
-{
- public:
- Frustum();
- Frustum(const Frustum &);
- Frustum(T near, T far, T left, T right, T top, T bottom, bool ortho=false);
- Frustum(T near, T far, T fovx, T fovy, T aspect);
- virtual ~Frustum();
-
- //--------------------
- // Assignment operator
- //--------------------
-
- const Frustum &operator = (const Frustum &);
-
- //--------------------
- // Operators: ==, !=
- //--------------------
-
- bool operator == (const Frustum<T> &src) const;
- bool operator != (const Frustum<T> &src) const;
-
- //--------------------------------------------------------
- // Set functions change the entire state of the Frustum
- //--------------------------------------------------------
-
- void set(T near, T far,
- T left, T right,
- T top, T bottom,
- bool ortho=false);
-
- void set(T near, T far, T fovx, T fovy, T aspect);
-
- //------------------------------------------------------
- // These functions modify an already valid frustum state
- //------------------------------------------------------
-
- void modifyNearAndFar(T near, T far);
- void setOrthographic(bool);
-
- //--------------
- // Access
- //--------------
-
- bool orthographic() const { return _orthographic; }
- T near() const { return _near; }
- T far() const { return _far; }
- T left() const { return _left; }
- T right() const { return _right; }
- T bottom() const { return _bottom; }
- T top() const { return _top; }
-
- //-----------------------------------------------------------------------
- // Sets the planes in p to be the six bounding planes of the frustum, in
- // the following order: top, right, bottom, left, near, far.
- // Note that the planes have normals that point out of the frustum.
- // The version of this routine that takes a matrix applies that matrix
- // to transform the frustum before setting the planes.
- //-----------------------------------------------------------------------
-
- void planes(Plane3<T> p[6]);
- void planes(Plane3<T> p[6], const Matrix44<T> &M);
-
- //----------------------
- // Derived Quantities
- //----------------------
-
- T fovx() const;
- T fovy() const;
- T aspect() const;
- Matrix44<T> projectionMatrix() const;
-
- //-----------------------------------------------------------------------
- // Takes a rectangle in the screen space (i.e., -1 <= left <= right <= 1
- // and -1 <= bottom <= top <= 1) of this Frustum, and returns a new
- // Frustum whose near clipping-plane window is that rectangle in local
- // space.
- //-----------------------------------------------------------------------
-
- Frustum<T> window(T left, T right, T top, T bottom) const;
-
- //----------------------------------------------------------
- // Projection is in screen space / Conversion from Z-Buffer
- //----------------------------------------------------------
-
- Line3<T> projectScreenToRay( const Vec2<T> & ) const;
- Vec2<T> projectPointToScreen( const Vec3<T> & ) const;
-
- T ZToDepth(long zval, long min, long max) const;
- T normalizedZToDepth(T zval) const;
- long DepthToZ(T depth, long zmin, long zmax) const;
-
- T worldRadius(const Vec3<T> &p, T radius) const;
- T screenRadius(const Vec3<T> &p, T radius) const;
-
-
- protected:
-
- Vec2<T> screenToLocal( const Vec2<T> & ) const;
- Vec2<T> localToScreen( const Vec2<T> & ) const;
-
- protected:
- T _near;
- T _far;
- T _left;
- T _right;
- T _top;
- T _bottom;
- bool _orthographic;
-};
-
-
-template<class T>
-inline Frustum<T>::Frustum()
-{
- set(T (0.1),
- T (1000.0),
- T (-1.0),
- T (1.0),
- T (1.0),
- T (-1.0),
- false);
-}
-
-template<class T>
-inline Frustum<T>::Frustum(const Frustum &f)
-{
- *this = f;
-}
-
-template<class T>
-inline Frustum<T>::Frustum(T n, T f, T l, T r, T t, T b, bool o)
-{
- set(n,f,l,r,t,b,o);
-}
-
-template<class T>
-inline Frustum<T>::Frustum(T near, T far, T fovx, T fovy, T aspect)
-{
- set(near,far,fovx,fovy,aspect);
-}
-
-template<class T>
-Frustum<T>::~Frustum()
-{
-}
-
-template<class T>
-const Frustum<T> &
-Frustum<T>::operator = (const Frustum &f)
-{
- _near = f._near;
- _far = f._far;
- _left = f._left;
- _right = f._right;
- _top = f._top;
- _bottom = f._bottom;
- _orthographic = f._orthographic;
-
- return *this;
-}
-
-template <class T>
-bool
-Frustum<T>::operator == (const Frustum<T> &src) const
-{
- return
- _near == src._near &&
- _far == src._far &&
- _left == src._left &&
- _right == src._right &&
- _top == src._top &&
- _bottom == src._bottom &&
- _orthographic == src._orthographic;
-}
-
-template <class T>
-inline bool
-Frustum<T>::operator != (const Frustum<T> &src) const
-{
- return !operator== (src);
-}
-
-template<class T>
-void Frustum<T>::set(T n, T f, T l, T r, T t, T b, bool o)
-{
- _near = n;
- _far = f;
- _left = l;
- _right = r;
- _bottom = b;
- _top = t;
- _orthographic = o;
-}
-
-template<class T>
-void Frustum<T>::modifyNearAndFar(T n, T f)
-{
- if ( _orthographic )
- {
- _near = n;
- }
- else
- {
- Line3<T> lowerLeft( Vec3<T>(0,0,0), Vec3<T>(_left,_bottom,-_near) );
- Line3<T> upperRight( Vec3<T>(0,0,0), Vec3<T>(_right,_top,-_near) );
- Plane3<T> nearPlane( Vec3<T>(0,0,-1), n );
-
- Vec3<T> ll,ur;
- nearPlane.intersect(lowerLeft,ll);
- nearPlane.intersect(upperRight,ur);
-
- _left = ll.x;
- _right = ur.x;
- _top = ur.y;
- _bottom = ll.y;
- _near = n;
- _far = f;
- }
-
- _far = f;
-}
-
-template<class T>
-void Frustum<T>::setOrthographic(bool ortho)
-{
- _orthographic = ortho;
-}
-
-template<class T>
-void Frustum<T>::set(T near, T far, T fovx, T fovy, T aspect)
-{
- if (fovx != 0 && fovy != 0)
- throw Iex::ArgExc ("fovx and fovy cannot both be non-zero.");
-
- if (fovx != 0)
- {
- _right = near * Math<T>::tan(fovx/2.0);
- _left = -_right;
- _top = ((_right - _left)/aspect)/2.0;
- _bottom = -_top;
- }
- else
- {
- _top = near * Math<T>::tan(fovy/2.0);
- _bottom = -_top;
- _right = (_top - _bottom) * aspect / 2.0;
- _left = -_right;
- }
- _near = near;
- _far = far;
- _orthographic = false;
-}
-
-template<class T>
-T Frustum<T>::fovx() const
-{
- return Math<T>::atan2(_right,_near) - Math<T>::atan2(_left,_near);
-}
-
-template<class T>
-T Frustum<T>::fovy() const
-{
- return Math<T>::atan2(_top,_near) - Math<T>::atan2(_bottom,_near);
-}
-
-template<class T>
-T Frustum<T>::aspect() const
-{
- T rightMinusLeft = _right-_left;
- T topMinusBottom = _top-_bottom;
-
- if (abs(topMinusBottom) < 1 &&
- abs(rightMinusLeft) > limits<T>::max() * abs(topMinusBottom))
- {
- throw Iex::DivzeroExc ("Bad viewing frustum: "
- "aspect ratio cannot be computed.");
- }
-
- return rightMinusLeft / topMinusBottom;
-}
-
-template<class T>
-Matrix44<T> Frustum<T>::projectionMatrix() const
-{
- T rightPlusLeft = _right+_left;
- T rightMinusLeft = _right-_left;
-
- T topPlusBottom = _top+_bottom;
- T topMinusBottom = _top-_bottom;
-
- T farPlusNear = _far+_near;
- T farMinusNear = _far-_near;
-
- if ((abs(rightMinusLeft) < 1 &&
- abs(rightPlusLeft) > limits<T>::max() * abs(rightMinusLeft)) ||
- (abs(topMinusBottom) < 1 &&
- abs(topPlusBottom) > limits<T>::max() * abs(topMinusBottom)) ||
- (abs(farMinusNear) < 1 &&
- abs(farPlusNear) > limits<T>::max() * abs(farMinusNear)))
- {
- throw Iex::DivzeroExc ("Bad viewing frustum: "
- "projection matrix cannot be computed.");
- }
-
- if ( _orthographic )
- {
- T tx = -rightPlusLeft / rightMinusLeft;
- T ty = -topPlusBottom / topMinusBottom;
- T tz = -farPlusNear / farMinusNear;
-
- if ((abs(rightMinusLeft) < 1 &&
- 2 > limits<T>::max() * abs(rightMinusLeft)) ||
- (abs(topMinusBottom) < 1 &&
- 2 > limits<T>::max() * abs(topMinusBottom)) ||
- (abs(farMinusNear) < 1 &&
- 2 > limits<T>::max() * abs(farMinusNear)))
- {
- throw Iex::DivzeroExc ("Bad viewing frustum: "
- "projection matrix cannot be computed.");
- }
-
- T A = 2 / rightMinusLeft;
- T B = 2 / topMinusBottom;
- T C = -2 / farMinusNear;
-
- return Matrix44<T>( A, 0, 0, 0,
- 0, B, 0, 0,
- 0, 0, C, 0,
- tx, ty, tz, 1.f );
- }
- else
- {
- T A = rightPlusLeft / rightMinusLeft;
- T B = topPlusBottom / topMinusBottom;
- T C = -farPlusNear / farMinusNear;
-
- T farTimesNear = -2 * _far * _near;
- if (abs(farMinusNear) < 1 &&
- abs(farTimesNear) > limits<T>::max() * abs(farMinusNear))
- {
- throw Iex::DivzeroExc ("Bad viewing frustum: "
- "projection matrix cannot be computed.");
- }
-
- T D = farTimesNear / farMinusNear;
-
- T twoTimesNear = 2 * _near;
-
- if ((abs(rightMinusLeft) < 1 &&
- abs(twoTimesNear) > limits<T>::max() * abs(rightMinusLeft)) ||
- (abs(topMinusBottom) < 1 &&
- abs(twoTimesNear) > limits<T>::max() * abs(topMinusBottom)))
- {
- throw Iex::DivzeroExc ("Bad viewing frustum: "
- "projection matrix cannot be computed.");
- }
-
- T E = twoTimesNear / rightMinusLeft;
- T F = twoTimesNear / topMinusBottom;
-
- return Matrix44<T>( E, 0, 0, 0,
- 0, F, 0, 0,
- A, B, C, -1,
- 0, 0, D, 0 );
- }
-}
-
-template<class T>
-Frustum<T> Frustum<T>::window(T l, T r, T t, T b) const
-{
- // move it to 0->1 space
-
- Vec2<T> bl = screenToLocal( Vec2<T>(l,b) );
- Vec2<T> tr = screenToLocal( Vec2<T>(r,t) );
-
- return Frustum<T>(_near, _far, bl.x, tr.x, tr.y, bl.y, _orthographic);
-}
-
-
-template<class T>
-Vec2<T> Frustum<T>::screenToLocal(const Vec2<T> &s) const
-{
- return Vec2<T>( _left + (_right-_left) * (1.f+s.x) / 2.f,
- _bottom + (_top-_bottom) * (1.f+s.y) / 2.f );
-}
-
-template<class T>
-Vec2<T> Frustum<T>::localToScreen(const Vec2<T> &p) const
-{
- T leftPlusRight = _left - 2 * p.x + _right;
- T leftMinusRight = _left-_right;
- T bottomPlusTop = _bottom - 2 * p.y + _top;
- T bottomMinusTop = _bottom-_top;
-
- if ((abs(leftMinusRight) < 1 &&
- abs(leftPlusRight) > limits<T>::max() * abs(leftMinusRight)) ||
- (abs(bottomMinusTop) < 1 &&
- abs(bottomPlusTop) > limits<T>::max() * abs(bottomMinusTop)))
- {
- throw Iex::DivzeroExc
- ("Bad viewing frustum: "
- "local-to-screen transformation cannot be computed");
- }
-
- return Vec2<T>( leftPlusRight / leftMinusRight,
- bottomPlusTop / bottomMinusTop );
-}
-
-template<class T>
-Line3<T> Frustum<T>::projectScreenToRay(const Vec2<T> &p) const
-{
- Vec2<T> point = screenToLocal(p);
- if (orthographic())
- return Line3<T>( Vec3<T>(point.x,point.y, 0.0),
- Vec3<T>(point.x,point.y,-_near));
- else
- return Line3<T>( Vec3<T>(0, 0, 0), Vec3<T>(point.x,point.y,-_near));
-}
-
-template<class T>
-Vec2<T> Frustum<T>::projectPointToScreen(const Vec3<T> &point) const
-{
- if (orthographic() || point.z == 0)
- return localToScreen( Vec2<T>( point.x, point.y ) );
- else
- return localToScreen( Vec2<T>( point.x * _near / -point.z,
- point.y * _near / -point.z ) );
-}
-
-template<class T>
-T Frustum<T>::ZToDepth(long zval,long zmin,long zmax) const
-{
- int zdiff = zmax - zmin;
-
- if (zdiff == 0)
- {
- throw Iex::DivzeroExc
- ("Bad call to Frustum::ZToDepth: zmax == zmin");
- }
-
- if ( zval > zmax+1 ) zval -= zdiff;
-
- T fzval = (T(zval) - T(zmin)) / T(zdiff);
- return normalizedZToDepth(fzval);
-}
-
-template<class T>
-T Frustum<T>::normalizedZToDepth(T zval) const
-{
- T Zp = zval * 2.0 - 1;
-
- if ( _orthographic )
- {
- return -(Zp*(_far-_near) + (_far+_near))/2;
- }
- else
- {
- T farTimesNear = 2 * _far * _near;
- T farMinusNear = Zp * (_far - _near) - _far - _near;
-
- if (abs(farMinusNear) < 1 &&
- abs(farTimesNear) > limits<T>::max() * abs(farMinusNear))
- {
- throw Iex::DivzeroExc
- ("Frustum::normalizedZToDepth cannot be computed. The "
- "near and far clipping planes of the viewing frustum "
- "may be too close to each other");
- }
-
- return farTimesNear / farMinusNear;
- }
-}
-
-template<class T>
-long Frustum<T>::DepthToZ(T depth,long zmin,long zmax) const
-{
- long zdiff = zmax - zmin;
- T farMinusNear = _far-_near;
-
- if ( _orthographic )
- {
- T farPlusNear = 2*depth + _far + _near;
-
- if (abs(farMinusNear) < 1 &&
- abs(farPlusNear) > limits<T>::max() * abs(farMinusNear))
- {
- throw Iex::DivzeroExc
- ("Bad viewing frustum: near and far clipping planes "
- "are too close to each other");
- }
-
- T Zp = -farPlusNear/farMinusNear;
- return long(0.5*(Zp+1)*zdiff) + zmin;
- }
- else
- {
- // Perspective
-
- T farTimesNear = 2*_far*_near;
- if (abs(depth) < 1 &&
- abs(farTimesNear) > limits<T>::max() * abs(depth))
- {
- throw Iex::DivzeroExc
- ("Bad call to DepthToZ function: value of `depth' "
- "is too small");
- }
-
- T farPlusNear = farTimesNear/depth + _far + _near;
- if (abs(farMinusNear) < 1 &&
- abs(farPlusNear) > limits<T>::max() * abs(farMinusNear))
- {
- throw Iex::DivzeroExc
- ("Bad viewing frustum: near and far clipping planes "
- "are too close to each other");
- }
-
- T Zp = farPlusNear/farMinusNear;
- return long(0.5*(Zp+1)*zdiff) + zmin;
- }
-}
-
-template<class T>
-T Frustum<T>::screenRadius(const Vec3<T> &p, T radius) const
-{
- // Derivation:
- // Consider X-Z plane.
- // X coord of projection of p = xp = p.x * (-_near / p.z)
- // Let q be p + (radius, 0, 0).
- // X coord of projection of q = xq = (p.x - radius) * (-_near / p.z)
- // X coord of projection of segment from p to q = r = xp - xq
- // = radius * (-_near / p.z)
- // A similar analysis holds in the Y-Z plane.
- // So r is the quantity we want to return.
-
- if (abs(p.z) > 1 || abs(-_near) < limits<T>::max() * abs(p.z))
- {
- return radius * (-_near / p.z);
- }
- else
- {
- throw Iex::DivzeroExc
- ("Bad call to Frustum::screenRadius: the magnitude of `p' "
- "is too small");
- }
-
- return radius * (-_near / p.z);
-}
-
-template<class T>
-T Frustum<T>::worldRadius(const Vec3<T> &p, T radius) const
-{
- if (abs(-_near) > 1 || abs(p.z) < limits<T>::max() * abs(-_near))
- {
- return radius * (p.z / -_near);
- }
- else
- {
- throw Iex::DivzeroExc
- ("Bad viewing frustum: the near clipping plane is too "
- "close to zero");
- }
-}
-
-template<class T>
-void Frustum<T>::planes(Plane3<T> p[6])
-{
- //
- // Plane order: Top, Right, Bottom, Left, Near, Far.
- // Normals point outwards.
- //
-
- Vec3<T> a( _left, _bottom, -_near);
- Vec3<T> b( _left, _top, -_near);
- Vec3<T> c( _right, _top, -_near);
- Vec3<T> d( _right, _bottom, -_near);
- Vec3<T> o(0,0,0);
-
- p[0].set( o, c, b );
- p[1].set( o, d, c );
- p[2].set( o, a, d );
- p[3].set( o, b, a );
- p[4].set( Vec3<T>(0, 0, 1), -_near );
- p[5].set( Vec3<T>(0, 0,-1), _far );
-}
-
-
-template<class T>
-void Frustum<T>::planes(Plane3<T> p[6], const Matrix44<T> &M)
-{
- //
- // Plane order: Top, Right, Bottom, Left, Near, Far.
- // Normals point outwards.
- //
-
- Vec3<T> a = Vec3<T>( _left, _bottom, -_near) * M;
- Vec3<T> b = Vec3<T>( _left, _top, -_near) * M;
- Vec3<T> c = Vec3<T>( _right, _top, -_near) * M;
- Vec3<T> d = Vec3<T>( _right, _bottom, -_near) * M;
- double s = _far / double(_near);
- T farLeft = (T) (s * _left);
- T farRight = (T) (s * _right);
- T farTop = (T) (s * _top);
- T farBottom = (T) (s * _bottom);
- Vec3<T> e = Vec3<T>( farLeft, farBottom, -_far) * M;
- Vec3<T> f = Vec3<T>( farLeft, farTop, -_far) * M;
- Vec3<T> g = Vec3<T>( farRight, farTop, -_far) * M;
- Vec3<T> o = Vec3<T>(0,0,0) * M;
-
- p[0].set( o, c, b );
- p[1].set( o, d, c );
- p[2].set( o, a, d );
- p[3].set( o, b, a );
- p[4].set( a, d, c );
- p[5].set( e, f, g );
-}
-
-typedef Frustum<float> Frustumf;
-typedef Frustum<double> Frustumd;
-
-
-} // namespace Imath
-
-#endif
projects / opencv / blobdiff