CDisplayWindow3D.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
#ifndef CDisplayWindow3D_H
#define CDisplayWindow3D_H
 
#include <mrpt/gui/CBaseGUIWindow.h>
#include <mrpt/opengl/COpenGLScene.h>
#include <mrpt/opengl/opengl_fonts.h>
#include <mrpt/img/CImage.h>
#include <mrpt/system/datetime.h>
 
#include <mutex>
 
namespace mrpt::gui
{
class C3DWindowDialog;
class CMyGLCanvas_DisplayWindow3D;
 
/** A graphical user interface (GUI) for efficiently rendering 3D scenes in
 * real-time.
  *  This class always contains internally an instance of opengl::COpenGLScene,
 * which
  *   the objects, viewports, etc. to be rendered.
  *
  *  Images can be grabbed automatically to disk for easy creation of videos.
  *  See CDisplayWindow3D::grabImagesStart  (and for creating videos,
 * mrpt::vision::CVideoFileWriter).
  *
  *  A short-cut for displaying 2D images (using the OpenGL rendering hardware)
 * is available
  *  through \a setImageView() and \a setImageView_fast(). Internally, these
 * methods call methods
  *  in the "main" viewport of the window (see \a COpenGLViewport).
  *
  *  Since the 3D rendering is performed in a detached thread, especial care
 * must be taken
  *   when updating the 3D scene to be rendered. The process involves an
 * internal critical section
  *   and it must always consist of these steps:
  *
  * \code
  *   mrpt::gui::CDisplayWindow3D   win("My window");
  *
  *   // Adquire the scene:
  *   mrpt::opengl::COpenGLScene::Ptr &ptrScene = win.get3DSceneAndLock();
  *
  *   // Modify the scene:
  *   ptrScene->...
  *   // or replace by another scene:
  *   ptrScene = otherScene;
  *
  *   // Unlock it, so the window can use it for redraw:
  *   win.unlockAccess3DScene();
  *
  *   // Update window, if required
  *   win.forceRepaint();
  * \endcode
  *
  * An alternative way of updating the scene is by creating, before locking the
 * 3D window, a new object
  *  of class COpenGLScene, then locking the window only for replacing the smart
 * pointer. This may be
  *  advantageous is generating the 3D scene takes a long time, since while the
 * window
  *  is locked it will not be responsive to the user input or window redraw.
  *
  * It is safer against exceptions to use the auxiliary class
 * CDisplayWindow3DLocker.
  * \code
  *   mrpt::gui::CDisplayWindow3D   win("My window");
  *   // ...
  *   { // The scene is adquired in this scope
  *      mrpt::opengl::COpenGLScene::Ptr ptrScene;
  *      mrpt::gui::CDisplayWindow3DLocker  locker(win,ptrScene);
  *      //...
  *
  *   } // scene is unlocked upon dtor of `locker`
  * \endcode
  *
  * Notice however that a copy of the smart pointer is made, so replacement of
 * the entire scene
  * via `operator =` is not possible if using this method. Still, in general it
 * should be preferred because
  * the mutexes are automatically released in case of unexpected exceptions.
  *
  * The window can also display a set of 2D text messages overlapped to the 3D
 * scene.
  *  See CDisplayWindow3D::addTextMessage
  *
  *  For a list of supported events with the observer/observable pattern, see
 * the discussion in mrpt::gui::CBaseGUIWindow.
  *  In addition to those events, this class introduces
 * mrpt::gui::mrptEvent3DWindowGrabImageFile
  *
  * ** CDisplayWindow3D mouse view navigation cheatsheet **
  *  - <b>Orbit camera</b>: Left-button pressed + move
  *  - <b>Zoom in / out</b>:
  *    - Mouse scroll wheel, or
  *    - SHIFT+Left-button pressed + move up/down
  *  - <b>Look around (pivot camera)</b>: CTRL+Left-button pressed + move
 * up/down
  *  - <b>Pan (XY plane)</b>: Right-button pressed + move
  *  - <b>Move camera along Z axis</b>: SHIFT+Left-button pressed + move
 * left/right
  *
  * \sa  The example /samples/display3D, the <a
 * href="http://www.mrpt.org/Tutorial_3D_Scenes" > tutorial only</a>.
  * \ingroup mrpt_gui_grp
  */
class CDisplayWindow3D : public mrpt::gui::CBaseGUIWindow
{
   public:
    using Ptr = std::shared_ptr<CDisplayWindow3D>;
    using ConstPtr = std::shared_ptr<const CDisplayWindow3D>;
 
   protected:
    friend class C3DWindowDialog;
    friend class CMyGLCanvas_DisplayWindow3D;
 
    /** Internal OpenGL object (see general discussion in about usage of this
     * object) */
    mrpt::opengl::COpenGLScene::Ptr m_3Dscene;
    /** Critical section for accesing m_3Dscene */
    mutable std::recursive_mutex m_csAccess3DScene;
 
    /** Throws an exception on initialization error */
    void createOpenGLContext();
 
    mrpt::void_ptr_noncopy m_DisplayDeviceContext;
    mrpt::void_ptr_noncopy m_GLRenderingContext;
 
    std::string m_grab_imgs_prefix;
    unsigned int m_grab_imgs_idx;
 
    bool m_is_capturing_imgs;
    mrpt::img::CImage::Ptr m_last_captured_img;
    mutable std::mutex m_last_captured_img_cs;
 
    void doRender();
 
    mrpt::system::TTimeStamp m_lastFullScreen;
 
    /** \sa getRenderingFPS */
    double m_last_FPS;
 
    void internalSetMinMaxRange();
 
   public:
    /** Constructor */
    CDisplayWindow3D(
        const std::string& windowCaption = std::string(),
        unsigned int initialWindowWidth = 400,
        unsigned int initialWindowHeight = 300);
 
    /** Class factory returning a smart pointer */
    static CDisplayWindow3D::Ptr Create(
        const std::string& windowCaption, unsigned int initialWindowWidth = 400,
        unsigned int initialWindowHeight = 300);
 
    /** Destructor */
    virtual ~CDisplayWindow3D();
 
    /** Gets a reference to the smart shared pointer that holds the internal
     * scene (carefuly read introduction in gui::CDisplayWindow3D before use!)
      *  This also locks the critical section for accesing the scene, thus the
     * window will not be repainted until it is unlocked.
      * \note It is safer to use mrpt::gui::CDisplayWindow3DLocker instead.*/
    mrpt::opengl::COpenGLScene::Ptr& get3DSceneAndLock();
 
    /** Unlocks the access to the internal 3D scene. It is safer to use
     * mrpt::gui::CDisplayWindow3DLocker instead.
      *  Typically user will want to call forceRepaint after updating the scene.
     */
    void unlockAccess3DScene();
 
    /** Repaints the window. forceRepaint, repaint and updateWindow are all
     * aliases of the same method */
    void forceRepaint();
    /** Repaints the window. forceRepaint, repaint and updateWindow are all
     * aliases of the same method */
    void repaint() { forceRepaint(); }
    /** Repaints the window. forceRepaint, repaint and updateWindow are all
     * aliases of the same method */
    void updateWindow() { forceRepaint(); }
    /** Return the camera field of view (in degrees) (used for gluPerspective)
     */
    float getFOV() const;
    /** Changes the camera min clip range (z) (used for gluPerspective). The
     * window is not updated with this method, call "forceRepaint" to update the
     * 3D view. */
    void setMinRange(double new_min);
    /** Changes the camera max clip range (z) (used for gluPerspective. The
     * window is not updated with this method, call "forceRepaint" to update the
     * 3D view. */
    void setMaxRange(double new_max);
    /** Changes the camera field of view (in degrees) (used for gluPerspective).
     * The window is not updated with this method, call "forceRepaint" to update
     * the 3D view. */
    void setFOV(float v);
    /** Resizes the window, stretching the image to fit into the display area.
     */
    void resize(unsigned int width, unsigned int height) override;
    /** Changes the position of the window on the screen. */
    void setPos(int x, int y) override;
    /**  Changes the window title. */
    void setWindowTitle(const std::string& str) override;
    /** Changes the camera parameters programmatically */
    void setCameraElevationDeg(float deg);
    /** Changes the camera parameters programmatically */
    void setCameraAzimuthDeg(float deg);
    /** Changes the camera parameters programmatically */
    void setCameraPointingToPoint(float x, float y, float z);
    /** Changes the camera parameters programmatically */
    void setCameraZoom(float zoom);
    /** Sets the camera as projective, or orthogonal. */
    void setCameraProjective(bool isProjective);
    /** Get camera parameters programmatically */
    float getCameraElevationDeg() const;
    /** Get camera parameters programmatically */
    float getCameraAzimuthDeg() const;
    /** Get camera parameters programmatically */
    void getCameraPointingToPoint(float& x, float& y, float& z) const;
    /** Get camera parameters programmatically */
    float getCameraZoom() const;
    /** Sets the camera as projective, or orthogonal */
    bool isCameraProjective() const;
    /** If set to true (default = false), the mouse-based scene navigation will
     * be disabled and the camera position will be determined by the opengl
     * viewports in the 3D scene */
    void useCameraFromScene(bool useIt = true);
    /** Gets the 3D ray for the direction line of the pixel where the mouse
     * cursor is at. \return False if the window is closed. \sa
     * getLastMousePosition */
    bool getLastMousePositionRay(mrpt::math::TLine3D& ray) const;
    /** Gets the last x,y pixel coordinates of the mouse. \return False if the
     * window is closed. \sa getLastMousePositionRay */
    virtual bool getLastMousePosition(int& x, int& y) const override;
    /** Set cursor style to default (cursorIsCross=false) or to a cross
     * (cursorIsCross=true) \sa getLastMousePositionRay */
    virtual void setCursorCross(bool cursorIsCross) override;
 
    /** Start to save rendered images to disk.
      *  Images will be saved independently as png files, depending on
      *   the template path passed to this method. For example:
      *
      *  path_prefix: "./video_"
      *
      *  Will generate "./video_000001.png", etc.
      *
      *  If this feature is enabled, the window will emit events of the type
     * mrpt::gui::mrptEvent3DWindowGrabImageFile() which you can subscribe to.
      *
      *  \sa grabImagesStop
      */
    void grabImagesStart(
        const std::string& grab_imgs_prefix = std::string("video_"));
 
    /** Stops image grabbing started by grabImagesStart
      * \sa grabImagesStart
      */
    void grabImagesStop();
 
    /** Enables the grabbing of CImage objects from screenshots of the window.
      *  \sa getLastWindowImage
      */
    void captureImagesStart();
 
    /** Stop image grabbing
      * \sa captureImagesStart
      */
    void captureImagesStop();
 
    /** Retrieve the last captured image from the window.
      *  You MUST CALL FIRST captureImagesStart to enable image grabbing.
      * \return false if there was no time yet for grabbing any image (then, the
     * output image is undefined).
      * \sa captureImagesStart, getLastWindowImagePtr
      */
    bool getLastWindowImage(mrpt::img::CImage& out_img) const;
 
    /** Retrieve the last captured image from the window, as a smart pointer.
      *  This method is more efficient than getLastWindowImage since only a copy
     * of the pointer is performed, while
      *   getLastWindowImage would copy the entire image.
      *
      *  You MUST CALL FIRST captureImagesStart to enable image grabbing.
      * \Note If there was no time yet for grabbing any image, an empty smart
     * pointer will be returned.
      * \sa captureImagesStart, getLastWindowImage
      */
    mrpt::img::CImage::Ptr getLastWindowImagePtr() const;
 
    /** Increments by one the image counter and return the next image file name
     * (Users normally don't want to call this method).
      * \sa grabImagesStart
      */
    std::string grabImageGetNextFile();
 
    bool isCapturingImgs() const { return m_is_capturing_imgs; }
    /** Add 2D text messages overlapped to the 3D rendered scene. The string
     * will remain displayed in the 3D window
      *   until it's changed with subsequent calls to this same method, or all
     * the texts are cleared with clearTextMessages().
      *
      *  \param x The X position, interpreted as absolute pixels from the left
     * if X>=1, absolute pixels from the left if X<0 or as a width factor if in
     * the range [0,1[.
      *  \param y The Y position, interpreted as absolute pixels from the bottom
     * if Y>=1, absolute pixels from the top if Y<0 or as a height factor if in
     * the range [0,1[.
      *  \param text The text string to display.
      *  \param color The text color. For example: TColorf(1.0,1.0,1.0)
      *  \param unique_index An "index" for this text message, so that
     * subsequent calls with the same index will overwrite this text message
     * instead of creating new ones.
      *
      *  You'll need to refresh the display manually with forceRepaint().
      *
      * \sa clearTextMessages
      */
    void addTextMessage(
        const double x, const double y, const std::string& text,
        const mrpt::img::TColorf& color = mrpt::img::TColorf(1.0, 1.0, 1.0),
        const size_t unique_index = 0,
        const mrpt::opengl::TOpenGLFont font =
            mrpt::opengl::MRPT_GLUT_BITMAP_TIMES_ROMAN_24);
 
    /** overload with more font parameters - refer to
     * mrpt::opengl::gl_utils::glDrawText()
     *  Available fonts are enumerated at mrpt::opengl::gl_utils::glSetFont() */
    void addTextMessage(
        const double x_frac, const double y_frac, const std::string& text,
        const mrpt::img::TColorf& color, const std::string& font_name,
        const double font_size,
        const mrpt::opengl::TOpenGLFontStyle font_style = mrpt::opengl::NICE,
        const size_t unique_index = 0, const double font_spacing = 1.5,
        const double font_kerning = 0.1, const bool draw_shadow = false,
        const mrpt::img::TColorf& shadow_color = mrpt::img::TColorf(0, 0, 0));
 
    /**  Clear all text messages created with addTextMessage().
      *  You'll need to refresh the display manually with forceRepaint().
      * \sa addTextMessage
      */
    void clearTextMessages();
 
    /** Get the average Frames Per Second (FPS) value from the last 250
     * rendering events */
    double getRenderingFPS() const { return m_last_FPS; }
    /** A short cut for getting the "main" viewport of the scene object, it is
     * equivalent to:
      *  \code
      *    mrpt::opengl::COpenGLScene::Ptr &scene = win3D.get3DSceneAndLock();
      *    viewport = scene->getViewport("main");
      *    win3D.unlockAccess3DScene();
      *  \endcode
      */
    mrpt::opengl::COpenGLViewport::Ptr getDefaultViewport();
 
    /** Set the "main" viewport into "image view"-mode, where an image is
     * efficiently drawn (fitting the viewport area) using an OpenGL textured
     * quad.
      *  Call this method with the new image to update the displayed image (but
     * recall to first lock the parent openglscene's critical section, then do
     * the update, then release the lock, and then issue a window repaint).
      *  Internally, the texture is drawn using a mrpt::opengl::CTexturedPlane
      *  The viewport can be reverted to behave like a normal viewport by
     * calling setNormalMode()
      * \sa setImageView_fast, COpenGLViewport
        * \note This method already locks/unlocks the 3D scene of the window, so
     * the user must NOT call get3DSceneAndLock() / unlockAccess3DScene()
     * before/after calling it.
      */
    void setImageView(const mrpt::img::CImage& img);
 
    /** Just like \a setImageView but moves the internal image memory instead of
     * making a copy, so it's faster but empties the input image.
      * \sa setImageView, COpenGLViewport
        * \note This method already locks/unlocks the 3D scene of the window, so
     * the user must NOT call get3DSceneAndLock() / unlockAccess3DScene()
     * before/after calling it.
      */
    void setImageView_fast(mrpt::img::CImage& img);
 
   protected:
    /** Set the rendering FPS (users don't call this, the method is for internal
     * MRPT objects only) \sa getRenderingFPS */
    void internal_setRenderingFPS(double FPS);
    /** called by CMyGLCanvas_DisplayWindow3D::OnPostRenderSwapBuffers */
    void internal_emitGrabImageEvent(const std::string& fil);
 
};  // End of class def.
 
/** @name Events specific to CDisplayWindow3D
    @{  */
 
/**  An event sent by a CDisplayWindow3D window when an image is saved after
 * enabling this feature with CDisplayWindow3D::grabImagesStart()
  *
  *  IMPORTANTE NOTICE: Event handlers in your observer class will be invoked
 * from the wxWidgets internal MRPT thread,
  *    so all your code in the handler must be thread safe.
  */
class mrptEvent3DWindowGrabImageFile : public mrpt::system::mrptEvent
{
   protected:
    /** Just to allow this class to be polymorphic */
    virtual void do_nothing() override {}
   public:
    inline mrptEvent3DWindowGrabImageFile(
        CDisplayWindow3D* obj, const std::string& _img_file)
        : source_object(obj), img_file(_img_file)
    {
    }
 
    CDisplayWindow3D* source_object;
    /** The absolute path of the file that has been just saved. */
    const std::string& img_file;
};  // End of class def.
 
/** @} */
 
/** Auxiliary class for safely claiming the 3DScene of a
 * mrpt::gui::CDisplayWindow3D.
  * The mutex will be hold between ctor and dtor calls of objects of this class,
 * safely releasing
  * the lock upon exceptions. See example usage code in docs of
 * mrpt::gui::CDisplayWindow3D
  *
  * \ingroup mrpt_gui_grp
  * \note New in MRPT 1.5.0
  */
class CDisplayWindow3DLocker
{
   public:
    /** Acquires the lock of the 3D scene of the referenced window, and returns
     * a copy of the smart pointer to it. */
    CDisplayWindow3DLocker(
        CDisplayWindow3D& win, mrpt::opengl::COpenGLScene::Ptr& out_scene_ptr);
    /** Acquires the lock of the 3D scene of the referenced window. Use this
     * signature when the scene object is not required. */
    CDisplayWindow3DLocker(CDisplayWindow3D& win);
    ~CDisplayWindow3DLocker();
 
   private:
    CDisplayWindow3D& m_win;
};
 
}
#endif