Commit 282a7f91 authored by Matthieu PERREIRA DA SILVA's avatar Matthieu PERREIRA DA SILVA
Browse files

Passage à plotly pour le TP2

parent 3994bbc9
Pipeline #33905 passed with stage
in 31 seconds
This diff is collapsed.
%% Cell type:markdown id: tags:
 
**Nom du / des étudiant(s)** : ETUDIANT 1 - ETUDIANT 2
 
%% Cell type:markdown id: tags:
 
# TP image - Classification d'images
 
Les TP de traitement d'images sont réalisés en Python3, à l'aide de la librairie [scikit-image](http://scikit-image.org/docs/stable/). Les tableaux utilisés (`ndarray`) par cette librairie pour manipuler les images proviennent de la librairie [numpy](https://docs.scipy.org/doc/). L'affichage des images et autres figures est réalisé grace à [matplotlib](https://matplotlib.org/contents.html). La documentation de ces trois librairies vous sera donc bien utile.
 
Dans ce TP, les questions seront indiquées dans un bloc **question**, et les réponses seront à donner dans le bloc **réponse** situé en dessous du bloc de question. Vos réponses sont à rédiger en [markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). Vous pourrez ainsi répondre non seulement avec du texte, mais aussi avec des tableaux et des images.
 
Ce TP est à réaliser en deux séances d'1h30.
 
**Remarque importante:** Les questions posées dans ce TP requièrent généralement des <u>réponses courtes mais justifées</u>. Un simple oui ou non ne nous est d'aucune utilité pour juger de votre compréhension de la question et de sa réponse...
 
**Autre remarque:** Il y a parfois plusieurs sous-questions dans une même question. <u>Pensez a répondre à toutes les sous-questions</u>.
 
%% Cell type:code id: tags:
 
``` python
%matplotlib inline
# la ligne précédente permet d'afficher les figures directement dans votre notebook
# si vous voulez des figures interactives et n'êtes PAS dans un notebook cocalc vous pouvez utiliser widget à la place d'inline
 
%config InlineBackend.figure_formats = {'png', 'retina'}
from skimage import data, filters, io
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np
import scipy.stats as stats
import math
from numba import jit
```
 
%% Cell type:markdown id: tags:
 
## Preliminaire : le code vectorisé
 
%% Cell type:markdown id: tags:
 
Dans cette petite manipulation préliminaire python, on examine deux façons d'écrire un algorithme de seuillage d'image. L'opération sur l'image considérée ici est un exemple simple quelconque, le sujet est la ** vectorisation de code **.
 
%% Cell type:code id: tags:
 
``` python
image = data.coins() # Une image avec des pieces de monnaie, fournie dans la librairie python
 
nb_lignes, nb_colonnes = image.shape
 
seuil=145
 
def seuillage_deroule(image): # La fonction naïve
image_seuillee = np.copy(image)
for i in range(nb_lignes):
for j in range(nb_colonnes):
if image[i,j]>seuil:
image_seuillee[i,j]=255
else:
image_seuillee[i,j]=0
return(image_seuillee)
 
def seuillage_vectorise(image): # La fonction moins naïve
image_seuillee = np.copy(image)
image_seuillee = image>seuil
return(image_seuillee)
 
@jit(nopython=False)
def seuillage_deroule_jit(image): # La fonction naïve en version compilée juste à temps (jit)
image_seuillee = np.copy(image)
for i in range(nb_lignes):
for j in range(nb_colonnes):
if image[i,j]>seuil:
image_seuillee[i,j]=255
else:
image_seuillee[i,j]=0
return(image_seuillee)
 
print ("Boucle déroulée")
%timeit image_seuillee = seuillage_deroule(image)
print ("\n \n Boucle déroulée en compilation juste à temps")
%timeit image_seuillee = seuillage_deroule_jit(image)
print ("\n \n Code vectorisé")
%timeit image_seuillee = seuillage_vectorise(image)
 
#pour pouvoir afficher l'image seuillée
image_seuillee = seuillage_vectorise(image)
 
plt.figure(figsize=(11,5))
plt.subplot(1,2,1)
plt.imshow(image, cmap = cm.Greys_r)
plt.title('Image originale')
plt.subplot(1,2,2)
plt.imshow(image_seuillee, cmap = cm.Greys_r)
plt.title('Image seuillée')
```
 
%% Output
 
Boucle déroulée
 
329 ms ± 80.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
243 ms ± 9.25 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
Boucle déroulée en compilation juste à temps
 
46.5 µs ± 7.91 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
147 µs ± 4.5 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
Code vectorisé
 
39.2 µs ± 7.72 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
22.4 µs ± 844 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
 
Text(0.5, 1.0, 'Image seuillée')
 
<Figure size 792x360 with 2 Axes>
 
%% Cell type:markdown id: tags:
 
**Question 1:**
* Que fait le code ci-dessus ?
* Quelle fonction de seuillage est plus facile à lire ?
* Laquelle est plus facile à maintenir ?
* Quel est le rapport (ratio) des temps d'execution entre les trois procédés ? (expliquer les raisons techniques)
 
 
%% Cell type:markdown id: tags:
 
**Réponse 1:** VOTRE REPONSE ICI
 
%% Cell type:markdown id: tags:
 
Le même principe s'applique pour des programmes en R, en Matlab, en Julia (un langage/environnement qui ressemble à python mais se donne pour objectif d'être rapide à l'execution comme du C http://julialang.org), même si ce dernier se donne pour objectif d'être aussi rapide pour l'écriture "déroulée" du code - car tous les algorithmes ne peuvent pas se vectoriser.
 
%% Cell type:markdown id: tags:
 
## Détection de contours
 
%% Cell type:markdown id: tags:
 
Cette section examine une manière simple de détecter des contours dans des images. Les contours peuvent ensuite servir à reconnaître l'objet selon sa forme, ou le point de vue 3D de la caméra sur cet objet, ou encore à faire un suivi de cet objet dans une séquence d'images.
 
On va utiliser la convolution de l'image avec des filtres de Sobel (deux filtres : un horizontal et un vertical) pour détecter la présence de contours.
 
%% Cell type:code id: tags:
 
``` python
 
from skimage import filters,feature
from skimage.color import rgb2gray
 
#im = data.coins() #enlever le commentaire pour utiliser cette image
im = rgb2gray(io.imread("polytech.jpg"))
#im = data.camera()
 
fig=plt.figure(figsize=(8,8))
plt.imshow(im, cmap = cm.Greys_r)
 
# Regarder si un filtrage passe-bas préalable améliore le résultat
# im=filters.gaussian(im, sigma=2)
 
seuil = 0.1
 
sx = filters.sobel_h(im)
ssx = abs(sx)>seuil
sy = filters.sobel_v(im)
ssy = abs(sy)>seuil
 
plt.figure(figsize=(10,10))
plt.subplot(2,2,1)
plt.imshow(sx, cmap = cm.Greys_r)
plt.subplot(2,2,2)
plt.imshow(ssx, cmap = cm.Greys_r)
plt.subplot(2,2,3)
plt.imshow(sy, cmap = cm.Greys_r)
plt.subplot(2,2,4)
plt.imshow(ssy, cmap = cm.Greys_r)
fig.tight_layout()
 
plt.figure(figsize=(10,10))
ss = np.maximum(ssx,ssy)
plt.imshow(ss, cmap = cm.Greys_r)
 
#from skimage.morphology import erosion, dilation, opening, closing
#from skimage.morphology import disk
 
#struct_elem = disk(4)
 
#dilated = dilation(ss, struct_elem)
#eroded = erosion(dilated, struct_elem)
 
#plt.subplot(3,2,6)
#plt.imshow(eroded, cmap = cm.Greys_r)
#plt.imshow(feature.canny(im), cmap = cm.Greys_r)
 
```
 
%% Output
 
<matplotlib.image.AxesImage at 0x7f9eb367b7f0>
<matplotlib.image.AxesImage at 0x7f27035b4ca0>