Instalação • Visão geral • Script de exemplo • Ler ou gravar uma imagem • Manipular uma imagem • Definir atributos de imagem • Obter atributos de imagem • Comparar uma imagem com sua reconstrução • Criar uma montagem de imagens • Trabalhar com Blobs • Acesso direto aos pixels da imagem • Outros métodos • Tratamento de exceções • Constantes

O PerlMagick é uma interface Perl orientada a objetos para o ImageMagick. Use o módulo para ler, manipular ou gravar uma imagem ou sequência de imagens a partir de um script Perl. Isso o torna muito adequado para scripts CGI da Web. Para que o PerlMagick compile corretamente, você precisa ter o ImageMagick 6.5.5 ou superior e o Perl versão 5.005_02 ou superior instalados no seu sistema.

Há vários scripts úteis disponíveis que mostram o valor do PerlMagick. Você pode fazer manipulação e conversão de imagens baseadas na Web com o MagickStudio, ou usar L-systems para criar imagens de plantas usando construções matemáticas, e ainda navegar por coleções de miniaturas e selecionar a imagem a ser visualizada com o WebMagick Image Navigator.

Você pode experimentar o PerlMagick a partir do seu navegador Web no ImageMagick Studio. Ou pode ver exemplos de funções selecionadas do PerlMagick.

Instalação

UNIX

O PerlMagick está disponível no repositório RPM do seu sistema? Por exemplo, no nosso sistema CentOS, instalamos o PerlMagick assim:

yum install ImageMagick-perl

Se não estiver, você precisa instalar o PerlMagick a partir da distribuição de código-fonte do ImageMagick. Baixe a versão mais recente do código-fonte.

Descompacte a distribuição com este comando:

tar xvzf ImageMagick.tar.gz

Em seguida, configure e compile o ImageMagick:

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

Se o ImageMagick / PerlMagick foi configurado e compilado sem reclamações, você está pronto para instalá-lo no seu sistema. São necessários privilégios de administrador para instalar. Para instalar, digite

sudo make install

Talvez seja necessário configurar as ligações em tempo de execução do vinculador dinâmico:

sudo ldconfig /usr/local/lib

Por fim, para verificar se a instalação do PerlMagick funcionou corretamente, digite

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

Parabéns, você tem uma distribuição funcional do ImageMagick e está pronto para usar o PerlMagick para converter, compor ou editar suas imagens.

Windows XP / Windows 2000

O ImageMagick já deve estar instalado no seu sistema. Além disso, é necessária a distribuição de código-fonte do ImageMagick para Windows 2000. Você também precisa do nmake do ambiente de desenvolvimento Visual C++ ou J++. Copie \bin\IMagick.dll e \bin\X11.dll para um diretório no seu caminho de carregamento dinâmico, como c:\perl\site\5.00502.

Em seguida, digite

cd PerlMagick
perl Makefile.nt
nmake
nmake install

Executando os testes de regressão

Para verificar uma instalação correta, digite

make test

No Windows, use nmake test. Há alguns scripts de demonstração disponíveis para exercitar muitas das funções que o PerlMagick pode realizar.

Use o utilitário prove para executar um teste a partir da pasta de compilação:

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



cd demo
make

Agora você está pronto para utilizar os métodos do PerlMagick a partir dos seus scripts Perl.

Visão geral

Qualquer script que queira usar métodos do PerlMagick deve primeiro definir os métodos dentro do seu namespace e instanciar um objeto de imagem. Faça isso com:

use Image::Magick;

$image = Image::Magick->new;

O PerlMagick reconhece quantum. Você pode solicitar uma profundidade de quantum específica ao instanciar um objeto de imagem:

use Image::Magick::Q16;

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

O método new() aceita os mesmos parâmetros que SetAttribute. Por exemplo,

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

Em seguida, você vai querer ler uma imagem ou sequência de imagens, manipulá-la e então exibi-la ou gravá-la. Os métodos de entrada e saída do PerlMagick estão definidos em "Ler ou gravar uma imagem". Consulte "Definir atributos de imagem" para os métodos que afetam a forma como uma imagem é lida ou gravada. Consulte "Manipular uma imagem" para obter uma lista de métodos que transformam uma imagem. "Obter atributos de imagem" descreve como recuperar um atributo de uma imagem. Consulte "Criar uma montagem de imagens" para detalhes sobre como dispor suas imagens em mosaico como miniaturas sobre um fundo. Por fim, alguns métodos não se encaixam perfeitamente em nenhuma das categorias mencionadas. Consulte "Outros métodos" para obter uma lista desses métodos.

Quando terminar de usar um objeto PerlMagick, considere destruí-lo. Cada imagem de uma sequência de imagens é armazenada em memória virtual. Isso pode somar potencialmente vários mebibytes de memória. Ao destruir um objeto PerlMagick, a memória é devolvida para uso por outros métodos do Perl. A forma recomendada de destruir um objeto é com undef:

undef $image;

Para excluir todas as imagens, mas manter o objeto Image::Magick, use

@$image = ();

e, por fim, para excluir uma única imagem de uma sequência de várias imagens, use

undef $image->[$x];

A próxima seção ilustra como usar vários métodos do PerlMagick para manipular uma sequência de imagens.

Alguns métodos do PerlMagick requerem programas externos como o Ghostscript. Isso pode exigir um caminho explícito na sua variável de ambiente PATH para funcionar corretamente. Por exemplo (no Linux),

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

Script de exemplo

Aqui está um script de exemplo para você começar:

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

O script lê três imagens, recorta-as e grava uma única imagem como sequência de animação GIF. Em muitos casos, você pode querer acessar imagens individuais de uma sequência. O próximo exemplo ilustra como isso é feito:

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

Suponha que você queira começar com uma tela branca de 100 por 100 pixels com um pixel vermelho no centro. Tente

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

Aqui reduzimos pela metade a intensidade do componente vermelho em (1,1):

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

Ou suponha que você queira converter sua imagem colorida para tons de cinza:

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

Vamos anotar uma imagem com uma fonte TrueType de Taipei:

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

Talvez você queira extrair todas as intensidades de pixel de uma imagem e gravá-las em STDOUT:

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

Outras coisas engenhosas que você pode fazer com objetos PerlMagick incluem

$i = $#$p"+1";   # retorna o número de imagens associadas ao objeto p
push(@$q, @$p);  # empurra as imagens do objeto p para o objeto q
@$p = ();        # exclui as imagens, mas não o objeto p
$p->Convolve([1, 2, 1, 2, 4, 2, 1, 2, 1]);   # kernel gaussiano 3x3

Ler ou gravar uma imagem

Use os métodos listados abaixo para ler, gravar ou exibir uma imagem ou sequência de imagens:

Por conveniência, os métodos Write(), Display() e Animate() podem aceitar qualquer parâmetro que SetAttribute conheça. Por exemplo,

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

Use - como nome de arquivo no método Read() para ler da entrada padrão ou no método Write() para gravar na saída padrão:

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

Para ler uma imagem no formato GIF a partir de um filehandle do PERL, use:

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

Para gravar uma imagem no formato PNG em um filehandle do PERL, use:

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

Observe que a leitura ou gravação a partir de um filehandle do Perl pode falhar no Windows devido a versões diferentes das bibliotecas de tempo de execução C entre as distribuições do ImageMagick e do ActiveState Perl, ou se uma das DLLs for vinculada com a opção /MT. Consulte Potential Errors Passing CRT Objects Across DLL Boundaries para uma explicação.

Se %0Nd, %0No ou %0Nx aparecerem no nome do arquivo, eles são interpretados como uma especificação de formato printf, e a especificação é substituída pela codificação decimal, octal ou hexadecimal especificada do número da cena. Por exemplo,

image%03d.miff

converte os arquivos image000.miff, image001.miff, etc.

Você pode opcionalmente adicionar Image a qualquer nome de método. Por exemplo, ReadImage() é um alias para o método Read().

Manipular uma imagem

Depois de criar uma imagem com, por exemplo, o método ReadImage(), você pode querer operar sobre ela. Abaixo está uma lista de todos os métodos de manipulação de imagem disponíveis para você no PerlMagick. Há exemplos de métodos selecionados do PerlMagick. Aqui está um exemplo de chamada a um método de manipulação de imagem:

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

E aqui está uma lista de outros métodos de manipulação de imagem que você pode chamar:

Observe que o parâmetro geometry é um atalho para os parâmetros width e height (por exemplo, geometry=>'106x80' é equivalente a width=>106, height=>80).

Você pode especificar @filename tanto em Annotate() quanto em Draw(). Isso lê as instruções de texto ou de primitivas gráficas de um arquivo no disco. Por exemplo,

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

é equivalente a

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

onde draw.txt é um arquivo no disco que contém isto:

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

O parâmetro text dos métodos Annotate(), Comment(), Draw() e Label() pode incluir o nome do arquivo, tipo, largura, altura ou outro atributo da imagem, incorporando estes caracteres especiais de formato:

%b   tamanho do arquivo
%c   comentário
%d   diretório
%e   extensão do nome do arquivo
%f   nome do arquivo
%g   geometria da página
%h   altura
%i   nome do arquivo de entrada
%k   número de cores únicas
%l   rótulo
%m   magick
%n   número de cenas
%o   nome do arquivo de saída
%p   número da página
%q   profundidade de quantum
%r   classe da imagem e espaço de cor
%s   número da cena
%t   nome do arquivo sem diretório e extensão
%u   nome de arquivo temporário único
%w   largura
%x   resolução x
%y   resolução y
%z   profundidade da imagem
%C   tipo de compressão da imagem
%D   método de descarte (dispose) da imagem
%H   altura da página
%Q   qualidade de compressão da imagem
%T   atraso da imagem
%W   largura da página
%X   deslocamento x da página
%Y   deslocamento y da página
%@   caixa delimitadora
%#   assinatura
%%   sinal de porcentagem
\n   nova linha
\r   retorno de carro

Por exemplo,

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

produz uma anotação MIFF:bird.miff 512x480 para uma imagem intitulada bird.miff cuja largura é 512 e altura é 480.

Você pode opcionalmente adicionar Image a qualquer nome de método. Por exemplo, TrimImage() é um alias para o método Trim().

A maioria dos atributos listados acima tem um análogo no magick. Consulte a documentação para uma descrição mais detalhada desses atributos.

Definir atributos de imagem

Use o método Set() para definir um atributo de imagem. Por exemplo,

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

Onde este exemplo usa 'True' e este documento diz '{True, False}', você pode usar as strings sem distinção de maiúsculas/minúsculas 'True' e 'False', ou pode usar os inteiros 1 e 0.

Quando você chama Get() em um atributo booleano, o Image::Magick retorna 1 ou 0, não uma string.

E aqui está uma lista de todos os atributos de imagem que você pode definir:

Observe que o parâmetro geometry é um atalho para os parâmetros width e height (por exemplo, geometry=>'106x80' é equivalente a width=>106, height=>80).

SetAttribute() é um alias para o método Set().

A maioria dos atributos listados acima tem um análogo no magick. Consulte a documentação para uma descrição mais detalhada desses atributos.

Obter atributos de imagem

Use o método Get() para obter um atributo de imagem. Por exemplo,

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

Além de todos os atributos listados em "Definir atributos de imagem", você pode obter estes atributos adicionais:

GetAttribute() é um alias para o método Get().

A maioria dos atributos listados acima tem um análogo no magick. Consulte a documentação para uma descrição mais detalhada desses atributos.

Comparar uma imagem com sua reconstrução

Com o método Compare(), anote matemática e visualmente a diferença entre uma imagem e sua reconstrução. O método suporta estes parâmetros:

Neste exemplo, comparamos o logotipo do ImageMagick com uma reconstrução aguçada:

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

Além do erro quadrático médio reportado de cerca de 0,024, é exibida uma imagem de diferença para que você possa identificar visualmente a diferença entre as imagens.

Criar uma montagem de imagens

Use o método Montage() para criar uma imagem composta combinando várias imagens separadas. As imagens são dispostas em mosaico sobre a imagem composta, com o nome da imagem aparecendo opcionalmente logo abaixo de cada ladrilho. Por exemplo,

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

E aqui está uma lista de parâmetros do Montage() que você pode definir:

Observe que o parâmetro geometry é um atalho para os parâmetros width e height (por exemplo, geometry=>'106x80' é equivalente a width=>106, height=>80).

MontageImage() é um alias para o método Montage().

A maioria dos atributos listados acima tem um análogo no montage. Consulte a documentação para uma descrição mais detalhada desses atributos.

Trabalhar com Blobs

Um blob contém dados que representam diretamente um formato de imagem específico na memória, em vez de no disco. O PerlMagick suporta blobs em qualquer um destes formatos de imagem e fornece métodos para converter um blob de ou para um formato de imagem específico.

ImageToBlob() retorna os dados da imagem em seus respectivos formatos. Você pode então imprimi-los, salvá-los em um banco de dados ODBC, gravá-los em um arquivo ou enviá-los por pipe a um programa de exibição:

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

O método BlobToImage() retorna uma imagem ou sequência de imagens convertida a partir do blob fornecido:

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

Acesso direto aos pixels da imagem

Use estes métodos para obter acesso direto aos pixels da imagem:

Outros métodos

O método Append() anexa um conjunto de imagens. Por exemplo,

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

anexa todas as imagens associadas ao objeto $image. Por padrão, as imagens são empilhadas da esquerda para a direita. Defina stack como True para empilhá-las de cima para baixo.

O método Clone() copia um conjunto de imagens. Por exemplo,

$q = $p->Clone();

copia todas as imagens do objeto $p para $q. Você pode usar este método para sequências de imagem única ou de múltiplas imagens.

Coalesce() compõe um conjunto de imagens respeitando quaisquer deslocamentos de página e métodos de descarte. As sequências de animação GIF, MIFF e MNG normalmente começam com uma imagem de fundo, e cada imagem subsequente varia em tamanho e deslocamento. É retornada uma nova sequência de imagens, todas do mesmo tamanho da tela virtual da primeira imagem e compostas com a próxima imagem da sequência. Por exemplo,

$q = $p->Coalesce();

O método ComplexImages() realiza operações matemáticas com números complexos sobre uma sequência de imagens. Por exemplo,

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

O método EvaluateImages() aplica uma expressão aritmética, lógica ou relacional a um conjunto de imagens. Por exemplo,

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

calcula a média de todas as imagens associadas ao objeto $image.

O método Features() retorna as características (features) de cada canal da imagem em cada uma das quatro direções (horizontal, vertical e as diagonais esquerda e direita) para a distância especificada. As características incluem o momento angular de segunda ordem, contraste, correlação, soma de quadrados: variância, momento de diferença inversa, média da soma, variância da soma, entropia da soma, entropia, variância da diferença, entropia da diferença, medidas de informação de correlação 1, medidas de informação de correlação 2 e coeficiente de correlação máximo. Os valores estão na ordem RGB, CMYK, RGBA ou CMYKA (dependendo do tipo da imagem).

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

O método Flatten() achata um conjunto de imagens e o retorna. Por exemplo,

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

A sequência de imagens é substituída por uma única imagem criada compondo cada imagem após a primeira sobre a primeira imagem.

O método Fx() aplica uma expressão matemática a um conjunto de imagens e retorna os resultados. Por exemplo,

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

substitui o canal vermelho pela média dos canais verde e azul.

Consulte FX, o operador de imagem de efeitos especiais para uma discussão detalhada deste método.

Histogram() retorna as cores únicas da imagem e uma contagem para cada uma. Os valores retornados são um array de valores de vermelho, verde, azul, opacidade e contagem.

O método Morph() faz a transição (morph) de um conjunto de imagens. Tanto os pixels quanto o tamanho da imagem são interpolados linearmente para dar a aparência de uma metamorfose de uma imagem para a próxima:

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

onde frames é o número de imagens intermediárias a gerar. O padrão é 1.

Mosaic() cria um mosaico a partir de uma sequência de imagens.

O método Mogrify() é um ponto de entrada único para os métodos de manipulação de imagem ("Manipular uma imagem"). Os parâmetros são o nome de um método seguido de quaisquer parâmetros que o método possa exigir. Por exemplo, estas chamadas são equivalentes:

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

O método MogrifyRegion() aplica uma transformação a uma região da imagem. É semelhante ao Mogrify(), mas começa com a geometria da região. Por exemplo, suponha que você queira clarear uma região de 100x100 da sua imagem na posição (40, 50):

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

PerceptualHash() mapeia imagens visualmente idênticas para o mesmo hash, ou para um hash semelhante — útil em recuperação, autenticação, indexação ou detecção de cópias de imagens, bem como em marcas d'água digitais. Para cada canal e para os espaços de cor sRGB e HCLp, são retornados 7 valores de hash. Para imagens sRGB, por exemplo, espere 42 hashes perceptuais.

@phash = $image->PerceptualHash();

Ping() é um método de conveniência que retorna informações sobre uma imagem sem precisar lê-la na memória. Ele retorna a largura, a altura, o tamanho do arquivo em bytes e o formato do arquivo da imagem. Você pode especificar mais de um nome de arquivo, mas apenas um filehandle:

($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 é uma forma mais eficiente e que consome menos memória de consultar se uma imagem existe e quais são suas características.

Poly() constrói um polinômio a partir da sequência de imagens e dos termos correspondentes (pares de coeficiente e grau):

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

PreviewImage() dispõe em mosaico 9 miniaturas da imagem especificada com uma operação de processamento de imagem aplicada em intensidades variadas. Isso pode ajudar a determinar um parâmetro apropriado para uma operação de processamento de imagem específica. Escolha entre estas operações: 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. Aqui está um exemplo:

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

Para ter controle total sobre o posicionamento do texto, você precisa de informações de métrica da fonte. Use

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

onde parameters é qualquer parâmetro do método Annotate. Os valores retornados são:

1. largura do caractere
2. altura do caractere
3. ascendente
4. descendente
5. largura do texto
6. altura do texto
7. avanço horizontal máximo
8. limites: x1
9. limites: y1
10. limites: x2
11. limites: y2
12. origem: x
13. origem: y

Use QueryMultilineFontMetrics() para obter a largura e a altura máximas do texto para múltiplas linhas de texto.

Chame QueryColor() sem parâmetros para retornar uma lista de nomes de cores conhecidos, ou especifique um ou mais nomes de cores para obter estes atributos: valores de vermelho, verde, azul e opacidade.

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

QueryColorname() aceita um valor de cor e retorna seu respectivo nome ou valor hexadecimal:

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

Chame QueryFont() sem parâmetros para retornar uma lista de fontes conhecidas, ou especifique um ou mais nomes de fontes para obter estes atributos: nome da fonte, descrição, família, estilo, esticamento (stretch), peso, codificação, fundição (foundry), formato, métricas e glifos.

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

Chame QueryFormat() sem parâmetros para retornar uma lista de formatos de imagem conhecidos, ou especifique um ou mais nomes de formatos para obter estes atributos: adjoin, suporte a blob, raw, decodificador, codificador, descrição e módulo.

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

Chame MagickToMime() com o nome do formato da imagem para obter seu tipo MIME, como image/tiff a partir de tif.

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

Use RemoteCommand() para enviar um comando a uma aplicação display ou animate já em execução. O único parâmetro é o nome do arquivo de imagem a exibir ou animar.

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

O método Smush() une um conjunto de imagens de forma justaposta. Por exemplo,

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

une de forma justaposta todas as imagens associadas ao objeto $image. Por padrão, as imagens são justapostas da esquerda para a direita. Defina stack como True para justapô-las de cima para baixo.

Statistics() retorna as estatísticas da imagem para cada canal da imagem. Os valores retornados são um array de valores de profundidade, mínimo, máximo, média, desvio padrão, curtose, assimetria e entropia, na ordem RGB, CMYK, RGBA ou CMYKA (dependendo do tipo da imagem).

@statistics = $image->Statistics();

Por fim, o método Transform() aceita uma especificação de geometria totalmente qualificada para recortar ou redimensionar uma ou mais imagens. Por exemplo,

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

Você pode opcionalmente adicionar Image a qualquer nome de método acima. Por exemplo, PingImage() é um alias para o método Ping().

Tratamento de exceções

Todos os métodos do PerlMagick retornam um contexto de string indefinido em caso de sucesso. Se ocorrer algum problema, o erro é retornado como uma string com um código numérico de status incorporado. Um código de status menor que 400 é um aviso. Isso significa que a operação não foi concluída, mas era recuperável até certo ponto. Um código numérico maior ou igual a 400 é um erro e indica que a operação falhou completamente. Veja como as exceções são retornadas pelos diferentes métodos:

Métodos que retornam um número (por exemplo, Read(), Write()):

$x = $image->Read(...);
warn "$x" if "$x";      # imprime a mensagem de erro
$x =~ /(\d+)/;
print $1;               # imprime o número do erro
print 0+$x;             # imprime o número de imagens lidas

Métodos que operam sobre uma imagem (por exemplo, Resize(), Crop()):

$x = $image->Crop(...);
warn "$x" if "$x";      # imprime a mensagem de erro
$x =~ /(\d+)/;
print $1;               # imprime o número do erro

Os métodos que retornam imagens (EvaluateSequence(), Montage(), Clone()) devem ser verificados quanto a erros desta forma:

$x = $image->Montage(...);
warn "$x" if !ref($x);  # imprime a mensagem de erro
$x =~ /(\d+)/;
print $1;               # imprime o número do erro

Aqui está um exemplo de mensagem de erro:

Error 400: Memory allocation failed

Consulte a lista completa de códigos de erro e aviso.

O exemplo a seguir mostra como você pode usar um código numérico de status:

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

Constantes

O PerlMagick inclui 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

Você pode acessá-las assim:

Image::Magick->QuantumDepth