Dissimuler une image – Bac théorique – Section informatique – 2024
Sujet (Algo et programmation - Bac 2024)
On se propose de dissimuler une image Img2 dans une autre image Imgl de manière discrète en utilisant les étapes de dissimulation détaillées ci-après.
Les deux images sont représentées par deux matrices de même dimension L*C pixels. Un pixel est un enregistrement composé de trois champs R, V et B de type entier (code décimal entre 0 et 255) représentant respectivement les couleurs Rouge, Verte et Bleue.
Exemple : l'enregistrement (80,120,43) représente un pixel dont le champ R = 80, le champ V = 120 et le champ B = 43.
Etapes de dissimulation
- Pour chaque deux pixels de même position dans les images Imgl et Img2 :
2- Dissimulation : remplacer les 4 derniers bits (les plus à droite) de binl par les 4 premiers bits (les plus à gauche) du nombre binaire
3- Conversion décimale : convertir la valeur binaire résultat de l'étape "Dissimulation" en décimale qui devient alors la nouvelle valeur de la couleur rouge du pixel de l'image
- Refaire les trois étapes précédentes pour la couleur verte puis pour la couleur bleue.
Travail demandé :
1) Déclarer un type pour les matrices représentant les deux images Img1 et Img2 sachant que 2 < L < 400 et 2 < C < 500, ainsi que tous les types nécessaires à sa déclaration. 2) Ecrire un algorithme d'un module Resultat (Imgl , Img2 , L , C) permettant de dissimuler une image représentée par une matrice Img2 dans une image représentée par une matrice Imgl, en appliquant le principe décrit précédemment sachant que les deux matrices Img1 et Img2 ont le même nombre de lignes L et le même nombre de colonnes C.
3) Ecrire un algorithme d'un module nommé Image (Img1 , L , C , Ch) permettant de générer un fichier texte F contenant les représentations décimales des couleurs des pixels de l'image résultat Une ligne du fichier F correspond à une ligne de la matrice résultat et contient la concaténation des codes des couleurs des pixels structurés comme suit :
- les codes des couleurs d'un pixel sont séparés par un tiret "-".
- les pixels sont séparés par le caractère "#".
NB:
- Le paramètre Ch utilisé dans l'entête du module Image est une chaine de caractères contenant l'emplacement et le nom physique du fichier F.
- Le module demandé doit prendre en charge la création et la fermeture du fichier F.
Exemple :
Pour la matrice résultat Img1 précédente, la concaténation des pixels donne pour :
- la Cre ligne : 181-7-2#180-16-17
- la 2ème ligne : 167-16-112#153-60-91
Et ainsi le contenu du fichier F est :
Solution Algorithmique
Dans cet algorithme, On va utiliser quatre fonctions fonctions et quatre procédures
- la fonction saisie()
- la procédure remplir_img()
- la fonction decimal_vers_octet()
- la fonction octet_vers_decimal()
- la procédure afficher_img()
- la fonction dissimuler()
- la procédure resultat()
- la procédure remplir_fichier
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Algorithme coefficient_binomial Debut Ecrire('*** Saisir le nombre des lignes et des colonnes ***') l <- saisie(2, 400) c <- saisie(2, 500) Ecrire('*** remplir image1 ***') remplir_img(img1, l, c) Ecrire('*** remplir image2 ***') remplir_img(img2, l, c) # Dissimulation de l’image 2 dans l’image 1 resultat(img1, img2, l, c) Ecrire('*** Contenu de image1 apres dissimulation ***') afficher_img(img1, l, c) Ecrire('*** Contenu du fichier F.txt ***') remplir_fichier(img1, l, c) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| l | entier |
| c | entier |
| img1 | matrice |
| img2 | matrice |
La fonction saisie
Cette fonction permet de saisir et retourner un entier compris entre binf et bsup en contrôlant la validité de la saisie.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie(binf:entier,bsup:entier):entier # Demande à l'utilisateur de saisir un entier n dans l'intervalle [binf, bsup] Ecrire('donner un entier dans [',binf,' , ',bsup),'] : ') Lire(n) # Vérification de la validité de la saisie Tant que Non (binf <= n <= bsup) faire Ecrire('donner un entier dans [',binf,' , ',bsup,'] : ') Lire(n) Fin tant que # Retourne la valeur valide saisie par l'utilisateur retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir_img
Cette procédure permet de remplir une image de l lignes et c colonnes en saisissant, pour chaque pixel, les composantes rouge, verte et bleue.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
Procedure remplir_img(img:matrice, l:entier, c:entier) Pour i de 0 à l-1 faire Pour j de 0 à c-1 faire # Création d’un pixel vide pixel = Enregistrement( r=entier(), v=entier(), b=entier() ) # Saisie des composantes RVB du pixel pixel['r'] <- saisie(0, 255) pixel['v'] <- saisie(0, 255) pixel['b'] <- saisie(0, 255) # Affectation du pixel à la position (i,j) img[i][j] <- pixel Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| pixel | enregistrement |
La fonction decimal_vers_octet
Cette fonction transforme un entier décimal en un octet binaire (chaîne de 8 bits).
|
1 2 3 4 5 6 7 8 |
Fonction decimal_vers_octet(n:entier):chaine binaire <- "" Pour i de 0 à 7 faire # Ajout du reste de la division par 2 binaire <- Convch(n mod 2) + binaire n <- n div 2 retourner binaire Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| binaire | chaîne |
La fonction octet_vers_decimal
Cette fonction Fonction convertit un octet binaire (8 bits) en nombre décimal
|
1 2 3 4 5 6 7 8 9 |
Fonction octet_vers_decimal(binaire:chaine):entier decimal <- 0 puissance <- 7 # Poids du bit de gauche Pour i de 0 à len(binaire)-1 faire decimal <- decimal + Valeur(binaire[i]) * (2 ** puissance) puissance <- puissance - 1 Fin pour retourner decimal Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| decimal | entier |
| puissance | entier |
La procédure afficher_img
La procédure afficher_img affiche à l’écran tous les pixels de l’image sous forme de matrice
|
1 2 3 4 5 6 |
Procedure afficher_img(img:matrice, l:entier, c:entier) Pour i de 0 à l-1 faire Pour j de 0 à c-1 faire Ecrire(img[i][j], end=' ') Ecrire() Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La fonction dissimuler
Cette fonction réalise une dissimulation d’information entre deux valeurs décimales.
|
1 2 3 4 5 6 7 8 9 10 11 |
Fonction dissimuler(bin1:entier, bin2:entier):entier # Conversion des deux valeurs en binaire octet1 <- decimal_vers_octet(bin1) octet2 <- decimal_vers_octet(bin2) # Fusion des 4 bits de poids fort octet1 <- octet1[0:4] + octet2[0:4] # Retour du nouvel octet en décimal retourner octet_vers_decimal(octet1) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| octet1 | chaîne |
| octet2 | chaîne |
La procédure resultat
La procédure resultat dissimule entièrement l’image img2 à l’intérieur de l’image img1, composante par composante et pixel par pixel.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Procédure resultat(img1:matrice, img2:matrice, l:entier, c:entier) Pour de i de 0 à l-1 faire Pour de j de 0 à c-1 faire # Composante rouge img1[i][j]['r'] <- dissimuler(img1[i][j]['r'], img2[i][j]['r']) # Composante verte img1[i][j]['v'] <- dissimuler(img1[i][j]['v'], img2[i][j]['v']) # Composante bleue img1[i][j]['b'] <- dissimuler(img1[i][j]['b'], img2[i][j]['b']) Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La procédure remplir_fichier
La procédure remplir_fichier sauvegarde l’image finale (contenant l’image dissimulée) dans un fichier texte, en conservant la structure de l’image et les valeurs RGB de chaque pixel.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Procédure remplir_fichier(img1:matrice, l:entier, c:entier) # Ouverture du fichier en mode écriture Ouvrir(f , "F.txt", "w") Pour i de 0 à l-1 faire ligne <- '' Pour j de 0 à c-1 faire # Construction de la ligne pixel par pixel ligne <- ligne + Convch(img1[i][j]['r']) + '-' + Convch(img1[i][j]['v']) + '-' + Convch(img1[i][j]['b']) + '#' Fin pour # Écriture de la ligne sans le dernier séparateur Ecrire(f, Sous_chaine(ligne, 0 , long(ligne)-1) + '\n') Ecrire(Sous_chaine(ligne, 0 , long(ligne)-1)) Fin pour # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| ligne | chaîne |
Solution en Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales des images # -------------------------------------------------- lignes = 400 # Nombre maximal de lignes possibles colonnes = 500 # Nombre maximal de colonnes possibles # -------------------------------------------------- # Création de deux matrices représentant deux images # Chaque élément de la matrice est un pixel représenté # par un dictionnaire contenant les composantes r, v et b # -------------------------------------------------- img1 = array([[{}] * colonnes] * lignes) img2 = array([[{}] * colonnes] * lignes) # -------------------------------------------------- # Fonction de saisie sécurisée # Elle force l’utilisateur à saisir un entier # compris entre binf et bsup # -------------------------------------------------- def saisie(binf, bsup): # Première saisie n = int(input('donner un entier dans [' + str(binf) + ' , ' + str(bsup) + '] : ')) # Répéter la saisie tant que la valeur n'est pas valide while not (binf <= n <= bsup): n = int(input('donner un entier dans [' + str(binf) + ' , ' + str(bsup) + '] : ')) # Retourner la valeur valide return n # -------------------------------------------------- # Procédure de remplissage d’une image # Chaque pixel est un enregistrement contenant : # r : rouge, v : vert, b : bleu (entre 0 et 255) # -------------------------------------------------- def remplir_img(img, l, c): for i in range(l): for j in range(c): # Création d’un pixel vide pixel = dict( r=int(), v=int(), b=int() ) # Saisie des composantes RVB du pixel pixel['r'] = saisie(0, 255) pixel['v'] = saisie(0, 255) pixel['b'] = saisie(0, 255) # Affectation du pixel à la position (i,j) img[i][j] = pixel # -------------------------------------------------- # Fonction qui convertit un nombre décimal # en un octet binaire (chaîne de 8 bits) # -------------------------------------------------- def decimal_vers_octet(n): binaire = "" for i in range(8): # Ajout du reste de la division par 2 binaire = str(n % 2) + binaire n = n // 2 return binaire # -------------------------------------------------- # Fonction qui convertit un octet binaire (8 bits) # en nombre décimal # -------------------------------------------------- def octet_vers_decimal(binaire): decimal = 0 puissance = 7 # Poids du bit de gauche for i in range(len(binaire)): decimal = decimal + int(binaire[i]) * (2 ** puissance) puissance = puissance - 1 return decimal # -------------------------------------------------- # Procédure d’affichage d’une image # Affiche chaque pixel # -------------------------------------------------- def afficher_img(img, l, c): for i in range(l): for j in range(c): print(img[i][j], end=' ') print() # -------------------------------------------------- # Fonction de dissimulation (stéganographie) # Elle remplace les 4 bits de poids faible de bin1 # par les 4 bits de poids fort de bin2 # -------------------------------------------------- def dissimuler(bin1, bin2): # Conversion des deux valeurs en binaire octet1 = decimal_vers_octet(bin1) octet2 = decimal_vers_octet(bin2) # Fusion des 4 bits de poids fort octet1 = octet1[0:4] + octet2[0:4] # Retour du nouvel octet en décimal return octet_vers_decimal(octet1) # -------------------------------------------------- # Procédure principale de traitement # Elle dissimule l’image img2 dans img1 # pixel par pixel et composante par composante # -------------------------------------------------- def resultat(img1, img2, l, c): for i in range(l): for j in range(c): # Composante rouge img1[i][j]['r'] = dissimuler(img1[i][j]['r'], img2[i][j]['r']) # Composante verte img1[i][j]['v'] = dissimuler(img1[i][j]['v'], img2[i][j]['v']) # Composante bleue img1[i][j]['b'] = dissimuler(img1[i][j]['b'], img2[i][j]['b']) # -------------------------------------------------- # Procédure qui enregistre l’image résultante # dans un fichier texte "F.txt" # Chaque pixel est enregistré sous la forme r-v-b # -------------------------------------------------- def remplir_fichier(img1, l, c): # Ouverture du fichier en mode écriture f = open("F.txt", "w") for i in range(l): ligne = '' for j in range(c): # Construction de la ligne pixel par pixel ligne += str(img1[i][j]['r']) + '-' \ + str(img1[i][j]['v']) + '-' \ + str(img1[i][j]['b']) + '#' # Écriture de la ligne sans le dernier séparateur f.write(ligne[:-1] + '\n') print(ligne[:-1]) # Fermeture du fichier f.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- print('*** Saisir le nombre des lignes et des colonnes ***') l = saisie(2, 400) c = saisie(2, 500) print('*** remplir image1 ***') remplir_img(img1, l, c) print('*** remplir image2 ***') remplir_img(img2, l, c) # Dissimulation de l’image 2 dans l’image 1 resultat(img1, img2, l, c) print('*** Contenu de image1 apres dissimulation ***') afficher_img(img1, l, c) print('*** Contenu du fichier F.txt ***') remplir_fichier(img1, l, c) |
Exécution du programme
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
