• 什么是图像处理? 我的理解是,图像处理即就是对图像的各个像素点进行处理。 一、灰度化 灰度化,也就是黑白化,就是将图像进行黑白处理,使其失去色彩。而从像素点出发,就是使各个像素点的三种颜色分量R、G、B...

    什么是图像处理?

    我的理解是,图像处理即就是对图像的各个像素点进行处理。

    一、灰度化

    灰度化,也就是黑白化,就是将图像进行黑白处理,使其失去色彩。而从像素点出发,就是使各个像素点的三种颜色分量R、G、B的值相同。

    常用的黑白化的方法有三种:

    • 第一种是最大值法(Maximum):

                       R=G=B=Max(R,G,B),这种方法处理后灰度图象的亮度会偏高,不建议采用。

    • 第二种就是平均值法(Average):

                       R=G=B=(R+G+B)/3,这种方法处理后灰度图象的亮度较柔和,本人就是采用的这种方法。

    • 第三种是加权平均值法(Weighted Average):

                       R=G=B=wr*R+wg*G+wb*B,wr、wg、wb分别为R、G、B的权值。

    鉴于本人只使用了第二种,所以就先贴上第二种的代码:

            public Bitmap bmp1;
            public Bitmap bmp2;
            //黑白化
            //平均值法: 使用每个像素点的 R,G,B值等于原像素点的RGB值的平均值
            //效率略低,暂未查明具体原因,需3秒等待
            public Image BlackANDWhite(PictureBox pic)
            {
                bmp1 = new Bitmap(pic.Image);
                int width = bmp1.Width;
                int height = bmp1.Height;
                bmp2 = new Bitmap(width, height);
    
                Color c;
                for (int x = 0; x < width; x++)
                {
                    for (int y = 0; y < height; y++)
                    {
                        c = bmp1.GetPixel(x, y);//获取像素
                        int value = (c.R + c.G + c.B) / 3;
                        bmp2.SetPixel(x, y, Color.FromArgb(value, value, value));//设置像素
                    }
                }
                return bmp2;
            }

    以下是代码的相关结果展示:

                

    (未处理的图片来自百度)

    二、锐化

    锐化就是通过增强高频分量来减少图象中的模糊,因此又称为高通滤波。锐化处理在增强图象边缘的同时增加了图象的噪声。

    常用的锐化模板是拉普拉斯(Laplacian)模板,而本人也是采用的拉普拉斯模板进行的锐化处理。

                                                        

    下面是拉普拉斯模板的锐化处理的相关代码:

            //锐化
            //突出显示颜色值大(即形成形体边缘)的像素点
            public Image Sharpen(PictureBox pic)
            {
                bmp1 = new Bitmap(pic.Image);
                int width = bmp1.Width;
                int height = bmp1.Height;
                bmp2 = new Bitmap(width, height);
    
                Color c;
                int[] Laplacian = { -1, -1, -1, -1, 9, -1, -1, -1, -1 };//拉普拉斯锐化模板
                for (int x = 1; x < width - 1; x++)
                {
                    for (int y = 1; y < height - 1; y++)
                    {
                        int r = 0, g = 0, b = 0;
                        int Index = 0;
                        //两个for循环刚好将拉普拉斯锐化模板数组完全遍历
    
                        for (int col = -1; col <= 1; col++)
                            for (int row = -1; row <= 1; row++)
                            {
    
                                //获取bmp1的各个点的像素值     
                                c = bmp1.GetPixel(x + row, y + col);
                                r += c.R * Laplacian[Index];
                                g += c.G * Laplacian[Index];
                                b += c.B * Laplacian[Index];
                                Index++;
                            }
                        //要注意的是,运算后如果出现了大于255或者小于0的点,称为溢出,
                        //溢出点的处理通常是截断,即大于255时,令其等于255;小于0时,取其绝对值。
    
                        
                        //处理颜色值溢出
                        r = r > 255 ? 255 : r;
                        r = r < 0 ? 0 : r;
                        g = g > 255 ? 255 : g;
                        g = g < 0 ? 0 : g;
                        b = b > 255 ? 255 : b;
                        b = b < 0 ? 0 : b;
    
                        //将bmp2的各个像素点进行赋值
                        bmp2.SetPixel(x - 1, y - 1, Color.FromArgb(r, g, b));
                    }
                }
                return bmp2;
            }
    

     

    三、平滑

    平滑与锐化相反,就是滤掉高频分量,从而达到减少图象噪声,使图片变得有些模糊。

    常用的平滑处理方法有三种:

    • Box模板去噪平滑处理,也就是均一化处理。

                         Box模板是{1,1,1,1,1,1,1,1,1}

    • 高斯模板去噪平滑处理,就是在Box模板的基础上加入了加权系数,考虑了距离某点位置越近影响越大的因素。相比Box模板,较为清晰一些。

                         高斯模板是{1,2,1,2,4,2,1,2,1}

    • 中值滤波去噪平滑处理,就是将该点左右邻近的两个点的rgb值与该点自身进行比较,选择其中最中间的值赋给该点。

    下面是平滑处理的相关代码:

            //Box模板去噪平滑处理
            public void Box_Smooth(PictureBox pic)
            {
                bmp1 = new Bitmap(pic.Image);
                int width = bmp1.Width;
                int height = bmp1.Height;
                bmp2 = new Bitmap(width, height);
    
                Color c;
                int[] Box = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };//Box模板
    
                for (int x = 1; x < width - 1; x++)
                {
                    for (int y = 1; y < height - 1; y++)
                    {
                        int r = 0, g = 0, b = 0;
                        int Index = 0;
    
                        for (int col = -1; col <= 1; col++)
                            for (int row = -1; row <= 1; row++)
                            {
                                c = bmp1.GetPixel(x + row, y + col);
                                r += c.R * Box[Index];
                                g += c.G * Box[Index];
                                b += c.B * Box[Index];
                                Index++;
                            }
                        r = r / 9;
                        g = g / 9;
                        b = b / 9;
    
                        //处理颜色值溢出
                        r = r > 255 ? 255 : r;
                        r = r < 0 ? 0 : r;
                        g = g > 255 ? 255 : g;
                        g = g < 0 ? 0 : g;
                        b = b > 255 ? 255 : b;
                        b = b < 0 ? 0 : b;
    
                        bmp2.SetPixel(x, y, Color.FromArgb(r, g, b));
                    }
                }
            }
    
            //高斯模板去噪平滑处理  
            public void Gauss_Smooth(PictureBox pic)
            {
                bmp1 = new Bitmap(pic.Image);
                int width = bmp1.Width;
                int height = bmp1.Height;
                bmp2 = new Bitmap(width, height);
    
                Color c;
                int[] Guass = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };//Gauss模板
    
                for (int x = 1; x < width - 1; x++)
                {
                    for (int y = 1; y < height - 1; y++)
                    {
                        int r = 0, g = 0, b = 0;
                        int Index = 0;
    
                        for (int col = -1; col <= 1; col++)
                            for (int row = -1; row <= 1; row++)
                            {
                                c = bmp1.GetPixel(x + row, y + col);
                                r += c.R * Guass[Index];
                                g += c.G * Guass[Index];
                                b += c.B * Guass[Index];
                                Index++;
                            }
                        r = r / 16;
                        g = g / 16;
                        b = b / 16;
    
                        //处理颜色值溢出
                        r = r > 255 ? 255 : r;
                        r = r < 0 ? 0 : r;
                        g = g > 255 ? 255 : g;
                        g = g < 0 ? 0 : g;
                        b = b > 255 ? 255 : b;
                        b = b < 0 ? 0 : b;
    
                        bmp2.SetPixel(x, y, Color.FromArgb(r, g, b));
                    }
                 } 
            }
    
            //中值滤波去噪平滑处理
            public void MiddleValue_Smooth(PictureBox pic)
            {
                bmp1 = new Bitmap(pic.Image);
                int width = bmp1.Width;
                int height = bmp1.Height;
                bmp2 = new Bitmap(width, height);
    
                //分别建立r,g,b数组
                int[] r = new int[3];
                int[] g = new int[3];
                int[] b = new int[3];
    
                for (int x = 1; x < width - 1; x++)
                {
                    for (int y = 1; y < height - 1; y++)
                    {
                        int Index = 0;
                        for (int row = -1; row <= 1; row++)
                        {
                            Color c = bmp1.GetPixel(x + row, y);//获取像素值
                            //分别给r,g,b数组赋值
                            r[Index]= c.R ;
                            g[Index]= c.G ;
                            b[Index]= c.B ;
                            Index++;
                        }
    
                        //排序
                        Array.Sort(r);
                        Array.Sort(g);
                        Array.Sort(b);
    
                        //处理颜色值溢出
                        r[1] = r[1] > 255 ? 255 : r[1];
                        r[1] = r[1] < 0 ? 0 : r[1];
                        g[1] = g[1] > 255 ? 255 : g[1];
                        g[1] = g[1] < 0 ? 0 : g[1];
                        b[1] = b[1] > 255 ? 255 : b[1];
                        b[1] = b[1] < 0 ? 0 : b[1];
    
                        bmp2.SetPixel(x - 1, y - 1, Color.FromArgb(r[1], g[1], b[1]));
    
                    }
                }
    
            }


    下面是是那种平滑处理所得的效果图与原图的对比展示:

    原图:

    Box模板:     

                                                                  

    Guass模板:  

                                                              

    中值滤波:

    PS:源码在我的资源下载里,点击这里可以下载

    展开全文
  • 图像处理之图像的平滑与锐化概念:锐化就是通过增强高频分量来减少图象中的模糊,因此又称为高通滤波。锐化处理在增强图象边缘的同时增加了图象的噪声。平滑与锐化相反,就是滤掉高频分量,从而达到减少图象噪声,使...

    图像处理之图像的平滑与锐化
    概念:
    锐化就是通过增强高频分量来减少图象中的模糊,因此又称为高通滤波。锐化处理在增强图象边缘的同时增加了图象的噪声。
    平滑与锐化相反,就是滤掉高频分量,从而达到减少图象噪声,使图片变得有些模糊。
    一、灰度化
    灰度化,也就是黑白化,就是将图像进行黑白处理,使其失去色彩。而从像素点出发,就是使各个像素点的三种颜色分量R、G、B的值相同。

    常用的黑白化的方法有三种:

    第一种是最大值法(Maximum):
                       R=G=B=Max(R,G,B),这种方法处理后灰度图象的亮度会偏高,不建议采用。

    第二种就是平均值法(Average):
                       R=G=B=(R+G+B)/3,这种方法处理后灰度图象的亮度较柔和,本人就是采用的这种方法。

    第三种是加权平均值法(Weighted Average):
                       R=G=B=wr*R+wg*G+wb*B,wr、wg、wb分别为R、G、B的权值。

    鉴于本人只使用了第二种,所以就先贴上第二种的代码:
    src=imread('background.bmp');
    [m,n,channel]=size(src);
    desc=zeros(m,n);
    desc=double(desc);
    for i=1:m
    for j=1:n
    for k=1:channel
    desc(i,j)=desc(i,j)+src(i,j,k);
    end
    desc(i,j)=desc(i,j)/3;
    end
    end
    imshow(uint8(desc));

    二、锐化
    锐化就是通过增强高频分量来减少图象中的模糊,因此又称为高通滤波。锐化处理在增强图象边缘的同时增加了图象的噪声。

    常用的锐化模板是拉普拉斯(Laplacian)模板,而本人也是采用的拉普拉斯模板进行的锐化处理。

    [-1,-1,-1]

    [-1,9,-1]

    [-1,-1,-1]

    三、平滑
    平滑与锐化相反,就是滤掉高频分量,从而达到减少图象噪声,使图片变得有些模糊。

    常用的平滑处理方法有三种:

    Box模板去噪平滑处理,也就是均一化处理。
                         Box模板是{1,1,1,1,1,1,1,1,1}

    高斯模板去噪平滑处理,就是在Box模板的基础上加入了加权系数,考虑了距离某点位置越近影响越大的因素。相比Box模板,较为清晰一些。
                         高斯模板是{1,2,1,2,4,2,1,2,1}

    中值滤波去噪平滑处理,就是将该点左右邻近的两个点的rgb值与该点自身进行比较,选择其中最中间的值赋给该点。


    最终代码:
    Img1=imread('Fig4.jpg');subplot(3,3,1);imshow(Img1);title('Fig4.jpg');
    w1=[1,1,1;1,1,1;1,1,1];w2=[1,2,1;2,4,2;1,2,1];
    w3=[-1,-2,-1;0,0,0;1,2,1];w4=[-1,0,1;-2,0,2;-1,0,1];
    k1=1/sum(sum(w1));k2=1/sum(sum(w2));
    variance=225;
    [m,n]=size(Img1);
    I1=uint8(double(Img1)+randn(m,n).*sqrt(variance)+5);
    subplot(3,3,2);imshow(I1);title('gs.png');

    II1=double(I1);
    II11=double(I1);
    II111=double(I1);
    for i=2:m-1
    for j=2:n-1
    p=[II1(i-1,j-1),II1(i-1,j),II1(i-1,j+1);II1(i,j-1),II1(i,j),II1(i,j+1);II1(i+1,j-1),II1(i+1,j),II1(i+1,j+1)];
    II1(i,j)=sum(sum((p.*w1)*k1));
    a=(p.*w1);
    pp=sort(reshape(a,1,9));
    II11(i,j)=pp(5);
    II111(i,j)=abs(sum(sum(p.*w3)))+abs(sum(sum(p.*w4)));
    end
    end
    subplot(3,3,5);imshow(uint8(II1));title('normal 均值滤波 gs.png');
    subplot(3,3,8);imshow(uint8(II11));title('normal 中值滤波 gs.png');
    subplot(3,3,7);imshow(uint8(II11));title('normal 锐化 gs.png');
    I2=Img1;
    a=rand(m,n);
    for i=1:m
    for j=1:n
    if(a(i,j)>0.975)
    I2(i,j)=255;
    elseif(a(i,j)<0.05)
    I2(i,j)=0;
    end
    end
    end
    subplot(3,3,3);imshow(I2);title('jyzs.png');
    II2=double(I2);
    II22=double(I2);
    for i=2:m-1
    for j=2:n-1
    p=[II2(i-1,j-1),II2(i-1,j),II2(i-1,j+1);II2(i,j-1),II2(i,j),II2(i,j+1);II2(i+1,j-1),II2(i+1,j),II2(i+1,j+1)];
    II2(i,j)=sum(sum((p.*w2)*k2));
    a=(p.*w1);
    pp=sort(reshape(a,1,9));
    II22(i,j)=pp(5);
    end
    end
    subplot(3,3,6);imshow(uint8(II2));title('normal jyzs.png');
    subplot(3,3,9);imshow(uint8(II22));title('normal 中值滤波 jyzs.png');

     

    原文:https://blog.csdn.net/qq_26399665/article/details/53496958

    转载于:https://www.cnblogs.com/Ph-one/p/11567650.html

    展开全文
  • 图像锐化算法

    2015-11-25 16:08:46
    图像锐化可以实现边缘增强,凸显细节。 常用的方法有拉普拉斯算子和反掩膜法,两者都可以通过滤波模板实现,非常方便简单。说到滤波模板,也就是空域滤波了,这个PPT对空域滤波的原理阐述得比较清晰:...

    图像锐化可以实现边缘增强,凸显细节。

    常用的方法有拉普拉斯算子和反锐化掩膜法,两者都可以通过滤波模板实现,非常方便简单。说到滤波模板,也就是空域滤波了,这个PPT对空域滤波的原理阐述得比较清晰:http://pan.baidu.com/s/1qWJmGoO

    拉普拉斯算子的介绍:http://www.cnblogs.com/xfzhang/archive/2011/01/19/1939020.htmlhttp://blog.csdn.net/iaccepted/article/details/41869685

    反锐化掩膜法的介绍:http://blog.csdn.net/laviewpbt/article/details/8945663


    拉普拉斯算子的matlab实现 


    思路很简单,就是获得滤波模板、高斯模糊、锐化。通过fspecial函数可以轻易获得滤波模板。fspecial函数的用法:http://blog.csdn.net/wyl_steven/article/details/6314959

    fspecial只能生成3*3的模板,锐化性能有限,还需要从原理上理解怎么生产拉普拉斯模板。其实拉普拉斯算子就是一个二阶微分的公式,其滤波模板只是对公式的一种近似,为了简化运算过程,所以,拉普拉斯算子的锐化能力是非常有限的,当然你可以加大模板中心的权重,但这会导致锐化过度,违反了图像增强的原则——图像失真了。


    利用filter2函数对图像进行空域滤波。

     img = imread('test1.jpg');
    % img = imread('test.jpg');
    %     Hg = fspecial('gaussian',[3 3],1);
    %  for channel=1:3
    %    img0 = img(:,:,channel);
    %    img0 = double(img0);
    %    img0 = filter2(Hg,img0); %smooth
    %    img(:,:,channel) = uint8(img0);
    %  end
     
     figure(1)
     imshow(img);title('org')
     
     H1 = fspecial('laplacian',0.2);
    % H1=[1,1,1;1,-8,1;1,1,1];
     Hg = fspecial('gaussian',[3 3],0.5);
     for channel=1:3
     img0 = img(:,:,channel);
     img0 = double(img0);
     
     img0 = filter2(Hg,img0); %smooth
     img1 = filter2(H1,img0);
     img2 = img0-img1; 
    
     img(:,:,channel) = uint8(img2);
     end
     
     figure(2)
     imshow(img);title('sharpen')
     
      H1 = fspecial('laplacian',0.2);
    % H1=[1,1,1;1,-8,1;1,1,1];
     Hg = fspecial('gaussian',[3 3],0.5);
     for channel=1:3
     img0 = img(:,:,channel);
     img0 = double(img0);
     
     img0 = filter2(Hg,img0); %smooth
     img1 = filter2(H1,img0);
     img2 = img0-img1; 
    
     img(:,:,channel) = uint8(img2);
     end
     
     figure(3)
     imshow(img);title('sharpen2')


    test.jpg:http://pan.baidu.com/s/1eQ8bJl4

    test1.jpg:http://pan.baidu.com/s/1eQgXv14

    反锐化掩膜法的matlab实现 

    反锐化掩膜法(USM)是一种常用的锐化算法,photoshop中就采用了这种算法。它可以说是拉普拉斯算子的加强版,算法具有相当的锐化能力与可控性。

    其思路很简单:高通滤波、高频提升、合成。

    高通滤波,从原始图像中提取高频成分,从而提取细节(这里可以使用拉普拉斯算子),然后对细节进行一定的增强(增益可调),最后把增强的细节叠加到原始图像中。

    这样做的效果不是很好,后来又有改进的方法:

    先做高斯模糊(半径可调),提取低频成分;然后把原始图像减去低频成分获得高频成分(间接提取高频);再对高频成分与阈值(阈值可调)比较,比阈值大的才进行增强(提高抗噪声性能);最后叠加。

    发现,这样做的效果比较理想。


    %USM算法仿真
    
     img = imread('test.jpg');
    %  img = imread('test1.jpg');
     channel = size(img,3);
     figure(1);imshow(img);title('origin');
     
     %USM算法
     radius = 3;        %模糊半径
     amount = 50;       %增益
     threshold = max(img(:))/2;   %阈值
     Hg = fspecial('gaussian',[3 3],radius);    %高斯核
     for i=1:channel
     imgcyp = img(:,:,i);       %多通道分离
     imgcyp = double(imgcyp); 
     imgl = filter2(Hg,imgcyp);	%高斯模糊
     imgh = imgcyp - imgl;      %提取高频成分 
     imgh(abs(imgh)>threshold) = ... %增益
        imgh(abs(imgh)>threshold) * amount;
     imgcyp = imgcyp + imgh;    %叠加
     img(:,:,i) = uint8(imgcyp);
     end
     
     figure(2);imshow(img);title('enhanced');


    USM(unsharp mask)锐化之openCV代码



    展开全文
  •  1、图像锐化和边缘检测的基本概念,微分梯度已经差分的定义  2、锐化和边缘检测的像素处理方式(3种)  3、单方向一阶微分锐化,包括:  水平方向  垂直方向  Kirsch算子  4、无方向微分锐化,包括:

    本文内容构成:

           1、图像锐化和边缘检测的基本概念,微分梯度已经差分的定义

           2、锐化和边缘检测的像素处理方式(3种)

           3、单方向一阶微分锐化,包括:

                 水平方向

                 垂直方向

                 Kirsch算子

            4、无方向微分锐化,包括:

                 Roberts算子

                 Sobel算子

                 Prewitt算子

                 Laplacian算子(二阶微分)

                 LOG算子(二阶微分

            5、二阶微分

            6、实验结果对比

     

            在图像增强过程中,通常利用各类图像平滑算法消除噪声,图像的常见噪声主要有加性噪声、乘性噪声和量化噪声等。一般来说,图像的能量主要集中在其低频部分,噪声所在的频段主要在高频段,同时图像边缘信息也主要集中在其高频部分。这将导致原始图像在平滑处理之后,图像边缘和图像轮廓模糊的情况出现(平滑可以认为是去除噪声,这样也就模糊了图像的边缘信息)。为了减少这类不利效果的影响,就需要利用图像锐化技术,使图像的边缘变得清晰。图像锐化处理的目的是为了使图像的边缘、轮廓线以及图像的细节变得清晰,经过平滑的图像变得模糊的根本原因是因为图像受到了平均或积分运算,因此可以对其进行逆运算(如微分运算)就可以使图像变得清晰。微分运算是求信号的变化率,由傅立叶变换的微分性质可知,微分运算具有较强高频分量作用。从频率域来考虑,图像模糊的实质是因为其高频分量被衰减,因此可以用高通滤波器来使图像清晰。但要注意能够进行锐化处理的图像必须有较高的性噪比,否则锐化后图像性噪比反而更低,从而使得噪声增加的比信号还要多,因此一般是先去除或减轻噪声后再进行锐化处理

           针对平均或积分运算使图像模糊,可逆行其道而采取微分运算:使用高通滤波器优化高频分量,抑制低频分量,提高图像边界清晰度等。

           图像锐化的方法分为高通滤波和空域微分法。图像的边缘或线条的细节(边缘)部分 与图像频谱的高频分量相对应,因此采用高通滤波让高频分量顺利通过,并适当抑制中低频分量,是图像的细节变得清楚,实现图像的锐化,由于高通滤波我们在前面频域滤波已经讲过,所以这里主要讲空域的方法——微分法。

           边缘是指图象中灰度发生急剧变化的区域。图象灰度的变化情况可以用灰度分布的梯度来反映,给定连续图象f(x,y),其方向导数在边缘法线方向上取得局部最大值。图象中一点的边缘被定义为一个矢量,模为当前点最人的方向导数,方向为该角度代表的方向。通常我们只考虑其模,而不关心方向。

     

           一阶微分运算一阶微分主要指梯度模运算,图像的梯度模值包含了边界及细节信息。梯度模算子用于计算梯度模值,通常认为它是边界提取算子,具有极值性、位移不变性和旋转不变性。

    图像在点处的梯度 定义为一个二维列矢量:

    梯度大的幅值即模值,为:

     

     

    梯度的方向在 最大变化率方向上,方向角可表示为:

            对于离散函数 也有相应的概念和公式,只是用差分代替微分。差分可取为后向差分,前向差分。

    在x,y方向上的一阶向后差分分别定义为:

     梯度定义为:

     其模和方向分别为:


     

            在实际应用中,梯度的模还有很多近似式,如使用x,y方向上差分绝对值替代模来度量

    梯度的模(幅值)就是 最大变化率方向的单位距离所增加的量。由梯度的计算可知,在图像灰度变化较大的边沿区域其梯度值大,在灰度变化平缓的区域梯度值较小,而在灰度均匀的区域其梯度值为零。我们根据得到的梯度值来返回像素的值,如将梯度值大的像素设置成白色,梯度值小的设置为黑色,这样就可以将边缘提取出来了,或者是加强梯度值大的像素灰度值就可以突出细节了达到了锐化的目的。    

     

     

           根据梯度值,进而对像素的处理一般有三种方式:锐化是要突出细节(边界),所以要对边缘的像素加强(比如直接用梯度值作为像素的灰度或者RGB的分量),而边缘检测只要根据设置的阀值,超过阀值的像素灰度设为0,否则设为255。          

     1)辅以阀值判断    设T为阀值,像素的梯度值大于T,则像素的灰度(或者RGB的分量)加上某一个值(如100),加上某一个值(如100)像素的灰度值(或RGB的分量值)后若大于255,取255

       

     

     2)设以某一特定值     设t为阀值,像素的梯度值大于T,则像素的灰度(或者RGB的分量)设置为某一定值La    

                                                                 

     3)二值化图像     设T为阀值,像素的梯度值大于T,则像素的灰度(或者RGB的分量)设置为255,否则设置为0     


                                                                     

     

           根据图像边界(细节,边缘)的拓扑结构,一阶微分锐化具体又分为单方向的一阶微分锐化和无方向的微分锐化          

    单方向的一阶锐化是指对某个特定方向上的边缘(细节)信息的进行加强。最简单的单方向一阶锐化就是水平方向与垂直方向上的锐化。        

    水平方向的锐化非常简单,通过一个可以检测出水平方向上的像素值的变化模板来实现。


                                                                  
     垂直方向只需要将方向改变下就可以得到:
                                                                               

    Kirsch算子

            Kirsch算子采用8个模板对图像上的每一个像素点进行卷积求导数,这8个模板代表8个方向,对图像上的8个特定边缘方向作出最大响应,运算(与3*3像素加权之和,就是对应位置相乘后求和)中取最大值作为图像的边缘输出。下面是8个模板:

                                                                                                   

     

           问题:单方向锐化的计算结果中出现了小于零的像素值?

           方法1:整体加一个正整数,以保证所有的像素值均为正。比如+128,还有<0的则视为0,若有>255视为255处理,这样做的结果是:可以获得类似浮雕的效果。

           方法2:将所有的像素值取绝对值。这样做的结果是,可以获得对边缘的有方向提取。

     

    无方向一阶锐化问题的提出                  

           前面的锐化处理结果对于人工设计制造的具有矩形特征物体(例如:楼房、汉字等)的边缘的提取很有效。但是,对于不规则形状(如:人物)的边缘提取,则存在信息的缺损。

    为了解决上面的问题,就希望提出对任何方向上的边缘信息均敏感的锐化算法。因为这类锐化方法要求对边缘的方向没有选择,所有称为无方向的锐化算法。

    双方向一次微分运算,直接以梯度值代替

           理论基础:对灰度图像f在纵方向和横方向两个方向进行微分。该算法是同时增强水平和垂直方向的边缘。利用双方向一次微分运算,算出梯度后让梯度值赋给该点的灰度值。

    数学表达式为:

    G(i,j)=sqrt{[f(i,j)-f(i,j-1)]*[f(i,j)-f(i,j-1)]+[f(i,j)-f(i-1,j)]*[f(i,j)-f(i-1,j)]}

    或G(i,j)=|f(i,j)-f(i,j-1)|+|f(i,j)-f(i-1,j)|

     

    边缘检测

           

           边缘检测算子检查每个像素的领域并对灰度变化率进行量化,通常也包括方向的确定。大多数是基于方向当属模板求卷积的方法。

    将所有的边缘模板逐一作用于图像中的每一个像素,产生最大输出值的边缘模板方向表示该点边缘的方向,如果所有方向上的边缘模板接近于零,该点处没有边缘;如果所有方向上的边缘模板输出值都近似相等,没有可靠边缘方向   

                                                                                

    卷积
                                                                            

    卷积可以简单的看成加权求和的过程。

    下面分别对Roberts算子,Sobel算子,Prewitt算子,Laplacian算子介绍:

     

    (1)无方向一阶锐化——交叉微分

    交叉微分算子(Robert算子)计算公式如下:

                                                                                    

    特点:算法简单

     

    (2)无方向一阶锐化——Sobel锐化

    Sobel锐化计算公式如下:

                                                                                                     

    Sobel边缘算子的卷积和如上图所示,图像中的每个像素都用这两个核做卷积。Sobel算子认为邻域的像素对当前像素产生的影响不是等价的,所以距离不同的像素具有不同的权值,对算子结果产生的影响也不同。一般来说,距离越大,产生的影响越小。这两个核分别对垂直边缘和水平边缘响应最大,两个卷积的最大值作为该点的输出位。运算结果是一幅边缘幅度图像。

     特点:锐化的边缘信息较强

     

    (3)无方向一阶锐化——Priwitt锐化                                                                             

    Priwitt锐化计算公式如下:

    Prewitt算子在一个方向求微分,而在另一个方向求平均,因而对噪声相对不敏感,有抑制噪声作用。但是像素平均相当于对图像的低通滤波,所以Prewitt算子对边缘的定位不如Roberts算子。

    特点:与Sobel相比,有一定的抗干扰性,图像效果比较干净。

     

    几种方法的效果比较

           Sobel算法与Priwitt算法的思路相同,属于同一类型,因此处理效果基本相同。

           Roberts算法的模板为2*2,提取信息较弱。

           单方向锐化经过处理之后,也可以对边界进行增强。

     

    二阶微分锐化——问题的提出

                                                                                           

           1)对应突变形的细节,通过一阶微分的极值点,二阶微分的过0点均可以检测处理

           2)对应细线行的细节,通过一阶微分的过0点,二阶微分的极小值点均可以检测处理。

           3)对应渐变的细节,一边情况很难检测,但二阶微分的信息比一阶微分的信息略多。

    二阶微分锐化——算法推导


                                                                                    
     
                                                 

     

    将上面推导的公式写成模板系数形式,即为Laplacian算子:     

           Laplacian算子利用二阶导数信息,具有各向同性,即与坐标轴方向无关,坐标轴旋转后梯度结果不变。使得图像经过二阶微分后,在边缘处产生一个陡峭的零交叉点,根据这个对零交叉点判断边缘。                                                                    

    Laplacian变形算子

                                                                      

    为了改善锐化效果,可以脱离微分的计算原理,在原有的算子基础上,对模板系数进行改变,获得Laplacian变形算子:

    其中H2是在H1的基础上在考虑45°和135°方向的结果

                                                                

    Laplacian算子对噪声比较敏感,Laplacian算子有一个缺点是它对图像中的某些边缘产生双重响应。所以图像一般先经过平滑处理,通常把Laplacian算子和平滑算子结合起来生成一个新的模板。

    Log边缘算子

    现在介绍一种利用图像强度二阶导数的零交叉点来求边缘点的算法对噪声十分敏感,所以在边缘增强前滤除噪声。为此,马尔(Marr)和希尔得勒斯(Hildreth)根据人类视觉特性提出了一种边缘检测的方法,该方法将高斯滤波和拉普拉斯检测算子结合在一起进行边缘检测的方法,故称为Log(Laplacian of Gassian )算法。也称之为拉普拉斯高斯算法。该算法的主要思路和步骤如下:

    (1)滤波:首先对图像f(x,y)进行平滑滤波,其滤波函数根据人类视觉特性选为高斯函数,即:

     

    其中,G(x,y)是一个圆对称函数,其平滑的作用是可通过  来控制的。将图像 G(x,y)与f(x,y) 进行卷积,可以得到一个平滑的图像,即:

    (2)增强:对平滑图像g(x,y) 进行拉普拉斯运算,即:

                                                                       

    (3)检测:边缘检测判据是二阶导数的零交叉点(即h(x,y)=0  的点)并对应一阶导数的较大峰值。

     这种方法的特点是图像首先与高斯滤波器进行卷积,这样既平滑了图像又降低了噪声,孤立的噪声点和较小的结构组织将被滤除。但是由于平滑会造成图像边缘的延伸,因此边缘检测器只考虑那些具有局部梯度最大值的点为边缘点。这一点可以用二阶导数的零交叉点来实现。拉普拉斯函数用二维二阶导数的近似,是因为它是一种无方向算子。在实际应用中为了避免检测出非显著边缘,应选择一阶导数大于某一阈值的零交叉点作为边缘点。由于对平滑图像g(x,y) 进行拉普拉斯运算可等效为G(x,y) 的拉普拉斯运算与f(x,y) 的卷积,故上式变为:

                                                                   

    式中  称为LOG滤波器,其为:

                                                         
    这样就有两种方法求图像边缘:

    ①先求图像与高斯滤波器的卷积,再求卷积的拉普拉斯的变换,然后再进行过零判断。

    ②求高斯滤波器的拉普拉斯的变换,再求与图像的卷积,然后再进行过零判断。

    这两种方法在数学上是等价的。上式就是马尔和希尔得勒斯提出的边缘检测算子(简称M-H算子),由于LOG滤波器在(x,y) 空间中的图形与墨西哥草帽形状相似,所以又称为墨西哥草帽算子。

    拉普拉斯算子对图像中的嗓声相当敏感。而且它常产生双像素宽的边缘,也不能提供边缘方向的信息。高斯-拉普拉斯算子是效果较好的边沿检测器,常用的5×5模板的高斯--拉普拉斯算子如图2.7所示:

                                                                                        

                                                                                                高斯—拉普拉斯算子

    高斯--拉普拉斯算子把高斯平滑滤波器和拉普拉斯锐化滤波器结合起来,先平化掉噪声,再进行边缘检测,所以效果更好。

    程序的主要思想就是将每个像素的灰度值或RGB的分量与算子矩阵求卷积(用加权求和代替),只是锐化是要突出细节(边界),所以要对边缘的像素加强(比如直接用梯度值作为像素的灰度或者RGB的分量),而边缘检测只要根据设置的阀值,超过阀值的像素灰度设为0,否则设为255。
    查看实验效果:


     

    展开全文
  • 图像锐化(原理篇)        图像锐化处理的目的是为了使图像的边缘、轮廓线以及图像的细节变得清晰,经过平滑的图像变得模糊的根本原因是因为图像受到了平均或积分运算,因此可以...

    图像锐化(原理篇)

           图像锐化处理的目的是为了使图像的边缘、轮廓线以及图像的细节变得清晰,经过平滑的图像变得模糊的根本原因是因为图像受到了平均或积分运算,因此可以对其进行逆运算(如微分运算,其实这里用的是差分)就可以使图像变得清晰。
           图像中边缘的定义是什么?在图像处理中认为,灰度值变化剧烈的地方就是边缘。变化剧烈程度,数学上就是函数的一阶导数。假设下面第一张图是图像的灰度函数,可以看出,中间变化较快的地方应该是图像的边缘。第二张图是图一的一阶导数,由数学知识可知,一阶导数的极值就是那个变化最快的点–边缘。第三张图是图一的二阶导数,二阶导数为0时,可以看出是图像的边缘处。所以,对于确定图像的边缘,我们只需要找到一阶导数为极值点或者二阶导数为0的位置就行(二阶导数为0不一定为边缘点 比如一副颜色相同的图像 其一阶导数 二阶导数都是0 没有边缘)
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
           那为什么用差分来寻找边缘呢对于连续的函数来说,一阶导数就是直接求导,二阶同理。但是,图像本质是一个二维矩阵,离散型的。是无法求导的。这时候,就需要用到差分这个概念了。实在理解不到的话,可以认为:连续型函数是求导(求微分),离散型函数则是求差分。

    一阶导数、二阶导数差分的证明
    在这里插入图片描述
    图像上差分的求法
    在这里插入图片描述
    常用一阶微分算子证明
    在这里插入图片描述
    二阶算子证明
    在这里插入图片描述

    更多

    获取更多资料、代码,微信公众号:海轰Pro
    回复 海轰 即可

    展开全文
  • 2.掌握图像锐化原理及数学运算。 3.于MATLAB环境下编程实现对图片锐化。 三、实验内容     利用图像基于单方向梯度算子,Robert算子,Sobel算 子,Pritt算 子, Laplacian算子,多方向模板,...
  • 本文内容构成: 1、图像锐化和边缘检测的基本概念,微分梯度已经差分的定义 2、锐化和边缘检测的像素处理方式(3种) 3、单方向一阶微分锐化,包括: 水平方向 垂直方向 Kirsch算子
  • 数字图像处理中的图像锐化 图像锐化的作用: 突出增强边缘轮廓细节 空间域锐化处理方法: (空间锐化滤波) 梯度算法:(一阶差分)——景物边缘轮廓提取, (1): 正交梯度算法——水平垂直差分 (2): Roberts梯度算法——...
  • 图像的平滑和锐化原理及实现,如果做图像增强,这些应该有用
  • 图像锐化是和平滑相反的操作,目的是为了使模糊的图像变得清晰。既然是相反的目的,那么操作应该也是相反的,平滑使用的是图像邻域的加权求和或者是积分运算,而锐化则是使用求导数(梯度)或有限差分来实现。 基于...
  • 2、利用MATLAB进行频率域滤波,观察图像平滑和图像锐化的效果,加深对频率域滤波的理解; 3、掌握图像FFT变换与DCT变换后进行频率域滤波的不同; 4、掌握低通滤波与高通滤波原理,对DCT变换后的图像进行低通滤波和高通...
  • #include<opencv2/highgui/highgui.hpp>//包括图形界面和视频图像处理的头文件 #include<iostream>//每个c++程序必须包含的头文件 #include void sharpen(const cv::Mat &image, cv::Mat &result) { result....
  • 图像锐化算法-sharpen

    2020-04-28 02:07:18
    图像锐化,是使图像边缘更清晰的一种图像处理方法,细节增强(detail enhancement)我理解也包含了图像锐化,常用的做法是提取图像的高频分量,将其叠加到原图上。图像高频分量的提取有两种做法,一种是用高通滤波器...
  • 锐化滤波器 锐化处理的主要目的是,突出灰度的过渡部分,增强图像中的细节。空间域像素邻域平均法可以使图像变模糊,均值处理与积分类似
  • 1、掌握一阶锐化算法的工作原理和算法实现。 2、掌握二阶锐化算法的工作原理和算法实现。 实验内容 实现拉普拉斯锐化。测试图像:’Grayblur6.png’。 实验代码 im = imread('.\im\Grayblur6.png'); imshow(im); ...
  • 17/100发布文章 博文管理我的博客退出 ...什么是指针 OpenCV入门即颠峰:使用Mat类(彩色测试) OpenCV入门即颠峰:使用Mat类(灰度测试) OpenCV入门即巅峰:Mat类的使用(彩色测试) OpenCV图像处理:图像锐化操...
  • GDAL 图像锐化简介拉普拉斯(Laplace)算子部分代码:索贝尔(Sobel)算子部分代码:处理效果原图(Laplace)(Sobel)结尾参考文章 简介 图像锐化(image sharpening)是补偿图像的轮廓,增强图像的边缘及灰度跳变...
  • 图像锐化和边缘提取技术可以消除图像中的噪声,提取图像信息中用来表征图像的一些变量,为图像识别提供基础。通常使用灰度差分法对图像的边缘、轮廓进行处理,将其凸显。本文分别采用Laplacian算子、Robert算子、...
  • 本文主要讲述基于VC++6.0 MFC图像处理的应用知识,主要结合自己大三所学课程《数字图像处理》及课件进行讲解,主要通过MFC单文档视图实现显示BMP图像增强处理,包括图像普通平滑、高斯平滑、不同算子的图像锐化知识...
  • 基于Matlab的图像空间锐化处理,包含梯度法、罗伯特梯度法、拉普拉斯算法
1 2 3 4 5 ... 20
收藏数 3,256
精华内容 1,302