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

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
 */
public class FrequencyTable {

    /** Tableau des fréquences pour la composante rouge (valeurs de 0 à 255). */
    private final int[] freqR;

    /** Tableau des fréquences pour la composante verte (valeurs de 0 à 255). */
    private final int[] freqG;

    /** Tableau des fréquences pour la composante bleue (valeurs de 0 à 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>
     */
    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
     * @throws IllegalArgumentException si l'image est null
     */
    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()]++;
            }
        }
    }

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