Bonjour,
Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.
Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.
Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.
Voilà mon code:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image
Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"
#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)
Image.show(the_image)
# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")
nb_pixels=l*h
print("nombre de pixels :",nb_pixels)
#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))
# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'
Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'
Qu'à cela ne tienne, je trouve sur cette page :
https://www.education-du-numerique.fr/module-pil.html un exemple qui commence
par : from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes...)
je décommente donc la ligne '#from PIL import Image' et relance mon
script :
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'
(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)
J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!
Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.
Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax
Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.
Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).
PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance
Bonjour,
Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.
Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.
Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.
Voilà mon code:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image
Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"
#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)
Image.show(the_image)
# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")
nb_pixels=l*h
print("nombre de pixels :",nb_pixels)
#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))
# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'
Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'
Qu'à cela ne tienne, je trouve sur cette page :
https://www.education-du-numerique.fr/module-pil.html un exemple qui commence
par : from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes...)
je décommente donc la ligne '#from PIL import Image' et relance mon
script :
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'
(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)
J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!
Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.
Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax
Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.
Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).
PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance
Bonjour,
Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.
Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.
Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.
Voilà mon code:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image
Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"
#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)
Image.show(the_image)
# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")
nb_pixels=l*h
print("nombre de pixels :",nb_pixels)
#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))
# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'
Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'
Qu'à cela ne tienne, je trouve sur cette page :
https://www.education-du-numerique.fr/module-pil.html un exemple qui commence
par : from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes...)
je décommente donc la ligne '#from PIL import Image' et relance mon
script :
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'
(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)
J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!
Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.
Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax
Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.
Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).
PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance
Lulu :Bonjour,
Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.
Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.
Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.
Voilà mon code:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image
Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"
#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)
Image.show(the_image)
# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")
nb_pixels=l*h
print("nombre de pixels :",nb_pixels)
#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))
# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'
Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'
Qu'à cela ne tienne, je trouve sur cette page :
https://www.education-du-numerique.fr/module-pil.html un exemple qui commence
par : from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes...)
je décommente donc la ligne '#from PIL import Image' et relance mon
script :
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'
(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)
J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!
Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.
Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax
Là vous avez simplement oublié une parenthèse dans le print() dans
l'except'.
Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.
Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).
PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance
Vous avez juste un problème avec la structure de PIL et PIL.Image en
particulier. new, show et open sont des fonctions de PIL.Image.
Il n'y a aucune raison de simplifier par des imports, des imports *
/a fortiori/ , c'est même néfaste,
en particulier aviez-vous vous-même bien vu que le open était un
PIL.Image.open par la magie des imports ?
Donc juste un
import sys
from PIL import Image
puis:
try:
the_image=Image.open(Fichier_Image).convert("RGB")
except:
print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?")
sys.exit(1)
...
the_image.show()
( ou Image._show(the_image) )
...
the_image_ndg=Image.new("RGB", (l, h), "white")
( ou the_image_ndg=Image.new("RGB", (l, h)) )
Lulu :
Bonjour,
Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.
Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.
Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.
Voilà mon code:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image
Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"
#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)
Image.show(the_image)
# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")
nb_pixels=l*h
print("nombre de pixels :",nb_pixels)
#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))
# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'
Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'
Qu'à cela ne tienne, je trouve sur cette page :
https://www.education-du-numerique.fr/module-pil.html un exemple qui commence
par : from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes...)
je décommente donc la ligne '#from PIL import Image' et relance mon
script :
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'
(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)
J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!
Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.
Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax
Là vous avez simplement oublié une parenthèse dans le print() dans
l'except'.
Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.
Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).
PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance
Vous avez juste un problème avec la structure de PIL et PIL.Image en
particulier. new, show et open sont des fonctions de PIL.Image.
Il n'y a aucune raison de simplifier par des imports, des imports *
/a fortiori/ , c'est même néfaste,
en particulier aviez-vous vous-même bien vu que le open était un
PIL.Image.open par la magie des imports ?
Donc juste un
import sys
from PIL import Image
puis:
try:
the_image=Image.open(Fichier_Image).convert("RGB")
except:
print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?")
sys.exit(1)
...
the_image.show()
( ou Image._show(the_image) )
...
the_image_ndg=Image.new("RGB", (l, h), "white")
( ou the_image_ndg=Image.new("RGB", (l, h)) )
Lulu :Bonjour,
Je veux faire quelque chose qui me paraît simple, mais je m'arrache les
cheveux depuis plusieurs heures parce que des fonctions python sont
indisponibles ou causent des erreurs.
Je veux ouvrir une image PNG en RGB, créer une nouvelle image de la même
taille, lire la valeur RGB de l'image originale (getpixel), modifier la
valeur du pixel (niveaux de gris, noir et blanc, négatif, etc.) et
écrire le nouveau pixel (putpixel) dans l'image créée en mémoire avant
de l'afficher.
Évidemment, comme j'apprends "sur le tas" (PDF imprimé, exemples péchés
sur le web), je dois commettre des erreurs grossières : merci de
m'indiquer lesquelles.
Voilà mon code:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#import sys
from PIL.Image import *
#from PIL import Image
#from PIL import *
#import PIL
#import PIL.Image
Fichier_Image="Les_Horribles_Cernettes.png"
#Fichier_Image="avengers-endseries-comics-png-475.png"
#try:
the_image=open(Fichier_Image).convert("RGB")
#except:
#print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?"
#sys.exit(1)
Image.show(the_image)
# l = largeur en pixel de l'image
# h = hauteur en pixel de l'image
(l, h) = the_image.size
print("taille de l'image :",l,"px *",h,"px")
nb_pixels=l*h
print("nombre de pixels :",nb_pixels)
#creation de l'image en niveau de gris
the_image_ndg=Image.new("RGB",(l,h))
# pour y variant de 0 à h-1
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
#print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Tel quel, mon code affiche bien l'image des horribles Cernettes, mais j'ai
une erreur:
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 31, in <module>
the_image_ndg=Image.new("RGB",(l,h))
AttributeError: type object 'Image' has no attribute 'new'
Je comprends que la fonction 'new' n'est pas présente dans le module
'PIL.Image'
Qu'à cela ne tienne, je trouve sur cette page :
https://www.education-du-numerique.fr/module-pil.html un exemple qui commence
par : from PIL.Image import *
from PIL import Image
(au passage, si on peut m'expliquer la différence entre ces deux lignes...)
je décommente donc la ligne '#from PIL import Image' et relance mon
script :
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 20, in <module>
Image.show(the_image)
AttributeError: module 'PIL.Image' has no attribute 'show'
(J'ai essayé toutes les combinaisons possibles 'PIL.Image.show',
'Image.PIL.show', 'PIL.show' avec toujours des erreurs)
J'en conclue (faussement, j'en suis sûr), que je peux soit afficher une
image, soit en créer une, mais pas les deux en même temps !!
Petite bizarrerie au passage: bien que mon fichier soit en RGB (vérifié
grâce à ImageMagick), je suis contraint d'ouvrir le fichier en ajoutant
'.convert("RGB"), sinon getpixel ne me retourne qu'une valeur entière au
lieu d'une liste de trois valeurs.
Deuxième bizarrerie : je veux interrompre mon script s'il ne trouve pas
l'image, donc j'importe 'sys' (tiré d'un exemple trouvé sur le web) et
j'ai cette erreur :
File "img_niveau_de_gris.py", line 18
sys.exit(1)
^
SyntaxError: invalid syntax
Là vous avez simplement oublié une parenthèse dans le print() dans
l'except'.
Je tourne avec python3 version 3.6.8 sur une Linux Mint à jour.
Merci de m'éclairer sur l'erreur que je commets (et de m'excuser pour la
trivialité de celle-ci, parce qu'elle doit vous paraître énorme).
PS : Je ne veux pas de solution à base de numpy ou autre matplot car je
dois rester leplus simple possible sans aucun impératif de performance
Vous avez juste un problème avec la structure de PIL et PIL.Image en
particulier. new, show et open sont des fonctions de PIL.Image.
Il n'y a aucune raison de simplifier par des imports, des imports *
/a fortiori/ , c'est même néfaste,
en particulier aviez-vous vous-même bien vu que le open était un
PIL.Image.open par la magie des imports ?
Donc juste un
import sys
from PIL import Image
puis:
try:
the_image=Image.open(Fichier_Image).convert("RGB")
except:
print("Erreur : le fichier ",Fichier_Image," exsite-t-il ?")
sys.exit(1)
...
the_image.show()
( ou Image._show(the_image) )
...
the_image_ndg=Image.new("RGB", (l, h), "white")
( ou the_image_ndg=Image.new("RGB", (l, h)) )
Le 14-08-2019, Pierre Maurette a écrit :Lulu :
0K
Un grand merci pour votre aide.
J'ai donc un script qui ouvre une image, qui l'affiche, qui lit la valeur
(R,G,B) de chacun des pixels et qui créé trois images dans lesquelles
écrire (du moins pas d'erreur à l'exécution de
'the_image_ndg=Image.new("RGB",(l,h))'
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
J'ai ça dans ma boucle :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
Image.putpixel(the_image_ndg, (x,y), gris)
Image._show(the_image_ndg)
Le 14-08-2019, Pierre Maurette <maurette.pierre@free.fr> a écrit :
Lulu :
0K
Un grand merci pour votre aide.
J'ai donc un script qui ouvre une image, qui l'affiche, qui lit la valeur
(R,G,B) de chacun des pixels et qui créé trois images dans lesquelles
écrire (du moins pas d'erreur à l'exécution de
'the_image_ndg=Image.new("RGB",(l,h))'
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
J'ai ça dans ma boucle :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
Image.putpixel(the_image_ndg, (x,y), gris)
Image._show(the_image_ndg)
Le 14-08-2019, Pierre Maurette a écrit :Lulu :
0K
Un grand merci pour votre aide.
J'ai donc un script qui ouvre une image, qui l'affiche, qui lit la valeur
(R,G,B) de chacun des pixels et qui créé trois images dans lesquelles
écrire (du moins pas d'erreur à l'exécution de
'the_image_ndg=Image.new("RGB",(l,h))'
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
J'ai ça dans ma boucle :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
for y in range(h):
# pour x variant de 0 à l-1
for x in range(l):
# deux moyens d'obtenir la couleur RGB d'un pixel, pourvu qu'on
# ait "converti" l'image à l'ouverture : .convert("RGB")
# couleur = Image.getpixel(the_image, (x,y))
# print(x,y,"pixel =",couleur)
(rouge, vert, bleu) = the_image.getpixel((x,y))
print(x,y," : couleur RGB =(",rouge,",",vert,",",bleu,")")
gris=int(0.11*rouge + 0.83*vert + 0.06*bleu)
if gris < 128:
noir_ou_blanc=0
else:
noir_ou_blanc%5
rouge_sombre = rouge // 2
vert_sombre = vert // 2
bleu_sombre = bleu // 2
Image.putpixel(the_image_ndg, (x,y), gris)
Image._show(the_image_ndg)
Le 14-08-2019, Lulu a écrit :Le 14-08-2019, Pierre Maurette a écrit :Lulu :
0K
Un grand merci pour votre aide.
[...]
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
[...]
Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
Le 14-08-2019, Lulu <lulu042@fry.fr.invalid> a écrit :
Le 14-08-2019, Pierre Maurette <maurette.pierre@free.fr> a écrit :
Lulu :
0K
Un grand merci pour votre aide.
[...]
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
[...]
Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
Le 14-08-2019, Lulu a écrit :Le 14-08-2019, Pierre Maurette a écrit :Lulu :
0K
Un grand merci pour votre aide.
[...]
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
[...]
Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
Le 14-08-2019, Lulu a écrit :Le 14-08-2019, Pierre Maurette a écrit :Lulu :
0K
Un grand merci pour votre aide.
[...]
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
[...]
Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
Le 14-08-2019, Lulu <lulu042@fry.fr.invalid> a écrit :
Le 14-08-2019, Pierre Maurette <maurette.pierre@free.fr> a écrit :
Lulu :
0K
Un grand merci pour votre aide.
[...]
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
[...]
Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
Le 14-08-2019, Lulu a écrit :Le 14-08-2019, Pierre Maurette a écrit :Lulu :
0K
Un grand merci pour votre aide.
[...]
mais la ligne 'Image.putpixel(the_image_ndg, (x,y), gris)' plante :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 63, in <module>
Image.putpixel(the_image_ndg, (x,y), gris)
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
[...]
Corrigé en 'Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))'
mais toujours la même erreur :
taille de l'image : 585 px * 473 px
nombre de pixels : 276705
0 0 : couleur RGB =( 158 , 156 , 139 )
gris = 155 ///
noir_ou_blanc = 255 ///
couleur RGB sombre ( 79 , 78 , 69 )
Traceback (most recent call last):
File "img_niveau_de_gris.py", line 66, in <module>
Image.putpixel(the_image_ndg, (x,y), (gris,gris,gris))
AttributeError: module 'PIL.Image' has no attribute 'putpixel'
Lulu :
[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).
Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html
Dans ce module, des fonctions et une classe (un objet): Image. Dans
la même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-class
C'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image
Parmi les fonctions du module (PIL.Image): open, new, etc.
from PIL import Image
dir(Image)
Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.
Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.
Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)
theimage1.putpixel(blah)
theimage2.show()
Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)
Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.
Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.
Pourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire import builtins puis builtins.open(), il est clair que c'est
débile, ça casse les habitudes, les templates, le copier-coller de
code, ça fait chier le lecteur du code, et sans doute bien d'autres
choses.
Lulu :
[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).
Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html
Dans ce module, des fonctions et une classe (un objet): Image. Dans
la même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-class
C'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image
Parmi les fonctions du module (PIL.Image): open, new, etc.
from PIL import Image
dir(Image)
Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.
Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.
Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)
theimage1.putpixel(blah)
theimage2.show()
Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)
Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.
Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.
Pourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire import builtins puis builtins.open(), il est clair que c'est
débile, ça casse les habitudes, les templates, le copier-coller de
code, ça fait chier le lecteur du code, et sans doute bien d'autres
choses.
Lulu :
[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).
Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html
Dans ce module, des fonctions et une classe (un objet): Image. Dans
la même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-class
C'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image
Parmi les fonctions du module (PIL.Image): open, new, etc.
from PIL import Image
dir(Image)
Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.
Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.
Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)
theimage1.putpixel(blah)
theimage2.show()
Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)
Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.
Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.
Pourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire import builtins puis builtins.open(), il est clair que c'est
débile, ça casse les habitudes, les templates, le copier-coller de
code, ça fait chier le lecteur du code, et sans doute bien d'autres
choses.
Le 15-08-2019, Pierre Maurette a écrit :Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).
0K. J'avais un peu peur de cette histoire de fork...
Voullez-vous dire que lorsque je "cause" avec PIL, j'ai aussi accès aux
fonctions/modules/classes de Pillow ? (Est-ce newbie friendly ?)
Je lis dans les premières lignes du votre lien : « Pillow is the
_friendly_ PIL fork by... », donc a priori, « oui » à ma question.Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html
Je note la distinction que je dois faire entre "bibliothèque" et
"module"...Dans ce module, des fonctions et une classe (un objet): Image. Dans
la même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-classC'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image
0K.
(J'essaye de suivre)
Image est un module de la bibliothèque PIL
mais Image est aussi une "classe" du module Image de PIL.Parmi les fonctions du module (PIL.Image): open, new, etc.
Liste de fonctions que l'on obtient en tapant dans un shell bash :
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
'CONTAINER', 'CUBIC', 'DECODERS', 'DEFAULT_STRATEGY',
'DecompressionBombError', 'DecompressionBombWarning', 'ENCODERS',
'EXTENSION', 'EXTENT', 'FASTOCTREE', 'FILTERED', 'FIXED',
'FLIP_LEFT_RIGHT', 'FLIP_TOP_BOTTOM', 'FLOYDSTEINBERG', 'HAMMING',
'HAS_CFFI', 'HAS_PATHLIB', 'HUFFMAN_ONLY', 'ID', 'Image', 'ImageMode',
'ImagePointHandler', 'ImageTransformHandler', 'LANCZOS',
'LIBIMAGEQUANT', 'LINEAR', 'MAXCOVERAGE', 'MAX_IMAGE_PIXELS',
'MEDIANCUT', 'MESH', 'MIME', 'MODES', 'NEAREST', 'NONE', 'NORMAL',
'OPEN', 'ORDERED', 'PERSPECTIVE', 'PILLOW_VERSION', 'Path', 'QUAD',
'RASTERIZE', 'RLE', 'ROTATE_180', 'ROTATE_270', 'ROTATE_90', 'SAVE',
'SAVE_ALL', 'SEQUENCE', 'TRANSPOSE', 'TRANSVERSE', 'USE_CFFI_ACCESS',
'VERSION', 'WEB', '_E', '_ENDIAN', '_MAPMODES', '_MODEINFO',
'_MODE_CONV', '__builtins__', '__cached__', '__doc__', '__file__',
'__loader__', '__name__', '__package__', '__spec__',
'_apply_env_variables', '_check_size', '_conv_type_shape',
'_decompression_bomb_check', '_fromarray_typemap', '_getdecoder',
'_getencoder', '_getscaleoffset', '_imaging_not_installed',
'_initialized', '_plugins', '_show', '_showxv', '_wedge',
'alpha_composite', 'atexit', 'blend', 'builtins', 'coerce_e',
'collections', 'composite', 'core', 'deferred_error',
'effect_mandelbrot', 'effect_noise', 'eval', 'fromarray', 'frombuffer',
'frombytes', 'fromqimage', 'fromqpixmap', 'fromstring',
'getmodebandnames', 'getmodebands', 'getmodebase', 'getmodetype', 'i8',
'init', 'io', 'isImageType', 'isPath', 'isStringType',
'linear_gradient', 'logger', 'logging', 'math', 'merge', 'new',
'numbers', 'open', 'os', 'preinit', 'radial_gradient',
'register_decoder', 'register_encoder', 'register_extension',
'register_extensions', 'register_mime', 'register_open',
'register_save', 'register_save_all', 'registered_extensions', 'struct',
'sys', 'warnings']
Ce qui me permet de connaître les fonctions que je peux appeler depuis
le code que j'écris.Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.
Justement.
Je suis étonné de ne trouver dans la liste ci-dessus, ni convert, ni
putpixel, ni getpixel.
J'ai avancé...
Avant mon code ne marchait pas et je ne savais pourquoi.
Maintenant, mon code marche, mais je ne sais toujours pas pourquoi
puisque je ne vois, dans PIL.Image aucune fonction convert, putpixel ou
getpixel.Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.
Soit.Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)
OK.
'open' et 'new' font bien partie des fonctions du module Image de PIL.theimage1.putpixel(blah)
theimage2.show()
Par contre ni 'putpixel' ni 'show' ne sont listées par 'dir(Image)'.
Comment pourrais-je (autrement que par des exemples tirés du web)
savoir que ces fonctions sont disponibles ?Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)
Même remarque.Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.
Pas comprisPourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire import builtins puis builtins.open(), il est clair que c'est
débile, ça casse les habitudes, les templates, le copier-coller de
code, ça fait chier le lecteur du code, et sans doute bien d'autres
choses.
0K.
Bien compris.
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gréfrom PIL import Image
dir(PIL.Image)
dir(PIL.Image.Image)
Le 15-08-2019, Pierre Maurette <maurette.pierre@free.fr> a écrit :
Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).
0K. J'avais un peu peur de cette histoire de fork...
Voullez-vous dire que lorsque je "cause" avec PIL, j'ai aussi accès aux
fonctions/modules/classes de Pillow ? (Est-ce newbie friendly ?)
Je lis dans les premières lignes du votre lien : « Pillow is the
_friendly_ PIL fork by... », donc a priori, « oui » à ma question.
Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html
Je note la distinction que je dois faire entre "bibliothèque" et
"module"...
Dans ce module, des fonctions et une classe (un objet): Image. Dans
la même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-class
C'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image
0K.
(J'essaye de suivre)
Image est un module de la bibliothèque PIL
mais Image est aussi une "classe" du module Image de PIL.
Parmi les fonctions du module (PIL.Image): open, new, etc.
Liste de fonctions que l'on obtient en tapant dans un shell bash :
hugo@Minty ~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
'CONTAINER', 'CUBIC', 'DECODERS', 'DEFAULT_STRATEGY',
'DecompressionBombError', 'DecompressionBombWarning', 'ENCODERS',
'EXTENSION', 'EXTENT', 'FASTOCTREE', 'FILTERED', 'FIXED',
'FLIP_LEFT_RIGHT', 'FLIP_TOP_BOTTOM', 'FLOYDSTEINBERG', 'HAMMING',
'HAS_CFFI', 'HAS_PATHLIB', 'HUFFMAN_ONLY', 'ID', 'Image', 'ImageMode',
'ImagePointHandler', 'ImageTransformHandler', 'LANCZOS',
'LIBIMAGEQUANT', 'LINEAR', 'MAXCOVERAGE', 'MAX_IMAGE_PIXELS',
'MEDIANCUT', 'MESH', 'MIME', 'MODES', 'NEAREST', 'NONE', 'NORMAL',
'OPEN', 'ORDERED', 'PERSPECTIVE', 'PILLOW_VERSION', 'Path', 'QUAD',
'RASTERIZE', 'RLE', 'ROTATE_180', 'ROTATE_270', 'ROTATE_90', 'SAVE',
'SAVE_ALL', 'SEQUENCE', 'TRANSPOSE', 'TRANSVERSE', 'USE_CFFI_ACCESS',
'VERSION', 'WEB', '_E', '_ENDIAN', '_MAPMODES', '_MODEINFO',
'_MODE_CONV', '__builtins__', '__cached__', '__doc__', '__file__',
'__loader__', '__name__', '__package__', '__spec__',
'_apply_env_variables', '_check_size', '_conv_type_shape',
'_decompression_bomb_check', '_fromarray_typemap', '_getdecoder',
'_getencoder', '_getscaleoffset', '_imaging_not_installed',
'_initialized', '_plugins', '_show', '_showxv', '_wedge',
'alpha_composite', 'atexit', 'blend', 'builtins', 'coerce_e',
'collections', 'composite', 'core', 'deferred_error',
'effect_mandelbrot', 'effect_noise', 'eval', 'fromarray', 'frombuffer',
'frombytes', 'fromqimage', 'fromqpixmap', 'fromstring',
'getmodebandnames', 'getmodebands', 'getmodebase', 'getmodetype', 'i8',
'init', 'io', 'isImageType', 'isPath', 'isStringType',
'linear_gradient', 'logger', 'logging', 'math', 'merge', 'new',
'numbers', 'open', 'os', 'preinit', 'radial_gradient',
'register_decoder', 'register_encoder', 'register_extension',
'register_extensions', 'register_mime', 'register_open',
'register_save', 'register_save_all', 'registered_extensions', 'struct',
'sys', 'warnings']
Ce qui me permet de connaître les fonctions que je peux appeler depuis
le code que j'écris.
Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.
Justement.
Je suis étonné de ne trouver dans la liste ci-dessus, ni convert, ni
putpixel, ni getpixel.
J'ai avancé...
Avant mon code ne marchait pas et je ne savais pourquoi.
Maintenant, mon code marche, mais je ne sais toujours pas pourquoi
puisque je ne vois, dans PIL.Image aucune fonction convert, putpixel ou
getpixel.
Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.
Soit.
Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)
OK.
'open' et 'new' font bien partie des fonctions du module Image de PIL.
theimage1.putpixel(blah)
theimage2.show()
Par contre ni 'putpixel' ni 'show' ne sont listées par 'dir(Image)'.
Comment pourrais-je (autrement que par des exemples tirés du web)
savoir que ces fonctions sont disponibles ?
Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)
Même remarque.
Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.
Pas compris
Pourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire import builtins puis builtins.open(), il est clair que c'est
débile, ça casse les habitudes, les templates, le copier-coller de
code, ça fait chier le lecteur du code, et sans doute bien d'autres
choses.
0K.
Bien compris.
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gré
from PIL import Image
dir(PIL.Image)
dir(PIL.Image.Image)
Le 15-08-2019, Pierre Maurette a écrit :Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).[...]
Quelques indications qui devraient vous permettre de répondre vous-même
à vos questions.
Pour la doc, vous devriez partir de la doc officielle:
https://pillow.readthedocs.io/en/latest/
Vous voyez que Pillow est la distribution actuelle de l'historique
bibliothèque PIL (Pillow est un nom "commercial", c'est bien sous le
nom de PIL qu'elle sera importée, Pillow n'existe pas dans le code).
0K. J'avais un peu peur de cette histoire de fork...
Voullez-vous dire que lorsque je "cause" avec PIL, j'ai aussi accès aux
fonctions/modules/classes de Pillow ? (Est-ce newbie friendly ?)
Je lis dans les premières lignes du votre lien : « Pillow is the
_friendly_ PIL fork by... », donc a priori, « oui » à ma question.Dans cette bibliothèque, une foule de modules, dont un nous intéresse
particulièrement (et pour un temps exclusivement): Image :
https://pillow.readthedocs.io/en/latest/reference/Image.html
Je note la distinction que je dois faire entre "bibliothèque" et
"module"...Dans ce module, des fonctions et une classe (un objet): Image. Dans
la même page:
https://pillow.readthedocs.io/en/latest/reference/Image.html#the-image-classC'est peut être confusant, mais en définitive logique.
Un module: PIL.Image
Une classe: PIL.Image.Image
0K.
(J'essaye de suivre)
Image est un module de la bibliothèque PIL
mais Image est aussi une "classe" du module Image de PIL.Parmi les fonctions du module (PIL.Image): open, new, etc.
Liste de fonctions que l'on obtient en tapant dans un shell bash :
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
'CONTAINER', 'CUBIC', 'DECODERS', 'DEFAULT_STRATEGY',
'DecompressionBombError', 'DecompressionBombWarning', 'ENCODERS',
'EXTENSION', 'EXTENT', 'FASTOCTREE', 'FILTERED', 'FIXED',
'FLIP_LEFT_RIGHT', 'FLIP_TOP_BOTTOM', 'FLOYDSTEINBERG', 'HAMMING',
'HAS_CFFI', 'HAS_PATHLIB', 'HUFFMAN_ONLY', 'ID', 'Image', 'ImageMode',
'ImagePointHandler', 'ImageTransformHandler', 'LANCZOS',
'LIBIMAGEQUANT', 'LINEAR', 'MAXCOVERAGE', 'MAX_IMAGE_PIXELS',
'MEDIANCUT', 'MESH', 'MIME', 'MODES', 'NEAREST', 'NONE', 'NORMAL',
'OPEN', 'ORDERED', 'PERSPECTIVE', 'PILLOW_VERSION', 'Path', 'QUAD',
'RASTERIZE', 'RLE', 'ROTATE_180', 'ROTATE_270', 'ROTATE_90', 'SAVE',
'SAVE_ALL', 'SEQUENCE', 'TRANSPOSE', 'TRANSVERSE', 'USE_CFFI_ACCESS',
'VERSION', 'WEB', '_E', '_ENDIAN', '_MAPMODES', '_MODEINFO',
'_MODE_CONV', '__builtins__', '__cached__', '__doc__', '__file__',
'__loader__', '__name__', '__package__', '__spec__',
'_apply_env_variables', '_check_size', '_conv_type_shape',
'_decompression_bomb_check', '_fromarray_typemap', '_getdecoder',
'_getencoder', '_getscaleoffset', '_imaging_not_installed',
'_initialized', '_plugins', '_show', '_showxv', '_wedge',
'alpha_composite', 'atexit', 'blend', 'builtins', 'coerce_e',
'collections', 'composite', 'core', 'deferred_error',
'effect_mandelbrot', 'effect_noise', 'eval', 'fromarray', 'frombuffer',
'frombytes', 'fromqimage', 'fromqpixmap', 'fromstring',
'getmodebandnames', 'getmodebands', 'getmodebase', 'getmodetype', 'i8',
'init', 'io', 'isImageType', 'isPath', 'isStringType',
'linear_gradient', 'logger', 'logging', 'math', 'merge', 'new',
'numbers', 'open', 'os', 'preinit', 'radial_gradient',
'register_decoder', 'register_encoder', 'register_extension',
'register_extensions', 'register_mime', 'register_open',
'register_save', 'register_save_all', 'registered_extensions', 'struct',
'sys', 'warnings']
Ce qui me permet de connaître les fonctions que je peux appeler depuis
le code que j'écris.Parmi les fonctions (méthodes) de la classe (PIL.Image.Image): convert,
putpixel, getpixel, etc.
Justement.
Je suis étonné de ne trouver dans la liste ci-dessus, ni convert, ni
putpixel, ni getpixel.
J'ai avancé...
Avant mon code ne marchait pas et je ne savais pourquoi.
Maintenant, mon code marche, mais je ne sais toujours pas pourquoi
puisque je ne vois, dans PIL.Image aucune fonction convert, putpixel ou
getpixel.Donc, si je fais juste:
from PIL import Image
je n'ai importé que le module PIL.Image, en faisant simplement
l'économie d'avoir à saisir PIL.Image au profit de Image. La classe
PIL.Image.Image deviendra Image.Image, c'est tout.
Soit.Je vais donc avoir:
theimage1 = Image.open(blah)
theimage2 = Image.new(blahblah)
OK.
'open' et 'new' font bien partie des fonctions du module Image de PIL.theimage1.putpixel(blah)
theimage2.show()
Par contre ni 'putpixel' ni 'show' ne sont listées par 'dir(Image)'.
Comment pourrais-je (autrement que par des exemples tirés du web)
savoir que ces fonctions sont disponibles ?Mais je peux également faire:
Image.Image.putpixel(theimage1, blah)
Image.Image.show(theimage2)
Même remarque.Cas particulier:
Image._show(theimage2)
fonctionne. C'est un peu un hasard (ne fonctionne pas pour _convert,
qui n'existe pas), même si la pratique est habituelle. _show(unobjet)
est une fonction utile au module PIL.Image, l'underscore indique
qu'elle est vaguement "à usage interne" (peut-être héritée par
PIL.Image.Image, peu importe en fait), elle ne sera pas importée avec
*, ne sera pas documentée, etc. Mais reste parfaitement accessible.
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...Un code qui utilise des écritures exotiques (les "mais je peux
également...") masque un problème, et doit être corrigé.
Pas comprisPourquoi (par exemple)
from PIL.Image import *
est *réellement* bad ?
PIL.Image.open() devient open(). Hors open() est une fonction native
largement utilisée, elle sera masquée. Il ne sera pas rare d'avoir à
l'utiliser dans un code incluant PIL.Image.open(). On peut bien sûr
faire import builtins puis builtins.open(), il est clair que c'est
débile, ça casse les habitudes, les templates, le copier-coller de
code, ça fait chier le lecteur du code, et sans doute bien d'autres
choses.
0K.
Bien compris.
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gréfrom PIL import Image
dir(PIL.Image)
dir(PIL.Image.Image)
Lulu :Le 15-08-2019, Pierre Maurette a écrit :Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gréfrom PIL import Image
dir(PIL.Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]dir(PIL.Image.Image)
['_Image__transformer', '__array_interface__', '__class__', '__copy__',
[...]
Voilà ;-)
dir(Image) affiche la liste des _FONCTIONS_ du _MODULE_ PIL.Image
help(Image) (équivalente à votre 'dir(PIL.Image.Image)' affiche
Lulu :
Le 15-08-2019, Pierre Maurette <maurette.pierre@free.fr> a écrit :
Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
hugo@Minty ~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gré
from PIL import Image
dir(PIL.Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
dir(PIL.Image.Image)
['_Image__transformer', '__array_interface__', '__class__', '__copy__',
[...]
Voilà ;-)
dir(Image) affiche la liste des _FONCTIONS_ du _MODULE_ PIL.Image
help(Image) (équivalente à votre 'dir(PIL.Image.Image)' affiche
Lulu :Le 15-08-2019, Pierre Maurette a écrit :Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gréfrom PIL import Image
dir(PIL.Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]dir(PIL.Image.Image)
['_Image__transformer', '__array_interface__', '__class__', '__copy__',
[...]
Voilà ;-)
dir(Image) affiche la liste des _FONCTIONS_ du _MODULE_ PIL.Image
help(Image) (équivalente à votre 'dir(PIL.Image.Image)' affiche
Lulu :Le 15-08-2019, Pierre Maurette a écrit :Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gréfrom PIL import Image
dir(PIL.Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]dir(PIL.Image.Image)
['_Image__transformer', '__array_interface__', '__class__', '__copy__',
[...]
Voilà ;-)
Lulu :
Le 15-08-2019, Pierre Maurette <maurette.pierre@free.fr> a écrit :
Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
hugo@Minty ~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gré
from PIL import Image
dir(PIL.Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
dir(PIL.Image.Image)
['_Image__transformer', '__array_interface__', '__class__', '__copy__',
[...]
Voilà ;-)
Lulu :Le 15-08-2019, Pierre Maurette a écrit :Lulu :
Tout d'abord, merci de me répondre d'une réponse aussi détaillée, j'ai
juste un peu peur que ce ne soit pas à la portée d'un newbie de mon
espèce (but i'm working hard).
~ $ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.from PIL import Image
dir(Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]
0K pour "_show" qui apparaît avec 'dir (Image)'
Reste le problème de 'putpixel' et 'getpixel' qui n'apparaissent pas
comme fonction du module Image de PIL...
J'ai peur d'abuser de votre temps, mais si vous trouvez moyen de
répondre à mes interrogations, je vous en serais gréfrom PIL import Image
dir(PIL.Image)
['ADAPTIVE', 'AFFINE', 'ANTIALIAS', 'BICUBIC', 'BILINEAR', 'BOX',
[...]dir(PIL.Image.Image)
['_Image__transformer', '__array_interface__', '__class__', '__copy__',
[...]
Voilà ;-)