diff --git a/src/Couleur.java b/src/Couleur.java
index c0e1035..56d1d0a 100644
--- a/src/Couleur.java
+++ b/src/Couleur.java
@@ -1,21 +1,76 @@
+
 public class Couleur {
-	private int[] RVB= {0,0,0};
-	public Couleur(int R, int V, int B)
+	int R,G,B;
+	int N=1;
+	// N représente de combien de Couleurs est issue celle ci, 
+	//pour pouvoir faire des moyennes sans consommer trop de mémoire 
+	public Couleur(int Red, int Green, int Blue)
 	{
-		this.RVB[0]=R;
-		this.RVB[1]=V;
-		this.RVB[2]=B;
+		R=Red;
+		G=Green;
+		B=Blue;
+	}
+	public Couleur(int[] RVB)
+	{
+		// deuxième constructeur pour faciliter la vie
+		R=RVB[0];
+		G=RVB[1];
+		B=RVB[2];
+	}
+	
+	public void initN(int n)
+	{
+		N=n;
 	}
 	public int getR()
 	{
-		return this.RVB[0];
+		return R;
 	}
-	public int getV()
+	public int getG()
 	{
-		return this.RVB[1];
+		return G;
 	}
 	public int getB()
 	{
-		return this.RVB[2];
+		return B;
+	}
+	public int getN()
+	{
+		return N;
+	}
+	public int[] getRVB()
+	{
+		int[] a= {R,G,B};
+		return a;
+	}
+	
+	public int distance(Couleur C)
+	{
+		//calcule la distance au carré entre 2 Couleurs, sur les 3 axes
+		int A=(R-C.getR())*(R-C.getR());
+		A+=(G-C.getG())*(G-C.getG());
+		A+=(B-C.getB())*(B-C.getB());
+		return A;
+	}
+	
+	public void printcoul()
+	{
+		System.out.printf(" %d , %d , %d \n",R, G, B);
+	}
+	
+	public Couleur moyenne(Couleur C)
+	{
+		int[] A=new int[3];
+		A[0]=(R*N + C.getR()*C.getN())/(N+C.getN());
+		A[1]=(G*N + C.getG()*C.getN())/(N+C.getN());
+		A[2]=(B*N + C.getB()*C.getN())/(N+C.getN());
+		Couleur Retour=new Couleur(A);
+		Retour.initN(N+C.getN());
+		return Retour;
+	}
+	public boolean egal(Couleur C)
+	{
+		return(R==C.getR() && G==C.getG() && B==C.getB());
 	}
+	
 }
diff --git a/src/DisplayedImage.java b/src/DisplayedImage.java
index 14a2401..9c2187e 100644
--- a/src/DisplayedImage.java
+++ b/src/DisplayedImage.java
@@ -30,5 +30,8 @@ public void RefreshImage(BufferedImage newimg){
     public void paintComponent(Graphics g){
     		//g.drawImage(image, 0, 0, this); // draw as much as possible
     		g.drawImage(image, 0, 0, this.getWidth(), this.getHeight(), this); // draw full image
-    }                   
+    }  
+    public BufferedImage getImage() {
+    	return image;
+    }
 }
\ No newline at end of file
diff --git a/src/ImageViewer.java b/src/ImageViewer.java
index 081b6c5..0f89364 100644
--- a/src/ImageViewer.java
+++ b/src/ImageViewer.java
@@ -3,11 +3,12 @@
 import javax.swing.JMenuBar;
 import javax.swing.JMenuItem;
 import javax.swing.JPanel;
+import javax.swing.JTextField;
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.imageio.ImageIO;
 import javax.swing.BoxLayout;
 
-import java.awt.Image;
 import java.awt.Color;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -24,11 +25,14 @@ public class ImageViewer extends JFrame /*implements ActionListener*/
 	private JButton buttonHisto = new JButton("Histogramme");
 	private JButton buttonQuant = new JButton("Quantification");
 
-
 	private JButton buttonInverse = new JButton("Inverse");
 
 	private JMenuBar menuBar = new JMenuBar();
 	private JMenu fileMenu = new JMenu("File");
+	private JMenuItem itemSave = new JMenuItem("Save");
+	
+	private JMenuItem itemCharge = new JMenuItem("Charger une image");
+
 
 	private JMenuItem itemClose = new JMenuItem("Close");
 
@@ -44,6 +48,12 @@ public ImageViewer () {
 		JPanel inverse = new JPanel();
 		inverse.setLayout(new BoxLayout(inverse, BoxLayout.PAGE_AXIS));
 		inverse.add(buttonInverse);
+		
+		JPanel charger = new JPanel();
+		charger.setLayout(new BoxLayout(charger, BoxLayout.PAGE_AXIS));
+		charger.add(itemCharge);
+		// Defines action associated to buttons
+		itemCharge.addActionListener(new ButtonCharger());
 		// Defines action associated to buttons
 
 		buttonAction.addActionListener(new ButtonListener());
@@ -58,8 +68,10 @@ public ImageViewer () {
 		quant.setLayout(new BoxLayout(quant, BoxLayout.PAGE_AXIS));
 		quant.add(buttonQuant);
 		// Defines action associated to buttons
-		buttonQuant.addActionListener(new Quant());
-
+		
+		// ##########  CLASS QUANT  ##########
+		buttonQuant.addActionListener(new Quanti());
+// ############## FIN CLASS QUANT #############
 		buttonInverse.addActionListener(new ButtonListener(){
 			public void actionPerformed(ActionEvent arg0) {						
 	    		BufferedImage Invimage;
@@ -94,7 +106,6 @@ public void actionPerformed(ActionEvent arg0) {
 		global.setLayout(new BoxLayout(global, BoxLayout.LINE_AXIS));
 		global.add(input);
 
-		global.add(action);
 		global.add(quant);
 		global.add(histo);
 
@@ -111,11 +122,13 @@ public void actionPerformed(ActionEvent arg0) {
 				System.exit(0);
 			}        
 		});
-		this.fileMenu.add(itemClose);  
+		this.fileMenu.add(itemClose);
+		this.fileMenu.add(itemCharge);
 
 		this.menuBar.add(fileMenu);
 		this.setJMenuBar(menuBar);
-
+		itemSave.addActionListener(new ButtonListener2());
+		this.fileMenu.add(itemSave);
 		this.setVisible(true);
 		
 		
@@ -124,18 +137,102 @@ public void actionPerformed(ActionEvent arg0) {
 	/**
 	 * Class listening to a given button
 	 */
+	class ButtonListener2 implements ActionListener{
+		public void actionPerformed(ActionEvent arg0)
+		{
+			final JFileChooser fc=new JFileChooser();
+	        fc.setMultiSelectionEnabled(true);
+	        int returnVal = fc.showSaveDialog(null);
+	        if(returnVal == JFileChooser.APPROVE_OPTION)
+	        {
+	        File saved = fc.getSelectedFile();
+	        try {
+				ImageIO.write(ouputImage.getImage(),"png",saved);
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+	        }
+	    }                                                
+	}
+	class ButtonCharger implements ActionListener{
+		public JTextField status = new JTextField("pas de fichier chargé");
+	    public JFileChooser choose = new JFileChooser();
+	    private BufferedImage image = inputImage.getimage();
+	    
+	    public void actionPerformed(ActionEvent evt){ //ouvrir une boite de dialogue pour choisir un fichier
+	    	choose.setApproveButtonText("Charger un fichier");
+	    	choose.showOpenDialog(null);
+	    	if (choose.showOpenDialog(null)==JFileChooser.APPROVE_OPTION){
+	    		status.setText(choose.getSelectedFile().getAbsolutePath());
+	    		System.out.println(status.getText());
+	    		
+	    		try{
+	    			image = ImageIO.read(new File(status.getText()));
+	    		}
+	    		catch (IOException e) {
+	        		e.printStackTrace();
+	    		}
+	    		
+
+	    	}
+	    	inputImage.RefreshImage(image);
+	    	ouputImage.RefreshImage(image);
+	    	
+	    }
+	    
+	    
+	}
 	class ButtonListener implements ActionListener{
 		public void actionPerformed(ActionEvent arg0) 
 		{
 		}
-
-	class HistoListener implements ActionListener{
+	}	
+	class Quanti implements ActionListener{
 		public void actionPerformed(ActionEvent arg0) 
 		{
-			System.out.println("Histogramme créé");
+				BufferedImage ima = null;
+				try {
+					ima = ImageIO.read(new File("img.png"));
+				} catch (IOException e) {
+					
+					e.printStackTrace();
+				}
+				System.out.println("Matrice importée");
+				int h;
+				int w;
+				w= ima.getWidth();
+				h= ima.getHeight();
+				int[][][] image = new int[w][h][3];
+				System.out.println("L x H :"+w +"  "+ h);
+				//récupération des couleurs, mises dans le tableau image
+				int i,j,A;
+				for( j=0 ; j<h;  j+=1)
+				{
+					for(i=0; i<w ; i+=1)
+						{
+				        	A = ima.getRGB( i, j );
+				        	image[i][j][0]=(byte)(A >>> 16)&0xFF;
+				        	image[i][j][1]=(byte)(A >>> 8)&0xFF;
+				        	image[i][j][2]=(byte)(A >>> 0)&0xFF;
+						}   
+				}
+				Traitement PAL = new Traitement(image, w,h);
+				int[][][] image_finale= PAL.returnImage();
+				BufferedImage Invimage;
+				Invimage = ouputImage.getimage();
+				
+				int x,y;
+				for(x=0;x<w;x++){
+					for(y=0; y<h;y++){
+						Color newclr= new Color(image_finale[x][y][0],image_finale[x][y][1], image_finale[x][y][2]);
+						Invimage.setRGB(x, y, newclr.getRGB());
+						ouputImage.RefreshImage(Invimage);
+					}
+				}
 		}
 
-	}
 
 	}
-}
\ No newline at end of file
+}
+
diff --git a/src/KdNode.java b/src/KdNode.java
index 4426406..0f92ff9 100644
--- a/src/KdNode.java
+++ b/src/KdNode.java
@@ -2,20 +2,20 @@
 
 public class KdNode {
 	int P;
-	couleur coul;
+	Couleur coul;
 	KdNode filsG;
 	KdNode filsD;
 	boolean[] fils= {false,false};
-	public KdNode(couleur C, int p)
+	public KdNode(Couleur C, int p)
 	{
-		//Constructeur : P=profondeur du noeud, coul= couleur
+		//Constructeur : P=profondeur du noeud, coul= Couleur
 		P=p;
 		coul=C;
 	}
 	
-	public int addpointnode(couleur RVB)
+	public int addpointnode(Couleur RVB)
 	{
-		//ajoute un point par r�cursivit� et renvoie la profondeur � laquelle il a �t� ajout�
+		//ajoute un point par recursivite et renvoie la profondeur a laquelle il a �t� ajout�
 		if (RVB.getRVB()[P%3]>coul.getRVB()[P%3])
 		{
 			if(fils[1])
@@ -43,9 +43,205 @@ public int addpointnode(couleur RVB)
 			}
 		}
 	}
-	public couleur[] palettenode(couleur[] palette,int p)
+	public Couleur getcoul()
 	{
+		return coul;
+	}
+	public Couleur[] palnode(Couleur[] pal)
+	{
+		int L= pal.length;
+		if(L==2)
+		{
+			pal[0]=filsD.Moy();
+			pal[1]=filsG.Moy();
+			return pal;
+		}
+		else
+		{
+			int i;
+			Couleur[] A=new Couleur[L/2];
+			Couleur[] B=new Couleur[L/2];
+			if(fils[0]) {A=filsG.palnode(A);}
+			else {
+				for(i=0;i<L/2;i++)
+				{
+					A[i]=new Couleur(0,0,0);
+				}
+			}
+			if(fils[1]) {B=filsD.palnode(B);}
+			else
+			{
+				for(i=0;i<L/2;i++)
+				{
+					B[i]=new Couleur(0,0,0);
+				}
+			}
+			for(i=0;i<L;i++)
+			{
+				if(i<L/2) {pal[i]=A[i];}
+				else {pal[i]=B[i-L/2];}
+			}
+			return pal;
+			
+		}
+	}
+	
+	public int getNombreFils(){
+		if(this.filsG != null && this.filsD != null){
+			return 2;
+		}
+		else if (this.filsG != null || this.filsD != null){
+			return 1;
+		}
+		else{
+			return 0;
+		}
+	}
+	
+	public KdNode getFilsG(){
+		return this.filsG;
+	}
+	
+	public KdNode getFilsD(){
+		return this.filsD;
+	}
+	
+	public void replaceNode(KdNode point){ //remplace this par point
+		this.coul = point.getcoul();
+		this.filsG = point.getFilsG();
+		this.filsD = point.getFilsD();
+	}
+	
+	
+	public ArrayList<KdNode> getPointFromTree(KdNode point, ArrayList<KdNode> liste){ //donne tous les points en dessous dans l'arbre
+		if (point != null){
+ 			liste.add(point);
+			if(point.getFilsG()!=null){
+				getPointFromTree(point.getFilsG(),liste);
+			}
+			else if(point.getFilsD()!=null){
+				getPointFromTree(point.getFilsD(),liste);
+			}
+		}
+		return liste;
+	}
+	
+	public int getDirection(){
+		return this.P % 3; //0:R;1:V;2:B
+	}
+	
+	public int removePointNode(KdNode point){ // enleve point et reconstruit arbre, renvoie profondeur 
+		int direction = this.getDirection();
+		int new_p = 0;
+		switch (this.coul.comparaison(direction, point.getcoul())){
+		case 1: //fils de gauche
+			return (this.filsG.removePointNode(point));
 		
+		case -1: //fils de droite
+			return (this.filsD.removePointNode(point));
+			
+		default: //0 
+			if (this.coul.egal(point.getcoul())){//c'est le point à supprimer
+				//son fils de droite va prendre sa place, tous les fils de gauche reconstruits
+				point.replaceNode(point.getFilsD());//il emmene tous ses fils avec 
+				
+				ArrayList<KdNode> liste = new ArrayList<KdNode>();
+				getPointFromTree(point.getFilsG(), liste);
+				for (int i=0;i<liste.size();i++){
+					new_p = point.getFilsD().addpointnode(liste.get(i).getcoul()); // point fils ou point tt court
+				}
+				//calcul de la nouvelle profondeur
+				if (new_p<KdTree.getProf()){
+					return new_p;
+				}
+				else{
+					return KdTree.getProf();
+				}
+			}
+			
+			else{// c'est un autre point on va à gauche
+				return (this.filsG.removePointNode(point));
+			}
+			
+			
+			
+		}
+	}
+	
+	
+	public Couleur Moy()
+	{
+		if(fils[0] && fils[1])
+		{
+			Couleur A = (filsD.Moy()).moyenne(coul);
+			A=(filsG.Moy()).moyenne(A);
+			return A;
+		}
+		else if(fils[1])
+		{
+			Couleur A = (filsD.Moy()).moyenne(coul);
+			return A;
+		}
+		else if(fils[0])
+		{
+			Couleur A = (filsG.Moy()).moyenne(coul);
+			return A;
+		}
+		else
+		{
+			return coul;
+		}
+	}
 
+	public Couleur getNN(Couleur A)
+	{
+		if ((A.getRVB())[P%3] > (coul.getRVB())[P%3])
+		{
+			if (fils[1])
+			{
+				Couleur CurrentBest = filsD.getNN(A);
+				if (CurrentBest.distance(A) > coul.distance(A))
+				{
+					CurrentBest=coul;
+				}
+				if(CurrentBest.distance(A) > Math.abs((coul.getRVB())[P%3] - (A.getRVB())[P%3])  && fils[0])
+				{
+					Couleur Alter = filsG.getNN(A);
+					if(CurrentBest.distance(A) > Alter.distance(A))
+					{
+						CurrentBest=Alter;
+					}
+				}
+				return CurrentBest;
+			}
+			else
+			{
+				return coul;
+			}
+		}
+		else
+		{
+			if (fils[0])
+			{
+				Couleur CurrentBest = filsG.getNN(A);
+				if (CurrentBest.distance(A) > coul.distance(A))
+				{
+					CurrentBest=coul;
+				}
+				if(CurrentBest.distance(A) > Math.abs((coul.getRVB())[P%3] - (A.getRVB())[P%3])  && fils[1])
+				{
+					Couleur Alter = filsD.getNN(A);
+					if(CurrentBest.distance(A) > Alter.distance(A))
+					{
+						CurrentBest=Alter;
+					}
+				}
+				return CurrentBest;
+			}
+			else
+			{
+				return coul;
+			}
+		}
 	}
 }
diff --git a/src/KdTree.java b/src/KdTree.java
index c2909c1..7a1102d 100644
--- a/src/KdTree.java
+++ b/src/KdTree.java
@@ -1,28 +1,62 @@
 
-public class KdTree {
-	int P=0;
-	KdNode Racine;
-	public KdTree(int[] RVB)
-	{
-		couleur coul= new couleur(RVB);
-		Racine= new KdNode(coul,P);
+public class KdTree{
+	private int profondeur=0;
+
+	private Couleur CouleurR;
+	private KdNode Racine;
+
+	public KdTree (int RVB[]){
+		this.CouleurR=new Couleur(RVB[0], RVB[1], RVB[2]);
+		this.Racine= new KdNode(CouleurR,0);
 	}
 	
-	void addpoint(int []RVB)
-	{
-		//ajoute un point à l'arbre, si il est plus profond, on augemente la profondeur max de l'arbre
-		couleur coul=new couleur(RVB);
-		int A=Racine.addpointnode(coul);
-		if (A>P)
+	public static int getProf(){
+		return profondeur;
+	}
+	
+
+
+	public void addpoint(int RVB[]){
+		Couleur C=new Couleur(RVB);
+		int p= Racine.addpointnode(C);
+		if(p>profondeur)
 		{
-			P=A;
+			profondeur=p;
 		}
+		
+	}
+	
+	public void removePoint(int RVB[],int XY[]){
+		Couleur couleur = new Couleur(RVB);
+		KdNode point = new KdNode(couleur,0);
+		int p = this.Racine.removePointNode(point);
+		
+		if (p<this.profondeur){
+			this.profondeur = p;
+		}				
 	}
-	couleur[] palette(int p)
+	
+	public Couleur[] palette(int pow)
 	{
-		int L=(int) Math.pow(2,p);
-		couleur[] palette= new couleur[L];
-		palette= Racine.palettenode(palette, p);
+		//renvoie une palette de 2**pow Couleurs
+		Couleur[] palette= new Couleur[(int) Math.pow(2, pow-1)];
+		palette= Racine.palnode(palette);
 		return palette;
 	}
+	
+	public int getNearestNeighbors(Couleur A, Couleur[] pal)
+	{
+		Couleur Nearest= Racine.getNN(A);
+		int i;
+		for(i=0;i<pal.length;i++)
+		{
+			if (Nearest.egal(pal[i]))
+			{
+				return (i);
+			}
+		}
+		return 0;
+	}
+
+
 }
diff --git a/src/Kdtree.java b/src/Kdtree.java
deleted file mode 100644
index a71802b..0000000
--- a/src/Kdtree.java
+++ /dev/null
@@ -1,45 +0,0 @@
-
-public class Kdtree{
-
-	private Couleur couleurR;
-	private KdNode Racine;
-
-	public Kdtree (int RVB[], int XY[]){
-		this.couleurR=new Couleur(RVB[0], RVB[1], RVB[2]);
-		this.Racine= new KdNode(couleurR, XY,0);
-	}
-	
-	public void removePoint(int XY[]){
-		
-	}
-	//Retire un noeud de l’arbe
-	public void addpoint(int XY[], int RVB[]){
-		
-	}
-	/*Ajoute un point à la racine de l’arbre, en créant une couleur associée à RVB
-	Met à jour profondeur
-	>> la méthode addpoint de KdNode devra renvoyer un entier la profondeur du nouveau noeud créé*/
-	
-	/*public int addpoint(Couleur RVB, int[] XY){ 
-	 	if(RVB.compare(couleur, P%3)){
-			if (fils[0]){
-				filsG.addpoint(RVB, XY);
-			}
-			else{ 
-				filsG= new KdNode(RVB,XY, P+1);
-				fils[0]=true; return P+1;
-			}
-		}
-		else{
-			if (fils[1]){
-				filsD.addpoint(RVB, XY);
-			}
-				else{ 
-					filsD= new KdNode(RVB,XY,P+1);
-					fils[1]=true; return P+1;
-				}
-		}*/
-}
-/*couleurR= couleur de la racine (class Couleur)
-Profondeur=profondeur de l’arbre
-Racine = Premier noeud de l’arbe (class KdNode)*/
\ No newline at end of file
diff --git a/src/Quant.java b/src/Quant.java
deleted file mode 100644
index 409c052..0000000
--- a/src/Quant.java
+++ /dev/null
@@ -1,166 +0,0 @@
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
-
-
-
-import javax.imageio.ImageIO;
-
-public class Quant implements ActionListener {
-	public void actionPerformed(ActionEvent arg0) 
-	{
-		couleur[] palette;
-		int[][] image_traitee;
-		//importation de l'image
-		BufferedImage ima = null;
-		try {
-			ima = ImageIO.read(new File("img.png"));
-		} catch (IOException e) {
-			
-			e.printStackTrace();
-		}
-		System.out.println("Matrice importée");
-		int h;
-		int w;
-		int total=0;
-		w= ima.getWidth();
-		h= ima.getHeight();
-		int[][][] image = new int[w][h][3];
-		System.out.println("L x H :"+w +"  "+ h);
-		//récupération des couleurs, mises dans le tableau image
-		int R,V,B,i,j,A;
-		for( j=0 ; j<h;  j+=1)
-		{
-			for(i=0; i<w ; i+=1)
-				{
-		        	A = ima.getRGB( i, j );
-		        	image[i][j][0]=(byte)(A >>> 16)&0xFF;
-		        	image[i][j][1]=(byte)(A >>> 8)&0xFF;
-		        	image[i][j][2]=(byte)(A >>> 0)&0xFF;
-				}   
-		}
-		
-		//passage d'un tableau w*h à un tableau à une ligne
-		int[][] line= linear(image,w,h);
-		//création d'un arbre à partir de line
-		KdTree Arbre1 = InitFromArray(line);
-		
- }
-	public void printtab(int[][] tableau, int dim)
-	{
-		int i;
-		for (i=0; i<tableau.length; i++)
-		{
-			System.out.println(tableau[i][dim]);
-		}
-	}
-	public int[][] linear(int[][][] matrice, int w, int h)
-	//passage d'un tableau w*h à un tableau à une ligne
-
-	{
-		int j,i;
-		int[][] line = new int[w*h][3];
-		for( j=0 ; j<h;  j+=1)
-		{
-			for(i=0; i<w ; i+=1)
-				{
-
-		        	line[i+ w*j][0]=matrice[i][j][0];
-		        	line[i+ w*j][1]=matrice[i][j][1];
-		        	line[i+ w*j][2]=matrice[i][j][2];
-
-				}   
-		}
-		return line;
-	}
-	public int[][] tridim(int[][] liste, int dim)
-	{
-		int L=liste.length;
-		int[][][] Tri = new int[256][L][3];
-		int i,j,k=0;
-		int[] Compte= new int[256];
-		for(i=0;i<256;i++)
-		{
-			Compte[i]=0;
-		}
-		for(i=0;i<L;i++)
-		{
-			j=(int)liste[i][dim];
-			Tri[j][Compte[j]]=liste[i];
-			Compte[j]++;
-		}
-		int[][] Retour = new int[L][3];
-		for(i=0;i<256;i++)
-		{
-			if(Compte[i]!=0)
-			{
-				for(j=0;j<Compte[i];j++)
-				{
-					Retour[k]=Tri[i][j];
-					k++;
-				}
-			}
-		}
-		return Retour;
-
-	}
-	
-	KdTree InitFromArray(int[][] line)
-	{
-		line = tridim(line, 0);
-		System.out.println("premier tri fini");
-		int L=line.length;
-		KdTree Arbre= new KdTree(line[(int)(L/2)]);
-		int[][] LP=new int[(int)(L/2)][3];
-		int[][] LG=new int[L-1-(int)(L/2)][3];
-		int i;
-		for(i=0;i<(int)(L/2);i++)
-		{
-			LP[i]=line[i];
-		}
-		for(i=(int)(L/2) +1;i<L; i++)
-		{
-			LG[i-((int)(L/2) +1)]=line[i];
-		}
-		i=InitR(Arbre, LG, 1);
-		i=InitR(Arbre, LP, 1);
-		System.out.println("arbre implanté");
-		return Arbre;
-	}
-	int InitR(KdTree Arbre, int[][] list, int dim)
-	{
-		int L=list.length;
-		switch(L) {
-		case 0:
-			return 0;
-		case 1:
-			Arbre.addpoint(list[0]);
-			return 0;
-		case 2:
-			Arbre.addpoint(list[0]);
-			Arbre.addpoint(list[1]);
-			return 0;
-		}
-		list=tridim(list, dim);
-		Arbre.addpoint(list[(int)(L/2)]);
-		int[][] LP=new int[(int)(L/2)][3];
-		int[][] LG=new int[L-1-(int)(L/2)][3];
-		int i;
-		for(i=0;i<(int)(L/2);i++)
-		{
-			LP[i]=list[i];
-		}
-		for(i=(int)(L/2) +1;i<L; i++)
-		{
-			LG[i-((int)(L/2) +1)]=list[i];
-		}
-		System.out.println("dimension: "+ dim);
-		InitR(Arbre, LG, (dim+1)%3);
-		InitR(Arbre, LP, (dim+1)%3);
-		return 0;
-		
-	}
-
-}
diff --git a/src/Traitement.java b/src/Traitement.java
new file mode 100644
index 0000000..55be298
--- /dev/null
+++ b/src/Traitement.java
@@ -0,0 +1,202 @@
+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;
+
+
+
+import javax.imageio.ImageIO;
+
+public class Traitement {
+	int[][][] imagefinale;
+	public Traitement(int[][][] image, int w, int h) 
+	{
+		
+		
+		Couleur[] palette;
+		//passage d'un tableau w*h à un tableau à une ligne
+		int[][] line= linear(image,w,h);
+		//création d'un arbre à partir de line
+		KdTree Arbre1 = InitFromArray(line);
+		palette = Arbre1.palette(5);
+		line = CoulToInt(palette);
+		KdTree Arbre2 = InitFromArray(line);
+		System.out.println("arbre de la palette créé.");
+		int[][] image_traitee = quantif(Arbre2, image, w,h, palette);
+		System.out.println("Image Traitée!!!");
+		imagefinale = ajoutcoul(image_traitee, palette,w,h);		
+ }
+
+	public int[][][] returnImage()
+	{
+		return this.imagefinale;
+	}
+	public int[][][] ajoutcoul(int[][] image, Couleur[] palette, int w, int h)
+	{
+		int[][][] imagefinale = new int[w][h][3];
+		int i,j;
+		for (i=0; i<w; i++)
+		{
+			for(j=0; j<h; j++)
+			{
+				imagefinale[i][j]= palette[image[i][j]].getRVB();
+			}
+		}
+		return imagefinale;
+	}
+	public int[][] quantif(KdTree Arbre, int[][][] image, int w, int h, Couleur[] pal)
+	{
+		int[][] image_t= new int[w][h];
+		Couleur A= new Couleur(0,0,0);
+		int i,j;
+		for(i=0; i<w; i++)
+		{
+			for(j=0; j<h; j++)
+			{
+				A= new Couleur(image[i][j]);
+				image_t[i][j]= Arbre.getNearestNeighbors(A, pal);
+			}
+		}
+		
+		return image_t;
+	}
+	
+	public int[][] CoulToInt(Couleur[] pal)
+	{
+		int[][] line = new int[pal.length][3];
+		int i;
+		for(i=0;i<pal.length;i++)
+		{
+			int[] A= pal[i].getRVB();
+			line[i]=A;
+		}
+		return line;
+	}
+	
+	public void printpal(Couleur[] pal)
+	{
+		int i;
+		for(i=0;i<pal.length;i++)
+		{
+			pal[i].printcoul();
+		}
+	}
+	
+	public void printtab(int[][] tableau, int dim)
+	{
+		int i;
+		for (i=0; i<tableau.length; i++)
+		{
+			System.out.println(tableau[i][dim]);
+		}
+	}
+	public int[][] linear(int[][][] matrice, int w, int h)
+	//passage d'un tableau w*h à un tableau à une ligne
+
+	{
+		int j,i;
+		int[][] line = new int[w*h][3];
+		for( j=0 ; j<h;  j+=1)
+		{
+			for(i=0; i<w ; i+=1)
+				{
+
+		        	line[i+ w*j][0]=matrice[i][j][0];
+		        	line[i+ w*j][1]=matrice[i][j][1];
+		        	line[i+ w*j][2]=matrice[i][j][2];
+
+				}   
+		}
+		return line;
+	}
+	public int[][] tridim(int[][] liste, int dim)
+	{
+		int L=liste.length;
+		int[][][] Tri = new int[256][L][3];
+		int i,j,k=0;
+		int[] Compte= new int[256];
+		for(i=0;i<256;i++)
+		{
+			Compte[i]=0;
+		}
+		for(i=0;i<L;i++)
+		{
+			j=(int)liste[i][dim];
+			Tri[j][Compte[j]]=liste[i];
+			Compte[j]++;
+		}
+		int[][] Retour = new int[L][3];
+		for(i=0;i<256;i++)
+		{
+			if(Compte[i]!=0)
+			{
+				for(j=0;j<Compte[i];j++)
+				{
+					Retour[k]=Tri[i][j];
+					k++;
+				}
+			}
+		}
+		return Retour;
+
+	}
+	
+	KdTree InitFromArray(int[][] line)
+	{
+		line = tridim(line, 0);
+		System.out.println("premier tri fini: veuillez attendre environ 70sec");
+		int L=line.length;
+		int mid=(int)(L/2);
+		KdTree Arbre= new KdTree(line[mid]);
+		int[][] LP=new int[mid][3];
+		int[][] LG=new int[L-1-mid][3];
+		int i;
+		for(i=0;i<mid;i++)
+		{
+			LP[i]=line[i];
+		}
+		for(i=mid +1;i<L; i++)
+		{
+			LG[i-(mid +1)]=line[i];
+		}
+		i=InitR(Arbre, LP, 1);
+		i=InitR(Arbre, LG, 1);
+		System.out.println("arbre implanté ");
+		return Arbre;
+	}
+	int InitR(KdTree Arbre, int[][] list, int dim)
+	{
+		int L=list.length;
+		switch(L) {
+		case 0:
+			return 0;
+		case 1:
+			Arbre.addpoint(list[0]);
+			return 0;
+		case 2:
+			Arbre.addpoint(list[0]);
+			Arbre.addpoint(list[1]);
+			return 0;
+		}
+		
+		int mid=(int)(L/2), i;
+		list=tridim(list, dim);
+		int[][] LP=new int[mid][3];
+		int[][] LG=new int[L-1-mid][3];
+
+		for(i=0;i<L;i++)
+		{
+			if(i<mid) {LP[i]=list[i];}
+			else if(i==mid) {Arbre.addpoint(list[mid]);}
+			else {LG[i-1 -mid]= list[i];}
+		}
+		
+		i=InitR(Arbre, LP, (dim+1)%3);
+		i=InitR(Arbre, LG, (dim+1)%3);
+		return 0;
+		
+	}
+
+}
diff --git a/src/couleur.java b/src/couleur.java
deleted file mode 100644
index 254ecaa..0000000
--- a/src/couleur.java
+++ /dev/null
@@ -1,45 +0,0 @@
-
-public class couleur {
-	int R,G,B;
-	public couleur(int Red, int Green, int Blue)
-	{
-		R=Red;
-		G=Green;
-		B=Blue;
-	}
-	public couleur(int[] RVB)
-	{
-		// deuxième constructeur pour faciliter la vie
-		R=RVB[0];
-		G=RVB[1];
-		B=RVB[2];
-	}
-	
-	public int getR()
-	{
-		return R;
-	}
-	public int getG()
-	{
-		return G;
-	}
-	public int getB()
-	{
-		return B;
-	}
-	public int[] getRVB()
-	{
-		int[] a= {R,G,B};
-		return a;
-	}
-	
-	public int distance(couleur C)
-	{
-		//calcule la distance au carré entre 2 couleurs, sur les 3 axes
-		int A=(R-C.getR())*(R-C.getR());
-		A+=(G-C.getG())*(G-C.getG());
-		A+=(B-C.getB())*(B-C.getB());
-		return A;
-	}
-	
-}