Présentation

Le module ImageChops contient un certain nombre d'opérations arithmétiques sur les images, parfois appelées opérations sur canaux (channel operations : chops).

Ces chops ne marchent, pour la plupart, que sur des images 8-bit (par exemple "L" et "RGB").

Exemple d'utilisation

Voici comment faire la moyenne de deux images :

  >>> import Image as im
  >>> im1=im.open('nath2.jpg')
  >>> im2=im.open('nath3.jpg')
  >>> from ImageChops import *
  >>> dd = add(im1,im2, scale = 2)
  >>> dd.show()

Les opérations proposées

Les opérations proposées sont...

add(image1, image2, scale, offset)

Ajoute les deux images, divise le résultat par scale, et ajoute au final offset à chaque pixel de l'image. Par défaut, scale = 1.0 et offset = 0.0.

  out = (image1 + image2) / scale + offset

blend(image1, image2, alpha)

Comme la fonction blend du module Image.

composite(image1, image2, mask)

Comme la fonction composite du module Image.

constant(image, value)

Renvoie une image de même taille que image, dont tous les pixels ont pour valeur value.

  >>> import Image, ImageChops
  >>> image = Image.open('cover.jpeg')

  >>> fixe=ImageChops.constant(image,150)
  >>> fixe.show()

  >>> image.size, fixe.size
  ((300, 300), (300, 300))

darker(image1, image2)

Compare deux à deux les pixels des images image1 et image2, et ne conserve à chaque fois que le pixel le moins lumineux (le min des deux valeurs).

difference(image1, image2)

Renvoie la valeur absolue de la différence entre les deux images passées en argument.

  out = abs(image1 - image2)

Voici un exemple d'utilisation :

  >>> import Image as im
  >>> im1 = im.open('image1.jpeg')
  >>> im2 = im.open('image2.jpeg')

  >>> from ImageChops import difference
  >>> im3 = difference(im1,im2)
  >>> im3.show()

duplicate(image)

Renvoie une copie de l'image donnée.

  >>> import Image, ImageChops
  >>> image = Image.open('cover.jpeg')
  >>> image2 = ImageChops.duplicate(image)

invert(image)

Renvoie le négatif de l'image (chaque valeur x devient 255-x).

  >>> import Image, ImageChops
  >>> image = Image.open('cover.jpeg')

  >>> negatif=ImageChops.invert(image)
  >>> negatif.show()
  >>> negatif.mode
  'RGB'

lighter(image1, image2)

Compare deux à deux les pixels des images image1 et image2, et ne conserve à chaque fois que le pixel le plus lumineux (le max des deux valeurs).

  >>> import Image, ImageChops
  >>> image = Image.open('cover.jpeg')
  >>> image2 = Image.open('cover2.jpeg')
  >>> image3 = ImageChops.lighter(image,image2)

multiply(image1, image2)

Surimpression des deux images. Pour chaque couple de pixels (im1,im2), appartenant respectivement à image1 et image2, renvoie le pixel

  out = im1*im2 / 255.

Cas particulier :

• Si on multiplie une image avec une autre toute noire, le résultat est une image noire.
• Si on multiplie une image I avec une autre toute blanche, le résultat est I.

offset(xoffset, yoffset)

Retourne une copie, décalée de xoffset pixels en x, et de yoffset pixels en y, de l'image d'origine. Si yoffset n'est pas précisé, il sera égal à xoffset.

  >>> import Image, ImageChops
  >>> image = Image.open('cover.jpeg')

  >>> decale=ImageChops.offset(image,50)
  >>> decale.show()

  >>> decale2=ImageChops.offset(image,50,20)
  >>> decale2.show()

screen(image1, image2)

Surimpression des deux négatifs...

  out = MAX - ((MAX - image1) * (MAX - image2) / MAX)

subtract(image1, image2, scale, offset)

Comme ci-dessus, en remplaçant addition par soustraction.

  out = (image1 - image2) / scale + offset

La plupart des opérations sur canaux reçoivent une ou deux images en argument, et renvoient une nouvelle image (dont les valeurs sont éventuellement tronquées à l'intervalle entier [0,255])