/// <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.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, 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(); }
/// <summary> /// Updates motion history image using the current silhouette /// </summary> /// <param name="silhouette">Silhouette mask that has non-zero pixels where the motion occurs.</param> /// <param name="mhi">Motion history image that is updated by the function (single-channel, 32-bit floating-point).</param> /// <param name="timestamp">Current time in milliseconds or other units.</param> /// <param name="duration">Maximal duration of the motion track in the same units as timestamp .</param> public static void UpdateMotionHistory( InputArray silhouette, InputOutputArray mhi, double timestamp, double duration) { if (silhouette == null) throw new ArgumentNullException("silhouette"); if (mhi == null) throw new ArgumentNullException("mhi"); silhouette.ThrowIfDisposed(); mhi.ThrowIfNotReady(); NativeMethods.video_updateMotionHistory( silhouette.CvPtr, mhi.CvPtr, timestamp, duration); mhi.Fix(); }
/// <summary> /// Updates motion history image using the current silhouette /// </summary> /// <param name="silhouette">Silhouette mask that has non-zero pixels where the motion occurs.</param> /// <param name="mhi">Motion history image that is updated by the function (single-channel, 32-bit floating-point).</param> /// <param name="timestamp">Current time in milliseconds or other units.</param> /// <param name="duration">Maximal duration of the motion track in the same units as timestamp .</param> public static void UpdateMotionHistory( InputArray silhouette, InputOutputArray mhi, double timestamp, double duration) { if (silhouette == null) { throw new ArgumentNullException("silhouette"); } if (mhi == null) { throw new ArgumentNullException("mhi"); } silhouette.ThrowIfDisposed(); mhi.ThrowIfNotReady(); NativeMethods.video_updateMotionHistory( silhouette.CvPtr, mhi.CvPtr, timestamp, duration); mhi.Fix(); }
/// <summary> /// /// </summary> /// <param name="mat"></param> /// <param name="distType"></param> /// <param name="a"></param> /// <param name="b"></param> /// <param name="saturateRange"></param> public void Fill(InputOutputArray mat, DistributionType distType, InputArray a, InputArray b, bool saturateRange = false) { if (mat == null) { throw new ArgumentNullException("mat"); } if (a == null) { throw new ArgumentNullException("a"); } if (b == null) { throw new ArgumentNullException("b"); } mat.ThrowIfNotReady(); a.ThrowIfDisposed(); b.ThrowIfDisposed(); NativeMethods.core_RNG_fill(State, mat.CvPtr, (int)distType, a.CvPtr, b.CvPtr, saturateRange ? 1 : 0); mat.Fix(); }
/// <summary> /// Performs a marker-based image segmentation using the watershed algorithm. /// </summary> /// <param name="image">Input 8-bit 3-channel image.</param> /// <param name="markers">Input/output 32-bit single-channel image (map) of markers. /// It should have the same size as image.</param> public static void Watershed(InputArray image, InputOutputArray markers) { if (image == null) throw new ArgumentNullException("image"); if (markers == null) throw new ArgumentNullException("markers"); image.ThrowIfDisposed(); markers.ThrowIfNotReady(); NativeMethods.imgproc_watershed(image.CvPtr, markers.CvPtr); markers.Fix(); }
/// <summary> /// Computes a Hanning window coefficients in two dimensions. /// </summary> /// <param name="dst">Destination array to place Hann coefficients in</param> /// <param name="winSize">The window size specifications</param> /// <param name="type">Created array type</param> public static void CreateHanningWindow(InputOutputArray dst, Size winSize, MatType type) { if (dst == null) throw new ArgumentNullException("dst"); dst.ThrowIfNotReady(); NativeMethods.imgproc_createHanningWindow(dst.CvPtr, winSize, type); dst.Fix(); }
/// <summary> /// Renders the detected chessboard corners. /// </summary> /// <param name="image">Destination image. It must be an 8-bit color image.</param> /// <param name="patternSize">Number of inner corners per a chessboard row and column (patternSize = cv::Size(points_per_row,points_per_column)).</param> /// <param name="corners">Array of detected corners, the output of findChessboardCorners.</param> /// <param name="patternWasFound">Parameter indicating whether the complete board was found or not. The return value of findChessboardCorners() should be passed here.</param> public static void DrawChessboardCorners(InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound) { if (image == null) throw new ArgumentNullException("image"); if (corners == null) throw new ArgumentNullException("corners"); image.ThrowIfNotReady(); corners.ThrowIfDisposed(); NativeMethods.calib3d_drawChessboardCorners_InputArray( image.CvPtr, patternSize, corners.CvPtr, patternWasFound ? 1 : 0); image.Fix(); }
/// <summary> /// /// </summary> /// <param name="data"></param> /// <param name="mean"></param> /// <param name="eigenvectors"></param> /// <param name="retainedVariance"></param> public static void PCAComputeVar(InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance) { if (data == null) throw new ArgumentNullException("data"); if (mean == null) throw new ArgumentNullException("mean"); if (eigenvectors == null) throw new ArgumentNullException("eigenvectors"); data.ThrowIfDisposed(); mean.ThrowIfNotReady(); eigenvectors.ThrowIfNotReady(); NativeMethods.core_PCAComputeVar(data.CvPtr, mean.CvPtr, eigenvectors.CvPtr, retainedVariance); mean.Fix(); eigenvectors.Fix(); }
/// <summary> /// fills array with uniformly-distributed random numbers from the range [low, high) /// </summary> /// <param name="dst"></param> /// <param name="low"></param> /// <param name="high"></param> public static void Randu(InputOutputArray dst, Scalar low, Scalar high) { if (dst == null) throw new ArgumentNullException("dst"); dst.ThrowIfNotReady(); NativeMethods.core_randu_Scalar(dst.CvPtr, low, high); dst.Fix(); }
/// <summary> /// 輪郭線,または内側が塗りつぶされた輪郭を描きます. /// </summary> /// <param name="image">出力画像</param> /// <param name="contours"> 入力される全輪郭.各輪郭は,点のベクトルとして格納されています.</param> /// <param name="contourIdx">描かれる輪郭を示します.これが負値の場合,すべての輪郭が描画されます.</param> /// <param name="color">輪郭の色.</param> /// <param name="thickness">輪郭線の太さ.これが負値の場合(例えば thickness=CV_FILLED ),輪郭の内側が塗りつぶされます.</param> /// <param name="lineType">線の連結性</param> /// <param name="hierarchy">階層に関するオプションの情報.これは,特定の輪郭だけを描画したい場合にのみ必要になります.</param> /// <param name="maxLevel">描画される輪郭の最大レベル.0ならば,指定された輪郭のみが描画されます. /// 1ならば,指定された輪郭と,それに入れ子になったすべての輪郭が描画されます.2ならば,指定された輪郭と, /// それに入れ子になったすべての輪郭,さらにそれに入れ子になったすべての輪郭が描画されます.このパラメータは, /// hierarchy が有効な場合のみ考慮されます.</param> /// <param name="offset">輪郭をシフトするオプションパラメータ.指定された offset = (dx,dy) だけ,すべての描画輪郭がシフトされます.</param> #else /// <summary> /// draws contours in the image /// </summary> /// <param name="image">Destination image.</param> /// <param name="contours">All the input contours. Each contour is stored as a point vector.</param> /// <param name="contourIdx">Parameter indicating a contour to draw. If it is negative, all the contours are drawn.</param> /// <param name="color">Color of the contours.</param> /// <param name="thickness">Thickness of lines the contours are drawn with. If it is negative (for example, thickness=CV_FILLED ), /// the contour interiors are drawn.</param> /// <param name="lineType">Line connectivity. </param> /// <param name="hierarchy">Optional information about hierarchy. It is only needed if you want to draw only some of the contours</param> /// <param name="maxLevel">Maximal level for drawn contours. If it is 0, only the specified contour is drawn. /// If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, /// all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account /// when there is hierarchy available.</param> /// <param name="offset">Optional contour shift parameter. Shift all the drawn contours by the specified offset = (dx, dy)</param> #endif public static void DrawContours( InputOutputArray image, IEnumerable<Mat> contours, int contourIdx, Scalar color, int thickness = 1, LineType lineType = LineType.Link8, Mat hierarchy = null, int maxLevel = Int32.MaxValue, Point? offset = null) { if (image == null) throw new ArgumentNullException("image"); if (contours == null) throw new ArgumentNullException("contours"); image.ThrowIfNotReady(); CvPoint offset0 = offset.GetValueOrDefault(new Point()); IntPtr[] contoursPtr = EnumerableEx.SelectPtrs(contours); NativeMethods.imgproc_drawContours_InputArray(image.CvPtr, contoursPtr, contoursPtr.Length, contourIdx, color, thickness, (int)lineType, ToPtr(hierarchy), maxLevel, offset0); image.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, 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(); }
/// <summary> /// 2値画像中の輪郭を検出します. /// </summary> /// <param name="image">入力画像,8ビット,シングルチャンネル.0以外のピクセルは 1として,0のピクセルは0のまま扱われます. /// また,この関数は,輪郭抽出処理中に入力画像 image の中身を書き換えます.</param> /// <param name="contours">検出された輪郭.各輪郭は,点のベクトルとして格納されます.</param> /// <param name="hierarchy">画像のトポロジーに関する情報を含む出力ベクトル.これは,輪郭数と同じ数の要素を持ちます.各輪郭 contours[i] に対して, /// 要素 hierarchy[i]のメンバにはそれぞれ,同じ階層レベルに存在する前後の輪郭,最初の子輪郭,および親輪郭の /// contours インデックス(0 基準)がセットされます.また,輪郭 i において,前後,親,子の輪郭が存在しない場合, /// それに対応する hierarchy[i] の要素は,負の値になります.</param> /// <param name="mode">輪郭抽出モード</param> /// <param name="method">輪郭の近似手法</param> /// <param name="offset">オプションのオフセット.各輪郭点はこの値の分だけシフトします.これは,ROIの中で抽出された輪郭を,画像全体に対して位置づけて解析する場合に役立ちます.</param> #else /// <summary> /// Finds contours in a binary image. /// </summary> /// <param name="image">Source, an 8-bit single-channel image. Non-zero pixels are treated as 1’s. /// Zero pixels remain 0’s, so the image is treated as binary. /// The function modifies the image while extracting the contours.</param> /// <param name="contours">Detected contours. Each contour is stored as a vector of points.</param> /// <param name="hierarchy">Optional output vector, containing information about the image topology. /// It has as many elements as the number of contours. For each i-th contour contours[i], /// the members of the elements hierarchy[i] are set to 0-based indices in contours of the next /// and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. /// If for the contour i there are no next, previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative.</param> /// <param name="mode">Contour retrieval mode</param> /// <param name="method">Contour approximation method</param> /// <param name="offset"> Optional offset by which every contour point is shifted. /// This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.</param> #endif public static void FindContours(InputOutputArray image, out Point[][] contours, out HierarchyIndex[] hierarchy, ContourRetrieval mode, ContourChain method, Point? offset = null) { if (image == null) throw new ArgumentNullException("image"); image.ThrowIfNotReady(); CvPoint offset0 = offset.GetValueOrDefault(new Point()); IntPtr contoursPtr, hierarchyPtr; NativeMethods.imgproc_findContours1_vector(image.CvPtr, out contoursPtr, out hierarchyPtr, (int)mode, (int)method, offset0); using (var contoursVec = new VectorOfVectorPoint(contoursPtr)) using (var hierarchyVec = new VectorOfVec4i(hierarchyPtr)) { contours = contoursVec.ToArray(); Vec4i[] hierarchyOrg = hierarchyVec.ToArray(); hierarchy = EnumerableEx.SelectToArray(hierarchyOrg, HierarchyIndex.FromVec4i); } image.Fix(); }
/// <summary> /// shuffles the input array elements /// </summary> /// <param name="dst"></param> /// <param name="iterFactor"></param> public static void RandShuffle(InputOutputArray dst, double iterFactor = 1.0) { if (dst == null) throw new ArgumentNullException("dst"); dst.ThrowIfNotReady(); NativeMethods.core_randShuffle_(dst.CvPtr, iterFactor); dst.Fix(); }
/// <summary> /// inserts a single channel to dst (coi is 0-based index) /// </summary> /// <param name="src"></param> /// <param name="dst"></param> /// <param name="coi"></param> public static void InsertChannel(InputArray src, InputOutputArray dst, int coi) { if (src == null) throw new ArgumentNullException("src"); if (dst == null) throw new ArgumentNullException("dst"); src.ThrowIfDisposed(); dst.ThrowIfNotReady(); NativeMethods.core_insertChannel(src.CvPtr, dst.CvPtr, coi); dst.Fix(); }
/// <summary> /// shuffles the input array elements /// </summary> /// <param name="dst"></param> /// <param name="iterFactor"></param> /// <param name="rng"></param> public static void RandShuffle(InputOutputArray dst, double iterFactor, out RNG rng) { if (dst == null) throw new ArgumentNullException("dst"); dst.ThrowIfNotReady(); ulong state; NativeMethods.core_randShuffle(dst.CvPtr, iterFactor, out state); dst.Fix(); rng = new RNG(state); }
/// <summary> /// fills array with normally-distributed random numbers with the specified mean and the standard deviation /// </summary> /// <param name="dst"></param> /// <param name="mean"></param> /// <param name="stddev"></param> public static void Randn(InputOutputArray dst, Scalar mean, Scalar stddev) { if (dst == null) throw new ArgumentNullException("dst"); dst.ThrowIfNotReady(); NativeMethods.core_randn_Scalar(dst.CvPtr, mean, stddev); dst.Fix(); }
/// <summary> /// fills array with normally-distributed random numbers with the specified mean and the standard deviation /// </summary> /// <param name="dst"></param> /// <param name="mean"></param> /// <param name="stddev"></param> public static void Randn(InputOutputArray dst, InputArray mean, InputArray stddev) { if (dst == null) throw new ArgumentNullException("dst"); if (mean == null) throw new ArgumentNullException("mean"); if (stddev == null) throw new ArgumentNullException("stddev"); dst.ThrowIfNotReady(); mean.ThrowIfDisposed(); stddev.ThrowIfDisposed(); NativeMethods.core_randn_InputArray(dst.CvPtr, mean.CvPtr, stddev.CvPtr); dst.Fix(); }
/// <summary> /// Segments the image using GrabCut algorithm /// </summary> /// <param name="img">Input 8-bit 3-channel image.</param> /// <param name="mask">Input/output 8-bit single-channel mask. /// The mask is initialized by the function when mode is set to GC_INIT_WITH_RECT. /// Its elements may have Cv2.GC_BGD / Cv2.GC_FGD / Cv2.GC_PR_BGD / Cv2.GC_PR_FGD</param> /// <param name="rect">ROI containing a segmented object. The pixels outside of the ROI are /// marked as "obvious background". The parameter is only used when mode==GC_INIT_WITH_RECT.</param> /// <param name="bgdModel">Temporary array for the background model. Do not modify it while you are processing the same image.</param> /// <param name="fgdModel">Temporary arrays for the foreground model. Do not modify it while you are processing the same image.</param> /// <param name="iterCount">Number of iterations the algorithm should make before returning the result. /// Note that the result can be refined with further calls with mode==GC_INIT_WITH_MASK or mode==GC_EVAL .</param> /// <param name="mode">Operation mode that could be one of GrabCutFlag value.</param> public static void GrabCut(InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, GrabCutFlag mode) { if (img == null) throw new ArgumentNullException("img"); if (mask == null) throw new ArgumentNullException("mask"); if (bgdModel == null) throw new ArgumentNullException("bgdModel"); if (fgdModel == null) throw new ArgumentNullException("fgdModel"); img.ThrowIfDisposed(); mask.ThrowIfNotReady(); bgdModel.ThrowIfNotReady(); fgdModel.ThrowIfNotReady(); NativeMethods.imgproc_grabCut(img.CvPtr, mask.CvPtr, rect, bgdModel.CvPtr, fgdModel.CvPtr, iterCount, (int)mode); mask.Fix(); bgdModel.Fix(); fgdModel.Fix(); }
/// <summary> /// 2値画像中の輪郭を検出します. /// </summary> /// <param name="image">入力画像,8ビット,シングルチャンネル.0以外のピクセルは 1として,0のピクセルは0のまま扱われます. /// また,この関数は,輪郭抽出処理中に入力画像 image の中身を書き換えます.</param> /// <param name="mode">輪郭抽出モード</param> /// <param name="method">輪郭の近似手法</param> /// <param name="offset">オプションのオフセット.各輪郭点はこの値の分だけシフトします.これは,ROIの中で抽出された輪郭を,画像全体に対して位置づけて解析する場合に役立ちます.</param> /// <return>検出された輪郭.各輪郭は,点のベクトルとして格納されます.</return> #else /// <summary> /// Finds contours in a binary image. /// </summary> /// <param name="image">Source, an 8-bit single-channel image. Non-zero pixels are treated as 1’s. /// Zero pixels remain 0’s, so the image is treated as binary. /// The function modifies the image while extracting the contours.</param> /// <param name="mode">Contour retrieval mode</param> /// <param name="method">Contour approximation method</param> /// <param name="offset"> Optional offset by which every contour point is shifted. /// This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.</param> /// <returns>Detected contours. Each contour is stored as a vector of points.</returns> #endif public static MatOfPoint[] FindContoursAsMat(InputOutputArray image, ContourRetrieval mode, ContourChain method, Point? offset = null) { if (image == null) throw new ArgumentNullException("image"); image.ThrowIfNotReady(); CvPoint offset0 = offset.GetValueOrDefault(new Point()); IntPtr contoursPtr; NativeMethods.imgproc_findContours2_OutputArray(image.CvPtr, out contoursPtr, (int)mode, (int)method, offset0); image.Fix(); using (var contoursVec = new VectorOfMat(contoursPtr)) { return contoursVec.ToArray<MatOfPoint>(); } }
/// <summary> /// Fills a connected component with the given color. /// </summary> /// <param name="image">Input/output 1- or 3-channel, 8-bit, or floating-point image. /// It is modified by the function unless the FLOODFILL_MASK_ONLY flag is set in the /// second variant of the function. See the details below.</param> /// <param name="mask">(For the second function only) Operation mask that should be a single-channel 8-bit image, /// 2 pixels wider and 2 pixels taller. The function uses and updates the mask, so you take responsibility of /// initializing the mask content. Flood-filling cannot go across non-zero pixels in the mask. For example, /// an edge detector output can be used as a mask to stop filling at edges. It is possible to use the same mask /// in multiple calls to the function to make sure the filled area does not overlap.</param> /// <param name="seedPoint">Starting point.</param> /// <param name="newVal">New value of the repainted domain pixels.</param> /// <param name="rect">Optional output parameter set by the function to the /// minimum bounding rectangle of the repainted domain.</param> /// <param name="loDiff">Maximal lower brightness/color difference between the currently /// observed pixel and one of its neighbors belonging to the component, or a seed pixel /// being added to the component.</param> /// <param name="upDiff">Maximal upper brightness/color difference between the currently /// observed pixel and one of its neighbors belonging to the component, or a seed pixel /// being added to the component.</param> /// <param name="flags">Operation flags. Lower bits contain a connectivity value, /// 4 (default) or 8, used within the function. Connectivity determines which /// neighbors of a pixel are considered. </param> /// <returns></returns> public static int FloodFill(InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, out Rect rect, Scalar? loDiff = null, Scalar? upDiff = null, FloodFillFlag flags = FloodFillFlag.Link4) { if (image == null) throw new ArgumentNullException("image"); if (mask == null) throw new ArgumentNullException("mask"); image.ThrowIfNotReady(); mask.ThrowIfNotReady(); Scalar loDiff0 = loDiff.GetValueOrDefault(new Scalar()); Scalar upDiff0 = upDiff.GetValueOrDefault(new Scalar()); CvRect rect0; int ret = NativeMethods.imgproc_floodFill(image.CvPtr, mask.CvPtr, seedPoint, newVal, out rect0, loDiff0, upDiff0, (int)flags); rect = rect0; image.Fix(); mask.Fix(); return ret; }
/// <summary> /// fills array with uniformly-distributed random numbers from the range [low, high) /// </summary> /// <param name="dst"></param> /// <param name="low"></param> /// <param name="high"></param> public static void Randu(InputOutputArray dst, InputArray low, InputArray high) { if (dst == null) throw new ArgumentNullException("dst"); if (low == null) throw new ArgumentNullException("low"); if (high == null) throw new ArgumentNullException("high"); dst.ThrowIfNotReady(); low.ThrowIfDisposed(); high.ThrowIfDisposed(); NativeMethods.core_randu_InputArray(dst.CvPtr, low.CvPtr, high.CvPtr); dst.Fix(); }
/// <summary> /// 2値画像中の輪郭を検出します. /// </summary> /// <param name="image">入力画像,8ビット,シングルチャンネル.0以外のピクセルは 1として,0のピクセルは0のまま扱われます. /// また,この関数は,輪郭抽出処理中に入力画像 image の中身を書き換えます.</param> /// <param name="contours">検出された輪郭.各輪郭は,点のベクトルとして格納されます.</param> /// <param name="hierarchy">画像のトポロジーに関する情報を含む出力ベクトル.これは,輪郭数と同じ数の要素を持ちます.各輪郭 contours[i] に対して, /// 要素 hierarchy[i]のメンバにはそれぞれ,同じ階層レベルに存在する前後の輪郭,最初の子輪郭,および親輪郭の /// contours インデックス(0 基準)がセットされます.また,輪郭 i において,前後,親,子の輪郭が存在しない場合, /// それに対応する hierarchy[i] の要素は,負の値になります.</param> /// <param name="mode">輪郭抽出モード</param> /// <param name="method">輪郭の近似手法</param> /// <param name="offset">オプションのオフセット.各輪郭点はこの値の分だけシフトします.これは,ROIの中で抽出された輪郭を,画像全体に対して位置づけて解析する場合に役立ちます.</param> #else /// <summary> /// Finds contours in a binary image. /// </summary> /// <param name="image">Source, an 8-bit single-channel image. Non-zero pixels are treated as 1’s. /// Zero pixels remain 0’s, so the image is treated as binary. /// The function modifies the image while extracting the contours.</param> /// <param name="contours">Detected contours. Each contour is stored as a vector of points.</param> /// <param name="hierarchy">Optional output vector, containing information about the image topology. /// It has as many elements as the number of contours. For each i-th contour contours[i], /// the members of the elements hierarchy[i] are set to 0-based indices in contours of the next /// and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. /// If for the contour i there are no next, previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative.</param> /// <param name="mode">Contour retrieval mode</param> /// <param name="method">Contour approximation method</param> /// <param name="offset"> Optional offset by which every contour point is shifted. /// This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.</param> #endif public static void FindContours(InputOutputArray image, out Mat[] contours, OutputArray hierarchy, ContourRetrieval mode, ContourChain method, Point? offset = null) { if (image == null) throw new ArgumentNullException("image"); if (hierarchy == null) throw new ArgumentNullException("hierarchy"); image.ThrowIfNotReady(); hierarchy.ThrowIfNotReady(); CvPoint offset0 = offset.GetValueOrDefault(new Point()); IntPtr contoursPtr; NativeMethods.imgproc_findContours1_OutputArray(image.CvPtr, out contoursPtr, hierarchy.CvPtr, (int)mode, (int)method, offset0); using (var contoursVec = new VectorOfMat(contoursPtr)) { contours = contoursVec.ToArray(); } image.Fix(); hierarchy.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> /// 輪郭線,または内側が塗りつぶされた輪郭を描きます. /// </summary> /// <param name="image">出力画像</param> /// <param name="contours"> 入力される全輪郭.各輪郭は,点のベクトルとして格納されています.</param> /// <param name="contourIdx">描かれる輪郭を示します.これが負値の場合,すべての輪郭が描画されます.</param> /// <param name="color">輪郭の色.</param> /// <param name="thickness">輪郭線の太さ.これが負値の場合(例えば thickness=CV_FILLED ),輪郭の内側が塗りつぶされます.</param> /// <param name="lineType">線の連結性</param> /// <param name="hierarchy">階層に関するオプションの情報.これは,特定の輪郭だけを描画したい場合にのみ必要になります.</param> /// <param name="maxLevel">描画される輪郭の最大レベル.0ならば,指定された輪郭のみが描画されます. /// 1ならば,指定された輪郭と,それに入れ子になったすべての輪郭が描画されます.2ならば,指定された輪郭と, /// それに入れ子になったすべての輪郭,さらにそれに入れ子になったすべての輪郭が描画されます.このパラメータは, /// hierarchy が有効な場合のみ考慮されます.</param> /// <param name="offset">輪郭をシフトするオプションパラメータ.指定された offset = (dx,dy) だけ,すべての描画輪郭がシフトされます.</param> #else /// <summary> /// draws contours in the image /// </summary> /// <param name="image">Destination image.</param> /// <param name="contours">All the input contours. Each contour is stored as a point vector.</param> /// <param name="contourIdx">Parameter indicating a contour to draw. If it is negative, all the contours are drawn.</param> /// <param name="color">Color of the contours.</param> /// <param name="thickness">Thickness of lines the contours are drawn with. If it is negative (for example, thickness=CV_FILLED ), /// the contour interiors are drawn.</param> /// <param name="lineType">Line connectivity. </param> /// <param name="hierarchy">Optional information about hierarchy. It is only needed if you want to draw only some of the contours</param> /// <param name="maxLevel">Maximal level for drawn contours. If it is 0, only the specified contour is drawn. /// If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, /// all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account /// when there is hierarchy available.</param> /// <param name="offset">Optional contour shift parameter. Shift all the drawn contours by the specified offset = (dx, dy)</param> #endif public static void DrawContours( InputOutputArray image, IEnumerable<IEnumerable<Point>> contours, int contourIdx, Scalar color, int thickness = 1, LineType lineType = LineType.Link8, IEnumerable<HierarchyIndex> hierarchy = null, int maxLevel = Int32.MaxValue, Point? offset = null) { if (image == null) throw new ArgumentNullException("image"); if (contours == null) throw new ArgumentNullException("contours"); image.ThrowIfNotReady(); CvPoint offset0 = offset.GetValueOrDefault(new Point()); Point[][] contoursArray = EnumerableEx.SelectToArray(contours, EnumerableEx.ToArray); int[] contourSize2 = EnumerableEx.SelectToArray(contoursArray, pts => pts.Length); using (var contoursPtr = new ArrayAddress2<Point>(contoursArray)) { if (hierarchy == null) { NativeMethods.imgproc_drawContours_vector(image.CvPtr, contoursPtr.Pointer, contoursArray.Length, contourSize2, contourIdx, color, thickness, (int)lineType, IntPtr.Zero, 0, maxLevel, offset0); } else { Vec4i[] hiearchyVecs = EnumerableEx.SelectToArray(hierarchy, hi => hi.ToVec4i()); NativeMethods.imgproc_drawContours_vector(image.CvPtr, contoursPtr.Pointer, contoursArray.Length, contourSize2, contourIdx, color, thickness, (int)lineType, hiearchyVecs, hiearchyVecs.Length, maxLevel, offset0); } } image.Fix(); }
/// <summary> /// finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern. /// </summary> /// <param name="objectPoints">In the new interface it is a vector of vectors of calibration pattern points in the calibration pattern coordinate space. /// The outer vector contains as many elements as the number of the pattern views. If the same calibration pattern is shown in each view and /// it is fully visible, all the vectors will be the same. Although, it is possible to use partially occluded patterns, or even different patterns /// in different views. Then, the vectors will be different. The points are 3D, but since they are in a pattern coordinate system, then, /// if the rig is planar, it may make sense to put the model to a XY coordinate plane so that Z-coordinate of each input object point is 0. /// In the old interface all the vectors of object points from different views are concatenated together.</param> /// <param name="imagePoints">In the new interface it is a vector of vectors of the projections of calibration pattern points. /// imagePoints.Count() and objectPoints.Count() and imagePoints[i].Count() must be equal to objectPoints[i].Count() for each i.</param> /// <param name="imageSize">Size of the image used only to initialize the intrinsic camera matrix.</param> /// <param name="cameraMatrix">Output 3x3 floating-point camera matrix. /// If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be /// initialized before calling the function.</param> /// <param name="distCoeffs">Output vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements.</param> /// <param name="rvecs">Output vector of rotation vectors (see Rodrigues() ) estimated for each pattern view. That is, each k-th rotation vector /// together with the corresponding k-th translation vector (see the next output parameter description) brings the calibration pattern /// from the model coordinate space (in which object points are specified) to the world coordinate space, that is, a real position of the /// calibration pattern in the k-th pattern view (k=0.. M -1)</param> /// <param name="tvecs">Output vector of translation vectors estimated for each pattern view.</param> /// <param name="flags">Different flags that may be zero or a combination of the CalibrationFlag values</param> /// <param name="criteria">Termination criteria for the iterative optimization algorithm.</param> /// <returns></returns> public static double CalibrateCamera( IEnumerable<Mat> objectPoints, IEnumerable<Mat> imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, out Mat[] rvecs, out Mat[] tvecs, CalibrationFlag flags = CalibrationFlag.Zero, TermCriteria? criteria = null) { if (objectPoints == null) throw new ArgumentNullException("objectPoints"); if (objectPoints == null) throw new ArgumentNullException("objectPoints"); if (cameraMatrix == null) throw new ArgumentNullException("cameraMatrix"); if (distCoeffs == null) throw new ArgumentNullException("distCoeffs"); cameraMatrix.ThrowIfNotReady(); distCoeffs.ThrowIfNotReady(); TermCriteria criteria0 = criteria.GetValueOrDefault( new TermCriteria(CriteriaType.Iteration | CriteriaType.Epsilon, 30, Double.Epsilon)); IntPtr[] objectPointsPtrs = EnumerableEx.SelectPtrs(objectPoints); IntPtr[] imagePointsPtrs = EnumerableEx.SelectPtrs(imagePoints); double ret; using (var rvecsVec = new VectorOfMat()) using (var tvecsVec = new VectorOfMat()) { ret = NativeMethods.calib3d_calibrateCamera_InputArray( objectPointsPtrs, objectPointsPtrs.Length, imagePointsPtrs, objectPointsPtrs.Length, imageSize, cameraMatrix.CvPtr, distCoeffs.CvPtr, rvecsVec.CvPtr, tvecsVec.CvPtr, (int)flags, criteria0); rvecs = rvecsVec.ToArray(); tvecs = tvecsVec.ToArray(); } cameraMatrix.Fix(); distCoeffs.Fix(); return ret; }
/// <summary> /// finds subpixel-accurate positions of the chessboard corners /// </summary> /// <param name="img"></param> /// <param name="corners"></param> /// <param name="regionSize"></param> /// <returns></returns> public static bool Find4QuadCornerSubpix(InputArray img, InputOutputArray corners, Size regionSize) { if (img == null) throw new ArgumentNullException("img"); if (corners == null) throw new ArgumentNullException("corners"); img.ThrowIfDisposed(); corners.ThrowIfNotReady(); int ret = NativeMethods.calib3d_find4QuadCornerSubpix_InputArray( img.CvPtr, corners.CvPtr, regionSize); corners.Fix(); return ret != 0; }
/// <summary> /// filters off speckles (small regions of incorrectly computed disparity) /// </summary> /// <param name="img">The input 16-bit signed disparity image</param> /// <param name="newVal">The disparity value used to paint-off the speckles</param> /// <param name="maxSpeckleSize">The maximum speckle size to consider it a speckle. Larger blobs are not affected by the algorithm</param> /// <param name="maxDiff">Maximum difference between neighbor disparity pixels to put them into the same blob. /// Note that since StereoBM, StereoSGBM and may be other algorithms return a fixed-point disparity map, where disparity values /// are multiplied by 16, this scale factor should be taken into account when specifying this parameter value.</param> /// <param name="buf">The optional temporary buffer to avoid memory allocation within the function.</param> public static void FilterSpeckles(InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf = null) { if (img == null) throw new ArgumentNullException("img"); img.ThrowIfNotReady(); NativeMethods.calib3d_filterSpeckles(img.CvPtr, newVal, maxSpeckleSize, maxDiff, ToPtr(buf)); img.Fix(); }
/// <summary> /// Renders the detected chessboard corners. /// </summary> /// <param name="image">Destination image. It must be an 8-bit color image.</param> /// <param name="patternSize">Number of inner corners per a chessboard row and column (patternSize = cv::Size(points_per_row,points_per_column)).</param> /// <param name="corners">Array of detected corners, the output of findChessboardCorners.</param> /// <param name="patternWasFound">Parameter indicating whether the complete board was found or not. The return value of findChessboardCorners() should be passed here.</param> public static void DrawChessboardCorners(InputOutputArray image, Size patternSize, IEnumerable<Point2f> corners, bool patternWasFound) { if (image == null) throw new ArgumentNullException("image"); if (corners == null) throw new ArgumentNullException("corners"); image.ThrowIfNotReady(); Point2f[] cornersArray = EnumerableEx.ToArray(corners); NativeMethods.calib3d_drawChessboardCorners_array( image.CvPtr, patternSize, cornersArray, cornersArray.Length, patternWasFound ? 1 : 0); image.Fix(); }
/// <summary> /// /// </summary> /// <param name="data"></param> /// <param name="mean"></param> /// <param name="eigenvectors"></param> /// <param name="maxComponents"></param> public static void PCACompute(InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents = 0) { if (data == null) throw new ArgumentNullException("data"); if (mean == null) throw new ArgumentNullException("mean"); if (eigenvectors == null) throw new ArgumentNullException("eigenvectors"); data.ThrowIfDisposed(); mean.ThrowIfNotReady(); eigenvectors.ThrowIfNotReady(); NativeMethods.core_PCACompute(data.CvPtr, mean.CvPtr, eigenvectors.CvPtr, maxComponents); mean.Fix(); eigenvectors.Fix(); }
/// <summary> /// finds intrinsic and extrinsic parameters of a stereo camera /// </summary> /// <param name="objectPoints">Vector of vectors of the calibration pattern points.</param> /// <param name="imagePoints1">Vector of vectors of the projections of the calibration pattern points, observed by the first camera.</param> /// <param name="imagePoints2">Vector of vectors of the projections of the calibration pattern points, observed by the second camera.</param> /// <param name="cameraMatrix1">Input/output first camera matrix</param> /// <param name="distCoeffs1">Input/output vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. /// The output vector length depends on the flags.</param> /// <param name="cameraMatrix2"> Input/output second camera matrix. The parameter is similar to cameraMatrix1 .</param> /// <param name="distCoeffs2">Input/output lens distortion coefficients for the second camera. The parameter is similar to distCoeffs1 .</param> /// <param name="imageSize">Size of the image used only to initialize intrinsic camera matrix.</param> /// <param name="R">Output rotation matrix between the 1st and the 2nd camera coordinate systems.</param> /// <param name="T">Output translation vector between the coordinate systems of the cameras.</param> /// <param name="E">Output essential matrix.</param> /// <param name="F">Output fundamental matrix.</param> /// <param name="criteria">Termination criteria for the iterative optimization algorithm.</param> /// <param name="flags">Different flags that may be zero or a combination of the CalibrationFlag values</param> /// <returns></returns> public static double StereoCalibrate(IEnumerable<InputArray> objectPoints, IEnumerable<InputArray> imagePoints1, IEnumerable<InputArray> imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, TermCriteria? criteria = null, CalibrationFlag flags = CalibrationFlag.FixIntrinsic) { if (objectPoints == null) throw new ArgumentNullException("objectPoints"); if (imagePoints1 == null) throw new ArgumentNullException("imagePoints1"); if (imagePoints2 == null) throw new ArgumentNullException("imagePoints2"); if (cameraMatrix1 == null) throw new ArgumentNullException("cameraMatrix1"); if (distCoeffs1 == null) throw new ArgumentNullException("distCoeffs1"); if (cameraMatrix2 == null) throw new ArgumentNullException("cameraMatrix2"); if (distCoeffs2 == null) throw new ArgumentNullException("distCoeffs2"); cameraMatrix1.ThrowIfDisposed(); distCoeffs1.ThrowIfDisposed(); cameraMatrix2.ThrowIfDisposed(); distCoeffs2.ThrowIfDisposed(); cameraMatrix1.ThrowIfNotReady(); cameraMatrix2.ThrowIfNotReady(); distCoeffs1.ThrowIfNotReady(); distCoeffs2.ThrowIfNotReady(); IntPtr[] opPtrs = EnumerableEx.SelectPtrs(objectPoints); IntPtr[] ip1Ptrs = EnumerableEx.SelectPtrs(imagePoints1); IntPtr[] ip2Ptrs = EnumerableEx.SelectPtrs(imagePoints2); TermCriteria criteria0 = criteria.GetValueOrDefault( new TermCriteria(CriteriaType.Iteration | CriteriaType.Epsilon, 30, 1e-6)); double result = NativeMethods.calib3d_stereoCalibrate_InputArray( opPtrs, opPtrs.Length, ip1Ptrs, ip1Ptrs.Length, ip2Ptrs, ip2Ptrs.Length, cameraMatrix1.CvPtr, distCoeffs1.CvPtr, cameraMatrix2.CvPtr, distCoeffs2.CvPtr, imageSize, ToPtr(R), ToPtr(T), ToPtr(E), ToPtr(F), criteria0, (int)flags ); cameraMatrix1.Fix(); distCoeffs1.Fix(); cameraMatrix2.Fix(); distCoeffs2.Fix(); if (R != null) R.Fix(); if (T != null) T.Fix(); if (E != null) E.Fix(); if (F != null) F.Fix(); return result; }
/// <summary> /// Adds the per-element product of two input images to the accumulator. /// </summary> /// <param name="src1">First input image, 1- or 3-channel, 8-bit or 32-bit floating point.</param> /// <param name="src2">Second input image of the same type and the same size as src1</param> /// <param name="dst">Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point.</param> /// <param name="mask">Optional operation mask.</param> public static void AccumulateProduct(InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask) { if (src1 == null) throw new ArgumentNullException("src1"); if (src2 == null) throw new ArgumentNullException("src2"); if (dst == null) throw new ArgumentNullException("dst"); src1.ThrowIfDisposed(); src2.ThrowIfDisposed(); dst.ThrowIfNotReady(); NativeMethods.imgproc_accumulateProduct(src1.CvPtr, src2.CvPtr, dst.CvPtr, ToPtr(mask)); dst.Fix(); }
/// <summary> /// validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm /// </summary> /// <param name="disparity"></param> /// <param name="cost"></param> /// <param name="minDisparity"></param> /// <param name="numberOfDisparities"></param> /// <param name="disp12MaxDisp"></param> public static void ValidateDisparity(InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1) { if (disparity == null) throw new ArgumentNullException("disparity"); if (cost == null) throw new ArgumentNullException("cost"); disparity.ThrowIfNotReady(); cost.ThrowIfDisposed(); NativeMethods.calib3d_validateDisparity( disparity.CvPtr, cost.CvPtr, minDisparity, numberOfDisparities, disp12MaxDisp); disparity.Fix(); }
/// <summary> /// Updates a running average. /// </summary> /// <param name="src">Input image as 1- or 3-channel, 8-bit or 32-bit floating point.</param> /// <param name="dst">Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.</param> /// <param name="alpha">Weight of the input image.</param> /// <param name="mask">Optional operation mask.</param> public static void AccumulateWeighted(InputArray src, InputOutputArray dst, double alpha, InputArray mask) { if (src == null) throw new ArgumentNullException("src"); if (dst == null) throw new ArgumentNullException("dst"); src.ThrowIfDisposed(); dst.ThrowIfNotReady(); NativeMethods.imgproc_accumulateWeighted(src.CvPtr, dst.CvPtr, alpha, ToPtr(mask)); dst.Fix(); }