Como repetir um gradiente várias vezes no Illustrator e no Photoshop?

Como repetir um gradiente 'n' vezes, por exemplo, repetindo gradiente de preto para branco 5 vezes (ao longo do caminho do traçado), como fiz manualmente na imagem de exemplo abaixo.

Existe uma maneira de automatizá-lo para multiplicar 'n' vezes, como 50 ou 100, sem copiar manualmente o controle deslizante de gradiente?

Use scripts!

Como outras pessoas responderam, você deve usar scripts. Mas algumas das outras soluções aqui usam apenas RGB, enquanto as minhas usam cores que você escolhe no seu documento. Além disso, algumas soluções não produziram cores uniformes no ponto envolvente, ou tiveram muitas paradas de gradiente e / ou sobrepostas, portanto meu script aborda esses problemas.

Para usá-lo, selecione 2 ou mais caminhos preenchidos com cores destinadas ao gradiente e, quando solicitado, digite o número de vezes para repetir o gradiente.

http://pastie.org/10924009

Edit : site pastie não funciona, por isso incluí o código abaixo:

// 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;
}

Exemplo 1: preto e branco, repete 6 vezes, documento CMYK:

Exemplo 2: gradiente de 3 cores, 6 repetições:

Exemplo 3: documento RGB, 6 cores, 20 repetições. Observe como os caminhos preenchidos estão sobrepostos? Essa ordem de empilhamento (da frente para trás) determina a ordem das cores no gradiente.

Alteração de cores no gradiente : selecione um caminho com o gradiente aplicado e escolha o menu suspenso Painel de amostras → Adicionar cores selecionadas. Novas amostras globais serão adicionadas ao painel de amostras e, quando você editar uma, ela será atualizada em todos os lugares em que aparecer.

Você pode conseguir isso com scripts do Illustrator. Verificando a documentação do CC15.3 no PDF de referência do JavaScript em Gradientes na página 68.

Crie as cores:

// 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;  

Crie o gradiente:

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

Crie um gradiente linear:

newGradient.type = GradientType.LINEAR;  

ou Crie um gradiente radial:

newGradient.type = GradientType.RADIAL; 

Onde você deseja criar os vários tipos de gradiente seria 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;

Minhas desculpas, notei que não expliquei completamente como você pode criar um gradiente n vezes, então modifiquei ainda mais o script para incluir um prompt e um loop.

Ligue para o número de vezes:

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

Crie um loop e adicione ainda a quantidade 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;
}

Código acima de uma mistura do que está na página 65-71 no link na parte superior:

Exemplo com 1 vez:

Exemplo com 5 vezes:

Você pode modificar lastStop.rampPoint - npara ajustar onde eles pousam. Espero que isto ajude.

Isso só funcionará se você estiver usando o gradiente como um derrame (como na sua pergunta). Se você deseja repetir o gradiente indefinidamente (em oposição a um número específico de repetições), pule as etapas 2 e 3 e use um pincel de padrão em vez de um pincel de arte. No CC, agora você pode usar imagens em pincéis para poder rasterizar o gradiente em vez de expandi-lo, mas estou usando o CS6, portanto não posso testar isso.

1. Configure um único retângulo preenchido com o gradiente que você deseja repetir.

2. Use um efeito de transformação ( Efeito → Distorcer e transformar → Transformar ... ) para duplicar seu retângulo. Defina a movimentação horizontal para a largura do seu retângulo e defina quantas cópias você precisar.

3. Expanda o efeito de transformação ( Objeto → Expandir Aparência ).

4. Você não pode usar gradientes nos pincéis; portanto, você precisará expandir o gradiente ( Objeto → Expandir ). Escolha um número de objetos para expandir em "Expandir gradiente para".

   Ao expandir o gradiente, você terá algumas máscaras de recorte no gradiente expandido. Você precisará percorrer as camadas e excluí-las (ou clique com o botão direito do mouse e em "Desagrupar" e depois "Liberar máscara de recorte" até não haver mais máscaras).

5. Arraste seus gradientes expandidos para o painel Pincéis e selecione "Pincel artístico". As opções padrão para o seu pincel provavelmente estarão ok, então clique em "OK". Você sempre pode voltar e ajustar as opções de pincel posteriormente.

6. Aplique seu novo pincel.

Baseado no manual do Illustrator JS, criei o código abaixo. Este código faz exatamente o que você deseja:

• Cria um gradiente com duas paradas de cores: preto e branco
• Repete cinco vezes
• Aplica-o como um traçado ao elemento ativo (selecionado)

Uma versão mais geral pode ser encontrada abaixo da linha.

(1) Primeiro, definimos o número desejado de cores e os tempos desejados para que o gradiente precise 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) Em seguida, definimos algumas variáveis ​​para serem usadas posteriormente. O GradientIntervalcalcula a posição percentual em que cada ponto precisa ser definido. totalNumberofStopsé bastante auto-explicativo. A colorsmatriz será usada posteriormente.

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

(3) Então podemos definir nossas cores. Você precisa exatamente do número de cores definido no numberOfColorsinício. As cores ausentes serão padronizadas para preto.

//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 criar nosso gradiente e dar um nome a ele. Agora também podemos definir o 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) Agora, para a parte boa. Primeiro, percorreremos o loop totalNumberOfStopspara que possamos criar cada parada e adicioná-la ao gradiente. Criamos uma nova parada e a definimos mais uma que a última. Agora precisamos obter a cor certa da nossa matriz de cores. Quando o módulo do índice de loop dividido pelo número de cores é 0, sabemos que tivemos todas as cores e precisamos começar novamente, por isso redefinimos nosso índice de cores.

Exemplo Digamos que tenho seis cores que quero repetir 5 vezes. Temos trinta paradas. Passamos por todas as cores usando j. Quando jse torna 6, não há mais cores (seis é a sétima cor na matriz, mas existem apenas seis cores na matriz). Portanto, cada múltiplo de seis começa novamente em 0. Caso contrário, passamos para a próxima cor.

Agora só precisamos adicionar a parada final da cor em 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) A etapa final: aplicar o gradiente ao golpe. Feito. Festa!

//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) Talvez você precise definir o traçado para 'Aplicar gradiente ao longo do traçado' manualmente, porque não encontrei o código para fazer isso.

Este código foi feito especificamente para o seu caso. Uma versão mais generalista pode ser encontrada aqui: http://pastie.org/10921740

Alguns exemplos:

Um gradiente com duas cores, repetindo duas vezes:

Um gradiente com cinco cores, repetindo 10 vezes:

Um gradiente com duas cores, repetindo 50 vezes:

Um gradiente impressionante com 50 cores repetindo 50 vezes:

Eu tive o mesmo problema, e essa resposta de MG_ era exatamente o que eu precisava!

No entanto, depois de um tempo, notei que de vez em quando eu também preciso de gradientes não suaves e também não gradientes. Foi um pouco doloroso encontrar uma boa solução, por isso estou compartilhando o script modificado aqui para outras pessoas com o mesmo problema. Eu também incluí uma interface simples para configurar tudo.

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);
}

Então, basicamente, funciona da mesma maneira que a resposta que eu vinculei, mas tem algumas opções extras:

Bem, eu não usaria gradiente até o fim. Primeiro, crie um gradiente como o que você possui, depois preencha uma tela e defina o padrão (editar> definir padrão). Então você vai para a camada. nova camada de preenchimento e escolha o padrão. Você pode usar a camada existente como uma máscara de corte. Agora, o "n" é "escala", então 100% é 1, 50% é n = 2 e assim por diante. Quanto menor a escala, mais repetível o padrão e o gradiente se tornarão.

A segunda abordagem que eu adotaria é "pise e repita". Não sei onde e como você deseja usar esse gradiente "ondulado" múltiplo, mas o "S&R" é muito útil para multiplicar as coisas no photoshop. Basta pressionar "ctrl (cmd) + alt + t", faça o que quiser (dimensionar, mover, girar objeto), pressione Enter e, em seguida, use "shift + ctrl (cmd) + alt + t" e o photoshop replicará o que você fez. Se você girar, mova e dimensione um objeto Ps fará isso quantas vezes você pressionar o atalho de repetição.

Aqui eu apenas toquei com o segundo maior envelope e depois repeti o passo.