c#数字图像处理（十三）图像开运算与闭运算

最新推荐文章于 2022-11-09 17:22:55 发布
最新推荐文章于 2022-11-09 17:22:55 发布
阅读量255 收藏
点赞数
文章标签： 人工智能 c# runtime
原文链接：http://www.cnblogs.com/dearzhoubi/p/8711000.html
版权

图像开运算与闭运算定义

二值图像开运算的数学表达式为:

g(x, y)=open[f(x, y ), B]=dilate{erode[f(x, y),B],B}

二值图像的开运算事实上就是先作腐蚀运算,再作膨胀运算。

二值图像闭运算的数学表达式为:

g(x, y)=close[f(x, y ), B]=erode{dilate[f(x, y),B],B}

二值图像的闭运算事实上就是先作膨胀运算,再作腐蚀运算

        private void opening_Click(object sender, EventArgs e)
        {
            if (curBitmap != null)
            {
                struction struForm = new struction();
                struForm.Text = "开运算结构元素";
                if (struForm.ShowDialog() == DialogResult.OK)
                {
                    Rectangle rect = new Rectangle(0, 0, curBitmap.Width, curBitmap.Height);
                    System.Drawing.Imaging.BitmapData bmpData = curBitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, curBitmap.PixelFormat);
                    IntPtr ptr = bmpData.Scan0;
                    int bytes = curBitmap.Width * curBitmap.Height;
                    byte[] grayValues = new byte[bytes];
                    Marshal.Copy(ptr, grayValues, 0, bytes);

                    byte flagStru = struForm.GetStruction;

                    byte[] temp1Array = new byte[bytes];
                    byte[] tempArray = new byte[bytes];
                    for (int i = 0; i < bytes; i++)
                    {
                        tempArray[i] = temp1Array[i] = 255;
                    }

                    switch (flagStru)
                    {
                        case 0x11:
                            //腐蚀运算
                            for (int i = 0; i < curBitmap.Height; i++)
                            {
                                for (int j = 1; j < curBitmap.Width - 1; j++)
                                {
                                    if (grayValues[i * curBitmap.Width + j] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 1] == 0)
                                    {
                                        temp1Array[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            //膨胀运算
                            for (int i = 0; i < curBitmap.Height; i++)
                            {
                                for (int j = 1; j < curBitmap.Width - 1; j++)
                                {
                                    if (temp1Array[i * curBitmap.Width + j] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 1] == 0)
                                    {
                                        tempArray[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            break;
                        case 0x21:
                            //腐蚀运算
                            for (int i = 0; i < curBitmap.Height; i++)
                            {
                                for (int j = 2; j < curBitmap.Width - 2; j++)
                                {
                                    if (grayValues[i * curBitmap.Width + j] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 2] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 2] == 0)
                                    {
                                        temp1Array[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            //膨胀运算
                            for (int i = 0; i < curBitmap.Height; i++)
                            {
                                for (int j = 2; j < curBitmap.Width - 2; j++)
                                {
                                    if (temp1Array[i * curBitmap.Width + j] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 2] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 2] == 0)
                                    {
                                        tempArray[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            break;
                        case 0x12:
                            //腐蚀运算
                            for (int i = 1; i < curBitmap.Height - 1; i++)
                            {
                                for (int j = 0; j < curBitmap.Width; j++)
                                {
                                    if (grayValues[i * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j] == 0)
                                    {
                                        temp1Array[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            //膨胀运算
                            for (int i = 1; i < curBitmap.Height - 1; i++)
                            {
                                for (int j = 0; j < curBitmap.Width; j++)
                                {
                                    if (temp1Array[i * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j] == 0)
                                    {
                                        tempArray[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            break;
                        case 0x22:
                            //腐蚀运算
                            for (int i = 2; i < curBitmap.Height - 2; i++)
                            {
                                for (int j = 0; j < curBitmap.Width; j++)
                                {
                                    if (grayValues[i * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 2) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 2) * curBitmap.Width + j] == 0)
                                    {
                                        temp1Array[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            //膨胀运算
                            for (int i = 2; i < curBitmap.Height - 2; i++)
                            {
                                for (int j = 0; j < curBitmap.Width; j++)
                                {
                                    if (temp1Array[i * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 2) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 2) * curBitmap.Width + j] == 0)
                                    {
                                        tempArray[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            break;
                        case 0x14:
                            //腐蚀运算
                            for (int i = 1; i < curBitmap.Height - 1; i++)
                            {
                                for (int j = 1; j < curBitmap.Width - 1; j++)
                                {
                                    if (grayValues[i * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 1] == 0)
                                    {
                                        temp1Array[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            //膨胀运算
                            for (int i = 1; i < curBitmap.Height - 1; i++)
                            {
                                for (int j = 1; j < curBitmap.Width - 1; j++)
                                {
                                    if (temp1Array[i * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 1] == 0)
                                    {
                                        tempArray[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            break;
                        case 0x24:
                            //腐蚀运算
                            for (int i = 2; i < curBitmap.Height - 2; i++)
                            {
                                for (int j = 2; j < curBitmap.Width - 2; j++)
                                {
                                    if (grayValues[i * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 2) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 2) * curBitmap.Width + j] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 2] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 2] == 0)
                                    {
                                        temp1Array[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            //膨胀运算
                            for (int i = 2; i < curBitmap.Height - 2; i++)
                            {
                                for (int j = 2; j < curBitmap.Width - 2; j++)
                                {
                                    if (temp1Array[i * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 2) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 2) * curBitmap.Width + j] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 2] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 2] == 0)
                                    {
                                        tempArray[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            break;
                        case 0x18:
                            //腐蚀运算
                            for (int i = 1; i < curBitmap.Height - 1; i++)
                            {
                                for (int j = 1; j < curBitmap.Width - 1; j++)
                                {
                                    if (grayValues[i * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j + 1] == 0)
                                    {
                                        temp1Array[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            //膨胀运算
                            for (int i = 1; i < curBitmap.Height - 1; i++)
                            {
                                for (int j = 1; j < curBitmap.Width - 1; j++)
                                {
                                    if (temp1Array[i * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j + 1] == 0)
                                    {
                                        tempArray[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            break;
                        case 0x28:
                            //腐蚀运算
                            for (int i = 2; i < curBitmap.Height - 2; i++)
                            {
                                for (int j = 2; j < curBitmap.Width - 2; j++)
                                {
                                    if (grayValues[(i - 2) * curBitmap.Width + j - 2] == 0 &&
                                        grayValues[(i - 2) * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[(i - 2) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 2) * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[(i - 2) * curBitmap.Width + j + 2] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j - 2] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[(i - 1) * curBitmap.Width + j + 2] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 2] == 0 &&
                                        grayValues[i * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[i * curBitmap.Width + j + 2] == 0 &&
                                        grayValues[(i + 2) * curBitmap.Width + j - 2] == 0 &&
                                        grayValues[(i + 2) * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[(i + 2) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 2) * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[(i + 2) * curBitmap.Width + j + 2] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j - 2] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j - 1] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j + 1] == 0 &&
                                        grayValues[(i + 1) * curBitmap.Width + j + 2] == 0)
                                    {
                                        temp1Array[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            //膨胀运算
                            for (int i = 2; i < curBitmap.Height - 2; i++)
                            {
                                for (int j = 2; j < curBitmap.Width - 2; j++)
                                {
                                    if (temp1Array[(i - 2) * curBitmap.Width + j - 2] == 0 ||
                                        temp1Array[(i - 2) * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[(i - 2) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 2) * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[(i - 2) * curBitmap.Width + j + 2] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j - 2] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[(i - 1) * curBitmap.Width + j + 2] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 2] == 0 ||
                                        temp1Array[i * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[i * curBitmap.Width + j + 2] == 0 ||
                                        temp1Array[(i + 2) * curBitmap.Width + j - 2] == 0 ||
                                        temp1Array[(i + 2) * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[(i + 2) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 2) * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[(i + 2) * curBitmap.Width + j + 2] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j - 2] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j - 1] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j + 1] == 0 ||
                                        temp1Array[(i + 1) * curBitmap.Width + j + 2] == 0)
                                    {
                                        tempArray[i * curBitmap.Width + j] = 0;
                                    }

                                }
                            }
                            break;
                        default:
                            MessageBox.Show("错误的结构元素！");
                            break;
                    }


                    grayValues = (byte[])tempArray.Clone();

                    System.Runtime.InteropServices.Marshal.Copy(grayValues, 0, ptr, bytes);
                    curBitmap.UnlockBits(bmpData);
                }

                Invalidate();
            }
        }

 

        #region 关于图像尺寸的说明

        //本代码只能处理8位深度的512*512图像。可自行修改，如修改3位水平方向结构元素代码：

        //01修改成如下代码即可处理任意尺寸的8位深度的图像
        //int bytes = bmpData.Stride * curBitmap.Height;
        //for (int i = 0; i < curBitmap.Height; i++)
        //{
        //    for (int j = 1; j < curBitmap.Width - 1; j++)
        //    {
        //        if (grayValues[i * bmpData.Stride + j] == 0 &&
        //            grayValues[i * bmpData.Stride + j + 3] == 0 &&
        //            grayValues[i * bmpData.Stride + j - 1] == 0)
        //        {
        //            tempArray[i * bmpData.Stride + j] = 0;
        //            tempArray[i * bmpData.Stride + j + 1] = 0;
        //            tempArray[i * bmpData.Stride + j + 2] = 0;
        //        }
        //    }
        //}

        //for (int i = 0; i < curBitmap.Height; i++)
        //{
        //    for (int j = 1; j < curBitmap.Width - 1; j++)
        //    {
        //        if (grayValues[i * bmpData.Stride + j] == 0 ||
        //            grayValues[i * bmpData.Stride + j + 3] == 0 ||
        //            grayValues[i * bmpData.Stride + j - 1] == 0)
        //        {
        //            tempArray[i * bmpData.Stride + j] = 0;
        //            tempArray[i * bmpData.Stride + j + 1] = 0;
        //            tempArray[i * bmpData.Stride + j + 2] = 0;
        //        }
        //    }
        //}

        //02修改成如下代码即可处理任意尺寸的24位深度的图像
        //int bytes = bmpData.Stride * curBitmap.Height;
        //for (int i = 0; i < curBitmap.Height; i++)
        //{
        //    for (int j = 4; j < curBitmap.Width * 3 - 3; j += 3)
        //    {
        //        if (grayValues[i * bmpData.Stride + j] == 0 &&
        //            grayValues[i * bmpData.Stride + j + 3] == 0 &&
        //            grayValues[i * bmpData.Stride + j - 1] == 0)
        //        {
        //            tempArray[i * bmpData.Stride + j] = 0;
        //            tempArray[i * bmpData.Stride + j + 1] = 0;
        //            tempArray[i * bmpData.Stride + j + 2] = 0;
        //        }
        //    }
        //}

        //for (int i = 0; i < curBitmap.Height; i++)
        //{
        //    for (int j = 1; j < curBitmap.Width - 1; j++)
        //    {
        //        if (grayValues[i * bmpData.Stride + j] == 0 ||
        //            grayValues[i * bmpData.Stride + j + 3] == 0 ||
        //            grayValues[i * bmpData.Stride + j - 1] == 0)
        //        {
        //            tempArray[i * bmpData.Stride + j] = 0;
        //            tempArray[i * bmpData.Stride + j + 1] = 0;
        //            tempArray[i * bmpData.Stride + j + 2] = 0;
        //        }
        //    }
        //}
        #endregion

 

转载于:https://www.cnblogs.com/dearzhoubi/p/8711000.html

weixin_30542079
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数字图像处理----开运算与闭运算
qq_42598935的博客
10-10 2489
参考博文 1.图像开运算（先腐蚀，再膨胀） 图像开运算是图像依次经过腐蚀、膨胀处理后的过程。图像被腐蚀后，去除了噪声，但是也压缩了图像（原图中的前景也就变小了）；接着对腐蚀过的图像进行膨胀处理，可以去除噪声，并保留原有图像（前景恢复，但是去除了噪声）。 如上图所示，先经过腐蚀，再膨胀，原图的内容不变，但是噪点都被去除了。 2 图像闭运算(先膨胀，后腐蚀) 图像闭运算是图像依次经过膨胀、腐蚀处理后的过程。图像先膨胀，后腐蚀，它有助于关闭前景物体内部的小孔，或物体上的小黑点。如下图所示： ..
C#实现图像腐蚀运算、膨胀运算、开运算与闭运算、击中击不中变换
12-10
实现数学形态学对二值图像的各种处理，如腐蚀运算、膨胀运算、开运算、闭运算和击中击不中变换等。
数字图像处理java语句闭运算_【数字图像处理】图像开运算与闭运算
weixin_42512723的博客
03-02 476
图像开启与闭合图像开运算与闭运算与膨胀和腐蚀运算有关，由膨胀和腐蚀两个运算的复合与集合操作(并、交、补等)组合成的所以运算构成。开运算与闭运算依据腐蚀和膨胀的不可逆性，演变而来。开运算：先对图像腐蚀后膨胀闭运算：先对图像膨胀后腐蚀注意：使用同一个结构元素。图像开运算开运算：能够去除孤立的小点、毛刺和小桥(即连通两块区域的小点)，消除小物体、平滑较大物体的边界，同时并不明显改变其面积。不过这一恢复不...
数字图像处理(13): 形态学处理——图像开运算与图像闭运算
热门推荐
TechArtisan6的博客
05-03 4万+
目录 1 图像开运算(先腐蚀，后膨胀) 1.1 基本原理 1.2 代码示例 2 图像闭运算(先膨胀，后腐蚀) 2.1 基本原理 2.2 代码示例 3 图像梯度运算(膨胀—腐蚀) 3.1 基本原理 3.2 代码示例 参考资料 前面介绍了 形态学处理——图像腐蚀与图像膨胀，图像膨胀会扩大一幅图像的组成部分，而图像腐蚀会缩小一幅图像的组成部分。下面将继续介绍形态学处理中的开...
Emgu CV4图像处理之膨胀和腐蚀、梯度计算、开闭运算14(C#)
zxy13826134783的博客
11-09 775
4 添加项目引用Emgu.CV.dll、Emgu.CV.Platform.NetFramework.dll、System.Drawing.dll和System.Runtime.InteropServices.RuntimeInformation.dll。3的矩阵，卷积计算后，该像素点的值等于以该像素点为中心的3*3范围内的最大值。borderType：边界模式，一般为默认Emgu.CV.CvEnum.BorderType.Default。图中的128=Max(128,0,0,0,126,24,0,0,0)
基于c#的数字图像处理源代码(VS2021)
11-25
内容有文件（打开、保存、退出）、点处理（彩色转灰阶、图像取反、图像...开运算、闭运算）、彩色图像处理（均值滤波、中值滤波、高斯滤波、Roberts算子、Laplace算子、Sobel算子、Prewitt算子、伪彩色）、图像操作...
c# 数字图像处理：程序代码 + 课件PPT
03-26
C# 图像处理程序设计：程序代码 + 课件PPT ...5 图像形态学处理（腐蚀、膨胀、开运算、闭运算、击中、击不中） 6 图像分割（阈值分割、图像生长） 7 彩色图像处理 等、、、 不一一列举了，大家自己下载看吧~~
基于C#的基础数字图像处理（Visual Studio）
06-26
内容有文件（打开、保存、退出）、点处理（彩色转灰阶、图像取反、图像...开运算、闭运算）、彩色图像处理（均值滤波、中值滤波、高斯滤波、Roberts算子、Laplace算子、Sobel算子、Prewitt算子、伪彩色）、图像操作...
C#数字图像处理算法典型.zip_C#图像_图像处理算法_图像处理经典算法_数字图像处理_边缘检测
07-15
图像处理的基本算法汇总 , 灰度化 , 点运算 , 几何运算 , 边缘检测 , 平滑去噪 ,图像分割 ,彩色图像处理等 . C#语言编写的图像处理算法集合 .
基于C#的数字图像处理软件, 实现了点运算, 代数运算, 集合运算, 图像增强, 图像分割等算法.zip
最新发布
04-15
包括C++、Java、python、web、C#、EDA等项目的源码。 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】：项目具有较高的...
winform(c#)集成所有opencv功能demo
04-26
1.集成opencv。调用opencvsharp包含所有实例 2.集成打开本地视频、网络摄像头、本地摄像头 3.利用opencv处理图片 4.简单的图片识别 5.直接编译使用
C#概述笔记（2021-1223）
weixin_44119674的博客
12-23 639
C#的五大数据类型： 1）类（Class; 如Windows,Form,Console,String,etc）； 2）结构体（Structures; 如int32,int64,Single,Double,etc）； 3）枚举（Enumeration; 如Horizontal,Alignment,Visibility ,etc）； 4）接口（interfaces）； 5）委托（Delegates）; C# -功能键： 1、工具–>选项—>文本编辑器–>所有语言–>常规–>行号；
C# EMGU 3.4.1学习笔记（三）综合示例：形态学滤波（腐蚀/膨胀、开运算/闭运算、顶帽运算/黑帽运算）
FLY的博客
09-03 1932
以下是《OpenCV3编程入门》中6.4.9的示例程序的C# + EMGU 3.4.1版： 有任何问题或疑问，欢迎交流探讨。 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Lin...
Win8Metro(C#)数字图像处理--2.24二值图像闭运算
Trent1985的专栏
04-08 1181
[函数名称] 二值图像闭运算函数CloseOperateProcess(WriteableBitmap src) [算法说明]   闭运算就是先进性一次膨胀后进行一次腐蚀。算法过程如公式2-(28)。 [函数代码]         ///         /// Close operate process.         ///
OpenCV与EmguCV中的形态学滤波
lc__________的博客
06-28 7397
形态学（morphology）一词通常表示生物学的一个分支，该分支主要研究动植物的形态和结构。而我们图像处理中指的形态学，往往表示的是数学形态学。下面一起来了解数学形态学的概念。数学形态学是由一组形态学的代数运算子组成的，它的基本运算有4个： 膨胀、腐蚀、开启和闭合， 它们在二值图像和灰度图像中各有特点。简单来讲，形态学操作就是基于形状的一系列图像处理操作。OpenCV为进行图像的形态学变换提供了
OpenCV学习十二：morphologyEx，图像的开运算、闭运算、顶帽运算、黑帽运算以及形态学梯度
Thomas会写字
02-14 1万+
开运算---先腐蚀，后膨胀。去除图像中小的亮点（CV_MOP_OPEN）；闭运算---先膨胀，后腐蚀。去除图像中小的暗点（CV_MOP_CLOSE）；形态学梯度---原图膨胀图像 — 原图腐蚀图像（CV_MOP_GRADIENT）；顶帽---原图像 — 原图像开操作。保留小亮点，去除大亮点。（CV_MOP_TOPHAT）；黑帽---原图像闭操作 — 原图像（CV_MOP_BLACKHAT）；api...
EmguCV Image类中的函数（二）使用MorphologyEx进行更多的变换
k
08-21 9474
MorphologyEx中所有的变换如下图所示 调用方法： Mat aaa = CvInvoke.GetStructuringElement(Emgu.CV.CvEnum.ElementShape.Rectangle, new Size(5, 5), new Point(2, 2)); imageBox1.Image = a.Convert().Morpho
C# emgu 多个算子边缘检测
qq_42391680的博客
11-20 215
private void button6_Click(object sender, EventArgs e) { //简单图像处理 Mat src = CvInvoke.Imread(ImgPath, ImreadModes.Color); CvInvoke.CvtColor(src, src, ColorCo...
c#数字图像处理算法典型实例
07-13
是一个介于C和D之间的字母，属于拉丁字母表的第三个字母。在英语中，C通常发音为/k/。C是一个非常常见的字母，它在很多单词中都有着重要的作用。比如，在英语中，C通常与元音字母a、o、u结合在一起形成不同的音节，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值