EAS PBO: ImageEditor

Sore.... kali ini mimin mau menampilkan hasil EAS mimin. Kali ini mimin mau membuat aplikasi bernama ImageEditor. Dimana aplikasi ini dapat mengedit gambar secara sederhana.

Untuk link soal: http://fajarbaskoro.blogspot.com/2018/12/evaluasi-akhir-semester-pbo-2018.html

1. Rancangan Interface. Sederhana saja, mirip dengan yang ini:

Hanya saja, untuk fungsi tambahannya ditaruh ditoolbar samping kiri dan dibawah fungsi resize (Smaller dan Larger)

2. Class diagram dari mimin:

Penjelasan:
ImageViewer: Bagian kelas utama untuk aplikasi editor gambar, GUI dari aplikasi, Inisialisasi semua komponen, dan untuk memulai aplikasi (atau bisa disebut juga dengan class Main)
ImageFileManager: Untuk memuat dan menyimpan gambar
ImagePanel: Komponen swing yang dapat menampilkan class OFImage
OFImage: Kelas yang mendefinisikan gambar dalam format OF (Object First)
Filter: Kelas Abstrak untuk menjalankan semua filter yang ada didalam program
EdgeFilter: Membuat filter efek edge
FishEyeFilter: Membuat filter efek mata ikan (Hasil akan seperti di kamera GoPro)
GrayScaleFilter: Membuat filter efek hitam putih
PixelizeFilter: Membuat filter efek banyak pixel atau kotak2 (seperti gambar pecah)
SolarizeFilter: Membuat filter efek Solarize
MirrorFilter: Membuat filter efek mirror atau terbalik (Seperti kaca)
SmoothFilter: Membuat filter efek smooth atau halus
InvertFilter: Membuat filter efek invert atau warna yang dibalik (atau negatif)
ThresholdFilter: Membuat filter efek Threshold
LighterFilter: Mencerahkan gambar
DarkerFilter: Menggelapkan gambar

3. Source Code:

ImageViewer.java

 import java.awt.*;  
 import java.awt.event.*;  
 import java.awt.image.*;  
 import javax.swing.*;  
 import javax.swing.border.*;  
   
 import java.io.File;  
   
 import java.util.List;  
 import java.util.ArrayList;  
 import java.util.Iterator;  
   
 public class ImageViewer  
 {  
   private static final String VERSION = "Version 1.0";  
   private static JFileChooser fileChooser = new JFileChooser(System.getProperty("user.dir"));  
   
   private JFrame frame;  
   private ImagePanel imagePanel;  
   private JLabel filenameLabel;  
   private JLabel statusLabel;  
   private JButton smallerButton;  
   private JButton largerButton;  
   private JButton textButton;  
   private JButton cropButton;   
   private JButton rotButton;   
   private JButton rotaButton;   
   private JButton rotateButton;  
   private OFImage currentImage;  
     
   private List<Filter> filters;  
     
   public ImageViewer()  
   {  
     currentImage = null;  
     filters = createFilters();  
     makeFrame();  
   }  
   
   private void makeText()   
   {   
    if(currentImage != null) {   
     int width = currentImage.getWidth();   
     int height = currentImage.getHeight();   
     int xPosition = Integer.parseInt(JOptionPane.showInputDialog("X Position"));   
     int yPosition = Integer.parseInt(JOptionPane.showInputDialog("Y Position"));   
     float fontSize = Float.parseFloat(JOptionPane.showInputDialog("Font Size"));   
     String addText = JOptionPane.showInputDialog("Type Something..");   
     OFImage newImage = new OFImage(width, height);    
     for(int y = 0; y < height; y++) {   
      for(int x = 0; x < width; x++) {   
       Color col = currentImage.getPixel(x, y);   
       newImage.setPixel(x, y, col);   
      }   
     }   
     Graphics g = newImage.getGraphics();   
     g.setFont(g.getFont().deriveFont(fontSize));   
     g.drawString(addText, xPosition, yPosition);   
     g.dispose();   
     currentImage = newImage;   
     imagePanel.setImage(currentImage);   
    }   
   }   
     
   private void openFile()  
   {  
     int returnVal = fileChooser.showOpenDialog(frame);  
   
     if(returnVal != JFileChooser.APPROVE_OPTION) {  
       return;  
     }  
     File selectedFile = fileChooser.getSelectedFile();  
     currentImage = ImageFileManager.loadImage(selectedFile);  
       
     if(currentImage == null) {  
       JOptionPane.showMessageDialog(frame,  
           "The file was not in a recognized image file format.",  
           "Image Load Error",  
           JOptionPane.ERROR_MESSAGE);  
       return;  
     }  
   
     imagePanel.setImage(currentImage);  
     setButtonsEnabled(true);  
     showFilename(selectedFile.getPath());  
     showStatus("File loaded.");  
     frame.pack();  
   }  
   
   private void close()  
   {  
     currentImage = null;  
     imagePanel.clearImage();  
     showFilename(null);  
     setButtonsEnabled(false);  
   }  
   
   private void saveAs()  
   {  
     if(currentImage != null) {  
       int returnVal = fileChooser.showSaveDialog(frame);  
     
       if(returnVal != JFileChooser.APPROVE_OPTION) {  
         return;  
       }  
       File selectedFile = fileChooser.getSelectedFile();  
       ImageFileManager.saveImage(currentImage, selectedFile);  
         
       showFilename(selectedFile.getPath());  
     }  
   }  
   
   private void quit()  
   {  
     System.exit(0);  
   }  
   
   private void applyFilter(Filter filter)  
   {  
     if(currentImage != null) {  
       filter.apply(currentImage);  
       frame.repaint();  
       showStatus("Applied: " + filter.getName());  
     }  
     else {  
       showStatus("No image loaded.");  
     }  
   }  
   
   private void showAbout()  
   {  
     JOptionPane.showMessageDialog(frame,   
           "ImageEditor\n" + VERSION,  
           "About ImageEditor",   
           JOptionPane.INFORMATION_MESSAGE);  
   }  
   
   private void makeLarger()  
   {  
     if(currentImage != null) {  
       int width = currentImage.getWidth();  
       int height = currentImage.getHeight();  
       OFImage newImage = new OFImage(width * 2, height * 2);  
   
       for(int y = 0; y < height; y++) {  
         for(int x = 0; x < width; x++) {  
           Color col = currentImage.getPixel(x, y);  
           newImage.setPixel(x * 2, y * 2, col);  
           newImage.setPixel(x * 2 + 1, y * 2, col);  
           newImage.setPixel(x * 2, y * 2 + 1, col);  
           newImage.setPixel(x * 2+1, y * 2 + 1, col);  
         }  
       }  
         
       currentImage = newImage;  
       imagePanel.setImage(currentImage);  
       frame.pack();  
     }  
   }  
     
   private void makeSmaller()  
   {  
     if(currentImage != null) {  
       int width = currentImage.getWidth() / 2;  
       int height = currentImage.getHeight() / 2;  
       OFImage newImage = new OFImage(width, height);  
   
       for(int y = 0; y < height; y++) {  
         for(int x = 0; x < width; x++) {  
           newImage.setPixel(x, y, currentImage.getPixel(x * 2, y * 2));  
         }  
       }  
         
       currentImage = newImage;  
       imagePanel.setImage(currentImage);  
       frame.pack();  
     }  
   }  
     
   private void crop()   
   {   
    if (currentImage != null)   
    {   
     int width = currentImage.getWidth();   
     int height = currentImage.getWidth();   
     int xFrom = Integer.parseInt(JOptionPane.showInputDialog("x.to"));   
     int yFrom = Integer.parseInt(JOptionPane.showInputDialog("y.to"));   
     int xTo = Integer.parseInt(JOptionPane.showInputDialog("x.from"));   
     int yTo = Integer.parseInt(JOptionPane.showInputDialog("y.from"));   
     OFImage newImage = new OFImage(xTo - xFrom, yTo - yFrom);   
     for (int y = 0; y < yTo - yFrom; y++)   
     {   
      for (int x = 0; x < xTo - xFrom; x++)   
      {   
       newImage.setPixel(x, y, currentImage.getPixel(x + xFrom, y + yFrom));   
      }   
     }   
     currentImage = newImage;   
     imagePanel.setImage(currentImage);   
     frame.pack();   
    }   
   }   
     
   private void showFilename(String filename)  
   {  
     if(filename == null) {  
       filenameLabel.setText("No file displayed.");  
     }  
     else {  
       filenameLabel.setText("File: " + filename);  
     }  
   }  
     
   private void showStatus(String text)  
   {  
     statusLabel.setText(text);  
   }  
     
   private void setButtonsEnabled(boolean status)  
   {  
     smallerButton.setEnabled(status);   
     largerButton.setEnabled(status);   
     cropButton.setEnabled(status);   
     rotButton.setEnabled(status);   
     rotaButton.setEnabled(status);   
     rotateButton.setEnabled(status);  
   }  
     
   private List<Filter> createFilters()  
   {  
     List<Filter> filterList = new ArrayList<Filter>();  
     filterList.add(new DarkerFilter("Darker"));  
     filterList.add(new LighterFilter("Lighter"));  
     filterList.add(new ThresholdFilter("Threshold"));  
     filterList.add(new InvertFilter("Invert"));  
     filterList.add(new SolarizeFilter("Solarize"));  
     filterList.add(new SmoothFilter("Smooth"));  
     filterList.add(new PixelizeFilter("Pixelize"));  
     filterList.add(new MirrorFilter("Mirror"));  
     filterList.add(new GrayScaleFilter("Grayscale"));  
     filterList.add(new EdgeFilter("Edge Detection"));  
     filterList.add(new FishEyeFilter("Fish Eye"));  
       
     return filterList;  
   }  
     
   private void makeFrame()  
   {  
     frame = new JFrame("ImageEditor");  
     JPanel contentPane = (JPanel)frame.getContentPane();  
     contentPane.setBorder(new EmptyBorder(6, 6, 6, 6));  
   
     makeMenuBar(frame);  
       
     contentPane.setLayout(new BorderLayout(6, 6));  
       
     imagePanel = new ImagePanel();  
     imagePanel.setBorder(new EtchedBorder());  
     contentPane.add(imagePanel, BorderLayout.CENTER);  
   
     filenameLabel = new JLabel();  
     contentPane.add(filenameLabel, BorderLayout.NORTH);  
   
     statusLabel = new JLabel(VERSION);  
     contentPane.add(statusLabel, BorderLayout.SOUTH);  
       
     JPanel toolbar = new JPanel();  
     toolbar.setLayout(new GridLayout(0, 1));  
       
     smallerButton = new JButton("Smaller");  
     smallerButton.addActionListener(new ActionListener() {  
         public void actionPerformed(ActionEvent e) { makeSmaller(); }  
         });  
     toolbar.add(smallerButton);  
       
     largerButton = new JButton("Larger");  
     largerButton.addActionListener(new ActionListener() {  
         public void actionPerformed(ActionEvent e) { makeLarger(); }  
         });  
     toolbar.add(largerButton);  
       
     textButton = new JButton("Add Text");   
     textButton.addActionListener(new ActionListener() {   
         public void actionPerformed(ActionEvent e) { makeText();}   
         });   
     toolbar.add(textButton);  
       
     cropButton = new JButton("Crop");   
     cropButton.addActionListener(new ActionListener() {   
         public void actionPerformed(ActionEvent e) { crop(); }   
         });   
     toolbar.add(cropButton);   
       
     rotateButton = new JButton("Rotate 180");   
     rotateButton.addActionListener(new ActionListener() {   
         public void actionPerformed(ActionEvent e) { Rotate180(); }   
         });   
     toolbar.add(rotateButton);   
       
     rotButton = new JButton("Rotate Counterclockwise");   
     rotButton.addActionListener(new ActionListener() {   
         public void actionPerformed(ActionEvent e) { Rotate90left(); }   
         });   
     toolbar.add(rotButton);   
       
     rotaButton = new JButton("Rotate Clockwise");   
     rotaButton.addActionListener(new ActionListener() {   
          public void actionPerformed(ActionEvent e) { Rotate90right(); }   
         });   
     toolbar.add(rotaButton);  
   
     JPanel flow = new JPanel();  
     flow.add(toolbar);  
       
     contentPane.add(flow, BorderLayout.WEST);  
        
     showFilename(null);  
     setButtonsEnabled(false);  
     frame.pack();  
       
     Dimension d = Toolkit.getDefaultToolkit().getScreenSize();  
     frame.setLocation(d.width/2 - frame.getWidth()/2, d.height/2 - frame.getHeight()/2);  
     frame.setVisible(true);  
   }  
     
   private void Rotate180() {   
    if(currentImage != null) {   
     int width = currentImage.getWidth();   
     int height = currentImage.getHeight();   
     OFImage newImage = new OFImage(width, height);   
   
     for(int y = 0; y < height; y++) {   
      for(int x = 0; x < width; x++) {   
       Color col = currentImage.getPixel(width-x-1, height-y-1);   
       newImage.setPixel(x, y, col);   
      }   
     }   
     currentImage = newImage;   
     imagePanel.setImage(currentImage);   
     frame.pack();   
    }   
   }   
     
   private void Rotate90left() {   
    if(currentImage != null) {   
     int width = currentImage.getWidth();   
     int height = currentImage.getHeight();   
     OFImage newImage = new OFImage(height, width);   
     for(int y = 0; y < height; y++) {   
      for(int x = 0; x < width; x++) {   
       Color col = currentImage.getPixel(x, y);   
       newImage.setPixel(y, width-x-1, col);   
      }   
     }   
     currentImage = newImage;   
     imagePanel.setImage(currentImage);   
     frame.pack();   
    }   
   }   
     
   private void Rotate90right() {   
    if(currentImage != null) {   
     int width = currentImage.getWidth();   
     int height = currentImage.getHeight();   
     OFImage newImage = new OFImage(height, width);   
     for(int y = 0; y < height; y++) {   
      for(int x = 0; x < width; x++) {   
       Color col = currentImage.getPixel(x, y);   
       newImage.setPixel(height-y-1, x, col);   
      }   
     }   
     currentImage = newImage;   
     imagePanel.setImage(currentImage);   
     frame.pack();   
    }   
   }   
     
     
   private void makeMenuBar(JFrame frame)  
   {  
     final int SHORTCUT_MASK =  
       Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();  
   
     JMenuBar menubar = new JMenuBar();  
     frame.setJMenuBar(menubar);  
       
     JMenu menu;  
     JMenuItem item;  
       
     menu = new JMenu("File");  
     menubar.add(menu);  
       
     item = new JMenuItem("Open...");  
       item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, SHORTCUT_MASK));  
       item.addActionListener(new ActionListener() {  
                 public void actionPerformed(ActionEvent e) { openFile(); }  
               });  
     menu.add(item);  
   
     item = new JMenuItem("Close");  
       item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W, SHORTCUT_MASK));  
       item.addActionListener(new ActionListener() {  
                 public void actionPerformed(ActionEvent e) { close(); }  
               });  
     menu.add(item);  
     menu.addSeparator();  
   
     item = new JMenuItem("Save As...");  
       item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, SHORTCUT_MASK));  
       item.addActionListener(new ActionListener() {  
                 public void actionPerformed(ActionEvent e) { saveAs(); }  
               });  
     menu.add(item);  
     menu.addSeparator();  
       
     item = new JMenuItem("Quit");  
       item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q, SHORTCUT_MASK));  
       item.addActionListener(new ActionListener() {  
                 public void actionPerformed(ActionEvent e) { quit(); }  
               });  
     menu.add(item);  
   
     menu = new JMenu("Filter");  
     menubar.add(menu);  
       
     for(final Filter filter : filters) {  
       item = new JMenuItem(filter.getName());  
       item.addActionListener(new ActionListener() {  
                 public void actionPerformed(ActionEvent e) {   
                   applyFilter(filter);  
                 }  
               });  
        menu.add(item);  
      }  
   
     menu = new JMenu("Help");  
     menubar.add(menu);  
       
     item = new JMenuItem("About ImageEditor...");  
       item.addActionListener(new ActionListener() {  
                 public void actionPerformed(ActionEvent e) { showAbout(); }  
               });  
     menu.add(item);  
   
   }  
 }  
   

ImageFileManager.java:

 import java.awt.image.*;  
 import javax.imageio.*;  
 import java.io.*;  
   
 public class ImageFileManager  
 {  
   private static final String IMAGE_FORMAT = "jpg";  
   
   public static OFImage loadImage(File imageFile)  
   {  
     try {  
       BufferedImage image = ImageIO.read(imageFile);  
       if(image == null || (image.getWidth(null) < 0)) {  
         return null;  
       }  
       return new OFImage(image);  
     }  
     catch(IOException exc) {  
       return null;  
     }  
   }  
   
   public static void saveImage(OFImage image, File file)  
   {  
     try {  
       ImageIO.write(image, IMAGE_FORMAT, file);  
     }  
     catch(IOException exc) {  
       return;  
     }  
   }  
 }  
   

ImagePanel.java

 import java.awt.*;  
 import javax.swing.*;  
 import java.awt.image.*;  
   
 public class ImagePanel extends JComponent  
 {  
   private int width, height;  
   
   private OFImage panelImage;  
   
   public ImagePanel()  
   {  
     width = 360;  
     height = 240;  
     panelImage = null;  
   }  
   
   public void setImage(OFImage image)  
   {  
     if(image != null) {  
       width = image.getWidth();  
       height = image.getHeight();  
       panelImage = image;  
       repaint();  
     }  
   }  
     
   public void clearImage()  
   {  
     Graphics imageGraphics = panelImage.getGraphics();  
     imageGraphics.setColor(Color.LIGHT_GRAY);  
     imageGraphics.fillRect(0, 0, width, height);  
     repaint();  
   }  
   
   public Dimension getPreferredSize()  
   {  
     return new Dimension(width, height);  
   }  
   
   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);  
     }  
   }  
 }  
   

OFImage.java

 import java.awt.*;  
 import java.awt.image.*;  
 import javax.swing.*;  
   
 public class OFImage extends BufferedImage  
 {  
   public OFImage(BufferedImage image)  
   {  
      super(image.getColorModel(), image.copyData(null),   
         image.isAlphaPremultiplied(), null);  
   }  
   
   public OFImage(int width, int height)  
   {  
     super(width, height, TYPE_INT_RGB);  
   }  
   
   public void setPixel(int x, int y, Color col)  
   {  
     int pixel = col.getRGB();  
     setRGB(x, y, pixel);  
   }  
     
   public Color getPixel(int x, int y)  
   {  
     int pixel = getRGB(x, y);  
     return new Color(pixel);  
   }  
 }  
   

Filter.java (Note: Filter ini adalah kelas abstrak)

 public abstract class Filter  
 {  
   private String name;  
   public Filter(String name)  
   {  
     this.name = name;  
   }  
   public String getName()  
   {  
     return name;  
   }  
   public abstract void apply(OFImage image);  
 }  

DarkerFilter.java

 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.java

 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());  
       }  
     }  
   }  
 }  

ThresholdFilter.java

 import java.awt.Color;  
 public class ThresholdFilter extends Filter  
 {  
      public ThresholdFilter(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);  
         }  
       }  
     }  
   }  
 }  

FishEyeFilter.java

 import java.awt.Color;  
 public class FishEyeFilter extends Filter  
 {  
   private final static int SCALE = 20;  
   private final static double TWO_PI = 2 * Math.PI;  
   public FishEyeFilter(String name)  
   {  
     super(name);  
   }  
   public void apply(OFImage image)  
   {  
     int height = image.getHeight();  
     int width = image.getWidth();  
     OFImage original = new OFImage(image);  
     int[] xa = computeXArray(width);  
     int[] ya = computeYArray(height);  
     for(int y = 0; y < height; y++) {  
       for(int x = 0; x < width; x++) {  
         image.setPixel(x, y, original.getPixel(x + xa[x], y + ya[y]));  
       }  
     }  
   }  
   private int[] computeXArray(int width)  
   {  
     int[] xArray = new int[width];  
     for(int i=0; i < width; i++) {  
       xArray[i] = (int)(Math.sin( ((double)i / width) * TWO_PI) * SCALE);  
     }  
     return xArray;  
   }  
   private int[] computeYArray(int height)  
   {  
     int[] yArray = new int[height];  
     for(int i=0; i < height; i++) {  
       yArray[i] = (int)(Math.sin( ((double)i / height) * TWO_PI) * SCALE);  
     }  
     return yArray;  
   }  
 }  

EdgeFilter.java

 import java.awt.Color;  
   
 import java.util.List;  
 import java.util.ArrayList;  
   
   
 public class EdgeFilter extends Filter  
 {  
   private static final int TOLERANCE = 20;  
     
   private OFImage original;  
   private int width;  
   private int height;  
   
   public EdgeFilter(String name)  
   {  
     super(name);  
   }  
   
   public void apply(OFImage image)  
   {  
     original = new OFImage(image);  
     width = original.getWidth();  
     height = original.getHeight();  
       
     for(int y = 0; y < height; y++) {  
       for(int x = 0; x < width; x++) {  
         image.setPixel(x, y, edge(x, y));  
       }  
     }  
   }  
   
   private Color edge(int xpos, int ypos)  
   {  
     List<Color> pixels = new ArrayList<Color>(9);  
       
     for(int y = ypos-1; y <= ypos+1; y++) {  
       for(int x = xpos-1; x <= xpos+1; x++) {  
         if( x >= 0 && x < width && y >= 0 && y < height ) {  
           pixels.add(original.getPixel(x, y));  
         }  
       }  
     }  
   
     return new Color(255 - diffRed(pixels), 255 - diffGreen(pixels), 255 - diffBlue(pixels));  
   }  
   
   private int diffRed(List<Color> pixels)  
   {  
     int max = 0;  
     int min = 255;  
     for(Color color : pixels) {  
       int val = color.getRed();  
       if(val > max) {  
         max = val;  
       }  
       if(val < min) {  
         min = val;  
       }  
     }  
     int difference = max - min - TOLERANCE;  
     if(difference < 0) {  
       difference = 0;  
     }  
     return difference;  
   }  
   
   private int diffGreen(List<Color> pixels)  
   {  
     int max = 0;  
     int min = 255;  
     for(Color color : pixels) {  
       int val = color.getGreen();  
       if(val > max) {  
         max = val;  
       }  
       if(val < min) {  
         min = val;  
       }  
     }  
     int difference = max - min - TOLERANCE;  
     if(difference < 0) {  
       difference = 0;  
     }  
     return difference;  
   }  
   
   private int diffBlue(List<Color> pixels)  
   {  
     int max = 0;  
     int min = 255;  
     for(Color color : pixels) {  
       int val = color.getBlue();  
       if(val > max) {  
         max = val;  
       }  
       if(val < min) {  
         min = val;  
       }  
     }  
     int difference = max - min - TOLERANCE;  
     if(difference < 0) {  
       difference = 0;  
     }  
     return difference;  
   }  
   
 }  
   

GrayScaleFilter.java:

 import java.awt.Color;  
   
 public class GrayScaleFilter extends Filter  
 {  
      public GrayScaleFilter(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 pix = image.getPixel(x, y);  
         int avg = (pix.getRed() + pix.getGreen() + pix.getBlue()) / 3;  
         image.setPixel(x, y, new Color(avg, avg, avg));  
       }  
     }  
   }  
 }  
   

PixelizeFilter.java:

 import java.awt.Color;  
   
 public class PixelizeFilter extends Filter  
 {  
   public PixelizeFilter(String name)  
   {  
     super(name);  
   }  
   
   public void apply(OFImage image)  
   {  
     final int PIXEL_SIZE = 5;  
     int width = image.getWidth();  
     int height = image.getHeight();  
       
     for(int y = 0; y < height; y += PIXEL_SIZE) {  
       for(int x = 0; x < width; x += PIXEL_SIZE) {  
         Color pix = image.getPixel(x, y);  
         for(int dy = y; dy < y + PIXEL_SIZE; dy++) {  
           for(int dx = x; dx < x + PIXEL_SIZE; dx++) {  
             if( dx < width && dy < height )  
               image.setPixel(dx, dy, pix);  
           }  
         }  
       }  
     }  
   }  
 }  
   

SolarizeFilter.java

 import java.awt.Color;  
   
 public class SolarizeFilter extends Filter  
 {  
   public SolarizeFilter(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 pix = image.getPixel(x, y);  
         int red = pix.getRed();  
         if(red <= 127) {  
           red = 255 - red;  
         }  
         int green = pix.getGreen();  
         if(green <= 127) {  
           green = 255 - green;  
         }  
         int blue = pix.getBlue();  
         if(blue <= 127) {  
           blue = 255 - blue;  
         }  
         image.setPixel(x, y, new Color(red, green, blue));  
       }  
     }  
   }  
   
 }  
   

MirrorFilter.java

 import java.awt.Color;  
   
 public class MirrorFilter extends Filter  
 {  
      public MirrorFilter(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 / 2; x++) {  
         Color left = image.getPixel(x, y);  
         image.setPixel(x, y, image.getPixel(width - 1 - x, y));  
         image.setPixel(width - 1 - x, y, left);  
       }  
     }  
   }  
 }  
   

SmoothFilter.java

 import java.awt.Color;  
 import java.util.List;  
 import java.util.ArrayList;  
   
 public class SmoothFilter extends Filter  
 {  
   private OFImage original;  
   private int width;  
   private int height;  
     
   public SmoothFilter(String name)  
   {  
     super(name);  
   }  
   
   public void apply(OFImage image)  
   {  
     original = new OFImage(image);  
     width = original.getWidth();  
     height = original.getHeight();  
       
     for(int y = 0; y < height; y++) {  
       for(int x = 0; x < width; x++) {  
         image.setPixel(x, y, smooth(x, y));  
       }  
     }  
   }  
   
   private Color smooth(int xpos, int ypos)  
   {  
     List<Color> pixels = new ArrayList<Color>(9);  
       
     for(int y = ypos - 1; y <= ypos + 1; y++) {  
       for(int x = xpos - 1; x <= xpos + 1; x++) {  
         if( x >= 0 && x < width && y >= 0 && y < height )  
           pixels.add(original.getPixel(x, y));  
       }  
     }  
   
     return new Color(avgRed(pixels), avgGreen(pixels), avgBlue(pixels));  
   }  
   
   private int avgRed(List<Color> pixels)  
   {  
     int total = 0;  
     for(Color color : pixels) {  
       total += color.getRed();  
     }  
     return total / pixels.size();  
   }  
   
   private int avgGreen(List<Color> pixels)  
   {  
     int total = 0;  
     for(Color color : pixels) {  
       total += color.getGreen();  
     }  
     return total / pixels.size();  
   }  
   
   private int avgBlue(List<Color> pixels)  
   {  
     int total = 0;  
     for(Color color : pixels) {  
       total += color.getBlue();  
     }  
     return total / pixels.size();  
   }  
 }  
   

InvertFilter.java

 import java.awt.Color;  
   
 public class InvertFilter extends Filter  
 {  
   public InvertFilter(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 pix = image.getPixel(x, y);  
         image.setPixel(x, y, new Color(255 - pix.getRed(),  
                         255 - pix.getGreen(),  
                         255 - pix.getBlue()));  
       }  
     }  
   }  
 }  
   

Hasil output program, dalam bentuk Video: