Comment faire pour vérifier si un fichier jpeg de l'image est en couleur ou en niveaux de gris en utilisant uniquement Python stdlib

Je dois écrire un cas de test en python afin de vérifier qu'une image jpg est en couleur ou en niveaux de gris. Quelqu'un peut s'il vous plaît laissez-moi savoir si il y a moyen de le faire avec l'installation de bibliothèques supplémentaires comme opencv?

Questions: a) Que les bibliothèques ne sont pas considérés comme des bibliothèques supplémentaires? NumPy/Scipy? b) voulez-vous simplement détecter des 2 vs 3 canaux et de l'utiliser comme vos critères de niveaux de gris ou vous avez 3 canal des images qui sont en fait des niveaux de gris dans l'apparence?
Nous n'avons que la version 2.6 de python sur notre linux postes de travail. Il y a des instructions strictes de ne pas utiliser les bibliothèques externes à écrire des cas de test. Donc nous n'avons pas les autorisations pour installer les bibliothèques. Nous avons des 3 canaux images qui sont en fait des niveaux de gris dans l'apparence.
Avez-vous des aucun moyen de l'ouverture d'une image en pixels? Si non cela va être un problème difficile.
Rançon: vous voulez dire que vous ne pouvez pas simplement faire confiance à la JPEG en-tête, compensé 6: nombre de composants (1 = niveau de gris, 3 = RGB) ?
Je suppose que les niveaux de gris des images Jpeg sont si rares que je ne me souvenais pas que c'était possible. Il y aura aussi des cas où une image en niveaux de gris est enregistré avec 3 composants.

OriginalL'auteur kadina | 2014-05-14

  1. 9

    Expansion @gat réponse:

    import Image

def is_grey_scale(img_path):
    img = Image.open(img_path).convert('RGB')
    w,h = img.size
    for i in range(w):
        for j in range(h):
            r,g,b = img.getpixel((i,j))
            if r != g != b: return False
    return True

    Fondamentalement, consultez chaque pixel pour voir si elle est en niveaux de gris (R == G == B)

    Juste une performance enhance pour des résultats rapides: depuis de nombreuses images en noir ou en blanc de la frontière, vous attendez plus rapide en cas de résiliation par échantillonnage aléatoire i,j-points de im et de les tester? Ou de l'utilisation de l'arithmétique modulo pour parcourir l'image. Si l'échantillonnage (sans remplacement) de 100 aléatoire i,j-points n'est pas concluante, puis il suffit de le scanner de façon linéaire. Ou peut-être varier la ligne de commande avec l'arithmétique modulo. Vous pouvez rassembler tout cela dans un personnalisé itérateur iter_pixels(im).
    Désolé. Le code est un échec quand j'ai essayé d'exécuter le script et c'est ce qui donne l'erreur @ r,g,b = im.getpixel((i,j)) TypeError: 'int' object n'est pas itérable
    Besoin d'ajouter rgb_im = im.convert('RGB')
    si elle s'ouvre et n'est pas RVB alors que vous avez déjà votre réponse - je crois que la seule autre possibilité est en niveaux de gris. Au moins pour un JPEG.
    par le temps de l'ouverture de l'image par la plupart des bibliothèques, la distinction est perdu.

    OriginalL'auteur joaoricardo000

  2. 11

    Peut être fait comme suit:

    from scipy.misc import imread, imsave, imresize
image = imread(f_name)
if(len(image.shape)<3):
      print 'gray'
elif len(image.shape)==3:
      print 'Color(RGB)'
else:
      print 'others'
    Réponse efficace. Si une image est en RVB ou niveaux de gris peut être déterminé par sa taille.

    OriginalL'auteur superMind

  3. 5

    Pour un traitement plus rapide, il est préférable d'éviter les boucles sur chaque pixel, en utilisant ImageChops, mais aussi pour être sûr que l'image est vraiment en niveaux de gris, nous avons besoin de comparer les couleurs sur chaque pixel et ne peut pas utiliser la somme):

    from PIL import Image,ImageChops

def is_greyscale(im):
    """
    Check if image is monochrome (1 channel or 3 identical channels)
    """
    if im.mode not in ("L", "RGB"):
        raise ValueError("Unsuported image mode")

    if im.mode == "RGB":
        rgb = im.split()
        if ImageChops.difference(rgb[0],rgb[1]).getextrema()[1]!=0: 
            return False
        if ImageChops.difference(rgb[0],rgb[2]).getextrema()[1]!=0: 
            return False
    return True

    OriginalL'auteur Karl K

  4. 4

    La performance enhance pour des résultats rapides: depuis de nombreuses images en noir ou en blanc de la frontière, vous attendez plus rapide en cas de résiliation par l'échantillonnage un peu aléatoire i,j-points de la gi et de les tester? Ou de l'utilisation de l'arithmétique modulo pour traverser les lignes de l'image. Nous avons d'abord l'échantillon (sans remplacement) de 100 aléatoire i,j-points; dans le cas peu probable que n'est pas concluante, alors nous allons le scanner de façon linéaire.

    À l'aide d'un custom itérateur iterpixels(im). Je n'ai pas PIL installé donc je ne peux pas le tester, voici le plan:

    import Image

def isColor(r,g,b): # use tuple-unpacking to unpack pixel -> r,g,b
    return (r != g != b)

class Image_(Image):
    def __init__(pathname):
        self.im = Image.open(pathname)
        self.w, self.h = self.im.size
    def iterpixels(nrand=100, randseed=None):
        if randseed:
            random.seed(randseed) # For deterministic behavior in test
        # First, generate a few random pixels from entire image
        for randpix in random.choice(im, n_rand)
            yield randpix
        # Now traverse entire image (yes we will unwantedly revisit the nrand points once)
        #for pixel in im.getpixel(...): # you could traverse rows linearly, or modulo (say) (im.height * 2./3) -1
        #    yield pixel

    def is_grey_scale(img_path="lena.jpg"):
        im = Image_.(img_path)
        return (any(isColor(*pixel)) for pixel in im.iterpixels())

    (Aussi mon premier commentaire stands, d'abord, vous vérifiez le format de l'en-tête, compensé 6: nombre de composants (1 = niveau de gris, 3 = RGB). Si c'est 1=niveaux de gris, vous connaissez la réponse déjà sans avoir besoin d'inspecter chacun des pixels.)

    OriginalL'auteur smci

  5. 1

    Pourquoi n'utilisons-nous pas ImageStat module?

    from PIL import Image, ImageStat

def is_grayscale(path="image.jpg")

    im = Image.open(path).convert("RGB")
    stat = ImageStat.Stat(im)

    if sum(stat.sum)/3 == stat.sum[0]:
        return True
    else:
        return False

    stat.somme nous donne une somme de tous les pixels dans la vue liste = [R, G, B] par exemple [568283302.0, 565746890.0, 559724236.0]. Pour les niveaux de gris de l'image tous les éléments de la liste sont égaux.

    une image composée d'un nombre égal de rouge pur, pur vert et le bleu pur pixels aurait tort de les identifier en tant que niveaux de gris

    OriginalL'auteur GriMel

  6. -2

    Que vous avez probablement raison, OpenCV est peut-être trop pour cette tâche, mais il devrait être d'accord pour utiliser Python Image Library (PIL) pour cela. Les éléments suivants doivent travailler pour vous:

    import Image
im = Image.open("lena.jpg")

    MODIFIER
    Comme l'a souligné Mark et JRicardo000, vous pouvez effectuer une itération sur chaque pixel. Vous pouvez également faire usage de la messagerie instantanée.split() de la fonction ici.

    La mode est toujours RVB à partir d'un JPEG. Vous avez besoin d'examiner réellement les pixels.
    Oui, vous avez raison. Permettez-moi de corriger cela dans un moment.

    OriginalL'auteur gat