igl::Camera Class Reference

#include <src/libigl/igl/Camera.h>

Public Member Functions
	Camera ()
virtual	~Camera ()
Eigen::Matrix4d	projection () const
Eigen::Affine3d	affine () const
Eigen::Affine3d	inverse () const
Eigen::Vector3d	eye () const
Eigen::Vector3d	at () const
Eigen::Vector3d	up () const
Eigen::Vector3d	unit_plane () const
void	dolly (const Eigen::Vector3d &dv)
void	push_away (const double s)
void	dolly_zoom (const double da)
void	turn_eye (const Eigen::Quaterniond &q)
void	orbit (const Eigen::Quaterniond &q)
void	look_at (const Eigen::Vector3d &eye, const Eigen::Vector3d &at, const Eigen::Vector3d &up)

Public Attributes
double	m_angle
double	m_aspect
double	m_near
double	m_far
double	m_at_dist
bool	m_orthographic
Eigen::Quaterniond	m_rotation_conj
Eigen::Vector3d	m_translation

Detailed Description

Constructor & Destructor Documentation

Camera()

igl::Camera::Camera ( )

inline

                        :
  m_angle(45.0),m_aspect(1),m_near(1e-2),m_far(100),m_at_dist(1),
  m_orthographic(false),
  m_rotation_conj(1,0,0,0),
  m_translation(0,0,1)
{
}

~Camera()

virtual igl::Camera::~Camera ( )

inlinevirtual

{}

Member Function Documentation

affine()

Eigen::Affine3d igl::Camera::affine ( ) const

inline

{
  using namespace Eigen;
  Affine3d t = Affine3d::Identity();
  t.rotate(m_rotation_conj.conjugate());
  t.translate(m_translation);
  return t;
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::rotate(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translate().

Here is the call graph for this function:

at()

Eigen::Vector3d igl::Camera::at ( ) const

inline

{
  using namespace Eigen;
  return affine() * (Vector3d(0,0,-1)*m_at_dist);
}

dolly()

void igl::Camera::dolly ( const Eigen::Vector3d &  dv )

inline

{
  m_translation += dv;
}

dolly_zoom()

void igl::Camera::dolly_zoom ( const double  da )

inline

{
  using namespace std;
  using namespace Eigen;
#ifndef NDEBUG
  Vector3d old_at = at();
#endif
  const double old_angle = m_angle;
  if(old_angle + da < IGL_CAMERA_MIN_ANGLE)
  {
    m_orthographic = true;
  }else if(old_angle + da > IGL_CAMERA_MIN_ANGLE)
  {
    m_orthographic = false;
  }
  if(!m_orthographic)
  {
    m_angle += da;
    m_angle = min(89.,max(IGL_CAMERA_MIN_ANGLE,m_angle));
    // change in distance
    const double s = 
      (2.*tan(old_angle/2./180.*igl::PI)) /
      (2.*tan(m_angle/2./180.*igl::PI)) ;
    const double old_at_dist = m_at_dist;
    m_at_dist = old_at_dist * s;
    dolly(Vector3d(0,0,1)*(m_at_dist - old_at_dist));
    assert((old_at-at()).squaredNorm() < DOUBLE_EPS);
  }
}

References igl::DOUBLE_EPS, IGL_CAMERA_MIN_ANGLE, igl::max(), igl::min(), igl::PI, and tan().

Here is the call graph for this function:

eye()

Eigen::Vector3d igl::Camera::eye ( ) const

inline

{
  using namespace Eigen;
  return affine() * Vector3d(0,0,0);
}

inverse()

Eigen::Affine3d igl::Camera::inverse ( ) const

inline

{
  using namespace Eigen;
  Affine3d t = Affine3d::Identity();
  t.translate(-m_translation);
  t.rotate(m_rotation_conj);
  return t;
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::rotate(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translate().

Here is the call graph for this function:

look_at()

void igl::Camera::look_at ( const Eigen::Vector3d &  eye, const Eigen::Vector3d &  at, const Eigen::Vector3d &  up  )

inline

{
  using namespace Eigen;
  using namespace std;
  // http://www.opengl.org/sdk/docs/man2/xhtml/gluLookAt.xml
  // Normalize vector from at to eye
  Vector3d F = eye-at;
  m_at_dist = F.norm();
  F.normalize();
  // Project up onto plane orthogonal to F and normalize
  assert(up.cross(F).norm() > DOUBLE_EPS && "(eye-at) x up ≈ 0");
  const Vector3d proj_up = (up-(up.dot(F))*F).normalized();
  Quaterniond a,b;
  a.setFromTwoVectors(Vector3d(0,0,-1),-F);
  b.setFromTwoVectors(a*Vector3d(0,1,0),proj_up);
  m_rotation_conj = (b*a).conjugate();
  m_translation = m_rotation_conj * eye;
  //cout<<"m_at_dist: "<<m_at_dist<<endl;
  //cout<<"proj_up: "<<proj_up.transpose()<<endl;
  //cout<<"F: "<<F.transpose()<<endl;
  //cout<<"eye(): "<<this->eye().transpose()<<endl;
  //cout<<"at(): "<<this->at().transpose()<<endl;
  //cout<<"eye()-at(): "<<(this->eye()-this->at()).normalized().transpose()<<endl;
  //cout<<"eye-this->eye(): "<<(eye-this->eye()).squaredNorm()<<endl;
  assert(           (eye-this->eye()).squaredNorm() < DOUBLE_EPS);
  //assert((F-(this->eye()-this->at()).normalized()).squaredNorm() < 
  //  DOUBLE_EPS);
  assert(           (at-this->at()).squaredNorm() < DOUBLE_EPS);
  //assert(        (proj_up-this->up()).squaredNorm() < DOUBLE_EPS);
}

References conjugate(), and igl::DOUBLE_EPS.

Here is the call graph for this function:

orbit()

void igl::Camera::orbit ( const Eigen::Quaterniond &  q )

inline

{
  using namespace Eigen;
  Vector3d old_at = at();
  // at should be fixed
  //
  // at_1 = R_1 * t_1 - R_1 * z = at_0
  // t_1 = R_1' * (at_0 + R_1 * z)
  m_rotation_conj = q.conjugate();
  m_translation = 
    m_rotation_conj * 
      (old_at + 
         m_rotation_conj.conjugate() * Vector3d(0,0,1) * m_at_dist);
  assert((old_at - at()).squaredNorm() < DOUBLE_EPS);
}

References Eigen::QuaternionBase< Derived >::conjugate(), and igl::DOUBLE_EPS.

Here is the call graph for this function:

projection()

Eigen::Matrix4d igl::Camera::projection ( ) const

inline

{
  Eigen::Matrix4d P;
  using namespace std;
  const double far = m_at_dist + m_far;
  const double near = m_near;
  // http://stackoverflow.com/a/3738696/148668
  if(m_orthographic)
  {
    const double f = 0.5;
    const double left = -f*m_aspect;
    const double right = f*m_aspect;
    const double bottom = -f;
    const double top = f;
    const double tx = (right+left)/(right-left);
    const double ty = (top+bottom)/(top-bottom);
    const double tz = (far+near)/(far-near);
    const double z_fix = 0.5 /m_at_dist / tan(m_angle*0.5 * (igl::PI/180.) );
    P<<
      z_fix*2./(right-left), 0, 0, -tx,
      0, z_fix*2./(top-bottom), 0, -ty,
      0, 0, -z_fix*2./(far-near),  -tz,
      0, 0, 0, 1;
  }else
  {
    const double yScale = tan(PI*0.5 - 0.5*m_angle*PI/180.);
    // http://stackoverflow.com/a/14975139/148668
    const double xScale = yScale/m_aspect;
    P<< 
      xScale, 0, 0, 0,
      0, yScale, 0, 0,
      0, 0, -(far+near)/(far-near), -1,
      0, 0, -2.*near*far/(far-near), 0;
    P = P.transpose().eval();
  }
  return P;
}

References igl::PI, and tan().

Here is the call graph for this function:

push_away()

void igl::Camera::push_away ( const double  s )

inline

{
  using namespace Eigen;
#ifndef NDEBUG
  Vector3d old_at = at();
#endif
  const double old_at_dist = m_at_dist;
  m_at_dist = old_at_dist * s;
  dolly(Vector3d(0,0,1)*(m_at_dist - old_at_dist));
  assert((old_at-at()).squaredNorm() < DOUBLE_EPS);
}

References igl::DOUBLE_EPS.

turn_eye()

void igl::Camera::turn_eye ( const Eigen::Quaterniond &  q )

inline

{
  using namespace Eigen;
  Vector3d old_eye = eye();
  // eye should be fixed
  //
  // eye_1 = R_1 * t_1 = eye_0
  // t_1 = R_1' * eye_0
  m_rotation_conj = q.conjugate();
  m_translation = m_rotation_conj * old_eye;
  assert((old_eye - eye()).squaredNorm() < DOUBLE_EPS);
}

References Eigen::QuaternionBase< Derived >::conjugate(), and igl::DOUBLE_EPS.

Here is the call graph for this function:

unit_plane()

Eigen::Vector3d igl::Camera::unit_plane ( ) const

inline

{
  // Distance of center pixel to eye
  const double d = 1.0;
  const double a = m_aspect;
  const double theta = m_angle*PI/180.;
  const double w =
    2.*sqrt(-d*d/(a*a*pow(tan(0.5*theta),2.)-1.))*a*tan(0.5*theta);
  const double h = w/a;
  return Eigen::Vector3d(w*0.5,h*0.5,-d);
}

References igl::PI, sqrt(), and tan().

Here is the call graph for this function:

up()

Eigen::Vector3d igl::Camera::up ( ) const

inline

{
  using namespace Eigen;
  Affine3d t = Affine3d::Identity();
  t.rotate(m_rotation_conj.conjugate());
  return t * Vector3d(0,1,0);
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::rotate().

Here is the call graph for this function:

Member Data Documentation

m_angle

double igl::Camera::m_angle

m_aspect

double igl::Camera::m_aspect

m_at_dist

double igl::Camera::m_at_dist

m_far

double igl::Camera::m_far

m_near

double igl::Camera::m_near

m_orthographic

bool igl::Camera::m_orthographic

m_rotation_conj

Eigen::Quaterniond igl::Camera::m_rotation_conj

m_translation

Eigen::Vector3d igl::Camera::m_translation

---

The documentation for this class was generated from the following file:

• src/libigl/igl/Camera.h