3.1. Conociendo el Scheme
3.1.1. Comencemos
Lo primero que aprenderemos es que:
Todas las declaraciones en scheme van entre paréntesis ().
La segunda cosa que debe saber es que:
El nombre de función/operadores, siempre, lo primero en los paréntesis, y el resto son parámetros de la función.
Sin embargo, no todo lo encerrado entre paréntesis es una función -- pueden ser artículos de una lista -- lo veremos más tarde. Esta notación es referida como notación prefix, porque la función prefija todo. Si está familiarizado con la notación postfix, o posee una calculadora que usa Notación Polish Reverse (como muchas calculadoras HP), no debería tener problemas adaptandose a la formulación de expresiones en Scheme.
La tercera cosa a entender es que:
Los operadores matemáticos son, tambien, considarados funciones, y, así, son listados primero cuando se escriben expresiones matemáticas.
Esto seguido, logicamente, de la notación prefix que mencionamos.
3.1.2. Ejemplos de notaciones Prefix, Infix, Y Postfix
Aquí están algunos ejemplos rápidos que ilustran las diferencias entre notaciones
prefix,
infix, y
postfix.Sumamos un 1 y un 3:
- Prefix notation: + 1 3 ( la manera en que Sheme lo quiere)
- Infix notation: 1 + 3 (La manera en que, "normalmente", lo escribimos)
- Postfix notation: 1 3 + (la manera en que muchas calculadoras HP lo quieren)
3.1.3. Practicando scheme
Ahora, practicaremos lo que hemos aprendido. Inicie GIMP, si todavia no lo ha hecho, y seleccione Exts → Script-Fu → Consola. Esto inicia la ventana de la consola de Script-Fu, lo que nos permite trabajar, interactivamente, en Scheme. En un momento, la Consola de Script-Fu aparecerá.:
3.1.4. La ventana de la consola de Script-Fu
En el fondo de esta ventana hay una campo de entrada con el título Comando actual. Aquí, puede probar los comandos Scheme interactivamente. Comienze , y añada unos números:
(+ 3 5) Tecleando esto y presionando
Enter, da la respuesta esperada, 8, en el centro de la ventana.
Ahora, ¿Si queremos sumar más de un número?, La función "+" puede tener dos o más argumentos, así que esto no es un problema:
(+ 3 5 6) Esto da la respuesta esperada, 14.
Bueno, tecleamos una declaración en Scheme y se ejecuta inmediatamente en la ventana de la consola de Script-Fu. Ahora unas palabras de precaución...
3.1.5. Tener cuidado con los paréntesis extras
Si es como yo, lo usará para ser capaz de usar paréntesis extras donde quiera, como cuando teclea una ecuación matemática compleja y quiere separar las partes con paréntesis, para hacerla más clara cuando la lee. En Scheme, hay que ser cuidadoso y no insertar estos paréntesis extra, de manera incorrecta. Por ejemplo, decir que queremos sumar 3 al resultado de sumar 5 y 6:
3 + (5 + 6) + 7 = ? Sabiendo que el operador “+” puede usar una lista de números para sumar, podría tentatarle convertir lo de arriba en lo siguiente:
(+ 3 (5 6) 7) Esto es incorrecto, recuerde, cada declaración en Scheme comienza y termina con paréntesis, así que el intérprete Scheme pensará que intenta llamar a una función llamada "5" en el segundo grupo de paréntesis, más que sumar esos números, antes de sumarles el 3.
La forma correcta de escribir esta declaración sería:
(+ 3 (+ 5 6) 7)
3.1.6. Asegúrese de tener el espacio apropiado, también
Si está familiarizado con otros lenguajes de programación, como C/C++, Perl o Java, sabe que no necesita espacios blancos alrededor de operadores matemáticos para formar, apropiadamente, una expresión:
3+5, 3 +5, 3+ 5
Estos son aceptados por los compiladores de C/C++, Perl o Java. Esto mismo, no es cierto para Scheme. En Scheme, debe tener un espacio después de un operador matemático (u otra nombre de función u operador), para que sea correctamente interpretado por el intérprete de Scheme.
Practique un poco con operaciones matemáticas simples en la consola de Script-Fu hasta que esté cómodo con estos conceptos iniciales.
3.2. Variables y funciones
Ahora que sabemos que todas las declaraciones en Scheme están entre paréntesis, y que el nombre de función/operadores se listan primero, necesitamos saber como crear y usar variables, y como crear y usar funciones. Comenzaremos con las funciones.
3.2.1. Declarando variables
Aunque hay un par de métodos diferentes para declarar variables, el método preferido es usar la construcción let*. Si está familiarizado con otros lenguajes de programación, esta construcción es equivalente a definir una lista de variables locales y una extensión en la cual están activas. Como ejemplo, para declarar dos variables, a y b, inicializadas a 1 y 2, respectivamente, escriba:
(let*
(
(a 1)
(b 2)
)
(+ a b)
)
o, en una linea:
(let* ( (a 1) (b 2) ) (+ a b) )
Nota_____________
Tendrá que poner todo esto en una linea si está usando la ventana de la consola. En general, querrá adoptar una práctica similar para ayudar a hacer sus scripts más legibles. Hablaremos un poco más de esto en la sección espacio blanco.
Esto declara dos variables locales, a y b, inicializados, que muestra la suma de las dos variables.
3.2.2. ¿Que es una variable local?
Notará que escribimos la suma (+ a b) bajo los paréntesis de la expresión let* , no después de ella.
Esto es porque la declaración let* define un area en su script en el que se declaran las variables que serán utilizables; si teclea (+ a b) y después (let* ...), obtendrá un error, porque las variables declaradas son, solo, válidas bajo el contexto de la declaración let* ; son lo que los programadores llaman variables locales.
3.2.3. La sintaxis general de let*
la forma general de una declaración let*:
(let* (
variables )
expressions )
donde las variables son declaradas bajo paréntesis, p. e. (a2), y expresiones son cualquier expresión válida de Scheme. Recuerde que las variables declaradas aquí son solo válidas bajo la declaración let*, son variables locales..
3.2.4. Espacio blanco
Previamente, mencionamos el hecho de que, probablemente, quiere usar indetation para ayudar a clarificar y organizar sus scripts. Esto es una buena politica a adoptar, y no es un problema en Scheme, espacio en blanco es ignorado por el interprete Scheme, y se puede aplicar para ayudar a clarificar y organizar el código bajo un script. , si está trabajando en la ventana de la consola de Script-Fu, tendrá que entrar una expresión entera en una linea; todo, entre los paréntesis de inicio y fin de una expresión, debe venir en una linea en la ventana de la consola de Script-Fu.
3.2.5. Asignando un nuevo valor a una variable
Una vez que ha inicializado una variable, podría necesitar cambiar este valor, más tarde en el script. Usa la declaración set! para cambiar el valor de la variable:
(let* ( (theNum 10) ) (set! theNum (+ theNum theNum)) )
Intente adivinar lo que la declaración de arriba hará, entonces, adelante e introdúzcalo en la ventana de la consola de Script-Fu.
Nota_______________
La "\" indica que allí no hay una linea rota. Ignórelo (no lo escriba en su consola de Script-Fu y no pulse Enter), justo continue con la siguiente linea.
3.2.6. Funciones
Ahora que entendemos las variables, trabajemos con algunas funciones. Declare una función con la siguiente sintaxis:
(define (
name param-list )
expressions )
donde
name es el nombre asignado a esta función,
param-list es una lista espacio -delimitada de nombres de parámetros, y
expressions son una serie de expresiones que las funciones ejecutan cuando se las llama. Por ejemplo:
(define (AddXY inX inY) (+ inX inY) )
AddXY es el nombre de función y inX y inY son las variables. Esta función toma los dos parámetros y los suma juntos.
Si ha programado en otro lenguaje imperativo (como C/C++, Java, Pascal, etc.), podría notar que un par de cosas no están presentes en esta definición de función, cuando la comparas con otros lenguajes de programación.
- Primero, nota que los parámetros no tienen un "tipo" (no se declaran como cadenas, o íntegros, etc.). Scheme es un lenguaje sin tipos. Esto es práctico y permite una escritura más rápida de scripts.
- Segundo, nota que no necesitamos preocuparnos de como devolver los resultados de nuestra función, la última declaración es el valor devuelto cuando llama a esta función. Escriba la función en la consola, entonces intente algo como:
(AddXY (AddXY 5 6) 4)
3.3. Listas, listas y más listas
Le hemos entrenado en variables y funciones, y ahora, entramos en el lúgubre pantano de las listas Scheme.
3.3.1. Definir una lista
Antes de que hablamos más sobre las listas, es necesario que sepa la diferencia entre valores atómicos y listas.
Ya ha visto los valores atómicos cuando inicializamos variables en la lección anterior. Un valor atómico es un valor simple. Así, por ejemplo, podemos asignar a la variable "x" el valor simple de 8 en la declaración siguiente:
(let* ( (x
) x) (Añadimos la expresión x al final para imprimir el valor asignado a x-- normalmente, no necesitará hacer esto. Note como let* opera justo como una función: El valor de la última declaración es el valor devuelto).
Una variable puede, tambien, referirse a una lista de valores, casi como un valor simple. Para asignar a la variable x , la lista de valores 1, 3, 5, tecleamos:
(let* ( (x '(1 3 5))) x) Intente teclear ambas declaraciones en la consola de Script-Fu y verá como contesta. Cuando teclea la primera declaración, responde con el resultado:
8 Cuando teclea la otra declaración, responde con el siguiente resultado:
(1 3 5) Cuando responde con el valor 8 está informando que x contiene el valor atómico 8. Cuando responde con (1 3 5), entonces, está informando que x no contiene un valor simple, sino una lista de valores. Note que no hay comillas en nuestra declaración o en la asignación de la lista, ni en el resultado impreso.
La sintaxis para definir una lista es:
'(a b c) donde a, b, y c son literales. Usamos el apóstrofe (') para indicar que lo que sigue entre paréntesis es una lista de valores literales, casí como una función o expresión.
Una lista vacia puede definirse como:
'() o simplemente:
() Las listas pueden contener valores atómicos, así como otras listas:
(let*
(
(x
'("GIMP" (1 2 3) ("is" ("great" () ) ) )
)
)
x
)
Note que después del primer apóstrofe, no necesita usar un apóstrofe cuando defina las listas internas. Adelante, copie la declaración en la consola de Script-Fu y mire que devuelve.
Notará que el resultado devuelto no es una lista de simples valores atómicos; casí es una lista de un literal ("GIMP"), la lista (1 2 3), etc.
3.3.2. ¿Como se representan las listas?
Es útil pensar que las listas están compuestas de una “cabeza” y de una “cola”. La cabeza es el primer elemento de la lista, la cola es el resto de la lista. Verá porque esto es importante cuando tratemos como añadir listas y como acceder elementos en la lista.
3.3.3. Crear listas mediante concatenación (Lafunción cons)
Una de las funciones más comunes que encontrará es la función cons. Toma un valor y lo situa en el segundo argumento, una lista. En la sección previa, sugerí que piense que una lista está compuesta de un elemento (la cabeza) y el resto de la lista (la cola). Es, exactamente, como cons funciona -- añade un elemento a la cabeza de la lista. Puede crear una lista como sigue:
(cons 1 '(2 3 4) ) El resultado es la lista (1 2 3 4).
También, podrías crear una lista con un elemento:
(cons 1 () ) Puede usar, previamente, variables declaradas en lugar de literales, como cabría esperar.
3.3.4. Definir una lista usando la función list
Para definir una lista compuesta de literales o, previamente, variables declaradas, use la función list:
(list 5 4 3 a b c) Esto compondrá y devolverá una lista conteniendo los valores de las variables a, b y c. Por ejemplo:
(let* (
(a 1)
(b 2)
(c 3)
)
(list 5 4 3 a b c)
)
Este código crea la lista (5 4 3 1 2 3).
3.3.5. Acceder a los valores de una lista
Para acceder a los valores de una lista, use las funciones car y cdr, que devuelven el primer elemento de la lista y el resto de la lista, respectivamente. Estas funciones rompen la lista en la construcción cabeza::cola que mencioné antes.
3.3.6. La función car
car devuelve el primer elemento de la lista (la cabeza de la lista). La lista necesita ser no -null. La siguiente devuelve el primer elemento de la lista:
(car '("first" 2 "third")) que es:
"first"
3.3.7. La función cdr
cdr devuelve el resto de la lista después del primer elemento (la cola de la lista). Si solo hay un elemento en la lista, devuelve una lista vacia.
(cdr '("first" 2 "third")) devuelve:
(2 "third") donde la siguiente:
(cdr '("one and only")) devuelve:
()
3.3.8. Acceder a otros elementos de una lista
OK, bravo,podemos obtener el primer elemento en una lista, tanto como el resto de la lista, pero ¿como hacemos para acceder al segundo, tercero o otros elementos de la lista?. Existen varias funciones convenientes para acceder, por ejemplo, la cabeza de la cabeza de una cola de una lista (caadr), la cola de la cola de una lista (cddr), etc.
La convención básica para nombrar es fácil: a y d representan las cabezas y las colas de la lista, así
(car (cdr (car x) ) ) se podría escribir como:
(cadar x) Para tener práctica con las funciones de acceso a listas, intente teclear lo siguiente ( en una sola linea si está usando la consola); use diferentes variaciones de car y cdr para acceder a los diferentes elementos de la lista:
(let* (
(x '( (1 2 (3 4 5) 6) 7 8 (9 10) )
)
)
; place your car/cdr code here
)
Intente acceder al número 3 en la lista usando solo dos llamadas a función. Si puede hacer eso, está en el camino para llegar a ser un Maestro de Script-Fu!.
Nota_________
En Scheme, un punto y coma ";" marca un comentario. Esto y todo lo que siga en la misma linea, es ignorado por el interprete de script, así que puede usar esto para añadir comentarios para refrescar su memoria cuando vuelva a mirar su script
3.4. Su primer código de Script-Fu
¿No necesita parar y tomar algo? ¿No? Bien, entonces procederemos con la cuarta lección, su primer código de Script-Fu.
3.4.1. Crear un código: una caja de texto
Una de las operaciones más comunes que realizo en el GIMP es crear una caja con algún texto en ella para una página web, un logo o algo así. Nunca se sabe el tamaño adecuado de una imagen cuando se empieza. No sabe cuanto espacio llenará el texto con la fuente ni el tamaño de fuente que quiere.
Los maestros de Script-Fu (y los estudiantes), rapidamente, reconocen que este problema puede resolverse, facilmente, y automatizando con Script-Fu.
Crearemos un script, llamado Text Box, que creará una imagen, con el tamaño correctamente ajustado a una linea de texto, que el usuario introduce. También, dejaremos al usuario elegir la fuente, el tamaño de la fuente y el color del texto.
3.4.2. Editar y guardar su código
Hasta ahora, hemos trabajado en la consola de Script-Fu. Ahora, sin embargo, vamos a cambiar para editar códigos de archivos de texto.
Donde situar sus códigos es cuestión de preferencias, si tiene acceso al directorio de scripts predefinido de GIMP, puede situarlos allí. Sin embargo, yo prefiero dejar mis códigos personales en mi propio directorio de scripts, para mantenerlos separados de los instalados de fabrica.
En el directorio .gimp-2.4, que el GIMP crea en directorio home, debería encontrar un directorio llamado scripts. El GIMP, automaticamente, buscará en su directorio .gimp-2.4, el directorio de scripts, y añadirá los scripts de este directorio a la base de datos de Script-Fu. Debería situar sus scripts personales aquí.
3.4.3. Lo esencial al descubierto
Cada script Script-Fu define al menos una función, la cual es la función principal del script. Esta es donde haces el trabajo.
Cada script debe, también, registrarse en la base de datos de procedimientos, para poder acceder a el bajo GIMP.
Definiremos la función principal, primero:
(define (script-fu-text-box inText inFont inFontSize inTextColor))
Aquí, hemos definido una nueva función llamada script-fu-text-box que toma cuatro parámetros, que, más tarde, corresponderán al texto, una fuente, el tamaño de la fuente y el color del texto. La función está vacia y no hace nada.
3.4.4. Convenciones de nombres
Las convenciones de nombres en Scheme parecen preferir minúsculas con guiones, en el nombre de la función. Sin embargo, parto de la convención con los parámetros. Quiero nombres más descriptivos para mis parámetros y variables, y añado el prefijo "in" a los parámetros, así que, puedo, rapidamente, ver que valores entran en el script, más bien que los que se crean en el. Uso el prefijo "the" para las variables definidas en el script.
Es la convención del GIMP para nombrar sus funciones de códigos Script-Fu, porque así están listados en la base de datos de procedimientos, todos ellos se mostrarán bajo script-fu cuando se estén listando las funciones. Esto, también, ayuda a distinguirlos de los plug-ins.
3.4.5. Registro de la función
Ahora, registremos la función con el GIMP. Esto se hace llamando a la función script-fu-register. Cuando el GIMP lee en un script, ejecutará esta función, que registrará el script en la base de datos de procedimientos. Puede situar esta llamada a función donde quiera en su script, pero, normalmente, se situa al final, después de las otras lineas de códigos.
Aquí está el listado de registro de esta función (explicaré todos estos parámetros en un minuto):
(script-fu-register
"script-fu-text-box" ;func name
"Text Box" ;menu label
"Creates a simple text box, sized to fit\
around the user's choice of text,\
font, font size, and color." ;description
"Michael Terry" ;author
"copyright 1997, Michael Terry" ;copyright notice
"October 27, 1997" ;date created
"" ;image type that the script works on
SF-STRING "Text:" "Text Box" ;a string variable
SF-FONT "Font:" "Charter" ;a font variable
SF-ADJUSTMENT "Font size" '(50 1 1000 1 10 0 1)
;a spin-button
SF-COLOR "Color:" '(0 0 0) ;color variable
)
(script-fu-menu-register "script-fu-text-box" "<Toolbox>/Xtns/Script-Fu/Text")
Si guardas estas funciones en un archivo de texto con el sufijo .scm en su directorio de script, seleccione Exts → Script-Fu → Refresh Scripts, este nuevo script aparecerá como Exts → Script-Fu → Text → Text Box.
Si llama a este nuevo script, no hará nada, desde luego, pero puede ver los apuntes creados cuando se registra el script (más información de lo que hicimos, se descubrirá luego).
Finalmente, si abre el examinador de procedimientos Exts → Examinador de procedimientos), notará que nuestro script aparece en la base de datos.
3.4.6. Pasos para registrar el código
Para registrar nuestro script en elGIMP, llamamos a la función script-fu-register, rellenamos los siete parámetros requeridos y añadimos los nuestros propios, junto con una descripción y valores predefinidos para cada parámetro.
Los parámetros requeridos
- El nombre de la función que definimos. Esto es la llamada de función cuando nuestro script es invocado (el punto de entrada de nuestro script). Esto es necesario porque podriamos definir funciones adicionales bajo el mismo archivo, y GIMP necesita saber a cuales de estas funciones se llama. En nuestro ejemplo, solo definimos una función, text box, que registramos.
- La localización en el menú donde el script será insertado. El lugar exacto de el script está especificado, como una ruta en Unix, con la raiz de la ruta estando entre la caja de herramientas o click derecho. The location in the menu where the script will be inserted. The exact location of the script is specified like a path in Unix, with the root of the path being either toolbox or right-click.
Si su script no opera sobre una imagen existente (y crea una imagen nueva, como hará nuestro Text Box), querrá insertarlo en el menú de la caja de herramientas, este es el menu en la ventana principal del GIMP (donde se localizan todas las herramientas: herramientas de selección, lupa, etc.).
Si u script está intentando trabajar sobre una imagen que está siendo editada, querrá insertarla en el menú que aparece cuando pulsa el botón derecho sobre una imagen abierta. El resto de la ruta apunta a la lista de menú, menús y sub-menús. Resgistramos nuestro script Text Box en el menú Text de el menú Script-Fu del menú Exts, en el menú de la caja de herramientas ( Exts → Script-Fu → Text → Text Box ).
Si se fija, el sub-menú Text, en el menú Script-Fu, no estaba allí cuando empezamos, el GIMP crea, automaticamente, cualquier menú que todavia no exista.
- Una descripción de su script, para ser mostrada en el Examinador de Procedimientos.
- Su nombre (el autor del código).
- Información del copyright.
- La fecha en que se hizó el código, o la última revisión del mismo.
- El tipo de imágenes con las trabaja el script. Puede ser uno de los siguientes: RGB, RGBA, GRAY, GRAYA, INDEXED, INDEXEDA. O podría no ser ninguno de ellos, en nuestro caso, estamos creando una imagen, y no necesitamos definir el tipo de imagen sobre la que trabajaremos.
3.4.7. Registro de los parámetros del código
Una vez que hemos listado los parámetros requeridos, necesitamos listar los parámetros que corresponden a los parámetros que nuestro script necesita. Cuando listamos estos parámetros, les damos indicación de como son. Esto es por el diálogo que surge cuando el usuario selecciona nuestro script. También podemos proporcionar valores predefinidos.
Esta sección del proceso de registro tiene el siguiente formato:
Tipo de parámetro
Descripción
Ejemplo
SF-IMAGE
Si su script opera en una imagen nueva, esta debería ser el primer parámetro después de los parámetros requeridos. GIMP pasará una referencia a la imagen en este parámetro.
3
SF-DRAWABLE
Si su script opera sobre una imagen abierta, este sería el segundo parámetro después de el parámetro SF-IMAGE. Se refiere a la capa activa. GIMP pasará una referencia a la capa activa en este parámetro.
17
SF-VALUE
Acepta números y cadenas. Notese que las cuotas deben eludir el texto predefinido, mejor usar SF-STRING.
42
SF-STRING
Acepta cadenas.
"Un texto"
SF-COLOR
Indica que color se requiere en este parámetro.
'(0 102 255)
SF-TOGGLE
Se muestra una caja, para obtener un valor Booleano
TRUE o FALSE
3.5. Dar algo de sustancia a nuestro script
Continuemos con nuestro entrenamiento y añadamos alguna funcionalidad a nuestro script
3.5.1. Crear una nueva imagen
En la lección anterior, creamos una función vacia y la registramos en el GIMP. En esta lección, queremos proporcionar funcionalidad a nuestro script, queremos crear una nueva imagen, añadirle texto del usuario y redimensionar la imagen para adecuarla al texto exactamente.
Una vez que sabe como configurar variables, definir funciones y acceder a los miembros de la lista, el resto es cuesta abajo, todo lo que necesita hacer es familiarizarse con las funciones disponibles en la base de datos de procedimientos del GIMP y llamar, directamente, a las funciones. Así que encienda su examinador de procedimientos y vamos a cocinar!.
Comencemos haciendo una imagen nueva. Crearemos una nueva variable, theImage, es el resultado de llamar a la función de construcción del GIMP gimp-image-new.
Como puede ver en el examinador de procedimientos, la función gimp-image-new toma tres parámetros ancho, alto y tipo de la imagen. Porque, más tarde, redimensionaremos la imagen al tamaño adecuado para el texto, haremos una imagen 10x10 RGB. Almacenaremos el ancho y tamaño de la imagen en algunas variables, tambien, las remitiremos y manipularemos, más tarde, en el script.
(define (script-fu-text-box inText inFont inFontSize inTextColor)
(let*
(
; define our local variables
; create a new image:
(theImageWidth 10)
(theImageHeight 10)
(theImage (car
(gimp-image-new
theImageWidth
theImageHeight
RGB
)
)
)
(theText) ;a declaration for the text
;we create later
Nota: Usamos el valor RGB para especificar que la imagen es una imagen RGB. Se podría usar, tambien, 0, pero RGB es más descriptivo cuando ojeemos el código.
Tambien, debería notar que tomamos la cabeza de el resultado de la función llamada. Esto podría parecer extraño, porque la base de datos, explicitamente, nos dice que devuelve solo un valor, el ID de la imagen recien creada. Todas las funciones devuelven una lista, siempre que haya un solo elemento en la lista, así que necesitamos conseguir la cabeza de la lista.
3.5.2. Añadir una capa nueva a la imagen
Ahora que tenemos una imagen, necesitamos añadirle una capa. Llamaremos a la función gimp-layer-new para crear la capa, basado en el ID de la imagen, que justo creamos. (Por ahora, en lugar de listar la función completa, solo listamos las lineas que se le están añadiendo.). Porque hemos declarado las variables locales que usaremos, cerraremos los paréntesis al final de nuestras declaraciones de variables:
;create a new layer for the image:
(theLayer
(car
(gimp-layer-new
theImage
theImageWidth
theImageHeight
RGB-IMAGE
"layer 1"
100
NORMAL
)
)
)
) ;end of our local variables
Una vez tenemos la capa nueva, necesitaremos añadirla a la imagen:
(gimp-image-add-layer theImage theLayer 0)
Ahora, por diversión, veremos los frutos de nuestra labor hasta este punto, y añadiremos esta linea para mostrar la imagen nueva y vacia:
(gimp-display-new theImage)
Guarde el trabajo, seleccionando Exts → Script-Fu → Refrescar scripts, ejecute el script y aparece una nueva imagen. Probablemente, contiene basura (colores aleatorios), porque no la hemos borrado. Conseguiremos eso en un segundo.
3.5.3. Añadir el texto
Avancemos y quitamos la linea de representación de la imagen (o la comentamos con un ; como primer caracter de la linea).
Antes de que añadamos texto a la imagen, necesitamos seleccionar los colores de fondo y frente, para que así aparezca con el color especificado por el usuario. Usaremos las funciones gimp-context-set-background y gimp-context-set-foreground:
(gimp-context-set-background '(255 255 255) )
(gimp-context-set-foreground inTextColor)
Con los colores seleccionados correctamente, ahora, limpiaremos la basura actual en la imagen para rellenar el dibujable con el color de fondo:
(gimp-drawable-fill theLayer BACKGROUND-FILL)
Con la imagen limpia, estamos listos para añadir algún texto:
(set! theText
(car
(gimp-text-fontname
theImage theLayer
0 0
inText
0
TRUE
inFontSize PIXELS
"Sans")
)
)
Aunque hay una llamada de función, es bastante más sencillo si repasas los parámetros mientras miras las entradas de función en el examinador de procedimientos. Basicamente, estamos creando una nueva capa de texto y la asignamos a la variable theText.
Ahora que tenemos el texto, podemos coger el ancho y alto y redimensionar la imagen y la capa de la imagen al tamaño del texto:
(set! theImageWidth (car (gimp-drawable-width theText) ) )
(set! theImageHeight (car (gimp-drawable-height theText) ) )
(gimp-image-resize theImage theImageWidth theImageHeight 0 0)
(gimp-layer-resize theLayer theImageWidth theImageHeight 0 0)
Si es como yo, le maravillará lo que es un dibujable comparado con una capa. La diferencia entre los dos es que un dibujable es algo en lo que puedes dibujar, incluido capas, pero también canales, máscaras de capa, selecciones, etc.; una capa es una versión más especifica de un dibujable. En muchos casos, la distinción no es importante.
Con la imagen lista, podemos reañadir nuestra linea de representación:
(gimp-display-new theImage)
Guarde su trabajo, refresque la base de datos y ejecute su primer script!.
3.5.4. Limpiar
Si intenta cerrar la imagen creada sin primero guardar el archivo, el GIMP le preguntará si quiere guardar su trabajo antes de cerrar la imagen. Pregunta esto porque la imagen está marcada como sucia, o no guardada. En el caso de nuestro script, esto es una molestia, las veces que simplemente hace una prueba y no le añade o cambia algo en la imagen resultante, eso es que nuestro trabajo es facilmente reproducible como un simple script, asi que dele sentido liberandose de esa marca sucia.
Para hacer esto, puede limpiar la marca sucia y despues mostrar la imagen:
(gimp-image-clean-all theImage)
Esto da 0 al contador sucio, haciendolo aparecer como una imagen limpia.
Añadir esta linea o no es cuestión del gusto personal. Uselo en scripts que produzcan nuevas imágenes, donde los resultados son triviales, como en este caso. Si su script es muy complicado, o si trabaja sobre una imagen existente, probablemente no querrá usar esta función..
3.6. Extender el script: Text Box
3.6.1. Mantener correctamente deshacer
Cuando crea un script, quiere dar a sus usuarios la habilidad para deshacer sus acciones, podrían cometer un error. Esto es fácil de efectuar llamando a las funciones gimp-undo-push-group-start y gimp-undo-push-group-end sobre el código que manipula la imagen. Puede pensar que son declaraciones marcadas que dejan al GIMP saber cuando empezar y parar la grabación de manipulaciones sobre la imagen, así esas manipulaciones pueden ser deshechas más tarde.
Si crea una imagen nueva, no tiene sentido usar estas funciones porque no cambia una imagen existente. Cuando está cambiando una imagen existente, debe asegurarse que quiere usar estas funciones.
Deshacer un script trabaja casi perfectamente cuando usa estas funciones.
3.6.2. Extender el script un poco más
Ahora que hemos creado un excelente y manejable script para crear cajas de texto, añadamosle dos capacidades:
- La imagen se redimensiona exactamente alrededor del texto, no hay sitio para nada, como sombras o efectos especiales (muchos scripts redimensionan la imagen cuando es necesario.
- Este script podría facilmente ser usado en otro script para trabajar con texto. Extendiéndolo para que devuelva la imagen y las capas, así otros scripts pueden llamar a este script y usar la imagen y las capas que creemos.
3.6.3. Modificando los parámetros y la función de registro
Para dejar al usuario especificar la cantidad del bufer, añadiremos un parámetro a nuestra función y a la función de registrar:
(define (script-fu-text-box inTest inFont inFontSize inTextColor inBufferAmount)
(let*
(
; define our local variables
; create a new image:
(theImageWidth 10)
(theImageHeight 10)
(theImage (car
(gimp-image-new
theImageWidth
theImageHeight
RGB
)
)
)
(theText) ;a declaration for the text
;we create later
(theBuffer) ;
added
(theLayer
(car
(gimp-layer-new
theImage
theImageWidth
theImageHeight
RGB-IMAGE
"layer 1"
100
NORMAL
)
)
)
) ;end of our local variables
[Code here]
)
(script-fu-register
"script-fu-text-box" ;func name
"Text Box" ;menu label
"Creates a simple text box, sized to fit\
around the user's choice of text,\
font, font size, and color." ;description
"Michael Terry" ;author
"copyright 1997, Michael Terry" ;copyright notice
"October 27, 1997" ;date created
"" ;image type that the script works on
SF-STRING "Text:" "Text Box" ;a string variable
SF-FONT "Font:" "Charter" ;a font variable
SF-ADJUSTMENT "Font size" '(50 1 1000 1 10 0 1)
;a spin-button
SF-COLOR "Color:" '(0 0 0) ;color variable
SF-ADJUSTMENT "Buffer amount" '(35 0 100 1 10 1 0)
;a slider
)
(script-fu-menu-register "script-fu-text-box" "<Toolbox>/Xtns/Script-Fu/Text")
3.6.4. Añadir el nuevo código
Vamos a añadir código en dos sitios: antes de redimensionar la imagen y al final del script (para devolver la nueva imagen, la capa y el texto).
Después de obtener el ancho y alto del texto, necesitamos redimensionar estos valores basados en la cantidad del bufer especificado por el usuario. No queremos cometer ningún error, chequeando para asegurar que está en el rango de 0-100%, porque no es vital y porque no hay razón para que el usuario no pueda dar un valor como 200 % de bufer para añadir.
(set! theBuffer (* theImageHeight (/ inBufferAmount 100) ) )
(set! theImageHeight (+ theImageHeight theBuffer theBuffer) )
(set! theImageWidth (+ theImageWidth theBuffer theBuffer) )
Todo lo que hacemos aquí es configurar el bufer basado en la altura del texto, y añadirlo dos veces a ambos, el alto y ancho de nuestra nueva imagen. (Lo añadiremos dos veces porque el bufer necesita ser añadido a ambos lados del texto).
Ahora que hemos redimensionado la imagen para permitir un bufer, necesitamos centrar el texto bajo la imagen. Esto se hace para moverlo a las coordenadas (x, y) de (theBuffer, theBuffer). Añadí esta linea después de redimensionar la capa y la imagen:
(gimp-layer-set-offsets theText theBuffer theBuffer)
Adelante y guarde su script, e inténtelo después de refrescar la base de datos.
Todo lo que queda por hacer es devolver nuestra imagen, la capa y la capa del texto. Después de mostrar la imagen, añadimos esta linea:
(list theImage theLayer theText)
Esta es la última linea de la función, hace que esta linea esté disponible a otros scripts que quieran usarla.
Para usar nuestro nuevo script text box en otro script, podriamos escribir algo como lo siguiente:
(set! theResult (script-fu-text-box
"Some text"
"Charter" "30"
'(0 0 0)
"35"
)
)
(gimp-image-flatten (car theResult))
Felicitaciones, está en el camino para su ¡Cinturón Negro de Script-Fu!.
3DsMax
After Effects
Amapi 3D
Blender 3D
Cinema 4D
Combustion
Flash
Gimp
Inkscape
Lightscape
Lightwave
Maya
Photoshop
Premiere
Rhino
Temas Generales
Wings 3D
XSI
Zbrush
Glosario de Gimp
URL del LinkBack
Acerca de los LinkBacks
Ver Perfil
Ver Mensajes de Foro
Mensaje Privado
Ver Entradas de Blog
Visitar la Página de Inicio
Glosario de Gimp
Nota_________________________________________
Sugerencia____________________________________
Nota_________________________________________
el botón en la caja de herramientas o botón derecho sobre la imagen y siga el menú Herramientas → Herramientas de transformación → Recortar y redimensionar, en la ventana de la imagen. Esto cambiará el cursor y le permitirá pulsar y arrastrar una forma rectangular. El botón en la caja de herramientas es el mejor modo de seleccionar cualquier herramienta. He encontrado una imagen enorme del APOD 
en la caja de herramientas. 
Nota__________________________________ En casi todos los casos, si selecciona un nombre de archivo de la lista y cliquea el botón Abrir de la esquina inferior derechadel diálogo, el GIMP automáticamente determina su formato y lo abre. Pero en ocaciones muy particulares, cuando el tipo de archivo no es muy usual y su nombre no tiene la extensión apropiada, esta detección puede fallar. Si así sucede, puede comunicarle al GIMP específicamente qué tipo de archivo es, expandiendo la opción Seleccione el tipo de archivo que está en la parte más baja del diálogo, y escogiendo un tipo apropiado. En general, si el GIMP falla al abrir un archivo, es muy probable que este esté corrupto, o sea de un formato no admitido.
Atención________________________
Nota___________________________
Sugerencia______________________
Sugerencia____________________________
Visibilidad Es posible ocultar temporalmente una capa de la imagen, sin necesidad de destruirla, haciendo clic en el icono que tiene un "ojo abierto" del diálogo de capas. A esto se le llama "cambiar la visibilidad" de la capa. Muchas operaciones de la imagen tratan a las capas ocultas como si no existieran. Cuando trabaje con imágenes que contienen muchas capas, con diferentes opacidades, puede obtener una mejor vista de la capa que quiera modificar ocultando algunas de las otras capas. 
Sugerencia______________________
Enlace a otras capas Si hace clic entre el icono del ojo y la miniatura de la capa, obtiene un icono con una cadena ( 
), el cual le permite agrupar capas para operarlas en conjunto (por ejemplo con la herramienta Mover o con una herramienta de transformación). 
Nota___________________________
Para comprender algunas de las idiosincracias de la manipulación de texto, puede ayudar saber que una capa de texto contiene más información que los datos de píxeles que muestra. Además contiene una representación en forma de texto. Puede verla en la ventana del editor de texto, que aparece cuando emplea esta herramienta. Cada vez que altere el texto, la capa de la imagen que lo contiene se vuelve a dibujar para reflejar los cambios. 
Nota__________________________
Nota__________________________
Nota________________
Sugerencia___________
Nota__________
Aviso___________
Atención _____________
Sugerencia____________
Sugerencia____________
Guardar opciones en Este botón permite guardar las opciones de la herramienta activa, para luego poder recuperarlas. Hace aparecer un pequeño diálogo que solicita un nombre para el conjunto de opciones guardadas. Cuando recupera las opciones, sólo los conjuntos guardados para la herramienta activa son mostrados, así que no tiene que preocuparse por incluir el nombre de la herramienta cuando asigne el nombre. 
Recuperar opciones Este botón permite recuperar un conjunto de opciones previamente guardadas para la herramienta activa. Si todavía no se han guardado opciones para esta herramienta, el botón aparecerá gris. De otra forma, haciendo clic en él aparecerá un menú mostrando los nombres de los conjuntos de opciones guardados: escogiendo una entrada del menú aplicará esas opciones. 
Borrar las opciones guardadas Este botón permite borrar una conjunto de opciones previamente guardado para la herramienta activa. Si ningún conjunto de opciones fue guardado para esta herramienta, el botón aparecerá gris. En otro caso, haciendo clic en él aparecerá un menú mostrando los nombres de los conjuntos de opciones guardados: escogiendo una entrada del menú borrará esa configuración. 
Reiniciar con los valores predephraseinados Este botón reinicia las opciones de la herramienta activa a sus valores por defecto. 
Nota____________
de la caja de herramientas.
; o desde el teclado usando el atajo e. 
. 
; o desde el teclado por medio del atajo f. 
en la caja de herramientas. 
; o por medio del atajo de teclado z. La "Z" es la inicial de "Zauber", término que en alemán significa magia. 
Nota _________
; o por medio del atajo de teclado Shift +Ctrl+C 
de la caja de herramientas. 
Aviso__________________
; o desde el teclado mediante el atajo i. 
Marcadores