Java Image Processing Cookbook
网上看到一本e-book，名字叫“Java Image Processing Cookbook”（链接：http://www.lac.inpe.br/~rafael.santos/JIPCookbook 作者：Rafael Santos）。尚未全部写完。
最近正好有些照片需要处理，对这个话题比较感兴趣，给出一些中文翻译和source代码，供以后参考。
如何比较两幅图片以便知道是否相同？
人们经常会询问如何比较两幅图片以便知道它们是否相同，希望能给出个简单的函数或者方法来返回一个true/false，或是0-1之间的值。其中，0代表不同，1代表相同，而0-1之间的值则被看作是不同的相似程度。现实中有许多这方面的应用，比如，想要了解是否违反了肖像权，出于安全目的而进行的人群中的脸部识别，语义学上的图片检索，以及宇宙飞船的可视化导航等等。
不幸的是图片内容的比较可不是一件简单的任务，相反，在大多数情况下是件非常棘手的事。
例如，考虑下面的几幅图片。它们中的大多数都反映了同一种动物，因此在某些情况下它们被认为是相同的（比如想要在网上查找栅栏后的哺乳动物），而在另外一些场合却被认为是完全不相同的（比如想要查找松鼠抬脸或是栅栏后的大型哺乳动物）。
问题是计算机无法去“看”一副图片，并且去和别的图片进行“比较”来决定它们的内容是否相同。考虑下这里会有多少变量我们需要处理：图片中的每个物体都有形状，大小，方向，颜色，纹理等等；同样的物体在不同的图片里会有不同的位置，大小，方向或亮度，或是它们的混合。我们应该如何处理这些不同呢？无视还是重视？我们要给每个物体赋予不同的“权重”以便在比较中使得某些方面的测量要比另外些更重要吗？小的物体可能会在某些图片中丢失，我们要忽略它们吗？如果一个物体是背景的话我们需要考虑进行比较吗？那什么又是所谓的背景呢？
比较图片内容
如果你想从语义上比较图片的话，你面对的将是一个艰巨的任务，用简单的算法是无法完成的。你可能会不得不处理图片，抽取出一些特征来映射到那些语义上的物体，即使这些特征在某些方面（诸如位置，大小）是不同的，然后再比较这些物体的特征而不是像素或其它图片特征。
你看，图片内容比较确实不是一件简单的事情，但是如果我们决定把问题简单化，那么事情就会变得简单起来。与其问“这些图片里的物体是否一致？”，我们可以这样问“这张图片里的一些地方是否在某种程度上和另一张里的相似？”。现在我们可以用一些图片处理技术来解决这个问题了。
可以解决这个问题的一些步骤是：
1. 如果需要，预处理图片（诸如增强对比度，滤除干扰等）。
2. 图片分段。即把图片分成若干区域，把相近的像素放在同一个区域。这可以用region-growing，mathematical morphology, clustering or classification等算法。有很多这样的算法，只要google下“image segmentation”和别的关键字就可以得到很多信息。
3. 为每个区域创建描述符。描述符由区域计算得到，可以包含形状，面积，周长，洞的数目，区域的一般颜色，纹理，方向，位置等等。
4. 如果需要，再做一次图片分段。如果某些区域被认为是同一个物体则可以将它们合并。注意这步可能需要具备对物体和任务的深入了解，且经常和要解决的任务有关。
5. 如果需要，根据手头的任务过滤区域，去除掉那些跟任务无关的小区域或者不重要的区域（这里又需要具备对任务的理解）。
6. 保存图片的区域描述符以便未来处理，重复上述步骤处理其它图片。
7. 用描述符来比较图片的内容。可以使用很多算法：pattern matching, classification, clustering, artificial intelligence and data mining in general。
注意上述步骤仅仅是一般方法，并不保证能够解决特殊的任务。还要注意有很多可能的算法能够用于这些步骤，而且每种算法又会有很多变种和参数，因此使用不恰当的算法将会导致失败-要知道自己正在做什么，这很重要，这样你才会得到预期的，有用的结果。
还要记住一点的是，对我们人类来说，指出哪些图片是“松鼠仰脸”或者“小的啮齿动物挂在栅栏上”是很容易的事情，但是仅仅用一些图片处理算法是轻易做不到这点的。
简单图片比较
有时候，对图片只做简单的相似性比较也是很有用的。例如，考虑下面这个任务：请找出跟你手上有的那张内容相似的所有图片来，但不必保证他们代表或包含有相同的物体-仅仅是差不多相似就行了。很显然，这样结果将会找出磁盘上所有的图片来，只要相似就可以。
有多种解决方案，不过，它们都要求从图片里抽出一些特征，用来和其他图片里的特征作比较，并且，还要计算相似程度。当然，根据你的喜好这些可以做得很简单也可以做得很复杂。
作为例子，让我们选择一个简单的特征抽取方法和相似度计算来说明。参见下图：
| 用于这个测试的特征将是个25RGB的三棱锥，对照左图上的25个方格子上的平均RGB值。这个图片将被标准化成300*300的像素。只保存颜色均值，其他特征都被舍弃。每个格子是30*30像素。 因此图片将由25*3个特征向量代表。为了计算A，B两张图片的相似度，我们将取出每张图片的25个格子，计算它们间的Euclidean距离并累计。 |
之所以选择这个方法是因为它简单易懂，容易实现，并且能很容易被读者修改。它混合了颜色和空间信息，比起像素与像素的比较或者是整幅图片的均值比较，这种方法被认为更健壮。但是，它确实非常简单，不能期望在任何情况下都表现出色，而仅仅只能当作个例子。
下面将用24张测试图片作例子来验证上述方法（图片略），源代码是 NaiveSimilarityFinder.java。它有一个GUI，允许用户选择一个参照图片A，然后读取同一个目录下所有的图片，将他们归一化成相同的大小（300*300），抽取出特征值，计算与A的特征值的距离，并按照从最近距离到最远距离的顺序显示出来。
NaiveSimilarityFinder.java
1 /*
2 * Part of the Java Image Processing Cookbook, please see
3 * http://www.lac.inpe.br/~rafael.santos/JIPCookbook/index.jsp
4 * for information on usage and distribution.
5 * Rafael Santos ([email protected])
6 */
7 package howto.compare;
8
9 import java.awt.BorderLayout;
10 import java.awt.Color;
11 import java.awt.Container;
12 import java.awt.Font;
13 import java.awt.GridLayout;
14 import java.awt.image.RenderedImage;
15 import java.awt.image.renderable.ParameterBlock;
16 import java.io.File;
17 import java.io.IOException;
18
19 import javax.imageio.ImageIO;
20 import javax.media.jai.InterpolationNearest;
21 import javax.media.jai.JAI;
22 import javax.media.jai.iterator.RandomIter;
23 import javax.media.jai.iterator.RandomIterFactory;
24 import javax.swing.JFileChooser;
25 import javax.swing.JFrame;
26 import javax.swing.JLabel;
27 import javax.swing.JOptionPane;
28 import javax.swing.JPanel;
29 import javax.swing.JScrollPane;
30
31 import com.sun.media.jai.widget.DisplayJAI;
32 /**
33 * This class uses a very simple, naive similarity algorithm to compare an image
34 * with all others in the same directory.
35 */
36 public class NaiveSimilarityFinder extends JFrame
37 {
38 // The reference image "signature" (25 representative pixels, each in R,G,B).
39 // We use instances of Color to make things simpler.
40 private Color[][] signature;
41 // The base size of the images.
42 private static final int baseSize = 300;
43 // Where are all the files?
44 private static final String basePath =
45 "/home/rafael/Pesquisa/ImageSimilarity";
46
47 /*
48 * The constructor, which creates the GUI and start the image processing task.
49 */
50 public NaiveSimilarityFinder(File reference) throws IOException
51 {
52 // Create the GUI
53 super("Naive Similarity Finder");
54 Container cp = getContentPane();
55 cp.setLayout(new BorderLayout());
56 // Put the reference, scaled, in the left part of the UI.
57 RenderedImage ref = rescale(ImageIO.read(reference));
58 cp.add(new DisplayJAI(ref), BorderLayout.WEST);
59 // Calculate the signature vector for the reference.
60 signature = calcSignature(ref);
61 // Now we need a component to store X images in a stack, where X is the
62 // number of images in the same directory as the original one.
63 File[] others = getOtherImageFiles(reference);
64 JPanel otherPanel = new JPanel(new GridLayout(others.length, 2));
65 cp.add(new JScrollPane(otherPanel), BorderLayout.CENTER);
66 // For each image, calculate its signature and its distance from the
67 // reference signature.
68 RenderedImage[] rothers = new RenderedImage[others.length];
69 double[] distances = new double[others.length];
70 for (int o = 0; o < others.length; o++)
71 {
72 rothers[o] = rescale(ImageIO.read(others[o]));
73 distances[o] = calcDistance(rothers[o]);
74 }
75 // Sort those vectors *together*.
76 for (int p1 = 0; p1 < others.length - 1; p1++)
77 for (int p2 = p1 + 1; p2 < others.length; p2++)
78 {
79 if (distances[p1] > distances[p2])
80 {
81 double tempDist = distances[p1];
82 distances[p1] = distances[p2];
83 distances[p2] = tempDist;
84 RenderedImage tempR = rothers[p1];
85 rothers[p1] = rothers[p2];
86 rothers[p2] = tempR;
87 File tempF = others[p1];
88 others[p1] = others[p2];
89 others[p2] = tempF;
90 }
91 }
92 // Add them to the UI.
93 for (int o = 0; o < others.length; o++)
94 {
95 otherPanel.add(new DisplayJAI(rothers[o]));
96 JLabel ldist = new JLabel("<html>" + others[o].getName() + "<br>"
97 + String.format("% 13.3f", distances[o]) + "</html>");
98 ldist.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 36));
99 System.out.printf("<td class=\"simpletable legend\"> <img src=\"MiscResources/ImageSimilarity/icons/miniicon_%s\" alt=\"Similarity result\"><br>% 13.3f</td>\n", others[o].getName(),distances[o]);
100 otherPanel.add(ldist);
101 }
102 // More GUI details.
103 pack();
104 setVisible(true);
105 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
106 }
107
108 /*
109 * This method rescales an image to 300,300 pixels using the JAI scale
110 * operator.
111 */
112 private RenderedImage rescale(RenderedImage i)
113 {
114 float scaleW = ((float) baseSize) / i.getWidth();
115 float scaleH = ((float) baseSize) / i.getHeight();
116 // Scales the original image
117 ParameterBlock pb = new ParameterBlock();
118 pb.addSource(i);
119 pb.add(scaleW);
120 pb.add(scaleH);
121 pb.add(0.0F);
122 pb.add(0.0F);
123 pb.add(new InterpolationNearest());
124 // Creates a new, scaled image and uses it on the DisplayJAI component
125 return JAI.create("scale", pb);
126 }
127
128 /*
129 * This method calculates and returns signature vectors for the input image.
130 */
131 private Color[][] calcSignature(RenderedImage i)
132 {
133 // Get memory for the signature.
134 Color[][] sig = new Color[5][5];
135 // For each of the 25 signature values average the pixels around it.
136 // Note that the coordinate of the central pixel is in proportions.
137 float[] prop = new float[]
138 {1f / 10f, 3f / 10f, 5f / 10f, 7f / 10f, 9f / 10f};
139 for (int x = 0; x < 5; x++)
140 for (int y = 0; y < 5; y++)
141 sig[x][y] = averageAround(i, prop[x], prop[y]);
142 return sig;
143 }
144
145 /*
146 * This method averages the pixel values around a central point and return the
147 * average as an instance of Color. The point coordinates are proportional to
148 * the image.
149 */
150 private Color averageAround(RenderedImage i, double px, double py)
151 {
152 // Get an iterator for the image.
153 RandomIter iterator = RandomIterFactory.create(i, null);
154 // Get memory for a pixel and for the accumulator.
155 double[] pixel = new double[3];
156 double[] accum = new double[3];
157 // The size of the sampling area.
158 int sampleSize = 15;
159 // Sample the pixels.
160 for (double x = px * baseSize - sampleSize; x < px * baseSize + sampleSize; x++)
161 {
162 for (double y = py * baseSize - sampleSize; y < py * baseSize
163 + sampleSize; y++)
164 {
165 iterator.getPixel((int) x, (int) y, pixel);
166 accum[0] += pixel[0];
167 accum[1] += pixel[1];
168 accum[2] += pixel[2];
169 }
170 }
171 // Average the accumulated values.
172 accum[0] /= sampleSize * sampleSize * 4;
173 accum[1] /= sampleSize * sampleSize * 4;
174 accum[2] /= sampleSize * sampleSize * 4;
175 return new Color((int) accum[0], (int) accum[1], (int) accum[2]);
176 }
177
178 /*
179 * This method calculates the distance between the signatures of an image and
180 * the reference one. The signatures for the image passed as the parameter are
181 * calculated inside the method.
182 */
183 private double calcDistance(RenderedImage other)
184 {
185 // Calculate the signature for that image.
186 Color[][] sigOther = calcSignature(other);
187 // There are several ways to calculate distances between two vectors,
188 // we will calculate the sum of the distances between the RGB values of
189 // pixels in the same positions.
190 double dist = 0;
191 for (int x = 0; x < 5; x++)
192 for (int y = 0; y < 5; y++)
193 {
194 int r1 = signature[x][y].getRed();
195 int g1 = signature[x][y].getGreen();
196 int b1 = signature[x][y].getBlue();
197 int r2 = sigOther[x][y].getRed();
198 int g2 = sigOther[x][y].getGreen();
199 int b2 = sigOther[x][y].getBlue();
200 double tempDist = Math.sqrt((r1 - r2) * (r1 - r2) + (g1 - g2)
201 * (g1 - g2) + (b1 - b2) * (b1 - b2));
202 dist += tempDist;
203 }
204 return dist;
205 }
206
207 /*
208 * This method get all image files in the same directory as the reference.
209 * Just for kicks include also the reference image.
210 */
211 private File[] getOtherImageFiles(File reference)
212 {
213 File dir = new File(reference.getParent());
214 // List all the image files in that directory.
215 File[] others = dir.listFiles(new JPEGImageFileFilter());
216 return others;
217 }
218
219 /*
220 * The entry point for the application, which opens a file with an image that
221 * will be used as reference and starts the application.
222 */
223 public static void main(String[] args) throws IOException
224 {
225 JFileChooser fc = new JFileChooser(basePath);
226 fc.setFileFilter(new JPEGImageFileFilter());
227 int res = fc.showOpenDialog(null);
228 // We have an image!
229 if (res == JFileChooser.APPROVE_OPTION)
230 {
231 File file = fc.getSelectedFile();
232 new NaiveSimilarityFinder(file);
233 }
234 // Oops!
235 else
236 {
237 JOptionPane.showMessageDialog(null,
238 "You must select one image to be the reference.", "Aborting...",
239 JOptionPane.WARNING_MESSAGE);
240 }
241 }
242
辅助类：
JPEGImageFileFilter.java
1 /*
2 * Part of the Java Image Processing Cookbook, please see
3 * http://www.lac.inpe.br/~rafael.santos/JIPCookbook/index.jsp
4 * for information on usage and distribution.
5 * Rafael Santos ([email protected])
6 */
7 package howto.compare;
8
9 import java.io.File;
10
11 import javax.swing.filechooser.FileFilter;
12
13 /*
14 * This class implements a generic file name filter that allows the listing/selection
15 * of JPEG files.
16 */
17 public class JPEGImageFileFilter extends FileFilter implements java.io.FileFilter
18 {
19 public boolean accept(File f)
20 {
21 if (f.getName().toLowerCase().endsWith(".jpeg")) return true;
22 if (f.getName().toLowerCase().endsWith(".jpg")) return true;
23 return false;
24 }
25 public String getDescription()
26 {
27 return "JPEG files";
28 }
29
30 }
上述程序在帮助整理大量的重复拍摄的数码照片（只有细微的一些差别）方面很有用。当然，对该程序稍作修改即可增强其功能。