compilation plantuml
This commit is contained in:
AlgaLaptop
+2
-7
@@ -20,8 +20,8 @@ Objectif : Mise en place des fondations techniques
|
||||
|----------|---------|--------|-----|-------------|
|
||||
| US-D1 | AD | TODO | 🟩 | Implémenter BitInputStream (lecture bit par bit) |
|
||||
| US-D2 | AD | TODO | 🟩 | Implémenter BitOutputStream (écriture bit par bit) |
|
||||
| US-D3 | AD | TODO | 🟥 | Générer les tables de fréquences RGB |
|
||||
| US-D4 | AD | TODO | 🟥 | Construire l’arbre Huffman |
|
||||
| US-D3 | AD | TODO | 🟨 | Générer les tables de fréquences RGB |
|
||||
| US-D4 | AD | TODO | 🟨 | Construire l’arbre Huffman |
|
||||
| US-D5 | AA | TODO | 🟥 | Générer les codes Huffman |
|
||||
| US-D6 | AA | TODO | 🟥 | Générer les codes canoniques |
|
||||
| US-U5 | YB | TODO | 🟥 | Chargement d’image via ImageIO |
|
||||
@@ -104,11 +104,6 @@ Objectif : Écriture du format `.pif` + finalisation convertisseur
|
||||
|----------------|-------|----|
|
||||
| `SavePanel.java` *(optionnel)* | Interface de sauvegarde `.pif` | US-U6 |
|
||||
|
||||
### `src/`
|
||||
| Nom du fichier | Rôle | US |
|
||||
|----------------|-------|----|
|
||||
| *(aucun nouveau fichier obligatoire)* | — | — |
|
||||
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -113,6 +113,20 @@ Le projet doit inclure :
|
||||
|
||||
---
|
||||
|
||||
## Classes Java
|
||||
|
||||
Les classes Java utilisées dans le projet :
|
||||
|
||||
- [BitinputStream](src/fr/iutfbleau/sae/util/BitinputStream.java)
|
||||
- [BitOutputStream](src/fr/iutfbleau/sae/util/BitOutputStream.java)
|
||||
- [ByteUtils](src/fr/iutfbleau/sae/util/ByteUtils.java)
|
||||
- [CanonicalCode](src/fr/iutfbleau/sae/mhuffman/CanonicalCode.java)
|
||||
- [FrequencyTable](src/fr/iutfbleau/sae/mhuffman/FrequencyTable.java)
|
||||
- [HuffmanNode](src/fr/iutfbleau/sae/mhuffman/HuffmanNode.java)
|
||||
- [HuffmanTree](src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java)
|
||||
|
||||
---
|
||||
|
||||
## Rapport à produire
|
||||
|
||||
Un rapport PDF doit contenir :
|
||||
|
||||
@@ -83,33 +83,39 @@ CanonicalCode ..> HuffmanTree : dérive
|
||||
package util {
|
||||
|
||||
class BitInputStream #aliceblue {
|
||||
- in
|
||||
- currentByte : int
|
||||
- bitPosition : int
|
||||
+ BitInputStream(in)
|
||||
+ readBit()
|
||||
+ readBits(n)
|
||||
+ close()
|
||||
- fluxEntree
|
||||
- octetCourant : int
|
||||
- positionBit : int
|
||||
- finDeFlux : boolean
|
||||
|
||||
+ BitInputStream(fluxEntree)
|
||||
+ readBit() : int
|
||||
+ readBits(nombreBits) : int
|
||||
+ closeFlux()
|
||||
}
|
||||
|
||||
class BitOutputStream #aliceblue {
|
||||
- out
|
||||
- currentByte : int
|
||||
- bitCount : int
|
||||
+ BitOutputStream(out)
|
||||
- fluxSortie
|
||||
- octetEnConstruction : int
|
||||
- positionBit : int
|
||||
- fluxFerme : boolean
|
||||
|
||||
+ BitOutputStream(fluxSortie)
|
||||
+ writeBit(bit)
|
||||
+ writeBits(value, n)
|
||||
+ writeBits(valeur, nombreBits)
|
||||
+ flush()
|
||||
+ close()
|
||||
+ fermerFlux()
|
||||
}
|
||||
|
||||
class ByteUtils #aliceblue {
|
||||
+ toInt(high, low)
|
||||
+ toBytes(value)
|
||||
<<utilitaire>>
|
||||
+ toInt(high, low) : int
|
||||
+ toBytes(value) : byte[]
|
||||
}
|
||||
|
||||
class FileUtils #aliceblue {
|
||||
+ isPIFFile(f)
|
||||
<<utilitaire>>
|
||||
+ isPIFFile(f) : boolean
|
||||
+ readBinaryFile(path)
|
||||
}
|
||||
|
||||
|
||||
@@ -1,31 +1,113 @@
|
||||
import java.awt.image.BufferedImage;
|
||||
package fr.iutfbleau.sae.mhuffman;
|
||||
|
||||
/**
|
||||
* 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() {
|
||||
// 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];
|
||||
this.freqR = new int[256];
|
||||
this.freqG = new int[256];
|
||||
this.freqB = new int[256];
|
||||
}
|
||||
|
||||
|
||||
public void computeFromImage(BufferedImage image){
|
||||
|
||||
/**
|
||||
* 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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -15,6 +15,12 @@ import java.io.InputStream;
|
||||
* 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 {
|
||||
|
||||
@@ -96,8 +102,6 @@ public class BitInputStream {
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Ferme le flux d'entrée sous-jacent.
|
||||
*
|
||||
|
||||
@@ -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) {
|
||||
|
||||
Reference in New Issue
Block a user