LIBMAS/Data/SmoothIntent.cs

using ImageMagick;
using OpenCvSharp;
using PaintDotNet.Base;
using System;
using System.Collections.Generic;

namespace PaintDotNet.Adjust
{
    /// <summary>
    /// 图像平滑
    /// </summary>
    public class SmoothIntent
    {
        /// <summary>
        /// 西格玛
        /// 目前使用的是opencv的加权中值滤波
        /// </summary>
        /// <param name="mat"></param>
        /// <returns></returns>
        public static Mat SigemaFunction(Mat mat, List<Args> lists)
        {
            //半径
            int radius = 1;
            //西格玛值
            double sigma = 25.5;
            foreach (Args args in lists)
            {
                switch (args.key)
                {
                    case "KernelSize":
                        radius = int.Parse(args.Value.ToString());
                        break;
                    case "Sigma":
                        sigma = double.Parse(args.Value.ToString());
                        break;
                }
            }

            //第四个参数是过滤内核的半径，正整数 范围：3-255
            //第五个参数是西格玛值，默认25.5 范围：0-127(Filter range standard deviation for the joint image.)
            OpenCvSharp.XImgProc.CvXImgProc.WeightedMedianFilter(mat, mat, mat, radius, sigma);
            return mat;
        }

        /// <summary>
        /// 各向异性高斯滤波
        /// </summary>
        /// <param name="mat"></param>
        /// <returns></returns>
        public static Mat GaussianFiltering(Mat mat, List<Args> lists)
        {
            double sigmax = 0.0;
            double sigmay = 0.0;
            foreach (Args args in lists)
            {
                switch (args.key)
                {
                    case "SigmaX":
                        sigmax = double.Parse(args.Value.ToString());
                        break;
                    case "SigmaY":
                        sigmay = double.Parse(args.Value.ToString());
                        break;
                }
            }
            Cv2.GaussianBlur(mat, mat, new Size(0, 0), sigmax, sigmay);
            return mat;
        }

        /// <summary>
        /// 低通滤波
        /// 参考 https://www.cnblogs.com/zx-zhang/p/10999617.html
        /// </summary>
        /// <param name="mat"></param>
        /// <returns></returns>
        public static Mat LowPassFiltering(Mat mat, List<Args> lists)
        {
            int KernelSizeX = 3;
            int KernelSizeY = 3;
            int Count = 1;

            foreach (Args args in lists)
            {
                switch (args.key)
                {
                    case "KernelSizeX":
                        KernelSizeX = int.Parse(args.Value.ToString());
                        break;
                    case "KernelSizeY":
                        KernelSizeY = int.Parse(args.Value.ToString());
                        break;
                    case "Count":
                        Count = int.Parse(args.Value.ToString());
                        break;
                }
            }

            //构造kernel
            Mat mx = Cv2.GetGaussianKernel(KernelSizeX, KernelSizeX);
            Mat my = Cv2.GetGaussianKernel(KernelSizeY, KernelSizeY);
            Mat dst = new Mat();
            mat.CopyTo(dst);

            for (int i = 0; i < Count; i++)
            {
                Cv2.SepFilter2D(dst, dst, mat.Type(), mx, my);
            }
            return dst;
        }

        /// <summary>
        /// 中值滤波
        /// </summary>
        /// <param name="mat"></param>
        /// <returns></returns>
        public static Mat MedianFiltering(Mat mat, List<Args> lists)
        {
            int ksize = 3;
            foreach (Args args in lists)
            {
                switch (args.key)
                {
                    case "KernelSize":
                        ksize = int.Parse(args.Value.ToString());
                        break;
                }
            }
            Cv2.MedianBlur(mat, mat, ksize);
            return mat;
        }

        /// <summary>
        /// 高斯模糊
        /// </summary>
        /// <param name="mat"></param>
        /// <returns></returns>
        public static Mat GaussianBlur(Mat mat, List<Args> lists)
        {
            int ksize = 11;
            foreach (Args args in lists)
            {
                switch (args.key)
                {
                    case "KernelSize":
                        ksize = int.Parse(args.Value.ToString());
                        break;
                }
            }
            Cv2.GaussianBlur(mat, mat, new Size(ksize, ksize), 0);

            return mat;
        }

        /// <summary>
        /// 双边滤波
        /// </summary>
        /// <param name="mat"></param>
        /// <returns></returns>
        public static Mat BilateralFiltering(Mat mat, List<Args> lists)
        {
            Mat dst = new Mat();
            //像素邻域的直径
            int diameter = 0;
            //颜色空间过滤器的sigma值
            double sigmaColor = 0.0;
            //坐标空间中滤波器的sigma值
            double sigmaSpace = 0.0;

            foreach (Args args in lists)
            {
                switch (args.key)
                {
                    case "Diameter":
                        diameter = int.Parse(args.Value.ToString());
                        break;
                    case "SigmaColor":
                        sigmaColor = int.Parse(args.Value.ToString());
                        break;
                    case "SigmaSpace":
                        sigmaSpace = int.Parse(args.Value.ToString());
                        break;
                }
            }
            
            Cv2.BilateralFilter(mat, dst, diameter, sigmaColor, sigmaSpace);
            return dst;
        }

        /// <summary>
        /// 小波降噪
        /// opencv没有提供小波相关函数
        /// MagickImage的小波降噪源码比较复杂，回头考虑是否扒一份
        /// 均值滤波 https://blog.csdn.net/dcrmg/article/details/78817985
        /// </summary>
        /// <param name="mat"></param>
        /// <returns></returns>
        public static Mat WaveletDenoising(Mat mat, List<Args> lists)
        {
            int ksize = 3;
            foreach (Args args in lists)
            {
                switch (args.key)
                {
                    case "KernelSize":
                        ksize = int.Parse(args.Value.ToString());
                        break;
                }
            }
            //Cv2.FastNlMeansDenoisingColored(mat, mat);
            
            Cv2.Blur(mat, mat, new Size(ksize, ksize));
            return mat;

            /*CLAHE clahe = Cv2.CreateCLAHE(8, null);
            mat = mat.CvtColor(ColorConversionCodes.BGR2GRAY);
            clahe.Apply(mat, mat);
            return mat;*/

            //MagickImage image = new MagickImage(OpenCvSharp.Extensions.BitmapConverter.ToBitmap(mat));
            //image.WaveletDenoise((byte)threshold);
            //return OpenCvSharp.Extensions.BitmapConverter.ToMat(image.ToBitmap());
        }
    }
}