class cv::GFTTDetector

Wrapping class for feature detection using the goodFeaturesToTrack function. :

#include <features2d.hpp>

class GFTTDetector: public cv::Feature2D
{
public:
    // methods

    static
    Ptr<GFTTDetector>
    create(
        int maxCorners = 1000,
        double qualityLevel = 0.01,
        double minDistance = 1,
        int blockSize = 3,
        bool useHarrisDetector = false,
        double k = 0.04
        );

    virtual
    int
    getBlockSize() const = 0;

    virtual
    bool
    getHarrisDetector() const = 0;

    virtual
    double
    getK() const = 0;

    virtual
    int
    getMaxFeatures() const = 0;

    virtual
    double
    getMinDistance() const = 0;

    virtual
    double
    getQualityLevel() const = 0;

    virtual
    void
    setBlockSize(int blockSize) = 0;

    virtual
    void
    setHarrisDetector(bool val) = 0;

    virtual
    void
    setK(double k) = 0;

    virtual
    void
    setMaxFeatures(int maxFeatures) = 0;

    virtual
    void
    setMinDistance(double minDistance) = 0;

    virtual
    void
    setQualityLevel(double qlevel) = 0;
};

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

    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;

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;