OpenCV 4.5.3(日本語機械翻訳)
linemod.hpp
1 // This file is part of OpenCV project.
2 // It is subject to the license terms in the LICENSE file found in the top-level directory
3 // of this distribution and at http://opencv.org/license.html
4
5 // This code is also subject to the license terms in the LICENSE_WillowGarage.md file found in this module's directory
6
7 #ifndef __OPENCV_RGBD_LINEMOD_HPP__
8 #define __OPENCV_RGBD_LINEMOD_HPP__
9
10 #include "opencv2/core.hpp"
11 #include <map>
12
13 /****************************************************************************************\
14 * LINE-MOD *
15 \****************************************************************************************/
16
17 namespace cv {
18 namespace linemod {
19
22
26 struct CV_EXPORTS_W_SIMPLE Feature
27{
28 CV_PROP_RW int x;
29 CV_PROP_RW int y;
30 CV_PROP_RW int label;
31
32 CV_WRAP Feature() : x(0), y(0), label(0) {}
33 CV_WRAP Feature(int x, int y, int label);
34
35 void read(const FileNode& fn);
36 void write(FileStorage& fs) const;
37};
38
39 inline Feature::Feature(int _x, int _y, int _label) : x(_x), y(_y), label(_label) {}
40
41 struct CV_EXPORTS_W_SIMPLE Template
42{
43 CV_PROP int width;
44 CV_PROP int height;
45 CV_PROP int pyramid_level;
46 CV_PROP std::vector<Feature> features;
47
48 void read(const FileNode& fn);
49 void write(FileStorage& fs) const;
50};
51
55 class CV_EXPORTS_W QuantizedPyramid
56{
57 public:
58 // Virtual destructor
59 virtual ~QuantizedPyramid() {}
60
67 CV_WRAP virtual void quantize(CV_OUT Mat& dst) const =0;
68
74 CV_WRAP virtual bool extractTemplate(CV_OUT Template& templ) const =0;
75
81 CV_WRAP virtual void pyrDown() =0;
82
83 protected:
85 struct Candidate
86 {
87 Candidate(int x, int y, int label, float score);
88
90 bool operator<(const Candidate& rhs) const
91 {
92 return score > rhs.score;
93 }
94
95 Feature f;
96 float score;
97 };
98
107 static void selectScatteredFeatures(const std::vector<Candidate>& candidates,
108 std::vector<Feature>& features,
109 size_t num_features, float distance);
110};
111
112 inline QuantizedPyramid::Candidate::Candidate(int x, int y, int label, float _score) : f(x, y, label), score(_score) {}
113
119 class CV_EXPORTS_W Modality
120{
121 public:
122 // Virtual destructor
123 virtual ~Modality() {}
124
132 CV_WRAP Ptr<QuantizedPyramid> process(const Mat& src,
133 const Mat& mask = Mat()) const
134 {
135 return processImpl(src, mask);
136 }
137
138 CV_WRAP virtual String name() const =0;
139
140 CV_WRAP virtual void read(const FileNode& fn) =0;
141 virtual void write(FileStorage& fs) const =0;
142
150 CV_WRAP static Ptr<Modality> create(const String& modality_type);
151
155 CV_WRAP static Ptr<Modality> create(const FileNode& fn);
156
157 protected:
158 // Indirection is because process() has a default parameter.
159 virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
160 const Mat& mask) const =0;
161};
162
166 class CV_EXPORTS_W ColorGradient : public Modality
167{
168 public:
172 ColorGradient();
173
182 ColorGradient(float weak_threshold, size_t num_features, float strong_threshold);
183
184 CV_WRAP static Ptr<ColorGradient> create(float weak_threshold, size_t num_features, float strong_threshold);
185
186 virtual String name() const CV_OVERRIDE;
187
188 virtual void read(const FileNode& fn) CV_OVERRIDE;
189 virtual void write(FileStorage& fs) const CV_OVERRIDE;
190
191 CV_PROP float weak_threshold;
192 CV_PROP size_t num_features;
193 CV_PROP float strong_threshold;
194
195protected:
196 virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
197 const Mat& mask) const CV_OVERRIDE;
198};
199
203 class CV_EXPORTS_W DepthNormal : public Modality
204{
205 public:
209 DepthNormal();
210
221 DepthNormal(int distance_threshold, int difference_threshold, size_t num_features,
222 int extract_threshold);
223
224 CV_WRAP static Ptr<DepthNormal> create(int distance_threshold, int difference_threshold,
225 size_t num_features, int extract_threshold);
226
227 virtual String name() const CV_OVERRIDE;
228
229 virtual void read(const FileNode& fn) CV_OVERRIDE;
230 virtual void write(FileStorage& fs) const CV_OVERRIDE;
231
232 CV_PROP int distance_threshold;
233 CV_PROP int difference_threshold;
234 CV_PROP size_t num_features;
235 CV_PROP int extract_threshold;
236
237protected:
238 virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
239 const Mat& mask) const CV_OVERRIDE;
240};
241
245 CV_EXPORTS_W void colormap(const Mat& quantized, CV_OUT Mat& dst);
246
254 CV_EXPORTS_W void drawFeatures(InputOutputArray img, const std::vector<Template>& templates, const Point2i& tl, int size = 10);
255
259 struct CV_EXPORTS_W_SIMPLE Match
260{
261 CV_WRAP Match()
262 {
263 }
264
265 CV_WRAP Match(int x, int y, float similarity, const String& class_id, int template_id);
266
268 bool operator<(const Match& rhs) const
269 {
270 // Secondarily sort on template_id for the sake of duplicate removal
271 if (similarity != rhs.similarity)
272 return similarity > rhs.similarity;
273 else
274 return template_id < rhs.template_id;
275 }
276
277 bool operator==(const Match& rhs) const
278 {
279 return x == rhs.x && y == rhs.y && similarity == rhs.similarity && class_id == rhs.class_id;
280 }
281
282 CV_PROP_RW int x;
283 CV_PROP_RW int y;
284 CV_PROP_RW float similarity;
285 CV_PROP_RW String class_id;
286 CV_PROP_RW int template_id;
287};
288
289 inline
290Match::Match(int _x, int _y, float _similarity, const String& _class_id, int _template_id)
291 : x(_x), y(_y), similarity(_similarity), class_id(_class_id), template_id(_template_id)
292{}
293
298 class CV_EXPORTS_W Detector
299{
300 public:
304 CV_WRAP Detector();
305
313 CV_WRAP Detector(const std::vector< Ptr<Modality> >& modalities, const std::vector<int>& T_pyramid);
314
330 CV_WRAP void match(const std::vector<Mat>& sources, float threshold, CV_OUT std::vector<Match>& matches,
331 const std::vector<String>& class_ids = std::vector<String>(),
332 OutputArrayOfArrays quantized_images = noArray(),
333 const std::vector<Mat>& masks = std::vector<Mat>()) const;
334
345 CV_WRAP int addTemplate(const std::vector<Mat>& sources, const String& class_id,
346 const Mat& object_mask, CV_OUT Rect* bounding_box = NULL);
347
351 CV_WRAP int addSyntheticTemplate(const std::vector<Template>& templates, const String& class_id);
352
359 CV_WRAP const std::vector< Ptr<Modality> >& getModalities() const { return modalities; }
360
364 CV_WRAP int getT(int pyramid_level) const { return T_at_level[pyramid_level]; }
365
369 CV_WRAP int pyramidLevels() const { return pyramid_levels; }
370
377 CV_WRAP const std::vector<Template>& getTemplates(const String& class_id, int template_id) const;
378
379 CV_WRAP int numTemplates() const;
380 CV_WRAP int numTemplates(const String& class_id) const;
381 CV_WRAP int numClasses() const { return static_cast< int >(class_templates.size()); }
382
383 CV_WRAP std::vector<String> classIds() const;
384
385 CV_WRAP void read(const FileNode& fn);
386 void write(FileStorage& fs) const;
387
388 String readClass(const FileNode& fn, const String &class_id_override = "");
389 void writeClass(const String& class_id, FileStorage& fs) const;
390
391 CV_WRAP void readClasses(const std::vector<String>& class_ids,
392 const String& format = "templates_%s.yml.gz");
393 CV_WRAP void writeClasses(const String& format = "templates_%s.yml.gz") const;
394
395 protected:
396 std::vector< Ptr<Modality> > modalities;
397 int pyramid_levels;
398 std::vector<int> T_at_level;
399
400 typedef std::vector<Template> TemplatePyramid;
401 typedef std::map<String, std::vector<TemplatePyramid> > TemplatesMap;
402 TemplatesMap class_templates;
403
404 typedef std::vector<Mat> LinearMemories;
405 // Indexed as [pyramid level][modality][quantized label]
406 typedef std::vector< std::vector<LinearMemories> > LinearMemoryPyramid;
407
408 void matchClass(const LinearMemoryPyramid& lm_pyramid,
409 const std::vector<Size>& sizes,
410 float threshold, std::vector<Match>& matches,
411 const String& class_id,
412 const std::vector<TemplatePyramid>& template_pyramids) const;
413};
414
420 CV_EXPORTS_W Ptr<linemod::Detector> getDefaultLINE();
421
428 CV_EXPORTS_W Ptr<linemod::Detector> getDefaultLINEMOD();
429
431
432} // namespace linemod
433} // namespace cv
434
435 #endif // __OPENCV_OBJDETECT_LINEMOD_HPP__
cv::_InputOutputArray
Definition: mat.hpp:386
cv::_OutputArray
This type is very similar to InputArray except that it is used for input/output and output function p...
Definition: mat.hpp:295
cv::FileNode
File Storage Node class.
Definition: persistence.hpp:482
cv::FileStorage
XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or readi...
Definition: persistence.hpp:304
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Point_< int >
cv::Rect_
Template class for 2D rectangles
Definition: core/types.hpp:421
cv::linemod::ColorGradient
Modality that computes quantized gradient orientations from a color image.
Definition: linemod.hpp:167
cv::linemod::ColorGradient::ColorGradient
ColorGradient()
Default constructor. Uses reasonable default parameter values.
cv::linemod::ColorGradient::ColorGradient
ColorGradient(float weak_threshold, size_t num_features, float strong_threshold)
Constructor.
cv::linemod::DepthNormal
Modality that computes quantized surface normals from a dense depth map.
Definition: linemod.hpp:204
cv::linemod::DepthNormal::DepthNormal
DepthNormal(int distance_threshold, int difference_threshold, size_t num_features, int extract_threshold)
Constructor.
cv::linemod::DepthNormal::DepthNormal
DepthNormal()
Default constructor. Uses reasonable default parameter values.
cv::linemod::Detector
Object detector using the LINE template matching algorithm with any set of modalities.
Definition: linemod.hpp:299
cv::linemod::Modality
Interface for modalities that plug into the LINE template matching representation.
Definition: linemod.hpp:120
cv::linemod::QuantizedPyramid
Represents a modality operating over an image pyramid.
Definition: linemod.hpp:56
cv::linemod::QuantizedPyramid::selectScatteredFeatures
static void selectScatteredFeatures(const std::vector< Candidate > &candidates, std::vector< Feature > &features, size_t num_features, float distance)
Choose candidate features so that they are not bunched together.
cv::pyrDown
CV_EXPORTS_W void pyrDown(InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
Blurs an image and downsamples it.
cv::threshold
CV_EXPORTS_W double threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type)
Applies a fixed-level threshold to each array element.
cv::linemod::getDefaultLINEMOD
CV_EXPORTS_W Ptr< linemod::Detector > getDefaultLINEMOD()
Factory function for detector using LINE-MOD algorithm with color gradients and depth normals.
cv::linemod::drawFeatures
CV_EXPORTS_W void drawFeatures(InputOutputArray img, const std::vector< Template > &templates, const Point2i &tl, int size=10)
Debug function to draw linemod features
cv::linemod::colormap
CV_EXPORTS_W void colormap(const Mat &quantized, CV_OUT Mat &dst)
Debug function to colormap a quantized image for viewing.
cv::linemod::getDefaultLINE
CV_EXPORTS_W Ptr< linemod::Detector > getDefaultLINE()
Factory function for detector using LINE algorithm with color gradients.
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::Ptr
Definition: cvstd_wrapper.hpp:74
cv::linemod::Feature
Discriminant feature described by its location and label.
Definition: linemod.hpp:27
cv::linemod::Match
Represents a successful template match.
Definition: linemod.hpp:260
cv::linemod::Match::operator<
bool operator<(const Match &rhs) const
Sort matches with high similarity to the front
Definition: linemod.hpp:268
cv::linemod::QuantizedPyramid::Candidate
Candidate feature with a score
Definition: linemod.hpp:86
cv::linemod::QuantizedPyramid::Candidate::operator<
bool operator<(const Candidate &rhs) const
Sort candidates with high score to the front
Definition: linemod.hpp:90
cv::linemod::Template
Definition: linemod.hpp:42
構築: doxygen 1.9.2