FaceFind.h

Go to the documentation of this file.

#ifndef FACE_FIND_H
#define FACE_FIND_H


#include <ros/ros.h>

//for conversion from 3D ROS frame coordinates to 2D pixel coordinates
#include <image_geometry/pinhole_camera_model.h>

//faces
#include <FaceWrapper.h>

//point cloud
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>

//laser scanner
#include <laser_assembler/base_assembler.h>

//gui
#include <QObject>
#include <QImage>

//intra-project message callback
#include <portrait_robot_msgs/alubsc_status_msg.h>
#include <portrait_robot_msgs/alubsc_node_instr.h>


class FaceFind : public QObject
{
        Q_OBJECT
        
public Q_SLOTS:

        void ReceiveMouseEvent(int, int, int);

  void EdgeImageFromFile(const char* filename);
  void PhotoFromFile(const char* photo, const char* mask);

        
        void Mirror();
        
        //button slots
        void PenButton();                               
        void EdgeButton();                              
        void PaintButton();                             
        void CornerButton();                            
        void HeadButton();                              
        void AbortButton();                             

Q_SIGNALS:

        void newCameraImage(QImage);

        
        void newPhoto(QImage);

        
        void newMask(QImage);

        
        void setGUIInfo(QString);
        
        void setGUIStatus(QString);
                
        void newStatusMessage(int, QString);
        
        void activateButton(int);

public :
        ros::ServiceClient prosilica_client;
        
        ros::ServiceClient laserscanner_client;
        
        ros::ServiceClient lasertilt_client;

        
        ros::ServiceClient pen_gripper_client;                          
        ros::ServiceClient contour_detector_client;                     
        ros::ServiceClient painter_client;                                      
        ros::ServiceClient corner_client;                                       

        
        FaceFind();


        
        void ImageCBAll(const sensor_msgs::Image::ConstPtr &limage);


        void FacePosCBAll(const people_msgs::PositionMeasurement::ConstPtr &position);


        void CameraModelCBAll(const sensor_msgs::CameraInfoConstPtr& cam_info);


        void ProsilicaCameraModelCBAll(const sensor_msgs::CameraInfoConstPtr& cam_info);


        void ProsilicaCBAll(const sensor_msgs::Image::ConstPtr &image);

        
        bool StatusMessageCBAll(portrait_robot_msgs::alubsc_status_msg::Request &req,
                portrait_robot_msgs::alubsc_status_msg::Response &res);


        bool EdgeImageCBAll(portrait_robot_msgs::alubsc_node_instr::Request &req,
                portrait_robot_msgs::alubsc_node_instr::Response &res);

        void TurnHead(cv::Point3d facecenter);


        void MakeMask(cv::Mat& maskImage);



        void Cluster(cv::Mat_<cv::Vec3b>& copy, int n_x, int border_x, int inc_x, int n_y, int border_y, int inc_y);


        void AdjustLaser(geometry_msgs::Point p);


        void TakePhoto(uint index);


        QImage cvMat2QImage(const cv::Mat& image, unsigned int idx);

private:
        cv::Mat storedImage_;
        cv::Mat storedProsilicaImage_;
        cv::Mat storedPhoto_;
        cv::Mat storedMaskImage_;
        cv::Mat storedMirroredMaskImage_;
        cv::Mat edgeImage_;
        
        std::deque<FaceWrapper> facesQueue_;

        image_geometry::PinholeCameraModel model_;

        image_geometry::PinholeCameraModel prosilicamodel_;
        
        std::vector<cv::Mat> rgbaBuffer_;
        
        cv::Point lastMousePosition_;
        int mouseClicked_;
        
        bool CheckFaceBox(int x1, int y1, int x2, int y2);

        
        void StartPhoto(uint index);

        
        void MirrorPointCloud();
        bool mirror_;
        bool mirroredMaskExists_;
        
        bool headBusy_;
        
        int drawingCorners_;
        
        ros::Time lastCameraImage_;
};

#endif