/// <summary>
/// computes sparse optical flow using multi-scale Lucas-Kanade algorithm
/// </summary>
/// <param name="prevImg"></param>
/// <param name="nextImg"></param>
/// <param name="prevPts"></param>
/// <param name="nextPts"></param>
/// <param name="status"></param>
/// <param name="err"></param>
/// <param name="winSize"></param>
/// <param name="maxLevel"></param>
/// <param name="criteria"></param>
/// <param name="flags"></param>
/// <param name="minEigThreshold"></param>
public static void CalcOpticalFlowPyrLK(
InputArray prevImg, InputArray nextImg,
InputArray prevPts, InputOutputArray nextPts,
OutputArray status, OutputArray err,
Size?winSize = null,
int maxLevel = 3,
TermCriteria?criteria = null,
OpticalFlowFlags flags = OpticalFlowFlags.None,
double minEigThreshold = 1e-4)
{
if (prevImg == null)
{
throw new ArgumentNullException(nameof(prevImg));
}
if (nextImg == null)
{
throw new ArgumentNullException(nameof(nextImg));
}
if (prevPts == null)
{
throw new ArgumentNullException(nameof(prevPts));
}
if (nextPts == null)
{
throw new ArgumentNullException(nameof(nextPts));
}
if (status == null)
{
throw new ArgumentNullException(nameof(status));
}
if (err == null)
{
throw new ArgumentNullException(nameof(err));
}
prevImg.ThrowIfDisposed();
nextImg.ThrowIfDisposed();
prevPts.ThrowIfDisposed();
nextPts.ThrowIfNotReady();
status.ThrowIfNotReady();
err.ThrowIfNotReady();
var winSize0 = winSize.GetValueOrDefault(new Size(21, 21));
var criteria0 = criteria.GetValueOrDefault(
TermCriteria.Both(30, 0.01));
NativeMethods.HandleException(
NativeMethods.video_calcOpticalFlowPyrLK_InputArray(
prevImg.CvPtr, nextImg.CvPtr, prevPts.CvPtr, nextPts.CvPtr,
status.CvPtr, err.CvPtr, winSize0, maxLevel,
criteria0, (int)flags, minEigThreshold));
GC.KeepAlive(prevImg);
GC.KeepAlive(nextImg);
GC.KeepAlive(prevPts);
nextPts.Fix();
status.Fix();
err.Fix();
}
/// <summary>
/// computes sparse optical flow using multi-scale Lucas-Kanade algorithm
/// </summary>
/// <param name="prevImg"></param>
/// <param name="nextImg"></param>
/// <param name="prevPts"></param>
/// <param name="nextPts"></param>
/// <param name="status"></param>
/// <param name="err"></param>
/// <param name="winSize"></param>
/// <param name="maxLevel"></param>
/// <param name="criteria"></param>
/// <param name="flags"></param>
/// <param name="minEigThreshold"></param>
public static void CalcOpticalFlowPyrLK(
InputArray prevImg,
InputArray nextImg,
Point2f[] prevPts,
ref Point2f[] nextPts,
out byte[] status,
out float[] err,
Size?winSize = null,
int maxLevel = 3,
TermCriteria?criteria = null,
OpticalFlowFlags flags = OpticalFlowFlags.None,
double minEigThreshold = 1e-4)
{
if (prevImg == null)
{
throw new ArgumentNullException(nameof(prevImg));
}
if (nextImg == null)
{
throw new ArgumentNullException(nameof(nextImg));
}
if (prevPts == null)
{
throw new ArgumentNullException(nameof(prevPts));
}
if (nextPts == null)
{
throw new ArgumentNullException(nameof(nextPts));
}
prevImg.ThrowIfDisposed();
nextImg.ThrowIfDisposed();
var winSize0 = winSize.GetValueOrDefault(new Size(21, 21));
var criteria0 = criteria.GetValueOrDefault(
TermCriteria.Both(30, 0.01));
using var nextPtsVec = new VectorOfPoint2f(nextPts);
using var statusVec = new VectorOfByte();
using var errVec = new VectorOfFloat();
NativeMethods.HandleException(
NativeMethods.video_calcOpticalFlowPyrLK_vector(
prevImg.CvPtr, nextImg.CvPtr, prevPts, prevPts.Length,
nextPtsVec.CvPtr, statusVec.CvPtr, errVec.CvPtr,
winSize0, maxLevel, criteria0, (int)flags, minEigThreshold));
GC.KeepAlive(prevImg);
GC.KeepAlive(nextImg);
nextPts = nextPtsVec.ToArray();
status = statusVec.ToArray();
err = errVec.ToArray();
}
/// <summary>
/// Computes a dense optical flow using the Gunnar Farneback's algorithm.
/// </summary>
/// <param name="prev">first 8-bit single-channel input image.</param>
/// <param name="next">second input image of the same size and the same type as prev.</param>
/// <param name="flow">computed flow image that has the same size as prev and type CV_32FC2.</param>
/// <param name="pyrScale">parameter, specifying the image scale (<1) to build pyramids for each image;
/// pyrScale=0.5 means a classical pyramid, where each next layer is twice smaller than the previous one.</param>
/// <param name="levels">number of pyramid layers including the initial image;
/// levels=1 means that no extra layers are created and only the original images are used.</param>
/// <param name="winsize">averaging window size; larger values increase the algorithm robustness to
/// image noise and give more chances for fast motion detection, but yield more blurred motion field.</param>
/// <param name="iterations">number of iterations the algorithm does at each pyramid level.</param>
/// <param name="polyN">size of the pixel neighborhood used to find polynomial expansion in each pixel;
/// larger values mean that the image will be approximated with smoother surfaces,
/// yielding more robust algorithm and more blurred motion field, typically poly_n =5 or 7.</param>
/// <param name="polySigma">standard deviation of the Gaussian that is used to smooth derivatives used as
/// a basis for the polynomial expansion; for polyN=5, you can set polySigma=1.1,
/// for polyN=7, a good value would be polySigma=1.5.</param>
/// <param name="flags">operation flags that can be a combination of OPTFLOW_USE_INITIAL_FLOW and/or OPTFLOW_FARNEBACK_GAUSSIAN</param>
public static void CalcOpticalFlowFarneback(InputArray prev, InputArray next,
InputOutputArray flow, double pyrScale, int levels, int winsize,
int iterations, int polyN, double polySigma, OpticalFlowFlags flags)
{
if (prev == null)
{
throw new ArgumentNullException(nameof(prev));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
if (flow == null)
{
throw new ArgumentNullException(nameof(flow));
}
prev.ThrowIfDisposed();
next.ThrowIfDisposed();
flow.ThrowIfNotReady();
NativeMethods.HandleException(
NativeMethods.video_calcOpticalFlowFarneback(
prev.CvPtr, next.CvPtr, flow.CvPtr, pyrScale, levels, winsize,
iterations, polyN, polySigma, (int)flags));
GC.KeepAlive(prev);
GC.KeepAlive(next);
flow.Fix();
}
/// <summary>
/// Computes a dense optical flow using the Gunnar Farneback's algorithm.
/// </summary>
/// <param name="prev">first 8-bit single-channel input image.</param>
/// <param name="next">second input image of the same size and the same type as prev.</param>
/// <param name="flow">computed flow image that has the same size as prev and type CV_32FC2.</param>
/// <param name="pyrScale">parameter, specifying the image scale (<1) to build pyramids for each image;
/// pyrScale=0.5 means a classical pyramid, where each next layer is twice smaller than the previous one.</param>
/// <param name="levels">number of pyramid layers including the initial image;
/// levels=1 means that no extra layers are created and only the original images are used.</param>
/// <param name="winsize">averaging window size; larger values increase the algorithm robustness to
/// image noise and give more chances for fast motion detection, but yield more blurred motion field.</param>
/// <param name="iterations">number of iterations the algorithm does at each pyramid level.</param>
/// <param name="polyN">size of the pixel neighborhood used to find polynomial expansion in each pixel;
/// larger values mean that the image will be approximated with smoother surfaces,
/// yielding more robust algorithm and more blurred motion field, typically poly_n =5 or 7.</param>
/// <param name="polySigma">standard deviation of the Gaussian that is used to smooth derivatives used as
/// a basis for the polynomial expansion; for polyN=5, you can set polySigma=1.1,
/// for polyN=7, a good value would be polySigma=1.5.</param>
/// <param name="flags">operation flags that can be a combination of OPTFLOW_USE_INITIAL_FLOW and/or OPTFLOW_FARNEBACK_GAUSSIAN</param>
public static void CalcOpticalFlowFarneback(InputArray prev, InputArray next,
InputOutputArray flow, double pyrScale, int levels, int winsize,
int iterations, int polyN, double polySigma, OpticalFlowFlags flags)
{
if (prev == null)
throw new ArgumentNullException("prev");
if (next == null)
throw new ArgumentNullException("next");
if (flow == null)
throw new ArgumentNullException("flow");
prev.ThrowIfDisposed();
next.ThrowIfDisposed();
flow.ThrowIfNotReady();
NativeMethods.video_calcOpticalFlowFarneback(prev.CvPtr, next.CvPtr,
flow.CvPtr, pyrScale, levels, winsize, iterations, polyN, polySigma,
(int)flags);
flow.Fix();
}
/// <summary>
/// computes sparse optical flow using multi-scale Lucas-Kanade algorithm
/// </summary>
/// <param name="prevImg"></param>
/// <param name="nextImg"></param>
/// <param name="prevPts"></param>
/// <param name="nextPts"></param>
/// <param name="status"></param>
/// <param name="err"></param>
/// <param name="winSize"></param>
/// <param name="maxLevel"></param>
/// <param name="criteria"></param>
/// <param name="flags"></param>
/// <param name="minEigThreshold"></param>
public static void CalcOpticalFlowPyrLK(
InputArray prevImg, InputArray nextImg,
Point2f[] prevPts, ref Point2f[] nextPts,
out byte[] status, out float[] err,
Size? winSize = null,
int maxLevel = 3,
TermCriteria? criteria = null,
OpticalFlowFlags flags = OpticalFlowFlags.None,
double minEigThreshold = 1e-4)
{
if (prevImg == null)
throw new ArgumentNullException("prevImg");
if (nextImg == null)
throw new ArgumentNullException("nextImg");
if (prevPts == null)
throw new ArgumentNullException("prevPts");
if (nextPts == null)
throw new ArgumentNullException("nextPts");
prevImg.ThrowIfDisposed();
nextImg.ThrowIfDisposed();
Size winSize0 = winSize.GetValueOrDefault(new Size(21, 21));
TermCriteria criteria0 = criteria.GetValueOrDefault(
TermCriteria.Both(30, 0.01));
using (var nextPtsVec = new VectorOfPoint2f())
using (var statusVec = new VectorOfByte())
using (var errVec = new VectorOfFloat())
{
NativeMethods.video_calcOpticalFlowPyrLK_vector(
prevImg.CvPtr, nextImg.CvPtr, prevPts, prevPts.Length,
nextPtsVec.CvPtr, statusVec.CvPtr, errVec.CvPtr,
winSize0, maxLevel, criteria0, (int)flags, minEigThreshold);
nextPts = nextPtsVec.ToArray();
status = statusVec.ToArray();
err = errVec.ToArray();
}
}
/// <summary>
/// computes sparse optical flow using multi-scale Lucas-Kanade algorithm
/// </summary>
/// <param name="prevImg"></param>
/// <param name="nextImg"></param>
/// <param name="prevPts"></param>
/// <param name="nextPts"></param>
/// <param name="status"></param>
/// <param name="err"></param>
/// <param name="winSize"></param>
/// <param name="maxLevel"></param>
/// <param name="criteria"></param>
/// <param name="flags"></param>
/// <param name="minEigThreshold"></param>
public static void CalcOpticalFlowPyrLK(
InputArray prevImg, InputArray nextImg,
InputArray prevPts, InputOutputArray nextPts,
OutputArray status, OutputArray err,
Size? winSize = null,
int maxLevel = 3,
TermCriteria? criteria = null,
OpticalFlowFlags flags = OpticalFlowFlags.None,
double minEigThreshold = 1e-4)
{
if (prevImg == null)
throw new ArgumentNullException("prevImg");
if (nextImg == null)
throw new ArgumentNullException("nextImg");
if (prevPts == null)
throw new ArgumentNullException("prevPts");
if (nextPts == null)
throw new ArgumentNullException("nextPts");
if (status == null)
throw new ArgumentNullException("status");
if (err == null)
throw new ArgumentNullException("err");
prevImg.ThrowIfDisposed();
nextImg.ThrowIfDisposed();
prevPts.ThrowIfDisposed();
nextPts.ThrowIfNotReady();
status.ThrowIfNotReady();
err.ThrowIfNotReady();
Size winSize0 = winSize.GetValueOrDefault(new Size(21, 21));
TermCriteria criteria0 = criteria.GetValueOrDefault(
TermCriteria.Both(30, 0.01));
NativeMethods.video_calcOpticalFlowPyrLK_InputArray(
prevImg.CvPtr, nextImg.CvPtr, prevPts.CvPtr, nextPts.CvPtr,
status.CvPtr, err.CvPtr, winSize0,maxLevel,
criteria0, (int)flags, minEigThreshold);
nextPts.Fix();
status.Fix();
err.Fix();
}
