face_recognizer_algorithms.h

Go to the documentation of this file.

#include<opencv/cv.h>
#include<iostream>
#include<opencv/highgui.h>
#include<opencv/ml.h>
#include<fstream>
#include<ostream>
#include<limits>

#include<cob_people_detection/subspace_analysis.h>

#include<boost/filesystem.hpp>
#include<boost/lexical_cast.hpp>

namespace ipa_PeopleDetector
{

enum Classifier
{
        CLASS_DIFS, CLASS_SVM, CLASS_KNN, CLASS_RF
};

enum Method
{
        NONE, METH_FISHER, METH_EIGEN, METH_LDA2D, METH_PCA2D
};

class FaceRecognizerBaseClass
{
public:
        FaceRecognizerBaseClass() :
                use_unknown_thresh_(false), trained_(false)
        {
        }
        ;

        virtual ~FaceRecognizerBaseClass()
        {
        }
        ;

        virtual bool trainModel(std::vector<cv::Mat>& img_vec, std::vector<int>& label_vec, int& target_dim)=0;

        virtual void classifyImage(cv::Mat& probe_mat, int& max_prob_index)=0;

        virtual void classifyImage(cv::Mat& probe_mat, int& max_prob_index, cv::Mat& classification_probabilities)=0;

        virtual bool saveModel(boost::filesystem::path& model_file)=0;

        virtual bool loadModel(boost::filesystem::path& model_file)=0;

        inline virtual void activate_unknown_treshold()
        {
                use_unknown_thresh_ = true;
        }
        ;

        bool trained_; 
protected:

        virtual void extractFeatures(std::vector<cv::Mat>& src_vec, cv::Mat& proj_mat, std::vector<cv::Mat>& coeff_vec)=0;
        virtual void extractFeatures(cv::Mat& src_mat, cv::Mat& proj_mat, cv::Mat& coeff_mat)=0;

        virtual void calcDIFS(cv::Mat& probe_mat, int& minDIFSindex, double& minDIFS, cv::Mat& probabilities)=0;

        virtual void calc_threshold(cv::Mat& data, double& thresh)=0;

        virtual void calc_threshold(std::vector<cv::Mat>& data, double& thresh)=0;
        virtual bool input_param_check(std::vector<cv::Mat>& imgs, std::vector<int>& labels, int& target_dim);

        inline bool is_known(double& distance, double& threshold)
        {
                if (distance >= threshold)
                        return false;
                return true;
        }
        ;

        double unknown_thresh_; 
        cv::Size source_dim_; 
        int target_dim_; 
        int num_classes_; 
        cv::Mat projection_mat_;
        cv::Mat eigenvalues_; 
        std::vector<int> model_label_vec_; 
        bool use_unknown_thresh_; 
};

class FaceRecognizer1D: public FaceRecognizerBaseClass
{

public:
        FaceRecognizer1D()
        {
        }
        ;
        virtual ~FaceRecognizer1D()
        {
        }
        ;

        virtual void extractFeatures(std::vector<cv::Mat>& src_vec, cv::Mat& proj_mat, std::vector<cv::Mat>& coeff_vec)
        {
        }
        ;
        virtual void extractFeatures(cv::Mat& src_vec, cv::Mat& proj_mat, cv::Mat& coeff_vec);
        virtual void classifyImage(cv::Mat& probe_mat, int& max_prob_index);
        virtual void classifyImage(cv::Mat& probe_mat, int& max_prob_index, cv::Mat& classification_probabilities);
        virtual void calcDIFS(cv::Mat& probe_mat, int& minDIFSindex, double& minDIFS, cv::Mat& probabilities);
        virtual void calc_threshold(cv::Mat& data, double& thresh);
        virtual void calc_threshold(std::vector<cv::Mat>& data, double& thresh)
        {
        }
        ;

        virtual bool saveModel(boost::filesystem::path& model_file);
        virtual bool loadModel(boost::filesystem::path& model_file);

        virtual void model_data_mat(std::vector<cv::Mat>& input_data, cv::Mat& data_mat);

protected:
        cv::Mat average_arr_;
        cv::Mat model_features_;

};

class FaceRecognizer2D: public FaceRecognizerBaseClass
{

public:
        virtual void extractFeatures(std::vector<cv::Mat>& src_vec, cv::Mat& proj_mat, std::vector<cv::Mat>& coeff_vec);
        virtual void extractFeatures(cv::Mat& src_vec, cv::Mat& proj_mat, cv::Mat& coeff_vec);
        virtual void classifyImage(cv::Mat& probe_mat, int& max_prob_index, cv::Mat& classification_probabilities);
        virtual void classifyImage(cv::Mat& probe_mat, int& max_prob_index);
        virtual void calcDIFS(cv::Mat& probe_mat, int& minDIFSindex, double& minDIFS, cv::Mat& probabilities);
        virtual void calc_threshold(cv::Mat& data, double& thresh)
        {
        }
        ;
        virtual void calc_threshold(std::vector<cv::Mat>& data, double& thresh);

        virtual bool saveModel(boost::filesystem::path& model_file);
        virtual bool loadModel(boost::filesystem::path& model_file);

protected:
        cv::Mat average_mat_;
        std::vector<cv::Mat> model_features_;
};

class FaceRecognizer_Eigenfaces: public FaceRecognizer1D
{
public:
        FaceRecognizer_Eigenfaces()
        {
        }
        ;
        virtual ~FaceRecognizer_Eigenfaces()
        {
        }
        ;
        virtual bool trainModel(std::vector<cv::Mat>& img_vec, std::vector<int>& label_vec, int& target_dim);
};

class FaceRecognizer_Fisherfaces: public FaceRecognizer1D
{
public:
        FaceRecognizer_Fisherfaces()
        {
        }
        ;
        virtual ~FaceRecognizer_Fisherfaces()
        {
        }
        ;
        virtual bool trainModel(std::vector<cv::Mat>& img_vec, std::vector<int>& label_vec, int& target_dim);

protected:
        SubspaceAnalysis::LDA lda_;
};

class FaceRecognizer_LDA2D: public FaceRecognizer2D
{
public:
        FaceRecognizer_LDA2D()
        {
        }
        ;
        virtual ~FaceRecognizer_LDA2D()
        {
        }
        ;
        virtual bool trainModel(std::vector<cv::Mat>& img_vec, std::vector<int>& label_vec, int& target_dim);
};

class FaceRecognizer_PCA2D: public FaceRecognizer2D
{
public:
        FaceRecognizer_PCA2D()
        {
        }
        ;
        virtual ~FaceRecognizer_PCA2D()
        {
        }
        ;
        virtual bool trainModel(std::vector<cv::Mat>& img_vec, std::vector<int>& label_vec, int& target_dim);
};

}
;