दिलचस्प पोस्ट
एक IntentService में बनाया टोस्ट कभी दूर चला जाता है Asp.net 5 में विंडोज प्रमाणीकरण स्क्रॉलटॉप के बाद तय की गई बटन पर मोबाइल सफारी बग प्रोग्रामैटिक रूप से बदल गया …? जावास्क्रिप्ट: विशिष्ट समय अवधि के बाद फ़ंक्शन बुलाएं प्रत्येक बार जब कोई सेल मिलता है, तो मैं एक वीबीए कोड कैसे चला सकता हूं, जो सूत्र से बदल जाता है? Cx_freeze का उपयोग करते समय मैं अन्य फ़ाइलों को कैसे बंडल कर सकता हूं? सूची से बहु-आयामी सरणी कैसे बनाएं? कैसे बूटस्ट्रैप बटन ड्रॉपडाउन शीर्षक में चयनित आइटम प्रदर्शित करने के लिए मौजूदा सारणी में स्वत: वृद्धि प्राथमिक कुंजी डालें एक्लिप्स डीबगिंग "स्रोत नहीं मिला" सी # WPF में, क्यों मेरे TabControl की चयन चेंजेड घटना भी अक्सर फायरिंग है? मैं कमांड लाइन पर कितने मूल्यों को कैसे पारित कर सकता हूं – तर्क के रूप में एक अभिव्यक्ति को पारित करना एक नया मैक ओएस एक्स टर्मिनल विंडो में एक कमांड चलाने यूनिट परीक्षण के लिए आईओसी का उपयोग करना माइक्रोसॉफ्ट रोसेन बनाम कोडडॉम

आरजीबी मान के लिए Additive रंग मिश्रण के लिए एल्गोरिदम

मैं आरजीबी मूल्यों के लिए मिश्रित रंग मिश्रण करने के लिए एक एल्गोरिथ्म की तलाश कर रहा हूँ।

क्या यह आरजीबी मूल्यों को एक साथ अधिकतम 256 जोड़कर जोड़ना आसान है?

(r1, g1, b1) + (r2, g2, b2) = (min(r1+r2, 256), min(g1+g2, 256), min(b1+b2, 256)) 

Solutions Collecting From Web of "आरजीबी मान के लिए Additive रंग मिश्रण के लिए एल्गोरिदम"

यह आपकी इच्छानुसार निर्भर करता है, और यह देखने में मदद कर सकता है कि परिणाम विभिन्न तरीकों के हैं।

अगर तुम चाहते हो

 लाल + काला = लाल
 लाल + हरा = पीला
 लाल + हरा + ब्लू = व्हाइट
 लाल + सफेद = सफेद 
 ब्लैक + व्हाइट = व्हाइट

फिर एक दबाना कार्यों के साथ जोड़ना (जैसे min(r1 + r2, 255) ) यह आपके द्वारा उल्लिखित प्रकाश मॉडल की तरह अधिक है

अगर तुम चाहते हो

 लाल + काले = अंधेरे लाल
 लाल + हरा = डार्क पीला
 लाल + हरा + नीला = डार्क ग्रे
 लाल + सफेद = गुलाबी
 काला + सफेद = ग्रे

तो आपको मूल्यों को औसत करना होगा (उदाहरण के लिए (r1 + r2) / 2 ) यह हल्के / काले रंग के रंगों के लिए और बेहतर बनाने के लिए काम करता है।

अल्फा चैनल का उपयोग करने के लिए, आप इन फ़ार्मुलों का उपयोग कर सकते हैं:

 r = new Color(); rA = 1 - (1 - fg.A) * (1 - bg.A); if (rA < 1.0e-6) return r; // Fully transparent -- R,G,B not important rR = fg.R * fg.A / rA + bg.R * bg.A * (1 - fg.A) / rA; rG = fg.G * fg.A / rA + bg.G * bg.A * (1 - fg.A) / rA; rB = fg.B * fg.A / rA + bg.B * bg.A * (1 - fg.A) / rA; 

fg रंग का रंग है bg पृष्ठभूमि है r परिणामस्वरूप रंग है 1.0e-6 केवल एक बहुत ही छोटी संख्या है, जिससे गोल त्रुटियों की भरपाई हो सकती है।

नोट: यहां इस्तेमाल किए गए सभी चर [0.0, 1.0] में हैं। यदि आपको [0, 255] श्रेणी में मानों का उपयोग करना है, तो आपको 255 से विभाजित या गुणा करना होगा

उदाहरण के लिए, 50% हरे रंग के ऊपर 50% लाल:

 // background, 50% green var bg = new Color { R = 0.00, G = 1.00, B = 0.00, A = 0.50 }; // paint, 50% red var fg = new Color { R = 1.00, G = 0.00, B = 0.00, A = 0.50 }; // The result var r = new Color(); rA = 1 - (1 - fg.A) * (1 - bg.A); // 0.75 rR = fg.R * fg.A / rA + bg.R * bg.A * (1 - fg.A) / rA; // 0.67 rG = fg.G * fg.A / rA + bg.G * bg.A * (1 - fg.A) / rA; // 0.33 rB = fg.B * fg.A / rA + bg.B * bg.A * (1 - fg.A) / rA; // 0.00 

परिणामस्वरूप रंग है: (0.67, 0.33, 0.00, 0.75) , या 75% भूरा (या अंधेरे नारंगी)।


आप इन फ़ार्मुलों को भी उलटा सकते हैं:

 var bg = new Color(); if (1 - fg.A <= 1.0e-6) return null; // No result -- 'fg' is fully opaque if (rA - fg.A < -1.0e-6) return null; // No result -- 'fg' can't make the result more transparent if (rA - fg.A < 1.0e-6) return bg; // Fully transparent -- R,G,B not important bg.A = 1 - (1 - rA) / (1 - fg.A); bg.R = (rR * rA - fg.R * fg.A) / (bg.A * (1 - fg.A)); bg.G = (rG * rA - fg.G * fg.A) / (bg.A * (1 - fg.A)); bg.B = (rB * rA - fg.B * fg.A) / (bg.A * (1 - fg.A)); 

या

 var fg = new Color(); if (1 - bg.A <= 1.0e-6) return null; // No result -- 'bg' is fully opaque if (rA - bg.A < -1.0e-6) return null; // No result -- 'bg' can't make the result more transparent if (rA - bg.A < 1.0e-6) return bg; // Fully transparent -- R,G,B not important fg.A = 1 - (1 - rA) / (1 - bg.A); fg.R = (rR * rA - bg.R * bg.A * (1 - fg.A)) / fg.A; fg.G = (rG * rA - bg.G * bg.A * (1 - fg.A)) / fg.A; fg.B = (rB * rA - bg.B * bg.A * (1 - fg.A)) / fg.A; 

सूत्रों को उस पृष्ठभूमि या रंग के रंग की गणना करने के लिए दिए जाने वाले रंग का उत्पादन करना होगा।


यदि आपकी पृष्ठभूमि अपारदर्शी है, तो परिणाम भी अपारदर्शी होगा। अग्रभूमि का रंग तब भिन्न अल्फा मूल्यों के साथ कई मान ले सकता था प्रत्येक चैनल (लाल, हरा और नीला) के लिए, आपको वैध मूल्य (0 – 1) में कौन सी सीमा का अल्फा परिणाम दिखाना होगा।

मजेदार तथ्य: कंप्यूटर आरजीबी मूल्य फोटोन फ्लक्स के वर्गमूल से प्राप्त किए जाते हैं। तो एक सामान्य कार्य के रूप में, आपके गणित को उस खाते को ध्यान में रखना चाहिए। किसी दिए गए चैनल के लिए इसके लिए सामान्य कार्य है:

 blendColorValue(a, b, t) return sqrt((1 - t) * a^2 + t * b^2) 

जहां ए और बी मिश्रण करने के लिए रंग हैं, और टी 0-1 से एक नंबर है, जो कि आप को एक और बी के बीच मिश्रण के बिंदु में दर्शाता है।

अल्फा चैनल अलग है; यह फोटान की तीव्रता का प्रतिनिधित्व नहीं करता है, केवल पृष्ठभूमि का प्रतिशत जो कि इसके माध्यम से दिखना चाहिए; इसलिए जब अल्फा मूल्यों का मिश्रण होता है, तो रैखिक औसत पर्याप्त होता है:

 blendAlphaValue(a, b, t) return (1-t)*a + t*b; 

इसलिए, दो रंगों को सम्मिलित करने के लिए, उन दो कार्यों का उपयोग करने के लिए, निम्नलिखित स्यूडोकोड आपको अच्छा करना चाहिए:

 blendColors(c1, c2, t) ret [r, g, b].each n -> ret[n] = blendColorValue(c1[n], c2[n], t) ret.alpha = blendAlphaValue(c1.alpha, c2.alpha, t) return ret 

संयोग से, मैं एक प्रोग्रामिंग भाषा और कीबोर्ड के लिए लंबे समय से दोनों गणित का प्रतिनिधित्व करने के लिए अनुमति देता है जो कि (या अधिक) स्वच्छ रूप से (ओवरलाइन यूनिकोड वर्ण को जोड़कर अतिलेख, प्रतीक, और अन्य वर्णों की एक विशाल सरणी के लिए काम नहीं करता है) और इसे सही ढंग से व्याख्या करना sqrt ((1-टी) * पाउ (ए, 2) + टी * पाउ (बी, 2)) बस के रूप में साफ नहीं पढ़ा है

कुछ बिंदु:

  • मुझे लगता है कि आप अधिकतम के बजाय न्यूनतम उपयोग करना चाहते हैं I
  • मुझे लगता है कि आप 256 के बजाय 255 का उपयोग करना चाहते हैं

यह देगा:

(आर 1, जी 1, बी 1) + (आर 2, जी 2, बी 2) = (न्यूनतम (आर 1 + आर 2, 255), मिनट (जी -1 + जी 2, 255), न्यूनतम (बी 1 + बी 2, 255))

हालांकि, मिश्रण रंगों का "प्राकृतिक" तरीका औसत का उपयोग करना है, और फिर आपको न्यूनतम आवश्यकता नहीं है:

(आर 1, जी 1, बी 1) + (आर 2, जी 2, बी 2) = ((आर 1 + आर 2) / 2, (जी -1 + जी 2) / 2, (बी 1 + बी 2) / 2)

आरजीबीए रंग मिश्रण करने के लिए जावास्क्रिप्ट फ़ंक्शन

c1, c2 और परिणाम – JSON की तरह सी 1 = {r: 0.5, g: 1, b: 0, a: 0.33}

  var rgbaSum = function(c1, c2){ var a = c1.a + c2.a*(1-c1.a); return { r: (c1.r * c1.a + c2.r * c2.a * (1 - c1.a)) / a, g: (c1.g * c1.a + c2.g * c2.a * (1 - c1.a)) / a, b: (c1.b * c1.a + c2.b * c2.a * (1 - c1.a)) / a, a: a } } 

हां, यह उतना आसान है जितना कि एक और विकल्प औसत (ग्रेडियेंट बनाने के लिए) खोजने के लिए है

यह वास्तव में केवल उस प्रभाव पर निर्भर करता है जिसे आप प्राप्त करना चाहते हैं

हालांकि, जब अल्फा जोड़ा जाता है, तो यह जटिल हो जाता है। एक अल्फा का उपयोग करने के लिए कई अलग-अलग विधियां हैं

सरल अल्फा मिश्रण का एक उदाहरण: http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending

पीयाथोन रंग सीएमवाइक स्पेस में इसके अलावा मिलाकर

ऐसा करने का एक संभावित तरीका पहले रंगों को सीएमवाइके प्रारूप में रूपांतरित करना है, उन्हें वहां जोड़ें और फिर आरजीबी को फिर से खोजें।

पायथन में यहां एक उदाहरण कोड है:

 rgb_scale = 255 cmyk_scale = 100 def rgb_to_cmyk(self,r,g,b): if (r == 0) and (g == 0) and (b == 0): # black return 0, 0, 0, cmyk_scale # rgb [0,255] -> cmy [0,1] c = 1 - r / float(rgb_scale) m = 1 - g / float(rgb_scale) y = 1 - b / float(rgb_scale) # extract out k [0,1] min_cmy = min(c, m, y) c = (c - min_cmy) m = (m - min_cmy) y = (y - min_cmy) k = min_cmy # rescale to the range [0,cmyk_scale] return c*cmyk_scale, m*cmyk_scale, y*cmyk_scale, k*cmyk_scale def cmyk_to_rgb(self,c,m,y,k): """ """ r = rgb_scale*(1.0-(c+k)/float(cmyk_scale)) g = rgb_scale*(1.0-(m+k)/float(cmyk_scale)) b = rgb_scale*(1.0-(y+k)/float(cmyk_scale)) return r,g,b def ink_add_for_rgb(self,list_of_colours): """input: list of rgb, opacity (r,g,b,o) colours to be added, o acts as weights. output (r,g,b) """ C = 0 M = 0 Y = 0 K = 0 for (r,g,b,o) in list_of_colours: c,m,y,k = rgb_to_cmyk(r, g, b) C+= o*c M+=o*m Y+=o*y K+=o*k return cmyk_to_rgb(C, M, Y, K) 

आपके प्रश्न का नतीजा तब होगा (अपने दो रंगों का आधा-आधा मिश्रण:

 r_mix, g_mix, b_mix = ink_add_for_rgb([(r1,g1,b1,0.5),(r2,g2,b2,0.5)]) 

जहां 0.5 का कहना है कि हम पहले रंग के 50% को दूसरे रंग के 50% के साथ मिश्रण करते हैं।

फ़ंक्शन और मैक्रो प्रारूप दोनों में एक अत्यधिक अनुकूलित, स्टैंडअलोन सी ++ क्लास, पब्लिक डोमेन, फ्लोटिंग प्वाइंट और दो अलग-अलग अनुकूलित 8-बिट सम्मिश्रण तंत्र के साथ-साथ दोनों समस्याओं का तकनीकी चर्चा और हाथ में और कैसे, और महत्व की, इस समस्या का अनुकूलन:

https://github.com/fyngyrz/colorblending