face_recognizer.h

Go to the documentation of this file.

#ifndef __FACE_RECOGNIZER_H__
#define __FACE_RECOGNIZER_H__

#ifdef __LINUX__
#include <cob_people_detection/abstract_face_recognizer.h>
#include <cob_people_detection/face_normalizer.h>
#include <cob_people_detection/face_recognizer_algorithms.h>
#else
#include "cob_vision/cob_vision_ipa_utils/common/include/cob_vision_ipa_utils/MathUtils.h"
#include "cob_vision/cob_sensor_fusion/common/include/cob_sensor_fusion/ColoredPointCloud.h"    // todo: necessary?
#endif

// opencv
#include <opencv2/opencv.hpp>

// boost
#include <boost/thread/mutex.hpp>
#include <boost/thread/locks.hpp>
#include "boost/filesystem/path.hpp"
#include "boost/lexical_cast.hpp"

#include <algorithm>
namespace ipa_PeopleDetector
{

class FaceRecognizer: public AbstractFaceRecognizer
{
public:

        FaceRecognizer(void); 
        ~FaceRecognizer(void); 

        virtual unsigned long init(std::string data_directory, int norm_size, bool norm_illumination, bool norm_align, bool norm_extreme_illumination, int metric, bool debug,
                        std::vector<std::string>& identification_labels_to_recognize, int subs_meth, int feature_dim, bool use_unknown_thresh, bool use_depth);

        virtual unsigned long initTraining(std::string data_directory, int norm_size, bool norm_illumination, bool norm_align, bool norm_extreme_illumination, bool debug,
                        std::vector<cv::Mat>& face_images, std::vector<cv::Mat>& face_depthmaps, bool use_depth);

        virtual unsigned long addFace(cv::Mat& color_image, cv::Mat& depth_image, cv::Rect& face_bounding_box, cv::Rect& head_bounding_box, std::string label,
                        std::vector<cv::Mat>& face_images, std::vector<cv::Mat>& face_depthmaps);

        virtual unsigned long updateFaceLabels(std::string old_label, std::string new_label);

        virtual unsigned long updateFaceLabel(int index, std::string new_label);

        virtual unsigned long deleteFaces(std::string label, std::vector<cv::Mat>& face_images, std::vector<cv::Mat>& face_depthmaps);

        virtual unsigned long deleteFace(int index, std::vector<cv::Mat>& face_images, std::vector<cv::Mat>& face_depthmaps);

        virtual unsigned long saveTrainingData(std::vector<cv::Mat>& face_images, std::vector<cv::Mat>& face_depthmaps);
        virtual unsigned long saveTrainingData(std::vector<cv::Mat>& face_images);

        virtual unsigned long trainRecognitionModel(std::vector<std::string>& identification_labels_to_train);

        virtual unsigned long saveRecognitionModel();

        virtual unsigned long loadRecognitionModel(std::vector<std::string>& identification_labels_to_recognize);

        enum Metrics
        {
                EUCLIDEAN, MAHALANOBIS, MAHALANOBISCOSINE
        };

protected:

        virtual unsigned long recognizeFace(cv::Mat& color_image, std::vector<cv::Rect>& face_coordinates, std::vector<std::string>& identification_labels);
        virtual unsigned long recognizeFace(cv::Mat& color_image, cv::Mat& depth_image, std::vector<cv::Rect>& face_coordinates, std::vector<std::string>& identification_labels);

        virtual unsigned long convertAndResize(cv::Mat& img, cv::Mat& resized, cv::Rect& face, cv::Size new_size);

        virtual unsigned long loadTrainingData(std::vector<cv::Mat>& face_images, std::vector<std::string>& identification_labels_to_train);
        virtual unsigned long loadTrainingData(std::vector<cv::Mat>& face_images, std::vector<cv::Mat>& face_depthmaps, std::vector<std::string>& identification_labels_to_train);

        void assertDirectories(boost::filesystem::path& data_directory);

        // DEPTH
        std::vector<std::string> depth_str_labels; 
        std::vector<std::string> depth_str_labels_unique; 
        std::vector<int> depth_num_labels; 
        //
        FaceNormalizer face_normalizer_; 

        ipa_PeopleDetector::FaceRecognizerBaseClass* eff_depth; 
        ipa_PeopleDetector::FaceRecognizerBaseClass* eff_color; 
        std::vector<int> m_label_num;
        int m_rec_method; 
        std::vector<bool> dm_exist; 
        bool m_depth_mode; 
        ipa_PeopleDetector::Method m_subs_meth; 
        bool m_use_unknown_thresh; 
        unsigned long trainFaceRecognition(ipa_PeopleDetector::FaceRecognizerBaseClass* eff, std::vector<cv::Mat>& data, std::vector<int>& labels);
        //----------------------------------------------------
        //----------------------------------------------------

        // data
        std::vector<cv::Mat> m_eigenvectors; 
        IplImage** m_eigenvectors_ipl; 
        cv::Mat m_eigenvalues; 
        cv::Mat m_average_image; 
        cv::Mat m_projected_training_faces; 
        std::vector<std::string> m_face_labels; 
        cv::Mat m_face_class_average_projections; 
        std::vector<std::string> m_current_label_set; 
#if CV_MAJOR_VERSION == 2
        cv::SVM m_face_classifier; 
#else
// OpenCV 3
        cv::Ptr<cv::ml::SVM> m_face_classifier; 
#endif
        boost::filesystem::path m_data_directory; 

        // mutex
        boost::mutex m_data_mutex; 

        // parameters
        int m_norm_size; 
        int m_eigenvectors_per_person; 
        double m_threshold_facespace; 
        double m_threshold_unknown; 
        int m_metric; 
        bool m_debug; 

        int m_feature_dim; 
};

} // end namespace

#endif // __FACE_RECOGNIZER_H__