Update 13 files

- /projet/codes/Block.py
- /projet/codes/calbuth.png
- /projet/codes/Color.py
- /projet/codes/Decouper_Image.py
- /projet/codes/ex.py
- /projet/codes/Image_Recursive.py
- /projet/file.bmp
- /projet/codes/block.py
- /projet/codes/color_manipulation.py
- /projet/codes/image_rec.py
- /projet/images/calbuth.png
- /projet/images/file.bmp
- /projet/ReadMe.md

projet/ReadMe.md

-
-### Images récursives
-### KINADINOVA Dariya
+### Images récursives
+### Dariya KINADINOVA 
 
 #### **06/03/24 :**
 - J'ai lu les documents et j'ai crée un dossier "projet" et un fichier "ReadMe.md" pour documenter le processus.
 
 #### **13/03/24 :**
-- J'ai commencé à travailler sur la classe Block (j'ai commencé par _ _ init _ _ et j'ai ajouté les paramètres pour is_uniform, color et coordinates) et j'ai créé deux fonctions pour la manipulation des couleurs (pour la moyenne des couleurs et leur distance).
+- J'ai commencé à travailler sur la classe Block (j'ai commencé par _ _ init _ _ et j'ai ajouté les paramètres pour is_uniform, color et coordinates) et j'ai créée deux fonctions pour la manipulation des couleurs (pour la moyenne des couleurs et leur distance).
 
 #### **20/03/24 :**
-- Work on Block.py and Decouper_Image.py
+- Travail sur Block.py et Decouper_Image.py
 
 #### **27/03/24 :**
-- I remade functions decouper, added functions list_col and is_col_close. Made functions average_color, divide_blocks to class Block using the functions previously made. Work on Image_Recursive.
+- J'ai refait les fonctions decouper, ajouté les fonctions list_col et is_col_close. J'ai créée les fonctions average_color, divide_blocks pour la classe Block en utilisant les fonctions précédemment créées. Travail sur Image_Recursive.
+
+#### **28/03/24 :**
+- J'ai décidé de refaire la classe Block car l'algorithme récursif ne fonctionnait pas comme prévu. J'ai décidé de mettre la plupart des fonctions nécessaires à l'algorithme à l'intérieur de la classe.
+- Dans block.py pour les arguments dans __init__ j'ai utilisé *args avec l'aide de sa documentation sur le site. J'ai utilisé l'argument is_uniform comme argument principal, ce qui permettra de faire la différence entre un bloc et un block contenant 4 blocs. 
+- Au lieu de vérifier si le bloc est uniforme, j'ai créée une fonction qui vérifie si 4 blocs sont uniformes pour l'utiliser dans l'algorithme.
+
+#### **29/03/24 :**
+- J'ai travaillé sur image_rec, au lieu qu'il retourne une image, j'ai décidé qu'il retournerait un bloc que je transformerai en image dans le code plus tard.
+
+#### **30/03/24 :**
+- Pour average_col, je l'ai modifié pour qu'il ne prenne pas un bloc mais quatre et qu'il envoie leur couleur moyenne, ce qui est plus utile pour image_rec.
+- J'ai terminé image_rec.
+
+#### **31/03/24**:
+- Pour transformer le bloc en image, j'ai créée une fonction block_to_image à l'intérieur de la classe. Fini la fonction main() qui permettra d'utiliser la fonction rec_algorithm dans le terminal.
+- j'ai renommé certaines fonctions, ajouté des exemples, complété la docstring et ajouté des commentaires sur certaines fonctions.
+

projet/codes/Block.py

-"""
-:author: dariya kinadinova
-:date: 03/2024
-
-"""
-
-from PIL import Image, ImageDraw
-from Color import *
-from Decouper_Image import *
-
-class Block:
-    def __init__(self, image):
-        """à_remplacer_par_ce_que_fait_la_fonction
-
-        Précondition : 
-        Exemple(s) :
-        $$$ 
-
-        """
-        self.image = image
-        self.width, self.height = image.size
-        
-    def average_color(self):
-        """à_remplacer_par_ce_que_fait_la_fonction
-
-        Précondition : 
-        Exemple(s) :
-        $$$ 
-
-        """
-        colors = liste_col(self.image, (0, 0), (self.width-1, self.height-1))
-        return avg_col(colors)
-    
-    def divide_blocks(self):
-        """à_remplacer_par_ce_que_fait_la_fonction
-
-        Précondition : 
-        Exemple(s) :
-        $$$ 
-
-        """
-        allblocks = []
-        d = decouper(self.image)
-        for blocks in d:
-            allblocks.append(Block(blocks))
-        return allblocks
-        
-    def is_uniform(self, coordinates: tuple()):
-        """à_remplacer_par_ce_que_fait_la_fonction
-
-        Précondition : 
-        Exemple(s) :
-        $$$ 
-
-        """
-        x, y = coordinates
-        if all(self.image.getpixel((x, y)) == self.image.getpixel((x1, y1)) for x in range(self.width) for y in range(self.height)):
-            return True
-        else:
-            return False
-    
-    
-
-

projet/codes/Decouper_Image.py

-"""
-:author: dariya kinadinova
-:date: 03/2024
-
-"""
-
-from PIL import Image, ImageDraw
-
-
-def decouper(im: Image) -> list[Image]:
-    """splits image into four blocks
-
-    Précondition : 
-    Exemple(s) :
-    $$$ 
-
-    """
-    im_rgb = im.convert('RGB')
-    size = im_rgb.size
-    w = size[0]
-    h = size[1]
-    crop1 = (0, 0, (w//2), (h//2))
-    block_1 = im.crop(crop1)
-    crop2 = ((w//2), 0, w, (h//2))
-    block_2 = im.crop(crop2)
-    crop3 = (0, (h//2), (w//2), h)
-    block_3 = im.crop(crop3)
-    crop4 = ((h//2), (w//2), h, w)
-    block_4 = im.crop(crop4)
-    l  = [block_1, block_2, block_3, block_4]
-    return l
-
-
-        
-    
-    
-    
-
-
-
-

projet/codes/Image_Recursive.py

-"""
-:author: dariya kinadinova
-:date: 03/2024
-
-"""
-import sys
-from PIL import Image, ImageDraw
-from Color import *
-from Decouper_Image import *
-from Block import *
-
-def Image_Recursive(image: Image, order: int):
-    """à_remplacer_par_ce_que_fait_la_fonction
-
-    Précondition : 
-    Exemple(s) :
-    $$$ 
-
-    """
-    im = image.convert('RGB')
-    b = Block(im)
-    if order != 0:
-        allblocks = b.divide_blocks()
-        allb = [Image_Recursive(b1.image, order -1) for b1 in allblocks]
-        if all(b1.is_uniform() for b1 in allb):
-            avg_c = average_color([b1.color for b1 in allb])
-            new_b = Block(Image.new(image.size, avg_c))
-            return new_b
-        else:
-            # create a block with index or a loop
-            block_im = Image.new(image.size)
-            pass
-        
-
-
-def main():
-    """à_remplacer_par_ce_que_fait_la_fonction
-
-    Précondition : 
-    Exemple(s) :
-    $$$ 
-
-    """
-    
-    
\ No newline at end of file

projet/codes/block.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:mod:`block` module
+
+:author: Dariya Kinadinova
+
+:date: 03/2024
+
+
+"""
+from PIL import Image, ImageDraw
+from color_manipulation import *
+
+class Block:
+    def __init__(self, *args):
+        """Initialiser un nouveau bloc.
+
+        Précondition : 
+        Exemple(s) :
+        $$$ bloc1 = Block(True, (240, 189, 255))
+        $$$ bloc2 = Block(True, (255, 198, 240))
+        $$$ bloc3 = Block(True, (247, 185, 245))
+        $$$ bloc4 = Block(True, (235, 179, 245))
+        $$$ bloc1.are_4_uniform(bloc2, bloc3, bloc4)
+        True
+        $$$ bloc1.get_average_color(bloc2, bloc3, bloc4)
+        (244, 187, 246)
+        $$$ big_block = Block(False, bloc1, bloc2, bloc3, bloc4)
+        $$$ big_block.upper_left_block.get_average_color(big_block.upper_right_block, big_block.lower_left_block, big_block.lower_right_block)
+        (244, 187, 246)
+        
+        """
+        assert len(args) >= 1 and len(args) <= 5 , "1, 2, 3, 4 ou 5 arguments"
+        self.is_uniform = args[0]
+        if self.is_uniform:
+            assert len(args) == 2, "Le bloc uniforme doit avoir deux arguments"
+            assert type(args[1]) == tuple and len(args[1]) == 3, "La couleur doit être un tuple de 3 éléments"
+            self.color = args[1]
+        else:
+            assert len(args) == 5, "Le bloc non uniforme doit avoir quatre arguments representant les sous-blocs"
+            self.upper_left_block = args[1]
+            self.upper_right_block = args[2]
+            self.lower_left_block = args[3]
+            self.lower_right_block = args[4]
+            
+    def are_4_uniform(self, block2: 'Block', block3: 'Block', block4: 'Block') -> bool:
+        """Vérifiez si quatre blocs différents sont uniformes.
+
+        Précondition : doit fournir 3 blocs en plus du premier bloc
+        Exemple(s) :
+        $$$ 
+
+        """
+        if self.is_uniform and block2.is_uniform and block3.is_uniform and block4.is_uniform:
+            return is_col_close(self.color, block2.color) and \
+                   is_col_close(self.color, block3.color) and \
+                   is_col_close(self.color, block4.color)
+        else:
+            return False
+        
+    def get_average_color(self, block2: 'Block', block3: 'Block', block4: 'Block') -> tuple:
+        """Calcule la couleur moyenne de quatre blocs.
+
+        Précondition : doit fournir 3 blocs en plus du premier bloc
+        Exemple(s) :
+        $$$ 
+
+        """
+        r_avg = (self.color[0] + block2.color[0] + block3.color[0] + block4.color[0]) // 4
+        g_avg = (self.color[1] + block2.color[1] + block3.color[1] + block4.color[1]) // 4
+        b_avg = (self.color[2] + block2.color[2] + block3.color[2] + block4.color[2]) // 4
+        return (r_avg, g_avg, b_avg)
+    
+    def block_to_image(self, size: tuple) -> Image:
+        """Transformer un bloc en image.
+
+        Précondition : block est un objet Block, size est un tuple représentant la taille de l'image
+        Exemple(s) :
+        $$$
+        
+        """
+        if self.is_uniform:
+        # Si le bloc est uniforme, une nouvelle image est cree
+            im = Image.new('RGB', size, self.color)
+        else:
+        # Calculer les tailles
+            upper_left_size = (size[0] // 2, size[1] // 2)
+            upper_right_size = (size[0] - upper_left_size[0], upper_left_size[1])
+            lower_left_size = (upper_left_size[0], size[1] - upper_left_size[1])
+            lower_right_size = (size[0] - upper_left_size[0], size[1] - upper_left_size[1])
+        # transformer chaque sous-bloc en image
+            upper_left_im = self.upper_left_block.block_to_image(upper_left_size)
+            upper_right_im = self.upper_right_block.block_to_image(upper_right_size)
+            lower_left_im = self.lower_left_block.block_to_image(lower_left_size)
+            lower_right_im = self.lower_right_block.block_to_image(lower_right_size)
+        # Creer une nouvelle image et coller les sous-blocs
+            im = Image.new('RGB', size)
+            im.paste(upper_left_im, (0, 0))
+            im.paste(upper_right_im, (upper_left_size[0], 0))
+            im.paste(lower_left_im, (0, upper_left_size[1]))
+            im.paste(lower_right_im, (upper_left_size[0], upper_left_size[1]))
+        return im
+
+

projet/codes/Color.py → projet/codes/color_manipulation.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
 """
-:author: dariya kinadinova
+:mod:`manipulation des couleurs` module
+
+:author: Dariya Kinadinova
+
 :date: 03/2024
 
-"""
 
+"""
 from PIL import Image, ImageDraw
 
-# Color manipulation
+# Découper l'image
+def decouper(im: Image) -> list[Image]:
+    """Divise l'image en quatre blocs.
+
+    Précondition : 
+    Exemple(s) :
+    $$$ 
+
+    """
+    im_rgb = im.convert('RGB')
+    size = im_rgb.size
+    w = size[0]
+    h = size[1]
+    crop1 = (0, 0, (w//2), (h//2))
+    block_1 = im.crop(crop1)
+    crop2 = ((w//2), 0, w, (h//2))
+    block_2 = im.crop(crop2)
+    crop3 = (0, (h//2), (w//2), h)
+    block_3 = im.crop(crop3)
+    crop4 = ((h//2), (w//2), h, w)
+    block_4 = im.crop(crop4)
+    l  = [block_1, block_2, block_3, block_4]
+    return l
+
+# Manipulation des couleurs
 def avg_col(l:list) -> tuple():
-    """renvoie la couleur moyenne d'une liste de couleurs
+    """Renvoie la couleur moyenne d'une liste de couleurs
 
     Précondition : 
     Exemple(s) :
@@ -29,7 +59,7 @@ def avg_col(l:list) -> tuple():
     return (avg1, avg2, avg3)
 
 def list_col(im: Image, left_top: tuple(), right_bottom: tuple()) -> list[int]:
-    """return a list of colors of each pixels in the given space
+    """Renvoie une liste de tuples de couleurs pour chaque pixel de la région spécifiée de l'image.
 
     Précondition : 
     Exemple(s) :
@@ -42,8 +72,8 @@ def list_col(im: Image, left_top: tuple(), right_bottom: tuple()) -> list[int]:
     return [im.getpixel((x, y)) for x in range(x_max+1) for y in range(y_max+1)]
 
 def is_col_close(color1: tuple(), color2: tuple()) -> bool:
-    """returns True if the distance between two colors is not more than 30,
-    returns False if the distance is more than 30
+    """renvoie True si la distance entre deux couleurs est inférieure ou égale à 30,
+    renvoie False si la distance est supérieure à 30.
 
     Précondition : 
     Exemple(s) : 
@@ -53,11 +83,8 @@ def is_col_close(color1: tuple(), color2: tuple()) -> bool:
     False
 
     """
-    if (abs(color1[0] - color2[0]) <= 30) and (abs(color1[1] - color2[1]) <= 30) and (abs(color1[2] - color2[2]) <= 30):
-        res = True
-    else:
-        res = False
-    return res
-    
-    
+    return (abs(color1[0] - color2[0]) <= 30) and (abs(color1[1] - color2[1]) <= 30) \
+           and (abs(color1[2] - color2[2]) <= 30)
+
+
     
\ No newline at end of file

projet/codes/ex.py

-from PIL import Image, ImageDraw
-
-im = Image.open('calbuth.png')
-size = im.size
-w = size[0]
-h = size[1]
-cb1 = (0)
-
-crop_rectangle = (0, (h//2), (w//2), h)
-cropped_im = im.crop(crop_rectangle)
-
-print(cropped_im.size)

projet/codes/image_rec.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:mod:`image récursive` module
+
+:author: Dariya Kinadinova
+
+:date: 03/2024
+
+
+"""
+from PIL import Image, ImageDraw
+from color_manipulation import *
+from block import *
+import sys
+
+# Algorithme récursif
+def rec_algorithm(image: Image, order:int):
+    """Cet algorithme permet de créer des blocs imbriqués les uns dans les autres \
+    à partir d'une image.
+
+    Précondition : order >= 0
+    Exemple(s) :
+    $$$ 
+
+    """
+    average_color = avg_col(list_col(image, (0, 0), (image.size[0]-1, image.size[1]-1)))
+    rec_blocks = []
+    if order != 0:
+        # Divise image en quatre sous-blocs
+        blocks = decouper(image)
+        for block in blocks:
+            # executer l'algorithme sur chaque sous-bloc en diminuant l'ordre de 1
+            rec_blocks.append(rec_algorithm(block, order-1))
+        if rec_blocks[0].are_4_uniform(rec_blocks[1], rec_blocks[2], rec_blocks[3]):
+            # si les quatre blocs sont uniforms, alors creer un bloc uniforme de couleur \
+            # la couleur moyenne des quatre blocs
+            res = Block(True, rec_blocks[0].get_average_color(rec_blocks[1], rec_blocks[2], \
+                                                              rec_blocks[3]))
+        else:
+            # sinon, il cee et renvoie un bloc avec les quatre blocs
+            res = Block(False, rec_blocks[0], rec_blocks[1], rec_blocks[2], rec_blocks[3])
+    else:
+        # il cree et renvoie un bloc de la couleur moyenne de l'image
+        res = Block(True, average_color)
+    return res
+
+def main():
+    """permet d'utiliser le terminal
+
+    Précondition : 
+    Exemple(s) :
+    $$$ 
+
+    """
+    if len(sys.argv) != 3:
+        print("usage: image_rec.py image.png order")
+    else:
+        im_path = sys.argv[1]
+        order = int(sys.argv[2])
+        im = Image.open(im_path)
+        block = rec_algorithm(im, order)
+        res_im = block.block_to_image(im.size)
+        res_im.show()
+
+if __name__ == "__main__":
+    main()
+
+# Le terminal doit être ouvert dans le dossier du projet
+# Par exemple:
+# $ python3 codes\image_rec.py images\calbuth.png 5 
+    
\ No newline at end of file