WingAIDiagnosisService/Carotid/Utilities/ImageTools.cs

using System;
using System.Collections.Generic;
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;
using Emgu.CV.Util;
using System.Drawing;
using WingServerCommon.Log;

namespace WingAIDiagnosisService.Carotid.Utilities
{

    /// <summary>
    /// 图像相关静态函数
    /// </summary>
    public class ImageTools
    {

        /// <summary>
        /// 调整图像亮度和对比度
        /// </summary>
        /// <param name="imageMat"></param>
        public  static void Adjust(Mat imageMat)
        {
            var contrastDegree = 1.4;
            var brightness = 20;
            var sharpFactor = 1f;
            imageMat.ConvertTo(imageMat, Emgu.CV.CvEnum.DepthType.Cv8U, contrastDegree, brightness);

            //float[,] temp =
            //    {{0, -sharpFactor, 0}, {-sharpFactor, 1 + 4 * sharpFactor, -sharpFactor}, {0, -sharpFactor, 0}};
            //ConvolutionKernelF kernel = new ConvolutionKernelF(temp);

            //CvInvoke.Filter2D(imageMat, imageMat, kernel, new Point(-1, -1));
        }

        /// <summary>
        /// 获取图像分割阈值
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public static int GetThreshold(CvArray<byte> image)
        {
            try
            {
                //统计每个灰度值的个数
                var grayValue = new int[256];
                var data = image.Bytes;

                foreach (var pixelValue in data)
                {
                    grayValue[pixelValue]++;
                }

                //双峰法获取阈值------------------------
                var maxTemp = 0;
                var minTemp = 0;
                var sumMaxValue = 0;
                var sumMinValue = 0;
                var maxByte = 0;
                for (var i = grayValue.Length - 1; i > 1; --i)
                {
                    if (grayValue[i] == 0) continue;
                    maxByte = i;
                    break;
                }

                if (maxByte == 0)
                {
                    return 0;
                }

                var threshold = (1 + maxByte) / 2;
                int threshold1;
                int threshold2;
                do
                {
                    for (var i = 0; i < 256; ++i)
                    {
                        var temp = grayValue[i];
                        if (i > threshold)
                        {
                            maxTemp += temp;
                            sumMaxValue += temp * i;
                        }
                        else
                        {
                            minTemp += temp;
                            sumMinValue += temp * i;
                        }
                    }

                    if (minTemp == 0)
                    {
                        return threshold;
                    }

                    if (maxTemp == 0)
                    {
                        return threshold;
                    }

                    threshold1 = (sumMaxValue / maxTemp + sumMinValue / minTemp) / 2;
                    threshold2 = threshold;
                    threshold = threshold1;
                } while (Math.Abs(threshold2 - threshold1) > 10);

                return threshold;
            }
            catch (Exception e)
            {
                Logger.WriteLineInfo("ImageTools GetThreshold," + e.Message + "," + e.StackTrace);
                return 0;
            }
        }

        /// <summary>
        /// 按照一列一列的方式去改变图像的像素
        /// </summary>
        /// <param name="image"></param>
        /// <param name="points"></param>
        /// <param name="rect"></param>
        public static void ChangeImageW(Image<Gray, byte> image, Point[] points, Rectangle rect)
        {
            var wMax = rect.Left + rect.Width;
            for (var w = rect.Left; w < wMax; w++)
            {
                var maxH = 0;
                var minH = int.MaxValue;
                foreach (var point in points)
                {
                    if (point.X == w)
                    {
                        var y = point.Y;
                        if (y > maxH)
                        {
                            maxH = y;
                        }

                        if (y < minH)
                        {
                            minH = y;
                        }
                    }
                }

                if (maxH <= 0) continue;
                for (var h = minH; h <= maxH; h++)
                {
                    image.Data[h, w, 0] = 0;
                }
            }
        }

        /// <summary>
        ///  按照一行一行的方式去改变图像的像素
        /// </summary>
        /// <param name="image"></param>
        /// <param name="points"></param>
        /// <param name="rect"></param>
        public static void ChangeImageH(Image<Gray, byte> image, Point[] points, Rectangle rect)
        {
            var hMax = rect.Top + rect.Height;
            for (var h = rect.Top; h < hMax; h++)
            {
                var maxW = 0;
                var minW = int.MaxValue;

                foreach (var point in points)
                {
                    if (point.Y == h)
                    {
                        var x = point.X;
                        if (maxW < x)
                        {
                            maxW = x;
                        }
                        if (minW > x)
                        {
                            minW = x;
                        }
                    }
                }

                if (maxW > 0)
                {
                    for (var w = minW; w <= maxW; w++)
                    {
                        image.Data[h, w, 0] = 0;
                    }
                }
            }
        }

        /// <summary>
        /// 求两个点间的中间点
        /// </summary>
        /// <param name="p1">为开始点</param>
        /// <param name="p2">为结束点</param>
        /// <returns></returns>
        public static List<Point> GetPointsInTwoPoint(Point p1, Point p2)
        {
            try
            {
                if (p1 == p2)
                {
                    return new List<Point>();
                }
                var x1 = p1.X;
                var y1 = p1.Y;
                var x2 = p2.X;
                var y2 = p2.Y;

                var x3 = x1 + Math.Abs(x2 - x1);
                var y3 = y1 + Math.Abs(y2 - y1);
                var pointList = new List<Point>();

                if (x1 == x3)
                {
                    if (y3 - y1 == 1)
                    {
                        return new List<Point>();
                    }
                    for (var i = y1 + 1; i < y3; ++i)
                    {
                        pointList.Add(new Point(x1, i));
                    }
                }

                if (y1 == y3)
                {
                    if (x3 - x1 == 1)
                    {
                        return new List<Point>();
                    }
                    for (var i = x1 + 1; i < x3; ++i)
                    {
                        pointList.Add(new Point(i, y1));
                    }
                }

                if (x3 - x1 == 1 && y3 - y1 == 1)
                {
                    return new List<Point>();
                }
                var diffX = x3 - x1;
                var diffY = y3 - y1;
                var minDiff = Math.Min(diffX, diffY);
                for (var i = 1; i < minDiff; ++i)
                {
                    pointList.Add(new Point(x1 + i, y1 + i));
                }
                if (diffX > diffY)
                {
                    for (var i = x1 + minDiff; i < x3; ++i)
                    {
                        pointList.Add(new Point(i, y1 + minDiff));
                    }
                }
                if (diffX < diffY)
                {
                    for (var i = y1 + minDiff; i < y3; ++i)
                    {
                        pointList.Add(new Point(x1 + minDiff, i));
                    }
                }
                //判断点的符号
                if (x2 > x1 && y2 > y1)
                {
                    return pointList;
                }

                if (x2 > x1 && y2 < y1)
                {
                    for (var i = 0; i < pointList.Count; ++i)
                    {
                        pointList[i] = new Point(pointList[i].X, 2 * y1 - pointList[i].Y);
                    }
                }
                if (x2 < x1 && y2 > y1)
                {
                    for (var i = 0; i < pointList.Count; ++i)
                    {
                        pointList[i] = new Point(2 * x1 - pointList[i].X, pointList[i].Y);
                    }
                }
                if (x2 < x1 && y2 < y1)
                {
                    for (var i = 0; i < pointList.Count; ++i)
                    {
                        pointList[i] = new Point(2 * x1 - pointList[i].X, 2 * y1 - pointList[i].Y);
                    }
                }
                return pointList;
            }
            catch (Exception e)
            {
                Logger.WriteLineError("ImageTools GetPointsInTwoPoint error." + e.Message + "," + e.StackTrace);
                return new List<Point>();
            }
        }

        public static VectorOfVectorOfPoint FindContours(Image<Gray, byte> image)
        {
            var contours = new VectorOfVectorOfPoint();
            var outPutArray = new Mat();
            CvInvoke.FindContours(image, contours, outPutArray, RetrType.Ccomp, ChainApproxMethod.ChainApproxNone);
            return contours;
        }

    }
}