maj Projet

Projet/Readme.md

@@ -5,14 +5,34 @@ author: M'bah Ange Pascal Tanoh
 
 # journal
 -06/03: importation des bibliotheques necessaires
--20/03: importation des bibliotheques necessaires pourmanipuler les images
+
+-20/03: importation des bibliotheques necessaires pour manipuler les images
  20/03: definition de la fonction image_recursion : cette fonction prend en entrée une image et un ordre qui determine le niveau de detail de la représentation finale.
  elle effectue les etapes suivantes de manieres recursive:
+ 
  -si l'ordre est nul ou si l'image ou l'image est un pixel, la fonction retourne la couleur du pixel, sinon elle divise l'image en quatre blocs de taille egale.
+ 
  - elle appelle recursivement la fonction sur chaque bloc.
+-
+02/04: modification du projet du debut au commencement en commencant par la construction de la class Bloc et ses differentes methodes.
+
+- ensuite je vais diviser l'image en 4 blocs
+
+- ensuite je vais utiliser la methode qui va me permettre et renvoyer un tuple(r,g,b) representant la couleur moyenne d'un bloc
+
+-La fonction modife_couleur modifie la couleur d'un bloc dans un programme Python. Elle parcourt les sous-blocs du bloc en question, et calcule la moyenne des valeurs rouge (r), vert (g) et bleu (b) pour tous les sous-blocs. Si la couleur d'un sous-bloc est un entier, il est considéré comme une valeur de couleur unique qui est ajoutée aux valeurs r, g ou b correspondantes. Si la couleur d'un sous-bloc est un tuple, il est considéré comme contenant trois valeurs représentant les valeurs r, g et b pour ce sous-bloc. La couleur finale du bloc est alors définie comme la moyenne des valeurs r, g et b de tous ses sous-blocs.
 
+-La fonction est_uniforme est une méthode qui vérifie si un bloc est uniforme. Cette fonction renvoie une valeur booléenne, qui est True si le bloc n'a pas de sous-blocs et False dans le cas contraire.
 
+-La fonction blocs_proches est une méthode  qui vérifie si deux blocs sont proches en fonction de leur couleur. Cette fonction prend deux paramètres, self et autre_bloc, qui représentent respectivement le bloc actuel et le bloc à comparer.
 
+La fonction commence par vérifier si les deux blocs sont uniformes, c'est-à-dire s'ils ne contiennent pas de sous-blocs. Si l'un des deux blocs n'est pas uniforme, la fonction renvoie False pour indiquer qu'ils ne sont pas proches.
+
+Si les deux blocs sont uniformes, la fonction calcule la différence entre les composantes rouge, verte et bleue de leur couleur respective. Elle utilise la fonction abs pour prendre la valeur absolue de chaque différence, et vérifie si chaque valeur est inférieure ou égale à 10.
+
+Si toutes les valeurs absolues sont inférieures ou égales à 10, la fonction renvoie True pour indiquer que les deux blocs sont proches en termes de couleur. Sinon, la fonction renvoie False pour indiquer qu'ils ne sont pas proches.
+
+-
 
 
 # documentation
@@ -20,3 +40,22 @@ author: M'bah Ange Pascal Tanoh
 20/03: # definition de la fonction image_recursion: def image_recursion(image, ordre):
        # diviser l'image en quatre blocs
 
+02/04: # modification du projet du debut au commencement en commencant par la construction de la class Bloc et ses differentes methodes :
+
+- #initialisation de la class Bloc et ses differentes methode
+_#initialisation de la fonction init qui prend en parametre une image, haut_gauche, bas_droit, 
+la couleur, et les sous_blocs comme l'ennonce l'indique
+
+_ #utilisation de la methode de la class Bloc pour diviser l'image en quatre blocs
+
+_#utilation de la methode de la class pour representer la couleur moyenne d'un bloc 
+(tuple(r,g,b))
+
+_ # utilisation de la methode qui va me permettre de modifier la couleur d'un bloc
+
+_# utilisation de la methode est_uniforme qui verifie si un bloc est uniforme
+
+_# utilisation de la methode blocs_proches qui verifie si deux blocs sont proches
+
+_#
+

Projet/src/projet.py

 #importation des bibliotheques necessaires pourmanipuler les images
 from PIL import Image, ImageDraw
 
-def image_recursion(image, ordre):
-    """à_remplacer_par_ce_que_fait_la_fonction
+# Creation de la classe Bloc et ses differentes methodes
+
+class Bloc:
+    """Paramètres :
+    à_remplacer_par_ce_que_fait_la_fonction
 
     Précondition : 
     Exemple(s) :
     $$$ 
 
     """
-    if ordre == 0:
+# initialisation de la fonction init
+    def __init__(self, Image, haut_gauche, bas_droit, couleur=None, sous_blocs=None):
+        """initialise un élement de type Bloc
+
+        Précondition :
+        Exemple(s) :
+        $$$
+
+        """
+        
+        self.image = Image
+        self.haut_gauche = haut_gauche
+        self.bas_droit = bas_droit
+        self.couleur = couleur
+        self.sous_blocs = sous_blocs or []
+        
+  # diviser l'image en quatre bloc      
+    def diviser_en_quatre(self):
+        """ Methode qui renvoie une liste de quatre objets Bloc
+
+        Précondition :
+        Exemple(s) :
+        $$$
+
+        """
+        
+        abscisse_x = (self.haut_gauche[0] + self.bas_droit[0]) // 2
+        ordonne_y = (self.haut_gauche[1] + self.bas_droit[1]) // 2
+        return [
+            Bloc(self.image, self.haut_gauche, (abscisse_x, ordonne_y)),
+            Bloc(self.image, (self.haut_gauche[0], ordonne_y), (abscisse_x, self.bas_droit[1])),
+            Bloc(self.image, (abscisse_x, self.haut_gauche[1]), (self.bas_droit[0], ordonne_y)),
+            Bloc(self.image, (abscisse_x, ordonne_y), self.bas_droit)
+        ]
+    
+# Methode qui renvoie un tuple(r,g,b) representant la couleur moyenne d'un bloc     
+    def couleur_moyenne(self):
+        """Methode qui renvoie un tuple(r,g,b) representant la couleur moyenne d'un bloc
+
+        Précondition : aucune
+        Exemple(s) :
+        $$$
+
+        """
+        
+        couleur_r = 0
+        couleur_g = 0
+        couleur_b = 0
+        total_pixels = 0
+        for x in range(self.haut_gauche[0], self.bas_droit[0]):
+            for y in range(self.haut_gauche[1], self.bas_droit[1]):
+                pixel = self.image.getpixel((x, y))
+                if isinstance(pixel, int):
+                    couleur_r = couleur_r + pixel
+                    couleur_g = couleur_g + pixel
+                    couleur_b  = couleur_b + pixel
+                else:
+                    couleur_r  = couleur_r +  pixel[0]
+                    couleur_g  = couleur_g + pixel[1]
+                    couleur_b = couleur_b + pixel[2]
+                total_pixels  = total_pixels +1
+        return (couleur_r // total_pixels, couleur_g // total_pixels, couleur_b // total_pixels)
+
+# methode qui va me permettre de modifier la couleur d'un bloc.  
+    def modife_couleur(self):
+            """Methode qui modifie la couleur d'un bloc  
+
+            Précondition :
+            Exemple(s) :
+            $$$
+
+            """
+        
+            if self.est_uniforme():
+                return
+            r = 0
+            g = 0
+            b = 0
+            for bloc in self.sous_blocs:
+                if isinstance(bloc.couleur, int):
+                    r  = r + bloc.couleur
+                    g  =  g + bloc.couleur
+                    b = b+ bloc.couleur
+                else:
+                    r  = r + bloc.couleur[0]
+                    g = g + bloc.couleur[1]
+                    b = b + bloc.couleur[2]
+            self.couleur = (r // 4, g // 4, b // 4)
+
+# utilisation de la methode qui verifie si un bloc est uniforme
+
+    def est_uniforme(self):
+        """Methode qui verifie si un bloc est uniforme
+
+        Précondition : aucune
+        Exemple(s) :
+        $$$
+
+        """
+        
+        return len(self.sous_blocs) == 0
+    
+# utilisation de la methode qui verifie si deux blocs sont proches    
+    def blocs_proches(self, autre_bloc):
+        """Verifie si deux blocs sont proches
+
+        Précondition : aucune
+        Exemple(s) :
+        $$$
+
+        """
+        
+        if not self.est_uniforme() or not autre_bloc.est_uniforme():
+            return False
+        return abs(self.couleur[0] - autre_bloc.couleur[0]) <= 10 and \
+               abs(self.couleur[1] - autre_bloc.couleur[1]) <= 10 and \
+               abs(self.couleur[2] - autre_bloc.couleur[2]) <= 10
+    
+# utilisation de la fonction qui cree une nouvelle image de la meme tailleque le bloc
+   
+    def creer_image(self):
+        """Crée une nouvelle image de la même taille que le bloc
+
+        Précondition :
+        Exemple(s) :
+        $$$
+
+        """
+        image = Image.new('RGB', (self.bas_droit[0] - self.haut_gauche[0], self.bas_droit[1] - self.haut_gauche[1]))
+
+        if self.est_uniforme():
+            for x in range(image.width):
+                for y in range(image.height):
+                    image.putpixel((x, y), self.couleur)
+        else:
+            milieu_x = image.width // 2
+            milieu_y = image.height // 2
+            image.paste(self.sous_blocs[0].creer_image(), (0,0, milieu_x, milieu_y))
+            image.paste(self.sous_blocs[1].creer_image(), (0, milieu_y, milieu_x, image.height))
+            image.paste(self.sous_blocs[2].creer_image(), (milieu_x, 0, image.width, milieu_y))
+            image.paste(self.sous_blocs[3].creer_image(), (milieu_x, milieu_y, image.width, image.height))
+
         return image
-#  diviser l'image en quatre blocs
-    largeur_bloc = largeur//2
-    hauteur_bloc = hauteur//2
-    blocs = [ image.crop((0, 0, largeur_bloc, hauteur_bloc))/
-              image.crop((largeur_bloc, 0, largeur, hauteur_blocs))/
-              image.crop((0, hauteur_bloc, largeur_bloc, hauteur))/
-              image.crop((largeur_bloc, hauteur_bloc, largeur, hauteur))]
-
-# appliquons l'algorithme sur chaque en diminuant l'ordre de 1
-    nouveau_blocs = [image_recursion(blocs,ordre-1) for blocs in blocs]
-
-# verifions si les quatres blos sont de couleur proches
-    seuil =
-    couleurs = [blocs.getpixel((0,0)) for blocs in nouveau_blocs]
-    couleurs_moyenne = tuple(sum(c)//len(c) for c in zip(couleurs))
+
+
     
\ No newline at end of file