dialloa/SAE32_2025
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

correction ayoub et controleur conv

Browse Source
This commit is contained in:
AlgaLaptop
2025-12-27 10:20:24 +01:00
parent fa80b2ce38
commit ca80d9b28b
17 changed files with 220 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/fr/iutfbleau/sae/mhuffman/CanonicalCode.java
+6 -6
View File
@@ -2,11 +2,11 @@ package fr.iutfbleau.sae.mhuffman;
import java.util.*;
public class CanonicalCode{
private Map<Integer,Integer> codeLengths = HuffmanTree.getDictionnary();
private Map<Integer,Integer> canonicalCodes = new HashMap<>();
private Map<Integer, Integer> codeLengths = new HashMap<>(); // Changer ici car la premiere version est incorecte
private Map<Integer, String> canonicalCodes = new HashMap<>();
public Map<Integer,Integer> generateCodes(){
public Map<Integer,String> generateCodes(){
// 1 ere chose à faire : on regarde uniquement la longueur des codes initiaux(Huffman)
// 2eme chose à faire : remettre dans l'ordre des longueurs : si meme taille ==> regarder valeur
// 3eme chose à faire : ecriture des codes canoniques :
@@ -37,16 +37,16 @@ public class CanonicalCode{
}
public int getCode(){
public int getCode(int value){
return 0;
}
public int getLength(){
public int getLength(int value){
return 0;
}
public Map<Integer,Integer> getCanonicalCodes(){
public Map<Integer,String> getCanonicalCodes(){
return this.canonicalCodes;
}
}
src/fr/iutfbleau/sae/mhuffman/FrequencyTable.java
+7 -5
View File
@@ -1,4 +1,5 @@
package fr.iutfbleau.sae.mhuffman;
import fr.iutfbleau.sae.mimage.RGBImage;
/**
* Représente une table de fréquences pour une image RGB.
@@ -72,11 +73,12 @@ public class FrequencyTable {
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
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
}
}
}
src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java
+78 -60
View File
@@ -57,7 +57,9 @@ public class HuffmanTree {
/**
* Dictionnaire pour enregistrer les codes Huffman
*/
private static Map<Integer,Integer> codes;
// 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<Integer, String> codes;
/**
* Chaine de caracteres qui va nous permettre de sauvegader le code Huffman
@@ -85,12 +87,7 @@ public class HuffmanTree {
// J'initialise la racine à null.
this.root = null;
// je cree une collection de feuilles
/////////////////////////////////// Voir si ya moyen doptimiser //////////////////////////////////////
// tu pourrait utiliser une PriorityQueue pour placer selon les fréquences comme dit dans l'énoncé !!!!
// je cree une collection de feuilles
List<HuffmanNode> feuilles = new ArrayList<>();
// pour chaque valeur(symbole) dans la table de frequence
@@ -132,26 +129,13 @@ public class HuffmanTree {
// a la fin il ne reste qu'un seul noeud : la racine de l'arbre
this.root = feuilles.get(0);
}
/**
* Retourne la racine de l'arbre de Huffman.
* <p>
* Cette méthode permet d'accéder à la structure complète de l'arbre,
* notamment lors de la génération des codes ou du décodage des données.
* </p>
*
* @return le nœud racine de l'arbre de Huffman
*/
public HuffmanNode getRoot() {
return root;
}
/**
// Méthode pour générer les codes Huffman à partir de l'arbre
// pourquoi string et pas int ? car on va construire une chaine de 0 et de 1
/**
* @return Map on stockera les codes Huffman sous forme de dictionnaire
*/
public Map<Integer,Integer> generateCodes(){
*/
public Map<Integer,String> generateCodes() {
/**
* Le but de cette méthode est de pouvoir generer les codes Huffman à partir de l'arbre :
* Les branches prendront comme valeur 1 ou 0 selon differents cas :
@@ -159,42 +143,76 @@ public class HuffmanTree {
* 0 - si on saute vers un fils gauche.
* On construit les codes qui partent de la racine jusqu'à notre objectif
*/
this.codes = new HashMap<>();
this.chaineCarac = new String();
if(root.isLeaf()){
codes.put(root.getValue(),Integer.parseInt(chaineCarac));
return codes;
}
HuffmanNode temp = root;
if (root.getLeft() != null) {
root = root.getLeft();
chaineCarac = chaineCarac + "0";
generateCodes();
// on retire le dernier bit lorsqu'on remonte car sinon les codes seront faussés
chaineCarac = chaineCarac.substring(0, chaineCarac.length() - 1);
}
if (temp.getRight() != null) {
root = temp.getRight();
chaineCarac = chaineCarac + "1";
generateCodes();
chaineCarac = chaineCarac.substring(0, chaineCarac.length() - 1);
}
root = temp;
return codes;
}
public static Map<Integer,Integer> getDictionnary(){
this.codes = new HashMap<>();
// je lance la methode recursive avec une chaine vide qui va se remplir au fur et à mesure
generateCodesRec(this.root, "");
return codes;
}
private void generateCodesRec(HuffmanNode node, String prefiixe) {
// Cas de base: si le noeud est une feuille, on ajoute le code au dictionnaire
if (node.isLeaf()) {
if (prefiixe.length() > 0){
this.codes.put(node.getValue(), prefiixe);
}else{
this.codes.put(node.getValue(), "0");
}
return;
}
//Case general : sinon on continue a parcourir l'arbre
// On va a gauche en ajoutant "0" au code
generateCodesRec(node.getLeft(), prefiixe + "0");
// On va a droite en ajoutant "1" au code
generateCodesRec(node.getRight(), prefiixe + "1");
// this.codes = new HashMap<>();
// this.chaineCarac = new String();
// if(root.isLeaf()){
// codes.put(root.getValue(),Integer.parseInt(chaineCarac));
// return codes;
// }
// HuffmanNode temp = root;
// if (root.getLeft() != null) {
// root = root.getLeft();
// chaineCarac = chaineCarac + "0";
// generateCodes();
// // on retire le dernier bit lorsqu'on remonte car sinon les codes seront faussés
// chaineCarac = chaineCarac.substring(0, chaineCarac.length() - 1);
// }
// if (temp.getRight() != null) {
// root = temp.getRight();
// chaineCarac = chaineCarac + "1";
// generateCodes();
// chaineCarac = chaineCarac.substring(0, chaineCarac.length() - 1);
// }
// root = temp;
// return codes;
}
/**
* @return Dictionnaire des codes Huffman
*/
public Map<Integer,String> getCodes(){
return codes;
}
/**
* @return le nœud racine de l'arbre de Huffman
*/
public HuffmanNode getRoot() {
return root;
}
}