TrabalhoProcessamento.java

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.swing.*;
import java.awt.GridLayout;
import java.util.Scanner;
import java.awt.Color;
import java.awt.image;

public class TrabalhoProcessamento {
    public static void main (String[] args) {
        /* Cria a janela e define a ação ao clicar no botão de fechar e seu
           tipo de layout.
        */
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new GridLayout(2, 2));

        // Carrega imagem original na memória.
        // Caso, por alguma razão, falhe, exibe mensagem de alerta e termina.
        BufferedImage originalImage;
        try {
            originalImage = ImageIO.read(new File("lena.png"));
        } catch (IOException ex) {
            JOptionPane.showMessageDialog(null, "Error: " + ex.toString());
            return;
        }

        // Cria  label para exibir a imagem original.
        // Notar que o label exibe a imagem diretamente da memória.
        JLabel originalImageLabel = new JLabel(new ImageIcon(originalImage));
        frame.add(originalImageLabel);

        // Passa a imagem original para Sépia e a coloca num label.
        BufferedImage sepImage = convertToSepia(originalImage);
        JLabel sepImageLabel = new JLabel(new ImageIcon(sepImage));
        frame.add(sepImageLabel);

        // Imagem binária - preto e branco.
        BufferedImage bwImage = ConvertToBinary(originalImage);
        JLabel bwImageLabel = new JLabel(new ImageIcon(bwImage));
        frame.add(bwImageLabel);

        // Borramento da imagem.
        BufferedImage sharpenFilter = FiltroSharpen(originalImage);
        JLabel sharImageLabel = new JLabel(new ImageIcon(sharpenFilter));
        frame.add(sharImageLabel);

        // Procedimentos para exibição da janela.
        frame.pack();
        frame.setVisible(true);
    }

    //Converte a Imagem Original para Sépia
    private static BufferedImage convertToSepia(
            BufferedImage originalImage
    ) {
		
		int sepiaIntensity = 30;
		int sepiaDepth = 20;
		
        // Obtém dimensões da imagem 
        int columns = originalImage.getWidth();
        int rows = originalImage.getHeight();

        // Cria nova imagem de mesmo tamanho que a original, sem conteúdo.
        BufferedImage sepImage = new BufferedImage(
                columns, rows, BufferedImage.TYPE_INT_RGB
        );

        // Caminha pelas colunas e linhas da imagem.
        for(int x = 0; x < columns; ++x) {
            for(int y = 0; y < rows; ++y) {

                int pixelValue = originalImage.getRGB(x, y);

                int red = pixelValue >> 16 & 0xFF;
                int green = pixelValue >> 8 & 0xFF;
                int blue = pixelValue & 0xFF;

				int gry = (red + green + blue) / 3;
				red = green = blue = gry;
				red = red + (sepiaDepth * 2);
				green = green + sepiaDepth;

				if (red>255) red=255;
				if (green>255) green=255;
				if (blue>255) blue=255;


				blue-= sepiaIntensity;

				// Normalização
				if (blue<0) blue=0;
				if (blue>255) blue=255;	

                pixelValue = (red << 16) + (green << 8) + blue;

                // Define o valor do pixel na posição (x, y) da nova imagem.
                sepImage.setRGB(x, y, pixelValue);
            }
        }

        return sepImage;
    }
    

    private static BufferedImage ConvertToBinary(BufferedImage originalImage) {
		
		//Valor do Threshold
		int t = 175;
		
		//Pegando os calores da cor branca e preta
		int BLACK = Color.BLACK.getRGB();
		int WHITE = Color.WHITE.getRGB();
		
        int columns = originalImage.getWidth();
        int rows = originalImage.getHeight();
        
        BufferedImage bwImage = new BufferedImage(
                columns, rows, BufferedImage.TYPE_BYTE_GRAY
        );

        for (int y = 0; y < rows; y++)
			for (int x = 0; x < columns; x++) {
				Color pixel = new Color(originalImage.getRGB(x, y));
				//Definindo qual pixel ficara com o valor da cor preta, e qual será branca
				bwImage.setRGB(x, y, pixel.getRed() < t ? BLACK : WHITE);
			}
			
        return bwImage;
    }
    
    /**
     * Borra uma imagem.
     * 
     * O processo de borramento aqui utilizando consiste em, para cada
     * componente de cor de cada pixel, tirar a média de valor desse componente
     * na vizinhança do pixel. O tamanho da vizinhança é determinado
     * a partir do parâmetro $level. Para cada pixel pesquisado, a vizinhança
     * incluirá $level pixels acima, $level pixels abaixo, $level pixels a
     * direita e $level pixels a esquerda.
     * 
     * Pixels que estejam nas bordas da imagem, tal que seja impossível obter
     * suas vizinhanças são ignorados, formando, assim, uma borda preta na
     * imagem final.
     * 
     * @param originalImage A imagem original a ser convertida.
     * @param level Nível do borramento (quanto maior, mais borrada).
     * @return Uma nova imagem do tipo RGB que representa a imagem original com
     *         borrada.
     */
   private static BufferedImage FiltroSharpen(
            BufferedImage originalImage
    ) {
		
		float[] sharpenMatrix = { 0.0f, -1.0f, 0.0f, -1.0f, 5.0f, -1.0f, 0.0f, -1.0f, 0.0f };
		
		BufferedImageOp sharpenFilter = new ConvolveOp(new Kernel(3, 3, sharpenMatrix), ConvolveOp.EDGE_NO_OP, null);
		
		return sharpenFilter;
        
    }
}