Visualizer.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// Avoid warning caused by redefinition of APIENTRY macro
// defined also in glfw3.h
#ifdef _WIN32
#include <windows.h>
#endif
 
#include <GL/glew.h>  // Make sure glew.h is included before gl.h
#include <GLFW/glfw3.h>
 
#include <Eigen/Core>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
 
#include "visualization/shader/GeometryRenderer.h"
#include "visualization/utility/ColorMap.h"
#include "visualization/visualizer/RenderOption.h"
#include "visualization/visualizer/ViewControl.h"
 
class ccMesh;
class ccHObject;
namespace cloudViewer {
 
namespace geometry {
class Image;
}  // namespace geometry
 
namespace visualization {
 
class GLFWContext;
 
class Visualizer {
public:
    struct MouseControl {
    public:
        bool is_mouse_left_button_down = false;
        bool is_mouse_middle_button_down = false;
        bool is_control_key_down = false;
        bool is_shift_key_down = false;
        bool is_alt_key_down = false;
        bool is_super_key_down = false;
        double mouse_position_x = 0.0;
        double mouse_position_y = 0.0;
    };
 
public:
    Visualizer();
    virtual ~Visualizer();
    Visualizer(Visualizer &&) = delete;
    Visualizer(const Visualizer &) = delete;
    Visualizer &operator=(const Visualizer &) = delete;
 
public:
    bool CreateVisualizerWindow(const std::string &window_name = "CloudViewer",
                                const int width = 640,
                                const int height = 480,
                                const int left = 50,
                                const int top = 50,
                                const bool visible = true);
 
    void DestroyVisualizerWindow();
 
    void RegisterAnimationCallback(
            std::function<bool(Visualizer *)> callback_func);
 
    void Run();
 
    void Close();
 
    bool WaitEvents();
 
    bool PollEvents();
 
    virtual bool AddGeometry(std::shared_ptr<const ccHObject> geometry_ptr,
                             bool reset_bounding_box = true);
 
    virtual bool RemoveGeometry(std::shared_ptr<const ccHObject> geometry_ptr,
                                bool reset_bounding_box = true);
 
    virtual bool ClearGeometries();
 
    virtual bool UpdateGeometry(
            std::shared_ptr<const ccHObject> geometry_ptr = nullptr);
    virtual bool HasGeometry() const;
 
    virtual void UpdateRender();
 
    virtual void SetFullScreen(bool fullscreen);
    virtual void ToggleFullScreen();
    virtual bool IsFullScreen();
 
    virtual void PrintVisualizerHelp();
    virtual void UpdateWindowTitle();
    virtual void BuildUtilities();
 
    ViewControl &GetViewControl() { return *view_control_ptr_; }
    RenderOption &GetRenderOption() { return *render_option_ptr_; }
    std::shared_ptr<geometry::Image> CaptureScreenFloatBuffer(
            bool do_render = true);
    void CaptureScreenImage(const std::string &filename = "",
                            bool do_render = true);
    std::shared_ptr<geometry::Image> CaptureDepthFloatBuffer(
            bool do_render = true);
    void CaptureDepthImage(const std::string &filename = "",
                           bool do_render = true,
                           double depth_scale = 1000.0);
    void CaptureDepthPointCloud(const std::string &filename = "",
                                bool do_render = true,
                                bool convert_to_world_coordinate = false);
    void CaptureRenderOption(const std::string &filename = "");
    void ResetViewPoint(bool reset_bounding_box = false);
 
    const std::string &GetWindowName() const { return window_name_; }
 
protected:
    virtual bool InitOpenGL();
 
    virtual bool InitViewControl();
 
    virtual bool InitRenderOption();
 
    virtual void Render(bool render_screen = false);
 
    void CopyViewStatusToClipboard();
 
    void CopyViewStatusFromClipboard();
 
    // callback functions
    virtual void WindowRefreshCallback(GLFWwindow *window);
    virtual void WindowResizeCallback(GLFWwindow *window, int w, int h);
    virtual void MouseMoveCallback(GLFWwindow *window, double x, double y);
    virtual void MouseScrollCallback(GLFWwindow *window, double x, double y);
    virtual void MouseButtonCallback(GLFWwindow *window,
                                     int button,
                                     int action,
                                     int mods);
    virtual void KeyPressCallback(
            GLFWwindow *window, int key, int scancode, int action, int mods);
    virtual void WindowCloseCallback(GLFWwindow *window);
 
protected:
    // window
    GLFWwindow *window_ = nullptr;
    std::string window_name_ = "CloudViewer";
 
    std::shared_ptr<GLFWContext> glfw_context_ = nullptr;
 
    Eigen::Vector2i saved_window_size_ = Eigen::Vector2i::Zero();
    Eigen::Vector2i saved_window_pos_ = Eigen::Vector2i::Zero();
    std::function<bool(Visualizer *)> animation_callback_func_ = nullptr;
    // Auxiliary internal backup of the callback function.
    // It copies animation_callback_func_ in each PollEvent() or WaitEvent()
    // so that even if user calls RegisterAnimationCallback() within the
    // callback function it is still safe.
    std::function<bool(Visualizer *)> animation_callback_func_in_loop_ =
            nullptr;
 
    // control
    MouseControl mouse_control_;
    bool is_redraw_required_ = true;
    bool is_initialized_ = false;
    GLuint vao_id_ = 0;
 
    // render targets for "capture_screen_float_buffer" and
    // "capture_screen_image" in offscreen render mode
    GLuint render_fbo_ = 0;
    GLuint render_rgb_tex_ = 0;
    GLuint render_depth_stencil_rbo_ = 0;
 
    // view control
    std::unique_ptr<ViewControl> view_control_ptr_;
 
    // rendering properties
    std::unique_ptr<RenderOption> render_option_ptr_;
 
    // geometry to be rendered
    std::unordered_set<std::shared_ptr<const ccHObject>> geometry_ptrs_;
 
    // geometry renderers
    std::unordered_set<std::shared_ptr<glsl::GeometryRenderer>>
            geometry_renderer_ptrs_;
 
    // utilities owned by the Visualizer
    std::vector<std::shared_ptr<const ccHObject>> utility_ptrs_;
 
    // utility renderers
    std::vector<std::shared_ptr<glsl::GeometryRenderer>> utility_renderer_ptrs_;
    // map's key is the renderer for which the RenderOption applies
    // (should be something in utility_renderer_ptrs_)
    std::unordered_map<std::shared_ptr<glsl::GeometryRenderer>, RenderOption>
            utility_renderer_opts_;
 
    // coordinate frame
    std::shared_ptr<ccMesh> coordinate_frame_mesh_ptr_;
    std::shared_ptr<glsl::CoordinateFrameRenderer>
            coordinate_frame_mesh_renderer_ptr_;
 
#ifdef __APPLE__
    // MacBook with Retina display does not have a 1:1 mapping from screen
    // coordinates to pixels. Thus we hack it back.
    // http://www.glfw.org/faq.html#why-is-my-output-in-the-lower-left-corner-of-the-window
    double pixel_to_screen_coordinate_ = 1.0;
#endif  //__APPLE__
};
 
}  // namespace visualization
}  // namespace cloudViewer