camera.h

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#ifndef CAMERA_H
#define CAMERA_H


#include <jwsc++/config.h>

#include <iostream>

#if defined JWSCXX_HAVE_OPENGL
#include <GL/gl.h>
#elif defined JWSCXX_HAVE_OPENGL_FRAMEWORK
#include <OpenGL/gl.h>
#endif

#include <jwsc/vector/vector.h>
#include <jwsc/matrix/matrix.h>
#include <jwsc/image/image.h>

#include <jwsc++/base/exception.h>
#include <jwsc++/base/cloneable.h>
#include <jwsc++/base/readable.h>
#include <jwsc++/base/writeable.h>


namespace jwscxx {
namespace graphics {


class Camera_f : public jwscxx::base::Cloneable, 
                 public jwscxx::base::Writeable, 
                 public jwscxx::base::Readable
{
    public:

        Camera_f
        (
            float focal_pt_x,
            float focal_pt_y,
            float focal_pt_z,
            float ref_pt_x,
            float ref_pt_y,
            float ref_pt_z,
            float up_x,
            float up_y,
            float up_z,
            float aperture, 
            float clip_near, 
            float clip_far
        )
        throw (jwscxx::base::Arg_error);


        Camera_f
        (
            const jwsc::Vector_f* focal_pt,
            const jwsc::Vector_f* ref_pt,
            const jwsc::Vector_f* up,
            float                 aperture, 
            float                 clip_near, 
            float                 clip_far
        )
        throw (jwscxx::base::Arg_error);


        Camera_f(const Camera_f& c);


        Camera_f(const char* fname) throw (jwscxx::base::Arg_error,
                jwscxx::base::IO_error);


        Camera_f(std::istream& in) throw (jwscxx::base::Arg_error,
                jwscxx::base::IO_error);


        virtual ~Camera_f();


        virtual Camera_f& operator= (const Camera_f& c);


        virtual Camera_f* clone() const;


        const jwsc::Vector_f* get_u() const;


        const jwsc::Vector_f* get_v() const;


        const jwsc::Vector_f* get_n() const;


        const jwsc::Vector_f* get_prp() const;


        const jwsc::Vector_f* get_vrp() const;


        float get_clipping_near() const;


        float get_clipping_far() const;


        float get_focal_length() const;


        float get_aperture() const;


        float get_half_focal_height() const;


        virtual void set_f_with_new_aperture_using_prp(float f) 
            throw (jwscxx::base::Arg_error);


        virtual void set_f_with_same_aperture_using_prp(float f) 
            throw (jwscxx::base::Arg_error);


        virtual void set_f_with_new_aperture_using_vrp(float f) 
            throw (jwscxx::base::Arg_error);


        virtual void set_f_with_same_aperture_using_vrp(float f) 
            throw (jwscxx::base::Arg_error);


        virtual void set_aperture(float aperture) 
            throw (jwscxx::base::Arg_error);


        virtual void set_clipping(float clip_near, float clip_far) 
            throw (jwscxx::base::Arg_error);


        virtual void rotate(float angle, float x, float y, float z) 
            throw (jwscxx::base::Arg_error);


        virtual void rotate(float angle, const jwsc::Vector_f* r) 
            throw (jwscxx::base::Arg_error);


        virtual void translate(float x, float y, float z);


        virtual void translate(const jwsc::Vector_f* t) 
            throw (jwscxx::base::Arg_error);


        virtual void look_at
        (
            float focal_pt_x,
            float focal_pt_y,
            float focal_pt_z,
            float ref_pt_x,
            float ref_pt_y,
            float ref_pt_z,
            float up_x,
            float up_y,
            float up_z
        )
        throw (jwscxx::base::Arg_error);


        void look_at
        (
            const jwsc::Vector_f* focal_pt,
            const jwsc::Vector_f* ref_pt,
            const jwsc::Vector_f* up
        )
        throw (jwscxx::base::Arg_error);


        virtual void set_gl_modelview() const;


        virtual void set_gl_projection() const;


        void get_image_pt_on_focal_plane
        (
            jwsc::Vector_f** pt_out, 
            float      x, 
            float      y
        ); 


        void get_image_pt_on_focal_plane
        (
            jwsc::Vector_f**      pt_out, 
            const jwsc::Vector_f* pt_in
        )
        throw (jwscxx::base::Arg_error); 


        void get_image_pt_on_near_clipping_plane
        (
            jwsc::Vector_f** pt_out, 
            float            x, 
            float            y
        ); 


        void get_image_pt_on_near_clipping_plane
        (
            jwsc::Vector_f**      pt_out, 
            const jwsc::Vector_f* pt_in
        )
        throw (jwscxx::base::Arg_error); 


        void get_image_pt_on_far_clipping_plane
        (
            jwsc::Vector_f** pt_out, 
            float            x, 
            float            y
        ); 


        void get_image_pt_on_far_clipping_plane
        (
            jwsc::Vector_f**      pt_out, 
            const jwsc::Vector_f* pt_in
        )
        throw (jwscxx::base::Arg_error); 


        static float get_gl_viewport_aspect();


        static float get_gl_viewport_width();


        static float get_gl_viewport_height();


        static void capture_gl_view(jwsc::Image_f** img_out);


        static void capture_gl_view(const char* fname) 
            throw (jwscxx::base::IO_error);


        static void capture_gl_view(const char* fname_base, uint32_t N) 
            throw (jwscxx::base::IO_error);


        virtual void read(std::istream& in) throw (jwscxx::base::IO_error,
                jwscxx::base::Arg_error);


        virtual void write(std::ostream& out) const
            throw (jwscxx::base::IO_error);


    protected:

        jwsc::Vector_f* vrp;

        jwsc::Vector_f* prp;

        jwsc::Vector_f* u;

        jwsc::Vector_f* v;

        jwsc::Vector_f* n;

        float aperture;

        float focal_length;

        float half_focal_height;

        float half_near_height;

        float near;

        float far;

        jwsc::Matrix_f* R_phi;

        jwsc::Matrix_f* R_theta;

        jwsc::Matrix_f* R_psi;

        jwsc::Matrix_f* R;
};




class Camera_d : public jwscxx::base::Cloneable, 
                 public jwscxx::base::Writeable, 
                 public jwscxx::base::Readable
{
    public:

        Camera_d
        (
            double focal_pt_x,
            double focal_pt_y,
            double focal_pt_z,
            double ref_pt_x,
            double ref_pt_y,
            double ref_pt_z,
            double up_x,
            double up_y,
            double up_z,
            double aperture, 
            double clip_near, 
            double clip_far
        )
        throw (jwscxx::base::Arg_error);


        Camera_d
        (
            const jwsc::Vector_d* focal_pt,
            const jwsc::Vector_d* ref_pt,
            const jwsc::Vector_d* up,
            double                aperture, 
            double                clip_near, 
            double                clip_far
        )
        throw (jwscxx::base::Arg_error);


        Camera_d(const Camera_d& c);


        Camera_d(const char* fname) throw (jwscxx::base::Arg_error,
                jwscxx::base::IO_error);


        Camera_d(std::istream& in) throw (jwscxx::base::Arg_error,
                jwscxx::base::IO_error);


        virtual ~Camera_d();


        virtual Camera_d& operator= (const Camera_d& c);


        virtual Camera_d* clone() const;


        const jwsc::Vector_d* get_u() const;


        const jwsc::Vector_d* get_v() const;


        const jwsc::Vector_d* get_n() const;


        const jwsc::Vector_d* get_prp() const;


        const jwsc::Vector_d* get_vrp() const;


        double get_clipping_near() const;


        double get_clipping_far() const;


        double get_focal_length() const;


        double get_aperture() const;


        double get_half_focal_height() const;


        virtual void set_f_with_new_aperture_using_prp(double f) 
            throw (jwscxx::base::Arg_error);


        virtual void set_f_with_same_aperture_using_prp(double f) 
            throw (jwscxx::base::Arg_error);


        virtual void set_f_with_new_aperture_using_vrp(double f) 
            throw (jwscxx::base::Arg_error);


        virtual void set_f_with_same_aperture_using_vrp(double f) 
            throw (jwscxx::base::Arg_error);


        virtual void set_aperture(double aperture) 
            throw (jwscxx::base::Arg_error);


        virtual void set_clipping(double clip_near, double clip_far) 
            throw (jwscxx::base::Arg_error);


        virtual void rotate(double angle, double x, double y, double z) 
            throw (jwscxx::base::Arg_error);


        virtual void rotate(double angle, const jwsc::Vector_d* r) 
            throw (jwscxx::base::Arg_error);


        virtual void translate(double x, double y, double z);


        virtual void translate(const jwsc::Vector_d* t) 
            throw (jwscxx::base::Arg_error);


        virtual void look_at
        (
            double focal_pt_x,
            double focal_pt_y,
            double focal_pt_z,
            double ref_pt_x,
            double ref_pt_y,
            double ref_pt_z,
            double up_x,
            double up_y,
            double up_z
        )
        throw (jwscxx::base::Arg_error);


        void look_at
        (
            const jwsc::Vector_d* focal_pt,
            const jwsc::Vector_d* ref_pt,
            const jwsc::Vector_d* up
        )
        throw (jwscxx::base::Arg_error);


        virtual void set_gl_modelview() const;


        virtual void set_gl_projection() const;


        void get_image_pt_on_focal_plane
        (
            jwsc::Vector_d** pt_out, 
            double     x, 
            double     y
        ); 


        void get_image_pt_on_focal_plane
        (
            jwsc::Vector_d**      pt_out, 
            const jwsc::Vector_d* pt_in
        )
        throw (jwscxx::base::Arg_error); 


        void get_image_pt_on_near_clipping_plane
        (
            jwsc::Vector_d** pt_out, 
            double           x, 
            double           y
        ); 


        void get_image_pt_on_near_clipping_plane
        (
            jwsc::Vector_d**      pt_out, 
            const jwsc::Vector_d* pt_in
        )
        throw (jwscxx::base::Arg_error); 


        void get_image_pt_on_far_clipping_plane
        (
            jwsc::Vector_d** pt_out, 
            double           x, 
            double           y
        ); 


        void get_image_pt_on_far_clipping_plane
        (
            jwsc::Vector_d**      pt_out, 
            const jwsc::Vector_d* pt_in
        )
        throw (jwscxx::base::Arg_error); 


        static double get_gl_viewport_aspect();


        static double get_gl_viewport_width();


        static double get_gl_viewport_height();


        static void capture_gl_view(jwsc::Image_f** img_out);


        static void capture_gl_view(const char* fname) 
            throw (jwscxx::base::IO_error);


        static void capture_gl_view(const char* fname_base, uint32_t N) 
            throw (jwscxx::base::IO_error);


        virtual void read(std::istream& in) throw (jwscxx::base::IO_error,
                jwscxx::base::Arg_error);


        virtual void write(std::ostream& out) const
            throw (jwscxx::base::IO_error);


    protected:

        jwsc::Vector_d* vrp;

        jwsc::Vector_d* prp;

        jwsc::Vector_d* u;

        jwsc::Vector_d* v;

        jwsc::Vector_d* n;

        double aperture;

        double focal_length;

        double half_focal_height;

        double half_near_height;

        double near;

        double far;

        jwsc::Matrix_d* R_phi;

        jwsc::Matrix_d* R_theta;

        jwsc::Matrix_d* R_psi;

        jwsc::Matrix_d* R;
};




class Stereo_camera_f : public Camera_f
{
    public:

        Stereo_camera_f
        (
            float focal_pt_x,
            float focal_pt_y,
            float focal_pt_z,
            float ref_pt_x,
            float ref_pt_y,
            float ref_pt_z,
            float up_x,
            float up_y,
            float up_z,
            float aperture, 
            float clip_near, 
            float clip_far
        )
        throw (jwscxx::base::Arg_error);


        Stereo_camera_f
        (
            const jwsc::Vector_f* focal_pt,
            const jwsc::Vector_f* ref_pt,
            const jwsc::Vector_f* up,
            float                 aperture, 
            float                 clip_near, 
            float                 clip_far
        )
        throw (jwscxx::base::Arg_error);


        Stereo_camera_f(const Stereo_camera_f& c);


        Stereo_camera_f(const char* fname) throw (jwscxx::base::Arg_error,
                jwscxx::base::IO_error);


        Stereo_camera_f(std::istream& in) throw (jwscxx::base::Arg_error,
                jwscxx::base::IO_error);


        virtual ~Stereo_camera_f();


        virtual Stereo_camera_f& operator= (const Stereo_camera_f& c);


        virtual Stereo_camera_f* clone() const;


        const jwsc::Vector_f* get_left_prp() const;


        const jwsc::Vector_f* get_right_prp() const;


        const jwsc::Vector_f* get_left_vrp() const;


        const jwsc::Vector_f* get_right_vrp() const;


        void set_aperture(float aperture) throw (jwscxx::base::Arg_error);


        void set_f_with_new_aperture_using_prp(float f) 
            throw (jwscxx::base::Arg_error);


        void set_f_with_same_aperture_using_prp(float f) 
            throw (jwscxx::base::Arg_error);


        void set_f_with_new_aperture_using_vrp(float f) 
            throw (jwscxx::base::Arg_error);


        void set_f_with_same_aperture_using_vrp(float f) 
            throw (jwscxx::base::Arg_error);



        void set_clipping(float clip_near, float clip_far) 
            throw (jwscxx::base::Arg_error);


        void rotate(float angle, float x, float y, float z) 
            throw (jwscxx::base::Arg_error);


        void rotate(float angle, const jwsc::Vector_f* r) 
            throw (jwscxx::base::Arg_error);


        void translate(float x, float y, float z);


        void translate(const jwsc::Vector_f* t) 
            throw (jwscxx::base::Arg_error);


        void look_at
        (
            float focal_pt_x,
            float focal_pt_y,
            float focal_pt_z,
            float ref_pt_x,
            float ref_pt_y,
            float ref_pt_z,
            float up_x,
            float up_y,
            float up_z
        )
        throw (jwscxx::base::Arg_error);


        void set_left_gl_modelview();


        void set_right_gl_modelview();


        void set_left_gl_projection();


        void set_right_gl_projection();


        void read(std::istream& in) throw (jwscxx::base::IO_error,
                jwscxx::base::Arg_error);


        void write(std::ostream& out) const throw (jwscxx::base::IO_error);


    protected:

        jwsc::Vector_f* left_vrp;

        jwsc::Vector_f* right_vrp;

        jwsc::Vector_f* left_prp;

        jwsc::Vector_f* right_prp;

        float separation;

        float ndfl;
};




class Stereo_camera_d : public Camera_d
{
    public:

        Stereo_camera_d
        (
            double focal_pt_x,
            double focal_pt_y,
            double focal_pt_z,
            double ref_pt_x,
            double ref_pt_y,
            double ref_pt_z,
            double up_x,
            double up_y,
            double up_z,
            double aperture, 
            double clip_near, 
            double clip_far
        )
        throw (jwscxx::base::Arg_error);


        Stereo_camera_d
        (
            const jwsc::Vector_d* focal_pt,
            const jwsc::Vector_d* ref_pt,
            const jwsc::Vector_d* up,
            double                aperture, 
            double                clip_near, 
            double                clip_far
        )
        throw (jwscxx::base::Arg_error);


        Stereo_camera_d(const Stereo_camera_d& c);


        Stereo_camera_d(const char* fname) throw (jwscxx::base::Arg_error,
                jwscxx::base::IO_error);


        Stereo_camera_d(std::istream& in) throw (jwscxx::base::Arg_error,
                jwscxx::base::IO_error);


        virtual ~Stereo_camera_d();


        virtual Stereo_camera_d& operator= (const Stereo_camera_d& c);


        virtual Stereo_camera_d* clone() const;


        const jwsc::Vector_d* get_left_prp() const;


        const jwsc::Vector_d* get_right_prp() const;


        const jwsc::Vector_d* get_left_vrp() const;


        const jwsc::Vector_d* get_right_vrp() const;


        void set_aperture(double aperture) throw (jwscxx::base::Arg_error);


        void set_f_with_new_aperture_using_prp(double f) 
            throw (jwscxx::base::Arg_error);


        void set_f_with_same_aperture_using_prp(double f) 
            throw (jwscxx::base::Arg_error);


        void set_f_with_new_aperture_using_vrp(double f) 
            throw (jwscxx::base::Arg_error);


        void set_f_with_same_aperture_using_vrp(double f) 
            throw (jwscxx::base::Arg_error);



        void set_clipping(double clip_near, double clip_far) 
            throw (jwscxx::base::Arg_error);


        void rotate(double angle, double x, double y, double z) 
            throw (jwscxx::base::Arg_error);


        void rotate(double angle, const jwsc::Vector_d* r) 
            throw (jwscxx::base::Arg_error);


        void translate(double x, double y, double z);


        void translate(const jwsc::Vector_d* t) 
            throw (jwscxx::base::Arg_error);


        void look_at
        (
            double focal_pt_x,
            double focal_pt_y,
            double focal_pt_z,
            double ref_pt_x,
            double ref_pt_y,
            double ref_pt_z,
            double up_x,
            double up_y,
            double up_z
        )
        throw (jwscxx::base::Arg_error);


        void set_left_gl_modelview();


        void set_right_gl_modelview();


        void set_left_gl_projection();


        void set_right_gl_projection();


        void read(std::istream& in) throw (jwscxx::base::IO_error,
                jwscxx::base::Arg_error);


        void write(std::ostream& out) const throw (jwscxx::base::IO_error);


    protected:

        jwsc::Vector_d* left_vrp;

        jwsc::Vector_d* right_vrp;

        jwsc::Vector_d* left_prp;

        jwsc::Vector_d* right_prp;

        double separation;

        double ndfl;
};


}}


#endif