एक छवि का रिवर्स बायर फ़िल्टर

Question

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

उदाहरण के लिए: "सामान्य" आगे बायर फ़िल्टर चरण हैं:

• पैनटोन के साथ एक लाइटवेट बीज़वैक्स कलर सेंसर को हिट करता है;
• बीजीजीआर (ब्लू - ग्रीन / ग्रीन - रेड) फिल्टर इसे चार किरणों में विघटित करता है।
• चार किरणें सेंसर से टकराती हैं, जो पढ़ती है: 81 - 168/168 - 235 (सेंसर मान 0 से 255 सीमा तक);
• बायर फ़िल्टर रंग (235, 168, 81) के साथ एक RGB पिक्सेल में इसका अनुवाद करता है।

रिवर्स बायर फ़िल्टर चरण हैं:

• आरजीबी पिक्सेल रंग के साथ (235, 168, 81) आरजीबी मूल्यों के साथ चार पिक्सेल में विभाजित है: (0,0,81) - (0,168,0) / (0,168,0) - (235,0,0)।

चुनौती

आपको सबसे कम संभव फ़ंक्शन या प्रोग्राम लिखना चाहिए जो निम्न कार्य करता है:

• इनपुट के रूप में फ़ाइल नाम लें और DeBayered छवि को आउटपुट करें।
• आउटपुट को फ़ाइल में लिखा जा सकता है या स्क्रीन पर प्रदर्शित किया जा सकता है।
• आउटपुट दो बार चौड़ाई और मूल छवि की ऊंचाई से दोगुना होना चाहिए।

• बीजीजीआर (ब्लू - ग्रीन / ग्रीन - रेड) बायर फिल्टर पैटर्न के अनुसार इनपुट छवि के प्रत्येक पिक्सेल को मैप किया जाना चाहिए जैसा कि निम्नलिखित चित्र में बताया गया है:

  

• हम मान लेंगे कि दोनों हरे रंग के फोटो सेंसर एक ही संकेत प्राप्त करते हैं, इसलिए बायर मैट्रिक्स में दोनों G मान RGB छवि में G मान के बराबर हैं।

• आप परिणामी छवि का एक सरणी प्रतिनिधित्व नहीं लौटा सकते हैं । आउटपुट एक छवि या एक फ़ाइल ( किसी भी उपयुक्त छवि प्रारूप में ) होनी चाहिए जिसे छवि के रूप में प्रदर्शित किया जा सकता है।

उदाहरण

इस फाइल को इनपुट के रूप में दिया गया है:

परिणामी छवि होनी चाहिए:

संदर्भ अजगर कार्यान्वयन:

from PIL import Image
import numpy
import sys

if len(sys.argv) == 1:
    print "Usage: python DeByer.py <<image_filename>>"
    sys.exit()

# Open image and put it in a numpy array
srcArray = numpy.array(Image.open(sys.argv[1]), dtype=numpy.uint8)
w, h, _ = srcArray.shape

# Create target array, twice the size of the original image
resArray = numpy.zeros((2*w, 2*h, 3), dtype=numpy.uint8)

# Map the RGB values in the original picture according to the BGGR pattern# 

# Blue
resArray[::2, ::2, 2] = srcArray[:, :, 2]

# Green (top row of the Bayer matrix)
resArray[1::2, ::2, 1] = srcArray[:, :, 1]

# Green (bottom row of the Bayer matrix)
resArray[::2, 1::2, 1] = srcArray[:, :, 1]

# Red
resArray[1::2, 1::2, 0] = srcArray[:, :, 0]

# Save the imgage
Image.fromarray(resArray, "RGB").save("output.png")

याद रखें: यह एक है कोड गोल्फ, इसलिए सबसे छोटा कोड जीतता है!

Comments

जब मुझे स्क्रॉल किया गया तो लगभग एक जब्ती मिली

— घातक

@ इसके लिए क्षमा करें! ;-) अजीब प्रभाव, है ना?

— 18

निर्देश BGशीर्ष पंक्ति और GRतल पर के साथ एक सेल दिखाते हैं , जबकि उदाहरण छवि RGशीर्ष और GBतल पर दिखाई देती है। क्या इसका मतलब यह है कि एक विकर्ण पर दो हरी कोशिकाओं को डालने वाली कोई भी व्यवस्था स्वीकार्य है? (अन्य जीबी / आरजी और जीआर / बीजी होंगे।)

— स्तर नदी सेंट

@LevelRiverSt मेरा इरादा BGGR (चौथी चुनौती बुलेट में निर्दिष्ट) का पालन करना था। मेरी गलती अगर वास्तविक उदाहरण छवि RGGB में है। मैं ठीक करूँगा कि जैसे ही मैं अपने लैपटॉप पर हूँ।

— २३:१६ तक

मुझे नहीं लगता कि आपकी उदाहरण छवि सही है, एक के लिए यह एक अजीब नीली टिंट है

— orlp

Answer 1

पायथ, 26 बाइट्स

[e-mail],U2tU3'

स्टड पर उद्धरण चिह्नों के साथ इनपुट फ़ाइल नाम की अपेक्षा करता है, और लिखता है o.png। उदाहरण आउटपुट:

Comments

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

— agtoever

मैंने पिछले प्रश्न के उत्तर का उपयोग करते हुए, क्रोनकर उत्पाद का उपयोग किया था: codegolf.stackexchange.com/questions/78797/… ।

— orlp

Answer 2

मतलाब, 104 92 बाइट्स

यह मतलाब में आरजीबी छवियों के 3 डी-सरणी / मैट्रिक्स प्रतिनिधित्व के साथ-साथ क्रोनकर उत्पाद का उपयोग करता है, जो कि वास्तव में हमें इस नए 2x2 "मेटापिल" को प्रत्येक स्रोत पिक्सेल बनाने की आवश्यकता है। आउटपुट को पॉपअप विंडो में प्रदर्शित किया जाता है।

a=double(imread(input('')));for n=1:3;b(:,:,n)=kron(a(:,:,n),[1:2;2:3]==n)/255;end;imshow(b)

आकार बदलने वाला पेंच:

Comments

यह [1:2;2:3]==nचतुर है! क्या आप नहीं निकाल सकते b=[a,a;a,a];?

— लुइस मेन्डो

@LuisMendo धन्यवाद =) यह वास्तव में काम करता है, मुझे उम्मीद नहीं थी कि!

— दोष

Answer 3

पायथन 3, 259 254 बाइट्स

from PIL.Image import*
o=open(input())
w,h=o.size
n=new('RGB',(2*w,2*h))
P=Image.putpixel
for b in range(w*h):x=b//h;y=b%h;r,g,b=o.getpixel((x,y));c=2*x;d=2*y;G=0,g,0;P(n,(c,d),(0,0,b));P(n,(c+1,d),G);P(n,(c,d+1),G);P(n,(c+1,d+1),(r,0,0))
n.save('o.png')

इनपुट फ़ाइल नाम मानक इनपुट में दिया गया है। को आउटपुट देता हैo.png ।

उदाहरण उपयोग:

$ echo mona-lisa.jpg | python bayer.py

Comments

PPCG में आपका स्वागत है, अच्छा पहला जवाब!

— लीकी नून

Answer 4

गणितज्ञ 118 127 बाइट्स

मूल सबमिशन ने इनपुट के रूप में एक वास्तविक चित्र का उपयोग किया। इसके बजाय एक फ़ाइल नाम का उपयोग करता है।

यह संदर्भित फ़ाइल के छवि डेटा पर दो प्रतिस्थापन नियम लागू करता है:

1. छवि डेटा मैट्रिक्स की प्रत्येक पंक्ति के लिए, प्रत्येक पिक्सेल {r, b, g} को नीले पिक्सेल से बदलें, {0,0, b} के बाद एक हरे रंग का पिक्सेल, {0, g, 0};
2. अलग से, छवि डेटा मैट्रिक्स की प्रत्येक पंक्ति के लिए, प्रत्येक पिक्सेल {r, b, g} को हरे रंग के पिक्सेल {0, g, 0} से बदलें, उसके बाद लाल पिक्सेल, {r, 0,0};

तब Riffle(यानी इंटरलेव) 1 और 2 के परिणामस्वरूप मेट्रिसेस।

Image[Riffle[#/.{{_,g_,b_}:>(s=Sequence)[{0,0,b},{0,g,0}]}&/@(m=Import[#,"Data"]/255),#/.{{r_,g_,_}:>s[{0,g,0},{r,0,0}]}&/@m]]&

---

Image[Riffle[#/.{{_,g_,b_}:>(s=Sequence)[{0,0,b},{0,g,0}]}&/@(m=Import[#,"Data"]/255),#/.{{r_,g_,_}:>s[{0,g,0},{r,0,0}]}&/@m]]&["mona.jpg"]

Comments

यकीन नहीं है, लेकिन यह " इनपुट के रूप में एक फ़ाइल नाम लें " को संतुष्ट करने के लिए प्रतीत नहीं होता है

— मार्च

अब, यह अब एक छवि के बजाय एक फ़ाइल नाम इनपुट के रूप में उपयोग करता है।

— डेविड जूल

Answer 5

जे, 100 96 90 बाइट्स

load'bmp'
'o'writebmp~,./,./($a)$2 1 1 0(_2]\(2^0 8 8 16)*{)"1(3#256)#:,a=:readbmp]stdin''

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

नमूना उपयोग

$ echo -n mona.bmp | jconsole reversebayer.ijs

व्याख्या

A=:readbmp]stdin''  Store the image in A as a 2d array of 24-bit rgb ints
,                   Flatten it into a list
(3#256) #:          Convert each 24-bit int to a tuple of 8-bit r/g/b ints
2 1 1 0 {"1         Select each column in BGGR order
(2^0 8 8 16) *      Shift each color to make it a 24-bit rgb value
_2 ]\               Convert each row from dimensions 1x4 to 2x2
($A) $              Reshape the list of 2x2 matrices into a matrix of
                    2x2 matrices with dimensions matching A
,./                 Append the 2x2 matrices by column
,./                 Append the 2x2 matrices by row - This is now a matrix of
                     24-bit rgb values with twice the dimensions of A
'o'writebmp~        Write the image array to a bmp file named 'o'

Answer 6

अजगर 2, 256 275 बाइट्स

पहले मैंने मूल कोड को सरल बनाया:

from PIL import Image
from numpy import*
import sys

# Open image and put it in a numpy array
srcArray = array(Image.open(sys.argv[1]), dtype=uint8)
w, h, _ = srcArray.shape

# Create target array, twice the size of the original image
resArray = zeros((2*w, 2*h, 3), dtype=uint8)

# Map the RGB values in the original picture according to the BGGR pattern# 

# Blue
resArray[::2, ::2, 2] = srcArray[:, :, 2]

# Green (top row of the Bayer matrix)
resArray[1::2, ::2, 1] = srcArray[:, :, 1]

# Green (bottom row of the Bayer matrix)
resArray[::2, 1::2, 1] = srcArray[:, :, 1]

# Red
resArray[1::2, 1::2, 0] = srcArray[:, :, 0]

# Save the imgage
Image.fromarray(resArray, "RGB").save("o.png")

फिर इसे छोटा करें:

from PIL import Image
from numpy import*
import sys
a=array(Image.open(sys.argv[1]),dtype=uint8)
w,h,_=a.shape
b=zeros((2*w,2*h,3),dtype=uint8)
b[::2,::2,2]=a[:,:,2]
b[1::2,::2,1]=a[:,:,1]
b[::2,1::2,1]=a[:,:,1]
b[1::2,1::2,0]=a[:,:,0]
Image.fromarray(b,"RGB").save("o.png")

छवि में परिणाम o.png: