Scripting Illustrator: Convierte un color de proceso plano en un degradado coincidente
Spanish (Español) translation by Andrea Jiménez (you can also view the original English article)
Todos estamos bastante familiarizados con Adobe Illustrator y su interfaz de usuario. En nuestras tareas creativas diarias utilizamos muchas funciones, como: menú, paletas, colores, plugins y herramientas. Utilizamos estas características en forma de interfaz de usuario. Estas características de la interfaz de usuario se nos presentan a través de varios scripts y plugins.
De una manera más sencilla, podemos codificar scripts para automatizar tareas o para obtener algún efecto en Illustrator. Síguenos para aprender a hacerlo. En este tutorial, codificaremos en Javascript un script que convertirá un objeto lleno de proceso plano en su degradado correspondiente.
Vector Plus
¿Quieres acceder a los archivos completos de Vector Source y copias descargables de cada tutorial, incluido este? Únete a Vector Plus por solo 9$ dólares al mes.
Detalles del tutorial
- Programa: Adobe Illustrator CS3 y ExtendedScript Toolkit
- Dificultad: Intermedia
- Tiempo estimado de finalización: 3 a 4 horas
OBJETIVO del Script
Queremos que este script realice una tarea muy sencilla. En Adobe Illustrator, cuando un usuario selecciona algunos objetos rellenos con un color CMYK plano y ejecuta este script; los objetos se convertirán en un relleno de degradado CMYK coincidente. El degradado de salida será algo similar a un efecto de superposición de degradado visto en el modo multiplicador. Esto se muestra en la imagen de abajo.


Por lo tanto, el objetivo de nuestro script es convertir un objeto plano relleno de CMYK en un degradado de coincidencia de oscuro a claro. Esta es una acción simple que es un buen ejercicio para aprender a escribir un script para Illustrator.
Lógica y algoritmo
La lógica para convertir un color plano en un degradado de oscuro a claro se puede entender en cinco sencillos pasos:
- Paso 1: Elige el color del objeto actual; es decir, currentColor = color del objeto seleccionado actualmente.
- Paso 2: Crea un nuevo color degradado con dos rampas: startColor y endColor.
- Paso 3: startColor = currentColor – gShift, es decir, aclarar el color original.
- Paso 4: endColor = currentColor + gShift, es decir, oscurecer el color original.
- Paso 5: Aplica el nuevo degradado con startColor y endColor al objeto.
Donde, gShift es la cantidad de cambio de degradado que ingresará el usuario. El algoritmo anterior se puede entender fácilmente a partir de la representación gráfica que se muestra a continuación.


Aparte de la lógica central, implementaremos algunas validaciones y verificaciones para el correcto funcionamiento de este script. Estas validaciones se cubrirán en varias etapas de este tutorial. Antes de continuar con el tutorial real, familiaricémonos con algunos requisitos previos.
Introducción al Scripting
Este tutorial requiere algunos conocimientos básicos de scripting y su entorno. Para familiarizarte con el entorno de Scripting de Illustrator, puedes revisar rápidamente la documentación disponible en la carpeta de instalación de Illustrator, ve a installation_Directory \ Adobe \ Adobe Illustrator CS3 \ Scripting \ Documentación. Aquí, encontrarás los siguientes documentos para comenzar con JavaScript:
- Introducción de Adobe al Scripting.pdf
- Scripting de Illustrator CS3 Guide.pdf
- JavaScript de Illustrator CS3 Reference.pdf
- Guía de herramientas de JavaScript CS3.pdf
Tipos de Scripts
Hay tres tipos de scripts que podemos escribir para Illustrator. Estos son: AppleScript, JavaScript y VBScript. Dado que JavaScript es compatible tanto con Windows como con Mac OS, codificaremos nuestra lógica en JavaScript. La sintaxis y las notaciones son muy similares a las del JavaScript estándar. La única diferencia está en la extensión. Para Illustrator, indicaremos todos los archivos JavaScript con una extensión .jsx en lugar de la extensión .js común.
Herramientas requeridas
Aunque, puedes codificar todo el JavaScript en cualquiera de tus editores de texto favoritos; es recomendable utilizar Adobe ExtendedScript Toolkit. Al usar esta aplicación, podemos ejecutar, depurar, probar y verificar nuestro código sincrónicamente con Illustrator.
Nota: A lo largo de este tutorial, denotaremos ExtendScript Toolkit con una forma corta: ESTK.
Paso 1
Abre el kit de herramientas Adobe ExtendScript y crea un nuevo archivo JavaScript. Luego, selecciona Adobe Illustrator de la lista desplegable para la aplicación de destino. Esto le dice a ESTK que estamos escribiendo JavaScript para una aplicación en particular, es decir, Adobe Illustrator.


Paso 2 - Escribir un fragmento de código simple
En el área de edición de código, inserta las siguientes líneas de código:
1 |
if(app.documents.length > 0) |
2 |
alert("Documents are available");
|
3 |
else |
4 |
alert("No documents available");
|
En el código anterior, estamos verificando si hay algún documento abierto actualmente en Illustrator. Esto se hace a través de
app.documents.length, es decir, el objeto de nivel superior en cualquier DOM de aplicación de Adobe es el objeto de aplicación. El siguiente es el objeto del documento, que además contiene objetos como colores, capas, texto, páginas, entre otros. Guarda este archivo en tu disco duro como "test.jsx".
Paso 2.1 - Ejecución del Script
Hay dos formas de ejecutar el Script:
1. Ejecución desde ESTK
Si quieres ejecutar tu script a través de ESTK, presiona el botón Reproducir como se muestra a continuación.


Esto iniciará automáticamente la aplicación Adobe Illustrator y generará el mensaje de alerta. Puedes frenar o detener la ejecución presionando los botones de pausa o detención respectivamente.


2. Ejecución desde Illustrator
Para ejecutar este script desde Illustrator, ve a Archivo > Scripts > Otro script (Comando + F12) y localiza tu archivo recién creado "test.jsx". Después de hacer clic en Abrir, se ejecutará el script.
Entonces, ¿qué viste? Un mensaje de alerta, "No hay documentos disponibles".


Luego, crea un par de documentos nuevos en Illustrator y vuelve a ejecutar este script. Esta vez, verás una alerta, "Los documentos están disponibles".


Hasta este punto, escribimos y probamos una pequeña pieza de código. Esto se hizo como un ejercicio de calentamiento para familiarizarse con ESTK e Illustrator. En nuestros próximos pasos, trabajaremos en el script real.
Paso 3 - La estructura del código
Vuelve a ESTK y elimina el código de prueba que creamos en el paso 2. Después, agrega las siguientes líneas de código en "test.jsx:"
1 |
/* To make sure there is at least one document available in Illustrator |
2 |
and atleast one object in that document to work upon*/ |
3 |
if ( app.documents.length > 0 && app.activeDocument.pathItems.length > 0) |
4 |
{
|
5 |
// To make sure the Document Color Mode is CMYK |
6 |
if(app.activeDocument.documentColorSpace == DocumentColorSpace.CMYK) |
7 |
{
|
8 |
convertToGrad(); // Call to actual function which will contain all the logic |
9 |
} |
10 |
|
11 |
else |
12 |
{
|
13 |
alert("Document Color Space is not CMYK. Change the Document Color Mode to CMYK Mode", "CMYK Document required");
|
14 |
} |
15 |
|
16 |
} |
17 |
|
18 |
else |
19 |
{
|
20 |
alert("Either no document is available or the document is empty");
|
21 |
} |
22 |
|
23 |
function convertTograd() |
24 |
{
|
25 |
//Logic for converting flat color into gradient |
26 |
} |
En la estructura de código anterior, simplemente estamos creando una comprobación previa para nuestra función lógica principal: converToGrad(). Es decir, la lógica principal debe ejecutarse solo si se cumplen las siguientes condiciones:
- Existe al menos un documento con un objeto, para que podamos trabajar en él.
- El espacio de color del documento debe ser CMYK, porque toda la lógica se basa en colores CMYK.
Paso 3.1 - Descripción de las entidades DOM
app.documents.length devuelve el número total de documentos abiertos en Illustrator.
Un objeto activeDocument hace referencia al documento actual (activo) en el que estás trabajando.
pathItems hace referencia a una colección de todos los objetos pathItem de un documento de Illustrator. Cualquier elemento gráfico como rectángulo, elipse, polígono, línea, formas personalizadas, entre otros, se denota como pathItem; y una colección de todos estos pathItem se denotan como pathItems. Por lo tanto, app.activeDocument.pathItems.length devolverá el número de entidades gráficas contenidas en el documento actual.
El objeto documentColorSpace define el modo de color del documento. Estamos haciendo esta validación porque toda la lógica en este script se basará en el espacio de color CMYK.
La estructura básica del código está lista. A continuación, entraremos en la función convertToGrad().
Paso 4 - Comenzando con la lógica principal
El primer y principal requisito de nuestra lógica principal es obtener el número total de elementos seleccionados. Si no se selecciona ningún elemento, el script te notificará que selecciones al menos un objeto. Para ello, agrega las siguientes líneas de código a la función convertToGrad():
1 |
function convertToGrad() |
2 |
{
|
3 |
|
4 |
var items = selection; |
5 |
var totalSelected = items.length; |
6 |
|
7 |
if(totalSelected > 0) |
8 |
{
|
9 |
// proceed with the main logic |
10 |
} |
11 |
|
12 |
else |
13 |
{
|
14 |
alert("Please select atleast one object");
|
15 |
} |
16 |
|
17 |
}//end convertToGrad |


var items = selection crea una nueva variable items y le asigna toda la selección. En la línea siguiente, items.length devuelve el número total de elementos seleccionados, que se asignan a totalSelected.
Paso 5 - Obtención de los datos del usuario
Para convertir un color plano en un degradado, le solicitaremos al usuario que introduzca algunos valores para el desplazamiento de degradado y el ángulo de degradado. Pero antes de eso, repasemos cuáles son.
Gradient Shift: este es un valor numérico que decide cuánto color se agregará o eliminará del color original. Esta es la parte central de nuestra lógica para convertir un color plano en un degradado.
¿Cómo funciona un cambio de degradado? Para entender cómo funciona, ten en cuenta un ejemplo simple de un objeto lleno de valores CMYK: C = 50, M = 20, Y = 100 y K = 30 respectivamente.


Luego, le pedimos al usuario que ingrese un valor para Gradient Shift. Denotemos este valor por gShift, y el usuario ingresó 10 para gShift.


Una vez que tengamos el valor gShift, crearemos dos paradas de degradado para nuestro objeto. La primera parada, es decir, la más ligera; tendrá todos los valores CMYK disminuidos por gShift. Mientras que, la última parada, es decir, la más oscura, tendrá todos los valores CMYK incrementados por gShift.


De esta manera, se generará un degradado de oscuro a claro a partir del color de relleno real. También realizaremos algunas validaciones para restringir los valores CMYK dentro de 0 y 100, porque sumar o restar un valor gShift puede mover los valores CMYK más allá de 0 o 100.
Ángulo de degradado: Aunque no forma parte de la lógica central, usaremos esta función para proporcionar cierta accesibilidad y libertad para elegir un ángulo personalizado para el degradado resultante. El uso del ángulo de degradado se verá en la etapa posterior de este tutorial.
Volvamos al código y busquemos los datos del usuario.
Paso 6
Para obtener los datos del usuario, escribe las siguientes líneas de código en el bloque if(totalSelected >0):
1 |
if(totalSelected > 0) |
2 |
{
|
3 |
|
4 |
var gShift = Math.round(prompt("Enter a value for gradient shift","10","Gradient Shift"));
|
5 |
if(gShift == null || gShift <=0) gShift=0; |
6 |
if(gShift >=100) gShift =100; |
7 |
|
8 |
var gradAngle = prompt("Vector angle for Gradient","0.0","Gradient Angle")
|
9 |
if(gradAngle == null) gradAngle=0; |
10 |
|
11 |
} //endif |
En las líneas de código anteriores, le solicitamos a un usuario que introduzca algún valor para el desplazamiento de degradado y el ángulo de degradado. La función Math.round() redondea el valor introducido en un número entero. (Nota: Puedes omitir Math.round() si quieres que se acepten los valores decimales). Los valores predeterminados para gShift y gradAngle se configuran en "10" y "0.0" respectivamente.
Ten en cuenta que también estamos validando los valores introducidos para null y zero. Null se encuentra cuando un usuario hace clic en el botón Cancelar. Además, estamos restringiendo el valor gShift dentro de 0 y 100.
Una vez que tenemos los valores gShift y gradAngle, podemos continuar con el resto del código.
Paso 7 - Trabajar en los objetos seleccionados
Justo después de la declaración gradAngle, introduce las siguientes líneas de código:
1 |
for(var j=0; j < totalSelected; j++) |
2 |
{
|
3 |
var currentObject = app.activeDocument.selection[j]; |
4 |
|
5 |
if(currentObject.typename != "CompoundPathItem" && |
6 |
currentObject.typename != "GroupItem") |
7 |
{
|
8 |
if(currentObject.filled==true && |
9 |
currentObject.fillColor.typename != "GradientColor" && |
10 |
currentObject.fillColor.typename != "PatternColor" && |
11 |
currentObject.fillColor.typename != "SpotColor" &&) |
12 |
currentObject.fillColor.typename != "GrayColor" |
13 |
{
|
14 |
|
15 |
//perform color conversion here |
16 |
} |
17 |
|
18 |
else |
19 |
{
|
20 |
alert("Fill an object with CMYK color. Any objects containing\ngradients, patterns, spot colors or empty fills will be omitted."," Only CMYK Colors Allowed");
|
21 |
} |
22 |
} |
23 |
|
24 |
else |
25 |
{
|
26 |
alert("This script only works with Non-Compound Objects or Isolated Group items.\nAny items with Groups or Compound Objects will be omitted.", "Ungroup or Isolate the Group Items");
|
27 |
} |
28 |
|
29 |
}//endfor |
app.activeDocument.selection[j] devuelve el objeto seleccionado uno por uno para cada iteración de j.
Para cada objeto seleccionado, estamos haciendo algunas validaciones y comprobaciones. Estos controles son cruciales en esta etapa. La primera comprobación es determinar si el objeto es un elemento compuesto o un elemento de grupo. Dado que este script no funcionará directamente en grupos u objetos compuestos, esta comprobación es obligatoria.
En el siguiente nivel, estamos comprobando si el objeto seleccionado ya es un degradado, patrón o tinta plano. Si es así, estos objetos se omitirán.
Hay una verificación más para la especificación grayColor. GrayColor es ligeramente diferente a la especificación de color CMYK.
Se incluye una técnica detallada para tratar objetos con la especificación grayColor, que no incluyo en esta etapa del tutorial. Sin embargo, esta técnica se incluye en los archivos fuente de tu interés.
Paso 8 - Elige y divide el color
Según nuestra lógica y algoritmo, elegiremos el color para cada objeto seleccionado y dividiremos sus valores CMYK en cuatro variables diferentes, como se muestra a continuación:
1 |
var currentColor = currentObject.fillColor; |
2 |
|
3 |
var currentCyan = Math.round(currentColor.cyan); |
4 |
var currentMagenta = Math.round(currentColor.magenta); |
5 |
var currentYellow = Math.round(currentColor.yellow); |
6 |
var currentBlack = Math.round(currentColor.black); |
Nota: Todas estas líneas de código deben venir dentro del bloque "Realizar conversión de color", como se muestra en el Paso 7.
pathItem.fillColor devuelve el color de relleno de un elemento de trazado determinado. En nuestro caso, el pathItem es currentObject. Estamos usando las propiedades color.cyan, color.magenta, color.yellow y color.black para recuperar los valores C, M, Y y K respectivamente en cuatro variables diferentes. Una vez que establezcamos estos valores, podemos compensarlos fácilmente con gShift.
Paso 9 - Declarar colores para rampas de degradado
Nuestro degradado resultante tendrá dos paradas de degradado. Denotaremos con startColor y endColor. La declaración variable para estos dos colores de rampstop será la que se muestra a continuación:
1 |
var startColor = new CMYKColor(); |
2 |
var endColor = new CMYKColor(); |
El CMYKColor es una especificación de color CMYK utilizada para objetos de color. Aquí, el startColor y el endColor se declaran como nuevos colores CMYK.
Paso 10 - Desplazamiento de startColor y endColor
En esta etapa, tenemos todos los recursos necesarios para crear un nuevo degradado. Tenemos currentColor (con valores CMYK separados), startColor, endColor y gShift. Ahora podemos configurar los valores de color finales para startColor y endColor utilizando la técnica offset.
Paso 10.1 - Configuración del startColor
El startColor será la parte más ligera del degradado. Por lo tanto, restaremos gShift de los valores C, M, Y y K de currentColor, lo que da como resultado startColor.
1 |
startColor.cyan = currentCyan – gShift; |
2 |
startColor.magenta = currentMagenta - gShift; |
3 |
startColor.yellow= currentYellow - gShift; |
4 |
startColor.black = currentBlack - gShift; |
Esto es simple, pero necesitamos realizar algunas comprobaciones. Por ejemplo, ¿qué pasará si el currentCyan ya es menor que gShift? Digamos, currentCyan es 10 y gShift es 20. El valor cian resultante para startColor será 10-20 = (-) 10. Para solucionar este problema, modificaremos el conjunto de código anterior en las siguientes líneas de código:
1 |
if(currentCyan < gShift) |
2 |
startColor.cyan= 0; |
3 |
else |
4 |
startColor.cyan= currentCyan - gShift; |
5 |
|
6 |
if(currentMagenta < gShift) |
7 |
startColor.magenta= 0; |
8 |
else |
9 |
startColor.magenta = currentMagenta - gShift; |
10 |
|
11 |
if(currentYellow < gShift) |
12 |
startColor.yellow= 0; |
13 |
else |
14 |
startColor.yellow= currentYellow - gShift; |
15 |
|
16 |
if(currentBlack < gShift) |
17 |
startColor.black= 0; |
18 |
else |
19 |
startColor.black = currentBlack - gShift; |
Paso 10.2 - Configuración del endColor
El endColor será la parte más oscura del degradado. Por lo tanto, agregaremos gShift a los valores C, M, Y y K o currentColor respectivamente. Después de una simple adición, el código debe verse de la siguiente manera:
1 |
endColor.cyan= currentCyan + gShift; |
2 |
endColor.magenta = currentMagenta + gShift; |
3 |
endColor.yellow= currentYellow + gShift; |
4 |
endColor.black = currentBlack + gShift; |
Una vez más, todo se ve bien. Pero hay una complicación: ¿Qué sucederá si la adición de gShift resulta en un valor mayor que 100? Por ejemplo, currentCyan es 95 y gShift es 20. La adición de estos dos resultará como endColor.cyan = 115; lo cual no es aceptable. Así que compensaremos esto con algunas validaciones.
Crearemos una nueva variable gShiftEnd, que es igual a 100-gShift. Después, comprobaremos si el valor actual de C, M, Y o K es mayor que gShiftEnd. Si es así, configuraremos el valor C, M, Y o K de endColor en 100; de lo contrario, configuraremos el valor C, M, Y o K de endColor agregando gShift al C, M, Y o K actual. Esto se puede elaborar a partir del ejemplo que acabamos de ver arriba.
Tenemos currentCyan = 95 y gShift = 20. Por lo tanto gShiftEnd = 100 – 20, es decir, 80. Luego, currentCyan es mayor que gShiftEnd; así que configuraremos endColor.cyan en 100.
Siguiendo este principio, nuestro código se modificará a lo siguiente:
1 |
gShiftEnd = 100-gShift; |
2 |
|
3 |
if(currentCyan > gShiftEnd) |
4 |
endColor.cyan= 100; |
5 |
else |
6 |
endColor.cyan= currentCyan + gShift; |
7 |
|
8 |
if(currentMagenta > gShiftEnd) |
9 |
endColor.magenta= 100; |
10 |
else |
11 |
endColor.magenta = currentMagenta + gShift; |
12 |
|
13 |
if(currentYellow > gShiftEnd) |
14 |
endColor.yellow= 100; |
15 |
else |
16 |
endColor.yellow= currentYellow + gShift; |
17 |
|
18 |
if(currentBlack > gShiftEnd) |
19 |
endColor.black= 100; |
20 |
else |
21 |
endColor.black = currentBlack + gShift; |
Entonces, hasta este punto, el código completo se verá así:
1 |
if ( app.documents.length > 0 && app.activeDocument.pathItems.length > 0) |
2 |
{
|
3 |
if(app.activeDocument.documentColorSpace == DocumentColorSpace.CMYK) |
4 |
{
|
5 |
convertToGrad(); |
6 |
} |
7 |
else |
8 |
{
|
9 |
alert("Document Color Space is not CMYK. Change the Document Color Mode to CMYK Mode", "CMYK Document required");
|
10 |
} |
11 |
|
12 |
}//end main if |
13 |
|
14 |
else |
15 |
{
|
16 |
alert("Either no document is available or the document is empty");
|
17 |
} |
18 |
|
19 |
|
20 |
function convertToGrad() {
|
21 |
|
22 |
var items = selection; |
23 |
var totalSelected = items.length; |
24 |
|
25 |
if(totalSelected > 0) |
26 |
{
|
27 |
var gShift = Math.round(prompt("Enter a value for gradient shift","10","Gradient Shift"));
|
28 |
if(gShift == null || gShift <=0) gShift=0; |
29 |
if(gShift >=100) gShift =100; |
30 |
|
31 |
var gradAngle = prompt("Vector angle for Gradient","0.0","Gradient Angle")
|
32 |
if(gradAngle == null) gradAngle=0; |
33 |
|
34 |
for(var j=0; j < totalSelected; j++) |
35 |
{
|
36 |
var currentObject = app.activeDocument.selection[j]; |
37 |
if(currentObject.typename != "CompoundPathItem" && currentObject.typename != "GroupItem") |
38 |
{
|
39 |
if(currentObject.filled==true && |
40 |
currentObject.fillColor.typename != "GradientColor" && |
41 |
currentObject.fillColor.typename != "PatternColor" && |
42 |
currentObject.fillColor.typename != "SpotColor" && |
43 |
currentObject.fillColor.typename != "GrayColor" |
44 |
) |
45 |
{
|
46 |
|
47 |
var currentColor = currentObject.fillColor; |
48 |
var currentCyan = Math.round(currentColor.cyan); |
49 |
var currentMagenta = Math.round(currentColor.magenta); |
50 |
var currentYellow = Math.round(currentColor.yellow); |
51 |
var currentBlack = Math.round(currentColor.black); |
52 |
|
53 |
|
54 |
// Create a color for both ends of the gradient |
55 |
var startColor = new CMYKColor(); |
56 |
var endColor = new CMYKColor(); |
57 |
|
58 |
if(currentCyan < gShift) |
59 |
startColor.cyan = 0; |
60 |
else |
61 |
startColor.cyan = currentCyan - gShift; |
62 |
|
63 |
if(currentMagenta < gShift) |
64 |
startColor.magenta = 0; |
65 |
else |
66 |
startColor.magenta = currentMagenta - gShift; |
67 |
|
68 |
if(currentYellow < gShift) |
69 |
startColor.yellow = 0; |
70 |
else |
71 |
startColor.yellow = currentYellow - gShift; |
72 |
|
73 |
if(currentBlack < gShift) |
74 |
startColor.black= 0; |
75 |
else |
76 |
startColor.black = currentBlack - gShift; |
77 |
|
78 |
gShiftEnd = 100 - gShift; |
79 |
|
80 |
if(currentCyan > gShiftEnd) |
81 |
endColor.cyan = 100; |
82 |
else |
83 |
endColor.cyan = currentCyan + gShift; |
84 |
|
85 |
if(currentMagenta > gShiftEnd) |
86 |
endColor.magenta = 100; |
87 |
else |
88 |
endColor.magenta = currentMagenta + gShift; |
89 |
|
90 |
if(currentYellow > gShiftEnd) |
91 |
endColor.yellow = 100; |
92 |
else |
93 |
endColor.yellow = currentYellow + gShift; |
94 |
|
95 |
if(currentBlack > gShiftEnd) |
96 |
endColor.black = 100; |
97 |
else |
98 |
endColor.black = currentBlack + gShift; |
99 |
|
100 |
// Gradient Declaration Block |
101 |
|
102 |
|
103 |
} //endif |
104 |
|
105 |
else |
106 |
{
|
107 |
alert("Fill an object with CMYK color. Any objects containing\ngradients, patterns, spot colors or empty fills will be omitted."," Only CMYK Colors Allowed");
|
108 |
} |
109 |
} |
110 |
|
111 |
else |
112 |
{
|
113 |
alert("This script only works with Non-Compound Objects or Isolated Group items.\nAny items with Groups or Compound Objects will be omitted.", "Ungroup or Isolate the Group Items");
|
114 |
|
115 |
} |
116 |
|
117 |
}//endfor |
118 |
}//end selected |
119 |
else |
120 |
{
|
121 |
alert("Please select atleast one object");
|
122 |
} |
123 |
} |
Paso 11 - Creación del nuevo degradado
Ya que configuramos el startColor y endColor; podemos proceder con la creación del nuevo gradiente.
Paso 11.1 - Declarar el degradado
Para agregar un nuevo degradado, inserta las siguientes líneas de código en el "//Bloque de declaración de degradado".
1 |
var newGradient = app.activeDocument.gradients.add(); |
2 |
newGradient.type = GradientType.LINEAR; |
Esto agregará un nuevo degradado de tipo lineal en el documento activo actual.
Paso 11.2 - Configurar las propiedades del degradado recién creado
Agrega las siguientes líneas de código justo después de la declaración de degradado:
1 |
// Modify the first gradient stop |
2 |
newGradient.gradientStops[0].rampPoint = 0; |
3 |
newGradient.gradientStops[0].midPoint = 50; |
4 |
newGradient.gradientStops[0].color = startColor; |
5 |
|
6 |
// Modify the last gradient stop |
7 |
newGradient.gradientStops[1].rampPoint = 100; |
8 |
newGradient.gradientStops[1].color = endColor; |
gradientStop[0] es la primera parada de degradado, mientras que gradientStop[1] es la última parada de degradado. Si quieres tener más paradas de degradado, puedes denotarlas como gradientStop[2], gradientStop[3] y así sucesivamente.
rampPoint se utiliza para establecer la posición del punto de rampa del gradientStop asociado. Configuramos el primer y último punto de rampa como 0 y 100 respectivamente. midpoint se utiliza para configurar la posición del punto medio entre dos paradas de degradado. Configuramos esto en 50. Finalmente, asignamos los valores de startColor y endColor al primer y último gradientStops respectivamente.
Paso 12 - Crear un objeto de color degradado
Casi terminamos con la conversión de color y la formación de degradados. Luego, debemos aplicarle este degradado recién creado al objeto seleccionado actualmente. Para ello, crearemos un objeto de color degradado que hace referencia al degradado recién creado.
Nota: No podemos aplicarle el degradado recién creado directamente como color de relleno al objeto. Para poder utilizar este degradado, tendremos que crear un nuevo objeto Color degradado, como se muestra a continuación:
1 |
// construct an Illustrator.GradientColor object referring to the |
2 |
// newly created gradient |
3 |
var colorOfGradient= new GradientColor(); |
4 |
colorOfGradient.gradient = newGradient; |
Paso 13 - Aplicar el degradado
Finalmente, llenaremos el currentObject con el colorOfGradient, como se muestra a continuación:
1 |
// get current path item, apply new gradient as its fill |
2 |
currentObject.fillColor = colorOfGradient; |
3 |
currentObject.rotate(gradAngle, false, false, true, false, Transformation.CENTER); |
Aplicamos una matriz de rotación al objeto actual. Esta matriz de rotación hace uso del ángulo de gradiente para transformar el gradiente. La sintaxis de la rotación es:
rotate (angle [,changePositions] [,changeFillPatterns] [,changeFillGradients] [,changeStrokePattern] [,rotateAbout])
Aquí, configuramos changeFillgradients en "true" y el resto en "false". Esta es una forma complicada de girar el color degradado en un ángulo particular. Gracias a John Wundes por sugerirme esta técnica inteligente.
Paso 14 - El Script final
El script final después de completar la codificación se muestra a continuación:
1 |
if ( app.documents.length > 0 && app.activeDocument.pathItems.length > 0) |
2 |
{
|
3 |
if(app.activeDocument.documentColorSpace == DocumentColorSpace.CMYK) |
4 |
{
|
5 |
convertToGrad(); |
6 |
} |
7 |
else |
8 |
{
|
9 |
alert("Document Color Space is not CMYK. Change the Document Color Mode to CMYK Mode", "CMYK Document required");
|
10 |
} |
11 |
|
12 |
}//end main if |
13 |
|
14 |
else |
15 |
{
|
16 |
alert("Either no document is available or the document is empty");
|
17 |
} |
18 |
|
19 |
|
20 |
function convertToGrad() {
|
21 |
|
22 |
var items = selection; |
23 |
var totalSelected = items.length; |
24 |
|
25 |
if(totalSelected > 0) |
26 |
{
|
27 |
var gShift = Math.round(prompt("Enter a value for gradient shift","10","Gradient Shift"));
|
28 |
if(gShift == null || gShift <=0) gShift=0; |
29 |
if(gShift >=100) gShift =100; |
30 |
|
31 |
var gradAngle = prompt("Vector angle for Gradient","0.0","Gradient Angle")
|
32 |
if(gradAngle == null) gradAngle=0; |
33 |
|
34 |
for(var j=0; j < totalSelected; j++) |
35 |
{
|
36 |
var currentObject = app.activeDocument.selection[j]; |
37 |
if(currentObject.typename != "CompoundPathItem" && currentObject.typename != "GroupItem") |
38 |
{
|
39 |
if(currentObject.filled==true && |
40 |
currentObject.fillColor.typename != "GradientColor" && |
41 |
currentObject.fillColor.typename != "PatternColor" && |
42 |
currentObject.fillColor.typename != "SpotColor" && |
43 |
currentObject.fillColor.typename != "GrayColor" |
44 |
) |
45 |
{
|
46 |
|
47 |
var currentColor = currentObject.fillColor; |
48 |
var currentCyan = Math.round(currentColor.cyan); |
49 |
var currentMagenta = Math.round(currentColor.magenta); |
50 |
var currentYellow = Math.round(currentColor.yellow); |
51 |
var currentBlack = Math.round(currentColor.black); |
52 |
|
53 |
|
54 |
// Create a color for both ends of the gradient |
55 |
var startColor = new CMYKColor(); |
56 |
var endColor = new CMYKColor(); |
57 |
|
58 |
if(currentCyan < gShift) |
59 |
startColor.cyan= 0; |
60 |
else |
61 |
startColor.cyan = currentCyan - gShift; |
62 |
|
63 |
if(currentMagenta < gShift) |
64 |
startColor.magenta = 0; |
65 |
else |
66 |
startColor.magenta = currentMagenta - gShift; |
67 |
|
68 |
if(currentYellow < gShift) |
69 |
startColor.yellow = 0; |
70 |
else |
71 |
startColor.yellow = currentYellow - gShift; |
72 |
|
73 |
if(currentBlack < gShift) |
74 |
startColor.black = 0; |
75 |
else |
76 |
startColor.black = currentBlack - gShift; |
77 |
|
78 |
gShiftEnd = 100 - gShift; |
79 |
|
80 |
if(currentCyan > gShiftEnd) |
81 |
endColor.cyan = 100; |
82 |
else |
83 |
endColor.cyan = currentCyan + gShift; |
84 |
|
85 |
if(currentMagenta > gShiftEnd) |
86 |
endColor.magenta = 100; |
87 |
else |
88 |
endColor.magenta = currentMagenta + gShift; |
89 |
|
90 |
if(currentYellow > gShiftEnd) |
91 |
endColor.yellow = 100; |
92 |
else |
93 |
endColor.yellow = currentYellow + gShift; |
94 |
|
95 |
if(currentBlack > gShiftEnd) |
96 |
endColor.black = 100; |
97 |
else |
98 |
endColor.black = currentBlack + gShift; |
99 |
|
100 |
// Create a new gradient |
101 |
// A new gradient always has 2 stops |
102 |
var newGradient = app.activeDocument.gradients.add(); |
103 |
newGradient.type = GradientType.LINEAR; |
104 |
|
105 |
|
106 |
// Modify the first gradient stop |
107 |
newGradient.gradientStops[0].rampPoint = 0; |
108 |
newGradient.gradientStops[0].midPoint = 50; |
109 |
newGradient.gradientStops[0].color = startColor; |
110 |
|
111 |
// Modify the last gradient stop |
112 |
newGradient.gradientStops[1].rampPoint = 100; |
113 |
newGradient.gradientStops[1].color = endColor; |
114 |
|
115 |
// construct an Illustrator.GradientColor object referring to the |
116 |
// newly created gradient |
117 |
var colorOfGradient= new GradientColor(); |
118 |
colorOfGradient.gradient = newGradient; |
119 |
|
120 |
// get current path item, apply new gradient as its fill |
121 |
currentObject.fillColor = colorOfGradient; |
122 |
currentObject.rotate(gradAngle, false, false, true, false, Transformation.CENTER); |
123 |
|
124 |
} //endif |
125 |
|
126 |
else |
127 |
{
|
128 |
alert("Fill an object with CMYK color. Any objects containing\ngradients, patterns, spot colors or empty fills will be omitted."," Only CMYK Colors Allowed");
|
129 |
} |
130 |
} |
131 |
|
132 |
else |
133 |
{
|
134 |
alert("This script only works with Non-Compound Objects or Isolated Group items.\nAny items with Groups or Compound Objects will be omitted.", "Ungroup or Isolate the Group Items");
|
135 |
|
136 |
} |
137 |
|
138 |
}//endfor |
139 |
}//end selected |
140 |
else |
141 |
{
|
142 |
alert("Please select atleast one object");
|
143 |
} |
144 |
} |
Paso 15 - Ejecutar el Script
Guarda el script y crea un nuevo documento en Adobe Illustrator. Después, crea algunos objetos con colores CMYK planos. Selecciona algunos de estos objetos y ejecuta el script siguiendo los métodos descritos en el Paso 2.1.


Se te pedirá que introduzcas el desplazamiento de degradado. Introduce cualquier valor para gShift.


Después, se te pedirá el ángulo de degradado. Introduce algún valor para gradAngle.


Finalmente, verás el resultado que se muestra a continuación.


Conclusión y alcance
Aprendimos a escribir scripts para automatizar o generar un efecto. El ejemplo mostrado en este tutorial fue una simple demostración de lo que podemos realizar a través de scripts. Con este ejemplo, aprendimos cómo se representan los colores CMYK en los scripts, cómo funcionan y cómo se comportan los objetos en el DOM de Adobe Illustrator. En nuestra siguiente parte, hablaremos de un script que funde el color degradado disponible en un color CMYK plano. Espero que hayas disfrutado de este tutorial introductorio a los scripts.
Suscríbete a Vectortuts+ RSS Feed para mantenerte al día de los últimos tutoriales y artículos de vectores.