इलस्ट्रेटर और फ़ोटोशॉप में कई बार एक ढाल कैसे दोहराएं?


12

एक ग्रेडिएंट 'एन' बार कैसे दोहराएं , उदाहरण के लिए, ब्लैक टू व्हाइट ग्रेडिएंट को 5 बार (स्ट्रोक के रास्ते के साथ) दोहराते हुए , जैसे मैंने नीचे उदाहरण छवि में मैन्युअल रूप से किया है।

वहाँ गुणा करने के लिए यह स्वचालित करने के लिए एक रास्ता है 'एन' , बार, 50 या 100 की तरह मैन्युअल रूप से ढाल स्लाइडर को कॉपी किए बिना?

धीरे-धीरे कई बार मैन्युअल रूप से दोहराया गया


विष्णु, क्या आपने इसे एक क्रिया में बदलने की कोशिश की है और इसे अपनी इच्छा के अनुसार अक्सर करने के लिए रिकॉर्ड किया है। कोई उपद्रव नहीं मुस।
सीन

जवाबों:


7

स्क्रिप्टिंग का उपयोग करें!

जैसा कि दूसरों ने उत्तर दिया है, आपको स्क्रिप्टिंग का उपयोग करना चाहिए। लेकिन यहां कुछ अन्य समाधान केवल RGB का उपयोग करते हैं, जबकि मेरा उपयोग उन रंगों का करता है जिन्हें आप अपने दस्तावेज़ से चुनते हैं। इसके अलावा कुछ समाधान रैपराउंड पॉइंट पर भी रंग उत्पन्न नहीं करते थे, या बहुत सारे और / या अतिव्यापी ढाल बंद हो गए थे, इसलिए मेरी स्क्रिप्ट इन मुद्दों को संबोधित करती है।

इसका उपयोग करने के लिए, ढाल के लिए इच्छित रंगों से भरे 2 या अधिक रास्तों का चयन करें, फिर जब संकेत दिया जाए कि ढाल को दोहराने के लिए कितनी बार दर्ज करें।

http://pastie.org/10924009

संपादित करें : पेस्टी साइट काम नहीं कर रही है, इसलिए मैंने नीचे कोड शामिल किया है:

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

उदाहरण 1: काले और सफेद, 6 बार दोहराता है, CMYK दस्तावेज़:

उदाहरण 1

उदाहरण 2: 3 रंग ढाल, 6 दोहराता है:

उदाहरण 2

उदाहरण 3: आरजीबी डॉक्टर, 6 रंग, 20 पुनरावृत्ति। ध्यान दें कि भरे हुए मार्ग कैसे अतिव्यापी हैं? वह स्टैकिंग ऑर्डर (आगे से पीछे) ढाल में रंगों के क्रम को निर्धारित करता है।

उदाहरण 3

ग्रेडिएंट में रंग बदलना : लागू किए गए ग्रेडिएंट के साथ एक पथ चुनें, फिर स्वैचेस पैनल फ्लाई-आउट मेनू चुनें → चयनित रंगों को जोड़ें। नए ग्लोबल स्वैचेस को स्वैचेस पैनल में जोड़ा जाएगा, और जब आप किसी को संपादित करते हैं, तो यह हर जगह अपडेट होता है।

उदाहरण 4


बहुत अच्छा। मुझे यह तथ्य पसंद है कि आपको चयन से रंग मिलते हैं। उस के बारे में सोचा नहीं था।
PieBie

बहुत बढ़िया! लेकिन paste.org लिंक काम नहीं कर रहा है। कृपया जाँच करें और अद्यतन करें।
विष्णु विगत

1
@ विष्णु: ऐसा लगता है जैसे पूरा पेस्ट्री सर्वर डाउन है। मैं अनुमान लगा रहा हूं कि आपको कुछ धैर्य की आवश्यकता होगी जब तक कि यह फिर से वापस नहीं आता है।
PieBie

6

आप इलस्ट्रेटर स्क्रिप्टिंग के साथ इसे प्राप्त कर सकते हैं। पृष्ठ 68 पर स्नातक के तहत जावास्क्रिप्ट संदर्भ पीडीएफ में CC15.3 के लिए प्रलेखन की जाँच करना

रंग बनाएँ:

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

ग्रेडिएंट बनाएँ:

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

एक रैखिक ढाल बनाएं:

newGradient.type = GradientType.LINEAR;  

या एक रेडियल ढाल बनाएँ:

newGradient.type = GradientType.RADIAL; 

जहाँ आप कई प्रकार के ग्रेडिएंट का निर्माण करना चाहेंगे 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;

मेरी क्षमायाचना, यह नोट किया गया था कि मैंने पूरी तरह से यह नहीं बताया कि आप एक ढाल n कैसे बना सकते हैं इसलिए मैंने एक संकेत और लूप को शामिल करने के लिए स्क्रिप्ट को और संशोधित किया।

कई बार कॉल करें:

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

एक लूप बनाएं और आगे चलकर ग्रेडिएंट की मात्रा जोड़ें:

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

शीर्ष पर लिंक से पृष्ठ 65-71 पर जो कुछ है, उसके ऊपर कोड:

1 बार के साथ उदाहरण:

यहाँ छवि विवरण दर्ज करें

5 बार के साथ उदाहरण:

यहाँ छवि विवरण दर्ज करें

आप lastStop.rampPoint - nसमायोजित करने के लिए संशोधित कर सकते हैं कि वे कहाँ हैं। उम्मीद है की यह मदद करेगा।


5

यह तभी काम करेगा जब आप ढाल का उपयोग एक स्ट्रोक के रूप में कर रहे हैं (जैसा कि आपके प्रश्न में है)। यदि आप धीरे-धीरे ढाल को दोहराना चाहते हैं (जैसा कि एक विशिष्ट संख्या में दोहराव के विपरीत है) तो आप चरण 2 और 3 को छोड़ सकते हैं और कला ब्रश के बजाय पैटर्न ब्रश का उपयोग कर सकते हैं। CC में अब आप ब्रश में छवियों का उपयोग कर सकते हैं ताकि आप इसे विस्तारित करने के बजाय ग्रेडिएंट को व्यवस्थित करने में सक्षम हो सकें लेकिन मैं CS6 का उपयोग कर रहा हूं इसलिए मैं इसका परीक्षण नहीं कर सकता।

  1. जिस ढाल को आप दोहराना चाहते हैं, उससे भरा हुआ एक आयत सेट करें।

यहाँ छवि विवरण दर्ज करें

  1. अपनी आयत को डुप्लिकेट करने के लिए एक ट्रांसफ़ॉर्मेशन इफ़ेक्ट ( Effect → Distort & Transform → Transform ... ) का उपयोग करें। अपनी आयत की चौड़ाई के लिए क्षैतिज चाल सेट करें और जितनी ज़रूरत हो उतनी प्रतियां सेट करें।

यहाँ छवि विवरण दर्ज करें

  1. परिवर्तन प्रभाव का विस्तार करें ( ऑब्जेक्ट → विस्तार सूरत )।

  2. आप ब्रश में ग्रेडिएंट्स का उपयोग नहीं कर सकते हैं, इसलिए आपको ग्रेडिएंट ( ऑब्जेक्ट → एक्सपैंड) का विस्तार करने की आवश्यकता होगी , "विस्तार ग्रेड टू" के तहत अपने विस्तार के लिए कई ऑब्जेक्ट चुनें।

    ग्रेडिएंट का विस्तार आपको विस्तारित ढाल में कुछ क्लिपिंग मास्क के साथ छोड़ देगा, आपको परतों के माध्यम से जाने और उन को हटाने की आवश्यकता होगी (या राइट क्लिक पर रखें और "अनग्रुप" तब तक "रिलीज क्लिपिंग मास्क" जब तक कि अधिक मास्क न हों)।

यहाँ छवि विवरण दर्ज करें

  1. अपने विस्तृत ग्रेडर को ब्रश पैनल पर खींचें और "आर्ट ब्रश" चुनें। आपके ब्रश के लिए डिफ़ॉल्ट विकल्प सबसे अधिक संभावना है, बस "ओके" मारा जाएगा। आप हमेशा वापस जा सकते हैं और बाद में ब्रश विकल्पों को समायोजित कर सकते हैं।

  2. अपना नया ब्रश लगायें।

यहाँ छवि विवरण दर्ज करें


5

इलस्ट्रेटर जेएस मैनुअल के आधार पर मैं नीचे दिए गए कोड के साथ आया हूं। यह कोड वही करता है जो आप चाहते हैं:

  • दो रंग स्टॉप के साथ एक ढाल बनाता है: काले और सफेद
  • इसे पांच बार दोहराते हैं
  • इसे सक्रिय (चयनित) तत्व के लिए एक स्ट्रोक के रूप में लागू करता है

लाइन के नीचे एक अधिक सामान्य संस्करण पाया जा सकता है।

यहाँ छवि विवरण दर्ज करें

(1) सबसे पहले हम रंगों की संख्या निर्धारित करते हैं और वांछित समय के अनुसार ढाल की आवश्यकता होती है:

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

(२) फिर हम बाद में उपयोग किए जाने वाले कुछ चर निर्धारित करते हैं। GradientIntervalप्रत्येक बिंदु को सेट करने के लिए आवश्यक प्रतिशत स्थिति की गणना करता है। totalNumberofStopsबहुत आत्म-व्याख्यात्मक है। colorsसरणी बाद में इस्तेमाल किया जाएगा।

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

(३) तब हम अपने रंगों को परिभाषित कर सकते हैं। आपको numberOfColorsशुरुआत में सेट के रूप में बिल्कुल कई रंगों की आवश्यकता होती है । लापता रंग काले रंग के लिए डिफ़ॉल्ट होंगे।

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

(४) हमारी ढाल बनाने और उसे नाम देने का समय। हम अब टाइप भी सेट कर सकते हैं।

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

(५) अब अच्छे हिस्से के लिए। पहले हम लूप करेंगे totalNumberOfStopsताकि हम प्रत्येक स्टॉप बना सकें और इसे ग्रेडिएंट में जोड़ सकें। हम एक नया स्टॉप बनाते हैं और इसे पिछले एक से आगे सेट करते हैं। अब हमें अपने रंग सरणी से सही रंग प्राप्त करने की आवश्यकता है। जब रंगों की संख्या से विभाजित लूप इंडेक्स का मापांक 0 होता है, तो हम जानते हैं कि हमारे पास हर रंग है और हमें फिर से शुरू करने की आवश्यकता है, इसलिए हम अपने रंग सूचकांक को रीसेट करते हैं।

उदाहरण कहो मुझे छह रंग मिले हैं जिन्हें मैं 5 बार लूप करना चाहता हूं। हमें तीस स्टॉप मिले हैं। हम सभी रंगों का उपयोग करके लूप करते हैं j। जब j6 हो जाते हैं तो अधिक रंग नहीं होते हैं (छह सरणी में सातवां रंग है लेकिन सरणी में केवल छह रंग हैं)। तो प्रत्येक छह में से कई हम फिर से शुरू करते हैं। 0. हम सिर्फ अगले रंग की ओर बढ़ते हैं।

अब हमें केवल अंतिम रंगीन स्टॉप को 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) अंतिम चरण: स्ट्रोक के लिए ढाल को लागू करना। किया हुआ। पार्टी!

//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) आपको मैन्युअल रूप से 'स्ट्रोक के साथ ग्रेडिएंट लागू करें' के लिए स्ट्रोक सेट करना पड़ सकता है, क्योंकि मुझे ऐसा करने के लिए कोड नहीं मिला है।

धीरे-धीरे स्ट्रोक


यह कोड विशेष रूप से आपके मामले के लिए बनाया गया था। एक अधिक सामान्य संस्करण यहां पाया जा सकता है: http://pastie.org/10921740

कुछ उदाहरण:

दो रंगों के साथ एक ढाल, दो बार दोहराते हुए: यहाँ छवि विवरण दर्ज करें

पांच रंगों के साथ एक ढाल, 10 बार दोहराते हुए: यहाँ छवि विवरण दर्ज करें

दो रंगों के साथ एक ढाल, 50 बार दोहराते हुए: यहाँ छवि विवरण दर्ज करें

50 बार दोहराए जाने वाले 50 रंगों के साथ एक तेज ढाल: यहाँ छवि विवरण दर्ज करें


यह स्क्रिप्ट अच्छी है, सिवाय इसके कि दो अतिरिक्त ग्रेडिएंट स्टॉप हैं - एक शुरुआत में और एक अंत में - जो कि ग्रेडिएंट को पूरी तरह से निर्बाध होने से रोकता है। जब आप एक ढाल बनाते हैं, तो डिफ़ॉल्ट रूप से दो स्टॉप होते हैं।
MG_

हां इलस्ट्रेटर हमेशा स्क्रिप्ट से जनरेट करते समय 100% पर एक रंग ठहराव जोड़ता है, भले ही आप एक निर्दिष्ट न करें। लेकिन यदि आप इसे निर्दिष्ट नहीं करते हैं, तो रंग काला हो गया है। मेरा काम शुरू करने वाले के साथ 100% पर एक अतिरिक्त रंग ठहराव जोड़ना था। यह सहज नहीं है, लेकिन यह सबसे अच्छा मैं साथ आ सकता है।
पाईबे

अरे नहीं, मैं अब देख रहा हूं, पेस्टी लिंक एक पुराना संस्करण है, मैं अपडेट करूंगा।
PieBie

0

मेरे पास एक ही मुद्दा था, और MG_ का वह जवाब सिर्फ वही था जिसकी मुझे जरूरत थी!

हालांकि, थोड़ी देर के बाद, मैंने देखा कि हर अब और फिर मुझे गैर-चिकनी ग्रेडिएंट भी चाहिए, और गैर-सहज ग्रेडिएंट भी। एक अच्छा समाधान खोजने के लिए यह थोड़ा दर्दनाक था, इसलिए मैं उसी मुद्दे के साथ दूसरों के लिए यहां संशोधित स्क्रिप्ट साझा कर रहा हूं। मैंने सब कुछ सेटअप करने के लिए सरल UI भी शामिल किया।

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

इसलिए मूल रूप से यह उसी तरह से काम करता है जैसा कि मैंने जो उत्तर दिया है, लेकिन इसमें कुछ अतिरिक्त विकल्प हैं: यहाँ छवि विवरण दर्ज करें


-3

खैर, मैं सभी तरह से ढाल का उपयोग नहीं करूंगा। पहले एक ढाल बनाएं जैसे आपके पास है, फिर उसके साथ एक कैनवास भरें और पैटर्न को परिभाषित करें (संपादित करें> परिभाषित पैटर्न)। फिर आप लेयर पर जाएं। नई भराव परत और पैटर्न चुनें। आप मौजूदा परत का उपयोग क्लिपिंग मास्क के रूप में कर सकते हैं। अब, "एन" "स्केल" है इसलिए 100% 1, 50% n = 2 और इसी तरह है। छोटे पैमाने पर अधिक दोहरावदार पैटर्न, और ढाल, बन जाएगा।

दूसरा तरीका जो मैं उठाऊंगा वह है "स्टेप एंड रिपीट"। मुझे नहीं पता कि आप इस मल्टीपल "वेवी" ग्रेडिएंट का उपयोग कहां और कैसे करना चाहते हैं लेकिन फोटोशॉप में चीजों को गुणा करने के लिए "एस एंड आर" बहुत उपयोगी है। बस "ctrl (cmd) + alt + t" को अपनी चीज़ (स्केल, मूव, रोटेट ऑब्जेक्ट), हिट एंटर करें, और फिर "Shift + ctrl (cmd) + alt + t" का उपयोग करें और फ़ोटोशॉप आपके द्वारा किए गए काम को दोहराएगा। यदि आप किसी ऑब्जेक्ट को घुमाते, घुमाते और स्केल करते हैं, तो Ps वही करेगा जो आप रिपीट शॉर्टकट को हिट करते हैं। यहाँ छवि विवरण दर्ज करें

यहां मैंने सिर्फ दूसरे सबसे बड़े लिफाफे के साथ खेला और फिर कदम को दोहराया।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.