OpenCV 4.12.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
}
 全局补丁碰撞器 (Global Patch Collider) 的描述符类型。更多...
 
枚举  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)
 使用鲁棒局部光流 (RLOF) 为稀疏特征集计算快速光流，类似于 optflow::calcOpticalFlowPyrLK()。
 
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>

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

枚举器
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

快速测地插值，参见 [104]

INTERP_EPIC 
Python: cv.optflow.INTERP_EPIC

使用 ximgproc::EdgeAwareInterpolator 的边缘保留插值，参见 [228],Geistert2016。

INTERP_RIC 
Python: cv.optflow.INTERP_RIC

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

◆ SolverType

enum cv::optflow::SolverType

#include <opencv2/optflow/rlofflow.hpp>

枚举器
ST_STANDART 
Python: cv.optflow.ST_STANDART

应用标准迭代细化

ST_BILINEAR 
Python: cv.optflow.ST_BILINEAR

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

◆ SupportRegionType

enum cv::optflow::SupportRegionType

#include <opencv2/optflow/rlofflow.hpp>

枚举器
SR_FIXED 
Python: cv.optflow.SR_FIXED

应用恒定支持区域

SR_CROSS 
Python: cv.optflow.SR_CROSS

应用通过基于交叉分割获得的自适应支持区域，如 [243] 中所述

函数文档

◆ 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 的时间戳。
持续时间运动轨迹的最大持续时间（毫秒），传递给 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} ).\]

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,
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 是一种快速局部光流方法，在 [241] [242] [243] 和 [244] 中有描述，类似于 [37] 提出的金字塔迭代 Lucas-Kanade 方法。更多细节和实验可在以下论文中找到 [245]。该实现源自 optflow::calcOpticalFlowPyrLK()。

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

  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 应用快速测地插值，参见 [104]。
  • INTERP_EPIC_RESIDUAL 应用边缘保留插值，参见 [228],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

参数已在 [241], [242], [243] 和 [244] 中描述。有关 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检测具有不规则光流的点（即在上采样后需要重新计算光流的点）的阈值

参见 [267] 。项目网站 - 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>

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

RLOF 是一种快速局部光流方法，在 [241] [242] [243] 和 [244] 中有描述，类似于 [37] 提出的金字塔迭代 Lucas-Kanade 方法。更多细节和实验可在以下论文中找到 [245]。该实现源自 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 变量为 true 时，向量必须与输入具有相同的大小，并包含初始化点对应关系。
status输出状态向量（无符号字符）；如果相应特征的光流通过了前向后向检查，则向量的每个元素设置为 1。
err输出误差向量；向量的每个元素设置为相应特征的前向后向误差。
rlofParam参见 optflow::RLOFOpticalFlowParameter
forwardBackwardThreshold前向后向置信度检查的阈值。如果 forewardBackwardThreshold <=0，则前向
注意
SIMD 并行化仅在用 SSE4.1 编译时可用。

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

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

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

参数
[输入]imgFrom序列中的第一幅图像。
[输入]imgTo序列中的第二幅图像。
[输出]corr带有对应点对的输出向量。
[输入]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当前时间，以毫秒或其他单位表示。
持续时间运动轨迹的最大持续时间，与 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 一起，实现了 [68] 和 [39] 中描述的运动模板技术。

生成于 2025 年 7 月 3 日 12:14:37，由 doxygen 1.12.0 为 OpenCV 生成