Instalación • Resumen • Script de ejemplo • Leer o escribir una imagen • Manipular una imagen • Establecer un atributo de imagen • Obtener un atributo de imagen • Comparar una imagen con su reconstrucción • Crear un montaje de imágenes • Trabajar con blobs • Acceso directo a los píxeles de la imagen • Métodos varios • Manejo de excepciones • Constantes

PerlMagick es una interfaz Perl orientada a objetos para ImageMagick. Use el módulo para leer, manipular o escribir una imagen o una secuencia de imágenes desde dentro de un script de Perl. Esto lo hace muy adecuado para scripts CGI web. Debe tener ImageMagick 6.5.5 o superior y Perl versión 5.005_02 o superior instalados en su sistema para que PerlMagick se compile correctamente.

Hay una serie de scripts útiles disponibles que le muestran el valor de PerlMagick. Puede realizar manipulación y conversión de imágenes basada en web con MagickStudio, o usar L-systems para crear imágenes de plantas mediante construcciones matemáticas, y finalmente navegar por colecciones de imágenes en miniatura y seleccionar la imagen a ver con el WebMagick Image Navigator.

Puede probar PerlMagick desde su navegador web en ImageMagick Studio. O bien, puede ver ejemplos de funciones selectas de PerlMagick.

Instalación

UNIX

¿Está PerlMagick disponible en el repositorio RPM de su sistema? Por ejemplo, en nuestro sistema CentOS, instalamos PerlMagick así:

yum install ImageMagick-perl

Si no, debe instalar PerlMagick desde la distribución de fuentes de ImageMagick. Descargue la última versión de fuentes.

Descomprima la distribución con este comando:

tar xvzf ImageMagick.tar.gz

A continuación configure y compile ImageMagick:

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

Si ImageMagick / PerlMagick se configuró y compiló sin problemas, está listo para instalarlo en su sistema. Se requieren privilegios de administrador para instalar. Para instalar, escriba

sudo make install

Es posible que necesite configurar los enlaces en tiempo de ejecución del enlazador dinámico:

sudo ldconfig /usr/local/lib

Por último, para verificar que la instalación de PerlMagick funcionó correctamente, escriba

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

Enhorabuena, tiene una distribución de ImageMagick funcional y está listo para usar PerlMagick para convertir, componer o editar sus imágenes.

Windows XP / Windows 2000

ImageMagick ya debe estar instalado en su sistema. Además, se requiere la distribución de fuentes de ImageMagick para Windows 2000. También debe tener nmake del entorno de desarrollo Visual C++ o J++. Copie \bin\IMagick.dll y \bin\X11.dll a un directorio dentro de su ruta de carga dinámica, como c:\perl\site\5.00502.

A continuación, escriba

cd PerlMagick
perl Makefile.nt
nmake
nmake install

Ejecución de las pruebas de regresión

Para verificar una instalación correcta, escriba

make test

Use nmake test en Windows. Hay algunos scripts de demostración disponibles para ejercitar muchas de las funciones que PerlMagick puede realizar.

Use la utilidad prove para ejecutar una prueba desde la carpeta de compilación:

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



cd demo
make

Ahora está listo para utilizar los métodos de PerlMagick desde dentro de sus scripts de Perl.

Resumen

Cualquier script que quiera usar los métodos de PerlMagick debe primero definir los métodos dentro de su espacio de nombres e instanciar un objeto de imagen. Hágalo con:

use Image::Magick;

$image = Image::Magick->new;

PerlMagick reconoce los cuánticos. Puede solicitar una profundidad cuántica específica al instanciar un objeto de imagen:

use Image::Magick::Q16;

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

El método new() toma los mismos parámetros que SetAttribute. Por ejemplo,

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

A continuación querrá leer una imagen o una secuencia de imágenes, manipularla y luego mostrarla o escribirla. Los métodos de entrada y salida de PerlMagick se definen en «Leer o escribir una imagen». Consulte «Establecer un atributo de imagen» para ver los métodos que afectan a la forma en que se lee o escribe una imagen. Consulte «Manipular una imagen» para ver una lista de métodos que transforman una imagen. «Obtener un atributo de imagen» describe cómo recuperar un atributo de una imagen. Consulte «Crear un montaje de imágenes» para ver los detalles sobre cómo disponer sus imágenes en mosaico como miniaturas sobre un fondo. Por último, algunos métodos no encajan claramente en ninguna de las categorías mencionadas. Revise «Métodos varios» para ver una lista de estos métodos.

Una vez que haya terminado con un objeto de PerlMagick, debería considerar destruirlo. Cada imagen de una secuencia de imágenes se almacena en memoria virtual. Esto puede acumular potencialmente mebibytes de memoria. Al destruir un objeto de PerlMagick, la memoria se devuelve para su uso por otros métodos de Perl. La forma recomendada de destruir un objeto es con undef:

undef $image;

Para eliminar todas las imágenes pero conservar el objeto Image::Magick use

@$image = ();

y finalmente, para eliminar una sola imagen de una secuencia de varias imágenes, use

undef $image->[$x];

La siguiente sección ilustra cómo usar varios métodos de PerlMagick para manipular una secuencia de imágenes.

Algunos de los métodos de PerlMagick requieren programas externos como Ghostscript. Esto puede requerir una ruta explícita en su variable de entorno PATH para funcionar correctamente. Por ejemplo (en Linux),

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

Script de ejemplo

Aquí tiene un script de ejemplo para empezar:

 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";

El script lee tres imágenes, las recorta y escribe una sola imagen como secuencia de animación GIF. En muchos casos puede que quiera acceder a imágenes individuales de una secuencia. El siguiente ejemplo ilustra cómo se hace esto:

 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');

Supongamos que quiere empezar con un lienzo blanco de 100 por 100 píxeles con un píxel rojo en el centro. Pruebe

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

Aquí reducimos a la mitad la intensidad del componente rojo en (1,1):

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

O supongamos que quiere convertir su imagen en color a escala de grises:

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

Anotemos una imagen con una fuente TrueType de Taipéi:

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

Quizá quiera extraer todas las intensidades de píxel de una imagen y escribirlas en STDOUT:

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

Otras cosas ingeniosas que puede hacer con los objetos de PerlMagick incluyen

$i = $#$p"+1";   # devuelve el número de imágenes asociadas al objeto p
push(@$q, @$p);  # añade las imágenes del objeto p al objeto q
@$p = ();        # elimina las imágenes pero no el objeto p
$p->Convolve([1, 2, 1, 2, 4, 2, 1, 2, 1]);   # núcleo gaussiano 3x3

Leer o escribir una imagen

Use los métodos listados abajo para leer, escribir o mostrar una imagen o una secuencia de imágenes:

Por comodidad, los métodos Write(), Display() y Animate() pueden tomar cualquier parámetro que SetAttribute conozca. Por ejemplo,

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

Use - como nombre de archivo en el método Read() para leer desde la entrada estándar o en el método Write() para escribir en la salida estándar:

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

Para leer una imagen en formato GIF desde un descriptor de archivo de PERL, use:

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

Para escribir una imagen en formato PNG en un descriptor de archivo de PERL, use:

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

Tenga en cuenta que leer o escribir en un descriptor de archivo de Perl puede fallar en Windows debido a versiones diferentes de las bibliotecas del entorno de ejecución de C entre ImageMagick y las distribuciones de ActiveState Perl, o si una de las DLL está enlazada con la opción /MT. Consulte Potential Errors Passing CRT Objects Across DLL Boundaries para una explicación.

Si aparece %0Nd, %0No o %0Nx en el nombre de archivo, se interpreta como una especificación de formato printf y la especificación se reemplaza por la codificación decimal, octal o hexadecimal especificada del número de escena. Por ejemplo,

image%03d.miff

convierte los archivos image000.miff, image001.miff, etc.

Opcionalmente puede añadir Image a cualquier nombre de método. Por ejemplo, ReadImage() es un alias del método Read().

Manipular una imagen

Una vez que crea una imagen con, por ejemplo, el método ReadImage(), puede que quiera operar sobre ella. A continuación se muestra una lista de todos los métodos de manipulación de imágenes disponibles con PerlMagick. Hay ejemplos de métodos selectos de PerlMagick. Aquí tiene un ejemplo de llamada a un método de manipulación de imágenes:

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

Y aquí tiene una lista de otros métodos de manipulación de imágenes que puede llamar:

Tenga en cuenta que el parámetro geometry es un atajo para los parámetros width y height (p. ej. geometry=>'106x80' equivale a width=>106, height=>80).

Puede especificar @filename tanto en Annotate() como en Draw(). Esto lee las instrucciones de texto o de primitiva gráfica de un archivo en disco. Por ejemplo,

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

equivale a

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

donde draw.txt es un archivo en disco que contiene esto:

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

El parámetro text de los métodos Annotate(), Comment(), Draw() y Label() puede incluir el nombre de archivo, el tipo, el ancho, el alto u otros atributos de la imagen incrustando estos caracteres de formato especiales:

%b   tamaño del archivo
%c   comentario
%d   directorio
%e   extensión del nombre de archivo
%f   nombre de archivo
%g   geometría de página
%h   alto
%i   nombre de archivo de entrada
%k   número de colores únicos
%l   etiqueta
%m   magick
%n   número de escenas
%o   nombre de archivo de salida
%p   número de página
%q   profundidad cuántica
%r   clase de imagen y espacio de color
%s   número de escena
%t   nombre de archivo sin directorio ni extensión
%u   nombre de archivo temporal único
%w   ancho
%x   resolución x
%y   resolución y
%z   profundidad de la imagen
%C   tipo de compresión de la imagen
%D   método dispose de la imagen
%H   alto de página
%Q   calidad de compresión de la imagen
%T   retardo de la imagen
%W   ancho de página
%X   desplazamiento x de página
%Y   desplazamiento y de página
%@   cuadro delimitador
%#   firma
%%   un signo de porcentaje
\n   nueva línea
\r   retorno de carro

Por ejemplo,

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

produce una anotación de MIFF:bird.miff 512x480 para una imagen titulada bird.miff y cuyo ancho es 512 y alto 480.

Opcionalmente puede añadir Image a cualquier nombre de método. Por ejemplo, TrimImage() es un alias del método Trim().

La mayoría de los atributos listados arriba tienen un análogo en magick. Consulte la documentación para una descripción más detallada de estos atributos.

Establecer un atributo de imagen

Use el método Set() para establecer un atributo de imagen. Por ejemplo,

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

Donde este ejemplo usa 'True' y este documento dice '{True, False}', puede usar las cadenas 'True' y 'False' sin distinción de mayúsculas y minúsculas, o puede usar los enteros 1 y 0.

Cuando llama a Get() sobre un atributo booleano, Image::Magick devuelve 1 o 0, no una cadena.

Y aquí tiene una lista de todos los atributos de imagen que puede establecer:

Tenga en cuenta que el parámetro geometry es un atajo para los parámetros width y height (p. ej. geometry=>'106x80' equivale a width=>106, height=>80).

SetAttribute() es un alias del método Set().

La mayoría de los atributos listados arriba tienen un análogo en magick. Consulte la documentación para una descripción más detallada de estos atributos.

Obtener un atributo de imagen

Use el método Get() para obtener un atributo de imagen. Por ejemplo,

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

Además de todos los atributos listados en «Establecer un atributo de imagen», puede obtener estos atributos adicionales:

GetAttribute() es un alias del método Get().

La mayoría de los atributos listados arriba tienen un análogo en magick. Consulte la documentación para una descripción más detallada de estos atributos.

Comparar una imagen con su reconstrucción

Anote matemática y visualmente la diferencia entre una imagen y su reconstrucción con el método Compare(). El método admite estos parámetros:

En este ejemplo, comparamos el logotipo de ImageMagick con una reconstrucción enfocada:

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();

Además del error cuadrático medio raíz informado de alrededor de 0,024, se muestra una imagen de diferencia para que pueda identificar visualmente la diferencia entre las imágenes.

Crear un montaje de imágenes

Use el método Montage() para crear una imagen compuesta combinando varias imágenes separadas. Las imágenes se disponen en mosaico sobre la imagen compuesta, con el nombre de la imagen apareciendo opcionalmente justo debajo de cada mosaico individual. Por ejemplo,

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

Y aquí tiene una lista de los parámetros de Montage() que puede establecer:

Tenga en cuenta que el parámetro geometry es un atajo para los parámetros width y height (p. ej. geometry=>'106x80' equivale a width=>106, height=>80).

MontageImage() es un alias del método Montage().

La mayoría de los atributos listados arriba tienen un análogo en montage. Consulte la documentación para una descripción más detallada de estos atributos.

Trabajar con blobs

Un blob contiene datos que representan directamente un formato de imagen particular en memoria en lugar de en disco. PerlMagick admite blobs en cualquiera de estos formatos de imagen y proporciona métodos para convertir un blob a o desde un formato de imagen particular.

ImageToBlob() devuelve los datos de la imagen en sus respectivos formatos. Luego puede imprimirlos, guardarlos en una base de datos ODBC, escribirlos en un archivo o canalizarlos a un programa de visualización:

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

El método BlobToImage() devuelve una imagen o una secuencia de imágenes convertida a partir del blob suministrado:

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

Acceso directo a los píxeles de la imagen

Use estos métodos para obtener acceso directo a los píxeles de la imagen:

Métodos varios

El método Append() añade un conjunto de imágenes. Por ejemplo,

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

añade todas las imágenes asociadas al objeto $image. De forma predeterminada, las imágenes se apilan de izquierda a derecha. Establezca stack en True para apilarlas de arriba a abajo.

El método Clone() copia un conjunto de imágenes. Por ejemplo,

$q = $p->Clone();

copia todas las imágenes del objeto $p a $q. Puede usar este método para secuencias de una sola imagen o de múltiples imágenes.

Coalesce() compone un conjunto de imágenes respetando los desplazamientos de página y los métodos de descarte (disposal). Las secuencias de animación GIF, MIFF y MNG normalmente comienzan con un fondo de imagen y cada imagen subsiguiente varía en tamaño y desplazamiento. Se devuelve una nueva secuencia de imágenes con todas las imágenes del mismo tamaño que el lienzo virtual de la primera imagen y compuestas con la siguiente imagen de la secuencia. Por ejemplo,

$q = $p->Coalesce();

El método ComplexImages() realiza operaciones matemáticas complejas sobre una secuencia de imágenes. Por ejemplo,

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

El método EvaluateImages() aplica una expresión aritmética, lógica o relacional a un conjunto de imágenes. Por ejemplo,

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

promedia todas las imágenes asociadas al objeto $image.

El método Features() devuelve las características de cada canal de la imagen en cada una de las cuatro direcciones (horizontal, vertical, diagonales izquierda y derecha) para la distancia especificada. Las características incluyen el segundo momento angular, el contraste, la correlación, la suma de cuadrados: varianza, el momento de diferencia inversa, la media de la suma, la varianza de la suma, la entropía de la suma, la entropía, la varianza de la diferencia, la entropía de la diferencia, las medidas de información de correlación 1, las medidas de información de correlación 2 y el coeficiente de correlación máxima. Valores en orden RGB, CMYK, RGBA o CMYKA (según el tipo de imagen).

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

El método Flatten() aplana un conjunto de imágenes y lo devuelve. Por ejemplo,

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

La secuencia de imágenes se reemplaza por una sola imagen creada componiendo cada imagen posterior a la primera sobre la primera imagen.

El método Fx() aplica una expresión matemática a un conjunto de imágenes y devuelve los resultados. Por ejemplo,

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

reemplaza el canal rojo con el promedio de los canales verde y azul.

Consulte FX, el operador de imagen de efectos especiales para una discusión detallada de este método.

Histogram() devuelve los colores únicos de la imagen y un recuento para cada uno. Los valores devueltos son un arreglo de valores de rojo, verde, azul, opacidad y recuento.

El método Morph() transforma (morphs) un conjunto de imágenes. Tanto los píxeles como el tamaño de la imagen se interpolan linealmente para dar la apariencia de una metamorfosis de una imagen a la siguiente:

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

donde frames es el número de imágenes intermedias a generar. El valor predeterminado es 1.

Mosaic() crea un mosaico a partir de una secuencia de imágenes.

El método Mogrify() es un único punto de entrada para los métodos de manipulación de imágenes (Manipular una imagen). Los parámetros son el nombre de un método seguido de los parámetros que el método pueda requerir. Por ejemplo, estas llamadas son equivalentes:

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

El método MogrifyRegion() aplica una transformación a una región de la imagen. Es similar a Mogrify() pero comienza con la geometría de la región. Por ejemplo, supongamos que quiere aclarar una región de 100x100 de su imagen en la ubicación (40, 50):

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

PerceptualHash() mapea imágenes visualmente idénticas al mismo hash o a uno similar; útil en la recuperación, autenticación, indexación o detección de copias de imágenes, así como en la marca de agua digital. Para cada canal y para los espacios de color sRGB y HCLp, se devuelven 7 valores de hash. Para una imagen sRGB, por ejemplo, espere 42 hashes perceptuales.

@phash = $image->PerceptualHash();

Ping() es un método de conveniencia que devuelve información sobre una imagen sin tener que leer la imagen en memoria. Devuelve el ancho, el alto, el tamaño del archivo en bytes y el formato del archivo de la imagen. Puede especificar más de un nombre de archivo, pero solo un descriptor de archivo:

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

Esta es una forma más eficiente y que consume menos memoria de consultar si una imagen existe y cuáles son sus características.

Poly() construye un polinomio a partir de la secuencia de imágenes y los términos correspondientes (pares de coeficientes y grados):

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

PreviewImage() dispone en mosaico 9 miniaturas de la imagen especificada con una operación de procesamiento de imágenes aplicada con intensidades variables. Esto puede ser útil para localizar un parámetro adecuado para una operación de procesamiento de imágenes particular. Elija entre estas operaciones: 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. Aquí tiene un ejemplo:

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

Para tener control total sobre el posicionamiento del texto necesita información de métrica de la fuente. Use

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

donde parameters es cualquier parámetro del método Annotate. Los valores devueltos son:

1. ancho del carácter
2. alto del carácter
3. ascendente
4. descendente
5. ancho del texto
6. alto del texto
7. avance horizontal máximo
8. límites: x1
9. límites: y1
10. límites: x2
11. límites: y2
12. origen: x
13. origen: y

Use QueryMultilineFontMetrics() para obtener el ancho y el alto máximos del texto para múltiples líneas de texto.

Llame a QueryColor() sin parámetros para devolver una lista de nombres de colores conocidos, o especifique uno o más nombres de colores para obtener estos atributos: valor de rojo, verde, azul y opacidad.

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

QueryColorname() acepta un valor de color y devuelve su nombre o valor hexadecimal respectivo;

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

Llame a QueryFont() sin parámetros para devolver una lista de fuentes conocidas, o especifique uno o más nombres de fuentes para obtener estos atributos: nombre de la fuente, descripción, familia, estilo, anchura (stretch), peso, codificación, fundición (foundry), formato, métricas y valores de glifos.

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

Llame a QueryFormat() sin parámetros para devolver una lista de formatos de imagen conocidos, o especifique uno o más nombres de formato para obtener estos atributos: adjoin, soporte de blob, raw, decodificador, codificador, descripción y módulo.

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

Llame a MagickToMime() con el nombre del formato de imagen para obtener su tipo MIME, como image/tiff a partir de tif.

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

Use RemoteCommand() para enviar un comando a una aplicación display o animate que ya esté en ejecución. El único parámetro es el nombre del archivo de imagen a mostrar o animar.

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

El método Smush() junta (smushes) un conjunto de imágenes. Por ejemplo,

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

junta todas las imágenes asociadas al objeto $image. De forma predeterminada, las imágenes se juntan de izquierda a derecha. Establezca stack en True para juntarlas de arriba a abajo.

Statistics() devuelve las estadísticas de imagen de cada canal de la imagen. Los valores devueltos son un arreglo de valores de profundidad, mínimos, máximos, media, desviación estándar, curtosis, asimetría y entropía en orden RGB, CMYK, RGBA o CMYKA (según el tipo de imagen).

@statistics = $image->Statistics();

Por último, el método Transform() acepta una especificación de geometría completamente cualificada para recortar o redimensionar una o más imágenes. Por ejemplo,

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

Opcionalmente puede añadir Image a cualquier nombre de método anterior. Por ejemplo, PingImage() es un alias del método Ping().

Manejo de excepciones

Todos los métodos de PerlMagick devuelven un contexto de cadena indefinido en caso de éxito. Si ocurre algún problema, el error se devuelve como una cadena con un código de estado numérico incrustado. Un código de estado menor que 400 es una advertencia. Esto significa que la operación no se completó pero fue recuperable en cierta medida. Un código numérico mayor o igual a 400 es un error e indica que la operación falló por completo. Así es como se devuelven las excepciones para los distintos métodos:

Métodos que devuelven un número (p. ej. Read(), Write()):

$x = $image->Read(...);
warn "$x" if "$x";      # imprime el mensaje de error
$x =~ /(\d+)/;
print $1;               # imprime el número de error
print 0+$x;             # imprime el número de imágenes leídas

Métodos que operan sobre una imagen (p. ej. Resize(), Crop()):

$x = $image->Crop(...);
warn "$x" if "$x";      # imprime el mensaje de error
$x =~ /(\d+)/;
print $1;               # imprime el número de error

Los métodos que devuelven imágenes (EvaluateSequence(), Montage(), Clone()) deben comprobarse en busca de errores de esta manera:

$x = $image->Montage(...);
warn "$x" if !ref($x);  # imprime el mensaje de error
$x =~ /(\d+)/;
print $1;               # imprime el número de error

Aquí tiene un ejemplo de mensaje de error:

Error 400: Memory allocation failed

Revise la lista completa de códigos de error y advertencia.

Lo siguiente ilustra cómo puede usar un código de estado numérico:

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

Constantes

PerlMagick incluye estas 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

Puede acceder a ellas así:

Image::Magick->QuantumDepth