Bootstrap project

1 files changed, 169 insertions, 0 deletions

diff --git a/src/test/java/Tests.java b/src/test/java/Tests.java
new file mode 100644
index 0000000..cbb154f
--- /dev/null
+++ b/src/test/java/Tests.java
@@ -0,0 +1,169 @@
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.internal.InexactComparisonCriteria;
+
+public class Tests {
+
+    // Tolerance used to compare two floating point numbers
+    private static final float EPSILON = 0.0001f;
+
+    // Check whether value is equal to expected integer
+    private void assertEquals(int expected, int actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    // Check whether value is approximately equal to expected floating point number
+    private void assertEquals(float expected, float actual) {
+        Assert.assertEquals(expected, actual, EPSILON);
+    }
+
+    // Check whether integer array has correct size and values
+    private void assertEquals(int[] expected, int[] actual) {
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    // Check whether integer two-dimensional array has correct size and values
+    private void assertEquals(int[][] expected, int[][] actual) {
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    // Check whether floating point two-dimensional array has correct size and similar values
+    private void assertEquals(float[][] expected, float[][] actual) {
+        new InexactComparisonCriteria(EPSILON).arrayEquals(null, expected, actual);
+    }
+
+    // Test based on example in section 3.1 (pixel coding)
+    @Test
+    public void testColorSinglePixel() {
+
+        // Check RGB components and gray level of this bluish color
+        int color = 0b00100000_11000000_11111111;
+        assertEquals(0.1254902f, Color.getRed(color));
+        assertEquals(0.7529412f, Color.getGreen(color));
+        assertEquals(1.0f, Color.getBlue(color));
+        assertEquals(0.6261438f, Color.getGray(color));
+
+        // Encode some colors
+        assertEquals(0x0000ff, Color.getRGB(0.0f, 0.0f, 1.0f));
+        assertEquals(0x7f7f7f, Color.getRGB(0.5f));
+        assertEquals(0x0000ff, Color.getRGB(-0.5f, 0, 2));
+        assertEquals(0x000000, Color.getRGB(-1.0f));
+
+    }
+
+    // Test based on example in section 3.2 (image coding)
+    @Test
+    public void testColorWholeImage() {
+
+        // A 2x2 image
+        int[][] image = {
+                {0x20c0ff, 0x123456},
+                {0xffffff, 0x000000}
+        };
+
+        // Convert to grayscale
+        float[][] gray = {
+                {0.62614375f, 0.20392157f},
+                {1.0f, 0.0f}
+        };
+        assertEquals(gray, Color.toGray(image));
+
+        // Convert back to integer representation
+        int[][] back = {
+                {0x9f9f9f, 0x343434},
+                {0xffffff, 0x000000}
+        };
+        assertEquals(back, Color.toRGB(gray));
+
+    }
+
+    // Test based on example in section 4.1 (image filtering)
+    @Test
+    public void testFilterConvolution() {
+
+        // A 2x2 grayscale image
+        float[][] gray = {
+                {0.5f, 1.0f},
+                {0.2f, 0.0f}
+        };
+
+        // Access some pixels
+        assertEquals(0.5f, Filter.at(gray, 0, 0));
+        assertEquals(0.2f, Filter.at(gray, 1, 0));
+        assertEquals(0.2f, Filter.at(gray, 2, -1));
+
+        // Apply smoothing and Sobel
+        assertEquals(new float[][]{
+                {0.49f, 0.62f},
+                {0.3f, 0.29f}
+        }, Filter.smooth(gray));
+        assertEquals(new float[][]{
+                {1.3f, 1.3f},
+                {-0.1f, -0.1f}
+        }, Filter.sobelX(gray));
+        assertEquals(new float[][]{
+                {-1.9f, -3.3f},
+                {-1.9f, -3.3f}
+        }, Filter.sobelY(gray));
+        assertEquals(new float[][]{
+                {2.302173f, 3.5468295f},
+                {1.9026297f, 3.3015149f}
+        }, Filter.sobel(gray));
+
+    }
+
+    // Test based on example in section 5.1 (shortest path)
+    @Test
+    public void testSeamPath() {
+
+        // Simple graph stored as an adjacency list
+        int[][] successors = new int[][]{
+            /* 0 -> */ {1, 3},
+                        /* 1 -> */ {2},
+                        /* 2 -> */ {},
+                        /* 3 -> */ {4},
+                        /* 4 -> */ {1, 5},
+                        /* 5 -> */ {2}
+        };
+        float[] costs = new float[]{
+                        /* 0 : */ 1.0f,
+                        /* 1 : */ 9.0f,
+                        /* 2 : */ 2.0f,
+                        /* 3 : */ 1.0f,
+                        /* 4 : */ 3.0f,
+                        /* 5 : */ 1.0f
+        };
+
+        // Compute and check shortest path
+        int[] vertices = Seam.path(successors, costs, 0, 2);
+        assertEquals(new int[]{0, 3, 4, 5, 2}, vertices);
+
+    }
+
+    // Test based on example in section 5.2 (resizing)
+    @Test
+    public void testSeamResize() {
+
+        // A 3x3 image
+        int[][] image = {
+                {0x888888, 0x666666, 0xcccccc},
+                {0x000000, 0x111111, 0x222222},
+                {0xbbbbbb, 0xffffff, 0x666666}
+        };
+        float[][] gray = Color.toGray(image);
+
+        // Find best seam, using gray level as energy
+        int[] seam = Seam.find(gray);
+        assertEquals(new int[]{1, 1, 2}, seam);
+
+        // Remove seam
+        int[][] resized = Seam.shrink(image, seam);
+        assertEquals(new int[][]{
+                {0x888888, 0xcccccc},
+                {0x000000, 0x222222},
+                {0xbbbbbb, 0xffffff}
+        }, resized);
+
+    }
+
+}