Visual Servoing Platform version 3.5.0
vpKltOpencv.h
1/****************************************************************************
2 *
3 * ViSP, open source Visual Servoing Platform software.
4 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5 *
6 * This software is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 * See the file LICENSE.txt at the root directory of this source
11 * distribution for additional information about the GNU GPL.
12 *
13 * For using ViSP with software that can not be combined with the GNU
14 * GPL, please contact Inria about acquiring a ViSP Professional
15 * Edition License.
16 *
17 * See http://visp.inria.fr for more information.
18 *
19 * This software was developed at:
20 * Inria Rennes - Bretagne Atlantique
21 * Campus Universitaire de Beaulieu
22 * 35042 Rennes Cedex
23 * France
24 *
25 * If you have questions regarding the use of this file, please contact
26 * Inria at visp@inria.fr
27 *
28 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30 *
31 * Description:
32 * Wrapper for the KLT (Kanade-Lucas-Tomasi) feature tracker implemented
33 * with opencv.
34 *
35 * Authors:
36 * Fabien Servant
37 * Fabien Spindler
38 *
39 *****************************************************************************/
40
48#ifndef vpKltOpencv_h
49#define vpKltOpencv_h
50
51#include <visp3/core/vpColor.h>
52#include <visp3/core/vpConfig.h>
53#include <visp3/core/vpImage.h>
54
55#if (defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION >= 0x020408))
56
57#include <opencv2/highgui/highgui.hpp>
58#include <opencv2/imgproc/imgproc.hpp>
59#include <opencv2/video/tracking.hpp>
60
78class VISP_EXPORT vpKltOpencv
79{
80public:
82 vpKltOpencv(const vpKltOpencv &copy);
83 virtual ~vpKltOpencv();
84
85 void addFeature(const float &x, const float &y);
86 void addFeature(const long &id, const float &x, const float &y);
87 void addFeature(const cv::Point2f &f);
88
89 void display(const vpImage<unsigned char> &I, const vpColor &color = vpColor::red, unsigned int thickness = 1);
90 static void display(const vpImage<unsigned char> &I, const std::vector<cv::Point2f> &features,
91 const vpColor &color = vpColor::green, unsigned int thickness = 1);
92 static void display(const vpImage<vpRGBa> &I, const std::vector<cv::Point2f> &features,
93 const vpColor &color = vpColor::green, unsigned int thickness = 1);
94 static void display(const vpImage<unsigned char> &I, const std::vector<cv::Point2f> &features,
95 const std::vector<long> &featuresid, const vpColor &color = vpColor::green,
96 unsigned int thickness = 1);
97 static void display(const vpImage<vpRGBa> &I, const std::vector<cv::Point2f> &features,
98 const std::vector<long> &featuresid, const vpColor &color = vpColor::green,
99 unsigned int thickness = 1);
100
102 int getBlockSize() const { return m_blockSize; }
103 void getFeature(const int &index, long &id, float &x, float &y) const;
105 std::vector<cv::Point2f> getFeatures() const { return m_points[1]; }
106 // CvPoint2D32f* getFeatures() const {return features;}
108 std::vector<long> getFeaturesId() const { return m_points_id; }
109 // long* getFeaturesId() const {return featuresid;}
111 double getHarrisFreeParameter() const { return m_harris_k; }
113 // bool *getListOfLostFeature() const { return lostDuringTrack; }
115 int getMaxFeatures() const { return m_maxCount; }
118 double getMinDistance() const { return m_minDistance; }
120 int getNbFeatures() const { return (int)m_points[1].size(); }
122 int getNbPrevFeatures() const { return (int)m_points[0].size(); }
123 // void getPrevFeature(int index, int &id, float &x, float &y) const;
125 std::vector<cv::Point2f> getPrevFeatures() const { return m_points[0]; }
126 // CvPoint2D32f* getPrevFeatures() const {return prev_features;}
128 // long* getPrevFeaturesId() const {return prev_featuresid;}
130 int getPyramidLevels() const { return m_pyrMaxLevel; }
133 double getQuality() const { return m_qualityLevel; }
135 int getWindowSize() const { return m_winSize; }
136
137 void initTracking(const cv::Mat &I, const cv::Mat &mask = cv::Mat());
138 void initTracking(const cv::Mat &I, const std::vector<cv::Point2f> &pts);
139 void initTracking(const cv::Mat &I, const std::vector<cv::Point2f> &pts, const std::vector<long> &ids);
140
141 vpKltOpencv &operator=(const vpKltOpencv &copy);
142 void track(const cv::Mat &I);
143 void setBlockSize(int blockSize);
144 void setHarrisFreeParameter(double harris_k);
145 void setInitialGuess(const std::vector<cv::Point2f> &guess_pts);
146 void setInitialGuess(const std::vector<cv::Point2f> &init_pts, const std::vector<cv::Point2f> &guess_pts,
147 const std::vector<long> &fid);
148 void setMaxFeatures(int maxCount);
149 void setMinDistance(double minDistance);
150 void setMinEigThreshold(double minEigThreshold);
151 void setPyramidLevels(int pyrMaxLevel);
152 void setQuality(double qualityLevel);
155 void setTrackerId(int tid) { (void)tid; }
156 void setUseHarris(int useHarrisDetector);
157 void setWindowSize(int winSize);
158 void suppressFeature(const int &index);
159
160protected:
161 cv::Mat m_gray, m_prevGray;
162 std::vector<cv::Point2f> m_points[2];
163 std::vector<long> m_points_id;
165 cv::TermCriteria m_termcrit;
176};
177
178#elif defined(VISP_HAVE_OPENCV)
179#ifdef _CH_
180#pragma package < opencv >
181#endif
182
183#if (VISP_HAVE_OPENCV_VERSION >= 0x020101) // Require opencv >= 2.1.1
184#include <opencv2/highgui/highgui.hpp>
185#include <opencv2/imgproc/imgproc.hpp>
186#include <opencv2/legacy/legacy.hpp>
187#include <opencv2/video/tracking.hpp>
188#else
189#ifndef _EiC
190#include <ctype.h>
191#include <cv.h>
192#include <highgui.h>
193#include <stdio.h>
194#endif
195#endif
196
197#include <visp3/core/vpDebug.h>
198#include <visp3/core/vpDisplay.h>
199#include <visp3/core/vpException.h>
200#include <visp3/core/vpImage.h>
201#include <visp3/core/vpTrackingException.h>
202
203typedef int (*funccheck)(int, double, double);
204typedef void (*funcinfo)(int, int, int, double, double);
205typedef void (*funcevent)(int);
206
222class VISP_EXPORT vpKltOpencv
223{
224private:
225 int initialized; // Is the tracker ready ?
226
227 int maxFeatures; // Maximum number of features to track (Default 50)
228 int globalcountFeatures; // Keep over time for ID
229
230 int win_size; // Size of search window for tracker (default 10)
231 double quality; // Multiplier for the maxmin eigenvalue; specifies minimal
232 // accepted quality of image corners (default 0.01)
233 double min_distance; // Limit, specifying minimum possible distance between
234 // returned corners; Euclidian distance is used.
235 // (default 10)
236 double harris_free_parameter; // Harris detector free parameter. (default 0.04)
237 int block_size; // Size of the averaging block used by the corner detector
238 // (default 3)
239 int use_harris; // 0 use a simple Minimum EigenValue Detector, != 0 use
240 // Harris (default 1)
241 int pyramid_level; // Number of level for the tracker's gaussian pyramid
242 // data (default 3)
243 int _tid; // tracker id for multiple trackers
244
245 IplImage *image; // Image buffer
246 IplImage *prev_image; // Image buffer for the previous iteration
247 IplImage *pyramid; // Gaussian pyramid data
248 IplImage *prev_pyramid; // Gaussian pyramid data for the previous iteration
249 IplImage *swap_temp; // Internal
250
251 int countFeatures; // Currently tracked features
252 int countPrevFeatures; // Previously tracked features
253
254 CvPoint2D32f *features; // List of features
255 CvPoint2D32f *prev_features; // List of features for previous iteration
256
257 long *featuresid; // Array of ids for features
258 long *prev_featuresid; // Array of ids for previous features
259
260 int flags; // Flags for tracking (internal)
261
262 bool initial_guess; // Bool to precise if the next call to track() uses an
263 // initial guess
264
265 bool *lostDuringTrack; // Result of the tracker for every feature : 1 =
266 // lost, 0 = still present
267 char *status; // Result of the tracker for every features : 0 = lost, 1 =
268 // found
269
270 // EVENT FUNCTION POINTERS
271 funcevent OnInitialize;
272 funcinfo OnFeatureLost;
273 funcinfo OnNewFeature;
274 funcinfo OnMeasureFeature;
275 funccheck IsFeatureValid;
276
277private:
278 // Internal
279 void clean();
280 void cleanAll();
281 void reset();
282
283public:
284 vpKltOpencv();
285 vpKltOpencv(const vpKltOpencv &copy);
286 virtual ~vpKltOpencv();
287
288 void addFeature(const int &id, const float &x, const float &y);
289
290 // Draw the tracked features on the given image
291 void display(const vpImage<unsigned char> &I, vpColor color = vpColor::red, unsigned int thickness = 1);
292
294 int getBlockSize() const { return block_size; }
295 void getFeature(int index, long &id, float &x, float &y) const;
297 CvPoint2D32f *getFeatures() const { return features; }
299 long *getFeaturesId() const { return featuresid; }
301 double getHarrisFreeParameter() const { return harris_free_parameter; }
303 bool *getListOfLostFeature() const { return lostDuringTrack; }
305 int getMaxFeatures() const { return maxFeatures; }
307 double getMinDistance() const { return min_distance; }
309 int getNbFeatures() const { return countFeatures; }
311 int getNbPrevFeatures() const { return countPrevFeatures; }
312 void getPrevFeature(int index, int &id, float &x, float &y) const;
314 CvPoint2D32f *getPrevFeatures() const { return prev_features; }
316 long *getPrevFeaturesId() const { return prev_featuresid; }
318 int getPyramidLevels() const { return pyramid_level; }
320 double getQuality() const { return quality; }
322 int getWindowSize() const { return win_size; }
323
324 // Detect corners in the image. Initialize the tracker
325 void initTracking(const IplImage *I, const IplImage *mask = NULL);
326 void initTracking(const IplImage *I, CvPoint2D32f *pts, int size);
327 void initTracking(const IplImage *I, CvPoint2D32f *pts, long *fid, int size);
328 vpKltOpencv &operator=(const vpKltOpencv &copy);
329 // Track !
330 void track(const IplImage *I);
331
332 // Seters
341 void setBlockSize(int input)
342 {
343 initialized = 0;
344 block_size = input;
345 }
354 void setHarrisFreeParameter(double input)
355 {
356 initialized = 0;
357 harris_free_parameter = input;
358 }
359 void setInitialGuess(CvPoint2D32f **guess_pts);
360 void setInitialGuess(CvPoint2D32f **init_pts, CvPoint2D32f **guess_pts, long *fid, int size);
365 void setIsFeatureValid(funccheck input) { IsFeatureValid = input; }
366
367 /* Should be used only before initTracking */
368 void setMaxFeatures(int input);
377 void setMinDistance(double input)
378 {
379 initialized = 0;
380 min_distance = input;
381 }
382
383 // Functors
384
385 // Event when tracker is initialized -> event(id_tracker)
386 void setOnInitialize(funcevent input) { OnInitialize = input; }
387 // Event when a feature is lost -> event(id_tracker, index, uid, x, y)
388 void setOnFeatureLost(funcinfo input) { OnFeatureLost = input; }
389 // Event when a new feature is found -> event(id_tracker, index, uid, x, y)
390 void setOnNewFeature(funcinfo input) { OnNewFeature = input; }
391 // Event when a feature is found while tracking -> event(id_tracker, index,
392 // uid, x, y)
393 void setOnMeasureFeature(funcinfo input) { OnMeasureFeature = input; }
403 void setPyramidLevels(int input)
404 {
405 initialized = 0;
406 pyramid_level = input;
407 }
408 void setQuality(double input)
409 {
410 initialized = 0;
411 quality = input;
412 }
413 void setTrackerId(int tid) { _tid = tid; }
422 void setUseHarris(int input)
423 {
424 initialized = 0;
425 use_harris = input;
426 }
427 void setWindowSize(int input)
428 {
429 initialized = 0;
430 win_size = input;
431 }
432
433 void suppressFeature(int index);
434
435 // Static Functions
436public:
437 static void display(const vpImage<unsigned char> &I, const CvPoint2D32f *features_list, const int &nbFeatures,
438 vpColor color = vpColor::green, unsigned int thickness = 1);
439 static void display(const vpImage<vpRGBa> &I, const CvPoint2D32f *features_list, const int &nbFeatures,
440 vpColor color = vpColor::green, unsigned int thickness = 1);
441
442 static void display(const vpImage<unsigned char> &I, const CvPoint2D32f *features_list, const long *featuresid_list,
443 const int &nbFeatures, vpColor color = vpColor::green, unsigned int thickness = 1);
444 static void display(const vpImage<vpRGBa> &I, const CvPoint2D32f *features_list, const long *featuresid_list,
445 const int &nbFeatures, vpColor color = vpColor::green, unsigned int thickness = 1);
446};
447
448#endif
449#endif
Class to define RGB colors available for display functionnalities.
Definition: vpColor.h:158
static const vpColor red
Definition: vpColor.h:217
static const vpColor green
Definition: vpColor.h:220
Wrapper for the KLT (Kanade-Lucas-Tomasi) feature tracker implemented in OpenCV. Thus to enable this ...
Definition: vpKltOpencv.h:79
std::vector< long > m_points_id
Keypoint id.
Definition: vpKltOpencv.h:163
int m_useHarrisDetector
Definition: vpKltOpencv.h:172
double getQuality() const
Definition: vpKltOpencv.h:133
int getMaxFeatures() const
Get the list of lost feature.
Definition: vpKltOpencv.h:115
int getNbPrevFeatures() const
Get the number of previous features.
Definition: vpKltOpencv.h:122
void setTrackerId(int tid)
Definition: vpKltOpencv.h:155
int getWindowSize() const
Get the window size used to refine the corner locations.
Definition: vpKltOpencv.h:135
double m_minDistance
Definition: vpKltOpencv.h:168
int getNbFeatures() const
Get the number of current features.
Definition: vpKltOpencv.h:120
cv::TermCriteria m_termcrit
Definition: vpKltOpencv.h:165
std::vector< cv::Point2f > getPrevFeatures() const
Get the list of previous features.
Definition: vpKltOpencv.h:125
double m_minEigThreshold
Definition: vpKltOpencv.h:169
int m_pyrMaxLevel
Definition: vpKltOpencv.h:173
double getHarrisFreeParameter() const
Get the free parameter of the Harris detector.
Definition: vpKltOpencv.h:111
double m_qualityLevel
Definition: vpKltOpencv.h:167
bool m_initial_guess
Definition: vpKltOpencv.h:175
cv::Mat m_gray
Definition: vpKltOpencv.h:161
std::vector< long > getFeaturesId() const
Get the unique id of each feature.
Definition: vpKltOpencv.h:108
double m_harris_k
Definition: vpKltOpencv.h:170
double getMinDistance() const
Definition: vpKltOpencv.h:118
long m_next_points_id
Definition: vpKltOpencv.h:174
int getBlockSize() const
Get the size of the averaging block used to track the features.
Definition: vpKltOpencv.h:102
int getPyramidLevels() const
Get the list of features id.
Definition: vpKltOpencv.h:130
std::vector< cv::Point2f > getFeatures() const
Get the list of current features.
Definition: vpKltOpencv.h:105