finir le sprint 3

src/fr/iutfbleau/sae/mhuffman/FrequencyTable.java

@@ -1,4 +1,5 @@
 package fr.iutfbleau.sae.mhuffman;
+import fr.iutfbleau.sae.mimage.Pixel;
 import fr.iutfbleau.sae.mimage.RGBImage;
 
 /**
@@ -26,7 +27,7 @@ import fr.iutfbleau.sae.mimage.RGBImage;
  * </p>
  *
  * @author Algassimou Pellel Diallo
- * @version 1.0
+ * @version 1.1
  * @since 2025-12-13
  */
 public class FrequencyTable {
@@ -62,22 +63,28 @@ public class FrequencyTable {
      * </p>
      *
      * @param img l'image RGB à analyser
+     * @throws IllegalArgumentException si l'image est null
      */
     public void computeFromImage(RGBImage img) {
-		/*Nb: une composante de couleur est un entier entre 0 et 255 qui représente la part de rouge,vert ou bleu
+        if (img == null) {
-			dans la couleur d'un pixel.
+            throw new IllegalArgumentException("L'image ne peut pas être null");
+        }
+        
+        /* Pour chaque composante de couleur de chaque pixel, on incrémente la fréquence correspondante,
+         * c'est-à-dire on compte le nombre de fois que la composante apparaît dans l'image.
+         * Ex: si un pixel P a une composante rouge de 150, on incrémente freqR[150] de 1.
+         * Puis on fait de même pour les composantes verte et bleue.
+         * On répète ce processus pour tous les pixels de l'image.
          */
-		/* pour chaque composante de couleur de chaque pixel, on incrémente la fréquence correspondante,
+        for (int x = 0; x < img.getWidth(); x++) {
-			c'est-à-dire on compte le nombre de fois que la composante apparaît dans l'image.
+            for (int y = 0; y < img.getHeight(); y++) {
-			ex: si un pixel P a une composante rouge de 150, on incrémente freqR[150] de 1.
+                // On récupère le pixel une seule fois pour optimiser
-			puis on fait de même pour les composantes verte et bleue.
+                Pixel pixel = img.getPixel(x, y);
-			on répète ce processus pour tous les pixels de l'image.
+                
-		*/
+                // Puis on incrémente les trois fréquences
-        for (int ligne = 0; ligne < img.getWidth(); ligne++) {
+                this.freqR[pixel.getR()]++;
-            for (int colonne = 0; colonne < img.getHeight(); colonne++) {
+                this.freqG[pixel.getG()]++;
-                this.freqR[img.getPixel(ligne, colonne).getR()]++; // Incrémente la fréquence de la composante rouge
+                this.freqB[pixel.getB()]++;
-                this.freqG[img.getPixel(ligne, colonne).getG()]++; // Incrémente la fréquence de la composante verte
-                this.freqB[img.getPixel(ligne, colonne).getB()]++; // Incrémente la fréquence de la composante bleue
             }
         }
     }
@@ -93,7 +100,6 @@ public class FrequencyTable {
 
     /**
      * Retourne le tableau des fréquences de la composante verte.
-     *
      * @return un tableau de 256 entiers représentant les fréquences du vert
      */
     public int[] getGreen() {
@@ -109,7 +115,3 @@ public class FrequencyTable {
         return this.freqB;
     }
 }
-
-
-
-

src/fr/iutfbleau/sae/mhuffman/HuffmanNode.java

@@ -21,10 +21,14 @@ package fr.iutfbleau.sae.mhuffman;
  */
 public class HuffmanNode {
 
-    /** Valeur de la composante (cette valeur est appelée symbole, voir l'histoire de huffman, tres interressant) représentée par ce nœud (si feuille). c'est la part de la composante (rouge, verte ou bleue) dans la couleur d'un pixel. */
+    /** 
+     * Valeur de la composante (symbole) représentée par ce nœud (uniquement pour les feuilles).
+     * Représente la part de la composante (rouge, verte ou bleue) dans la couleur d'un pixel.
+     * Pour les nœuds internes, cette valeur vaut -1.
+     */
     private int value;
 
-    /** Fréquence du symbole (somme des fréquences des enfants). */
+    /** Fréquence du symbole (somme des fréquences des enfants pour les nœuds internes). */
     private int frequence;
 
     /** Fils gauche du nœud (null si feuille). */
@@ -40,10 +44,18 @@ public class HuffmanNode {
      * issue de la table de fréquences.
      * </p>
      *
-     * @param value la valeur (symbole) représentée par ce nœud
+     * @param value la valeur (symbole) représentée par ce nœud (entre 0 et 255)
      * @param frequence la fréquence d'apparition de la valeur
+     * @throws IllegalArgumentException si la valeur n'est pas entre 0 et 255
+     *         ou si la fréquence est négative
      */
     public HuffmanNode(int value, int frequence) {
+        if (value < 0 || value > 255) {
+            throw new IllegalArgumentException("La valeur doit être entre 0 et 255");
+        }
+        if (frequence < 0) {
+            throw new IllegalArgumentException("La fréquence ne peut pas être négative");
+        }
         this.value = value;
         this.frequence = frequence;
         this.left = null;
@@ -59,8 +71,13 @@ public class HuffmanNode {
      *
      * @param left le fils gauche
      * @param right le fils droit
+     * @throws IllegalArgumentException si l'un des fils est null
      */
     public HuffmanNode(HuffmanNode left, HuffmanNode right) {
+        if (left == null || right == null) {
+            throw new IllegalArgumentException("Les fils ne peuvent pas être null");
+        }
+        this.value = -1; // Valeur sentinelle pour les nœuds internes
         this.left = left;
         this.right = right;
         this.frequence = left.frequence + right.frequence;
@@ -87,7 +104,7 @@ public class HuffmanNode {
     /**
      * Retourne le fils gauche du nœud.
      *
-     * @return le fils gauche
+     * @return le fils gauche, ou null si le nœud est une feuille
      */
     public HuffmanNode getLeft() {
         return this.left;
@@ -96,7 +113,7 @@ public class HuffmanNode {
     /**
      * Retourne le fils droit du nœud.
      *
-     * @return le fils droit
+     * @return le fils droit, ou null si le nœud est une feuille
      */
     public HuffmanNode getRight() {
         return this.right;
@@ -108,7 +125,8 @@ public class HuffmanNode {
      * Cette méthode n'a de sens que si le nœud est une feuille.
      * </p>
      *
-     * @return la valeur du symbole
+     * @return la valeur du symbole (entre 0 et 255)
+     * @throws IllegalStateException si le nœud n'est pas une feuille
      */
     public int getValue() {
         if (!this.isLeaf()) {
@@ -116,4 +134,20 @@ public class HuffmanNode {
         }
         return this.value;
     }
+
+    /**
+     * Retourne une représentation textuelle du nœud.
+     * <p>
+     * Utile pour le débogage et l'affichage de l'arbre.
+     * </p>
+     *
+     * @return une chaîne décrivant le nœud
+     */
+    @Override
+    public String toString() {
+        if (this.isLeaf()) {
+            return "Feuille(valeur=" + this.value + ", freq=" + this.frequence + ")";
+        }
+        return "Noeud(freq=" + this.frequence + ")";
+    }
 }

src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java

@@ -167,36 +167,6 @@ public class HuffmanTree {
 		generateCodesRec(node.getLeft(), prefiixe + "0");
 		// On va a droite en ajoutant "1" au code
 		generateCodesRec(node.getRight(), prefiixe + "1");
-
-
-		// this.codes = new HashMap<>();
-		// this.chaineCarac = new String();
-
-		// if(root.isLeaf()){
-		// 	codes.put(root.getValue(),Integer.parseInt(chaineCarac));
-		// 	return codes;
-		// }
-
-		// HuffmanNode temp = root;
-
-    	// if (root.getLeft() != null) {
-		// 	root = root.getLeft();
-		// 	chaineCarac = chaineCarac + "0";
-		// 	generateCodes();
-		// 	// on retire le dernier bit lorsqu'on remonte car sinon les codes seront faussés
-		// 	chaineCarac = chaineCarac.substring(0, chaineCarac.length() - 1);
-    	// }
-
-    	// if (temp.getRight() != null) {
-		// 	root = temp.getRight();
-		// 	chaineCarac = chaineCarac + "1";
-		// 	generateCodes();
-		// 	chaineCarac = chaineCarac.substring(0, chaineCarac.length() - 1);
-    	// }
-
-    
-    	// root = temp;
-		// return codes;
 	}
 
 	/**

src/fr/iutfbleau/sae/mpif/PIFReader.java

@@ -1,13 +1,11 @@
 package fr.iutfbleau.sae.mpif;
-
+import fr.iutfbleau.sae.mimage.RGBImage;
 import fr.iutfbleau.sae.util.BitInputStream;
-import fr.iutfbleau.sae.util.BitOutputStream;
 
+import java.io.BufferedInputStream;
 import java.io.FileInputStream;
 import java.util.Map;
 
-import fr.iutfbleau.sae.mimage.RGBImage;
-
 
 public class PIFReader {
 
@@ -19,8 +17,11 @@ public class PIFReader {
 
     public RGBImage read(String filepath)
     throws Exception {
+
+        // j'Utilise d'un BufferedInputStream pour une meilleure performance
         FileInputStream fis = new FileInputStream(filepath);
-        BitInputStream lecteur = new BitInputStream(fis);
+        BufferedInputStream bis = new BufferedInputStream(fis);
+        BitInputStream lecteur = new BitInputStream(bis);
         
         // je lis l'entête et les tables canoniques
         this.readHeader(lecteur);
@@ -42,7 +43,7 @@ public class PIFReader {
     }
 
     public  void readHeader(BitInputStream in) {
-        // TODO: Implement header reading
+        
     }
     
     public void readCanonicalTables(BitInputStream in) {

src/fr/iutfbleau/sae/mpif/PIFWriter.java

@@ -1,6 +1,7 @@
 package fr.iutfbleau.sae.mpif;
 
 import fr.iutfbleau.sae.mimage.RGBImage;
+import fr.iutfbleau.sae.mimage.Pixel;
 import fr.iutfbleau.sae.util.BitOutputStream;
 import java.io.BufferedOutputStream;
 import java.io.FileOutputStream;
@@ -31,21 +32,17 @@ public class PIFWriter {
 
         ecriveur.fermerFlux();
 
-        System.err.println("SYSTEME");
+        System.out.println("Fichier PIF écrit avec succès");
     }
 
     // Ecriture de l'en-tête du fichier PIF (largeur et hauteur)
     public void writeHeader(BitOutputStream out, int width, int height) {
         try {
-            out.writeBits(width >> 8 & 0xFF, 8); // octet de poids fort
+            out.writeBits(width, 16);  // ✅ Simplifié : 16 bits d'un coup
-            out.writeBits(width & 0xFF, 8); // octet de poids faible
+            out.writeBits(height, 16); // ✅ Simplifié : 16 bits d'un coup
-
-            out.writeBits(height >> 8 & 0xFF, 8); // octet de poids fort
-            out.writeBits(height & 0xFF, 8); // octet de poids faible
         } catch (Exception e) {
-            System.err.println("Erreur lors de l’écriture de l’en-tête du fichier PIF");
+            System.err.println("Erreur lors de l'écriture de l'en-tête du fichier PIF");
         }
-        
     }
 
     public void writeTables(BitOutputStream out, Map<Integer, String> canonR, 
@@ -55,14 +52,14 @@ public class PIFWriter {
             // Écriture des longueurs des codes canoniques pour chaque composante
             for (int i = 0; i < 256; i++) {
                 int len;
-                if (canonR.containsKey(i)) { // petite securité (au cas où)
+                if (canonR.containsKey(i)) {
                     len = canonR.get(i).length();  
                 } else {
                     len = 0;
                 }
                 out.writeBits(len, 8); 
-
             }
+            
             for (int i = 0; i < 256; i++) {
                 int len;
                 if (canonG.containsKey(i)) {
@@ -72,6 +69,7 @@ public class PIFWriter {
                 }
                 out.writeBits(len, 8);  
             }
+            
             for (int i = 0; i < 256; i++) {
                 int len;
                 if (canonB.containsKey(i)) {
@@ -82,45 +80,61 @@ public class PIFWriter {
                 out.writeBits(len, 8);
             }
         } catch (IOException e) {
-            System.err.println("Erreur lors de l’écriture des tables de fréquences dans le fichier PIF");
+            System.err.println("Erreur lors de l'écriture des tables de fréquences dans le fichier PIF");
+        }
+
+
+       // Debug pour compter les symboles utilisés et calculer les longueurs moyennes
+        int totalBitsR = 0, totalBitsG = 0, totalBitsB = 0;
+        int countR = 0, countG = 0, countB = 0;
+
+        for (int i = 0; i < 256; i++) {
+            if (canonR.containsKey(i)) {
+                totalBitsR += canonR.get(i).length();
+                countR++;
+            }
+            if (canonG.containsKey(i)) {
+                totalBitsG += canonG.get(i).length();
+                countG++;
+            }
+            if (canonB.containsKey(i)) {
+                totalBitsB += canonB.get(i).length();
+                countB++;
             }
         }
 
-    private void writeBitFromString(BitOutputStream out, String code){
+        System.out.println("Longueur moyenne Rouge : " + (totalBitsR / (double)countR));
-        try {
+        System.out.println("Longueur moyenne Vert : " + (totalBitsG / (double)countG));
-            for (int i = 0; i < code.length(); i++) {
+        System.out.println("Longueur moyenne Bleu : " + (totalBitsB / (double)countB));
-                if (code.charAt(i) == '1') {
+        System.out.println("Symboles utilisés - R:" + countR + " G:" + countG + " B:" + countB);
-                    out.writeBit(1);
-                } else {
-                    out.writeBit(0);   
-                }
-            }
-        } catch (IOException e) {
-            System.err.println("Erreur lors de l’écriture des bits dans le fichier PIF");
-        }
     }
 
     // Méthode pour encoder les pixels de l'image en utilisant les codes canoniques
-    public void encodePixels(BitOutputStream out, RGBImage image, Map<Integer, String> canonRED, Map<Integer, String> canonGREEN, Map<Integer, String> canonBLUE){
+    public void encodePixels(BitOutputStream out, RGBImage image, 
+            Map<Integer, String> canonRED, 
+            Map<Integer, String> canonGREEN, 
+            Map<Integer, String> canonBLUE) {
+        
         int width = image.getWidth();
         int height = image.getHeight();
+        
+        try {
             for (int y = 0; y < height; y++) {
                 for (int x = 0; x < width; x++) {
-                // Récupérer les valeurs R, G, B du pixel
+                    // Récupérer le pixel une seule fois pour optimiser
-                int r = image.getPixel(x, y).getR();
+                    Pixel pixel = image.getPixel(x, y);
-                int g = image.getPixel(x, y).getG();
+                    int r = pixel.getR();
-                int b = image.getPixel(x, y).getB();
+                    int g = pixel.getG();
-
+                    int b = pixel.getB();
-                // Écrire les codes dans le flux binaire
-                writeBitFromString(out, canonRED.get(r));
-                writeBitFromString(out, canonGREEN.get(g));
-                writeBitFromString(out, canonBLUE.get(b));
 
+                    // OPTIMISATION : Utiliser writeBitString() directement
+                    out.writeBitString(canonRED.get(r));
+                    out.writeBitString(canonGREEN.get(g));
+                    out.writeBitString(canonBLUE.get(b));
                 }
             }
-
+        } catch (IOException e) {
-        
+            System.err.println("Erreur lors de l'écriture des pixels dans le fichier PIF");
+        }
     }
-
-    
 }

src/fr/iutfbleau/sae/util/BitOutputStream.java

@@ -109,6 +109,30 @@ public class BitOutputStream {
         this.fluxSortie.flush(); // Force l'écriture dans le flux sous-jacent dans le but de vider le buffer
     }
 
+    /**
+     * Écrit une séquence de bits à partir d'une chaîne de '0' et '1'.
+     *
+     * @param codeBinaire chaîne contenant uniquement '0' et '1'
+     * @throws IOException si une erreur d'écriture survient
+     * @throws IllegalArgumentException si la chaîne contient autre chose que '0' ou '1'
+     */
+    public void writeBitString(String codeBinaire) throws IOException {
+        if (codeBinaire == null) {
+            throw new IllegalArgumentException("Le code binaire ne peut pas être null");
+        }
+        
+        for (int i = 0; i < codeBinaire.length(); i++) {
+            char c = codeBinaire.charAt(i);
+            if (c == '0') {
+                writeBit(0);
+            } else if (c == '1') {
+                writeBit(1);
+            } else {
+                throw new IllegalArgumentException("Le code binaire ne doit contenir que '0' et '1'");
+            }
+        }
+    }
+
     /**
      * Vide les buffers internes et ferme le flux de sortie.
      *