OpenCVSharp 景深融合

C#景深融合

最近因为一个项目要求，将matlab写的一些关于图像的算法转成C#。这个挺坑爹的，C#处理图像还是挺少的，opencv关于这方面的资源挺少的。我用的是opencvsharp这个第三方库，GitHub上有资源。
这个景深融合其实是一个显微镜扫描成像的问题，一共有数张图像，都是局部清晰，其它部分模糊。比如下面这样：

实际处理思路是：图像边缘检测，然后做了一个平滑处理，根据灰度图的亮度进行筛选，形成一个分区。最后根据分区处理像素的填充。
下面贴代码：
读取图片的操作就略去了，边缘提取用的是sobel，注意一下，opencvsharp中的图像处理注意mat数据的溢出。及时调整mat的像素深度比如16s，通常原始图像读取是8u。像素深度关系到具体坐标的数据格式。

    class Oper
    {
        public static Mat Deal(Mat ImIn)
        {
            Mat mat_gray = new Mat();
            //
            //Mat smooth_img = new Mat();
            //Cv2.GaussianBlur(ImIn, smooth_img, new OpenCvSharp.Size(3, 3), 0.96, 0.96, BorderTypes.Default);
            //灰度图


            Cv2.CvtColor(ImIn, mat_gray, ColorConversionCodes.BGR2GRAY);
            //GetMatData.Arr(mat_gray);

            Mat X = new Mat(); Mat Y = new Mat();
            //InputArray arr = InputArray.Create<float>(new float[3, 3] { { -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 } });
            //Cv2.Filter2D(mat_gray,X , -1, arr, new Point(-1, -1), 0);
            //InputArray arr_convert = InputArray.Create<float>(new float[3, 3] { { -1, 0, -1 }, { -2, 0, 2 }, { -1, 0, 1 } });
            //Cv2.Filter2D(mat_gray, Y, -1, arr, new Point(-1, -1), 0);
            
            
            //sobel边缘
            //-----------这里开始转变为16位运算-------------
            Cv2.Sobel(mat_gray, X, MatType.CV_16S, 1, 0, 3,1,0,BorderTypes.Replicate);
            Cv2.Sobel(mat_gray, Y, MatType.CV_16S, 0, 1, 3,1,0,BorderTypes.Replicate);
            //GetMatData.getData(X); 
            //GetMatData.getData(Y);

            int width = X.Cols; int heigth = Y.Rows;
            //-------double型数据的对应像素深度是64F---------
            var output = new Mat(X.Size(),MatType.CV_64F);

            var indexer_x = X.GetGenericIndexer<Int16>();
            var indexer_y = Y.GetGenericIndexer<Int16>();
            var indexer_op = output.GetGenericIndexer<double>();
            //算术平均
            for (int index = 0; index < heigth ; index++)
            {
                for (int index_y = 0; index_y < width; index_y++)
                {
                    Int16 Gx = indexer_x[index,index_y];
                    Int16 Gy = indexer_y[index,index_y];

                    double v1 = Math.Pow(Gx, 2);
                    double v2 = Math.Pow(Gy, 2);
                    double val = Math.Sqrt(v1 + v2);

                    indexer_op[index, index_y] = val;
                }
            }
            //var ss =indexer_op[0, 0];

            Cv2.GaussianBlur(output,output,new OpenCvSharp.Size(31,31),11);
            //Cv2.ImShow("te", output); Cv2.WaitKey(0);
            return output;
        }

    }

到这里基本完成了图像的局部提取，下面进行一下分区的对比提取。
这部分我是这样理解的，比如十张局部扫描图，根据像素的梯度变化可以将清晰处与模糊处区分开来，sobel可以很好的将边缘提取出来，经过平滑处理形成分区。
之后十张图相当于MN10 的矩阵，根据像素的梯度变化，每个像素取最大值可以准确提取这部分图像的清晰部分。（这里一个理解是实际上清晰部分的梯度变化较模糊处大，梯度值实际上可以表现为亮度的大小）
像素对比处代码如下：

        public static Mat id_Mat (Mat[]coll)
        {
            int heigth = coll[0].Rows;
            int width = coll[0].Cols;
            
            Mat max_id = new Mat(coll[0].Size(),MatType.CV_8U);
            var indexer_id = max_id.GetGenericIndexer<byte>();
            //int ss = max_id.At<double>(10, 10);
            //
            

            //注意像素深度的设置，数据格式的统一
            Mat mat1 = coll[0];
            var indexer_pre=mat1.GetGenericIndexer<double>();
            for (int num = 1; num < coll.Length; num++)
            {
                var mat2 = coll[num];
                var indexer = mat2.GetGenericIndexer<double>();
                for (int index = 0; index < heigth ; index++)
                {
                    for (int index_y = 0; index_y < width; index_y++)
                    {
                        double G1 = indexer_pre[index,index_y];
                        double G2 = indexer[index, index_y];
                        if (G1 <= G2)
                        {
                            double G_double = (double)G2;
                            indexer_pre[index, index_y] = G_double;
                            indexer_id[index, index_y] = (byte)num;
                        }
                    }
                }
            }
            return max_id;
        }

一点说明，这里为了后续图像合成的方便，输出mat max_id实际是每个像素选取的最大值所属的图像编号。
比如这样的：

1	2
1	2

左上的像素取图片1中对应像素的值。

最后就是填像素值合成了，如下：

    class Merge
    {   //ID点阵选择相应ID图像填色
        public static Mat ImMerge(Mat IDIm,Mat[]Coll_Ori)
        {
            Mat ImMer = new Mat(Coll_Ori[0].Size(), Coll_Ori[0].Type());
            var indexer_mer=ImMer.GetGenericIndexer<Vec3b>();
            var indexer_id = IDIm.GetGenericIndexer<byte>();

            int heigth = IDIm.Rows; int width = IDIm.Cols;
            for (int index=0;index<Coll_Ori.Length;index++)
            {
                for (int x = 0; x < heigth; x++)
                {
                    for (int y = 0; y < width; y++)
                    {
                        int val_ID = indexer_id[x, y];
                        if (val_ID == index) 
                        {
                            var Ori_indexer = Coll_Ori[index].GetGenericIndexer<Vec3b>();
                            indexer_mer[x, y] = Ori_indexer[x, y];
                        }
                        else { continue; }
                    }
                }
            }
            return ImMer;
        }
    }

最后的输出图像如下：
例子1，图有点大，截个屏吧！

例子2

总的来说算法的处理效果是不错的，速度上也可以，毕竟C#还是不太适合做算法。我看网上基于C#的这方面代码还没有，希望对大家有一定的价值！