Hampir semua sensor kamera digital diatur dalam kotak sensor foto. Setiap sensor foto sensitif untuk salah satu warna utama : merah, hijau dan biru. Cara sensor-sensor foto tersebut diatur disebut filter Bayer , menurut penemunya, Bryce Bayer dari Eastman Kodak. Setelah gambar diambil, empat sensor foto menyusun nilai RGB satu piksel pada gambar yang dihasilkan. Tugas Anda adalah membalikkan proses itu dan mewarnai piksel yang dihasilkan sesuai dengan warna filternya. Demi kesederhanaan, kami akan mengabaikan koreksi gamma .

Misalnya: langkah-langkah filter maju Bayer "normal" adalah:

• sebuah lightray dengan warna Pantone Beeswax mengenai sensor;
• filter BGGR (Biru - Hijau / Hijau - Merah) menguraikan ini menjadi empat sinar.
• Keempat sinar itu mengenai sensor, yang berbunyi: 81 - 168/168 - 235 (nilai sensor berkisar dari 0 - 255);
• Filter Bayer menerjemahkan ini ke satu piksel RGB dengan warna (235, 168, 81).

Langkah-langkah filter Bayer terbalik adalah:

• Piksel RGB dengan warna (235, 168, 81) dibagi menjadi empat piksel dengan nilai RGB: (0,0,81) - (0,168,0) / (0,168,0) - (235,0,0).

Tantangan

Anda harus menulis fungsi atau program sesingkat mungkin yang melakukan hal berikut:

• Ambil nama file sebagai input dan output gambar DeBayered.
• Outputnya dapat ditulis ke file atau ditampilkan di layar.
• Output harus dua kali lebar dan dua kali tinggi gambar asli.

• Setiap piksel dari gambar input harus dipetakan sesuai dengan pola filter BGGR (Biru - Hijau / Hijau - Merah) seperti yang dijelaskan secara grafis dalam gambar berikut:

  

• Kita akan mengasumsikan bahwa kedua fotosensor hijau menerima sinyal yang sama, sehingga kedua nilai G dalam matriks Bayer sama dengan nilai G pada gambar RGB.

• Anda tidak dapat mengembalikan representasi array dari gambar yang dihasilkan. Output harus berupa gambar atau file (dalam format gambar apa pun yang sesuai ) yang dapat ditampilkan sebagai gambar.

Contoh

Diberikan file ini sebagai input:

Gambar yang dihasilkan harus:

Referensi implementasi python:

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

Ingat: ini adalah kode-golf , jadi kode terpendek menang!

Pyth, 26 byte

[email protected],U2tU3'

Mengharapkan nama file input dengan tanda kutip di stdin, dan menulis ke o.png. Contoh output:

Matlab, 104 92 byte

Ini memanfaatkan representasi 3d-array / matriks dari gambar RGB di Matlab, serta produk Kronecker yang persis apa yang kita butuhkan untuk membuat 2x2 "metapixel" baru ini dari setiap piksel sumber. Outputnya kemudian ditampilkan di jendela sembulan.

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

Screencapture yang diubah ukurannya:

Python 3, 259 254 byte

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

Nama file input diberikan dalam input standar. Output ke o.png.

Contoh penggunaan:

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

Mathematica 118 127 byte

Pengiriman asli menggunakan gambar aktual sebagai input. Ini menggunakan nama file sebagai gantinya.

Ini menerapkan dua aturan penggantian pada data gambar dari file yang direferensikan:

1. Untuk setiap baris matriks data gambar, ganti setiap piksel {r, b, g} dengan piksel biru, {0,0, b} diikuti oleh piksel hijau, {0, g, 0};
2. Secara terpisah, untuk setiap baris matriks data gambar, ganti setiap piksel {r, b, g} dengan piksel hijau {0, g, 0} diikuti oleh piksel merah, {r, 0,0};

Kemudian Riffle(yaitu interleave) matriks yang dihasilkan dari 1 dan 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"]

J, 100 96 90 byte

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

Ini adalah skrip dalam J yang membaca nama file dari gambar input dari stdin dan menampilkan hasilnya ke file bernama o. Gambar input dan output keduanya akan dalam bmpformat. Itu juga mengharapkan hanya nama file yang akan menjadi input, yang berarti bahwa spasi putih depan dan belakang tidak boleh ada.

Contoh Penggunaan

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

Penjelasan

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'

Python 2, 256 275 byte

Pertama saya menyederhanakan kode aslinya:

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

Kemudian minify ke:

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

Menghasilkan gambar o.png: