Bloc.py

projet/Block.py

+
+
+class Block:
+   
+   
+   
+   def __init__(self, zone, couleur=None, sous_blocs=None):
+        """Initialisation un objet Bloc avec une zone, une couleur et des sous_blocs"""
+        
+        self.zone=zone
+        self.couleur=couleur
+        self.sous_blocs=sous_blocs
+        
+        if self.sous_blocs:
+            if len(self.sous_blocs)!=4:
+                raise ValueError()
+            if couleur is not None:
+                raise ValueError()
+            self.couleur=self.moyenne_couleurs()
+            
+            
+    def moyenne_couleurs(self):
+        """Renvoie la moyenne des couleurs des sous_blocs"""
+
+        if not self.sous_blocs:
+            return  self.couleur
+        else:
+            r,g,b=0, 0, 0
+            for blocs in self.sous_blocs:
+                r+=bloc.couleur[0]
+                g+=bloc.couleur[1]
+                b+=bloc.couleur[2]
+            return [r/len(self.sous_blocs), g / len(self.sous_blocs),b/len(self.sous_blocs)]
+        
+        
+        
+        
+    def est_uniforme(self)->bool:
+        """Renvoie True si le bloc est uniforme"""
+        return not self.sous_blocs
+    
+    
+    
+    def est_dans_limites(self,limites_min, limites_max):
+       """Renvoie True si la zone du bloc est dans les limites spécifiées """
+       x,y=self.zone[:2]
+       width, height=self.zone[2:]
+       return (x>=limites_min[0] and x + width<=limites_max[0] and y>=limites_min[1] and x + height<=limites_max[1])
+   
+   
+   
+   
+   
+   
+    def __str__(self):
+        
+        """Renvoie une représentation en chaine de caractére du bloc"""
+        
+        if self.est_uniforme():
+            return f"Bloc(uniforme, couleur={self.couleur})"
+        else:
+            return f"Bloc(non_uniforme, couleur={self.couleur})"
+            
+        
+        
+        
+        
+        
+        
+
+                
+    
+               
+     
+      
+      
+    
+    
+    
+    
+
+            
+            
+    
\ No newline at end of file

projet/Readme.md

+Nom: Dahmane
+Prenom:Lynda
+
+
+#JOURNAL:
+
+
+#la date: 06/03/2024
+discription: Creation de la classe Block en thonny , dans cette classe j'ai lis déffirents constructeurs : init , moyenne_couleur, est_uniforme, est_dans_limites et str.
+
+
+
+#La date: 13/03/2024
+#La discription: Compte le nombre de pixels d'une certaine couleur dans une image
+
+Aujourd'hui j'ai crée la fonction count_color pour compter le nombre de pixels d'une certaine couleur dans une image.
+j'ai mis à cette fonction 2 parmetre image et color,  - image (Image PIL) : Image à traiter.
+                                                      - color (tuple) : Couleur à compter, sous la forme (rouge, vert, bleu).
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Docomuntation:
+La date :06/03/2024
+
+La classe Bloc sert a représenter un bloc avec une zone , une couleur, et ces sous_blocs. Si le bloc a des sous_blocs, la couleur moyenne de ces sous_blocs est calculée et affectée à la couleur de bloc . 
+Le constructeur  init  prend 3 arguments   (zone , couleur et sous_bloc) Si aucune couleur spécifiée , la couleur du bloc prend par défaut la valeur None .De meme , si aucun sous_bloc n'est spécifié , la valeur de sous 'sous_blocs'est "None"
+
+la fonction" init": 
+
+
+
+La fonction moyenne_couleur:
+
+
+
+la fonction est_uniforme:
+
+
+
+la fonction est_dans_limites:
+
+
+
+la fonction str:
+
+
+
+#La date: 13/03/2024
+
+
+ini: represente le Nombre de pixels de la couleur donnée
+
+J'ai utiliser " im_rgb = image.convert('RGB')" pour convertir l'image en mode RGB
+
+
+Les Tests:
+ count_color(im, (255, 0, 0)): renvoie le nombres de pixels rouges
+  
+ count_color(im, (0, 225, 0)): renvoie le nombres de pixels vert 
+ 
+ count_color(im, (0, 0, 255)): renvoie le nombres de pixels bleu
+
+pour  Compter les pixels de la couleur donnée j'ai fais ça :
+    count=0
+    width, height = im_rgb.size
+    for x in range(width):
+        for y in range(height)
+et pour obtenir  la couleur du pixel à la position (x, y) : pixel_color = im_rgb.getpixel((x, y))
+if pixel_color == color:c'est pour Vérifier si la couleur du pixel est égale à la couleur donnée
+count+=1: Incrémenter le compteur si la couleur correspond
+               
+

projet/charger_image.py

+def charger_image(fichier):
+    
+    """renvoie le contenu de l'image sous forme de données binaires
+
+    Précondition : 
+    Exemple(s) :
+    $$$ 
+    """
+    
+    with open(fichier, 'rb') as file:
+        image = file.read()
+    return image
\ No newline at end of file

projet/count_color.py

+from PIL import Image
+
+def count_color(image, color:tuple([int, int,int]))-> int:
+    """renvoie le nombre de pixels d'une certaine couleur dans une image donnée 
+
+    Précondition : 
+    Exemple(s) :
+    $$$ count_color(im, (255, 0, 0))
+    100
+    $$$ count_color(im, (0, 255, 0))   
+    50
+    $$$ count_color(im, (0, 0, 255)) 
+    200
+
+    """
+    im_rgb = image.convert('RGB')
+   
+    count = 0
+    width, height = im_rgb.size
+    for x in range(width):
+        for y in range(height):
+            if im_rgb.getpixel((x, y)) == color:
+                count += 1
+
+    return count
+

projet/crop_image.py

+from PIL import Image
+
+
+def crop_image(image_path, left, upper, right, lower):
+    """à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition : 
+    Exemple(s) :
+    $$$ 
+
+    """
+    
+    
+    image = Image.open(image_path)
+    cropped_image = image.crop((left, upper, right, lower))
+    cropped_image.show()
\ No newline at end of file

projet/diviser_image.py

+from PIL import Image
+
+def diviser_image(image, taille:int):
+    """renvoie une liste de blocs d'images. Chaque bloc est une partie
+    de l'image initiale, découpée en carrés de taille spécifiée
+
+    
+    """
+    
+    largeur, hauteur = image.size
+    blocs = []
+    
+    for i in range(0, largeur, taille):
+        for j in range(0, hauteur, taille):
+            bloc = image.crop((i, j, i+taille, j+taille))
+            blocs.append(bloc)
+    
+    return blocs
\ No newline at end of file

projet/image.py

+def couleur_moyenne(liste_couleurs:[tuple])->[tuple]:
+    """calcule la couleur moyenne à partir d'une liste de couleurs. Elle prend en entrée
+    une liste de tuples représentant des couleurs et retourne un tuple représentant la couleur moyenne
+
+    Précondition : 
+    Exemple(s) :
+    $$$ couleur_moyenne([(255, 0, 0), (0, 255, 0), (0, 0, 255)])
+    (85, 85, 85)
+    """
+    
+    total_rouge = 0
+    total_vert = 0
+    total_bleu = 0
+    
+    for couleur in liste_couleurs:
+        total_rouge += couleur[0]
+        total_vert += couleur[1]
+        total_bleu += couleur[2]
+    
+    nb_couleurs = len(liste_couleurs)
+    moyenne_rouge = total_rouge / nb_couleurs
+    moyenne_vert = total_vert / nb_couleurs
+    moyenne_bleu = total_bleu / nb_couleurs
+    
+    return (moyenne_rouge, moyenne_vert, moyenne_bleu)
+