/// <summary> /// Performs image denoising using the Block-Matching and 3D-filtering algorithm /// (http://www.cs.tut.fi/~foi/GCF-BM3D/BM3D_TIP_2007.pdf) with several computational optimizations.Noise expected to be a gaussian white noise. /// </summary> /// <param name="src">Input 8-bit or 16-bit 1-channel image.</param> /// <param name="dst">Output image with the same size and type as src.</param> /// <param name="h">Parameter regulating filter strength. Big h value perfectly removes noise but also /// removes image details, smaller h value preserves details but also preserves some noise.</param> /// <param name="templateWindowSize">Size in pixels of the template patch that is used for block-matching. Should be power of 2.</param> /// <param name="searchWindowSize">Size in pixels of the window that is used to perform block-matching. /// Affect performance linearly: greater searchWindowsSize - greater denoising time. Must be larger than templateWindowSize.</param> /// <param name="blockMatchingStep1">Block matching threshold for the first step of BM3D (hard thresholding), /// i.e.maximum distance for which two blocks are considered similar.Value expressed in euclidean distance.</param> /// <param name="blockMatchingStep2">Block matching threshold for the second step of BM3D (Wiener filtering), /// i.e.maximum distance for which two blocks are considered similar. Value expressed in euclidean distance.</param> /// <param name="groupSize">Maximum size of the 3D group for collaborative filtering.</param> /// <param name="slidingStep">Sliding step to process every next reference block.</param> /// <param name="beta">Kaiser window parameter that affects the sidelobe attenuation of the transform of the /// window.Kaiser window is used in order to reduce border effects.To prevent usage of the window, set beta to zero.</param> /// <param name="normType">Norm used to calculate distance between blocks. L2 is slower than L1 but yields more accurate results.</param> /// <param name="step">Step of BM3D to be executed. Allowed are only BM3D_STEP1 and BM3D_STEPALL. /// BM3D_STEP2 is not allowed as it requires basic estimate to be present.</param> /// <param name="transformType">Type of the orthogonal transform used in collaborative filtering step. /// Currently only Haar transform is supported.</param> public static void Bm3dDenoising( InputArray src, OutputArray dst, float h = 1, int templateWindowSize = 4, int searchWindowSize = 16, int blockMatchingStep1 = 2500, int blockMatchingStep2 = 400, int groupSize = 8, int slidingStep = 1, float beta = 2.0f, NormTypes normType = NormTypes.L2, Bm3dSteps step = Bm3dSteps.STEPALL, TransformTypes transformType = TransformTypes.HAAR) { if (src == null) { throw new ArgumentNullException(nameof(src)); } if (dst == null) { throw new ArgumentNullException(nameof(dst)); } src.ThrowIfDisposed(); dst.ThrowIfNotReady(); NativeMethods.HandleException( NativeMethods.xphoto_bm3dDenoising2( src.CvPtr, dst.CvPtr, h, templateWindowSize, searchWindowSize, blockMatchingStep1, blockMatchingStep2, groupSize, slidingStep, beta, (int)normType, (int)step, (int)transformType)); GC.KeepAlive(src); dst.Fix(); }
static double ComputeNorm(double x, double y, double z, NormTypes norm) { switch (norm) { case NormTypes.C: return(Math.Max(Math.Abs(x), Math.Max(Math.Abs(y), Math.Abs(z)))); case NormTypes.L1: return(Math.Abs(x) + Math.Abs(y) + Math.Abs(z)); case NormTypes.L2: return(Math.Sqrt(x * x + y * y + z * z)); case NormTypes.L2Sqr: return(x * x + y * y + z * z); default: throw new InvalidOperationException("The specified norm is not supported for this data type."); } }
public override bool run() { bool ret = false; try { alpha = (double)getValue("alpha"); beta = (double)getValue("beta"); normType = (NormTypes)getValue("normType"); dst = src.Normalize(alpha, beta, normType, -1, null); ret = true; } catch (Exception ex) { throw ex; } return(ret); }
/// <summary> /// scales and shifts array elements so that either the specified norm (alpha) /// or the minimum (alpha) and maximum (beta) array values get the specified values /// </summary> /// <param name="src">The source array</param> /// <param name="dst">The destination array; will have the same size as src</param> /// <param name="alpha">The norm value to normalize to or the lower range boundary /// in the case of range normalization</param> /// <param name="beta">The upper range boundary in the case of range normalization; /// not used for norm normalization</param> /// <param name="normType">The normalization type</param> /// <param name="dtype">When the parameter is negative, /// the destination array will have the same type as src, /// otherwise it will have the same number of channels as src and the depth =CV_MAT_DEPTH(rtype)</param> /// <param name="mask">The optional operation mask</param> public static void Normalize( InputArray src, InputOutputArray dst, double alpha=1, double beta=0, NormTypes normType=NormTypes.L2, int dtype=-1, InputArray mask=null) { if (src == null) throw new ArgumentNullException("src"); if (dst == null) throw new ArgumentNullException("dst"); src.ThrowIfDisposed(); dst.ThrowIfNotReady(); NativeMethods.core_normalize(src.CvPtr, dst.CvPtr, alpha, beta, (int)normType, dtype, ToPtr(mask)); GC.KeepAlive(src); dst.Fix(); }
/// <summary> /// naive nearest neighbor finder /// </summary> /// <param name="src1"></param> /// <param name="src2"></param> /// <param name="dist"></param> /// <param name="dtype"></param> /// <param name="nidx"></param> /// <param name="normType"></param> /// <param name="k"></param> /// <param name="mask"></param> /// <param name="update"></param> /// <param name="crosscheck"></param> public static void BatchDistance(InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, NormTypes normType = NormTypes.L2, int k = 0, InputArray mask = null, int update = 0, bool crosscheck = false) { if (src1 == null) throw new ArgumentNullException("src1"); if (src2 == null) throw new ArgumentNullException("src2"); if (dist == null) throw new ArgumentNullException("dist"); if (nidx == null) throw new ArgumentNullException("nidx"); src1.ThrowIfDisposed(); src2.ThrowIfDisposed(); dist.ThrowIfNotReady(); nidx.ThrowIfNotReady(); NativeMethods.core_batchDistance(src1.CvPtr, src2.CvPtr, dist.CvPtr, dtype, nidx.CvPtr, (int)normType, k, ToPtr(mask), update, crosscheck ? 1 : 0); GC.KeepAlive(src1); GC.KeepAlive(src2); dist.Fix(); nidx.Fix(); }
/// <summary> /// computes norm of selected part of the difference between two arrays /// </summary> /// <param name="src1">The first source array</param> /// <param name="src2">The second source array of the same size and the same type as src1</param> /// <param name="normType">Type of the norm</param> /// <param name="mask">The optional operation mask</param> /// <returns></returns> public static double Norm(InputArray src1, InputArray src2, NormTypes normType = NormTypes.L2, InputArray mask = null) { if (src1 == null) throw new ArgumentNullException("src1"); if (src2 == null) throw new ArgumentNullException("src2"); src1.ThrowIfDisposed(); src2.ThrowIfDisposed(); var ret = NativeMethods.core_norm(src1.CvPtr, src2.CvPtr, (int)normType, ToPtr(mask)); GC.KeepAlive(src1); GC.KeepAlive(src2); GC.KeepAlive(mask); return ret; }
/// <summary> /// /// </summary> /// <param name="normType"></param> /// <param name="crossCheck"></param> public BFMatcher(NormTypes normType = NormTypes.L2, bool crossCheck = false) { ptr = NativeMethods.features2d_BFMatcher_new((int)normType, crossCheck ? 1 : 0); }
internal static extern IntPtr cv_features2d_BFMatcher_new(NormTypes normType, [MarshalAs(UnmanagedType.I1)] bool crossCheck);
internal static extern double cvNorm(Arr arr1, Arr arr2, NormTypes norm_type, Arr mask);
internal static extern void cvNormalize(Arr src, Arr dst, double a, double b, NormTypes norm_type, Arr mask);
/// <summary> /// scales and shifts array elements so that either the specified norm (alpha) /// or the minimum (alpha) and maximum (beta) array values get the specified values /// </summary> /// <param name="alpha">The norm value to normalize to or the lower range boundary /// in the case of range normalization</param> /// <param name="beta">The upper range boundary in the case of range normalization; /// not used for norm normalization</param> /// <param name="normType">The normalization type</param> /// <param name="dtype">When the parameter is negative, /// the destination array will have the same type as src, /// otherwise it will have the same number of channels as src and the depth =CV_MAT_DEPTH(rtype)</param> /// <param name="mask">The optional operation mask</param> /// <returns></returns> public Mat Normalize(double alpha = 1, double beta = 0, NormTypes normType = NormTypes.L2, int dtype = -1, InputArray mask = null) { var dst = new Mat(); Cv2.Normalize(this, dst, alpha, beta, normType, dtype, mask); return dst; }
/// <summary> /// computes norm of the selected array part /// </summary> /// <param name="normType">Type of the norm</param> /// <param name="mask">The optional operation mask</param> /// <returns></returns> public double Norm(NormTypes normType = NormTypes.L2, InputArray mask = null) { return Cv2.Norm(this, normType, mask); }
/// <summary> /// /// </summary> /// <param name="normType"></param> /// <param name="crossCheck"></param> public BFMatcher(NormTypes normType = NormTypes.L2, bool crossCheck = false) { NativeMethods.HandleException( NativeMethods.features2d_BFMatcher_new((int)normType, crossCheck ? 1 : 0, out ptr)); detectorPtr = null; }
/// <summary> /// Initializes a new instance of the <see cref="BFMatcher"/> class. /// </summary> /// <param name="normType">The norm used for matching descriptors.</param> /// <param name="crossCheck">Specifies whether kNN matching should return only consistent pairs.</param> public BFMatcher(NormTypes normType = NormTypes.L2, bool crossCheck = false) { var handle = NativeMethods.cv_features2d_BFMatcher_new(normType, crossCheck); SetHandle(handle); }
/// <summary> /// /// </summary> /// <param name="normType"></param> /// <param name="crossCheck"></param> public BFMatcher(NormTypes normType = NormTypes.L2, bool crossCheck = false) { ptr = NativeMethods.features2d_BFMatcher_new((int) normType, crossCheck ? 1 : 0); }