#!/usr/bin/env python
# coding: utf-8

# ![En tête](img/En_tete_general.png)
# 
# 
# *(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*
# 
# <span style="color: #9317B4"> Pour exécuter une saisie Python, sélectionner la cellule et valider avec </span><span style="color: #B317B4"><strong>SHIFT+Entrée</strong></span>.
# 

# # Applications de filtres sur une image
# 
# ### Activité sur le traitement d'images n°1

# Le but de cette activité est de programmer et d'appliquer des <strong>filtres</strong> sur des images :<br>
# L'application d'un filtre consiste à transformer une image en modifiant les composantes R,G,B de chacun de ses pixels.
# 

# <strong>1. Exécuter la cellule ci-dessous, qui permet :
# - d'ouvrir un fichier et de stocker l'image dans un objet Python de type Image;
# - d'afficher le format, le type de codage et la dimension de l'image;
# - d'afficher l'image.</strong>
# 
# NB: Vous pouvez réexécuter la cellule pour obtenir une autre image (choix aléatoire dans une bibliothèque d'images de la ville de Strasbourg).

# In[ ]:


# import du module permettant la gestion des images
from PIL import Image

#ouverture de l'image
from random import randint
Strasbourg = Image.open('img/Strasbourg/Strasbourg'+str(randint(1,10))+'.jpg')

#affichage du format, du type et de la dimension de l'image
print("Format:",Strasbourg.format,"\nMode:",Strasbourg.mode,"\nDimensions:",Strasbourg.size) ; 

#affichage de l'image
Strasbourg


# __2. Pour éclaircir une image, on peut augmenter de 50% les composantes couleurs de chaque pixel.__<br><br>
# $\;\;\;$__a. Suivre la vidéo suivante, qui détaille la fonction Python <mark>eclaircissement</mark> donnée ci-dessous.__<br><br>
# 
# 
# <video controls src="video/Traitement_image_filtre.mp4" width="960" height="540" />
# 
# 
# 

# $\;\;\;$__b. Exécuter les deux cellules ci-dessous, pour appliquer la fonction <mark>eclaircissement</mark> à l'image <mark>Strasbourg</mark>.__

# In[ ]:


def eclaircissement(im_originale):
    """
    fonction qui renvoie l'image im_originale éclaircie
    """
        
    # récupération des dimensions de l'image originale
    L,H = im_originale.size
    
    # création d'une image vierge, de même format et même dimension que l'image initiale
    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )
    
    # ouverture de l'accès aux pixels des deux images 
    pix_origine = im_originale.load()
    pix_modifie = im_modifiee.load()
    
    # on parcourt tous les pixels des images
    for x in range(L):
        for y in range(H):
            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original
            
            R = int(R*1.5)
            G = int(G*1.5)
            B = int(B*1.5)
            
            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié
    
    # on renvoie l'image modifiée
    return im_modifiee
    


# In[ ]:


eclaircissement(Strasbourg)


# __3. Pour assombrir une image, on peut diminuer de 50% les composantes couleurs de l'image d'origine.__<br>
# $\;\;\;$__Écrire une fonction Python <mark>assombrissement</mark> qui permet d'assombrir une image, puis tester cette fonction.__<br>
# $\;\;\;$Aide : On pourra commencer par effectuer un copier/coller de la fonction <mark>eclaircissement</mark> puis l'adapter.

# In[ ]:


# Ecrire ici la fonction assombrissement



# In[ ]:


# Tester ici un appel à la fonction assombrissement



# __4. Le principe du filtre rouge consiste à conserver les composantes rouges des pixels de l'image et à remplacer les autres par $0$.__<br><br>
# $\;\;\;$__a. Écrire une fonction Python <mark>filtre_R</mark> qui applique le filtre rouge à une image, puis tester cette fonction.__<br>
# 

# In[ ]:


# Écrire ici la fonction filtre_R



# In[ ]:


# Tester ici un appel à la fonction filtre_R



# $\;\;\;$__b. Écrire sur le même principe des fonctions Python <mark>filtre_G</mark> et <mark>filtre_B</mark> pour les filtres vert et bleu.__

# In[ ]:


# Écrire ici la fonction filtre_G



# In[ ]:


# Tester ici un appel à la fonction filtre_G



# In[ ]:


# Écrire ici la fonction filtre_B



# In[ ]:


# Tester ici un appel à la fonction filtre_B



# __5. Dans cette question, on souhaite convertir une image couleur en image en niveau de gris.__<br>
# $\;\;\;$__En RGB, on obtient un pixel en niveau de gris lorsque ses 3 composantes couleur sont égales.__<br><br>
# $\;\;\;$__a. Une première méthode consiste à remplacer chacune des composantes couleur d'un pixel par la moyenne des trois composantes initiales.__<br>
# $\;\;\;\;\;\;$__Écrire une fonction Python <mark>gris_rapide</mark> qui effectue cette conversion.__<br>
# $\;\;\;\;\;\;$__Tester cette fonction.__
# 

# In[ ]:


# Écrire ici la fonction gris_rapide



# In[ ]:


# Tester ici un appel à la fonction gris_rapide



# $\;\;\;$__b. La perception des composantes couleur par l'oeil humain diffère selon ces couleurs.__<br>
# $\;\;\;\;\;\;$__Ainsi, l'organisme CIE (Commission Internationale de l'Éclairage) préconise la méthode suivante pour convertir une image en niveau de gris :__<br>
# 
# <p style='background-color:#E0EDF0;'>
# <strong style='color:#84B8C5;'>Conversion en niveau de gris :</strong><br>
# On attribue à chaque composante couleur la valeur obtenue en additionnant :<br>
# 21,25% de la valeur de la composante rouge initiale;<br>
# 71,54% de la valeur de la composante verte;<br>
# 7,21% de la valeur de la composante bleue.
# </p>
# <br>
# 
# $\;\;\;\;\;\;$__Écrire une fonction Python <mark>gris_precis</mark> qui réalise cette conversion.__

# In[ ]:


# Écrire ici la fonction gris_precis



# In[ ]:


# Tester ici un appel à la fonction gris_precis



# __6. Pour obtenir le négatif d'une image, on remplace chaque composante de chaque pixel par la différence entre 255 et cette composante initiale.__<br>
# $\;\;\;$__Écrire une fonction Python <mark>negatif</mark> qui renvoie le négatif d'une image.__<br>
# 

# In[ ]:


# Écrire ici la fonction negatif



# In[ ]:


# Tester ici un appel à la fonction negatif



# __7. Dans cette question, on souhaite convertir l'image en noir et blanc (sans niveaux de gris).__<br><br>
# $\;\;\;$__a. Rappeler les codes R,G,B correspondant respectivement au noir et au blanc.__<br>
# $\;\;\;$__b. On décide qu'un pixel sera blanc si et seulement si la moyenne de ses composantes initiales est supérieure ou égale à 128.__<br>
# $\;\;\;\;\;\;$__Ecrire une fonction Python <mark>NB</mark> qui réalise cette transformation.__<br>
# 

# In[ ]:


# Écrire ici la fonction NB



# In[ ]:


# Tester ici un appel à la fonction NB



# <p style='background-color:#DDDDDD;'>
# Pour démarrer l'activité sur le traitement d'images n°2 (Composition d'images) : <a href="https://mybinder.org/v2/gh/PythonLycee/PyLyc/master?filepath=Traitement_images_2.ipynb"> Cliquer ici </a>
# </p>

# *(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*
#