initial commit pj1 1st part

Author: bjrara

build.gradle

@@ -15,3 +15,10 @@ project(':homework') {
     testCompile 'junit:junit:4.11'
   }
 }
+
+project(':project') {
+  dependencies {
+    testCompile 'junit:junit:4.11'
+    compile files('libs/jai_core.jar')
+  }
+}

project/libs/jai_codec.jar

@@ -0,0 +1,90 @@
+package com.offline.training.project.pj1;
+
+/* Blur.java */
+
+/* DO NOT CHANGE THIS FILE. */
+/* YOUR SUBMISSION MUST WORK CORRECTLY WITH _OUR_ COPY OF THIS FILE. */
+
+/* You may wish to make temporary changes or insert println() statements     */
+/* while testing your code.  When you're finished testing and debugging,     */
+/* though, make sure your code works with the original version of this file. */
+
+/**
+ *  The Blur class is a program that reads an image file in TIFF format, blurs
+ *  it with a 3x3 box blurring kernel, writes the blurred image as a TIFF file,
+ *  and displays both images.
+ *
+ *  The Blur program takes up to two parameters.  The first parameter is
+ *  the name of the TIFF-format file to read.  (The output image file is
+ *  constructed by adding "blur_" to the beginning of the input filename.)
+ *  An optional second parameter specifies the number of iterations of the
+ *  box blurring operation.  (The default is one iteration.)  For example, if
+ *  you run
+ *
+ *         java Blur engine.tiff 5
+ *
+ *  then Blur will read engine.tiff, perform 5 iterations of blurring, and
+ *  write the blurred image to blur_engine.tiff .
+ *
+ *  @author Joel Galenson and Jonathan Shewchuk
+ */
+
+public class Blur {
+  
+  /**
+   *  blurFile() reads a TIFF image file, blurs it, write the blurred image to
+   *  a new TIFF image file, and displays both images.
+   *
+   *  @param filename the name of the input TIFF image file.
+   *  @param numIterations the number of iterations of blurring to perform.
+   */
+  private static void blurFile(String filename, int numIterations) {
+    System.out.println("Reading image file " + filename);
+    PixImage image = ImageUtils.readTIFFPix(filename);
+
+    System.out.println("Blurring image file.");
+    PixImage blurred = image.boxBlur(numIterations);
+
+    String blurname = "blur_" + filename;
+    System.out.println("Writing blurred image file " + blurname);
+    TIFFEncoder.writeTIFF(blurred, blurname);
+    /*
+    TIFFEncoder.writeTIFF(new RunLengthEncoding(edges), "rle" + blurname);
+    */
+
+    System.out.println("Displaying input image and blurred image.");
+    System.out.println("Close the image to quit.");
+    ImageUtils.displayTIFFs(new PixImage[] { image, blurred });
+  }
+
+  /**
+   *  main() reads the command-line arguments and initiates the blurring.
+   *
+   *  The first command-line argument is the name of the image file.
+   *  An optional second argument is number of iterations of blurring.
+   *
+   *  @param args the usual array of command-line argument Strings.
+   */
+  public static void main(String[] args) {
+    if (args.length == 0) {
+      System.out.println("usage:  java Blur imagefile [iterations]");
+      System.out.println("  imagefile is an image in TIFF format.");
+      System.out.println("  interations is the number of blurring iterations" +
+                         " (default 1).");
+      System.out.println("The blurred image is written to blur_imagefile.");
+      System.exit(0);
+    }
+
+    int numIterations = 1;
+    if (args.length > 1) {
+      try {
+        numIterations = Integer.parseInt(args[1]);
+      } catch (NumberFormatException ex) {
+        System.err.println("The second argument must be a number.");
+        System.exit(1);
+      }
+    }
+
+    blurFile(args[0], numIterations);
+  }
+}

project/libs/jai_core.jar

@@ -0,0 +1,189 @@
+package com.offline.training.project.pj1;
+
+/* ImageUtils.java */
+
+/* DO NOT CHANGE THIS FILE. */
+/* YOUR SUBMISSION MUST WORK CORRECTLY WITH _OUR_ COPY OF THIS FILE. */
+
+/* You may wish to make temporary changes or insert println() statements     */
+/* while testing your code.  When you're finished testing and debugging,     */
+/* though, make sure your code works with the original version of this file. */
+
+/**
+ *  The ImageUtils class reads and writes TIFF file, converting to and from
+ *  pixel arrays in PixImage format or run-length encodings in
+ *  RunLengthEncoding format.  Methods are also included for displaying images
+ *  in PixImage format.
+ *
+ *  @author Joel Galenson
+ **/
+
+import java.awt.Color;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.image.BufferedImage;
+
+import javax.media.jai.JAI;
+import javax.media.jai.RenderedImageAdapter;
+import javax.swing.Box;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+
+/**
+ *  ImageUtils contains utilities for reading, writing, and displaying images.
+ * 
+ *  It uses JAI to read and write TIFF files, as the standard libraries cannot
+ *  read them.
+ * 
+ *  All image data is in RGB format (see BufferedImage.getRGB).
+ */
+public class ImageUtils {
+
+  /**
+   *  buffer2PixImage() converts a BufferedImage to a PixImage.
+   *  @param bImage the image to convert.
+   *  @return a PixImage with the same pixels as the BufferedImage.
+   */
+  private static PixImage buffer2PixImage(BufferedImage bImage) {
+    PixImage pImage = new PixImage(bImage.getWidth(), bImage.getHeight());
+    for (int x = 0; x < bImage.getWidth(); x++) {
+      for (int y = 0; y < bImage.getHeight(); y++) {
+        Color color = new Color(bImage.getRGB(x, y));
+        pImage.setPixel(x, y, (short) color.getRed(), (short) color.getGreen(),
+                        (short) color.getBlue());
+      }
+    }
+    return pImage;
+  }
+
+  /**
+   *  pixImage2buffer() converts a PixImage to a BufferedImage.
+   *  @param pImage the image to convert.
+   *  @return a BufferedImage with the same pixels as the PixImage.
+   */
+  static BufferedImage pixImage2buffer(PixImage pImage) {
+    BufferedImage bImage = new BufferedImage(pImage.getWidth(),
+                                             pImage.getHeight(),
+                                             BufferedImage.TYPE_INT_ARGB);
+    for (int x = 0; x < bImage.getWidth(); x++) {
+      for (int y = 0; y < bImage.getHeight(); y++) {
+        bImage.setRGB(x, y, new Color(pImage.getRed(x, y),
+                                      pImage.getGreen(x, y),
+                                      pImage.getBlue(x, y)).getRGB());
+      }
+    }
+    return bImage;
+  }
+
+  /**
+   *  readTIFF() reads an image from a file and formats it as a BufferedImage.
+   *  @param filename the name of the file to read.
+   *  @return a BufferedImage of the file
+   */
+  private static BufferedImage readTIFF(String filename) {
+    return (new RenderedImageAdapter(JAI.create("fileload", filename)))
+           .getAsBufferedImage();
+  }
+
+  /**
+   *  readTIFFPix() reads an image from a file and formats it as a PixImage.
+   *  @param filename the name of the file to read.
+   *  @return a PixImage of the file
+   */
+  public static PixImage readTIFFPix(String filename) {
+    return buffer2PixImage(readTIFF(filename));
+  }
+
+  /**
+   *  readTIFFRLE() reads an image from a file and formats it as a run-length
+   *  encoding.
+   *  @param filename the name of the file to read.
+   *  @return a RunLengthEncoding of the file.
+   */
+  public static RunLengthEncoding readTIFFRLE(String filename) {
+    return new RunLengthEncoding(readTIFFPix(filename));
+  }
+
+  /**
+   *  writeTIFF() writes a BufferedImage to a specified file in TIFF format.
+   *  @param rle the input BufferedImage.
+   *  @param filename the output filename.
+   */
+  private static void writeTIFF(BufferedImage image, String filename) {
+    JAI.create("filestore", image, filename, "tiff");
+  }
+
+  /**
+   *  writeTIFF() writes a PixImage to a specified file in TIFF format.
+   *  @param image the input PixImage.
+   *  @param filename the output filename.
+   */
+  public static void writeTIFF(PixImage image, String filename) {
+    writeTIFF(pixImage2buffer(image), filename);
+  }
+
+  /**
+   *  writeTIFF() writes a run-length encoding to a specified file in TIFF
+   *  format.
+   *  @param rle the input run-length encoded image.
+   *  @param filename the output filename.
+   */
+  public static void writeTIFF(RunLengthEncoding rle, String filename) {
+    writeTIFF(rle.toPixImage(), filename);
+  }
+
+  /**
+   *  displayFrame displays a JFrame and pauses until the window is closed.
+   *  @param frame a JFrame to display.
+   */
+  private static void displayFrame(final JFrame frame) {
+    try {
+      synchronized (ImageUtils.class) {
+        frame.setResizable(false);
+        frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+        frame.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent event) {
+              synchronized (ImageUtils.class) {
+                ImageUtils.class.notify();
+                frame.dispose();
+              }
+            }
+          });
+        frame.pack();
+        frame.setVisible(true);
+        ImageUtils.class.wait();
+      }
+    } catch (InterruptedException e) {
+      System.out.println("Interrupted Exception in displayFrame().");
+      e.printStackTrace();
+    }
+  }
+
+  /**
+   *  displayTIFFs displays a sequence of PixImages and pauses until the window
+   *  is closed.
+   *  @param images an array of PixImages to display.
+   */
+  public static void displayTIFFs(PixImage[] images) {
+    JFrame frame = new JFrame();
+    Box box = Box.createHorizontalBox();
+    for (int i = 0; i < images.length; i++) {
+      box.add(new JLabel(new ImageIcon(pixImage2buffer(images[i]))));
+      if (i < images.length - 1) {
+        box.add(Box.createHorizontalStrut(10));
+      }
+    }
+    frame.add(box);
+    displayFrame(frame);
+  }
+
+  /**
+   *  displayTIFF displays a PixIamge and pauses until the window is closed.
+   *  @param image the PixImage to display.
+   */
+  public static void displayTIFF(PixImage image) {
+    displayTIFFs(new PixImage[] { image });
+  }
+}