OpenCV 4.11.0
开源计算机视觉
加载中…
搜索中…
未找到匹配项
类 | 类型定义 | 枚举 | 函数
光流算法

详细描述

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

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

读取和写入“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) 算法计算稀疏光流和特征跟踪的类。更多…
 

类型定义

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

快速测地线插值，参见 [102]

INTERP_EPIC 
Python: cv.optflow.INTERP_EPIC

使用 ximgproc::EdgeAwareInterpolator 进行边缘保持插值，参见 [225]，Geistert2016。

INTERP_RIC 
Python: cv.optflow.INTERP_RIC

使用 ximgproc::RICInterpolator 的基于 SLIC 的鲁棒插值，参见 [129]。

◆ SolverType

enum cv::optflow::SolverType

#include <opencv2/optflow/rlofflow.hpp>

枚举器
ST_STANDART 
Python: cv.optflow.ST_STANDART

应用标准迭代细化

ST_BILINEAR 
Python: cv.optflow.ST_BILINEAR

应用基于双线性方程解的优化迭代细化，如 [239] 中所述

◆ SupportRegionType

enum cv::optflow::SupportRegionType

#include <opencv2/optflow/rlofflow.hpp>

枚举器
SR_FIXED 
Python: cv.optflow.SR_FIXED

应用恒定支持区域

SR_CROSS 
Python: cv.optflow.SR_CROSS

应用基于交叉分割的自适应支持区域，如 [240] 中所述

函数文档

◆ calcGlobalOrientation()

double cv::motempl::calcGlobalOrientation ( InputArray 方向,
InputArray 掩码,
InputArray 运动历史图像,
double 时间戳,
double 持续时间 )
Python
cv.motempl.calcGlobalOrientation(orientation, mask, mhi, timestamp, duration) -> 返回值

#include <opencv2/optflow/motempl.hpp>

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

参数
方向由 calcMotionGradient 函数计算的运动梯度方向图像
掩码掩码图像。它可能是由 calcMotionGradient 计算的有效梯度掩码和需要计算方向的区域掩码的组合。
运动历史图像由 updateMotionHistory 计算的运动历史图像。
时间戳传递给 updateMotionHistory 的时间戳。
持续时间传递给 updateMotionHistory 的运动轨迹最大持续时间（毫秒）。

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

◆ calcMotionGradient()

void cv::motempl::calcMotionGradient ( InputArray 运动历史图像,
输出数组 掩码,
输出数组 方向,
double delta1,
double delta2,
int apertureSize = 3 )
Python
cv.motempl.calcMotionGradient(mhi, delta1, delta2[, mask[, orientation[, apertureSize]]]) -> mask, orientation

#include <opencv2/optflow/motempl.hpp>

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

参数
运动历史图像运动历史单通道浮点图像。
掩码输出掩码图像，类型为 CV_8UC1，大小与 mhi 相同。其非零元素标记运动梯度数据正确的像素。
方向输出运动梯度方向图像，类型和大小与 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} ).\]

apertureSizeSobel 算子的孔径大小。

该函数计算每个像素 \((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,
输入输出数组 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 是一种快速的局部光流方法，在 [238] [239] [240] 和 [241] 中有描述，类似于 [36] 提出的金字塔迭代 Lucas-Kanade 方法。更多细节和实验结果可以在以下论文中找到 [242]。该实现源自 optflow::calcOpticalFlowPyrLK()。

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

  1. 在规则采样网格上计算种子运动向量。可以使用 setGridStep 配置此网格的稀疏性。
  2. (可选) 基于前向后向置信度过滤错误的运动向量。可以使用 setForwardBackward 配置阈值。只有当阈值 > 0 时才应用过滤器，但由于估计反向流，运行时间会加倍。
  3. 将向量场插值应用于运动向量集以获得稠密向量场。
参数
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 应用快速测地线插值，参见 [102]。
  • INTERP_EPIC_RESIDUAL 应用边缘保持插值，参见 [225]，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

参数已在 [238]，[239]，[240]，[241] 中描述。有关 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 来自,
InputArray 到,
输出数组 flow,
int 层,
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 来自,
InputArray 到,
输出数组 flow,
int 层,
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”算法计算光流。

参数
来自第一个 8 位 3 通道图像。
到第二个 8 位 3 通道图像，大小与 prev 相同
flow计算出的光流图像，大小与 prev 相同，类型为 CV_32FC2
层层数
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检测具有不规则流动的点的阈值 - 在上采样后应重新计算流动的点

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

注意
  • 在 samples/simpleflow_demo.cpp 中可以找到一个使用 simpleFlow 算法的示例

◆ calcOpticalFlowSparseRLOF()

void cv::optflow::calcOpticalFlowSparseRLOF ( InputArray prevImg,
InputArray nextImg,
InputArray prevPts,
输入输出数组 nextPts,
输出数组 status,
输出数组 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 是一种快速的局部光流方法，在 [238] [239] [240] 和 [241] 中有描述，类似于 [36] 提出的金字塔迭代 Lucas-Kanade 方法。更多细节和实验结果可以在以下论文中找到 [242]。该实现源自 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包含在第二幅图像中计算出的输入特征的新位置的二维点输出向量（具有单精度浮点坐标）；当 optflow::RLOFOpticalFlowParameter::useInitialFlow 变量为 true 时，向量的大小必须与输入向量相同，并且包含初始化点对应关系。
status输出状态向量（无符号字符）；如果对应特征的流动已通过前向后向检查，则向量的每个元素都设置为 1。
err输出错误向量；向量的每个元素都设置为对应特征的前向后向误差。
rlofParam参见 optflow::RLOFOpticalFlowParameter
forwardBackwardThreshold前向后向置信度检查的阈值。如果 forewardBackwardThreshold <=0，则前向
注意
只有在使用 SSE4.1 编译时才可以使用 SIMD 并行化。

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

◆ calcOpticalFlowSparseToDense()

void cv::optflow::calcOpticalFlowSparseToDense ( InputArray 来自,
InputArray 到,
输出数组 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 稀疏匹配插值的快速稠密光流。

参数
来自第一张8位3通道或1通道图像。
到第二张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() -> 返回值

#include <opencv2/optflow.hpp>

DeepFlow 光流算法实现。

该类实现了文献[296]中描述的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() -> 返回值

#include <opencv2/optflow/rlofflow.hpp>

稠密 RLOF 算法的附加接口 - optflow::calcOpticalFlowDenseRLOF()

◆ createOptFlow_DualTVL1()

Ptr< DualTVL1OpticalFlow > cv::optflow::createOptFlow_DualTVL1 ( )
Python
cv.optflow.createOptFlow_DualTVL1() -> 返回值

#include <opencv2/optflow.hpp>

创建 cv::DenseOpticalFlow 的实例。

◆ createOptFlow_Farneback()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_Farneback ( )
Python
cv.optflow.createOptFlow_Farneback() -> 返回值

#include <opencv2/optflow.hpp>

Farneback 算法的附加接口 - calcOpticalFlowFarneback()

◆ createOptFlow_PCAFlow()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_PCAFlow ( )
Python
cv.optflow.createOptFlow_PCAFlow() -> 返回值

#include <opencv2/optflow/pcaflow.hpp>

创建一个 PCAFlow 实例。

◆ createOptFlow_SimpleFlow()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_SimpleFlow ( )
Python
cv.optflow.createOptFlow_SimpleFlow() -> 返回值

#include <opencv2/optflow.hpp>

SimpleFlow 算法的附加接口 - calcOpticalFlowSF()

◆ createOptFlow_SparseRLOF()

Ptr< SparseOpticalFlow > cv::optflow::createOptFlow_SparseRLOF ( )
Python
cv.optflow.createOptFlow_SparseRLOF() -> 返回值

#include <opencv2/optflow/rlofflow.hpp>

稀疏 RLOF 算法的附加接口 - optflow::calcOpticalFlowSparseRLOF()

◆ createOptFlow_SparseToDense()

Ptr< DenseOpticalFlow > cv::optflow::createOptFlow_SparseToDense ( )
Python
cv.optflow.createOptFlow_SparseToDense() -> 返回值

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

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

参数
[输入]imgFrom序列中的第一张图像。
[输入]imgTo序列中的第二张图像。
[输出]corr包含对应点对的输出向量。
[输入]params用于微调的其他匹配参数。
以下是此函数的调用图

◆ segmentMotion()

void cv::motempl::segmentMotion ( InputArray 运动历史图像,
输出数组 segmask,
std::vector< Rect > & boundingRects,
double 时间戳,
double segThresh )
Python
cv.motempl.segmentMotion(mhi, timestamp, segThresh[, segmask]) -> segmask, boundingRects

#include <opencv2/optflow/motempl.hpp>

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

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

该函数查找所有运动片段，并使用单个值（1,2,...）在segmask中标记它们。它还计算包含运动连接组件的ROI的向量。之后，可以使用calcGlobalOrientation使用提取的特定组件掩码计算每个组件的运动方向。

◆ updateMotionHistory()

void cv::motempl::updateMotionHistory ( InputArray silhouette,
输入输出数组 运动历史图像,
double 时间戳,
double 持续时间 )
Python
cv.motempl.updateMotionHistory(silhouette, mhi, timestamp, duration) -> 运动历史图像

#include <opencv2/optflow/motempl.hpp>

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

参数
silhouette轮廓掩码，其中运动发生的位置具有非零像素。
运动历史图像由函数更新的运动历史图像（单通道，32位浮点型）。
时间戳以毫秒或其他单位表示的当前时间。
持续时间运动轨迹的最大持续时间，单位与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像素被设置为当前时间戳，而很久以前发生运动的像素将被清除。

该函数与`calcMotionGradient`和`calcGlobalOrientation`一起，实现了文献[66]和[38]中描述的运动模板技术。

2025年1月8日星期三16:06:36 为OpenCV生成，由 doxygen 1.12.0 生成