Select Git revision
traite_img.py
traite_img.py 4.29 KiB
from PIL import Image, ImageDraw
def process_image(image, ordre):
"""cette fonction devise l'image en 4 blocs à chaque niveau de recursion ensuite, il vérifie si les blocs sont suffisamment proches en couleur. S'ils le sont, il crée un bloc uniforme avec la couleur moyenne. Sinon, il fusionne les quatre blocs.
Précondition :
Exemple(s) :
$$$
"""
# Cas de base : si l'ordre est zéro, crée et renvoie un bloc de la couleur moyenne de l'image
if ordre == 0:
largeur, hauteur = image.size
couleur_moyenne_rgb = average_rgb(image)
bloc_uniforme = Image.new("RGB", (largeur, hauteur), couleur_moyenne_rgb)
return bloc_uniforme
# Diviser l'image en quatre blocs
blocs = diviser_image(image)
# Appliquer l'algorithme à chaque bloc récursivement
blocs_traites = []
for bloc in blocs:
bloc_traite = process_image(bloc, ordre - 1)
blocs_traites.append(bloc_traite)
# Vérifier si les blocs sont proches en couleur
if sont_blocs_proches(blocs_traites):
# Si c'est le cas, créer un bloc uniforme avec la couleur moyenne
return creer_bloc_uniforme(blocs_traites)
else:
# Sinon, créer un bloc contenant les quatre blocs traités
return fusionner_blocs(blocs_traites)
def diviser_image(image):
"""cette fonction divise l'image en 4 blocs
Précondition :
Exemple(s) :
$$$
"""
width, height = image.size
half_width = width // 2
half_height = height // 2
block1 = image.crop((0, 0, half_width, half_height)) # en haut à gauche
block2 = image.crop((half_width, 0, width, half_height)) # en haut à droite
block3 = image.crop((0, half_height, half_width, height)) # en bas à gauche
block4 = image.crop((half_width, half_height, width, height)) # en bas à droite
return [block1, block2, block3, block4]
def average_rgb(image):
"""Cette fonction calcule la couleur moyenne de l'image en termes de composantes (RGB)
Précondition :
Exemple(s) :
$$$
"""
# Chargez l'image et convertissez-la en mode RGB si elle n'est pas déjà dans ce mode
image = image.convert('RGB')
# Obtenez la largeur et la hauteur de l'image
width, height = image.size
# Obtenez les données de pixels pour l'ensemble de l'image
pixels = image.load()
# Initialisez les variables pour stocker la somme des valeurs RGB
total_r, total_g, total_b = 0, 0, 0
# Parcourez chaque pixel de l'image et additionnez les valeurs RGB
for y in range(height):
for x in range(width):
r, g, b = pixels[x, y] # Obtenez les valeurs RGB du pixel actuel
total_r += r
total_g += g
total_b += b
# Calculez les valeurs RGB moyennes en divisant la somme totale par le nombre de pixels
nb_pixels = width * height
average_r = total_r // nb_pixels
average_g = total_g // nb_pixels
average_b = total_b // nb_pixels
return (average_r, average_g, average_b)
def sont_blocs_proches(blocs):
"""qui calcule la moyenne de chaque bloc et verifie si les couleurs sont assez proches,
dans ce cas j'ai pris un seuil de 20 pixels
Précondition :
Exemple(s) :
$$$
"""
# Calculer la couleur moyenne de chaque bloc
couleurs = [average_rgb(bloc) for bloc in blocs]
# Vérifier si les couleurs sont assez proches (seuil de 20 pixels)
seuil = 20
for i in range(len(couleurs) - 1):
for j in range(i + 1, len(couleurs)):
couleur1 = couleurs[i]
couleur2 = couleurs[j]
if abs(couleur1[0] - couleur2[0]) > seuil or \
abs(couleur1[1] - couleur2[1]) > seuil or \
abs(couleur1[2] - couleur2[2]) > seuil:
return False
return True
def creer_bloc_uniforme(blocs):
"""cette fonction cree un bloc uniforme à partir d'une liste de blocs d'images en utilisant la couleur moyenne des blocs
Précondition :
Exemple(s) :
$$$
"""
def fusionner_blocs(blocs):
"""Cette fonction prend une liste de quatre blocs d'images et les fusionne pour créer une seule image contenant ces quatre blocs
Précondition :
Exemple(s) :
$$$
"""