42 #include <visp3/core/vpConfig.h>
44 #if defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO) && \
45 ((VISP_HAVE_OPENCV_VERSION < 0x050000) && defined(HAVE_OPENCV_CALIB3D) && defined(HAVE_OPENCV_FEATURES2D)) || \
46 ((VISP_HAVE_OPENCV_VERSION >= 0x050000) && defined(HAVE_OPENCV_3D) && defined(HAVE_OPENCV_FEATURES))
48 #include <visp3/core/vpImage.h>
49 #include <visp3/core/vpIoTools.h>
50 #include <visp3/gui/vpDisplayFactory.h>
51 #include <visp3/io/vpImageIo.h>
52 #include <visp3/io/vpParseArgv.h>
53 #include <visp3/io/vpVideoReader.h>
54 #include <visp3/mbt/vpMbEdgeTracker.h>
55 #include <visp3/vision/vpKeyPoint.h>
58 #define GETOPTARGS "cdph"
60 #ifdef ENABLE_VISP_NAMESPACE
64 void usage(
const char *name,
const char *badparam);
65 bool getOptions(
int argc,
const char **argv,
bool &click_allowed,
bool &display);
75 void usage(
const char *name,
const char *badparam)
78 Test keypoints matching.\n\
81 %s [-c] [-d] [-p] [-h]\n",
88 Disable the mouse click. Useful to automate the \n\
89 execution of this program without human intervention.\n\
92 Turn off the display.\n\
95 Use parallel RANSAC.\n\
101 fprintf(stdout,
"\nERROR: Bad parameter [%s]\n", badparam);
115 bool getOptions(
int argc,
const char **argv,
bool &click_allowed,
bool &display,
bool &use_parallel_ransac)
123 click_allowed =
false;
129 use_parallel_ransac =
true;
132 usage(argv[0],
nullptr);
137 usage(argv[0], optarg_);
143 if ((c == 1) || (c == -1)) {
145 usage(argv[0],
nullptr);
146 std::cerr <<
"ERROR: " << std::endl;
147 std::cerr <<
" Bad argument " << optarg_ << std::endl << std::endl;
154 template <
typename Type>
155 void run_test(
const std::string &env_ipath,
bool opt_click_allowed,
bool opt_display,
bool use_parallel_ransac,
158 #if VISP_HAVE_DATASET_VERSION >= 0x030600
159 std::string ext(
"png");
161 std::string ext(
"pgm");
174 #ifdef VISP_HAVE_DISPLAY
178 std::cout <<
"No image viewer is available..." << std::endl;
187 #if defined(VISP_HAVE_PUGIXML)
219 if (opt_display && opt_click_allowed) {
220 tracker.initClick(I, init_file);
223 vpHomogeneousMatrix cMoi(0.02044769891, 0.1101505452, 0.5078963719, 2.063603907, 1.110231561, -0.4392789872);
232 vpKeyPoint keypoints(
"ORB",
"ORB",
"BruteForce-Hamming");
233 keypoints.setRansacParallel(use_parallel_ransac);
234 #if (VISP_HAVE_OPENCV_VERSION >= 0x020400)
237 keypoints.setMatcher(
"FlannBased");
238 #if (VISP_HAVE_OPENCV_VERSION < 0x030000)
239 keypoints.setDetectorParameter(
"ORB",
"nLevels", 1);
241 cv::Ptr<cv::ORB> orb_detector = keypoints.getDetector(
"ORB").dynamicCast<cv::ORB>();
243 orb_detector->setNLevels(1);
249 std::vector<cv::KeyPoint> trainKeyPoints;
251 keypoints.detect(I, trainKeyPoints, elapsedTime);
254 std::vector<vpPolygon> polygons;
255 std::vector<std::vector<vpPoint> > roisPt;
256 std::pair<std::vector<vpPolygon>, std::vector<std::vector<vpPoint> > > pair =
258 polygons = pair.first;
259 roisPt = pair.second;
262 std::vector<cv::Point3f> points3f;
266 keypoints.buildReference(I, trainKeyPoints, points3f,
false, 1);
273 cMo.
buildFrom(0.02651282185, -0.03713587374, 0.6873765919, 2.314744454, 0.3492296488, -0.1226054828);
277 keypoints.detect(I, trainKeyPoints, elapsedTime);
282 polygons = pair.first;
283 roisPt = pair.second;
289 keypoints.buildReference(I, trainKeyPoints, points3f,
true, 2);
296 cMo.
buildFrom(0.02965448956, -0.07283091786, 0.7253526051, 2.300529617, -0.4286674806, 0.1788761025);
300 keypoints.detect(I, trainKeyPoints, elapsedTime);
304 polygons = pair.first;
305 roisPt = pair.second;
311 keypoints.buildReference(I, trainKeyPoints, points3f,
true, 3);
321 keypoints.createImageMatching(I, IMatching);
324 #ifdef VISP_HAVE_DISPLAY
330 bool opt_click =
false;
333 std::vector<double> times_vec;
334 while ((opt_display && !g.
end()) || (!opt_display && g.
getFrameIndex() < 30)) {
341 keypoints.insertImageMatching(I, IMatching);
347 if (keypoints.matchPoint(I, cam, cMo, error, elapsedTime)) {
348 times_vec.push_back(elapsedTime);
357 std::vector<vpImagePoint> ransacInliers = keypoints.getRansacInliers();
358 std::vector<vpImagePoint> ransacOutliers = keypoints.getRansacOutliers();
360 for (std::vector<vpImagePoint>::const_iterator it = ransacInliers.begin(); it != ransacInliers.end(); ++it) {
363 imPt.set_u(imPt.get_u() + I.
getWidth());
364 imPt.set_v(imPt.get_v() + I.
getHeight());
368 for (std::vector<vpImagePoint>::const_iterator it = ransacOutliers.begin(); it != ransacOutliers.end(); ++it) {
371 imPt.set_u(imPt.get_u() + I.
getWidth());
372 imPt.set_v(imPt.get_v() + I.
getHeight());
376 keypoints.displayMatching(I, IMatching);
383 tracker.
setPose(IMatching, cMo);
394 if (opt_click_allowed && opt_display) {
423 if (!times_vec.empty()) {
430 int main(
int argc,
const char **argv)
433 std::string env_ipath;
434 bool opt_click_allowed =
true;
435 bool opt_display =
true;
436 bool use_parallel_ransac =
false;
439 if (getOptions(argc, argv, opt_click_allowed, opt_display, use_parallel_ransac) ==
false) {
447 if (env_ipath.empty()) {
448 std::cerr <<
"Please set the VISP_INPUT_IMAGE_PATH environment "
457 std::cout <<
"-- Test on gray level images" << std::endl;
459 run_test(env_ipath, opt_click_allowed, opt_display, use_parallel_ransac, I, IMatching);
464 std::cout <<
"-- Test on color images" << std::endl;
466 run_test(env_ipath, opt_click_allowed, opt_display, use_parallel_ransac, I, IMatching);
471 std::cerr << e.
what() << std::endl;
475 std::cout <<
"testKeyPoint-2 is ok !" << std::endl;
481 std::cerr <<
"You need OpenCV library." << std::endl;
Generic class defining intrinsic camera parameters.
void initPersProjWithoutDistortion(double px, double py, double u0, double v0)
static const vpColor none
static const vpColor green
Class that defines generic functionalities for display.
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)
virtual void setDownScalingFactor(unsigned int scale)
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 flush(const vpImage< unsigned char > &I)
unsigned int getDownScalingFactor()
error that can be emitted by ViSP classes.
const char * what() const
Implementation of an homogeneous matrix and operations on such kind of matrices.
vpHomogeneousMatrix & buildFrom(const vpTranslationVector &t, const vpRotationMatrix &R)
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.
unsigned int getWidth() const
unsigned int getHeight() const
Class that allows keypoints 2D features detection (and descriptors extraction) and matching thanks to...
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=nullptr)
static double rad(double deg)
static double getMedian(const std::vector< double > &v)
static double getStdev(const std::vector< double > &v, bool useBesselCorrection=false)
static double getMean(const std::vector< double > &v)
Make the complete tracking of an object by using its CAD model.
virtual void setNearClippingDistance(const double &dist) VP_OVERRIDE
virtual void display(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const vpColor &col, unsigned int thickness=1, bool displayFullModel=false) VP_OVERRIDE
virtual void setFarClippingDistance(const double &dist) VP_OVERRIDE
virtual void setClipping(const unsigned int &flags) VP_OVERRIDE
void setMovingEdge(const vpMe &me)
virtual void setCameraParameters(const vpCameraParameters &cam) VP_OVERRIDE
virtual void setPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cdMo) VP_OVERRIDE
virtual void loadConfigFile(const std::string &configFile, bool verbose=true) VP_OVERRIDE
virtual void getCameraParameters(vpCameraParameters &cam) const
virtual void getPose(vpHomogeneousMatrix &cMo) const
virtual void setAngleDisappear(const double &a)
virtual void initFromPose(const vpImage< unsigned char > &I, const std::string &initFile)
virtual void loadModel(const std::string &modelFile, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
virtual void setAngleAppear(const double &a)
virtual std::pair< std::vector< vpPolygon >, std::vector< std::vector< vpPoint > > > getPolygonFaces(bool orderPolygons=true, bool useVisibility=true, bool clipPolygon=false)
virtual unsigned int getClipping() const
void setMu1(const double &mu_1)
void setRange(const unsigned int &range)
void setLikelihoodThresholdType(const vpLikelihoodThresholdType likelihood_threshold_type)
void setNbTotalSample(const int &ntotal_sample)
void setMaskNumber(const unsigned int &mask_number)
void setThreshold(const double &threshold)
void setSampleStep(const double &sample_step)
void setMaskSize(const unsigned int &mask_size)
void setMu2(const double &mu_2)
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
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)
long getFrameIndex() const
vpDisplay * allocateDisplay()
Return a newly allocated vpDisplay specialization if a GUI library is available or nullptr otherwise.