people_detector.h

Go to the documentation of this file.

#ifndef __PEOPLEDETECTOR_H__
#define __PEOPLEDETECTOR_H__

#ifdef __LINUX__
        //#include "cob_vision_ipa_utils/MathUtils.h"
        //#include "cob_sensor_fusion/ColoredPointCloud.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
#include <fstream>
#include <set>
#include <opencv/ml.h>
#include <opencv/cv.h>

namespace ipa_PeopleDetector {

class PeopleDetector
{
public:

        PeopleDetector(void); 
        ~PeopleDetector(void); 

        virtual unsigned long Init(std::string directory);

        virtual unsigned long DetectColorFaces(cv::Mat& img, std::vector<cv::Rect>& faceCoordinates);

        virtual unsigned long DetectRangeFace(cv::Mat& img, std::vector<cv::Rect>& rangeFaceCoordinates, bool fillUnassignedDepthValues=false);

        virtual unsigned long DetectFaces(cv::Mat& img, cv::Mat& rangeImg, std::vector<cv::Rect>& colorFaceCoordinates, std::vector<cv::Rect>& rangeFaceCoordinates, std::set<size_t>& colorToRangeFaceDependency, bool fillUnassignedDepthValues=false);

        virtual unsigned long AddFace(cv::Mat& img, cv::Rect& face, std::string id, std::vector<cv::Mat>& images, std::vector<std::string>& ids);

        virtual unsigned long ConvertAndResize(cv::Mat& img, cv::Mat& resized, cv::Rect& face);

        virtual cv::Mat preprocessImage(cv::Mat& input_image);

        virtual unsigned long PCA(int* nEigens, std::vector<cv::Mat>& eigenVectors, cv::Mat& eigenValMat, cv::Mat& avgImage, std::vector<cv::Mat>& images, cv::Mat& projectedTrainFaceMat);

        virtual unsigned long RecognizeFace(cv::Mat& colorImage, std::vector<cv::Rect>& colorFaces, int* nEigens, std::vector<cv::Mat>& eigenVectArr, cv::Mat& avgImage, cv::Mat& projectedTrainFaceMat,
                                                                                                                                                        std::vector<int>& index, int *threshold, int *threshold_FS, cv::Mat& eigenValMat, cv::SVM* personClassifier = 0);

        virtual unsigned long ClassifyFace(float *projectedTestFace, int *nearest, int *nEigens, cv::Mat& projectedTrainFaceMat, int *threshold, cv::Mat& eigenValMat, cv::SVM* personClassifier = 0);

        virtual unsigned long CalculateFaceClasses(cv::Mat& projectedTrainFaceMat, std::vector<std::string>& id, int *nEigens, cv::Mat& faceClassAvgProjections, std::vector<std::string>& idUnique, cv::SVM* personClassifier = 0);

        double m_faces_increase_search_scale;           
        int m_faces_drop_groups;                                        
        int m_faces_min_search_scale_x;                         
        int m_faces_min_search_scale_y;                         

        double m_range_increase_search_scale;           
        int m_range_drop_groups;                                        
        int m_range_min_search_scale_x;                         
        int m_range_min_search_scale_y;                         

private:
        unsigned long InterpolateUnassignedPixels(cv::Mat& img);

        CvMemStorage* m_storage;                                        
        CvHaarClassifierCascade* m_face_cascade;        
        CvHaarClassifierCascade* m_range_cascade;       
};

} // end namespace

#endif // __PEOPLEDETECTOR_H__