compilation plantuml

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

@@ -1,31 +1,113 @@
-import java.awt.image.BufferedImage;
+package fr.iutfbleau.sae.mhuffman;
 
-public class FrequencyTable{
-	private int[] freqR;
-	private int[] freqG;
-	private int[] freqB;
+/**
+ * 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.0
+ * @since 2025-12-13
+ */
+public class FrequencyTable {
 
-	public FrequencyTable(){
-		// creation des 3 tableaux : la taille n'est pas definitive : ell est susceptible de changer (tres fortement)
-		this.freqR = new int[50];
-		this.freqG = new int[50];
-		this.freqB = new int[50];
-	}
+    /** Tableau des fréquences pour la composante rouge (valeurs de 0 à 255). */
+    private int[] freqR;
+
+    /** Tableau des fréquences pour la composante verte (valeurs de 0 à 255). */
+    private int[] freqG;
+
+    /** Tableau des fréquences pour la composante bleue (valeurs de 0 à 255). */
+    private 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>
+     */
+    public FrequencyTable() {
+        this.freqR = new int[256];
+        this.freqG = new int[256];
+        this.freqB = new int[256];
+    }
+
+    /**
+     * 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>
+     *
+     * @param img l'image RGB à analyser
+     */
+    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
+			dans la couleur d'un pixel.
+		*/
+		/* 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 i = 0; i < img.getWidth() * img.getHeight(); i++) {
+			// En un mot: frequence[Composante] += 1
+            this.freqR[img.getPixel(i).getR()]++; // Incrémente la fréquence de la composante rouge
+            this.freqG[img.getPixel(i).getG()]++; // Incrémente la fréquence de la composante verte
+            this.freqB[img.getPixel(i).getB()]++; // Incrémente la fréquence de la composante bleue
+        }
+    }
+
+    /**
+     * Retourne le tableau des fréquences de la composante rouge.
+     *
+     * @return un tableau de 256 entiers représentant les fréquences du 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
+     */
+    public int[] getGreen() {
+        return this.freqG;
+    }
+
+    /**
+     * Retourne le tableau des fréquences de la composante bleue.
+     *
+     * @return un tableau de 256 entiers représentant les fréquences du bleu
+     */
+    public int[] getBlue() {
+        return this.freqB;
+    }
+}
 
 
-	public void computeFromImage(BufferedImage image){
 
-	}
 
-	public int[] getRed(){
-		return this.freqR;
-	}
-
-	public int[] getGreen(){
-		return this.freqG;
-	}
-
-	public int[] getBlue(){
-		return this.freqB;
-	}
-}

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

@@ -10,11 +10,13 @@ import java.io.OutputStream;
  * l'écriture de bits individuellement ou par groupes.
  * Les bits sont accumulés afin de former des octets avant écriture.
  * </p>
- *
  * <p>
  * Utilisée notamment pour l'encodage des fichiers compressés
  * (ex : format PIF utilisant des codes de Huffman).
  * </p>
+ * @author Algassimou Pellel Diallo
+ * @version 1.0
+ * @since 2025-12-13
  */
 public class BitOutputStream {
 
@@ -100,7 +102,7 @@ public class BitOutputStream {
         while (this.positionBit >= 0) {
             writeBit(0);
         }
-        this.fluxSortie.flush(); // Force l'écriture dans le flux sous-jacent
+        this.fluxSortie.flush(); // Force l'écriture dans le flux sous-jacent dans le but de vider le buffer
     }
 
     /**

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

@@ -10,11 +10,17 @@ import java.io.InputStream;
  * des opérations de lecture bit par bit ou par groupes de bits.
  * Elle ne gère ni l'ouverture ni la sélection du fichier source.
  * </p>
- *
+ * 
  * <p>
  * Utilisée notamment pour le décodage des fichiers compressés
  * (ex : format PIF utilisant des codes de Huffman).
  * </p>
+ * 
+ * 
+ * 
+ * @author Algassimou Pellel Diallo
+ * @version 1.0
+ * @since 2025-12-13
  */
 public class BitInputStream {
 
@@ -83,7 +89,7 @@ public class BitInputStream {
      * @return valeur entière correspondant aux bits lus,
      *         ou -1 si la fin du flux est atteinte prématurément
      * @throws IOException si une erreur de lecture survient
-    */
+     */
     public int readBits(int nombreBits) throws IOException {
         int res=0;
         for (int i = 0; i < nombreBits; i++) {
@@ -96,8 +102,6 @@ public class BitInputStream {
         return res;
     }
 
-
-
     /**
      * Ferme le flux d'entrée sous-jacent.
      *

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

@@ -27,7 +27,7 @@ public final class ByteUtils {
      * </p>
      */
     private ByteUtils() {
-        // empêche l'instanciation
+        // j'empêche l'instanciation
     }
 
     /**
@@ -38,7 +38,7 @@ public final class ByteUtils {
      * </p>
      *
      * @param value valeur entière à convertir (0 ≤ value ≤ 65535)
-     * @return tableau de deux octets : [octetFort, octetFaible]
+     * @return tableau de deux octets : [octetFort, octetFaible] M
      * @throws IllegalArgumentException si la valeur ne tient pas sur 2 octets
      */
     public static byte[] toBytes(int value) {