Recognizer3D.h

Go to the documentation of this file.

#ifndef _RECOGNIZER_3D_
#define _RECOGNIZER_3D_

#include <blort/Recognizer3D/DetectGPUSIFT.hh>
#include <blort/Recognizer3D/ODetect3D.hh>
#include <blort/Recognizer3D/Object3D.hh>
#include <blort/Recognizer3D/ModelObject3D.hh>
#include <blort/Recognizer3D/KeypointDescriptor.hh>
#include <blort/Recognizer3D/PoseCv.hh>
#include <blort/TomGine/tgModel.h>
#include <blort/TomGine/tgPose.h>
#include <string>
#include <opencv2/core/core.hpp>
#include <sensor_msgs/CameraInfo.h>

namespace blortRecognizer{

struct CameraParameter {
        int w,h;
        float fx, fy;
        float cx, cy;
        float k1, k2, k3;
        float p1, p2;
        CameraParameter(){ w=h=fx=fy=cx=cy=k1=k2=k3=p1=p2=0; }
        CameraParameter(const sensor_msgs::CameraInfo& cam_info);
};

struct Siftex{
        vec3 pos;
        vec3 normal;
        vec3 viewray;
};

class Recognizer3D{

public:
        Recognizer3D(const CameraParameter& camParam, std::string config_root = "",
                     bool display = false);
        ~Recognizer3D();
        
        void setCameraParameter(const blortRecognizer::CameraParameter& camParam);
        
        void setGaussian(int kernel, float stdDeviation){ m_gauss_kernel = kernel; m_gauss_dev = stdDeviation; }
        
        bool recognize(IplImage* tFrame, TomGine::tgPose& pose, float &conf);
        
        bool learnSifts(IplImage* tFrame, const TomGine::tgModel& model, const TomGine::tgPose& pose);
        
        bool loadModelFromFile(const std::string sift_file);
        
        bool saveModelToFile(const char* sift_file);
        
        void getSifts(std::vector<Siftex>& sl){ sl = m_siftexlist; }
        
        void getLastSifts(std::vector<Siftex> &sl){ sl = m_lastsiftexlist; }
        
        //BENCE
        unsigned int getCodeBookSize();
        cv::Mat getImage(){ return display_image; }
        void setDoUndistort(bool enable){ do_undistort = enable; }

        static void Convert(P::PoseCv& p1, TomGine::tgPose& p2);

        void setNNThreshold(double nn_threshold);
        void setRansacNPointsToMatch(unsigned int n);
        cv::Mat getDebugImage(){ return debug_image; }

private:
        Recognizer3D();
        
        P::DetectGPUSIFT sift;
        P::ModelObject3D m_sift_model_learner;
        P::ODetect3D m_detect;
        P::Object3D m_sift_model;
        
        P::Array<P::KeypointDescriptor*> m_image_keys;
        
        std::vector<Siftex> m_lastsiftexlist;
        std::vector<Siftex> m_siftexlist;
        
        CvMat *pIntrinsicDistort;
        CvMat *pDistortion;
        CvMat *C;
        CvMat *pMapX, *pMapY;
        CameraParameter m_cp;
        
        bool m_model_loaded;
        bool m_display;
        
        int m_gauss_kernel;
        float m_gauss_dev;

        //BENCE
        cv::Mat display_image;
        cv::Mat debug_image; // usually empty
        bool do_undistort;
        std::string config_root;
        //cv::Ptr<pal_blort::CvDetect3D> cv_detect;
};

}

#endif /* _RECOGNIZER_3D_ */