class cv::cuda::ORB

Overview

Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor. More…

#include <cudafeatures2d.hpp>

class ORB:
    public cv::ORB,
    public cv::cuda::Feature2DAsync
{
public:
    // enums

    enum
    {
        X_ROW        = 0,
        Y_ROW,
        RESPONSE_ROW,
        ANGLE_ROW,
        OCTAVE_ROW,
        SIZE_ROW,
        ROWS_COUNT,
    };

    // methods

    static
    Ptr<ORB>
    create(
        int nfeatures = 500,
        float scaleFactor = 1.2f,
        int nlevels = 8,
        int edgeThreshold = 31,
        int firstLevel = 0,
        int WTA_K = 2,
        int scoreType = ORB::HARRIS_SCORE,
        int patchSize = 31,
        int fastThreshold = 20,
        bool blurForDescriptor = false
        );

    virtual
    bool
    getBlurForDescriptor() const = 0;

    virtual
    void
    setBlurForDescriptor(bool blurForDescriptor) = 0;
};

Inherited Members

public:
    // enums

    enum
    {
        kBytes       = 32,
        HARRIS_SCORE =0,
        FAST_SCORE   =1,
    };

    // 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);

    virtual
    void
    compute(
        InputArray image,
        std::vector<KeyPoint>& keypoints,
        OutputArray descriptors
        );

    virtual
    void
    compute(
        InputArrayOfArrays images,
        std::vector<std::vector<KeyPoint>>& keypoints,
        OutputArrayOfArrays descriptors
        );

    virtual
    int
    defaultNorm() const;

    virtual
    int
    descriptorSize() const;

    virtual
    int
    descriptorType() const;

    virtual
    void
    detect(
        InputArray image,
        std::vector<KeyPoint>& keypoints,
        InputArray mask = noArray()
        );

    virtual
    void
    detect(
        InputArrayOfArrays images,
        std::vector<std::vector<KeyPoint>>& keypoints,
        InputArrayOfArrays masks = noArray()
        );

    virtual
    void
    detectAndCompute(
        InputArray image,
        InputArray mask,
        std::vector<KeyPoint>& keypoints,
        OutputArray descriptors,
        bool useProvidedKeypoints = false
        );

    virtual
    bool
    empty() const;

    void
    read(const String& fileName);

    virtual
    void
    read(const FileNode& fn);

    void
    write(const String& fileName) const;

    virtual
    void
    write(FileStorage& fs) const;

    static
    Ptr<ORB>
    create(
        int nfeatures = 500,
        float scaleFactor = 1.2f,
        int nlevels = 8,
        int edgeThreshold = 31,
        int firstLevel = 0,
        int WTA_K = 2,
        int scoreType = ORB::HARRIS_SCORE,
        int patchSize = 31,
        int fastThreshold = 20
        );

    virtual
    int
    getEdgeThreshold() const = 0;

    virtual
    int
    getFastThreshold() const = 0;

    virtual
    int
    getFirstLevel() const = 0;

    virtual
    int
    getMaxFeatures() const = 0;

    virtual
    int
    getNLevels() const = 0;

    virtual
    int
    getPatchSize() const = 0;

    virtual
    double
    getScaleFactor() const = 0;

    virtual
    int
    getScoreType() const = 0;

    virtual
    int
    getWTA_K() const = 0;

    virtual
    void
    setEdgeThreshold(int edgeThreshold) = 0;

    virtual
    void
    setFastThreshold(int fastThreshold) = 0;

    virtual
    void
    setFirstLevel(int firstLevel) = 0;

    virtual
    void
    setMaxFeatures(int maxFeatures) = 0;

    virtual
    void
    setNLevels(int nlevels) = 0;

    virtual
    void
    setPatchSize(int patchSize) = 0;

    virtual
    void
    setScaleFactor(double scaleFactor) = 0;

    virtual
    void
    setScoreType(int scoreType) = 0;

    virtual
    void
    setWTA_K(int wta_k) = 0;

    virtual
    void
    computeAsync(
        InputArray image,
        OutputArray keypoints,
        OutputArray descriptors,
        Stream& stream = Stream::Null()
        );

    virtual
    void
    convert(
        InputArray gpu_keypoints,
        std::vector<KeyPoint>& keypoints
        ) = 0;

    virtual
    void
    detectAndComputeAsync(
        InputArray image,
        InputArray mask,
        OutputArray keypoints,
        OutputArray descriptors,
        bool useProvidedKeypoints = false,
        Stream& stream = Stream::Null()
        );

    virtual
    void
    detectAsync(
        InputArray image,
        OutputArray keypoints,
        InputArray mask = noArray(),
        Stream& stream = Stream::Null()
        );

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;

Detailed Documentation

Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor.

See also:

cv::ORB

Methods

virtual
void
setBlurForDescriptor(bool blurForDescriptor) = 0

if true, image will be blurred before descriptors calculation