quaternion_demo.cpp
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #include "quaternion_demo.h"
11 #include "icosphere.h"
12 
13 #include <Eigen/Geometry>
14 #include <Eigen/QR>
15 #include <Eigen/LU>
16 
17 #include <iostream>
18 #include <QEvent>
19 #include <QMouseEvent>
20 #include <QInputDialog>
21 #include <QGridLayout>
22 #include <QButtonGroup>
23 #include <QRadioButton>
24 #include <QDockWidget>
25 #include <QPushButton>
26 #include <QGroupBox>
27 
28 using namespace Eigen;
29 
31 {
32  public:
34 
36  {
37  const int levels = 4;
38  const float scale = 0.33;
39  float radius = 100;
40  std::vector<int> parents;
41 
42  // leval 0
43  mCenters.push_back(Vector3f::Zero());
44  parents.push_back(-1);
45  mRadii.push_back(radius);
46 
47  // generate level 1 using icosphere vertices
48  radius *= 0.45;
49  {
50  float dist = mRadii[0]*0.9;
51  for (int i=0; i<12; ++i)
52  {
53  mCenters.push_back(mIcoSphere.vertices()[i] * dist);
54  mRadii.push_back(radius);
55  parents.push_back(0);
56  }
57  }
58 
59  static const float angles [10] = {
60  0, 0,
61  M_PI, 0.*M_PI,
62  M_PI, 0.5*M_PI,
63  M_PI, 1.*M_PI,
64  M_PI, 1.5*M_PI
65  };
66 
67  // generate other levels
68  int start = 1;
69  for (int l=1; l<levels; l++)
70  {
71  radius *= scale;
72  int end = mCenters.size();
73  for (int i=start; i<end; ++i)
74  {
75  Vector3f c = mCenters[i];
76  Vector3f ax0 = (c - mCenters[parents[i]]).normalized();
77  Vector3f ax1 = ax0.unitOrthogonal();
78  Quaternionf q;
79  q.setFromTwoVectors(Vector3f::UnitZ(), ax0);
80  Affine3f t = Translation3f(c) * q * Scaling(mRadii[i]+radius);
81  for (int j=0; j<5; ++j)
82  {
83  Vector3f newC = c + ( (AngleAxisf(angles[j*2+1], ax0)
84  * AngleAxisf(angles[j*2+0] * (l==1 ? 0.35 : 0.5), ax1)) * ax0)
85  * (mRadii[i] + radius*0.8);
86  mCenters.push_back(newC);
87  mRadii.push_back(radius);
88  parents.push_back(i);
89  }
90  }
91  start = end;
92  }
93  }
94 
95  void draw()
96  {
97  int end = mCenters.size();
98  glEnable(GL_NORMALIZE);
99  for (int i=0; i<end; ++i)
100  {
101  Affine3f t = Translation3f(mCenters[i]) * Scaling(mRadii[i]);
102  gpu.pushMatrix(GL_MODELVIEW);
103  gpu.multMatrix(t.matrix(),GL_MODELVIEW);
104  mIcoSphere.draw(2);
105  gpu.popMatrix(GL_MODELVIEW);
106  }
107  glDisable(GL_NORMALIZE);
108  }
109  protected:
110  std::vector<Vector3f> mCenters;
111  std::vector<float> mRadii;
113 };
114 
115 
116 // generic linear interpolation method
117 template<typename T> T lerp(float t, const T& a, const T& b)
118 {
119  return a*(1-t) + b*t;
120 }
121 
122 // quaternion slerp
123 template<> Quaternionf lerp(float t, const Quaternionf& a, const Quaternionf& b)
124 { return a.slerp(t,b); }
125 
126 // linear interpolation of a frame using the type OrientationType
127 // to perform the interpolation of the orientations
128 template<typename OrientationType>
129 inline static Frame lerpFrame(float alpha, const Frame& a, const Frame& b)
130 {
131  return Frame(lerp(alpha,a.position,b.position),
132  Quaternionf(lerp(alpha,OrientationType(a.orientation),OrientationType(b.orientation))));
133 }
134 
135 template<typename _Scalar> class EulerAngles
136 {
137 public:
138  enum { Dim = 3 };
139  typedef _Scalar Scalar;
143 
144 protected:
145 
146  Vector3 m_angles;
147 
148 public:
149 
151  inline EulerAngles(Scalar a0, Scalar a1, Scalar a2) : m_angles(a0, a1, a2) {}
152  inline EulerAngles(const QuaternionType& q) { *this = q; }
153 
154  const Vector3& coeffs() const { return m_angles; }
155  Vector3& coeffs() { return m_angles; }
156 
157  EulerAngles& operator=(const QuaternionType& q)
158  {
159  Matrix3 m = q.toRotationMatrix();
160  return *this = m;
161  }
162 
163  EulerAngles& operator=(const Matrix3& m)
164  {
165  // mat = cy*cz -cy*sz sy
166  // cz*sx*sy+cx*sz cx*cz-sx*sy*sz -cy*sx
167  // -cx*cz*sy+sx*sz cz*sx+cx*sy*sz cx*cy
168  m_angles.coeffRef(1) = std::asin(m.coeff(0,2));
169  m_angles.coeffRef(0) = std::atan2(-m.coeff(1,2),m.coeff(2,2));
170  m_angles.coeffRef(2) = std::atan2(-m.coeff(0,1),m.coeff(0,0));
171  return *this;
172  }
173 
174  Matrix3 toRotationMatrix(void) const
175  {
176  Vector3 c = m_angles.array().cos();
177  Vector3 s = m_angles.array().sin();
178  Matrix3 res;
179  res << c.y()*c.z(), -c.y()*s.z(), s.y(),
180  c.z()*s.x()*s.y()+c.x()*s.z(), c.x()*c.z()-s.x()*s.y()*s.z(), -c.y()*s.x(),
181  -c.x()*c.z()*s.y()+s.x()*s.z(), c.z()*s.x()+c.x()*s.y()*s.z(), c.x()*c.y();
182  return res;
183  }
184 
185  operator QuaternionType() { return QuaternionType(toRotationMatrix()); }
186 };
187 
188 // Euler angles slerp
190 {
192  res.coeffs() = lerp(t, a.coeffs(), b.coeffs());
193  return res;
194 }
195 
196 
198 {
199  mAnimate = false;
200  mCurrentTrackingMode = TM_NO_TRACK;
201  mNavMode = NavTurnAround;
202  mLerpMode = LerpQuaternion;
203  mRotationMode = RotationStable;
204  mTrackball.setCamera(&mCamera);
205 
206  // required to capture key press events
207  setFocusPolicy(Qt::ClickFocus);
208 }
209 
211 {
212  // ask user for a time
213  bool ok = false;
214  double t = 0;
215  if (!m_timeline.empty())
216  t = (--m_timeline.end())->first + 1.;
217  t = QInputDialog::getDouble(this, "Eigen's RenderingWidget", "time value: ",
218  t, 0, 1e3, 1, &ok);
219  if (ok)
220  {
221  Frame aux;
222  aux.orientation = mCamera.viewMatrix().linear();
223  aux.position = mCamera.viewMatrix().translation();
224  m_timeline[t] = aux;
225  }
226 }
227 
229 {
230  static FancySpheres sFancySpheres;
231  float length = 50;
232  gpu.drawVector(Vector3f::Zero(), length*Vector3f::UnitX(), Color(1,0,0,1));
233  gpu.drawVector(Vector3f::Zero(), length*Vector3f::UnitY(), Color(0,1,0,1));
234  gpu.drawVector(Vector3f::Zero(), length*Vector3f::UnitZ(), Color(0,0,1,1));
235 
236  // draw the fractal object
237  float sqrt3 = std::sqrt(3.);
238  glLightfv(GL_LIGHT0, GL_AMBIENT, Vector4f(0.5,0.5,0.5,1).data());
239  glLightfv(GL_LIGHT0, GL_DIFFUSE, Vector4f(0.5,1,0.5,1).data());
240  glLightfv(GL_LIGHT0, GL_SPECULAR, Vector4f(1,1,1,1).data());
241  glLightfv(GL_LIGHT0, GL_POSITION, Vector4f(-sqrt3,-sqrt3,sqrt3,0).data());
242 
243  glLightfv(GL_LIGHT1, GL_AMBIENT, Vector4f(0,0,0,1).data());
244  glLightfv(GL_LIGHT1, GL_DIFFUSE, Vector4f(1,0.5,0.5,1).data());
245  glLightfv(GL_LIGHT1, GL_SPECULAR, Vector4f(1,1,1,1).data());
246  glLightfv(GL_LIGHT1, GL_POSITION, Vector4f(-sqrt3,sqrt3,-sqrt3,0).data());
247 
248  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Vector4f(0.7, 0.7, 0.7, 1).data());
249  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Vector4f(0.8, 0.75, 0.6, 1).data());
250  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Vector4f(1, 1, 1, 1).data());
251  glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64);
252 
253  glEnable(GL_LIGHTING);
254  glEnable(GL_LIGHT0);
255  glEnable(GL_LIGHT1);
256 
257  sFancySpheres.draw();
258  glVertexPointer(3, GL_FLOAT, 0, mVertices[0].data());
259  glNormalPointer(GL_FLOAT, 0, mNormals[0].data());
260  glEnableClientState(GL_VERTEX_ARRAY);
261  glEnableClientState(GL_NORMAL_ARRAY);
262  glDrawArrays(GL_TRIANGLES, 0, mVertices.size());
263  glDisableClientState(GL_VERTEX_ARRAY);
264  glDisableClientState(GL_NORMAL_ARRAY);
265 
266  glDisable(GL_LIGHTING);
267 }
268 
270 {
271  m_alpha += double(m_timer.interval()) * 1e-3;
272 
273  TimeLine::const_iterator hi = m_timeline.upper_bound(m_alpha);
274  TimeLine::const_iterator lo = hi;
275  --lo;
276 
277  Frame currentFrame;
278 
279  if(hi==m_timeline.end())
280  {
281  // end
282  currentFrame = lo->second;
283  stopAnimation();
284  }
285  else if(hi==m_timeline.begin())
286  {
287  // start
288  currentFrame = hi->second;
289  }
290  else
291  {
292  float s = (m_alpha - lo->first)/(hi->first - lo->first);
293  if (mLerpMode==LerpEulerAngles)
294  currentFrame = ::lerpFrame<EulerAngles<float> >(s, lo->second, hi->second);
295  else if (mLerpMode==LerpQuaternion)
296  currentFrame = ::lerpFrame<Eigen::Quaternionf>(s, lo->second, hi->second);
297  else
298  {
299  std::cerr << "Invalid rotation interpolation mode (abort)\n";
300  exit(2);
301  }
302  currentFrame.orientation.coeffs().normalize();
303  }
304 
305  currentFrame.orientation = currentFrame.orientation.inverse();
306  currentFrame.position = - (currentFrame.orientation * currentFrame.position);
307  mCamera.setFrame(currentFrame);
308 
309  updateGL();
310 }
311 
313 {
314  switch(e->key())
315  {
316  case Qt::Key_Up:
317  mCamera.zoom(2);
318  break;
319  case Qt::Key_Down:
320  mCamera.zoom(-2);
321  break;
322  // add a frame
323  case Qt::Key_G:
324  grabFrame();
325  break;
326  // clear the time line
327  case Qt::Key_C:
328  m_timeline.clear();
329  break;
330  // move the camera to initial pos
331  case Qt::Key_R:
332  resetCamera();
333  break;
334  // start/stop the animation
335  case Qt::Key_A:
336  if (mAnimate)
337  {
338  stopAnimation();
339  }
340  else
341  {
342  m_alpha = 0;
343  connect(&m_timer, SIGNAL(timeout()), this, SLOT(animate()));
344  m_timer.start(1000/30);
345  mAnimate = true;
346  }
347  break;
348  default:
349  break;
350  }
351 
352  updateGL();
353 }
354 
356 {
357  disconnect(&m_timer, SIGNAL(timeout()), this, SLOT(animate()));
358  m_timer.stop();
359  mAnimate = false;
360  m_alpha = 0;
361 }
362 
364 {
365  mMouseCoords = Vector2i(e->pos().x(), e->pos().y());
366  bool fly = (mNavMode==NavFly) || (e->modifiers()&Qt::ControlModifier);
367  switch(e->button())
368  {
369  case Qt::LeftButton:
370  if(fly)
371  {
372  mCurrentTrackingMode = TM_LOCAL_ROTATE;
373  mTrackball.start(Trackball::Local);
374  }
375  else
376  {
377  mCurrentTrackingMode = TM_ROTATE_AROUND;
378  mTrackball.start(Trackball::Around);
379  }
380  mTrackball.track(mMouseCoords);
381  break;
382  case Qt::MidButton:
383  if(fly)
384  mCurrentTrackingMode = TM_FLY_Z;
385  else
386  mCurrentTrackingMode = TM_ZOOM;
387  break;
388  case Qt::RightButton:
389  mCurrentTrackingMode = TM_FLY_PAN;
390  break;
391  default:
392  break;
393  }
394 }
396 {
397  mCurrentTrackingMode = TM_NO_TRACK;
398  updateGL();
399 }
400 
402 {
403  // tracking
404  if(mCurrentTrackingMode != TM_NO_TRACK)
405  {
406  float dx = float(e->x() - mMouseCoords.x()) / float(mCamera.vpWidth());
407  float dy = - float(e->y() - mMouseCoords.y()) / float(mCamera.vpHeight());
408 
409  // speedup the transformations
410  if(e->modifiers() & Qt::ShiftModifier)
411  {
412  dx *= 10.;
413  dy *= 10.;
414  }
415 
416  switch(mCurrentTrackingMode)
417  {
418  case TM_ROTATE_AROUND:
419  case TM_LOCAL_ROTATE:
420  if (mRotationMode==RotationStable)
421  {
422  // use the stable trackball implementation mapping
423  // the 2D coordinates to 3D points on a sphere.
424  mTrackball.track(Vector2i(e->pos().x(), e->pos().y()));
425  }
426  else
427  {
428  // standard approach mapping the x and y displacements as rotations
429  // around the camera's X and Y axes.
430  Quaternionf q = AngleAxisf( dx*M_PI, Vector3f::UnitY())
431  * AngleAxisf(-dy*M_PI, Vector3f::UnitX());
432  if (mCurrentTrackingMode==TM_LOCAL_ROTATE)
433  mCamera.localRotate(q);
434  else
435  mCamera.rotateAroundTarget(q);
436  }
437  break;
438  case TM_ZOOM :
439  mCamera.zoom(dy*100);
440  break;
441  case TM_FLY_Z :
442  mCamera.localTranslate(Vector3f(0, 0, -dy*200));
443  break;
444  case TM_FLY_PAN :
445  mCamera.localTranslate(Vector3f(dx*200, dy*200, 0));
446  break;
447  default:
448  break;
449  }
450 
451  updateGL();
452  }
453 
454  mMouseCoords = Vector2i(e->pos().x(), e->pos().y());
455 }
456 
458 {
459  glEnable(GL_DEPTH_TEST);
460  glDisable(GL_CULL_FACE);
461  glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
462  glDisable(GL_COLOR_MATERIAL);
463  glDisable(GL_BLEND);
464  glDisable(GL_ALPHA_TEST);
465  glDisable(GL_TEXTURE_1D);
466  glDisable(GL_TEXTURE_2D);
467  glDisable(GL_TEXTURE_3D);
468 
469  // Clear buffers
470  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
471 
472  mCamera.activateGL();
473 
474  drawScene();
475 }
476 
478 {
479  glClearColor(1., 1., 1., 0.);
480  glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
481  glDepthMask(GL_TRUE);
482  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
483 
484  mCamera.setPosition(Vector3f(-200, -200, -200));
485  mCamera.setTarget(Vector3f(0, 0, 0));
486  mInitFrame.orientation = mCamera.orientation().inverse();
487  mInitFrame.position = mCamera.viewMatrix().translation();
488 }
489 
490 void RenderingWidget::resizeGL(int width, int height)
491 {
492  mCamera.setViewport(width,height);
493 }
494 
496 {
497  mNavMode = NavMode(m);
498 }
499 
501 {
502  mLerpMode = LerpMode(m);
503 }
504 
506 {
507  mRotationMode = RotationMode(m);
508 }
509 
511 {
512  if (mAnimate)
513  stopAnimation();
514  m_timeline.clear();
515  Frame aux0 = mCamera.frame();
516  aux0.orientation = aux0.orientation.inverse();
517  aux0.position = mCamera.viewMatrix().translation();
518  m_timeline[0] = aux0;
519 
520  Vector3f currentTarget = mCamera.target();
521  mCamera.setTarget(Vector3f::Zero());
522 
523  // compute the rotation duration to move the camera to the target
524  Frame aux1 = mCamera.frame();
525  aux1.orientation = aux1.orientation.inverse();
526  aux1.position = mCamera.viewMatrix().translation();
527  float duration = aux0.orientation.angularDistance(aux1.orientation) * 0.9;
528  if (duration<0.1) duration = 0.1;
529 
530  // put the camera at that time step:
531  aux1 = aux0.lerp(duration/2,mInitFrame);
532  // and make it look at the target again
533  aux1.orientation = aux1.orientation.inverse();
534  aux1.position = - (aux1.orientation * aux1.position);
535  mCamera.setFrame(aux1);
536  mCamera.setTarget(Vector3f::Zero());
537 
538  // add this camera keyframe
539  aux1.orientation = aux1.orientation.inverse();
540  aux1.position = mCamera.viewMatrix().translation();
541  m_timeline[duration] = aux1;
542 
543  m_timeline[2] = mInitFrame;
544  m_alpha = 0;
545  animate();
546  connect(&m_timer, SIGNAL(timeout()), this, SLOT(animate()));
547  m_timer.start(1000/30);
548  mAnimate = true;
549 }
550 
552 {
553  QWidget* panel = new QWidget();
554  QVBoxLayout* layout = new QVBoxLayout();
555 
556  {
557  QPushButton* but = new QPushButton("reset");
558  but->setToolTip("move the camera to initial position (with animation)");
559  layout->addWidget(but);
560  connect(but, SIGNAL(clicked()), this, SLOT(resetCamera()));
561  }
562  {
563  // navigation mode
564  QGroupBox* box = new QGroupBox("navigation mode");
565  QVBoxLayout* boxLayout = new QVBoxLayout;
566  QButtonGroup* group = new QButtonGroup(panel);
567  QRadioButton* but;
568  but = new QRadioButton("turn around");
569  but->setToolTip("look around an object");
570  group->addButton(but, NavTurnAround);
571  boxLayout->addWidget(but);
572  but = new QRadioButton("fly");
573  but->setToolTip("free navigation like a spaceship\n(this mode can also be enabled pressing the \"shift\" key)");
574  group->addButton(but, NavFly);
575  boxLayout->addWidget(but);
576  group->button(mNavMode)->setChecked(true);
577  connect(group, SIGNAL(buttonClicked(int)), this, SLOT(setNavMode(int)));
578  box->setLayout(boxLayout);
579  layout->addWidget(box);
580  }
581  {
582  // track ball, rotation mode
583  QGroupBox* box = new QGroupBox("rotation mode");
584  QVBoxLayout* boxLayout = new QVBoxLayout;
585  QButtonGroup* group = new QButtonGroup(panel);
586  QRadioButton* but;
587  but = new QRadioButton("stable trackball");
588  group->addButton(but, RotationStable);
589  boxLayout->addWidget(but);
590  but->setToolTip("use the stable trackball implementation mapping\nthe 2D coordinates to 3D points on a sphere");
591  but = new QRadioButton("standard rotation");
592  group->addButton(but, RotationStandard);
593  boxLayout->addWidget(but);
594  but->setToolTip("standard approach mapping the x and y displacements\nas rotations around the camera's X and Y axes");
595  group->button(mRotationMode)->setChecked(true);
596  connect(group, SIGNAL(buttonClicked(int)), this, SLOT(setRotationMode(int)));
597  box->setLayout(boxLayout);
598  layout->addWidget(box);
599  }
600  {
601  // interpolation mode
602  QGroupBox* box = new QGroupBox("spherical interpolation");
603  QVBoxLayout* boxLayout = new QVBoxLayout;
604  QButtonGroup* group = new QButtonGroup(panel);
605  QRadioButton* but;
606  but = new QRadioButton("quaternion slerp");
607  group->addButton(but, LerpQuaternion);
608  boxLayout->addWidget(but);
609  but->setToolTip("use quaternion spherical interpolation\nto interpolate orientations");
610  but = new QRadioButton("euler angles");
611  group->addButton(but, LerpEulerAngles);
612  boxLayout->addWidget(but);
613  but->setToolTip("use Euler angles to interpolate orientations");
614  group->button(mNavMode)->setChecked(true);
615  connect(group, SIGNAL(buttonClicked(int)), this, SLOT(setLerpMode(int)));
616  box->setLayout(boxLayout);
617  layout->addWidget(box);
618  }
619  layout->addItem(new QSpacerItem(0,0,QSizePolicy::Minimum,QSizePolicy::Expanding));
620  panel->setLayout(layout);
621  return panel;
622 }
623 
625 {
626  mRenderingWidget = new RenderingWidget();
627  setCentralWidget(mRenderingWidget);
628 
629  QDockWidget* panel = new QDockWidget("navigation", this);
630  panel->setAllowedAreas((QFlags<Qt::DockWidgetArea>)(Qt::RightDockWidgetArea | Qt::LeftDockWidgetArea));
631  addDockWidget(Qt::RightDockWidgetArea, panel);
632  panel->setWidget(mRenderingWidget->createNavigationControlWidget());
633 }
634 
635 int main(int argc, char *argv[])
636 {
637  std::cout << "Navigation:\n";
638  std::cout << " left button: rotate around the target\n";
639  std::cout << " middle button: zoom\n";
640  std::cout << " left button + ctrl quake rotate (rotate around camera position)\n";
641  std::cout << " middle button + ctrl walk (progress along camera's z direction)\n";
642  std::cout << " left button: pan (translate in the XY camera's plane)\n\n";
643  std::cout << "R : move the camera to initial position\n";
644  std::cout << "A : start/stop animation\n";
645  std::cout << "C : clear the animation\n";
646  std::cout << "G : add a key frame\n";
647 
648  QApplication app(argc, argv);
649  QuaternionDemo demo;
650  demo.resize(600,500);
651  demo.show();
652  return app.exec();
653 }
654 
655 #include "quaternion_demo.moc"
656 
Point2 a1
Definition: testPose2.cpp:769
Matrix3f m
EIGEN_DEVICE_FUNC Coefficients & coeffs()
virtual void mouseMoveEvent(QMouseEvent *e)
Scalar * b
Definition: benchVecAdd.cpp:17
EIGEN_MAKE_ALIGNED_OPERATOR_NEW FancySpheres()
T lerp(float t, const T &a, const T &b)
virtual void drawScene(void)
GpuHelper gpu
Definition: gpuhelper.cpp:18
Frame lerp(float alpha, const Frame &other) const
Definition: camera.h:26
IcoSphere mIcoSphere
Matrix< Scalar, 3, 3 > Matrix3
Scalar Scalar * c
Definition: benchVecAdd.cpp:17
#define M_PI
Definition: main.h:106
Vector3 & coeffs()
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW
Definition: Memory.h:841
virtual void mousePressEvent(QMouseEvent *e)
Vector4f Color
Definition: gpuhelper.h:19
virtual void grabFrame(void)
QWidget * createNavigationControlWidget()
void popMatrix(GLenum matrixTarget)
Definition: gpuhelper.h:185
virtual void keyPressEvent(QKeyEvent *e)
void pushMatrix(const Matrix< Scalar, 4, 4, _Flags, 4, 4 > &mat, GLenum matrixTarget)
Definition: gpuhelper.h:170
void drawVector(const Vector3f &position, const Vector3f &vec, const Color &color, float aspect=50.)
Definition: gpuhelper.cpp:56
virtual void mouseReleaseEvent(QMouseEvent *e)
Translation< float, 3 > Translation3f
Definition: Translation.h:170
Quaternion< Scalar > QuaternionType
EulerAngles & operator=(const QuaternionType &q)
UniformScaling< float > Scaling(float s)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index rowId, Index colId)
virtual void resetCamera()
EIGEN_DEVICE_FUNC Derived & setFromTwoVectors(const MatrixBase< Derived1 > &a, const MatrixBase< Derived2 > &b)
cout<< "Here is the matrix m:"<< endl<< m<< endl;Matrix< ptrdiff_t, 3, 1 > res
EIGEN_DEVICE_FUNC const MatrixType & matrix() const
Definition: Transform.h:389
static const Line3 l(Rot3(), 1, 1)
virtual void setNavMode(int)
EulerAngles(const QuaternionType &q)
static EIGEN_DEVICE_FUNC Matrix< Scalar, 2, 2 > toRotationMatrix(const Scalar &s)
Definition: RotationBase.h:182
virtual void stopAnimation()
Eigen::Quaternionf orientation
Definition: camera.h:32
virtual void setRotationMode(int)
virtual void initializeGL()
std::vector< float > mRadii
virtual void setLerpMode(int)
AngleAxis< float > AngleAxisf
Definition: AngleAxis.h:157
int data[]
EIGEN_DEVICE_FUNC Quaternion< Scalar > inverse() const
RealScalar alpha
virtual void animate(void)
Array< double, 1, 3 > e(1./3., 0.5, 2.)
RealScalar s
Represents a rotation in a 3 dimensional space as three Euler angles.
EIGEN_DEVICE_FUNC const Scalar & q
static Frame lerpFrame(float alpha, const Frame &a, const Frame &b)
AnnoyingScalar atan2(const AnnoyingScalar &y, const AnnoyingScalar &x)
EIGEN_MAKE_ALIGNED_OPERATOR_NEW RenderingWidget()
int main(int argc, char *argv[])
Point2 a2
Definition: testPose2.cpp:770
virtual void paintGL()
The quaternion class used to represent 3D orientations and rotations.
static EIGEN_DEPRECATED const end_t end
Definition: camera.h:17
EulerAngles & operator=(const Matrix3 &m)
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy y set format x g set format y g set format x2 g set format y2 g set format z g set angles radians set nogrid set key title set key left top Right noreverse box linetype linewidth samplen spacing width set nolabel set noarrow set nologscale set logscale x set set pointsize set encoding default set nopolar set noparametric set set set set surface set nocontour set clabel set mapping cartesian set nohidden3d set cntrparam order set cntrparam linear set cntrparam levels auto set cntrparam points set size set set xzeroaxis lt lw set x2zeroaxis lt lw set yzeroaxis lt lw set y2zeroaxis lt lw set tics in set ticslevel set tics scale
EIGEN_DEVICE_FUNC Scalar angularDistance(const QuaternionBase< OtherDerived > &other) const
Matrix3 toRotationMatrix(void) const
Jet< T, N > sqrt(const Jet< T, N > &f)
Definition: jet.h:418
std::vector< Vector3f > mCenters
EIGEN_DEVICE_FUNC Matrix3 toRotationMatrix() const
EulerAngles(Scalar a0, Scalar a1, Scalar a2)
The matrix class, also used for vectors and row-vectors.
const Vector3 & coeffs() const
void multMatrix(const Matrix< Scalar, 4, 4, _Flags, 4, 4 > &mat, GLenum matrixTarget)
Definition: gpuhelper.h:141
EIGEN_DEVICE_FUNC const AsinReturnType asin() const
Represents an homogeneous transformation in a N dimensional space.
std::ptrdiff_t j
Matrix< Scalar, 3, 1 > Vector3
Eigen::Vector3f position
Definition: camera.h:33
Point2 t(10, 10)
EIGEN_DEVICE_FUNC Quaternion< Scalar > slerp(const Scalar &t, const QuaternionBase< OtherDerived > &other) const
virtual void resizeGL(int width, int height)


gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:35:29