class cv::DescriptorMatcher

Overview

Abstract base class for matching keypoint descriptors. More…

#include <features2d.hpp>

class DescriptorMatcher: public cv::Algorithm
{
public:
    // enums

    enum
    {
        FLANNBASED            = 1,
        BRUTEFORCE            = 2,
        BRUTEFORCE_L1         = 3,
        BRUTEFORCE_HAMMING    = 4,
        BRUTEFORCE_HAMMINGLUT = 5,
        BRUTEFORCE_SL2        = 6,
    };

    // classes

    class DescriptorCollection;

    // methods

    virtual
    void
    add(InputArrayOfArrays descriptors);

    virtual
    void
    clear();

    virtual
    Ptr<DescriptorMatcher>
    clone(bool emptyTrainData = false) const = 0;

    virtual
    bool
    empty() const;

    const std::vector<Mat>&
    getTrainDescriptors() const;

    virtual
    bool
    isMaskSupported() const = 0;

    void
    knnMatch(
        InputArray queryDescriptors,
        InputArray trainDescriptors,
        std::vector<std::vector<DMatch>>& matches,
        int k,
        InputArray mask = noArray(),
        bool compactResult = false
        ) const;

    void
    knnMatch(
        InputArray queryDescriptors,
        std::vector<std::vector<DMatch>>& matches,
        int k,
        InputArrayOfArrays masks = noArray(),
        bool compactResult = false
        );

    void
    match(
        InputArray queryDescriptors,
        InputArray trainDescriptors,
        std::vector<DMatch>& matches,
        InputArray mask = noArray()
        ) const;

    void
    match(
        InputArray queryDescriptors,
        std::vector<DMatch>& matches,
        InputArrayOfArrays masks = noArray()
        );

    void
    radiusMatch(
        InputArray queryDescriptors,
        InputArray trainDescriptors,
        std::vector<std::vector<DMatch>>& matches,
        float maxDistance,
        InputArray mask = noArray(),
        bool compactResult = false
        ) const;

    void
    radiusMatch(
        InputArray queryDescriptors,
        std::vector<std::vector<DMatch>>& matches,
        float maxDistance,
        InputArrayOfArrays masks = noArray(),
        bool compactResult = false
        );

    void
    read(const String& fileName);

    virtual
    void
    read(const FileNode& fn);

    virtual
    void
    train();

    void
    write(const String& fileName) const;

    virtual
    void
    write(FileStorage& fs) const;

    static
    Ptr<DescriptorMatcher>
    create(const String& descriptorMatcherType);

    static
    Ptr<DescriptorMatcher>
    create(int matcherType);

protected:
    // fields

    std::vector<Mat> trainDescCollection;
    std::vector<UMat> utrainDescCollection;

    // methods

    void
    checkMasks(
        InputArrayOfArrays masks,
        int queryDescriptorsCount
        ) const;

    virtual
    void
    knnMatchImpl(
        InputArray queryDescriptors,
        std::vector<std::vector<DMatch>>& matches,
        int k,
        InputArrayOfArrays masks = noArray(),
        bool compactResult = false
        ) = 0;

    virtual
    void
    radiusMatchImpl(
        InputArray queryDescriptors,
        std::vector<std::vector<DMatch>>& matches,
        float maxDistance,
        InputArrayOfArrays masks = noArray(),
        bool compactResult = false
        ) = 0;

    static
    Mat
    clone_op(Mat m);

    static
    bool
    isMaskedOut(
        InputArrayOfArrays masks,
        int queryIdx
        );

    static
    bool
    isPossibleMatch(
        InputArray mask,
        int queryIdx,
        int trainIdx
        );
};

// direct descendants

class BFMatcher;
class FlannBasedMatcher;

Inherited Members

public:
    // methods

    virtual
    void
    clear();

    virtual
    bool
    empty() const;

    virtual
    String
    getDefaultName() const;

    virtual
    void
    read(const FileNode& fn);

    virtual
    void
    save(const String& filename) const;

    virtual
    void
    write(FileStorage& fs) const;

    template <typename _Tp>
    static
    Ptr<_Tp>
    load(
        const String& filename,
        const String& objname = String()
        );

    template <typename _Tp>
    static
    Ptr<_Tp>
    loadFromString(
        const String& strModel,
        const String& objname = String()
        );

    template <typename _Tp>
    static
    Ptr<_Tp>
    read(const FileNode& fn);

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;

Detailed Documentation

Abstract base class for matching keypoint descriptors.

It has two groups of match methods: for matching descriptors of an image with another image or with an image set.

Fields

std::vector<Mat> trainDescCollection

Collection of descriptors from train images.

Methods

virtual
void
add(InputArrayOfArrays descriptors)

Adds descriptors to train a CPU(trainDescCollectionis) or GPU(utrainDescCollectionis) descriptor collection.

If the collection is not empty, the new descriptors are added to existing train descriptors.

Parameters:

descriptors Descriptors to add. Each descriptors[i] is a set of descriptors from the same train image. 
virtual
void
clear()

Clears the train descriptor collections.

virtual
Ptr<DescriptorMatcher>
clone(bool emptyTrainData = false) const = 0

Clones the matcher.

Parameters:

emptyTrainData If emptyTrainData is false, the method creates a deep copy of the object, that is, copies both parameters and train data. If emptyTrainData is true, the method creates an object copy with the current parameters but with empty train data. 
virtual
bool
empty() const

Returns true if there are no train descriptors in the both collections.

const std::vector<Mat>&
getTrainDescriptors() const

Returns a constant link to the train descriptor collection trainDescCollection .

virtual
bool
isMaskSupported() const = 0

Returns true if the descriptor matcher supports masking permissible matches.

void
knnMatch(
    InputArray queryDescriptors,
    InputArray trainDescriptors,
    std::vector<std::vector<DMatch>>& matches,
    int k,
    InputArray mask = noArray(),
    bool compactResult = false
    ) const

Finds the k best matches for each descriptor from a query set.

These extended variants of DescriptorMatcher::match methods find several best matches for each query descriptor. The matches are returned in the distance increasing order. See DescriptorMatcher::match for the details about query and train descriptors.

Parameters:

queryDescriptors Query set of descriptors.
trainDescriptors Train set of descriptors. This set is not added to the train descriptors collection stored in the class object.
mask Mask specifying permissible matches between an input query and train matrices of descriptors.
matches Matches. Each matches[i] is k or less matches for the same query descriptor.
k Count of best matches found per each query descriptor or less if a query descriptor has less than k possible matches in total.
compactResult Parameter used when the mask (or masks) is not empty. If compactResult is false, the matches vector has the same size as queryDescriptors rows. If compactResult is true, the matches vector does not contain matches for fully masked-out query descriptors. 
void
knnMatch(
    InputArray queryDescriptors,
    std::vector<std::vector<DMatch>>& matches,
    int k,
    InputArrayOfArrays masks = noArray(),
    bool compactResult = false
    )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

queryDescriptors Query set of descriptors.
matches Matches. Each matches[i] is k or less matches for the same query descriptor.
k Count of best matches found per each query descriptor or less if a query descriptor has less than k possible matches in total.
masks Set of masks. Each masks[i] specifies permissible matches between the input query descriptors and stored train descriptors from the i-th image trainDescCollection[i].
compactResult Parameter used when the mask (or masks) is not empty. If compactResult is false, the matches vector has the same size as queryDescriptors rows. If compactResult is true, the matches vector does not contain matches for fully masked-out query descriptors. 
void
match(
    InputArray queryDescriptors,
    InputArray trainDescriptors,
    std::vector<DMatch>& matches,
    InputArray mask = noArray()
    ) const

Finds the best match for each descriptor from a query set.

In the first variant of this method, the train descriptors are passed as an input argument. In the second variant of the method, train descriptors collection that was set by DescriptorMatcher::add is used. Optional mask (or masks) can be passed to specify which query and training descriptors can be matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j] only if mask.at<uchar>(i,j) is non-zero.

Parameters:

queryDescriptors Query set of descriptors.
trainDescriptors Train set of descriptors. This set is not added to the train descriptors collection stored in the class object.
matches Matches. If a query descriptor is masked out in mask , no match is added for this descriptor. So, matches size may be smaller than the query descriptors count.
mask Mask specifying permissible matches between an input query and train matrices of descriptors. 
void
match(
    InputArray queryDescriptors,
    std::vector<DMatch>& matches,
    InputArrayOfArrays masks = noArray()
    )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

queryDescriptors Query set of descriptors.
matches Matches. If a query descriptor is masked out in mask , no match is added for this descriptor. So, matches size may be smaller than the query descriptors count.
masks Set of masks. Each masks[i] specifies permissible matches between the input query descriptors and stored train descriptors from the i-th image trainDescCollection[i]. 
void
radiusMatch(
    InputArray queryDescriptors,
    InputArray trainDescriptors,
    std::vector<std::vector<DMatch>>& matches,
    float maxDistance,
    InputArray mask = noArray(),
    bool compactResult = false
    ) const

For each query descriptor, finds the training descriptors not farther than the specified distance.

For each query descriptor, the methods find such training descriptors that the distance between the query descriptor and the training descriptor is equal or smaller than maxDistance. Found matches are returned in the distance increasing order.

Parameters:

queryDescriptors Query set of descriptors.
trainDescriptors Train set of descriptors. This set is not added to the train descriptors collection stored in the class object.
matches Found matches.
compactResult Parameter used when the mask (or masks) is not empty. If compactResult is false, the matches vector has the same size as queryDescriptors rows. If compactResult is true, the matches vector does not contain matches for fully masked-out query descriptors.
maxDistance Threshold for the distance between matched descriptors. Distance means here metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured in Pixels)!
mask Mask specifying permissible matches between an input query and train matrices of descriptors. 
void
radiusMatch(
    InputArray queryDescriptors,
    std::vector<std::vector<DMatch>>& matches,
    float maxDistance,
    InputArrayOfArrays masks = noArray(),
    bool compactResult = false
    )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

queryDescriptors Query set of descriptors.
matches Found matches.
maxDistance Threshold for the distance between matched descriptors. Distance means here metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured in Pixels)!
masks Set of masks. Each masks[i] specifies permissible matches between the input query descriptors and stored train descriptors from the i-th image trainDescCollection[i].
compactResult Parameter used when the mask (or masks) is not empty. If compactResult is false, the matches vector has the same size as queryDescriptors rows. If compactResult is true, the matches vector does not contain matches for fully masked-out query descriptors. 
virtual
void
read(const FileNode& fn)

Reads algorithm parameters from a file storage.

virtual
void
train()

Trains a descriptor matcher.

Trains a descriptor matcher (for example, the flann index). In all methods to match, the method train() is run every time before matching. Some descriptor matchers (for example, BruteForceMatcher) have an empty implementation of this method. Other matchers really train their inner structures (for example, FlannBasedMatcher trains flann::Index).

virtual
void
write(FileStorage& fs) const

Stores algorithm parameters in a file storage.

static
Ptr<DescriptorMatcher>
create(const String& descriptorMatcherType)

Creates a descriptor matcher of a given type with the default parameters (using default constructor).

Parameters:

descriptorMatcherType

Descriptor matcher type. Now the following matcher types are supported:

  • BruteForce (it uses L2)
  • BruteForce-L1
  • BruteForce-Hamming
  • BruteForce-Hamming(2)
  • FlannBased
 
virtual
void
knnMatchImpl(
    InputArray queryDescriptors,
    std::vector<std::vector<DMatch>>& matches,
    int k,
    InputArrayOfArrays masks = noArray(),
    bool compactResult = false
    ) = 0

In fact the matching is implemented only by the following two methods. These methods suppose that the class object has been trained already. Public match methods call these methods after calling train().