4.1.1.1. Descripción

Este primer ejemplo ya lo hemos estado viendo durante el documento. Como ya sabemos escala una imagen al tamaño que le digamos.

4.1.1.2. Como usarlo

Abre cualquier imagen y lanza el script.

4.1.1.3. Código

El código ya ha sido explicado detenidamente, recordemos que en la línea 12 llamamos a la función para escalar la imagen pasádole como parámetros la imagen en sí, la nueva altura y la nueva anchura. Los parámetros los creamos en la línea 28 y 29.

01 >>> #!/usr/bin/env python
02 >>> # Script para Gimp en Python
03 >>> # Realizado por Fco. Javier Pérez Pacheco como ejercicio
04 >>> # para el artículo "Python-fu para no programadores".
05 >>> # Este ejercicio escala una imagen

06 >>> # importamos los módulos necesarios
07 >>> from gimpfu import *

08 >>> # definimos las funciones necesarias
09 >>> def Resize(img, drawable, width, height):
10 >>>	    # comenzamos a agrupar el UNDO
11 >>>     pdb.gimp_image_undo_group_start(img)
	
12 >>>     pdb.gimp_image_scale(img, width, height)

13 >>>    # agrupamos UNDO
14 >>>    pdb.gimp_image_undo_group_end(img)

15 >>> # función principal
16 >>> if __name__ == '__main__':

17>>>     # llamada a función register
18 >>>     register(
19 >>>         "redimensionar_imagen",
20 >>>         "Redimensionar imagen",
21 >>>         "Redimensionar imagen",
22 >>>         "Javi Pacheco",
23 >>>         "Javi Pacheco",
24 >>>         "2005",
25 >>>         "<Image>/Python-Fu/Ejemplos/1- Basico/Redimensionar imagen",
26 >>>         "RGB*, GRAY*",
27 >>>         [
28 >>>             (PF_SPINNER, "width", "Ancho", 200, (0, 1000, 1)),
29 >>>             (PF_SPINNER, "height", "Alto", 200, (0, 1000, 1))
30 >>>         ],
31 >>>         [],
32 >>>         Resize)
33 >>>     main()
		

4.1.2.1. Descripción

En este ejemplo podremos colocar una capa en las esquinas de nuestra imagen o en el centro. Para ello aprederemos como trabajar con radiobuttons (PF_RADIO) y los métodos necesarios para mover capas.

4.1.2.2. Como usarlo

Abre cualquier imagen que tengas o simplemente crea una nueva a un tamaño de 500x500 pixels. Ahora crea una capa de color transparente y pinta un cuadrado de color negro, por ejemplo, en medio. Luego ve al menú "Capa - Capa de autorecorte". Eso hará que la capa sea del tamaño exacto de nuestro cuadrado de color. Ya puedes usar el script con la capa del cuadrado seleccionada.

4.1.2.3. Código

Primero fijémonos en la línea 43. Allí es donde le diremos a nuestro script que coloque un radiobutton con diferentes opciones. El último parámetro está entre paréntesis y es el siguiente:

>>> (("Esquina superior izquierda", 0), ("Esquina superior derecha", 1), 
>>> ("Esquina inferior izquierda", 2), 	("Esquina inferior derecha", 3), ("Centrado", 4))
				

Nos fijamos que hay 5 opciones (radiobutton) que podemos seleccionar separados por comas, y cada uno de ellos es otro parétesis con dos opciones: una la cadena de texto que parecerá por pantalla y que verá el usuario y otra con el valor que se le pasará al método principio del script (en nuestro caso "Align"). Una característica de los radiobutton es que sólo podemos seleccionar una de las opciones, por lo que la variable "align" tendrá un valor numérico según se selecione uno u otro radiobutton.

De la línea 12 a la 26 comprobamos el valor de la variable "align" que nos dirá la opción que ha seleccionado el usuario y según sea una u otra posicionaremos la capa en el lugar que sea oportuno. Para hacerlo utilizaremos las variables "x" e "y" que almacenarán la posición donde vamos a colocar la capa y al finalizar la posicionaremos (línea 27).

01 >>> #!/usr/bin/env python

02 >>> # Script para Gimp en Python
03 >>> # Realizado por Fco. Javier Pérez Pacheco como ejercicio
04 >>> # para el artículo "Python-fu para no programadores".
05 >>> # Este ejercicio alinea una capa dentro del imagen

06 >>> # importamos los módulos necesarios
07 >>> from gimpfu import *

08 >>> # definimos las funciones necesarias
09 >>> def Align(img, drawable, align):
10 >>>     # comenzamos a agrupar el UNDO
11 >>>     pdb.gimp_image_undo_group_start(img)

12 >>>     if align == 0:
13 >>>         x = 0
14 >>>         y = 0	
15 >>>     elif align == 1:
16 >>>         x = img.width - drawable.width
17 >>>         y = 0
18 >>>     elif align == 2:
19 >>>         x = 0
20 >>>         y = img.height - drawable.height
21 >>>     elif align == 3:
22 >>>         x = img.width - drawable.width
23 >>>         y = img.height - drawable.height	
24 >>>     else:
25 >>>         x = (img.width - drawable.width) / 2
26 >>>         y = (img.height - drawable.height) / 2	

27 >>>     drawable.set_offsets(x, y)
	
28 >>> # agrupamos UNDO
29 >>> pdb.gimp_image_undo_group_end(img)

30 >>> # función principal
31 >>> if __name__ == '__main__':

32 >>>     # llamada a función register
33 >>>     register(
34 >>>         "alinear_capas",
35 >>>         "Alinear Capas",
36 >>>         "Alinear Capas",
37 >>>         "Javi Pacheco",
38 >>>         "Javi Pacheco",
39 >>>         "2005",
40 >>>         "<Image>/Python-Fu/Ejemplos/1- Basico/Alinear Capas",
41 >>>         "RGB*, GRAY*",
42 >>>         [
43 >>>         (PF_RADIO, "align", "Alinear en:", 0, (("Esquina superior izquierda", 0), ("Esquina superior derecha", 1), 
44 >>>           ("Esquina inferior izquierda", 2), ("Esquina inferior derecha", 3), ("Centrado", 4)))
45 >>>         ],
46 >>>         [],
47 >>>         Align)
48 >>>     main()
				

4.1.3.1. Descripción

En este ejemplo crearemos una sombra a una imagen. Hay muchos scripts que hacen esto mismo y que ya vienen de serie en Gimp y que por supuesto son mucho mejores, pero vamos a ver como crearnos uno nosotros mismos.

4.1.3.2. Como usarlo

Para usar este script abrimos cualquier imagen que tenemos en nuestro ordenador, lo importante es que no tenga capas, sólo la imagen y lanzamos el script.

4.1.3.3. Código

Aunque el código está comentado con las datos más básicos a lo largo del script vamos a detallarlo. En la línea 55 y 56 tenemos los parámetros del script. Estos son la separación, tanto vertical como horizontal, con la que vamos a desplazar la capa que contiene la sombra. Estos datos nos servirán para más cosas. De principio tenemos una imagen que ocupa toda la ventana, si le ponemos una sombra, la capa que contiene la sombra no se verá. Lo primero que tenemos que hacer es agrandar la ventana, línea 16, con espacio suficiente para que la sombra se pueda ver correctamente.

¿Pero cuanto lo agrandaremos? El tamaño de la imagen final será proporcional a la distacia que queramos separar la capa con la sombra. No es lo mismo separar la sombra 10 pixel de la imagen que separarla 50. Y ¿cómo lo hacemos? Pues el tamaño final será el tamaño original de la ventana y le sumaremos 4 veces la separación de la capa (parámetros que pasará el usuario en el script). En el caso del ancho de la ventana será:

>>> img.width+(move_x*4)

y en el caso del alto será:

>>> img.height+(move_y*4)

Luego separaremos la fotografía de la esquina superior izquierda de la ventana la separación que tendrá la sombra. Esto se puede ver en los parámetros 4º y 5º del método "gimp_image_resize" de la línea 16.

Una vez redimensionada la imagen creamos una capa de fondo que será del color que tengamos seleccionado de fondo en la paleta de colores de Gimp. Esto lo podemos ver entre las líneas 19 a la 22.

Por último creamos la capa con la sombra. Esto se puede hacer de muchas maneras, nosotros lo hicimos de la siguiente manera. De la línea 24 a la 31 creamos la capa y la pintamos de color negro. Para ello primero creamos una capa nueva que será una copia de la capa donde tenemos la fotografía, línea 24. Recuerda que "drawable" apunta a la capa que tenemos seleccionada a la hora de lanzar el script, que es la capa con la fotografía. Con el método "copy(TRUE)" hacemos una copia de la capa y guardamos en la variable "layer_shadow". En la línea 25 le ponemos un nombre a la capa y en la 26 la añadimos a nuestra imagen debajo de la fotografía, como podemos ver:

>>> img.layers.index(drawable)+1

De la línea 29 a la 31 establecemos el color de frente de la paleta de colores de Gimp a negro y coloremos la capa de ese color.

En la línea 34 agrandamos los límites de la capa de la sombra hasta el tamaño de la imagen. Si no lo hacemos así cuando hagamos el desenfoque a la imagen no podrá pintar fuera de los límites de la capa por lo que no desenfocará la imagen haciendo una sombra dura. Para finalizar en la línea 37 desenfocamos la capa y en la 39 la desplazamos.

01 >>> #!/usr/bin/env python

02 >>> # Script para Gimp en Python
03 >>> # Realizado por Fco. Javier Pérez Pacheco como ejercicio
04 >>> # para el artículo "Python-fu para no programadores".
05 >>> # Este ejercicio crea una sombra a la capa activa

06 >>> # importamos los módulos necesarios
07 >>> from gimpfu import *

08 >>> # definimos las funciones necesarias
09 >>> def Shadow(img, drawable, move_x, move_y):
10 >>>     # comenzamos a agrupar el UNDO
11 >>>     pdb.gimp_image_undo_group_start(img)

12 >>>     # establecemos el nuevo tamaño de la imagen
13 >>>     # este será mas grande que la imagen actual para que la sombra se pueda ver
14 >>>     # le sumamos al tamaño actual de la imagen la separación tanto en x como en y
15 >>>     # multiplicada por 4. Luego separamos el fondo

16 >>>     pdb.gimp_image_resize(img, img.width+(move_x*4), img.height+(move_y*4), move_x, move_y)

17 >>>     # creamos una imagen de fondo  desde una copia de la capa actual
18 >>>     # del color del fondo que tengamos en la paleta
19 >>>     layer_background = pdb.gimp_layer_new(img, img.width, img.height, RGB_IMAGE, "background", 100, NORMAL_MODE)
20 >>>     layer_background.add_alpha()
21 >>>     img.add_layer(layer_background, 1)
22 >>>     layer_background.fill(BACKGROUND_FILL)

23 >>>     # creamos la capa que tendrá la sombra desde una copia de la capa actual

24 >>>     layer_shadow = drawable.copy(TRUE)
25 >>>     layer_shadow.name = "shadow"
26 >>>     img.add_layer(layer_shadow, img.layers.index(drawable)+1)
27 >>>     # colocamos el negro como color de frente en la paleta y 
28 >>>     # rellenamos de ese color la capa
29 >>>     black = (0,0,0)
30 >>>     pdb.gimp_context_set_foreground(black)
31 >>>     pdb.gimp_edit_fill(layer_shadow, FOREGROUND_FILL)

32 >>>     # redimensionamos el límite de la capa al tamaño actual de la imagen
33 >>>     # esto lo hacemos para cuando hagamos el desenfoque a la capa salga correctamente
34 >>>     pdb.gimp_layer_resize_to_image_size(layer_shadow)

35 >>>     # para que nuestra capa tenga el efecto de sombra le damos un desenfoque gaussiano
36 >>>     # de 20 unidades
37 >>>     pdb.plug_in_gauss_iir(img, layer_shadow, 20, TRUE, TRUE)

38 >>>     # separamos la sombra
39 >>>     layer_shadow.translate(move_x, move_y)	
	
40 >>>     # agrupamos UNDO
41 >>>     pdb.gimp_image_undo_group_end(img)

42 >>> # función principal
43 >>> if __name__ == '__main__':

44 >>>     # llamada a función register
45 >>>     register(
46 >>>         "sombra",
47 >>>         "Sombra",
48 >>>         "Sombra",
49 >>>         "Javi Pacheco",
50 >>>         "Javi Pacheco",
51 >>>         "2005",
52 >>>         "<Image>/Python-Fu/Ejemplos/1- Basico/Sombra",
53 >>>         "RGB*, GRAY*",
54 >>>         [
55 >>>             (PF_SPINNER, "move_x", "Separacion en X", 10, (0, 1000, 1)),
56 >>>             (PF_SPINNER, "move_y", "Separacion en Y", 10, (0, 1000, 1))
57 >>>         ],
58 >>>         [],
59 >>>         Shadow)
60 >>>     main()