详细描述

稠密光流算法计算每个点的运动

运动模板是检测运动和计算其方向的另一种技术。请参见 samples/motempl.py。

函数用于读取和写入“Middlebury”格式的 .flo 文件，请参见：http://vision.middlebury.edu/flow/code/flow-code/README.txt

cv::optflow::readOpticalFlow
cv::optflow::writeOpticalFlow

类
类	cv::optflow::DenseRLOFOpticalFlow
	基于鲁棒局部光流 (RLOF) 算法和稀疏到稠密插值方案的快速稠密光流计算。更多...

类	cv::optflow::DualTVL1OpticalFlow
	“双 TV L1” 光流算法。更多...

类	cv::optflow::GPCDetails

类	cv::optflow::GPCForest< T >

结构	cv::optflow::GPCMatchingParams
	封装匹配参数的类。更多...

结构	cv::optflow::GPCPatchDescriptor

结构	cv::optflow::GPCPatchSample

结构	cv::optflow::GPCTrainingParams
	封装训练参数的类。更多...

类	cv::optflow::GPCTrainingSamples
	封装训练样本的类。更多...

类	cv::optflow::GPCTree
	用于单个树的类。更多...

类	cv::optflow::OpticalFlowPCAFlow
	PCAFlow 算法。更多...

类	cv::optflow::PCAPrior
	此类可用于对结果光流施加学习的先验。解决方案将根据此先验进行正则化。您需要事先使用“learn_prior.py”脚本生成相应的先验文件。更多...

类	cv::optflow::RLOFOpticalFlowParameter
	用于存储和设置鲁棒局部光流 (RLOF) 算法的参数。更多...

类	cv::optflow::SparseRLOFOpticalFlow
	用于使用鲁棒局部光流 (RLOF) 算法计算稀疏光流和特征跟踪的类。更多...

类型定义
typedef std::vector< GPCPatchSample >	cv::optflow::GPCSamplesVector

枚举
枚举	cv::optflow::GPCDescType { cv::optflow::GPC_DESCRIPTOR_DCT = 0 , cv::optflow::GPC_DESCRIPTOR_WHT }
	全局块碰撞器的描述符类型。更多...

枚举	cv::optflow::InterpolationType { cv::optflow::INTERP_GEO = 0 , cv::optflow::INTERP_EPIC = 1 , cv::optflow::INTERP_RIC = 2 }

枚举	cv::optflow::SolverType { cv::optflow::ST_STANDART = 0 , cv::optflow::ST_BILINEAR = 1 }

枚举	cv::optflow::SupportRegionType { cv::optflow::SR_FIXED = 0 , cv::optflow::SR_CROSS = 1 }

函数
double	cv::motempl::calcGlobalOrientation (InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration)
	计算选定区域中的全局运动方向。

void	cv::motempl::calcMotionGradient (InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize=3)
	计算运动历史图像的梯度方向。

void	cv::optflow::calcOpticalFlowDenseRLOF (InputArray I0, InputArray I1, InputOutputArray flow, Ptr< RLOFOpticalFlowParameter > rlofParam=Ptr< RLOFOpticalFlowParameter >(), float forwardBackwardThreshold=0, Size gridStep=Size(6, 6), InterpolationType interp_type=InterpolationType::INTERP_EPIC, int epicK=128, float epicSigma=0.05f, float epicLambda=100.f, int ricSPSize=15, int ricSLICType=100, bool use_post_proc=true, float fgsLambda=500.0f, float fgsSigma=1.5f, bool use_variational_refinement=false)
	基于鲁棒局部光流 (RLOF) 算法和稀疏到稠密插值方案的快速稠密光流计算。

void	cv::optflow::calcOpticalFlowSF (InputArray from, InputArray to, OutputArray flow, int layers, int averaging_block_size, int max_flow)

void	cv::optflow::calcOpticalFlowSF (InputArray from, InputArray to, OutputArray flow, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radius, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr)
	使用“SimpleFlow”算法计算光流。

void	cv::optflow::calcOpticalFlowSparseRLOF (InputArray prevImg, InputArray nextImg, InputArray prevPts, InputOutputArray nextPts, OutputArray status, OutputArray err, Ptr< RLOFOpticalFlowParameter > rlofParam=Ptr< RLOFOpticalFlowParameter >(), float forwardBackwardThreshold=0)
	使用类似于 optflow::calcOpticalFlowPyrLK() 的鲁棒局部光流 (RLOF) 计算稀疏特征集的快速光流。

void	cv::optflow::calcOpticalFlowSparseToDense (InputArray from, InputArray to, OutputArray flow, int grid_step=8, int k=128, float sigma=0.05f, bool use_post_proc=true, float fgs_lambda=500.0f, float fgs_sigma=1.5f)
	基于 PyrLK 稀疏匹配插值的快速稠密光流。

Ptr< DenseOpticalFlow >	cv::optflow::createOptFlow_DeepFlow ()
	DeepFlow 光流算法实现。

Ptr< DenseOpticalFlow >	cv::optflow::createOptFlow_DenseRLOF ()
	对稠密 RLOF 算法的额外接口 - optflow::calcOpticalFlowDenseRLOF()

Ptr< DualTVL1OpticalFlow >	cv::optflow::createOptFlow_DualTVL1 ()
	创建 cv::DenseOpticalFlow 的实例。

Ptr< DenseOpticalFlow >	cv::optflow::createOptFlow_Farneback ()
	对 Farneback 算法的额外接口 - calcOpticalFlowFarneback()

Ptr< DenseOpticalFlow >	cv::optflow::createOptFlow_PCAFlow ()
	创建 PCAFlow 的实例。

Ptr< DenseOpticalFlow >	cv::optflow::createOptFlow_SimpleFlow ()
	对 SimpleFlow 算法的额外接口 - calcOpticalFlowSF()

Ptr< SparseOpticalFlow >	cv::optflow::createOptFlow_SparseRLOF ()
	对稀疏 RLOF 算法的额外接口 - optflow::calcOpticalFlowSparseRLOF()

Ptr< DenseOpticalFlow >	cv::optflow::createOptFlow_SparseToDense ()
	对 SparseToDenseFlow 算法的额外接口 - calcOpticalFlowSparseToDense()

void	cv::optflow::GPCForest< T >::findCorrespondences (InputArray imgFrom, InputArray imgTo, std::vector< std::pair< Point2i, Point2i > > &corr, const GPCMatchingParams params=GPCMatchingParams()) const
	查找两幅图像之间的对应关系。

void	cv::motempl::segmentMotion (InputArray mhi, OutputArray segmask, std::vector< Rect > &boundingRects, double timestamp, double segThresh)
	将运动历史图像分割成几个部分，对应于不同的独立运动（例如，左手，右手）。

void	cv::motempl::updateMotionHistory (InputArray silhouette, InputOutputArray mhi, double timestamp, double duration)
	通过移动的轮廓更新运动历史图像。

类型定义文档

◆ GPCSamplesVector

typedef std::vector< GPCPatchSample > cv::optflow::GPCSamplesVector

#include <opencv2/optflow/sparse_matching_gpc.hpp>

枚举类型文档

◆ GPCDescType

enum cv::optflow::GPCDescType

#include <opencv2/optflow/sparse_matching_gpc.hpp>

全局块碰撞器的描述符类型。

枚举器
GPC_DESCRIPTOR_DCT Python: cv.optflow.GPC_DESCRIPTOR_DCT	质量更好，但速度较慢。
GPC_DESCRIPTOR_WHT Python: cv.optflow.GPC_DESCRIPTOR_WHT	质量较差，但速度快得多。

◆ InterpolationType

enum cv::optflow::InterpolationType

#include <opencv2/optflow/rlofflow.hpp>

枚举器
INTERP_GEO Python: cv.optflow.INTERP_GEO	快速测地线插值，参见 [103]
INTERP_EPIC Python: cv.optflow.INTERP_EPIC	使用 ximgproc::EdgeAwareInterpolator 进行边缘保留插值，参见 [224],Geistert2016。
INTERP_RIC Python: cv.optflow.INTERP_RIC	使用 ximgproc::RICInterpolator 进行基于 SLIC 的鲁棒插值，参见 [130]。

◆ SolverType

enum cv::optflow::SolverType

#include <opencv2/optflow/rlofflow.hpp>

枚举器
ST_STANDART Python: cv.optflow.ST_STANDART	应用标准迭代细化
ST_BILINEAR Python: cv.optflow.ST_BILINEAR	应用基于双线性方程解的优化迭代细化，如 [238] 中所述。

◆ SupportRegionType

enum cv::optflow::SupportRegionType

#include <opencv2/optflow/rlofflow.hpp>

枚举器
SR_FIXED Python: cv.optflow.SR_FIXED	应用恒定支持区域
SR_CROSS Python: cv.optflow.SR_CROSS	应用通过基于交叉的分割获得的自适应支持区域，如 [239] 中所述。

函数文档

◆ calcGlobalOrientation()

double cv::motempl::calcGlobalOrientation	(	InputArray	orientation,
		InputArray	mask,
		InputArray	mhi,
		double	timestamp,
		double	duration
	)

Python
	cv.motempl.calcGlobalOrientation(	orientation, mask, mhi, timestamp, duration	) ->	retval

#include <opencv2/optflow/motempl.hpp>

计算选定区域中的全局运动方向。

参数

orientation	由 calcMotionGradient 函数计算的运动梯度方向图像。
mask	掩码图像。它可能是由 calcMotionGradient 计算的有效梯度掩码以及需要计算其方向的区域的掩码的结合。
mhi	由 updateMotionHistory 计算的运动历史图像。
timestamp	传递给 updateMotionHistory 的时间戳。
duration	传递给 updateMotionHistory 的运动轨迹的最大持续时间（以毫秒为单位）。

该函数计算选定区域中的平均运动方向，并返回 0 度到 360 度之间的角度。平均方向是从加权方向直方图计算出来的，其中最近的运动具有更大的权重，而过去发生的运动具有更小的权重，如 mhi 中记录的那样。

◆ calcMotionGradient()

void cv::motempl::calcMotionGradient	(	InputArray	mhi,
		OutputArray	mask,
		OutputArray	orientation,
		double	delta1,
		double	delta2,
		int	apertureSize = `3`
	)

Python
	cv.motempl.calcMotionGradient(	mhi, delta1, delta2[, mask[, orientation[, apertureSize]]]	) ->	mask, orientation

#include <opencv2/optflow/motempl.hpp>

计算运动历史图像的梯度方向。

参数

mhi	运动历史单通道浮点图像。
mask	输出掩码图像，其类型为 CV_8UC1 且大小与 mhi 相同。其非零元素标记运动梯度数据正确的位置。
orientation	输出运动梯度方向图像，其类型和大小与 mhi 相同。图像的每个像素都是运动方向，从 0 到 360 度。
delta1	像素邻域内 mhi 值之间允许的最小（或最大）差值。
delta2	像素邻域内 mhi 值之间允许的最大（或最小）差值。也就是说，该函数找到每个像素 \(3 \times 3\) 邻域内的最小值（\(m(x,y)\)）和最大值（\(M(x,y)\)），并且仅当 \[\min ( \texttt{delta1} , \texttt{delta2} ) \le M(x,y)-m(x,y) \le \max ( \texttt{delta1} , \texttt{delta2} ).\]
apertureSize	Sobel 算子的孔径大小。

该函数计算每个像素 \((x, y)\) 的梯度方向，如下所示：

\[\texttt{orientation} (x,y)= \arctan{\frac{d\texttt{mhi}/dy}{d\texttt{mhi}/dx}}\]

实际上，使用了 fastAtan2 和 phase，因此计算出的角度以度为单位，并覆盖完整的范围 0..360。此外，填充掩码以指示计算出的角度有效的位置。

注意

(Python) 关于如何执行运动模板技术的示例可以在 opencv_source_code/samples/python2/motempl.py 中找到。

◆ calcOpticalFlowDenseRLOF()

void cv::optflow::calcOpticalFlowDenseRLOF	(	InputArray	I0,
		InputArray	I1,
		InputOutputArray	flow,
		Ptr< RLOFOpticalFlowParameter >	rlofParam = `Ptr< RLOFOpticalFlowParameter >()`,
		float	forwardBackwardThreshold = `0`,
		Size	gridStep = `Size(6, 6)`,
		InterpolationType	interp_type = `InterpolationType::INTERP_EPIC`,
		int	epicK = `128`,
		float	epicSigma = `0.05f`,
		float	epicLambda = `100.f`,
		int	ricSPSize = `15`,
		int	ricSLICType = `100`,
		bool	use_post_proc = `true`,
		float	fgsLambda = `500.0f`,
		float	fgsSigma = `1.5f`,
		bool	use_variational_refinement = `false`
	)

Python
	cv.optflow.calcOpticalFlowDenseRLOF(	I0, I1, flow[, rlofParam[, forwardBackwardThreshold[, gridStep[, interp_type[, epicK[, epicSigma[, epicLambda[, ricSPSize[, ricSLICType[, use_post_proc[, fgsLambda[, fgsSigma[, use_variational_refinement]]]]]]]]]]]]]	) ->	flow

#include <opencv2/optflow/rlofflow.hpp>

基于鲁棒局部光流 (RLOF) 算法和稀疏到稠密插值方案的快速稠密光流计算。

RLOF 是一种快速局部光流方法，如 [237] [238] [239] 和 [240] 中所述，类似于 [36] 提出的金字塔迭代 Lucas-Kanade 方法。更多细节和实验可以在以下论文中找到 [241]。该实现源自 optflow::calcOpticalFlowPyrLK()。

稀疏到密集的插值方案允许使用 RLOF 快速计算密集光流（参见 [103]）。对于此方案，将应用以下步骤

在规则采样网格上播种的运动向量被计算出来。此网格的稀疏性可以通过 setGridStep 进行配置。
(可选) 错误的运动向量将根据前后置信度进行过滤。阈值可以通过 setForwardBackward 进行配置。只有在阈值 >0 时才会应用过滤器，但这样会由于反向流的估计而导致运行时间加倍。
向量场插值应用于运动向量集以获得密集向量场。

参数

I0	第一个 8 位输入图像。如果使用基于交叉的 RLOF（通过选择 optflow::RLOFOpticalFlowParameter::supportRegionType = SupportRegionType::SR_CROSS），则图像必须是 8 位 3 通道图像。
I1	第二个 8 位输入图像。如果使用基于交叉的 RLOF（通过选择 optflow::RLOFOpticalFlowParameter::supportRegionType = SupportRegionType::SR_CROSS），则图像必须是 8 位 3 通道图像。
flow	计算出的流图像，其大小与 I0 相同，类型为 CV_32FC2。
rlofParam	参见 optflow::RLOFOpticalFlowParameter
forwardBackwardThreshold	前后置信度检查的阈值。对于每个网格点 \( \mathbf{x} \)，计算一个运动向量 \( d_{I0,I1}(\mathbf{x}) \)。如果前后误差 \[ EP_{FB} = \|\| d_{I0,I1} + d_{I1,I0} \|\| \] 大于此函数给出的阈值，则该运动向量将不会被后续的向量场插值使用。\( d_{I1,I0} \) 表示反向流。注意，只有在阈值 > 0 时才会应用前后测试。这可能会导致运动估计的运行时间加倍。
gridStep	生成运动向量的网格大小。对于每个网格点，都会计算一个运动向量。由于前后阈值（如果设置为 >0），一些运动向量将被删除。其余向量将是向量场插值的基准。
interp_type	用于计算密集光流的插值方法。支持两种插值算法 INTERP_GEO 应用快速测地线插值，参见 [103]。 INTERP_EPIC_RESIDUAL 应用边缘保留插值，参见 [224],Geistert2016。
epicK	参见 ximgproc::EdgeAwareInterpolator 设置相应的参数。
epicSigma	参见 ximgproc::EdgeAwareInterpolator 设置相应的参数。
epicLambda	参见 ximgproc::EdgeAwareInterpolator 设置相应的参数。
ricSPSize	参见 ximgproc::RICInterpolator 设置相应的参数。
ricSLICType	参见 ximgproc::RICInterpolator 设置相应的参数。
use_post_proc	启用 ximgproc::fastGlobalSmootherFilter() 参数。
fgsLambda	设置相应的 ximgproc::fastGlobalSmootherFilter() 参数。
fgsSigma	设置相应的 ximgproc::fastGlobalSmootherFilter() 参数。
use_variational_refinement	启用 VariationalRefinement

参数已在 [237]、[238]、[239]、[240] 中描述。有关 RLOF 配置，请参见 optflow::RLOFOpticalFlowParameter 以获取更多详细信息。

注意: 如果网格大小设置为 (1,1) 且前后阈值 <= 0，则密集光流场完全由 RLOF 计算。; 仅在使用 SSE4.1 编译时可用 SIMD 并行化。; 注意，在输出中，如果在 I0 和 I1 之间找不到对应关系，则 flow 将设置为 0。

另请参阅: optflow::DenseRLOFOpticalFlow，optflow::RLOFOpticalFlowParameter

◆ calcOpticalFlowSF() [1/2]

void cv::optflow::calcOpticalFlowSF	(	InputArray	from,
		InputArray	to,
		OutputArray	flow,
		int	layers,
		int	averaging_block_size,
		int	max_flow
	)

Python
	cv.optflow.calcOpticalFlowSF(	from_, to, layers, averaging_block_size, max_flow[, flow]	) ->	flow
	cv.optflow.calcOpticalFlowSF(	from_, to, layers, averaging_block_size, max_flow, sigma_dist, sigma_color, postprocess_window, sigma_dist_fix, sigma_color_fix, occ_thr, upscale_averaging_radius, upscale_sigma_dist, upscale_sigma_color, speed_up_thr[, flow]	) ->	flow

#include <opencv2/optflow.hpp>

这是一个重载的成员函数，为了方便提供。它只在接受的参数方面与上面的函数不同。

◆ calcOpticalFlowSF() [2/2]

void cv::optflow::calcOpticalFlowSF	(	InputArray	from,
		InputArray	to,
		OutputArray	flow,
		int	layers,
		int	averaging_block_size,
		int	max_flow,
		double	sigma_dist,
		double	sigma_color,
		int	postprocess_window,
		double	sigma_dist_fix,
		double	sigma_color_fix,
		double	occ_thr,
		int	upscale_averaging_radius,
		double	upscale_sigma_dist,
		double	upscale_sigma_color,
		double	speed_up_thr
	)

Python
	cv.optflow.calcOpticalFlowSF(	from_, to, layers, averaging_block_size, max_flow[, flow]	) ->	flow
	cv.optflow.calcOpticalFlowSF(	from_, to, layers, averaging_block_size, max_flow, sigma_dist, sigma_color, postprocess_window, sigma_dist_fix, sigma_color_fix, occ_thr, upscale_averaging_radius, upscale_sigma_dist, upscale_sigma_color, speed_up_thr[, flow]	) ->	flow

#include <opencv2/optflow.hpp>

使用“SimpleFlow”算法计算光流。

参数

from	第一个 8 位 3 通道图像。
to	第二个 8 位 3 通道图像，与 prev 大小相同
flow	计算出的流图像，与 prev 大小相同，类型为 CV_32FC2
layers	层数
averaging_block_size	计算像素成本函数时累加的块大小
max_flow	我们在每层搜索的最大流
sigma_dist	向量平滑空间 sigma 参数
sigma_color	向量平滑颜色 sigma 参数
postprocess_window	后处理交叉双边滤波的窗口大小
sigma_dist_fix	后处理交叉双边滤波的空间 sigma
sigma_color_fix	后处理交叉双边滤波的颜色 sigma
occ_thr	检测遮挡的阈值
upscale_averaging_radius	双边上采样操作的窗口大小
upscale_sigma_dist	双边上采样操作的空间 sigma
upscale_sigma_color	双边上采样操作的颜色 sigma
speed_up_thr	检测具有不规则流的点的阈值 - 在上采样后应重新计算流的地方

参见 [263]。以及项目网站 - http://graphics.berkeley.edu/papers/Tao-SAN-2012-05/.

注意

使用 simpleFlow 算法的示例可以在 samples/simpleflow_demo.cpp 中找到

◆ calcOpticalFlowSparseRLOF()

void cv::optflow::calcOpticalFlowSparseRLOF	(	InputArray	prevImg,
		InputArray	nextImg,
		InputArray	prevPts,
		InputOutputArray	nextPts,
		OutputArray	status,
		OutputArray	err,
		Ptr< RLOFOpticalFlowParameter >	rlofParam = `Ptr< RLOFOpticalFlowParameter >()`,
		float	forwardBackwardThreshold = `0`
	)

Python
	cv.optflow.calcOpticalFlowSparseRLOF(	prevImg, nextImg, prevPts, nextPts[, status[, err[, rlofParam[, forwardBackwardThreshold]]]]	) ->	nextPts, status, err

#include <opencv2/optflow/rlofflow.hpp>

使用类似于 optflow::calcOpticalFlowPyrLK() 的鲁棒局部光流 (RLOF) 计算稀疏特征集的快速光流。

RLOF 是一种快速局部光流方法，如 [237] [238] [239] 和 [240] 中所述，类似于 [36] 提出的金字塔迭代 Lucas-Kanade 方法。更多细节和实验可以在以下论文中找到 [241]。该实现源自 optflow::calcOpticalFlowPyrLK()。

参数

prevImg	第一个 8 位输入图像。如果使用基于交叉的 RLOF（通过选择 optflow::RLOFOpticalFlowParameter::supportRegionType = SupportRegionType::SR_CROSS），则图像必须是 8 位 3 通道图像。
nextImg	第二个 8 位输入图像。如果使用基于交叉的 RLOF（通过选择 optflow::RLOFOpticalFlowParameter::supportRegionType = SupportRegionType::SR_CROSS），则图像必须是 8 位 3 通道图像。
prevPts	需要找到流的 2D 点向量；点坐标必须是单精度浮点数。
nextPts	包含计算出的第二个图像中输入特征的新位置的 2D 点输出向量（具有单精度浮点数坐标）；当 optflow::RLOFOpticalFlowParameter::useInitialFlow 变量为真时，向量必须与输入向量大小相同，并且包含初始化点对应关系。
status	无符号字符输出状态向量；向量的每个元素如果对应特征的流通过了前向后向检查，则设置为 1。
err	输出错误向量；向量的每个元素都设置为对应特征的前向后向错误。
rlofParam	参见 optflow::RLOFOpticalFlowParameter
forwardBackwardThreshold	前向后向置信检查的阈值。如果 forewardBackwardThreshold <=0，则前向

注意: 仅在使用 SSE4.1 编译时可用 SIMD 并行化。

参数在 [237]、[238]、[239] 和 [240] 中进行了描述。对于 RLOF 配置，请参见 optflow::RLOFOpticalFlowParameter，以获取更多详细信息。

◆ calcOpticalFlowSparseToDense()

void cv::optflow::calcOpticalFlowSparseToDense	(	InputArray	from,
		InputArray	to,
		OutputArray	flow,
		int	grid_step = `8`,
		int	k = `128`,
		float	sigma = `0.05f`,
		bool	use_post_proc = `true`,
		float	fgs_lambda = `500.0f`,
		float	fgs_sigma = `1.5f`
	)

Python
	cv.optflow.calcOpticalFlowSparseToDense(	from_, to[, flow[, grid_step[, k[, sigma[, use_post_proc[, fgs_lambda[, fgs_sigma]]]]]]]	) ->	flow

#include <opencv2/optflow.hpp>

基于 PyrLK 稀疏匹配插值的快速稠密光流。

参数

from	第一个 8 位 3 通道或 1 通道图像。
to	第二个 8 位 3 通道或 1 通道图像，与 from 大小相同
flow	计算出的流图像，与 from 大小相同，类型为 CV_32FC2
grid_step	稀疏匹配计算中使用的步长。较小的值通常会导致更高的质量，但会减慢算法速度。
k	拟合局部仿射模型时考虑的最近邻匹配数量。较小的值可以使算法明显更快，但会以牺牲一些质量为代价。
sigma	定义局部加权仿射拟合中权重下降速度的参数。较高的值可以帮助保留精细细节，较小的值可以帮助消除输出流中的噪声。
use_post_proc	定义是否 ximgproc::fastGlobalSmootherFilter() 用于插值后的后处理
fgs_lambda	请参见 ximgproc::fastGlobalSmootherFilter() 的相应参数
fgs_sigma	请参见 ximgproc::fastGlobalSmootherFilter() 的相应参数

◆ createOptFlow_DeepFlow()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_DeepFlow ( )

Python
	cv.optflow.createOptFlow_DeepFlow(		) ->	retval

#include <opencv2/optflow.hpp>

DeepFlow 光流算法实现。

该类实现了 [295] 中描述的 DeepFlow 光流算法。另请参见 http://lear.inrialpes.fr/src/deepmatching/。参数 - 类字段 - 可以在创建类实例后修改

成员 float alpha 平滑假设权重
成员 float delta 颜色恒定假设权重
成员 float gamma 梯度恒定权重
成员 float sigma 高斯平滑参数
成员 int minSize 金字塔中图像的最小尺寸（金字塔中下一个较小的图像将生成，直到其中一个尺寸达到此大小）
成员 float downscaleFactor 图像金字塔中的缩放因子（必须小于 1）
成员 int fixedPointIterations 金字塔每一层迭代的次数
成员 int sorIterations 逐次超松弛迭代次数（求解器）
成员 float omega SOR 中的松弛因子

◆ createOptFlow_DenseRLOF()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_DenseRLOF ( )

Python
	cv.optflow.createOptFlow_DenseRLOF(		) ->	retval

#include <opencv2/optflow/rlofflow.hpp>

对稠密 RLOF 算法的额外接口 - optflow::calcOpticalFlowDenseRLOF()

◆ createOptFlow_DualTVL1()

Ptr< DualTVL1OpticalFlow > cv::optflow::createOptFlow_DualTVL1 ( )

Python
	cv.optflow.createOptFlow_DualTVL1(		) ->	retval

#include <opencv2/optflow.hpp>

创建 cv::DenseOpticalFlow 的实例。

◆ createOptFlow_Farneback()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_Farneback ( )

Python
	cv.optflow.createOptFlow_Farneback(		) ->	retval

#include <opencv2/optflow.hpp>

对 Farneback 算法的额外接口 - calcOpticalFlowFarneback()

◆ createOptFlow_PCAFlow()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_PCAFlow ( )

Python
	cv.optflow.createOptFlow_PCAFlow(		) ->	retval

#include <opencv2/optflow/pcaflow.hpp>

创建 PCAFlow 的实例。

◆ createOptFlow_SimpleFlow()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_SimpleFlow ( )

Python
	cv.optflow.createOptFlow_SimpleFlow(		) ->	retval

#include <opencv2/optflow.hpp>

对 SimpleFlow 算法的额外接口 - calcOpticalFlowSF()

◆ createOptFlow_SparseRLOF()

Ptr< SparseOpticalFlow > cv::optflow::createOptFlow_SparseRLOF ( )

Python
	cv.optflow.createOptFlow_SparseRLOF(		) ->	retval

#include <opencv2/optflow/rlofflow.hpp>

对稀疏 RLOF 算法的额外接口 - optflow::calcOpticalFlowSparseRLOF()

◆ createOptFlow_SparseToDense()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_SparseToDense ( )

Python
	cv.optflow.createOptFlow_SparseToDense(		) ->	retval

#include <opencv2/optflow.hpp>

对 SparseToDenseFlow 算法的额外接口 - calcOpticalFlowSparseToDense()

◆ findCorrespondences()

template<int T>

void cv::optflow::GPCForest< T >::findCorrespondences	(	InputArray	imgFrom,
		InputArray	imgTo,
		std::vector< std::pair< Point2i, Point2i > > &	corr,
		const GPCMatchingParams	params = `GPCMatchingParams()`
	)		const

#include <opencv2/optflow/sparse_matching_gpc.hpp>

查找两幅图像之间的对应关系。

参数

[in]	imgFrom	序列中的第一个图像。
[in]	imgTo	序列中的第二个图像。
[out]	corr	具有对应点对的输出向量。
[in]	params	用于微调的额外匹配参数。

这是此函数的调用图

◆ segmentMotion()

void cv::motempl::segmentMotion	(	InputArray	mhi,
		OutputArray	segmask,
		std::vector< Rect > &	boundingRects,
		double	timestamp,
		double	segThresh
	)

Python
	cv.motempl.segmentMotion(	mhi, timestamp, segThresh[, segmask]	) ->	segmask, boundingRects

#include <opencv2/optflow/motempl.hpp>

将运动历史图像分割成几个部分，对应于不同的独立运动（例如，左手，右手）。

参数

mhi	运动历史图像。
segmask	应存储找到的掩码的图像，单通道，32 位浮点数。
boundingRects	包含运动连通分量的 ROI 的向量。
timestamp	以毫秒或其他单位表示的当前时间。
segThresh	分割阈值，建议等于运动历史“步长”之间的间隔或更大。

该函数找到所有运动片段并在 segmask 中使用单独的值 (1,2,...) 对其进行标记。它还计算包含运动连通分量 ROI 的向量。之后，可以使用 calcGlobalOrientation 使用提取的特定组件掩码计算每个组件的运动方向。

◆ updateMotionHistory()

void cv::motempl::updateMotionHistory	(	InputArray	silhouette,
		InputOutputArray	mhi,
		double	timestamp,
		double	duration
	)

Python
	cv.motempl.updateMotionHistory(	silhouette, mhi, timestamp, duration	) ->	mhi

#include <opencv2/optflow/motempl.hpp>

通过移动的轮廓更新运动历史图像。

参数

silhouette	具有非零像素的轮廓掩码，运动发生在这些像素处。
mhi	通过函数更新的运动历史图像（单通道，32 位浮点数）。
timestamp	以毫秒或其他单位表示的当前时间。
duration	运动轨迹的最大持续时间，与 timestamp 使用相同的单位。

该函数按如下方式更新运动历史图像

\[\texttt{mhi} (x,y)= \forkthree{\texttt{timestamp}}{if \(\texttt{silhouette}(x,y) \ne 0\)}{0}{if \(\texttt{silhouette}(x,y) = 0\) and \(\texttt{mhi} < (\texttt{timestamp} - \texttt{duration})\)}{\texttt{mhi}(x,y)}{otherwise}\]

也就是说，运动发生的 MHI 像素设置为当前时间戳，而很久以前发生运动的像素将被清除。

该函数与 calcMotionGradient 和 calcGlobalOrientation 一起，实现了一种运动模板技术，如 [66] 和 [38] 中所述。