java BufferedImage.getRGB आउटपुट मानों को समझना



image-processing colors (4)

मुझे इस विधि का उपयोग कर छवि में पिक्सेल के लिए एक पूर्णांक मान मिल रहा है:

int colour = img.getRGB(x, y);

फिर मैं मूल्यों को प्रिंट कर रहा हूं और मुझे लगता है कि ब्लैक पिक्सल "-16777216" जैसे किसी मान के अनुरूप हैं, "-16755216" जैसे कुछ नीले रंग का आदि। क्या कोई मुझे इस मूल्य के पीछे तर्क बता सकता है?


getRGB(int x, int y) आपको स्थान पर रंग पिक्सेल का मान देता है (x, y)
आप लौटे हुए मूल्य की गलत व्याख्या कर रहे हैं।
यह बाइनरी प्रारूप में है। 11 की तरह ... 11010101 और यह आपको int मूल्य के रूप में दिया जाता है।
यदि आप उस मूल्य के आरजीबी (यानी लाल, हरे, नीले) घटक प्राप्त करना चाहते हैं तो रंग वर्ग का उपयोग करें। जैसे

Color mycolor = new Color(img.getRGB(x, y));

फिर आप getRed() , getGreen() , getBlue() , getAlpha() का उपयोग करके लाल, हरा या नीला मान प्राप्त कर सकते हैं। फिर इन तरीकों से परिचित स्वरूप में मूल्य 0 < value < 225 होने पर एक int मान वापस कर दिया जाएगा

int red = mycolor.getRed();

यदि आप Color क्लास का उपयोग नहीं करना चाहते हैं तो आपको इसके मूल्य प्राप्त करने के लिए बिटवाई ऑपरेशंस का उपयोग करना होगा।


असल में, आप Intger.toBinaryString (-16755216) द्वारा int से बाइनरी स्ट्रिंग को बदल सकते हैं, जो 11111111000000000101010111110000.it 4 बाइट्स से बना है: अल्फा, लाल, हरा, नीला। मान अप्रचलित हैं, जिसका अर्थ है कि कोई भी पारदर्शिता अल्फा घटक में पूरी तरह से संग्रहीत होती है, न कि रंग घटकों में। घटकों को निम्नानुसार संग्रहीत किया जाता है (अल्फा << 24) | (लाल << 16) | (हरा << 8) | नीला। प्रत्येक घटक 0..255 के बीच 0 के बीच है जिसका अर्थ है उस घटक के लिए कोई योगदान नहीं, और 255 का अर्थ 100% योगदान है। इस प्रकार अपारदर्शी-काला 0xFF000000 (100% अपारदर्शी लेकिन लाल, हरे या नीले रंग से कोई योगदान नहीं होगा), और अपारदर्शी सफेद 0xFFFFFFFF होगा।


ColorModel.getRgb के implementation को देखें:

589  public int getRGB(int pixel) {
590        return (getAlpha(pixel) << 24)
591             | (getRed(pixel) << 16)
592             | (getGreen(pixel) << 8)
593             | (getBlue(pixel) << 0);
594   }

आरजीबी int रंग में इसके बिट्स में रंग के लाल, हरे, नीले रंग के घटक होते हैं। आपको इसके बाइनरी या हेक्साडेसिमल प्रतिनिधित्व को देखना होगा और इसे पूर्ण पूर्णांक संख्या के रूप में नहीं देखना होगा (इसके दशमलव प्रतिनिधित्व को न देखें)।

एक int में 32 बिट्स हैं, 3x8 = 24 का उपयोग निम्न प्रारूप में आरजीबी घटकों (प्रत्येक के लिए 8 बिट्स) को स्टोर करने के लिए किया जाता है:

               2          1          0
bitpos      32109876 54321098 76543210
------   --+--------+--------+--------+
bits     ..|RRRRRRRR|GGGGGGGG|BBBBBBBB|

आप बिटकमास्क का उपयोग कर घटकों को निकाल या सेट कर सकते हैं:

int color = img.getRGB(x, y);

// Components will be in the range of 0..255:
int blue = color & 0xff;
int green = (color & 0xff00) >> 8;
int red = (color & 0xff0000) >> 16;

अगर रंग में अल्फा घटक (पारदर्शिता) एआरजीबी भी है, तो यह शेष शेष 8 बिट्स प्राप्त करता है।

           3          2          1          0
bitpos    10987654 32109876 54321098 76543210
------   +--------+--------+--------+--------+
bits     |AAAAAAAA|RRRRRRRR|GGGGGGGG|BBBBBBBB|

और मूल्य:

int alpha = (color & 0xff000000) >>> 24; // Note the >>> shift
                                         // required due to sign bit

255 का अल्फा मान का अर्थ है कि एक रंग पूरी तरह से अपारदर्शी है और 0 का मान यह है कि रंग पूरी तरह से पारदर्शी है।

आपका रंग:

आपका रंग color = -16755216 जिसमें color = -16755216 है:

blue : 240         // Strong blue
green:  85         // A little green mixed in
red  :   0         // No red component at all
alpha: 255         // Completely opaque




bufferedimage