Informatique au lycée Faustin Fleret

# script inversion_image_pgm.py
import imghdr

print("Inversion d'une image PGM en mode binaire à 256 niveaux de gris\n"))

NomFichierSource = 'image.pgm'
NomFichierDestination = 'imageInverse.pgm'

print('Fichier source :',NomFichierSource))
print('Fichier destination :',NomFichierDestination))

def Inversion(octet):
    # cette fonction fait une inversion du niveau de gris
    # 0 (noir)    -> 255 (blanc)
    # 255 (blanc) -> 0 (noir)
    return 255-octet

if imghdr.what(NomFichierSource)=='pgm':	# test du format de l'image
    FichierSource = open(NomFichierSource,'rb')
    TailleFichier = len(FichierSource.read())
    print('\nTaille du fichier (en octets) :',TailleFichier))

    Largeur = int(input('Largeur de l\'image (en pixels) ? '))
    Hauteur = int(input('Hauteur de l\'image (en pixels) ? '))
    NbPixel = Largeur*Hauteur

    TailleEntete = TailleFichier - Largeur*Hauteur

    FichierSource.seek(0)

    # extraction de l'en-tête
    # la variable Entete est une chaîne de caractères (type str)
    Entete = FichierSource.read(TailleEntete)

    # extraction des données
    # Data est une liste de nombre entiers (type list)
    # la fonction ord() retourne le contenu d'un octet sous forme d'un entier
    # ord('\xf3') -> 243
    Data = [ord(i) for i in FichierSource.read()]	# compréhension de listes

    FichierSource.close()

    if NbPixel == len(Data):
        print('Nombre de pixels :',Largeur*Hauteur)
        print("Nombre d'octets de données :",len(Data))
        print("Taille de l'en-tête :",TailleEntete)

        FichierDestination = open(NomFichierDestination,'wb')
        # écriture de l'en-tête du fichier destination
        FichierDestination.write(Entete)

        # écriture des données du fichier destination
        for i in Data:
            # la fonction chr() fait le contraire de la fonction ord()
            # chr(243) -> '\xf3'
            FichierDestination.write(chr(Inversion(i)))

        FichierDestination.close()
        print('Travail terminé !')

    else:
        print('Erreur dans la saisie des données !')

else:
    print("Ce n'est pas une image PGM !")

>>>
Inversion d'une image PGM en mode binaire à 256 niveaux de gris

Fichier source : image.pgm
Fichier destination : imageInverse.pgm

Taille du fichier (en octets) : 153654
Largeur de l'image (en pixels) ? 480
Hauteur de l'image (en pixels) ? 320
Nombre de pixels : 153600
Nombre d'octets de données : 153600
Taille de l'en-tête : 54
Travail terminé !

>>> print(Entete.encode('hex')) # contenu de l'en-tête en hexadécimal
50350a232043524541544f523a2047494d5020504e4d2046696c7465722056657273696f6e20312e310a343830203332300a3235350a
>>> print(Entete)       # contenu de l'en-tête en chaîne de caractères
P5
# CREATOR: GIMP PNM Filter Version 1.1
480 320
255

>>>

>>> print(Data[0],hex(Data[0]))     # premier octet : pixel en haut à gauche de l'image
153 0x99
>>> print(Data[1],hex(Data[1]))     # deuxième octet : pixel à droite du précédent
142 0x8e
>>> print(hex(Data[479]))   # 480ème octet : pixel en haut à droite
0xbf
>>> print(hex(Data[480]))   # 481ème octet : pixel de la deuxième ligne à gauche
0x92
>>> print(hex(Data[153599]))    # dernier octet : pixel en bas à droite de l'image (320ème ligne)
0x25

# Python 2.7
# PIL 1.1.7
# importation du module Image de la librairie PIL
from PIL import Image

# ouverture de l'image
img = Image.open('photo.jpg')
# affichage de l'image
img.show()
# affichage de la taille de l'image (en pixels)
print(img.size)
# conversion au format PPM (en couleur) et enregistrement de l'image
img.save('photo.ppm','PPM')
img.show()
# conversion en niveau de gris (pour obtenir le format PGM)
img0 = img.convert('L')
# enregistrement dans le fichier image.pgm
img0.save('image.pgm')
img0.show()

# retournement de l'image
img1 = img0.rotate(180)
# affichage et enregistrement de l'image retournée
img1.show()
img1.save('image_retourne.pgm')

# miroir horizontal
img2 = img0.transpose(Image.FLIP_LEFT_RIGHT)
img2.show()
img2.save('image_miroir_horizontal.pgm')

# miroir vertical
img3 = img0.transpose(Image.FLIP_TOP_BOTTOM)
img3.show()
img3.save('image_miroir_vertical.pgm')




>>>
(480, 320)

# script camenbert.py
# Python 2.7
# PIL 1.1.7
from PIL import Image,ImageDraw

# création d'une image 400x400 (fond blanc)
img = Image.new("RGB",(400,400),"#FFFFFF")

# création d'un objet Draw
dessin = ImageDraw.Draw(img)

# dessine un arc partiel et le remplit
dessin.pieslice((50,50,350,350),0,60,fill="blue")
dessin.pieslice((50,50,350,350),60,150,fill="gray")
dessin.pieslice((50,50,350,350),150,360,fill="red")

# dessine du texte
dessin.text((50,20),"Camenbert 2D",fill="red")

img.save("camenbert.png","PNG")
img.show()

>>>
Redimensionnement d'une image JPEG

Nom de l'image originale ? photo.jpg
Taille de l'image originale : (largeur, hauteur) = (1944, 2592)

Nouvelle taille :
Hauteur en pixels ? 800
Largeur en pixels : 600

Enregistrement de l'image redimensionnée
Nom de l'image redimensionnée ? photo_1.jpg
>>>

>>>
Nom du fichier ? disque.png

Largeur en pixels :  380
Hauteur en pixels :  250

Nombre de pixels (blanc) :  8820
Position du centre : x = 129.0 y = 100.0
Diamètre en pixels : 105.971565925
>>>