Jak powtórzyć gradient wiele razy w programach Illustrator i Photoshop?

Jak powtórzyć gradient „n” razy, na przykład, powtarzając gradient czarno-biały 5 razy (wzdłuż ścieżki obrysu), jak zrobiłem ręcznie na poniższym przykładowym obrazie.

Czy istnieje sposób na zautomatyzowanie go w celu pomnożenia „n” razy, np. 50 lub 100, bez ręcznego kopiowania suwaka gradientu?

Użyj skryptów!

Jak inni odpowiedzieli, powinieneś użyć skryptów. Ale niektóre inne rozwiązania tutaj wykorzystują tylko RGB, podczas gdy moje używają kolorów wybranych z dokumentu. Również niektóre rozwiązania nie wytwarzały równomiernego koloru w punkcie owijania, lub miały zbyt wiele i / lub nakładające się stopnie gradientu, więc mój skrypt rozwiązuje te problemy.

Aby z niego skorzystać, wybierz 2 lub więcej ścieżek wypełnionych kolorami przeznaczonymi dla gradientu, a następnie po wyświetleniu monitu wprowadź liczbę powtórzeń gradientu.

http://pastie.org/10924009

Edycja : witryna pastie nie działa, więc dołączyłem poniższy kod:

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

Przykład 1: czarno-biały, powtarza się 6 razy, dokument CMYK:

Przykład 2: 3-kolorowy gradient, 6 powtórzeń:

Przykład 3: Dokument RGB, 6 kolorów, 20 powtórzeń. Zauważ, w jaki sposób wypełnione ścieżki nakładają się na siebie? Ta kolejność układania (od przodu do tyłu) określa kolejność kolorów w gradiencie.

Zmienianie kolorów w gradiencie : Wybierz ścieżkę z zastosowanym gradientem, a następnie wybierz menu wysuwane Panel próbek → Dodaj wybrane kolory. Nowe globalne próbki zostaną dodane do panelu próbek, a kiedy je edytujesz, jest ono aktualizowane wszędzie, gdzie się pojawi.

Możesz to osiągnąć za pomocą skryptów programu Illustrator. Sprawdzanie dokumentacji dla CC15.3 w PDF Reference JavaScript w Gradienty na stronie 68.

Utwórz kolory:

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

Utwórz gradient:

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

Utwórz gradient liniowy:

newGradient.type = GradientType.LINEAR;  

lub Utwórz gradient radialny:

newGradient.type = GradientType.RADIAL; 

W miejscu, w którym chcesz zbudować wiele typów gradientu, znajdziesz 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;

Przepraszam, zauważono, że nie w pełni wyjaśniłem, w jaki sposób można utworzyć gradient n razy, więc zmodyfikowałem skrypt tak, aby zawierał monit i pętlę.

Zadzwoń ile razy:

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

Utwórz pętlę i dodaj liczbę gradientów:

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

Kod powyżej mieszanki tego, co jest na stronie 65-71 z linku u góry:

Przykład z 1 czasem:

Przykład z 5 razy:

Możesz zmodyfikować, lastStop.rampPoint - naby dostosować miejsce wylądowania. Mam nadzieję że to pomoże.

Działa to tylko wtedy, gdy używasz gradientu jako obrysu (jak w pytaniu). Jeśli chcesz powtarzać gradient bez końca (w przeciwieństwie do określonej liczby powtórzeń), możesz pominąć kroki 2 i 3 i użyć pędzla wzorowego zamiast pędzla artystycznego. W CC możesz teraz używać obrazów w pędzlach, więc możesz zrasteryzować gradient zamiast go powiększać, ale używam CS6, więc nie mogę tego przetestować.

1. Ustaw pojedynczy prostokąt wypełniony gradientem, który chcesz powtórzyć.

2. Użyj efektu przekształcenia ( Efekt → Zniekształć i przekształć → Przekształć ... ), aby powielić prostokąt. Ustaw ruch poziomy na szerokość prostokąta i ustaw tyle kopii, ile potrzebujesz.

3. Rozwiń efekt przekształcenia ( Obiekt → Rozwiń wygląd ).

4. Nie możesz używać gradientów w pędzlach, więc musisz rozwinąć gradient ( Obiekt → Rozwiń ), wybierz liczbę obiektów do rozwinięcia w obszarze „Rozwiń gradient do”.

   Po rozwinięciu gradientu pozostanie Ci kilka masek przycinających w rozwiniętym gradiencie, musisz przejść przez warstwy i usunąć je (lub przytrzymać prawy przycisk myszy i „Rozgrupuj”, a następnie „Zwolnij maskę przycinającą”, aż nie będzie już żadnych masek).

5. Przeciągnij rozwinięte gradienty do panelu Pędzle i wybierz „Pędzel artystyczny”. Domyślne opcje pędzla najprawdopodobniej będą w porządku, więc po prostu naciśnij „OK”. Zawsze możesz wrócić i dostosować opcje pędzla później.

6. Zastosuj swój nowy pędzel.

Na podstawie instrukcji JS programu Illustrator opracowałem poniższy kod. Ten kod robi dokładnie to, co chcesz:

• Tworzy gradient z dwoma punktami przejścia koloru: czarnym i białym
• Powtarza to pięć razy
• Stosuje go jako obrys do aktywnego (wybranego) elementu

Bardziej ogólną wersję można znaleźć poniżej linii.

(1) Najpierw ustawiamy pożądaną liczbę kolorów i żądane czasy iteracji gradientu:

//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) Następnie ustawiamy niektóre zmienne do późniejszego użycia. GradientIntervalOblicza pozycję procentowy co wymaga punktu do ustawienia na. totalNumberofStopsjest dość oczywiste. colorsTablica będzie później wykorzystane.

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

(3) Następnie możemy zdefiniować nasze kolory. Potrzebujesz dokładnie tyle kolorów, ile ustawiono numberOfColorsna początku. Brakujące kolory będą domyślnie czarne.

//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) Czas stworzyć nasz gradient i nadać mu nazwę. Możemy również teraz ustawić typ.

//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) Teraz dobra część. Najpierw zapętlimy nad totalNumberOfStops, abyśmy mogli utworzyć każdy przystanek i dodać go do gradientu. Tworzymy nowy przystanek i ustawiamy go o jeden krok dalej niż ostatni. Teraz musimy uzyskać odpowiedni kolor z naszej palety kolorów. Kiedy moduł indeksu pętli podzielony przez liczbę kolorów wynosi 0, wiemy, że mieliśmy każdy kolor i musimy zacząć od nowa, więc resetujemy nasz indeks kolorów.

Przykład Powiedz, że mam sześć kolorów, które chcę zapętlić 5 razy. Mamy trzydzieści przystanków. Używamy pętli nad wszystkimi kolorami j. Kiedy jstaje się 6, nie ma już kolorów (sześć to siódmy kolor w tablicy, ale jest tylko sześć kolorów w tablicy). Tak więc każda wielokrotność szóstki zaczynamy od 0. W przeciwnym razie przechodzimy do następnego koloru.

Teraz musimy tylko dodać końcowy kolor do 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) Ostatni krok: zastosowanie gradientu do obrysu. Gotowy. Przyjęcie!

//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) Może być konieczne ręczne ustawienie obrysu „Zastosuj gradient wzdłuż obrysu”, ponieważ nie znalazłem kodu, aby to zrobić.

Ten kod został stworzony specjalnie dla twojego przypadku. Bardziej ogólną wersję można znaleźć tutaj: http://pastie.org/10921740

Kilka przykładów:

Gradient w dwóch kolorach, powtarzany dwukrotnie:

Gradient w pięciu kolorach, powtarzany 10 razy:

Gradient w dwóch kolorach, powtarzający się 50 razy:

Ogromny gradient z 50 kolorami powtarzającymi się 50 razy:

Miałem ten sam problem, a odpowiedź MG_ była dokładnie tym, czego potrzebowałem!

Jednak po pewnym czasie zauważyłem, że od czasu do czasu potrzebuję również nieładnych gradientów, a także nie płynnych gradientów. Znalezienie dobrego rozwiązania było trochę bolesne, dlatego udostępniam zmodyfikowany skrypt innym osobom z tym samym problemem. Dołączyłem również prosty interfejs użytkownika, aby wszystko skonfigurować.

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

Zasadniczo działa tak samo jak odpowiedź, którą podałem, ale ma kilka dodatkowych opcji:

Cóż, nie użyłbym gradientu do końca. Najpierw utwórz gradient podobny do tego, który masz, a następnie wypełnij go płótnem i zdefiniuj wzór (edycja> zdefiniuj wzór). Następnie przejdź do warstwy. nowa warstwa wypełnienia i wybierz wzór. Możesz użyć istniejącej warstwy jako maski przycinającej. Teraz „n” jest „skalą”, więc 100% to 1, 50% to n = 2 i tak dalej. Im mniejsza skala, tym bardziej powtarzalny będzie wzór i gradient.

Drugie podejście, które wybrałbym to „krok i powtórz”. Nie wiem, gdzie i jak chcesz użyć tego wielokrotnego „falistego” gradientu, ale „S&R” jest bardzo przydatny do mnożenia rzeczy w Photoshopie. Po prostu wciśnij „ctrl (cmd) + alt + t” i zrób coś (skaluj, przesuń, obróć obiekt), naciśnij Enter, a następnie użyj „shift + ctrl (cmd) + alt + t”, a Photoshop powtórzy to, co zrobiłeś. Jeśli obracasz, przesuwasz i skalujesz obiekt Ps zrobi to tyle razy, ile naciśniesz skrót powtarzania.

Tutaj właśnie grałem drugą największą kopertą, a następnie powtórzyłem krok.