/// <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(); }