gr_camera.h

Go to the documentation of this file.

/* =========================================================================== *
|
|  Copyright (c) 1994-2008 by Kobus Barnard (author).
|
|  Personal and educational use of this code is granted, provided that this
|  header is kept intact, and that the authorship is not misrepresented, that
|  its use is acknowledged in publications, and relevant papers are cited.
|
|  For other use contact the author (kobus AT cs DOT arizona DOT edu).
|
|  Please note that the code in this file has not necessarily been adequately
|  tested. Naturally, there is no guarantee of performance, support, or fitness
|  for any particular task. Nonetheless, I am interested in hearing about
|  problems that you encounter.
|
| Authors:
|     Luca Del Pero, Kyle Simek
|
* =========================================================================== */


#ifndef KJB_CAMERA_H
#define KJB_CAMERA_H

#include <m_cpp/m_matrix.h>
#include <gr_cpp/gr_rigid_object.h>


namespace kjb_c {
    struct KJB_image;
}

namespace kjb {

class Image;
class Vector;
class Int_matrix;
class Polygon;

class Base_gl_interface
{
typedef Base_gl_interface Self;
public:
    Base_gl_interface(double inear = 10, double ifar = 10000);
    Base_gl_interface(const Base_gl_interface &);
    virtual Base_gl_interface& operator=(const Base_gl_interface& src);

    virtual ~Base_gl_interface() {}

    virtual void swap(Self& other)
    {
        using std::swap;

        modelview_matrix.swap(other.modelview_matrix);
        projection_matrix.swap(other.projection_matrix);
        swap(near, other.near);
        swap(far, other.far);

    }

    virtual void set_gl_modelview() const;

    virtual void set_gl_projection() const;

    virtual void mult_gl_projection() const;

    void prepare_for_rendering(bool clean_buffers) const;


    void set_near_clipping_plane(double inear);

    void set_far_clipping_plane(double ifar);

    void set_clipping_planes(double inear, double ifar);

    inline double get_near() const {return near;}

    inline double get_far() const {return far;}

    inline const Matrix & get_modelview_matrix() const {return modelview_matrix; }
    inline const Matrix & get_projection_matrix() const 
    {
        return  projection_matrix;
    }

    Matrix get_gl_projection_matrix() const;
    

    static double get_gl_viewport_aspect();
    static double get_gl_viewport_width();
    static double get_gl_viewport_height();
    static void get_gl_viewport_size(double * w, double *h);
    static void get_gl_viewport(double * x, double *y, double *w, double *h);

    static void set_gl_viewport_size(double, double);
    static void set_gl_viewport(double x, double y, double w, double h);

    static void capture_gl_view(kjb_c::KJB_image** img_out);
    static void capture_gl_view(const char* fname);
    static void capture_gl_view(const char* fname_fmt, uint32_t N);
    static void capture_gl_view(kjb::Int_matrix & matrix);
    static void capture_gl_view(Image & img_out);

    static void set_gl_view(const kjb::Image & img_in);

    void project_point(double & x, double & y,double &z, const kjb::Vector & point3D, double img_height) const;

    static void construct_image_from_int_matrix(kjb::Image & im, kjb::Int_matrix & m);

    virtual bool Polygon_visibility_test(const kjb::Polygon & p, double epsilon = 0) const;

    inline void set_modelview_entry(unsigned int row, unsigned int col, double value)
    {
        modelview_matrix(row, col) = value;
    }

    inline void set_projection_entry(unsigned int row, unsigned int col, double value)
    {
        projection_matrix(row, col) = value;
    }

    inline double& get_modelview_entry(unsigned int row, unsigned int col)
    {
        return modelview_matrix(row, col);
    }

    inline double get_modelview_entry(unsigned int row, unsigned int col) const
    {
        return modelview_matrix(row, col);
    }

    inline double& get_projection_entry(unsigned int row, unsigned int col)
    {
            return projection_matrix(row, col);
    }

    inline double get_projection_entry(unsigned int row, unsigned int col) const
    {
            return projection_matrix(row, col);
    }


protected:
    Base_gl_interface(const Matrix &, const Matrix &, double near, double far);

    void set_modelview_matrix(const Matrix &mv);
    void set_projection_matrix(const Matrix &pm);

    void scale_modelview(double xscale, double yscale, double zscale);



private:
    Matrix modelview_matrix;
    Matrix projection_matrix;
    double near;
    double far;

};

class Parametric_camera_gl_interface : public Base_gl_interface, public Rigid_object
{
typedef Parametric_camera_gl_interface Self;
public:
    Parametric_camera_gl_interface(double inear = 10, double ifar = 10000);
    Parametric_camera_gl_interface(const Parametric_camera_gl_interface &);
    virtual Parametric_camera_gl_interface& operator=(const Parametric_camera_gl_interface& src);
    virtual Parametric_camera_gl_interface* clone() const;
    virtual ~Parametric_camera_gl_interface() {}

    virtual void swap(Self& other)
    {
        Base_gl_interface::swap(other);
        Rigid_object::swap(other);
        camera_center_in_world_coordinates.swap(other.camera_center_in_world_coordinates);
    }

    //Intrinsic parameters
    void set_focal_length(double focal_length, double skew, double aspect_ratio);
    void set_aspect_ratio(double aspect_ratio, double focal_length, double skew);
    void set_skew(double skew, double aspect_ratio, double focal_length);

    void set_principal_point_x(double px);
    void set_principal_point_y(double py);
    inline void set_principal_point(double px, double py)
    {
        set_principal_point_x(px);
        set_principal_point_y(py);
    }

    void set_focal_no_skew(double focal_length, double aspect_ratio);

    void set_focal_no_aspect_ratio(double focal_length, double skew);

    void set_focal_no_aspect_ratio_no_skew(double focal_length);

    void set_intrinsic_parameters(
            double focal_length,
            double aspect_ratio,
            double skew,
            double px,
            double py);

    //Extrinsic parameters

    void set_camera_center(const kjb::Vector & center);

    void set_world_origin(const kjb::Vector & center);

    inline void set_world_scale(double xscale, double yscale, double zscale)
    {
        scale_modelview(xscale, yscale, zscale);
    }

    void set_rotation_angles(double pitch, double yaw, double roll);

    void transform_point_to_camera_frame(kjb::Vector & point) const;

    void rotate_point_to_camera_frame(kjb::Vector & point) const;

    void get_point_in_world_coordinates
    (
        const kjb::Vector & point_in_camera_coordinates,
        kjb::Vector & point_in_world_coordinates
    ) const;

    bool Polygon_visibility_test(const kjb::Polygon & p, double epsilon = 0) const;

    bool is_point_in_camera_frustum
    (
            const kjb::Vector & point_in_world_coordinates,
            double & ox,
            double & oy,
                unsigned int num_rows,
                unsigned int num_cols
    ) const;


private:
    void set_rotation_matrix(const kjb::Matrix & rotation_matrix);

    void translate(double dx, double dy, double dz);

    void set_rotations_and_translate(double pitch, double yaw, double roll, double dx, double dy, double dz);

    void transform(const kjb::Matrix & M);

    // Stores the camera center in world coordinates
    Vector camera_center_in_world_coordinates;
};



}

#endif