Video Analysis

ocl::GoodFeaturesToTrackDetector_OCL

Class used for strong corners detection on an image.

class GoodFeaturesToTrackDetector_OCL
{
public:
    explicit GoodFeaturesToTrackDetector_OCL(int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 0.0,
        int blockSize = 3, bool useHarrisDetector = false, double harrisK = 0.04);

    //! return 1 rows matrix with CV_32FC2 type
    void operator ()(const oclMat& image, oclMat& corners, const oclMat& mask = oclMat());
    //! download points of type Point2f to a vector. the vector's content will be erased
    void downloadPoints(const oclMat &points, std::vector<Point2f> &points_v);

    int maxCorners;
    double qualityLevel;
    double minDistance;

    int blockSize;
    bool useHarrisDetector;
    double harrisK;
    void releaseMemory()
    {
        Dx_.release();
        Dy_.release();
        eig_.release();
        minMaxbuf_.release();
        tmpCorners_.release();
    }
};

The class finds the most prominent corners in the image.

ocl::GoodFeaturesToTrackDetector_OCL::GoodFeaturesToTrackDetector_OCL

Constructor.

ocl::GoodFeaturesToTrackDetector_OCL::operator ()

Finds the most prominent corners in the image.

ocl::GoodFeaturesToTrackDetector_OCL::releaseMemory

Releases inner buffers memory.

ocl::FarnebackOpticalFlow

Class computing a dense optical flow using the Gunnar Farneback's algorithm.

class CV_EXPORTS FarnebackOpticalFlow
{
public:
    FarnebackOpticalFlow();

    int numLevels;
    double pyrScale;
    bool fastPyramids;
    int winSize;
    int numIters;
    int polyN;
    double polySigma;
    int flags;

    void operator ()(const oclMat &frame0, const oclMat &frame1, oclMat &flowx, oclMat &flowy);

    void releaseMemory();

private:
    /* hidden */
};

ocl::FarnebackOpticalFlow::operator ()

Computes a dense optical flow using the Gunnar Farneback's algorithm.

ocl::FarnebackOpticalFlow::releaseMemory

Releases unused auxiliary memory buffers.

ocl::PyrLKOpticalFlow

Class used for calculating an optical flow.

class PyrLKOpticalFlow
{
public:
    PyrLKOpticalFlow();

    void sparse(const oclMat& prevImg, const oclMat& nextImg, const oclMat& prevPts, oclMat& nextPts,
        oclMat& status, oclMat* err = 0);

    void dense(const oclMat& prevImg, const oclMat& nextImg, oclMat& u, oclMat& v, oclMat* err = 0);

    Size winSize;
    int maxLevel;
    int iters;
    double derivLambda;
    bool useInitialFlow;
    float minEigThreshold;
    bool getMinEigenVals;

    void releaseMemory();

private:
    /* hidden */
};

The class can calculate an optical flow for a sparse feature set or dense optical flow using the iterative Lucas-Kanade method with pyramids.

ocl::PyrLKOpticalFlow::sparse

Calculate an optical flow for a sparse feature set.

ocl::PyrLKOpticalFlow::dense

Calculate dense optical flow.

ocl::PyrLKOpticalFlow::releaseMemory

Releases inner buffers memory.

ocl::interpolateFrames

Interpolates frames (images) using provided optical flow (displacement field).

ocl::KalmanFilter

Kalman filter class.

class CV_EXPORTS KalmanFilter
{
public:
    KalmanFilter();
    //! the full constructor taking the dimensionality of the state, of the measurement and of the control vector
    KalmanFilter(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F);
    //! re-initializes Kalman filter. The previous content is destroyed.
    void init(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F);

    const oclMat& predict(const oclMat& control=oclMat());
    const oclMat& correct(const oclMat& measurement);

    oclMat statePre; //!< predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
    oclMat statePost; //!< corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
    oclMat transitionMatrix; //!< state transition matrix (A)
    oclMat controlMatrix; //!< control matrix (B) (not used if there is no control)
    oclMat measurementMatrix; //!< measurement matrix (H)
    oclMat processNoiseCov; //!< process noise covariance matrix (Q)
    oclMat measurementNoiseCov;//!< measurement noise covariance matrix (R)
    oclMat errorCovPre; //!< priori error estimate covariance matrix (P'(k)): P'(k)=A*P(k-1)*At + Q)*/
    oclMat gain; //!< Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
    oclMat errorCovPost; //!< posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)
private:
    /* hidden */
};

ocl::KalmanFilter::KalmanFilter

The constructors.

ocl::KalmanFilter::init

Re-initializes Kalman filter. The previous content is destroyed.

ocl::KalmanFilter::predict

Computes a predicted state.

ocl::KalmanFilter::correct

Updates the predicted state from the measurement.

ocl::BackgroundSubtractor

Base class for background/foreground segmentation.

class CV_EXPORTS BackgroundSubtractor
{
public:
    //! the virtual destructor
    virtual ~BackgroundSubtractor();
    //! the update operator that takes the next video frame and returns the current foreground mask as 8-bit binary image.
    virtual void operator()(const oclMat& image, oclMat& fgmask, float learningRate);

    //! computes a background image
    virtual void getBackgroundImage(oclMat& backgroundImage) const = 0;
};

The class is only used to define the common interface for the whole family of background/foreground segmentation algorithms.

ocl::BackgroundSubtractor::operator()

Computes a foreground mask.

ocl::BackgroundSubtractor::getBackgroundImage

Computes a background image.

ocl::MOG

Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm.

class CV_EXPORTS MOG: public cv::ocl::BackgroundSubtractor
{
public:
    //! the default constructor
    MOG(int nmixtures = -1);

    //! re-initiaization method
    void initialize(Size frameSize, int frameType);

    //! the update operator
    void operator()(const oclMat& frame, oclMat& fgmask, float learningRate = 0.f);

    //! computes a background image which are the mean of all background gaussians
    void getBackgroundImage(oclMat& backgroundImage) const;

    //! releases all inner buffers
    void release();

    int history;
    float varThreshold;
    float backgroundRatio;
    float noiseSigma;

private:
    /* hidden */
};

The class discriminates between foreground and background pixels by building and maintaining a model of the background. Any pixel which does not fit this model is then deemed to be foreground. The class implements algorithm described in [MOG2001]_.

ocl::MOG::MOG

The constructor.

Default constructor sets all parameters to default values.

ocl::MOG::operator()

Updates the background model and returns the foreground mask.

ocl::MOG::getBackgroundImage

Computes a background image.

ocl::MOG::release

Releases all inner buffer's memory.

ocl::MOG2

ocl::MOG2::MOG2

The constructor.

Default constructor sets all parameters to default values.

ocl::MOG2::operator()

Updates the background model and returns the foreground mask.

ocl::MOG2::getBackgroundImage

Computes a background image.

ocl::MOG2::release

Releases all inner buffer's memory.