Class cv::FarnebackOpticalFlow#

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

#include <opencv2/video/tracking.hpp>

Collaboration diagram for cv::FarnebackOpticalFlow:

Public Member Functions#

Public Member Functions inherited from cv::DenseOpticalFlow

Return	Name	Description
`void`	`calc(` `InputArray I0,` `InputArray I1,` `InputOutputArray flow )`	Calculates an optical flow.
`void`	`collectGarbage()`	Releases all inner buffers.

Public Member Functions inherited from cv::Algorithm

Return	Name	Description
	`Algorithm()`
	`~Algorithm()`
`void`	`clear()`	Clears the algorithm state.
`bool`	`empty()`	Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read.
`String`	`getDefaultName()`
`void`	`read(const FileNode & fn)`	Reads algorithm parameters from a file storage.
`void`	`save(const String & filename)`
`void`	`write(` `const Ptr< FileStorage > & fs,` `const String & name = String() )`
`void`	`write(FileStorage & fs)`	Stores algorithm parameters in a file storage.
`void`	`write(` `FileStorage & fs,` `const String & name )`

Static Public Member Functions#

Static Public Member Functions inherited from cv::Algorithm

Return	Name	Description
`static Ptr< _Tp >`	`load(` `const String & filename,` `const String & objname = String() )`	Loads algorithm from the file.
`static Ptr< _Tp >`	`loadFromString(` `const String & strModel,` `const String & objname = String() )`	Loads algorithm from a String.
`static Ptr< _Tp >`	`read(const FileNode & fn)`	Reads algorithm from the file node.

Additional Inherited Members#

Detailed Description#

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

Member Function Documentation#

getFastPyramids()#

bool cv::FarnebackOpticalFlow::getFastPyramids()

Python:

cv.FarnebackOpticalFlow.getFastPyramids() -> retval

getFlags()#

int cv::FarnebackOpticalFlow::getFlags()

Python:

cv.FarnebackOpticalFlow.getFlags() -> retval

getNumIters()#

int cv::FarnebackOpticalFlow::getNumIters()

Python:

cv.FarnebackOpticalFlow.getNumIters() -> retval

getNumLevels()#

int cv::FarnebackOpticalFlow::getNumLevels()

Python:

cv.FarnebackOpticalFlow.getNumLevels() -> retval

getPolyN()#

int cv::FarnebackOpticalFlow::getPolyN()

Python:

cv.FarnebackOpticalFlow.getPolyN() -> retval

getPolySigma()#

double cv::FarnebackOpticalFlow::getPolySigma()

Python:

cv.FarnebackOpticalFlow.getPolySigma() -> retval

getPyrScale()#

double cv::FarnebackOpticalFlow::getPyrScale()

Python:

cv.FarnebackOpticalFlow.getPyrScale() -> retval

getWinSize()#

int cv::FarnebackOpticalFlow::getWinSize()

Python:

cv.FarnebackOpticalFlow.getWinSize() -> retval

setFastPyramids()#

void cv::FarnebackOpticalFlow::setFastPyramids(bool fastPyramids)

Python:

cv.FarnebackOpticalFlow.setFastPyramids(fastPyramids)

setFlags()#

void cv::FarnebackOpticalFlow::setFlags(int flags)

Python:

cv.FarnebackOpticalFlow.setFlags(flags)

setNumIters()#

void cv::FarnebackOpticalFlow::setNumIters(int numIters)

Python:

cv.FarnebackOpticalFlow.setNumIters(numIters)

setNumLevels()#

void cv::FarnebackOpticalFlow::setNumLevels(int numLevels)

Python:

cv.FarnebackOpticalFlow.setNumLevels(numLevels)

setPolyN()#

void cv::FarnebackOpticalFlow::setPolyN(int polyN)

Python:

cv.FarnebackOpticalFlow.setPolyN(polyN)

setPolySigma()#

void cv::FarnebackOpticalFlow::setPolySigma(double polySigma)

Python:

cv.FarnebackOpticalFlow.setPolySigma(polySigma)

setPyrScale()#

void cv::FarnebackOpticalFlow::setPyrScale(double pyrScale)

Python:

cv.FarnebackOpticalFlow.setPyrScale(pyrScale)

setWinSize()#

void cv::FarnebackOpticalFlow::setWinSize(int winSize)

Python:

cv.FarnebackOpticalFlow.setWinSize(winSize)

create()#

static Ptr< FarnebackOpticalFlow > cv::FarnebackOpticalFlow::create(
int numLevels = 5,
double pyrScale = 0.5,
bool fastPyramids = false,
int winSize = 13,
int numIters = 10,
int polyN = 5,
double polySigma = 1.1,
int flags = 0 )

Python:

cv.FarnebackOpticalFlow.create([, numLevels[, pyrScale[, fastPyramids[, winSize[, numIters[, polyN[, polySigma[, flags]]]]]]]]) -> retval

cv.FarnebackOpticalFlow_create([, numLevels[, pyrScale[, fastPyramids[, winSize[, numIters[, polyN[, polySigma[, flags]]]]]]]]) -> retval

Source file#

The documentation for this class was generated from the following file:

opencv2/video/tracking.hpp