精华内容
下载资源
问答
  • 膨胀腐蚀算法

    2019-11-15 19:08:26
    膨胀腐蚀算法

    膨胀腐蚀算法


    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • PAGE / NUMPAGES 灰度图像的腐蚀算法和细化算法C#代码 ? 最近做一些图像处理需要将图像中的一些像素过滤一下有网友给提了个名词腐蚀算法我不是学图像学的乍一听觉得很神奇后来从网上收集了一些VC代码研究了一下发现...
  • 膨胀与腐蚀算法

    万次阅读 2017-04-17 11:00:05
    膨胀与腐蚀算法 对图像处理有所了解的人都知道图像的形态学处理里最为基础的膨胀和腐蚀算法。二值图像即只有黑白两种颜色组成的图像,一般的白色为内容,黑色为背景。其实简单点理解二值图像的膨胀与腐蚀,腐蚀即...

    膨胀与腐蚀算法

    对图像处理有所了解的人都知道图像的形态学处理里最为基础的膨胀和腐蚀算法。二值图像即只有黑白两种颜色组成的图像,一般的白色为内容,黑色为背景。其实简单点理解二值图像的膨胀与腐蚀,腐蚀即是删除对象边界某些像素,也就是让白色的区域瘦一圈;而膨胀则是给图像中的对象边界添加像素,即让白色的区域胖上一圈。而这个“圈”的大小,则是由参数来指定的。下面的表展示了一幅图像经过膨胀和腐蚀算法的结果。可以看出膨胀让白色区域大了一圈,白色区域若有较小的黑色洞,则洞被填上。

    原图 腐蚀结果 膨胀结果

    腐蚀膨胀的算法原理并不复杂,而且网上有太多的文章都着重于介绍算法的原理思路,对用具体代码实现算法的方式讨论的不多,因而本文专注于几种实现膨胀腐蚀算法的方法。本文介绍了几种不同的腐蚀膨胀算法的实现,每一种实现都各有特点,今后若有更多的方法,也会继续更新加入至本文中。

    结构元素与窗口形态

    在介绍算法逻辑之前,有必要先介绍跟腐蚀膨胀算法关系密切的结构元素。结构元素是形态学的基本算子,合理选取结构元素直接影响图像处理的效果和质量。结构元素的选择在于结构元素的形状和尺寸。结构元素可以有不同的形状,圆形、正方形、菱形、六边形、线段形都是可以选择的形状。圆形结构元素,由于各向同性,因此可以得到与方向无关的运算结果,正方形、菱形可以看作是圆盘形的变异。不同形状的结构元素运算结果会有差异,应针对待处理图像的几何形状进行选择。下表对比了正方形,圆形和正菱形三种结构元素形态。

    预览
    ElementSize 121 98 61
    WindowSize 11×11 (r=5) 11×11 (r=5) 11×11 (r=5)
    非空点个数计算方式 (2*r+1) 2 pi*(r+0.5) 2 (2*r+1) 2 /2

    在算法实现过程中,往往会将卷积窗口中所有像素相对中心像素的偏移存在一个数组之中,这样在对不规则形状的卷积窗口进行处理时,可以不重复判断结构元素中哪些位置为有效位置,能减少计算次数。 在实现之前首先贴上基本数据结构的实现,其中visit_count用来记录像素的访问次数:

    #define byte unsigned char
    struct IntDouble
    {
        int X;
        int Y;
        IntDouble(int x,int y)
        {
            this->X=x;
            this->Y=y;
        }
        IntDouble()
        {
            this->X=0;
            this->Y=0;
        }
    };
    class Bitmap2d
    {
    private:
        byte* data;
        int width;
        int height;
    public:
        int visit_count;
        Bitmap2d(int width,int height,byte v)
        {
            this->data=new byte[width*height];
            memset(data,v,width*height*sizeof(byte));
            this->width=width;
            this->height=height;
            this->visit_count=0;
        }
        Bitmap2d(Bitmap2d& bitmap)
        {
            this->width=bitmap.Width();
            this->height=bitmap.Height();
            this->data=new byte[width*height];
            memcpy(this->data,bitmap.data,sizeof(byte)*Length());
            this->visit_count=0;
        }
        ~Bitmap2d()
        {
            delete[] data;
        }
        inline byte GetValue(int x,int y)
        {
            visit_count++;
            return data[x+y*width];
        }
        inline void SetValue(int x,int y,byte v)
        {
            visit_count++;
            data[x+y*width]=v;
        }
        inline int Width()
        {
            return width;
        }
        inline int Height()
        {
            return height;
        }
        inline int Length()
        {
            return width*height;
        }
        inline bool InRange(int x,int y)
        {
            return x>=0&&x<width&&y>=0&&y<height;
        }
        void ReadRaw(const char* filename)
        {
            FILE* file=fopen(filename,"rb");
            fread(data,sizeof(byte),Length(),file);
            fclose(file);
        }
        void SaveRaw(const char* filename)
        {
            FILE *const file = fopen(filename,"wb");
            fwrite(data,sizeof(byte),Length(),file);
            fclose(file);
        }
    };

    实现思路1—根据定义直接算

    首先最为简单的思路是按算法基本原理直接正向求取输出图片的像素值:

    • 膨胀:对于输出图像的所有像素点P,调查原图像中对应窗口中的像素集合S,若S中至少有一个255,则P为255。
    • 腐蚀:对于输出图像的所有像素点P,调查原图像中对应窗口中的像素集合S,若S中至少有一个0,则P为0。

    该算法的腐蚀实现函数(膨胀的类似,就不重复贴,代码工程里有)如下:

    Bitmap2d* Execute()
    {
        Bitmap2d* newBmp=new Bitmap2d(bmp.Width(),bmp.Height(),0);
        for(int j=0;j<bmp.Height();j++)
        {
            for(int i=0;i<bmp.Width();i++)
            {
                if(HasBlackInWindow(this->bmp,i,j))
                    newBmp->SetValue(i,j,0);
                else
                    newBmp->SetValue(i,j,255);
            }
        }
        return newBmp;
    }
    bool HasBlackInWindow(Bitmap2d& bmp,int i,int j)
    {
        for(size_t k=0;k<winOffsets.size();k++)
        {
            int tx=i+winOffsets[k].X;
            int ty=j+winOffsets[k].Y;
            if(!bmp.InRange(tx,ty))
                continue;
            if(bmp.GetValue(tx,ty)==0)
            {
                return true;
            }
        }
        return false;
    }

    膨胀腐蚀算法的主要时间开销来至于对像素的访问,从上述实现不难得该算法对于width*height的位图访问像素的次数为width*height*elementSize。事实上这是实现腐蚀膨胀算法最直接但也是最慢的方式。 下图是Engine数据的一个切片二值化之后分别用正方形、圆形和菱形为结构元素膨胀和腐蚀的效果图:

    腐蚀(正方形) 腐蚀(圆形) 腐蚀(菱形)
    原图预览 膨胀(正方形) 膨胀(圆形) 膨胀(菱形)

    实现思路2—跳过一些内部区域

    考虑到思路1的算法逻辑耗费在访问黑色区域和白色区域内部的时间较多,我们可以考虑只对黑白交界的边界考察窗口像素。这样的过程我们就可以想象成一把具有尺寸的刷子,膨胀算法刷子为白色,腐蚀算法刷子为黑色,然后让刷子在黑白交界的地方刷过,这样的过程生成的结果等价于思路1的结果。

    其优化的部分是针对远离边界的内部区域的涂刷,这样就能很大程度上减少像素的访问次数。不难想象出,对远离边界的内部区域的涂刷是不起效果的,这就是思路2对思路1改进的主要原因。 按思路2实现的算法代码如下:

    Bitmap2d* Execute2()
    {
        Bitmap2d* newBmp=new Bitmap2d(bmp);
        for(int j=0;j<bmp.Height();j++)
        {
            for(int i=0;i<bmp.Width();i++)
            {
                if(bmp.GetValue(i,j)==0&&HasWhiteAdjacencyPixel(i,j))
                {
                    SetWindowValue(*newBmp,i,j,0);
                }
            }
        }
        return newBmp;
    }
    bool HasWhiteAdjacencyPixel(int i,int j)
    {
        if(i>0&&bmp.GetValue(i-1,j)==255)
            return true;
        if(i<bmp.Width()-1&&bmp.GetValue(i+1,j)==255)
            return true;
        if(j>0&&bmp.GetValue(i,j-1)==255)
            return true;
        if(j<bmp.Height()-1&&bmp.GetValue(i,j+1)==255)
            return true;
        return false;
    }
    void SetWindowValue(Bitmap2d& bmp,int i,int j,byte v)
    {
        for(size_t k=0;k<winOffsets.size();k++)
        {
            int tx=i+winOffsets[k].X;
            int ty=j+winOffsets[k].Y;
            if(!bmp.InRange(tx,ty))
                continue;
            bmp.SetValue(tx,ty,v);
        }
    }

    基于结构元素分解的算法

    对于一些具有规则形状的结构元素,可以利用矩阵分解的原理降低计算次数,例如3*3的正方形结构元素,等价于一个3*3的矩阵,这个矩阵可以为解为{1,1,1}与{1,1,1} -1 的乘积。这样使用3*3的矩阵对图像进行卷积等价于先使用{1,1,1}进行卷积,再将结果使用{1,1,1} -1 进行卷积。

    由于膨胀腐蚀算法本质上属于卷积的一种特殊形式,这样,正方形结构元素的膨胀腐蚀可以使用如下的方式实现:

    Bitmap2d* Execute4()
    {
        Bitmap2d* newBmp=new Bitmap2d(bmp);
        Bitmap2d* newBmp2=new Bitmap2d(bmp);
        if(this->mode==SQUARE)
        {
            winOffsets.clear();
            for (int i = 0; i < 2 * radius + 1; i++)
            {
                IntDouble t(i-radius,0);
                this->winOffsets.push_back(t);
            }
            for(int j=0;j<bmp.Height();j++)
            {
                for(int i=0;i<bmp.Width();i++)
                {
                    if(HasBlackInWindow(this->bmp,i,j))
                        newBmp->SetValue(i,j,0);
                    else
                        newBmp->SetValue(i,j,255);
                }
            }
            winOffsets.clear();
            for (int j = 0; j < 2 * radius + 1; j++)
            {
                IntDouble t(0,j-radius);
                this->winOffsets.push_back(t);
            }
            for(int j=0;j<newBmp->Height();j++)
            {
                for(int i=0;i<newBmp->Width();i++)
                {
                    if(HasBlackInWindow(*newBmp,i,j))
                        newBmp2->SetValue(i,j,0);
                    else
                        newBmp2->SetValue(i,j,255);
                }
            }
        }
        newBmp2->visit_count+=newBmp->visit_count;
        delete newBmp;
        return newBmp2;
    }

    经过测试可以知道这种方式可以大大减少像素访问次数,以k*k的结构元素腐蚀n*n的图像为例,用思路1的方法需要至少访问k 2 n 2 次像素,经过分解再处理两次只需要2kn 2 次访问。这个思路的详细数学原理可以参考 链接 。 

    下图是分解的方法与思路1的方法的结果对比,可以看出这两个算法的结果确实是完全等价的。

    思路1 分解的方法

    基于曼哈顿距离的算法

    上述思路1思路2可以适用于任意形状的处理窗口。还有一种基于曼哈顿距离的实现方式,来源于 链接 ,这种方式主要是实现了基于菱形窗口的膨胀腐蚀。这里简单介绍一下曼哈顿距离,曼哈顿距离(Manhattan Distance)是种使用在几何度量空间的几何学用语,用以标明两个点在标准坐标系上的绝对轴距总和。其计算公式为:

    这个距离简单点理解就是“格子距离”,如下图所示:A到B的走格子的最少步数是4,那么AB的曼哈顿距离就是4。

    设我们需要膨胀的图像是下图左这样一个背景为0,内容为1的二值图像。假如我们能够求得所有0像素到离自己最近的1像素的距离的话,我们便做成了一张曼哈顿距离图(下图右)。曼哈顿距离图中像素标的数字代表该像素在左图中寻找最近的1的曼哈顿距离。假如这个像素在左图中本来就是1,则该像素处的曼哈顿距离为0。可以看出,01边界处的0像素的曼哈顿距离较小,而原理边界的0像素曼哈顿距离很大。

    原图 原图得到的曼哈顿距离图

    对于二值图像I,若能够一定处理计算得到他的曼哈顿距离图D,则想求取他的菱形结构元素膨胀结果会非常容易。不难想到,对D进行一个阈值化既可以达到结果。若将曼哈顿图D中曼哈顿距离大于等于1与小于1的像素区分开,则等于原二值图像;若将曼哈顿距离大于等于2与小于2的像素区分开,则等价于对原二值图像进行一个尺寸为1的菱形元素膨胀;若将曼哈顿距离大于等于k(k>1)与小于k的像素区分开,则等价于对原二值图像进行一个尺寸为k的菱形元素膨胀。

    而腐蚀同样可以使用这个思路来完成,前面介绍的曼哈顿距离图是适用与膨胀的,求取的是每个0像素与距离最近的1的距离。在腐蚀的场合下,我们可以求取所有1像素与距离最近的0像素距离的曼哈顿图,这样再进行阈值化,也就完成了腐蚀操作。 利用曼哈顿图的好处还体现在需要使用对很多组不同大小的结构元素对相同图像进行膨胀或腐蚀的场合。一旦计算出曼哈顿距离图,就可“一次预处理,多次复用”,预处理的开销只在初次处理产生,之后的所有操作都是阈值化的过程,而阈值化我们知道只需要width*height的访问开销。

    所以问题的关键在与如何实现对二值图像I求取其曼哈顿距离图D。这里以求取膨胀的曼哈顿距离图为例进行说明。其实我们可以利用一种类似于动态规划的思想来解决这个问题。不难发现这个问题是能够分解为规模更小并且可以复用的小型子问题的和。这基于如下的事实:

    1. 对于所有I中为1的像素,D中他们为0。因为他们自己就是1像素显然到自己最近,所以不需要走格子。
    2. 对于I中的0像素p,若其四邻域像素在D中为d0、d1、d2、d3,则D(p)=min(d0,d1,d2,d3)+1。不难看出p到离其最近的1像素的通路必然经过了其四邻域像素。所以0像素p到最近的1的像素的曼哈顿距离可以基于其四邻域的曼哈顿距离求得。

    要实现这个思路,可以使用递归,但也可以使用更加直接的方式,下面的代码使用两次双循环来求得D。首先每个像素d值默认值为最大值width+height,第一次双循环,对每一个像素实际上是考察了上方和左方的像素,经过这一次循环,其d值不一定正确,仅是能够保证每个像素处的d值是相对与上方和左方的最小值加1;但第二次双循环是逆向,从下方和右方访问像素,依次再改变之前的d值,这样就实现了d值确实为min(d0,d1,d2,d3)+1。

    行序正向赋值,每个像素参考了两个父方向的d值 第二次迭代行序逆向复制,每个像素参考4个方向的d值

    采用这个思路实现的一个演示程序如下(不能跑刷新几次试试..):

    其实现的代码如下:

    class DistenceMap
    {
    private:
        int* data;
        int width;
        int height;
    public:
        int visit_count;
        DistenceMap(int width,int height,int v)
        {
            this->data=new int[width*height];
            for(int i=0;i<width*height;i++)
                data[i]=v;
    
            this->width=width;
            this->height=height;
            this->visit_count=0;
        }
        ~DistenceMap()
        {
            delete[] data;
        }
        inline int GetValue(int x,int y)
        {
            visit_count++;
            return data[x+y*width];
        }
        inline void SetValue(int x,int y,int v)
        {
            visit_count++;
            data[x+y*width]=v;
        }
        inline int Width()
        {
            return width;
        }
        inline int Height()
        {
            return height;
        }
        inline int Length()
        {
            return width*height;
        }
    };
    Bitmap2d* Execute3()
    {
        Bitmap2d* newBmp=new Bitmap2d(bmp);
        DistenceMap* dmap=GetDistenceMap();
        for (int i=0; i<bmp.Width(); i++)
        {
            for (int j=0; j<bmp.Height(); j++)
            {
                byte v=dmap->GetValue(i,j)<=radius?0:255;
                newBmp->SetValue(i,j,v);
            }
        }
        newBmp->visit_count+=dmap->visit_count;
        delete dmap;
        return newBmp;
    }
    DistenceMap* GetDistenceMap()
    {
        DistenceMap* distenceMap=new DistenceMap(this->bmp.Width(),this->bmp.Height(),0);
        for (int i=0; i<bmp.Width(); i++)
        {
            for (int j=0; j<bmp.Height(); j++)
            {
                if (bmp.GetValue(i, j) == 0)
                {
                    distenceMap->SetValue(i,j,0);
                } 
                else
                {
                    distenceMap->SetValue(i,j, bmp.Width()+bmp.Height());
                    if (i>0) 
                        distenceMap->SetValue(i,j,Min(distenceMap->GetValue(i,j),distenceMap->GetValue(i-1,j)+1));
                    if (j>0) 
                        distenceMap->SetValue(i,j,Min(distenceMap->GetValue(i,j), distenceMap->GetValue(i,j-1)+1));
                }
            }
        }
    
        for (int i=bmp.Width()-1; i>=0; i--)
        {
            for (int j=bmp.Height()-1; j>=0; j--)
            {
                if (i+1<bmp.Width())
                    distenceMap->SetValue(i,j,Min(distenceMap->GetValue(i,j), distenceMap->GetValue(i+1,j)+1));
                if (j+1<bmp.Height()) 
                    distenceMap->SetValue(i,j,Min(distenceMap->GetValue(i,j), distenceMap->GetValue(i,j+1)+1));
            }
        }
        return distenceMap;
    }

    总结

    本文介绍的实现方式,思路1和思路2是基本方法,其中思路2是对思路1的极大改进;矩阵分解方法适用于一些特殊形状的结构元素,其核心是把结构元素所代表的矩阵分解成两个更简单的矩阵的乘积,然后再使用这两个更简单的矩阵作为结构元素。这个思路同样能与思路1和2相配合使用;曼哈顿距离法使用一步预处理先计算出曼哈顿距离图,之后再对这个图进行阈值化,等价于使用菱形结构元素进行的膨胀腐蚀的结果,对于需要多次膨胀腐蚀的场合,这个方法非常适用。

    目前先介绍这么多,日后再有好的实现方法,会对本文进行补充。代码工程下载: https://github.com/chnhideyoshi/SeededGrow2d/tree/master/DilateErodeImp

    展开全文
  • C#膨胀腐蚀算法实现(vs2017可用),请在二值图的情况下使用
  • 实现图像的膨胀与腐蚀算法

    千次阅读 2018-08-12 20:01:25
    用C语言实现图像的膨胀与腐蚀算法 经过几次学习opencv源代码,我决定自己动手写一下膨胀与腐蚀算法,如果具体算法原理不明确的话,可以看看前几篇我总结的膨胀腐蚀算法原理: 腐蚀算法 /**********************...

    用C语言实现图像的膨胀与腐蚀算法

    经过几次学习opencv源代码,我决定自己动手写一下膨胀与腐蚀算法,如果具体算法原理不明确的话,可以看看前几篇我总结的膨胀腐蚀算法原理:


    腐蚀算法

    /*****************************************************
    function: achieve the erode algorithm of the binary image,using 3*3 structural elements 
    parameter:
      1 IplImage* img : original image
      2 int *elementArray : 3*3 structural elements
    return: Run code   0: right  -1: error
    *****************************************************/
    //在画图中 理解有中心点的位置,并将结果赋给结构元素中心点所对应的位置,但是在实际的编程中是遍历每一个点(i,j),可以理解为对应结构元素的中心点
    int ErodeYang01(IplImage* srcImg, IplImage* dstImg, int *elementArray)
    {
        int ret = 0;
        int imgHeight, imgWidth;
        int i, j, k, l;
        int rowPosi, colPosi;   //为结构元素在计算图像中的位置 rowPosi:行 colPosi:列
    
        bool isMatch;
    
        if (srcImg == NULL || elementArray == NULL)
            return ret = -1;
    
        imgHeight = srcImg->height;
        imgWidth = srcImg->width;
    
        memset((void*)dstImg->imageData, 0, dstImg->imageSize);    // memset((void*)dstImg->imageData, 255, dstImg->imageSize); 
    
        for (i = 1; i < imgHeight; i++)                             //i,j 都从1开始 是防止逐行扫描时,访问越界,四周留出一个像素的宽度
        {
            for (j = 1; j < imgWidth; j++)
            {
                isMatch = true;
                for (k = 0; k < 3; k++)                             //k,l 为结构元素的遍历
                {
                    for (l = 0; l < 3; l++)
                    {
                        rowPosi = (i - 1 + k)*srcImg->widthStep;
                        colPosi = j - 1 + l;
    
                        if (elementArray[3 * k + l] == -1)  //此点不关心
                            continue;
    
                        if (elementArray[3 * k + l] == 1)  //前景
                        {
                            if (srcImg->imageData[rowPosi + colPosi] != -1)   //opencv中 二值化图结果只是存放了 0 与 -1  但正常理解二值化值应该 0与1 或是 0与255
                            {
                                isMatch = false;
                                break;
                            }
                        }   
                        else
                        {
                            printf("structural elements exist illegal values");
                            return ret = -1;
                        }
    
                    }
    
                }
    
                if (isMatch)
                    dstImg->imageData[i*dstImg->widthStep + j] = 255;   //赋值为图像中位置点
    
            }
        }
    
        return ret;
    }
    

    膨胀算法

    /*****************************************************
    function: achieve the dilate algorithm of the binary image,using 3*3 structural elements
    parameter:
    1 IplImage* img : original image
    2 int *elementArray : 3*3 structural elements
    return: Run code   0: right  -1: error
    *****************************************************/
    int DilateYang(IplImage* img, IplImage* dstImg, int *elementArray /* elementArray[3][3] */)
    {
        int ret = 0;
        int imgHeight, imgWidth;
        int i, j;    //图像循环变量
        int i_, j_;  //结构元素的对称集循环变量
        int k, l;    //结构元素循环变量
    
        uchar temp;
    
        bool isMatch;
    
        if (img == NULL || elementArray == NULL)
            return ret = -1;
    
        imgHeight = img->height;
        imgWidth = img->width;
    
        memset((void*)dstImg->imageData,0,dstImg->imageSize);    //这是模仿程序写的 没确定是否正确 初始化整幅图都是白色
    
        //计算结构元素的对称集 --算法中是利用结构元素的对称集进行后续处理的
        for (i = 0; i < 2; i++)
        {
            for (j = 0; j < 3 - i; j++)
            {
                temp = elementArray[i * 3 + j];
                elementArray[i * 3 + j] = elementArray[(2 - i) * 3 + (2 - j)];
                elementArray[(2 - i) * 3 + (2 - j)] = temp;
            }
        }
    
    
        for (i = 1; i < imgHeight; i++)
        {
            for (j = 1; j < imgWidth; j++)
            {
    
                for (k = 0; k < 3; k++)
                {
                    for (l = 0; l < 3; l++)
                    {
                        int rowImg = (i - 1 + k)*img->widthStep;
                        int colImg = j - l + 1;
    
                        if (elementArray[k * 3 + l] == -1)
                            continue;
    
                        if (elementArray[k * 3 + l] == 1)
                        {
                            //if(img->imageData[rowImg + colImg] != 0)
                            //  printf("%d", img->imageData[rowImg + colImg]);
    
                            if (img->imageData[rowImg + colImg] == -1)   //opencv中 二值化图结果只是存放了 0 与 -1
                            {
                                dstImg->imageData[i*dstImg->widthStep + j] = 255;
                                break;
                            }
    
                        }
                        else
                        {
                            printf("structural elements exist illegal values");
                            return ret = -1;
                        }
                    }
                }
            }
        }
    
        return ret;
    }
    
    展开全文
  • 灰度膨胀和腐蚀算法

    千次阅读 2019-02-22 10:56:32
    灰度腐蚀算法: 1、腐蚀可以使一个孤立的低亮噪音扩大化。 2、可以使用物体的一些低亮度的关键细节丢失。 转自:https://blog.csdn.net/denyz/article/details/50522799?utm_source=blogxgwz3...

    灰度膨胀算法:

    1、膨胀可以使一个孤立的高亮噪音扩大化。

    2、可以使用物体的一些高亮度的关键细节丢失。

    灰度腐蚀算法:

    1、腐蚀可以使一个孤立的低亮噪音扩大化。

    2、可以使用物体的一些低亮度的关键细节丢失。

    转自:https://blog.csdn.net/denyz/article/details/50522799?utm_source=blogxgwz3

    展开全文
  • 用Python实现形态学处理(膨胀、腐蚀算法) 在不调用opencv库的情况下,利用卷积的思路实现膨胀腐蚀算法 文章目录用Python实现形态学处理(膨胀、腐蚀算法)前言一、膨胀与腐蚀的简介腐蚀(erode)膨胀(dilate)二、...
  • 灰度图象的腐蚀算法c语言版的,有需要的可以下载去看看
  • 最近做一些图像处理,需要将图像中的一些像素过滤一下,有网友给提了个名词:腐蚀算法。我不是学图像学的,乍一听,觉得很神奇。后来从网上收集了一些VC 代码,研究了一下,发现其它也就是那么回事。尤其是腐蚀算法...
  • 自己看书写的数学形态学灰度腐蚀算法,C码。通过MATLAB仿真,和标准算法效果相同
  • stm32颜色识别追踪算法。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • 基于FPGA的二值图像的腐蚀算法的实现九层之台,起于累土1 背景知识腐蚀和膨胀是形态学处理的基础,许多形态学算法都是以这两种操作作为基础的。图1 ...
  • 膨胀与腐蚀算法  对图像处理有所了解的人都知道图像的形态学处理里最为基础的膨胀和腐蚀算法。二值图像即只有黑白两种颜色组成的图像,一般的白色为内容,黑色为背景。其实简单点理解二值图像的膨胀与腐蚀,腐蚀...
  • 腐蚀算法是图像处理中的基础之一,它与膨胀可结合使用(开操作和闭操作)。
  • 图像处理——灰度化、二值化、膨胀算法、腐蚀算法以及开运算和闭运算的的C#代码实现
  • 图像膨胀、腐蚀算法实现 python源码

    千次阅读 2020-03-21 20:46:43
    如果您觉得本文不错!记得点赞哦! 一.... 图解图像腐蚀、膨胀 ↑ ...经验之谈:形态学操作一般作用于二值... 图像形态学操作 膨胀和腐蚀算法: 膨胀算法: 对于待操作的像素 f(x,y),不论 f(x,y-1) 、f(x,y+1) 、...
  • 图像处理之——膨胀、腐蚀算法详解 http://blog.csdn.net/minushuang/article/details/50435689 转载于:https://www.cnblogs.com/Crysaty/p/6510311.html
  • 程序代码不仅给出了完整的腐蚀代码,本身演示了一个如何用C#进行图像的简单框架。内含完整的代码和一个PDF解释文档(英文)。
  • 本文转自:http://www.cnblogs.com/yuanbao/archive/2008/04/12/1149923.html最近做一些图像处理,需要将图像中的一些像素过滤一下,有网友...尤其是腐蚀算法,我在以前的验证码图片去噪声的文章中提到过,只是那是我
  • 膨胀和腐蚀C语言代码,头文件在之前上传的资源中。 #include <math.h> #include <iostream> #include <string.h> #include "matrix.h" #include <time.h> #include <float.h> #...
  • c#_灰度图,二值化,腐蚀算法等具体实现这几天在折腾我们学校的教务管理系统,我想写一个程序不用输入密码和用户名and那个磨人的验证码就可以直接登陆的玩具出来,后来看到了网上的一些介绍,发现验证码就是专门阻止...
  • 数学形态学之腐蚀算法

    千次阅读 2018-03-10 10:27:31
    换句话说,用S来腐蚀X得到的集合是S完全包括在X中时S的原点位置的集合,用公式表示为:也就是说,对于图像X,用S当做刷子,当S完全被包含在X中时,S的原点集合构成的图像保留了下来,其他的部分被腐蚀掉:如下图所示...
  • 最近做一些图像处理,需要将图像中的一些像素过滤一下,有网友给提了个名词:腐蚀算法。我不是学图像学的,乍一听,觉得很神奇。后来从网上收集了一些VC代码,研究了一下,发现其它也就是那么回事。尤其是腐蚀算法,...
  • 可以看做是腐蚀的对偶运算,其定义是:把结构元素 B 平移 a 后得到 Ba ,若 Ba 击中 X ,我们记下这个 a 点。所有满足上述条件的 a 点组成的集合称做 X 被 B 膨胀的结果。用公式表示为: D(X)={a | Ba ↑ X}=X B ...
  • 膨胀和腐蚀算法原理

    千次阅读 2015-01-18 08:36:42
    腐蚀和膨胀是对白色部分(高亮部分)而言的,不是黑色部分。膨胀就是图像中的高亮部分进行膨胀,“领域扩张”,效果图拥有比原图更大的高亮区域。腐蚀就是原图中的高亮部分被腐蚀,“领域被蚕食”,效果图拥有比原图...
  • 图像处理之——膨胀、腐蚀算法详解

    万次阅读 多人点赞 2015-12-30 16:48:37
    结构元素:膨胀和腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理的图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,929
精华内容 2,771
关键字:

腐蚀算法