### Navigation

- index
- next |
- previous |
- OpenCV 2.4.13.4 documentation »
- OpenCV API Reference »
- stitching. Images stitching »

# Features Finding and Images Matching

## detail::ImageFeatures

struct `detail::``ImageFeatures`

Structure containing image keypoints and descriptors.

    struct CV_EXPORTS ImageFeatures
    {
        int img_idx;
        Size img_size;
        std::vector<KeyPoint> keypoints;
        Mat descriptors;
    };

## detail::FeaturesFinder

class `detail::``FeaturesFinder`

Feature finders base class.

    class CV_EXPORTS FeaturesFinder
    {
    public:
        virtual ~FeaturesFinder() {}
        void operator ()(const Mat &image, ImageFeatures &features);
        void operator ()(const Mat &image, ImageFeatures &features, const std::vector<cv::Rect> &rois);
        virtual void collectGarbage() {}

    protected:
        virtual void find(const Mat &image, ImageFeatures &features) = 0;
    };

## detail::FeaturesFinder::operator()

Finds features in the given image.

C++:`` void `detail::FeaturesFinder::``operator()`(const Mat& image, ImageFeatures& features)

C++:`` void `detail::FeaturesFinder::``operator()`(const Mat& image, ImageFeatures& features, const std::vector<cv::Rect>& rois)

  Parameters: | image – Source image features – Found features rois – Regions of interest

See also

`detail::ImageFeatures`, `Rect_`

## detail::FeaturesFinder::collectGarbage

Frees unused memory allocated before if there is any.

C++:`` void `detail::FeaturesFinder::``collectGarbage`()

## detail::FeaturesFinder::find

This method must implement features finding logic in order to make the wrappers detail::FeaturesFinder::operator() work.

C++:`` void `detail::FeaturesFinder::``find`(const Mat& image, ImageFeatures& features)

  Parameters: | image – Source image features – Found features

See also

`detail::ImageFeatures`

## detail::SurfFeaturesFinder

class `detail::``SurfFeaturesFinder` : public `detail::``FeaturesFinder`

SURF features finder.

    class CV_EXPORTS SurfFeaturesFinder : public FeaturesFinder
    {
    public:
        SurfFeaturesFinder(double hess_thresh = 300., int num_octaves = 3, int num_layers = 4,
                           int num_octaves_descr = /*4*/3, int num_layers_descr = /*2*/4);

    private:
        /* hidden */
    };

See also

`detail::FeaturesFinder`, `SURF`

## detail::OrbFeaturesFinder

class `detail::``OrbFeaturesFinder` : public `detail::``FeaturesFinder`

ORB features finder.

    class CV_EXPORTS OrbFeaturesFinder : public FeaturesFinder
    {
    public:
        OrbFeaturesFinder(Size _grid_size = Size(3,1), size_t n_features = 1500,
                          const ORB::CommonParams &detector_params = ORB::CommonParams(1.3f, 5));

    private:
        /* hidden */
    };

See also

`detail::FeaturesFinder`, `ORB`

## detail::MatchesInfo

struct `detail::``MatchesInfo`

Structure containing information about matches between two images. It’s assumed that there is a homography between those images.

    struct CV_EXPORTS MatchesInfo
    {
        MatchesInfo();
        MatchesInfo(const MatchesInfo &other);
        const MatchesInfo& operator =(const MatchesInfo &other);

        int src_img_idx, dst_img_idx;       // Images indices (optional)
        std::vector<DMatch> matches;
        std::vector<uchar> inliers_mask;    // Geometrically consistent matches mask
        int num_inliers;                    // Number of geometrically consistent matches
        Mat H;                              // Estimated homography
        double confidence;                  // Confidence two images are from the same panorama
    };

## detail::FeaturesMatcher

class `detail::``FeaturesMatcher`

Feature matchers base class.

    class CV_EXPORTS FeaturesMatcher
    {
    public:
        virtual ~FeaturesMatcher() {}

        void operator ()(const ImageFeatures &features1, const ImageFeatures &features2,
                         MatchesInfo& matches_info) { match(features1, features2, matches_info); }

        void operator ()(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches,
                         const Mat &mask = cv::Mat());

        bool isThreadSafe() const { return is_thread_safe_; }

        virtual void collectGarbage() {}

    protected:
        FeaturesMatcher(bool is_thread_safe = false) : is_thread_safe_(is_thread_safe) {}

        virtual void match(const ImageFeatures &features1, const ImageFeatures &features2,
                           MatchesInfo& matches_info) = 0;

        bool is_thread_safe_;
    };

## detail::FeaturesMatcher::operator()

Performs images matching.

C++:`` void `detail::FeaturesMatcher::``operator()`(const ImageFeatures& features1, const ImageFeatures& features2, MatchesInfo& matches_info)

  Parameters: | features1 – First image features features2 – Second image features matches_info – Found matches

C++:`` void `detail::FeaturesMatcher::``operator()`(const std::vector<ImageFeatures>& features, std::vector<MatchesInfo>& pairwise_matches, const Mat& mask=Mat() )

  Parameters: | features – Features of the source images pairwise_matches – Found pairwise matches mask – Mask indicating which image pairs must be matched

The function is parallelized with the TBB library.

See also

`detail::MatchesInfo`

## detail::FeaturesMatcher::isThreadSafe

C++:`` bool `detail::FeaturesMatcher::``isThreadSafe`()`const`

  Returns: | True, if it’s possible to use the same matcher instance in parallel, false otherwise

## detail::FeaturesMatcher::collectGarbage

Frees unused memory allocated before if there is any.

C++:`` void `detail::FeaturesMatcher::``collectGarbage`()

## detail::FeaturesMatcher::match

This method must implement matching logic in order to make the wrappers detail::FeaturesMatcher::operator() work.

C++:`` void `detail::FeaturesMatcher::``match`(const ImageFeatures& features1, const ImageFeatures& features2, MatchesInfo& matches_info)

  Parameters: | features1 – first image features features2 – second image features matches_info – found matches

## detail::BestOf2NearestMatcher

class `detail::``BestOf2NearestMatcher` : public `detail::``FeaturesMatcher`

Features matcher which finds two best matches for each feature and leaves the best one only if the ratio between descriptor distances is greater than the threshold `match_conf`.

    class CV_EXPORTS BestOf2NearestMatcher : public FeaturesMatcher
    {
    public:
        BestOf2NearestMatcher(bool try_use_gpu = false, float match_conf = 0.65f,
                              int num_matches_thresh1 = 6, int num_matches_thresh2 = 6);

        void collectGarbage();

    protected:
        void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo &matches_info);

        int num_matches_thresh1_;
        int num_matches_thresh2_;
        Ptr<FeaturesMatcher> impl_;
    };

See also

`detail::FeaturesMatcher`

## detail::BestOf2NearestMatcher::BestOf2NearestMatcher

Constructs a “best of 2 nearest” matcher.

C++:`` `detail::BestOf2NearestMatcher::``BestOf2NearestMatcher`(bool try_use_gpu=false, float match_conf=0.3f, int num_matches_thresh1=6, int num_matches_thresh2=6)

  Parameters: | try_use_gpu – Should try to use GPU or not match_conf – Match distances ration threshold num_matches_thresh1 – Minimum number of matches required for the 2D projective transform estimation used in the inliers classification step num_matches_thresh2 – Minimum number of matches required for the 2D projective transform re-estimation on inliers

## Help and Feedback

You did not find what you were looking for?

- Ask a question on the Q&A forum.
- If you think something is missing or wrong in the documentation, please file a bug report.

### Navigation

- index
- next |
- previous |
- OpenCV 2.4.13.4 documentation »
- OpenCV API Reference »
- stitching. Images stitching »