Guia Enciclopédico GIMP

O que você vai aprender

Navegar o Procedure Browser para descobrir procedimentos disponíveis
Consultar parâmetros e tipos de retorno de qualquer procedimento do PDB
Usar introspecção (gimp-procedural-db-*) para consultar a API programaticamente

Definição🔗

O PDB (Procedure Database) e o catálogo central que expõe toda a API interna do GIMP para scripts, plugins e o próprio aplicativo. Cada operação realizável — abrir arquivo, criar camada, aplicar filtro, desfazer, exportar — e registrada como um procedimento com nome, parâmetros tipados e valor de retorno. Quando você clica em um menu do GIMP, internamente ele chama um procedimento do PDB; quando um Script-Fu executa (gimp-desaturate ...), ele também. O PDB e, portanto, a única superfície de API estável e completa do GIMP.

O PDB pode ser inspecionado visualmente através do Procedure Browser, ou consultado via código com procedimentos de introspecção como gimp-procedural-db-procedure-entry e gimp-procedural-db-query.

Conceitos🔗

flowchart TB
    A[PDB - Catálogo central] --> B[gimp-image-*]
    A --> C[gimp-layer-*]
    A --> D[gimp-drawable-*]
    A --> E[file-*]
    A --> F[plug-in-*]
    A --> G[script-fu-*]
    A --> H[pdb-*]
    B --> B1[gimp-image-new]
    B --> B2[gimp-image-flatten]
    C --> C1[gimp-layer-new]
    C --> C2[gimp-layer-resize]
    D --> D1[gimp-drawable-desaturate]
    D --> D2[gimp-drawable-invert]
    E --> E1[file-png-load]
    E --> E2[file-png-save]
    F --> F1[plug-in-gauss]
    F --> F2[plug-in-unsharp-mask]

Conceitos-chave:

Procedimento — função registrada no PDB. Identificada por nome único (gimp-image-new), parâmetros tipados e tipo de retorno.
Tipo PDB — cada parâmetro tem um tipo do PDB (PDB_INT32, PDB_IMAGE, PDB_DRAWABLE, PDB_STRING, PDB_FLOAT, PDB_COLOR, PDB_STATUS, etc.). Em Python-Fu, esses tipos são automaticamente convertidos.
Introspecção — procedimentos do PDB podem listar outros procedimentos: gimp-procedural-db-query retorna nomes; gimp-procedural-db-procedure-entry retorna a definição completa.
Procedure Browser — interface gráfica em Help > Procedure Browser que lista todos os procedimentos com filtros por nome, descrição, autor, etc.
Prefixo de namespace — gimp- para o core, file- para formatos, plug-in- para filtros compilados, script-fu- e python-fu- para os respectivos módulos de scripting.

Fluxo de Uso🔗

flowchart TD
    A[Decidir tarefa] --> B[Help > Procedure Browser]
    B --> C{Filtro por nome ou descrição}
    C --> D[Selecionar procedimento]
    D --> E[Ver parâmetros e retorno]
    E --> F[Testar via Script-Fu Console]
    F --> G{Funciona?}
    G -->|Não| C
    G -->|Sim| H[Incorporar ao script]
    H --> I[Chamar de Script-Fu, Python-Fu ou C]

Exemplos Práticos🔗

Exemplo 1 — Listar todos os procedimentos via Script-Fu

(let* ((todos (cadr (gimp-procedural-db-query ".*" ".*" ".*" ".*" ".*" ".*" ".*")))
       (contador 0))
  (while (and (< contador 5) (not (null? todos)))
    (gimp-message (car todos))
    (set! todos (cdr todos))
    (set! contador (+ contador 1))))

gimp-procedural-db-query recebe 7 regex (nome, descrição, autor, copyright, data, tipo, help) e retorna (contador . lista). O exemplo imprime os 5 primeiros procedimentos.

Exemplo 2 — Obter a definição completa de um procedimento

(let* ((entry (car (gimp-procedural-db-procedure-entry "gimp-image-new"))))
  (gimp-message (car entry))                       ; nome
  (gimp-message (vector-ref entry 2))              ; parametros
  (gimp-message (vector-ref entry 4))              ; tipo de retorno
  (gimp-message (vector-ref entry 6)))             ; help string

procedure-entry retorna um vetor com: nome, descrição, parâmetros, valores de retorno, tipo, autor, help. Em Python-Fu, pdb.gimp_procedural_db_procedure_entry('gimp-image-new') retorna uma tupla mais ergonômica.

Exemplo 3 — Buscar procedimentos por substring em Python

import gi
gi.require_version('Gimp', '3.0')
from gi.repository import Gimp

# Buscar todos procedimentos cujo nome contem 'blur'
resultado = Gimp.procedural_db_query(".*blur.*", ".*", ".*", ".*", ".*", ".*", ".*")
# resultado = (count, list_of_names)
count, nomes = resultado
for nome in nomes[:10]:
    print(nome)

O Python-Fu expõe o PDB como módulo Gimp no estilo GObject; no estilo gimpfu clássico use pdb.gimp_procedural_db_query.

Exemplo 4 — Chamar procedimento via PDB a partir de Python

# Criar uma imagem 800x600 RGB
imagem = pdb.gimp_image_new(800, 600, RGB)
# Criar camada
camada = pdb.gimp_layer_new(imagem, 800, 600, RGBA_IMAGE, "Fundo", 100, LAYER_MODE_NORMAL)
# Inserir camada na imagem
pdb.gimp_image_insert_layer(imagem, camada, None, 0)
# Preencher com branco
pdb.gimp_context_set_background((1.0, 1.0, 1.0))
pdb.gimp_edit_fill(camada, FILL_BACKGROUND)
# Exibir
pdb.gimp_display_new(imagem)

Cada chamada aqui é um wrapper sobre um procedimento do PDB. O objeto pdb expõe todos eles como métodos Python.

Exemplo 5 — Verificar argumentos de um procedimento

(let* ((info (gimp-procedural-db-procedure-args "plug-in-gauss")))
  (map (lambda (arg)
         (gimp-message (format nil "tipo:~A  nome:~A  desc:~A"
                              (car arg) (cadr arg) (caddr arg))))
       info))

procedure-args retorna a lista de parâmetros com tipo, nome e descrição — útil para gerar wrappers tipados automaticamente ou validar chamadas antes de executá-las.

Categorias Principais🔗

Prefixo	Categoria	Exemplos
`gimp-image-*`	Operações em imagem	`gimp-image-new`, `gimp-image-flatten`, `gimp-image-resize`
`gimp-layer-*`	Operações em camada	`gimp-layer-new`, `gimp-layer-resize`, `gimp-layer-set-opacity`
`gimp-drawable-*`	Operações genéricas de drawable	`gimp-drawable-desaturate`, `gimp-drawable-invert`
`gimp-channel-*`	Canais e máscaras	`gimp-channel-new`, `gimp-channel-copy`
`gimp-vectors-*`	Caminhos (paths)	`gimp-vectors-new`, `gimp-vectors-stroke`
`file-*`	Carregar/salvar arquivos	`file-png-load`, `file-png-save`, `file-jpeg-load`
`plug-in-*`	Filtros compilados em C	`plug-in-gauss`, `plug-in-unsharp-mask`, `plug-in-cartoon`
`script-fu-` / `python-fu-`	Wrappers dos módulos de scripting	`script-fu-register`, `python-fu-eval`

Onde Encontrar Documentação🔗

Procedure Browser gráfico: Help > Procedure Browser dentro do GIMP.
Online: índice completo na GIMP Procedure Browser docs.
No código: sempre use o nome completo do procedimento; chamadas abreviadas não existem.

Você aprendeu

O PDB é o catálogo central que expõe toda a API do GIMP para scripts e plugins
O Procedure Browser (Help > Procedure Browser) permite inspecionar visualmente todos os procedimentos
Cada operação do GIMP — abrir arquivo, aplicar filtro, criar camada — é um procedimento PDB