openCV中的KeyPoints、DMatch、以及drawMatches函数（sift算法会用到的）

https://blog.youkuaiyun.com/lihuacui/article/details/56667342

1. keypoint类

/*!
 The Keypoint Class

 The class instance stores a keypoint, i.e. a point feature found by one of many available keypoint detectors, such as
 Harris corner detector, cv::FAST, cv::StarDetector, cv::SURF, cv::SIFT, cv::LDetector etc.
*/

class  KeyPoint
{
public:
    //! the default constructor默认构造函数
    KeyPoint() : pt(0,0), size(0), angle(-1), 
                 response(0), octave(0), class_id(-1) {}
    //! the full constructor
    KeyPoint(Point2f _pt, float _size, float _angle=-1,
             float _response=0, int _octave=0, int _class_id=-1)
          :pt(_pt), size(_size), angle(_angle),
           response(_response), octave(_octave), class_id(_class_id) {}
    //! another form of the full constructor
    KeyPoint(float x, float y, float _size, float _angle=-1,
             float _response=0, int _octave=0, int _class_id=-1)
          :pt(x, y), size(_size), angle(_angle),
           response(_response), octave(_octave), class_id(_class_id) {}

    size_t hash() const;

    //! converts vector of keypoints to vector of points
    static void convert(const vector<KeyPoint>& keypoints,
                        CV_OUT vector<Point2f>& points2f,
                        const vector<int>& keypointIndexes=vector<int>());
    //! converts vector of points to the vector of keypoints, where each keypoint is assigned the same size and the same orientation
    static void convert(const vector<Point2f>& points2f,
                        CV_OUT vector<KeyPoint>& keypoints,
                        float size=1, float response=1, int octave=0, int class_id=-1);

    //! computes overlap for pair of keypoints;
    //! overlap is a ratio between area of keypoint regions intersection and
    //! area of keypoint regions union (now keypoint region is circle)
    static float overlap(const KeyPoint& kp1, const KeyPoint& kp2);

    Point2f pt; //!<关键点坐标coordinates of the keypoints>
    float size; //!<关键点邻域直径大小diameter of the meaningful keypoint neighborhood
    float angle; //!<特征点方向computed orientation of the keypoint (-1 if not applicable);
                 //!< it's in [0,360) degrees and measured relative to
                 //!< image coordinate system, ie in clockwise.
    float response; //!< the response by which the most strong keypoints have been selected. Can be used for the further sorting or subsampling
    int octave; //!<关键点所在的图像金字塔的组octave (pyramid layer) from which the keypoint has been extracted
    int class_id; //!<用于聚类的ID object class (if the keypoints need to be clustered by an object they belong to)
};

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49

2.Dmatch结构

/*************************************/
*             DMatch                 *
/*************************************/
/* Struct for matching: query descriptor index, train descriptor index, train image index and distance between descriptors.
 */
struct  DMatch
{
//有三个构造函数
    DMatch() : queryIdx(-1), trainIdx(-1), imgIdx(-1), distance(FLT_MAX) {}
    DMatch( int _queryIdx, int _trainIdx, float _distance ) :
            queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(-1), distance(_distance) {}
    DMatch( int _queryIdx, int _trainIdx, int _imgIdx, float _distance ) :
            queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(_imgIdx), distance(_distance) {}

    CV_PROP_RW int queryIdx; //此匹配对应的查询图像的特征描述子索引 query descriptor index
    CV_PROP_RW int trainIdx; //此匹配对应的训练(模板)图像的特征描述子索引 train descriptor index
    CV_PROP_RW int imgIdx;   //训练图像的索引(若有多个) train image index

    CV_PROP_RW float distance;//两个特征向量之间的欧氏距离，越小表明匹配度越高

    // less is better
    bool operator<( const DMatch &m ) const
    {
        return distance < m.distance;
    }
};

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

3.drawMatches函数

// Draws matches of keypints from two images on output image.
void drawMatches( const Mat& img1, const vector<KeyPoint>& keypoints1,
                  const Mat& img2, const vector<KeyPoint>& keypoints2,
                  const vector<DMatch>& matches1to2, Mat& outIm     
                  const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1),
                  const vector<char>& matchesMask=vector<char>(), int flags=DrawMatchesFlags::DEFAULT );

void drawMatches( const Mat& img1, const vector<KeyPoint>& keypoints1,
                  const Mat& img2, const vector<KeyPoint>& keypoints2,
                  const vector<vector<DMatch> >& matches1to2, Mat& outImg,
                  const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1),
                  const vector<vector<char> >& matchesMask=vector<vector<char> >(), int flags=DrawMatchesFlags::DEFAULT );

/*
/*其中参数如下：
* img1 – 源图像1
* keypoints1 –源图像1的特征点.
* img2 – 源图像2.
* keypoints2 – 源图像2的特征点
* matches1to2 – 源图像1的特征点匹配源图像2的特征点[matches[i]] .
* outImg – 输出图像具体由flags决定.
* matchColor – 匹配的颜色（特征点和连线),若matchColor==Scalar::all(-1)，颜色随机.
* singlePointColor – 单个点的颜色，即未配对的特征点，若matchColor==Scalar::all(-1)，颜色随机.
matchesMask – Mask决定哪些点将被画出，若为空，则画出所有匹配点.
* flags – Fdefined by DrawMatchesFlags.

*/