je commence la java doc

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

@@ -0,0 +1,35 @@
+package fr.iutfbleau.sae.mpif;
+
+import java.util.Comparator;
+import java.util.Map;
+
+/**
+ * Comparateur pour trier les entrées (symbole, longueur) lors de la reconstruction
+ * des codes canoniques.
+ * Le tri s'effectue d'abord par longueur croissante, puis par symbole croissant
+ * en cas d'égalité de longueur.
+ * </p>
+ */
+public class ComparateurEntreeCanonique implements Comparator<Map.Entry<Integer, Integer>> {
+    
+    /**
+     * Compare deux entrées (symbole, longueur).
+     * 
+     * @param entree1 première entrée
+     * @param entree2 deuxième entrée
+     * @return un entier négatif, zéro, ou positif selon que la première entrée
+     *         est inférieure, égale ou supérieure à la seconde
+     */
+    @Override
+    public int compare(Map.Entry<Integer, Integer> entree1, Map.Entry<Integer, Integer> entree2) {
+        // Comparer d'abord par longueur (valeur)
+        int comparaisonLongueur = entree1.getValue().compareTo(entree2.getValue());
+        
+        if (comparaisonLongueur != 0) {
+            return comparaisonLongueur;
+        }
+        
+        // Si les longueurs sont égales, comparer par symbole (clé)
+        return entree1.getKey().compareTo(entree2.getKey());
+    }
+}

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

@@ -67,9 +67,12 @@ public class PIFReader {
     
 
     /**
-     * Lit les trois tables de longueurs (R, G, B).
-     * Chaque table contient 256 valeurs sur 5 bits.
-     * @throws IOException si erreur de lecture
+     * Lit les longueurs des code canoniques pour les trois composantes
+     * rouge, vert et bleu. Chaque table contient 256 valeurs sur 5 bits.
+     * Ces longueurs permettront  de reconstruire les vrais codes plus tard
+     * 
+     * @param in flux binaire d'entrée
+     * @throws IOException si erreur de lecture se produit
      */
     public void readCanonicalTables(BitInputStream in) throws IOException {
         // Table Rouge
@@ -93,11 +96,14 @@ public class PIFReader {
         System.out.println("Tables de longueurs lues");
     }
 
+
     /**
-     * Reconstruit les codes canoniques à partir des longueurs.
-     * 
-     * @param lengths tableau de 256 longueurs
-     * @return Map<code, symbole> pour le décodage
+     * Reconstruit les codes canoniques à partir des longueurs stockées dans le fichier.
+     * On trie d'abord les paires (symbole, longueur), puis on génère les codes
+     * en appliquant la règle des codes canoniques.
+     *
+     * @param lengths tableau contenant les longueurs des codes pour 256 symboles
+     * @return une table qui associe un code binaire (sous forme de texte) à son symbole
      */
     public Map<String, Integer> rebuildCanonical(int[] lengths) {
         // je cree une liste de paires (symbole, longueur)
@@ -110,11 +116,8 @@ public class PIFReader {
         }
 
         // Je trie par longueur croissante, puis par symbole croissant
-        entiers.sort((a, b) -> {
-            int cmp = a.getValue().compareTo(b.getValue());
-            if (cmp != 0) return cmp;
-            return a.getKey().compareTo(b.getKey());
-        });
+        ComparateurEntreeCanonique comparateur = new ComparateurEntreeCanonique();
+        entiers.sort(comparateur);
 
         // je genere les codes canoniques
         Map<String, Integer> codes = new HashMap<>();
@@ -146,9 +149,11 @@ public class PIFReader {
     }
 
     /**
-     * Construit l'arbre de décodage à partir des codes canoniques.
+     * Construit un arbre de décodage à partir des codes canoniques.
+     * Chaque code binaire définit un chemin dans l'arbre jusqu'à une feuille
+     * contenant le symbole à décoder.
      *
-     * @param codes Map<String (code binaire), symbole> les codes canoniques avec les bits comme clés et les symboles comme valeurs
+     * @param codes dictionnaire associant le code binaire au symbole
      * @return la racine de l'arbre de décodage
      */
     public DecodeNode buildDecodageTree(Map<String,Integer> codes) {
@@ -193,14 +198,17 @@ public class PIFReader {
 
 
     /**
-     * Décode les pixels à partir des arbres de décodage.
+     * Décode l'ensemble des pixels de l'image en utilisant les trois arbres
+     * correspondant aux composantes rouge, verte et bleue.
+     * Chaque symbole est lu en parcourant l'arbre bit par bit.
      *
-     * @param in flux d'entrée binaire
-     * @param red arbre de décodage pour la composante rouge
-     * @param green arbre de décodage pour la composante verte
-     * @param blue arbre de décodage pour la composante bleue
-     * @return l'image reconstruite
-     */
+     * @param in flux binaire contenant les données des pixels
+     * @param red arbre de décodage pour le rouge
+     * @param green arbre pour le vert
+     * @param blue arbre pour le bleu
+     * @return l'image RGB reconstruite
+     * @throws IOException si un symbole est invalide ou si la lecture échoue
+    */
     public RGBImage decodePixels(BitInputStream in, DecodeNode red, DecodeNode green, DecodeNode blue) throws IOException{
        RGBImage image = new RGBImage(width, height);
         
@@ -220,12 +228,15 @@ public class PIFReader {
     }
     
     /**
-     * Décode un symbole en parcourant l'arbre bit par bit 
-     * @param in le flux d'entrée binaire
-     * @param root la racine de l'arbre de décodage
-     * @return le symbole décodé (valeur entre 0 et 255)
-     * @throws IOException si une erreur d'entrée/sortie se produit
+     * Décode un seul symbole en parcourant l'arbre tant qu'on n'est pas sur une feuille.
+     * Chaque bit lu détermine si on part à gauche ou à droite dans l'arbre.
+     *
+     * @param in flux binaire source
+     * @param root racine de l'arbre de décodage
+     * @return la valeur du symbole trouvé
+     * @throws IOException si un chemin est invalide ou si la lecture échoue
      */
+
     private int decodeSymbole(BitInputStream in, DecodeNode root) throws IOException {
         DecodeNode current = root;
         
@@ -250,6 +261,14 @@ public class PIFReader {
     }
 
 
+    /**
+     * Vérifie si un fichier est un fichier .pif valide.
+     * On teste l'existence du fichier, son extension et une taille minimale
+     * permettant au moins de contenir l'en-tête et les tables de longueurs.
+     *
+     * @param f fichier à tester
+     * @return true si le fichier semble être un .pif valide, sinon false
+     */
     public static boolean isPIFFile(File f) {
         if (f == null){
             return false;