Processing : afficher et modifier des images

Je veux pouvoir charger des images (png ou jpg en principe) et pouvoir les positionner et les dimensionner comme je le veux. Je veux aussi pouvoir les teinter comme je l’entend.

J’explore donc ici les moyens de :

  • utiliser la classe PImage ;
  • charger une image avec loadImage() et éventuellement la redimensionner ;
  • attraper une portion d’une image, avec get() ;
  • utiliser des filtres, par exemple pour mettre en noir et blanc ou en niveau de gris ;
  • Rendre l’image transparente, avec ce qui est opaque soit blanc, soit en niveaux de gris clair ;
  • donner une couleur à cette image transparente ;
  • utiliser les images comme fond (background) ou les positionner à divers endroits.

charger une image et l’afficher comme fond d’écran

Pour qu’une image puisse être utilisée comme fond d’écran, elle doit impérativement être exactement à la taille de cet écran.

Dans le sketch ci-dessous, je réalise les opérations suivantes :

Dans setup()

  1. définir la taille de l’écran, ici 720 x 540 px ;
  2. définir un mode couleur HSB (voir l’article Processing : exploration des couleurs HSB et de l’ordre des dessins)
  3. Charger une image qui s’appelle test-fond-AL-2017-12.png et se trouve sur mon ordinateur dans le répertoire « C:/Processing Scripts/Patrice 2018 04/img »
  4. redimensionner l’image pour qu’elle fasse la largeur de l’écran et la hauteur de l’écran

Dans draw(), qui s’éxécute en boucle (noter que j’aurais pu tout mettre dans setup) :

  1. Définir une couleur de remplissage en mode HSB ;
  2. définir différentes variables aléatoires
  3. tous les 50 counter (sinon ça défile trop vite)
    1. redéfinir que le fond de l’écran est constitué par l’image ;
    2. tracer un rectangle sur ce fond, de position et dimension aléatoire
    3. par dessus ce rectangle, dessiner l’image, redimensionnée pour que le rectangle soit comme un cadre.
Et voici ce que celà donne (ici en gif) : l’image est affichée comme fond et aussi dans un encart. Dans l’encart, elle est retaillée à la taille du rectangle.

Afficher seulement une partie de l’image avec get()

get() permet de récupérer des pixels d’une l’image (cf l’aide de Processing.org) .

On peut récupérer tous les pixels, donc toute l’image ou seulement une partie.

Dans le sketch qui suit, j’utilise newimg = img.get(50, 50, w, h );  pour créer une image newimg qui correspond à un rectangle positionné en (50,50), de largeur w et de hauteur l.

J’utilise aussi c = img.get(160, 190); pour lire la couleur d’un pixel spécifique (coordonnées 160,190) de l’image img.

Processing : utilisation de PImage et get()
Processing : utilisation de PImage et get()

Cette image est produite par ce sketch :

background( imgbkg ) ;  produit le fond correspondant à l’image (qui a été redimensionnée à la taille de l’écran dans le setup).

image( img, width/10, height/10, width/2, height/2) ;  produit l’image encadrée de vert, en haut de la moitié gauche de l’écran.

fill(c) ;   et  rect( width/10-5, height*3/4, 200, 55 ) ;  produisent le rectangle de couleur rose. La couleur rose a été extraite du pixel de coordonnées  (160,190) de l’image par la commande c = img.get(160, 190);  dans setup().

Enfin image( newimg, width * 6/10 + 20, height/10 ) ; produit l’image à droite, c’est une portion de l’image d’origine. Elle a été obtenue par la commande newimg = img.get(50, 50, w, h );  dans setup().

tint, filter, pixel

Pour ce qui suit, je me suis aidée des informations du site processing.org et de deux pages d’un tutoriel, en anglais, sur la gestion des images avec Processing : cette page sur la teinte des images et cette page sur les filtres de transformation. Quant à l’image d’une oeuvre de Kandinsky, elle provient aussi de ces tutoriels. On peut la télécharger ici.

explication des différentes images obtenues

Le sketch qui suit illustre différentes possibilités de traitement d’une même image. Toutes ces possibilités sont visualisées sur un même écran de Processing :

Processing : utilisation de PImage et filter()
Processing : utilisation de PImage et filter()

Processing : utilisation de PImage et filter() - Positions

J’appelle A à D les lignes, 1 à 5 les colonnes et les différentes images correspondent à :

  • A1 l’image telle quelle, redimensionnée ;
  • A2 l’image avec une transparence ;
  • A3 un rectangle de couleur mauve qui est utilisée ensuite pour teinter des images ;
  • B1 l’image source passée en noir et blanc avec le filtre filter(THRESHOLD, 0.5)
  • B2 l’image précédente inversée avec le filtre filter(INVERT)
  • B3 l’image inversée teintée avec avec le filtre tint(196,85,189, 255); (un mauve) puis tint(255, 255);  qui remet la teinte à neutre (pas de teinte, pas de transparence)
  • B4 l’image inversée passée dans une « moulinette » qui transforme tous les pixels noirs en pixels noirs et transparents. On a alors uniquement les pixels blancs qui sont visibles lors de l’affichage
  • B5 l’image inversée et transparente de B4 est tintée en mauve.
  • Les différentes colonnes de la ligne C sont les mêmes qu’en ligne B sauf qu’au départ on met l’image en niveau de gris avec le filtre filter(GRAY)  .  La « moulinette » pour transformer en image transparente est différente.
  • En ligne D, on observe deux images transparentes. La première en D1 est le résultat d’une fonction créée dans le sketch, pour les images en noir et blanc. La deuxième, en D3 est une autre fonction qui passe en niveaux de gris.  Ces deux fonctions font la même chose que ce qui est réalisé de manière décomposée en lignes B et C.

Le code complet pour obtenir ce résultat est le suivant (attention ne pas oublier de placer l’image kandinsky dans le répertoire data du script) :

Aparté théorique sur la notion de « niveau de gris »

Lorsqu’on parle de niveau de gris, on a une couleur qui a deux caractéristiques :

  • les valeurs de R, G et B sont identiques ;
  • le niveau correspond au ratio entre la valeur de R (ou G ou B) et 256 : R = 126 correspond à un niveau de gris de 50%.

Pour une couleur (obtenue par exemple avec  c = img.get(160, 190);  comme précédemment), on peut savoir quelle sont les valeurs de rouge, vert et bleu, et même transparence, avec les fonctions respectivement red(), green(c), blue(c), alpha(c).

Ce sont ces caractéristiques qu’on utilise pour rendre une image teintable, avec nuances.

Rendre une image teintable et transparente

C’est réalisé avec la fonction fnbwTransp. Cette fonction est réalisée sur une image PImage img et renvoie une PImage puisqu’elle est définie comme PImage fnbwTransp( PImage img ) {} .

La « moulinette » qui transforme les pixels noirs en pixels transparents est inspirée d’une discussion sur le forum processing.  L’idée générale en est la suivante :

  • on crée une image vide appelée result, de dimensions celles de img (notre source) et au format ARGB, donc avec prise en compte de la transparence Alpha. Cette image est créée avec  result = createImage( img.width, img.height, ARGB );
  • on balaie l’image source, img, pixel par pixel.
    • Si la couleur du pixel est noir – color( 0, 0, 0 )  – alors la couleur du pixel correspondant dans l’image result est  color( 0, 0, 0, 0 )  – noir aussi mais transparent.
    • Si la couleur du pixel n’est pas le noir, alors la couleur du du pixel correspondant dans l’image result est la couleur du pixel d’origine de img.

La fonction retourne l’image résultante, une image dont tous les pixels noirs sont devenus transparents.

Rendre une image teintable, avec nuances, et transprente

On utilise là la fonction fnGreyTransp. Elle est semblable à fnbwTransp mais elle gère des niveaux d’intensité de la couleur. On utilise le même principe que dans fnbwTransp  mais la différence est dans les décisions lors du balayage des pixels d’img :

  • si le niveau de rouge est inférieur à 150 (on a un gris variant de très clair à assez clair)
    • si rouge = vert = bleu, alors on est en niveau de gris et  lightGrey = true  ;
  • si le niveau de rouge est > 150 ou bien rouge n’est pas identique à vert et bleu, alors   lightGrey = false  ;

Et ensuite on a deux possibilités :

  • si   lightGrey = true , alors le pixel correspondant de result est noir et totalement transparent (valeur 0 de transparence)
  • si   lightGrey = false , alors on donne au pixel correspondant de result l’exacte valeur de la couleur du pixel de img, avec une transparence nulle (valeur 255 de transparence).

Et maintenant !?

J’aimerais bien faire la même chose en p5.js pour avoir des sketch plus facilement présentables en ligne.

Mais avant, je vais probablement explorer la gestion des couches avec PGraphics, et aussi des masques, avec mask().

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *