#include <src/libigl/igl/opengl2/RotateWidget.h>

Public Types
enum	DownType { DOWN_TYPE_X = 0 , DOWN_TYPE_Y = 1 , DOWN_TYPE_Z = 2 , DOWN_TYPE_OUTLINE = 3 , DOWN_TYPE_TRACKBALL = 4 , DOWN_TYPE_NONE = 5 , NUM_DOWN_TYPES = 6 }

Public Member Functions
	RotateWidget ()

Eigen::Vector3d	unproject_onto (const int x, const int y) const

bool	intersect (const int x, const int y, Eigen::Vector3d &hit) const

double	unprojected_inner_radius () const

bool	down (const int x, const int y)

bool	drag (const int x, const int y)

bool	up (const int x, const int y)

bool	is_down () const

void	draw () const

void	draw_guide () const

Static Public Member Functions
static Eigen::Quaterniond	axis_q (const int a)

static Eigen::Vector3d	view_direction (const int x, const int y)

static Eigen::Vector3d	view_direction (const Eigen::Vector3d &pos)

Public Attributes
Eigen::Vector3d	pos

Eigen::Quaterniond	rot

Eigen::Quaterniond	down_rot

Eigen::Vector2d	down_xy

Eigen::Vector2d	drag_xy

Eigen::Vector2d	down_dir

Eigen::Vector3d	udown

Eigen::Vector3d	udrag

double	outer_radius_on_screen

double	outer_over_inner

bool	m_is_enabled

enum igl::opengl2::RotateWidget::DownType	down_type

enum igl::opengl2::RotateWidget::DownType	selected_type

Static Private Member Functions
static void	glColor4fv (const bool a, const Eigen::Vector4f &A)

Detailed Description

Member Enumeration Documentation

◆ DownType

enum igl::opengl2::RotateWidget::DownType

Enumerator
DOWN_TYPE_X
DOWN_TYPE_Y
DOWN_TYPE_Z
DOWN_TYPE_OUTLINE
DOWN_TYPE_TRACKBALL
DOWN_TYPE_NONE
NUM_DOWN_TYPES

        {
          DOWN_TYPE_X = 0,
          DOWN_TYPE_Y = 1,
          DOWN_TYPE_Z = 2,
          DOWN_TYPE_OUTLINE = 3,
          DOWN_TYPE_TRACKBALL = 4,
          DOWN_TYPE_NONE = 5,
          NUM_DOWN_TYPES = 6
        } down_type, selected_type;

Constructor & Destructor Documentation

◆ RotateWidget()

igl::opengl2::RotateWidget::RotateWidget ( )

inline

                                           :
  pos(0,0,0),
  rot(Eigen::Quaterniond::Identity()),
  down_rot(rot),
  down_xy(-1,-1),drag_xy(-1,-1),
  outer_radius_on_screen(91.),
  outer_over_inner(1.13684210526),
  m_is_enabled(true),
  down_type(DOWN_TYPE_NONE), 
  selected_type(DOWN_TYPE_NONE)
{
}

Member Function Documentation

◆ axis_q()

Eigen::Quaterniond igl::opengl2::RotateWidget::axis_q ( const int a )

inlinestatic

{
  assert(a<3 && a>=0);
  const Eigen::Quaterniond axes[3] = {
    Eigen::Quaterniond(Eigen::AngleAxisd(igl::PI*0.5,Eigen::Vector3d(0,1,0))),
    Eigen::Quaterniond(Eigen::AngleAxisd(igl::PI*0.5,Eigen::Vector3d(1,0,0))),
    Eigen::Quaterniond::Identity()};
  return axes[a];
}

References Eigen::QuaternionBase< Quaternion< _Scalar, _Options > >::Identity(), and igl::PI.

Here is the call graph for this function:

◆ down()

bool igl::opengl2::RotateWidget::down	(	const int	x,
		const int	y
	)

inline

{
  using namespace Eigen;
  using namespace std;
  if(!m_is_enabled)
  {
    return false;
  }
  down_type = DOWN_TYPE_NONE;
  selected_type = DOWN_TYPE_NONE;
  down_xy = Vector2d(x,y);
  drag_xy = down_xy;
  down_rot = rot;
  Vector3d ppos = project(pos);
  const double r = (ppos.head(2) - down_xy).norm();
  const double thresh = 3;
  if(fabs(r - outer_radius_on_screen)<thresh)
  {
    udown = unproject_onto(x,y);
    udrag = udown;
    down_type = DOWN_TYPE_OUTLINE;
    selected_type = DOWN_TYPE_OUTLINE;
    // project mouse to same depth as pos
    return true;
  }else if(r < outer_radius_on_screen/outer_over_inner+thresh*0.5)
  {
    Vector3d hit;
    const bool is_hit = intersect(down_xy(0),down_xy(1),hit);
    if(!is_hit)
    {
      //cout<<"~~~!is_hit"<<endl;
    }
    auto on_meridian = [&](
      const Vector3d & hit, 
      const Quaterniond & rot, 
      const Quaterniond & m,
      Vector3d & pl_hit) -> bool
    {
      // project onto rotate plane
      pl_hit = hit-pos;
      pl_hit = (m.conjugate()*rot.conjugate()*pl_hit).eval();
      pl_hit(2) = 0;
      pl_hit = (rot*m*pl_hit).eval();
      pl_hit.normalize();
      pl_hit *= unprojected_inner_radius();
      pl_hit += pos;
      return (project(pl_hit).head(2)-project(hit).head(2)).norm()<2*thresh;
    };
    udown = (hit-pos).normalized()/outer_radius_on_screen;
    udrag = udown;
    for(int a = 0;a<3;a++)
    {
      Vector3d pl_hit;
      if(on_meridian(hit,rot,Quaterniond(axis_q(a)),pl_hit))
      {
        udown = (pl_hit-pos).normalized()/outer_radius_on_screen;
        udrag = udown;
        down_type = DownType(DOWN_TYPE_X+a);
        selected_type = down_type;
        {
          Vector3d dir3 = axis_q(a).conjugate()*down_rot.conjugate()*(hit-pos);
          dir3 = AngleAxisd(-PI*0.5,Vector3d(0,0,1))*dir3;
          dir3 = (rot*axis_q(a)*dir3).eval();
          down_dir = (project((hit+dir3).eval())-project(hit)).head(2);
          down_dir.normalize();
          //down_dir(1) *= -1;
        }
        return true;
      }
    }
    //assert(is_hit);
    down_type = DOWN_TYPE_TRACKBALL;
    selected_type = DOWN_TYPE_TRACKBALL;
    return true;
  }else
  {
    return false;
  }
}

References head(), igl::intersect(), igl::PI, and igl::opengl2::project().

Here is the call graph for this function:

◆ drag()

bool igl::opengl2::RotateWidget::drag	(	const int	x,
		const int	y
	)

inline

{
  using namespace std;
  using namespace Eigen;
  if(!m_is_enabled)
  {
    return false;
  }
  drag_xy = Vector2d(x,y);
  switch(down_type)
  {
    case DOWN_TYPE_NONE:
      return false;
    default:
    {
      const Quaterniond & q = axis_q(down_type-DOWN_TYPE_X);
      const double dtheta = -(drag_xy - down_xy).dot(down_dir)/
        outer_radius_on_screen/outer_over_inner*PI/2.;
      Quaterniond dq(AngleAxisd(dtheta,down_rot*q*Vector3d(0,0,1)));
      rot = dq * down_rot;
      udrag = dq * udown;
      return true;
    }
    case DOWN_TYPE_OUTLINE:
      {
        Vector3d ppos = project(pos);
        // project mouse to same depth as pos
        udrag = unproject_onto(x,y);
        const Vector2d A = down_xy - ppos.head(2);
        const Vector2d B = drag_xy - ppos.head(2);
        const double dtheta = atan2(A(0)*B(1)-A(1)*B(0),A(0)*B(0)+A(1)*B(1));
        Vector3d n = view_direction(pos).normalized();
        Quaterniond dq(AngleAxisd(dtheta,-n));
        //Vector3d n = udrag.cross(udown).normalized();
        //Quaterniond dq(AngleAxisd(fabs(dtheta),-n));
        rot = dq * down_rot;
      }
      return true;
    case DOWN_TYPE_TRACKBALL:
      {
        Vector3d ppos = project(pos);
        const double r = (double)outer_radius_on_screen/outer_over_inner*2.0;
        //const int h = w;
        Vector4i vp;
        glGetIntegerv(GL_VIEWPORT,vp.data());
        const int h = vp(3);
        Quaterniond dq;
        trackball(
          r,r,
          1,
          Quaterniond::Identity(),
          double(    down_xy(0)-ppos(0)    )+r/2.,
          double((h-down_xy(1))-(h-ppos(1)))+r/2.,
          double(             x-ppos(0)    )+r/2.,
          double(         (h-y)-(h-ppos(1)))+r/2.,
          dq);
        // We've computed change in rotation according to this view:
        // R = mv * r, R' = rot * (mv * r)
        // But we only want new value for r:
        // R' = mv * r'
        // mv * r' = rot * (mv * r)
        // r' = mv* * rot * mv * r
        Matrix4d mv;
        glGetDoublev(GL_MODELVIEW_MATRIX,mv.data());
        Quaterniond scene_rot;
        // Convert modelview matrix to quaternion
        mat4_to_quat(mv.data(),scene_rot.coeffs().data());
        scene_rot.normalize();
        rot = scene_rot.conjugate() * dq * scene_rot * down_rot;
      }
      return true;
  }
}

References Eigen::Quaternion< _Scalar, _Options >::coeffs(), Eigen::QuaternionBase< Derived >::conjugate(), igl::dot(), igl::mat4_to_quat(), Eigen::QuaternionBase< Derived >::normalize(), igl::PI, igl::opengl2::project(), and igl::trackball().

Here is the call graph for this function:

◆ draw()

void igl::opengl2::RotateWidget::draw ( ) const

inline

{
  using namespace Eigen;
  using namespace std;
  glPushAttrib(GL_ENABLE_BIT | GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT | GL_LINE_BIT);
  glDisable(GL_CLIP_PLANE0);
 
  glDisable(GL_LIGHTING);
  glDisable(GL_DEPTH_TEST);
  glLineWidth(2.0);
 
  double r = unprojected_inner_radius();
  Vector3d view = view_direction(pos).normalized();
 
  auto draw_circle = [&](const bool cull)
  {
    Vector3d view = view_direction(pos).normalized();
    glBegin(GL_LINES);
    const double th_step = (2.0*igl::PI/100.0);
    for(double th = 0;th<2.0*igl::PI+th_step;th+=th_step)
    {
      Vector3d a(cos(th),sin(th),0.0);
      Vector3d b(cos(th+th_step),sin(th+th_step),0.0);
      if(!cull || (0.5*(a+b)).dot(view)<FLOAT_EPS)
      {
        glVertex3dv(a.data());
        glVertex3dv(b.data());
      }
    }
    glEnd();
  };
 
 
  glPushMatrix();
  glTranslated(pos(0),pos(1),pos(2));
 
  glScaled(r,r,r);
  // Draw outlines
  {
    glPushMatrix();
    glColor4fv(m_is_enabled,MAYA_GREY);
    Quaterniond q;
    q.setFromTwoVectors(Vector3d(0,0,1),view);
    glMultMatrixd(Affine3d(q).matrix().data());
    draw_circle(false);
    glScaled(outer_over_inner,outer_over_inner,outer_over_inner);
    if(selected_type == DOWN_TYPE_OUTLINE)
    {
      glColor4fv(m_is_enabled,MAYA_YELLOW);
    }else
    {
      glColor4fv(m_is_enabled,MAYA_CYAN);
    }
    draw_circle(false);
    glPopMatrix();
  }
  // Draw quartiles
  {
    glPushMatrix();
    glMultMatrixd(Affine3d(rot).matrix().data());
    if(selected_type == DOWN_TYPE_Z)
    {
      glColor4fv(m_is_enabled,MAYA_YELLOW);
    }else
    {
      glColor4fv(m_is_enabled,MAYA_BLUE);
    }
    draw_circle(true);
    if(selected_type == DOWN_TYPE_Y)
    {
      glColor4fv(m_is_enabled,MAYA_YELLOW);
    }else
    {
      glColor4fv(m_is_enabled,MAYA_GREEN);
    }
    glRotated(90.0,1.0,0.0,0.0);
    draw_circle(true);
    if(selected_type == DOWN_TYPE_X)
    {
      glColor4fv(m_is_enabled,MAYA_YELLOW);
    }else
    {
      glColor4fv(m_is_enabled,MAYA_RED);
    }
    glRotated(90.0,0.0,1.0,0.0);
    draw_circle(true);
    glPopMatrix();
  }
  glColor4fv(m_is_enabled,MAYA_GREY);
  draw_guide();
  glPopMatrix();
 
  glPopAttrib();
};

References cos(), igl::dot(), igl::FLOAT_EPS, igl::MAYA_BLUE(), igl::MAYA_CYAN(), igl::MAYA_GREEN(), igl::MAYA_GREY(), igl::MAYA_RED(), igl::MAYA_YELLOW(), igl::PI, Eigen::QuaternionBase< Derived >::setFromTwoVectors(), and sin().

Here is the call graph for this function:

◆ draw_guide()

void igl::opengl2::RotateWidget::draw_guide ( ) const

inline

{
  using namespace Eigen;
  using namespace std;
  glPushAttrib(
    GL_DEPTH_BUFFER_BIT | 
    GL_ENABLE_BIT | 
    GL_POLYGON_BIT | 
    GL_POINT_BIT | 
    GL_TRANSFORM_BIT |
    GL_STENCIL_BUFFER_BIT |
    GL_LIGHTING_BIT);
 
  // http://www.codeproject.com/Articles/23444/A-Simple-OpenGL-Stipple-Polygon-Example-EP_OpenGL_
  const GLubyte halftone[] = {
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
    0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55};
 
 
  switch(down_type)
  {
    case DOWN_TYPE_NONE:
    case DOWN_TYPE_TRACKBALL:
      goto finish;
    case DOWN_TYPE_OUTLINE:
      glScaled(outer_over_inner,outer_over_inner,outer_over_inner);
      break;
    default:
      break;
  }
  {
    const Vector3d nudown(udown.normalized()), 
      nudrag(udrag.normalized());
    glPushMatrix();
    glDisable(GL_CULL_FACE);
    glDisable(GL_POINT_SMOOTH);
    glPointSize(5.);
    glBegin(GL_POINTS);
    glVertex3dv(nudown.data());
    glVertex3d(0,0,0);
    glVertex3dv(nudrag.data());
    glEnd();
    glBegin(GL_LINE_STRIP);
    glVertex3dv(nudown.data());
    glVertex3d(0,0,0);
    glVertex3dv(nudrag.data());
    glEnd();
    glEnable(GL_POLYGON_STIPPLE);
    glPolygonStipple(halftone);
    glBegin(GL_TRIANGLE_FAN);
    glVertex3d(0,0,0);
    Quaterniond dq = rot * down_rot.conjugate();
    //dq.setFromTwoVectors(nudown,nudrag);
    for(double t = 0;t<1;t+=0.1)
    {
      const Vector3d p = Quaterniond::Identity().slerp(t,dq) * nudown;
      glVertex3dv(p.data());
    }
    glVertex3dv(nudrag.data());
    glEnd();
    glPopMatrix();
  }
finish:
  glPopAttrib();
}

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

Here is the call graph for this function:

◆ glColor4fv()

void igl::opengl2::RotateWidget::glColor4fv	(	const bool	a,
		const Eigen::Vector4f &	A
	)

inlinestaticprivate

{
  if(a)
  {
    ::glColor4fv(A.data());
  }else
  {
    Eigen::Vector4f B;
    const double f = 0.95; // desaturate by 95%
    const double L = 0.3*A(0) + 0.6*A(1) + 0.1*A(2);
    B.head(3) = A.head(3).array() + f*(L-A.head(3).array());
    B(3) = A(3);
    ::glColor4fv(B.data());
  }
}

References glColor4fv(), and L.

Referenced by glColor4fv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ intersect()

bool igl::opengl2::RotateWidget::intersect	(	const int	x,
		const int	y,
		Eigen::Vector3d &	hit
	)		const

inline

{
  using namespace Eigen;
  Vector3d view = view_direction(x,y);
  const Vector3d ppos = project(pos);
  Vector3d uxy = unproject(Vector3d(x,y,ppos(2)));
  double t0,t1;
  if(!ray_sphere_intersect(uxy,view,pos,unprojected_inner_radius(),t0,t1))
  {
    return false;
  }
  hit = uxy+t0*view;
  return true;
}

References igl::opengl2::project(), igl::ray_sphere_intersect(), and igl::opengl2::unproject().

Here is the call graph for this function:

◆ is_down()

bool igl::opengl2::RotateWidget::is_down ( ) const

inline

{
  return down_type != DOWN_TYPE_NONE;
}

Referenced by igl::opengl2::MouseController::is_widget_down().

Here is the caller graph for this function:

◆ unproject_onto()

Eigen::Vector3d igl::opengl2::RotateWidget::unproject_onto	(	const int	x,
		const int	y
	)		const

inline

{
  using namespace Eigen;
  // KNOWN BUG: This projects to same depths as pos. I think what we actually
  // want is The intersection with the plane perpendicular to the view
  // direction at pos. If the field of view angle is small then this difference
  // is negligible.
  //const Vector3d ppos = project(pos);
  //const Vector3d uxy = unproject( Vector3d(x,y,ppos(2)));
  // http://en.wikipedia.org/wiki/Line-plane_intersection
  //
  // Hrrmmm. There's still something wrong here if the ball's in the corner of
  // the screen. Am I somehow not accounting for perspective correctly?
  //
  // Q: What about just projecting the circle's equation and solving for the
  // distance?
  const Vector3d l0 = unproject(Vector3d(x,y,0));
  const Vector3d l = unproject(Vector3d(x,y,1))-l0;
  const Vector3d n = view_direction(pos);
  const double t = (pos-l0).dot(n)/l.dot(n);
  const Vector3d uxy = l0+t*l;
  return (uxy-pos)/unprojected_inner_radius()*outer_over_inner*outer_over_inner;
}

References igl::dot(), and igl::opengl2::unproject().

Here is the call graph for this function:

◆ unprojected_inner_radius()

double igl::opengl2::RotateWidget::unprojected_inner_radius ( ) const

inline

{
  using namespace Eigen;
  Vector3d off,ppos,ppos_off,pos_off;
  project(pos,ppos);
  ppos_off = ppos;
  ppos_off(0) += outer_radius_on_screen/outer_over_inner;
  unproject(ppos_off,pos_off);
  return (pos-pos_off).norm();
}

References igl::opengl2::project(), and igl::opengl2::unproject().

Here is the call graph for this function:

◆ up()

bool igl::opengl2::RotateWidget::up	(	const int	x,
		const int	y
	)

inline

{
  // even if disabled process up
  down_type = DOWN_TYPE_NONE;
  return false;
}

◆ view_direction() [1/2]

Eigen::Vector3d igl::opengl2::RotateWidget::view_direction ( const Eigen::Vector3d & pos )

inlinestatic

{
  using namespace Eigen;
  const Vector3d ppos = project(pos);
  return view_direction(ppos(0),ppos(1));
}

References igl::opengl2::project().

Here is the call graph for this function:

◆ view_direction() [2/2]

Eigen::Vector3d igl::opengl2::RotateWidget::view_direction	(	const int	x,
		const int	y
	)

inlinestatic

{
  using namespace Eigen;
  const Vector3d win_s(x,y,0), win_d(x,y,1);
  const Vector3d s = unproject(win_s);
  const Vector3d d = unproject(win_d);
  return d-s;
}

References igl::opengl2::unproject().

Here is the call graph for this function:

Member Data Documentation

◆ down_dir

Eigen::Vector2d igl::opengl2::RotateWidget::down_dir

◆ down_rot

Eigen::Quaterniond igl::opengl2::RotateWidget::down_rot

◆ down_type

enum igl::opengl2::RotateWidget::DownType igl::opengl2::RotateWidget::down_type

◆ down_xy

Eigen::Vector2d igl::opengl2::RotateWidget::down_xy

◆ drag_xy

Eigen::Vector2d igl::opengl2::RotateWidget::drag_xy

◆ m_is_enabled

bool igl::opengl2::RotateWidget::m_is_enabled

◆ outer_over_inner

double igl::opengl2::RotateWidget::outer_over_inner

◆ outer_radius_on_screen

double igl::opengl2::RotateWidget::outer_radius_on_screen

◆ pos

Eigen::Vector3d igl::opengl2::RotateWidget::pos

◆ rot

Eigen::Quaterniond igl::opengl2::RotateWidget::rot

◆ selected_type

enum igl::opengl2::RotateWidget::DownType igl::opengl2::RotateWidget::selected_type

◆ udown

Eigen::Vector3d igl::opengl2::RotateWidget::udown

◆ udrag

Eigen::Vector3d igl::opengl2::RotateWidget::udrag

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

src/libigl/igl/opengl2/RotateWidget.h

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Private Member Functions

Detailed Description

Member Enumeration Documentation

◆ DownType

Constructor & Destructor Documentation

◆ RotateWidget()

Member Function Documentation

◆ axis_q()

◆ down()

◆ drag()

◆ draw()

◆ draw_guide()

◆ glColor4fv()

◆ intersect()

◆ is_down()

◆ unproject_onto()

◆ unprojected_inner_radius()

◆ up()

◆ view_direction() [1/2]

◆ view_direction() [2/2]

Member Data Documentation

◆ down_dir

◆ down_rot

◆ down_type

◆ down_xy

◆ drag_xy

◆ m_is_enabled

◆ outer_over_inner

◆ outer_radius_on_screen

◆ pos

◆ rot

◆ selected_type

◆ udown

◆ udrag