详细说明

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

cv::optflow::calcOpticalFlowSF
cv::optflow::createOptFlow_DeepFlow

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

cv::motempl::updateMotionHistory
cv::motempl::calcMotionGradient
cv::motempl::calcGlobalOrientation
cv::motempl::segmentMotion

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

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

类	cv::optflow::DualTVL1OpticalFlow
	“Dual 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) 算法进行特征跟踪的类。更多...

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

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

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

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

enum	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 ()
	Dense 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 ()
	Sparse 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)
	通过移动轮廓更新运动历史图像。

类型定义文档 (Typedef Documentation)

◆ GPCSamplesVector

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

#include <opencv2/optflow/sparse_matching_gpc.hpp>

枚举类型文档 (Enumeration Type Documentation)

◆ GPCDescType

enum cv::optflow::GPCDescType

#include <opencv2/optflow/sparse_matching_gpc.hpp>

全局块碰撞器 (Global Patch Collider) 的描述符类型。

枚举值 (Enumerator)
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>

枚举值 (Enumerator)
INTERP_GEO Python: cv.optflow.INTERP_GEO	快速测地线插值，参见 [105]
INTERP_EPIC Python: cv.optflow.INTERP_EPIC	使用 ximgproc::EdgeAwareInterpolator 的边缘保留插值，参见 [231], Geistert2016。
INTERP_RIC Python: cv.optflow.INTERP_RIC	基于 SLIC 的鲁棒插值，使用 ximgproc::RICInterpolator，参见 [134]。

◆ SolverType

enum cv::optflow::SolverType

#include <opencv2/optflow/rlofflow.hpp>

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

◆ SupportRegionType

enum cv::optflow::SupportRegionType

#include <opencv2/optflow/rlofflow.hpp>

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

函数文档 (Function Documentation)

◆ 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)\) ) mhi 值，并仅在满足以下条件时才将 \((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 是一种快速局部光流方法，在 [244] [245] [246] 和 [247] 中有描述，类似于 [38] 提出的金字塔迭代 Lucas-Kanade 方法。更多详情和实验可以在以下论文 [248] 中找到。该实现源自 optflow::calcOpticalFlowPyrLK()。

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

计算以规则采样网格为种子的运动向量。该网格的稀疏度可以使用 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 (RLOF 参数)	参见 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 应用快速测地线插值，参见 [105]。 INTERP_EPIC_RESIDUAL 应用边缘保留插值，参见 [231], 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

参数已在 [244], [245], [246], [247] 中描述。有关 RLOF 配置的更多详细信息，请参见 optflow::RLOFOpticalFlowParameter。

注意: 如果网格大小设置为 (1,1) 且前后向阈值 <= 0，则稠密光流场纯粹使用 RLOF 计算。; SIMD 并行化仅在编译时使用 SSE4.1 时可用。; 注意，在输出中，如果在 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	检测具有不规则流的点的阈值 - 在上采样后应重新计算流的位置

参见 [270]。以及项目网站 - 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 是一种快速局部光流方法，在 [244] [245] [246] 和 [247] 中有描述，类似于 [38] 提出的金字塔迭代 Lucas-Kanade 方法。更多详情和实验可以在以下论文 [248] 中找到。该实现源自 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	需要寻找光流的二维点向量；点坐标必须是单精度浮点数。
nextPts	2D 点的输出向量（单精度浮点坐标），包含在第二幅图像中计算出的输入特征的新位置；当 optflow::RLOFOpticalFlowParameter::useInitialFlow 变量为 true 时，该向量的大小必须与输入相同，并包含初始化的点对应关系。
status	输出状态向量（无符号字符）；如果相应特征的流已通过前后向检查，则向量的每个元素都设置为 1。
err	输出误差向量；向量的每个元素都设置为相应特征的前后向误差。
rlofParam (RLOF 参数)	参见 optflow::RLOFOpticalFlowParameter
forwardBackwardThreshold (前后向一致性阈值)	前后向置信度检查的阈值。如果 forewardBackwardThreshold <= 0，则不执行前向检查。

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

参数已在 [244], [245], [246] 和 [247] 中描述。有关 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 光流算法实现。

该类实现了 [301] 中描述的 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>

Dense 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>

Sparse 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 (分割阈值)	建议等于运动历史“步长”之间的间隔或更大的分割阈值。

该函数找到所有的运动段，并用个别值 (1,2,...) 在 segmask 中标记它们。它还计算包含运动连通组件 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}}{如果 \(\texttt{silhouette}(x,y) \ne 0\)}{0}{如果 \(\texttt{silhouette}(x,y) = 0\) 且 \(\texttt{mhi} < (\texttt{timestamp} - \texttt{duration})\)}{\texttt{mhi}(x,y)}{否则}\]

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

该函数与 calcMotionGradient 和 calcGlobalOrientation 一起，实现了 [69] 和 [40] 中描述的运动模板技术。

详细说明

类

类型定义 (Typedefs)

枚举

函数

类型定义文档 (Typedef Documentation)

◆ GPCSamplesVector

枚举类型文档 (Enumeration Type Documentation)

◆ GPCDescType

◆ InterpolationType

◆ SolverType

◆ SupportRegionType

函数文档 (Function Documentation)

◆ calcGlobalOrientation()

◆ calcMotionGradient()

◆ calcOpticalFlowDenseRLOF()

◆ calcOpticalFlowSF() [1/2]

◆ calcOpticalFlowSF() [2/2]

◆ calcOpticalFlowSparseRLOF()

◆ calcOpticalFlowSparseToDense()

◆ createOptFlow_DeepFlow()

◆ createOptFlow_DenseRLOF()

◆ createOptFlow_DualTVL1()

◆ createOptFlow_Farneback()

◆ createOptFlow_PCAFlow()

◆ createOptFlow_SimpleFlow()

◆ createOptFlow_SparseRLOF()

◆ createOptFlow_SparseToDense()

◆ findCorrespondences()

◆ segmentMotion()

◆ updateMotionHistory()