Cape d'invisibilité en Python : HSV versus RGB..

Vidéo : démo de la cape d'invisibilité( https://youtu.be/RbZNrDFwvwI )

Somaire :

I   Import de modules préalables :

II  Introduction : Logique de la cape d'invisibilité :

    A.  Mise en scène :

    B.  Fenêtre de 'couleur' simplifiée : HSV versus RGB

III  Etude du script de la cape d'invisibilité :

    A.  De l'image à la vidéo modifiée : La boucle While

    B.  Logigramme des transformations RGB/HSV :

    C.  Etude de l'ensemble des pixels d'une image :

IV  Script (Python) de la cape d'invisibilité :

  Bug ? :

I. Import de modules préalables :

Exécutez la cellule ci-dessous ;
Si un message d'erreur, type module inexistant, apparait : il vous faudra les installer...
==> Si vous travaillez avec Edupython : faire : Outils->Outils->installer un module avec pip
(Normalement, Edupython 3.7.6 __ 2020 possède tous ces modules sauf imageio qu'il faudra 'piper')

import cv2
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import IPython.display
import imageio

II. Introduction : Logique de la cape d'invisibilité :

A. Mise en scène :

Travail : Proposez, dans la cellule 'proposition' ci-dessous, une stratégie numérique
permettant d'effacer une cape d'une couleur définie pour voir apparaître
ce qu'il y a derrière le personnage qui porte la cape...

Votre proposition :

(Solution : cliquez 1 fois ici) :

Il faut d'abord considérer qu'il y a 2 images avec le même décor :

* une image avec le décor sans personne devant,

* et, 'par dessus', une image extraite de la vidéo en cours du même décor avec un personnage mobile.
==> La logique consiste à tester la couleur de chaque pixel de l'image de la vidéo (640 x 480 = 307200 pixels testés tous les 1/24ème seconde !!!),

==> Si la couleur du pixel correspond à celle qui était recherchée, alors le script donne à ce pixel la même couleur que celui se trouvant à la même position dans l'image fixe du décor : le pixel a donc 'disparu'!

B. Fenêtre de 'couleur' simplifiée : HSV versus RGB

Le codage des couleurs des images numériques le plus courant est le codage RGB (ou RVB en français : Rouge, Vert Bleu):

--> La couleur d'un pixel est donc le résultat du mélange d'une quantité de rouge, de vert et de bleu :

Voici à quoi pourrait ressembler un objet contenant l'ensemble des couleurs selon le codage RGB :

Question : Regardez bien ce cube.. Imaginons que la cape d'invisibilité soit verte..
==> Est-ce que, selon vous, il sera aisé de choisir une teinte de couleur de cape (et toutes ses variations) à l'aide d'une seule grandeur (R, G, V) ?
Argumentez dans la cellule ci-dessous..

Votre réponse argumentée :

(Solution : cliquez 1 fois ici) :

Sur ce cube, on voit bien que toutes les briques un peu vertes du cube ne se trouvent pas uniquement sur une arrête du cube...

Autrement dit, de la même façon que le gilet vert de l'homme qui creuse contenait un peu de bleu et de rouge, cela veut dire que différents codages de vert nécessiteront des combinaisons sur les 3 axes !

Ce codage RGB est donc trop complexe pour dire au script de rendre la cape verte invisible !!

(Suite : cliquez 1 fois ici) :

Il nous faut donc utiliser un autre codage de couleurs pour notre image.. Le codage HSV.

HSV signifie Hue Saturation Value, ce qui se traduit par : Teinte, Saturation et Valeur.

==> Voici à quoi pourrait ressembler un objet contenant l'ensemble des couleurs selon le codage HSV :

Question : Regardez bien ce 'camembert'.. Imaginons que la cape d'invisibilité soit verte..
==> Est-ce que, selon vous, il sera plus aisé de choisir une teinte de couleur de cape (et toutes ses variations) à l'aide d'une seule grandeur (T, S ou V) ?
Argumentez dans la cellule ci-dessous..

Votre réponse argumentée :

(Solution : cliquez 1 fois ici) :

Sur ce camembert, on voit bien que Hue (la teinte de la couleur) suit un cercle qui conteint toutes les teintes..
Autrement dit, si on choist un angle de ce cercle on pourra globalement cibler une couleur.. et ses variations ?

A présent, imaginons qu'une partie de la cape soit dans l'ombre : on aura alors des verts foncés..

==> Donc il nous faut aussi paramétrer les valeurs S et V pour cibler toute notre cape !

MAIS.. au moins, la couleur globale de la cape est aisément définie à l'aide d'un seul paramètre : H.

Exercice :

Observez les 4 photos ci-dessous : Les contrôles Smin et Vmax ont été bloqués respectivement à 0 et 255 ; Seul le contrôle sur Hmax varie :
==> Vous pouvez observer que lorsque Hmax augmente des couleurs disparaissent : d'abord bleu, puis vert, puis rouge..
Essayez de reproduire ces captures d'écran en exécutant le script en fin de Notebook !

III. Etude du script de la cape d'invisibilité :

A. De l'image à la vidéo modifiée : La boucle While

Qu'est-ce qu'une vidéo si ce n'est une suite d'images !!

Autrement dit, losque votre webcam vous filme et que l'écran vous présente la vidéo en direct... En réalité, la webcam prend des photos qu'elle envoit, une à une, à votre ordinateur qui les présente rapidement dans une fenêtre... et ceci, tant que l'utilisateur le souhaite !

JUSTEMENT, tant que est codé, en Python, avec la fonction while :

Exercice :

1) Retrouver dans le script le ou les N° de ligne (sélectionnez la cellule du script-->barre bleue, et appuyez sur ' l ' ) où apparaissent une boucle while :
2) Quel argument contient cette fonction while, et qu'est-ce que cela veut dire ? :
3) Cette boucle while est-elle infinie ? Comment l'utilisateur peut en sortir ? Quelle instruction Python est utilisée ? :

(Solution : cliquez 1 fois ici) :

1) lignes : 10 et 36.
2) il contient l'argument True : cela veut dire : vrai
3) while cherche à savoir si son argument est vrai ; Donc le fait de lui donner l'argument déjà vrai (True) implique que le 'tant que' est infini. Pour sortir le sctript prévoit que l'utilisateur appuis sur une touche ce qui enclenche une instruction break qui interrompt la boucle.

B. Logigramme des transformations RGB/HSV :

Exercice : Etudiez le script pour répondre aux questions suivantes :

1) La 1ère fenêtre vidéo qui nous est présentée est en codage HSV, GBR ou RGB ?
2) Avant d'être enregistrée, l'image du décor subit des transformations de son codage couleur : lesquelles ?
3) Pour le 2ème flux vidéo, chaque image captée subit des transformations de son codage couleur avant qu'elles ne soient montrées : lesquelles ?
4) Pourquoi le dernier encodage couleur de cette image vidéo est important vis à vis des contrôles ?
5) Est-ce que finalement l'échange des pixels (vidéo/décor) se fait sous le même encodage couleur ? Si oui lequel ?
6) L'image vidéo qui nous est présentée a t-elle subi une dernière transformation d'encodage couleur ?

(Solution : cliquez 1 fois ici) :

1) Décor --> RGB --> Observation.
2) Décor --> RGB --> BGR --> HSV ==> Enregistrement.
3) Image_vidéo --> RGB --> BGR --> HSV.
4) Le contrôle des teintes des images, et donc leur transformation, est plus aisé en HSV qu'en RGB, donc on travaille en HSV.
5) Oui, le décor et l'image_vidéo sont alors encodé en HSV : donc les pixels échangés ont le même encodage !
6) L'image transformée qui était en HSV repasse en RGB pour nous être présentée.

C. Etude de l'ensemble des pixels d'une image :

Exercice : Etudiez le script pour répondre aux questions suivantes :

1) Etant donné que la méthode getpixel permet de récupérer le tupple (H,S,V) d'un pixel d'une image, expliquer l'intérêt d'utiliser préalablement la méthode Image.fromarray :
2) Expliquer ce que fait le script pour étudier chacun des pixels d'une image :
3) Pourquoi dans les boucles for, les bornes supérieures sont variable-1 ? :
4) Dans le cas où Smin est fixé à 0 et Vmax fixé à 255, comment interprétez vous la condition if ligne 55 ? Quel sera le résultat au niveau des couleurs de l'image visible lorsqu'on augmente progressivement Hmax ?
5) Proposez alors une solution qui permettrait d'éliminer que le vert mais pas le bleu ! :

(Solution : cliquez 1 fois ici) :

1) La variable nommée img1 n'est pas une image mais un tableau de valeurs. Sans doute que la méthode getpixel nécessite de travailler sur une image d'où la nécessité de transformer le tableau en image.
2) Le script va parcourir l'ensemble des pixels de l'image : pour cela, il fixe d'abord la variable hauteur de l'image, puis parcoure toutes les largeurs possibles, ensuite il implémente la hauteur et recommence : c'est une double boucle for intriquée.
3) Si la largeur est de 640 pixels, il faut se rappeler que l'indexation d'une suite d'éléments commence toujours par 0 : donc de 0 à 639 !
4) Si Smin est à 0 et Vmax à 255, les conditions sur S/Smin et V/Vmax seront toujours vérifiées. Donc les couleurs présentées dans l'image ne dépondront que du curseur Hmax : Dès lors, l'augmentation progressive du curseur Hmax entraîne la disparition progressive du bleu, puis du vert et enfin du rouge.
5) En gardant Smin à 0 et Vmax à 255, on pourrait tester la condition si H est compris entre 2 valeurs Hmax1 et Hmax2 qui encadre uniquement le vert.

IV. Script (Python) de la cape d'invisibilité :

--> Notice :

Lorsque vous lancez le script, faîtes en sorte de ne présenter que le décor à la caméra et appuyez sur ' p ' pour enregistrer le décor.
Puis la vidéo reprend et vous pouvez alors placer les curseurs de contrôle Hmax Smin et Vmax comme bon vous semble....
Pour sortir de la vidéo, appuyez sur ' q '

Si vous rencontrez un bug.. pas de panique : une solution se trouve en fin de Notebook.

###################################################
def sauvegarde_image(matrice):
    nom_format="Fondvisible.jpg"
    imageio.imwrite(nom_format, matrice[:, :]) # Enregistrement dans le dossier en cours de l'image 'matrice'
#####################################################
def trackChaned(x):
    pass
#####################################################
camera=cv2.VideoCapture(0) # Initiation de la caméra #0 pour la webcam intégrée, et 1 pour la webcam externe
while(True): 
    ret,img1=camera.read() # prise d'1 image par la caméra
    # Attention, img1 est en format : tableau : de pixels représentant l'image
    cv2.imshow("Enregistrement du Fond : -> Touche p", img1) # présentation de l'image dans 1 fenêtre avec 1 titre
    if(cv2.waitKey(1) ==ord("p")): # Condition : si on appuis sur la touche p
        capture=img1
        capture= cv2.cvtColor(capture, cv2.COLOR_RGB2BGR) # Passage du codage des couleurs de RGB à BGR
        capture= cv2.cvtColor(capture, cv2.COLOR_BGR2HSV) # Passage du codage des couleurs de BGR à HSV
        sauvegarde_image(capture) # Appel de la fonction (voir plus haut)
        break; 
camera.release() # Extinction de la caméra
cv2.destroyAllWindows() # Fermeture de la fenêtre (vidéo)
#####################################################
#####################################################
camera=cv2.VideoCapture(0) 
######## Ci-dessous : Construction de la fenêtre des curseurs de contrôle HSV #######
cv2.namedWindow("Controles :",1) # création d'1 fenêtre
cv2.resizeWindow("Controles :", (320,140)) # détermination de sa taille
cv2.moveWindow("Controles :", 973,50) # et de son positionnement
cv2.createTrackbar("Hmax=", "Controles :",0,180,trackChaned) #  Création d'une barre de contrôle de 0 à 180 nommée Hmax
cv2.createTrackbar("Smin=", "Controles :",0,255,trackChaned) #  ..
cv2.createTrackbar("Vmax=", "Controles :",0,255,trackChaned) #  ..
cv2.setTrackbarPos("Hmax=", "Controles :",0) # On impose le curseur à 0 pour Hmax
cv2.setTrackbarPos("Smin=", "Controles :",0) # ..
cv2.setTrackbarPos("Vmax=", "Controles :",255) # ..
######## Fin de paramétrage de la fenêtre des curseurs de contrôle HSV #######
while(True): 
    ret,img1=camera.read() # Attention, img1 est en format : tableau : de pixel représentant l'image
    img1= cv2.cvtColor(img1, cv2.COLOR_RGB2BGR)
    img1= cv2.cvtColor(img1, cv2.COLOR_BGR2HSV)
    Hmax=cv2.getTrackbarPos("Hmax=", "Controles :") # On récupère la position du curseur Hmax
    Smin=cv2.getTrackbarPos("Smin=", "Controles :") # ..
    Vmax=cv2.getTrackbarPos("Vmax=", "Controles :") # ..
##############
    img2 = Image.open('Fondvisible.jpg') # On ouvre, dans img2, le décor seul (en format image !)
    largeur = img1.shape[0] # on récupère la largeur de l'image vidéo
    hauteur = img1.shape[1] # et sa hauteur
    img1_img= Image.fromarray(img1) # Attention, on transforme le tableau de pixel d'img1 en image !
    for y in range (0, hauteur-1):
        for x in range (0,largeur-1):
            Codage_Couleur_pixel_video= img1_img.getpixel((y,x))# méthode getpixel récupère le tupple du codage couleur du
            # ..pixel à la position y,x de l'image.
            H=Codage_Couleur_pixel_video[0] # Accès au 1er élément du tupple
            S=Codage_Couleur_pixel_video[1] # ..
            V=Codage_Couleur_pixel_video[2] # ..
            if H<Hmax and S>Smin and V<Vmax: # Test du pixel vidéo par rapport aux contrôles 
                Codage_Couleur_pixel_fond= img2.getpixel((y,x))  
                Nouveau_H=Codage_Couleur_pixel_fond[0]
                Nouveau_S=Codage_Couleur_pixel_fond[1]
                Nouveau_V=Codage_Couleur_pixel_fond[2]
                img1_img.putpixel((y,x), (Nouveau_H,Nouveau_S,Nouveau_V)) # méthode putpixel pour imposer les couleurs
    img1 = np.array(img1_img) #attention, on retransforme l'image en tableau de pixels
    img1= cv2.cvtColor(img1, cv2.COLOR_HSV2RGB)
    cv2.imshow("Cape d invisibilite (vert) ; q pour sortir.", img1)
    if(cv2.waitKey(1) ==ord("q")):
        break;
camera.release()
cv2.destroyAllWindows()

Bug ? :

--> Activez (Enlever les # et exécutez) la cellule suivante.

# camera.release()
# cv2.destroyAllWindows()