sae fini les gars

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

@@ -1,52 +1,28 @@
 package fr.iutfbleau.sae.mhuffman;
+
 import fr.iutfbleau.sae.mpif.Pixel;
 import fr.iutfbleau.sae.mpif.RGBImage;
 
 /**
- * Représente une table de fréquences pour une image RGB.
- * <p>
- * Cette classe est utilisée dans le cadre de la compression de Huffman.
- * Elle compte le nombre d'occurrences de chaque valeur possible (0 à 255)
- * pour chacune des composantes de couleur : rouge, vert et bleu.
- * </p>
- *
- * <p>
- * Chaque composante est stockée dans un tableau de taille 256 :
- * <ul>
- *   <li>{@code freqR} pour le rouge</li>
- *   <li>{@code freqG} pour le vert</li>
- *   <li>{@code freqB} pour le bleu</li>
- * </ul>
- * L'indice du tableau correspond à la valeur de la composante,
- * et la valeur stockée correspond à sa fréquence d'apparition.
- * </p>
- *
- * <p>
- * Cette table de fréquences sert ensuite à construire les arbres de Huffman
- * nécessaires à la compression des données de l'image.
- * </p>
- *
- * @author Algassimou Pellel Diallo
- * @version 1.1
- * @since 2025-12-13
+ * 
+ * Classe qui calcule les fréquences des valeurs de couleur dans une image RGB.
+ * Elle compte combien de fois chaque valeur de rouge, vert et bleu apparaît,
+ * ce qui servira ensuite pour construire les arbres de Huffman.
  */
 public class FrequencyTable {
 
-    /** Tableau des fréquences pour la composante rouge (valeurs de 0 à 255). */
+    /** Fréquences des valeurs de rouge entre 0 et 255. */
     private final int[] freqR;
 
-    /** Tableau des fréquences pour la composante verte (valeurs de 0 à 255). */
+    /** Fréquences des valeurs de vert entre 0 et 255. */
     private final int[] freqG;
 
-    /** Tableau des fréquences pour la composante bleue (valeurs de 0 à 255). */
-    private final  int[] freqB;
+    /** Fréquences des valeurs de bleu entre 0 et 255. */
+    private final int[] freqB;
 
     /**
-     * Construit une table de fréquences vide.
-     * <p>
-     * Les trois tableaux de fréquences sont initialisés
-     * avec 256 cases mises à zéro.
-     * </p>
+     * Constructeur qui initialise les trois tableaux de fréquences
+     * à zéro pour toutes les valeurs possibles.
      */
     public FrequencyTable() {
         this.freqR = new int[256];
@@ -55,33 +31,23 @@ public class FrequencyTable {
     }
 
     /**
-     * Calcule les fréquences des composantes RGB à partir d'une image.
-     * <p>
-     * Pour chaque pixel de l'image, la méthode récupère les valeurs
-     * rouge, verte et bleue, puis incrémente la case correspondante
-     * dans le tableau de fréquences associé.
-     * </p>
+     * Analyse une image et remplit les tableaux de fréquences.
+     * Pour chaque pixel, on récupère la valeur de rouge, de vert et de bleu,
+     * puis on incrémente la fréquence associée.
      *
-     * @param img l'image RGB à analyser
-     * @throws IllegalArgumentException si l'image est null
+     * @param img l'image à analyser
+     * @throws IllegalArgumentException si l'image est nulle
      */
     public void computeFromImage(RGBImage img) {
         if (img == null) {
             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.
-         */
+
         for (int x = 0; x < img.getWidth(); x++) {
             for (int y = 0; y < img.getHeight(); y++) {
-                // On récupère le pixel une seule fois pour optimiser
+
                 Pixel pixel = img.getPixel(x, y);
-                
-                // Puis on incrémente les trois fréquences
+
                 this.freqR[pixel.getR()]++;
                 this.freqG[pixel.getG()]++;
                 this.freqB[pixel.getB()]++;
@@ -90,28 +56,29 @@ public class FrequencyTable {
     }
 
     /**
-     * Retourne le tableau des fréquences de la composante rouge.
+     * Renvoie les fréquences des valeurs rouges.
      *
-     * @return un tableau de 256 entiers représentant les fréquences du rouge
+     * @return tableau de fréquence pour le rouge
      */
     public int[] getRed() {
         return this.freqR;
     }
 
     /**
-     * Retourne le tableau des fréquences de la composante verte.
-     * @return un tableau de 256 entiers représentant les fréquences du vert
+     * Renvoie les fréquences des valeurs vertes.
+     *
+     * @return tableau de fréquence pour le vert
      */
     public int[] getGreen() {
         return this.freqG;
     }
 
     /**
-     * Retourne le tableau des fréquences de la composante bleue.
+     * Renvoie les fréquences des valeurs bleues.
      *
-     * @return un tableau de 256 entiers représentant les fréquences du bleu
+     * @return tableau de fréquence pour le bleu
      */
     public int[] getBlue() {
         return this.freqB;
     }
-}
+}