Opencv中的KeyPoints和DMatche类

/***好记性不如烂笔头，便于后续复习***/

最近用到OpenCV中KeyPoints和DMatch类，有些记忆模糊，特此记下！

一、DMatche类：

/*******  DMatch ******/
/* Struct for matching: 
         query descriptor index,
         train descriptor index,
         train image index，
         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;
    }
};

二、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)
};