Comment répéter plusieurs fois un dégradé dans Illustrator et Photoshop?

Comment répéter un dégradé 'n' fois, par exemple, répéter un dégradé noir à blanc 5 fois (le long du trajet du trait) comme je l'ai fait manuellement dans l'exemple ci-dessous.

Existe-t-il un moyen de l'automatiser pour multiplier 'n' fois, comme 50 ou 100, sans copier manuellement le curseur de dégradé?

Utilisez des scripts!

Comme d'autres l'ont répondu, vous devriez utiliser des scripts. Mais certaines des autres solutions ici n'utilisent que le RVB, tandis que la mienne utilise les couleurs que vous choisissez dans votre document. De plus, certaines solutions ne produisaient pas de couleur uniforme au point de bouclage, ou avaient trop d'arrêts de dégradé et / ou se chevauchaient, donc mon script résout ces problèmes.

Pour l'utiliser, sélectionnez 2 chemins ou plus remplis de couleurs destinées au dégradé, puis lorsque vous y êtes invité, entrez le nombre de fois pour répéter le dégradé.

http://pastie.org/10924009

Edit : le site de pastie ne fonctionne pas, j'ai donc inclus le code ci-dessous:

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

Exemple 1: noir et blanc, répété 6 fois, document CMJN:

Exemple 2: dégradé de 3 couleurs, 6 répétitions:

Exemple 3: doc RVB, 6 couleurs, 20 répétitions. Remarquez comment les chemins remplis se chevauchent? Cet ordre d'empilement (d'avant en arrière) détermine l'ordre des couleurs dans le dégradé.

Modification des couleurs dans le dégradé : sélectionnez un tracé auquel le dégradé est appliqué, puis choisissez le menu déroulant du panneau Nuancier → Ajouter les couleurs sélectionnées. De nouveaux échantillons globaux seront ajoutés au panneau d'échantillons et lorsque vous en modifiez un, il est mis à jour partout où il apparaît.

Vous pouvez y parvenir avec les scripts Illustrator. Vérification de la documentation de CC15.3 dans le PDF de référence JavaScript sous Gradients à la page 68.

Créez les couleurs:

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

Créez le dégradé:

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

Créez un dégradé linéaire:

newGradient.type = GradientType.LINEAR;  

ou Créez un dégradé radial:

newGradient.type = GradientType.RADIAL; 

L'endroit où vous souhaitez créer les différents types de dégradé se trouve dans 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;

Mes excuses, il a été noté que je n'ai pas entièrement expliqué comment vous pouvez créer un gradient n fois, j'ai donc modifié le script pour inclure une invite et une boucle.

Appelez le nombre de fois:

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

Créez une boucle et ajoutez en outre la quantité de dégradés:

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

Code au-dessus d'un mélange de ce qui est à la page 65-71 du lien en haut:

Exemple avec 1 fois:

Exemple avec 5 fois:

Vous pouvez modifier lastStop.rampPoint - npour ajuster où ils atterrissent. J'espère que cela t'aides.

Cela ne fonctionnera que si vous utilisez le dégradé comme trait (comme dans votre question). Si vous souhaitez répéter le dégradé à l'infini (par opposition à un nombre spécifique de répétitions), vous pouvez ignorer les étapes 2 et 3 et utiliser un pinceau à motifs au lieu d'un pinceau artistique. Dans CC, vous pouvez désormais utiliser des images dans des pinceaux afin que vous puissiez pixelliser le dégradé au lieu de le développer, mais j'utilise CS6, donc je ne peux pas tester cela.

1. Configurez un seul rectangle rempli du dégradé que vous souhaitez répéter.

2. Utilisez un effet de transformation ( Effet → Distorsion et transformation → Transformation ... ) pour dupliquer votre rectangle. Réglez le déplacement horizontal sur la largeur de votre rectangle et définissez autant de copies que vous le souhaitez.

3. Développez l'effet de transformation ( Objet → Agrandir l'apparence ).

4. Vous ne pouvez pas utiliser de dégradés dans les pinceaux, vous devrez donc étendre le dégradé ( Objet → Développer ), choisissez un certain nombre d'objets pour le développer sous "Développer le dégradé jusqu'à".

   L'élargissement du dégradé vous laissera quelques masques d'écrêtage dans le dégradé étendu, vous devrez parcourir les calques et les supprimer (ou continuer à faire un clic droit et "Dissocier" puis "Libérer le masque d'écrêtage" jusqu'à ce qu'il n'y ait plus de masques).

5. Faites glisser vos dégradés développés vers le panneau Pinceaux et sélectionnez "Pinceau artistique". Les options par défaut de votre pinceau seront très probablement correctes, appuyez simplement sur "OK". Vous pouvez toujours revenir en arrière et ajuster les options de pinceau ultérieurement.

6. Appliquez votre nouveau pinceau.

Sur la base du manuel Illustrator JS, j'ai trouvé le code ci-dessous. Ce code fait exactement ce que vous voulez:

• Crée un dégradé avec deux arrêts de couleur: noir et blanc
• Le répète cinq fois
• L'applique comme trait à l'élément actif (sélectionné)

Une version plus généraliste se trouve sous la ligne.

(1) Tout d'abord, nous définissons le nombre de couleurs souhaité et les temps souhaités pour que le dégradé soit itéré:

//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) Ensuite, nous avons défini certaines variables à utiliser plus tard. Le GradientIntervalcalcule la position en pourcentage sur laquelle chaque point doit être réglé. totalNumberofStopsest assez explicite. Le colorstableau sera utilisé ultérieurement.

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

(3) Ensuite, nous pouvons définir nos couleurs. Il vous faut exactement autant de couleurs que celles définies numberOfColorsau début. Les couleurs manquantes seront par défaut le noir.

//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) Il est temps de créer notre dégradé et de lui donner un nom. Nous pouvons également maintenant définir le type.

//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) Maintenant, pour la bonne partie. Nous allons d'abord parcourir le totalNumberOfStopsafin de pouvoir créer chaque arrêt et l'ajouter au dégradé. Nous créons un nouvel arrêt et le définissons un plus loin que le dernier. Maintenant, nous devons obtenir la bonne couleur de notre gamme de couleurs. Lorsque le module de l'index de boucle divisé par le nombre de couleurs est égal à 0, nous savons que nous avons eu toutes les couleurs et nous devons recommencer, nous réinitialisons donc notre indice de couleur.

Exemple Disons que j'ai six couleurs que je veux boucler 5 fois. Nous avons trente arrêts. Nous parcourons toutes les couleurs en utilisant j. Quand jdevient 6, il n'y a plus de couleurs (six est la septième couleur du tableau mais il n'y a que six couleurs dans le tableau). Donc, chaque multiple de six, nous recommençons à 0. Sinon, nous passons simplement à la couleur suivante.

Il ne nous reste plus qu'à ajouter la couleur finale à 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) Dernière étape: appliquer le dégradé au trait. Terminé. Fête!

//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) Vous devrez peut-être définir manuellement le trait sur «Appliquer le dégradé le long du trait», car je n'ai pas trouvé le code pour le faire.

Ce code a été spécialement conçu pour votre cas. Une version plus généraliste peut être trouvée ici: http://pastie.org/10921740

Quelques exemples:

Un dégradé à deux couleurs se répétant deux fois:

Un dégradé de cinq couleurs se répétant 10 fois:

Un dégradé à deux couleurs, répétant 50 fois:

Un dégradé énorme avec 50 couleurs se répétant 50 fois:

J'ai eu le même problème, et cette réponse de MG_ était exactement ce dont j'avais besoin!

Cependant, après un certain temps, j'ai remarqué que de temps en temps, j'ai également besoin de dégradés non lisses et de dégradés non continus. C'était un peu pénible de trouver une bonne solution, donc je partage le script modifié ici pour d'autres personnes ayant le même problème. J'ai également inclus une interface utilisateur simple pour tout configurer.

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

Donc, fondamentalement, cela fonctionne de la même manière que la réponse que j'ai liée, mais a quelques options supplémentaires:

Eh bien, je n'utiliserais pas le gradient complètement. Créez d'abord un dégradé comme celui que vous avez, puis remplissez un canevas avec celui-ci et définissez le motif (modifier> définir le motif). Ensuite, vous allez à Layer. nouveau calque de remplissage et choisissez le motif. Vous pouvez utiliser le calque existant comme masque d'écrêtage. Maintenant, le "n" est "échelle" donc 100% est 1, 50% est n = 2 et ainsi de suite. Plus l'échelle est petite, plus le motif et le dégradé seront reproductibles.

La deuxième approche que j'adopterais serait «répéter et répéter». Je ne sais pas où et comment vous souhaitez utiliser ce dégradé multiple "ondulé" mais le "S&R" est très pratique pour multiplier les choses dans photoshop. Appuyez simplement sur "ctrl (cmd) + alt + t", faites votre chose (redimensionner, déplacer, faire pivoter l'objet), appuyez sur Entrée, puis utilisez "shift + ctrl (cmd) + alt + t" et Photoshop répliquera ce que vous avez fait. Si vous faites pivoter, déplacez et redimensionnez un objet, Ps le fera autant de fois que vous appuyez sur le raccourci de répétition.

Ici, je viens de jouer avec la deuxième plus grande enveloppe, puis j'ai répété l'étape.