人工智能应用实例：图片降噪
场景设置
对白色背景、黑色前景的黑白图片进行降噪处理，可以假定背景部分多于前景。
图1 从左往右：原图、噪声图、降噪图
降噪模型
我们可以对图片建立这样一个两层的二维模型，底层表示原图，顶层表示任意的噪声图，xi为原图第i个像素，yi为噪声图第i个像素，xi、yi的取值只有1和-1，1表示白色，-1表示黑色。
图2 图片模型
显然，我们对噪声图任取的一个像素yi可以有以下3个推测：
1、这个像素更加可能是白色，因为白色背景多于黑色前景。
2、这个像素应该和它周围的几个像素颜色一致。
3、如果不能确定这个像素在原图到底是白色还是黑色，那么更有可能原图就是现在噪声图的这个颜色，因为毕竟噪声像素是少量的，大部分像素维持了原图的颜色。
基于此，可以对噪声图定义一个能量公式：
注意：这里的xi、yi颠倒过来了，xi为噪声图，yi为原图。
公式中三个参数都是正实数，第一项表示对噪声图每个像素的值求和，第二项表示对噪声图每个像素与之周围像素差异的求和，第三项表示噪声图像素与原图像素的差异求和。显然基于我们以上的3点推测，越接近原图，噪声图的能量值应该越低。
降噪过程
有了这样一个图片模型和噪声图能量公式，我们就可以对图片降噪了。图片降噪基于一个很简单的想法，我们对整个噪声图的每个像素扫描一次(也可以扫描多遍)，看看每次改变该像素点的颜色能否使整个噪声图的能量值降低，如果能量值降低了，我们就接受这一次改动，否则，该像素颜色保持不变。
不过，这里还存在一个问题，我们不可能取得能量公式中原图每个像素yi的值！其实这也无妨，可以简单地用每次降噪处理(一次只处理一个像素)得到的新的降噪图去逼近原图，而一开始采用的就是噪声图。因此，每次降噪处理都要计算两个能量值，一个是当前已经得到的降噪图(被用来逼近原图，即xi、yi都是自身)的能量值，另一个是改变一个像素颜色得到的图片(xi为自身，yi为前面得到的降噪图)的能量值。
Java代码实现
由于某些限制，代码实现中图片读写使用了十分复杂的手段，实际上可以通过Java的imageio包进行简化。
另外，图片能量公式的3个参数这里采用了手动指定的方式：fa=0.0，fb=1.0，fc=2.1，还可以通过更加智能的算法自动学习得到，比如爬山算法、模拟退火算法、遗传算法。
// ImageIOer.java
/**
* > ImageIOer
*
* ImageIOer is a class to read and save images,
* and it implements IImageIO.
*
* @author RuanShiHai
*/
import java.awt.*;
import java.awt.image.*;
import java.io.*;
import javax.imageio.*;
public class ImageIOer {
/**
* Read a bmp image
* @param filePath - the image file to read
* @return an Image object of the image
*/
public Image myRead(String filePath) {
try {
// the length of BMP file header
int bfLen = 14;
// the length of BMP information header
int biLen = 40;
FileInputStream fs = new FileInputStream(filePath);
byte[] bf = new byte[bfLen];
byte[] bi = new byte[biLen];
// read BMP file header
fs.read(bf, 0, bfLen);
// read BMP information header
fs.read(bi, 0, biLen);
// pixels value of width
int biWidth = ((((int) bi[7] & 0xff) << 24) |
(((int) bi[6] & 0xff) << 16) | (((int) bi[5] & 0xff) << 8) |
((int) bi[4] & 0xff));
// pixels value of height
int biHeight = (((int) bi[11] & 0xff) << 24) |
(((int) bi[10] & 0xff) << 16) | (((int) bi[9] & 0xff) << 8) |
((int) bi[8] & 0xff);
// the number of bits of each pixel
int biBitCount = ((((int) bi[15] & 0xff) << 8) |
((int) bi[14] & 0xff));
// the size of bytes of the image
int biSizeImage = ((((int) bi[23] & 0xff) << 24) |
(((int) bi[22] & 0xff) << 16) | (((int) bi[21] & 0xff) << 8) |
((int) bi[20] & 0xff));
// only processes 24bits bmp image
if (biBitCount != 24) {
fs.close();
return null;
}
// the number of bytes to be padded after each row
int nPad = (biSizeImage / biHeight) - (biWidth * 3);
// read pixels data from image into a byte array
byte[] bRGB = new byte[biSizeImage];
fs.read(bRGB, 0, biSizeImage);
fs.close();
int index = 0;
int[] data = new int[biWidth * biHeight];
// store pixels in an array of int type
for (int i = biHeight - 1; i >= 0; i--) {
for (int j = 0; j < biWidth; j++) {
data[(i * biWidth) + j] = (((int) 255 << 24) |
(((int) bRGB[index + 2] & 0xff) << 16) |
(((int) bRGB[index + 1] & 0xff) << 8) |
((int) bRGB[index] & 0xff));
index += 3;
}
index += nPad;
}
// create an Image object
Toolkit kit = Toolkit.getDefaultToolkit();
Image image = kit.createImage(new MemoryImageSource(biWidth,
biHeight, data, 0, biWidth));
return image;
} catch (Exception e) {
e.printStackTrace();
System.out.println("Caught exception in loadbitmap!");
}
return null;
}
/**
* Store an Image as a bmp image file
* @param image - Image object to be saved as a bmp image file
* @param filePath - the name of the bmp image file
* @return the Image object
*/
public Image myWrite(Image image, String filePath) {
try {
File imgFile = new File(filePath + ".bmp");
BufferedImage bi = new BufferedImage(image.getWidth(null),
image.getHeight(null), BufferedImage.TYPE_INT_RGB);
Graphics2D biContext = bi.createGraphics();
// get a BufferedImage object from an Image object
biContext.drawImage(image, 0, 0, null);
biContext.dispose();
ImageIO.write(bi, "bmp", imgFile);
return image;
} catch (Exception e) {
e.printStackTrace(System.out);
}
return null;
}
}
// PictureNoise.java
import java.awt.*;
import java.awt.image.*;
import java.io.*;
import java.util.Random;
import javax.imageio.*;
public class PictureNoise {
private static final double rate = 0.1;
private static final double fa = 0;
private static final double fb = 1.0;
private static final double fc = 2.1;
public void generateAPicture() {
try {
int width = 640;
int height = 480;
// 创建BufferedImage对象
Font font = new Font("微软雅黑", Font.BOLD, 160);
BufferedImage image = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
// 获取Graphics2D
Graphics2D g2d = image.createGraphics();
// 画图
g2d.setBackground(new Color(255, 255, 255));
g2d.setPaint(new Color(0, 0, 0));
g2d.clearRect(0, 0, width, height);
g2d.setFont(font);
g2d.drawString("Java", 140, 200);
g2d.drawString("Python", 40, 400);
// 释放对象
g2d.dispose();
// 保存文件
ImageIO.write(image, "bmp", new File("/home/ln/picture.bmp"));
} catch (Exception ex) {
ex.printStackTrace();
}
}
// generate a picture with noise
public Image getNoise(Image sourceImage) {
BufferedImage bi = new BufferedImage(sourceImage.getWidth(null),
sourceImage.getHeight(null), BufferedImage.TYPE_INT_RGB);
Graphics2D biContext = bi.createGraphics();
// get a BufferedImage object from an Image object
biContext.drawImage(sourceImage, 0, 0, null);
biContext.dispose();
// create an array of int type to store rgb values of each pixel
int[] rgbs = new int[bi.getWidth() * bi.getHeight()];
bi.getRGB(0, 0, bi.getWidth(), bi.getHeight(), rgbs, 0, bi.getWidth());
Random rd = new Random();
int index = 0;
for (int i = 0; i < bi.getHeight(); i++) {
for (int j = 0; j < bi.getWidth(); j++, index++) {
if (rd.nextDouble() < rate)
rgbs[index] = (rgbs[index] & 0xff000000)
| (~rgbs[index] & 0x00ffffff);
}
}
// create a new Image object
Toolkit kit = Toolkit.getDefaultToolkit();
Image image = kit.createImage(new MemoryImageSource(bi.getWidth(), bi
.getHeight(), rgbs, 0, bi.getWidth()));
return image;
}
public Image reduceNoise(Image sourceImage, double fa, double fb, double fc) {
BufferedImage bi = new BufferedImage(sourceImage.getWidth(null),
sourceImage.getHeight(null), BufferedImage.TYPE_INT_RGB);
Graphics2D biContext = bi.createGraphics();
// get a BufferedImage object from an Image object
biContext.drawImage(sourceImage, 0, 0, null);
biContext.dispose();
// create an array of int type to store rgb values of each pixel
int[] rgbs = new int[bi.getWidth() * bi.getHeight()];
bi.getRGB(0, 0, bi.getWidth(), bi.getHeight(), rgbs, 0, bi.getWidth());
int height = bi.getHeight(), width = bi.getWidth();
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
double dd;
int d1, d2, d3;
d1 = 2;
if ((rgbs[i * width + j] & 0x00ffffff) == 0)
d1 = -2;
d2 = 0;
int rc[][] = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
for (int k = 0; k < 4; k++) {
if (isValid(i + rc[k][0], j + rc[k][1], height, width)) {
if ((rgbs[(i + rc[k][0]) * width + j + rc[k][1]] & 0x00ffffff) == (rgbs[i
* width + j] & 0x00ffffff))
d2 += -2;
else
d2 += 2;
}
}
d2 *= 2;
d3 = -2;
dd = fa * d1 - fb * d2 - fc * d3;
if (dd < 0)
rgbs[i * width + j] = (rgbs[i * width + j] & 0xff000000)
| (~rgbs[i * width + j] & 0x00ffffff);
}
}
// create a new Image object
Toolkit kit = Toolkit.getDefaultToolkit();
Image image = kit.createImage(new MemoryImageSource(bi.getWidth(), bi
.getHeight(), rgbs, 0, bi.getWidth()));
return image;
}
private boolean isValid(int row, int col, int height, int width) {
return (row >= 0 && row < height && col >= 0 && col < width);
}
public static void main(String[] args) {
PictureNoise pictureNoise = new PictureNoise();
ImageIOer imageIOer = new ImageIOer();
pictureNoise.generateAPicture();
Image sourceImage = imageIOer.myRead("/picture.bmp");
Image noiseImage = pictureNoise.getNoise(sourceImage);
Image noNoiseImage = pictureNoise.reduceNoise(noiseImage, fa, fb, fc);
imageIOer.myWrite(noiseImage, "/picture_with_noise");
imageIOer.myWrite(noNoiseImage, "/picture_noise_processed");
}
}
