2019-07-02 20:57:49 qq_37486501 阅读数 1034
  • 机器学习算法实战——神秘奥妙的支持向量机

    支持向量机算法是机器学习的重要算法,如今已应用在图像处理、 语音识别和自然语言处理等方面。本课程详细讲解支持向量机的原理、相关概念、 推导过程和代码实战。包括:Logistic函数、最大化间隔、凸二次优化、核函数、 数据中的噪声点处理等知识。最后用了手写字分类实例,详细讲解了相关的代码实战。

    42 人正在学习 去看看 穆辉宇

噪声分类:

  • 高斯噪声
  1. 是随机噪声, 服从高斯分布
  2. 主要特点表现为:麻点
  • 椒盐噪声
  1. 胡椒噪声、盐噪声
  2. 主要特点表现为:黑白点

噪声的描述

  1. 均方误差 MSE : MSE越大,失真率越大
  2. 峰值信噪比 PSNR: PSNR越大,失真度越小

图像平滑(去噪)

  1. 平滑的目的: 在表刘源是图像基本特征的前提下, 消除或衰减噪声的影响, 提高视觉效果

  2. 基础知识:
    (1): 滤波: 使用空间模版(滤波器)处理图像的过程
    (2): 模版与模版运算: 模版和邻域大小相同

  3. 常用图像平滑方法(空间平滑滤波):

  • 均值滤波 (邻域平均法)——线性空间滤波
    MATLAB实现均值滤波,见我的博客:
    https://blog.csdn.net/qq_37486501/article/details/80274928
    (1): 基本思想: 某像素点灰度值=邻域中所有像素灰度值平均值 来代替
    (2): 优点: 在一定程度上可衰减噪声影响——拉小灰度差异
    (3): 缺点: 图像的边缘轮廓细节变模糊——边缘轮廓也做均值,导致的变模糊

  • 中值滤波(中位数)——非线性滤波
    MATLAB实现中值滤波,见我的博客:
    https://blog.csdn.net/qq_37486501/article/details/80274960
    (1): 基本思想: 某像素的灰度值=窗口内所有像素的灰度中值 来代替
    (2):窗口:
    有不同形状(
    一维:线状
    二维:十字、正方形、菱形、圆形)
    有不同大小(窗口大小中必含奇数元素, 为了保证中心像素值)
    (3): 优点:
    在去噪同时,较好的保持边缘轮廓细节
    适合处理椒盐噪声(因为: 不是去噪声点, 而使改变其灰度值)

  • 小波去噪
    将信号通过小波变换(采用Mallat算法)后,信号产生的小波系数含有信号的重要信息,将信号经小波分解后小波系数较大,噪声的小波系数较小,并且噪声的小波系数要小于信号的小波系数,通过选取一个合适的阀值,大于阀值的小波系数被认为是有信号产生的,应予以保留,小于阀值的则认为是噪声产生的,置为零从而达到去噪的目的。

  • 高斯滤波
    高斯滤波是一种线性平滑滤波,适用于消除高斯噪声,广泛应用于图像处理的减噪过程。高斯滤波就是对整幅图像进行加权平均的过程,每一个像素点的值,都由其本身和邻域内的其他像素值经过加权平均后得到。高斯滤波的具体操作是:用一个模板(或称卷积、掩模)扫描图像中的每一个像素,用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。

  • 双边滤波器去噪
    双边滤波器(Bilateral filter)是一种可以保边去噪的滤波器。可以滤除图像数据中的噪声,且还会保留住图像的边缘、纹理等(因噪声是高频信号,边缘、纹理也是高频信息,高斯滤波会在滤除噪声的同时使得边缘模糊)。是使用一个卷积核(模板矩阵),叠加到待处理像素点上,使用对应邻域像素点的加权求和来作为新的输出像素点的值一种方法,简单来说,双边滤波和高斯滤波一样,不同只在于模板矩阵的不同。

2018-12-19 22:11:06 freehawkzk 阅读数 332
  • 机器学习算法实战——神秘奥妙的支持向量机

    支持向量机算法是机器学习的重要算法,如今已应用在图像处理、 语音识别和自然语言处理等方面。本课程详细讲解支持向量机的原理、相关概念、 推导过程和代码实战。包括:Logistic函数、最大化间隔、凸二次优化、核函数、 数据中的噪声点处理等知识。最后用了手写字分类实例,详细讲解了相关的代码实战。

    42 人正在学习 去看看 穆辉宇

图像噪声

1 图像退化/复原过程模型

  退化过程被建模为一个退化函数和一个加性噪声项,对一幅输入图像f(x,yf(x,y进行处理,产生一幅退化后的图像g(x,yg(x,y。给定g(x,yg(x,y和关于退化函数HH的一些知识及关于加性噪声项η(x,y)\eta(x,y)的一些知识后,图像复原的目的就是获得原始图像的一个估计f^(x,y)\hat{f}(x,y)。如果HH是一个线性的、位置不变的过程,那么空间域中的退化图像可由下式给出:
(1)g(x,y)=h(x,y)f(x,y)+η(x,y) g(x,y)=h(x,y) \star f(x,y)+\eta (x,y) \tag{1}
  其中h(x,y)h(x,y)是退化函数的空间表示,符号\star表示空间卷积。由于空间域中的卷积等同于频率域中的乘积,那么式(1)(1)可以写成等价的频率域中的形式:
(2)G(u,v)=H(u,v)F(u,v)+N(u,v) G(u,v)=H(u,v)F(u,v)+N(u,v) \tag{2}
在这里插入图片描述

2 噪声模型

  数字图像中,噪声主要来源于图像的获取或传输过程。

2.1 噪声的空间和频率特性

  频率特性是指傅立叶域中噪声的频率内容(即相对于电磁波普的频率)。当噪声的傅立叶谱是常量时,噪声通常称为白噪声,这是从白光的物理特性派生出来的,它以相等的比例包含可见光谱中的几乎所有频率。以相同比例包含所有频率的函数的傅立叶谱是一个常量。

3 高斯噪声

3.1 高斯噪声的概率密度函数

  在空间域和频率域中,由于高斯噪声的数学上的易处理性,故实践中常用这种噪声(也称为正态噪声)模型。高斯随机变量zz的PDF由下式给出:
(3)p(z)=12πσe(zz)22σ2 p(z)=\frac{1}{\sqrt{2 \pi}\sigma }e^{-\frac{(z- \overline{z})^2}{2 \sigma ^2}} \tag{3}
  其中,zz表示灰度值,z\overline{z}表示灰度均值,σ\sigma表示灰度标准差,标准差的平方σ2\sigma ^2称为zz的方差。

在这里插入图片描述

3.2 实例

clc;
clear;
close all;

% 读取源图像
srcimg = imread('../images/18.jpg');
srcimg = im2double(srcimg);
[height,width,channels]=size(srcimg);
figure(1),imshow(srcimg),title('原图');

%% 加高斯噪声
res_gaussian = imnoise(srcimg,'gaussian',0,0.01);
figure(2),imshow(res_gaussian),title('高斯噪声结果');
imwrite(res_gaussian,'../images/18_gaussian-0-0.0.jpg');

在这里插入图片描述

4 瑞利噪声

4.1 瑞利噪声的额概率密度函数

  瑞利噪声的PDF如下:
(4)p(z)={2b(za)e(za)2/b,za0,z<ap(z)=\begin{cases} \frac{2}{b}(z-a)e^{-(z-a)^{2}/b},&z \geq a\\ &&&&\\ 0,& z < a \end{cases} \tag{4}
  其概率密度的均值和方差如下:
z=a+πb/4 \overline{z}=a+\sqrt{\pi b/4}
σ2=b(4π)4 \sigma ^2=\frac{b(4-\pi)}{4}
注意,距原点的位移和密度的基本形状向右变形了这一事实。瑞利密度对于近似歪斜的直方图十分适用。

在这里插入图片描述

5 爱尔兰(伽马)噪声

  爱尔兰噪声的PDF由下式给出:
(5)p(z)={abzb1(b1)!eaz,za0,z<ap(z)=\begin{cases} \frac{a^{b}z^{b-1}}{(b-1)!}e^{-az},&z \geq a\\ &&&&\\ 0,& z < a \end{cases} \tag{5}
  其中参数a>0a>0,bb为正整数,并且!!表示阶乘。其概率密度的均值和方差由
z=ba \overline{z}=\frac{b}{a}

σ2=ba2 \sigma ^2=\frac{b}{a^2}

6 指数噪声

  指数噪声的PDF如下:
(6)p(z)={aeaz,z00,z<0 p(z)=\begin{cases} ae^{-az},&z \geq 0\\ &&&&\\ 0,& z < 0 \end{cases} \tag{6}
  其中a>0a>0,概率密度函数的均值和方差是:
z=1a \overline{z}=\frac{1}{a}

σ2=1a2 \sigma ^2 = \frac{1}{a^2}

7 均匀噪声

  指数噪声的PDF如下:
(7)p(z)={1ba,azb0, p(z)=\begin{cases} \frac{1}{b-a},&a \leq z \leq b\\ &&&&\\ 0,& 其他 \end{cases} \tag{7}
  概率密度函数的均值和方差是:
z=a+b2 \overline{z}=\frac{a+b}{2}

σ2=(ba)212 \sigma ^2 = \frac{(b-a)^2}{12}

8 脉冲(椒盐)噪声

  指数噪声的PDF如下:
(8)p(z)={Pa,z=aPb,z=b1PaPb, p(z)=\begin{cases} P_a,&z = a\\ &&&&\\ P_b,&z=b\\ &&&&\\ 1-P_{a}-P_{b},&其他 \end{cases} \tag{8}
  如果b>ab>a,则灰度级bb在图像中将显示为一个两点,反之,灰度级aa在图像中将显示为一个暗点。若PaP_aPbP_b为0,则脉冲噪声为单极脉冲。如果PaP_aPbP_b两者均不可能为0,则脉冲噪声值将类似于在图像上随机分布的胡椒和盐粉微粒,双极脉冲噪声也称为椒盐噪声。

2017-11-16 10:39:20 hhyqhh 阅读数 903
  • 机器学习算法实战——神秘奥妙的支持向量机

    支持向量机算法是机器学习的重要算法,如今已应用在图像处理、 语音识别和自然语言处理等方面。本课程详细讲解支持向量机的原理、相关概念、 推导过程和代码实战。包括:Logistic函数、最大化间隔、凸二次优化、核函数、 数据中的噪声点处理等知识。最后用了手写字分类实例,详细讲解了相关的代码实战。

    42 人正在学习 去看看 穆辉宇

课后作业,实现:均值、谐波均值、中值、中点等滤波器。对应《数字图像处理》第三版,5.1-5.9课后题。


代码基于Matlab实现。完整代码及处理结果见:GitHub

步骤

  1. 加载图像
  2. 向外拓展一个像素的大小
  3. 与滤波器做卷积操作
  4. 输出图像

5.1 算数均值滤波

代码实现

close all
clear all
image=imread('filtering.tif');

figure();
subplot(2,2,1);
imshow(image);
xlabel('Raw image');

image_mean_3 = arithmetic_mean_filter(image,3);
subplot(2,2,2);
imshow(image_mean_3)
xlabel('arithmetic mean filter/3');

image_mean_5 = arithmetic_mean_filter(image,5);
subplot(2,2,3);
imshow(image_mean_5)
xlabel('arithmetic mean filter/5');

image_mean_9 = arithmetic_mean_filter(image,9);
subplot(2,2,4);
imshow(image_mean_9)
xlabel('arithmetic mean/9');

%%
function [result_imag]= arithmetic_mean_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;

    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);     
            result_imag(x,y)=sum(slid(:))/numel(slid);
        end
    end
end

%%
function [result_imag] = extend_imag(image)
    [M,N] = size(image);
    temp = zeros(M+2,N+2);
    for x = 1:M
        temp(x+1,:) = [image(x,1) image(x,:) image(x,N)];
    end
    temp(1,:) = temp(2,:);
    temp(M+2,:) = temp(M+1,:);
    result_imag = temp;
end

其中 extend_imag 用于向外拓展像素。arithmetic_mean_filter 是核心的滤波器实现以及运算操作。

结果


5.2 几何均值滤波

这里只展示核心的滤波器实现代码。完整代码见GitHub

%%
function [result_imag]= geo_mean_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;

    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);     
            result_imag(x,y)=prod(slid(:))^(1/numel(slid));
        end
    end
end

5.3 谐波均值滤波

%%
function [result_imag]= harmonic_wave_mean_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;

    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);
            slid = 1./slid;
            result_imag(x,y) = numel(slid(:))/sum(slid(:));
        end
    end
end

5.4 逆谐波均值滤波(Q=1.5)

%%
function [result_imag]= Inv_harmonic_wave_mean_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;
    Q=1.5;
    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);
            result_imag(x,y) = sum(slid(:).^(Q+1))/sum(slid(:).^(Q));
        end
    end
end

5.5 逆谐波均值滤波(Q=-1.5)

%%
function [result_imag]= Inv_harmonic_wave_mean_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;
    Q=-1.5;
    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);
            result_imag(x,y) = sum(slid(:).^(Q+1))/sum(slid(:).^(Q));
        end
    end
end

5.6 中值滤波

%%
function [result_imag]= min_value_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;

    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);
            temp = sort(slid(:));
            result_imag(x,y)= temp((numel(temp)-1)/2);
        end
    end
end

5.7 最大值滤波

%%
function [result_imag]= max_value_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;

    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);
            temp = slid(:);
            result_imag(x,y)= max(temp);
        end
    end
end

5.8 最小值滤波

%%
function [result_imag]= max_value_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;

    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);
            temp = slid(:);
            result_imag(x,y)= min(temp);
        end
    end
end

5.9 中点滤波

%%
function [result_imag]= half_value_filter(image,filter_size)
    Ex_image = extend_imag(image);
    result_imag = image;
    [M,N]=size(Ex_image);
    helf_size = (filter_size-1)/2;

    for x=1+helf_size:1:M-helf_size
        for y=1+helf_size:1:N-helf_size
            slid=Ex_image(x-helf_size:1:x+helf_size,y-helf_size:1:y+helf_size);
            temp = slid(:);
            result_imag(x,y)= (max(temp)+min(temp))/2;
        end
    end
end
2015-07-24 09:36:36 mao0514 阅读数 1869
  • 机器学习算法实战——神秘奥妙的支持向量机

    支持向量机算法是机器学习的重要算法,如今已应用在图像处理、 语音识别和自然语言处理等方面。本课程详细讲解支持向量机的原理、相关概念、 推导过程和代码实战。包括:Logistic函数、最大化间隔、凸二次优化、核函数、 数据中的噪声点处理等知识。最后用了手写字分类实例,详细讲解了相关的代码实战。

    42 人正在学习 去看看 穆辉宇

均值滤波:

均值滤波,是图像处理中最常用的手段,从频率域观点来看均值滤波是一种低通滤波器,高

频信号将会去掉,因此可以帮助消除图像尖锐噪声,实现图像平滑,模糊等功能。理想的均

值滤波是用每个像素和它周围像素计算出来的平均值替换图像中每个像素。采样Kernel数

据通常是3X3的矩阵,如下表示:


从左到右从上到下计算图像中的每个像素,最终得到处理后的图像。均值滤波可以加上两个

参数,即迭代次数,Kernel数据大小。一个相同的Kernel,但是多次迭代就会效果越来越好。

同样,迭代次数相同,Kernel矩阵越大,均值滤波的效果就越明显。

 

中值滤波

中值滤波也是消除图像噪声最常见的手段之一,特别是消除椒盐噪声,中值滤波的效果要比

均值滤波更好。中值滤波是跟均值滤波唯一不同是,不是用均值来替换中心每个像素,而是

将周围像素和中心像素排序以后,取中值,一个3X3大小的中值滤波如下:

 

最大最小值滤波

最大最小值滤波是一种比较保守的图像处理手段,与中值滤波类似,首先要排序周围像素和

中心像素值,然后将中心像素值与最小和最大像素值比较,如果比最小值小,则替换中心像

素为最小值,如果中心像素比最大值大,则替换中心像素为最大值。一个Kernel矩阵为3X3的最大最小值滤波如下:

 

 原图如下:



分别实现中值和均值滤波以后效果如下:


代码就不解释了,原理已经解释得很清楚了,全部算法源代码都是基于Java

特别说明一点的是,均值滤波对于高斯噪声的效果比较好,中值滤波对于椒盐噪声的效果比较好

想必大家从上面效果比较中也可以看到一点端倪。因为我选择的噪声图片是椒盐噪声的,哈哈


自己读吧,不解释了,有问题的可以问,源代码如下:

  1. package com.process.blur.study;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4. import java.util.ArrayList;  
  5. import java.util.Arrays;  
  6.   
  7.   
  8. public class SmoothFilter extends AbstractBufferedImageOp {  
  9.     public final static int MEAN_FILTER_TYPE = 1;  
  10.     public final static int MEADIAN_FILTER_TYPE = 2;  
  11.     public final static int MIN_MAX_FILTER_TYPE = 4;  
  12.       
  13.     private int repeats = 3// default 1  
  14.     private int kernel_size = 3// default 3  
  15.     private int type = 1// default mean type  
  16.       
  17.     public int getRepeat() {  
  18.         return repeats;  
  19.     }  
  20.       
  21.     public void setRepeat(int repeat) {  
  22.         this.repeats = repeat;  
  23.     }  
  24.       
  25.     public int getKernelSize() {  
  26.         return kernel_size;  
  27.     }  
  28.       
  29.     public void setKernelSize(int kernelSize) {  
  30.         this.kernel_size = kernelSize;  
  31.     }  
  32.       
  33.     public int getType() {  
  34.         return type;  
  35.     }  
  36.       
  37.     public void setType(int type) {  
  38.         this.type = type;  
  39.     }  
  40.   
  41.     @Override  
  42.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
  43.         int width = src.getWidth();  
  44.         int height = src.getHeight();  
  45.   
  46.         if ( dest == null )  
  47.             dest = createCompatibleDestImage( src, null );  
  48.           
  49.         int[] inPixels = new int[width*height];  
  50.         int[] outPixels = new int[width*height];  
  51.         getRGB( src, 00, width, height, inPixels );  
  52.           
  53.         // pick up one filter from here!!!  
  54.         if(this.type == MEAN_FILTER_TYPE)   
  55.         {  
  56.             for(int i=0; i<repeats; i++) {  
  57.                 performMeanFilter(width, height, inPixels, outPixels);  
  58.                 System.arraycopy(outPixels, 0, inPixels, 0, inPixels.length);  
  59.             }  
  60.         }   
  61.         else if(this.type == MEADIAN_FILTER_TYPE)   
  62.         {  
  63.             performMedianFilter(width, height, inPixels, outPixels);  
  64.         }   
  65.         else if(this.type == MIN_MAX_FILTER_TYPE)   
  66.         {  
  67.             performMinMaxFilter(width, height, inPixels, outPixels);  
  68.         }  
  69.           
  70.         // return result  
  71.         setRGB( dest, 00, width, height, outPixels );  
  72.         return dest;  
  73.     }  
  74.       
  75.     /** 
  76.      *  <p> perform convolution filter </p> 
  77.      *  
  78.      * @param width 
  79.      * @param height 
  80.      * @param inPixels 
  81.      * @param outPixels 
  82.      */  
  83.     public void performMeanFilter(int width, int height, int[] inPixels, int[] outPixels) {  
  84.   
  85.         int rows2 = kernel_size/2;  
  86.         int cols2 = kernel_size/2;  
  87.         int index = 0;  
  88.         int index2 = 0;  
  89.         float total = kernel_size * kernel_size;  
  90.         for (int y = 0; y < height; y++) {  
  91.             for (int x = 0; x < width; x++) {  
  92.                 float r = 0, g = 0, b = 0, a = 0;  
  93.                 for (int row = -rows2; row <= rows2; row++) {  
  94.                     int rowoffset = y + row;  
  95.                     if(rowoffset < 0 || rowoffset >=height) {  
  96.                         rowoffset = y;  
  97.                     }  
  98.                     //System.out.println("rowoffset == " + rowoffset);  
  99.                     for(int col = -cols2; col <= cols2; col++) {  
  100.                         int coloffset = col + x;  
  101.                         if(coloffset < 0 || coloffset >= width) {  
  102.                             coloffset = x;  
  103.                         }  
  104.                         index2 = rowoffset * width + coloffset;  
  105.                         int rgb = inPixels[index2];  
  106.                         a += ((rgb >> 24) & 0xff);  
  107.                         r += ((rgb >> 16) & 0xff);  
  108.                         g += ((rgb >> 8) & 0xff);  
  109.                         b += (rgb & 0xff);  
  110.                     }  
  111.                 }  
  112.                 int ia = 0xff;  
  113.                 int ir = clamp((int)(r/total));  
  114.                 int ig = clamp((int)(g/total));  
  115.                 int ib = clamp((int)(b/total));  
  116.                 outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;  
  117.             }  
  118.         }  
  119.     }  
  120.     /** 
  121.      *  <p> perform median filter </p> 
  122.      *  
  123.      * @param width 
  124.      * @param height 
  125.      * @param src 
  126.      * @param inPixels 
  127.      * @param outPixels 
  128.      */  
  129.     public void performMedianFilter(int width, int height, int[] inPixels, int[] outPixels) {  
  130.   
  131.         int rows2 = kernel_size/2;  
  132.         int cols2 = kernel_size/2;  
  133.         int index = 0;  
  134.         int index2 = 0;  
  135.         float total = kernel_size * kernel_size;  
  136.         int[] matrix = new int[(int)total];  
  137.         for (int y = 0; y < height; y++) {  
  138.             for (int x = 0; x < width; x++) {  
  139.                 int count = 0;  
  140.                 for (int row = -rows2; row <= rows2; row++) {  
  141.                     int rowoffset = y + row;  
  142.                     if(rowoffset < 0 || rowoffset >=height) {  
  143.                         rowoffset = y;  
  144.                     }  
  145.   
  146.                     for(int col = -cols2; col <= cols2; col++) {  
  147.                         int coloffset = col + x;  
  148.                         if(coloffset < 0 || coloffset >= width) {  
  149.                             coloffset = x;  
  150.                         }  
  151.                         index2 = rowoffset * width + coloffset;  
  152.                         int rgb = inPixels[index2];  
  153.                         matrix[count] = rgb;  
  154.                         count++;   
  155.                     }  
  156.                 }  
  157.                 Arrays.sort(matrix);  
  158.                   
  159.                 int ia = 0xff;  
  160.                 int ir = ((matrix[count/2] >> 16) & 0xff);  
  161.                 int ig = ((matrix[count/2] >> 8) & 0xff);  
  162.                 int ib = (matrix[count/2] & 0xff);  
  163.                 outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;  
  164.             }  
  165.         }  
  166.     }  
  167.       
  168.     /** 
  169.      * <p> perform min/max pixel filter </p> 
  170.      *  
  171.      * @param width 
  172.      * @param height 
  173.      * @param src 
  174.      * @param inPixels 
  175.      * @param outPixels 
  176.      */  
  177.     public void performMinMaxFilter(int width, int height, int[] inPixels, int[] outPixels) {  
  178.         int rows2 = kernel_size/2;  
  179.         int cols2 = kernel_size/2;  
  180.         int index = 0;  
  181.         int index2 = 0;  
  182.         float total = kernel_size * kernel_size;  
  183.         int[] matrix = new int[(int)total];  
  184.         for (int y = 0; y < height; y++) {  
  185.             for (int x = 0; x < width; x++) {  
  186.                 int count = 0;  
  187.                 for (int row = -rows2; row <= rows2; row++) {  
  188.                     int rowoffset = y + row;  
  189.                     if(rowoffset < 0 || rowoffset >=height) {  
  190.                         rowoffset = y;  
  191.                     }  
  192.   
  193.                     for(int col = -cols2; col <= cols2; col++) {  
  194.                         int coloffset = col + x;  
  195.                         if(coloffset < 0 || coloffset >= width) {  
  196.                             coloffset = x;  
  197.                         }  
  198.                         index2 = rowoffset * width + coloffset;  
  199.                         int rgb = inPixels[index2];  
  200.                         matrix[count] = rgb;  
  201.                         count++;   
  202.                     }  
  203.                 }  
  204.                 int ia = 0xff;  
  205.                 int oldPixel = matrix[count/2];  
  206.                 int targetRGB = findNewPixel(matrix, oldPixel);  
  207.                 int ir = ((targetRGB >> 16) & 0xff);  
  208.                 int ig = ((targetRGB >> 8) & 0xff);  
  209.                 int ib = (targetRGB & 0xff);  
  210.                 outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;  
  211.             }  
  212.         }  
  213.     }  
  214.       
  215.     private int findNewPixel(int[] matrix, int oldPixel) {  
  216.         ArrayList<Integer> list = new ArrayList<Integer>();  
  217.         for(int i=0; i<matrix.length; i++) {  
  218.             if(matrix[i] == oldPixel)  
  219.                 continue;  
  220.             list.add(matrix[i]);  
  221.         }  
  222.         int[] filterData = new int[list.size()];  
  223.         int index = 0;  
  224.         for(Integer rgb : list) {  
  225.             filterData[index++] = rgb;  
  226.         }  
  227.         Arrays.sort(filterData);  
  228.           
  229.         if(filterData.length == 0)  
  230.             return oldPixel;  
  231.         return (oldPixel > filterData[0]) ? filterData[0] : (oldPixel < filterData[filterData.length -1])? filterData[filterData.length -1] : oldPixel;  
  232.     }  
  233.   
  234.     public static int clamp(int c) {  
  235.         if (c < 0)  
  236.             return 0;  
  237.         if (c > 255)  
  238.             return 255;  
  239.         return c;  
  240.     }  
  241.   
  242. }  
2018-09-10 00:26:24 iiiil7 阅读数 756
  • 机器学习算法实战——神秘奥妙的支持向量机

    支持向量机算法是机器学习的重要算法,如今已应用在图像处理、 语音识别和自然语言处理等方面。本课程详细讲解支持向量机的原理、相关概念、 推导过程和代码实战。包括:Logistic函数、最大化间隔、凸二次优化、核函数、 数据中的噪声点处理等知识。最后用了手写字分类实例,详细讲解了相关的代码实战。

    42 人正在学习 去看看 穆辉宇

1,实验原理

图像增强是数字图像处理的基本内容之一,其目的是根据应用需要突出图像中的某些“有用”信息,削弱或去除不需要的信息,以改善图像的视觉效果,或突出图像的特征,便于计算机处理。图像增强可以在空间域进行,也可以在频率域中进行。

空间域滤波主要利用空间模板进行,如3*3,5*5模板等,一般来说,使用大小为m×n 的滤波器对大小为M×N 的图像f进行空间滤波,可表示成:

其中,m=2a+1, n=2b+1, w(s,t)是滤波器系数,f(x,y)是图像值

均值滤波器是一种空间平滑滤波器,它是对包含噪声的图像上的每个像素点,用它邻域内像素的平均值替代原来的像素值。例如,采用一个3×3的模板,待处理的像素为f(i,j),则处理后图像对应的像素值为g(i-1,j+1)

g(i,j)=1/9*(f(i-1,j-1)+f(i-1,j)+f(i-1,j+1)+f(i,j-1)+f(i,j)+f(i,j+1)+f(i+1,j-1)+f(i+1,j)+f(i+1,j+1));    

中值滤波器也是一种空间平滑滤波器,它是对以图像像素点为中心的一个滑动窗口内的诸像素灰度值排序,用中值代替窗口中心像素的原来灰度值,因此它是一种非线性的图像平滑法。

2,实验要求

对原图像分别加入高斯噪声、椒盐噪声

利用邻域平均法,分别采用3´3,5´5模板对加噪声图像进行平滑处理,显示原图像、加噪图像和处理后的图像

利用中值滤波法,分别采用3´3,5´5模板对加噪声图像进行去噪处理,显示原图像、加噪图像和处理后的图像

3,实验过程和结果

clc;
clear;
close all;

I = imread('test3.gif','gif');        %自己设置路径
imshow(I);
subplot(5,4,1);
imshow(I);
title('原图');

G1 = imnoise(I,'gaussian',0.02);
subplot(5,4,2);
imshow(G1);
title('加入高斯噪声');

G2 = imnoise(I,'salt & pepper',0.05);
subplot(5,4,3);
imshow(G2);
title('加入椒盐噪声');

G3 = imnoise(I,'speckle',0.04);
subplot(5,4,4);
imshow(G3);
title('均匀分布的随机噪声');

H1 = fspecial('average',[3,3]);

G331 = imfilter(I,H1);
subplot(5,4,5);
imshow(G331);
title('原图3*3均值滤波');

G332 = imfilter(G1,H1);
subplot(5,4,6);
imshow(G332);
title('高斯噪声3*3均值滤波');

G333 = imfilter(G2,H1);
subplot(5,4,7);
imshow(G333);
title('椒盐噪声3*3均值滤波');

G334 = imfilter(G3,H1);
subplot(5,4,8);
imshow(G334);
title('均匀分布的随机噪声3*3均值滤波');


H2 = fspecial('average',[5,5]);

G551 = imfilter(I,H2);
subplot(5,4,9);
imshow(G331);
title('原图5*5均值滤波');

G552 = imfilter(G1,H2);
subplot(5,4,10);
imshow(G552);
title('高斯噪声5*5均值滤波');

G553 = imfilter(G2,H2);
subplot(5,4,11);
imshow(G553);
title('椒盐噪声5*5均值滤波');

G554 = imfilter(G3,H2);
subplot(5,4,12);
imshow(G554);
title('均匀分布的随机噪声5*5均值滤波');

K331 = medfilt2(I,[3,3]);
subplot(5,4,13);
imshow(K331);
title('原图3*3中值滤波');

K332 = medfilt2(G1,[3,3]);
subplot(5,4,14);
imshow(K332);
title('高斯噪声3*3中值滤波');

K333 = medfilt2(G2,[3,3]);
subplot(5,4,15);
imshow(K333);
title('椒盐噪声3*3中值滤波');

K334 = medfilt2(G3,[3,3]);
subplot(5,4,16);
imshow(K334);
title('均匀分布的随机噪声3*3中值滤波');


K551 = medfilt2(I,[5,5]);
subplot(5,4,17);
imshow(K551);
title('原图5*5中值滤波');

K552 = medfilt2(G1,[5,5]);
subplot(5,4,18);
imshow(K552);
title('高斯噪声5*5中值滤波');

K553 = medfilt2(G2,[5,5]);
subplot(5,4,19);
imshow(K553);
title('椒盐噪声5*5中值滤波');

K554 = medfilt2(G3,[5,5]);
subplot(5,4,20);
imshow(K554);
title('均匀分布的随机噪声5*5中值滤波');

4,实验结果

采用邻域平均法即均值滤波对高斯噪声比较有效,但造成一定的模糊,邻域越大,模糊越严重。但均值滤波不能很好地处理椒盐噪声。

采用中值滤波法,不适用于去除高斯噪声,而且造成图像模糊严重。但可以很好的抑制椒盐噪声,3*3模板处理过的图像接近原图像,但模板增大即邻域扩大,加强去噪声能力的同时,使图像模糊严重。

最后附上实验原图

图像处理复习

阅读数 76

没有更多推荐了,返回首页