| Python-fu para no programadores: Creando scripts en Gimp | ||
|---|---|---|
| Anterior | Capítulo 3. Trabajando con script en Gimp | Siguiente |
La estructura de un script en Gimp, es muy parecida (por no decir igual) que la de un script en Python. Lo único es que nosotros no tenemos un programa principal tal cual lo tenemos en Python, lo que tenemos es la llamada a una función llamada "register", que se le pasan una serie de parámetros con la información de nuestro script. El código en sí (lo que hace nuestro programa) se encuentra en una función. La función "register" lo que contiene es el nombre del creador del script, una descripción del programa, los componentes que aparecerán en nuestra ventana (por ejemplo una caja de texto y una caja para insertar un dato numérico), la función que va a ejecutar nuestro script al pulsar el botón "Aceptar" y algunas cosas más que veremos una a una más adelante. Así que los scripts en Gimp tendrán la misma estructura que uno en Python. Pasamos ya a la acción y veamos un script sencillo y estudiamos todas sus partes:
>>> #!/usr/bin/env python >>> # Script para Gimp en Python >>> # Realizado por Fco. Javier Pérez Pacheco como ejercicio >>> # para el artículo "Python-fu para no programadores". >>> # Este ejercicio escala una imagen >>> # importamos los módulos necesarios >>> from gimpfu import * >>> # definimos las funciones necesarias >>> def Resize(img, drawable, width, height): >>> # comenzamos a agrupar el UNDO >>> pdb.gimp_image_undo_group_start(img) >>> pdb.gimp_image_scale(img, width, height) >>> # agrupamos UNDO >>> pdb.gimp_image_undo_group_end(img) >>> # función principal >>> if __name__ == '__main__': >>> # llamada a función register >>> register( >>> "redimensionar_imagen", >>> "Redimensionar imagen", >>> "Redimensionar imagen", >>> "Javi Pacheco", >>> "Javi Pacheco", >>> "2005", >>> "<Image>/Python-Fu/Ejemplos/1- Basico/Redimensionar imagen", >>> "RGB*, GRAY*", >>> [ >>> (PF_SPINNER, "width", "Ancho", 200, (0, 1000, 1)), >>> (PF_SPINNER, "height", "Alto", 200, (0, 1000, 1)) >>> ], >>> [], >>> Resize) >>> main()
El código de este ejemplo se encuentra en el archivo "resize.py".
Empezamos por algo muy sencillo para ver de que va todo esto. Este script lo único que hace es escalar el tamaño de una imagen, estableciendo nosotros tanto el ancho como el alto de esta.
Si nos fijamos en la estructura general de nuestro script es muy parecida a la estructura de un script en Python. Primero importamos los módulos necesarios, en nuestro caso importamos:
from gimpfu import *
Que es un módulo que siempre vamos a tener que importar en nuestros scripts. Lo segundo definimos las funciones necesarias, en nuestro caso la función se llama "Redimensionar" y es la función que va a realizar la tarea de escalar la imagen. Más tarde hablaremos sobre los parámetros que tenemos que pasarle. Por último tenemos la función principal que esta tiene una llamada a la función "register" que como ya hemos dicho es la encargada de decirle a Gimp lo que tiene que hacer con nuestro script.
Vamos a ir por partes y en las dos siguientes secciones vamos a ver las carácterísticas que tiene las dos partes esenciales de nuestro script: por una parte la llamada a "register" y por otra parte la función que va a realizar el trabajo.
Aquí es donde vamos a decirle a Gimp toda la información que necesita para trabajar con nuestro script. Vamos a ver uno a uno los parámetros de la función:
>>> register( >>> "redimensionar_imagen", >>> "Redimensionar imagen", >>> "Redimensionar imagen", >>> "Javi Pacheco", >>> "Javi Pacheco", >>> "2005", >>> "<Image>/Python-Fu/Ejemplos/1- Basico/Redimensionar imagen", >>> "RGB*, GRAY*", >>> [ >>> (PF_SPINNER, "width", "Ancho", 200, (0, 1000, 1)), >>> (PF_SPINNER, "height", "Alto", 200, (0, 1000, 1)) >>> ], >>> [], >>> Resize)
Algunos de los parámetros no hace falta que se expliquen, pero nos vamos a detener en varios que si necesitan un explicación.
El primer parámetro es el nombre del script. Este tiene que ser único, por lo que no puede existir otro script con el mismo nombre y no tiene que tener ni acentos, ni espacios, ni caracteres especiales.
Los siguiente parámetros son textos de ayuda, nombre del autor, año, etc.
Ruta del script en el menú de Gimp: aquí es donde colocaremos la ruta donde va a aparecer nuestro script. Esta ruta es donde el usuario va a tener que acceder para poder ejecutarlo. Pensemos en ella como una ruta de directorios y cada "/" será un submenú en el menú de Gimp. La ruta la podemos empezar de dos formas: con <Image> o con <Toolbox>. La primera significa que el menú por el que tendremos que ejecutar el script será en el menú de la imagen que tengamos abierta y la segunda será en el menú de la caja de herramientas de Gimp. Nosotros sólo veremos la primera opción, para no liarnos, pero podrás ver un ejemplo de creación de una esfera que Gimp trae por defecto.
Tipo de la imagen: este parámentro lo dejaremos siempre así.
Parámetros del script: aquí es donde vamos a colocar todos los componenetes (cajas de textos, radios, etc...) que necesitamos para nuestro script. En nuestro ejemplo tenemos dos objetos PF_SPINNER que son cajas donde podremos colocar un número (ancho y alto). Fijémonos que todos los elementos se encuentran entre corchetes y dentro cada uno de ellos se separan por comas. Cada elemento se encuentra entre paréntesis y cada parámetro del elemento de nuevo separado por comas. Esto puede parecer muy lioso pero luego lo que haremos es copiar y pegar, por lo que no resultará tan complicado. Cada elemento lo colocamos en una línea para poder visualizar mejor los parámetros aunque podríamos tenerlos todos juntos en una sólo línea. Vamos a fijaros en uno de los elementos:
(PF_SPINNER, "width", "Ancho", 200, (0, 1000, 1))
Primero se le pasa el tipo de elemento, en nuestro caso PF_SPINNER, en la siguiente sección veremos los diferentes tipos de elementos que existen. Luego se le pasa el nombre del parámetro (ancho). Este nombre es la variable que utilizará nuestra función para poder recoger el número que ha escrito el usuario en la caja. El siguiente es el nombre que acompañará a la caja a la izquierda de esta (Ancho). Luego le podremos el número por defecto que aparecerá en la caja (en nuestro caso 200). El último elementos es un poco especial y sólo sirve para elementos PF_SPINNER, en otros elementos este parámentro no aparecerá ya que no tiene sentido para ellos. Este elemento sirve para insertar un número, y a la derecha de la caja aparecen dos flechas para poder incrementar o decrementarlo. Los 3 valores que aparecen son en orden: el número más bajo que podemos colocar en el elemento, el número más alto y el valor de incremento. Así cada vez que pulsemos en los botones de incremento y decremento se sumará o restará 1, siempre entre los valores 0 a 1000.
Resultados: lo dejaremos siempre tal y como está.
Función: aquí colocaremos el nombre de la función que realizará el trabajo en nuestro caso "Resize". Vamos a fijarnos un momentos en los parametros definidos en la función "Resize":
def Resize(img, drawable, width, height):
Fijémonos que son 4 parámetros. Los dos primeros siempre aparecerán en la función. Estos hacen referencia, el primero a la imagen y el segundo a la capa activa. A continuación de estos 2 pondremos en orden los parámetros que hemos puesto entre corchetes en la función "register" (con el mismo nombre que hemos colocado en el segundo parámetro del elemento). Todo esto y como trabajar con la función lo veremos más adelante.
Como hemos visto, los parámetros se colocan entre paréntesis y dentro tenemos 4 partes sepadas por comas. En algunos casos especiales una quinta parte con información para ese elemento concreto. Recordemos las cuatros partes:
Tipo del elemento
Nombre de la variable (no puede tener espacios)
Título que acompañará a la izquierda del elemento en el script
Valor por defecto
Parámetro especial en el caso que sea necesario
A continuación vamos a explicar los tipos de parámetros que podemos utilizar en nuestro script:
PF_INT: es un tipo entero. A él solo podemos pasarle un número.
(PF_INT, "width_image", "Ancho de la imagen", 600)
PF_FLOAT: es un tipo racional con decimales. A él solo podemos pasarle un número decimal.
(PF_FLOAT, "scale", "Escala", 1.5)
PF_STRING: es un tipo texto.
(PF_STRING, "text", "Texto", "Texto por defecto")
PF_COLOR: con este elemento podremos definir un color. El color de definimos en RGB (se da por supuesto que se sabe como trabajar con colores RGB). El siguiente ejemplo define un elemento que por defecto se encuentra en color blanco.
(PF_COLOR, "color_background", "Color de Fondo", (255,255,255)),
PF_TOGGLE: es un tipo booleano. Esto es para preguntar al usuario por algo que puede ser verdadero o falso. Por ejemplo necesitamos saber si el usuario quiere alinear una capa en vertical, lo hacemos así (por defecto estará activada):
(PF_TOGGLE, "align_vertical", "Alineación vertical", True)
PF_SPINNER: este es de esos elementos con un quinto parámentro especial. Ya lo hemos explicado anteriormente. Para quien no lo recuerde, este elementos guarda un dato numérico y el quinto parámetro define los valores de inicio, fin e incremento.
(PF_SPINNER, "height", "Alto", 200, (0, 1000, 1))
PF_SLIDER: este elemento es igual que el anterior, lo único que cambia es la forma de mostrar el elemento al usuario para que pueda cambiar los datos. Este elemento aparecerá como una barra delizadora.
(PF_SLIDER, "height", "Alto", 200, (0, 1000, 1))
PF_FILE: aquí podremos abrir una ventana de diálogo para seleccionar un archivo o directorio.
(PF_FILE, "path", "Directorio", "")
PF_FONT: con este elemento podemos definir un tipo de fuente.
(PF_FONT, "font","Fuente", "Sans 10")
PF_RADIO: nos da la posibilidad de elegir entre varias opciones. En el siguiente ejemplo podemos elegir entre varios formatos de imágenes (gif o jpg). Por defecto ponemos que se seleccione "gif" y utilizamos el parámetro especial para decirle los tipos que queremos aparezcan. Aunque parece un lío de paréntesis no es tan complicado.
(PF_RADIO, "extension", "Extensión:", "gif", (("gif", "gif"), ("jpg", "jpg")) )PF_BRUSH: nos da la posibilidad de seleccionar una brocha.
(PF_BRUSH, "brush","Brocha", "")
PF_PATTERN: nos da la posibilidad de seleccionar un patrón.
(PF_PATTERN, "pattern","Patrón", "")
PF_GRADIENT: nos da la posibilidad de seleccionar un gradiente.
(PF_GRADIENT, "gradient","Gradiente", "")
Hemos visto los diferentes parámetros, pero ahora queda lo mejor, que hacer con ellos. En la siguiente sección podemos ver como trabajar con los parámetros y como utilizarlos. Empieza la acción.
Aquí vamos a empezar ya con lo que queremos que nuestros scripts hagan. Es importante entender esta parte con claridad y como utilizar los diferentes objetos. Vamos a poner la definición del ejemplo anterior para ver las cosas con más claridad:
def Resize(img, drawable, width, height):
Como hemos dicho anteriormente, los dos primeros parámetros son obligatorios, el primero es la imagen y el segundo la capa activa. A continuación se colocan todo los parámetros por orden. Estos parámetros los utilizaremos para hacer los que necesita nuestro script, en nuestro caso redimensionar la imagen.
Las variables "img" y "drawable" tienen una serie de propiedades que veremos más tarde cuales son y como trabajar con ellas. A estas dos tenemos que añadirle una más llamada "pdb" que es una variable global y no necesitamos pasarla en nuestra función principal. Esta variable es muy importante ya que es la que nos da accesos a todas las funciones de Gimp como escalar imágenes, utilizar filtros, dibujar, etc. También veremos más adelante como trabajar con este elemento, cuales son las funciones más comunes y como buscar en la API de Gimp para poder ver las posibilidades que tenemos.
Como hemos dicho "img" nos da información de la imagen y también podremos modificarla. A continuación mostramos sus propiedades:
img.height: devuelve la altura de la imagen
img.width: devuelve la anchura de la imagen
img.layers: devuelve un array con las capas de la imagen. Por ejemplo si queremos acceder a la primera capa deberíamos de poner "img.layers[0]" (el número dice la posición de la capa empezando por 0)
img.filename: devuelve el nombre del archivo con la ruta
img.active_layer: devuelve la capa activa.
Estas son las propiedades más importantes. A continuación mostramos los métodos. Los métodos son funciones con las que podremos generar una acción sobre la imagen.
img.add_layer(layer, position): a este método se le pasan dos parámetros. El primero una capa creada anteriormente y el segundo la posición donde queremos poner la capa en nuestra imagen
img.lower_layer(layer): baja la posición de la capa pasada en el parámetro
img.remove_layer(layer): borra la capa pasada en el parámetro
img.resize(width, height, x, y): redimensiona el lienzo de la imagen moviendola a una posición x e y
Por supuesto hay muchos más métodos y propiedades, pero estos son los más comunes.
La variable "drawable" nos da información de la capa. A continuación mostramos sus propiedades:
drawable.height: devuelve la altura de la capa
drawable.width: devuelve el ancho de la capa
drawable.name: devuelve el nombre de la capa
drawable.opacity: devuelve la opacidad de la capa
A continuación mostramos algunos de sus métodos:
drawable.add_alpha(): en el caso de la capa no tenga canal alpha (por ejemplo capa de fondo) esta función le añade este canal
drawable.copy([alpha]): crea una copia de la capa. Se le pasa un parámetro booleano (True o False) si queremos que tenga o no canal alpha
drawable.resize(width, height, x, y): redimensiona la capa moviendola a una posición x e y
drawable.scale(width, height, origin): escala la capa
drawable.translate(x, y): posiciona la capa en una coordenada x e y
Hemos visto muchas de las posibilidades que nos da Gimp para trabajar con capas. Es importante enterder que aunque se ha puesto la variable "drawable" en los ejemplos, estos métodos los podemos utilizar con cualquier capa. Por ejemplo podemos posicionar una capa cualquiera (en el siguiente ejemplo la capa que se encuentra en la posición 3) a otro punto cualquiera de la siguiente forma:
>>> # creamos una variable "capa" que apunta a la capa que está en la posición de la imagen >>> layer_postion3 = img.layers[3] >>> >>> # movemos la capa a la posición que queramos >>> layer_postion3.translate(200, 150)
La variable "pdb" es la que nos va a proporcionar el acceso a la API de Gimp. Estas son todas las funciones maravillosas que hacen que Gimp sea el gran programa de retoque fotográfico que todos conocemos. Así podremos redimensionar la imagen, crear selecciones, rellenar de color, crear capas, hacer degradados y todo lo que puedas hacer con Gimp, pero desde código. Aquí es realmente donde nuestros scripts hacen cosas interesantes.
Ahora ¿como sabemos cuales son las funciones de la API? Pues a continuación veremos algunas de ellas, y más tarde mostraremos como podemos encontrar en Gimp una lista de todos los métodos para poder utilizarlos en nuestros scripts. Estan todos, pero están en Inglés.
Pero ¿qué es un método? ¿cómo lo llamo? Imagínate que cada método al que llamas es como si pulsaras un botón de Gimp y le dieras una serie de opciones (parámetros). Por ejemplo, imaginemos que queremos escalar una imagen (como en el ejemplo anterior). Pues normalmente lo que hacemos es irnos al menú de Gimp, pulsamos en "Imagen - Escalar imagen" y en esa ventana ponemos el ancho y alto. Ahora lo que queremos es hacerlo en un script. Para ello escribimos lo siguiente:
pdb.gimp_image_scale(img, width, height)
Y ya está. ¿Qué hemos hecho? Muy sencillo. Hemos escrito "pdb" que es la variable que nos da acceso a toda la API de Gimp, luego escribimos ".", a continuación escribimos el nombre del método que se encarga de escalar la imagen (como si pulsasemos en "Escalar Imagen") y por último entre paréntesis y separados por comas los parámetros (opciones del método) que necesita la función. Para nuestra función son 3: el primero es la imagen que queremos escalar (recuerda que "img" en nuestro programa era el primer parámetro de la función "Resize" y nos apuntaba a la imagen), luego escribimos el ancho y el alto de la imagen (también son parámetro de la función "Resize" que en nuestro programa esas variables representaban a los valores que ha escrito el usuario en el script), y ya está. Ya tenemos nuestra función para escalar. Así serán todas las funciones. O sea, los métodos siempre tendrán un nombre (como un botón de Gimp, en nuestro caso "gimp_image_scale") y unos parámetros (que son las opciones de nuestro botón).
Por último comentar que algunos métodos devuelven infomación. Por ejemplo:
layer = pdb.gimp_file_load_layer(img, "nombrearchivo.jpg")
Fijaros al principio de la sentencia. El método "gimp_file_load_layer" crea una nueva capa en la imagen "img" cuyo contenido es la fotografía "nombrearchivo.jpg". A parte devuelve un valor que guardaremos en la variable "layer" que apunta a la nueva capa que hemos creado y a la cual podremos hacerle nuevas acciones, como posionar la capa en un punto concreto o cambiar el tamaño de la capa.
Ya estamos preparados para ver algunos de los métodos de Gimp.
Estos métodos nos ayudarán a trabajar con las imágenes:
pdb.gimp_image_scale(img, width, height): escala una imagen.
img: imagen que queremos escalar
width: ancho de la imagen
height: alto de la imagen
pdb.gimp_image_merge_visible_layers(img, 1): combina todas las capas visibles.
img: imagen que queremos combinar
img = pdb.gimp_file_load(file,file): carga una imagen en nuestro canvas y nos devuelve la imagen nueva con la que tenemos que trabajar.
file: ruta absoluta de la imagen (se coloca dos veces)
img: apunta a la imagen nueva
pdb.gimp_file_save(img, layer, file, file): guarda una imagen en el disco. En realialidad guarda la capa que se pasa como segundo parámetro.
img: imagen
layer: capa a guardar. Si anteriormente hemos combinado todas las capas podemos poner "img.layers[0]" para que guarde la primera capa
file ruta absoluta de la imagen (se coloca dos veces)
pdb.gimp_image_add_layer(img, layer, position): añade la capa "layer" a la imagen "img" en una posición concreta. No tenemos que confundir conceptos, este método no crea una capa sino que la añade (la capa hay que crearla previamente).
img: imagen
layer: capa que queremos añadir
position: posición de la capa. -1 la crea al fondo de la imagen
pdb.gimp_image_undo_group_start(img): comienza un grupo de UNDO. Este método se suele poner al principio de los scripts para que todas las acciones se realicen como si fuera una única acción y podamos deshacer todo lo que realicemos sólo pulsando CONTROL+Z.
img: imagen
pdb.gimp_image_undo_group_end(img): termina un grupo de UNDO. Este método se suele poner al final de los scripts.
img: imagen
Estos métodos nos ayudarán a trabajar con las imágenes:
layer_copy = layer.copy(TRUE): copia una capa.
layer: capa que queremos copiar
layer_copy: copia de la capa
pdb.gimp_layer_delete(layer): elimina una capa.
layer: capa a eliminar
new_layer = pdb.gimp_layer_new(img, w, h, type, name, opacity, mode): crea una nueva capa. Esto no añade la capa a la imagen, para esto luego de crearla hay que utilizar "gimp_image_add_layer".
new_layer: nueva capa
img: imagen
w: ancho de la capa
h: alto de la capa
type: puede ser: RGB_IMAGE (0), RGBA_IMAGE (1), GRAY_IMAGE (2), GRAYA_IMAGE (3), INDEXED_IMAGE (4) o INDEXEDA_IMAGE (5)
name: nombre de la capa
opacity: opacidad de la capa
mode: puede ser: NORMAL_MODE (0), DISSOLVE_MODE (1), BEHIND_MODE (2), MULTIPLY_MODE (3), SCREEN_MODE (4), OVERLAY_MODE (5), DIFFERENCE_MODE (6), ADDITION_MODE (7), SUBTRACT_MODE (8), DARKEN_ONLY_MODE (9), LIGHTEN_ONLY_MODE (10), HUE_MODE (11), SATURATION_MODE (12), COLOR_MODE (13), VALUE_MODE (14), DIVIDE_MODE (15), DODGE_MODE (16), BURN_MODE (17), HARDLIGHT_MODE (18), SOFTLIGHT_MODE (19), GRAIN_EXTRACT_MODE (20), GRAIN_MERGE_MODE (21), COLOR_ERASE_MODE (22)
pdb.gimp_layer_scale(layer, width, height, origen): escala una capa.
layer: capa que queremos escalar
width: ancho de la capa
height: alto de la capa
origen: valdrá "0"
pdb.gimp_layer_translate(layer, move_x, move_y): desplaza una capa.
layer: capa
move_x: pixels que queremos desplazar en x
move_y: pixels que queremos desplazar en y
pdb.gimp_layer_set_opacity(layer, opacity): establece la opacidad de una capa.
layer: capa
opacity: número del 0 al 100 con la opacidad
layer = pdb.gimp_text_fontname(img, drawable, x, y, "texto", border, antialias, size, type_size, font): crea una capa con un texto.
layer: capa que creará
img: imagen
drawable: capa
x: posición x
y: posición y
texto: cadena con el texto a escribir en la capa
border: tamaño del borde
antialias: podrá ser: "True" o "False"
size: número que contiene el tamaño de la fuente
type_size: la unidad en la que estará el tamaño. Podrá ser: "PIXELS" o "POINTS"
font: cadena de texto con el nombre de la fuente
Con los métodos de color podremos trabajar con la paleta de colores:
pdb.gimp_context_set_foreground(color): establece el color de frente de la paleta de colores
color: color en RGB. Por ejemplo (255,255,255) será el blanco
pdb.gimp_context_set_background(color): establece el color de fondo de la paleta de colores
color: color en RGB
fg = gimp.get_foreground(): nos proporciona el color que tiene el frente de la paleta de colores
fg: color de frente
bg = gimp.get_background(): nos proporciona el color que tiene el fondo de la paleta de colores
bg: color de fondo
pdb.gimp_edit_fill(layer, color): rellena una capa de un color determinado
layer: variable que apunta a la capa
color: color en RGB
Una de las cosas más importante es poder trabajar con las selecciones. Aquí vemos algunas posibilidades:
pdb.gimp_rect_select(img, x, y, w, h, operation, pluma, radio): crea una selección en forma de cuadrado
img: imagen
x: posición x donde empezará el cuadrado
y: posición y donde empezará el cuadrado
w: ancho del cuadrado
h: alto del cuadrado
operation: puede ser: CHANNEL_OP_ADD (0), CHANNEL_OP_SUBTRACT (1), CHANNEL_OP_REPLACE (2), CHANNEL_OP_INTERSECT (3). No dirá si se añade a otra selección anterior, la resta, la reemplaza o la intersecta
pluma: realmente no se para que sirve
radio: se le hace un desenfoque a la selección del radio puesto aquí
pdb.gimp_selection_border(img, thickness): crea un borde a la selección actual
img: imagen
thickness: pixels de grosor del borde
pdb.gimp_selection_none(img): elimina la selección de una imagen
img: imagen