1 #include <visp3/core/vpConfig.h>
3 #include <visp3/gui/vpDisplayX.h>
4 #include <visp3/gui/vpDisplayGDI.h>
5 #include <visp3/gui/vpDisplayOpenCV.h>
6 #include <visp3/mbt/vpMbEdgeTracker.h>
7 #include <visp3/io/vpVideoReader.h>
8 #include <visp3/vision/vpKeyPoint.h>
9 #include <visp3/core/vpIoTools.h>
12 #if defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION >= 0x020400)
15 std::vector<cv::KeyPoint> trainKeyPoints;
17 keypoint_learning.
detect(I, trainKeyPoints, elapsedTime);
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;
27 std::vector<cv::Point3f> points3f;
36 keypoint_learning.
buildReference(I, trainKeyPoints, points3f,
true,
id);
40 for(std::vector<cv::KeyPoint>::const_iterator it = trainKeyPoints.begin(); it != trainKeyPoints.end(); ++it) {
47 int main(
int argc,
char ** argv) {
48 #if defined(VISP_HAVE_OPENCV) && ((VISP_HAVE_OPENCV_VERSION >= 0x020400) || defined(VISP_HAVE_FFMPEG))
51 std::string videoname =
"cube.mpeg";
53 for (
int i=0; i<argc; i++) {
54 if (std::string(argv[i]) ==
"--name")
55 videoname = std::string(argv[i+1]);
56 else if (std::string(argv[i]) ==
"--help") {
57 std::cout <<
"\nUsage: " << argv[0] <<
" [--name <video name>] [--help]\n" << std::endl;
64 if(! parentname.empty())
65 objectname = parentname +
"/" + objectname;
67 std::cout <<
"Video name: " << videoname << std::endl;
68 std::cout <<
"Tracker requested config files: " << objectname
73 <<
"cao or wrl]" << std::endl;
74 std::cout <<
"Tracker optional config files: " << objectname <<
".[ppm]" << std::endl;
118 vpKeyPoint keypoint_learning(
"ORB",
"ORB",
"BruteForce-Hamming");
119 #if (VISP_HAVE_OPENCV_VERSION < 0x030000)
122 cv::Ptr<cv::ORB> orb_learning = keypoint_learning.
getDetector(
"ORB").dynamicCast<cv::ORB>();
123 if(orb_learning != NULL) {
124 orb_learning->setNLevels(1);
129 #if defined(VISP_HAVE_X11)
131 #elif defined(VISP_HAVE_GDI)
133 #elif defined(VISP_HAVE_OPENCV)
136 std::cout <<
"No image viewer is available..." << std::endl;
143 std::string imageName[] = {
"cube0001.png",
"cube0150.png",
"cube0200.png"};
145 vpHomogeneousMatrix(0.02143385294, 0.1098083886, 0.5127439561, 2.087159614, 1.141775176, -0.4701291124),
146 vpHomogeneousMatrix(0.02651282185, -0.03713587374, 0.6873765919, 2.314744454, 0.3492296488, -0.1226054828),
147 vpHomogeneousMatrix(0.02965448956, -0.07283091786, 0.7253526051, 2.300529617, -0.4286674806, 0.1788761025)};
148 for(
int i = 0; i < 3; i++) {
151 display.
init(I, 10, 10);
153 std::stringstream title;
154 title <<
"Learning cube on image: " << imageName[i];
160 tracker.
setPose(I, initPoseTab[i]);
173 learnCube(I, tracker, keypoint_learning, i);
195 vpKeyPoint keypoint_detection(
"ORB",
"ORB",
"BruteForce-Hamming");
196 #if (VISP_HAVE_OPENCV_VERSION < 0x030000)
197 keypoint_detection.setDetectorParameter(
"ORB",
"nLevels", 1);
199 cv::Ptr<cv::ORB> orb_detector = keypoint_detection.getDetector(
"ORB").dynamicCast<cv::ORB>();
200 orb_detector = keypoint_detection.getDetector(
"ORB").dynamicCast<cv::ORB>();
201 if(orb_detector != NULL) {
202 orb_detector->setNLevels(1);
208 keypoint_detection.loadLearningData(
"cube_learning_data.bin",
true);
213 keypoint_detection.createImageMatching(I, IMatching);
220 #if defined VISP_HAVE_X11
222 #elif defined VISP_HAVE_GTK
224 #elif defined VISP_HAVE_GDI
229 display2.
init(IMatching, 50, 50,
"Display matching between learned and current images");
233 bool click_done =
false;
240 keypoint_detection.insertImageMatching(I, IMatching);
248 if(keypoint_detection.matchPoint(I, cam, cMo, error, elapsedTime)) {
260 keypoint_detection.displayMatching(I, IMatching);
263 std::vector<vpImagePoint> ransacInliers = keypoint_detection.getRansacInliers();
264 std::vector<vpImagePoint> ransacOutliers = keypoint_detection.getRansacOutliers();
268 for(std::vector<vpImagePoint>::const_iterator it = ransacInliers.begin(); it != ransacInliers.end(); ++it) {
271 imPt.set_u(imPt.get_u() + I.
getWidth());
272 imPt.set_v(imPt.get_v() + I.
getHeight());
278 for(std::vector<vpImagePoint>::const_iterator it = ransacOutliers.begin(); it != ransacOutliers.end(); ++it) {
281 imPt.set_u(imPt.get_u() + I.
getWidth());
282 imPt.set_v(imPt.get_v() + I.
getHeight());
288 keypoint_detection.displayMatching(I, IMatching);
296 tracker.
setPose(IMatching, cMo);
318 #ifdef VISP_HAVE_XML2
321 #if defined(VISP_HAVE_COIN3D) && (COIN_MAJOR_VERSION == 3)
326 std::cout <<
"Catch an exception: " << e << std::endl;
331 std::cout <<
"Install OpenCV or ffmpeg and rebuild ViSP to use this example." << std::endl;
virtual void displayCircle(const vpImagePoint ¢er, unsigned int radius, const vpColor &color, bool fill=false, unsigned int thickness=1)=0
void init(vpImage< unsigned char > &I, int winx=-1, int winy=-1, const char *title=NULL)
void setMovingEdge(const vpMe &me)
unsigned int getWidth() const
virtual unsigned int getClipping() const
virtual void setAngleDisappear(const double &a)
Implementation of an homogeneous matrix and operations on such kind of matrices.
void track(const vpImage< unsigned char > &I)
void detect(const vpImage< unsigned char > &I, std::vector< cv::KeyPoint > &keyPoints, double &elapsedTime, const vpRect &rectangle=vpRect())
void setMaskNumber(const unsigned int &a)
Display for windows using GDI (available on any windows 32 platform).
void setSampleStep(const double &s)
static void displayText(const vpImage< unsigned char > &I, const vpImagePoint &ip, const std::string &s, const vpColor &color)
void setNbTotalSample(const int &nb)
Define the X11 console to display images.
Class that enables to manipulate easily a video file or a sequence of images. As it inherits from the...
static const vpColor none
error that can be emited by ViSP classes.
Make the complete tracking of an object by using its CAD model.
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo)
virtual void setCameraParameters(const vpCameraParameters &camera)
void loadConfigFile(const std::string &configFile)
static const vpColor green
static void flush(const vpImage< unsigned char > &I)
void setMu1(const double &mu_1)
void initPersProjWithoutDistortion(const double px, const double py, const double u0, const double v0)
virtual void setNearClippingDistance(const double &dist)
virtual void setOgreVisibilityTest(const bool &v)
void open(vpImage< vpRGBa > &I)
void setMaskSize(const unsigned int &a)
void getPose(vpHomogeneousMatrix &cMo_) const
static void compute3DForPointsInPolygons(const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, std::vector< cv::KeyPoint > &candidate, const std::vector< vpPolygon > &polygons, const std::vector< std::vector< vpPoint > > &roisPt, std::vector< cv::Point3f > &points, cv::Mat *descriptors=NULL)
static void display(const vpImage< unsigned char > &I)
The vpDisplayOpenCV allows to display image using the opencv library.
virtual void displayCross(const vpImagePoint &ip, unsigned int size, const vpColor &color, unsigned int thickness=1)=0
virtual void getCameraParameters(vpCameraParameters &camera) const
Generic class defining intrinsic camera parameters.
virtual void setTitle(const char *title)=0
The vpDisplayGTK allows to display image using the GTK+ library version 1.2.
void acquire(vpImage< vpRGBa > &I)
unsigned int buildReference(const vpImage< unsigned char > &I)
virtual void setFarClippingDistance(const double &dist)
void setFileName(const char *filename)
virtual void setAngleAppear(const double &a)
cv::Ptr< cv::FeatureDetector > getDetector(const std::string &name) const
static double rad(double deg)
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, vpImagePoint offset=vpImagePoint(0, 0))
void setMu2(const double &mu_2)
virtual void loadModel(const char *modelFile, const bool verbose=false)
Class that allows keypoints detection (and descriptors extraction) and matching thanks to OpenCV libr...
void saveLearningData(const std::string &filename, const bool binaryMode=false, const bool saveTrainingImages=true)
void setDetectorParameter(const T1 detectorName, const T2 parameterName, const T3 value)
void setThreshold(const double &t)
void display(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const vpColor &col, const unsigned int thickness=1, const bool displayFullModel=false)
unsigned int getHeight() const
virtual bool getClick(bool blocking=true)=0
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
void setDisplayFeatures(const bool displayF)
void setRange(const unsigned int &r)
virtual void setClipping(const unsigned int &flags)
static void read(vpImage< unsigned char > &I, const char *filename)
virtual std::pair< std::vector< vpPolygon >, std::vector< std::vector< vpPoint > > > getPolygonFaces(const bool orderPolygons=true, const bool useVisibility=true)