import java.awt.Color;
import java.awt.FileDialog;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.awt.image.ByteLookupTable;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.awt.image.LookupOp;
import java.awt.image.PixelGrabber;
import java.io.File;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
import javax.swing.KeyStroke;


public class TP_1 
    {
	JFrame frame;
	
	public int larg, haut;
	//variable pour charger le Raster
	int [] pixelsCourant;
	//tableau pour charger le masque 5x5
	static float [] elements25= new float[25];
	// des variables pour le calcul des histogrammes
	int[] tab= new int[256];
	int[][] tabC= new int[256][3];
	int[] tgris= new int[256];
	int[][] tcouleur= new int[256][3];


	//** creation des menu	
	JMenuBar menubar =new JMenuBar();
	 JMenu Fichier=new JMenu("Fichier");
	 JMenuItem ouvrir = new JMenuItem("Ouvrir");
	 JMenuItem Enregistrer = new JMenuItem("Enregistrer");
	 JMenuItem Quitter = new JMenuItem("Quitter");

	 JMenu Traitemant =new JMenu("Traitemant");
	 JMenuItem canalR = new JMenuItem("canal rouge");
	 JMenuItem NivGris = new JMenuItem("NivGris");
	 JMenuItem Bin = new JMenuItem("Binarisation");
	 JMenuItem negatif = new JMenuItem("negatif");	 
	 JMenuItem floue = new JMenuItem("floue");
	 JMenuItem mediane = new JMenuItem("mediane");
	 JMenuItem laplacien = new JMenuItem("Laplacien");
	 
	 JMenu histogramme = new JMenu("histogramme");
	 JMenuItem histo= new JMenuItem("dessiner histogramme couleur");
	 JMenuItem histoGris= new JMenuItem("dessiner histogramme gris");
	 
	 
	 JMenu aide = new JMenu("aide");
	 JMenuItem Aide= new JMenuItem("aide");
 
	 //** deux panels speciales pour l'affichages des deux images originale et traitée
	
	 JPane1 panel1 =new JPane1();
	 JPane2 panel2 =new JPane2();


	 //** le séparateur entre les deux images
	 JSplitPane jSplitPane1 = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,panel1,panel2);
	 
	 //** les menu dialogues ouverture, fermeture, enregistrement...
	 FileDialog dialog;
	 //** les deux images sur lesquels on travail
	 public BufferedImage buffeurActuel, image;

	 
public  TP_1() {
//crée les composant de la fenetre principale
	frame = new JFrame();
	frame.setTitle(" 1er TP traitemant d'image Master STIC "); 
	frame.setSize(frame.getMaximumSize());
	frame.getContentPane().setLayout(new GridLayout());
	frame.getContentPane().add(jSplitPane1);	
	frame.setResizable(true); 
	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
	
	jSplitPane1.setResizeWeight(0.5);
	jSplitPane1.setOneTouchExpandable(true);
	
	
	
	frame.setJMenuBar(menubar);
	menubar.add(Fichier);
	Fichier.add(ouvrir);
	ouvrir.setMnemonic(KeyEvent.VK_O);
	ouvrir.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK));
	ouvrir.setToolTipText("Ouvrir une image");
		
	Fichier.add(Enregistrer);
	Enregistrer.setMnemonic(KeyEvent.VK_S);
	Enregistrer.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK));
	Enregistrer.setEnabled(false);
	Fichier.addSeparator();
	Fichier.add(Quitter);
	Quitter.setMnemonic(KeyEvent.VK_Q);
	Quitter.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q, ActionEvent.CTRL_MASK));
	
	menubar.add(Traitemant);
	Traitemant.add(canalR);
	Traitemant.addSeparator();
	Traitemant.add(NivGris);
	Traitemant.addSeparator();
	Traitemant.add(Bin);
	Traitemant.addSeparator();
	Traitemant.add(negatif);
	Traitemant.addSeparator();
	Traitemant.add(laplacien);
	Traitemant.addSeparator();
	Traitemant.add(floue);
	Traitemant.addSeparator();
	Traitemant.add(mediane);
	
	menubar.add(histogramme);
	histogramme.add(histo);
	histogramme.add(histoGris);
	
	menubar.add(aide);
	aide.add(Aide);

		
// si on veut changer le langage d'affichage	
	ouvrir.setText(" ÇÝÜÜÜÜÜÜÜÜÊÍ");
	Enregistrer.setText(" ÓÜÜÜÜÜÌá ");
	Quitter.setText(" ÃÎÜÜÜÑÌ ");

	ouvrir.addActionListener(new ActionListener() {
		
		public void actionPerformed(ActionEvent e) {
			//......(1)
			long tempsDebut = System.currentTimeMillis();
			
			//cette fonction nous permet de charger une image et de la charger puis l'afficher sur le premier Panel 
			Ouvrir();
			
			//......(2)
			long tempsFin = System.currentTimeMillis();
		    float seconds = (tempsFin - tempsDebut) / 1000F;
		    System.out.println("Opération effectuée en: "+ Float.toString(seconds) + " secondes.");
		    // (1) et (2) permettent de calculer le temps de traitement
		}
	});
	
	Quitter.addActionListener(new ActionListener(){
		public void actionPerformed(ActionEvent e)
		{
			System.exit( 0);
		}
	});
	Enregistrer.addActionListener(new ActionListener(){
		public void actionPerformed(ActionEvent e)
		{
			sauvgarder();
			
		}
	});

	NivGris.addActionListener(new ActionListener(){
		public void actionPerformed(ActionEvent e)
		{
	//***************** choisir de faire la conversion en niveau de gris 
	//***************** soit en 2d (c-a-d bufferedImage) ou 1D (Raster ou vecteur)
			gris2D();
			//gris_Raster();
			//**
		}
	});
	canalR.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			//*************** faire un choix entre les trois méthodes de bases
			///////////////////////
			//canalR();
			canalR_Rasrer();
			//garderR();
		
		}
	});
	
	Bin.addActionListener(new ActionListener() {
		
		public void actionPerformed(ActionEvent e) {
					binarisation();
		}
	});

	
	negatif.addActionListener(new ActionListener() {
		
		public void actionPerformed(ActionEvent e) {
		
			negatif();
		}
	});


	floue.addActionListener(new ActionListener() {
		
		public void actionPerformed(ActionEvent e) {
			//choisir une entre les deux..masque 3x3	
			
			//moyenneur();
			//ou
			//floue();
			
			//ou moyenneur de 5x5
			floue5();
		}
	});


	mediane.addActionListener(new ActionListener() {
		
		public void actionPerformed(ActionEvent arg0) {
			Mediane();
		}
	});
	
	
	
	laplacien.addActionListener(new ActionListener() {
		
		public void actionPerformed(ActionEvent e) {
			laplacien();
			
		}
	});
		
	
histo.addActionListener(new ActionListener() {
		
		public void actionPerformed(ActionEvent e) {
			tcouleur=HistogrammeC(buffeurActuel);
			 dessinerhistoC(tcouleur);
			panel2.repaint();
			
			
			}
	});
	histoGris.addActionListener(new ActionListener() {
		
		public void actionPerformed(ActionEvent e) {
			tgris=Histogramme(buffeurActuel);
			dessinerhisto(tgris);
			panel2.repaint();
			
			}
	});
}

//***************************

public void Ouvrir(){ 
      dialog = new FileDialog(dialog);
	  dialog.setMode(FileDialog.LOAD); 
	  dialog.setVisible(true); 
	  try{ 
	    if(!dialog.getFile().equals("")){ 
	      File input=new File(dialog.getDirectory()+dialog.getFile()); 
	      buffeurActuel=ImageIO.read(input); 
	      
	      //** juste pour charger une tableau une dimmension a partir de l'image pour utilisation ulterieure
	      
	      	larg=buffeurActuel.getWidth();
			haut=buffeurActuel.getHeight();	      	      
	      panel1.repaint() ;
	       } 
	} 
	  catch (Exception e){ 
	    System.out.println(e.getMessage()); 
	  } 
	Enregistrer.setEnabled(true);
}
public class JPane1 extends JPanel{
	public void paint(Graphics g) { 
		
		if (buffeurActuel !=null){ 
		  g.drawImage(buffeurActuel,0,0,this); 
	  } 
    } 
}

public class JPane2 extends JPanel{
	public void paint(Graphics g) { 
		     g.drawImage(image,0,0,this);
		 } 
}
private void sauvgarder(){
	dialog.setMode(FileDialog.SAVE);
	dialog.setVisible(true);
	try {
	if(!dialog.getFile().equals("")){
	String outfile=dialog.getFile();
	File outputFile=new File(dialog.getDirectory()+outfile);
	ImageIO.write(image,outfile.substring(outfile.length()-3,
	outfile.length()),outputFile);
	}
	}
	catch(Exception e){
	System.out.println(e.getMessage());
	}
}
// ces trois fonctions permettent de décomposé les trois canal rouge Vert et Bleu
public int getBlue(int RGB) {
	return RGB&0xFF;
	}
public int getGreen(int RGB) {
	return (RGB>>8)&0xFF;
	}
public  int getRed(int RGB) {
	return (RGB>>16)&0xFF;
	}

//// c'est pour regrouper les trois canal rouge Vert et Bleu
public  int makeRGB(int red, int green, int blue){
	//** l'une ou l'autre puisque &0xFF n'est qu'une limitation en 11111111 (255) ce qui est
		//** la limite pour chaque couleur donc on peut la supprimée (&0xFF)
	
	//	************************* le prmier choix
	//** return ((blue&0xFF)+((green&0xFF)<<8)+((red&0xFF)<<16)+(0xFF<<24));
	  //	*****************************************
	
		
//	************************* le deuxieme choix
	return ((blue)+((green)<<8)+((red)<<16)+(0xFF<<24));
	}

//// *** convertir en tableau 1D pour un traitement en raster 
public int []tableau (BufferedImage img){
	int w,h;
	int [] pixels;
	w= img.getWidth();
	h= img.getHeight();
	pixels = new int [w*h];
	// pour comprendre le pixel graber
	PixelGrabber pg=new PixelGrabber(img,0,0,w,h,pixels,0,w); 
	try{ 
	  pg.grabPixels(); 
	} 
	catch (InterruptedException e){ 
	  System.out.println(e.getMessage()); 
	} 
	return pixels;
	
}

//fonction de récuperation de la couleur rouge (canal rouge):
public void canalR(){
	image = new BufferedImage(larg,haut,BufferedImage.TYPE_INT_RGB);

	for (int i = 0; i < larg; i++) 
	{
		for (int j = 0; j < haut; j++) 
		{
			//récuperer la valeur RGB du pixel actuel (i,j) 
			int RVB = buffeurActuel.getRGB(i, j);
			
			//récuperer la composante rouge partir de RGB du pixel actuel (i,j):...... (1)
			int r=getRed(RVB);
		
			image.setRGB(i, j, makeRGB(r,0,0));
		}
	}

	panel2.repaint();
}
//canal R with raster
public void canalR_Rasrer(){
    int r,i;
    int [] pixels;
//    w= buffeurActuel.getWidth();
//    h= buffeurActuel.getHeight();
    int [] resultat;
    resultat= new int [larg*haut];
    pixels= tableau(buffeurActuel) ;
    for(i=0; i<pixels.length; i++){
        r=getRed(pixels[i]);        
       
        resultat[i]=makeRGB(r,0,0);
    }
    image = new BufferedImage(larg,haut,BufferedImage.TYPE_INT_RGB);
    image.setRGB(0,0,larg,haut,resultat,0,larg);
    panel2.repaint();

}


//essaie de garger que une couleur par un intervale
public void garderR(){
	image = new BufferedImage(larg,haut,BufferedImage.TYPE_INT_RGB);

	for (int i = 0; i < buffeurActuel.getWidth(); i++) 
	{
		for (int j = 0; j < buffeurActuel.getHeight(); j++) 
		{
			int RVB = buffeurActuel.getRGB(i, j);
			int r=getRed(RVB);
			int b=getBlue(RVB);
			int g= getGreen(RVB);
			int gris =(r+g+b)/3;
			int rgb = new Color(gris,gris,gris).getRGB();
			if ((r>200)&&(g<200)&&(b<200))
					rgb=new Color(r,0,0).getRGB();
			
			image.setRGB(i, j, rgb); 
		}
	}
	panel2.repaint();

}


//gris with raster
public void gris_Raster(){
    int r,g,b,i;
    int [] pixels;
    int [] resultat;
    resultat= new int [larg*haut];
    pixels= tableau(buffeurActuel) ;
    for(i=0; i<pixels.length; i++){
        r=getRed(pixels[i]);
        g=getGreen(pixels[i]);
		b=getBlue(pixels[i]);	
		int gris =(r+g+b)/3;
//		
		//int gris = (int) ((0.2125*r)+(0.7154*g)+(0.0721*b));
		
//		int gris = (int) ((0.299*r)+(0.587*g)+(0.114*b));
		
        //////////////////////toute operation ce met ici
        
        resultat[i]=makeRGB(gris,gris,gris);
    }
//    image = new BufferedImage(buffeurActuel.getWidth(),buffeurActuel.getHeight(),
//			BufferedImage.TYPE_INT_RGB);
    image = new BufferedImage(larg,haut,BufferedImage.TYPE_INT_RGB);
    image.setRGB(0,0,larg,haut,resultat,0,larg);
    panel2.repaint();

}

//fonction de gris:
public void gris2D(){
	image = new BufferedImage(larg,haut,BufferedImage.TYPE_INT_RGB);

	for (int i = 0; i < larg; i++) 
	{
		for (int j = 0; j < haut; j++) 
		{
			//récuperer la valeur RGB du pixel actuel (i,j) 
			int RVB = buffeurActuel.getRGB(i, j);
			
			//récuperer la composante rouge partir de RGB du pixel actuel (i,j):...... (1)
			int r=getRed(RVB);
			int g=getGreen(RVB);
			int b=getBlue(RVB);	
			
			// coisir une entre les deux formules
			//int gris1 =(r+g+b)/3;
			int gris1 = (int) ((0.299*r)+(0.587*g)+(0.114*b));
			
			//
			int rgb = new Color(gris1,gris1,gris1).getRGB();
			//ou 
			//int rgb = makeRGB(gris1,gris1,gris1);
			
			image.setRGB(i, j, rgb);
		}
	}

	panel2.repaint();

}


//fonction de binarisation:
public void binarisation(){
	image = new BufferedImage(larg,haut,BufferedImage.TYPE_INT_RGB);

	for (int i = 0; i < larg; i++) 
	{
		for (int j = 0; j < haut; j++) 
		{
			//récuperer la valeur RGB du pixel actuel (i,j) 
			int RVB = buffeurActuel.getRGB(i, j);
			
			//récuperer la composante rouge partir de RGB du pixel actuel (i,j):...... (1)
			int r=getRed(RVB);
			int g=getGreen(RVB);
			int b=getBlue(RVB);	
				
			int gris =(r+g+b)/3;
			int seuil=100;
			int rgb;
			if (gris<=seuil)
			rgb = new Color(0,0,0).getRGB();
			else 
			rgb = new Color(255,255,255).getRGB();
			
			image.setRGB(i, j, rgb);
	
		}

	}

	panel2.repaint();

}
//////////////
// les fonctions qui utilisent les masques et la convolution													
//laplacien
public void laplacien() {
	image = new BufferedImage(larg,haut,buffeurActuel.getType());
	float[] elements = { 0.0f, -1.0f, 0.0f,
						-1.0f, 4.0f, -1.0f,
						 0.0f, -1.0f, 0.0f };
	//ou un autre masque
//	float[] elements = { -1.0f, -1.0f, -1.0f,															
//	-1.0f, 8.0f, -1.0f,																	
//	 -1.0f, -1.0f, -1.0f };	
	Kernel kernel = new Kernel(3, 3, elements);
	//appliquer la convolution
  ConvolveOp op = new ConvolveOp(kernel);
  op.filter(buffeurActuel, image);
  
  panel2.repaint();
}

//les fonction de transformations ponctuels..
void negatif() {
image = new BufferedImage(larg,haut,buffeurActuel.getType());
byte negative[] = new byte[256];
  for (int i = 0; i < 256; i++)
  	negative[i] = (byte) (255 - i);
  ByteLookupTable table = new ByteLookupTable(0, negative);
  LookupOp op = new LookupOp(table, null);
  op.filter(buffeurActuel, image);
  panel2.repaint();
 // filter(op);
}


//// *************** filtre moyenneur*******************
// deux façon..
//1
public void floue() {
	image = new BufferedImage(larg,haut,buffeurActuel.getType());
/////*essaié avec 															

float[] elements = { 1.0f/9.0f, 1.0f/9.0f, 1.0f/9.0f,
					1.0f/9.0f, 1.0f/9.0f, 1.0f/9.0f,
					1.0f/9.0f, 1.0f/9.0f, 1.0f/9.0f };

//*essaié aussi 
//	int i;																
//	for (i=0;i<9;i++){														
//
//		elements[i]=1.0f/9.0f;													
//	}
  Kernel kernel = new Kernel(3, 3, elements);
  ConvolveOp op = new ConvolveOp(kernel);
  op.filter(buffeurActuel, image);
  
  panel2.repaint();
}
public void floue5() {
	image = new BufferedImage(larg,haut,buffeurActuel.getType());

	int i;																
	for (i=0;i<25;i++){														

		elements25[i]=1.0f/25.0f;													
	}
  Kernel kernel = new Kernel(5, 5, elements25);
  ConvolveOp op = new ConvolveOp(kernel);
  op.filter(buffeurActuel, image);
  
  panel2.repaint();
}

//2
public void moyenneur(){

	image = new BufferedImage(larg,haut,buffeurActuel.getType());
	for (int i = 1; i < larg-1; i++) 
	{
		for (int j = 1; j < haut-1; j++) 
		{
			
			int r=(getRed(buffeurActuel.getRGB(i, j))+getRed(buffeurActuel.getRGB(i+1, j))+getRed(buffeurActuel.getRGB(i-1, j))+
					getRed(buffeurActuel.getRGB(i, j+1))+	getRed(buffeurActuel.getRGB(i+1, j+1))+getRed(buffeurActuel.getRGB(i-1, j+1))+
					getRed(buffeurActuel.getRGB(i, j-1))+getRed(buffeurActuel.getRGB(i+1, j-1))+getRed(buffeurActuel.getRGB(i-1, j-1)))/9;
			
			int g=(getGreen(buffeurActuel.getRGB(i, j))+getGreen(buffeurActuel.getRGB(i+1, j))+getGreen(buffeurActuel.getRGB(i-1, j))+
					getGreen(buffeurActuel.getRGB(i, j+1))+	getGreen(buffeurActuel.getRGB(i+1, j+1))+getGreen(buffeurActuel.getRGB(i-1, j+1))+
					getGreen(buffeurActuel.getRGB(i, j-1))+getGreen(buffeurActuel.getRGB(i+1, j-1))+getGreen(buffeurActuel.getRGB(i-1, j-1)))/9;
			
			int b=(getBlue(buffeurActuel.getRGB(i, j))+getBlue(buffeurActuel.getRGB(i+1, j))+getBlue(buffeurActuel.getRGB(i-1, j))+
					getBlue(buffeurActuel.getRGB(i, j+1))+	getBlue(buffeurActuel.getRGB(i+1, j+1))+getBlue(buffeurActuel.getRGB(i-1, j+1))+
					getBlue(buffeurActuel.getRGB(i, j-1))+getBlue(buffeurActuel.getRGB(i+1, j-1))+getBlue(buffeurActuel.getRGB(i-1, j-1)))/9;
			
			int rgb=new Color(r,g,b).getRGB();
			image.setRGB(i, j, rgb);
			}
	}

//////////////////////////////
	panel2.repaint();
}

//*************************************
/////////////////////mediane

public void Mediane(){
	image = new BufferedImage(larg,haut,buffeurActuel.getType());
int [][] pixelr= new int[larg][haut];
int [][] pixelg= new int[larg][haut];
int [][] pixelb= new int[larg][haut];

int Tab[]=new int[9];

for (int i = 0; i < larg; i++) 
{
	for (int j = 0; j < haut; j++) 
	{
		
		int RVB = buffeurActuel.getRGB(i, j);
		
		pixelr[i][j]=getRed(RVB);
		pixelg[i][j]=getGreen(RVB);
		pixelb[i][j]=getBlue(RVB);
		}
}
for (int i = 1; i < larg-1; i++) 
{
	for (int j = 1; j < haut-1; j++) {

		Tab[0]=pixelr[i-1][j-1];
		Tab[1]=pixelr[i][j-1];
		Tab[2]=pixelr[i+1][j-1];
		Tab[3]=pixelr[i-1][j];
		Tab[4]=pixelr[i+1][j];
		Tab[5]=pixelr[i][j+1];                                           
		Tab[6]=pixelr[i-1][j+1];
		Tab[7]=pixelr[i+1][j+1];
		Tab[8]=pixelr[i][j];
		
		int tr=tri(Tab);

		Tab[0]=pixelg[i-1][j-1];
		Tab[1]=pixelg[i][j-1];
		Tab[2]=pixelg[i+1][j-1];
		Tab[3]=pixelg[i-1][j];
		Tab[4]=pixelg[i+1][j];
		Tab[5]=pixelg[i][j+1];                                           
		Tab[6]=pixelg[i-1][j+1];
		Tab[7]=pixelg[i+1][j+1];
		Tab[8]=pixelg[i][j];
		
		int tg=tri(Tab);
		
		Tab[0]=pixelb[i-1][j-1];
		Tab[1]=pixelb[i][j-1];
		Tab[2]=pixelb[i+1][j-1];
		Tab[3]=pixelb[i-1][j];
		Tab[4]=pixelb[i+1][j];
		Tab[5]=pixelb[i][j+1];                                           
		Tab[6]=pixelb[i-1][j+1];
		Tab[7]=pixelb[i+1][j+1];
		Tab[8]=pixelb[i][j];
		int tb=tri(Tab);
									
		int rgb=new Color(tr,tg,tb).getRGB();
		image.setRGB(i, j, rgb);
		 
	}
}
panel2.repaint();
}
// fonction qui trie pour le mediane
int tri(int[] tab){
	int med=0;
	int x;
	
	for (int i=0;i<tab.length-1;i++){
		for (int j=i+1;j<tab.length;j++){
			if (tab[i]>tab[j]){
				x=tab[j];
				tab[j]=tab[i];
				tab[i]=x;
			}
		}
	}
	
	med=tab[4];
	return med;
}


//////////////////ces fonctions permettent de calculer l'histogramme
/////1-histogramme Gris
void dessinerhisto(int tgris[])
{

image = new BufferedImage(larg,haut,buffeurActuel.getType());
//int r=0; int s=0;
int v = haut-20;
  for (int i=0;i<256;i++){
    
	  Graphics ggg = image.getGraphics(); 
	  ggg.setColor(Color.white); 
	 
	  ggg.drawLine(i+3,v,i+3,v-(tgris[i]/20));
	  String r,r2 = null ;
		 if (i%20==0) {
		  r = toString().valueOf(tgris[i]);   // pour etiqueter l'historamme
		  ggg.setColor(Color.green); 
		  ggg.drawString(r, i+3,(v-20)-(tgris[i]/20));}
		 if (i%50==0) {
			  r2 = toString().valueOf(i);
			  ggg.setColor(Color.white); 
			  ggg.drawString(r2, i+3,v+15);}
		  
	ggg.dispose();  
  }
 }
int[] Histogramme (BufferedImage img){
	
	for (int i=0;i<256;i++){
              tab[i]=0;}
	
	for (int i = 0; i < img.getWidth(); i++) 
	{
		for (int j = 0; j < img.getHeight(); j++) 
		{

			int RVB = img.getRGB(i, j);
	
			
			int r=(RVB>>16)& 0xFF;
			int g=(RVB>>8)& 0xFF;
			int b=(RVB)& 0xFF;
			
			int gr = (r+g+b)/3;
			tab[gr]=tab[gr]+1;
					
		}
	
	}
 

	return tab;
}

/////2-histogramme couleur
void dessinerhistoC(int tcouleur[][])
{
	
	image = new BufferedImage(770,haut,buffeurActuel.getType()); // 770 pour avoir toute la largeur du panel2
	// pour dessiner les histogrammes
	int v = haut-30;
	  
	for (int i=0;i<256;i++){
		  
		Graphics ggg = image.getGraphics(); 
		  ggg.setColor(Color.red); 
		  ggg.drawLine(i+3,v,i+3,v-(tcouleur[i][0]/20));
		 String r,r2 = null ;
		 if (i%20==0) {
		  r = toString().valueOf(tcouleur[i][0]);   // pour etiqueter l'historamme
		  ggg.drawString(r, i+3,(v-20)-(tcouleur[i][0]/20));}
		 if (i%50==0) {
			  r2 = toString().valueOf(i);
			  ggg.drawString(r2, i+3,v+10);}
		 
		  				    
		  ggg.setColor(Color.green); 
		  ggg.drawLine(i+260,v,i+260,v-(tcouleur[i][1]/20));
		  if (i%20==0) {
			  r = toString().valueOf(tcouleur[i][1]);   // pour etiqueter l'historamme
			  ggg.drawString(r, i+260,(v-20)-(tcouleur[i][1]/20));}
		  if (i%50==0) {
			  r2 = toString().valueOf(i);
			  ggg.drawString(r2, i+260,v+10);} 
		  
		  ggg.setColor(Color.blue); 
		  ggg.drawLine(i+517,v,i+517,v-(tcouleur[i][2]/20));
		  if (i%20==0) {
			  r = toString().valueOf(tcouleur[i][2]);   // pour etiqueter l'historamme
			  ggg.drawString(r, i+517,(v-20)-(tcouleur[i][2]/20));}
		  if (i%50==0) {
			  r2 = toString().valueOf(i);
			  ggg.drawString(r2, i+517,v+10);} 
		  ggg.dispose();  
	  }
	  Graphics ggg = image.getGraphics(); 
	  ggg.setColor(Color.white); // deux lignes cblanches pour separer les histogrammes
	  ggg.drawLine(259,buffeurActuel.getHeight(),259,0);  
	  ggg.drawLine(516,buffeurActuel.getHeight(),516,0);
	  
	  ggg.setColor(Color.red); 
	  ggg.drawString("histogramme rouge", 128,buffeurActuel.getHeight()-10);
	  
	  ggg.setColor(Color.green); 
	  ggg.drawString("histogramme vert", 380,buffeurActuel.getHeight()-10);
	  
	  ggg.setColor(Color.blue); 
	  ggg.drawString("histogramme blue", larg-128,buffeurActuel.getHeight()-10);
	  
	  ggg.dispose();

}
public int[][] HistogrammeC (BufferedImage img){
	
	for (int i=0;i<256;i++){
              tabC[i][0]=0;
              tabC[i][1]=0;
              tabC[i][2]=0;
	}
	
	for (int i = 0; i < img.getWidth(); i++) 
	{
		for (int j = 0; j < img.getHeight(); j++) 
		{

			int RVB = img.getRGB(i, j);
	
			int r=(RVB>>16)& 0xFF;
			int g=(RVB>>8)& 0xFF;
			int b=(RVB)& 0xFF;
			
			tabC[r][0]=tabC[r][0]+1;
			tabC[g][1]=tabC[g][1]+1;
			tabC[b][2]=tabC[b][2]+1;
										
		}
	
	}
 
	return tabC;
}


////////////
public static void main(String[] args) {
	
	
		TP_1 fenetre= new TP_1();
		fenetre.frame.setVisible(true);
		}
}

//////////////