class cv::cuda::StereoBeliefPropagation

Overview

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

#include <cudastereo.hpp>

class StereoBeliefPropagation: public cv::StereoMatcher
{
public:
    // methods

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

// direct descendants

class StereoConstantSpaceBP;

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;

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;

Detailed Documentation

Class computing stereo correspondence using the belief propagation algorithm. :

The class implements algorithm described in [26]. It can compute own data cost (using a truncated linear model) or use a user-provided data cost.

StereoBeliefPropagation requires a lot of memory for message storage:

\[width \_ step \cdot height \cdot ndisp \cdot 4 \cdot (1 + 0.25)\]

and for data cost storage:

\[width\_step \cdot height \cdot ndisp \cdot (1 + 0.25 + 0.0625 + \dotsm + \frac{1}{4^{levels}})\]

width_step is the number of bytes in a line including padding.

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

\[DataCost = data \_ weight \cdot \min ( \lvert Img_Left(x,y)-Img_Right(x-d,y) \rvert , max \_ data \_ term)\]

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

For more details, see [26].

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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

Enables the stereo correspondence operator that finds the disparity for the specified data cost.

Parameters:

data	User-specified data cost, a matrix of msg_type type and Size(<image columns>*ndisp, <image rows>) size.
disparity	Output disparity map. If disparity is empty, the output type is CV_16SC1 . Otherwise, the type is retained. In 16-bit signed format, the disparity values do not have fractional bits.
stream	Stream for the asynchronous version.

virtual
double
getDataWeight() const = 0

data weight

virtual
double
getDiscSingleJump() const = 0

discontinuity single jump

virtual
double
getMaxDataTerm() const = 0

truncation of data cost

virtual
double
getMaxDiscTerm() const = 0

truncation of discontinuity cost

virtual
int
getMsgType() const = 0

type for messages (CV_16SC1 or CV_32FC1)

virtual
int
getNumIters() const = 0

number of BP iterations on each level

virtual
int
getNumLevels() const = 0

number of levels

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

Uses a heuristic method to compute the recommended parameters ( ndisp, iters and levels ) for the specified image size ( width and height ).