Hemen hemen tüm dijital kamera sensörleri bir fotosensör ızgarasında düzenlenmiştir. Her fotoğraf sensörü ana renklerden birine duyarlıdır : kırmızı, yeşil ve mavi. Bu fotoğraf sensörlerinin düzenlenme şekline , mucidi Eastman Kodak'tan Bryce Bayer'den sonra Bayer filtresi denir . Bir görüntü çekildikten sonra, dört fotoğraf sensörü ortaya çıkan görüntüdeki bir pikselin RGB değerini oluşturur. Göreviniz bu işlemi tersine çevirmek ve elde edilen pikselleri filtre renklerine göre renklendirmektir. Basitlik uğruna gama düzeltmesini görmezden geleceğiz .

Örneğin: "normal" ileri Bayer filtre adımları:

• Pantone Balmumu rengine sahip bir lightray sensöre çarpar;
• BGGR (Mavi - Yeşil / Yeşil - Kırmızı) filtresi bunu dört ışına ayırır.
• Dört ışın sensöre çarpar ve bu sensör: 81 - 168/168 - 235 (sensör değerleri 0 - 255 arasındadır);
• Bayer filtresi bunu renkli bir RGB piksele çevirir (235, 168, 81).

Ters Bayer filtre adımları:

• Renkli RGB piksel (235, 168, 81) RGB değerleriyle dört piksele bölünür: (0,0,81) - (0,168,0) / (0,168,0) - (235,0,0).

Meydan okuma

Aşağıdakileri yapan mümkün olan en kısa işlevi veya programı yazmalısınız:

• Girdi gibi bir dosya adı alın ve DeBayered görüntüsünü çıkarın.
• Çıktı bir dosyaya yazılabilir veya ekranda görüntülenebilir.
• Çıktı, orijinal görüntünün iki katı ve yüksekliğinin iki katı olmalıdır.

• Giriş görüntüsünün her pikseli, aşağıdaki resimde grafik olarak açıklandığı şekilde BGGR (Mavi - Yeşil / Yeşil - Kırmızı) Bayer filtre modeline göre eşlenmelidir:

  

• Her iki yeşil fotosensörün de aynı sinyali aldığını varsayacağız, bu nedenle Bayer matrisindeki G değerlerinin her ikisi de RGB görüntüsündeki G değerine eşittir.

• Sen olabilir değil Oluşan görüntünün bir dizi gösterimini döndürür. Çıktı, resim olarak görüntülenebilecek bir resim veya bir dosya ( uygun herhangi bir resim biçiminde ) olmalıdır.

Misal

Bu dosya girdi olarak verildiğinde:

Ortaya çıkan görüntü şöyle olmalıdır:

Referans python uygulaması:

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")

Unutmayın: bu bir kod golf, çok kısa kod kazanır!

Pyth, 26 bayt

MXm03H@GH.wsMsgLRRR,U2tU3'

Girdi dosya adını stdin'de tırnak işaretleri ile bekler ve yazar o.png. Örnek çıktı:

Matlab, 104 92 bayt

Bu, Matlab'daki RGB görüntülerinin 3B dizi / matris temsilini ve her yeni kaynak pikselinden bu yeni 2x2 "metaforu" oluşturmak için tam olarak ihtiyaç duyduğumuz Kronecker ürününü kullanır. Çıktı daha sonra bir açılır pencerede görüntülenir.

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

Yeniden boyutlandırılan ekran görüntüsü:

Python 3, 259254 bayt

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')

Giriş dosya adı standart girişte verilmiştir. Çıkışları o.png.

Örnek kullanım:

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

Mathematica 118 127 bayt

Orijinal gönderim, giriş olarak gerçek bir resim kullandı. Bunun yerine bir dosya adı kullanır.

Başvuru yapılan dosyanın görüntü verilerine iki değiştirme kuralı uygulanır:

1. Görüntü veri matrisinin her satırı için, her bir {r, b, g} pikselini mavi bir piksel, {0,0, b} ve ardından yeşil bir piksel, {0, g, 0};
2. Ayrı olarak, görüntü veri matrisinin her satırı için, her bir {r, b, g} pikselini yeşil bir piksel {0, g, 0} ve ardından kırmızı bir piksel, {r, 0,0};

Sonra Riffle1 ve 2'den kaynaklanan matrisleri (yani serpiştirin).

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"]

J, 100 96 90 bayt

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

Bu, stdin'den giriş görüntüsünün dosya adını okuyan ve sonucu adlı bir dosyaya çıkaran J'deki bir komut dosyasıdır o. Giriş ve çıkış görüntülerinin her ikisi de bmpformatta olacaktır. Ayrıca yalnızca dosya adının girilmesini bekler, yani öndeki ve sondaki boşluk olmamalıdır.

Örnek Kullanımı

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

açıklama

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'

Piton 2, 256 275 bayt

İlk önce orijinal kodu basitleştirdim:

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")

Ardından küçültün:

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")

Resmin sonucu o.png: