class cv::cuda::StereoBM

Overview

Class computing stereo correspondence (disparity map) using the block matching algorithm. : More…

#include <cudastereo.hpp>

class StereoBM: public cv::StereoBM
{
public:
    // methods

    virtual
    void
    compute(
        InputArray left,
        InputArray right,
        OutputArray disparity,
        Stream& stream
        ) = 0;
};

Inherited Members

public:
    // enums

    enum
    {
        DISP_SHIFT = 4,
        DISP_SCALE = (1 <<DISP_SHIFT),
    };

    enum
    {
        PREFILTER_NORMALIZED_RESPONSE = 0,
        PREFILTER_XSOBEL              = 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 left,
        InputArray right,
        OutputArray disparity
        ) = 0;

    virtual
    int
    getBlockSize() const = 0;

    virtual
    int
    getDisp12MaxDiff() const = 0;

    virtual
    int
    getMinDisparity() const = 0;

    virtual
    int
    getNumDisparities() const = 0;

    virtual
    int
    getSpeckleRange() const = 0;

    virtual
    int
    getSpeckleWindowSize() const = 0;

    virtual
    void
    setBlockSize(int blockSize) = 0;

    virtual
    void
    setDisp12MaxDiff(int disp12MaxDiff) = 0;

    virtual
    void
    setMinDisparity(int minDisparity) = 0;

    virtual
    void
    setNumDisparities(int numDisparities) = 0;

    virtual
    void
    setSpeckleRange(int speckleRange) = 0;

    virtual
    void
    setSpeckleWindowSize(int speckleWindowSize) = 0;

    virtual
    int
    getPreFilterCap() const = 0;

    virtual
    int
    getPreFilterSize() const = 0;

    virtual
    int
    getPreFilterType() const = 0;

    virtual
    Rect
    getROI1() const = 0;

    virtual
    Rect
    getROI2() const = 0;

    virtual
    int
    getSmallerBlockSize() const = 0;

    virtual
    int
    getTextureThreshold() const = 0;

    virtual
    int
    getUniquenessRatio() const = 0;

    virtual
    void
    setPreFilterCap(int preFilterCap) = 0;

    virtual
    void
    setPreFilterSize(int preFilterSize) = 0;

    virtual
    void
    setPreFilterType(int preFilterType) = 0;

    virtual
    void
    setROI1(Rect roi1) = 0;

    virtual
    void
    setROI2(Rect roi2) = 0;

    virtual
    void
    setSmallerBlockSize(int blockSize) = 0;

    virtual
    void
    setTextureThreshold(int textureThreshold) = 0;

    virtual
    void
    setUniquenessRatio(int uniquenessRatio) = 0;

    static
    Ptr<StereoBM>
    create(
        int numDisparities = 0,
        int blockSize = 21
        );

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;

Detailed Documentation

Class computing stereo correspondence (disparity map) using the block matching algorithm. :

See also:

StereoBM