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, bool training = 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, std::map<std::string, boost::shared_ptr<TomGine::tgPose> > & poses, std::map<std::string, double> & confs);

  bool recognize(IplImage* tFrame, std::map<std::string, boost::shared_ptr<TomGine::tgPose> > & poses, std::map<std::string, double> & confs, const std::map<std::string, bool> & select);

        void initTrainingModel();


        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
        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;
        /* Used to load model in tracking, only one needed */
        P::ModelObject3D m_sift_model_learner;
        /* Use to perform detection, one should do it */
        P::ODetect3D m_detect;
        /* Store the model, need one per object */
        std::vector< boost::shared_ptr<P::Object3D> > m_sift_models;

        /* Store all sifts in the image, shared among the objects */
        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_ */