Installation • Présentation • Exemple de script • Lire ou écrire une image • Manipuler une image • Définir un attribut d'image • Obtenir un attribut d'image • Comparer une image à sa reconstruction • Créer un montage d'images • Travailler avec les blobs • Accès direct aux pixels de l'image • Méthodes diverses • Gestion des exceptions • Constantes

PerlMagick est une interface Perl orientée objet vers ImageMagick. Utilisez ce module pour lire, manipuler ou écrire une image ou une séquence d'images depuis un script Perl. Cela le rend très adapté aux scripts CGI Web. Vous devez avoir ImageMagick 6.5.5 ou supérieur et Perl version 5.005_02 ou supérieur installés sur votre système pour que PerlMagick se compile correctement.

Il existe plusieurs scripts utiles pour vous montrer la valeur de PerlMagick. Vous pouvez effectuer la manipulation et la conversion d'images en environnement Web avec MagickStudio, ou utiliser les L-systems pour créer des images de plantes à l'aide de constructions mathématiques, et enfin naviguer parmi des collections de vignettes et sélectionner l'image à afficher avec le WebMagick Image Navigator.

Vous pouvez essayer PerlMagick depuis votre navigateur Web sur ImageMagick Studio. Ou vous pouvez voir des exemples de fonctions PerlMagick choisies.

Installation

UNIX

PerlMagick est-il disponible depuis le dépôt RPM de votre système ? Par exemple, sur notre système CentOS, nous installons PerlMagick ainsi :

yum install ImageMagick-perl

Sinon, vous devez installer PerlMagick depuis la distribution des sources d'ImageMagick. Téléchargez la dernière version des sources.

Décompressez la distribution avec cette commande :

tar xvzf ImageMagick.tar.gz

Ensuite, configurez et compilez ImageMagick :

cd ImageMagick-7.1.2-25
./configure -with-perl
make

Si ImageMagick / PerlMagick s'est configuré et compilé sans difficulté, vous êtes prêt à l'installer sur votre système. Des privilèges d'administrateur sont requis pour l'installation. Pour installer, tapez

sudo make install

Vous devrez peut-être configurer les liaisons d'exécution de l'éditeur de liens dynamique :

sudo ldconfig /usr/local/lib

Enfin, pour vérifier que l'installation de PerlMagick a bien fonctionné, tapez

perl -MImage::Magick -le 'print Image::Magick->QuantumDepth'

Félicitations, vous disposez d'une distribution ImageMagick fonctionnelle et vous êtes prêt à utiliser PerlMagick pour convertir, composer ou éditer vos images.

Windows XP / Windows 2000

ImageMagick doit déjà être installé sur votre système. De plus, la distribution des sources d'ImageMagick pour Windows 2000 est requise. Vous devez aussi disposer de nmake fourni par l'environnement de développement Visual C++ ou J++. Copiez \bin\IMagick.dll et \bin\X11.dll dans un répertoire de votre chemin de chargement dynamique tel que c:\perl\site\5.00502.

Ensuite, tapez

cd PerlMagick
perl Makefile.nt
nmake
nmake install

Exécuter les tests de régression

Pour vérifier une installation correcte, tapez

make test

Sous Windows, utilisez nmake test. Il existe quelques scripts de démonstration disponibles pour exercer un grand nombre des fonctions que PerlMagick peut accomplir. Tapez

Utilisez l'utilitaire prove pour exécuter un test depuis le dossier de compilation :

prove --blib blib -I `pwd` -bv ./t/read.t



cd demo
make

Vous êtes maintenant prêt à utiliser les méthodes PerlMagick depuis vos scripts Perl.

Présentation

Tout script qui souhaite utiliser les méthodes PerlMagick doit d'abord définir ces méthodes dans son espace de noms et instancier un objet image. Faites-le ainsi :

use Image::Magick;

$image = Image::Magick->new;

PerlMagick est conscient du quantum. Vous pouvez demander une profondeur de quantum spécifique lorsque vous instanciez un objet image :

use Image::Magick::Q16;

$image = Image::Magick::Q16->new;

La méthode new() prend les mêmes paramètres que SetAttribute. Par exemple,

$image = Image::Magick->new(size=>'384x256');

Ensuite, vous voudrez lire une image ou une séquence d'images, la manipuler, puis l'afficher ou l'écrire. Les méthodes d'entrée et de sortie de PerlMagick sont définies dans « Lire ou écrire une image ». Voir « Définir un attribut d'image » pour les méthodes qui affectent la façon dont une image est lue ou écrite. Reportez-vous à « Manipuler une image » pour une liste des méthodes permettant de transformer une image. « Obtenir un attribut d'image » décrit comment récupérer un attribut d'une image. Reportez-vous à « Créer un montage d'images » pour les détails sur la disposition en mosaïque de vos images sous forme de vignettes sur un fond. Enfin, certaines méthodes ne rentrent dans aucune des catégories mentionnées. Consultez « Méthodes diverses » pour une liste de ces méthodes.

Une fois que vous avez fini avec un objet PerlMagick, vous devriez envisager de le détruire. Chaque image d'une séquence d'images est stockée en mémoire virtuelle. Cela peut potentiellement représenter plusieurs mébioctets de mémoire. En détruisant un objet PerlMagick, la mémoire est restituée pour être utilisée par d'autres méthodes Perl. La façon recommandée de détruire un objet est avec undef :

undef $image;

Pour supprimer toutes les images tout en conservant l'objet Image::Magick, utilisez

@$image = ();

et enfin, pour supprimer une seule image d'une séquence multi-images, utilisez

undef $image->[$x];

La section suivante illustre comment utiliser diverses méthodes PerlMagick pour manipuler une séquence d'images.

Certaines des méthodes PerlMagick nécessitent des programmes externes tels que Ghostscript. Cela peut nécessiter un chemin explicite dans votre variable d'environnement PATH pour fonctionner correctement. Par exemple (sous Linux),

$ENV{PATH}' . "='/../bin:/usr/bin:/usr/local/bin';

Exemple de script

Voici un exemple de script pour vous lancer :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#!/usr/local/bin/perl
use Image::Magick;

my($image, $x);

$image = Image::Magick->new;
$x = $image->Read('girl.png', 'logo.png', 'rose.png');
warn "$x" if "$x";

$x = $image->Crop(geometry=>'100x100+100+100');
warn "$x" if "$x";

$x = $image->Write('x.png');
warn "$x" if "$x";

Ce script lit trois images, les rogne et écrit une seule image sous forme de séquence d'animation GIF. Dans de nombreux cas, vous voudrez accéder aux images individuelles d'une séquence. L'exemple suivant illustre comment procéder :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#!/usr/local/bin/perl
use Image::Magick;

my($image, $p, $q);

$image = new Image::Magick;
$image->Read('x1.png');
$image->Read('j*.jpg');
$image->Read('k.miff[1, 5, 3]');
$image->Contrast();
for ($x = 0; $image->[$x]; $x++)
{
  $image->[$x]->Frame('100x200') if $image->[$x]->Get('magick') eq 'GIF';
  undef $image->[$x] if $image->[$x]->Get('columns') < 100;
}
$p = $image->[1];
$p->Draw(stroke=>'red', primitive=>'rectangle', points=>20,20 100,100');
$q = $p->Montage();
undef $image;
$q->Write('x.miff');

Supposons que vous vouliez partir d'un canevas blanc de 100 sur 100 pixels avec un pixel rouge au centre. Essayez

$image = Image::Magick->new;
$image->Set(size=>'100x100');
$image->ReadImage('canvas:white');
$image->Set('pixel[49,49]'=>'red');

Ici, nous réduisons de moitié l'intensité de la composante rouge en (1,1) :

@pixels = $image->GetPixel(x=>1,y=>1);
$pixels[0]*=0.5;
$image->SetPixel(x=>1,y=>1,color=>\@pixels);

Ou supposons que vous vouliez convertir votre image en couleur en niveaux de gris :

$image->Quantize(colorspace=>'gray');

Annotons une image avec une police TrueType de Taipei :

$text = 'Works like magick!';
$image->Annotate(font=>'kai.ttf', pointsize=>40, fill=>'green', text=>$text);

Peut-être voulez-vous extraire toutes les intensités de pixels d'une image et les écrire sur STDOUT :

@pixels = $image->GetPixels(map=>'I', height=>$height, width=>$width, normalize=>true);
binmode STDOUT;
print pack('B*',join('',@pixels));

Parmi les autres choses astucieuses que vous pouvez faire avec un objet PerlMagick figurent :

$i = $#$p"+1";   # renvoie le nombre d'images associées à l'objet p
push(@$q, @$p);  # pousse les images de l'objet p sur l'objet q
@$p = ();        # supprime les images mais pas l'objet p
$p->Convolve([1, 2, 1, 2, 4, 2, 1, 2, 1]);   # noyau gaussien 3x3

Lire ou écrire une image

Utilisez les méthodes listées ci-dessous pour lire, écrire ou afficher une image ou une séquence d'images :

Par commodité, les méthodes Write(), Display() et Animate() peuvent prendre tout paramètre connu de SetAttribute. Par exemple,

$image->Write(filename=>'image.png', compression=>'None');

Utilisez - comme nom de fichier dans la méthode Read() pour lire depuis l'entrée standard ou dans la méthode Write() pour écrire vers la sortie standard :

binmode STDOUT;
$image->Write('png:-');

Pour lire une image au format GIF depuis un descripteur de fichier PERL, utilisez :

$image = Image::Magick->new;
open(IMAGE, 'image.gif');
$image->Read(file=>\*IMAGE);
close(IMAGE);

Pour écrire une image au format PNG vers un descripteur de fichier PERL, utilisez :

$filename = "image.png";
open(IMAGE, ">$filename");
$image->Write(file=>\*IMAGE, filename=>$filename);
close(IMAGE);

Notez que la lecture ou l'écriture vers un descripteur de fichier Perl peut échouer sous Windows en raison de versions différentes des bibliothèques d'exécution C entre ImageMagick et les distributions ActiveState Perl, ou si l'une des DLL est liée avec l'option /MT. Voir Potential Errors Passing CRT Objects Across DLL Boundaries pour une explication.

Si %0Nd, %0No ou %0Nx apparaît dans le nom de fichier, il est interprété comme une spécification de format printf et la spécification est remplacée par l'encodage décimal, octal ou hexadécimal spécifié du numéro de scène. Par exemple,

image%03d.miff

convertit les fichiers image000.miff, image001.miff, etc.

Vous pouvez éventuellement ajouter Image à n'importe quel nom de méthode. Par exemple, ReadImage() est un alias de la méthode Read().

Manipuler une image

Une fois que vous avez créé une image avec, par exemple, la méthode ReadImage(), vous voudrez peut-être agir dessus. Voici une liste de toutes les méthodes de manipulation d'image disponibles avec PerlMagick. Il existe des exemples de méthodes PerlMagick choisies. Voici un exemple d'appel à une méthode de manipulation d'image :

$image->Crop(geometry=>'100x100+10+20');
$image->[$x]->Frame("100x200");

Et voici une liste des autres méthodes de manipulation d'image que vous pouvez appeler :

Notez que le paramètre geometry est un raccourci pour les paramètres width et height (par ex. geometry=>'106x80' équivaut à width=>106, height=>80).

Vous pouvez spécifier @filename à la fois dans Annotate() et Draw(). Cela lit le texte ou les instructions de primitive graphique depuis un fichier sur disque. Par exemple,

image->Draw(fill=>'red', primitive=>'rectangle',
 points=>'20,20 100,100  40,40 200,200  60,60 300,300');

est équivalent à

$image->Draw(fill=>'red', primitive=>'@draw.txt');

où draw.txt est un fichier sur disque qui contient ceci :

rectangle 20, 20 100, 100
rectangle 40, 40 200, 200
rectangle 60, 60 300, 300

Le paramètre text des méthodes Annotate(), Comment(), Draw() et Label() peut inclure le nom de fichier de l'image, son type, sa largeur, sa hauteur ou d'autres attributs d'image en y intégrant ces caractères de format spéciaux :

%b   taille du fichier
%c   commentaire
%d   répertoire
%e   extension du nom de fichier
%f   nom de fichier
%g   géométrie de la page
%h   hauteur
%i   nom de fichier d'entrée
%k   nombre de couleurs uniques
%l   étiquette
%m   magick
%n   nombre de scènes
%o   nom de fichier de sortie
%p   numéro de page
%q   profondeur de quantum
%r   classe d'image et espace colorimétrique
%s   numéro de scène
%t   début du nom de fichier
%u   nom de fichier temporaire unique
%w   largeur
%x   résolution x
%y   résolution y
%z   profondeur de l'image
%C   type de compression de l'image
%D   méthode dispose de l'image
%H   hauteur de la page
%Q   qualité de compression de l'image
%T   délai de l'image
%W   largeur de la page
%X   décalage x de la page
%Y   décalage y de la page
%@   boîte englobante
%#   signature
%%   signe pourcent
\n   retour à la ligne
\r   retour chariot

Par exemple,

text=>"%m:%f %wx%h"

produit une annotation MIFF:bird.miff 512x480 pour une image intitulée bird.miff dont la largeur est 512 et la hauteur 480.

Vous pouvez éventuellement ajouter Image à n'importe quel nom de méthode. Par exemple, TrimImage() est un alias de la méthode Trim().

La plupart des attributs listés ci-dessus ont un équivalent dans magick. Voir la documentation pour une description plus détaillée de ces attributs.

Définir un attribut d'image

Utilisez la méthode Set() pour définir un attribut d'image. Par exemple,

$image->Set(dither=>'True');
$image->[$x]->Set(delay=>3);

Là où cet exemple utilise 'True' et où ce document indique '{True, False}', vous pouvez utiliser les chaînes 'True' et 'False' insensibles à la casse, ou les entiers 1 et 0.

Lorsque vous appelez Get() sur un attribut booléen, Image::Magick renvoie 1 ou 0, et non une chaîne.

Et voici une liste de tous les attributs d'image que vous pouvez définir :

Notez que le paramètre geometry est un raccourci pour les paramètres width et height (par ex. geometry=>'106x80' équivaut à width=>106, height=>80).

SetAttribute() est un alias de la méthode Set().

La plupart des attributs listés ci-dessus ont un équivalent dans magick. Voir la documentation pour une description plus détaillée de ces attributs.

Obtenir un attribut d'image

Utilisez la méthode Get() pour obtenir un attribut d'image. Par exemple,

($a, $b, $c) = $image->Get('colorspace', 'magick', 'adjoin');
$width = $image->[3]->Get('columns');

En plus de tous les attributs listés dans « Définir un attribut d'image », vous pouvez obtenir ces attributs supplémentaires :

GetAttribute() est un alias de la méthode Get().

La plupart des attributs listés ci-dessus ont un équivalent dans magick. Voir la documentation pour une description plus détaillée de ces attributs.

Comparer une image à sa reconstruction

Annotez mathématiquement et visuellement la différence entre une image et sa reconstruction avec la méthode Compare(). La méthode prend en charge ces paramètres :

Dans cet exemple, nous comparons le logo ImageMagick à une reconstruction rendue plus nette :

use Image::Magick;

$logo=Image::Magick->New();
$logo->Read('logo:');
$sharp=Image::Magick->New();
$sharp->Read('logo:');
$sharp->Sharpen('0x1');
$difference=$logo->Compare(image=>$sharp, metric=>'rmse');
print $difference->Get('error'), "\n";
$difference->Display();

Outre l'erreur quadratique moyenne rapportée d'environ 0,024, une image de différence est affichée afin que vous puissiez identifier visuellement la différence entre les images.

Créer un montage d'images

Utilisez la méthode Montage() pour créer une image composite en combinant plusieurs images distinctes. Les images sont disposées en mosaïque sur l'image composite, le nom de l'image apparaissant éventuellement juste en dessous de chaque tuile. Par exemple,

$image->Montage(geometry=>'160x160', tile=>'2x2', texture=>'granite:');

Et voici une liste des paramètres de Montage() que vous pouvez définir :

Notez que le paramètre geometry est un raccourci pour les paramètres width et height (par ex. geometry=>'106x80' équivaut à width=>106, height=>80).

MontageImage() est un alias de la méthode Montage().

La plupart des attributs listés ci-dessus ont un équivalent dans montage. Voir la documentation pour une description plus détaillée de ces attributs.

Travailler avec les blobs

Un blob contient des données qui représentent directement un format d'image particulier en mémoire plutôt que sur disque. PerlMagick prend en charge les blobs dans n'importe lequel de ces formats d'image et fournit des méthodes pour convertir un blob vers ou depuis un format d'image particulier.

ImageToBlob() renvoie les données d'image dans leurs formats respectifs. Vous pouvez ensuite les imprimer, les enregistrer dans une base de données ODBC, les écrire dans un fichier ou les rediriger vers un programme d'affichage :

@blobs = $image->ImageToBlob();
open(DISPLAY,"| display -") || die;
binmode DISPLAY;
print DISPLAY $blobs[0];
close DISPLAY;

La méthode BlobToImage() renvoie une image ou une séquence d'images convertie à partir du blob fourni :

@blob=$db->GetImage();
$image=Image::Magick->new(magick=>'jpg');
$image->BlobToImage(@blob);

Accès direct aux pixels de l'image

Utilisez ces méthodes pour obtenir un accès direct aux pixels de l'image :

Méthodes diverses

La méthode Append() concatène un ensemble d'images. Par exemple,

$p = $image->Append(stack=>{true,false});

concatène toutes les images associées à l'objet $image. Par défaut, les images sont empilées de gauche à droite. Mettez stack à True pour les empiler de haut en bas.

La méthode Clone() copie un ensemble d'images. Par exemple,

$q = $p->Clone();

copie toutes les images de l'objet $p vers $q. Vous pouvez utiliser cette méthode pour des séquences à une ou plusieurs images.

Coalesce() compose un ensemble d'images en respectant les décalages de page et les méthodes de disposition. Les séquences d'animation GIF, MIFF et MNG commencent généralement par un fond d'image, chaque image suivante variant en taille et en décalage. Une nouvelle séquence d'images est renvoyée, toutes les images ayant la même taille que le canevas virtuel de la première image et composées avec l'image suivante de la séquence. Par exemple,

$q = $p->Coalesce();

La méthode ComplexImages() effectue des opérations mathématiques complexes sur une séquence d'images. Par exemple,

$p = $image->ComplexImages('conjugate');

La méthode EvaluateImages() applique une expression arithmétique, logique ou relationnelle à un ensemble d'images. Par exemple,

$p = $image->EvaluateImages('mean');

calcule la moyenne de toutes les images associées à l'objet $image.

La méthode Features() renvoie les caractéristiques de chaque canal de l'image dans chacune des quatre directions (horizontale, verticale, diagonales gauche et droite) pour la distance spécifiée. Les caractéristiques comprennent le moment angulaire de second ordre, le contraste, la corrélation, la somme des carrés : variance, le moment de différence inverse, la moyenne des sommes, la variance des sommes, l'entropie des sommes, l'entropie, la variance des différences, l'entropie des différences, les mesures d'information de la corrélation 1, les mesures d'information de la corrélation 2 et le coefficient de corrélation maximal. Les valeurs sont dans l'ordre RGB, CMYK, RGBA ou CMYKA (selon le type d'image).

@features = $image->Features(1);

La méthode Flatten() aplatit un ensemble d'images et le renvoie. Par exemple,

$p = $images->Flatten(background=>'none');
$p->Write('flatten.png');

La séquence d'images est remplacée par une seule image créée en composant chaque image après la première sur la première image.

La méthode Fx() applique une expression mathématique à un ensemble d'images et renvoie les résultats. Par exemple,

$p = $image->Fx(expression=>'(g+b)/2.0',channel=>'red');
$p->Write('fx.miff');

remplace le canal rouge par la moyenne des canaux vert et bleu.

Voir FX, l'opérateur d'image à effets spéciaux pour une discussion détaillée de cette méthode.

Histogram() renvoie les couleurs uniques de l'image et un décompte pour chacune. Les valeurs renvoyées sont un tableau de valeurs rouge, vert, bleu, opacité et décompte.

La méthode Morph() effectue un morphing d'un ensemble d'images. À la fois les pixels et la taille de l'image sont interpolés linéairement pour donner l'apparence d'une métamorphose d'une image à la suivante :

$p = $image->Morph(frames=>_integer_);

où frames est le nombre d'images intermédiaires à générer. La valeur par défaut est 1.

Mosaic() crée une mosaïque à partir d'une séquence d'images.

La méthode Mogrify() est un point d'entrée unique vers les méthodes de manipulation d'image (Manipuler une image). Les paramètres sont le nom d'une méthode suivi de tous les paramètres que cette méthode peut nécessiter. Par exemple, ces appels sont équivalents :

$image->Crop('340x256+0+0');
$image->Mogrify('crop', '340x256+0+0');

La méthode MogrifyRegion() applique une transformation à une région de l'image. Elle est similaire à Mogrify() mais commence par la géométrie de la région. Par exemple, supposons que vous vouliez éclaircir une région 100x100 de votre image à l'emplacement (40, 50) :

$image->MogrifyRegion('100x100+40+50', 'modulate', brightness=>50);

PerceptualHash() fait correspondre des images visuellement identiques au même hachage ou à un hachage similaire — utile pour la recherche d'images, l'authentification, l'indexation ou la détection de copies ainsi que le filigranage numérique. Pour chaque canal et pour les espaces colorimétriques sRGB et HCLp, 7 valeurs de hachage sont renvoyées. Pour une image sRGB, par exemple, attendez-vous à 42 hachages perceptuels.

@phash = $image->PerceptualHash();

Ping() est une méthode pratique qui renvoie des informations sur une image sans avoir à la lire en mémoire. Elle renvoie la largeur, la hauteur, la taille du fichier en octets et le format de fichier de l'image. Vous pouvez spécifier plusieurs noms de fichiers mais un seul descripteur de fichier :

($width, $height, $size, $format) = $image->Ping('logo.png');
($width, $height, $size, $format) = $image->Ping(file=>\*IMAGE);
($width, $height, $size, $format) = $image->Ping(blob=>$blob);

C'est une façon plus efficace et moins gourmande en mémoire d'interroger l'existence d'une image et ses caractéristiques.

Poly() construit un polynôme à partir de la séquence d'images et des termes correspondants (paires de coefficients et de degrés) :

$p = $image->Poly([0.5,1.0,0.25,2.0,1.0,1.0]);

PreviewImage() dispose en mosaïque 9 vignettes de l'image spécifiée avec une opération de traitement d'image appliquée à des intensités variables. Cela peut aider à cerner un paramètre approprié pour une opération de traitement d'image particulière. Choisissez parmi ces opérations : Rotate, Shear, Roll, Hue, Saturation, Brightness, Gamma, Spiff, Dull, Grayscale, Quantize, Despeckle, ReduceNoise, AddNoise, Sharpen, Blur, Threshold, EdgeDetect, Spread, Solarize, Shade, Raise, Segment, Swirl, Implode, Wave, OilPaint, CharcoalDrawing, JPEG. Voici un exemple :

$preview = $image->Preview('Gamma');
$preview->Display();

Pour avoir un contrôle total sur le positionnement du texte, vous avez besoin d'informations sur les métriques de police. Utilisez

($x_ppem, $y_ppem, $ascender, $descender, $width, $height, $max_advance) =
  $image->QueryFontMetrics(_parameters_);

où parameters est n'importe quel paramètre de la méthode Annotate. Les valeurs renvoyées sont :

1. largeur du caractère
2. hauteur du caractère
3. ascendante
4. descendante
5. largeur du texte
6. hauteur du texte
7. avancée horizontale maximale
8. limites : x1
9. limites : y1
10. limites : x2
11. limites : y2
12. origine : x
13. origine : y

Utilisez QueryMultilineFontMetrics() pour obtenir la largeur et la hauteur maximales du texte sur plusieurs lignes.

Appelez QueryColor() sans paramètre pour renvoyer une liste des noms de couleurs connus, ou spécifiez un ou plusieurs noms de couleurs pour obtenir ces attributs : valeurs rouge, vert, bleu et opacité.

@colors = $image->QueryColor();
($red, $green, $blue) = $image->QueryColor('cyan');
($red, $green, $blue, $alpha) = $image->QueryColor('#716baeff');

QueryColorname() accepte une valeur de couleur et renvoie son nom ou sa valeur hexadécimale correspondante ;

$name = $image->QueryColorname('rgba(80,60,0,0)');

Appelez QueryFont() sans paramètre pour renvoyer une liste des polices connues, ou spécifiez un ou plusieurs noms de polices pour obtenir ces attributs : nom de police, description, famille, style, étirement, graisse, encodage, fonderie, format, métriques et glyphes.

@fonts = $image->QueryFont();
$weight = ($image->QueryFont('Helvetica'))[5];

Appelez QueryFormat() sans paramètre pour renvoyer une liste des formats d'image connus, ou spécifiez un ou plusieurs noms de formats pour obtenir ces attributs : adjoin, prise en charge des blobs, raw, décodeur, encodeur, description et module.

@formats = $image->QueryFormat();
($adjoin, $blob_support, $raw, $decoder, $encoder, $description, $module) =
  $image->QueryFormat('gif');

Appelez MagickToMime() avec le nom du format d'image pour obtenir son type MIME, tel que image/tiff à partir de tif.

$mime = $image->MagickToMime('tif');

Utilisez RemoteCommand() pour envoyer une commande à une application display ou animate déjà en cours d'exécution. Le seul paramètre est le nom du fichier image à afficher ou à animer.

$image->RemoteCommand('image.jpg');

La méthode Smush() accole un ensemble d'images. Par exemple,

$p = $image->Smush(stack=>{true,false},offset=>integer);

accole toutes les images associées à l'objet $image. Par défaut, les images sont accolées de gauche à droite. Mettez stack à True pour les accoler de haut en bas.

Statistics() renvoie les statistiques d'image de chaque canal de l'image. Les valeurs renvoyées sont un tableau de valeurs de profondeur, minimum, maximum, moyenne, écart-type, kurtosis, asymétrie et entropie, dans l'ordre RGB, CMYK, RGBA ou CMYKA (selon le type d'image).

@statistics = $image->Statistics();

Enfin, la méthode Transform() accepte une spécification de géométrie pleinement qualifiée pour le rognage ou le redimensionnement d'une ou plusieurs images. Par exemple,

$p = $image->Transform(crop=>'100x100+0+0');

Vous pouvez éventuellement ajouter Image à n'importe lequel des noms de méthode ci-dessus. Par exemple, PingImage() est un alias de la méthode Ping().

Gestion des exceptions

Toutes les méthodes PerlMagick renvoient un contexte de chaîne indéfini en cas de succès. En cas de problème, l'erreur est renvoyée sous forme de chaîne contenant un code d'état numérique intégré. Un code d'état inférieur à 400 est un avertissement. Cela signifie que l'opération ne s'est pas terminée mais était récupérable dans une certaine mesure. Un code numérique supérieur ou égal à 400 est une erreur et indique que l'opération a complètement échoué. Voici comment les exceptions sont renvoyées pour les différentes méthodes :

Méthodes qui renvoient un nombre (par ex. Read(), Write()) :

$x = $image->Read(...);
warn "$x" if "$x";      # affiche le message d'erreur
$x =~ /(\d+)/;
print $1;               # affiche le numéro d'erreur
print 0+$x;             # affiche le nombre d'images lues

Méthodes qui opèrent sur une image (par ex. Resize(), Crop()) :

$x = $image->Crop(...);
warn "$x" if "$x";      # affiche le message d'erreur
$x =~ /(\d+)/;
print $1;               # affiche le numéro d'erreur

Les méthodes qui renvoient des images (EvaluateSequence(), Montage(), Clone()) doivent être vérifiées pour les erreurs ainsi :

$x = $image->Montage(...);
warn "$x" if !ref($x);  # affiche le message d'erreur
$x =~ /(\d+)/;
print $1;               # affiche le numéro d'erreur

Voici un exemple de message d'erreur :

Error 400: Memory allocation failed

Consultez la liste complète des codes d'erreur et d'avertissement.

Ce qui suit illustre comment utiliser un code d'état numérique :

$x = $image->Read('rose.png');
$x =~ /(\d+)/;
die "unable to continue" if ($1 == ResourceLimitError);

Constantes

PerlMagick inclut ces constantes :

BlobError
BlobWarning
CacheError
CacheWarning
CoderError
CoderWarning
ConfigureError
ConfigureWarning
CorruptImageError
CorruptImageWarning
DelegateError
DelegateWarning
DrawError
DrawWarning
ErrorException
FatalErrorException
FileOpenError
FileOpenWarning
ImageError
ImageWarning
MissingDelegateError
MissingDelegateWarning
ModuleError
ModuleWarning
Opaque
OptionError
OptionWarning
QuantumDepth
QuantumRange
RegistryError
RegistryWarning
ResourceLimitError
ResourceLimitWarning
StreamError
StreamWarning
Success
Transparent
TypeError
TypeWarning
WarningException
XServerError
XServerWarning

Vous pouvez y accéder ainsi :

Image::Magick->QuantumDepth