opengaze/src/input_handler.cpp

#include "input_handler.hpp"
#include <iostream>
#include <cstdlib>
using namespace cv;
using namespace std;

namespace opengaze {

#if WIN32
#include <windows.h>
#else
#include <X11/Xlib.h>
#endif

void InputHandler::getScreenResolution(int &width, int &height) {
#if WIN32
    width  = (int) GetSystemMetrics(SM_CXSCREEN);
    height = (int) GetSystemMetrics(SM_CYSCREEN);
#else
    Display* disp = XOpenDisplay(NULL);
    Screen*  scrn = DefaultScreenOfDisplay(disp);
    width  = scrn->width;
    height = scrn->height;
#endif
}

InputHandler::InputHandler(){
    input_type_ = InputType::Camera;// defualt input type
    camera_id_ = 0;
    getScreenResolution(screen_width_, screen_height_);
    screen_width_ = screen_width_;
}
InputHandler::~InputHandler(){}


void InputHandler::initialize()
{
    if (input_type_ == InputType::Camera){
        cap_.open(camera_id_);
        if(!cap_.isOpened()) { // open Camera
            cout << "Could not open Camera with id " << camera_id_ << endl;
            std::exit(EXIT_FAILURE);
        }
        setFrameSize(1280, 720); // 800*600, 1280*720, 1920*1080,
    }
    else if (input_type_ == InputType::Video){
        cap_.open(input_file_video_name_);
        if(!cap_.isOpened()) { // open Camera
            cout << "Error: Could not open video file " << input_file_video_name_ << endl;
            std::exit(EXIT_FAILURE);
        }
    }
    else if (input_type_ == InputType::Directory) {
        if (!boost::filesystem::is_directory(input_path_)){
            cout << "Error: The input must be a directory, but it is " << input_path_ << endl;
            std::exit(EXIT_FAILURE);
        }
        current_itr_ = boost::filesystem::directory_iterator(input_path_);

    }
    else if (input_type_ == InputType::Memory) {}

    is_reach_end_ = false;
}

void InputHandler::setFrameSize(int frame_width, int frame_height){
    cap_.set(cv::CAP_PROP_FRAME_HEIGHT, frame_height);//720  1080
    cap_.set(cv::CAP_PROP_FRAME_WIDTH, frame_width);//1280 1980
    double dWidth = cap_.get(CV_CAP_PROP_FRAME_WIDTH); //get the width of frames of the video
    double dHeight = cap_.get(CV_CAP_PROP_FRAME_HEIGHT); //get the height of frames of the video
    cout << "Input frame size is : " << dWidth << " x " << dHeight << endl;
}

Mat InputHandler::getNextSample() {
    Mat frame;
    if (input_type_ == InputType::Camera) cap_ >> frame;
    else if (input_type_ == InputType::Video) {
        cap_ >> frame;
        if (frame.empty()) // we reach the end of video
            is_reach_end_ = true;
    }
    else if (input_type_ == InputType::Directory) {
        boost::filesystem::path file_path = current_itr_->path();
        if (file_path.extension() != ".jpg" && file_path.extension() != ".png" && file_path.extension() != ".bmp"){
            cout << "Error: The input file is not image file with extension of jpg, png or bmp!" << endl;
            cout << "The input file name is: " << file_path.string() << endl;
            std::exit(EXIT_FAILURE);
        }
        cout << "process image " << file_path << endl;
        frame = imread(file_path.string());
        if (current_itr_ == boost::filesystem::directory_iterator())
            is_reach_end_ = true;
    }
    else if (input_type_ == InputType::Memory) {}

    return frame;
}

bool InputHandler::closeInput() {
    if (input_type_ == InputType::Camera || input_type_ == InputType::Video){
        cap_.release();
        is_reach_end_ = true;
    }
    return true;
}

void InputHandler::setInput(std::string input_path) {
    if (input_type_ == InputType::Directory){
        input_path_ = move(input_path);
    }
    else if (input_type_ == InputType::Video){
        input_file_video_name_ = move(input_path);
    }
}

void InputHandler::readScreenConfiguration(string calib_file) {
    FileStorage fs_disp(calib_file, FileStorage::READ);
    fs_disp["monitor_W"] >> monitor_W_;
    fs_disp["monitor_H"] >> monitor_H_;
    fs_disp["monitor_R"] >> monitor_R_;
    fs_disp["monitor_T"] >> monitor_T_;
    // compute monitor plane
    Vec3f corners[4];
    corners[0] = Vec3f(0.0, 0.0, 0.0);
    corners[1] = Vec3f(monitor_W_, 0.0, 0.0);
    corners[2] = Vec3f(0.0, monitor_H_, 0.0);
    corners[3] = Vec3f(monitor_W_, monitor_H_, 0.0);

    for(int i=0; i<4; i++){
        Mat corners_cam = monitor_R_ * Mat(corners[i]) + monitor_T_;
        corners_cam.copyTo(monitor_corners_[i]);
    }

    Vec3f normal = Vec3f(0.0, 0.0, 1.0); // normal direction
    monitor_normal_ = monitor_R_ * Mat(normal);
    monitor_normal_.convertTo(monitor_normal_, CV_32F);
}

void InputHandler::readCameraConfiguration(string calib_file){
    cout << endl << "Reading calibration information from : " << calib_file << endl;
    FileStorage fs;
    fs.open(calib_file, FileStorage::READ);
    fs["camera_matrix"] >> camera_matrix_;
    fs["dist_coeffs"] >> camera_distortion_;
    fs.release();
}

void InputHandler::projectToDisplay(std::vector<opengaze::Sample> &inputs, bool is_face_model) {
    for(auto & sample : inputs) {
        if (is_face_model) {
            Vec3f face_center(sample.face_patch_data.face_center.at<float>(0), sample.face_patch_data.face_center.at<float>(1), sample.face_patch_data.face_center.at<float>(2));
            sample.gaze_data.gaze2d = mapToDisplay(face_center, sample.gaze_data.gaze3d);
        }
        else {
            Vec3f leye_pose(sample.eye_data.leye_pos.at<float>(0),sample.eye_data.leye_pos.at<float>(1),sample.eye_data.leye_pos.at<float>(2));
            Vec3f reye_pose(sample.eye_data.reye_pos.at<float>(0),sample.eye_data.reye_pos.at<float>(1),sample.eye_data.reye_pos.at<float>(2));
            sample.gaze_data.lgaze2d = mapToDisplay(leye_pose, sample.gaze_data.lgaze3d);
            sample.gaze_data.rgaze2d = mapToDisplay(reye_pose, sample.gaze_data.rgaze3d);
            float gaze_x = (sample.gaze_data.lgaze2d.x + sample.gaze_data.rgaze2d.x) / 2.0f;
            float gaze_y = (sample.gaze_data.lgaze2d.y + sample.gaze_data.rgaze2d.y) / 2.0f;
            sample.gaze_data.gaze2d.x = gaze_x;
            sample.gaze_data.gaze2d.y = gaze_y;
        }
    }
}

cv::Point2f InputHandler::mapToDisplay(Vec3f origin, Vec3f gaze_vec) {
    Point2f gaze_on_screen;
    // compute intersection
    float gaze_len = (float)(monitor_normal_.dot(Mat(monitor_corners_[0]-origin))/monitor_normal_.dot(Mat(gaze_vec)));
    Vec3f gaze_pos_cam = origin + gaze_len * gaze_vec;

    // convert to monitor coodinate system
    Mat gaze_pos_ = monitor_R_.inv() * (Mat(gaze_pos_cam) - monitor_T_);
    Vec3f gaze_pos_3d;
    gaze_pos_.copyTo(gaze_pos_3d);

    gaze_on_screen.x = gaze_pos_3d.val[0] / monitor_W_;
    gaze_on_screen.y = gaze_pos_3d.val[1] / monitor_H_;

    return gaze_on_screen;

}

}