TrabalhoProcessamento.java

import javax.imageio.*;
import java.awt.image.*;
import java.io.*;
import javax.swing.*;
import java.util.*;
import java.awt.*;

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);
	  BufferedImage aux = new BufferedImage(originalImage.getWidth(), originalImage.getHeight(), BufferedImage.TYPE_INT_RGB);
	  aux = sharpenFilter.filter(originalImage, aux);
		return aux;

    }
}