CFaceDetection.h

Go to the documentation of this file.

/* +---------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)               |
   |                          http://www.mrpt.org/                             |
   |                                                                           |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file        |
   | See: http://www.mrpt.org/Authors - All rights reserved.                   |
   | Released under BSD License. See details in http://www.mrpt.org/License    |
   +---------------------------------------------------------------------------+ */

#ifndef CFaceDetection_H
#define CFaceDetection_H

#include <mrpt/detectors/CObjectDetection.h>
#include <mrpt/detectors/CCascadeClassifierDetection.h>
#include <mrpt/utils/CTimeLogger.h>
#include <mrpt/system/threads.h>
#include <mrpt/synch/CSemaphore.h>
#include <mrpt/obs/CObservation3DRangeScan.h>
#include <mrpt/obs/obs_frwds.h>

namespace mrpt
{
        /** \ingroup mrpt_detectors_grp  */
        namespace detectors
        {
                /** Specific class for face detection.
                  * Methods and variables labeled as experimentals are temporals (for debug or testing
                  * purposes) and may disappear in future versions.
                  * \ingroup mrpt_detectors_grp
                  */
                class DETECTORS_IMPEXP CFaceDetection: public CObjectDetection
                {
                public:
                
                        CCascadeClassifierDetection cascadeClassifier;

                        CFaceDetection();

                        ~CFaceDetection();

                        virtual void init(const mrpt::utils::CConfigFileBase &cfg );

                        virtual void detectObjects_Impl(const mrpt::obs::CObservation *obs, vector_detectable_object &detected);
                        
                        struct TOptions
                        {
                                int             confidenceThreshold;
                                bool    multithread;

                                bool    useCovFilter;
                                bool    useRegionsFilter;
                                bool    useSizeDistanceRelationFilter;
                                bool    useDiagonalDistanceFilter;

                                bool    batchMode;

                        }m_options;

                        struct TTestsOptions
                        {
                                double  planeThreshold;
                                double  planeTest_eigenVal_top;
                                double  planeTest_eigenVal_bottom;
                                double  regionsTest_sumDistThreshold_top;                               
                                double  regionsTest_sumDistThreshold_bottom;                            

                        }m_testsOptions;

                        // Experimental methods
                        void experimental_showMeasurements();

                        void debug_returnResults( const vector_uint &falsePositives, const vector_uint &ignore, unsigned int &falsePositivesDeleted, unsigned int &realFacesDeleted );
                        
                private:

                        mrpt::system::TThreadHandle             m_thread_checkIfFaceRegions;    //!< Thread that execute checkIfFaceRegions filter
                        mrpt::system::TThreadHandle             m_thread_checkIfFacePlaneCov;   //!< Thread that execute checkIfFacePlaneCov filter
                        mrpt::system::TThreadHandle             m_thread_checkIfDiagonalSurface;        //!< Thread that execute checkIfDiagonalSurface filter

                        bool    m_checkIfFaceRegions_res;       //!< Save result of checkIfFaceRegions filter
                        bool    m_checkIfFacePlaneCov_res;      //!< Save result of checkIfFacePlaneCov filter
                        bool    m_checkIfDiagonalSurface_res;   //!< Save result of checkIfDiagonalSurface filter

                        bool    m_end_threads;  //!< Indicates to all threads that must finish their execution
                        
                        mrpt::synch::CSemaphore m_enter_checkIfFaceRegions;     //!< Indicates to thread_checkIfFaceRegions that exist a new face to analyze
                        mrpt::synch::CSemaphore m_enter_checkIfFacePlaneCov;    //!< Indicates to thread_checkIfFacePlaneCov that exist a new face to analyze
                        mrpt::synch::CSemaphore m_enter_checkIfDiagonalSurface; //!< Indicates to thread_checkIfDiagonalSurface that exist a new face to analyze

                        mrpt::synch::CSemaphore m_leave_checkIfFaceRegions;     //!< Indicates to main thread that thread_checkIfFaceRegions has been completed analisis of the last face detected
                        mrpt::synch::CSemaphore m_leave_checkIfFacePlaneCov;    //!< Indicates to main thread that thread_checkIfFacePlaneCov has been completed analisis of the last face detected
                        mrpt::synch::CSemaphore m_leave_checkIfDiagonalSurface; //!< Indicates to main thread that thread_checkIfDiagonalSurface has been completed analisis of the last face detected

                        mrpt::obs::CObservation3DRangeScan m_lastFaceDetected;  //!< Last face detected

                        struct TMeasurement
                        {       
                                bool                    takeMeasures;

                                mrpt::math::CVectorDouble       lessEigenVals;
                                mrpt::math::CVectorDouble       errorEstimations;
                                mrpt::math::CVectorDouble       meanRegions;

                                mrpt::math::CVectorDouble       sumDistances;

                                int                             faceNum;
                                vector_uint             deletedRegions;
                                int                             numPossibleFacesDetected;
                                int                             numRealFacesDetected;

                                bool                    takeTime;

                                bool                    saveMeasurementsToFile;

                        }m_measure;

                        // To take measures abaout execution time
                        mrpt::utils::CTimeLogger        m_timeLog;

                        std::vector<double> m_meanHist;


                        // Test to check if a candidate region is a real face

                        bool checkIfFacePlane( mrpt::obs::CObservation3DRangeScan* face );

                        bool checkIfFacePlaneCov( mrpt::obs::CObservation3DRangeScan* face );

                        void thread_checkIfFacePlaneCov( );

                        static void dummy_checkIfFacePlaneCov( CFaceDetection *obj );


                        bool checkIfFaceRegions( mrpt::obs::CObservation3DRangeScan* face );

                        void thread_checkIfFaceRegions( );

                        static void dummy_checkIfFaceRegions( CFaceDetection *obj );

                        size_t checkRelativePosition( const mrpt::math::TPoint3D &p1, const mrpt::math::TPoint3D &p2, const mrpt::math::TPoint3D &p, double &dist );


                        void thread_checkIfDiagonalSurface( );

                        bool checkIfDiagonalSurface( mrpt::obs::CObservation3DRangeScan* face );

                        bool checkIfDiagonalSurface2( mrpt::obs::CObservation3DRangeScan* face );

                        static void dummy_checkIfDiagonalSurface( CFaceDetection *obj );

                        // Experimental methods to view 3D points

                        void experimental_viewFacePointsScanned( const std::vector<float> &xs, const std::vector<float> &ys, const std::vector<float> &zs );

                        void experimental_viewFacePointsScanned( const mrpt::obs::CObservation3DRangeScan &face );
                        
                        void experimental_viewFacePointsScanned( const std::vector<mrpt::math::TPoint3D> &points );

                        void experimental_viewFacePointsAndEigenVects(  const std::vector<mrpt::math::CArrayDouble<3> > &pointsVector, const mrpt::math::CMatrixDouble &eigenVect, const mrpt::math::CVectorDouble &eigenVal );

                        void experimental_viewRegions( const std::vector<mrpt::math::TPoint3D> regions[9], const mrpt::math::TPoint3D meanPos[3][3] );          

                        // Segmentation methods
                        void experimental_segmentFace( const mrpt::obs::CObservation3DRangeScan &face, mrpt::math::CMatrixTemplate<bool> &region );

                        // Histogram methods
                        void experimental_calcHist( const mrpt::utils::CImage &face, const size_t &c1, const size_t &r1, const size_t &c2, 
                                                                                const size_t &r2, mrpt::math::CMatrixTemplate<unsigned int> &hist );

                        

                }; // End of class
        }

}

#endif