ViewControl.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
// clang-format off
#include "visualization/utility/GLHelper.h" // must include first
// clang-format on
#include <ecvBBox.h>
#include <ecvHObject.h>
#include <ecvOrientedBBox.h>
 
#include "camera/PinholeCameraParameters.h"
#include "visualization/visualizer/ViewParameters.h"
 
namespace cloudViewer {
namespace visualization {
 
class ViewControl {
public:
    static const double FIELD_OF_VIEW_MAX;
    static const double FIELD_OF_VIEW_MIN;
    static const double FIELD_OF_VIEW_DEFAULT;
    static const double FIELD_OF_VIEW_STEP;
 
    static const double ZOOM_DEFAULT;
    static const double ZOOM_MIN;
    static const double ZOOM_MAX;
    static const double ZOOM_STEP;
 
    static const double ROTATION_RADIAN_PER_PIXEL;
 
    enum ProjectionType {
        Perspective = 0,
        Orthogonal = 1,
    };
 
public:
    virtual ~ViewControl() {}
 
    void SetViewMatrices(
            const Eigen::Matrix4d &model_matrix = Eigen::Matrix4d::Identity());
 
    bool ConvertToViewParameters(ViewParameters &status) const;
    bool ConvertFromViewParameters(const ViewParameters &status);
 
    void SetZoom(const double zoom);
    void SetUp(const Eigen::Vector3d &up);
    void SetFront(const Eigen::Vector3d &front);
    void SetLookat(const Eigen::Vector3d &lookat);
 
    bool ConvertToPinholeCameraParameters(
            camera::PinholeCameraParameters &parameters);
 
    bool ConvertFromPinholeCameraParameters(
            const camera::PinholeCameraParameters &parameters,
            bool allow_arbitrary = false);
 
    ProjectionType GetProjectionType() const;
    void SetProjectionParameters();
    virtual void Reset();
    virtual void ChangeFieldOfView(double step);
    virtual void ChangeWindowSize(int width, int height);
 
    virtual void Scale(double scale);
 
    virtual void Rotate(double x, double y, double xo = 0.0, double yo = 0.0);
 
    virtual void Translate(double x,
                           double y,
                           double xo = 0.0,
                           double yo = 0.0);
 
    virtual void CameraLocalTranslate(double forward, double right, double up);
    virtual void CameraLocalRotate(double x,
                                   double y,
                                   double xo = 0.0,
                                   double yo = 0.0);
    virtual void ResetCameraLocalRotate();
 
    // Function to process rolling
    virtual void Roll(double x);
 
    const ccBBox &GetBoundingBox() const { return bounding_box_; }
 
    void ResetBoundingBox() { bounding_box_.clear(); }
 
    void FitInGeometry(const ccHObject &geometry) {
        if (geometry.isKindOf(CV_TYPES::POINT_CLOUD) ||
            geometry.isKindOf(CV_TYPES::MESH) ||
            geometry.isKindOf(CV_TYPES::MESH_BASE) ||
            geometry.isKindOf(CV_TYPES::LINESET) ||
            geometry.isKindOf(CV_TYPES::POLY_LINE) ||
            geometry.isKindOf(CV_TYPES::FACET) ||
            geometry.isKindOf(CV_TYPES::POINT_OCTREE2) ||
            geometry.isKindOf(CV_TYPES::VOXEL_GRID) ||
            geometry.isKindOf(CV_TYPES::RGBD_IMAGE) ||
            geometry.isKindOf(CV_TYPES::IMAGE2) ||
            geometry.isKindOf(CV_TYPES::BBOX) ||
            geometry.isKindOf(CV_TYPES::ORIENTED_BBOX)) {
            bounding_box_ += (const_cast<ccHObject &>(geometry))
                                     .GetAxisAlignedBoundingBox();
        }
        SetProjectionParameters();
    }
 
    double GetFieldOfView() const { return field_of_view_; }
    gl_util::GLMatrix4f GetMVPMatrix() const { return MVP_matrix_; }
    gl_util::GLMatrix4f GetProjectionMatrix() const {
        return projection_matrix_;
    }
    gl_util::GLMatrix4f GetViewMatrix() const { return view_matrix_; }
    gl_util::GLMatrix4f GetModelMatrix() const { return model_matrix_; }
    gl_util::GLVector3f GetEye() const { return eye_.cast<GLfloat>(); }
    gl_util::GLVector3f GetLookat() const { return lookat_.cast<GLfloat>(); }
    gl_util::GLVector3f GetUp() const { return up_.cast<GLfloat>(); }
    gl_util::GLVector3f GetFront() const { return front_.cast<GLfloat>(); }
    gl_util::GLVector3f GetRight() const { return right_.cast<GLfloat>(); }
    int GetWindowWidth() const { return window_width_; }
    int GetWindowHeight() const { return window_height_; }
    double GetZNear() const { return z_near_; }
    double GetZFar() const { return z_far_; }
 
    void SetConstantZNear(double z_near) { constant_z_near_ = z_near; }
    void SetConstantZFar(double z_far) { constant_z_far_ = z_far; }
    void UnsetConstantZNear() { constant_z_near_ = -1; }
    void UnsetConstantZFar() { constant_z_far_ = -1; }
 
protected:
    int window_width_ = 0;
    int window_height_ = 0;
    ccBBox bounding_box_;
    Eigen::Vector3d eye_;
    Eigen::Vector3d lookat_;
    Eigen::Vector3d up_;
    Eigen::Vector3d front_;
    Eigen::Vector3d right_;
    double distance_;
    double field_of_view_;
    double zoom_;
    double view_ratio_;
    double aspect_;
    double z_near_;
    double z_far_;
    double constant_z_near_ = -1;
    double constant_z_far_ = -1;
    gl_util::GLMatrix4f projection_matrix_;
    gl_util::GLMatrix4f view_matrix_;
    gl_util::GLMatrix4f model_matrix_;
    gl_util::GLMatrix4f MVP_matrix_;
 
    Eigen::Vector3d start_local_rotate_up_;
    Eigen::Vector3d start_local_rotate_right_;
    Eigen::Vector3d start_local_rotate_front_;
    Eigen::Vector3d start_local_rotate_eye_;
    Eigen::Vector3d start_local_rotate_lookat_;
    double local_rotate_up_accum_;
    double local_rotate_right_accum_;
};
 
}  // namespace visualization
}  // namespace cloudViewer