java 拉普拉斯滤波 拉普拉斯滤波原理

空间滤波的定义：

滤波的本义是指信号有各种频率的成分,滤掉不想要的成分,即为滤掉常说的噪声,留下想要的成分，这即是滤波的过程,也是目的。空间滤波是一种采用滤波处理的影像增强方法。其理论基础是空间卷积和空间相关。目的是改善影像质量，包括去除高频噪声与干扰，及影像边缘增强、线性增强以及去模糊等。分为低通滤波（平滑化）、高通滤波（锐化）和带通滤波。

图像需要增强的原因：

各类图像处理系统在图像的采集、获取、传送和转换(如成像、复制扫描、传输以及显示等)过程中，均处在复杂的环境中，光照、电磁多变，所有的图像均不同程度地被可见或不可见的噪声干扰。噪声源包括电子噪声、光子噪声、斑点噪声和量化噪声。如果信噪比低于一定的水平，噪声逐渐变成可见的颗粒形状，导致图像质量的下降。除了视觉上质量下降，噪声同样可能掩盖重要的图像细节，在对采集到的原始图像做进一步的分割处理时，我们发现有一些分布不规律的椒盐噪声，为此采取相应的对策就是对图像进行必要的滤波降噪处理。

1. 均值滤波

是将每个像元在以其为中心的M×N邻域内取平均亮度值来代替该像元值，以达到去尖锐“噪声”和平滑图像的目的。具体计算方法与模板卷积方法类似，仍采用活动窗口的扫描方法。取值时，计算M×N窗口内所有像元值平均值。一般来说，图像亮度为阶梯状变化时，取均值平滑比取中值滤波要明显得多，而对于突出亮点的“噪声”干扰，从去“噪声”后对原图的保留程度看取中值要优于取均值。优点是效率高，缺点是不能很好地保护图像细节，在图像去噪的同时也破坏了图像的细节部分，从而使图像变得模糊，不能很好地去除噪声点。

代码实现：

比如我们要对下面矩阵进行均值滤波运算，

4 4 3 7 6 8 8

4 4 3 7 6 8 8

2 2 15 8 9 9 9

5 5 8 9 13 10 10

7 7 9 12 15 11 11

8 8 11 10 14 13 13

8 8 11 10 14 13 13

输出结果如下图所示：

全部代码如下：

package NB;
import java.util.Scanner;
public class jzph {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入矩阵的行数：");
        int x = s.nextInt();
        System.out.println("请输入矩阵的列数：");
        int y = s.nextInt();
        int[][] b = new int[x][y];
        int[][] p = new int[x][y];
        System.out.println("请输入" + x + "*" + y + "的矩阵：");
        for (int i = 0; i < y; i++) {
            for (int j = 0; j < x; j++) {
                b[i][j] = s.nextInt();//完成对矩阵的输入读取
            }
        }
        System.out.println("运算结果如下：");
        for (int i = 1; i < y - 1; i++) {
            for (int j = 1; j < x - 1; j++) {//锁定到中心像元的位置
                int a = 0;//每算9个像元的和就清零
                for (int k = i - 1; k <= i + 1; k++) {
                    for (int l = j - 1; l <= j + 1; l++) {
                        a += b[k][l];//计算每个中心像元周围9个像元的总和
                    }
                }//计算中心像素的平均值，有小数就会选择绝对值最大的那个
                p[i][j] = (int) Math.round(a / 9.0);
                System.out.print(p[i][j] + " ");//输出平均值
            }
            System.out.println();//输出完一行就换行
        }
    }
}

有小伙伴看到就会说：我求的是5*5的矩阵，为什么输入的是7*7的矩阵？原因在于我们运用的3*3矩阵窗口放在矩阵4个角的像元时，需要额外添加邻近的像元来构成3*3的窗口，对于这个添加的临时像元值一般和最近的像元值保持一致。

（2）索伯尔锐化
图像锐化是为了突出图像上地物的边缘、轮廓，或某些线性目标要素的特征。这种滤波方法提高了地物边缘与周围像元之间的反差，因此也被称为边缘增强。锐化的方法很多，在此只介绍索伯尔梯度。梯度反映了相邻像元的亮度变化率，也就是说，图像中如果存在边缘，如湖泊、河流的边界，山脉和道路等，则边缘处有较大的梯度值。对于亮度值较平滑的部分，亮度梯度值较小。因此，找到梯度较大的位置，也就找到边缘，然后再用不同的梯度计算值代替边缘处像元的值，也就突出了边缘，实现了图像的锐化。

不过在讲解之前小编先给大家引入一个新的概念——图像卷积运算， 卷积运算：可看作是加权求和的过程，使图像区域中的每个像素分别与卷积核(权矩阵)的每个元素对应相乘，所有乘积之和作为区域中心像素的新值。它是在空间域上对图像作局部检测的运算，以实现平滑和锐化的目的。具体作法是选定一个卷积函数，又称为“模板”，实际上是一个M×N图像。二维的卷积运算是在图像中使用模板来实现运算的。运算方法从图像左上角开始，选定与模板同样大小的矩阵元素窗口，图像窗口与模板像元对应的亮度值相乘后再相加，最后一般将计算结果放在窗口中心位置（当M和N都是奇数时），代替原来的像元灰度值。然后活动窗口向右移动一个像元再以同样的方法进行卷积运算，逐行扫描，直到全幅影像都扫描一遍，最后生成新图像。索伯尔锐化方法使用的两个模板如下：

F=|ai*t1i|+|ai*t2i|，其中a是矩阵中的3*3个元素，i是第i个元素，i<=9,计算结果放在3*3像元的中心像元上，代替之前的灰度值。为了直白了断，小编直接上例子吧，比如有某个矩阵，如下图（1）所示，我要用上面两个模板进行索伯尔锐化，首先得在3*3模板上下左右分别添加两行两列，如下图（2）所示：

 图（1）

 图（2）

接下来对左上角像元2进行索伯尔梯度运算：|2*1+2*2+3*1+4*（-1）+4*（-2）+5*（-1）|+|2*（-1）+2*（-2）+4*（-1）+3*1+3*2+5*1|=12，其他也是一样的使用那两个矩阵进行运算即可，最终输出矩阵如下所示：

代码实现：

比如我们要对下面矩阵进行索伯尔滤波运算，

2 3 3

4 5 5

4 5 5

输出结果如下图所示：

全部代码如下：

package NB;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class zzlb {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("请输入矩阵的行数：");
        int x=s.nextInt();//获取键盘输入的数字
        System.out.println("请输入矩阵的列数：");
        int y=s.nextInt();//获取键盘输入的数字
        int[][]b=new int[x][y];//创建一个二维数组
        int[]p=new int[9];//创建一个可以存放9个元素的一维数组来获取#3*3窗口的像元值
        System.out.println("请输入"+x+"*"+y+"的矩阵：");
        for (int i = 0; i <y; i++) {
            for (int j = 0; j < x; j++) {
                b[i][j]=s.nextInt();//将键盘输入的矩阵存放到二维数组里面
            }
        }
        System.out.println("运算结果如下：");
        for (int i = 1; i <y-1; i++) {
            for (int j = 1; j < x-1; j++) {  //锁定到中心像元的位置，从（1，1）开始
                int g=0;
                for (int k =i-1; k <=i+1 ; k++) {
                    for (int l =j-1; l <=j+1 ; l++) {
                        p[g++]=b[k][l]; //将3*3矩阵窗口存储到一维数组中
                    }
                }
                for (int k = 0; k <p.length-1; k++) {
                    for (int l = 0; l < p.length-1-k; l++) {
                        if(p[l]>p[l+1]) {
                            int temp = p[l];
                            p[l]=p[l+1];
                            p[l+1]=temp;//本次采用冒泡排序法对3*3窗口内的像元从小到大排序
                        }
                    }
                }
                System.out.print(p[4]+" ");//输出每个3*3模板的中心值，下标都是4
            }
            System.out.println();//输出完一行就换行
        }
    }
}

下面这个是拉普拉斯滤波运算， 

import java.util.Scanner;

public class LPLS {
    public static void main(String[] args) {
        Scanner s2 = new Scanner(System.in);
        System.out.println("请输入矩阵的行数：");
        int x = s2.nextInt();
        System.out.println("请输入矩阵的列数：");
        int y = s2.nextInt();
        int[][] b = new int[x+2][y+2];//定义一个二维数组用来接受输入矩阵
        int[][] d = new int[x+2][y+2];//定义一个二维数组来
        int[][] c = new int[x+2][y+2];
        System.out.println("请输入" + x + "*" + y + "的矩阵：");
        for (int i = 0; i < y; i++) {
            for (int j = 0; j < x; j++) {
                b[i][j] = s2.nextInt();
            }
        }
        for (int i = 0; i <= y; i++) {
            for (int j = 0; j <= x; j++) {
                if(i==0||i==y+1||j==0||j==x+1)
                    c[i][j]=0;
                else
                c[i][j] = b[i][j];
            }
        }
        for (int i = 0; i <= y; i++) {
            for (int j = 0; j <= x; j++) {
                System.out.print(c[i][j]);
            }
            System.out.println();
        }
        System.out.println("运算结果如下：");
        for (int i = 1; i < y - 1; i++) {
            for (int j = 1; j < x - 1; j++) {//锁定到中心像元的位置，从（1，1）开始
                d[i][j] = (4*c[i][j]+(-1)*(c[i-1][j]+c[i][j-1]+c[i][j+1]+c[i+1][j])) ;//模板t2第三行的运算
                System.out.print(d[i][j] + " ");
            }
            System.out.println();//输出一行后换行
        }
    }
}