सी # के साथ रंग के रूप में तापमान प्रदर्शित करें?

Question

कोई व्यक्ति एल्गोरिदम जानता है जो केल्विन/सेल्सियस में समशीतोष्ण हो जाता है और आरजीबी देता है?

थर्मल कैमरों की तरह।

http://www.brucelindbloom.com/index.html?Eqn_XYZ_to_T.html

http://www.fourmilab.ch/documents/specrend/specrend.c

लेकिन मैं समझ नहीं कर सकते क्या XYZ रंग है:

मैं कुछ लिंक नहीं मिला?

.. मैं केवल सेल्सियस में तापमान है

मैं किसी भी तापमान के लिए Temperature Conversion Formulas

अद्यतन रूपांतरित कर सकते हैं: Blackbody Color Datafile मैं पाया है यह .. लेकिन उन केल्विन डिग्री असंभव हैं .. मेरा मतलब है लाल गर्म होने का मानना ​​है .. तो क्यों 8000k नीला है और 1000k लाल है ...

Answer 1

सबसे अच्छा विकल्प GetPixel वाली छवि का उपयोग करने के लिए है:

private void UpdateTemp() 
{ 
    Bitmap temps = (Bitmap)Properties.Resources.temp; 
    if (curTemp >= 0) 
    { 
     int i = curTemp; 
     if (i < 0) 
      i = 0; 
     if (i > temps.Width-1) 
      i = temps.Width-1; 
     this.BackColor = temps.GetPixel(i, 10); 
    } 
} 

या एक सरणी के निर्माण। Source

private static Color[] colors = 
    { 
     Color.FromArgb(155, 188, 255), // 40000 
     Color.FromArgb(155, 188, 255), // 39500 
     Color.FromArgb(155, 188, 255), // 39000 
     Color.FromArgb(155, 188, 255), // 38500 
     Color.FromArgb(156, 188, 255), // 38000 
     Color.FromArgb(156, 188, 255), // 37500 
     Color.FromArgb(156, 189, 255), // 37000 
     Color.FromArgb(156, 189, 255), // 36500 
     Color.FromArgb(156, 189, 255), // 36000 
     Color.FromArgb(157, 189, 255), // 35500 
     Color.FromArgb(157, 189, 255), // 35000 
     Color.FromArgb(157, 189, 255), // 34500 
     Color.FromArgb(157, 189, 255), // 34000 
     Color.FromArgb(157, 189, 255), // 33500 
     Color.FromArgb(158, 190, 255), // 33000 
     Color.FromArgb(158, 190, 255), // 32500 
     Color.FromArgb(158, 190, 255), // 32000 
     Color.FromArgb(158, 190, 255), // 31500 
     Color.FromArgb(159, 190, 255), // 31000 
     Color.FromArgb(159, 190, 255), // 30500 
     Color.FromArgb(159, 191, 255), // 30000 
     Color.FromArgb(159, 191, 255), // 29500 
     Color.FromArgb(160, 191, 255), // 29000 
     Color.FromArgb(160, 191, 255), // 28500 
     Color.FromArgb(160, 191, 255), // 28000 
     Color.FromArgb(161, 192, 255), // 27500 
     Color.FromArgb(161, 192, 255), // 27000 
     Color.FromArgb(161, 192, 255), // 26500 
     Color.FromArgb(162, 192, 255), // 26000 
     Color.FromArgb(162, 193, 255), // 25500 
     Color.FromArgb(163, 193, 255), // 25000 
     Color.FromArgb(163, 193, 255), // 24500 
     Color.FromArgb(163, 194, 255), // 24000 
     Color.FromArgb(164, 194, 255), // 23500 
     Color.FromArgb(164, 194, 255), // 23000 
     Color.FromArgb(165, 195, 255), // 22500 
     Color.FromArgb(166, 195, 255), // 22000 
     Color.FromArgb(166, 195, 255), // 21500 
     Color.FromArgb(167, 196, 255), // 21000 
     Color.FromArgb(168, 196, 255), // 20500 
     Color.FromArgb(168, 197, 255), // 20000 
     Color.FromArgb(169, 197, 255), // 19500 
     Color.FromArgb(170, 198, 255), // 19000 
     Color.FromArgb(171, 198, 255), // 18500 
     Color.FromArgb(172, 199, 255), // 18000 
     Color.FromArgb(173, 200, 255), // 17500 
     Color.FromArgb(174, 200, 255), // 17000 
     Color.FromArgb(175, 201, 255), // 16500 
     Color.FromArgb(176, 202, 255), // 16000 
     Color.FromArgb(177, 203, 255), // 15500 
     Color.FromArgb(179, 204, 255), // 15000 
     Color.FromArgb(180, 205, 255), // 14500 
     Color.FromArgb(182, 206, 255), // 14000 
     Color.FromArgb(184, 207, 255), // 13500 
     Color.FromArgb(186, 208, 255), // 13000 
     Color.FromArgb(188, 210, 255), // 12500 
     Color.FromArgb(191, 211, 255), // 12000 
     Color.FromArgb(193, 213, 255), // 11500 
     Color.FromArgb(196, 215, 255), // 11000 
     Color.FromArgb(200, 217, 255), // 10500 
     Color.FromArgb(204, 219, 255), // 10000 
     Color.FromArgb(208, 222, 255), // 9500 
     Color.FromArgb(214, 225, 255), // 9000 
     Color.FromArgb(220, 229, 255), // 8500 
     Color.FromArgb(227, 233, 255), // 8000 
     Color.FromArgb(235, 238, 255), // 7500 
     Color.FromArgb(245, 243, 255), // 7000 
     Color.FromArgb(255, 249, 253), // 6500 
     Color.FromArgb(255, 243, 239), // 6000 
     Color.FromArgb(255, 236, 224), // 5500 
     Color.FromArgb(255, 228, 206), // 5000 
     Color.FromArgb(255, 219, 186), // 4500 
     Color.FromArgb(255, 209, 163), // 4000 
     Color.FromArgb(255, 196, 137), // 3500 
     Color.FromArgb(255, 180, 107), // 3000 
     Color.FromArgb(255, 161, 72), // 2500 
     Color.FromArgb(255, 137, 18), // 2000 
     Color.FromArgb(255, 109, 0), // 1500 
     Color.FromArgb(255, 51, 0), // 1000 
    }; 

Answer 2

तो मिल आप सही आप XYZ color space

Answer 3

Color temperature पर एक सैद्धांतिक पृष्ठभूमि के लिए देख रहे हैं प्रकाश की वास्तविक रंग कुछ (सैद्धांतिक रूप से, एक "आदर्श काले शरीर") से उत्सर्जित है कि प्रकाश के आधार पर पूरी तरह का उत्सर्जन करता है पर आधारित है इसके तापमान।

प्रकाश स्रोत के इस प्रकार के कुछ उदाहरण: यदि आप एक इलेक्ट्रिक स्टोव तत्व यह है कि लाल चमक रहा है, यह 1000K के आसपास हो सकता है। एक नियमित गरमागरम बल्ब फिलामेंट लगभग 2700K है, और सूर्य लगभग 5700K है। सभी तीन "काले शरीर" के उचित अनुमान हैं; वे अपने वास्तविक तापमान के आधार पर प्रकाश का एक विशेष स्पेक्ट्रम उत्सर्जित करते हैं।

कई कृत्रिम प्रकाश स्रोत वास्तव में उनके द्वारा उत्सर्जित प्रकाश का "तापमान" नहीं होते हैं (और उनके स्पेक्ट्रा आम तौर पर काले-शरीर के स्पेक्ट्रा नहीं होते हैं ...)। इसके बजाय, उनका "तापमान" रेटिंग तापमान है जो सैद्धांतिक काला शरीर को उस रंग की रोशनी को उत्सर्जित करने के लिए होना चाहिए। ऐसे रंग भी हैं जिन्हें काले शरीर द्वारा उत्पन्न नहीं किया जा सकता है: प्रकाश जो अधिक "प्राकृतिक" दिखने वाले काले शरीर की रोशनी की तुलना में हरा या बैंगनी होता है।

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

क्योंकि झूठी रंग के डिस्प्ले मनमानी हैं, इसलिए यदि आप तापमान का आकलन करना चाहते हैं तो आपको वास्तव में किसी विशेष छवि या सिस्टम में रंग कुंजी की जांच करनी होगी (वैज्ञानिक छवियों को आमतौर पर इस उद्देश्य के लिए किसी प्रकार की रंग कुंजी होना चाहिए)। यदि आपके पास कोई रंग कुंजी नहीं है, और छवि उत्पन्न करने के तरीके पर कोई प्रलेखन नहीं है, तो आप भाग्य से बाहर हैं।

Answer 4

मुझे पता है यह एक दो साल पुराने धागा है, लेकिन मैं एक ही स्थिति थी।

मैंने रंग तालिका से डेटा लिया और पाइथन में Numpy.polyfit का उपयोग कर टुकड़े के अनुसार 5 वें क्रम बहुपद फिटिंग लागू किया। उन गुणांक से मैं नीचे सी # फ़ंक्शन के साथ आने में सक्षम था। फिट के लिए आर-वर्ग मूल्य 0.999 के करीब या उससे अधिक हैं। इसके अधिकांश डोमेन के माध्यम से इसकी .01% से कम त्रुटि है, लेकिन इसमें कुछ बिंदु हैं जहां यह 3% के करीब है। हालांकि ज्यादातर स्थितियों के लिए पर्याप्त होना चाहिए।

private Color blackBodyColor(double temp) 
{ 
    float x = (float)(temp/1000.0); 
    float x2 = x * x; 
    float x3 = x2 * x; 
    float x4 = x3 * x; 
    float x5 = x4 * x; 

    float R, G, B = 0f; 

    // red 
    if (temp <= 6600) 
     R = 1f; 
    else 
     R = 0.0002889f * x5 - 0.01258f * x4 + 0.2148f * x3 - 1.776f * x2 + 6.907f * x - 8.723f; 

    // green 
    if (temp <= 6600) 
     G = -4.593e-05f * x5 + 0.001424f * x4 - 0.01489f * x3 + 0.0498f * x2 + 0.1669f * x - 0.1653f; 
    else 
     G = -1.308e-07f * x5 + 1.745e-05f * x4 - 0.0009116f * x3 + 0.02348f * x2 - 0.3048f * x + 2.159f; 

    // blue 
    if (temp <= 2000f) 
     B = 0f; 
    else if (temp < 6600f) 
     B = 1.764e-05f * x5 + 0.0003575f * x4 - 0.01554f * x3 + 0.1549f * x2 - 0.3682f * x + 0.2386f; 
    else 
     B = 1f; 

    return Color.FromScRgb(1f, R, G, B); 
} 

Answer 5

ऊपर समारोह लाल रंग जिआदा जब अस्थायी> 10000 लालकृष्ण रंग बैंगनी जब अस्थायी> 14000 करने के लिए बदल जाते हैं। मैंने 7 वें ऑर्डर बहुपदों के साथ डेटा को दोहराया। के गुणांक होना चाहिए:

def temp_to_rgb(temp): 
    t = temp/1000. 

    # calculate red 
    if t < 6.527: 
     red = 1.0 
    else: 
     coeffs = [ 4.93596077e+00, -1.29917429e+00, 
        1.64810386e-01, -1.16449912e-02, 
        4.86540872e-04, -1.19453511e-05, 
        1.59255189e-07, -8.89357601e-10] 
     tt = min(t,40) 
     red = poly(coeffs,tt) 
    red = max(red,0) 
    red = min(red,1) 

    # calcuate green 
    if t < 0.85: 
     green = 0.0 
    elif t < 6.6: 
     coeffs = [ -4.95931720e-01, 1.08442658e+00, 
        -9.17444217e-01, 4.94501179e-01, 
        -1.48487675e-01, 2.49910386e-02, 
        -2.21528530e-03, 8.06118266e-05] 
     green = poly(coeffs,t) 
    else: 
     coeffs = [ 3.06119745e+00, -6.76337896e-01, 
        8.28276286e-02, -5.72828699e-03, 
        2.35931130e-04, -5.73391101e-06, 
        7.58711054e-08, -4.21266737e-10] 
     tt = min(t,40) 
     green = poly(coeffs,tt) 
    green = max(green,0) 
    green = min(green,1) 

    # calculate blue 
    if t < 1.9: 
     blue = 0.0 
    elif t < 6.6: 
     coeffs = [ 4.93997706e-01, -8.59349314e-01, 
        5.45514949e-01, -1.81694167e-01, 
        4.16704799e-02, -6.01602324e-03, 
        4.80731598e-04, -1.61366693e-05] 
     blue = poly(coeffs,t) 
    else: 
     blue = 1.0 
    blue = max(blue,0) 
    blue = min(blue,1) 

    return (red,green,blue) 

यहाँ पाली (coeffs, x) = coeffs [0] + coeffs [1] * x + coeffs [2] * x ** 2 + ...

क्षमा करें मैं सी # से परिचित नहीं हूं लेकिन आप आसानी से कोड पढ़ सकते हैं।

त्रुटि ज्यादातर मामलों के लिए केवल 0.5% के भीतर है और सबसे अधिक 1.2% temp = 6600 के में लाल रंग के लिए है। उच्च क्रम बहुपदों को यहां अपनाया जाता है इसलिए लाल और हरे रंग को अस्थायी के लिए स्थिर रखना चाहिए> 40000 के, अन्यथा अजीब चीजें होता है।