Use Python para escrever plug-ins para o GIMP

Estenda o GIMP para tarefas automatizadas

Este artigo demonstra como automatizar o GNU Image Manipulation Program (GIMP) com scripts para realizar duas tarefas simples: redimensionar todas as imagens em uma pasta e salvá-las no mesmo formato. Aprenderemos a criar plug-ins para GIMP usando a linguagem de script Python. Use seu novo plug-in com o comando gimp na linha de comando.

Nathan A. Good, Senior Consultant and Freelance Developer, Freelance Developer

Nathan GoodNathan A. Good vive na área de Twin Cities em Minnesota. Profissionalmente, ele realiza desenvolvimento de software, arquitetura de software e administração de sistemas. Quando não está gravando software, ele gosta de construir PCs e servidores, ler sobre e trabalhar com novas tecnologias e tentar convencer seus amigos de migrar para software livre. Ele escreveu e foi co-autor de muitos livros e artigos, incluindo Professional Red Hat Enterprise Linux 3, Regular Expression Recipes: A Problem-Solution Approach e Foundations of PEAR: Rapid PHP Development.



12/Mai/2011

Este artigo trata do uso de GIMP-Python, um conjunto de módulos Python que permite programar em Python para automatizar comandos no GNU Image Manipulation Program (GIMP). Esses módulos Python são wrappers em torno de bibliotecas libgimp. O GIMP-Python é diferente das extensões Script-Fu. Em Script-Fu, é usado um plug-in para executar scripts. Em GIMP-Python, o script Python assume o papel central e faz o trabalho. É possível instanciar os scripts GIMP-Python dentro do próprio GIMP, ou usar o modo de lote do GIMP para iniciá-lo a partir da linha de comando.

Neste artigo, aprenderemos a escrever código Python, que permitirá automatizar duas tarefas no GIMP: redimensionar imagens e salvá-las em diferentes formatos.

É possível instalar e usar o GIMP e o Python em diversas plataformas, incluindo Linux ®, Mac OS® X e Microsoft® Windows®. A natureza multiplataforma do GIMP e do Python permite escrever plug-ins complexos para GIMP usando Python, e executá-los em uma variedade de plataformas.

Visão geral do GIMP

O GIMP é um programa de software livre para manipulação de imagens usado por muitas pessoas como uma alternativa viável a algumas das ofertas comerciais. O GIMP tem recursos complexos, como camadas e caminhos. O GIMP suporta diversos formatos de imagem e vem com filtros relativamente complexos. O GIMP tem forte apoio e envolvimento da sua comunidade, de modo que geralmente é fácil encontrar informações sobre como usá-lo ou estendê-lo.

Consulte Recursos para um link para fazer o download e instalar o GIMP no seu computador.


Visão geral de scripts em Python

Python é uma linguagem de script orientada a objeto, que permite escrever códigos que podem ser executados em diversas plataformas. Python foi portado para máquinas virtuais .NET e Java™ , de modo que há muitas maneiras de executá-la. Consulte Recursos para saber como instalar Python no seu computador.

Existem muitos módulos para Python que fornecem funcionalidades que podem ser reutilizadas sem a necessidade de escrever seus próprios módulos (os módulos GIMP-Python são um exemplo). Um índice dos módulos Python lista diversos módulos pré-desenvolvidos que podem ser usados para executar uma variedade de tarefas, desde lidar com linguagem de marcação de hipertexto (HTML) e conexões de Protocolo de transporte de Hipertexto (HTTP) ao trabalho com arquivos em Linguagem de Marcação Extensível (XML) (consulte Recursos). Também é possível criar seus próprios módulos Python, permitindo a reutilização de partes de código dentro de sua empresa.

Similar ao GIMP, a Python também tem suporte significativo da sua comunidade. Isso significa que é possível encontrar informações, bem como baixar e usar ferramentas relativamente maduras que auxiliam seu desenvolvimento em Python.

Antes de prosseguir com o restante do artigo, instale Python em seu sistema operacional de acordo com as instruções no site da Python. Certifique-se de ter Python corretamente instalada abrindo um prompt de comandos e digitando python --version. O resultado deve se parecido à Listagem 1.

Listagem 1. Verificando a instalação de Python
$ python --version
Python 2.6.6

Após instalar o interpretador Python, será possível criar arquivos em Python em qualquer editor de texto e executá-los com o interpretador. Também é possível usar o plug-in PyDev para Eclipse, que oferece o destaque de sintaxe, bem como alguns outros recursos, como a captura de erros de sintaxe. Outra opção é usar o console Python diretamente no Eclipse, o que é conveniente para encontrar ajuda.

Os módulos GIMP-Python já devem estar instalados com as versões mais recentes de GIMP. Para checar se estão instalados, abra o GIMP e veja se há uma opção de menu Python-Fu no menu Filters. Se houver, estará tudo pronto para iniciar a criação de scripts. Se não houver essa opção, siga os links na seção Recursos para instalar as extensões de Python para GIMP.

Se quiser usar o plug-in PyDev para Eclipse, execute estas etapas:

  1. Instale o plug-in PyDev selecionando Help > Install New Software.
  2. Use http://pydev.org/updates como site de atualização (consulte Recursos).
  3. Siga o restante da instalação e reinicie o Eclipse quando terminar.
  4. Depois de reiniciar o Eclipse, selecione File > New > Project para criar um projeto.
  5. Selecione PyDev\PyDev Project e clique em Next .
  6. Digite o nome do seu projeto (por exemplo, MyPythonGimpPlugins).
  7. Desmarque a caixa de seleção Use default e digite o local do seu diretório GIMP para os plug-ins Python, como mostrado na Figura 1.
    Figura 1. Criando um projeto com o plug-in PyDev para Eclipse
    Screenshot shows the MyPythonGimpPlugins project being created, with project type Python, Grammar Version 2.6 and the interpreter as default
  8. Clique no link para configurar um interpretador. O botão Auto Config deve funcionar, desde que Python esteja instalada corretamente e esteja em seu caminho.

Para seu projeto, certifique-se de adicionar a pasta que inclui os módulos GIMP-Python gimp e gimpfu. Acrescente esse diretório ao seu projeto Eclipse (mas não ao caminho base) usando Project > Properties , como mostrado na Figura 2.

Figura 2. Acrescentando o diretório do módulo GIMP-Python ao seu projeto em Eclipse
Screenshot shows that PYTHONPATH now has /usr/lib/gimp/2.0/python added in Eclipse

Clique em PyDev - PYTHONPATH. Em seguida, selecione a guia External Libraries e clique no botão Add source folder para acrescentar a pasta onde os módulos GIMP-Python estão instalados. O caminho será similar a /usr/lib/gimp/2.0/python/.

Também é possível executar o console Python em Eclipse. Com o console visível, selecione Pydev Console na lista de consoles.


Registrando seu script

Os arquivos Python ficam na pasta inicial de usuário do GIMP. Em sistemas Mac e Linux, a pasta é ~/.gimp-2.6/plug-ins. Os arquivos de script Python também devem ser executáveis e possuir o interpretador de Python na primeira linha, como declarações de script padrão, conforme mostrado na Listagem 2.

Listagem 2. Script Python elementar que imprime "Hello, world!"
#!/usr/bin/python

print "Hello, world!"

É preciso registrar seu script Python para GIMP, a fim de colocar o plug-in em um dos menus do GIMP. A Listagem 3 mostra o script mínimo necessário para registrar um script em GIMP e imprimir "Hello, World!" no console quando chamado.

Listagem 3. Registrando seu plug-in no GIMP
#!/usr/bin/python

from gimpfu import *

def plugin_main(timg, tdrawable):
    print "Hello, world!"

register(
        "python_fu_resize",
        "Saves the image at a maximum width and height",
        "Saves the image at a maximum width and height",
        "Nathan A. Good",
        "Nathan A. Good",
        "2010",
        "<Image>/Image/Resize to max...",
        "RGB*, GRAY*",
        [],
        [],
        plugin_main)

main()

O método register() fornece ao GIMP informações sobre seu plug-in.

O método register() possui vários parâmetros que dizem ao GIMP como exibir as opções de menu para o plug-in, e que método Python chamar ao iniciar o plug-in a partir do menu. A Tabela 1 mostra os parâmetros do método register() .

Tabela 1. Parâmetros e exemplos para o método register() .
ParâmetroExemploDescrição
proc_namepython_fu_resizeO nome do comando chamado a partir da linha de comando ou do script
blurbSalva a imagem com largura e altura máximasInformações sobre o plug-in exibidas no navegador de procedimento
helpSalva a imagem com largura e altura máximasAjuda do plug-in
authorNathan A. GoodO autor do plug-in
copyrightNathan A. GoodO detentor do copyright do plug-in (em geral, o mesmo que o autor)
date2010A data do copyright
label<Image>/Image/Resize to max...A etiqueta que o plug-in usa no menu
imagetypesRGB*, GRAY*Os tipos de imagens que o plug-in foi feito para manipular
params[]Os parâmetros do método do plug-in
results[]Os resultados do método do plug-in
functionplugin_mainO nome do método a ser chamado no seu código Python

Pode-se obter as informações mais atualizadas sobre os parâmetros do método de registro abrindo o console Python-Fu (clique em Filters > Python-Fu > Console), e digitando os comandos mostrados na Listagem 4.

Listagem 4. Obtendo ajuda com o console Python
import gimpfu 
help(gimfu.register)

Após colocar seus valores no método register , salve seu script. Confirme se ele é executável e se está localizado na pasta .gimp2-6/plug-ins.

Após salvar o script, inicie o GIMP a partir da linha de comando, usando o comando gimp . Isso deve permitir que você veja qualquer informação impressa pelo seu plug-in, incluindo a saída da instrução de impressão. Além disso, se houver algum erro no seu plug-in, ele poderá ser visto aqui.

Com o GIMP iniciado, vá até o menu Image , onde se vê o novo item de menu Resize to max , como mostrado na Figura 3.

Figura 3. Novo item de menu para seu plug-in
Screenshot shows that 'Resize to max..' appears at the bottom of the Image menu in GIMP

Agora que seu plug-in está se registrando adequadamente no GIMP, e que é possível clicar em um item de menu para acessar seu plug-in, estamos prontos para continuar e acrescentar o código Python para redimensionar a imagem.


Script para redimensionar

Depois de ter o plug-in Python no GIMP, é possível acrescentar código real no método plugin_main dentro do código do seu plug-in.

A Listagem 5 demonstra o código para redimensionamento de imagem.

Listagem 5. Acrescentando o código ao método plugin_main .
def plugin_main(timg, tdrawable, maxh=500, maxw=500):

    currentWidth = tdrawable.width
    currentHeight = tdrawable.height
    
    newWidth = currentWidth
    newHeight = currentHeight
            
    if (maxw < newWidth):
        newWidth = maxw
        newHeight = (float(currentHeight) / (float(currentWidth) / newWidth))
        
    if (maxh < newHeight):
        newHeight = maxh
        newWidth = (float(currentWidth) / (float(currentHeight) / newHeight))
        
    pdb.gimp_image_scale(timg, newWidth, newHeight)

O código Python está simplesmente chamando o método pdb.gimp_scale_image para redimensionar a imagem após ter feito alguns cálculos elementares para descobrir quais devem ser os valores dos tamanhos da imagem escalada. Devido ao fato de que os valores colocados na caixa são valores máximos, o script precisa verificar a largura e a altura da imagem atual para checar se suas dimensões precisam ser restritas. Se uma dimensão da imagem for maior que o tamanho máximo, ele define a dimensão restrita ao tamanho máximo e depois calcula a outra dimensão.

Para saber mais sobre outros métodos que podem ser chamados dentro do seu script Python, consulte Help > Procedure Browser dentro do GIMP. O navegador de procedimento para o método pdb.gimp_image_scale é mostrado na Figura 4.

Figura 4. Visualizando o método gimp-image-scale no navegador de procedimento
Screenshot shows a list of procedures on the left side with the gimp-image-scale highlighted and details about the procedure on the right.

Executando o script de plug-in de redimensionamento

Após acrescentar o código para executar o redimensionamento, abra uma imagem no GIMP. Clique em seu novo item de menu Image > Resize to max . Seu script pedirá os tamanhos mostrados na Figura 5.

Figura 5. Parâmetros de entrada para seu plug-in
Screenshot shows the parameter window for python_fu_resize with inputs for Maximum width and maximum height, both set to 500

Ao clicar em OK, seu método plugin_main será executado, e seu script redimensionará sua imagem.


Script para transformação de imagem

Agora que o plug-in para redimensionar a imagem está funcionando, pode-se atualizar o script Python para também salvar a imagem em um formato de imagem diferente. Isso permite salvar a imagem original como arquivo JPEG, bem como redimensioná-la para caber em certas restrições.

Os acréscimos ao script são mostrados na Listagem 6.

Listagem 6. Acrescentando código para salvar uma cópia em JPEG da imagem original
#!/usr/bin/python

from gimpfu import *

def plugin_main(timg, tdrawable, maxh=500, maxw=500, savecopy=TRUE):

    currentWidth = tdrawable.width
    currentHeight = tdrawable.height
    
    newWidth = currentWidth
    newHeight = currentHeight
            
    if (maxw > newWidth):
        newWidth = maxw
        newHeight = (float(currentHeight) / (float(currentWidth) / newWidth))
        
    if (maxh > newHeight):
        newHeight = maxh
        newWidth = (float(currentWidth) / (float(currentHeight) / newHeight))
        
    pdb.gimp_image_scale(timg, newWidth, newHeight)
 
    if savecopy:
        pdb.file_jpeg_save(timg, tdrawable, timg.name+".jpg", timg.name+".jpg", 
                           0.9, 0, 0, 0, "", 0, 0, 0, 0)

register(
        "python_fu_resize",
        "Saves the image at a maximum width and height",
        "Saves the image at a maximum width and height",
        "Nathan A. Good",
        "Nathan A. Good",
        "2010",
        "<Image>/Image/Resize to max...",
        "RGB*, GRAY*",
        [
                (PF_INT, "max_width", "Maximum Width", 500),
                (PF_INT, "max_height", "Maximum Height", 500),
                (PF_BOOL, "copy", "Make a JPEG copy", TRUE),
        ],
        [],
        plugin_main)

main()

Pode-se obter o nome do método a ser usado a partir do banco de dados de procedimento (a variável pdb), usando Help > Procedure Browser no GIMP, como mostrado na Figura 6.

Figura 6. Observando o método para salvar como JPEG no navegador de procedimento
Screenshot shows a list of procedures on the left side with file-jpeg-save hightlighted and information about the procedure on the right, which includes a list of parameters with their type and purpose

As constantes usadas para os tipos de entrada de parâmetro vêm da biblioteca gimpfu . É possível obter a lista de constantes disponíveis digitando os comandos mostrados na Listagem 7 no console Python no GIMP ou no Eclipse.

Listagem 7. Obtendo ajuda para as constantes gimpfu
import gimpfu
help(gimpfu)

As constantes começam com PF_ e definem tipos de dados que podem ser usados para os controles na forma de entrada.


Executando o script de plug-in atualizado

Depois de adicionar o novo código ao script Python para salvar a imagem como JPEG, pode-se executar o plug-in ,abrindo uma imagem no GIMP e usando o item de menu Image > Resize to max . Pode-se ver a caixa de entrada de parâmetro atualizada como mostrado na Figura 7.

Figura 7. Entrada de parâmetro atualizada
Screenshot shows the python_fu_resize parameter window with Maximum Width and Maximum Height entries and a new button to 'Make a JPEG copy'

Agora que o script foi feito e testado em algumas imagens, você poderá executar o plug-in em todas as imagens de uma pasta.


Executando ambos em um uma pasta

O GIMP tem um modo de lote não interativo que permite chamar comandos dele a partir da linha de comando. Pode-se usar o recurso de linha de comando para operar em todas as imagens de uma pasta usando curingas padrão.

O método para salvar a imagem como JPEG, por exemplo, pode ser passado diretamente para o modo de lote do GIMP usando o comando da Listagem 8.

Listagem 8. Usando o modo de lote não interativo de GIMP para salvar a imagem
gimp -i -b '(file-jpeg-save "Menu_006.png" 200 200 TRUE)' -b '(gimp-quit 0)'

No entanto, isso fica um pouco mais difícil quando se leva em conta os cálculos necessários para as restrições de tamanho. Portanto, esse plug-in simplifica muito as duas operações para que se possa chamá-las a partir de um único comando do GIMP.

Agora que seu plug-in está funcionando e registrado no GIMP, ele tem seu próprio comando no banco de dados de procedimentos do GIMP. É possível ver o comando do seu plug-in indo até o navegador de procedimento (Help > Procedure Browser no GIMP) e digitando o nome dado ao seu plug-in. Por exemplo, se ele recebeu o nome de python_fu_resize no método de registro, como mostrado lá atrás na Listagem 6, ele será encontrado no navegador de procedimento do GIMP como python-fu-resize. Chame esse comando como mostrado no navegador de procedimento do GIMP a partir da linha de comando usando o comando gimp e os sinalizadores -i -b como mostrado na Listagem 9.

Listagem 9. Chamando seu plug-in a partir do modo de lote não interativo de GIMP
gimp -i -b '(python-fu-resize "myimage.png" 200 200 TRUE)' -b '(gimp-quit 0)'

O GIMP abre a imagem especificada, executa o comando com os parâmetros fornecidos e, então, encerra sem salvar as modificações feitas na imagem original. Usando o comando do GIMP no modo de lote não interativo, pode-se executar script em modificações de grande escala em uma pasta inteira e cheia de imagens.

O comando mostrado na Listagem 10 opera o novo comando de plug-in do comando em todas as imagens do tipo Portable Network Graphics (PNG) em uma pasta.

Listagem 10. Chamando seu plug-in a partir do GIMP em todas as imagens de uma pasta
gimp -i -b '(python-fu-resize "*.png" 200 200 TRUE)' -b '(gimp-quit 0)'

Resumo

Python é uma linguagem de script orientada a objeto, que permite escrever scripts que podem ser executados em diversas plataformas, como Linux, Mac e Windows. O suporte a ferramentas na linguagem de script Python é considerável — desde simples destaque de sintaxe em editores de texto até plug-ins do Eclipse

O GIMP é um aplicativo que oferece a edição sofisticada de arquivos gráficos em diversas plataformas. O GIMP suporta a noção de plug-ins, que fornecem pontos de extensão que podem ser usados para automatizar até mesmo tarefas extremamente complexas pela utilização de scripts. Devido ao fato de que o GIMP suporta o script Python em plug-ins, pode-se usar Python para estender o GIMP. Usando o modo de lote não interativo, pode-se chamar seus plug-ins a partir da linha de comando em um método adequado para script.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

  • Participe da comunidade do developerWorks. Conecte-se a outros usuários do developerWorks, ao mesmo tempo que explora os blogs, fóruns, grupos e wikis direcionados a desenvolvedores.
  • A Newsgroup do Eclipse tem muitos recursos para pessoas interessadas no uso e na extensão do Eclipse.

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=658276
ArticleTitle=Use Python para escrever plug-ins para o GIMP
publish-date=05122011