Tugas PBO-B: Image Viewer

Nama: Paramastri Ardiningrum
NRP: 05111740000019
Kelas: PBO-B

Hari ini, saya belajar membuat program Image Viewer yang dapat menampilkan image/gambar dari file dalam komputer saya dan menambahkan filter yang ada.

Kelas yang dibutuhkan antara lain:

ImageViewer
ImagePanel
OFImage
ImageFileManager
Filter (Abstract)
DarkerFilter
LighterFilter
TresholdFilter

Class ImageViewer

 /**  
  * ImageViewer class  
  *  
  * @author (Paramastri A)  
  * @version (26/11/2018)  
  */  
  import java.awt.*;   
  import java.awt.event.*;   
  import java.awt.image.*;   
  import javax.swing.*;   
  import java.io.File;   
 public class ImageViewer  
 {  
   // static fields:   
   private static final String VERSION = "Version 1.0";   
   private static JFileChooser fileChooser = new JFileChooser(System.getProperty("user.dir"));   
   // fields:   
   private JFrame frame;   
   private ImagePanel imagePanel;   
   private JLabel filenameLabel;   
   private JLabel statusLabel;   
   private OFImage currentImage;   
   /**   
   * Create an ImageViewer show it on screen.   
   */   
   public ImageViewer()   
   {   
    currentImage = null;   
    makeFrame();   
   }   
   // ---- implementation of menu functions ----   
   /**   
   * Open function: open a file chooser to select a new image file.   
   */   
   private void openFile()   
   {   
    int returnVal = fileChooser.showOpenDialog(frame);   
    if(returnVal != JFileChooser.APPROVE_OPTION) {   
     return; // cancelled   
    }   
    File selectedFile = fileChooser.getSelectedFile();   
    currentImage = ImageFileManager.loadImage(selectedFile);   
    if(currentImage == null) { // image file was not a valid image   
     JOptionPane.showMessageDialog(frame,   
       "The file was not in a recognized image file format.",   
       "Image Load Error",   
       JOptionPane.ERROR_MESSAGE);   
     return;   
    }   
    imagePanel.setImage(currentImage);   
    showFilename(selectedFile.getPath());   
    showStatus("File loaded.");   
    frame.pack();   
   }   
   /**   
   * Close function: close the current image.   
   */   
   private void close()   
   {   
    currentImage = null;   
    imagePanel.clearImage();   
    showFilename(null);   
   }   
   /**   
   * Quit function: quit the application.   
   */   
   private void quit()   
   {   
    System.exit(0);   
   }   
 }

Class ImagePanel

 /**  
  * ImagePanel class  
  *  
  * @author (Paramastri A)  
  * @version (26/11/2018)  
  */  
  import java.awt.*;   
  import javax.swing.*;   
  import java.awt.image.*;   
 public class ImagePanel extends JComponent   
 {  
   // The current width and height of this panel   
   private int width, height;   
   // An internal image buffer that is used for painting. For   
   // actual display, this image buffer is then copied to screen.   
   private OFImage panelImage;   
   /**   
   * Create a new, empty ImagePanel.   
   */   
   public ImagePanel()   
   {   
    width = 360; // arbitrary size for empty panel   
    height = 240;   
    panelImage = null;   
   }   
   /**   
   * Set the image that this panel should show.   
   *    
   * @param image The image to be displayed.   
   */   
   public void setImage(OFImage image)   
   {   
    if(image != null) {   
     width = image.getWidth();   
     height = image.getHeight();   
     panelImage = image;   
     repaint();   
    }   
   }   
   /**   
   * Clear the image on this panel.   
   */   
   public void clearImage()   
   {   
    Graphics imageGraphics = panelImage.getGraphics();   
    imageGraphics.setColor(Color.LIGHT_GRAY);   
    imageGraphics.fillRect(0, 0, width, height);   
    repaint();   
   }   
   // The following methods are redefinitions of methods   
   // inherited from superclasses.   
   /**   
   * Tell the layout manager how big we would like to be.   
   * (This method gets called by layout managers for placing   
   * the components.)   
   *    
   * @return The preferred dimension for this component.   
   */   
   public Dimension getPreferredSize()   
   {   
    return new Dimension(width, height);   
   }   
   /**   
   * This component needs to be redisplayed. Copy the internal image    
   * to screen. (This method gets called by the Swing screen painter    
   * every time it want this component displayed.)   
   *    
   * @param g The graphics context that can be used to draw on this component.   
   */   
   public void paintComponent(Graphics g)   
   {   
    Dimension size = getSize();   
    g.clearRect(0, 0, size.width, size.height);   
    if(panelImage != null) {   
     g.drawImage(panelImage, 0, 0, null);   
    }   
   }  
 }

Class OFImage

 /**  
  * OFImage class  
  *  
  * @author (Paramastri A)  
  * @version (26/11/2018)  
  */  
  import java.awt.*;   
  import java.awt.image.*;   
  import javax.swing.*;   
 public class OFImage extends BufferedImage   
 {  
   /**   
   * Create an OFImage copied from a BufferedImage.   
   * @param image The image to copy.   
   */   
   public OFImage(BufferedImage image)   
   {   
    super(image.getColorModel(), image.copyData(null),    
      image.isAlphaPremultiplied(), null);   
   }   
   /**   
   * Create an OFImage with specified size and unspecified content.   
   * @param width The width of the image.   
   * @param height The height of the image.   
   */   
   public OFImage(int width, int height)   
   {   
    super(width, height, TYPE_INT_RGB);   
   }   
   /**   
   * Set a given pixel of this image to a specified color. The   
   * color is represented as an (r,g,b) value.   
   * @param x The x position of the pixel.   
   * @param y The y position of the pixel.   
   * @param col The color of the pixel.   
   */   
   public void setPixel(int x, int y, Color col)   
   {   
    int pixel = col.getRGB();   
    setRGB(x, y, pixel);   
   }   
   /**   
   * Get the color value at a specified pixel position.   
   * @param x The x position of the pixel.   
   * @param y The y position of the pixel.   
   * @return The color of the pixel at the given position.   
   */   
   public Color getPixel(int x, int y)   
   {   
    int pixel = getRGB(x, y);   
    return new Color(pixel);   
   }   
 }

Class ImageFileManager

 /**  
  * ImageFileManager class  
  *  
  * @author (Paramastri A)  
  * @version (26/11/2018)  
  */  
  import java.awt.image.*;   
  import javax.imageio.*;   
  import java.io.*;   
 public class ImageFileManager  
 {  
   // A constant for the image format that this writer uses for writing.   
   // Available formats are "jpg" and "png".   
   private static final String IMAGE_FORMAT = "jpg";   
   /**   
   * Read an image file from disk and return it as an image. This method   
   * can read JPG and PNG file formats. In case of any problem (e.g the file    
   * does not exist, is in an undecodable format, or any other read error)    
   * this method returns null.   
   *    
   * @param imageFile The image file to be loaded.   
   * @return   The image object or null is it could not be read.   
   */   
   public static OFImage loadImage(File imageFile)   
   {   
    try {   
     BufferedImage image = ImageIO.read(imageFile);   
     if(image == null || (image.getWidth(null) < 0)) {   
      // we could not load the image - probably invalid file format   
      return null;   
     }   
     return new OFImage(image);   
    }   
    catch(IOException exc) {   
     return null;   
    }   
   }   
   /**   
   * Write an image file to disk. The file format is JPG. In case of any    
   * problem the method just silently returns.   
   *    
   * @param image The image to be saved.   
   * @param file The file to save to.   
   */   
   public static void saveImage(OFImage image, File file)   
   {   
    try {   
     ImageIO.write(image, IMAGE_FORMAT, file);   
    }   
    catch(IOException exc) {   
     return;   
    }   
   }   
 }

Filter

 /**  
  * Filter abstract class  
  *  
  * @author (Paramastri A)  
  * @version (26/11/2018)  
  */  
 public abstract class Filter  
 {  
   private String name;  
    /**  
    * Create a new filter with a given name.  
    */  
   public Filter(String name)  
   {  
   this.name = name;  
   }  
    /**  
    * Return the name of this filter.  
    *  
    * @return The name of this filter.  
    */  
   public String getName()  
   {  
   return name;  
   }  
   public abstract void apply(OFImage image);  
 }

DarkerFilter

 /**  
  * DarkerFilter class  
  *  
  * @author (your name)  
  * @version (a version number or a date)  
  */  
 public class DarkerFilter extends Filter  
 {  
   public DarkerFilter(String name)  
   {  
     super(name);  
   }  
   public void apply(OFImage image)  
   {  
     int height = image.getHeight();  
     int width = image.getWidth();  
     for(int y = 0; y < height; y++)   
     {  
       for(int x = 0; x < width; x++)   
       {  
         image.setPixel(  
         x, y, image.getPixel(x, y).darker());  
       }  
     }  
   }  
 }

LighterFilter

 /**  
  * LighterFilter class  
  *  
  * @author (Paramastri A)  
  * @version (26/11/2018)  
  */  
 public class LighterFilter extends Filter  
 {  
   public LighterFilter(String name)  
   {  
     super(name);  
   }  
   public void apply(OFImage image)  
   {  
      int height = image.getHeight();   
      int width = image.getWidth();   
      for(int y = 0; y < height; y++) {   
       for(int x = 0; x < width; x++) {   
        image.setPixel(x, y, image.getPixel(x, y).brighter());   
       }   
      }   
   }  
 }

TresholdFilter

 /**  
  * TresholdFilter class  
  *  
  * @author (Paramastri A)  
  * @version (26/11/2018)  
  */  
 import java.awt.Color;  
 public class TresholdFilter extends Filter  
 {  
   public TresholdFilter(String name)  
   {  
     super(name);  
   }  
   public void apply(OFImage image)  
   {  
      int height = image.getHeight();   
      int width = image.getWidth();   
      for(int y = 0; y < height; y++) {   
       for(int x = 0; x < width; x++) {  
        Color pixel = image.getPixel(x, y);   
        int brightness = (pixel.getRed() + pixel.getBlue() + pixel.getGreen()) / 3;   
        if(brightness <= 85) {   
         image.setPixel(x, y, Color.BLACK);   
        }   
        else if(brightness <= 170) {   
         image.setPixel(x, y, Color.GRAY);   
        }   
        else {   
         image.setPixel(x, y, Color.WHITE);   
        }  
       }   
      }  
   }  
 }

Run

Klik pada class ImageViewer dan jalankan fungsinya