MRPT  1.9.9
CGlCanvasBase.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2020, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #include "gui-precomp.h" // Precompiled headers
11 
12 #include <mrpt/gui/CGlCanvasBase.h>
13 #include <mrpt/opengl/opengl_api.h>
14 #include <mrpt/system/CTicTac.h>
15 #include <cstdlib>
16 
17 #if MRPT_HAS_OPENGL_GLUT
18 #ifdef _WIN32
19 // Windows:
20 #include <windows.h>
21 #endif
22 
23 #ifdef __APPLE__
24 #include <GLUT/glut.h>
25 #include <OpenGL/gl.h>
26 #include <OpenGL/glu.h>
27 #else
28 #include <GL/gl.h>
29 #include <GL/glu.h>
30 #include <GL/glut.h>
31 #ifdef HAVE_FREEGLUT_EXT_H
32 #include <GL/freeglut_ext.h>
33 #endif
34 #endif
35 #endif // MRPT_HAS_OPENGL_GLUT
36 
37 using namespace mrpt;
38 using namespace mrpt::gui;
39 using namespace mrpt::opengl;
40 using namespace std;
42 
44 
46 
48 {
49  // Ensure all OpenGL resources are freed before the opengl context is gone:
50  if (m_openGLScene) m_openGLScene->unloadShaders();
51 }
52 
53 void CGlCanvasBase::setMinimumZoom(float zoom) { m_minZoom = zoom; }
54 void CGlCanvasBase::setMaximumZoom(float zoom) { m_maxZoom = zoom; }
55 void CGlCanvasBase::setMousePos(int x, int y)
56 {
57  m_mouseClickX = x;
58  m_mouseClickY = y;
59 }
60 
61 void CGlCanvasBase::setMouseClicked(bool is) { mouseClicked = is; }
62 void CGlCanvasBase::updateZoom(CamaraParams& params, int x, int y) const
63 {
64  float zoom = params.cameraZoomDistance * exp(0.01f * (y - m_mouseClickY));
65  if (zoom <= m_minZoom || (m_maxZoom != -1.0f && m_maxZoom <= zoom)) return;
66  params.cameraZoomDistance = zoom;
67  if (params.cameraZoomDistance < 0.01f) params.cameraZoomDistance = 0.01f;
68 
69  float Az = -0.05f * (x - m_mouseClickX);
70  float D = 0.001f * params.cameraZoomDistance;
71  params.cameraPointingZ += D * Az;
72 }
73 
75 {
76  float zoom = params.cameraZoomDistance * (1 - 0.03f * (delta / 120.0f));
77  if (zoom <= m_minZoom || (m_maxZoom != -1.0f && m_maxZoom <= zoom)) return;
78 
79  params.cameraZoomDistance = zoom;
80 }
81 
83 {
84  const float dis = max(0.01f, (params.cameraZoomDistance));
85  float eye_x =
86  params.cameraPointingX + dis * cos(DEG2RAD(params.cameraAzimuthDeg)) *
87  cos(DEG2RAD(params.cameraElevationDeg));
88  float eye_y =
89  params.cameraPointingY + dis * sin(DEG2RAD(params.cameraAzimuthDeg)) *
90  cos(DEG2RAD(params.cameraElevationDeg));
91  float eye_z =
92  params.cameraPointingZ + dis * sin(DEG2RAD(params.cameraElevationDeg));
93 
94  // Orbit camera:
95  float A_AzimuthDeg = -SENSIBILITY_DEG_PER_PIXEL * (x - m_mouseClickX);
96  params.cameraAzimuthDeg += A_AzimuthDeg;
97 
98  float A_ElevationDeg = SENSIBILITY_DEG_PER_PIXEL * (y - m_mouseClickY);
99  params.setElevationDeg(params.cameraElevationDeg + A_ElevationDeg);
100 
101  // Move cameraPointing pos:
102  params.cameraPointingX =
103  eye_x - dis * cos(DEG2RAD(params.cameraAzimuthDeg)) *
104  cos(DEG2RAD(params.cameraElevationDeg));
105  params.cameraPointingY =
106  eye_y - dis * sin(DEG2RAD(params.cameraAzimuthDeg)) *
107  cos(DEG2RAD(params.cameraElevationDeg));
108  params.cameraPointingZ =
109  eye_z - dis * sin(DEG2RAD(params.cameraElevationDeg));
110 }
111 
113 {
114  params.cameraAzimuthDeg -= 0.2f * (x - m_mouseClickX);
115  params.setElevationDeg(
116  params.cameraElevationDeg + 0.2f * (y - m_mouseClickY));
117 }
118 
120 {
121  m_mouseLastX = x;
122  m_mouseLastY = y;
123 }
124 
126 {
127 #if MRPT_HAS_OPENGL_GLUT
128  if (w == -1 || h == -1) return;
129 
130  glViewport(0, 0, (GLint)w, (GLint)h);
131 #endif
132 }
133 
135 {
136 #if MRPT_HAS_OPENGL_GLUT
137  glClearColor(clearColorR, clearColorG, clearColorB, clearColorA);
138 #endif
139 }
140 
141 void CGlCanvasBase::updatePan(CamaraParams& params, int x, int y) const
142 {
143  float Ay = -(x - m_mouseClickX);
144  float Ax = -(y - m_mouseClickY);
145  float D = 0.001f * params.cameraZoomDistance;
146  params.cameraPointingX += D * (Ax * cos(DEG2RAD(params.cameraAzimuthDeg)) -
147  Ay * sin(DEG2RAD(params.cameraAzimuthDeg)));
148  params.cameraPointingY += D * (Ax * sin(DEG2RAD(params.cameraAzimuthDeg)) +
149  Ay * cos(DEG2RAD(params.cameraAzimuthDeg)));
150 }
151 
153 {
154  return m_cameraParams;
155 }
156 
158 {
159  return m_cameraParams;
160 }
161 
163 {
164  m_cameraParams = params;
165 }
166 
168 {
169  return m_cameraParams.cameraZoomDistance;
170 }
171 
173 {
174  m_cameraParams.cameraZoomDistance = zoom;
175 }
176 
178 {
179  cam.setPointingAt(
180  m_cameraParams.cameraPointingX, m_cameraParams.cameraPointingY,
181  m_cameraParams.cameraPointingZ);
182  cam.setZoomDistance(m_cameraParams.cameraZoomDistance);
183  cam.setAzimuthDegrees(m_cameraParams.cameraAzimuthDeg);
184  cam.setElevationDegrees(m_cameraParams.cameraElevationDeg);
185  cam.setProjectiveModel(m_cameraParams.cameraIsProjective);
186  cam.setProjectiveFOVdeg(m_cameraParams.cameraFOV);
187 
188  return cam;
189 }
190 
191 void CGlCanvasBase::setUseCameraFromScene(bool is) { useCameraFromScene = is; }
192 bool CGlCanvasBase::getUseCameraFromScene() const { return useCameraFromScene; }
194 {
195  m_cameraParams.cameraAzimuthDeg = ang;
196 }
197 
199 {
200  m_cameraParams.cameraElevationDeg = ang;
201 }
202 
204 {
205  return m_cameraParams.cameraAzimuthDeg;
206 }
207 
209 {
210  return m_cameraParams.cameraElevationDeg;
211 }
212 
214 {
215  m_cameraParams.cameraIsProjective = is;
216 }
217 
219 {
220  return m_cameraParams.cameraIsProjective;
221 }
222 
223 void CGlCanvasBase::setCameraFOV(float FOV) { m_cameraParams.cameraFOV = FOV; }
224 float CGlCanvasBase::cameraFOV() const { return m_cameraParams.cameraFOV; }
225 void CGlCanvasBase::setClearColors(float r, float g, float b, float a)
226 {
227  clearColorR = r;
228  clearColorG = g;
229  clearColorB = b;
230  clearColorA = a;
231 }
232 
233 float CGlCanvasBase::getClearColorR() const { return clearColorR; }
234 float CGlCanvasBase::getClearColorG() const { return clearColorG; }
235 float CGlCanvasBase::getClearColorB() const { return clearColorB; }
236 float CGlCanvasBase::getClearColorA() const { return clearColorA; }
238 {
239  m_openGLScene = scene;
240 }
241 
242 void CGlCanvasBase::setCameraPointing(float pointX, float pointY, float pointZ)
243 {
244  m_cameraParams.cameraPointingX = pointX;
245  m_cameraParams.cameraPointingY = pointY;
246  m_cameraParams.cameraPointingZ = pointZ;
247 }
248 
250 {
251  return m_cameraParams.cameraPointingX;
252 }
253 
255 {
256  return m_cameraParams.cameraPointingY;
257 }
258 
260 {
261  return m_cameraParams.cameraPointingZ;
262 }
263 
264 double CGlCanvasBase::renderCanvas(int width, int height)
265 {
266 #if MRPT_HAS_OPENGL_GLUT
267  CTicTac tictac;
268  double At = 0.1;
269 
270  try
271  {
272  // Call PreRender user code:
273  preRender();
274  CHECK_OPENGL_ERROR();
275 
276  // Set static configs:
277  glEnable(GL_DEPTH_TEST);
278  CHECK_OPENGL_ERROR();
279 
280  // Set the viewport
281  resizeViewport((GLsizei)width, (GLsizei)height);
282 
283  // Set the background color:
284  clearColors();
285 
286  if (m_openGLScene)
287  {
288  // Set the camera params in the scene:
289  if (!useCameraFromScene)
290  {
291  COpenGLViewport::Ptr view = m_openGLScene->getViewport("main");
292  if (!view)
293  {
295  "Fatal error: there is no 'main' viewport in the 3D "
296  "scene!");
297  }
298 
299  mrpt::opengl::CCamera& cam = view->getCamera();
300  updateCameraParams(cam);
301  }
302 
303  tictac.Tic();
304 
305  // Draw primitives:
306  m_openGLScene->render();
307 
308  } // end if "m_openGLScene!=nullptr"
309 
310  postRender();
311 
312  // Flush & swap buffers to disply new image:
313  glFinish();
314  swapBuffers();
315  CHECK_OPENGL_ERROR();
316 
317  At = tictac.Tac();
318  }
319  catch (const std::exception& e)
320  {
321  const std::string err_msg =
322  std::string("[CGLCanvasBase::Render] Exception:\n") +
324  std::cerr << err_msg;
325  renderError(err_msg);
326  }
327 
328  return At;
329 #else
330  THROW_EXCEPTION("Cant render: MRPT was built without OpenGL");
331 #endif
332 }
333 
335 {
336  cameraElevationDeg = deg;
337 
338  if (cameraElevationDeg < -90.0f)
339  cameraElevationDeg = -90.0f;
340  else if (cameraElevationDeg > 90.0f)
341  cameraElevationDeg = 90.0f;
342 }
343 
344 void CGlCanvasBaseHeadless::renderError(const std::string& e)
345 {
346  std::cerr << "[CGlCanvasBaseHeadless::renderError] Error:" << e
347  << std::endl;
348 }
float getCameraPointingX() const
Returns the x pointing of the camera See also setCameraPointing(float, float, float) ...
double Tac() noexcept
Stops the stopwatch.
Definition: CTicTac.cpp:86
virtual void setCameraProjective(bool is)
void updateOrbitCamera(CamaraParams &params, int x, int y) const
This function for the mouse event It gets a reference to CamaraParams, x, y and updates the elevation...
#define THROW_EXCEPTION(msg)
Definition: exceptions.h:67
CamaraParams cameraParams() const
Returns a copy of CamaraParams See also getRefCameraParams(), setCameraParams(const CamaraParams &) ...
A high-performance stopwatch, with typical resolution of nanoseconds.
void setProjectiveModel(bool v=true)
Enable/Disable projective mode (vs.
Definition: CCamera.h:70
void setMaximumZoom(float zoom)
Sets the maximum of the zoom See also setMinimumZoom(float)
float getZoomDistance() const
Returns a zoom See also setZoomDistance(float)
mrpt::vision::TStereoCalibParams params
STL namespace.
virtual void setCameraParams(const CamaraParams &params)
Sets the CamaraParams See also cameraParams(), getRefCameraParams()
void resizeViewport(int w, int h)
Calls the glViewport function.
const CamaraParams & getRefCameraParams() const
Returns a reference to CamaraParams See also cameraParams(), setCameraParams(const CamaraParams &) ...
void setMousePos(int x, int y)
Saves the click position of the mouse See also setMouseClicked(bool)
virtual void setElevationDegrees(float ang)
Saves the degrees of the elevation camera See also getElevationDegrees()
void setZoomDistance(float z)
Definition: CCamera.h:63
mrpt::system::CTicTac CTicTac
Definition: utils/CTicTac.h:5
void setAzimuthDegrees(float ang)
Definition: CCamera.h:67
virtual void renderError(const std::string &e) override
void setOpenGLSceneRef(mrpt::opengl::COpenGLScene::Ptr scene)
virtual void setAzimuthDegrees(float ang)
Saves the degrees of the azimuth camera See also getAzimuthDegrees()
virtual double renderCanvas(int width=-1, int height=-1)
constexpr double DEG2RAD(const double x)
Degrees to radians.
virtual void setCameraPointing(float pointX, float pointY, float pointZ)
Saves the pointing of the camera See also getCameraPointingX(), getCameraPointingY(), getCameraPointingZ()
void clearColors()
Calls the glClearColor function See also setClearColors(float, float, float, float) ...
void setProjectiveFOVdeg(float ang)
Vertical field-of-View in degs, only when projectiveModel=true (default=30 deg).
Definition: CCamera.h:87
float getCameraPointingZ() const
Returns the z pointing of the camera See also setCameraPointing(float, float, float) ...
virtual void setCameraFOV(float FOV)
void setClearColors(float r, float g, float b, float a=1.0f)
Sets the RGBA colors for glClearColor See also clearColors(), getClearColorR(), getClearColorG(),getClearColorB(), getClearColorA()
virtual void setZoomDistance(float zoom)
Saves camera zooming See also getZoomDistance()
bool getUseCameraFromScene() const
See also void setUseCameraFromScene(bool)
float getAzimuthDegrees() const
Returns a azimuth degrees See also setAzimuthDegrees(float)
float getCameraPointingY() const
Returns the y pointing of the camera See also setCameraPointing(float, float, float) ...
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
void setElevationDegrees(float ang)
Definition: CCamera.h:68
void setMouseClicked(bool is)
Sets the property mouseClicked By default, this property is false.
void updateLastPos(int x, int y)
Sets the last mouse position.
float getElevationDegrees() const
Returns a elevation degrees See also setElevationDegrees(float)
void updateRotate(CamaraParams &params, int x, int y) const
This function for the mouse event It gets a reference to CamaraParams, x, y and updates the elevation...
void setMinimumZoom(float zoom)
Sets the minimum of the zoom See also setMaximumZoom(float)
The namespace for 3D scene representation and rendering.
Definition: CGlCanvasBase.h:13
std::string exception_to_str(const std::exception &e)
Builds a nice textual representation of a nested exception, which if generated using MRPT macros (THR...
Definition: exceptions.cpp:59
void setUseCameraFromScene(bool is)
If set to true (default=false), the cameraPointingX,...
Classes for creating GUI windows for 2D and 3D visualization.
Definition: about_box.h:14
void Tic() noexcept
Starts the stopwatch.
Definition: CTicTac.cpp:75
A camera: if added to a scene, the viewpoint defined by this camera will be used instead of the camer...
Definition: CCamera.h:33
static float SENSIBILITY_DEG_PER_PIXEL
void updatePan(CamaraParams &params, int x, int y) const
This function for the mouse event It gets a reference to CamaraParams, x, y and updates the pointing ...
mrpt::opengl::CCamera & updateCameraParams(mrpt::opengl::CCamera &cam) const
This function gets a reference to mrpt::opengl::CCamera and updates the camera parameters(pointing, zoom, azimuth, elevation, IsProjective, FOV)
void updateZoom(CamaraParams &params, int x, int y) const
This function for the mouse event It gets a reference to CamaraParams, x, y and updates the zoom of t...
void setPointingAt(float x, float y, float z)
Definition: CCamera.h:41



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: c7a3bec24 Sun Mar 29 18:33:13 2020 +0200 at dom mar 29 18:50:38 CEST 2020