Tutorial Programação - Automatizar a edição

de Stephen Kiel

Tabela de Conteúdos

Motivação

Este tutorial descreverá e fornecerá exemplos para dois tipos de funções de automação. A primeira função é uma ferramenta para capturar e executar comandos “Macro”. A segunda função é um conjunto de ferramentas de automação para capturar e executar um "fluxo" ou "processo". O código deste tutorial é escrito usando o Gimp-Python e deve ser uma plataforma portátil - capaz de rodar em sistemas operacionais Linux ou Windows. *

O objetivo dessas funções é fornecer ferramentas que acelerem o processo de edição, tornem o processo de edição mais repetitivo e reduzam a quantidade de botão que o usuário precisa fazer. Assumir as tarefas de apertar botões e guardar livros permite que o usuário se concentre na parte mais criativa do processo de edição.

Essas ferramentas de automação são exemplos, portanto, modifique-as para atender às suas necessidades. O objetivo do tutorial é fornecer e explicar um exemplo funcional. Se o estilo de codificação parece um pouco áspero, peço desculpas, não sou programador.

O corpo principal deste tutorial estará discutindo as idéias por trás da automação do processo de edição. Espero que possamos manter o foco no conceito sem nos perdermos nos detalhes do exemplo incluído. Os detalhes de como configurar e executar o código de exemplo e o que o exemplo de automação deve realizar serão abordados nos apêndices do tutorial. Não vamos cobrir a programação em python, pois ela já está bem documentada.

Este tutorial usará alguns dos conceitos abordados em um tutorial anterior, " Automated Jpg to Xcf ". Provavelmente seria útil ler o tutorial anterior para o exemplo introdutório.

* Espero que seja fácil adaptá-lo ao Apple OS também.

Uma introdução às macros

Antes de mergulharmos em uma descrição do código, vamos dar uma breve olhada no processo de captura e execução de uma "Macro".

Suponha que desejamos configurar o espaçamento da grade para que fique centralizado na imagem, seja uma grade quadrada, dimensionado de modo que haja 24 blocos de grade na dimensão 'longa' e seja um padrão de traço on-off.Poderíamos inserir o seguinte fragmento de código no "Python Console" do Gimp (sob o menu suspenso "Filtros") para configurar a grade.

Exemplo - GIMP - Fragmento de Código Python

  >>> theImage = gimp .  image_list () [ 0 ]
 >>> centerX = theImage .  largura / 2
 >>> centerY = theImage .  altura / 2
 >>> gridSpacing = max (a largura da imagem , a altura da imagem ) / 24
 >>> pdb .  gimp_image_grid_set_offset ( theImage , centerX , centerY )
 >>> pdb .  gimp_image_grid_set_spacing ( theImage , gridSpacing , gridSpacing )
 >>> pdb .  gimp_image_grid_set_style ( theImage , GRID_ON_OFF_DASH )

Se você observar a imagem ao inserir os comandos e fazer com que a Grade seja “ ATIVADA ”, você verá o espaçamento da grade na imagem ativa mudando conforme executamos esses comandos.

A ferramenta que estamos escrevendo neste tutorial nos permitirá copiar este fragmento de código em um arquivo de texto, adicionar um nome e comentários opcionais e acessá-lo através de um widget de menu para que possamos executar novamente este fragmento de código em outras imagens. A ferramenta acessará o fragmento de código "macro" usando o nome que atribuímos através de um menu suspenso.

A capacidade de salvar os fragmentos de código de macro nos permite construir uma biblioteca de atalhos de edição que não apenas economizarão tempo, mas farão o trabalho melhor do que você poderia simplesmente apertar os botões. Nesse caso, fizemos o espaçamento da grade com base em uma porcentagem do tamanho da imagem em vez de um tamanho fixo em polegadas, pixels ou cm.

Implementação de Macro - em Broad Strokes

Vamos abordar as principais idéias que usaremos para implementar o esquema de gravação e execução de macro que podemos usar para capturar e executar um conjunto de comandos.

O conjunto de comandos será lido e analisado em uma estrutura de dados.Cada bloco de conjunto de comandos terá um nome e consistirá em comandos e comentários.
A estrutura de dados será lida para uma lista de nomes de macro. Essa lista será usada para preencher um widget da GUI para que possamos selecionar uma macro pelo nome.
Na Macro nomeada, a estrutura de dados retornará uma lista de comandos.
A lista de comandos será executada em um loop 'exec':

Exemplo "Loop Exec":

  para Cmd na commandList :
     exec ( Cmd )

Arquitetura

Quando você deseja escrever um script para fornecer uma única função, a abordagem comum e óbvia é escrever um único programa, inscrever o programa e fornecer uma interface de usuário, caso seja solicitado. Nosso exemplo de automação é multifuncional - mais parecido com um sistema, e queremos deixar algumas das funcionalidades um pouco fluidas. Se considerarmos o sistema (dados e código) e fizermos boas escolhas arquitetônicas, poderemos atingir nosso objetivo sem tornar o código excessivamente complexo.

Modelo de Execução

Estaremos quebrando a execução de nossas funções de automação em três categorias diferentes:

Funções da interface do usuário
Classe base e funções
Pseudo-código

Vamos examinar estas categorias resumidamente:

As funções da interface do usuário são a função de nível superior que são ativadas nos menus. Eles são a função 'principal', o bloco de registro e a função registrada no bloco de registro. Nós estaremos deliberadamente mantendo o código da Função de Interface do Usuário esparso. Embora as Funções da UI tenham muita funcionalidade, elas são bastante frágeis e difíceis de depurar. A abordagem que usaremos é obter a interface do usuário em execução e chamar uma função que possa ser gravada e depurada de forma independente, minimizando as edições na interface do usuário.

A classe base e as funções são apenas classes python normais e funções que podem ser executadas a partir de um shell. Essas funções não dependem de que a biblioteca gimpfu possa ser executada em qualquer shell python (incluindo o Gimp-Python Shell).

Se você cometer um erro de sintaxe no decorrer de uma edição, será possível isolá-lo rapidamente em uma determinada linha em uma função específica.Isso é mais fácil de fazer a partir do shell do que ao executar o programa a partir de uma GUI .
Manter o código python genérico separado do código que depende da biblioteca gimpfu minimiza o impacto que futuras liberações do gimp terão nos scripts. Como as chamadas de procedimento do gimp são tratadas pelo Pseudo-Código em vez da Classe-Base e Funções, temos menos risco de compatibilidade de versões futuras do Gimp dentro da Classe-Base e da Função.

O Pseudocódigo é a parte da funcionalidade geral do sistema que queremos deliberadamente deixar fluido. A funcionalidade do Pseudo-Código destina-se a etapas de edição simples (que devem abranger uma ampla gama de edições).

Os tipos de coisas que você pode fazer no Pseudo Code podem incluir: copiar camadas, nomear camadas, executar filtros, definir modos de camada, definir opacidade de camada, mesclar camadas e executar funções PDB . O pseudo-código pode acessar as características básicas da imagem e realizar operações com elas.
O pseudo-código é simples fragmentos de código do Gimp-Python. Como não há suporte para recuo, um teste simples de como o seu Pseudode Código pode se tornar complexo é se você precisa recuar ou não (note que você pode escrever uma instrução simples 'se' em uma linha). Apesar dessa restrição, mostraremos com alguns exemplos que você pode realizar várias edições com macros.

Uma última coisa que precisamos falar sobre isso não é uma 'categoria' de execução, mas é algo que é uma parte importante do nosso Modelo de Execução é o Escopo .Vamos abordar apenas alguns pontos que afetam quando as listas são definidas para a seleção dinâmica da interface do usuário.

Os widgets da interface do usuário do Gimp permitem que você selecione itens de uma lista.
Você pode especificar a lista dentro do widget ou passar ao widget uma lista por nome SE você definir a lista fora da função que está sendo chamada. A lista deve ser definida no nível da função main ().
Mantendo o escopo das listas da Interface do Usuário no nível superior, podemos usar o nome da lista na interface do usuário e na função que está sendo chamada . Desta forma, podemos usar o argumento real sendo selecionado em vez de sua posição de índice em uma lista.
Uma vantagem arquitetônica é criar essa lista com uma função que lê um arquivo de configuração. Nós só temos que definir e manter esta lista de configuração em um lugar dentro de nosso sistema e usar a lista resultante em tantos lugares quanto quisermos chamando uma função de leitura. É assim que vamos conseguir novas macros para aparecer nos menus quando os adicionamos.
Os fragmentos de código esquelético a seguir ilustram a definição de uma lista 'cmdList' no nível superior - 'main' e o uso dentro do bloco de registro e da função. Por ser definido no nível 'principal', podemos referenciá-lo dentro da função e do bloco de registro. Podemos recuperar o argumento do índice (passado pelo widget) porque estamos usando a mesma lista nos dois locais:

Exemplo - Listas e Escopo em Funções

  cmdList = cmdrReadObj .  CommanderMacros ()
 #
 def autoCommander ( theImage , cmdListIndex ):
     ...
     commanderName = cmdList [ cmdListIndex ]
     ...     
 #
 registrar (
     " autoCommander " , # Name registrado no Navegador de procedimentos
     ...
     [
     ...
     ( PF_OPTION , " cmdSet " , " Selecione um comando " , 0 , cmdList ),
     ]
 main ()

Modelo de Dados

Agora precisamos falar sobre a forma e organização dos dados que pretendemos usar. A maneira que escolhemos para organizar nossos dados pode ter um impacto dramático na complexidade das funções que precisamos escrever. No nosso caso, podemos tirar vantagem de alguns modelos de dados um pouco mais sofisticados para tornar as funções reais relativamente diretas. Nós estaremos usando “árvores” (Python ElementTree) e dados XML .

Árvores e dados XML

O Python possui diversas estruturas de dados internas, como dicionários, listas para nomear um par. Uma estrutura de biblioteca muito poderosa e adequada às nossas necessidades específicas é uma “árvore”. Alguns dos principais recursos que os tornam adequados para nossa aplicação são:

As árvores têm uma sensação 'hierárquica' natural para elas, como uma estrutura de diretório ou as 'pastas' de um sistema operacional. Os níveis de hierarquia podem ser considerados como "contendo" o conteúdo no nível inferior.
Uma ramificação pode conter um número indefinido de elementos, e esses elementos podem ser uma folha com atributos ou uma sub-ramificação para outro nível. Isso dá muita flexibilidade à maneira como estruturamos os dados.
O formato de entrada / saída é XML , que não é apenas hierárquico, mas é texto, por isso é legível e portátil para qualquer plataforma (computador / sistema operacional ).

Os exemplos usam ElementTree para ler e gravar os dados entre árvores e XML . O ElementTree está incluído no Python e é descrito na documentação do Python, portanto, não entraremos em detalhes sobre a mecânica das estruturas de árvore aqui.

Você pode estar se perguntando neste ponto em que esses arquivos XML serão localizados. As funções que lêem e escrevem os arquivos XML esperam encontrar o XML em um diretório chamado 'myXml' que você terá que criar sob o diretório gimp do usuário. Se você estiver usando Linux e seu diretório home for 'stephen', o caminho será algo como:

  / home / stephen / .  gimp - 2 .  8 / myXml

Se você estiver usando o Windows, o caminho será algo como:

  C : \ Users \ stephen \ .  gimp - 2 .  8 \ myXml

Nós estaremos lidando com alguns tipos de pseudocódigo e arquivos xml, e estes serão mantidos em diretórios separados em myXml, mas chegaremos a isso em breve.

Implementação de macros - revisitada

Agora que falamos sobre o modelo de execução e o modelo de dados, podemos revisitar a “Implementação - em amplas pinceladas” e vincular as etapas ao código que as manipula.

Pseudo Código para XML

Nosso primeiro item foi ler o pseudo código e analisá-lo em uma estrutura de dados . Essa estrutura de dados será uma Árvore.

Podemos começar a escrever um arquivo de pseudocódigo copiando e colando um conjunto de comandos do console python do gimp em um arquivo de texto cujo nome termina em “.def”. O “>>>” que precede cada comando será a “palavra-chave” para indicar um comando.

O pseudo código estará em um arquivo, neste exemplo é chamado NormalGridCanvas.def. Cada linha começa com uma palavra-chave. As opções de palavra-chave são: “commander>”, “macro>”, “comment>” ou “>>>”.

A classe XmlGenerator () em autoBase.py contém uma função GenCommanderXml () que lê todos os arquivos * .def em ~ / .gimp-2.8 / myXml / commander, insere as linhas em uma árvore (após remover a palavra-chave), e Em seguida, grava a árvore em um arquivo chamado combinedCommander.xml.

A palavra-chave determinará a "tag" associada à linha de pseudocódigo e se é um elemento "branch" (nome da macro) ou um elemento "leaf" (comando ou comentário). Estamos atribuindo uma definição e um nível na hierarquia para cada linha de texto de pseudo-código conforme o lemos na árvore.

Exemplo - Exemplo de pseudo-código - NormalGridCanvas.def

  Comandante > Normal Grid and Canvas
    macro >
       comentário > Diminuir a tela de volta para caber na camada
       >>> theImage .  resize_to_layers ()
       comentário > Definir grade para origem e tamanho = imagem
       >>> pdb .  gimp_image_grid_set_offset ( theImage , 0 , 0 )
       >>> pdb .  gimp_image_grid_set_spacing ( theImage , theImage . width , theImage . height )

Depois que todos os arquivos * .def são lidos na árvore e gravados de volta na forma de um arquivo XML , a formatação é feita. Escrever uma árvore gera automaticamente todos os compartimentos contidos, essencialmente tornando a formatação adequada do XML uma tarefa trivial. O fragmento de combinedCommander.xml ilustra o XML do pseudo-código em NormalGridCanvas.def.

Exemplo - combinedCommander.xml (fragmento)

  <combinado>
   Definição
  ...
   <commander>
     Grade Normal e Tela
     <comentário>
       Encolher a tela de volta para ajustar a camada
     </ comment>
     <comando>
       theImage.resize_to_layers ()
     </ command>
     <comentário>
       Definir grade para origem e tamanho = imagem
     </ comment>
     <comando>
       pdb.gimp_image_grid_set_offset (theImage, 0, 0)
     </ command>
     <comando>
       pdb.gimp_image_grid_set_spacing (theImage, theImage.width, theImage.height)
     </ command>
   </ commander>
   ...
 </ combined>

* O XML acima foi executado em uma impressora XML on-line para facilitar a leitura. O XML do ElementTree é funcional, mas difícil de ler.

O gerador Xml pode ser chamado a partir de um menu GUI .

Em nossa discussão sobre o escopo na seção “Modelo de execução”, mostramos um fragmento de código de exemplo no qual criamos uma lista “cmdList”. O código era do exemplo autoCommander.py e usa uma classe BaseXmlReader e a função CommanderMacros () que reside em autoBase.py.

A lista de Nomes de Comandos de Macro é criada ao carregar o arquivo XML combinedCommander.xml em um ElementTree.
A árvore é percorrida no nível da filial (a tag ) e o texto dos ramos, que são os nomes das macros, são incluídos em uma lista. A lista é essencialmente construída com um “loop for”.
A lista é passada para o widget e usada para selecionar a macro que você deseja usar.

Executando uma macro específica

O ponto final a ser expandido é como buscamos e executamos o conjunto específico de comandos para uma macro selecionada.

Podemos derivar o nome da macro por meio da seleção de menu (bloco de registro de autoCommander.py).
Voltaremos a usar a classe BaseXmlReader, mas desta vez utilizaremos a função CommanderExtract passando o nome da Macro como argumento. A função CommanderExtract percorre a árvore ramo por ramo, como antes, quando estávamos reunindo os nomes das macros, exceto que está comparando os nomes contra o argumento passado à medida que avançamos.Quando a função CommanderExtract encontra uma ramificação correspondente ao argumento, ela desce um nível para ler os elementos leaf nessa ramificação.
Os argumentos folha cujas tags estão definidas como "comando" são anexados à lista que será retornada para processamento. As folhas cujas tags são "comentário" serão ignoradas.
A lista retornada recém-criada será executada em um "loop for" que processará cada linha como um comando separado usando a função "exec" do python.

A variável 'theImage' é definida com a função autoCommander e pode ser usada como um identificador para acessar informações sobre a imagem ativa pelos comandos Macro.

Macros do Commander - Resumo

A discussão acima descreve como podemos gerar uma macro executando um conjunto de comandos no Console do Python, colando esses comandos em um arquivo de texto adicionando um nome e comentários e, em seguida, disponibilizando-o para uso.

O código para transformar o pseudo-código em uma macro está em autoWriteXml.py. O código para exibir o menu de macros que você escreveu e executá-las está em autoCommander.py. As classes referenciadas por esses dois scripts estão em autoBase.py.

Os arquivos de texto que você escreve para sua definição de macro precisam ser colocados em um diretório ~ / .gimp-2.x / myXml / commander e ter uma extensão '.def'. Crie um arquivo * .def separado para cada macro.

Uma Introdução à Edição Automatizada

As macros são uma ótima maneira de tornar o processo de edição mais rápido e mais repetitivo, embora tenham algumas limitações.

Há momentos em que a ordem das etapas de edição é importante.
Eles devem ser aplicados um de cada vez.
Você tem que acompanhar o que já foi feito e o que ainda resta.

Um fluxo de trabalho, um processo ou uma receita, o que você pode estar acostumado a chamá-lo (eu prefiro o fluxo de trabalho) pode ser visto como um conjunto de etapas ordenadas. Essas etapas normalmente correspondem às ações que você normalmente codificaria em um conjunto de macros. Automatizaremos um fluxo de trabalho que execute as etapas corretas no momento certo e registre o andamento da edição em cada uma das imagens.

Vamos rapidamente repassar como a captura e a execução de um "Fluxo de trabalho" funcionarão antes de mergulharmos. Capturamos os fragmentos de código que descrevem o processo de edição da mesma maneira que fizemos para as macros.Podemos copiar e colar a partir do console python para gerar uma série de comandos, ou podemos copiá-los de uma macro de trabalho.

As etapas em um fluxo de trabalho não são de fato muito diferentes das Macros do Commander que descrevemos na primeira parte deste tutorial, a única diferença real é que elas são um conjunto ordenado a ser seguido.

A maneira como vamos usar as ferramentas de automação é um pouco diferente do que usar macros. Quando queremos usar uma macro, nós a estamos executando na imagem que está aberta na janela do editor. As ferramentas de automação, por outro lado, são executadas em um diretório de imagens, portanto, executamos sem uma imagem sendo aberta na janela do editor.

Marcamos as imagens prontas para passar para a próxima etapa do fluxo de trabalho e, em seguida, executamos as ferramentas de automação. A atualização automatizada olha para cada imagem no diretório de trabalho, se ele estiver marcado para atualização, ele será atualizado para a próxima etapa, se não estiver marcado para atualização, será deixado sozinho.

A atualização automática moverá as imagens marcadas para a próxima etapa do fluxo de trabalho atribuído, essencialmente mantendo o controle da "contabilidade" para nós. Um benefício de gerenciamento de tempo é que, se houver várias imagens que exijam um filtro que leve um pouco de tempo para ser executado, você poderá fazer outra coisa enquanto estiver em execução.

Implementação da ferramenta de automação - em traços largos

Vamos abordar as principais idéias que usaremos para implementar as tarefas automatizadas de gravação e execução de fluxo de trabalho sobre as quais estamos falando.

O pseudo código será lido e analisado em uma estrutura de dados. Cada bloco de pseudocódigo (ou passo) terá um nome e consistirá em comandos e comentários. Cada fluxo de trabalho terá um nome e conterá um conjunto ordenado de etapas ou blocos de pseudocódigo.
O fluxo de automação gerará uma lista de imagens em um determinado diretório. Em seguida, ele passará por essa lista, verificando se uma imagem está marcada para atualização ou não.
Se uma imagem estiver marcada para atualização, o fluxo de automação determinará o nome do fluxo de trabalho e o próximo passo do nome a ser executado na imagem. O nome do 'fluxo de trabalho' e o 'próximo passo' serão usados para selecionar uma lista de comandos.
A lista de comandos será executada em um loop 'exec':
O 'passo atual' e o 'próximo passo' para a imagem serão incrementados e salvos com a imagem.

Arquitetura

Nós comentamos na seção sobre macros que boas escolhas arquitetônicas podem alcançar nosso objetivo sem tornar o código excessivamente complexo. Esse argumento é tão atraente para a atualização automatizada de nossas imagens. A arquitetura e o código para nossas ferramentas de atualização automatizada serão muito semelhantes aos usados para capturar e executar as macros "Commander".

Modelo de Execução

Como em nossa discussão sobre as macros, estaremos quebrando a execução de nossas funções de automação em três categorias diferentes:

Funções da interface do usuário
Classe base e funções
Pseudo-código

Não vamos refazer estes tópicos, mas sim comentar a diferença, que é a estrutura do pseudo-código. A organização dos fluxos de trabalho como um conjunto de etapas em que cada etapa é um conjunto de comandos nos leva a organizar o pseudo-código de maneira semelhante, em que pensamos em etapas que contêm uma sequência de comandos e fluxos de trabalho contendo uma sequência de etapas. Para refletir esse nível adicional de hierarquia ou contenção, usaremos uma palavra-chave adicional no pseudo-código do fluxo de trabalho.

Modelo de Dados

Existem dois tipos especiais de dados para o fluxo automatizado:

Árvores e dados XML são semelhantes às “macros do Commander”.
Dados de Parasite (ou Propriedade) para acompanhar o fluxo de trabalho específico que está sendo usado para editar uma imagem, a próxima etapa a ser usada e se uma imagem está pronta para ser incrementada para a próxima etapa.

A imagem e os dados de parasitas (ou propriedades)

O tipo de imagem que usaremos em todo o nosso trabalho é o formato nativo do Gimp * .xcf. Esse formato de imagem salva todas as camadas e modos que podemos definir durante a edição e também salva um tipo de dados chamado Parasites, que são semelhantes a Properties em muitos outros sistemas.

Parasitas são como variáveis que podem ser referenciadas pelo nome para acessar seu valor. Como variáveis, elas podem ser atribuídas e lidas. Diferentemente das variáveis, os parasitas são persistentes, muito persistentes. Um parasita, quando atribuído a uma imagem, torna-se parte da imagem e é salvo com o arquivo de imagem. Um parasita que é atribuído e salvo com uma imagem pode ser lido depois que o gimp é fechado e reaberto, é como qualquer outro arquivo de dados a esse respeito.

Os parasitas também são muito portáteis, você pode ler e escrever parasitas usando os scripts baseados em esquema ou python. Eles também são independentes do sistema operacional, então você pode escrever um parasita em uma imagem na sua máquina Linux Desktop, e lê-lo uma semana depois no seu laptop baseado no Windows assumindo que você salvou as imagens no formato de arquivo nativo gimp * .xcf . Parasitas também podem ser escritos em camadas específicas, mas para as nossas necessidades atuais, os parasitas de imagem são tudo o que estamos usando.

Como o parasita está associado à imagem, e é persistente até ser sobrescrito ou removido, é uma ferramenta ideal para acompanhar o estado do progresso da imagem no processo de edição. Além de poder apenas fazer anotações, os valores dos parasitas podem ser usados como uma propriedade para tomar decisões e influenciar a execução do script que leu os dados do parasita.

Se, por exemplo, abrimos uma imagem que tinha dois parasitas (propriedades), chamados 'UpdateFlag' e 'Flow', poderíamos usar os valores desses parasitas para tomar decisões:

Exemplo - Decisões baseadas em Parasite / Valores de Propriedade

  UpdateFlag = str ( theImage . Parasite_find ( 'UpdateFlag' ))
 Flow = str ( theImage . Parasite_find ( 'Flow' ))
 if ( UpdateFlag == 'SIM' ):
     if ( Fluxo == 'Padrão' ):
         { executar comandos para fluxo padrão }
     elif ( fluxo = = 'SemiAuto' ):
         { comandos de execução para o fluxo SemiAuto }
 elif ( UpdateFlag == 'NÃO' ):
     { do nothing }

Ler e escrever parasitas em uma imagem tem uma idiossincrasia que vale comentar qual é o formato dos dados que estão sendo gravados. Você deve expressar o parasita como um conjunto ordenado de 'Nome', 'Índice' e 'Valor'. Nome e Valor são ambos strings, e o Index é um inteiro pequeno, (fique entre 1 e 254). Se você não usou parasitas antes de estar imaginando como determinar um valor 'correto' para o índice. Você pode:

Jogue um dardo em um alvo e use o resultado (supondo que você acertou o tabuleiro).
Ou sinta-se à vontade para usar o meu favorito pessoal '5'.

Contanto que você escolha um número e, de preferência, fique com ele, tudo ficará bem. Quando você ler o valor do parasita, as funções na interface de script do Scheme fornecerão o 'Nome', 'Índice' e 'Valor'; as funções na interface de script do Python retornarão apenas o 'Nome' e 'Valor'.

Escrever o parasita é chamado de 'anexar' e ler o valor de volta é chamado 'get' ou 'find' dependendo do método que você escolher usar. Você pode ler e gravar parasitas de dentro de scripts ou de qualquer um dos consoles python ou esquema.

Executando as ferramentas de automação em um fluxo de trabalho

Nosso tópico final sobre um fluxo de trabalho automatizado em nossos "Broad Strokes" é como configurar e executar o fluxo de trabalho em um conjunto de imagens. Estamos rodando em um conjunto de imagens ao invés de apenas um, então abrimos o gimp sem uma imagem na janela do editor. As ferramentas abrirão, trabalharão, salvarão e fecharão as imagens uma a uma.

Em um tutorial anterior, " Automated Jpg to Xcf ", descrevemos como importar um diretório contendo imagens JPEG em um diretório com imagens gimp xcf. A implementação da ferramenta de automação modifica a função de importação para adicionar as atribuições de parasitas às imagens. As imagens são atribuídas a um fluxo específico à medida que são importadas e o conjunto inicial de propriedades de controle de fluxo é gravado e salvo como parte do processo de importação. A função jpeg-to-xcf também executa o processo de automação (Auto Update Image) uma vez para colocar todas as imagens na primeira etapa do fluxo atribuído, para que estejam prontas para o primeiro ajuste manual logo após serem importadas.

Depois de abrir e (opcionalmente) ajustar uma imagem, você marca a imagem como pronta para a próxima etapa definindo o parasita “UpdateFlag” para um valor de “ YES ”. Isso é feito com uma função que está disponível no menu: “Automação → A2 Marcar para Atualização Automática (Arquivo)”. (Nota: Como você estará fazendo muito isso, é muito conveniente usar um atalho de teclado para executar essa função).

As imagens são movidas para o próximo passo no seu fluxo, executando a função “Auto Update Images (Directory)” do menu. Isso incrementará todas as imagens cujos UpdateFlags estão definidos como YES para a próxima etapa do fluxo.Observe que, como cada imagem tem um registro de sua própria próxima etapa e fluxo, não há necessidade de as imagens em um diretório estarem na mesma etapa ou mesmo usando o mesmo fluxo de trabalho.

A mecânica para criar XML a partir do pseudocódigo para as macros de fluxos de trabalho, propriedades e de comando é executar a função Pseudocódigo para XMLno menu (Automação → Utilitários → Pseudocódigo para XML ).

A função exportar XCF para JPG no menu “Automation” abre cada arquivo xcf no diretório source / work e examina as propriedades da imagem. Se a imagem estiver “Concluída”, no final do fluxo, ela será exportada. As imagens que ainda estão sendo trabalhadas são deixadas em paz.

Implementação da Ferramenta de Automação - Detalhes

Pseudocódigo

Fluxograma de Fluxo de Trabalho

Você pode gerar a lista de comandos que deseja executar em uma imagem no console python e, quando ela estiver funcionando corretamente para a etapa que deseja executar, você poderá copiá-los e colá-los em um arquivo de texto de pseudocódigo. A função “Pseudocode para XML ” estará procurando por arquivos que tenham a extensão de arquivo “.def”, de forma que ele converta todos os arquivos * .def no diretório de fluxo em XML .

Como no caso das macros, você pode colocar linhas de comentário começando com “comentário>” e linhas em branco para tornar os fragmentos de código mais legíveis e mais fáceis de entender quando você voltar para fazer melhorias em alguns meses.

Cada conjunto de comandos é contido por um “Step” que usa a chave “step>”. O contêiner de nível superior é o fluxo de trabalho que usa a chave “fluxo>”. Cada fluxo de trabalho pode ser especificado em seu próprio arquivo ".def". A função “Pseudocode para XML ” lerá todos os arquivos * .def e criará um único arquivo XML chamado combinedFlow.xml no diretório myXml / flow.

Código do Pseudo de Propriedade / Parasite

O outro tipo de pseudo código que precisamos falar é o código das propriedades. O pseudo código para propriedades está contido no diretório “myXml / property”. O arquivo flagProperties.xml é criado pela função “Pseudocódigo para XML ” do arquivo flagProperties.def. No caso de propriedades, só faz sentido ter um conjunto de propriedades para todos os fluxos. As propriedades definidas no arquivo flagProperties.xml serão as propriedades "flag". Você pode definir o nome da propriedade, os comentários, os valores das opções e o valor padrão (configuração inicial). A chave “property>” define o nome da propriedade e contém os outros valores da propriedade dentro do XML . As outras chaves são "comentário>", "padrão>" e "opções>". A chave “flags>” com o nome Control Properties é usada no início do arquivo para definir o container de nível superior.

Existem três propriedades que são atribuídas pelos scripts de automação e normalmente não são editadas pelo usuário ou definidas no arquivo “.def”. Eles são criados, lidos e modificados pelos scripts. Estas são as propriedades de controle de fluxo, “Flow”, “CurrentStep”, “NextStep”.

Você pode ver todas as propriedades e valores atuais atribuídos a uma determinada imagem usando a função de menu "Automação" -> "A1) Exibir Parasitas Designados (Arquivo)".

Propriedades e Estado da Imagem - Parasitos de Controle de Fluxo

Uma maneira de pensar em um fluxo de trabalho é como uma série de estados. Esses estados são o que estamos nos referindo como etapas. À medida que a imagem evolui, ela passa de um estado para outro e passa pelo fluxo de trabalho do início ao fim, estado por estado (ou passo a passo).

Os Parasitos de Controle de Fluxo fornecem um método para tornar cada imagem “autoconsciente” de seu próprio estado, que é seu “Fluxo” e “CurrentStep”. Ele também está ciente do próximo passo para o qual irá proceder, o qual é determinado por seu “Flow” e “NextStep” atribuídos. A ordem das etapas é determinada pela ordem em que estão listadas no pseudocódigo. Quando uma imagem é atualizada, o “NextStep se torna o novo“ CurrentStep ”e um novo“ NextStep ”é procurado e escrito na imagem como um parasita.

Vamos examinar as etapas do exemplo de fluxo "Padrão" incluído neste tutorial. Os passos que a imagem percorrerá são:

Exemplo - estados ou etapas no exemplo de fluxo padrão

	CurrentStep	Próximo passo
1	Primeiro	Alinhamento
2	Alinhamento	DynamicRange
3	DynamicRange	Retinex-Filter
4	Retinex-Filter	Afiar
5	Afiar	ColorAdjust
6	ColorAdjust	ACABADO
7	ACABADO	ACABADO

O estado “First” é atribuído pela função Jpeg to Xcf. Essa etapa é designada automaticamente, independentemente do fluxo. Os passos seguintes ao “Primeiro” passo, “Alinhamento”, “DynamicRange”, “Retinex-Filter”, “Sharpen” e “ColorAdjust” são atribuídos através da representação Xml do fluxo. A etapa “ FINISHED ” é atribuída automaticamente quando o final da lista de etapas é atingido.

Quando as imagens são importadas pela primeira vez, a função de atualização automática é executada para mover as imagens da etapa “Primeira” designada automaticamente para a execução da primeira etapa real do fluxo. Quando o CurrentStep se torna “ FINISHED ”, a imagem está pronta para ser exportada pela função Xcf to Jpeg.

Parasitas da Bandeira de Status

Os Parasitas da Bandeira são para tomada de decisão. Eles serão atribuídos com um valor padrão quando a imagem for importada para um fluxo. O parasita cuja função é o controle de fluxo é o “UpdateFlag”. O valor do UpdateFlag é lido para determinar se uma imagem está pronta para ser movida para o próximo estado.

Flag Parasitas diferentes do UpdateFlag podem ser modificados ou eliminados para atender às necessidades de suas funções de pseudocódigo. Você poderia, por exemplo, adicionar Flags com valores que determinam determinada Opacidade da camada ou determinar se determinados filtros serão executados. Existem muitas possibilidades para essa poderosa capacidade.

Fluxo de Trabalho de Automação - Resumo

A execução de um Fluxo de Trabalho Automatizado é quase trivialmente fácil, desde que você o configure de acordo com o seu gosto. Há algum trabalho para se ter certeza na criação de um fluxo de trabalho, mas a recompensa é um fluxo de trabalho ou processo consistente e aparente (óbvio que etapas foram executadas).

Existem várias coisas que você pode precisar para configurar as Preferências do Gimp, a fim de otimizar a operação.

Conclusão

A combinação de uma linguagem de programação disponível, estruturas de dados adequadas, a capacidade de anexar propriedades a imagens e um rico conjunto de recursos de edição oferecem possibilidades poderosas para automatizar o processo de edição.

Usando um fluxo de trabalho automatizado mudou a maneira que eu uso o Gimp para editar minhas fotos. Espero que você possa aproveitar esses exemplos para tornar o trabalho com o Gimp mais produtivo para você. Links para os scripts de exemplo e pseudocódigo estão nos seguintes apêndices.

Apêndice - Notas

Os Apêndices a seguir contêm notas que são mais específicas para configurar os scripts de exemplo, os arquivos * .def de exemplo e comentários sobre depuração.

Configurando os Scripts de Exemplo

Todos os scripts de exemplo começam com “auto”, por exemplo, autoAutoUpdate.py, autoBase.py,… Se você experimentá-los, mas decidir que não gosta deles, eles devem ser fáceis de encontrar e remover. Os seguintes scripts de exemplo devem ser carregados no diretório gimp / plug-ins. Algo como /home/stephen/.gimp-2.8/plug-ins se o seu nome de usuário é stephen e você estava usando o gimp 2.8. Clique no nome do arquivo para fazer o download.

autoAutoUpdate.py
Executa a função de atualização automática em um diretório de imagens.
autoBase.py
Contém as classes que leem e gravam os arquivos XML que afetam o funcionamento da atualização.
autoCommander.py
Executa as macros 'Commander'.
autoJpegToXcf.py
Importa as imagens no formato xcf e atribui propriedades à imagem.
autoRWparasites.py
Funções da interface do usuário para ler e gravar parasitas de imagem no menu.
autoWriteXml.py
Lê arquivos * .def e gera XML para macros, fluxos de trabalho e propriedades do commander.
autoXcfToJpg.py
Exporta as imagens finalizadas de volta para o formato jpeg.

Configurando o pseudo-código de exemplo

Abaixo do seu diretório gimp (algo como /home/stephen/.gimp-2.8) você precisa criar um diretório chamado 'myXml'. Não seja criativo aqui, os scripts estão procurando por este diretório específico. Ele estará no mesmo diretório que contém seu diretório de plug-ins. Abaixo do diretório myXml, crie mais três diretórios, 'commander', 'flow', 'property'. Estes serão onde o seu pseudo código e três tipos de XML serão localizados.

Pseudo-código para macros Commander

Copie os seguintes arquivos * .def para o diretório “commander” (/home/stephen/.gimp-2.8/myXml/commander - assumindo um diretório home de / user / stephen e um gimp versão 2.8). Eles são exemplos de arquivos de pseudocódigo do Commander Macros. Clique no nome do arquivo para fazer o download.

Espero que com os comentários e executando-os, sua função seja aparente. Eles devem ser suficientes para você começar a escrever algumas macros de sua preferência.

Quando você executar a função Utilitário “Pseudocódigo para XML ”, ele lerá todos os arquivos * .def nesse diretório e gravará um arquivo XML nesse diretório chamado “combinedCommander.xml”. “CombinedCommander.xml” é o arquivo que é acessado para listar e executar todas as suas macros.

Pseudo-código para fluxos de trabalho de automação

Copie os seguintes arquivos * .def para o diretório “flow” (/home/stephen/.gimp-2.8/myXml/flow). Eles são exemplos de arquivos de código de pseudo-fluxo de trabalho.

Esses três fluxos de trabalho seguem os mesmos passos básicos do fluxo de trabalho padrão. Os fluxos de trabalho semiauto e fullauto combinam algumas das etapas. A ideia é oferecer alguns fluxos de trabalho diferentes para você jogar. O fullauto ilustra que você realmente pode colocar muitas edições em um “passo”, mas é provavelmente muito automático para ser de uso prático.

Quando você executar a função Utilitário “Pseudocódigo para XML ”, ele lerá todos os arquivos * .def nesse diretório e gravará um arquivo XML nesse diretório chamado “combinedFlow.xml”.

Pseudocódigo para propriedades

Copie o seguinte arquivo * .def para o diretório “property” (/home/stephen/.gimp-2.8/myXml/property). É um exemplo de arquivo de código de pseudo da propriedade (para propriedades de sinalizador / parasitas).

flagProperties.def

Quando você executar a função Utilitário “Pseudocódigo para XML ”, ele lerá o arquivo * .def nesse diretório e gravará um arquivo XML nesse diretório chamado “flagProperties.xml”.

Sintaxe de

Comandante Pseudo Código

Existem três palavras-chave usadas para escrever o pseudo código do commander:

commander> - O texto que segue esta palavra-chave é o nome da macro.Essa palavra-chave deve ser a primeira palavra-chave no arquivo. Este é o "container" ou a raiz da árvore para os seguintes comentários e comandos.
comment> - O texto que segue esta palavra-chave é para comentários descritivos. Os comentários serão representados no arquivo pseudo-código * .def e no XML resultante. Quando o XML é lido para processamento, os comentários serão ignorados.
>>> - O texto que segue esta palavra-chave é considerado como uma instrução python. Em seguida, o XML resultante é lido, as instruções de comando serão passadas para o script do comandante para serem processadas em ordem.

Observe que as linhas que começam com “#” são ignoradas. Você pode recuar se quiser legibilidade. Espaço em branco principal é removido.

Exemplo - exemplo de pseudocódigo de comandante

  Comandante > Grade Centrada
    comentário > ** Configurar a grade para Girar e ou Transformar Perspectiva
    comment > * Definir valores do objeto de imagem python - fu
    >>> centerX = theImage .  largura / 2
    >>> centerY = theImage .  altura / 2
    >>> gridSpacing = max (a largura da imagem , a altura da imagem ) / 24
    comentário > * configure grid com funções do PDB
    >>> pdb .  gimp_image_grid_set_offset ( theImage , centerX , centerY )
    >>> pdb .  gimp_image_grid_set_spacing ( theImage , gridSpacing , gridSpacing )
    >>> pdb .  gimp_image_grid_set_style ( theImage , GRID_ON_OFF_DASH )

Pseudo-código de propriedade

Existem cinco palavras-chave usadas para escrever o pseudo código de propriedade:

flags - O texto que segue esta palavra-chave é o container de nível superior, ou em outras palavras, a raiz da árvore.
property - O texto que segue a palavra-chave é o nome da propriedade / parasite. Este é um contêiner de segundo nível ou um ramo da árvore. Ele conterá todas as seguintes palavras-chave de folha (comentário, padrão e opção) até a próxima declaração de propriedade.
comment - O texto que segue esta palavra-chave é para comentários descritivos. Os comentários serão representados no arquivo pseudo-código * .def e no XML resultante. Quando o XML é lido para processamento, os comentários serão ignorados. Os comentários são folhas da árvore.
default - O texto que segue esta palavra-chave é o valor da propriedade padrão. O valor padrão é uma folha da árvore.
opção - o texto que segue esta palavra-chave é um dos possíveis valores de propriedade. Pode haver vários valores de opção para qualquer propriedade específica. Os valores das opções são folhas da árvore.

Exemplo - exemplo de pseudocódigo de propriedade

  sinalizadores > Propriedades do Controle
 propriedade > UpdateFlag
     comentário > Valor inicial definido na importação para Xcf
     comentário > Definir pelo usuário na imagem do menu de automação
     comentário > Leia por autoAutoUpdate ( função updateImage )
     comentário > Imagem Atualizada ( executa o Próximo Passo no Fluxo ) se SIM
     comentário > Redefinir para NÃO por updateImage
     padrão > YES
     opção > NÃO
     opção > SIM

 propriedade > EnhanceColorLevel
     padrão > NORMAL
     opção > EXTRA
     opção > NORMAL
     opção > MID
     opção > NONE

Fluir Pseudo Código

Existem quatro palavras-chave usadas para escrever pseudocódigo de fluxo:

flow O texto após essa palavra-chave é o contêiner de nível superior ou, em outras palavras, a raiz da árvore. Este é o nome do fluxo.
O texto que segue esta palavra-chave é o ramo de primeiro nível da raiz. A etapa contém comentários e comandos. Os passos selecionam grupos de comandos para execução.
comment comentários são folhas da árvore.
>>> Comandos são folhas da árvore. Quando o Xml é lido, os comandos serão processados na ordem em que aparecem na etapa.

Linhas começando com um “#” são ignoradas. Espaço em branco antes de as palavras-chave serem removidas. Espaço em branco após a palavra-chave ser removida.

Executando código no console do Gimp Python

O console Python-Fu é um shell python no qual você pode executar não apenas as funções pimp do gimp, mas também suas próprias funções python.

Primeiro, configure e verifique o caminho do Python para incluir o diretório de plug-ins do usuário:

Exemplo - Configurando o caminho do Python no console Python-Fu

  >>> import sys
 >>> sys  caminho .  append ( '/home/stephen/.gimp-2.8/plug-ins/' )
 >>> sys  caminho

echos de volta uma lista de caminhos que incluem o caminho adicionado acima

Em seguida, execute suas funções python no Gimp Python-Console. Este exemplo usa a classe 'TestBench' para executar funções nas outras classes no módulo autoBase.py. As instâncias de objetos da classe TestBench ecoam os resultados na tela.

Configure o diretório de trabalho para o diretório de plug-ins do usuário
Importar as funções do módulo autoBase
Criar e instância da classe TestBench
Execute as funções TestXmlGen e TestXmlRead

Exemplo - Executando suas próprias funções no console Python-Fu

  >>> import os
 >>> os .  chdir ( '/home/stephen/.gimp-2.8/plug-ins' )
 >>> da importação de autoBase *
 >>> testola = TestBench ()
 >>> testola  TestXmlGen ()
 >>> testola  TestXmlRead ()

A captura de tela abaixo ilustra o processo na versão Windows do Console Gimp / Python (o TestXmlGen é mostrado na imagem, o TestXmlRead produz várias páginas de saída):

Apêndice-testing-em-python-console.JPG — Image - Executando seu código no console do Gimp Python

Leitura adicional

JPG automatizado para XCF