Traitement d’images (1)

cm 2020-05-06 capture lumni

On se base comme prévu sur cette vidéo de la chaîne « LuMnI » de France Télévisions spéciale confinement qi était à visionner pour ce jour  pour :

  • réviser ainsi les listes,
  • et les listes de listes, ça vous rappellera notre « projetLaby » 😉
  • suivre l’introduction aux images numériques, des souvenirs 🙂
  • il fallait taper tous les codespython dans votre éditeur favori : on partira de là lundi pour un peu de traitement d’image !

Sur discord, on génère

  • une petite image pgm :cm 2020-05-11 test1 pgm zoomée
    ##########################
    # ISSU DE LA VIDEO LUMNI #
    ##########################
    
    # print(L[1]) # [235, 125, 78]
    # print(L[1][2]) # 78
    """print(L)
    for y in range(hauteur):
        for x in range(largeur):
            print(L[y][x])"""
    
    ########################
    # DEBUT DES NOUVEAUTES #
    ########################
    
    L = [[12, 248, 56], [235, 125, 78]]
    
    hauteur = len(L) # 2 lignes
    largeur = len(L[0]) # 3 colonnes
    
    fichier = open("test1.pgm", 'w') # = with open as fichier
    fichier.write("P2\n")
    fichier.write("# fichier test pour le cours de NSI :)\n")
    fichier.write(str(largeur) + ' ' + str(hauteur) + "\n")
    fichier.write("255\n")
    for y in range(hauteur):
        for x in range(largeur):
            fichier.write(str(L[y][x]) + ' ')
    fichier.close()
    
  • une petite image ppm et sa négative :cm 2020-05-11 test3 ppm et négatif zoomées
    def image_ppm(nom_de_fichier, L):
        '''
            Cette fonction attend en paramètre d'entrée :
            - un nom_de_fichier (chaîne de caractères)
            - une liste de liste de triplets (r, v, b) ou pixels
    
            Elle enregistre un fichier avec le bon nom
            et les bons pixels au format ppm
        '''
        # dimensions
        hauteur = len(L) # nb lignes
        largeur = len(L[0]) # nb colonnes
        # ouverture du fichier en écriture
        fichier = open(nom_de_fichier, 'w') # = with open as fichier
        # entête du fichier
        fichier.write("P3\n")
        fichier.write("# fichier test pour le cours de NSI (avec de belles couleurs)\n")
        fichier.write(str(largeur) + ' ' + str(hauteur) + "\n")
        fichier.write("255\n")
    
        # parcours de la liste de listes de pixels et écriture des trois
        # composantes r, v et b avec une boucle :
        # pour i == 0 on traite le rouge
        # pour i == 1 on traite le vert
        # pour i == 2 on traite le bleu
    
        for y in range(hauteur):
            for x in range(largeur):
                for i in range(3):
                    fichier.write(str(L[y][x][i]) + ' ')
    
        # fermeture du fichier ainsi enregistré
        fichier.close()
    
    def negatif(L):
        '''
            Cette fonction attend en paramètre d'entrée
            une liste de liste de triplets (r, v, b) ou pixels
    
            Elle renvoie une autre liste de mêmes dimensions
            avec les pixels correspondant au négatif
        '''
        # dimensions
        hauteur = len(L) # nb lignes
        largeur = len(L[0]) # nb colonnes
    
        # création d'une liste de listes de bonnes tailles
        # avec des pixels pour l'instant noirs
        # (Liste en compréhension)
        liste = [[0 for x in range(largeur)] for y in range(hauteur)]
    
        # parcours de la liste envoyée en argument
        for y in range(hauteur):
            for x in range(largeur):
                # récupération des pixels
                r, v, b = L[y][x]
                # calcul des négatifs
                r_n, v_n, b_n = 255 - r, 255 - v, 255 - b
                # enregistrement
                liste[y][x] = r_n, v_n, b_n
                # affichage
                print(r, v, b, "devient", r_n, v_n, b_n)
    
        # on renvoie la liste
        return liste
    
    # l'image initiale
    # [[rouge,      vert,       bleu],
    #  [jaune,      magenta,    cyan],
    #  [blanc,      noir,       gris]]
    pixels = [[(255, 0, 0), (0, 255, 0), (0, 0, 255)],
              [(255, 255, 0), (255, 0, 255), (0, 255, 255)],
              [(255, 255, 255), (0, 0, 0), (128, 128, 128)]]
    
    # enregistrement image initiale
    image_ppm("test3.ppm", pixels)
    
    # liste pour le négatif avec appel de la fonction
    pixels_negatifs = negatif(pixels)
    
    print(pixels_negatifs)
    # l'image négative
    # [[cyan,      magenta,   jaune],
    #  [bleu,      vert,      rouge],
    #  [noir,      blanc,     gris]]
    
    # enregistrement image négative
    image_ppm("negatif_test_3.ppm", pixels_negatifs)

Formats d’image ?

On l’avait déjà fait, mais on a discuté :

  • de ces formats pgm et ppm de type ASCII non compressés très voraces en octets (6 par pixel plus l’entête !),
  • du format compressé avec perte jpg très utilisé pour les photos,
  • du format compressé sans perte png très utilisé sur internet et qui de plus gère la transparence,
  • du vieux format gif avec moins de couleurs et une bonne compression et de la transparence mais qui survit surtout grâce à sa fonctionnalité de « gif animé » très en vogue encore,

A faire pour mercredi :

  • une fonction sur la base de celle faite pour les « négatifs » qui :
    • parcourt l’image,
    • garde les pixels rouges,
    • met tous les autres en niveau de gris en calculant la moyenne des intensités rouge, vert et bleu.
  • Une fonction « seuil » comme sur la vidéo.
  • Installer la bibliothèque « pillow »
    pip install pillow

Correction du 13 mai :

cm 2020-05-13 que le rouge et le reste en niveaux de gris et seuil ppm

pixels = [[(255, 0, 0), (0, 255, 0), (0, 0, 255)],
          [(255, 255, 0), (255, 0, 255), (0, 255, 255)],
          [(255, 255, 255), (0, 0, 0), (128, 128, 128)]]

def que_le_rouge_et_le_reste_en_niveaux_de_gris(L):
    '''
        Cette fonction attend en paramètre d'entrée
        une liste de liste de triplets (r, v, b) ou pixels
 
        Elle renvoie une autre liste de mêmes dimensions
        avec les pixels mis en niveaux de gris
        sauf 
    '''
    # dimensions
    hauteur = len(L) # nb lignes
    largeur = len(L[0]) # nb colonnes
 
    # création d'une liste de listes de bonnes tailles
    # avec des pixels pour l'instant noirs (0, 0, 0)
    # (Liste en compréhension)
    liste = [[(0, 0, 0) for x in range(largeur)] for y in range(hauteur)]
 
    # parcours de la liste envoyée en argument
    for y in range(hauteur):
        for x in range(largeur):
            # récupération des pixels
            r, v, b = L[y][x]
            if (r, v, b) == (255, 0, 0): # je garde le rouge
                liste[y][x] = 255, 0, 0
            else :
                # moyenne m
                m = (r + v + b) // 3
                # du gris
                liste[y][x] = m, m, m
                
                # affichage
                print(r, v, b, "devient", m, m, m)
 
    # on renvoie la liste
    return liste

# liste pour « que le rouge » avec appel de la fonction
pixels_que_le_rouge = que_le_rouge_et_le_reste_en_niveaux_de_gris(pixels)
print(pixels_que_le_rouge)

# enregistrement image « que le rouge »
image_ppm("negatif_que_le_rouge.ppm", pixels_que_le_rouge)

 
def image_seuil(L, seuil):
    '''
        Cette fonction attend en paramètre d'entrée
        une liste de liste de triplets (r, v, b) ou pixels
        et un entier seuil
        Elle renvoie une autre liste de mêmes dimensions
        avec les pixels blancs ou noirs selon le seuil
    '''
    # dimensions
    hauteur = len(L) # nb lignes
    largeur = len(L[0]) # nb colonnes
 
    # création d'une liste de listes de bonnes tailles
    # avec des pixels pour l'instant noirs (0, 0, 0)
    # (Liste en compréhension)
    liste = [[(0, 0, 0) for x in range(largeur)] for y in range(hauteur)]
 
    # parcours de la liste envoyée en argument
    for y in range(hauteur):
        for x in range(largeur):
            # récupération des pixels
            r, v, b = L[y][x]
            # moyenne m
            m = (r + v + b) // 3
            if m > seuil:
                # du blanc
                liste[y][x] = 255, 255, 255
            else :
                liste[y][x] = 0, 0, 0
            
    # on renvoie la liste
    return liste

# liste pour « que le rouge » avec appel de la fonction
pixels_N_B = image_seuil(pixels, 127) # ou 42
print(pixels_N_B)

# enregistrement image « que le rouge »
image_ppm("seuil.ppm", pixels_N_B)

N'hésitez-pas à poser une question, ou faire avancer le schmilblick

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur la façon dont les données de vos commentaires sont traitées.