TD Info

1 TD Traitement d’image PSI

On commence par charger les environnements utiles

import numpy as np
from math import *
import matplotlib.image as img
import matplotlib. pyplot as plt

On travaillera sur l’une des images fournies sur le site de votre enseignant de mathématiques.
Télécharger l’image choisie sur votre répertoire. Ensuite, on l’ouvre dans le logiciel Python avec la commande
photo=img.imread('chemin/nom_image.png')

ou selon les systèmes d’exploitation :

photo=img.imread('chemin\ nom_image.png')

Cette commande permet d’enregistrer dans photo un tableau de nombres phot o [i ][ j ][k ] de taille n × p × 3 où n
est le nombre de pixels par ligne, p le nombre de pixel par colonne.
phot o [i ][ j ][k ] est un nombre compris entre 0 et 1 qui indique le pourcentage de couleur rouge si k = 0, de cou-
leur verte si k = 1, et de couleur bleue si k = 2.
Si l’image est en niveau de gris, toutes les composantes k auront la même valeur indiquant le niveau de gris.

Exercice 1. composantes couleurs

Écrire un programme qui charge une image et l’enregistre dans un tableau de nombre à 3 dimensions, crée trois
tableau contenant chacun une des trois composantes de couleur de l’image (rouge, vert et bleu).
Afficher l’image de départ et les trois images selon les trois composantes de couleur.
On affichera les quatre images dans la même figure avec la commande
plt .subplot(n,p,k)

qui crée n ∗ p images réparties selon n lignes et p colonnes et qui sélectionne la k-ième image parmi ces np
images. Pour afficher une image, on utilise la commande :
plt .imshow(image)

où "image" est le tableau de trois dimensions contenant les données.

Exercice 2. négatif
Écrire un programme permettant d’obtenir le négatif de la photo de départ, et de l’afficher dans une même figure
que la photo de départ. Pour effectuer cette opération, il suffit d’inverser le niveau de chaque couleur et donc de
transformer la valeur x de chaque couleur de chaque pixel en 1 − x.
Attention, pour chaque transformation que l’on effectue, il faut s’assurer que la valeur obtenue reste dans [0; 1].

Exercice 3. noir et blanc

On cherche à obtenir l’image en noir et blanc à partir d’une image couleur. Pour cela, l’idée la plus simple est
de prendre comme niveau de gris pour chaque pixel, la moyenne des niveaux de chacune des trois composantes
rouge verte et bleue.
Écrire un programme qui permet d’obtenir la matrice des niveaux de gris pour chaque pixel, et afficher l’image
obtenue. Pour afficher une photo noir et blanc à partir d’une matrice "image" de niveau de gris (tableau à 2 di-
mensions de nombres compris entre 0 et 1), on utilise la fonction :
plt .imshow(image,plt.cm.gray)

En fait chaque couleur rouge, verte et bleue n’ayant pas la même luminosité, plutôt qu’une moyenne des trois
composantes, il est préférable de calculer une moyenne pondérée des trois composantes selon la formule : 0, 2126×
Roug e + 0, 7152 × V er t + 0, 0722 × Bl eu.
Écrire un programme qui permet d’afficher sur une même figure l’image de départ, l’image noir et blanc obtenue
par une moyenne simple et l’image obtenue par moyenne pondérée selon la dernière formule.

Exercice 4. contraste
À partir d’une image noir et blanc, on souhaite augmenter le contraste. Pour obtenir plus de contraste, une idée
TD Info
1 TD Traitement d’image PSI

simple est d’étirer la valeur des niveaux de gris dans le domaine de valeurs où l’on souhaite obtenir plus de
contraste. Pour cela, pour chaque pixel de l’image, on remplace chaque valeur x de niveau de gris par son image
par une fonction f de [0; 1] dans [0; 1] qui a une pente plus importante dans les valeurs de x que l’on veut plus
contraster.

Par exemple, on peut simplement considérer la fonction f ∶ [0; 1] → [0; 1]

RR 0 si x < 14
RRR
x ↦ RRRR 2x − 21 si 14 ⩽ x ⩽ 3
RRR 4
RR 1 si x > 34
Une autre idée est d’utiliser la fonction : x ↦ 12 + 21 sin (π (x − 12 )).
Tester ces deux idées.

Exercice 5. Floutage
À partir d’une image noir et blanc, ou couleur, on veut créer un floutage sur tout ou une partie d’une photo. Pour
cela, une idée simple est de remplacer chaque composante couleur de chaque pixel par la moyenne de cette com-
posante sur tous les pixels voisins ou proche à une certaine distance.
Pour simplifier, on calcule la moyenne de chaque composante sur des carrés de côté 2a + 1 sur les pixels qui ont
un indice de ligne et un indice de colonne distant d’au plus a de l’indice du pixel courant.
Programmer une fonction floutage sur une partie centrale de la photo et afficher le résultat pour différentes va-
leurs de a.
Programmer une fonction floutage sur toute la photo en tenant compte de la particularité des bords de photo, et
afficher le résultat.

Exercice 6. Détection de contour

⎛ 0 −1 0 ⎞
À partir d’un filtre différentiel de type A = ⎜ −1 0 1 ⎟ on détecte les contours sur une photo en noir et blanc.
⎝ 0 1 0 ⎠
Pour cela, on applique ce filtre au calcul et tous les pixels de la photo en évitant les problèmes de bord. On obtien-
dra ainsi une photo éventuellement plus petite.
Chaque nouvelle valeur du pixel est alors soit un nombre réel entre -2 et 2 soit un nombre entier entre -510 et 510
selon le format de la photo.
Il faut bien évidemment remettre ce format au format d’une image en tenant compte de ce qui nous intéresse ici :
la détection de contour.
On dira alors qu’il y a un contours si la valeur du calcul donne un nombre de valeur absolu supérieure à un seuil
que l’on fixera en paramètre dans la fonction contour :
● Si la valeur absolue du calcul est supérieure à ce seuil, on mettre le pixel à la couleur noire (i.e. valeur nulle) ;
● Si la valeur absolue du calcul est inférieure à ce seuil, on mettre le pixel à la couleur blanche (i.e. valeur 1
ou 255 selon le format de l’image) ;
Adapter le seuil pour obtenir au mieux les contours de la photo.
Faire des tests avec plusieurs filtres de différentes tailles.

Exercice 7. Image cachée

Dans la photo "sirenedansgaronne" il a été caché une image ou photo selon le procédé suivant : Cette photo est
un tableau numpy de dimension n × p × 3 telle que le coefficient i , j , k est un nombre entier compris entre 0 et 255
représentant selon l’entier k l’intensité une des trois couleurs rouge verte ou bleue du pixel de la i -ième ligne et
j -ième colonne de la photo.
Ce nombre entier est donc un octet dont
— les 4 premiers bits sont les quatre premiers bits du nombre correspondant de la photo originale
— les 4 derniers bits sont les quatre premiers bits du nombre correspondant de la photo cachée
Retrouver la photo cachée.
À partir de deux photos en noir et blanc, cacher la plus petite des deux photos dans la seconde selon ce même
principe.
TD Info
1 TD Traitement d’image PSI

Exercice 1. composantes couleurs

import numpy as np
from math import *
import matplotlib.image as img
import matplotlib. pyplot as plt

photo=img.imread('/Users/fzwolska/.../lena.png') #charge l'image (faire attention à mettre le bon chemin)

photo=photo [:,:, 0:3] #on limite au trois premiers octets de chaque pixels
#cela permet de ne pas tenir compte de l'eventuel quatrieme octet de transparence
n=len(photo) #nombre de lignes de pixels
p=len(photo[0]) #nombre de colonnes de pixels
q=len(photo[0][0]) #normalement égal à 3 pour R,V, B

# Extraction de chaque dans la photo

photo_rouge=np.zeros((n,p,q)) #on initialise les tableaux d'images
photo_verte=np.zeros((n,p,q))
photo_bleue=np.zeros((n,p,q))
photo_rouge [:,:, 0]=photo [:,:, 0] #on ne retient que la portion rouge de l ' image
photo_verte [:,:, 1]=photo [:,:, 1] #on ne retient que la portion verte de l ' image
photo_bleue [:,:, 2]=photo [:,:, 2] #on ne retient que la portion bleue de l ' image
plt .subplot(2,2,1)
plt .imshow(photo)
plt .subplot(2,2,2)
plt .imshow(photo_rouge)
plt .subplot(2,2,3)
plt .imshow(photo_verte)
plt .subplot(2,2,4)
plt .imshow(photo_bleue)
plt .show()

Ce programme permet d’afficher les images suivantes :

0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800
0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800

Exercice 2. négatif
TD Info
1 TD Traitement d’image PSI

Ici on n’a plus besoin de charger à nouveau la photo, on suppose qu’elle a été chargée dans un tableau à trois
dimensions photo et on va définir
● une fonction négatif qui prend en entrée une valeur entre 0 et 1 et retourne une valeur entre 0 et 1. Cela
permet de modifier la valeur x d’une couleur d’un pixel en 1 − x.
● une fonction traitement qui prend en entrée un tableau de nombre à 3 dimensions représentant une photo
et trois fonctions f, g et h. Cette fonction parcourt chaque pixel de l’image par deux boucles sur les lignes
et les colonnes, et applique la fonction f à la valeur rouge du pixel, g à la valeur vert du pixel et h à la valeur
bleue du pixel. Cette fonction retourne un tableau de nombre représentant une photo avec les modifica-
tions demandées par les trois fonctions.
● Pour obtenir le négatif d’une photo et l’affichée il ne reste plus qu’à appeler cette fonction traitement avec
les 3 fonctions négatifs sur la photo de départ et d’afficher la photo originale et le négatif avec la fonction
subplot
def negatif (k ):
return 1−k

def traitement (image,f,g,h):

n=len(image)
p=len(image[0])
image2=np.zeros((n,p,3))
for i in range(n):
for j in range(p):
image2[i][ j ][ 0]=f (image[i ][ j ][ 0])
image2[i][ j ][ 1]=g(image[i][ j ][ 1])
image2[i][ j ][ 2]=h(image[i][ j ][ 2])

return image2

photo2=traitement(photo,negatif, negatif , negatif )

plt .subplot(1,2,1)
plt .imshow(photo)
plt .subplot(1,2,2)
plt .imshow(photo2)
plt .show()

Ce programme permet d’afficher les images suivantes :

0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800

Exercice 3. noir et blanc

On considère toujours ici la photo de départ déjà enregistrée dans le tableau de nombres photo Pour obtenir une
image en noir et blanc par moyenne simple, on parcourt tous les pixels par une double boucle sur les lignes et les
TD Info
1 TD Traitement d’image PSI

colonnes, on fait la moyenne des pixels et on a alors deux solutions :

● soit on l’enregistre dans un tableau à deux dimension contenant ce niveau de gris de chaque pixel et on
affiche la photo en spécifiant bien que c’est une photo noir et blanc,
● soit on place ce même niveau de gris dans chaque composante couleur d’un tableau à trois dimensions
représentant une photo couleur. En effet, si les trois composantes couleurs d’un pixel ont les même valeur
cela revient à avoir une couleur correspondante dans la gamme des gris.
for i in range(n):
for j in range(p):
if q>0: #teste si on a une photo couleur
photo_bw[i][ j ]=photo[i ][ j ][ 0]
for k in range(1,q):
photo_bw[i][ j ]+=photo[i ][ j ][ k]
photo_bw[i][ j ]=photo_bw[i][ j ]/ 3 # pour la moyenne simple
photo_bw2[i][j]=0.2126*photo[i][ j ][ 0]+0.7152*photo[i][ j ][ 1]+0.0722*photo[i][ j ][ 2]
#pour la photo avec moyenne ponderee
else: # si la photo de départ est noir et blanc, on ne fait rien
photo_bw[i][ j ]+=photo[i ][ j ]
plt .subplot(2,2,1)
plt .imshow(photo) #affiche l ' image de départ
plt .subplot(2,2,3)
plt .imshow(photo_bw,plt.cm.gray) #affiche l'image par moyenne simple
plt .subplot(2,2,4)
plt .imshow(photo_bw2,plt.cm.gray) #affiche l'image par moyenne ponderee

Ce programme permet d’afficher les images suivantes :

0
100
200
300
400
500
600
0 100200300400500600700800
0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800

Exercice 4. contraste
On part ici de la photo lena_gray que l’on charge en noir et blanc dans un tableau à deux dimensions. et on définit
● Une fonction contraste qui à partir d’un nombre entre 0 et 1 retourne un nombre entre 0 et 1. Cela permet
de modifier la valeur du niveau de gris d’un pixel à partir de la fonction affine par morceaux que l’on a
définie dans l’énoncé.
● Une fonction traitement_nb qui prend en entrée un tableau de nombre à deux dimensions, et une fonction
f. On parcourt via une double boucle tous les pixels et on applique la fonction f à la valeur de niveau de gris
de chaque pixel et on enregistre la nouvelle valeur dans un nouveau tableau à deux dimension que l’on
renvoie en fin de fonction.
● on définit une fonction contraste2 avec la fonction sinus comme demandé ;
● Il ne reste plus qu’à appeler cette fonction traitement_nb avec comme paramètre la photo enregistrée
et la fonction contraste et une seconde fois avec comme paramètre la photo enregistrée et la fonction
TD Info
1 TD Traitement d’image PSI

contraste2 et afficher la photo de départ et celles obtenues dans les deux cas.
Par exemple, on peut faire le programme suivant :
import numpy as np
from math import *
import matplotlib.image as img
import matplotlib. pyplot as plt
photo=img.imread('/Users/fzwolska/.../lena_gray.png') #charge l'image

def contraste(k ): # contraste par fonction affine par morceaux

if 1/4<k<3/4:
x=2*k−1/2
elif k<=1/4:
x=0
else:
x=1
return x

def contraste3(k ):
return (1/2+sin(pi *(k−1/2))/2)

def traitement_nb(image,f): # application d'une fonction de traitement à une photo N&B

n=len(image)
p=len(image[0])
image2=np.zeros((n,p))
for i in range(n):
for j in range(p):
image2[i][ j ]= f (image[i ][ j ])
return image2

plt .subplot(2,2,1)
plt .imshow(photo,plt.cm.gray) # on affiche la photo de départ
photo2=traitement_nb(photo,contraste)
plt .subplot(2,2,3)
plt .imshow(photo2,plt.cm.gray)
photo2=traitement_nb(photo,contraste2)
plt .subplot(2,2,4)
plt .imshow(photo2,plt.cm.gray)
plt .show()

Ce programme permet d’afficher les images suivantes :

0
100
200
300
400
500
600
0 100200300400500600700800
0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800
TD Info
1 TD Traitement d’image PSI

Exercice 5. Floutage
Si la photo de départ a n × p pixels, pour créer du floutage sur toute la photo, on parcourt tous les pixels de la photo
avec une double boucle, et en chaque pixel (i , j ) on fait la moyenne pour chaque composante couleur de toutes
les valeurs des pixels situés entre les lignes i − k et i + k et entre les colonnes j − k et j + k, en ne gardant bien sûr
que les valeurs de lignes entres 0 et n − 1 et de colonnes entre 0 et p − 1. Un programme tenant compte ainsi des
bords est donné ci-après.
Par contre, la valeur de k étant souvent petite devant la taille de la photo, on pourrait s’abstenir de tenir compte
de ces effets de bords en ne calculant les valeurs moyennes des composantes couleurs que pour les pixels de la
photo situés entre les lignes k et n − 1 − k et entre les colonnes k et p − 1 − k, et laisser en noir (valeur 0) les pixels
de la bande entourant la photo. Le bord n’étant en général pas le plus important dans la photo.
import numpy as np
from math import *
import matplotlib.image as img
import matplotlib. pyplot as plt
photo=img.imread('/Users/fzwolska/Documents/enseignement/classes/PSI/Informatique/traitement_image/lena.png') #charge l'image

n=len(photo)
p=len(photo[0])
q=len(photo[0][0])

def floutage (image,k): #p tel que le floutage se fait sur un carre

# allant de k pixels avant celui ou on est a k pixels apres.
n=len(image)
p=len(image[0])
image2=np.zeros((n,p,3))
for i in range(n):
for j in range(p):
if i −k<0: #on définit les bords du carré de taille 2k+1
a=0 #en tenant compte des dépassements éventuels du cadre de la photo
else:
a=i−k
if j −k<0:
c=0
else:
c=j−k
if i +k<n:
b=i+k
else:
b=n−1
if j +k<p:
d=j+k
else:
d=p−1
for t in range(a,b+1):
for u in range(c,d+1):
image2[i][ j ][:]= image2[i][ j ][:]+ image[t ][ u ][:]
#on additionne toutes les valeurs de chaque couleur des cases du carré
for t in range(3):
image2[i][ j ][ t ]=image2[i][ j ][ t ]/( 2*k+1)**2 # on fait la moyenne sur le nombre de cases
return image2

# affichage des photos obtenues

plt .subplot(2,2,1)
plt .imshow(photo2)
plt .subplot(2,2,2)
photo3=floutage(photo2,2)
plt .imshow(photo3)
plt .subplot(2,2,3)
photo3=floutage(photo2,4)
plt .imshow(photo3)
plt .subplot(2,2,4)
photo3=floutage(photo2,6)
plt .imshow(photo3)
TD Info
1 TD Traitement d’image PSI

plt .show()

Ce programme permet d’afficher les images suivantes :

0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800
0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800

Exercice 6. Détection de contour

⎛ 0 −1 0 ⎞
À partir d’un filtre différentiel de type ⎜ −1 0 1 ⎟ on détecte les contours.
⎝ 0 1 0 ⎠
Pour cela, on crée une fonction contour qui prend en entrée une photo en noir et blanc image, un filtre : une
matrice A et sui retournera les valeurs obtenues après filtrage contourimage.
Ensuite, on peut à partir du tableau de valeurs contourimage obtenue afficher plusieurs images de contour pour
différents seuils dans une fonction affichecontour prenant en entrée ce tableau de valeur contours et une liste L
de valeurs de seuils.
On crée ensuite le calcul de toutes les valeurs après filtrage en ne considérant que les pixels qui ont assez de voisins
pour appliquer le filtrage.
def contour2(image,A):
#image est une photo en noir et blanc (tableau numpy a deux dimensions de valeurs comprises entre 0 et 1
#A est un tableau numpy a deux dimensions d x e qui permet de faire la detection de contour par filtrage
# seuil est le seuil de detection d'un contour apres calcul de filtrage
n=len(image)
p=len(image[0])
d=len(A)
e=len(A[0])
contourimage=np.zeros((n,p))
m=0
M=1
for i in range(n−d+1): #l'application du filtre commence a un point en haut a gauche
for j in range(p−e+1): #tel que la taille du filtre reste dans l ' image
val=0
for t in range(i , i +d):
for u in range(j, j +e):
val+=image[t][u]* A[t −i ][ u−j]
contourimage[i+d//2][ j +e//2]=abs(val) #on affecte la valeur obtenue au pixel situe
# a peu pres au centre du filtre . Ce detail est toutefois inutile
TD Info
1 TD Traitement d’image PSI

#cela decale seulement un peu l'image

return contourimage #les pixels non modifie: le tour de l ' image reste a la valeur 0

On effectue ensuite la procédure d’affichage, en affichant en premier l’image de départ

def contour2(image,A):
#image est une photo en noir et blanc (tableau numpy a deux dimensions de valeurs comprises entre 0 et 1
#A est un tableau numpy a deux dimensions d x e qui permet de faire la detection de contour par filtrage
# seuil est le seuil de detection d'un contour apres calcul de filtrage
n=len(image)
p=len(image[0])
d=len(A)
e=len(A[0])
contourimage=np.zeros((n,p))
m=0
M=1
for i in range(n−d+1): #l'application du filtre commence a un point en haut a gauche
for j in range(p−e+1):#tel que la taille du filtre reste dans l ' image
val=0
for t in range(i , i +d):
for u in range(j, j +e):
val+=image[t][u]* A[t −i ][ u−j] #calcul du filtrage
contourimage[i+d//2][ j +e//2]=abs(val) #on affecte la valeur obtenue au pixel situe
# a peu pres au centre du filtre . Ce detail est toutefois inutile
#cela decale seulement un peu l'image
return contourimage #les pixels non modifie: le tour de l ' image reste a la valeur 0

Il ne reste plus qu’à passer les commandes

A=np.array([[0,−1,0],[−1,0,1 ],[ 0,1,0 ]]) # on enregistre le filtre dans un tableau numpyA
valeurs=contour(image,A) # on calcule les valeurs apres filtrage
affichecontour(image,valeurs,[0.1, 0.07, 0.05]) #on affiche les resultats .

Ce programme permet d’afficher les images suivantes :

0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800
0 0
100 100
200 200
300 300
400 400
500 500
600 600
0 100200300400500600700800 0 100200300400500600700800

Exercice 7. Image cachée

Comme pour chaque octet désignant chaque couleur de chaque pixel de l’image donnée,
TD Info
1 TD Traitement d’image PSI

● les 4 premiers bits sont les quatre premiers bits du nombre correspondant de la photo originale
● les 4 derniers bits sont les quatre premiers bits du nombre correspondant de la photo cachée
il suffit d’extraire de chaque octet les 4 derniers bits (bits de poids faible), cela s’obtient en calculant le reste d’un
octet par la division euclidienne par 16.
Et pour obtenir un octet normal d’une image il suffit ensuite de le multiplier par 16 pour obtenir à nouveau les 4
bits de poids forts de l’image cachée.
Toutefois comme le format de l’image de départ est un nombre entre 0 et 1, il faut déjà le multiplier par 255 et
prendre sa partie entière et obtenir de véritables octets pour chaque couleur de chaque pixel.
Pour cela, soit on le fait sur une triple boucle parcourant tous les octets de chaque pixel de la photo de départ, soit
on le fait directement sur la photo en multipliant tout le tableau nd.array par 255 et en lui adjoignant l’extension
.astype(np.uint8) :
photo=img.imread('/Users/fzwolska/Documents/enseignement/classes/PSI/Informatique/TDs/2020/TD1TraitementImage/sirenedansgaronne.png')
if photo.dtype == np.float32: # Si le résultat n'est pas un tableau d' entiers
photo = (photo * 255).astype(np.uint8) #on transforme le codage des couleurs en octet
plt .imshow(photo)
plt . figure ()
image=(photo%16)*16 #on prend le reste de chaque octet modulo 16 et on le multiplie par 16
#pour obtenir les 4 bits de poids fort de l ' image de départ.
#image=(photo−(photo//16)*16)*16
plt .imshow(image)
plt .show()

Ce programme permet de révéler l’image suivante de la sirène qui était cachée dans la photo de la garonne :

100

200

300

400

500
0 100 200 300 400 500 600 700 800

Pour cacher une photo dans une autre, on crée une nouvelle photo de la taille la plus grande des photos, et
pour chaque octet de chaque pixel :
● on lui met la valeur des 4 bits forts de la plus grande photo en prenant le quotient de ces octets dans la
divisions euclidienne par 16, que l’on multiplie par 16 pour que ce soit les 4 bits forts du nouvel octet.
● Et tant que le numéro de ligne et de la colonne du pixel que l’on traite reste dans les dimensions de la petite
image, on ajoute le quotient des octets de la petite image dans la divisions euclidienne par 16. Cela crée les
4 bits faibles de chaque octet des pixels de la nouvelle image. Le programme suivant a notamment permis
de créer l’image "sirenedansgaronne"
import numpy as np
TD Info
1 TD Traitement d’image PSI

import matplotlib.image as img

import matplotlib. pyplot as plt
from math import *
photo1=img.imread('/Users/fzwolska/Documents/enseignement/classes/PSI/Informatique/TDs/2020/TD1TraitementImage/lena.png')
photo2=img.imread('/Users/fzwolska/Documents/enseignement/classes/PSI/Informatique/TDs/2020/TD1TraitementImage/garonne_gelee.png') #charge l'image
if photo1.dtype == np.float32: # Si le résultat n'est pas un tableau d' entiers
photo1 = (photo1 * 255).astype(np.uint8)
if photo2.dtype == np.float32: # Si le résultat n'est pas un tableau d' entiers
photo2 = (photo2 * 255).astype(np.uint8)
n=len(photo1)
p=len(photo1[0])
q=len(photo1[0][0])
n2=len(photo2)
p2=len(photo2[0])
q2=len(photo2[0][0])

def cacheimage(image1,image2):
# on suppose que les deux dimensions de l'image 2 sont plus petites que celle de l ' image 1, et l ' image 2 sera cachée dans l'image 1
# chaque couleur étant codée par un nombre p/255, p étant un entier entre 0 et 255.
n=len(image1)
p=len(image1[0])
n2=len(image2)
p2=len(image2[0])
image3=np.zeros((n,p,3))
image3=(image1//16)*16
for i in range(n2):
for j in range(p2):
for k in range(3):
image3[i][ j ][ k]+=image2[i][ j ][ k ]// 16
plt . figure ()
plt .subplot(2,2,1)
plt .imshow(image1)
plt .subplot(2,2,2)
plt .imshow(image2)
plt .subplot(2,2,3)
plt .imshow(image3)
return image3

cacheimage(photo2,photo1)

Le résultat de ce programme est l’image suivante :

TD Info
1 TD Traitement d’image PSI

0
0
100 100

200 200
300 300
400
400
500
0 100 200 300 400 500 600 700 800 500
0 100 200 300 400 500

0
100
200
300
400
500
0 100 200 300 400 500 600 700 800