class cv::cuda::StereoConstantSpaceBP

Overview

Class computing stereo correspondence using the constant space belief propagation algorithm. : More…

#include <cudastereo.hpp>

class StereoConstantSpaceBP: public cv::cuda::StereoBeliefPropagation
{
public:
    // methods

    virtual
    int
    getNrPlane() const = 0;

    virtual
    bool
    getUseLocalInitDataCost() const = 0;

    virtual
    void
    setNrPlane(int nr_plane) = 0;

    virtual
    void
    setUseLocalInitDataCost(bool use_local_init_data_cost) = 0;

    static
    void
    estimateRecommendedParams(
        int width,
        int height,
        int& ndisp,
        int& iters,
        int& levels,
        int& nr_plane
        );
};

Inherited Members

public:
    // enums

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

    // 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
    void
    compute(
        InputArray left,
        InputArray right,
        OutputArray disparity,
        Stream& stream
        ) = 0;

    virtual
    void
    compute(
        InputArray data,
        OutputArray disparity,
        Stream& stream = Stream::Null()
        ) = 0;

    virtual
    double
    getDataWeight() const = 0;

    virtual
    double
    getDiscSingleJump() const = 0;

    virtual
    double
    getMaxDataTerm() const = 0;

    virtual
    double
    getMaxDiscTerm() const = 0;

    virtual
    int
    getMsgType() const = 0;

    virtual
    int
    getNumIters() const = 0;

    virtual
    int
    getNumLevels() const = 0;

    virtual
    void
    setDataWeight(double data_weight) = 0;

    virtual
    void
    setDiscSingleJump(double disc_single_jump) = 0;

    virtual
    void
    setMaxDataTerm(double max_data_term) = 0;

    virtual
    void
    setMaxDiscTerm(double max_disc_term) = 0;

    virtual
    void
    setMsgType(int msg_type) = 0;

    virtual
    void
    setNumIters(int iters) = 0;

    virtual
    void
    setNumLevels(int levels) = 0;

    static
    void
    estimateRecommendedParams(
        int width,
        int height,
        int& ndisp,
        int& iters,
        int& levels
        );

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;

Detailed Documentation

Class computing stereo correspondence using the constant space belief propagation algorithm. :

The class implements algorithm described in [93]. StereoConstantSpaceBP supports both local minimum and global minimum data cost initialization algorithms. For more details, see the paper mentioned above. By default, a local algorithm is used. To enable a global algorithm, set use_local_init_data_cost to false .

StereoConstantSpaceBP uses a truncated linear model for the data cost and discontinuity terms:

\[DataCost = data \_ weight \cdot \min ( \lvert I_2-I_1 \rvert , max \_ data \_ term)\]

\[DiscTerm = \min (disc \_ single \_ jump \cdot \lvert f_1-f_2 \rvert , max \_ disc \_ term)\]

For more details, see [93].

By default, StereoConstantSpaceBP uses floating-point arithmetics and the CV_32FC1 type for messages. But it can also use fixed-point arithmetics and the CV_16SC1 message type for better performance. To avoid an overflow in this case, the parameters must satisfy the following requirement:

\[10 \cdot 2^{levels-1} \cdot max \_ data \_ term < SHRT \_ MAX\]

Methods

virtual
int
getNrPlane() const = 0

number of active disparity on the first level

static
void
estimateRecommendedParams(
    int width,
    int height,
    int& ndisp,
    int& iters,
    int& levels,
    int& nr_plane
    )

Uses a heuristic method to compute parameters (ndisp, iters, levelsand nrplane) for the specified image size (widthand height).