Floutage en java

package pack_TI;

import pack_TI.JImageViewer;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.GridLayout;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JLabel;
import javax.swing.border.LineBorder;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class TI extends JFrame implements ActionListener {

 private static final long serialVersionUID = 1L;
 private JPanel contentPane;
 private JButton btnNewButton;
 private JFileChooser fc;
 private BufferedImage bufImgSource=null;
 private BufferedImage bufImgInter=null;
 private BufferedImage bufImgDest=null;
 private JImageViewer imgSourceViewer=null;
 private JImageViewer imgDestViewer=null;

 public static void main(String[] args) {
  
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     TI frame = new TI();
     frame.setVisible(true);
    }
    catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 public TI() {
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  setBounds(50, 50, 1020, 475);
  setTitle("Traitement d'images");
  
  contentPane = new JPanel();
  contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  setContentPane(contentPane);
  contentPane.setLayout(new BorderLayout(0, 0));
  
  JPanel panel_0 = new JPanel();
  panel_0.setBorder(new LineBorder(new Color(0, 0, 0)));
  contentPane.add(panel_0, BorderLayout.NORTH);
  
  btnNewButton = new JButton("Ouvrir l'image");
  btnNewButton.addActionListener(this);
  panel_0.add(btnNewButton);
  
  
  
  JPanel panel_1 = new JPanel();
  panel_1.setBorder(new LineBorder(new Color(0, 0, 0)));
  panel_1.setLayout(new BorderLayout(0, 0));
  JPanel panel_2 = new JPanel();
  panel_2.setBorder(new LineBorder(new Color(0, 0, 0)));
  panel_2.setLayout(new BorderLayout(0, 0));
  
  JPanel panel_inter = new JPanel();
  panel_inter.setLayout(new GridLayout(1, 2));
  panel_inter.add(panel_1);
  panel_inter.add(panel_2);
  
  contentPane.add(panel_inter, BorderLayout.CENTER);
  
  JLabel lblImgSource = new JLabel(" Source");
  imgSourceViewer=new JImageViewer();
  panel_1.add(imgSourceViewer,BorderLayout.CENTER);
  panel_1.add(lblImgSource,BorderLayout.SOUTH);
  JLabel lblImgDest = new JLabel(" Destination");
  imgDestViewer=new JImageViewer();
  panel_2.add(imgDestViewer,BorderLayout.CENTER);
  panel_2.add(lblImgDest,BorderLayout.SOUTH);
 }
 
 @Override
 public void actionPerformed(ActionEvent arg0) {
  if (arg0.getSource() == btnNewButton){
         fc = new JFileChooser("./");
   int returnVal = fc.showDialog(null,"Open Image");
         if (returnVal == JFileChooser.APPROVE_OPTION) {
             File file = fc.getSelectedFile();
             try {
     bufImgSource = ImageIO.read(file);
    } catch (IOException e) {
     e.printStackTrace();
    }
             
             //bufImgDest=ImageEnDegrade();
               
             // 1 traitement
             //bufImgDest=Traitement_simple(bufImgSource);

             // 2 traitements
             bufImgInter=Traitement_simple(bufImgSource);
             bufImgDest=Traitement_par_filtage(bufImgInter);

             imgSourceViewer.setImage(bufImgSource);
             imgDestViewer.setImage(bufImgDest);
             repaint();
       try {
        ImageIO.write(bufImgDest, "gif", new File("./Image_traitee.gif"));
       } catch (IOException e) {
        e.printStackTrace();
       }
         }
  }
 }
 
 /**
  * @param source : l'image à traiter
  * @return l'image traitée
  */
 private static BufferedImage Traitement_simple(BufferedImage source) {
  
  int w = source.getWidth();
  int h = source.getHeight();
  int[] rgbs = new int[w*h]; 
  rgbs=source.getRGB(0,0,w,h,null,0,w);
  int[] newrgbs=new int[rgbs.length];
  int rouge = 0;
  int vert = 0;
  int bleu = 0; 
  int gris=0;
  int pixel=0 ;
  int error=0 ;
  for (int x = 0 ; x < w ; x++){
   for ( int y = 0 ; y < h ; y++){
    rouge = ((rgbs[y*w+x] & 0x00ff0000) >> 16) ;
    vert = ((rgbs[y*w+x] & 0x0000ff00) >> 8) ;
    bleu = (rgbs[y*w+x] & 0x000000ff );
    gris = (rouge+vert+bleu)/3;
    
    //Niveau de gris
    newrgbs[y*w+x]= (gris << 16) | (gris << 8) | gris; 
    //newrgbs[y*w+x]= gris;
    
    }
  }
  
  BufferedImage dest = new BufferedImage(w,h,source.getType());
  dest.setRGB(0,0,w,h,newrgbs,0,w);
  return dest;
 } 


 /**
  * @param source : l'image à traiter
  * @return l'image traitée par le filtre
  */
 
  private static BufferedImage Traitement_par_filtage(BufferedImage source) {
   int[] filtre = new int [3*3];
  
  
   //Filtre Flou
   filtre[0] = 1;
   filtre[1] = 1;
   filtre[2] = 1;
   filtre[3] = 1;
   filtre[4] = 1;
   filtre[5] = 1;
   filtre[6] = 1;
   filtre[7] = 1;
   filtre[8] = 1; 
   
  
  //Calcul diviseur
  int diviseur = 0;
  for(int count=0; count<9; count++){
   diviseur=diviseur+ filtre[count] ;
    }
 

  //PARTIE A COMPLETER : calcul du diviseur
  
  int w = source.getWidth();
  int h = source.getHeight();
  int[] rgbs = new int[w*h]; 
  rgbs=source.getRGB(0,0,w,h,null,0,w);
  int[] newrgbs=new int[rgbs.length];
  int count;
  int pixel=0 , newpixel=0 ;
  int v=0 ;

  //PARTIE A COMPLETER : application du filtre sur toute l'image
  for (int x = 0 ; x < w ; x++){
   for ( int y = 0 ; y < h ; y++){
    
    for (int i = x-1 ; i <= (x+1) ; i++){
     for (int j = y-1 ; j <= (y+1) ; j++){
      if (i>=0 && i<w && j>=0 && j<h) 
       pixel=pixel + ((rgbs [j*w+i] & 0x0000ff)*filtre[v]) ;
         else  
       pixel=pixel+((rgbs [y*w+x] & 0x0000ff)*filtre[v]) ;
         v++;
     }
    }
    if(diviseur!=0)
     newpixel=pixel/diviseur ;
    else
     newpixel = pixel +128;
    if (newpixel>255) newpixel=255;
    if (newpixel<0) newpixel=0;
    pixel=0;
    newrgbs [y*w+x] = (newpixel <<16)| (newpixel <<8)| (newpixel) ;
    v=0 ;
   }
  }
  
  BufferedImage dest = new BufferedImage(w,h,source.getType());
  dest.setRGB(0,0,w,h,newrgbs,0,w);
  return dest;
 }


 /**
  * @return une image en dégradé de couleur
  */
 private static BufferedImage ImageEnDegrade() {
  int w = 256;
  int h = 256;
  int r = 0;
  int v = 0;
  int b = 0xff;
  int[] rgbs = new int[w*h]; 
  for (int x = 0 ; x < w ; x++){
   for ( int y = 0 ; y < h ; y++){
    rgbs [y*w+x] = b|v<<8|r<<16|0xFF000000 ;
   }
   r++;
   v++;
   
  }
  // PARTIE A COMPLETER
  
 
  BufferedImage dest = new BufferedImage(w,h,BufferedImage.TYPE_INT_ARGB);
  dest.setRGB(0,0,w,h,rgbs,0,w);
  return dest;
 }
   
 
}