Exemples ImageMagick -- Techniques avancées

Exemples ImageMagick -- Préface et index | Puces 3D à partir de formes | | Utiliser un script pour générer un grand nombre d'images
Teinter et mettre en forme une image d'ombrage 3D en niveaux de gris
---|---|---|---
Rendre les logos en 3D | Utiliser des calques transparents pour teinter l'image de base mise en forme
Reflets | Ajouter des reflets de surface de toutes sortes.
Pièces de puzzle | Découper et embellir une pièce de forme irrégulière à partir d'une photo
Effets « gel » | Ajuster la taille, la luminosité et la netteté du reflet lumineux
Éclaircir et assombrir à l'aide des compositions « Screen » et « Multiply »
Effets « aqua » | Utiliser les « courbes » pour ajuster les reflets.
Étoiles et comètes carrelables | Points aléatoires.
« Mon Dieu ! C'est plein d'étoiles ! -- 2001, l'Odyssée de l'espace »
Halos radiaux | Générer des rayons et des anneaux aléatoires autour d'un point central.
Cette page propose de très grands exemples où nous combinons plusieurs techniques pour produire des effets composés de manipulation d'image, au-delà des opérations de base d'IM. Les principales techniques sont résumées dans l'index ci-dessus. Bien que de nombreuses techniques soient présentées sur d'autres pages, comme la création de modèles de police, l'ajout d'étiquettes élaborées aux images et l'utilisation de masques, ces pages montrent comment combiner ces techniques pour produire un effet plus complexe.

Puces 3D à partir de formes -- une approche par script

Il existe sur le web quantité d'images de « puces » pour vos listes web. Mais vous pouvez générer vos propres objets 3D, ce qui vous permet de faire en sorte que tout votre site adopte un style particulier qui l'unifie. L'une des meilleures façons d'y parvenir est de créer un script de « génération » qui produit automatiquement toute une gamme de boutons et de formes d'un style donné, mais en utilisant n'importe quelle couleur voulue. En voici un, très simple. Ici nous utilisons l'option « [-shade](https://imagemagick.org/command-line-options/#shade) » pour générer des objets d'aspect 3D à partir d'une simple forme transparente. La forme ne comporte qu'une transparence franche activée/désactivée, qui est soigneusement préservée, ce qui permet de l'utiliser comme image GIF transparente pour un usage général sur les pages web. L'image « ombrée » en niveaux de gris ainsi obtenue est ensuite colorée à l'aide de l'opérateur « [-tint](https://imagemagick.org/command-line-options/#tint) », qui règle les gris de tons moyens de l'image tout en laissant intactes les nuances de noir et de blanc plus extrêmes. Après quoi la forme d'origine de l'image fournie est réajoutée au résultat coloré. En prime, si l'image d'entrée ne possédait qu'une transparence booléenne, le résultat possède lui aussi une transparence booléenne adaptée à une image au format GIF.

    magick {_input_image_} -alpha set \
            \( +clone -channel A -separate +channel \
               -bordercolor black -border 5  -blur 0x2 -shade 120x30 \
               -normalize -blur 0x1 -fill {_color_} -tint 100 \) \
            -gravity center -compose Atop -composite \
            {_output_image_}

Notez que l'image d'entrée n'est lue qu'une seule fois par le script ci-dessus. Cela vous permet aussi d'utiliser le script dans un pipeline de commandes en employant « - » comme noms de fichiers d'entrée et de sortie (avec éventuellement un réglage de format d'image IM). Cela peut être important lorsque vous écrivez vos propres scripts IM. La commande ci-dessus a été enregistrée dans un script shell très simple appelé « create_bullet », et les commandes suivantes ont été exécutées pour générer toute une gamme d'images de symboles dans de nombreuses couleurs différentes.

    magick +antialias -size 15x15 xc:none -draw 'circle 7,7 3,3'  ball.gif
    create_bullet ball.gif  grey    ball_grey.gif
    create_bullet ball.gif  red     ball_red.gif
    create_bullet ball.gif  green   ball_green.gif
    create_bullet ball.gif  blue    ball_blue.gif
    create_bullet ball.gif  yellow  ball_yellow.gif
    create_bullet ball.gif  maroon  ball_maroon.gif
    create_bullet ball.gif  cyan    ball_cyan.gif

    magick -size 12x12 xc:black   square.gif
    create_bullet square.gif  grey    square_grey.gif
    create_bullet square.gif  red     square_red.gif
    create_bullet square.gif  green   square_green.gif
    create_bullet square.gif  blue    square_blue.gif
    create_bullet square.gif  yellow  square_yellow.gif
    create_bullet square.gif  maroon  square_maroon.gif
    create_bullet square.gif  cyan    square_cyan.gif

    # retrieve asterix symbol from
    # [Anthony's Web Images, Symbols](http://www.cit.griffith.edu.au/images/Symbols/Images.html)
    create_bullet asterix.gif  grey    asterix_grey.gif
    create_bullet asterix.gif  red     asterix_red.gif
    create_bullet asterix.gif  green   asterix_green.gif
    create_bullet asterix.gif  blue    asterix_blue.gif
    create_bullet asterix.gif  yellow  asterix_yellow.gif
    create_bullet asterix.gif  maroon  asterix_maroon.gif
    create_bullet asterix.gif  cyan    asterix_cyan.gif

    # Use a heart symbol from "WebDings" font (22 point => 16x16 pixel image)
    magick -font WebDings -pointsize 22 -background none \
            label:Y -trim +repage    heart.png
    create_bullet heart.png  grey    heart_grey.png
    create_bullet heart.png  red     heart_red.png
    create_bullet heart.png  green   heart_green.png
    create_bullet heart.png  blue    heart_blue.png
    create_bullet heart.png  yellow  heart_yellow.png
    create_bullet heart.png  maroon  heart_maroon.png
    create_bullet heart.png  cyan    heart_cyan.png

Seule la forme ou la transparence de l'image source est utilisée pour générer les puces ; ainsi, n'importe quelle forme peut convenir. Choisissez votre propre forme, unique à votre site web. Notez aussi que l'on peut employer du GIF ou du PNG, avec ou sans transparence définissant la forme. La commande ne fait aucune distinction. Si vous utilisez une image plus grande que celle montrée ici, vous aurez peut-être intérêt à augmenter la quantité de flou appliquée avant l'opération d'ombrage. Sinon, vous risquez de constater que seules les zones proches du bord des images seront arrondies. Il peut aussi être préférable de flouter plusieurs fois plutôt que d'employer une grande valeur de flou (afin d'accélérer le floutage). Bien sûr, si vous apportez des améliorations ou avez d'autres idées, faites-le-moi savoir, afin que nous puissions les partager avec les autres.

Rendre les logos en 3D

Dans cet exemple, nous avons un logo plat et coloré, de forme difficile, que nous voulons traiter pour lui donner un aspect 3D marqué. Pour cela, nous utilisons le logo afin de générer des rehauts et des ombres, que nous transformons en transparences à superposer sur l'image d'origine. Cela met en œuvre, étape par étape, un grand nombre de techniques différentes issues de toutes les pages d'exemples. Cet exemple fait un usage intensif d'images générées par l'opérateur Shade et de diverses méthodes de composition alpha. Je vous suggère de vous familiariser avec ces opérateurs d'image avant de poursuivre, ou de les consulter lorsque vous souhaitez mieux comprendre ce qui se passe.

Avant de commencer, cependant, il nous faudra un logo simple auquel appliquer notre technique, ainsi que son masque… Créons d'abord une forme pour le fond coloré de l'exemple de logo… |

  magick -size 170x100 xc:black \
          -fill white -draw 'circle    50,50  13,50' \
                      -draw 'circle   120,50 157,50' \
                      -draw 'rectangle 50,13 120,87' \
          -fill black -draw 'circle    50,50  25,50' \
                      -draw 'circle   120,50 145,50' \
                      -draw 'rectangle 50,25 120,75' \
          -fill white -draw 'circle    60,50  40,50' \
                      -draw 'circle   110,50 130,50' \
                      -draw 'rectangle 60,30 110,70' \
          -gaussian 1x1 -alpha off logo_mask.png

Nous utilisons maintenant notre masque pour découper la couleur unie de notre logo et ajouter du texte, afin de générer un logo simple, d'une seule couleur. |

  magick logo_mask.png -background red -alpha shape \
          -font Candice  -pointsize 36  -fill white  -stroke black \
          -gravity Center  -annotate 0 "Ant" \
          logo.png

Donnons-lui maintenant un aspect 3D en utilisant les techniques de rehaut par superposition. |

  magick logo.png  -alpha extract -blur 0x6  -shade 110x30  -normalize \
          logo.png  -compose Overlay -composite \
          logo.png  -alpha on  -compose Dst_In  -composite \
          logo_3D.png

Ajouter des ombres est également plus facile grâce au nouvel opérateur de génération d'ombre fourni par IM. |

  magick logo_3D.png \( +clone -background navy -shadow 80x4+6+6 \) +swap \
          -background none  -layers merge +repage logo_3D_shadowed.png

Pour le plaisir, terminons en superposant notre logo sur un fond de type « papier rugueux ». On peut créer un très grand nombre d'autres toiles de fond ; voyez les exemples d'arrière-plans pour une collection de tels exemples. |

  magick logo_3D_shadowed.png \
          \( +clone +repage -alpha off -fx 'rand()' -shade 120x30 \
             -fill grey70 -colorize 60 \
             -fill lavender -tint 100 \) \
          +swap -composite logo_3D_bg.jpg

Reflets

Les reflets sont relativement faciles à réaliser, même si ce n'est souvent pas l'impression que l'on a. Vous devez tenir compte d'aspects tels que la couleur et la texture de la surface, mais aussi de la façon dont un tel effet augmente avec la distance entre la surface réfléchissante et l'objet qu'elle reflète. En somme, ce qui devrait être une affaire relativement simple devient très vite assez complexe. Commençons donc par le reflet d'une image relativement simple, en l'occurrence l'image d'un personnage de Pokémon, Azumarill (voir à droite). Remplacez-la par votre propre image si vous le souhaitez. Or, pour réaliser le reflet d'un miroir parfait, il suffirait de copier et de retourner l'objet source, puis d'ajouter un arrière-plan derrière lui pour lui donner un peu de contexte. Par exemple…
|

  magick pokemon.gif \( +clone -flip \) -append \
          -size 100x100 xc:black +swap \
          -gravity North -geometry +0+5 -composite  reflect_perfect.png

Couleur de surface - atténuation générale

Ce qu'il faut remarquer ci-dessus, c'est que le reflet étant parfait, il ne ressemble pas vraiment à un reflet dans une surface noire. Cela évoque davantage une « tuile miroir » de l'image d'origine, ce qui est d'ailleurs exact. Même un miroir de salle de bain ordinaire ne réfléchit pas toute la lumière qui le frappe, et c'est pourtant à peu près le meilleur miroir que l'on puisse avoir. La première règle des reflets est donc…

Un reflet n'est jamais, au grand jamais, parfait.

Aucun reflet n'est jamais une réflexion à 100 %, et il est donc coloré par la surface (ou par l'environnement alentour). Le monde est imparfait, et les reflets mettent très bien en valeur et en évidence ces imperfections. Réessayons donc, mais cette fois en colorant le reflet avec la couleur de la surface réfléchissante. On peut le faire de deux façons. La méthode la plus simple consiste simplement à coloriser le reflet de la même couleur que la surface. La quantité de coloration dépend de la qualité de réflexion de la surface ; pour les surfaces colorées, elle est généralement assez mauvaise, il faut donc ajouter une grande quantité de couleur : « 65% » convient très bien pour une surface noire. |

  magick pokemon.gif \
      \( +clone -flip -fill black -colorize 65% \) -append \
      -size 100x100 xc:black +swap \
      -gravity North -geometry +0+5 -composite  reflect_colored.png

Bien mieux… On dirait maintenant vraiment un reflet ! L'autre façon d'affaiblir un reflet consiste à rendre l'image réfléchie semi-transparente, ou translucide. Par exemple, en multipliant la valeur alpha de l'image pour que seuls 35 % environ de l'objet source restent visibles. |

  magick pokemon.gif -alpha on \
      \( +clone -flip -channel A -evaluate multiply .35 +channel \) -append \
      -size 100x100 xc:black +swap \
      -gravity North -geometry +0+5 -composite  reflect_alpha.png

C'est en réalité préférable, car cela signifie que la couleur de la surface peut être n'importe quelle couleur, voire une sorte de texture ou de motif coloré. Par exemple, générons un plancher de bois horizontal en utilisant une technique de carrelage infini tirée de Contempler des horizons lointains. |

  magick tile_wood.gif   -set option:distort:viewport 100x100 \
          -virtual-pixel tile     -distort Perspective \
                '0,0 -20,65  96,0 60,40  96,96 120,55  0,96 50,99' \
          wooden_floor.png

Et maintenant, superposons notre image avec son reflet semi-transparent sur ce plancher de bois. |

  magick pokemon.gif -alpha on \
      \( +clone -flip -channel A -evaluate multiply .35 +channel \) -append \
      wooden_floor.png +swap \
      -gravity North -geometry +0+5 -composite  reflect_wood.png

Sans l'objet réfléchi, la surface en bois paraît plutôt terne et sans vie, mais dès qu'un objet s'y reflète, le plancher prend soudain un aspect très bien poli !

Source déformée

Bien. Essayons quelque chose d'un peu plus élaboré et donnons à l'image une certaine profondeur en perspective 3D. |

  magick pokemon.gif -alpha on   -virtual-pixel transparent \
      +distort Perspective '0,0 0,0  0,64 0,64  64,0 54,10  64,64 54,54' \
      \( +clone -flip -channel A -evaluate multiply .35 +channel \) -append \
      +filter  -size 100x100 xc:black +swap \
      -gravity North -geometry +0+5 -composite  reflect_distort_bad.png

Ce qui est manifestement erroné. On dirait que l'image est déformée, mais qu'elle reste de face par rapport à l'utilisateur d'origine. Pourquoi ? Parce que…

Un objet en contact avec la surface est aussi en contact avec son reflet.

Cela paraît assez évident, mais j'ai vu des gens se tromper là-dessus. Bien sûr, si l'objet flotte au-dessus de la surface, il n'y aura pas de contact. Une façon de corriger cela serait de déformer séparément l'image source et le reflet de cette image, avant de fusionner les calques des résultats. |

  magick pokemon.gif -alpha on   -virtual-pixel transparent \
      \( -clone 0 \
         +distort Perspective '0,0,0,0  0,64,0,64  64,0,54,10  64,64,54,54' \) \
      \( -clone 0  -channel A -evaluate multiply .35 +channel \
         +distort Perspective '0,0,0,128  0,64,0,64  64,0,54,98  64,64,54,54' \
      \) -delete 0 +swap -background none  -layers merge \
      +filter  -size 100x100 xc:black +swap \
      -gravity North -geometry +0+5 -composite  reflect_distort_sep.png

Comme le montre l'ensemble très différent de paramètres de déformation, déformer un reflet peut devenir très difficile. C'est d'autant plus difficile qu'une simple modification de la première déformation exige un changement calculé de la seconde déformation, pour l'image réfléchie. Il existe deux autres règles qui vous indiquent comment calculer les coordonnées de la déformation réfléchie.

Les reflets dans une surface horizontale se dirigent toujours droit vers le bas.

Autrement dit, un reflet se dirige toujours vers l'utilisateur ; comme celui-ci se trouve directement en face de l'image, tout reflet dans une surface horizontale ira vers le bas, droit vers l'utilisateur. C'est une loi de la physique, et c'est une chose que vous ne voulez pas enfreindre si vous voulez que vos images soient au moins à demi réalistes. Et enfin, une autre règle dont vous devez vous souvenir.

Les surfaces verticales, réfléchies dans des surfaces horizontales, ont des
reflets de la même hauteur que l'objet réfléchi

Peu importe à quel point l'objet semble « lointain » dans une image, la hauteur de son reflet dans l'image finale doit être la même que celle de l'objet réfléchi ! Ce n'est pas évident, et c'est très facile à rater.

Ces trois règles signifient que la valeur X de la coordonnée réfléchie reste la même, tandis que la valeur Y est retournée vers le bas autour du « point de contact avec la surface », de la même distance qu'elle se trouve au-dessus de ce point.

Ainsi, avec un peu de soin, vous pouvez calculer les coordonnées de déformation du reflet à partir des coordonnées de l'image source déformée. Or ces règles nous fournissent aussi une méthode qui peut simplifier les reflets pour les images déformées. Il suffit d'abord d'accoler le reflet à l'image source, puis de déformer l'image source comme si aucun reflet n'y était attaché, en laissant son reflet se déformer en même temps que l'image principale… |

  magick pokemon.gif -alpha on   -virtual-pixel transparent \
      \( +clone -flip -channel A -evaluate multiply .35 +channel \) -append \
      +distort Perspective '0,0,0,0  0,64,0,64  64,0,54,10  64,64,54,54' \
      -gravity North  -crop 100x100+0-5\! \
      -background black -compose Over -flatten    reflect_distort.png

Comme vous le voyez, cela fonctionne bien plus facilement, et vous n'avez qu'un seul jeu de déformations à gérer pour l'objet, ce qui rend aussi les modifications bien plus simples. Cela vous permet également d'utiliser des déformations qu'il serait autrement impossible de reproduire pour créer un reflet séparé. Par exemple, en générant un arc 3D à partir de l'image… |

  magick pokemon.gif -alpha on   -virtual-pixel transparent \
      \( +clone -flip -channel A -evaluate multiply .35 +channel \) -append \
      +distort Barrel '0,0,0,1  0,0,-.35,1.5  32,32' \
      -gravity North  -crop 100x100+0-5\! \
      -background black -compose Over -flatten    reflect_3Darc.png

Un dernier point avant de passer à la section suivante… Les ombres obéissent en général aux mêmes règles que les reflets, à l'exception des deux dernières. Elles ne tombent pas forcément droit vers le bas, mais s'éloignent de la source lumineuse (parallèlement, pour des sources lointaines). De plus, elles ne se trouvent pas à la même distance du « point de contact avec la surface », mais présentent le même rapport de distances, sans être dans un rapport de 1:1 comme c'est le cas pour les reflets.

Atténuation par dégradé

Jusqu'ici, nous avons traité une surface réfléchissante parfaitement lisse, mais la plupart des surfaces ne sont pas polies jusqu'à l'éclat d'un miroir. Une surface apparemment lisse ne l'est en réalité pas aux petites échelles, ce qui influe à son tour sur la lumière réfléchie par une telle surface. Cet effet se renforce aussi avec la distance que la lumière réfléchie doit parcourir entre l'objet et le point de réflexion. Ainsi…

Les reflets deviennent plus faibles et plus déformés
à mesure qu'ils s'éloignent de l'image source.

La façon la plus simple de créer un effet de distance est d'affaiblir le reflet à mesure qu'il s'éloigne de la surface. Pour cela, il est généralement acceptable de rendre le reflet un peu plus lumineux à proximité de l'image. |

  magick pokemon.gif -alpha on \
      \( +clone -flip \
         -size 64x28 gradient:gray40-black   \
         -alpha off -compose CopyOpacity -composite \
      \) -append \
      -gravity North  -crop 100x100+0-5\! \
      -background black -compose Over -flatten    reflect_attenuated.png

Cela fonctionne raisonnablement bien, et c'est si facile à générer que c'est une méthode assez courante pour produire des reflets. La technique marche parce qu'une bonne part de la lumière réfléchie n'est pas un reflet parfait, mais provient plutôt de l'environnement global. Plus vous vous éloignez de l'image d'origine, moins celle-ci est réfléchie.

Atténuation par flou

La composante qui constitue le vrai reflet de l'objet source ne fait pas que s'affaiblir avec la distance. En réalité, les reflets deviennent plus flous, plus estompés et plus déformés avec la distance, car la surface réfléchissante n'est généralement pas très lisse. Il ne s'agit pas d'une déformation macroscopique, mais de déformations à des échelles microscopiques minuscules. C'est le même effet qui produit les reflets d'éclairage spéculaire. Autrement dit, à proximité de la source du reflet, ils peuvent être raisonnablement nets, mais plus vous vous éloignez de la source, plus l'image devient floue. Avant la version 6.5.5-0 d'IM, c'était quelque chose de très difficile à obtenir (c'était possible, mais non sans beaucoup d'astuces). Désormais, cependant, vous pouvez utiliser une carte de flou variable pour flouter un reflet en fonction de sa distance à l'image source, assez facilement. Toutefois, pour que cela fonctionne, il est judicieux d'ajouter une bordure transparente autour de l'objet, dans laquelle diffuser le flou. Dans ces exemples, j'ai agrandi l'image finale afin que vous puissiez voir le reflet en entier et en apprécier l'effet. |

  magick pokemon.gif -alpha on \
      -background None -gravity South -extent 100x100 \
      \( +clone -flip -channel A -evaluate multiply .35 +channel \
         -size 100x100 gradient:gray5-white \
         -compose Blur -set option:compose:args 10 -composite -compose Over \
      \) -append -trim +repage \
      -gravity North  -crop 100x140+0-5\! \
      -background black -compose Over -flatten    reflect_blurred.png

Le flou du reflet peut être renforcé davantage en utilisant une ellipse de flou étirée verticalement. Par exemple, en employant des arguments de flou elliptique « 10x30 » plutôt qu'un simple flou circulaire de « 20 ». Si vous combinez ensuite l'« atténuation par flou » avec une « atténuation par dégradé », vous commencerez à obtenir un reflet très réaliste, typique d'une surface lisse mais peu polie. |

  magick pokemon.gif -alpha on \
      -background None -gravity South -extent 100x100 \
      \( +clone -flip \
         \( -size 100x64 gradient:'rgba(0,0,0,0.6)-none' \
            -size 100x36 xc:none  -append \
         \) -compose Dst_In -composite \
         \( -size 100x100 gradient:gray5-white \
         \) -compose Blur -set option:compose:args 4x8 -composite \
      \) -append -trim +repage \
      -gravity North  -crop 100x140+0-5\! \
      -background black -compose Over -flatten    reflect_blur_atten.png

Vous auriez bien du mal à obtenir une meilleure image de reflet pour des surfaces planes que celle-ci.

À venir : ajouter des exemples de...
  Effets de texture de surface
    givré - ou surfaces non lisses (petites distorsions aléatoires à petite échelle)
    ondulé - reflets sur l'eau
        (très peu de flou ou d'atténuation, juste une distorsion macro plus forte)

Pièces de puzzle

L'une des choses les plus intéressantes qu'on m'ait demandé de faciliter a été de découper et d'embellir une pièce de « puzzle » de forme irrégulière à partir d'une image plus grande. En fait, Theo van Hoesel, également connu sous le nom de « Mr Jigsaw », voulait générer un grand nombre de pièces distinctes, sous une multitude de rotations différentes. Ce qui suit a été mis au point à partir de notre discussion pour une seule pièce, mais avec le bon jeu de modèles, n'importe quel agencement de pièces peut être généré. À droite se trouve une vignette liée à une image 800x600 d'une photo du Mémorial de l'Holocauste, à Berlin, en Allemagne. J'ai pris cette photo lors de mon voyage en Europe en avril 2006. Elle a tout d'une image parfaite pour en faire un puzzle vraiment difficile. Et en dessous se trouve une image modèle de la pièce de puzzle que je vais extraire de l'image ci-dessus. Elle faisait partie d'un ensemble de telles images. L'ensemble complet des pièces de puzzle comprend 192 masques de ce type, dans une grille de 16 sur 12, y compris les bords et les coins. Cette pièce de puzzle particulière est un masque de 100x100 pixels, conçu pour être utilisé avec un décalage de +365+96 sur une image de 800x600 pixels. Ces chiffres n'ont d'importance que si vous disposez d'un grand ensemble de pièces différentes destinées à s'emboîter. Si vous ne comptez pas le faire, vous pouvez bien sûr utiliser le décalage que vous voulez.
J'ai moi-même rassemblé un certain nombre de ces ensembles de puzzle, ce qui me permet de faire un puzzle à partir de n'importe quelle image. Et c'est précisément ce que fait Theo van Hoesel sur son site web. Si vous fabriquez un vrai puzzle, l'information de décalage est très importante, car elle identifie l'emplacement et la position de cette pièce dans l'image d'origine. C'est pourquoi je m'efforcerai de préserver cette information. Notez que les décalages des masques peuvent dans certains cas être négatifs, à cause du remplissage supplémentaire autour de la forme ; vous devrez donc peut-être tester et ajuster les commandes d'image pour gérer cette situation. Le remplissage supplémentaire lui-même vous permettra d'ajouter facilement des effets de rotation, d'épaisseur et d'ombre à l'image finale, sans avoir à modifier la taille ou le décalage de la pièce de puzzle découpée. Mais d'abord, transformons ce modèle en un contour.

    magick jigsaw_tmpl.png -edge .5 -blur 0x.5 jigsaw_edge.png

Je peux ensuite le superposer sur l'image pour avoir une idée approximative de ce qui va être découpé pour former la pièce de puzzle. |

    magick holocaust_md.jpg \
            \( jigsaw_edge.png -negate \) -geometry +365+96 \
            -compose multiply -composite \
            -crop 100x100+365+96 +repage jigsaw_outline.png

Normalement, on ne fait pas cela lors de la génération d'un puzzle, mais c'est utile lorsque la position de la pièce n'a pas d'importance (car elle ne fait pas partie d'un puzzle plus grand). Dans ce cas, vous pouvez ajuster le décalage pour choisir un meilleur contenu pour cette pièce de puzzle. | En raison du fonctionnement de « [-edge](https://imagemagick.org/command-line-options/#edge) », le contour de puzzle généré ci-dessus se trouve à l'intérieur de la zone (blanche) masquée de l'image de masquage. Cela peut être important si vous souhaitez réutiliser ce contour par la suite.
---|---
Bien, nous avons une forme de puzzle et un décalage pour la pièce à découper. Découpons-la donc, et faisons-la pivoter aussi. |

    magick holocaust_md.jpg \
            -crop 100x100+365+96\! -background none -flatten +repage \
            \( jigsaw_tmpl.png -alpha off \) -compose CopyOpacity -composite \
            -rotate -20 -gravity center -crop 100x100+0+0 +repage \
            jigsaw_cutout.png

Notez que nous avons rogné l'image source à la zone couverte par la forme de notre modèle. Nous n'aurons pas besoin de la zone située hors du masque, et la supprimer tôt accélérera le traitement de l'image. Notez aussi l'usage particulier d'un rognage par fenêtre d'affichage, suivi de « [-flatten](https://imagemagick.org/command-line-options/#flatten) ». Cette méthode de rognage nous garantira une image de 100x100 pixels dans laquelle « découper » le modèle, même en utilisant des masques de pièces de bord ou de coin, et gérera aussi un décalage négatif pour les pièces situées sur ou près des bords supérieur ou gauche de l'image. La rotation est également effectuée à ce stade, car la plupart des embellissements ajoutent des effets selon une direction donnée. Le résultat de cette rotation est lui aussi rogné au centre, car cet opérateur agrandit normalement la taille de l'image obtenue, selon l'angle de rotation utilisé, et nous ne voulons pas qu'il le fasse. Le premier embellissement consiste à donner aux pièces un léger rehaut biseauté, ou arrondi, autour des bords. Cela suit les rehauts par superposition d'ombrage, qui permettent un contrôle fin (4 facteurs distincts) de la manière dont le rehaut est produit. |

   magick jigsaw_cutout.png \
           \( +clone -channel A -separate +channel -negate \
              -background black -virtual-pixel background \
              -blur 0x2 -shade 120x21.78 -contrast-stretch 0% \
              +sigmoidal-contrast 7x50%  -fill grey50 -colorize 10% \
              +clone +swap -compose overlay -composite \) \
          -compose In -composite jigsaw_bevel.png

Dans un vrai puzzle, ce biseau résulte de la découpe des pièces par pressage mécanique. Il donne aussi aux pièces un léger creux, de sorte que, si l'on réassemble les pièces, on peut encore voir l'empreinte des découpes. Ajoutons maintenant un peu d'épaisseur à la pièce. C'est la meilleure et la plus rapide méthode que j'aie trouvée, même si je ne la considère pas comme une très bonne technique. Si vous trouvez mieux, faites-le-moi savoir. |

   magick jigsaw_bevel.png \
           \( +clone -fill DarkSlateGrey -colorize 100% -repage +0+1 \) \
           \( +clone -repage +1+2 \)  \( +clone -repage +1+3 \) \
           \( +clone -repage +2+4 \)  \( +clone -repage +2+5 \) \
          -background none -compose DstOver -flatten \
          jigsaw_thickness.png

Et enfin, que diriez-vous d'un peu d'ombre. |

    magick jigsaw_thickness.png \
            \( +clone   -background Black -shadow 50x3+4+4 \) \
            -background none -compose DstOver -flatten \
            jigsaw_shadow.png

Toutes les commandes ci-dessus peuvent facilement être enregistrées dans un unique script shell, et c'est ce que j'ai fait pour mon propre usage. Le script « [jigsaw](../static/img/scripts/jigsaw) » prend trois paramètres d'image : la photo source, le modèle et la destination, ainsi que de nombreuses options permettant d'activer les divers embellissements montrés ci-dessus. Il n'a même pas besoin d'utiliser une forme de puzzle. N'importe quel modèle de masque peut servir à découper des parties d'images, avec les effets appropriés en prime. La plus grande différence entre ce qui précède et ma version scriptée, c'est que par défaut le script garde l'image finale aussi petite que possible, tout en gardant trace du décalage de l'image découpée. En préservant cette position de décalage, vous pouvez utiliser un simple « [-mosaic](https://imagemagick.org/command-line-options/#mosaic) » ou « [-flatten](https://imagemagick.org/command-line-options/#flatten) » pour superposer plusieurs pièces afin de produire des effets intéressants (voir le dernier exemple ci-dessous). Voici quelques exemples d'utilisation de ce script, de plusieurs manières.

    jigsaw -o +365+96 -m  null: jigsaw_tmpl.png  jigsaw_mask.png
    magick -size 800x600 xc:gray miff:- |\
                 jigsaw -r 30 -l -h -s miff:- jigsaw_mask.png jigsaw_grey.png
    jigsaw -r -60 -h -t 4 -s holocaust_md.jpg jigsaw_mask.png jigsaw_piece.png

    magick jigsaw_cnr.png -resize 50% -flip -flop -repage 120x90 \
            -background black -flatten -flip -flop jigsaw_cnr_tmpl.png
    jigsaw -t 3 -s  -r 15  -d +15+7 \
            holocaust_tn.gif jigsaw_cnr_tmpl.png   holocaust_piece_tn.png
    magick jigsaw_cnr_tmpl.png -negate png:- |\
      jigsaw -t 3 -s holocaust_tn.gif png:-   holocaust_puzzle_tn.png
    magick holocaust_puzzle_tn.png  holocaust_piece_tn.png \
            -background none  -mosaic    holocaust_jigsaw_tn.png

La dernière image est l'amorce d'un style possible de vignette de puzzle… Elle prend une pièce de coin, et par quelques mises à l'échelle et agrandissements convertit le masque en un masque modèle d'image en taille réelle. Celui-ci sert ensuite non seulement à découper la pièce de coin d'une vignette existante, mais aussi, une fois négativé, à produire le reste de l'image. La superposition de ces deux images donne alors une vignette de puzzle à l'aspect assez soigné. Notez l'emploi d'un « -d +15+7 » dans les options de création de la pièce. Cela déplace légèrement le « décalage de page » de l'image PNG générée par rapport à sa position d'origine dans l'image, produisant le résultat montré, simplement et facilement. Voyez le script lui-même pour les autres options disponibles. | _Comme les décalages de page générés peuvent être négatifs et contenir un effet d'ombre douce facultatif, il est recommandé de n'utiliser que des images PNG pour les pièces extraites. Les images GIF ne peuvent gérer ni les décalages de page négatifs ni les effets d'ombre, et ne produisent pas non plus de bords lisses et anticrénelés lorsque la transparence est en jeu.

En général, vous devriez éviter les images GIF (et JPEG) pour tout sauf votre image finale. Pour plus d'informations, voyez la page d'exemples Formats d'image courants._
---|---
Vous n'êtes pas limité aux modèles de puzzle : n'importe quel masque de n'importe quelle forme peut être utilisé avec n'importe quelle image. Faites-moi savoir ce que vous obtenez. Je n'ai pas tout à fait terminé le développement du script « [jigsaw](../static/img/scripts/jigsaw) », car j'aimerais de meilleurs contrôles pour les effets de rehaut, d'épaisseur et d'ombre, et éventuellement une option de « masque négatif ». C'est cependant un programme fondamentalement complet et fonctionnel, que vous êtes libre d'utiliser. Faites un lien retour si vous l'utilisez pour une page web :-) Pour ceux qui ont quelques compétences avec l'API PerlMagick, essayez de reprendre le script ci-dessus et de le convertir en PerlMagick pour gagner en vitesse, puis soumettez-le-moi afin que tout le monde puisse aussi l'utiliser et mesurer à quel point vous êtes doué avec IM. Les suggestions et idées supplémentaires sont toujours les bienvenues.
Si vous voulez simplement découper toutes les pièces d'une image à l'aide d'une collection de masques (avec ou sans décalages de pixels virtuels), la commande suivante vous permettra de les faire TOUTES très rapidement.

  magick mask_*.png -set filename:mask %t -alpha shape \
          null: image.jpg -compose In -layers composite \
          pieces_%[filename:mask].png

Chacune des images « pieces_mask_*.png » obtenues contient non seulement l'image appropriée issue de l'image d'origine au bon décalage, mais préserve aussi ce décalage dans l'image finale. Cela se fait à l'aide de la composition multicalque, qui fusionne toutes les images situées à gauche de l'image marqueur spéciale « null: » avec l'unique image de droite. En prime, elle intègre le nom de fichier du masque utilisé dans le nom de fichier de l'image de pièce (y compris son format de fichier image final), ce qui rend bien plus facile l'identification de chaque pièce. (Voyez les échappements de pourcentage dans les noms de fichiers pour les détails. Notez que les masques n'ont pas à recouvrir entièrement toute l'image d'origine, mais ne doivent pas laisser d'espaces ni de vides entre les pièces. Bien sûr, pour un vrai puzzle, tous les masques doivent être correctement alignés, de façon à produire un tout sans couture, comme montré dans les exemples de composition Dst_Out.

Effets « gel »

Les ombrages 3D utilisés ci-dessus ne sont que le début de ce que vous pouvez faire avec les effets de rehaut et d'ombrage. En appliquant divers ajustements d'histogramme à la sortie de « -shade », une énorme gamme de possibilités s'ouvre. L'un de ces effets que vous pouvez reproduire est ce qu'on appelle un effet « gel », tel qu'on en voit souvent sur les sites web de tutoriels « Photoshop » (cherchez « Gel Effects Tutorial » sur Google). Créons d'abord la forme dont nous avons besoin. Ce pourrait être une image préparée à l'avance ou extraite d'une police « Dings », comme nous l'avons fait pour la puce 3D en forme de « heart » plus haut. Ici, utilisons une simple forme ovale pour un bouton… |

  magick -size 100x60 xc:none \
          -fill red -draw 'circle    25,30  10,30' \
                    -draw 'circle    75,30  90,30' \
                    -draw 'rectangle 25,15  75,45' \
          gel_shape.png

Ajoutons maintenant le rehaut « gel » net à la forme colorée, à l'aide d'une opération d'ombrage flouté fortement modifiée… |

    magick gel_shape.png \
            \( +clone -alpha extract  -blur 0x12  -shade 110x0 -normalize \
               -sigmoidal-contrast 16,60% -evaluate multiply .5 \
               -roll +5+10 +clone -compose Screen -composite \) \
            -compose In  -composite  gel_highlight.png

Nous avons appliqué « -shade » à une copie du canal de transparence (matte) après l'avoir flouté pour l'arrondir. Cet ombrage a employé une source lumineuse sans aucun angle de « hauteur » ni d'« azimut », ce qui signifie en gros que l'on obtient un rehaut de couleur grise sur un seul côté de la forme floutée, et du noir pour tout le reste. Ce niveau de gris de rehaut a ensuite été ajusté (accentué) à l'aide de l'opérateur « -sigmoidal-contrast » afin de réduire la taille de la zone rehaussée (le seuil de « 60% ») et d'en accentuer les bords (à l'aide d'un facteur exponentiel très élevé de « 16 »). Avec une valeur exponentielle aussi élevée, l'opérateur agit presque comme un opérateur « -threshold » « flou », pour produire une région de couleur uniforme fondée sur la forme de l'image d'origine. Pour plus d'informations sur cette fonction de contraste/seuil douce, voyez Contraste sigmoïde non linéaire. Et enfin, le niveau du rehaut a été ajusté au moyen d'un « -evaluate » multipliant toutes les couleurs par le niveau de rehaut voulu, puis un « -roll » sert à décaler sa position dans la zone mise en forme. Or, comme le rehaut est gris sur noir (le noir devant rester inchangé), une composition alpha « [Screen](compose.html#screen) » sert à éclaircir les zones non noires du niveau de gris donné. Il ne reste plus qu'à assombrir un peu les bords… |

    magick gel_highlight.png \
          \( +clone -alpha extract  -blur 0x2 -shade 0x90 -normalize \
             -blur 0x2  +level 60,100%  -alpha On \) \
          -compose Multiply  -composite  gel_border.png

Notez que cette fois j'ai utilisé un « -shade » éclairé verticalement pour assombrir les bords, ce qui rend blanches les zones que je veux préserver inchangées. Ainsi, après avoir ajusté le niveau de gris à l'aide d'un ajustement de niveaux inversé et restauré la transparence sauvegardée par la méthode d'extraction alpha, j'ai pu employer une composition alpha « [Multiply](compose.html#multiply) » pour assombrir les bords affectés. Terminons le bouton « gel » ovale avec un peu de texte et des effets d'ombre… |

    magick gel_border.png \
            -font Candice  -pointsize 24  -fill white  -stroke black \
            -gravity Center  -annotate 0 "Gel"  -trim -repage 0x0+4+4 \
            \( +clone -background navy -shadow 80x4+4+4 \) +swap \
            -background none  -flatten    gel_button.png

Effets « aqua » ou « bulle »

Vous pouvez aussi ajuster la teinte d'un « -shade » 3D complet (avec un éclairage à 30 degrés) pour produire un effet d'eau « aqua ». Pour cela, cependant, il nous faut effectuer un ajustement d'histogramme d'une manière semblable à ce que l'on fait avec des programmes graphiques à interface comme « Gimp » et « Photoshop ». Je vais d'abord procéder lentement, étape par étape, pour que vous puissiez voir la démarche que je suis. Créons d'abord une image à utiliser, en l'occurrence une lettre A tout en courbes. |

  magick -background none -fill DodgerBlue \
          -font Candice -pointsize 72  label:A  -trim +repage \
          -bordercolor None -border 1x1 \
          aqua_shape.png

Notez que j'ai ajouté une bordure transparente d'un pixel autour de l'image. Cela rend les étapes de traitement suivantes juste un peu plus faciles. Nous devons maintenant générer un ombrage arrondi de cette image mise en forme. |

  magick aqua_shape.png \
          -alpha Extract -blur 0x8  -shade 130x30 -alpha On \
          -background gray50 -alpha background -auto-level \
          aqua_shade.png

La drôle de ligne qui traite de l'arrière-plan alpha sert à réinitialiser la couleur cachée des zones transparentes à un gris de tons moyens, afin qu'elle n'ait pas d'effet sur la normalisation des couleurs. Cela peut être très important. Nous transformons maintenant cet ombrage en un « effet d'éclairage » qui ressemble vaguement à la façon dont la lumière est déformée par une bulle d'eau ou de verre. |

  magick aqua_shade.png \
          -function polynomial  3.5,-5.05,2.05,0.3 \
          aqua_lighting.png

La fonction polynomiale est utilisée pour un ajustement par courbes de l'image. C'est cette fonction qui donne l'effet d'ensemble, et elle peut être difficile à déterminer. Pour y parvenir, j'ai transmis les points de contrôle nécessaires à cette « courbe » au script shell de support d'IM appelé « [**im_fx_curves**](../static/img/scripts/im_fx_curves) ». Celui-ci renvoie alors les « coefficients » de l'équation polynomiale nécessaire à la « courbe » qui passe par ces points de contrôle.

  im_fx_curves -c -p  0,30  100,80  50,50  80,50  > aqua_coeffs.txt

| | |

Le dernier ajustement de cet effet d'éclairage consiste à assombrir les bords de l'effet d'éclairage. |

  magick aqua_lighting.png \
          \( +clone -alpha extract  -blur 0x2 \) \
          -channel RGB -compose multiply -composite \
          aqua_light+edge.png

Et l'overlay d'ombrage est terminé. Il ne reste plus qu'à l'appliquer à l'image d'origine, à l'aide de la composition HardLight. |

  magick aqua_shape.png aqua_light+edge.png \
          -compose Hardlight -composite   aqua_result.png

Remarquez que la couleur d'ensemble de l'image obtenue est en fait la couleur d'origine de la forme d'origine. En réalité, vous pourriez même appliquer ceci à une image multicolore, sans aucun problème. Répétons donc toutes les étapes ci-dessus, y compris la création de l'image de forme initiale, en une seule commande.

  magick -background none -fill DodgerBlue \
          -font Candice -pointsize 96  label:'Aqua Text' -trim +repage \
          \
          \( +clone -bordercolor None -border 1x1 \
             -alpha Extract -blur 0x8  -shade 130x30 -alpha On \
             -background gray50 -alpha background -auto-level \
             -function polynomial  3.5,-5.05,2.05,0.3 \
             \( +clone -alpha extract  -blur 0x2 \) \
             -channel RGB -compose multiply -composite \
             +channel +compose -chop 1x1 \
          \) \
          -compose Hardlight -composite  aqua_text.png

Si vous étudiez ce qui précède, vous verrez que toutes les étapes décrites précédemment sont appliquées pour générer l'image d'éclairage, laquelle est ensuite composée sur l'image d'origine.

Étoiles et comètes carrelables

Je voulais réaliser une tuile de champs d'étoiles aléatoires (avec des étoiles d'intensités variables) à diverses fins. Voici le résultat de mes tentatives, améliorées peu à peu. Une image de bruit aléatoire sert à s'éclaircir elle-même pour générer un motif moucheté. |

  magick -size 100x100 xc: +noise Random -channel R -threshold 5% \
          -negate -channel RG -separate +channel \
          -compose multiply -composite   speckles.gif

Ce motif est la base des effets d'animation scintillante, mais aussi le point de départ d'autres effets. Par exemple, pour créer des étoiles, il nous faut modifier un peu plus son motif « moucheté » aléatoire, afin de le rendre plus réaliste. |

  magick -size 100x100 xc: +noise Random -channel R -threshold 1% \
          -negate -channel RG -separate +channel \
          \( +clone \) -compose multiply -flatten \
          -virtual-pixel tile -blur 0x.4 -contrast-stretch .8% \
          stars.gif

Notez que je multiplie non seulement le masque moucheté (canal « R »), mais aussi, deux fois, l'image d'intensité des étoiles (canal « G »). Cela produit une décroissance quadratique des intensités de pixels, de sorte qu'il y a davantage d'étoiles sombres que d'étoiles brillantes, tout comme dans le vrai ciel nocturne. Après quoi, nous agrandissons la taille des étoiles selon leur intensité par floutage. Cela produit un effet semblable aux étoiles qui se gravent sur la plaque photographique d'un astronome, ce qui le rend encore plus réaliste. Plus la valeur de flou est grande, plus l'effet est marqué. Un dernier « [-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch) » ramène les résultats à la visibilité. En utilisant deux images de bruit aléatoire (l'une pour le masque, l'autre pour la couleur des étoiles), nous pouvons générer des étoiles de couleurs aléatoires, au lieu de simples étoiles en niveaux de gris. |

  magick -size 100x100 xc: +noise Random -channel R -threshold 1% \
          -negate -channel RG -separate +channel \
          \( xc: +noise Random \) -compose multiply -flatten \
          -virtual-pixel tile -blur 0x.4 -contrast-stretch .8% \
          stars_colored.gif

Cela demanderait toutefois davantage de travail, car il faudrait élever au carré l'intensité des couleurs directement, au lieu de simplement les multiplier par une distribution linéaire. Cela fonctionne néanmoins et fournit un point de départ pour des développements ultérieurs. Notez que la couleur n'a pas à être aléatoire : elle pourrait aisément provenir d'une autre image pour les étoiles. Par exemple, la couleur des étoiles elle-même pourrait être puisée dans l'image qui servira d'arrière-plan final. Maintenant que j'ai un générateur de champs d'étoiles, je peux simplement utiliser « [-motion-blur](https://imagemagick.org/command-line-options/#motion-blur) » pour créer un champ d'étoiles filantes ! |

  magick -size 100x100 xc: +noise Random -channel R -threshold .4% \
          -negate -channel RG -separate +channel \
          \( +clone \) -compose multiply -flatten \
          -virtual-pixel tile -blur 0x.4 -motion-blur 0x20+45 -normalize \
          star_fall.gif

Bien sûr, nous voulons moins d'étoiles et une moindre « décroissance » des intensités stellaires. En appliquant une déformation polaire à l'image, nous pouvons faire en sorte que les comètes filent ou spiralent vers un point ! |

  magick -size 250x100 xc: +noise Random -channel R -threshold .4% \
          -negate -channel RG -separate +channel \
          \( +clone \) -compose multiply -flatten \
          -virtual-pixel Tile -background Black \
          -blur 0x.6 -motion-blur 0x15-90 -normalize \
          +distort Polar 0 +repage  star_inward.gif
  magick -size 250x100 xc: +noise Random -channel R -threshold .4% \
          -negate -channel RG -separate +channel \
          \( +clone \) -compose multiply -flatten \
          -virtual-pixel Tile -background Black \
          -blur 0x.6 -motion-blur 0x15-60 -normalize \
          +distort Polar 0 +repage   star_spiral.gif

Ici, nous appliquons un flou de mouvement aux étoiles dans six directions (par paires), puis nous les fusionnons pour créer un champ d'« éclats d'étoiles », comme on en obtient dans une lentille de verre. |

  magick -size 100x100 xc: +noise Random -channel R -threshold .2% \
          -negate -channel RG -separate +channel \
          \( +clone \) -compose multiply -flatten \
          -virtual-pixel tile  -blur 0x.3 \
          \( -clone 0  -motion-blur 0x10+15  -motion-blur 0x10+195 \) \
          \( -clone 0  -motion-blur 0x10+75  -motion-blur 0x10+255 \) \
          \( -clone 0  -motion-blur 0x10-45  -motion-blur 0x10+135 \) \
          -compose screen -background black -flatten  -normalize \
          star_field.gif

Remarquez comme les étoiles plus sombres ne produisent qu'un petit point et très peu d'« éclat », tandis que les étoiles plus grandes et brillantes produisent un très grand « éclat ». Maintenant, si je parviens à trouver un moyen d'ajouter un floutage de type « sinc() » afin de produire aussi un « anneau » de halo autour des étoiles les plus brillantes, nous aurons un excellent générateur de champs d'étoiles. Ajoutez un arrière-plan de plasma et nous pourrons même générer de fausses photos astronomiques de nébuleuses et de nuages de gaz. En combinant ce qui précède avec une animation scintillante de plasma, vous pouvez créer un ensemble d'étoiles qui ressemblent à des décorations de Noël. |

  magick -size 100x100 xc: +noise Random -separate \
          null: \
            \( xc: +noise Random -separate -threshold 50% -negate \) \
            -compose CopyOpacity -layers composite \
          null: \
            plasma:red-firebrick plasma:red-firebrick plasma:red-firebrick \
            -compose Screen -layers composite \
          null:  \
            \( xc: +noise Random -channel R -threshold .08% \
              -negate -channel RG -separate +channel \
              \( +clone \) -compose multiply -flatten \
              -virtual-pixel tile  -blur 0x.4 \
              \( -clone 0  -motion-blur 0x15+90  -motion-blur 0x15-90 \) \
              \( -clone 0  -motion-blur 0x15+30  -motion-blur 0x15-150 \) \
              \( -clone 0  -motion-blur 0x15-30  -motion-blur 0x15+150 \) \
              -compose screen -background black -flatten  -normalize \) \
            -compose multiply -layers composite \
          -set delay 30 -loop 0 -layers Optimize       stars_xmas.gif

La technique ci-dessus n'est que le début de ce qu'on peut accomplir. À l'aide de quelques techniques d'animation simples, on peut créer des scintillements et des halos aléatoires à ajouter aux images. Un exemple simple en a été fourni dans les exemples d'animation GIF, à l'aide d'un simple script shell « [star_field](../static/img/scripts/star_field) » pour générer les éclats d'étoiles. Que pouvez-vous faire avec ce générateur d'étoiles ? Défi :

• Générer des scintillements plutôt que des étoiles. Le champ moucheté initial doit être limité par un masque (par exemple par multiplication). Les scintillements comme les étoiles peuvent ensuite être superposés à une image à l'aide d'une composition « screen ».
• Utiliser un « champ moucheté » masqué pour générer des éclats d'étoiles à superposer. En masquant les germes plutôt que l'éclat d'étoile complet, les « rayons » des éclats peuvent sortir de la zone masquée pour se superposer à d'autres parties de l'image. Autrement dit, les rayons ne sont pas simplement « coupés ».
• Créer une animation d'éclats d'étoiles aléatoires. Cela peut vous obliger à animer un unique champ d'éclats d'étoiles (avec, peut-être, les rayons qui tournent).
• En générant quelques animations d'éclats d'étoiles, vous pouvez les fusionner pour former une série d'éclats d'étoiles qui se chevauchent, venant d'emplacements différents.
• Trouver un unique point « germe » sur la partie la plus brillante de l'image, par étirement d'histogramme et seuillage. Puis choisir des pixels isolés jusqu'à ce que l'un d'eux tombe dans la zone masquée.
• Créer des étoiles sur le bord d'une forme ombrée uniformément.

Si vous réussissez l'un des défis ci-dessus ou utilisez le générateur d'étoiles à d'autres fins, faites-le-moi savoir, à moi et au reste de la communauté IM.

Halos radiaux

Expériences de génération de halos radiaux. Notez que la largeur de l'image initiale, avant la déformation polaire, détermine en gros le nombre de rayons qui seront produits.

  magick -size 100x1 xc: +noise Random -channel G -separate +channel \
          -scale 100x100\!                                +write flare_1a.png \
          \( -size 100x100 gradient:'gray(100%)' -sigmoidal-contrast 10x50% \) \
          -colorspace sRGB -compose hardlight -composite  +write flare_1b.png \
          -virtual-pixel HorizontalTileEdge -distort Polar -1 \
          flare_1_final.png

Remarquez comme j'utilise « [+write](https://imagemagick.org/command-line-options/#write) » pour sauvegarder des images intermédiaires à des fins d'affichage. C'est une technique de débogage détaillée dans Traitement d'image complexe et débogage. Voici un autre exemple utilisant plusieurs superpositions pour obtenir un halo d'aspect différent. Notez la technique employée pour générer des images intermédiaires de débogage et d'exemple montrant les étapes en jeu.

  magick -size 100x1 xc: +noise Random -channel G -separate +channel \
          -size 100x99 xc:black -append -motion-blur 0x35-90 \
          \( -size 100x50 gradient:'gray(0)' \
             -evaluate cos .5 -sigmoidal-contrast 3,100% \
             -size 100x50 xc:'gray(0)' -append \) \
          \( -size 1x50 xc:'gray(0)' \
             -size 1x1 xc:'gray(50%)' \
             -size 1x49 xc:'gray(0)' \
             -append -blur 0x2 -scale 100x100\! \) \
          \
          -scene 10 +write flare_2%x.png \
          \
          -background 'gray(0)' -compose screen -flatten +write flare_2f.png \
          \
          -virtual-pixel HorizontalTileEdge -distort Polar -1 \
          -colorspace sRGB flare_2_final.png

Le principal problème de l'utilisation de la déformation polaire pour générer des images de halo, c'est que les rayons s'élargissent avec le rayon, alors qu'en réalité nous voudrions qu'ils conservent une largeur à peu près constante à mesure qu'ils s'estompent, ou du moins qu'ils s'affinent. Idées et pistes bienvenues La teinte de couleur peut aussi être importante dans ce type d'image. Par exemple, ici je teinte les couleurs de tons moyens en bleu. |

  magick flare_2_final.png  -fill SkyBlue  -tint 100%  flare_2_color.png

Le pourcentage utilisé pour l'opération « [-tint](https://imagemagick.org/command-line-options/#tint) » peut aussi servir à ajuster l'intensité des rayons et de l'anneau de halo, même s'il ne changera pas beaucoup le cœur blanc de l'image. Ces exemples ont été approfondis dans la discussion du forum IM Utiliser un halo radial comme masque.