Telechargez les fichiers image.py, vector.py, tp4-titi_grosminet.py et lac.ppm. Vous allez completer le fichier tp4-titi_grosminet.py dans la suite du TP...

Complétez la fonction moyenneParBlocs(T, lng) qui prend en entrée un tableau T et un entier lng. Cette fonction retourne un tableau de la même longueur que T dont les lng premières valeurs sont toutes égales à la moyenne des lng premières valeurs de T. Ensuite, un deuxième bloc prend la valeur des lng valeurs suivantes, et ainsi de suite.

Exemples:

>>> T = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> moyenneParBlocs(T, 5)
[2, 2, 2, 2, 2, 7, 7, 7, 7, 7]
>>> moyenneParBlocs(T, 4)
[1, 1, 1, 1, 5, 5, 5, 5, 8, 8]
>>> moyenneParBlocs(T, 3)
[1, 1, 1, 4, 4, 4, 7, 7, 7, 9]

Le code de cette fonction ressemble à ceci. Modifiez le pour prendre en compte le dernier bloc, dont la taille peut être différente de lng.

def moyenneParBlocs(T, lng):
    """
    Retourne un tableau dont les ``lng`` premières valeurs sont égales à la
    moyenne des ``lng`` première valeurs de ``T``, les ``lng`` suivantes sont
    égales à la moyenne des ``lng`` valeurs suivantes de ``T`` et ainsi de
    suite.
    """
    res = []
    for i in range(0, len(T), lng):
        taille_bloc = lng     # modifier pour gérer le dernier bloc
        moyenne = sum(T[i:i+lng]) // taille_bloc
        res.extend([moyenne]*taille_bloc)
    return res

1. Écrivez la procédure suivante :

   def testCompresseMoyenne(fichier, lng):
       """
       Charge l'image contenu dans le fichier et
         - affiche la taille de l'image (sous forme de chaine)
         - affiche la taille de l'image compressée (sous forme de tableau
           d'octets)
         - simplifie l'image en remplaçant les blocs par leurs moyennes
         - affiche la taille de l'image simplifiée (sous forme de chaine)
         - affiche la taille de l'image simplifiée compressée (sous forme
           de tableau d'octets)
         - sauve l'image simplifiée dans un fichier "...-lng.ppm"
       """
   

   Les fonctions fournies compresse et decompresse permettent de compresser/décompresser une chaine de caractères (str) et produisent un tableau d'octets (bytearray). Ces fonctions utilisent une variante de l'algorithme LZ78 étudié au TP2.

   Par exemple sur l'un des fichiers du TP1:

   >>> testCompresseMoyenne("vague.ppm", 8)
   image :                                     1901226
   image compressée :                           511636
   image après simplification :                1903335
   image après simplification compressée :      113996
   

   L'image obtenue ressemble alors à

   

2. Exécutez le code suivant :

   >>> testCompresseMoyenne("lac.ppm", 5)
   ???
   
   >>> testCompresseMoyenne("lac.ppm", 8)
   ???
   
   >>> testCompresseMoyenne("lac.ppm", 20)
   ???
   
   

   Observez les images obtenues dans les fichiers lac-5.ppm, lac-8.ppm et lac-20.ppm.

   • Que pouvez-vous dire de la taille de l'image une fois compressée en fonction de la taille des blocs ?

   • Que pouvez-vous dire de la qualité visuelle de l'image obtenue en fonction de la taille des blocs ?

   Inscrivez vos observations dans votre fichier.

Écrivez la fonction changeBase qui prend en argument

• un vecteur (x₁, ..., x_k)

• une base (c'est à dire une liste de vecteurs) v₁, ..., v_k

et qui calcule le nouveau vecteur x₁*v₁ + ... + x_k * v_k.

def changeBase(v, B):
    """
    calcule les coordonnées du vecteur ``v`` dans la base ``B``
    Note : la taille de ``v`` doit être égale à la taille de ``B`` !
    """

               [ 1, 1, 0 |
 (2, 0, -1) x  | 1, 0, 1 | = (2, 1, -1)
               | 0, 1, 1 ]

Vérifiez que votre fonction changeBase produit bien le même résultat que les exemples précédents.

Dans le langage de l'algèbre linéaire, la matrice "escalier"

   [ 1, 1, 1, 1, 1, 1, 1, 1  |
   | 0, 1, 1, 1, 1, 1, 1, 1  |
   | 0, 0, 1, 1, 1, 1, 1, 1  |
   | 0, 0, 0, 1, 1, 1, 1, 1  |
   | 0, 0, 0, 0, 1, 1, 1, 1  |
   | 0, 0, 0, 0, 0, 1, 1, 1  |
   | 0, 0, 0, 0, 0, 0, 1, 1  |
   | 0, 0, 0, 0, 0, 0, 0, 1  ]

est inversible et a pour inverse la matrice

   [ 1, -1,  0,  0,  0,  0,  0,  0  |
   | 0,  1, -1,  0,  0,  0,  0,  0  |
   | 0,  0,  1, -1,  0,  0,  0,  0  |
   | 0,  0,  0,  1, -1,  0,  0,  0  |
   | 0,  0,  0,  0,  1, -1,  0,  0  |
   | 0,  0,  0,  0,  0,  1, -1,  0  |
   | 0,  0,  0,  0,  0,  0,  1, -1  |
   | 0,  0,  0,  0,  0,  0,  0,  1  ]

1. Écrivez la fonction baseEscalierInverse qui calcule la base correspondante.

2. Vérifiez que cette base permet effectivement de retrouver un vecteur v à partir du résultat de changeBase(v, baseEscalier(len(v))).

1. Exécutez le code suivante et observez les images obtenues :

   >>> B = baseTFD(100)
   
   >>> barGraph(B[1]).save('TFD-1.ppm')
   >>> barGraph(B[51]).save('TFD-51.ppm')
   
   >>> barGraph(B[2]).save('TFD-2.ppm')
   >>> barGraph(B[52]).save('TFD-52.ppm')
   
   >>> barGraph(B[3]).save('TFD-3.ppm')
   >>> barGraph(B[53]).save('TFD-53.ppm')
   

2. Quelle est la forme générale des vecteurs de la base donnée par baseTFD ?

La fonction fournie TFD transforme un vecteur exprimé dans la base canonique dans le même vecteur exprimé dans la base produite par baseTFD.

Autrement dit, elle fait théoriquement la transformation inverse à changeBase(_, baseTFD).

Exécutez le code :

>>> v = Vector((1,2,3,4,5))

>>> u = TFD(v)

>>> B = baseTFD(5)
>>> v2 = changeBase(u, B)
>>> v == v2
False
>>> print(v2)
???

Observez le vecteur v2, comment le corriger pour avoir v == v2 ?

Écrivez la fonction inverseTFD(u) qui prend en entré un vecteur exprimé dans la base TFD et retourne le vecteur correspondant dans la base canonique dont toutes les coordonnées sont des entiers.

Testez votre code :

>>> v = randomVector(1000)
>>> u = TFD(v)
>>> v2 = inverseTFD(u)
>>> v == v2
True

Aide : la fonction round arrondi un flottant à l'entier le plus proche...

Programmez une fonction filtre qui remplace les petites valeurs d'un vecteur par 0.

Pour ceci, vous devez :

• créer un tableau auxiliaire contenant les valeurs absolues des valeurs de v (la fonction abs permet de calculer la valeur absolue d'un nombre)

• trier ce tableau (la méthode T.sort() permet de trier un tableau T)

• repérer la valeur seuil dans ce tableau qui sépare les valeur "hautes" (a conserver) des valeur "basses" (a remplacer par 0)

• créer le tableau résultat en recopiant les valeurs "hautes" du tableau initial et en remplaçant les valeurs "basses" par 0.

  def filtre(v, qualite):
      """
      renvoie une copie du vecteur ``v`` où les plus petites valeurs (en
      valeur absolue) sont remplacées par 0
      Par exemple,
        - si ``qualite`` est 0.5, les 50% des valeurs les plus petites sont
          remplacées par 0
        - si ``qualite`` est 0.9, les 10% des valeurs les plus petites sont
          remplacées par 0
        - ...
      """
  

Par exemple :

>>> v = Vector([27, -27, -6, -5, -16, -2, -56, 17, 5, 74, -9, -43, -19, 73, 8, 6])
>>> filtre(v, 0.5)
Vector([27, -27, 0, 0, 0, 0, -56, 17, 0, 74, 0, -43, -19, 73, 0, 0])

>>> filtre(Vector([0,1,2,3,4,5,6,7,8,9]), 0.7)
Vector([0, 0, 0, 3, 4, 5, 6, 7, 8, 9])

Inscrivez les réponses aux questions suivantes dans votre fichier :

• Que peut-on dire de la compression du vecteur filtré par rapport à celle du vecteur original ?

• De manière qualitative, que pouvez-vous dire du graphique à barre du vecteur filtré par rapport à celui du vecteur original ?

Écrivez la fonction la fonction encodeTFDParBlocs(v, lng, qualite). Cette fonction reprend les mêmes principes que la fonction moyenneParBlocs mais cette fois-ci, chaque bloc de données est obtenu en appliquant la fonction TFD sur un bloc, puis en remplaçant les petites valeurs par des 0 avec la fonction filtre.

def encodeTFDParBlocs(v, lng, qualite):
    """
    Applique TFD sur le vecteur ``v`` par blocs de taille ``lng``. Chaque
    bloc résultant est filtré avec la fonction ``filtre``.
    """

Exemples :

>>> v = Vector((1,2,3,4,5,6,7,8,9,10))
>>> v
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

>>> encodeTFDParBlocs(v, 4, 0.25)
(10, 0, 0, 0, 26, 0, 0, 0, 19, 0)

>>> encodeTFDParBlocs(v, 6, 0.6 )
(21, -6, -6, 0, -10, 0, 34, -4, 0, -4)

>>> encodeTFDParBlocs(v, 3, 0.3 )
(6, 0, 0, 15, 0, 0, 24, 0, 0, 10)

Écrivez la fonction decodeTFDParBlocs(u, lng) qui effectue la transformation inverse de la fonction encodeTFDParBlocs en appelant la fonction inverseTFD sur les blocs de taille lng.

>>> v = randomVector(10000)
>>> u = encodeTFDParBlocs(v, 100, 1)
>>> v2 = decodeTFDParBlocs(u, 100)
>>> v == v2
True

Écrivez la fonction testCompressionTFD, similaire à la fonction testCompresseMoyenne du début du TP.

def testCompresseTFD(fichier, lng, qualite):
    """
    Charge l'image contenu dans le fichier et
      - affiche la taille de l'image (sous forme de chaine)
      - affiche la taille de l'image compressée (sous forme de tableau
        d'octets)
      - simplifie l'image avec la fonction encodeTDFParBloc
      - affiche la taille de l'image simplifiée (sous forme de chaine)
      - affiche la taille de l'image simplifiée compressée (sous forme
        de tableau d'octets)
      - décode l'image simplifiée et la sauve dans un fichier
        "...TFD-lng-qualite.ppm"
    """

Exécutez la commande :

>>> testCompresseTFD( 'lac.ppm', 'tfd-100-05.ppm', 100, 0.1 )

1. Dans votre fichier, notez la taille de l'image compressée.

2. Déterminez la valeur de lng qui vous permet d'obtenir une taille comparable avec la fonction testeCompressionMoyenne.

3. Visuellement, quelle image vous parait le plus dégradée ? Notez vos observations dans votre fichier.

Après avoir transformé une image avec simplifieImageTFD, lorsqu'on veut reconstruire l'image il faut absolument connaitre le taille des blocs.

Écrivez une fonction qui, à partir d'un nom de fichier :

• charge l'image,

• appelle simplifieImageTFD pour la dégrader,

• converti le résultat en une chaine de caractères,

• écrire dans un fichier toutes les informations nécessaire pour reconstruire l'image. Ces informations doivent être compressées et écrite sous la forme d'une suite d'octets (bytearray).

Ensuite, écrivez une deuxième fonction qui, à partir d'un tel fichier reconstruit une image.

>>> im = Image.init_from_string(s) # Construction d'un image à partir de la chaine de caractères.
>>> im.save( 'out.ppm' )