回顾
第二周主要内容仍然是关于图的算法，主要内容为：
-
最小生成树
-
最短路径
- Dijkstra算法：适用无负权值边的图
- DAG最短路径算法：使用拓扑排序
- Bellman-Ford算法：适用含负权值边的图
编程作业是SeamCarver：原题地址
题目
SeamCarving是一种调整图像尺寸的算法：从一幅图像中选出最不重要的像素并删去，在尽可能保留图像内容的情况下改变图像的尺寸。
original image
resized image
上图就是SeamCarving算法的应用，原图尺寸为505-by-287，变换后的图片尺寸为355-by-287。虽然尺寸变了，但是没有发生拉伸扭曲，保留了原图的特征。
算法步骤：
- 计算每个像素点的权重
- 找到水平（垂直）方向上的权重最小的像素序列，称为seam
- 移除seam
vertical seam
备注：
- 像素点的权重计算使用
dual-gradient energy function,具体计算方法在原题中有。 - 从像素点
(i,j)出发(假设垂直方向)只能连接到下一行的相邻三个像素(i-1,j+1),(i,j+1),(i+1,j+1) - 坐标系与默认的不同：
(i,j)表示第j行，第i列
a 3-by-4 image
(0, 0) (1, 0) (2, 0)
(0, 1) (1, 1) (2, 1)
(0, 2) (1, 2) (2, 2)
(0, 3) (1, 3) (2, 3)
API:
public class SeamCarver {
public SeamCarver(Picture picture) // create a seam carver object based on the given picture
public Picture picture() // current picture
public int width() // width of current picture
public int height() // height of current picture
public double energy(int x, int y) // energy of pixel at column x and row y
public int[] findHorizontalSeam() // sequence of indices for horizontal seam
public int[] findVerticalSeam() // sequence of indices for vertical seam
public void removeHorizontalSeam(int[] seam) // remove horizontal seam from current picture
public void removeVerticalSeam(int[] seam) // remove vertical seam from current picture
}
解析
图像的表示使用alg4.jar中的Picture类。但是构造这个类的开销很大，在内部用一个二维数组作为类成员变量来表示图像中每个点，数组中存的值为此像素点
int类型的rbg值。在实现算法的时候使用此二维数组，只在public Picture picture()方法中生成Picture对象并返回。-
核心算法是找到某一方向上的seam，下面一步步思考：
- 首先可以把图像抽象成一个有向图，顶点是每一个像素点，每个顶点有三条边指向下一行（列）的相邻顶点。
- seam即是一条最短路径，权值就是最短路径上所有像素点的权重。
- 这是一个无环有向图（DAG），从时间复杂度考虑应该使用无环有向图的最短路径算法，而不是Dijkstra算法。
- 因此需要得到拓扑顺序，在这里不需要使用深度优先搜索来计算。以垂直方向为例，自上而下，每一行的拓扑顺序先于下一行，而每一行中各个顶点的顺序无关紧要。
- 因此在最短路径算法中，可以直接for循环自上而下遍历所有顶点，进行松弛（relax）操作。
水平和垂直方向：两个不同方向的算法实质是一样的，只要先对表示图像的二维数组进行转置，就能够复用代码。
java中二维数组实际是由一维数组的每个元素表示其他各个一维数组，根据题意，垂直方向的像素作为第二层数组，方便用System.arraycopy()来整体移动，因此我们实现removeHorizontalSeam(int[] seam)方法：即水平方向上每行移除一个像素点，再整体移动剩余像素点；而对于removeVerticalSeam(int[] seam)方法，只要转置二维数组、调用removeHorizontalSeam(int[] seam)、再转置二维数组。
代码
成员变量：
private int[][] colors;
构造方法：
public Picture picture() {
Picture picture = new Picture(colors.length, colors[0].length);
for (int i = 0; i < colors.length; i++) {
for (int j = 0; j < colors[0].length; j++) {
Color color = new Color(this.colors[i][j]);
picture.set(i, j, color);
}
}
return picture;
}
width()和height()：
public int width() {
return this.colors.length;
}
public int height() {
return this.colors[0].length;
}
energy()：使用dual-gradient energy function来计算
public double energy(int x, int y) {
if (x < 0 || x > this.width() - 1 || y < 0 || y > this.height() - 1) {
throw new IndexOutOfBoundsException();
}
if (x == 0 || x == this.width() - 1 || y == 0 || y == this.height() - 1) {
return 1000.0;
} else {
int deltaXRed = red(colors[x - 1][y]) -
red(colors[x + 1][y]);
int deltaXGreen = green(colors[x - 1][y]) -
green(colors[x + 1][y]);
int deltaXBlue = blue(colors[x - 1][y]) -
blue(colors[x + 1][y]);
int deltaYRed = red(colors[x][y - 1]) - red(colors[x][y + 1]);
int deltaYGreen = green(colors[x][y - 1]) - green(colors[x][y + 1]);
int deltaYBlue = blue(colors[x][y - 1]) - blue(colors[x][y + 1]);
return Math.sqrt(Math.pow(deltaXRed, 2) + Math.pow(deltaXBlue, 2) + Math.pow(deltaXGreen, 2) + Math.pow(deltaYRed, 2) + Math.pow(deltaYBlue, 2) + Math.pow(deltaYGreen, 2));
}
}
findVerticalSeam()
- 先计算所有顶点的distTo值，即从第一行到此顶点的最短路径上所有顶点权值之和
- 找出最后一行中distTo值最小的顶点，此顶点属于seam
- 根据nodeTo，逐行逆向找到每个属于seam的顶点
public int[] findVerticalSeam() {
int n = this.width() * this.height();
int[] seam = new int[this.height()];
int[] nodeTo = new int[n];
double[] distTo = new double[n];
for (int i = 0; i < n; i++) {
if (i < width())
distTo[i] = 0;
else
distTo[i] = Double.POSITIVE_INFINITY;
}
for (int i = 0; i < height(); i++) {
for (int j = 0; j < width(); j++) {
for (int k = -1; k <= 1; k++) {
if (j + k < 0 || j + k > this.width() - 1 || i + 1 < 0 || i + 1 > this.height() - 1) {
continue;
} else {
if (distTo[index(j + k, i + 1)] > distTo[index(j, i)] + energy(j, i)) {
distTo[index(j + k, i + 1)] = distTo[index(j, i)] + energy(j, i);
nodeTo[index(j + k, i + 1)] = index(j, i);
}
}
}
}
}
// find min dist in the last row
double min = Double.POSITIVE_INFINITY;
int index = -1;
for (int j = 0; j < width(); j++) {
if (distTo[j + width() * (height() - 1)] < min) {
index = j + width() * (height() - 1);
min = distTo[j + width() * (height() - 1)];
}
}
// find seam one by one
for (int j = 0; j < height(); j++) {
int y = height() - j - 1;
int x = index - y * width();
seam[height() - 1 - j] = x;
index = nodeTo[index];
}
return seam;
}
private int index(int x, int y) {
return width() * y + x;
}
findHorizontalSeam()
public int[] findHorizontalSeam() {
this.colors = transpose(this.colors);
int[] seam = findVerticalSeam();
this.colors = transpose(this.colors);
return seam;
}
removeHorizontalSeam
public void removeHorizontalSeam(int[] seam) {
if (height() <= 1) throw new IllegalArgumentException();
if (seam == null) throw new NullPointerException();
if (seam.length != width()) throw new IllegalArgumentException();
for (int i = 0; i < seam.length; i++) {
if (seam[i] < 0 || seam[i] > height() - 1)
throw new IllegalArgumentException();
if (i < width() - 1 && Math.pow(seam[i] - seam[i + 1], 2) > 1)
throw new IllegalArgumentException();
}
int[][] updatedColor = new int[width()][height() - 1];
for (int i = 0; i < seam.length; i++) {
if (seam[i] == 0) {
System.arraycopy(this.colors[i], seam[i] + 1, updatedColor[i], 0, height() - 1);
} else if (seam[i] == height() - 1) {
System.arraycopy(this.colors[i], 0, updatedColor[i], 0, height() - 1);
} else {
System.arraycopy(this.colors[i], 0, updatedColor[i], 0, seam[i]);
System.arraycopy(this.colors[i], seam[i] + 1, updatedColor[i], seam[i], height() - seam[i] - 1);
}
}
this.colors = updatedColor;
}
removeVerticalSeam:转置后复用removeHorizontalSeam(int[] seam)
public void removeVerticalSeam(int[] seam) {
this.colors = transpose(this.colors);
removeHorizontalSeam(seam);
this.colors = transpose(this.colors);
}
最后是转置方法：
private int[][] transpose(int[][] origin) {
if (origin == null) throw new NullPointerException();
if (origin.length < 1) throw new IllegalArgumentException();
int[][] result = new int[origin[0].length][origin.length];
for (int i = 0; i < origin[0].length; i++) {
for (int j = 0; j < origin.length; j++) {
result[i][j] = origin[j][i];
}
}
return result;
}
成绩
ASSESSMENT SUMMARY
Compilation: PASSED
API: PASSED
Findbugs: PASSED
Checkstyle: FAILED (3 warnings)
Correctness: 31/31 tests passed
Memory: 7/7 tests passed
Timing: 6/6 tests passed
Aggregate score: 100.00%
[Compilation: 5%, API: 5%, Findbugs: 0%, Checkstyle: 0%, Correctness: 60%, Memory: 10%, Timing: 20%]
完整代码和测试用例在GitHub上，欢迎讨论
https://github.com/michael0905/SeamCarver
