Code de répétition

Ce TP permet de mettre en œuvre les bases de la syntaxe Java (boucles, conditions, tableaux) à travers deux applications : le code de répétition issu de la théorie de l'information et la binarisation d'images. Vous apprendrez à simuler la transmission d'un message binaire via un canal bruité, à coder et décoder ce message pour corriger les erreurs, ainsi qu'à binariser une image en niveaux de gris. Pour réaliser ce TP, un environnement Java avec accès à des images est nécessaire.

Objectifs

• Comprendre le principe du code de répétition pour la correction d'erreurs dans un canal bruité.
• Implémenter en Java les fonctions d'encodage, de bruitage, de décodage et d'évaluation de la qualité de transmission.
• Convertir une image en niveaux de gris puis la binariser.
• Simuler la transmission d'une image binaire via un canal bruité et observer l'effet du codage.

Prérequis et installation

• Connaissances de base en Java : boucles, conditions, tableaux.
• Environnement de développement Java configuré (JDK et IDE recommandés).
• Image d'exemple fournie ou toute autre image placée à la racine du projet.
• Bibliothèque Java pour la manipulation d'images (ex. java.awt.image).

Transmission au travers d’un canal bruité

Le but est de simuler la transmission d’un message binaire via un canal bruité, où chaque bit peut être inversé avec une certaine probabilité f. Le code de répétition R3 consiste à répéter chaque bit trois fois pour permettre la correction d’erreurs par vote majoritaire.

Par exemple, le message source :

s = 0 0 1 0 1 1 0

est encodé en :

t = 0 0 0 0 0 0 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0

À la réception, on considère chaque groupe de 3 bits et on applique un vote majoritaire pour retrouver le message original.

Travail à réaliser

Vous devez compléter un programme Java avec les méthodes suivantes :

1. Ajouter du bruit à une suite de bits

La méthode addNoise simule un canal bruité où chaque bit a une probabilité f d’être inversé.

int[] addNoise(int[] data, double f) {
    Random randomGenerator = new Random();
    int[] noisyData = new int[data.length];
    for (int i = 0; i < data.length; i++) {
        if (randomGenerator.nextFloat() < f) {
            noisyData[i] = 1 - data[i]; // inversion du bit
        } else {
            noisyData[i] = data[i];
        }
    }
    return noisyData;
}

Cette méthode renvoie un tableau binaire de même taille que data, avec certains bits inversés selon la probabilité f.

2. Encoder une image selon le code de répétition R3

La méthode encode répète chaque bit trois fois.

int[] encode(int[] data) {
    int[] encoded = new int[data.length * 3];
    for (int i = 0; i < data.length; i++) {
        encoded[3*i] = data[i];
        encoded[3*i + 1] = data[i];
        encoded[3*i + 2] = data[i];
    }
    return encoded;
}

3. Décoder une image encodée

La méthode decode applique un vote majoritaire sur chaque groupe de 3 bits pour reconstruire le message original.

int[] decode(int[] data) {
    int[] decoded = new int[data.length / 3];
    for (int i = 0; i < decoded.length; i++) {
        int sum = data[3*i] + data[3*i + 1] + data[3*i + 2];
        decoded[i] = (sum >= 2) ? 1 : 0; // vote majoritaire
    }
    return decoded;
}

4. Évaluer la qualité de la reconstruction

La méthode score calcule le pourcentage de bits différents entre l’image originale et l’image reconstruite.

float score(int[] imageOriginale, int[] imageFinale) {
    int erreurs = 0;
    for (int i = 0; i < imageOriginale.length; i++) {
        if (imageOriginale[i] != imageFinale[i]) {
            erreurs++;
        }
    }
    return (float) erreurs / imageOriginale.length * 100;
}

5. Modifier le programme principal

Le programme principal doit :

1. Charger une image (exemple fournie ou autre).
2. Convertir l’image en niveaux de gris puis la binariser (seuillage fixe à 120).
3. Convertir l’image binaire en tableau de 0 et 1.
4. Simuler la transmission via un canal bruité (méthode addNoise), sauvegarder dans noise.png.
5. Encoder l’image, la transmettre via le canal bruité, décoder, sauvegarder dans encoded.png.
6. Afficher la qualité de la transmission avec et sans codage.

Résultats attendus

• L’image binaire binary.png doit contenir uniquement des pixels noirs et blancs selon le seuil fixé.
• L’image noise.png montre l’effet du bruit sur l’image binaire, avec des pixels inversés aléatoirement selon la probabilité f.
• L’image encoded.png doit présenter une meilleure qualité que noise.png grâce au code de répétition et au décodage.
• Le score de qualité affiché doit être inférieur (meilleur) pour l’image encodée comparée à la transmission brute.

Pièges courants

• Ne pas initialiser correctement le générateur aléatoire Random dans addNoise, ce qui peut fausser la simulation du bruit.
• Oublier de répéter chaque bit exactement trois fois dans encode, ce qui empêche un décodage correct.
• Dans decode, ne pas appliquer le vote majoritaire correctement (par exemple, utiliser < 2 au lieu de >= 2).
• Ne pas convertir correctement l’image en binaire avant la transmission, ce qui fausse les données.
• Confondre les indices lors de la conversion image-tableau et vice versa.