using AccImage;
using OpenCvSharp;
using OpenCvSharp.Blob;
using OpenCvSharp.Extensions;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;

namespace Acc.Img
{
    public class ImageUtil
    {
        /// <summary>
        /// 读取图片,，支持格式*.raw,*.bmp;*.gif;*.jpg;*.png
        /// </summary>
        /// <param name="imagePath"></param>
        /// <returns>读取到的图片对像，读取失败时返回null</returns>
        public static Image ReadImage(string imagePath)
        {
            Image image = null;
            try
            {
                if (imagePath.ToLower().EndsWith(".raw"))
                {
                    byte[] src = System.IO.File.ReadAllBytes(imagePath);
                    int width = 3072;
                    int height = 3072;
                    int n = 0;
                    byte[] buff = new byte[src.Length * 3];
                    for (int i = 0; i < src.Length; i += 2)
                    {
                        short ss = BitConverter.ToInt16(src, i);
                        ss *= 10;
                        byte[] bb = BitConverter.GetBytes(ss);
                        buff[n++] = bb[0];
                        buff[n++] = bb[1];
                        buff[n++] = bb[0];
                        buff[n++] = bb[1];
                        buff[n++] = bb[0];
                        buff[n++] = bb[1];
                    }

                    Bitmap bmp = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format48bppRgb);
                    System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, width, height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat);
                    System.Runtime.InteropServices.Marshal.Copy(buff, 0, bmpData.Scan0, bmpData.Stride * height);
                    bmp.UnlockBits(bmpData);
                    //bmp.Save(@"C:\Users\ASA\Desktop\222.jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                    image = bmp;
                }
                else
                {
                    image = Image.FromFile(imagePath);
                }
            }
            catch (Exception)
            {

            }

            return image;
        }


        /// <summary>
        /// 二值化图像
        /// </summary>
        /// <param name="image">图像数据</param>
        /// <param name="thresh">阈值</param>
        /// <param name="inv">true表示元器件为白色，false表示元器件为黑色</param>
        /// <returns>二值化后的图像</returns>
        public static Image Threshhold(Image image, int thresh)
        {
            Mat imageMat = BitmapConverter.ToMat(new Bitmap(image));
            Mat threshMat = Threshhold(imageMat, thresh);
            return BitmapConverter.ToBitmap(threshMat);
        }
       
        /// <summary>
        /// 获取鼠标位置的元器件特征值
        /// </summary>
        /// <param name="image">输入的图像</param>
        /// <param name="markX">鼠标的X点坐标</param>
        /// <param name="markY">鼠标的Y点坐标</param>
        /// <param name="thresh">二值化阈值</param>
        /// <param name="inv">true表示元器件为白色，false表示元器件为黑色</param>
        /// <returns>鼠标指向的元器件特征值</returns>
        public static int GetItemFeature(Image image, int markX = -1, int markY = -1, int thresh = -1)
        {
            Mat imageMat = BitmapConverter.ToMat(new Bitmap(image));
            List<CvBlob> blobList = GetBlobs(imageMat, thresh);
            int blobCount = blobList.Count;
            int selectIndex = blobCount / 2;
            if (markX != -1 && markY != -1)
            {
                //查找标记的Blob
                int markIndex = -1;
                for (int i = 0; i < blobCount; i++)
                {
                    CvBlob blob = blobList[i];
                    if (blob.Rect.Contains(new OpenCvSharp.Point(markX, markY)))
                    {
                        if (markIndex == -1 || blobList[i].Area < blobList[markIndex].Area)
                        {
                            markIndex = i;
                        }
                    }
                }
                if (markIndex != -1)
                {
                    int area = blobList[markIndex].Area;
                    area = area * 5 / 3 - 23;
                    return area;
                }
            }
            return 0;
        }
        public static int GetItemFeatureAuto(Image image, int markX = -1, int markY = -1, int thresh = -1, bool inv = true)
        {
            Mat imageMat = BitmapConverter.ToMat(new Bitmap(image));
            List<CvBlob> blobList = GetBlobs(imageMat, thresh);
            List<int> sampleList = new List<int>();
            CvBlob srcBlob = new CvBlob();
            srcBlob.Area = -1;
            int blobCount = blobList.Count;
            int selectIndex = blobCount / 2 + blobCount / 16;
            for (int i = 0; i < blobList.Count; i++)
            {
                if (srcBlob.Area == -1)
                {
                    srcBlob = blobList[i];
                    if (srcBlob.Area < 40)
                    {
                        srcBlob.Area = -1;
                    }
                }
                else
                {
                    if (blobList[i].Area < srcBlob.Area && blobList[i].Area > 40)
                    {
                        srcBlob = blobList[i];
                    }
                }
            }
            for (int i = 0; i < blobList.Count; i++)
            {
                if (srcBlob.Area < blobList[i].Area)
                {
                    double num = (double)blobList[i].Area / srcBlob.Area;
                    if (num < 2)
                    {
                        sampleList.Add(blobList[i].Area);
                    }
                }
                if (sampleList.Count == blobList.Count - 1 || i == blobList.Count - 1)
                {
                    int nums = 0;
                    for (int j = 0; j < sampleList.Count; j++)
                    {
                        nums += sampleList[j];
                    }
                    double area = (double)nums / sampleList.Count;
                    double ss = area * 0.35;
                    int areaI = (int)Math.Round(area + ss);
                    //int sss = (int)Math.Round(areaI);
                    return areaI;
                }

            }

            //if (markX != -1 && markY != -1)
            //{
            //    //查找标记的Blob
            //    int markIndex = -1;
            //    for (int i = 0; i < blobCount; i++)
            //    {
            //        CvBlob blob = blobList[i];
            //        if (blob.Rect.Contains(new OpenCvSharp.Point(markX, markY)))
            //        {
            //            if (markIndex == -1 || blobList[i].Area < blobList[markIndex].Area)
            //            {
            //                markIndex = i;
            //            }
            //        }
            //    }
            //    if (markIndex != -1)
            //    {
            //        int area = blobList[markIndex].Area;
            //        area = area * 5 / 3 - 23;
            //        return area;
            //    }
            //}
            return srcBlob.Area;
        }

        /// <summary>
        /// 根据元器件特征统计图片中的元器件数量
        /// </summary>
        /// <param name="image"></param>
        /// <param name="itemFeature"></param>
        /// <param name="thresh"></param>
        /// <param name="inv"></param>
        /// <returns></returns>
        public static int CountItems(ref Image image, int itemArea)
        {
            Bitmap bitmap = new Bitmap(image);
            Mat imageMat = BitmapConverter.ToMat(bitmap);
            RadiusPt radiusPt, radiusPtOut;
            GetCenter(imageMat, out radiusPt);
            GetOutContour(imageMat, out radiusPtOut);
            Cv2.CvtColor(imageMat, imageMat, ColorConversionCodes.RGBA2BGR);
            Mat grayMat = BitmapConverter.ToMat(bitmap);
            Cv2.CvtColor(grayMat, grayMat, ColorConversionCodes.RGB2GRAY);
            CvBlobs blobs = AutoThreshBlobs(ref grayMat, itemArea,out itemArea,radiusPt,radiusPtOut);
            int totalCount = findCircles(ref imageMat, grayMat, blobs, itemArea,radiusPt,radiusPtOut);
            //imageMat = grayMat;
            //int totalCount = CountBlobs(blobs, itemArea, ref imageMat);
            image = BitmapConverter.ToBitmap(imageMat);
            return totalCount;
        }

        
        private static void FindCours(Mat srcMat, Mat threshMat)
        {
            Mat[] contours = null;
            Mat hierarchy = new Mat();
            Cv2.FindContours(threshMat, out contours, hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
            Mat linePic = Mat.Zeros(threshMat.Rows, threshMat.Cols, MatType.CV_8UC3);
            int contoursSize = contours.Length;
            for (int index = 0; index < contoursSize; index++)
            {
                //Cv2.DrawContours(linePic, contours, index, Scalar.RandomColor());
                //找出完整包含轮廓的最小矩形
                //Rect rect = Cv2.BoundingRect(contours[index]);
                RotatedRect rect = Cv2.MinAreaRect(contours[index]);
                double area = Cv2.ContourArea(contours[index]);
                if (rect.Size.Height < 100 || rect.Size.Width < 100)
                {
                    continue;
                }
                //Cv2.Rectangle(originalImg, rect, Scalar.Red);
                Point2f[] pf = rect.Points();
                OpenCvSharp.Point[] ps = new OpenCvSharp.Point[pf.Length];
                for (int i = 0; i < pf.Length; i++)
                {
                    ps[i] = new OpenCvSharp.Point(pf[i].X, pf[i].Y);
                }
                Cv2.Line(srcMat, ps[0], ps[1], Scalar.Red);
                Cv2.Line(srcMat, ps[1], ps[2], Scalar.Red);
                Cv2.Line(srcMat, ps[2], ps[3], Scalar.Red);
                Cv2.Line(srcMat, ps[0], ps[3], Scalar.Red);

            }
        }




        private static void LabelBlobsInCircle(ref string[] labels, List<CvBlob> blobList, double centerX, double centerY, double radius)
        {
            int labelCount = 0;
            double minX = 0;
            double maxX = 0;
            double minY = 0;
            double maxY = 0;
            for (int i = 0; i < labels.Length; i++)
            {
                if (labels[i] == null)
                {
                    CvBlob anotherBlob = blobList[i];
                    //左上，右上，左下，右下
                    bool isNeighbour = false;
                    if (Math.Abs(anotherBlob.MinX - centerX) < radius && Math.Abs(anotherBlob.MinY - centerY) < radius)
                    {
                        isNeighbour = true;
                    }
                    else if (Math.Abs(anotherBlob.MaxX - centerX) < radius && Math.Abs(anotherBlob.MinY - centerY) < radius)
                    {
                        isNeighbour = true;
                    }
                    else if (Math.Abs(anotherBlob.MinX - centerX) < radius && Math.Abs(anotherBlob.MaxY - centerY) < radius)
                    {
                        isNeighbour = true;
                    }
                    else if (Math.Abs(anotherBlob.MaxX - centerX) < radius && Math.Abs(anotherBlob.MaxY - centerY) < radius)
                    {
                        isNeighbour = true;
                    }
                    if (isNeighbour)
                    {
                        labels[i] = "1";
                        labelCount = labelCount + 1;
                        if (anotherBlob.MinX < minX || minX == 0)
                        {
                            minX = anotherBlob.MinX;
                        }
                        if (anotherBlob.MinY < minY || minY == 0)
                        {
                            minY = anotherBlob.MinY;
                        }
                        if (anotherBlob.MaxX > maxX)
                        {
                            maxX = anotherBlob.MaxX;
                        }
                        if (anotherBlob.MaxY > maxY)
                        {
                            maxY = anotherBlob.MaxY;
                        }
                    }
                }
            }
            if (labelCount > 0)
            {
                double rightX = centerX;
                do
                {
                    rightX = rightX + radius;
                    LabelBlobsInCircle(ref labels, blobList, rightX, centerY, radius);
                } while (rightX < maxX);

                double leftX = centerX;
                do
                {
                    leftX = leftX - radius;
                    LabelBlobsInCircle(ref labels, blobList, leftX, centerY, radius);
                } while (leftX > minX);

                double downY = centerY;
                do
                {
                    downY = downY + radius;
                    LabelBlobsInCircle(ref labels, blobList, centerX, downY, radius);
                } while (downY < maxY);

                double upY = centerY;
                do
                {
                    upY = upY - radius;
                    LabelBlobsInCircle(ref labels, blobList, centerX, upY, radius);
                } while (upY > minY);
            }
        }

        private static double GetLabelStep(List<CvBlob> blobList, int avgArea, out CvBlob markBlob)
        {
            int leastNeighbourBlobCount = 15;
            int selectIndex = blobList.Count / 2;
            markBlob = blobList[selectIndex];
            for (int i = selectIndex; i < blobList.Count; i++)
            {
                CvBlob blob = blobList[i];
                int blobArea = markBlob.Area;
                if (BlobHasItem(avgArea, blob) == 1)
                // if(blobArea > 0.9 * avgArea && blobArea < 1.1 * avgArea)
                {
                    //面积与给定的面积差不多,以其为中心，周围至少要有15个Blob
                    int neighbourCount = 0;
                    int blobRectSize = (blob.MaxX - blob.MinX) < (blob.MaxY - blob.MinY) ? (blob.MaxX - blob.MinX) : (blob.MaxY - blob.MinY);
                    double radius = blobRectSize;
                    while (neighbourCount != blobList.Count)
                    {
                        neighbourCount = blobList.Count(b =>
                        {
                            if (BlobHasItem(avgArea, b) >= 1)
                            {
                                double distance = blob.Centroid.DistanceTo(b.Centroid);
                                return distance < radius;
                            }
                            return false;
                        });
                        if (neighbourCount > leastNeighbourBlobCount)
                        {
                            markBlob = blob;
                            return radius;
                        }
                        radius = radius + blobRectSize;
                        if (radius > leastNeighbourBlobCount * blobRectSize)
                        {
                            break;
                        }
                    }
                }
            }
            return Math.Sqrt(avgArea);
        }
        //百分比阀值
        public static int GetPTileThreshold(Mat hist, double tile = 40)
        {
            int Y;
            double amount = 0, sum = 0;
            for (Y = 0; Y < 256; Y++) amount += hist.Get<float>(Y);
            for (Y = 0; Y < 256; Y++)
            {
                sum = sum + hist.Get<float>(Y);
                if (sum >= amount * tile / 100) return Y;
            }
            return -1;
        }
        //判断直方图是否是双峰的函数
        public static bool IsDimodal(double[] histGram)
        {
            int count = 0;
            for (int i = 1; i < 255; i++)
            {
                if (histGram[i - 1] < histGram[i] && histGram[i + 1] < histGram[i])
                {
                    count++;
                    if (count > 2) return false;
                }
            }
            if (count == 2)
                return true;
            else
                return false;
        }
        //基于双峰平均值的阈值
        public static int GetIntermodesThreshold(Mat hist)
        {
            int Y, Iter = 0, Index;
            double[] HistGramC = new double[256];           // 基于精度问题，一定要用浮点数来处理，否则得不到正确的结果
            double[] HistGramCC = new double[256];          // 求均值的过程会破坏前面的数据，因此需要两份数据
            for (Y = 0; Y < 256; Y++)
            {
                HistGramC[Y] = hist.Get<float>(Y);
                HistGramCC[Y] = hist.Get<float>(Y);
            }
            // 通过三点求均值来平滑直方图
            while (IsDimodal(HistGramCC) == false)                                                  // 判断是否已经是双峰的图像了      
            {
                HistGramCC[0] = (HistGramC[0] + HistGramC[0] + HistGramC[1]) / 3;                   // 第一点
                for (Y = 1; Y < 255; Y++)
                    HistGramCC[Y] = (HistGramC[Y - 1] + HistGramC[Y] + HistGramC[Y + 1]) / 3;       // 中间的点
                HistGramCC[255] = (HistGramC[254] + HistGramC[255] + HistGramC[255]) / 3;           // 最后一点
                System.Buffer.BlockCopy(HistGramCC, 0, HistGramC, 0, 256 * sizeof(double));         // 备份数据，为下一次迭代做准备
                Iter++;
                if (Iter >= 10000) return -1;                                                       // 似乎直方图无法平滑为双峰的，返回错误代码
            }
            // 阈值为两峰值的平均值
            int[] Peak = new int[2];
            for (Y = 1, Index = 0; Y < 255; Y++)
                if (HistGramCC[Y - 1] < HistGramCC[Y] && HistGramCC[Y + 1] < HistGramCC[Y]) Peak[Index++] = Y - 1;
            return ((Peak[0] + Peak[1]) / 2);

        }

        private static CvBlobs AutoThreshBlobs(ref Mat imageMat,int blobArea,out int standArea,RadiusPt radiusPt,RadiusPt radiusPtOut)
        {          
            Mat[] mats = new Mat[] { imageMat };//一张图片，初始化为panda
            Mat hist = new Mat();//用来接收直方图
            int[] channels = new int[] { 0 };//一个通道,初始化为通道0
            int[] histsize = new int[] { 256 };//一个通道，初始化为256箱子
            Rangef[] range = new Rangef[1];//一个通道，值范围
            range[0].Start = 0.0F;//从0开始（含）
            range[0].End = 256.0F;//到256结束（不含）
            Mat mask = new Mat();//不做掩码
            Cv2.CalcHist(mats, channels, mask, hist, 1, histsize, range);//计算灰度图，dim为1 1维
            double total = 0;
            for (int i = 0; i < 256; i++)//灰度值总数量
            {
                total = total + hist.Get<double>(i);
            }
            double percent = 0;
            int startIndex = -1;
            int endIndex = -1;
            for (int i = 0; i < 256; i++)//直方图
            {
                double len = hist.Get<double>(i);
                if (len > 100)
                {//灰度值的像素数小于100的忽略
                    if (startIndex == -1)
                    {
                        startIndex = i;
                    }
                    endIndex = i - 1;
                    percent = percent + len / total;
                    //近似的认为元器件的灰度值 数量占总数的百分比小于10%
                    if (percent > 0.1)
                    {
                        break;
                    }
                }
            }

            int avgIndex = (startIndex + endIndex) / 2;

            //avgIndex = GetIntermodesThreshold(hist);

            Mat threshMat = new Mat();
            Cv2.Threshold(imageMat, threshMat, avgIndex, 255, ThresholdTypes.BinaryInv);
            //Mat erodeMat = Mat.Ones(new OpenCvSharp.Size(3, 3), MatType.CV_8UC1);
            //Cv2.MorphologyEx(threshMat,threshMat,MorphTypes.Open,erodeMat);
            CvBlobs resultBlobs = new CvBlobs();
            resultBlobs.Label(threshMat);
            List<CvBlob> autoBlobList = resultBlobs.Values.Where(b => b.Area > blobArea).ToList();
            int blobCount = resultBlobs.Count();
            int threshIndex = avgIndex;
            double theArea = blobArea * 0.8;
            if (theArea < 1) theArea = 1;

            while (true)
            {
                //阈值向下走，找满足条件Blob数量最多的
                threshIndex = threshIndex - 1;
                Cv2.Threshold(imageMat, threshMat, threshIndex, 255, ThresholdTypes.BinaryInv);
                //Cv2.MorphologyEx(threshMat, threshMat, MorphTypes.Open, erodeMat);
                CvBlobs blobs = new CvBlobs();
                blobs.Label(threshMat);
                List<CvBlob> blobList = blobs.Values.Where(b => b.Area > theArea).ToList();
                if (blobList.Count > blobCount)
                {
                    resultBlobs = blobs;
                    blobCount = blobList.Count;
                }
                else
                {
                    break;
                }
            }
            threshIndex = avgIndex;
            while (true)
            {
                //阈值向上走，找满足条件Blob数量最多的
                threshIndex = threshIndex + 1;
                Cv2.Threshold(imageMat, threshMat, threshIndex, 255, ThresholdTypes.BinaryInv);
                //Cv2.MorphologyEx(threshMat, threshMat, MorphTypes.Open, erodeMat);
                CvBlobs blobs = new CvBlobs();
                blobs.Label(threshMat);
                List<CvBlob> blobList = blobs.Values.Where(b => b.Area > theArea).ToList();
                if (blobList.Count > blobCount)
                {
                    resultBlobs = blobs;
                    blobCount = blobList.Count;
                }
                else
                {
                    break;
                }
            }

            List<CvBlob> averBlobs = resultBlobs.Values.Where(a => a.Area > blobArea * 0.5 && a.Area < blobArea * 3).ToList();
            if (averBlobs.Count != 0 && blobArea < 120)
            {
                double averArea = averBlobs.Sum(a => a.Area) / averBlobs.Count;
                double veri = averBlobs.Sum(a => Math.Pow(a.Area - averArea, 2)) / averBlobs.Count;
                double standerdeviation = Math.Sqrt(veri);
                standArea = (int)Math.Round(averArea + standerdeviation);
                threshIndex = avgIndex;
                theArea = (int)Math.Round(averArea - standerdeviation);
                while (true)
                {
                    //阈值向下走，找满足条件Blob数量最多的
                    threshIndex = threshIndex - 1;
                    Cv2.Threshold(imageMat, threshMat, threshIndex, 255, ThresholdTypes.BinaryInv);
                    //Cv2.MorphologyEx(threshMat, threshMat, MorphTypes.Open, erodeMat);
                    CvBlobs blobs = new CvBlobs();
                    blobs.Label(threshMat);
                    List<CvBlob> blobList = blobs.Values.Where(b => b.Area > theArea).ToList();
                    if (blobList.Count > blobCount)
                    {
                        resultBlobs = blobs;
                        blobCount = blobList.Count;
                    }
                    else
                    {
                        break;
                    }
                }
                threshIndex = avgIndex;
                while (true)
                {
                    //阈值向上走，找满足条件Blob数量最多的
                    threshIndex = threshIndex + 1;
                    Cv2.Threshold(imageMat, threshMat, threshIndex, 255, ThresholdTypes.BinaryInv);
                    //Cv2.MorphologyEx(threshMat, threshMat, MorphTypes.Open, erodeMat);
                    CvBlobs blobs = new CvBlobs();
                    blobs.Label(threshMat);
                    List<CvBlob> blobList = blobs.Values.Where(b => b.Area > theArea).ToList();
                    if (blobList.Count > blobCount)
                    {
                        resultBlobs = blobs;
                        blobCount = blobList.Count;
                    }
                    else
                    {
                        break;
                    }
                }

                List<CvBlob> blobL = resultBlobs.Values.Where(a => a.Area > 0 && a.Area < averArea * 3).ToList();
                standArea = (int)Math.Round((double)blobL.Sum(a => a.Area) / blobL.Count);

            }
            else
            {
                standArea = blobArea;
            }
            imageMat = threshMat;
            Console.WriteLine("thresh: " + threshIndex + " Blob: " + blobCount + "  Area:" + theArea);
            return resultBlobs;
        }

        /// <summary>
        /// 二值化图像
        /// </summary>
        /// <param name="imageMat"></param>
        /// <param name="thresh"></param>
        /// <param name="inv"></param>
        /// <returns></returns>
        private static Mat Threshhold(Mat imageMat, int thresh = -1)
        {
            Mat dst = new Mat();
            Cv2.CvtColor(imageMat, dst, ColorConversionCodes.RGB2GRAY);
            if (thresh == -1)
            {
                //全局自动二值 化
                Cv2.Threshold(dst, dst, 0, 255, ThresholdTypes.Otsu | ThresholdTypes.BinaryInv);
                //自动局部二值化
                //Binarizer.Sauvola(dst, dst, 221, 0.02, 232);
                //Cv2.AdaptiveThreshold(dst, dst, 255, AdaptiveThresholdTypes.GaussianC, ThresholdTypes.Binary, 5, 0);
            }
            else
            {
                //二值化
                Cv2.Threshold(dst, dst, thresh, 255, ThresholdTypes.BinaryInv);
            }
            return dst;
        }
        /// <summary>
        /// 获取所有Blobs
        /// </summary>
        /// <param name="imageMat"></param>
        /// <param name="thresh"></param>
        /// <param name="inv"></param>
        /// <returns></returns>
        private static List<CvBlob> GetBlobs(Mat imageMat, int thresh = -1)
        {
            Cv2.CvtColor(imageMat, imageMat, ColorConversionCodes.RGBA2BGR);
            Mat dst = Threshhold(imageMat, thresh);
            CvBlobs blobs = new CvBlobs();
            blobs.Label(dst);
            List<CvBlob> blobList = blobs.Values.Where(b => b.Area > 0).ToList();
            return blobList;
        }


        /// <summary>
        /// 给定Blob包含几个元器件
        /// </summary>
        /// <param name="averageArea"></param>
        /// <param name="blob"></param>
        /// <returns></returns>
        public static int BlobHasItem(int averageArea, CvBlob blob)
        {
            int blobArea = blob.Area;
            double minArea = 0.5 * averageArea;
            double k = 1.5;
            if (averageArea < 50)
            {
                minArea = 0.2 * averageArea;
            }
            if (blobArea < minArea*2/3)
            {
                return 0;
            }
            //if (blobArea >= 0.5 * averageArea && blobArea <= 1.5 * averageArea)
            //{
            //    return 1;
            //}
            //else if (blobArea > 1.5 * averageArea && blobArea <= 3 * averageArea)
            //{
            //    return 2;
            //}
            //else if (blobArea > 3.5 * averageArea && blobArea < 5.5 * averageArea)
            //{
            //    return 3;
            //}
            int count = 0;
            //if (blobArea < 130)
            //{
            //    count = (int)((blobArea + k * averageArea) / (k * averageArea));
            //}
            //else
            //{
            //    count = (int)Math.Round((blobArea + k * averageArea) / (k * averageArea));
            //}
            //count = (int)((blobArea + k * averageArea) / (k * averageArea));
            count = (int)((blobArea + k * averageArea) / (k * averageArea));

            if (count == 0 || count == 1)
            {
                count = 1;
            }
            //if (count <= 10000)
            //{
                return count;
            //}
            //return 0;
        }

        /// <summary>
        /// 读取Raw格式图片
        /// </summary>
        /// <param name="imagePath"></param>
        /// <returns></returns>
        private static Bitmap[] ReadRaw(string imagePath)
        {
            byte[] buff = System.IO.File.ReadAllBytes(imagePath);


            if (buff == null || buff.Length == 0)
            {
                return null;
            }
            bool needRevertLayer = false;
            for (int i = 0; i < buff.Length; i++)
            {
                if (buff[i] != 0)
                {
                    if (i > 65535)
                    {
                        byte[] b = new byte[buff.Length - 65535];
                        Array.Copy(buff, 65535, b, 0, b.Length);
                        buff = b;
                        needRevertLayer = true;
                    }
                    break;
                }
            }

            byte[] buffer_src = new byte[buff.Length / 2];
            byte[] buffer_filter = new byte[buff.Length / 2];
            for (int i = 0; i < buffer_src.Length; i++)
            {
                byte currentByte = buff[i * 2];
                byte filterByte = buff[i * 2 + 1];
                if (needRevertLayer)
                {
                    currentByte = (byte)(currentByte * 3);
                    filterByte = (byte)(filterByte * 3);
                }
                buffer_src[i] = currentByte;
                if (filterByte == 1)
                    buffer_filter[i] = currentByte;
                else
                {
                    //buffer_filter[i] = 255;
                    buffer_filter[i] = filterByte;
                }
            }

            Bitmap filter_bitmap = ToImage32(buffer_filter);
            Bitmap src_bitmap = ToImage32(buffer_src);
            //翻转图层
            if (needRevertLayer)
            {
                return new Bitmap[] { filter_bitmap, src_bitmap };
            }
            else
            {
                return new Bitmap[] { src_bitmap, filter_bitmap };
            }
        }
        /// <summary>
        /// 8位灰度转32位图像
        /// </summary>
        /// <returns></returns>
        private static Bitmap ToImage32(byte[] buff)
        {
            int w = Convert.ToInt32(Math.Sqrt(buff.Length));
            int a = buff.Length % w;
            if (a != 0)
            {
                w = w - 1;
            }
            int n = 0;
            byte[] bb = new byte[buff.Length * 4];
            for (int i = 0; i < buff.Length; i++)
            {
                byte currentByte = buff[i];
                //currentByte = (byte)(Math.Log(1 + currentByte) * 255);
                bb[n++] = currentByte;
                bb[n++] = currentByte;
                bb[n++] = currentByte;
                bb[n++] = 255;
            }
            Bitmap bmp = new Bitmap(w, w, PixelFormat.Format32bppArgb);
            BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, w, w), ImageLockMode.ReadWrite, bmp.PixelFormat);
            IntPtr ptrBmp = bmpData.Scan0;
            System.Runtime.InteropServices.Marshal.Copy(bb, 0, ptrBmp, bmpData.Stride * w);
            bmp.UnlockBits(bmpData);
            return bmp;
        }

        private static List<OpenCvSharp.Point> toContourPoints(CvContourChainCode contour)
        {
            List<OpenCvSharp.Point> contourPoints = new List<OpenCvSharp.Point>();
            contourPoints.Add(contour.StartingPoint);
            int x = contour.StartingPoint.X;
            int y = contour.StartingPoint.Y;
            foreach (CvChainCode cc in contour.ChainCode)
            {
                x += CvBlobConst.ChainCodeMoves[(int)cc][0];
                y += CvBlobConst.ChainCodeMoves[(int)cc][1];
                contourPoints.Add(new OpenCvSharp.Point(x, y));
            }
            return contourPoints;
        }

        private static CvBlob findMarkBlob(List<CvBlob> blobList, int markX = -1, int markY = -1, int thresh = -1, bool inv = true)
        {
            int blobCount = blobList.Count;
            int selectIndex = blobCount / 2;
            if (markX != -1 && markY != -1)
            {
                //查找标记的Blob
                int markIndex = -1;
                for (int i = 0; i < blobCount; i++)
                {
                    CvBlob blob = blobList[i];
                    if (blob.Rect.Contains(new OpenCvSharp.Point(markX, markY)))
                    {
                        if (markIndex == -1 || blobList[i].Area < blobList[markIndex].Area)
                        {
                            markIndex = i;
                        }
                    }
                }
                if (markIndex != -1)
                {
                    CvBlob markBlob = blobList[markIndex];
                    return markBlob;
                }
            }
            return null;
        }

        /// <summary>
        /// 查找Blob中包含的所有与给定半径差不多的内接圆
        /// </summary>
        /// <param name="matDistanceArr"></param>
        /// <param name="blobs"></param>
        /// <param name="blob"></param>
        /// <param name="reelCenter"></param>
        /// <param name="oneBlobWidth"></param>
        /// <param name="oneBlobRadius"></param>
        /// <returns></returns>
        public static SplitItem findCircleInBlob(double[,]  matDistanceArr, CvBlobs blobs, CvBlob blob,  Point2d reelCenter, double oneBlobWidth= -1, double oneBlobRadius = -1)
        {
            SplitItem item = new SplitItem();
            while (true)
            {
                bool hasFind = false;
                bool hasPixToHandle = false;
                for (int x = blob.MinX; x< blob.MaxX; x++)
                {
                    for (int y = blob.MinY; y < blob.MaxY; y++)
                    {
                        double distance = matDistanceArr[x, y];
                        if (distance > 0)
                        {
                            int label = blobs.GetLabel(x, y);
                            if (label != blob.Label)
                            {
                                //不是当前Blob的像素
                                //matDistanceArr[x, y] = 0;
                                continue;
                            }
                            hasPixToHandle = true;
                            if (!item.isEnd)
                            {
                                //点到圆心的距离
                                double distanceToCircle = item.minDistanceToCircles(x, y, reelCenter);
                                if (distanceToCircle == 0)
                                {
                                    matDistanceArr[x, y] = 0;
                                    continue;
                                }
                                if (distanceToCircle> 0 && distanceToCircle < distance)
                                {
                                    distance = distanceToCircle;
                                    matDistanceArr[x, y] = distance;
                                }
                                if (distance > item.currentMaxRadius)
                                {
                                    item.currentMaxRadius = distance;
                                    item.centerX = x;
                                    item.centerY = y;
                                    if (oneBlobRadius != -1 && distance >= oneBlobRadius)
                                    {
                                        item.calOneItem(oneBlobRadius);
                                        hasFind = true;
                                        break;
                                    }
                                }                            
                            }
                        }
                        
                    }                              
                    if (hasFind)
                    {
                        break;
                    }
                }
                if (!hasFind)
                {
                    item.calOneItem(oneBlobRadius);
                }             
                if (item.isEnd || !hasPixToHandle )
                {
                    break;
                }

            }
            return item;
        }
        public struct CircleStruct
        {
           public  OpenCvSharp.Point centerPt;
            public double radius;
        }
        private static int startI = -1;
        private static List<CircleStruct> resultList = new List<CircleStruct>();
        private static List<List<CircleStruct>> spitList = new List<List<CircleStruct>>();
        private static CircleStruct circleStruct = new CircleStruct();
        public static void findCircleInBlobNew(double[,] matDistanceArr, CvBlobs blobs, CvBlob blob, Point2d reelCenter, double oneBlobWidth = -1, double oneBlobRadius = -1)
        {
            resultList.Clear();
            for (int x = blob.MinX; x < blob.MaxX; x++)
            {
                for (int y = blob.MinY; y < blob.MaxY; y++)
                {
                    double distance = matDistanceArr[x, y];
                    if (distance > 0)
                    {
                        int label = blobs.GetLabel(x, y);
                        if (label != blob.Label)
                        {                          
                            continue;
                        }
                        else
                        {
                            if (distance>=oneBlobRadius*0.8)
                            {
                                circleStruct.centerPt.X = x;
                                circleStruct.centerPt.Y = y;
                                circleStruct.radius = distance;
                                if (startI == -1)
                                {
                                    startI = 1;
                                    resultList.Add(circleStruct);
                                }
                                else
                                {
                                    bool intersectionB = false;
                                    foreach (CircleStruct item in resultList)
                                    {
                                        //if (Math.Abs(item.centerPt.DistanceTo(new OpenCvSharp.Point(reelCenter.X,reelCenter.Y))-circleStruct.centerPt.DistanceTo(new OpenCvSharp.Point(reelCenter.X, reelCenter.Y)))<=oneBlobWidth)
                                        //{
                                        //    intersectionB = true;
                                        //    break;
                                        //}
                                        if (item.centerPt.DistanceTo(circleStruct.centerPt)<item.radius+distance)
                                        {
                                            intersectionB = true;
                                            break;
                                        }
                                    }
                                    if (!intersectionB)
                                    {
                                        resultList.Add(circleStruct);
                                    }
                                }
                                

                            }
                        }
                        
                    }

                }
               
            }

            //分离
            while (resultList.Count != 0)
            {

            }





        }

        /// <summary>
        /// 查找Blobs包含的元器件数量
        /// </summary>
        /// <param name="srcMat"></param>
        /// <param name="threshMat"></param>
        /// <param name="blobs"></param>
        /// <param name="avgArea"></param>
        /// <returns></returns>
        public  static int findCircles(ref Mat srcMat, Mat threshMat, CvBlobs blobs, int avgArea, RadiusPt radiusPt,RadiusPt radiusPtOut)
        {
            Mat distanceMat = new Mat();            
            Cv2.DistanceTransform(threshMat, distanceMat, DistanceTypes.L2, DistanceMaskSize.Mask3);
            double[,] distanceArr = new double[threshMat.Cols, threshMat.Rows];
            
            IntPtr dddd = distanceMat.Data;

            Console.WriteLine("Start to distance array");
            unsafe
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                for (int y = 0; y < threshMat.Rows; y++) {                  
                    for (int x = 0; x < threshMat.Cols; x++){
                        float* dd = (float*)distanceMat.Ptr(y, x);
                        distanceArr[x, y] = dd[0];                     
                    }
                }
                sw.Stop();
                Console.WriteLine("=" + sw.ElapsedMilliseconds + " ms");
            }
            
            Dictionary<int, SplitItem> blobCircles = new Dictionary<int, SplitItem>();

            Console.WriteLine("Start find reel center");
            Point2d reelCenter = new Point2d(0,0) ;
            ////查找中心            
            reelCenter.X = radiusPtOut.pt.X;
            reelCenter.Y = radiusPtOut.pt.Y;
            srcMat.Line(new OpenCvSharp.Point(radiusPtOut.pt.X - 10, radiusPtOut.pt.Y), new OpenCvSharp.Point(radiusPtOut.pt.X + 10, radiusPtOut.pt.Y), Scalar.Blue);
            srcMat.Line(new OpenCvSharp.Point(radiusPtOut.pt.X, radiusPtOut.pt.Y - 10), new OpenCvSharp.Point(radiusPtOut.pt.X, radiusPtOut.pt.Y + 10), Scalar.Blue);          
            Console.WriteLine("Start find reel Max Radius, max Width");
            //最大
            double maxRadius = 0;
            double maxWidth = 0;
            List<SplitItem> averItem = new List<SplitItem>();
            averItem.Clear();
            foreach (CvBlob blob in blobs.Values)
            {

                int count = BlobHasItem(avgArea, blob);
                if (count == 1)
                {
                    if (blob.Rect.Width > maxWidth)
                    {
                        maxWidth = blob.Rect.Width;
                    }
                    if (blob.Rect.Height > maxWidth)
                    {
                        maxWidth = blob.Rect.Height;
                    }

                    SplitItem item = findCircleInBlob(distanceArr, blobs, blob, reelCenter);
                    averItem.Add(item);

                    foreach (Circle c in item.circles)
                    {
                        if (c.radius > maxRadius || maxRadius == 0)
                        {
                            maxRadius = c.radius;
                        }
                        //srcMat.Circle(c.x, c.y, (int)c.radius, Scalar.Green);
                    }
                }
            }
            //平均半径
            double averRadius = averItem.Sum(a => a.circles.Sum(b => b.radius)) / averItem.Sum(a => a.circles.Count);
            maxRadius = averRadius*3/2;
            //放大宽度，防止误判断
            //maxWidth = maxWidth * 1.6;
            Console.WriteLine("Start count");
            int totalCount = 0;
            foreach (CvBlob blob in blobs.Values)
            {
                int count = BlobHasItem(avgArea, blob);
                if (count == 1)
                {
                    //单个元器件
                    if (blob.Centroid.DistanceTo(new Point2d(radiusPt.pt.X,radiusPt.pt.Y)) < radiusPt.radius-10)
                    {
                        continue;
                    }
                    totalCount = totalCount + 1;
                    srcMat.Circle((int)blob.Centroid.X, (int)blob.Centroid.Y, (int)maxRadius / 2, Scalar.LightGreen);
                }
                else if (count > 1)
                {
                    //if (count > 20)
                    //{
                    //    //中间的圆，去除
                    //    if (blob.Centroid.DistanceTo(reelCenter) < radiusPt.radius)
                    //    {
                    //        continue;
                    //    }
                    //    //if (blob.Centroid.DistanceTo(new Point2d(srcMat.Cols / 2, srcMat.Rows / 2)) < 200)
                    //    //{
                    //    //    continue;
                    //    //}
                    //}
                    if (blob.Centroid.DistanceTo(new Point2d(radiusPt.pt.X, radiusPt.pt.Y)) < radiusPt.radius-10)
                    {
                        continue;
                    }
                    ////多个元器件，查找 所有圆
                    SplitItem item = findCircleInBlob(distanceArr, blobs, blob, reelCenter, maxWidth, maxRadius);
                    //对所有圆进行分组
                    List<List<Circle>> groupCircles = item.groupCircles(maxWidth, maxRadius, reelCenter);

                    //Scalar color = Scalar.RandomColor();
                    //blob.Contour.Render(srcMat, color);



                    foreach (List<Circle> groupCircle in groupCircles)
                    {
                        if (groupCircle.Count == 0)
                        {
                            continue;
                        }
                        Circle c = groupCircle[0];
                        srcMat.Circle(c.x, c.y, (int)c.radius / 2, Scalar.Yellow);
                        totalCount = totalCount + 1;
                        //foreach (Circle cg in groupCircle)
                        //{
                        //    srcMat.Circle(cg.x, cg.y, (int)c.radius, color);
                        //}
                    }
                }
            }

            Cv2.PutText(srcMat, totalCount + "", new OpenCvSharp.Point(reelCenter.X-40, reelCenter.Y+30), HersheyFonts.HersheySimplex, 1.0, Scalar.LightGreen);
            Console.WriteLine("===========" + totalCount);
            return totalCount;

        }

        ////TODO: 测试距离变换，用后删除
        //public static Image DistanceTransform(Image image)
        //{
        //    Mat imageMat = BitmapConverter.ToMat(new Bitmap(image));
        //    Mat gray = new Mat();
        //    Cv2.CvtColor(imageMat, gray, ColorConversionCodes.RGB2GRAY);
        //    ////开运算
        //    Mat k1 = Mat.Ones(new OpenCvSharp.Size(1, 1), MatType.CV_8UC1);
        //    Cv2.MorphologyEx(gray, gray, MorphTypes.Open, k1, new OpenCvSharp.Point(0, 0), 3);
        //    Mat distanceMat = new Mat();
        //    Mat labels = new Mat() ;
        //    Cv2.DistanceTransform(gray, distanceMat, DistanceTypes.L2, DistanceMaskSize.Mask3) ;

        //    Cv2.Normalize(distanceMat, gray, 0, 255, NormTypes.MinMax);
        //    gray.ConvertTo(gray, MatType.CV_8UC1);
        //    Cv2.Threshold(gray, gray, 0, 255, ThresholdTypes.Otsu);
        //    Mat colorImg = Mat.Zeros(gray.Size(), MatType.CV_8UC3);
        //    Cv2.ConnectedComponents(gray, labels, PixelConnectivity.Connectivity8);
        //    Dictionary<int, SplitItem> blobCircles = new Dictionary<int, SplitItem>();
        //    for(int y=0;y<labels.Rows; y++)
        //    {
        //        for (int x = 0; x < labels.Cols; x++)
        //        {
        //            int label = labels.At<int>(y, x);

        //            float distance = distanceMat.At<float>(y, x);
        //            SplitItem item = new SplitItem();
        //            if (blobCircles.ContainsKey(label))
        //            {
        //                item = blobCircles[label];
        //            }

        //            if (distance > item.currentMaxRadius)
        //            {
        //                item.currentMaxRadius = distance;
        //                item.centerX = x;
        //                item.centerY = y;
        //            }
        //            blobCircles[label] = item;

        //            byte b = (byte)(label % 255);
        //            byte g = 0;
        //            if (b < 128 && b>0)
        //            {
        //                g = (byte)(255 - b);
        //            }
        //            Vec3b color = new Vec3b(b,g,0);
        //            colorImg.Set<Vec3b>(y, x, color);
        //        }
        //    }

        //    foreach (SplitItem circle in blobCircles.Values)
        //    {
        //        circle.calOneItem(-1);
        //    }

        //    while (true)
        //    {
        //        for (int y = 0; y < labels.Rows; y++)
        //        {
        //            for (int x = 0; x < labels.Cols; x++)
        //            {
        //                int label = labels.At<int>(y, x);
        //                if (label == 0) continue;
        //                SplitItem item = new SplitItem();
        //                if (blobCircles.ContainsKey(label))
        //                {
        //                    item = blobCircles[label];
        //                }
        //                if (!item.isEnd)
        //                {
        //                    double distance = distanceMat.At<float>(y, x);
        //                    //此Blob未结束 
        //                    // bool validPoint = item.isValidPoint(x, y);
        //                    bool validPoint = false;
        //                    if (validPoint)
        //                    {
        //                        if (distance > item.currentMaxRadius)
        //                        {
        //                            item.currentMaxRadius = distance;
        //                            item.centerX = x;
        //                            item.centerY = y;
        //                            blobCircles[label] = item;
        //                        }
        //                    }
        //                }
        //            }
        //        }
        //        bool needContinue = false;
        //        foreach (SplitItem circle in blobCircles.Values)
        //        {
        //            circle.calOneItem();
        //            if (!circle.isEnd)
        //            {
        //                needContinue = true;
        //            }
        //        }
        //        if (!needContinue)
        //        {
        //            break;
        //        }
        //    }
        //    int totalCount = 0;
        //    foreach (SplitItem item in blobCircles.Values)
        //    {
        //        foreach(Circle circle in item.circles)
        //        {
        //            Cv2.Circle(colorImg, circle.x, circle.y, (int)circle.radius,Scalar.White);
        //            totalCount++;
        //        }
        //    }
        //    Console.WriteLine("Total: " + totalCount);
        //    return BitmapConverter.ToBitmap(colorImg);

        //    //dist.SaveImage("d:\\image\\dsitdist1.jpg");

        //    //Cv2.Threshold(dist, dist, 79, 255, ThresholdTypes.Binary);
        //    //Cv2.CvtColor(dist,dist,ColorConversionCodes.BGRA2BGR);
        //    //dist.ConvertTo(dist, MatType.CV_8UC1);
        //    //image = BitmapConverter.ToBitmap(dist);
        //    //return image;
        //}
        public static int GetGrayValue(ref Image image, int markX, int markY)
        {
            Mat imageMat = BitmapConverter.ToMat(new Bitmap(image));

            RadiusPt radiusPt, radiusPtOut;
            GetCenter(imageMat, out radiusPt);
            GetOutContour(imageMat, out radiusPtOut);
            Mat grayMat = new Mat();
            Mat thresholdMat = new Mat();
            int minThreshold = -1;                     
            int sampThreshold = -1, blobNum = -1;
            double minArea, maxArea, proportion=0;
            CvBlobs blobs = new CvBlobs();
            Cv2.CvtColor(imageMat,imageMat,ColorConversionCodes.BGRA2BGR);
            Cv2.CvtColor(imageMat, grayMat, ColorConversionCodes.RGB2GRAY);
            for (int i = 0; i < 2; i++)
            {
                if (i == 0)
                {
                    sampThreshold = 151;
                }
                else
                {
                    sampThreshold = 161;
                }
                Cv2.Threshold(grayMat, thresholdMat, sampThreshold, 255, ThresholdTypes.BinaryInv);
                Cv2.MedianBlur(thresholdMat, thresholdMat, 7);
                blobs.Label(thresholdMat);
                List<CvBlob> blobL = blobs.Values.Where(a => a.Area > 3 && a.Centroid.DistanceTo(radiusPtOut.pt) > radiusPt.radius && a.Centroid.DistanceTo(radiusPtOut.pt) < radiusPtOut.radius).ToList();
                blobL.Sort((a, b) => a.Area.CompareTo(b.Area));
                if (blobL.Count == 0)
                {
                    continue;
                }
                minArea = blobL[0].Area;
                maxArea = blobL[blobL.Count - 1].Area;
                if (i == 0)
                {
                    blobNum = blobL.Count();
                    proportion = maxArea / minArea;
                }
                else
                {                  
                    if (blobNum > blobL.Count && proportion < maxArea / minArea||blobL.Count<100)
                    {
                        minThreshold = 151;                        
                    }
                    else
                    {                      
                        minThreshold = 161;
                       
                    }
                }             
            }
                   
            Cv2.Threshold(grayMat, thresholdMat, minThreshold, 255, ThresholdTypes.BinaryInv);
            blobs.Label(thresholdMat);
            CvBlob selectBlob = null;
            foreach (CvBlob item in blobs.Values)
            {
                if (item.Rect.Contains(markX, markY))
                {
                    if (selectBlob == null)
                    {
                        selectBlob = item;
                    }
                    else
                    {
                        if (selectBlob.Area>item.Area)
                        {
                            selectBlob = item;
                        }
                    }
                }
            }
            if (selectBlob == null)
            {
                return -1;
            }
            selectBlob.Contour.Render(imageMat, Scalar.Red);
            image = BitmapConverter.ToBitmap(imageMat);
            return selectBlob.Area;
        }

        /// <summary>
        /// 获取单个元器件的特征
        /// </summary>
        /// <param name="image"></param>
        /// <param name="markX"></param>
        /// <param name="markY"></param>
        /// <returns></returns>
        public static int GetFeature(ref Image image, int markX, int markY)
        {
            Mat imageMat = BitmapConverter.ToMat(new Bitmap(image));
            Cv2.CvtColor(imageMat, imageMat, ColorConversionCodes.BGRA2BGR);
            Mat dst = new Mat();


            //Cv2.CvtColor(imageMat, gradMat, ColorConversionCodes.RGB2GRAY);
            ////全局二值化
            //Cv2.Threshold(gradMat, dst, 0, 255, ThresholdTypes.Otsu |ThresholdTypes.BinaryInv);

            //image = BitmapConverter.ToBitmap(dst);
            //CvBlobs blobs = new CvBlobs();
            //blobs.Label(dst);
            //int blobArea = -1;
            //foreach (CvBlob blob in blobs.Values)
            //{
            //    if (blob.Rect.Contains(new OpenCvSharp.Point(markX, markY)))
            //    {
            //        if (blob.Area < blobArea || blobArea == -1)
            //        {
            //            blobArea = blob.Area;
            //        }
            //    }
            //}

            Mat[] mats = new Mat[] { imageMat };//一张图片，初始化为panda
            Mat hist = new Mat();//用来接收直方图
            int[] channels = new int[] { 0 };//一个通道,初始化为通道0
            int[] histsize = new int[] { 256 };//一个通道，初始化为256箱子
            Rangef[] range = new Rangef[1];//一个通道，值范围
            range[0].Start = 0.0F;//从0开始（含）
            range[0].End = 256.0F;//到256结束（不含）
            Mat mask = new Mat();//不做掩码
            Cv2.CalcHist(mats, channels, mask, hist, 1, histsize, range);//计算灰度图，dim为1 1维
            double total = 0;
            for (int i = 0; i < 256; i++)//灰度值总数量
            {
                total = total + hist.Get<double>(i);
            }
            double percent = 0;
            int startIndex = -1;
            int endIndex = -1;
            for (int i = 0; i < 256; i++)//直方图
            {
                double len = hist.Get<double>(i);
                if (len > 100)
                {//灰度值的像素数小于100的忽略
                    if (startIndex == -1)
                    {
                        startIndex = i;
                    }
                    endIndex = i - 1;
                    percent = percent + len / total;
                    //近似的认为元器件的灰度值 数量占总数的百分比小于10%
                    //if (percent > 0.1)
                    //{
                    //    break;
                    //}
                }
            }

            int areaBlob = -1;
            int blobCount = 0;
            Mat grayMat = new Mat();
            CvBlob minBlob = null;
            Cv2.CvtColor(imageMat, grayMat, ColorConversionCodes.RGB2GRAY);

            for (int i = endIndex; i > startIndex; i--)
            {

                CvBlobs blobs = new CvBlobs();
                Cv2.Threshold(grayMat, dst, i, 255, ThresholdTypes.BinaryInv);
                blobs.Label(dst);
                int minArea = -1;
                foreach (CvBlob blob in blobs.Values)
                {
                    if (blob.Rect.Contains(new OpenCvSharp.Point(markX, markY)))
                    {
                        if (blob.Area < minArea || minArea == -1)
                        {
                            minArea = blob.Area;
                            if (minBlob==null)
                            {
                                minBlob = blob;
                            }
                        }
                    }
                }


                List<CvBlob> blobList = blobs.Values.Where(b => b.Area > minArea).ToList<CvBlob>();
                int currentBlobCount = blobList.Count;
                if(currentBlobCount <= 20 || minArea == -1)
                {
                    continue;
                }
                if (minArea * 2 <= areaBlob && areaBlob != -1 && blobCount * 1.5 < currentBlobCount && blobCount != -1)
                {
                    Console.WriteLine("thresh:" + i + " = " + minArea + "  count = " + currentBlobCount);
                    minBlob.Contour.Render(imageMat,Scalar.Red);
                    //image = BitmapConverter.ToBitmap(imageMat);
                    image = BitmapConverter.ToBitmap(dst);

                    return minArea;
                }
                areaBlob = minArea;
                blobCount = currentBlobCount;
            }

            Console.WriteLine("End");
            return -1;
        }
        //获取圆心半径
        public struct RadiusPt
        {
            public OpenCvSharp.Point pt;
            public int radius;
        }
        public static bool GetCenter(Mat srcMat, out RadiusPt radiusPt)
        {
            Mat grayMAT = srcMat.Clone();        
            Cv2.CvtColor(grayMAT, grayMAT, ColorConversionCodes.BGR2GRAY);
            Binarizer.Sauvola(grayMAT, grayMAT, 91, 0.1, 61);
            Cv2.MedianBlur(grayMAT, grayMAT, 5);
            Mat element = Cv2.GetStructuringElement(MorphShapes.Cross, new OpenCvSharp.Size(41, 41));
            Cv2.Erode(grayMAT, grayMAT, element);
            CvBlobs blobs = new CvBlobs();
            blobs.Label(grayMAT);
            CvBlob centerMat = null;
            Point2d pt;
            foreach (CvBlob item in blobs.Values)
            {
                item.SetMoments();
                pt = item.CalcCentroid();
                if (pt.X - 3072 * 0.5 < 150 && pt.Y - 3072 * 0.5 < 150 && 3072 * 0.5 - pt.X < 150 && 3072 * 0.5 - pt.Y < 150 && item.Rect.Width < 900)
                {
                    if (centerMat == null)
                    {
                        centerMat = item;
                    }
                    else if (centerMat.Rect.Width < item.Rect.Width)
                    {
                        centerMat = item;
                    }
                }

            }
            if (centerMat != null)
            {            
                pt = centerMat.CalcCentroid();
                radiusPt.pt.X = centerMat.Rect.Width/2+centerMat.Rect.X;
                radiusPt.pt.Y = centerMat.Rect.Height/ 2 + centerMat.Rect.Y;
                if (centerMat.Rect.Width < centerMat.Rect.Height)
                    radiusPt.radius = (int)Math.Round(centerMat.Rect.Width * 0.5);
                else
                    radiusPt.radius = (int)Math.Round(centerMat.Rect.Height * 0.5);                        
                return true;
            }
            else
            {
                radiusPt.radius = -1;
                radiusPt.pt = new OpenCvSharp.Point(0, 0);
                return false;
            }

        }
        //获取最外轮廓
        public static bool GetOutContour(Mat srcMat, out RadiusPt radiusPt)
        {
            Mat grayMAT = srcMat.Clone();
            Cv2.CvtColor(grayMAT, grayMAT, ColorConversionCodes.BGR2GRAY);
            Binarizer.Sauvola(grayMAT, grayMAT, 91, 0.1, 61);
            Cv2.MedianBlur(grayMAT, grayMAT, 5);
            Mat element = Cv2.GetStructuringElement(MorphShapes.Cross, new OpenCvSharp.Size(41, 41));
            Cv2.Erode(grayMAT, grayMAT, element);
            grayMAT = ~grayMAT;
            CvBlobs blobs = new CvBlobs();
            blobs.Label(grayMAT);
            CvBlob centerMat = null;
            Point2d pt;
            foreach (CvBlob item in blobs.Values)
            {
                item.SetMoments();
                pt = item.CalcCentroid();
                if (pt.X - 3072 * 0.5 < 150 && pt.Y - 3072 * 0.5 < 150 && 3072 * 0.5 - pt.X < 150 && 3072 * 0.5 - pt.Y < 150)
                {
                    if (centerMat == null)
                    {
                        centerMat = item;
                    }
                    else if (centerMat.Rect.Width < item.Rect.Width)
                    {
                        centerMat = item;
                    }
                }

            }
            if (centerMat != null)
            {
                pt = centerMat.CalcCentroid();
                radiusPt.pt.X = (int)pt.X;
                radiusPt.pt.Y = (int)pt.Y;
                if (centerMat.Rect.Width > centerMat.Rect.Height)
                    radiusPt.radius = (int)Math.Round(centerMat.Rect.Width * 0.5);
                else
                    radiusPt.radius = (int)Math.Round(centerMat.Rect.Height * 0.5);
                return true;
            }
            else
            {
                radiusPt.radius = -1;
                radiusPt.pt = new OpenCvSharp.Point(0, 0);
                return false;
            }
        }
    }
}