¿Cómo repetir un degradado varias veces en Illustrator y Photoshop?

Cómo repetir un gradiente 'n' veces, por ejemplo, repitiendo el degradado de negro a blanco 5 veces (a lo largo de la trayectoria del trazo) como lo hice manualmente en la imagen de ejemplo a continuación.

¿Hay alguna manera de automatizarlo para multiplicar 'n' veces, como 50 o 100, sin copiar manualmente el control deslizante de degradado?

¡Usa scripts!

Como han respondido otros, debe usar secuencias de comandos. Pero algunas de las otras soluciones aquí solo usan RGB, mientras que la mía usa colores que usted elige de su documento. Además, algunas soluciones no producían incluso el color en el punto envolvente, o tenían demasiadas paradas de gradiente superpuestas, por lo que mi script aborda esos problemas.

Para usarlo, seleccione 2 o más trazados que estén llenos de colores destinados al gradiente, luego, cuando se le solicite, ingrese el número de veces para repetir el gradiente.

http://pastie.org/10924009

Editar : el sitio pastie no funciona, así que he incluido el siguiente código:

// select two paths, then run this script
if (app.activeDocument.selection.length < 2) {

    alert("Please select two or more paths with fills.");

} else {

    var cycles = Number(prompt ("Repeat the gradient how many times?")) || 5;  
    var myselection = app.activeDocument.selection;
    var colors = [];

    for (var i = 0; i < myselection.length; i++) {
        var newColor = myselection[i].fillColor;
        colors.push(newColor);
    }

    var stops = colors.length * cycles - 1; // “stops” does not include default 2 stops
    var interval = 100 / (cycles * colors.length); // ... the distance between stops

    var newGradient = app.activeDocument.gradients.add();  

    newGradient.type = GradientType.LINEAR;     // asymmetric, for 3 or more colours
    //newGradient.type = GradientType.RADIAL;   // symetric, for 3 or more colours

    //  the default 2 gradient stops (at beginning and end)
    //  should be the same colour, so that the gradient smoothly wraps around:
    newGradient.gradientStops[0].color = colors[0]; 
    newGradient.gradientStops[1].color = colors[0]; 

    // now add stops between beginning and end stops:
    for ( i = 1; i <= stops; i++ ) {

        var thisStop = newGradient.gradientStops.add();
        thisStop.rampPoint = i * interval;
        thisStop.color = colors[i % colors.length];

    }

    // to get a even result, the first and last rampPoints cannot be 0 and 100:
    newGradient.gradientStops[0].rampPoint = 0.1;
    newGradient.gradientStops[stops + 1].rampPoint = 99.9;
}

Ejemplo 1: blanco y negro, se repite 6 veces, documento CMYK:

Ejemplo 2: gradiente de 3 colores, 6 repeticiones:

Ejemplo 3: documento RGB, 6 colores, 20 repeticiones. ¿Observa cómo se superponen los trazados rellenos? Ese orden de apilamiento (de adelante hacia atrás) determina el orden de los colores en el degradado.

Cambio de colores en el degradado : seleccione una ruta con el degradado aplicado, luego elija el menú desplegable Panel de muestras → Agregar colores seleccionados. Se agregarán nuevas muestras globales al panel de muestras, y cuando edite una, se actualizará en todas partes.

Puede lograr esto con las secuencias de comandos de Illustrator. Verificación de la documentación para CC15.3 en el PDF de referencia de JavaScript en Gradientes en la página 68.

Crea los colores:

// Create the colors
var startColor = new RGBColor();  
startColor.red = 0;  
startColor.green = 100;  
startColor.blue = 255;  

var middleColor = new RGBColor();
middleColor.red = 252;  
middleColor.green = 238;  
middleColor.blue = 33;

var endColor = new RGBColor();  
endColor.red = 220;  
endColor.green = 0;  
endColor.blue = 100;  

Crea el gradiente:

var newGradient = app.activeDocument.gradients.add();  
newGradient.name = "new_gradient_75097";  

Crea un gradiente lineal:

newGradient.type = GradientType.LINEAR;  

o Crear un degradado radial:

newGradient.type = GradientType.RADIAL; 

Donde desearía construir los múltiples tipos del gradiente sería en GradientStops:

// Modify the first gradient stop  
newGradient.gradientStops[0].rampPoint = 0  
newGradient.gradientStops[0].midPoint = 20;  
newGradient.gradientStops[0].color = startColor;  
// Modify the middle gradient stop  
newGradient.gradientStops.add();
// Modify the last gradient stop  
newGradient.gradientStops[1].rampPoint = 70;  
newGradient.gradientStops[1].midPoint = 80;  
newGradient.gradientStops[1].color = endColor;

Mis disculpas, se observó que no expliqué completamente cómo se podía crear un gradiente n veces, por lo que modifiqué aún más el script para incluir un indicador y un bucle.

Llame el número de veces:

var countgradient = Number(prompt ("Enter Gradient Count"));  

Cree un bucle y agregue aún más la cantidad de gradientes:

for ( i =0; i < countgradient; i++ ) {
    var origCount = newGradient.gradientStops.length;
    var lastStop = newGradient.gradientStops[origCount-1];

    var firstStop = newGradient.gradientStops.add();
    firstStop.rampPoint = lastStop.rampPoint;
    lastStop.rampPoint = lastStop.rampPoint - 1;
    firstStop.color = endColor;

    var secondStop = newGradient.gradientStops.add();
    secondStop.rampPoint = lastStop.rampPoint;
    lastStop.rampPoint = lastStop.rampPoint - 2;
    secondStop.color = startColor;
}

Codifique arriba una mezcla de lo que está en la página 65-71 del enlace en la parte superior:

Ejemplo con 1 vez:

Ejemplo con 5 veces:

Puede modificar lastStop.rampPoint - npara ajustar dónde aterrizan. Espero que esto ayude.

Esto solo funcionará si está utilizando el degradado como un trazo (como en su pregunta). Si desea repetir el gradiente sin fin (a diferencia de un número específico de repeticiones), puede omitir los pasos 2 y 3 y usar un pincel de patrón en lugar de un pincel de arte. En CC ahora puede usar imágenes en pinceles para que pueda rasterizar el gradiente en lugar de expandirlo, pero estoy usando CS6, así que no puedo probar eso.

1. Configure un solo rectángulo lleno con el degradado que desea repetir.

2. Use un efecto de transformación ( Efecto → Distorsionar y Transformar → Transformar ... ) para duplicar su rectángulo. Establezca el movimiento horizontal al ancho de su rectángulo y establezca tantas copias como necesite.

3. Expanda el efecto de transformación ( Objeto → Expandir apariencia ).

4. No puede utilizar degradados en pinceles, por lo que deberá expandir el degradado ( Objeto → Expandir ), elegir una cantidad de objetos para expandirlos en "Expandir degradado a".

   Expandir el degradado te dejará con algunas máscaras de recorte en el degradado expandido, tendrás que pasar por las capas y eliminarlas (o seguir haciendo clic derecho y "Desagrupar" y luego "Liberar máscara de recorte" hasta que no haya más máscaras).

5. Arrastre sus degradados expandidos al panel Pinceles y seleccione "Pincel de arte". Las opciones predeterminadas para su pincel probablemente estarán bien, así que simplemente presione "Aceptar". Siempre puede volver y ajustar las opciones de pincel más tarde.

6. Aplica tu nuevo pincel.

Basado en el manual de Illustrator JS, se me ocurrió el siguiente código. Este código hace exactamente lo que quieres:

• Crea un degradado con dos paradas de color: blanco y negro.
• Lo repite cinco veces
• Se aplica como un trazo al elemento activo (seleccionado)

Una versión más generalista se puede encontrar debajo de la línea.

(1) Primero establecemos el número deseado de colores y los tiempos deseados que el gradiente necesita iterar:

//Change these
var numberOfColors = 2; //Change this to the desired number of colors in the gradient
var iteration = 5; //Change this to the desired times you want to repeat the gradient

(2) Luego establecemos algunas variables para su uso posterior. El GradientIntervalcalcula la posición porcentaje necesidades de cada punto que se va a. totalNumberofStopsEs bastante autoexplicativo. La colorsmatriz se usará más tarde.

//Don't change these
var i,j;
var gradientInterval = 100 / numberOfColors / iteration;
var totalNumberOfStops = numberOfColors * iteration;
var colors = [];

(3) Entonces podemos definir nuestros colores. Necesita exactamente tantos colores como se configuraron numberOfColorsal principio. Los colores que faltan serán predeterminados a negro.

//Don't forget to push the colors to the colors array!

var color1 = new RGBColor();
color1.red = 0;
color1.green = 0;
color1.blue = 0;
colors.push(color1);

var color2 = new RGBColor();
color2.red = 255;
color2.green = 255;
color2.blue = 255;
colors.push(color2);

(4) Hora de crear nuestro gradiente y darle un nombre. Ahora también podemos establecer el tipo.

//Let's initiate the gradient & name it
var newGradient = app.activeDocument.gradients.add();
newGradient.name = "new_gradient";

//Choose the gradient type here
//newGradient.type = GradientType.RADIAL; //Uncomment the one you need
newGradient.type = GradientType.LINEAR; //Uncomment the one you need

(5) Ahora para la buena parte. Primero recorreremos el totalNumberOfStopspara que podamos crear cada parada y agregarla al gradiente. Creamos una nueva parada y la configuramos una más lejos que la última. Ahora necesitamos obtener el color correcto de nuestra matriz de colores. Cuando el módulo del índice de bucle dividido por el número de colores es 0, sabemos que hemos tenido todos los colores y necesitamos comenzar de nuevo, por lo que restablecemos nuestro índice de color.

Ejemplo Digamos que tengo seis colores que quiero repetir 5 veces. Tenemos treinta paradas. Repetimos todos los colores usando j. Cuando se jconvierte en 6, no hay más colores (seis es el séptimo color en la matriz, pero solo hay seis colores en la matriz). Entonces, cada múltiplo de seis comenzamos de nuevo en 0. De lo contrario, simplemente pasamos al siguiente color.

Ahora solo necesitamos agregar la parada de color final al 100%.

//Now here is where the magic starts
for(i=0;i<totalNumberOfStops;i++){
    var newStop = newGradient.gradientStops.add();
    newStop.rampPoint = i * gradientInterval;
    var modulus = i % numberOfColors;
    if(modulus === 0){
        j = 0;
    }else{
        j+=1;
    }
    newStop.color = colors[j];
}
var lastStop = newGradient.gradientStops.add();
lastStop.rampPoint = 100;
lastStop.color = colors[colors.length-1];

(6) El último paso: aplicar el gradiente al trazo. Hecho. ¡Fiesta!

//Apply gradient stroke to selected object
var colorOfGradient = new GradientColor();
colorOfGradient.gradient = newGradient;
var topPath = app.activeDocument.pathItems[0];
topPath.stroked = true;
topPath.strokeWidth = 140;
topPath.strokeColor =colorOfGradient;

(7) Es posible que deba configurar el trazo en 'Aplicar degradado a lo largo del trazo' manualmente, porque no he encontrado el código para hacerlo.

Este código fue hecho específicamente para su caso. Una versión más generalista se puede encontrar aquí: http://pastie.org/10921740

Algunos ejemplos:

Un degradado con dos colores, que se repite dos veces:

Un degradado con cinco colores, que se repite 10 veces:

Un degradado con dos colores, que se repite 50 veces:

Un gradiente enorme con 50 colores que se repite 50 veces:

Tuve el mismo problema, ¡y esa respuesta de MG_ fue justo lo que necesitaba!

Sin embargo, después de un tiempo, noté que de vez en cuando necesito también gradientes no uniformes y también gradientes no uniformes. Fue un poco doloroso encontrar una buena solución, así que estoy compartiendo el script modificado aquí para otros con el mismo problema. También incluí una interfaz de usuario simple para configurar todo.

var run = true;
if (app.activeDocument.selection.length < 2) {
    alert("Please select two or more paths with fills.");
} else {
    var dlg = new Window("dialog{text:'Create repeated gradient'}");

    dlg.location = [500,50];
    (dlg.alertBtnsPnl1 = dlg.add('panel', undefined, 'Color transition:')).helpTip = "Smooth or rough transition"; 
    (dlg.alertBtnsPnl1.selectS = dlg.alertBtnsPnl1.add('radiobutton', [15,15,95,35], 'Smooth' )).helpTip = "Smooth color transition"; 
    (dlg.alertBtnsPnl1.selectR = dlg.alertBtnsPnl1.add('radiobutton', [15,15,75,35], 'Rough' )).helpTip = "Sharp color transition"; 
    dlg.alertBtnsPnl1.orientation='row';
    dlg.alertBtnsPnl1.selectS.value = true;

    (dlg.alertBtnsPnl3 = dlg.add('panel', undefined, 'Gradient type:')).helpTip = "Linear or radial gradient"; 
    (dlg.alertBtnsPnl3.selectL = dlg.alertBtnsPnl3.add('radiobutton', [15,15,95,35], 'Linear' )).helpTip = "Linear gradient"; 
    (dlg.alertBtnsPnl3.selectR = dlg.alertBtnsPnl3.add('radiobutton', [15,15,75,35], 'Radial' )).helpTip = "Radial gradient"; 
    dlg.alertBtnsPnl3.orientation='row';
    dlg.alertBtnsPnl3.selectL.value = true;

    (dlg.alertBtnsPnl2 = dlg.add('panel', undefined, 'Gradient repeats:')).helpTip = "Gradient repeat count"; 
    (dlg.alertBtnsPnl2.slide = dlg.alertBtnsPnl2.add('slider', [25,15,165,39], 'Set repeat count for gradient:')).helpTip = "Use Slider to set a repeat count"; 
    dlg.alertBtnsPnl2.slide.value = 2; 
    (dlg.alertBtnsPnl2.titleEt = dlg.alertBtnsPnl2.add('edittext', [100,15,160,35], dlg.alertBtnsPnl2.slide.value)).helpTip = "Enter a repeat count value"; 
    dlg.alertBtnsPnl2.titleEt.text = Math.ceil(dlg.alertBtnsPnl2.slide.value); 
    dlg.alertBtnsPnl2.orientation='row';

    (dlg.alertBtnsPnl4 = dlg.add('panel', undefined, 'First and last colors:')).helpTip = "Define type of gradient loop";
    (dlg.sameStartAndEnd = dlg.alertBtnsPnl4.add('checkbox', [25,25,235,39], 'Start and end with same color')).helpTip="Use this for seamless gradient"; 
    dlg.sameStartAndEnd.value = true; 
    dlg.alertBtnsPnl4.orientation='column';

    dlg.btnPnl = dlg.add('group', undefined, 'Do It!'); 
    dlg.btnPnl.orientation='row';
    dlg.btnPnl.buildBtn1= dlg.btnPnl.add('button',[15,15,115,35], 'Cancel', {name:'cancel'}); 
    dlg.btnPnl.buildBtn2 = dlg.btnPnl.add('button', [125,15,225,35], 'OK', {name:'ok'}); 
    dlg.alertBtnsPnl2.slide.onChange= sliderChanged;
    dlg.alertBtnsPnl2.titleEt.onChanging = eTextChanged;
    dlg.btnPnl.buildBtn1.onClick= actionCanceled;
    dlg.show();

    if(run){
        var smooth = (dlg.alertBtnsPnl1.selectS.value) ? true : false;
        var cycles = dlg.alertBtnsPnl2.slide.value;
        var myselection = app.activeDocument.selection;
        var colors = [];

        for (var i = 0; i < myselection.length; i++) {
            var newColor = myselection[i].fillColor;
            colors.push(newColor);
        }

        var stops;
        var interval;
        if(dlg.sameStartAndEnd.value && !smooth){
            stops = colors.length * cycles - 2;
            interval = 100 / ((cycles * colors.length)+1);
        }else{
            if(smooth && !dlg.sameStartAndEnd.value){
                stops = colors.length * cycles - 2;
                interval = 100 / ((cycles * colors.length)-1);
            }else{
                stops = colors.length * cycles - 1;
                interval = 100 / (cycles * colors.length);
            }
        }

        var allStops = stops;
        var newGradient = app.activeDocument.gradients.add();  

        newGradient.type = (dlg.alertBtnsPnl3.selectL.value) ? GradientType.LINEAR : GradientType.RADIAL;

        newGradient.gradientStops[0].color = colors[0]; 
        if(dlg.sameStartAndEnd.value) newGradient.gradientStops[1].color = colors[0]; 
        else newGradient.gradientStops[1].color = colors[colors.length - 1]; 

        if(!smooth){
            var thisStop = newGradient.gradientStops.add();
            thisStop.rampPoint = interval-0.1;
            thisStop.color = colors[0];
            allStops++;
        }

        for(i = 1; i <= stops; i++){
            var thisStop = newGradient.gradientStops.add();
            thisStop.rampPoint = i * interval;
            thisStop.color = colors[i % colors.length];

            if(!smooth && i<(stops+1)){
                var thisStop = newGradient.gradientStops.add();
                thisStop.rampPoint = (i+1) * interval - 0.001;
                thisStop.color = colors[i % colors.length];
                allStops++;
            }
        }

        if(!smooth && dlg.sameStartAndEnd.value){
            var thisStop = newGradient.gradientStops.add();
            thisStop.rampPoint = 100 - (interval*2);
            thisStop.color = colors[colors.length-1];
            allStops++;
            var thisStop = newGradient.gradientStops.add();
            thisStop.rampPoint = 99.9 - interval;
            thisStop.color = colors[colors.length-1];
            allStops++;
            var thisStop = newGradient.gradientStops.add();
            thisStop.rampPoint = 100 - interval;
            thisStop.color = colors[0];
            allStops++;
        }

        newGradient.gradientStops[0].rampPoint = 0.1;
        if(dlg.sameStartAndEnd.value)newGradient.gradientStops[allStops + 1].rampPoint = 99.9;
    }
}

function actionCanceled() { 
    run = false;
    dlg.hide();
}

function sliderChanged() { 
    dlg.alertBtnsPnl2.slide.value = Math.ceil(dlg.alertBtnsPnl2.slide.value);
    dlg.alertBtnsPnl2.titleEt.text = Math.ceil(dlg.alertBtnsPnl2.slide.value);
}

function eTextChanged() { 
    dlg.alertBtnsPnl2.titleEt.text = Math.ceil(dlg.alertBtnsPnl2.titleEt.text);
    dlg.alertBtnsPnl2.slide.value = Math.ceil(dlg.alertBtnsPnl2.titleEt.text);
}

Básicamente, funciona de la misma manera que la respuesta que vinculé, pero tiene un par de opciones adicionales:

Bueno, no usaría gradiente por completo. Primero cree un degradado como el que tiene, luego llene un lienzo con él y defina un patrón (editar> definir patrón). Entonces vas a la capa. nueva capa de relleno y elija el patrón. Puede usar la capa existente como máscara de recorte. Ahora, la "n" es "escala", por lo que 100% es 1, 50% es n = 2 y así sucesivamente. Cuanto menor sea la escala, más repetible será el patrón y el gradiente.

El segundo enfoque que tomaría es "paso y repetir". No sé dónde y cómo quieres usar este gradiente "ondulado" múltiple, pero el "S&R" es muy útil para multiplicar cosas en Photoshop. Simplemente presiona "ctrl (cmd) + alt + t" haz lo tuyo (escala, mueve, gira el objeto), presiona Enter y luego usa "shift + ctrl (cmd) + alt + t" y photoshop replicará lo que hiciste. Si gira, mueve y escala un objeto Ps lo hará tantas veces como pulse el acceso directo de repetición.

Aquí solo jugué con el segundo sobre más grande y luego repetí el paso.