44 #include <visp3/core/vpConfig.h>
46 #if defined(HAVE_OPENCV_IMGPROC) && \
47 ((VISP_HAVE_OPENCV_VERSION < 0x050000) && defined(HAVE_OPENCV_CALIB3D) && defined(HAVE_OPENCV_FEATURES2D)) || \
48 ((VISP_HAVE_OPENCV_VERSION >= 0x050000) && defined(HAVE_OPENCV_3D) && defined(HAVE_OPENCV_FEATURES))
50 #include <visp3/core/vpHomogeneousMatrix.h>
51 #include <visp3/core/vpImage.h>
52 #include <visp3/core/vpIoTools.h>
53 #include <visp3/gui/vpDisplayFactory.h>
54 #include <visp3/io/vpImageIo.h>
55 #include <visp3/io/vpParseArgv.h>
56 #include <visp3/io/vpVideoReader.h>
57 #include <visp3/mbt/vpMbEdgeTracker.h>
58 #include <visp3/vision/vpKeyPoint.h>
61 #define GETOPTARGS "cdh"
63 #ifdef ENABLE_VISP_NAMESPACE
67 void usage(
const char *name,
const char *badparam);
68 bool getOptions(
int argc,
const char **argv,
bool &click_allowed,
bool &display);
78 void usage(
const char *name,
const char *badparam)
81 Test keypoints matching.\n\
91 Disable the mouse click. Useful to automate the \n\
92 execution of this program without human intervention.\n\
95 Turn off the display.\n\
101 fprintf(stdout,
"\nERROR: Bad parameter [%s]\n", badparam);
115 bool getOptions(
int argc,
const char **argv,
bool &click_allowed,
bool &display)
123 click_allowed =
false;
129 usage(argv[0],
nullptr);
134 usage(argv[0], optarg_);
140 if ((c == 1) || (c == -1)) {
142 usage(argv[0],
nullptr);
143 std::cerr <<
"ERROR: " << std::endl;
144 std::cerr <<
" Bad argument " << optarg_ << std::endl << std::endl;
151 template <
typename Type>
152 void run_test(
const std::string &env_ipath,
bool opt_click_allowed,
bool opt_display,
vpImage<Type> &I,
155 #if VISP_HAVE_DATASET_VERSION >= 0x030600
156 std::string ext(
"png");
158 std::string ext(
"pgm");
169 vpDisplay *display =
nullptr, *display2 =
nullptr;
175 #ifdef VISP_HAVE_DISPLAY
181 std::cout <<
"No image viewer is available..." << std::endl;
190 #if defined(VISP_HAVE_PUGIXML)
222 if (opt_display && opt_click_allowed) {
223 tracker.initClick(I, init_file);
226 vpHomogeneousMatrix cMoi(0.02044769891, 0.1101505452, 0.5078963719, 2.063603907, 1.110231561, -0.4392789872);
235 cv::Ptr<cv::FeatureDetector> detector;
236 cv::Ptr<cv::DescriptorExtractor> extractor;
237 cv::Ptr<cv::DescriptorMatcher> matcher;
239 #if ((VISP_HAVE_OPENCV_VERSION < 0x050000) && defined(HAVE_OPENCV_FEATURES2D)) || ((VISP_HAVE_OPENCV_VERSION >= 0x050000) && defined(HAVE_OPENCV_FEATURES))
240 #if (VISP_HAVE_OPENCV_VERSION >= 0x030000)
241 detector = cv::ORB::create(500, 1.2f, 1);
242 extractor = cv::ORB::create(500, 1.2f, 1);
243 #elif (VISP_HAVE_OPENCV_VERSION >= 0x020301)
244 detector = cv::FeatureDetector::create(
"ORB");
245 extractor = cv::DescriptorExtractor::create(
"ORB");
248 matcher = cv::DescriptorMatcher::create(
"BruteForce-Hamming");
251 std::vector<cv::KeyPoint> trainKeyPoints;
254 detector->detect(matImg, trainKeyPoints);
257 std::vector<vpPolygon> polygons;
258 std::vector<std::vector<vpPoint> > roisPt;
259 std::pair<std::vector<vpPolygon>, std::vector<std::vector<vpPoint> > > pair = tracker.
getPolygonFaces(
false);
260 polygons = pair.first;
261 roisPt = pair.second;
264 std::vector<cv::Point3f> points3f;
268 cv::Mat trainDescriptors;
269 extractor->compute(matImg, trainKeyPoints, trainDescriptors);
271 if (trainKeyPoints.size() != (
size_t)trainDescriptors.rows || trainKeyPoints.size() != points3f.size()) {
281 bool opt_click =
false;
287 std::vector<cv::KeyPoint> queryKeyPoints;
288 detector->detect(matImg, queryKeyPoints);
290 cv::Mat queryDescriptors;
291 extractor->compute(matImg, queryKeyPoints, queryDescriptors);
293 std::vector<std::vector<cv::DMatch> > knn_matches;
294 std::vector<cv::DMatch> matches;
295 matcher->knnMatch(queryDescriptors, trainDescriptors, knn_matches, 2);
296 for (std::vector<std::vector<cv::DMatch> >::const_iterator it = knn_matches.begin(); it != knn_matches.end();
298 if (it->size() > 1) {
299 double ratio = (*it)[0].distance / (*it)[1].distance;
301 matches.push_back((*it)[0]);
307 for (std::vector<cv::DMatch>::const_iterator it = matches.begin(); it != matches.end(); ++it) {
308 vpPoint pt(points3f[(
size_t)(it->trainIdx)].x, points3f[(
size_t)(it->trainIdx)].y,
309 points3f[(
size_t)(it->trainIdx)].z);
311 double x = 0.0, y = 0.0;
313 queryKeyPoints[(
size_t)(it->queryIdx)].pt.y, x, y);
320 bool is_pose_estimated =
false;
321 if (estimated_pose.
npt >= 4) {
323 unsigned int nb_inliers =
static_cast<unsigned int>(0.7 * estimated_pose.
npt);
328 is_pose_estimated =
true;
331 is_pose_estimated =
false;
335 is_pose_estimated =
false;
344 for (std::vector<cv::DMatch>::const_iterator it = matches.begin(); it != matches.end(); ++it) {
345 vpImagePoint leftPt(trainKeyPoints[(
size_t)it->trainIdx].pt.y, trainKeyPoints[(
size_t)it->trainIdx].pt.x);
346 vpImagePoint rightPt(queryKeyPoints[(
size_t)it->queryIdx].pt.y,
347 queryKeyPoints[(
size_t)it->queryIdx].pt.x + Iref.
getWidth());
351 if (is_pose_estimated) {
362 if (opt_click_allowed && opt_display) {
391 int main(
int argc,
const char **argv)
394 std::string env_ipath;
395 bool opt_click_allowed =
true;
396 bool opt_display =
true;
399 if (getOptions(argc, argv, opt_click_allowed, opt_display) ==
false) {
407 if (env_ipath.empty()) {
408 std::cerr <<
"Please set the VISP_INPUT_IMAGE_PATH environment "
417 std::cout <<
"-- Test on gray level images" << std::endl;
418 run_test(env_ipath, opt_click_allowed, opt_display, I, Imatch, Iref);
424 std::cout <<
"-- Test on color images" << std::endl;
425 run_test(env_ipath, opt_click_allowed, opt_display, I, Imatch, Iref);
430 std::cerr << e.
what() << std::endl;
434 std::cout <<
"testKeyPoint-4 is ok !" << std::endl;
441 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 display(const vpImage< unsigned char > &I)
static void displayLine(const vpImage< unsigned char > &I, const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color, unsigned int thickness=1, bool segment=true)
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.
static void convert(const vpImage< unsigned char > &src, vpImage< vpRGBa > &dest)
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
void resize(unsigned int h, unsigned int w)
resize the image : Image initialization
void insert(const vpImage< Type > &src, const vpImagePoint &topLeft)
unsigned int getHeight() const
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)
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)
static void convertPoint(const vpCameraParameters &cam, const double &u, const double &v, double &x, double &y)
Class that defines a 3D point in the object frame and allows forward projection of a 3D point in the ...
Class used for pose computation from N points (pose from point only). Some of the algorithms implemen...
void setRansacMaxTrials(const int &rM)
void addPoint(const vpPoint &P)
void setRansacNbInliersToReachConsensus(const unsigned int &nbC)
unsigned int npt
Number of point used in pose computation.
bool computePose(vpPoseMethodType method, vpHomogeneousMatrix &cMo, FuncCheckValidityPose func=nullptr)
void setRansacThreshold(const double &t)
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.