Tutorial Programação - Um tutorial para usuários do GIMP -Perl

de Ed J

Atualizado para o Gimp 2.8 / Gimp-Perl 2.3

Índice

• 1. Notas de versão
• 2. Antecedentes
• 3. O que você precisa
• 4. O módulo Gimp
• 5. O PDB do GIMP
  • 5.1. Gimp :: Fu e a função podregister
  • 5.2. parâmetros podregister
  • 5.3. Um script comentado
• 6. Sintaxe orientada a objetos
• 7. Áreas de pintura com seleções
  • 7.1. Seleções complexas
  • 7.2. rotações
• 8. Criando texto
  • 8.1. Hello World - escrevendo texto em uma imagem
• 9. Seleções flutuantes
• 10. O Servidor Perl e Scripts Independentes
  • 10.1. Uma concha para Gimp-Perl
• 11. notas finais
• 12. Links e referências

1. Notas de versão 

Este trabalho é uma versão ligeiramente modificada do excelente tutorial de Dov Grobgeld. Ele foi atualizado para o Gimp-Perl 2.3 e o GIMP 2.8.

2. Contexto 

Uma das características maravilhosas do GIMP é que toda a sua funcionalidade pode ser acessada através de scripts. Ambientes de scripts disponíveis incluem Scheme por meio de Script-Fu e Python.

Perl tem CPAN , dando acesso a um grande número de módulos para fazer as coisas.Agora, o GIMP também pode ser roteirizado em Perl. Este tutorial descreverá como escrever esses plug-ins e scripts para o Gimp.

Como há vários excelentes textos de tutorial descrevendo a linguagem perl, este tutorial assumirá um conhecimento prático do Perl e, ao invés disso, se concentrará no uso do GIMP junto com os módulos perl Gimp e Gimp :: Fu.

3. O que você precisa 

Os scripts do tutorial foram testados no Linux (uma versão do Windows está em andamento) com as seguintes versões:

1. Gimp versão 2.8.10.
2. Perl versão 5.14 ou posterior.
3. O módulo perl Gtk2, versão 1.249, disponível em http://gtk2-perl.sourceforge.net
4. O módulo Gimp-Perl, versão 2.3 ou posterior, disponível em http://search.cpan.org/dist/Gimp/

O Perl e todos os seus módulos associados estão disponíveis na forma de código-fonte da rede Comprehensive Perl Archive, CPAN .

4. O módulo Gimp 

A maioria dos scripts faz uso da interface simplificada Gimp :: Fu fornecida com o módulo Gimp. O Gimp :: Fu fornece uma estrutura para inserir parâmetros no script em uma interface de caixa de diálogo, assim como o Script-Fu, mas também permite a execução do script no modo batch a partir da linha de comando. Este tutorial vai entrar em descrições detalhadas da construção de um script Gimp :: Fu, mas antes de fazer isso, aqui está o quadro geral de tal script.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

#! / usr / bin / perl -w use o Gimp ; use Gimp :: Fu ; podregister { código # ... }; saída principal ; __FIM__ = head1 NAME test_exception - exceda as exceções de teste do filtro gimp-perl = head1 SINOPSE <Image> / Filters / Languages ​​/ _Perl / _Test / Exception = head1 DESCRIÇÃO Exercício de exceções Gimp-Perl. = head1 AUTHOR O autor. = head1 DATE 20140310 = head1 LICENSE Os termos de licenciamento.

Os principais pontos a serem observados no script são:

• o uso dos dois módulos Gimp e Gimp::Fu ,
• a função podregister, que será descrita em detalhes abaixo,
• a maneira como o controle é entregue ao módulo Gimp na linha 8, e
• a documentação do POD abaixo da linha __END__ .

5. O PDB do 

Antes de entrar nos detalhes do script Gimp :: Fu, descreveremos como acessar a funcionalidade do GIMP . Todas as funções conhecidas do GIMP estão disponíveis através do banco de dados procedural ( PDB ). Todas as funções do PDB podem ser chamadas a partir do perl, como será visto abaixo. Essas funções do PDB são internas ao GIMP ou disponibilizadas por meio de um plug-in ou de uma extensão de script, mas, no que diz respeito ao chamador, não há diferença. Como veremos abaixo, quando uma função perl é registrada através da função podregister , ela também aparecerá no PDB .

O Gimp vem com um navegador PDB disponível no Navegador de Ajuda / Procedimento . Este navegador fornece uma maneira de ver todas as funções no PDB , bem como seus parâmetros de entrada e saída. Por exemplo, a entrada do DBBrowser para plug-in-gauss-iir , que será usada no exemplo abaixo, é semelhante a esta:

Nome:	plug-in-gauss-iir
Síntese:	Aplique um desfoque gaussiano
Dentro:	INT32	modo corrida	O modo de execução { RUN - INTERACTIVE (0), RUN - NONINTERACTIVE (1)}
	IMAGEM	imagem	Imagem de entrada (não utilizada)
	DESENHAVEL	desenhavel	Entrada drawable
	FLUTUADOR	raio	Raio de desfoque gaussiano (em pixels,> 0,0)
	INT32	horizontal	Borrão na direção horizontal
	INT32	vertical	Borrão na direção vertical
Socorro:	Aplica um desfoque gaussiano ao drawable, com raio de efeito especificado. O desvio padrão da distribuição normal usada para modificar os valores de pixels é calculado com base no raio fornecido. O desfoque horizontal e vertical pode ser invocado independentemente, especificando apenas um para ser executado. O desfoque gaussiano IIR funciona melhor para valores de raio grande e para imagens que não são geradas por computador.

Todas as constantes mencionadas no Explorer do PDB foram definidas dentro do Gimp :: Fu e podem ser usadas dentro do perl. Por exemplo, uma chamada para desfocar uma imagem é a seguinte:

  Gimp :: Plugin -> gauss_iir ( $ imagem , $ drawable , 50 , 6 , 6 );

Note que o Perl está usando caracteres de sublinhado onde o navegador do banco de dados usa hífens! A entrada do PDB acima mostra que plug-in-gauss-iir é chamado com vários parâmetros, de vários tipos. Estes serão explicados abaixo.

Você também verá que o primeiro parâmetro, run-mode , foi omitido. Este é um recurso do Gimp-Perl, que fornecerá automaticamente esse parâmetro se você o deixar desligado. Isso tornará seu código muito mais organizado.

Scripts Script-Fu são chamados como qualquer outro script de acordo com a assinatura do PDB no navegador PDB . Por exemplo, para executar o script-fu-basic1-logo, faça:

  script_fu_basic1_logo ( " Olá " , 72 ,
                       " Utopia 72" , 
                       [ 0 , 0 , 0 ], [ 255 , 255 , 255 ]);

5.1. Gimp :: Fu e a função podregister 

Gimp :: Fu é a resposta de Perl para Script-Fu. Ele fornece um método simplificado para aceitar parâmetros para um script através de uma interface Gtk2, assim como o script-fu, mas como veremos abaixo, ele possui alguns sinos e assobios adicionais.

A função principal para um script Gimp-Fu é a função podregister . Esta função declara a interface do script para o GIMP . A função podregister fornece ao GIMPas seguintes informações, a partir de várias seções de seu POD (documentação antiga simples) :

• O nome da função. Vem da primeira parte da seção NAME , antes do traço. Diz ao GIMP o nome pelo qual a função será conhecida no PDB .
• Uma pequena descrição, da seção NAME , após o traço.
• Um texto de ajuda, da seção DESCRIÇÃO .
• O nome do autor, da seção AUTOR .
• Os direitos autorais do script, da seção LICENSE .
• Data de criação - qualquer texto, da seção DATE .
• Caminho do menu - uma string, da seção SINOPSE . O caminho pode levar esses formulários, embora existam outras opções:
  • " <Image> / Filters / Menu / Script Name"
  • “ <Toolbox> / Xtns / Perl / Script Name” Se você especificar “<Image>”, o script espera operar ou criar uma imagem. Neste caso, o Gimp :: Fu adicionará como os dois primeiros parâmetros ao script a imagem e o drawable ativos quando o script foi invocado. Se, no entanto, os “tipos de imagem” forem deixados em branco ou não especificados, espera-se que o plugin crie e, portanto, retorne uma imagem (e ela normalmente será colocada sob o menu Arquivo / Criar).
  Se você especificar “<Toolbox>”, então o script é um script autônomo que aparece na hierarquia de menu em Filters (isso é uma coisa histórica) e pega todas as suas entradas através do diálogo da interface do Gimp :: Fu.
• Os tipos de imagem aceitáveis, da seção IMAGE TYPES - uma string. Esta lista contém uma lista de tipos de imagem aceitáveis. Este campo é usado apenas para scripts que estão na hieararquia “<Image>”. Alguns valores possíveis estão listados na tabela abaixo:

  valor	significado
  *	Todas as imagens são aceitas
  RGB	Imagens RGB
  RGBA	Imagens RGB com canais alfa
  CINZENTO	Imagens de nível de cinza
  	(deixado em branco ou sem essa seção) Não pega imagem como entrada, retorna uma imagem. Gimp :: Fu irá adicionar automaticamente esse valor de retorno.
• Parâmetros da seção PARÂMETROS . Este será o código Perl, que o Gimp :: Fu avalia como uma lista de parâmetros. Cada parâmetro, por sua vez, é uma referência a uma matriz contendo os seguintes quatro ou cinco valores (uma referência a uma matriz em Perl é simplesmente uma matriz escrita entre colchetes):
  • O tipo do parâmetro. Os tipos reconhecidos pelo Gimp :: Fu e suas contrapartes Perl são fornecidos na tabela a seguir:

    Tipo	Formulários possíveis	Comente
    PF_INT32  PF_INT16  PF_INT8	42	Um inteiro.
    PF_FLOAT	3,114	Um número de ponto flutuante.
    PF_TOGGLE	0  1	Um valor booleano.
    PF_SLIDER  PF_SPINNER	Um valor inteiro através de um controle deslizante e uma interface giratória. O parâmetro range deve ser especificado e é interpretado como mínimo, máximo e passo, por exemplo, [0,100,1].
    PF_FONT	“Arial”	Um nome de fonte.
    PF_STRING	"Uma linha"	Uma linha
    PF_COLOR  PF_COLOUR	[255,127,0]  # ff7f00	Uma cor pode ser expressa como uma referência a uma matriz de três componentes ou como um triplo hexadecimal, seguido pelo sinal de hash.
    PF_TOGGLE	0  1	Um boolean alternar
    PF_IMAGE	-	Uma imagem
    PF_DRAWABLE	-	Um drawable.
    PF_BRUSH		Uma escova
    PF_GRADIENT		Um gradiente
    PF_PATTERN		Um padrão
  • O nome do parâmetro - uma string.
  • Um texto de ajuda para o parâmetro.
  • Valor padrão para o parâmetro. Isso deve ser dado na forma listada na tabela acima.
  • Uma matriz que define o intervalo permitido para o valor. Isso é usado apenas para PF_SLIDER e PF_SPINNER.
• Opcionalmente, os tipos de retorno da função podem ser fornecidos a partir de uma seção RETURN VALUES . Isso é especificado da mesma maneira que os parâmetros acima. Não há nenhum argumento padrão ou extra requerido.
• O código perl que implementa a função - mais comumente com uma sub-referência, rodeada de “{” e “}”, como abaixo - graças à prototipagem de Perl, você não precisa especificar “sub”. Isso será chamado quando a entrada do menu associado for declarada pelo caminho do menu descrito acima.Quando o sub é chamado, é passado uma lista de parâmetros conforme declarado no campo 9. No caso de um script “<Image>…”, a imagem ativa e o drawable (camada ou canal) serão passados ​​como primeiro e segundo parâmetros. Graças à magia da filtragem de fontes Perl, você não precisa declarar suas variáveis, mas pode simplesmente usá-las:

    podregister {
     $ drawable -> gauss_iir ( $ radius , $ horizontal , $ vertical );
   };
   # ...
   = head1 PARÂMETROS
  
     [ PF_FLOAT , 'radius' , "Radius" , 50.0 ],
     [ PF_INT32 , 'horizontal' , 'Horizontal blur' , 6 ],
     [ PF_INT32 , 'vertical' , ' Desfoque vertical ' , 6 ],
  

  Você também notará que “plug_in_” foi omitido da chamada de método acima, e que nem todos os seus parâmetros parecem estar sendo passados!Isso é graças à implementação orientada a objeto no Gimp-Perl, que, quando recebe um nome de método, pesquisa vários prefixos para a função subjacente, incluindo os relacionados ao plug-in (incluindo script_fu_ ).
  O código normalmente exibirá uma nova imagem se ela criar uma, e também retornará a nova imagem, de acordo com os tipos de retorno declarados no parâmetro 10 da chamada de registro do conjunto descrita acima. Isso permite que os scripts Gimp :: Fu sejam usados ​​de forma não interativa por outros scripts. Mais sobre esse comportamento abaixo.

5.2. parâmetros podregister 

Você terá notado acima que os parâmetros para a função dada ao podregisterusaram os parâmetros nomeados no POD ou fornecidos pelo Gimp :: Fu , como $ drawable . Isso ocorre porque o podregister disponibiliza automaticamente à sua função todas as variáveis ​​declaradas na documentação do POD (a seção “ PARÂMETROS ”) ou adicionadas dependendo de seus “tipos de imagem”.

5.3. Um script comentado 

O exemplo de script Gimp :: Fu a seguir mostra as etapas descritas na seção anterior.Ele registra um script que recebe dois valores, o tamanho da imagem e uma cor, e produz uma imagem do tamanho solicitado com a cor solicitada. Bastante inútil, mas mostra os passos importantes de como registrar um script, como criar uma nova imagem e como acessar algumas funções do PDB .

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

#! / usr / bin / perl -w use estrito ; use o Gimp ; use Gimp :: Fu ; podregister { # não precisa ter o meu ($ size, $ color) = @_; meu $ img = Gimp :: Image -> new ( tamanho $ , tamanho $ , RGB ); # Crie uma nova imagem # Crie uma nova camada my $ layer = $ img -> layer_new ( tamanho $ , tamanho $ , RGB , "Camada 1" , 100 , NORMAL_MODE ); $ img -> insert_layer ( $ layer , - 1 , 0 ); # adicione a camada à imagem Gimp :: Context -> set_background ( $ color ); # Definir o plano de fundo para a cor desejada $ layer -> edit_fill ( BACKGROUND_FILL ); # Pinte a camada Gimp :: Display -> novo ( $ img ); return $ img ; # Retornar imagem - retorno implícito por nenhum TIPO DE IMAGEM }; saída principal ; __FIM__ = head1 NAME img_uni - Crie uma imagem uniforme = head1 SINOPSE <Image> / Arquivo / Criar / Tutorial / Img Uni = head1 DESCRIÇÃO Um script tutorial = head1 PARÂMETROS [PF_INT32, "tamanho", "tamanho Img", 100], [PF_COLOR, "color", "Img color", [255,127,0]] = head1 AUTHOR Dov Grobgeld = head1 DATE 2004-03-27 = head1 LICENSE Dov Grobgeld (c)

A maioria desses comandos é copiada diretamente do PDB .

Este script mostra as etapas essenciais da produção de um script independente:

linha (s)	Descrição
7	Registro da extensão
9	Criando uma nova imagem.
11	Criando uma ou mais camadas.
12	Anexando a camada à imagem.
13-14	Faça algumas operações de pintura nas camadas.
15	Exibir a nova imagem
16	Devolve a imagem ao chamador

Para testar o script, salve-o no diretório $ HOME /.gimp-2.8/plug-ins . (Uma maneira mais oficial de adicionar scripts é usar o comando gimptool-2.0 --install-bin ). Deve então ser feito executável através do comando:

  chmod + x $ HOME / .  gimp - 2 .  8 / plug - ins / uni

Então inicie o GIMP . Geralmente, é uma boa ideia testar a sintaxe do script com perl -c antes de iniciar o GIMP .

Nota: Devido à maneira como o GIMP funciona, não é possível adicionar scripts depois que o GIMP estiver sendo executado. Por outro lado, é possível alterar um script que já tenha sido registrado, desde que os parâmetros não mudem.

O script agora está acessível através do sistema de menu através do menu superior File / Create / Tutorial :

Ao escolher esta entrada de menu, aparece a seguinte tela:

A escolha dos valores padrão resulta na imagem:

6. Sintaxe orientada a objetos 

O Gimp-Perl fornece uma sintaxe alternativa orientada a objetos para a imagem e os comandos que podem ser desenhados. Aqui está uma tabela mostrando a sintaxe procedural versus a orientação a objetos para alguns comandos:

sintaxe processual	sintaxe orientada a objetos
gimp_image_insert_layer ($ drw, 0,0);	$ img-> insert_layer ($ drw, 0,0);
gimp_drawable_width ($ drw);	$ drw-> width;

A regra de substituição para converter um PDB em um método é tão simples quanto apagar gimp_image_ (ou às vezes gimp_ ) desde o início da chamada de função e chamar esse método através do objeto de imagem. Da mesma forma para as funções gimp_drawable _... Veja os documentos do Gimp-Perl para mais detalhes.

Observe que a sintaxe orientada a objeto parece ser apenas um açúcar sintático que torna a sintaxe de chamada mais limpa. As mensagens de erro ainda são dadas no formato processual. O que está acontecendo é que o GIMP e a biblioteca na qual ele é implementado (Glib) usam o C de maneira orientada a objetos.

7. Pintando áreas com seleções 

No script uni, a função gimp_edit_fill foi chamada para preencher a imagem inteira. Olhando as informações para o gimp_edit_fill no navegador do banco de dados , encontramos o seguinte:

Nome:	gimp_edit_fill
Síntese:	Preencha a área selecionada de drawable
Dentro:	DESENHAVEL	desenhavel	O drawable para preencher a partir de
	INT32	fill_type	O tipo de preenchimento { FOREGROUND - FILL (0), BACKGROUND- FILL (1), WHITE - FILL (2), TRANSPARENT - FILL (3), PATTERN - FILL (4), NO - FILL (5)}
Socorro:	Este procedimento preenche o drawable especificado com o modo de preenchimento. Se o modo de preenchimento for primeiro plano, a cor de primeiro plano atual será usada. Se o modo de preenchimento for plano de fundo, a cor atual do plano de fundo será usada. Outros modos de preenchimento não devem ser usados. Este procedimento afeta apenas regiões dentro de uma seleção, se houver uma seleção ativa.Se você quiser preencher todo o drawable, independentemente da seleção, use 'gimp-drawable-fill'.

Assim, se uma seleção estiver ativa quando gimp_edit_fill for chamado, somente a região selecionada do drawable será pintada. Note também que você deve substituir “_” por “-” nos nomes.

Existem muitas maneiras de escolher uma seleção como pode ser visto ao procurar por um “select” no PDB . O exemplo abaixo usa gimp_image_select_rectangle , cuja entrada no PDB é a seguinte:

Nome: gimp-image-select-rectangle Síntese: Crie uma seleção retangular sobre a imagem especificada Dentro: IMAGEM imagem A imagem INT32 Operação A operação de seleção { CANAL - OP - ADICIONAR (0), CANAL - OP - SUBTRACTO (1), CANAL - OP - SUBSTITUIR (2), CANAL - OP - INTERSETE (3)} FLUTUADOR x x coordenada do canto superior esquerdo do retângulo FLUTUADOR y y coordenada do canto superior esquerdo do retângulo FLUTUADOR largura a largura do retângulo: largura> = 0 FLUTUADOR altura a altura do retângulo: largura> = 0 Socorro: Essa ferramenta cria uma seleção retangular sobre a imagem especificada. A região retangular pode ser adicionada, subtraída ou substituir o conteúdo da máscara de seleção anterior. Este procedimento é afetado pelos seguintes configuradores de contexto: 'gimp-contexto-conjunto-pena', 'gimp-contexto-conjunto-pena-raio'.

Um uso simples dessa função que seleciona um retângulo no meio de uma imagem e pinta esse retângulo com uma cor definida pelo usuário. Este exemplo também apresenta alguns novos recursos que não vimos antes:

• O script é associado a uma imagem, já que seu caminho de menu começa com “<Image> /…”. Observe que, como resultado disso, o retorno de chamada na linha 6 recebe dois parâmetros adicionais, a imagem ativa e o selecionável selecionado.
• O uso das funções do PDB gimp_image_undo_group_start e gimp_image_undo_group_end . Essas funções declaram um grupo desfazer.Quando um desfazer é feito na imagem, em vez de os operadores individuais serem desfeitos, todas as ações entre as chamadas de desfazer e desfazer serão desfeitas de uma só vez.

seleção de pintura

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 #! / usr / bin / perl -w use o Gimp ; use Gimp :: Fu ; podregister { my ( $ width , $ height ) = ( imagem $ -> largura , imagem $ -> altura ); # Selecione um retângulo dentro da imagem e pinte-o com cor $ image -> undo_group_start ; $ image -> select_rectangle ( CHANNEL_OP_REPLACE , $ width / 4, $ height / 4 , $ width / 2, $ height / 2 , ); Gimp :: Context -> set_background ( $ color ); $ drawable -> edit_fill ( BACKGROUND_FILL ); $ image -> selection_none ; $ image -> undo_group_end ; (); }; saída principal ; __FIM__ = head1 NAME img_paint_select - Pinta a seleção = head1 SINOPSE <Image> / Filters / Tutorial / Paint Select = head1 DESCRIÇÃO Pinta a seleção = head1 PARÂMETROS [PF_COLOR, "cor", "cor do retângulo", [0,0,255]] = head1 VALORES DE RETORNO = head1 TIPOS DE IMAGEM * = head1 AUTHOR Dov Grobgeld = head1 DATE 1999-05-14 = head1 LICENSE Dov Grobgeld

O resultado quando executado em nossa imagem anterior:

7.1. Seleções complexas 

Além de seleções retangulares, seleções elípticas também podem ser criadas através das funções do PDB gimp_image_select_ellipse e gimp_image_select_polygon, que permitem a seleção de elipses e polígonos.

Seleções mais complexas podem ser criadas através do mecanismo de canal. O PDBgimp_channel_new () ( Gimp :: Channel-> new ) cria um novo canal. O canal é um drawable que pode ser pintado, como qualquer outro drawable, mas com a diferença de que é sempre uma imagem de nível de cinza. Quando o canal estiver concluído, o canal pode ser carregado na seleção através da função gimp_image_select_item do PDB .

Procure por “select” no Navegador de BD para ver uma lista de todas as funções relacionadas à seleção.

7.2. Loops 

No perl, é trivial escrever loops que, junto com as várias ferramentas de seleção, oferecem poderosas possibilidades criativas. Aqui está um exemplo que mistura cores em círculos. Não há nada realmente novo aqui, mas mostra o poder do que descrevemos acima.

O resultado:

círculos

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 #! / usr / bin / perl use o Gimp ; use Gimp :: Fu ; podregister { # Crie o plano de fundo meu $ img = Gimp :: Image -> new ( tamanho $ , tamanho $ , RGB ); $ layer = $ img -> layer_new ( tamanho $ , tamanho $ , RGB , "Camada 1" , 100 , NORMAL_MODE ); $ img -> insert_layer ( $ layer , - 1 , 0 ); Gimp :: Context -> set_background ( $ bgcolor ); $ layer -> edit_fill ( BACKGROUND_FILL ); my $ ncircles = int ( $ tamanho / $ raio / 2 ); para ( $ i = 0 ; $ i < $ ncircles ; $ i ++ ) { para ( $ j = 0 ; $ j < $ ncircles ; $ j ++ ) { # Selecione um círculo $ img -> select_ellipse ( CHANNEL_OP_REPLACE , $ i * $ radius * 2 , $ j * $ radius * 2 , $ radius * 2 , $ radius * 2 ); my $ color = [ $ i * 30 , ( $ ncírculos - $ j ) * 25 , ( $ i + $ j ) * 15 ]; # misturar cores Gimp :: Context -> set_background ( $ color ); $ layer -> edit_fill ( BACKGROUND_FILL ); } } Gimp :: Display -> novo ( $ img ); return $ img ; }; saída principal ; __FIM__ = head1 NAME círculos - um loop = head1 SINOPSE <Image> / File / Create / Tutorial / Circles = head1 DESCRIÇÃO uma volta = head1 PARÂMETROS [PF_INT32, "tamanho", "Tamanho da imagem", 100], [PF_COLOR, "bgcolor", "Cor de fundo", [40,180,60]], [PF_INT32, "raio", "raio do círculo", 10] = head1 AUTHOR Dov = head1 DATE 1999-05-14 = head1 LICENSE Dov

8. Criando texto 

8.1. Hello World - escrevendo texto em uma imagem 

Para criar texto, a função PDB gimp_text_fontname () pode ser usada.

Aqui está um exemplo de um script que cria uma imagem contendo "Hello world".

ola-world1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 #! / usr / bin / perl use o Gimp ; use Gimp :: Fu ; podregister { meu $ img = Gimp :: Image -> new ( 350 , 100 , RGB ); my $ drw = $ img -> layer_new ( $ img -> largura , $ img -> altura , RGB , "BG" , 100 , NORMAL_MODE ); $ img -> insert_layer ( $ drw , - 1 , 0 ); Gimp :: Context -> set_background ( "preto" ); $ drw -> edit_fill ( BACKGROUND_FILL ); Gimp :: Context -> set_foreground ([ 255 , 255 , 0 ]); # Escolha a cor do texto # Crie o texto my $ textlayer = $ drw -> text_fontname ( 0 , 0 , $ text , 10 , 1 , tamanho $ , PONTOS , $ fonte ); $ textlayer -> floating_sel_anchor ; Gimp :: Display -> novo ( $ img ); return $ img ; }; saída principal ; __FIM__ = head1 NAME hello_world1 - texto básico = head1 SINOPSE <Image> / Arquivo / Criar / Tutorial / Texto Básico 1 = head1 DESCRIÇÃO texto básico = head1 PARÂMETROS [PF_FONT, "font", "Font", "Sans"], [PF_INT32, "tamanho", "Tamanho da fonte", 70], [PF_STRING, "texto", "Texto", "Olá mundo!"] = head1 AUTHOR Dov = head1 DATE 2004-03-27 = head1 LICENSE Dov

O resultado:

Uma coisa a notar neste script é que o texto criado na linha 15 é uma camada flutuante , que precisa ser ancorada à sua camada pai. Isso é feito na linha 16, através da chamada para gimp_floating_sel_anchor () .

Esse script sofre com o problema de o tamanho da imagem não estar relacionado ao tamanho do texto. Isso é resolvido no seguinte exemplo mais complexo, que mostra as etapas básicas para um script de geração de logotipo:

• Criação de uma imagem de tamanho arbitrário
• Criação de um fundo drawable de tamanho arbitrário
• Criação de camada de texto que ajusta exatamente o texto com o comando gimp_text_fontname .
• Redimensionando a imagem e o plano de fundo para o tamanho da camada de texto.

O resultado é uma imagem composta de duas camadas; uma camada de texto transparente sobre um fundo uniforme.

Observe a sintaxe especial de gimp_image_text_fontname na linha 14 no logo básicocom o drawable = -1. O caso especial drawable = -1 significa que, em vez de criar uma camada flutuante, uma nova camada de imagem será criada.

logotipo básico

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 #! / usr / bin / perl use o Gimp ; use Gimp :: Fu ; podregister { meu $ img = Gimp :: Image -> new ( 100 , 100 , RGB ); # qualquer tamanho antigo meu $ background = $ img -> layer_new ( 100 , 100 , RGB , "Fundo" , 100 , NORMAL_MODE ); $ img -> insert_layer ( $ background , 0 , 0 ); Gimp :: Context -> set_foreground ( $ fgcolor ); # Escolha a cor do texto # Crie a camada de texto. Usando -1 como o drawable cria uma nova camada. my $ text_layer = $ img -> text_fontname ( - 1 , 0 , 0 , $ text , $ border , 1 , $ size , POINTS , $ font ); # Obter tamanho do texto que pode ser desenhado e redimensionar a imagem e o # camada de fundo para esse tamanho. my ( $ width , $ height ) = ( $ text_layer -> largura , $ text_layer -> altura ); $ img -> redimensionar ( $ largura , $ altura , 0 , 0 ); $ background -> redimensionar ( $ largura , $ altura , 0 , 0 ); # Preencha a camada de fundo agora quando tiver o tamanho certo. Gimp :: Context -> set_background ( $ bgcolor ); $ background -> edit_fill ( BACKGROUND_FILL ); Gimp :: Display -> novo ( $ img ); return $ img ; }; saída principal ; __FIM__ = head1 NAME basic_logo - logo básico = head1 SINOPSE <Image> / File / Create / Tutorial / Logo Básico = head1 DESCRIÇÃO Faça um logotipo básico. = head1 PARÂMETROS [PF_FONT, "font", "Font", "Utopia Bold"], [PF_INT32, "tamanho", "Tamanho da fonte", 10], [PF_INT32, "border", "Border", 10], [PF_STRING, "texto", "Texto", "Olá mundo!"], [PF_COLOR, "bgcolor", "Cor de fundo", [40,180,160]], [PF_COLOR, "fgcolor", "Cor do primeiro plano", [255,255,0]], = head1 AUTHOR Dov Grobgeld = head1 DATE 2004-03-27 = head1 LICENSE Dov Grobgeld

O diálogo e a imagem resultante:

9. Seleções flutuantes 

Quando uma região é selecionada por meio de uma das rotinas de seleção, a área destacada pela seleção pode ser copiada para o buffer de corte por meio do comando gimp_edit_copy . O buffer de corte pode subsequentemente ser colado em uma camada diferente através do comando gimp_edit_paste . Quando uma camada é colada, ela se torna uma seleção flutuante. Esta seleção flutuante pode ser movida para sua posição requerida pelo comando gimp_layer_set_offsets e, finalmente, é colada pelo comando gimp_floating_sel_anchor . Outra maneira de determinar a posição de uma camada colada é criar uma seleção na imagem de destino antes que o cut-buffer seja colado.

Isso é ilustrado no programa a seguir, que funciona em uma imagem e usa como parâmetro outra imagem, que é concatenada à direita da primeira imagem. As linhas 28 a 38 mostram como a segunda imagem é copiada e colada na primeira imagem.

horiz-cat

#! / usr / bin / perl use o Gimp ; use Gimp :: Fu ; podregister { die "Deve selecionar a camada. \ n" a menos que $ drawable -> is_layer ; $ drawable -> become ( 'Gimp :: Layer' ); meu $ image2 = $ drawable2 -> get_image ; my ( $ w1 , $ h1 ) = ( $ drawable -> width , $ drawable -> altura ); my ( $ w2 , $ h2 ) = ( $ drawable2 -> width , $ drawable2 -> altura ); meu $ hmax = $ h1 > $ h2 ? $ h1 : $ h2 ; # nova altura é a altura máxima das imagens $ image -> undo_group_start ; # Criar um grupo de desfazer # Redimensione a camada drawable para dar espaço para a imagem $ image -> redimensionar ( $ w1 + $ w2 , $ hmax , 0 , ( $ hmax - $ h1 ) / 2 ); $ drawable -> resize ( $ w1 + $ w2 , $ hmax , 0 , ( $ hmax - $ h1 ) / 2 ); # Copiar $ drawable2 e colá-lo no novo espaço de $ drawable1 $ image2 -> selection_all ; # selecione todos os image2 $ drawable2 -> edit_copy ; $ image2 -> selection_none ; # faça uma seleção na imagem 1 onde $ drawable2 deve ser colado $ image -> select_rectangle ( CHANNEL_OP_ADD , $ w1 , ( $ hmax - $ h2 ) / 2 , $ w2 , $ h2 ); $ drawable -> edit_paste ( 0 ) -> floating_sel_anchor ; # colar e depois ancorar $ image -> undo_group_end ; # Feche o grupo de desfazer retorno ; }; saída principal ; __FIM__ = head1 NAME horiz_cat - Concat horizontal = head1 SINOPSE <Image> / Filters / Tutorial / Concat Horizontal = head1 DESCRIÇÃO Concatenação horizontal de imagens. = head1 PARÂMETROS [PF_DRAWABLE, "drawable2", "Drawable to concatenate", undef], = head1 TIPOS DE IMAGEM * = head1 AUTHOR Dov Grobgeld = head1 DATE 2004-03-27 = head1 LICENSE Dov Grobgeld

Você pode notar algo muito importante nas linhas 7 e 8: "sabemos" que sempre passamos uma camada como a primeira drawable, mas estamos verificando isso de qualquer maneira. Então, estamos dizendo ao Gimp-Perl que o drawable definitivamente é uma camada. A razão para isso é que (obviamente) Gimp :: Layere Gimp :: Drawable têm métodos diferentes disponíveis para eles, e o que importa aqui é que o Gimp :: Drawable não possui um método de redimensionamento. (ou seja, o PDB não tem uma função gimp_drawable_resize )

10. O servidor Perl e scripts independentes 

Até agora, todos os scripts foram iniciados a partir da estrutura de menus no GIMP .Mas, usando o Gimp :: Fu, existe outra possibilidade, que é executar os scripts a partir da linha de comando, como um programa Perl normal. Quando executado dessa maneira, o script tenta se conectar ao Perl-Server e, se falhar, ele lançará um GIMP próprio. Se você planeja executar vários scripts desta forma, é obviamente muito mais rápido rodar o Perl-Server, já que o lançamento do GIMP leva um pouco de tempo. O Perl-Server pode ser iniciado no menu Filters / Perl .

Quando um script Gimp :: Fu é executado a partir da linha de comando, o resultado é o mesmo de quando é executado através dos menus, exceto que pode ser executado com o parâmetro --output . Isso salvará o resultado em um arquivo em vez de exibi-lo no GIMP . Isso é ótimo para criação em lote de logotipos etc.

O nome do arquivo --output tem alguma magia especial que permite definir alguns parâmetros especiais de gravação de imagem, como interlace, fator de qualidade, etc. Veja os documentos do Gimp :: Fu para mais detalhes

Aqui estão duas invocações dos scripts declarados acima, mas com saída escrita para um arquivo jpg e um arquivo png.

perl-gimp-de-shell
1: uni -o /tmp/uni.png --size 100 - roxo de cor 2: logo básico --font 'utopia 100' -o /tmp/bl.ppm --size 20 --text "Regras de Perl"

Outro uso importante dessa interface é que ela permite executar o depurador Perl nos scripts perl.

10.1. Um shell para o Gimp-Perl 

Ao usar o Perl-Server, não é necessário usar o Gimp :: Fu e a função podregister .Em vez disso, você pode chamar Gimp :: on_net , que toma como parâmetro uma referência a uma sub-rotina que é chamada quando seu script se conectou a um GIMP (ou iniciou um).

Para um exemplo simples mas poderoso do uso do Gimp sem Fu, aqui está um shell Gimp-Perl interativo que pode ser executado a partir da linha de comando:

pg-shell

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #! / usr / bin / perl # Um shell de linha de comando interativo para o GIMP. use o Gimp ; use Term :: ReadLine ; Gimp :: on_net { $ term = new Termo :: ReadLine ( "Gimp" ); while ( definido ( $ _ = $ term -> readline ( "Gimp>" ))) { $ res = eval ( $ _ ) . "\ n" ; print ( "Error: $ @" ), next if $ @ ; print "\ n" ; Gimp -> displays_flush (); } }; saia do Gimp :: main ;

Aqui está um exemplo de uma sessão interativa com este shell:

interagir
1: Gimp> $ img = Gimp :: Image-> new (100,100, RGB) 2: Gimp> $ drw = $ img-> layer_new (100,100, RGB_IMAGE, "bg", 100, NORMAL_MODE) 3: Gimp> $ img-> insert_layer ($ drw, -1, 0) 4: Gimp> Gimp :: Display-> new ($ img) 5: Gimp> $ drw-> edit_clear 6: Gimp> print Gimp :: Image-> lista 7: Gimp :: Image-> existente (1)

11. Notas finais 

Este tutorial abrangeu apenas uma pequena parte das possibilidades disponíveis para um roteirista. Em particular, os seguintes problemas disponíveis para os scripts Gimp :: Perl não foram cobertos:

• A possibilidade de escrever interfaces Gtk customizadas (veja exemplos / example-no-fu na distribuição Gimp-Perl).
• Escrevendo plug-ins completos que manipulam os dados do bloco através do módulo Perl Data Language ( PDL ) (consulte os exemplos / map_to_gradient na distribuição do Gimp-Perl).
• Usando o Gimp-Perl em um ambiente CGI .
• Como preencher com gradientes em um plugin (veja exemplos / randomblends na distribuição Gimp-Perl).
• Como fazer seleções de polígonos (veja exemplos / triângulo na distribuição Gimp-Perl).

A distribuição Gimp-Perl também possui mais de 50 scripts de exemplo fornecidos.Dê uma olhada naqueles para mais inspiração!

12. Links e referências 

• Documentação do Gimp :: Fu
• O resto dos documentos do módulo Gimp-Perl
• Registro do GIMP com plug-ins do Perl