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

package fr.iutfbleau.sae.mhuffman;
import fr.iutfbleau.sae.mimage.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.0
 * @since 2025-12-13
 */
public class FrequencyTable {

    /** 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 ligne = 0; ligne < img.getWidth(); ligne++) {
            for (int colonne = 0; colonne < img.getHeight(); colonne++) {
                this.freqR[img.getPixel(ligne, colonne).getR()]++; // Incrémente la fréquence de la composante rouge
                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
            }
        }
    }

    /**
     * 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;
    }
}