- * Cette classe gère le chargement des fichiers image et les opérations - * de conversion associées. tel que - *
- * - */ -public class ConverterController { - // Image convertie en RGBImage - private RGBImage image; - - // Table de fréquences pour chaque composante - private FrequencyTable frequencyTable; - - // Arbres de Huffman pour chaque composante - private Map+ * Cette classe gère le chargement des fichiers image et les opérations + * de conversion associées. tel que + *
+ * + */ +public class ConverterController { + // Image convertie en RGBImage + private RGBImage image; + + // Table de fréquences pour chaque composante + private FrequencyTable frequencyTable; + + // Arbres de Huffman pour chaque composante + private Map- * 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. - *
- * - *- * Chaque composante est stockée dans un tableau de taille 256 : - *
- * Cette table de fréquences sert ensuite à construire les arbres de Huffman - * nécessaires à la compression des données de l'image. - *
- * - * @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. - *- * Les trois tableaux de fréquences sont initialisés - * avec 256 cases mises à zéro. - *
- */ - 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. - *- * 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é. - *
- * - * @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; - } -} - - - - +package fr.iutfbleau.sae.mhuffman; +import fr.iutfbleau.sae.mimage.RGBImage; + +/** + * Représente une table de fréquences pour une image RGB. + *+ * 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. + *
+ * + *+ * Chaque composante est stockée dans un tableau de taille 256 : + *
+ * Cette table de fréquences sert ensuite à construire les arbres de Huffman + * nécessaires à la compression des données de l'image. + *
+ * + * @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. + *+ * Les trois tableaux de fréquences sont initialisés + * avec 256 cases mises à zéro. + *
+ */ + 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. + *+ * 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é. + *
+ * + * @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; + } +} + + + + diff --git a/src/fr/iutfbleau/sae/mhuffman/HuffmanNode.java b/src/fr/iutfbleau/sae/mhuffman/HuffmanNode.java index 8c46124..652cce4 100644 --- a/src/fr/iutfbleau/sae/mhuffman/HuffmanNode.java +++ b/src/fr/iutfbleau/sae/mhuffman/HuffmanNode.java @@ -1,119 +1,119 @@ -package fr.iutfbleau.sae.mhuffman; - -/** - * Représente un nœud de l'arbre de Huffman. - *- * Un {@code HuffmanNode} peut être : - *
- * Cette classe est une structure de données utilisée par {@code HuffmanTree} - * pour construire l'arbre de Huffman. - *
- * - * @author Algassimou Pellel Diallo - * @version 1.1 - * @since 2025-12-17 - */ -public class HuffmanNode { - - /** Valeur de la composante (cette valeur est appelée symbole, voir l'histoire de huffman, tres interressant) représentée par ce nœud (si feuille). c'est la part de la composante (rouge, verte ou bleue) dans la couleur d'un pixel. */ - private int value; - - /** Fréquence du symbole (somme des fréquences des enfants). */ - private int frequence; - - /** Fils gauche du nœud (null si feuille). */ - private HuffmanNode left; - - /** Fils droit du nœud (null si feuille). */ - private HuffmanNode right; - - /** - * Construit un nœud feuille de Huffman. - *- * Ce constructeur est utilisé pour représenter une valeur - * issue de la table de fréquences. - *
- * - * @param value la valeur (symbole) représentée par ce nœud - * @param frequence la fréquence d'apparition de la valeur - */ - public HuffmanNode(int value, int frequence) { - this.value = value; - this.frequence = frequence; - this.left = null; - this.right = null; - } - - /** - * Construit un nœud interne de Huffman. - *- * Ce constructeur est utilisé lors de la fusion de deux nœuds - * de plus faible fréquence lors de la construction de l'arbre. - *
- * - * @param left le fils gauche - * @param right le fils droit - */ - public HuffmanNode(HuffmanNode left, HuffmanNode right) { - this.left = left; - this.right = right; - this.frequence = left.frequence + right.frequence; - } - - /** - * Indique si ce nœud est une feuille. - * - * @return {@code true} si le nœud est une feuille, {@code false} sinon - */ - public boolean isLeaf() { - return this.left == null && this.right == null; - } - - /** - * Retourne la fréquence du nœud. - * - * @return la fréquence - */ - public int getFrequence() { - return this.frequence; - } - - /** - * Retourne le fils gauche du nœud. - * - * @return le fils gauche - */ - public HuffmanNode getLeft() { - return this.left; - } - - /** - * Retourne le fils droit du nœud. - * - * @return le fils droit - */ - public HuffmanNode getRight() { - return this.right; - } - - /** - * Retourne la valeur représentée par ce nœud. - *- * Cette méthode n'a de sens que si le nœud est une feuille. - *
- * - * @return la valeur du symbole - */ - public int getValue() { - if (!this.isLeaf()) { - throw new IllegalStateException("La valeur n'est définie que pour les feuilles."); - } - return this.value; - } -} +package fr.iutfbleau.sae.mhuffman; + +/** + * Représente un nœud de l'arbre de Huffman. + *+ * Un {@code HuffmanNode} peut être : + *
+ * Cette classe est une structure de données utilisée par {@code HuffmanTree} + * pour construire l'arbre de Huffman. + *
+ * + * @author Algassimou Pellel Diallo + * @version 1.1 + * @since 2025-12-17 + */ +public class HuffmanNode { + + /** Valeur de la composante (cette valeur est appelée symbole, voir l'histoire de huffman, tres interressant) représentée par ce nœud (si feuille). c'est la part de la composante (rouge, verte ou bleue) dans la couleur d'un pixel. */ + private int value; + + /** Fréquence du symbole (somme des fréquences des enfants). */ + private int frequence; + + /** Fils gauche du nœud (null si feuille). */ + private HuffmanNode left; + + /** Fils droit du nœud (null si feuille). */ + private HuffmanNode right; + + /** + * Construit un nœud feuille de Huffman. + *+ * Ce constructeur est utilisé pour représenter une valeur + * issue de la table de fréquences. + *
+ * + * @param value la valeur (symbole) représentée par ce nœud + * @param frequence la fréquence d'apparition de la valeur + */ + public HuffmanNode(int value, int frequence) { + this.value = value; + this.frequence = frequence; + this.left = null; + this.right = null; + } + + /** + * Construit un nœud interne de Huffman. + *+ * Ce constructeur est utilisé lors de la fusion de deux nœuds + * de plus faible fréquence lors de la construction de l'arbre. + *
+ * + * @param left le fils gauche + * @param right le fils droit + */ + public HuffmanNode(HuffmanNode left, HuffmanNode right) { + this.left = left; + this.right = right; + this.frequence = left.frequence + right.frequence; + } + + /** + * Indique si ce nœud est une feuille. + * + * @return {@code true} si le nœud est une feuille, {@code false} sinon + */ + public boolean isLeaf() { + return this.left == null && this.right == null; + } + + /** + * Retourne la fréquence du nœud. + * + * @return la fréquence + */ + public int getFrequence() { + return this.frequence; + } + + /** + * Retourne le fils gauche du nœud. + * + * @return le fils gauche + */ + public HuffmanNode getLeft() { + return this.left; + } + + /** + * Retourne le fils droit du nœud. + * + * @return le fils droit + */ + public HuffmanNode getRight() { + return this.right; + } + + /** + * Retourne la valeur représentée par ce nœud. + *+ * Cette méthode n'a de sens que si le nœud est une feuille. + *
+ * + * @return la valeur du symbole + */ + public int getValue() { + if (!this.isLeaf()) { + throw new IllegalStateException("La valeur n'est définie que pour les feuilles."); + } + return this.value; + } +} diff --git a/src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java b/src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java index d87c0b3..0ae0341 100644 --- a/src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java +++ b/src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java @@ -1,218 +1,218 @@ -package fr.iutfbleau.sae.mhuffman; -import java.util.ArrayList; -import java.util.Comparator; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -// test - -/** - * Implémente un arbre de Huffman utilisé pour la compression de données. - *- * La classe {@code HuffmanTree} est chargée de représenter la structure - * de l'arbre de Huffman et de générer les codes binaires associés aux symboles. - * Elle s'appuie sur la classe {@link HuffmanNode} pour représenter les nœuds - * de l'arbre. - *
- * - *- * L'arbre est construit à partir des fréquences des symboles calculées - * en amont (par exemple à l'aide d'une {@code FrequencyTable}). - * Chaque symbole est d'abord représenté par une feuille, puis les nœuds - * sont combinés progressivement selon l'algorithme de Huffman afin - * d'obtenir un arbre binaire optimal. - *
- * - *- * Une fois l'arbre construit, celui-ci est parcouru afin de générer une - * table de correspondance associant à chaque symbole un code binaire unique. - * Les symboles les plus fréquents se retrouvent plus proches de la racine - * et possèdent donc des codes plus courts, ce qui permet de réduire - * la taille des données compressées. - *
- * - *- * Cette classe ne s'occupe pas de la lecture ou de l'écriture des bits. - * Elle fournit uniquement la structure et les informations nécessaires - * à la compression, qui sont ensuite exploitées par des flux binaires - * dédiés. - *
- * - * @author Algassimou Pellel Diallo,Ayoub Anhdire - * @version 1.0 - * @since 2025-12-13 - */ -public class HuffmanTree { - - /** - * Racine de l'arbre de Huffman. - *- * Ce nœud est le résultat final de la construction de l'arbre et constitue - * le point de départ pour la génération des codes binaires ainsi que - * pour le décodage des données compressées. - *
- */ - private HuffmanNode root; - - /** - * Dictionnaire pour enregistrer les codes Huffman - */ - // j'ai retirer le static car chaque arbre a ses propres codes et j'utilise string plutot que int pour stocker les codes car on construit une chaine de 0 et de 1 - private Map- * Le constructeur est responsable de l'initialisation de la structure - * de l'arbre. En pratique, il combine les nœuds feuilles représentant - * les symboles par ordre croissant de fréquence jusqu'à obtenir un - * unique nœud racine. - *
- * - *- * Les détails de la construction (structure de données utilisée, - * ordre des fusions, etc.) sont volontairement séparés de la logique - * de génération des codes. - *
- */ - public HuffmanTree(int[] freq) { - // J'initialise la racine à null. - this.root = null; - - // je cree une collection de feuilles - List+ * La classe {@code HuffmanTree} est chargée de représenter la structure + * de l'arbre de Huffman et de générer les codes binaires associés aux symboles. + * Elle s'appuie sur la classe {@link HuffmanNode} pour représenter les nœuds + * de l'arbre. + *
+ * + *+ * L'arbre est construit à partir des fréquences des symboles calculées + * en amont (par exemple à l'aide d'une {@code FrequencyTable}). + * Chaque symbole est d'abord représenté par une feuille, puis les nœuds + * sont combinés progressivement selon l'algorithme de Huffman afin + * d'obtenir un arbre binaire optimal. + *
+ * + *+ * Une fois l'arbre construit, celui-ci est parcouru afin de générer une + * table de correspondance associant à chaque symbole un code binaire unique. + * Les symboles les plus fréquents se retrouvent plus proches de la racine + * et possèdent donc des codes plus courts, ce qui permet de réduire + * la taille des données compressées. + *
+ * + *+ * Cette classe ne s'occupe pas de la lecture ou de l'écriture des bits. + * Elle fournit uniquement la structure et les informations nécessaires + * à la compression, qui sont ensuite exploitées par des flux binaires + * dédiés. + *
+ * + * @author Algassimou Pellel Diallo,Ayoub Anhdire + * @version 1.0 + * @since 2025-12-13 + */ +public class HuffmanTree { + + /** + * Racine de l'arbre de Huffman. + *+ * Ce nœud est le résultat final de la construction de l'arbre et constitue + * le point de départ pour la génération des codes binaires ainsi que + * pour le décodage des données compressées. + *
+ */ + private HuffmanNode root; + + /** + * Dictionnaire pour enregistrer les codes Huffman + */ + // j'ai retirer le static car chaque arbre a ses propres codes et j'utilise string plutot que int pour stocker les codes car on construit une chaine de 0 et de 1 + private Map+ * Le constructeur est responsable de l'initialisation de la structure + * de l'arbre. En pratique, il combine les nœuds feuilles représentant + * les symboles par ordre croissant de fréquence jusqu'à obtenir un + * unique nœud racine. + *
+ * + *+ * Les détails de la construction (structure de données utilisée, + * ordre des fusions, etc.) sont volontairement séparés de la logique + * de génération des codes. + *
+ */ + public HuffmanTree(int[] freq) { + // J'initialise la racine à null. + this.root = null; + + // je cree une collection de feuilles + List- * Cette classe encapsule un {@link OutputStream} existant et permet - * l'écriture de bits individuellement ou par groupes. - * Les bits sont accumulés afin de former des octets avant écriture. - *
- *- * Utilisée notamment pour l'encodage des fichiers compressés - * (ex : format PIF utilisant des codes de Huffman). - *
- * @author Algassimou Pellel Diallo - * @version 1.0 - * @since 2025-12-13 - */ -public class BitOutputStream { - - /** Flux de sortie sous-jacent */ - private final OutputStream fluxSortie; - - /** Octet en cours de construction */ - private int octetEnConstruction; - - /** Position du prochain bit à écrire (de 7 à 0) */ - private int positionBit; - - /** Indique si le flux est fermé */ - private boolean fluxFerme; - - /** - * Construit un écrivain binaire à partir d'un flux existant. - * - * @param fluxSortie flux de sortie à décorer - * @throws IllegalArgumentException si le flux est nul - */ - public BitOutputStream(OutputStream fluxSortie) { - if (fluxSortie == null) { - throw new IllegalArgumentException("Le flux de sortie ne peut pas être nul"); - } - this.fluxSortie = fluxSortie; - this.octetEnConstruction = 0; - this.positionBit = 7; - this.fluxFerme = false; - } - - /** - * Écrit un bit dans le flux binaire. - * - * @param bit bit à écrire (0 ou 1) - * @throws IOException si une erreur d'écriture survient - * @throws IllegalArgumentException si le bit n'est ni 0 ni 1 - */ - public void writeBit(int bit) throws IOException { - if (bit != 0 && bit != 1) { - throw new IllegalArgumentException("Le bit doit être 0 ou 1"); - } - if (fluxFerme) { - throw new IOException("Le flux de sortie est fermé"); - } - if (bit == 1) { - this.octetEnConstruction = this.octetEnConstruction | (1 << this.positionBit); - } - this.positionBit--; - - // si on atteint la fin de l'octet, on le grave dans le flux et rebolotte - if(this.positionBit < 0){ - this.fluxSortie.write(this.octetEnConstruction); - this.octetEnConstruction = 0; - this.positionBit = 7; - } - - } - - /** - * Écrit une séquence de bits correspondant à une valeur entière. - * - * @param valeur valeur contenant les bits à écrire - * @param nombreBits nombre de bits à écrire (strictement positif) - * @throws IOException si une erreur d'écriture survient - */ - public void writeBits(int valeur, int nombreBits) throws IOException { - for (int i = nombreBits - 1; i >= 0; i--) { - int bit = (valeur >> i) & 1; - writeBit(bit); - } - } - - /** - * Force l'écriture immédiate des données accumulées dans le flux sous-jacent. - * - * @throws IOException si une erreur survient lors du flush - */ - public void flush() throws IOException { - if (fluxFerme) { - throw new IOException("Le flux de sortie est fermé"); - } - - // Si l'octet nes pas vide on le complete avec des 0 - if(this.positionBit < 7){ - this.fluxSortie.write(this.octetEnConstruction); - this.octetEnConstruction = 0; - this.positionBit = 7; - } - - this.fluxSortie.flush(); // Force l'écriture dans le flux sous-jacent dans le but de vider le buffer - } - - /** - * Vide les buffers internes et ferme le flux de sortie. - * - * @throws IOException si une erreur survient lors de la fermeture - */ - public void fermerFlux() throws IOException { - // si le flux n'est pas déjà fermé - if (!fluxFerme) { - this.flush(); // compléter l'octet et forcer l'écriture - this.fluxSortie.close(); // fermer le flux sous-jacent - this.fluxFerme = true; // marquer le flux comme fermé - } - } - - -} +package fr.iutfbleau.sae.util; +import java.io.IOException; +import java.io.OutputStream; + +/** + * Décorateur de flux permettant l'écriture binaire à granularité du bit. + *+ * Cette classe encapsule un {@link OutputStream} existant et permet + * l'écriture de bits individuellement ou par groupes. + * Les bits sont accumulés afin de former des octets avant écriture. + *
+ *+ * Utilisée notamment pour l'encodage des fichiers compressés + * (ex : format PIF utilisant des codes de Huffman). + *
+ * @author Algassimou Pellel Diallo + * @version 1.0 + * @since 2025-12-13 + */ +public class BitOutputStream { + + /** Flux de sortie sous-jacent */ + private final OutputStream fluxSortie; + + /** Octet en cours de construction */ + private int octetEnConstruction; + + /** Position du prochain bit à écrire (de 7 à 0) */ + private int positionBit; + + /** Indique si le flux est fermé */ + private boolean fluxFerme; + + /** + * Construit un écrivain binaire à partir d'un flux existant. + * + * @param fluxSortie flux de sortie à décorer + * @throws IllegalArgumentException si le flux est nul + */ + public BitOutputStream(OutputStream fluxSortie) { + if (fluxSortie == null) { + throw new IllegalArgumentException("Le flux de sortie ne peut pas être nul"); + } + this.fluxSortie = fluxSortie; + this.octetEnConstruction = 0; + this.positionBit = 7; + this.fluxFerme = false; + } + + /** + * Écrit un bit dans le flux binaire. + * + * @param bit bit à écrire (0 ou 1) + * @throws IOException si une erreur d'écriture survient + * @throws IllegalArgumentException si le bit n'est ni 0 ni 1 + */ + public void writeBit(int bit) throws IOException { + if (bit != 0 && bit != 1) { + throw new IllegalArgumentException("Le bit doit être 0 ou 1"); + } + if (fluxFerme) { + throw new IOException("Le flux de sortie est fermé"); + } + if (bit == 1) { + this.octetEnConstruction = this.octetEnConstruction | (1 << this.positionBit); + } + this.positionBit--; + + // si on atteint la fin de l'octet, on le grave dans le flux et rebolotte + if(this.positionBit < 0){ + this.fluxSortie.write(this.octetEnConstruction); + this.octetEnConstruction = 0; + this.positionBit = 7; + } + + } + + /** + * Écrit une séquence de bits correspondant à une valeur entière. + * + * @param valeur valeur contenant les bits à écrire + * @param nombreBits nombre de bits à écrire (strictement positif) + * @throws IOException si une erreur d'écriture survient + */ + public void writeBits(int valeur, int nombreBits) throws IOException { + for (int i = nombreBits - 1; i >= 0; i--) { + int bit = (valeur >> i) & 1; + writeBit(bit); + } + } + + /** + * Force l'écriture immédiate des données accumulées dans le flux sous-jacent. + * + * @throws IOException si une erreur survient lors du flush + */ + public void flush() throws IOException { + if (fluxFerme) { + throw new IOException("Le flux de sortie est fermé"); + } + + // Si l'octet nes pas vide on le complete avec des 0 + if(this.positionBit < 7){ + this.fluxSortie.write(this.octetEnConstruction); + this.octetEnConstruction = 0; + this.positionBit = 7; + } + + this.fluxSortie.flush(); // Force l'écriture dans le flux sous-jacent dans le but de vider le buffer + } + + /** + * Vide les buffers internes et ferme le flux de sortie. + * + * @throws IOException si une erreur survient lors de la fermeture + */ + public void fermerFlux() throws IOException { + // si le flux n'est pas déjà fermé + if (!fluxFerme) { + this.flush(); // compléter l'octet et forcer l'écriture + this.fluxSortie.close(); // fermer le flux sous-jacent + this.fluxFerme = true; // marquer le flux comme fermé + } + } + + +} diff --git a/src/fr/iutfbleau/sae/util/BitinputStream.java b/src/fr/iutfbleau/sae/util/BitinputStream.java index 06ce9ca..0054036 100644 --- a/src/fr/iutfbleau/sae/util/BitinputStream.java +++ b/src/fr/iutfbleau/sae/util/BitinputStream.java @@ -1,115 +1,115 @@ -package fr.iutfbleau.sae.util; -import java.io.IOException; -import java.io.InputStream; - -/** - * Décorateur de flux permettant la lecture binaire à granularité du bit. - *- * Cette classe encapsule un {@link InputStream} existant et fournit - * 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. - *
- * - *- * Utilisée notamment pour le décodage des fichiers compressés - * (ex : format PIF utilisant des codes de Huffman). - *
- * - * - * - * @author Algassimou Pellel Diallo - * @version 1.0 - * @since 2025-12-13 - */ -public class BitInputStream { - - /** Flux d'entrée sous-jacent */ - private final InputStream fluxEntree; - - /** Octet actuellement chargé depuis le flux */ - private int octetCourant; - - /** Position du bit courant dans l'octet (du bit 7 au bit 0) */ - private int positionBit; - - /** Indique si la fin du flux a été atteinte */ - private boolean finDeFlux; - - /** - * Construit un lecteur binaire à partir d'un flux existant. - * - * @param fluxEntree flux d'entrée à décorer - * @throws IllegalArgumentException si le flux est nul - */ - public BitInputStream(InputStream fluxEntree) { - if (fluxEntree == null) { - throw new IllegalArgumentException("Le flux d'entrée ne peut pas être nul"); - } - this.fluxEntree = fluxEntree; - this.octetCourant = 0; - this.positionBit = -1; // force la lecture d'un nouvel octet - this.finDeFlux = false; - } - - /** - * Lit un bit depuis le flux binaire. - * - * @return 0 ou 1 si un bit est lu, -1 si la fin du flux est atteinte - * @throws IOException si une erreur de lecture survient - */ - public int readBit() throws IOException { - if (finDeFlux) { - return -1; - } - - if (this.positionBit < 0) { - int octetLu = this.fluxEntree.read(); - if (octetLu == -1) { - this.finDeFlux = true; - } else { - this.octetCourant = octetLu; - this.positionBit = 7; - } - } - - if (finDeFlux) { - return -1; - } - - int bit = (this.octetCourant >> this.positionBit) & 1; - this.positionBit--; - return bit; - } - - /** - * Lit une séquence de bits consécutifs et les assemble dans un entier. - * - * @param nombreBits nombre de bits à lire (strictement positif) - * @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++) { - int bit = readBit(); - if (bit == -1) { - return -1; - } - res = (res << 1) | bit; - } - return res; - } - - /** - * Ferme le flux d'entrée sous-jacent. - * - * @throws IOException si une erreur survient lors de la fermeture - */ - public void closeFlux() throws IOException { - this.fluxEntree.close(); - } - - - -} +package fr.iutfbleau.sae.util; +import java.io.IOException; +import java.io.InputStream; + +/** + * Décorateur de flux permettant la lecture binaire à granularité du bit. + *+ * Cette classe encapsule un {@link InputStream} existant et fournit + * 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. + *
+ * + *+ * Utilisée notamment pour le décodage des fichiers compressés + * (ex : format PIF utilisant des codes de Huffman). + *
+ * + * + * + * @author Algassimou Pellel Diallo + * @version 1.0 + * @since 2025-12-13 + */ +public class BitInputStream { + + /** Flux d'entrée sous-jacent */ + private final InputStream fluxEntree; + + /** Octet actuellement chargé depuis le flux */ + private int octetCourant; + + /** Position du bit courant dans l'octet (du bit 7 au bit 0) */ + private int positionBit; + + /** Indique si la fin du flux a été atteinte */ + private boolean finDeFlux; + + /** + * Construit un lecteur binaire à partir d'un flux existant. + * + * @param fluxEntree flux d'entrée à décorer + * @throws IllegalArgumentException si le flux est nul + */ + public BitInputStream(InputStream fluxEntree) { + if (fluxEntree == null) { + throw new IllegalArgumentException("Le flux d'entrée ne peut pas être nul"); + } + this.fluxEntree = fluxEntree; + this.octetCourant = 0; + this.positionBit = -1; // force la lecture d'un nouvel octet + this.finDeFlux = false; + } + + /** + * Lit un bit depuis le flux binaire. + * + * @return 0 ou 1 si un bit est lu, -1 si la fin du flux est atteinte + * @throws IOException si une erreur de lecture survient + */ + public int readBit() throws IOException { + if (finDeFlux) { + return -1; + } + + if (this.positionBit < 0) { + int octetLu = this.fluxEntree.read(); + if (octetLu == -1) { + this.finDeFlux = true; + } else { + this.octetCourant = octetLu; + this.positionBit = 7; + } + } + + if (finDeFlux) { + return -1; + } + + int bit = (this.octetCourant >> this.positionBit) & 1; + this.positionBit--; + return bit; + } + + /** + * Lit une séquence de bits consécutifs et les assemble dans un entier. + * + * @param nombreBits nombre de bits à lire (strictement positif) + * @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++) { + int bit = readBit(); + if (bit == -1) { + return -1; + } + res = (res << 1) | bit; + } + return res; + } + + /** + * Ferme le flux d'entrée sous-jacent. + * + * @throws IOException si une erreur survient lors de la fermeture + */ + public void closeFlux() throws IOException { + this.fluxEntree.close(); + } + + + +} diff --git a/src/fr/iutfbleau/sae/util/ByteUtils.java b/src/fr/iutfbleau/sae/util/ByteUtils.java index 8f0f8e4..864363b 100644 --- a/src/fr/iutfbleau/sae/util/ByteUtils.java +++ b/src/fr/iutfbleau/sae/util/ByteUtils.java @@ -1,89 +1,89 @@ -package fr.iutfbleau.sae.util; - -/** - * Classe utilitaire regroupant des opérations de conversion entre - * entiers et octets. - *- * Elle est utilisée pour encoder et décoder les champs binaires - * du format PIF (largeur, hauteur, tailles, etc.). - *
- * - *- * Cette classe : - *
- * Cette classe est purement utilitaire et ne doit pas être instanciée. - *
- */ - private ByteUtils() { - // j'empêche l'instanciation - } - - /** - * Convertit un entier non négatif en deux octets (ordre big-endian). - *- * L'octet de poids fort est placé en première position, - * suivi de l'octet de poids faible. - *
- * - * @param value valeur entière à convertir (0 ≤ value ≤ 65535) - * @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) { - if (value < 0 || value > 0xFFFF) { - throw new IllegalArgumentException( - "La valeur doit être comprise entre 0 et 65535" - ); - } - - byte[] result = new byte[2]; - - /* - * Extraction de l'octet de poids fort : - * - décalage de 8 bits vers la droite - * - masquage pour ne conserver que les 8 bits utiles - */ - result[0] = (byte) ((value >>> 8) & 0xFF); - - /* - * Extraction de l'octet de poids faible : - * - aucun décalage nécessaire - * - masquage pour conserver les 8 bits de droite - */ - result[1] = (byte) (value & 0xFF); - - return result; - } - - /** - * Reconstruit un entier à partir de deux octets (ordre big-endian). - *- * L'octet de poids fort est replacé dans les bits 15 à 8, - * puis combiné avec l'octet de poids faible. - *
- * - * @param high octet de poids fort - * @param low octet de poids faible - * @return entier reconstruit à partir des deux octets - */ - public static int toInt(byte high, byte low) { - /* - * - masquage pour supprimer le signe des octets Java - * - décalage de l'octet fort vers la gauche - * - combinaison des deux octets par un OU binaire - */ - return ((high & 0xFF) << 8) | (low & 0xFF); - } -} +package fr.iutfbleau.sae.util; + +/** + * Classe utilitaire regroupant des opérations de conversion entre + * entiers et octets. + *+ * Elle est utilisée pour encoder et décoder les champs binaires + * du format PIF (largeur, hauteur, tailles, etc.). + *
+ * + *+ * Cette classe : + *
+ * Cette classe est purement utilitaire et ne doit pas être instanciée. + *
+ */ + private ByteUtils() { + // j'empêche l'instanciation + } + + /** + * Convertit un entier non négatif en deux octets (ordre big-endian). + *+ * L'octet de poids fort est placé en première position, + * suivi de l'octet de poids faible. + *
+ * + * @param value valeur entière à convertir (0 ≤ value ≤ 65535) + * @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) { + if (value < 0 || value > 0xFFFF) { + throw new IllegalArgumentException( + "La valeur doit être comprise entre 0 et 65535" + ); + } + + byte[] result = new byte[2]; + + /* + * Extraction de l'octet de poids fort : + * - décalage de 8 bits vers la droite + * - masquage pour ne conserver que les 8 bits utiles + */ + result[0] = (byte) ((value >>> 8) & 0xFF); + + /* + * Extraction de l'octet de poids faible : + * - aucun décalage nécessaire + * - masquage pour conserver les 8 bits de droite + */ + result[1] = (byte) (value & 0xFF); + + return result; + } + + /** + * Reconstruit un entier à partir de deux octets (ordre big-endian). + *+ * L'octet de poids fort est replacé dans les bits 15 à 8, + * puis combiné avec l'octet de poids faible. + *
+ * + * @param high octet de poids fort + * @param low octet de poids faible + * @return entier reconstruit à partir des deux octets + */ + public static int toInt(byte high, byte low) { + /* + * - masquage pour supprimer le signe des octets Java + * - décalage de l'octet fort vers la gauche + * - combinaison des deux octets par un OU binaire + */ + return ((high & 0xFF) << 8) | (low & 0xFF); + } +} diff --git a/src/fr/iutfbleau/sae/util/GestErreur.java b/src/fr/iutfbleau/sae/util/GestErreur.java index da4779a..be95dd0 100644 --- a/src/fr/iutfbleau/sae/util/GestErreur.java +++ b/src/fr/iutfbleau/sae/util/GestErreur.java @@ -1,8 +1,8 @@ -package fr.iutfbleau.sae.util; - -public class GestErreur { - public static void erreur(String message) { - System.err.println("Erreur : " + message); - System.exit(1); - } +package fr.iutfbleau.sae.util; + +public class GestErreur { + public static void erreur(String message) { + System.err.println("Erreur : " + message); + System.exit(1); + } } \ No newline at end of file diff --git a/src/fr/iutfbleau/sae/vconverter/CodeTablePanel.java b/src/fr/iutfbleau/sae/vconverter/CodeTablePanel.java index 340a228..836d949 100644 --- a/src/fr/iutfbleau/sae/vconverter/CodeTablePanel.java +++ b/src/fr/iutfbleau/sae/vconverter/CodeTablePanel.java @@ -1,110 +1,110 @@ -package fr.iutfbleau.sae.vconverter; - -import javax.swing.*; -import java.awt.*; -import java.util.Map; - -/** - * Panneau d'affichage des codes Huffman et canoniques. - * Affiche les codes pour chaque composante de couleur (rouge, vert, bleu). - * @author Algassimou - */ -public class CodeTablePanel extends JPanel { - - // Zones de texte pour les codes Huffman - private JTextArea textHuffRouge, textHuffVert, textHuffBleu; - - // Zones de texte pour les codes canoniques - private JTextArea textCanonRouge, textCanonVert, textCanonBleu; - - /** - * Constructeur qui initialise l'interface utilisateur. - */ - public CodeTablePanel() { - setLayout(new BoxLayout(this, BoxLayout.Y_AXIS)); - setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15)); - - // Titre pour les codes Huffman - JLabel titreHuff = new JLabel("Codes Huffman"); - titreHuff.setFont(new Font("SansSerif", Font.BOLD, 16)); - add(titreHuff); - add(Box.createVerticalStrut(10)); - - // Création des zones de texte pour les codes Huffman - textHuffRouge = creerZoneTexte("Rouge"); - textHuffVert = creerZoneTexte("Vert"); - textHuffBleu = creerZoneTexte("Bleu"); - - // Séparateur - add(Box.createVerticalStrut(20)); - - // Titre pour les codes canoniques - JLabel titreCanon = new JLabel("Codes Canoniques"); - titreCanon.setFont(new Font("SansSerif", Font.BOLD, 16)); - add(titreCanon); - add(Box.createVerticalStrut(10)); - - // Création des zones de texte pour les codes canoniques - textCanonRouge = creerZoneTexte("Rouge (Canonique)"); - textCanonVert = creerZoneTexte("Vert (Canonique)"); - textCanonBleu = creerZoneTexte("Bleu (Canonique)"); - } - - /** - * Crée une zone de texte avec une étiquette. - * @param titre Le titre à afficher au-dessus de la zone de texte - * @return La zone de texte configurée - */ - private JTextArea creerZoneTexte(String titre) { - add(new JLabel(titre + ":")); - JTextArea zone = new JTextArea(8, 30); - zone.setEditable(false); - zone.setFont(new Font("Monospaced", Font.PLAIN, 12)); - JScrollPane scroll = new JScrollPane(zone); - scroll.setPreferredSize(new Dimension(300, 120)); - add(scroll); - add(Box.createVerticalStrut(10)); - return zone; - } - - /** - * Met à jour l'affichage des codes Huffman. - * @param rouge Les codes pour la composante rouge - * @param vert Les codes pour la composante verte - * @param bleu Les codes pour la composante bleue - */ - public void updateCodes(Map- * Cette classe correspond à la vue principale de l’application. - * Elle centralise l’affichage des informations liées à la conversion - * d’une image (aperçu, fréquences, codes). - *
- * - * - *- * Elle sert de point d’entrée unique pour la partie graphique - *
- */ -public class ConverterWindow extends JFrame { - - private ImagePreviewPanel imagePreviewPanel; - private FrequencyTablePanel frequencyTablePanel; - private CodeTablePanel codeTablePanel; - - - - /** - * Crée la fenêtre principale du convertisseur. - * - *- * Le constructeur initialise la fenêtre et met en place - * les différents panneaux graphiques utilisés pour l’affichage. - *
- */ - - public ConverterWindow() { - // Configuration de la fenetre - this.setTitle("Convertisseur PIF - Visualisation des données"); - this.setSize(900, 600); - this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); - this.setLocationRelativeTo(null); // Centre la fenêtre - this.setResizable(true); // on autorise le - this.setLayout(new BorderLayout()); - - - - // Initialisation des panels - this.imagePreviewPanel = new ImagePreviewPanel(); - this.frequencyTablePanel = new FrequencyTablePanel(); - this.codeTablePanel = new CodeTablePanel(); - - // Je gere le panel principal - JPanel contentPanel = new JPanel(); - contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS)); - //contentPanel.setBackground(new Color(255, 0, 0)); // rouge vif pour demo - contentPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); - - // Titre - JLabel header = new JLabel(" Convertisseur PIF – Visualisation des données "); - header.setFont(new Font("SansSerif", Font.BOLD, 18)); - header.setAlignmentX(Component.CENTER_ALIGNMENT); - contentPanel.add(header); - - contentPanel.add(Box.createRigidArea(new Dimension(0, 5))); // espace - - // Ajout du panel d'aperçu - contentPanel.add(imagePreviewPanel); - contentPanel.add(Box.createRigidArea(new Dimension(0, 5))); - // Ajout du panel des fréquences - contentPanel.add(frequencyTablePanel); - contentPanel.add(Box.createRigidArea(new Dimension(0, 5))); - // Ajout panel des codes - contentPanel.add(codeTablePanel); - contentPanel.add(Box.createRigidArea(new Dimension(0, 5))); - // la section du scrollpane - JScrollPane scrollPane = new JScrollPane(contentPanel); - scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED); - scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER); - scrollPane.getVerticalScrollBar().setUnitIncrement(16); // scroll plus adouci fluide - - this.add(scrollPane, BorderLayout.CENTER); - this.setVisible(true); - } - - - - /** - * Met à jour l’image affichée dans la zone d’aperçu. - * - *- * Cette méthode est appelée lorsque l’image à convertir - * a été chargée. La fenêtre ne modifie pas l’image : - * elle la transmet simplement au panneau d’aperçu. - *
- * - * @param img image à afficher - */ - public void setImagePreview(BufferedImage img) { - imagePreviewPanel.setImage(img); - } - - /** - * Met à jour l’affichage des tables de fréquences. - */ - public void setFrequencyTable(int[] freqR,int[] freqG,int[] freqB) { - frequencyTablePanel.updateFrequencies(freqR,freqG,freqB); - } - - /** - * Met à jour l’affichage des codes Huffman. - * - *- * Elle permet uniquement d’afficher les codes - * qui ont été produits par la partie traitement. - *
- */ - public void setHuffmanTable(Map- * Les codes canoniques sont transmis au panneau - * chargé de leur affichage. - *
- */ - public void setCanonicalTable(Map+ * Cette classe correspond à la vue principale de l’application. + * Elle centralise l’affichage des informations liées à la conversion + * d’une image (aperçu, fréquences, codes). + *
+ * + * + *+ * Elle sert de point d’entrée unique pour la partie graphique + *
+ */ +public class ConverterWindow extends JFrame { + + private ImagePreviewPanel imagePreviewPanel; + private FrequencyTablePanel frequencyTablePanel; + private CodeTablePanel codeTablePanel; + + + + /** + * Crée la fenêtre principale du convertisseur. + * + *+ * Le constructeur initialise la fenêtre et met en place + * les différents panneaux graphiques utilisés pour l’affichage. + *
+ */ + + public ConverterWindow() { + // Configuration de la fenetre + this.setTitle("Convertisseur PIF - Visualisation des données"); + this.setSize(900, 600); + this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + this.setLocationRelativeTo(null); // Centre la fenêtre + this.setResizable(true); // on autorise le + this.setLayout(new BorderLayout()); + + + + // Initialisation des panels + this.imagePreviewPanel = new ImagePreviewPanel(); + this.frequencyTablePanel = new FrequencyTablePanel(); + this.codeTablePanel = new CodeTablePanel(); + + // Je gere le panel principal + JPanel contentPanel = new JPanel(); + contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS)); + //contentPanel.setBackground(new Color(255, 0, 0)); // rouge vif pour demo + contentPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); + + // Titre + JLabel header = new JLabel(" Convertisseur PIF – Visualisation des données "); + header.setFont(new Font("SansSerif", Font.BOLD, 18)); + header.setAlignmentX(Component.CENTER_ALIGNMENT); + contentPanel.add(header); + + contentPanel.add(Box.createRigidArea(new Dimension(0, 5))); // espace + + // Ajout du panel d'aperçu + contentPanel.add(imagePreviewPanel); + contentPanel.add(Box.createRigidArea(new Dimension(0, 5))); + // Ajout du panel des fréquences + contentPanel.add(frequencyTablePanel); + contentPanel.add(Box.createRigidArea(new Dimension(0, 5))); + // Ajout panel des codes + contentPanel.add(codeTablePanel); + contentPanel.add(Box.createRigidArea(new Dimension(0, 5))); + // la section du scrollpane + JScrollPane scrollPane = new JScrollPane(contentPanel); + scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED); + scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER); + scrollPane.getVerticalScrollBar().setUnitIncrement(16); // scroll plus adouci fluide + + this.add(scrollPane, BorderLayout.CENTER); + this.setVisible(true); + } + + + + /** + * Met à jour l’image affichée dans la zone d’aperçu. + * + *+ * Cette méthode est appelée lorsque l’image à convertir + * a été chargée. La fenêtre ne modifie pas l’image : + * elle la transmet simplement au panneau d’aperçu. + *
+ * + * @param img image à afficher + */ + public void setImagePreview(BufferedImage img) { + imagePreviewPanel.setImage(img); + } + + /** + * Met à jour l’affichage des tables de fréquences. + */ + public void setFrequencyTable(int[] freqR,int[] freqG,int[] freqB) { + frequencyTablePanel.updateFrequencies(freqR,freqG,freqB); + } + + /** + * Met à jour l’affichage des codes Huffman. + * + *+ * Elle permet uniquement d’afficher les codes + * qui ont été produits par la partie traitement. + *
+ */ + public void setHuffmanTable(Map+ * Les codes canoniques sont transmis au panneau + * chargé de leur affichage. + *
+ */ + public void setCanonicalTable(Map- * Ce panneau affiche un aperçu de l’image en cours de conversion. - *
- */ - - -public class ImagePreviewPanel extends JPanel { - - private BufferedImage image; - - // je donne une taille préférée au panel - public ImagePreviewPanel() { - this.setPreferredSize(new Dimension(600, 800)); - this.setMinimumSize(new Dimension(600, 800)); - } - - - public void setImage(BufferedImage img) { - this.image = img; - repaint(); - - } - - @Override - protected void paintComponent(Graphics pinceau) { - // Appel de la méthode parente pour effacer l'arrière-plan - super.paintComponent(pinceau); - - if (image == null) { - return; - } - - // Recuperer les dimensions du panel pour centrer l'image - int panelWidth = this.getWidth(); - int panelHeight = this.getHeight(); - - // Recuperer les dimensions de l'image - int imgWidth = image.getWidth(); - int imgHeight = image.getHeight(); - - // Je calcule le facteur du reduction (si l'image est trop grande) en gros le dezoom - double scale = Math.min( - (double) panelWidth / imgWidth, - (double) panelHeight / imgHeight - ); - - // Si l'image est plus petite que le panel, on ne la redimensionne pas donc scale = 1 - if (scale > 1.0) { - scale = 1.0; - } - - // je recalcule les dimensions de l'image à dessiner - int drawWidth = (int) (imgWidth * scale); - int drawHeight = (int) (imgHeight * scale); - - // Centrage de l'image dans le panel - int x = (panelWidth - drawWidth) / 2; - int y = (panelHeight - drawHeight) / 2; - - Graphics2D pinceau2D = (Graphics2D) pinceau; - pinceau2D.setRenderingHint( - RenderingHints.KEY_INTERPOLATION, - RenderingHints.VALUE_INTERPOLATION_BILINEAR - ); - - pinceau2D.drawImage(image, x, y, drawWidth, drawHeight, this); - } +package fr.iutfbleau.sae.vconverter; + +import java.awt.image.BufferedImage; +import javax.swing.JPanel; +import java.awt.*; + /** + * Le panneau d’aperçu de l’image. + * + *+ * Ce panneau affiche un aperçu de l’image en cours de conversion. + *
+ */ + + +public class ImagePreviewPanel extends JPanel { + + private BufferedImage image; + + // je donne une taille préférée au panel + public ImagePreviewPanel() { + this.setPreferredSize(new Dimension(600, 800)); + this.setMinimumSize(new Dimension(600, 800)); + } + + + public void setImage(BufferedImage img) { + this.image = img; + repaint(); + + } + + @Override + protected void paintComponent(Graphics pinceau) { + // Appel de la méthode parente pour effacer l'arrière-plan + super.paintComponent(pinceau); + + if (image == null) { + return; + } + + // Recuperer les dimensions du panel pour centrer l'image + int panelWidth = this.getWidth(); + int panelHeight = this.getHeight(); + + // Recuperer les dimensions de l'image + int imgWidth = image.getWidth(); + int imgHeight = image.getHeight(); + + // Je calcule le facteur du reduction (si l'image est trop grande) en gros le dezoom + double scale = Math.min( + (double) panelWidth / imgWidth, + (double) panelHeight / imgHeight + ); + + // Si l'image est plus petite que le panel, on ne la redimensionne pas donc scale = 1 + if (scale > 1.0) { + scale = 1.0; + } + + // je recalcule les dimensions de l'image à dessiner + int drawWidth = (int) (imgWidth * scale); + int drawHeight = (int) (imgHeight * scale); + + // Centrage de l'image dans le panel + int x = (panelWidth - drawWidth) / 2; + int y = (panelHeight - drawHeight) / 2; + + Graphics2D pinceau2D = (Graphics2D) pinceau; + pinceau2D.setRenderingHint( + RenderingHints.KEY_INTERPOLATION, + RenderingHints.VALUE_INTERPOLATION_BILINEAR + ); + + pinceau2D.drawImage(image, x, y, drawWidth, drawHeight, this); + } } \ No newline at end of file diff --git a/src/fr/iutfbleau/sae/vviewer/ImagePanel.java b/src/fr/iutfbleau/sae/vviewer/ImagePanel.java new file mode 100644 index 0000000..17f6cda --- /dev/null +++ b/src/fr/iutfbleau/sae/vviewer/ImagePanel.java @@ -0,0 +1,7 @@ +package fr.iutfbleau.sae.vviewer; + +public class ImagePanel extends JPanel{ + + + +} \ No newline at end of file diff --git a/src/fr/iutfbleau/sae/vviewer/ViewerWindow.java b/src/fr/iutfbleau/sae/vviewer/ViewerWindow.java new file mode 100644 index 0000000..9df89f0 --- /dev/null +++ b/src/fr/iutfbleau/sae/vviewer/ViewerWindow.java @@ -0,0 +1,11 @@ +package fr.iutfbleau.sae.vviewer; + +public class ViewerWindow extends JFrame{ + + + + + + + +} \ No newline at end of file diff --git a/temp/learning-Log.txt b/temp/learning-Log.txt index b85448d..ec1e78d 100644 --- a/temp/learning-Log.txt +++ b/temp/learning-Log.txt @@ -1,50 +1,50 @@ -Learning log – Problème de blocage de la fenêtre après la sauvegarde: - - Après avoir implémenté la fonctionnalité d’export au format PIF depuis l’interface du convertisseur, - j’ai rencontré un problème important : une fois que je cliquais sur le bouton d’exportation, - la fenêtre se figeait complètement. Elle restait visible, mais impossible à fermer ou à interagir avec. - Le programme semblait bloqué. - - En analysant le comportement et en utilisant des impressions de debug, j’ai constaté que le blocage n’était pas lié à l’écriture du - fichier ni à la logique du convertisseur, mais bien à un problème de gestion des threads dans Swing. - - Swing repose sur un fonctionnement particulier : toute l’interface graphique est gérée par un seul thread dédié, - appelé l’Event Dispatch Thread (EDT). Ce thread est responsable de tout ce qui concerne l’interface utilisateur : - la gestion des clics, le rafraîchissement de la fenêtre, la fermeture, le dessin et l’affichage en général. - Tant que ce thread tourne correctement, l’application reste réactive. - - L’EDT ne démarre réellement qu’après l’appel à la méthode permettant d’afficher la fenêtre. À partir de ce moment, - toutes les opérations qui modifient l’interface devraient strictement être exécutées sur ce thread. - C’est une règle fondamentale pour éviter les blocages. - - En examinant mon programme, je me suis rendu compte que le problème venait de la manière dont j’avais structuré mon point d’entrée. - Mon programme principal créait la fenêtre, le contrôleur, puis lançait immédiatement tout le processus de conversion, - qui incluait le chargement du fichier image, le calcul des fréquences, la construction des arbres de Huffman, - la génération des codes canoniques, et éventuellement l’écriture du fichier PIF. - Ce sont des opérations potentiellement longues et qui se déroulaient sur le thread principal, - avant même que l’EDT ne prenne le relais pour gérer l’interface. - - Cela avait pour conséquences que Swing se retrouvait dans un état instable, puisque certaines opérations graphiques avaient été réalisées - hors du thread dédié. - C’est exactement ce qui provoquait le gel de l’interface : une fois le fichier enregistré, la fenêtre ne répondait plus car - l’EDT était bloqué ou interrompu, empêchant toute interaction, y compris la fermeture de la fenêtre. - - Une fois le problème identifié, les solutions étaient claires. Il fallait s’assurer que toutes les opérations qui touchent - a l’interface graphique soient exécutées sur l’Event Dispatch Thread. Cela signifie que toute interaction, y compris l’ouverture - d’un sélecteur de fichiers, doit obligatoirement être déclenchée dans ce contexte. De plus, il fallait veiller à ne pas exécuter - de longues opérations synchrones avant le démarrage complet de l’EDT. - - La solution consiste donc à déléguer l’appel du processus de conversion au thread graphique, en utilisant le mécanisme fourni par - Swing pour garantir que le code s’exécute sur l’EDT. Une autre possibilité serait d’exécuter les opérations lourdes dans un thread en - arrière-plan pour éviter de bloquer l’interface, mais dans tous les cas le respect strict de la séparation entre traitements et interface - est essentiel. - - Grâce à cette analyse, j’ai mieux compris la manière dont Swing gère les threads et j’ai pu corriger la structure de mon programme - afin qu’il reste totalement réactif, même après l’export. Cette expérience m’a rappelé l’importance de maîtriser les principes fondamentaux - des bibliothèques graphiques et leurs contraintes en matière de multithreading. - - - - - +Learning log – Problème de blocage de la fenêtre après la sauvegarde: + + Après avoir implémenté la fonctionnalité d’export au format PIF depuis l’interface du convertisseur, + j’ai rencontré un problème important : une fois que je cliquais sur le bouton d’exportation, + la fenêtre se figeait complètement. Elle restait visible, mais impossible à fermer ou à interagir avec. + Le programme semblait bloqué. + + En analysant le comportement et en utilisant des impressions de debug, j’ai constaté que le blocage n’était pas lié à l’écriture du + fichier ni à la logique du convertisseur, mais bien à un problème de gestion des threads dans Swing. + + Swing repose sur un fonctionnement particulier : toute l’interface graphique est gérée par un seul thread dédié, + appelé l’Event Dispatch Thread (EDT). Ce thread est responsable de tout ce qui concerne l’interface utilisateur : + la gestion des clics, le rafraîchissement de la fenêtre, la fermeture, le dessin et l’affichage en général. + Tant que ce thread tourne correctement, l’application reste réactive. + + L’EDT ne démarre réellement qu’après l’appel à la méthode permettant d’afficher la fenêtre. À partir de ce moment, + toutes les opérations qui modifient l’interface devraient strictement être exécutées sur ce thread. + C’est une règle fondamentale pour éviter les blocages. + + En examinant mon programme, je me suis rendu compte que le problème venait de la manière dont j’avais structuré mon point d’entrée. + Mon programme principal créait la fenêtre, le contrôleur, puis lançait immédiatement tout le processus de conversion, + qui incluait le chargement du fichier image, le calcul des fréquences, la construction des arbres de Huffman, + la génération des codes canoniques, et éventuellement l’écriture du fichier PIF. + Ce sont des opérations potentiellement longues et qui se déroulaient sur le thread principal, + avant même que l’EDT ne prenne le relais pour gérer l’interface. + + Cela avait pour conséquences que Swing se retrouvait dans un état instable, puisque certaines opérations graphiques avaient été réalisées + hors du thread dédié. + C’est exactement ce qui provoquait le gel de l’interface : une fois le fichier enregistré, la fenêtre ne répondait plus car + l’EDT était bloqué ou interrompu, empêchant toute interaction, y compris la fermeture de la fenêtre. + + Une fois le problème identifié, les solutions étaient claires. Il fallait s’assurer que toutes les opérations qui touchent + a l’interface graphique soient exécutées sur l’Event Dispatch Thread. Cela signifie que toute interaction, y compris l’ouverture + d’un sélecteur de fichiers, doit obligatoirement être déclenchée dans ce contexte. De plus, il fallait veiller à ne pas exécuter + de longues opérations synchrones avant le démarrage complet de l’EDT. + + La solution consiste donc à déléguer l’appel du processus de conversion au thread graphique, en utilisant le mécanisme fourni par + Swing pour garantir que le code s’exécute sur l’EDT. Une autre possibilité serait d’exécuter les opérations lourdes dans un thread en + arrière-plan pour éviter de bloquer l’interface, mais dans tous les cas le respect strict de la séparation entre traitements et interface + est essentiel. + + Grâce à cette analyse, j’ai mieux compris la manière dont Swing gère les threads et j’ai pu corriger la structure de mon programme + afin qu’il reste totalement réactif, même après l’export. Cette expérience m’a rappelé l’importance de maîtriser les principes fondamentaux + des bibliothèques graphiques et leurs contraintes en matière de multithreading. + + + + + le proble aussi avec mon flush infini \ No newline at end of file diff --git a/temp/test.pif b/temp/test.pif new file mode 100644 index 0000000..49ed9a3 Binary files /dev/null and b/temp/test.pif differ