MC_navigator_tool.cpp

Go to the documentation of this file.

#include <MC_navigator_tool.hpp>

#include <MC_matrix.hpp>
#include <MC_v3d_vector.hpp>

#include <fstream>

namespace mesh_conv
{
    MC_navigator_tool::MC_navigator_tool()
    {
#define PI 3.14159

        dist_cam1=-3.0;
        current_time=0;old_time=0;frame=0;current_fps=0.0;
        x_previous=0;y_previous=0;
        x_screen_size_1=100;y_screen_size_1=100;
        size_pointer=0.1;

        fov=45.0*PI/180.0;
        znear=0.01;
        zfar=150.0;
    }
    MC_matrix MC_navigator_tool::current_cam1() const
    {
        MC_matrix camera_1=MC_matrix::identity(4);
        camera_1.add_translation(MC_v3d(0,0,dist_cam1));
        camera_1=camera_1*trackball_cam1.quaternion().conjugated().matrix().to_matrix4();

        MC_v3d translate_after=camera_1.to_matrix3().first*tr_cam1;
        camera_1.add_translation(translate_after);

        return camera_1;
    }
    MC_matrix MC_navigator_tool::current_light1() const
    {
        MC_matrix light_1=MC_matrix::identity(4);
        light_1.add_translation(MC_v3d(0,0,dist_light1));
        light_1=light_1*trackball_light1.quaternion().conjugated().matrix().to_matrix4();

        MC_v3d translate_after=light_1.to_matrix3().first*tr_light1;
        light_1.add_translation(translate_after);

        return light_1;
    }
    MC_v3d_vector MC_navigator_tool::axis_cam1() const
    {
        MC_matrix camera_1=current_cam1();
//        MC_v3d eye_n(camera_1(0,2),camera_1(1,2),camera_1(2,2));
//        MC_v3d eye_up(camera_1(0,1),camera_1(1,1),camera_1(2,1));
//        MC_v3d eye_right(camera_1(0,0),camera_1(1,0),camera_1(2,0));
//
        MC_v3d eye_n(camera_1(2,0),camera_1(2,1),camera_1(2,2));
        MC_v3d eye_up(camera_1(1,0),camera_1(1,1),camera_1(1,2));
        MC_v3d eye_right(camera_1(0,0),camera_1(0,1),camera_1(0,2));



        MC_v3d local_p(camera_1(0,3),camera_1(1,3),camera_1(2,3));

        //local_p=camera_1.to_matrix3().first*(MC_v3d(0,0,-dist_cam1));
        //local_p=camera_1.to_matrix3().first.inverted()*(-local_p);
        //local_p=-(MC_v3d(camera_1.to_matrix3().first*MC_v3d(0,0,dist_cam1))+tr_cam1);
        local_p=-MC_v3d((camera_1.to_matrix3().first).inverted()*(camera_1.to_matrix3().second));

        MC_v3d_vector parameters;
        parameters=parameters<<local_p<<eye_n<<eye_right<<eye_up;
        return parameters;
    }

    MC_v3d_vector MC_navigator_tool::axis_light1() const
    {
        MC_matrix light_1=current_light1();

        MC_v3d eye_n(light_1(2,0),light_1(2,1),light_1(2,2));
        MC_v3d eye_up(light_1(1,0),light_1(1,1),light_1(1,2));
        MC_v3d eye_right(light_1(0,0),light_1(0,1),light_1(0,2));

        MC_v3d local_p(light_1(0,3),light_1(1,3),light_1(2,3));
        local_p=-MC_v3d((light_1.to_matrix3().first).inverted()*(light_1.to_matrix3().second));

        MC_v3d_vector parameters;
        parameters=parameters<<local_p<<eye_n<<eye_right<<eye_up;
        return parameters;
    }

    double MC_navigator_tool::update_fps()
    {
        current_fps=double(frame*1000)/double(current_time-old_time);
        old_time=current_time;
        frame=0;
        return current_fps;
    }

    void MC_navigator_tool::go_forward_trackball_cam1(const double& d_L)
    {
        MC_v3d z(0,0,1);
        tr_cam1+=d_L*(trackball_cam1.quaternion().conjugated()*z);
    }
    void MC_navigator_tool::go_right_trackball_cam1(const double& d_L)
    {
        MC_v3d z(-1,0,0);
        tr_cam1+=d_L*(trackball_cam1.quaternion().conjugated()*z);
    }
    void MC_navigator_tool::go_up_trackball_cam1(const double& d_L)
    {
        MC_v3d z(0,1,0);
        tr_cam1+=d_L*(trackball_cam1.quaternion().conjugated()*z);
    }

    std::ostream& MC_navigator_tool::write_cam1(std::ostream& stream) const
    {
        stream<<"quat "<<trackball_cam1.quaternion()<<"\ndist "<<dist_cam1<<"\ntr "<<tr_cam1<<std::endl;
        return stream;
    }
    const MC_navigator_tool& MC_navigator_tool::write_cam1_file(std::string& filename) const
    {
        std::ofstream fstream(filename.c_str());
        write_cam1(fstream);
        fstream.close();
        return *this;
    }
    MC_navigator_tool& MC_navigator_tool::read_cam1(std::istream& param)
    {
        std::string buffer;

        param>>buffer; //quat
        param>>trackball_cam1.quaternion();

        param>>buffer; //dist
        param>>dist_cam1;

        param>>buffer; //tr
        param>>tr_cam1;

        return *this;
    }
    MC_navigator_tool& MC_navigator_tool::read_cam1_file(const std::string& filename)
    {
        std::ifstream fstream(filename.c_str());
        if(!fstream.good())
        {std::cout<<"MC_navigator_tool::read_cam1_file("<<filename<<") cannot open the file"<<std::endl;}
        read_cam1(fstream);
        fstream.close();
        return *this;
    }

    std::ostream& MC_navigator_tool::write_light1(std::ostream& stream) const
    {
        stream<<"quat "<<trackball_light1.quaternion()<<"\ndist "<<dist_light1<<"\ntr "<<tr_light1<<std::endl;
        return stream;
    }
    const MC_navigator_tool& MC_navigator_tool::write_light1_file(std::string& filename) const
    {
        std::ofstream fstream(filename.c_str());
        write_light1(fstream);
        fstream.close();
        return *this;
    }
    MC_navigator_tool& MC_navigator_tool::read_light1(std::istream& param)
    {
        std::string buffer;

        param>>buffer; //quat
        param>>trackball_light1.quaternion();

        param>>buffer; //dist
        param>>dist_light1;

        param>>buffer; //tr
        param>>tr_light1;

        return *this;
    }
    MC_navigator_tool& MC_navigator_tool::read_light1_file(const std::string& filename)
    {
        std::ifstream fstream(filename.c_str());
        if(!fstream.good())
        {std::cout<<"MC_navigator_tool::read_light1_file("<<filename<<") cannot open the file"<<std::endl;}

        read_light1(fstream);
        fstream.close();
        return *this;
    }



    MC_double_vector MC_navigator_tool::projection_param() const
    {
        double aspect=static_cast<double>(x_screen_size_1)/static_cast<double>(y_screen_size_1);
        double top=tan(fov*0.5)*znear;
        double left=-aspect*top;
        return MC_double_vector(left,top,znear,zfar,aspect);
    }
    MC_matrix MC_navigator_tool::projection_matrix() const
    {
        MC_double_vector param=projection_param();
        double left=param[0];
        double right=-left;
        double top=param[1];
        double bottom=-top;
        double znear=param[2];
        double zfar=param[3];
        MC_matrix p(4,4);


        p(0,0)=2*znear/(right-left);
        p(1,1)=2*znear/(top-bottom);

        p(0,2)=(right+left)/(right-left);
        p(1,2)=(top+bottom)/(top-bottom);
        p(2,2)=-(zfar+znear)/(zfar-znear);
        p(3,2)=-1;

        p(2,3)=-2*zfar*znear/(zfar-znear);



        return p;
    }

    MC_v3d_vector MC_navigator_tool::ray_world_space_cam1(const int& x_screen,const int& y_screen) const
    {
        //normalized screen coordinates
        MC_v3d local(
                (x_screen_size_1-2*x_screen)/double(x_screen_size_1)
                ,
                (y_screen_size_1-2*y_screen)/double(y_screen_size_1),0);

        //camera parameters
        MC_double_vector proj_param=projection_param();
        double Lh=-proj_param[1];
        double aspect=proj_param[4];

        //coordinate on the camera
        MC_v3d proj_ray(local[0]*Lh*aspect,local[1]*Lh,-znear);

        // modelview
        MC_matrix mod=current_cam1();
        MC_matrix mod_inv=mod.inverted();

        MC_v3d ray=mod_inv.to_matrix3().first*proj_ray;
        MC_v3d center=mod_inv.translation_part();

        return MC_v3d_vector(center,ray.normalized());
    }

}