linemod.hpp

// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
 
// This code is also subject to the license terms in the LICENSE_WillowGarage.md file found in this module's directory
 
#ifndef __OPENCV_RGBD_LINEMOD_HPP__
#define __OPENCV_RGBD_LINEMOD_HPP__
 
#include "opencv2/core.hpp"
#include <map>
 
/****************************************************************************************\
*                                 LINE-MOD                                               *
\****************************************************************************************/
 
namespace cv {
namespace linemod {
 
 
struct CV_EXPORTS_W_SIMPLE Feature
{
  CV_PROP_RW int x; 
  CV_PROP_RW int y; 
  CV_PROP_RW int label; 
 
  CV_WRAP Feature() : x(0), y(0), label(0) {}
  CV_WRAP Feature(int x, int y, int label);
 
  void read(const FileNode& fn);
  void write(FileStorage& fs) const;
};
 
inline Feature::Feature(int _x, int _y, int _label) : x(_x), y(_y), label(_label) {}
 
struct CV_EXPORTS_W_SIMPLE Template
{
  CV_PROP int width;
  CV_PROP int height;
  CV_PROP int pyramid_level;
  CV_PROP std::vector<Feature> features;
 
  void read(const FileNode& fn);
  void write(FileStorage& fs) const;
};
 
class CV_EXPORTS_W QuantizedPyramid
{
public:
  // Virtual destructor
  virtual ~QuantizedPyramid() {}
 
  CV_WRAP virtual void quantize(CV_OUT Mat& dst) const =0;
 
  CV_WRAP virtual bool extractTemplate(CV_OUT Template& templ) const =0;
 
  CV_WRAP virtual void pyrDown() =0;
 
protected:
  struct Candidate
  {
    Candidate(int x, int y, int label, float score);
 
    bool operator<(const Candidate& rhs) const
    {
      return score > rhs.score;
    }
 
    Feature f;
    float score;
  };
 
  static void selectScatteredFeatures(const std::vector<Candidate>& candidates,
                                      std::vector<Feature>& features,
                                      size_t num_features, float distance);
};
 
inline QuantizedPyramid::Candidate::Candidate(int x, int y, int label, float _score) : f(x, y, label), score(_score) {}
 
class CV_EXPORTS_W Modality
{
public:
  // Virtual destructor
  virtual ~Modality() {}
 
  CV_WRAP Ptr<QuantizedPyramid> process(const Mat& src,
                    const Mat& mask = Mat()) const
  {
    return processImpl(src, mask);
  }
 
  CV_WRAP virtual String name() const =0;
 
  CV_WRAP virtual void read(const FileNode& fn) =0;
  virtual void write(FileStorage& fs) const =0;
 
  CV_WRAP static Ptr<Modality> create(const String& modality_type);
 
  CV_WRAP static Ptr<Modality> create(const FileNode& fn);
 
protected:
  // Indirection is because process() has a default parameter.
  virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
                        const Mat& mask) const =0;
};
 
class CV_EXPORTS_W ColorGradient : public Modality
{
public:
  ColorGradient();
 
  ColorGradient(float weak_threshold, size_t num_features, float strong_threshold);
 
  CV_WRAP static Ptr<ColorGradient> create(float weak_threshold, size_t num_features, float strong_threshold);
 
  virtual String name() const CV_OVERRIDE;
 
  virtual void read(const FileNode& fn) CV_OVERRIDE;
  virtual void write(FileStorage& fs) const CV_OVERRIDE;
 
  CV_PROP float weak_threshold;
  CV_PROP size_t num_features;
  CV_PROP float strong_threshold;
 
protected:
  virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
                        const Mat& mask) const CV_OVERRIDE;
};
 
class CV_EXPORTS_W DepthNormal : public Modality
{
public:
  DepthNormal();
 
  DepthNormal(int distance_threshold, int difference_threshold, size_t num_features,
              int extract_threshold);
 
  CV_WRAP static Ptr<DepthNormal> create(int distance_threshold, int difference_threshold,
                                         size_t num_features, int extract_threshold);
 
  virtual String name() const CV_OVERRIDE;
 
  virtual void read(const FileNode& fn) CV_OVERRIDE;
  virtual void write(FileStorage& fs) const CV_OVERRIDE;
 
  CV_PROP int distance_threshold;
  CV_PROP int difference_threshold;
  CV_PROP size_t num_features;
  CV_PROP int extract_threshold;
 
protected:
  virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
                        const Mat& mask) const CV_OVERRIDE;
};
 
CV_EXPORTS_W void colormap(const Mat& quantized, CV_OUT Mat& dst);
 
CV_EXPORTS_W void drawFeatures(InputOutputArray img, const std::vector<Template>& templates, const Point2i& tl, int size = 10);
 
struct CV_EXPORTS_W_SIMPLE Match
{
  CV_WRAP Match()
  {
  }
 
  CV_WRAP Match(int x, int y, float similarity, const String& class_id, int template_id);
 
  bool operator<(const Match& rhs) const
  {
    // Secondarily sort on template_id for the sake of duplicate removal
    if (similarity != rhs.similarity)
      return similarity > rhs.similarity;
    else
      return template_id < rhs.template_id;
  }
 
  bool operator==(const Match& rhs) const
  {
    return x == rhs.x && y == rhs.y && similarity == rhs.similarity && class_id == rhs.class_id;
  }
 
  CV_PROP_RW int x;
  CV_PROP_RW int y;
  CV_PROP_RW float similarity;
  CV_PROP_RW String class_id;
  CV_PROP_RW int template_id;
};
 
inline
Match::Match(int _x, int _y, float _similarity, const String& _class_id, int _template_id)
    : x(_x), y(_y), similarity(_similarity), class_id(_class_id), template_id(_template_id)
{}
 
class CV_EXPORTS_W Detector
{
public:
  CV_WRAP Detector();
 
  CV_WRAP Detector(const std::vector< Ptr<Modality> >& modalities, const std::vector<int>& T_pyramid);
 
  CV_WRAP void match(const std::vector<Mat>& sources, float threshold, CV_OUT std::vector<Match>& matches,
             const std::vector<String>& class_ids = std::vector<String>(),
             OutputArrayOfArrays quantized_images = noArray(),
             const std::vector<Mat>& masks = std::vector<Mat>()) const;
 
  CV_WRAP int addTemplate(const std::vector<Mat>& sources, const String& class_id,
          const Mat& object_mask, CV_OUT Rect* bounding_box = NULL);
 
  CV_WRAP int addSyntheticTemplate(const std::vector<Template>& templates, const String& class_id);
 
  CV_WRAP const std::vector< Ptr<Modality> >& getModalities() const { return modalities; }
 
  CV_WRAP int getT(int pyramid_level) const { return T_at_level[pyramid_level]; }
 
  CV_WRAP int pyramidLevels() const { return pyramid_levels; }
 
  CV_WRAP const std::vector<Template>& getTemplates(const String& class_id, int template_id) const;
 
  CV_WRAP int numTemplates() const;
  CV_WRAP int numTemplates(const String& class_id) const;
  CV_WRAP int numClasses() const { return static_cast<int>(class_templates.size()); }
 
  CV_WRAP std::vector<String> classIds() const;
 
  CV_WRAP void read(const FileNode& fn);
  void write(FileStorage& fs) const;
 
  String readClass(const FileNode& fn, const String &class_id_override = "");
  void writeClass(const String& class_id, FileStorage& fs) const;
 
  CV_WRAP void readClasses(const std::vector<String>& class_ids,
                   const String& format = "templates_%s.yml.gz");
  CV_WRAP void writeClasses(const String& format = "templates_%s.yml.gz") const;
 
protected:
  std::vector< Ptr<Modality> > modalities;
  int pyramid_levels;
  std::vector<int> T_at_level;
 
  typedef std::vector<Template> TemplatePyramid;
  typedef std::map<String, std::vector<TemplatePyramid> > TemplatesMap;
  TemplatesMap class_templates;
 
  typedef std::vector<Mat> LinearMemories;
  // Indexed as [pyramid level][modality][quantized label]
  typedef std::vector< std::vector<LinearMemories> > LinearMemoryPyramid;
 
  void matchClass(const LinearMemoryPyramid& lm_pyramid,
                  const std::vector<Size>& sizes,
                  float threshold, std::vector<Match>& matches,
                  const String& class_id,
                  const std::vector<TemplatePyramid>& template_pyramids) const;
};
 
CV_EXPORTS_W Ptr<linemod::Detector> getDefaultLINE();
 
CV_EXPORTS_W Ptr<linemod::Detector> getDefaultLINEMOD();
 
 
} // namespace linemod
} // namespace cv
 
#endif // __OPENCV_OBJDETECT_LINEMOD_HPP__