ObjectDetectorProvider.h

Go to the documentation of this file.

#ifndef __OBJECT_DETECTOR_PROVIDER__
#define __OBJECT_DETECTOR_PROVIDER__

#include "ros/ros.h"
#include "std_msgs/String.h"
#include "sensor_msgs/Image.h"
#include "sensor_msgs/CameraInfo.h"
#include "image_transport/image_transport.h"
#include "cv_bridge/CvBridge.h"
#include "re_vision/SearchFor.h"
#include "re_msgs/DetectedObject.h"
#include "CameraBridge.h"
#include <vector>
#include <string>

#include "ObjectModel.h"
#include "ObjectDetectorMethod.h"
#include "VisualizationManager.h"

#include <opencv/cv.h>


using namespace std;

class ObjectDetectorProvider
{
public:

  ObjectDetectorProvider(const ros::NodeHandle& node_handle);

  ObjectDetectorProvider(const ros::NodeHandle& node_handle,
    const CameraBridge &camera);

        virtual ~ObjectDetectorProvider();

        void init();

        bool ServiceSearchFor(re_vision::SearchFor::Request  &req,
                re_vision::SearchFor::Response &res );

  void TopicNewModel(const std_msgs::String::ConstPtr& msg);

  void TopicCameraInfo(const sensor_msgs::CameraInfo::ConstPtr& caminfo);

  void SetDebugMode(bool onoff, const std::string &dir = "");

  void SetVisualizationMode(bool onoff);

protected:
        // ROS-related functions

        cv::Mat getImage(const re_vision::SearchFor::Request &req);

        void showRequestInformation(const re_vision::SearchFor::Request &req,
                const cv::Mat &image) const;

        //void showImage(const cv::Mat &image) const;

        void processRequest(const re_vision::SearchFor::Request  &req,
                const cv::Mat &image, re_vision::SearchFor::Response &res);

        void emptyResponse(const re_vision::SearchFor::Request &req,
          re_vision::SearchFor::Response &res) const;

protected:
        // Detector-related functions

        void createDetectionAlgorithms();

        void learnNewModel(const std::string &path);

        void removeModel(const std::string &name);

        void rectifyDetections(std::vector<re_msgs::DetectedObject> &detections,
          int W, int H, int max_points_per_object) const;

        //void removeUnknownObjects(const std::vector<std::string> &objects,
        //      std::vector<std::string> &filtered) const;

        //virtual void initLearning() = 0;
        //virtual void finishLearning() = 0;

        void detectObjects(const std::vector<std::string> &objects,
                             const cv::Mat &image, int max_points_per_object,
                             std::vector<re_msgs::DetectedObject*> &ret);

  void removeSomePoints(re_msgs::DetectedObject& detection,
    int max_points) const;

        inline bool debugMode() const { return m_debug; }

        // Returns a reference to the camera
        inline const CameraBridge& getCamera() const
        {
                return m_camera;
        }

        void getValidObjects(const std::vector<std::string> &objects,
                std::vector<std::string>& valid_objects,
                std::vector<re_msgs::DetectedObject> &detections,
                std::vector<re_msgs::DetectedObject *> &pointers) const;

        /*
protected:


        // This function object is executed by another thread.
        // It must set m_ready = true when finished
        struct asyncLearner
        {
                asyncLearner(ObjectDetectorProvider &parent):
                        m_parent(parent){}

                void operator()();

                private:
                        ObjectDetectorProvider& m_parent;
        };


        void asyncLearnModels();
        */

protected:
        ros::NodeHandle m_node_handle;
        ros::ServiceServer m_service;
        ros::Subscriber m_new_model_sub;
        ros::Subscriber *m_camera_info_sub;
        ros::Publisher m_visualization_pub;
        sensor_msgs::CvBridge m_bridge;


  //std::string m_camera_info_topic;
        CameraBridge m_camera;
        bool m_camera_info_got;

        //bool m_ready;
        bool m_debug;

        // visualization flag
        VisualizationManager *m_visualizer;
        bool m_visualization;

        //std::vector<ParsedObjectInformation> m_object_list;

        // Map object_name -> object_model
        typedef std::map<std::string, ObjectModel*> tModelMap;
        tModelMap m_models;

        // Map object_type -> object_detection_algorithm
        typedef std::map<std::string, ObjectDetectorMethod*> tAlgorithmMap;
        tAlgorithmMap m_algorithms;

};

#endif