概述
二元函数f(x,y)的一阶微分为fx=ʚf/ʚx或fx=ʚf/ʚy,图像的坐标表示如下:
假设一张图片的各像素为:
3 3 3 3 3 3
3 5 5 5 5 3
3 5 9 9 5 3
3 5 9 9 5 3
3 5 5 5 5 3
3 3 3 3 3 3
在往下进行介绍之前,先给出两个读图片和写图片的函数
算法源代码1(读图片和写图片)
/**
* 读取图片
* @param srcPath 图片的存储位置
* @return 返回图片的BufferedImage对象
*/
public static BufferedImage readImg(String srcPath) {
BufferedImage img = null;
try {
img = ImageIO.read(new File(srcPath));
} catch (IOException e) {
e.printStackTrace();
}
return img;
}
/**
* 将图片写入磁盘
* @param img 图像的BufferedImage对象
* @param formatName 存储的文件格式
* @param distPath 图像要保存的存储位置
*/
public static void writeImg(BufferedImage img, String formatName, String distPath) {
OutputStream out = null;
try {
//int imgType = img.getType();
//System.out.println("w:" + img.getWidth() + " h:" + img.getHeight());
out = new FileOutputStream(distPath);
ImageIO.write(img, formatName, out);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(out != null) {
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
垂直微分算子
垂直方向的微分算子是要获得图像在垂直方向上的变化率。
定义
G=f(x-1,y-1) + 2f(x,y-1) + f(x+1,y-1) – f(x-1,y+1) – 2f(x,y+1) – f(x+1,y+1)
权系数矩阵模板
模板D1
垂直方向的微分算子处理结果:
0 0 0 0 0 0
0 -10 -20 -20 -10 0
0 -4 -12 -12 -4 0
0 4 12 12 4 0
0 10 20 20 10 0
0 0 0 0 0 0
为了能够正常显示处理后结果,将每个像素加上最小值的绝对值(如上面的|-20|),结果如下:
20 20 20 20 20 20
20 10 0 0 10 20
20 16 8 8 16 20
20 24 32 32 24 20
20 30 40 40 30 20
20 20 20 20 20 20
算法源代码2
/**
* 水平微分算子
* @param srcPath 图片的存储位置
* @param distPath 图像要保存的存储位置
* @param formatName 图像要保存的存储位置
*/
public static void firstMomentX(String srcPath, String distPath, String formatName) {
BufferedImage img = readImg(srcPath);
int w = img.getWidth();
int h = img.getHeight();
int pix[] = new int[w*h];
pix= img.getRGB(0, 0, w, h, pix, 0, w);
pix = firstMomentX(pix, w, h);
img.setRGB(0, 0, w, h, pix, 0, w);
writeImg(img, formatName, distPath);
}
/**
* 水平微分算子
* @param pix 像素矩阵数组
* @param w 矩阵的宽
* @param h 矩阵的高
* @return 处理后的数组
*/
public static int[] firstMomentX(int[] pix, int w, int h) {
int[] newpix = new int[w*h];
ColorModel cm = ColorModel.getRGBdefault();
int r, g, b;
for(int y=0; y<h; y++) {
for(int x=0; x<w; x++) {
if(x!=0 && x!=w-1 && y!=0 && y!=h-1){
//G=f(x-1,y-1) + 2f(x,y-1) + f(x+1,y-1) – f(x-1,y+1) – 2f(x,y+1) – f(x+1,y+1)
r = cm.getRed(pix[x-1+(y-1)*w]) + 2* cm.getRed(pix[x+(y-1)*w]) + cm.getRed(pix[x+1+(y-1)*w])
- cm.getRed(pix[x-1+(y+1)*w]) - 2* cm.getRed(pix[x+(y+1)*w]) - cm.getRed(pix[x+1+(y+1)*w]);
newpix[x+y*w] = 255<<24 | r<<16 | r<<8 | r;
}
}
}
int temp = findMinInt(newpix);
for(int i=0; i<newpix.length; i++) {
newpix[i] = newpix[i] + temp;
}
return newpix;
}
水平微分算子
水平方向的微分算子是要获得图像在水平方向上的变化率。
定义
G=f(x-1,y-1) + 2f(x-1,y) + f(x-1,y+1) - f(x+1,y-1) - 2f(x+1,y) - f(x+1, y+1)
权系数矩阵模板
模板D2
垂直方向的微分算子处理结果:
20 20 20 20 20 20
20 10 16 24 30 20
20 0 8 32 40 20
20 0 8 32 40 20
20 10 16 24 30 20
20 20 20 20 20 20
算法源代码3
/**
* 垂直微分算子
* @param srcPath 图片的存储位置
* @param distPath 图像要保存的存储位置
* @param formatName 图像要保存的存储位置
*/
public static void firstMomentY(String srcPath, String distPath, String formatName) {
BufferedImage img = readImg(srcPath);
int w = img.getWidth();
int h = img.getHeight();
int pix[] = new int[w*h];
pix= img.getRGB(0, 0, w, h, pix, 0, w);
pix = firstMomentY(pix, w, h);
img.setRGB(0, 0, w, h, pix, 0, w);
writeImg(img, formatName, distPath);
}
/**
* 垂直微分算子
* @param pix 像素矩阵数组
* @param w 矩阵的宽
* @param h 矩阵的高
* @return 处理后的数组
*/
public static int[] firstMomentY(int[] pix, int w, int h) {
int[] newpix = new int[w*h];
ColorModel cm = ColorModel.getRGBdefault();
int r;
for(int y=0; y<h; y++) {
for(int x=0; x<w; x++) {
if(x!=0 && x!=w-1 && y!=0 && y!=h-1) {
//G=f(x-1,y-1) + 2f(x-1,y) + f(x-1,y+1) - f(x+1,y-1) - 2f(x+1,y) - f(x+1, y+1)
/*newpix[x+y*w] = pix[x-1+(y-1)*w] + 2*pix[x-1+(y)*w] + pix[x-1+(y+1)*w]
- pix[x+1+(y-1)*w] - 2*pix[x+1+(y)*w] - pix[x+1+( y+1)*w];*/
r = cm.getRed(pix[x-1+(y-1)*w]) + 2*cm.getRed(pix[x-1+(y)*w]) + cm.getRed(pix[x-1+(y+1)*w])
- cm.getRed(pix[x+1+(y-1)*w]) - 2*cm.getRed(pix[x+1+(y)*w]) - cm.getRed(pix[x+1+( y+1)*w]);
newpix[x+y*w] = 255<<24 | r<<16 | r<<8 | r;
}
}
}
int temp = findMinInt(newpix);
for(int i=0; i<newpix.length; i++) {
newpix[i] = newpix[i] + temp;
}
return newpix;
}
实验效果:
原图:
垂直方向的微分算子的效果
水平方向的微分算子的效果
Roberts交叉微分算子
水平微分算子和垂直微分算子只求出了特定方向上的细节信息,但是对于大多数图像来说,求出细节轮廓是一全非常重要的信息,而往往遇到的大部分景物的细节是不规则的,所以在二维图像的两个方向上来考虑锐化微分是很有必要的。Roberts叉微分算子的作用模板如下:
定义:
G=|f(x+1,y+1) - f(x,y)| + |f(x,y+1)-f(x+1,y)|
权系数矩阵模板
F1’=D1(f(x,y)), F2’=D2(f(x,y))
G=|F1’| + |F2’|
算法源代码4
/**
* Roberts交叉微分算子
* @param srcPath 图片的存储位置
* @param distPath 图像要保存的存储位置
* @param formatName 图像要保存的存储位置
*/
public static void roberts(String srcPath, String distPath, String formatName) {
BufferedImage img = readImg(srcPath);
int w = img.getWidth();
int h = img.getHeight();
int pix[] = new int[w*h];
pix= img.getRGB(0, 0, w, h, pix, 0, w);
pix = roberts(pix, w, h);
img.setRGB(0, 0, w, h, pix, 0, w);
writeImg(img, formatName, distPath);
}
/**
* Roberts交叉微分算子
* @param pix 像素矩阵数组
* @param w 矩阵的宽
* @param h 矩阵的高
* @return 处理后的像素矩阵
*/
public static int[] roberts(int pix[], int w, int h) {
ColorModel cm = ColorModel.getRGBdefault();
int r;
int[] newpix = new int[w*h];
for(int y=0; y<h; y++) {
for(int x=0; x<w; x++) {
if(x!=w-1 && y!=h-1){
//G=|f(x+1,y+1) - f(x,y)| + |f(x,y+1)-f(x+1,y)|
r=Math.abs(cm.getRed(pix[x+1+(y+1)*w]) - cm.getRed(pix[x+y*w])) +
Math.abs(cm.getRed(pix[x+(y+1)*w]) - cm.getRed(pix[x+1+y*w]));
newpix[x+y*w] = 255<<24 | r<<16 | r <<8 | r;
} else {
if(x == w-1) {
newpix[x+y*w] = pix[x-1+y*w];
}
if(y == h-1) {
newpix[x+y*w] = pix[x+(y-1)*w];
}
}
}
}
return newpix;
}
效果:
Sobel微分算子
前面介绍的Roberts微分算子可以获得景物的细节轮廓,且模板小,计算量小;但由于模板的尺寸是偶数,待处理的像素不能放在模板中心。Sobel微分算子是一种奇数大小(3*3)模板下的全方向微分算子。
定义:
D1=f(x-1,y-1) + 2f(x,y-1) + f(x+1,y-1) – f(x-1,y+1) – 2f(x,y+1) – f(x+1,y+1)
D2=f(x-1,y-1) + 2f(x-1,y) + f(x-1,y+1) – f(x+1,y-1) – 2f(x+1,y) – f(x+1, y+1)
G=sqrt(D1^2 + D2^2)
算法源代码5
/**
* Sobel微分算子
* @param srcPath 图片的存储位置
* @param distPath 图像要保存的存储位置
* @param formatName 图像要保存的存储位置
*/
public static void sobel(String srcPath, String distPath, String formatName) {
BufferedImage img = readImg(srcPath);
int w = img.getWidth();
int h = img.getHeight();
int pix[] = new int[w*h];
pix= img.getRGB(0, 0, w, h, pix, 0, w);
pix = sobel(pix, w, h);
img.setRGB(0, 0, w, h, pix, 0, w);
writeImg(img, formatName, distPath);
}
/**
* Sobel微分算子
* @param pix 像素矩阵数组
* @param w 矩阵的宽
* @param h 矩阵的高
* @return 处理后的像素矩阵
*/
public static int[] sobel(int pix[], int w, int h) {
ColorModel cm = ColorModel.getRGBdefault();
int g1, g2, r;
int[] newpix = new int[w*h];
for(int y=0; y<h; y++) {
for(int x=0; x<w; x++) {
if(x!=0 && x!=w-1 && y!=0 && y!=h-1){
//G
g1 = cm.getRed(pix[x-1+(y-1)*w]) + 2* cm.getRed(pix[x+(y-1)*w]) + cm.getRed(pix[x+1+(y-1)*w])
- cm.getRed(pix[x-1+(y+1)*w]) - 2* cm.getRed(pix[x+(y+1)*w]) - cm.getRed(pix[x+1+(y+1)*w]);
g2 = cm.getRed(pix[x-1+(y-1)*w]) + 2*cm.getRed(pix[x-1+(y)*w]) + cm.getRed(pix[x-1+(y+1)*w])
- cm.getRed(pix[x+1+(y-1)*w]) - 2*cm.getRed(pix[x+1+(y)*w]) - cm.getRed(pix[x+1+( y+1)*w]);
r=(int) Math.round(Math.sqrt(g1*g1 + g2*g2));
newpix[x+y*w] = 255<<24 | r<<16 | r <<8 | r;
} else {
if(x == w-1) {
newpix[x+y*w] = pix[x-1+y*w];
}
if(y == h-1) {
newpix[x+y*w] = pix[x+(y-1)*w];
}
}
}
}
return newpix;
}
效果:
Priwitt微分算子
Priwitt微分算子与Sobel微分算子类似,是一个奇数大小(3*3)的模板中定义其微分算子。只是模板系数不同。
D1=f(x-1,y-1) + f(x,y-1) + f(x+1,y-1) – f(x-1,y+1) – f(x,y+1) – f(x+1,y+1)
D2=f(x-1,y-1) + f(x-1,y) + f(x-1,y+1) – f(x+1,y-1) – f(x+1,y) – f(x+1, y+1)
G=sqrt(D1^2 + D2^2)
算法源代码6
/**
* priwitt微分算子
* @param srcPath 图片的存储位置
* @param distPath 图像要保存的存储位置
* @param formatName 图像要保存的存储位置
*/
public static void priwitt(String srcPath, String distPath, String formatName) {
BufferedImage img = readImg(srcPath);
int w = img.getWidth();
int h = img.getHeight();
int pix[] = new int[w*h];
pix= img.getRGB(0, 0, w, h, pix, 0, w);
pix = priwitt(pix, w, h);
img.setRGB(0, 0, w, h, pix, 0, w);
writeImg(img, formatName, distPath);
}
/**
* priwitt微分算子
* @param pix 像素矩阵数组
* @param w 矩阵的宽
* @param h 矩阵的高
* @return 处理后的像素矩阵
*/
public static int[] priwitt(int pix[], int w, int h) {
ColorModel cm = ColorModel.getRGBdefault();
int g1, g2, r;
int[] newpix = new int[w*h];
for(int y=0; y<h; y++) {
for(int x=0; x<w; x++) {
if(x!=0 && x!=w-1 && y!=0 && y!=h-1){
//G
g1 = cm.getRed(pix[x-1+(y-1)*w]) + cm.getRed(pix[x+(y-1)*w]) + cm.getRed(pix[x+1+(y-1)*w])
- cm.getRed(pix[x-1+(y+1)*w]) - cm.getRed(pix[x+(y+1)*w]) - cm.getRed(pix[x+1+(y+1)*w]);
g2 = cm.getRed(pix[x-1+(y-1)*w]) + cm.getRed(pix[x-1+(y)*w]) + cm.getRed(pix[x-1+(y+1)*w])
- cm.getRed(pix[x+1+(y-1)*w]) - cm.getRed(pix[x+1+(y)*w]) - cm.getRed(pix[x+1+( y+1)*w]);
r=(int) Math.round(Math.sqrt(g1*g1 + g2*g2));
newpix[x+y*w] = 255<<24 | r<<16 | r <<8 | r;
} else {
if(x == w-1) {
newpix[x+y*w] = pix[x-1+y*w];
}
if(y == h-1) {
newpix[x+y*w] = pix[x+(y-1)*w];
}
}
}
}
return newpix;
}
效果: