Visual Servoing Platform version 3.6.0
Loading...
Searching...
No Matches
tutorial-detection-object-mbt2.cpp
1
2#include <visp3/core/vpConfig.h>
3#include <visp3/core/vpIoTools.h>
4#include <visp3/gui/vpDisplayGDI.h>
5#include <visp3/gui/vpDisplayOpenCV.h>
6#include <visp3/gui/vpDisplayX.h>
7#include <visp3/io/vpVideoReader.h>
8#include <visp3/mbt/vpMbGenericTracker.h>
9#include <visp3/vision/vpKeyPoint.h>
10
11#if defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_FEATURES2D)
12void learnCube(const vpImage<unsigned char> &I, vpMbGenericTracker &tracker, vpKeyPoint &keypoint_learning, int id)
13{
15 std::vector<cv::KeyPoint> trainKeyPoints;
16 double elapsedTime;
17 keypoint_learning.detect(I, trainKeyPoints, elapsedTime);
19
21 std::vector<vpPolygon> polygons;
22 std::vector<std::vector<vpPoint> > roisPt;
23 std::pair<std::vector<vpPolygon>, std::vector<std::vector<vpPoint> > > pair = tracker.getPolygonFaces();
24 polygons = pair.first;
25 roisPt = pair.second;
26
27 std::vector<cv::Point3f> points3f;
29 tracker.getPose(cMo);
31 tracker.getCameraParameters(cam);
32 vpKeyPoint::compute3DForPointsInPolygons(cMo, cam, trainKeyPoints, polygons, roisPt, points3f);
34
36 keypoint_learning.buildReference(I, trainKeyPoints, points3f, true, id);
38
40 for (std::vector<cv::KeyPoint>::const_iterator it = trainKeyPoints.begin(); it != trainKeyPoints.end(); ++it) {
41 vpDisplay::displayCross(I, (int)it->pt.y, (int)it->pt.x, 4, vpColor::red);
42 }
44}
45#endif
46
47int main(int argc, char **argv)
48{
49#if defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_FEATURES2D)
51 try {
52 std::string videoname = "cube.mp4";
53
54 for (int i = 0; i < argc; i++) {
55 if (std::string(argv[i]) == "--name")
56 videoname = std::string(argv[i + 1]);
57 else if (std::string(argv[i]) == "--help" || std::string(argv[i]) == "-h") {
58 std::cout << "\nUsage: " << argv[0] << " [--name <video name>] [--help] [-h]\n" << std::endl;
59 return EXIT_SUCCESS;
60 }
61 }
62 std::string parentname = vpIoTools::getParent(videoname);
63 std::string objectname = vpIoTools::getNameWE(videoname);
64
65 if (!parentname.empty())
66 objectname = parentname + "/" + objectname;
67
68 std::cout << "Video name: " << videoname << std::endl;
69 std::cout << "Tracker requested config files: " << objectname << ".[init,"
70 << "xml,"
71 << "cao or wrl]" << std::endl;
72 std::cout << "Tracker optional config files: " << objectname << ".[ppm]" << std::endl;
73
77
79 bool usexml = false;
80 if (vpIoTools::checkFilename(objectname + ".xml")) {
81 tracker.loadConfigFile(objectname + ".xml");
82 tracker.getCameraParameters(cam);
83 usexml = true;
84 }
85 if (!usexml) {
86 vpMe me;
87 me.setMaskSize(5);
88 me.setMaskNumber(180);
89 me.setRange(7);
91 me.setThreshold(20);
92 me.setMu1(0.5);
93 me.setMu2(0.5);
94 me.setSampleStep(4);
95 me.setNbTotalSample(250);
96 tracker.setMovingEdge(me);
97 cam.initPersProjWithoutDistortion(547, 542, 339, 235);
98 tracker.setCameraParameters(cam);
99 tracker.setAngleAppear(vpMath::rad(89));
100 tracker.setAngleDisappear(vpMath::rad(89));
101 tracker.setNearClippingDistance(0.01);
102 tracker.setFarClippingDistance(10.0);
104 }
105
106 tracker.setOgreVisibilityTest(false);
107 if (vpIoTools::checkFilename(objectname + ".cao"))
108 tracker.loadModel(objectname + ".cao");
109 else if (vpIoTools::checkFilename(objectname + ".wrl"))
110 tracker.loadModel(objectname + ".wrl");
111 tracker.setDisplayFeatures(true);
113
115 vpKeyPoint keypoint_learning("ORB", "ORB", "BruteForce-Hamming");
116#if (VISP_HAVE_OPENCV_VERSION < 0x030000)
117 keypoint_learning.setDetectorParameter("ORB", "nLevels", 1);
118#else
119 cv::Ptr<cv::ORB> orb_learning = keypoint_learning.getDetector("ORB").dynamicCast<cv::ORB>();
120 if (orb_learning) {
121 orb_learning->setNLevels(1);
122 }
123#endif
125
126#if defined(VISP_HAVE_X11)
127 vpDisplayX display;
128#elif defined(VISP_HAVE_GDI)
129 vpDisplayGDI display;
130#elif defined(HAVE_OPENCV_HIGHGUI)
131 vpDisplayOpenCV display;
132#else
133 std::cout << "No image viewer is available..." << std::endl;
134 return EXIT_FAILURE;
135#endif
136
137 /*
138 * Start the part of the code dedicated to object learning from 3 images
139 */
140 std::string imageName [] = { "cube0001.png", "cube0150.png", "cube0200.png" };
141 vpHomogeneousMatrix initPoseTab [] = {
142 vpHomogeneousMatrix(0.02143385294, 0.1098083886, 0.5127439561, 2.087159614, 1.141775176, -0.4701291124),
143 vpHomogeneousMatrix(0.02651282185, -0.03713587374, 0.6873765919, 2.314744454, 0.3492296488, -0.1226054828),
144 vpHomogeneousMatrix(0.02965448956, -0.07283091786, 0.7253526051, 2.300529617, -0.4286674806, 0.1788761025) };
145 for (int i = 0; i < 3; i++) {
146 vpImageIo::read(I, imageName[i]);
147 if (i == 0) {
148 display.init(I, 10, 10);
149 }
150 std::stringstream title;
151 title << "Learning cube on image: " << imageName[i];
152 vpDisplay::setTitle(I, title.str().c_str());
153
155
157 tracker.setPose(I, initPoseTab[i]);
159
161 tracker.track(I);
163
165 tracker.getPose(cMo);
166 tracker.display(I, cMo, cam, vpColor::red);
168
170 learnCube(I, tracker, keypoint_learning, i);
172
173 vpDisplay::displayText(I, 10, 10, "Learning step: keypoints are detected on visible cube faces", vpColor::red);
174 if (i < 2) {
175 vpDisplay::displayText(I, 30, 10, "Click to continue the learning...", vpColor::red);
176 }
177 else {
178 vpDisplay::displayText(I, 30, 10, "Click to continue with the detection...", vpColor::red);
179 }
180
182 vpDisplay::getClick(I, true);
183 }
184
186 keypoint_learning.saveLearningData("cube_learning_data.bin", true);
188
189 /*
190 * Start the part of the code dedicated to detection and localization
191 */
193 vpKeyPoint keypoint_detection("ORB", "ORB", "BruteForce-Hamming");
194#if (VISP_HAVE_OPENCV_VERSION < 0x030000)
195 keypoint_detection.setDetectorParameter("ORB", "nLevels", 1);
196#else
197 cv::Ptr<cv::ORB> orb_detector = keypoint_detection.getDetector("ORB").dynamicCast<cv::ORB>();
198 orb_detector = keypoint_detection.getDetector("ORB").dynamicCast<cv::ORB>();
199 if (orb_detector) {
200 orb_detector->setNLevels(1);
201 }
202#endif
204
206 keypoint_detection.loadLearningData("cube_learning_data.bin", true);
208
210 vpImage<unsigned char> IMatching;
211 keypoint_detection.createImageMatching(I, IMatching);
213
215 g.setFileName(videoname);
216 g.open(I);
217
218#if defined(VISP_HAVE_X11)
219 vpDisplayX display2;
220#elif defined(VISP_HAVE_GTK)
221 vpDisplayGTK display2;
222#elif defined(VISP_HAVE_GDI)
223 vpDisplayGDI display2;
224#elif defined(HAVE_OPENCV_HIGHGUI)
225 vpDisplayOpenCV display2;
226#endif
227 display2.init(IMatching, 50, 50, "Display matching between learned and current images");
228 vpDisplay::setTitle(I, "Cube detection and localization");
229
230 double error;
231 bool click_done = false;
232
233 while (!g.end()) {
234 g.acquire(I);
236
238 keypoint_detection.insertImageMatching(I, IMatching);
240
241 vpDisplay::display(IMatching);
242 vpDisplay::displayText(I, 10, 10, "Detection and localization in process...", vpColor::red);
243
244 double elapsedTime;
246 if (keypoint_detection.matchPoint(I, cam, cMo, error, elapsedTime)) {
248
250 tracker.setPose(I, cMo);
252
254 tracker.display(I, cMo, cam, vpColor::red, 2);
255 vpDisplay::displayFrame(I, cMo, cam, 0.05, vpColor::none, 3);
257
258 keypoint_detection.displayMatching(I, IMatching);
259
261 std::vector<vpImagePoint> ransacInliers = keypoint_detection.getRansacInliers();
262 std::vector<vpImagePoint> ransacOutliers = keypoint_detection.getRansacOutliers();
264
266 for (std::vector<vpImagePoint>::const_iterator it = ransacInliers.begin(); it != ransacInliers.end(); ++it) {
268 vpImagePoint imPt(*it);
269 imPt.set_u(imPt.get_u() + I.getWidth());
270 imPt.set_v(imPt.get_v() + I.getHeight());
271 vpDisplay::displayCircle(IMatching, imPt, 4, vpColor::green);
272 }
274
276 for (std::vector<vpImagePoint>::const_iterator it = ransacOutliers.begin(); it != ransacOutliers.end(); ++it) {
278 vpImagePoint imPt(*it);
279 imPt.set_u(imPt.get_u() + I.getWidth());
280 imPt.set_v(imPt.get_v() + I.getHeight());
281 vpDisplay::displayCircle(IMatching, imPt, 4, vpColor::red);
282 }
284
286 keypoint_detection.displayMatching(I, IMatching);
288
291 cam2.initPersProjWithoutDistortion(cam.get_px(), cam.get_py(), cam.get_u0() + I.getWidth(),
292 cam.get_v0() + I.getHeight());
293 tracker.setCameraParameters(cam2);
294 tracker.setPose(IMatching, cMo);
295 tracker.display(IMatching, cMo, cam2, vpColor::red, 2);
296 vpDisplay::displayFrame(IMatching, cMo, cam2, 0.05, vpColor::none, 3);
298 }
299
301 vpDisplay::displayText(IMatching, 30, 10, "A click to exit.", vpColor::red);
302 vpDisplay::flush(IMatching);
303 if (vpDisplay::getClick(I, false)) {
304 click_done = true;
305 break;
306 }
307 if (vpDisplay::getClick(IMatching, false)) {
308 click_done = true;
309 break;
310 }
311 }
312
313 if (!click_done)
314 vpDisplay::getClick(IMatching);
315 }
316 catch (const vpException &e) {
317 std::cout << "Catch an exception: " << e << std::endl;
318 }
319#else
320 (void)argc;
321 (void)argv;
322 std::cout << "Install OpenCV and rebuild ViSP to use this example." << std::endl;
323#endif
324
325 return EXIT_SUCCESS;
326}
Generic class defining intrinsic camera parameters.
void initPersProjWithoutDistortion(double px, double py, double u0, double v0)
static const vpColor red
Definition vpColor.h:211
static const vpColor none
Definition vpColor.h:223
static const vpColor green
Definition vpColor.h:214
Display for windows using GDI (available on any windows 32 platform).
The vpDisplayGTK allows to display image using the GTK 3rd party library. Thus to enable this class G...
The vpDisplayOpenCV allows to display image using the OpenCV library. Thus to enable this class OpenC...
Use the X11 console to display images on unix-like OS. Thus to enable this class X11 should be instal...
Definition vpDisplayX.h:132
void init(vpImage< unsigned char > &I, int win_x=-1, int win_y=-1, const std::string &win_title="")
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
static void displayCircle(const vpImage< unsigned char > &I, const vpImageCircle &circle, const vpColor &color, bool fill=false, unsigned int thickness=1)
static void display(const vpImage< unsigned char > &I)
static void displayFrame(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, double size, const vpColor &color=vpColor::none, unsigned int thickness=1, const vpImagePoint &offset=vpImagePoint(0, 0), const std::string &frameName="", const vpColor &textColor=vpColor::black, const vpImagePoint &textOffset=vpImagePoint(15, 15))
static void displayCross(const vpImage< unsigned char > &I, const vpImagePoint &ip, unsigned int size, const vpColor &color, unsigned int thickness=1)
static void setTitle(const vpImage< unsigned char > &I, const std::string &windowtitle)
static void flush(const vpImage< unsigned char > &I)
static void displayText(const vpImage< unsigned char > &I, const vpImagePoint &ip, const std::string &s, const vpColor &color)
error that can be emitted by ViSP classes.
Definition vpException.h:59
Implementation of an homogeneous matrix and operations on such kind of matrices.
static void read(vpImage< unsigned char > &I, const std::string &filename, int backend=IO_DEFAULT_BACKEND)
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition of the vpImage class member functions.
Definition vpImage.h:135
unsigned int getWidth() const
Definition vpImage.h:242
unsigned int getHeight() const
Definition vpImage.h:184
static bool checkFilename(const std::string &filename)
static std::string getNameWE(const std::string &pathname)
static std::string getParent(const std::string &pathname)
Class that allows keypoints detection (and descriptors extraction) and matching thanks to OpenCV libr...
Definition vpKeyPoint.h:212
void detect(const vpImage< unsigned char > &I, std::vector< cv::KeyPoint > &keyPoints, const vpRect &rectangle=vpRect())
static void compute3DForPointsInPolygons(const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, std::vector< cv::KeyPoint > &candidates, const std::vector< vpPolygon > &polygons, const std::vector< std::vector< vpPoint > > &roisPt, std::vector< cv::Point3f > &points, cv::Mat *descriptors=NULL)
void saveLearningData(const std::string &filename, bool binaryMode=false, bool saveTrainingImages=true)
cv::Ptr< cv::FeatureDetector > getDetector(const vpFeatureDetectorType &type) const
Definition vpKeyPoint.h:480
unsigned int buildReference(const vpImage< unsigned char > &I)
static double rad(double deg)
Definition vpMath.h:116
Real-time 6D object pose tracking using its CAD model.
virtual void setCameraParameters(const vpCameraParameters &camera)
virtual void getPose(vpHomogeneousMatrix &cMo) const
virtual void setDisplayFeatures(bool displayF)
virtual void setAngleAppear(const double &a)
virtual void setNearClippingDistance(const double &dist)
virtual void getCameraParameters(vpCameraParameters &camera) const
virtual void setAngleDisappear(const double &a)
virtual void setMovingEdge(const vpMe &me)
virtual std::pair< std::vector< vpPolygon >, std::vector< std::vector< vpPoint > > > getPolygonFaces(bool orderPolygons=true, bool useVisibility=true, bool clipPolygon=false)
virtual void getClipping(unsigned int &clippingFlag1, unsigned int &clippingFlag2) const
virtual void setFarClippingDistance(const double &dist)
virtual void setClipping(const unsigned int &flags)
virtual void loadConfigFile(const std::string &configFile, bool verbose=true)
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
virtual void setOgreVisibilityTest(const bool &v)
virtual void loadModel(const std::string &modelFile, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
virtual void display(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const vpColor &col, unsigned int thickness=1, bool displayFullModel=false)
virtual void track(const vpImage< unsigned char > &I)
Definition vpMe.h:122
void setMu1(const double &mu_1)
Definition vpMe.h:353
void setSampleStep(const double &s)
Definition vpMe.h:390
void setRange(const unsigned int &r)
Definition vpMe.h:383
void setLikelihoodThresholdType(const vpLikelihoodThresholdType likelihood_threshold_type)
Definition vpMe.h:445
void setMaskSize(const unsigned int &a)
Definition vpMe.cpp:452
void setNbTotalSample(const int &nb)
Definition vpMe.h:367
void setMu2(const double &mu_2)
Definition vpMe.h:360
@ NORMALIZED_THRESHOLD
Easy-to-use normalized likelihood threshold corresponding to the minimal luminance contrast to consid...
Definition vpMe.h:132
void setMaskNumber(const unsigned int &a)
Definition vpMe.cpp:445
void setThreshold(const double &t)
Definition vpMe.h:435
Class that enables to manipulate easily a video file or a sequence of images. As it inherits from the...
void acquire(vpImage< vpRGBa > &I)
void open(vpImage< vpRGBa > &I)
void setFileName(const std::string &filename)