Hầu như tất cả các cảm biến máy ảnh kỹ thuật số được tổ chức trong một mạng lưới cảm quang. Mỗi cảm biến ảnh nhạy cảm với một trong các màu chính : đỏ, xanh lá cây và xanh dương. Cách thức tổ chức các cảm biến ảnh này được gọi là bộ lọc của Bayer , theo tên người phát minh ra nó, Bryce Bayer của Eastman Kodak. Sau khi chụp ảnh, bốn cảm biến ảnh sẽ tạo giá trị RGB của một pixel trong ảnh thu được. Nhiệm vụ của bạn là đảo ngược quá trình đó và tô màu các pixel kết quả theo màu bộ lọc của chúng. Để đơn giản, chúng tôi sẽ bỏ qua điều chỉnh gamma .

Ví dụ: các bước bộ lọc chuyển tiếp "bình thường" của Bayer là:

• một tia sáng với màu sáp ong Pantone chạm vào cảm biến;
• bộ lọc BGGR (Xanh lam - Xanh lục / Xanh lục - Đỏ) phân hủy thành bốn tia.
• Bốn tia chạm vào cảm biến, có nội dung: 81 - 168/168 - 235 (giá trị cảm biến nằm trong khoảng từ 0 - 255);
• Bộ lọc của Bayer dịch điều này thành một pixel RGB có màu (235, 168, 81).

Các bước lọc ngược của Bayer là:

• Pixel RGB có màu (235, 168, 81) được chia thành bốn pixel với các giá trị RGB: (0,0,81) - (0,168,0) / (0,168,0) - (235,0,0).

Thử thách

Bạn nên viết hàm ngắn nhất có thể hoặc chương trình thực hiện như sau:

• Lấy tên tệp như trong đầu vào và xuất hình ảnh DeBayered.
• Đầu ra có thể được ghi vào một tập tin hoặc hiển thị trên màn hình.
• Đầu ra phải gấp đôi chiều rộng và gấp đôi chiều cao của ảnh gốc.

• Mỗi pixel của hình ảnh đầu vào phải được ánh xạ theo mẫu bộ lọc Bayer BGGR (Blue - Green / Green - Red) như được giải thích bằng đồ họa trong hình sau:

  

• Chúng ta sẽ giả sử rằng cả hai cảm biến quang màu xanh lục đều nhận được cùng một tín hiệu, vì vậy cả hai giá trị G trong ma trận Bayer đều bằng giá trị G trong hình ảnh RGB.

• Bạn không thể trả về một đại diện mảng của hình ảnh kết quả. Đầu ra phải là một hình ảnh hoặc một tập tin (ở bất kỳ định dạng hình ảnh phù hợp nào ) có thể được hiển thị dưới dạng hình ảnh.

Thí dụ

Cho tệp này làm đầu vào:

Hình ảnh thu được phải là:

Tham khảo thực hiện 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")

Hãy nhớ rằng: đây là một môn đánh gôn , vì vậy đoạn mã ngắn nhất sẽ thắng!

Bình thường, 26 byte

MXm03H@GH.wsMsgLRRR,U2tU3'

Yêu cầu tên tệp đầu vào với dấu ngoặc kép trên stdin và ghi vào o.png. Ví dụ đầu ra:

Matlab, 104 92 byte

Điều này sử dụng biểu diễn mảng 3d / ma trận của hình ảnh RGB trong Matlab, cũng như sản phẩm Kronecker , chính xác là những gì chúng ta cần để tạo "metapixel" 2x2 mới này cho mỗi pixel nguồn. Đầu ra sau đó được hiển thị trong một cửa sổ bật lên.

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

Thay đổi kích thước màn hình:

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

Tên tệp đầu vào được đưa ra trong đầu vào tiêu chuẩn. Đầu ra o.png.

Ví dụ sử dụng:

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

Toán học 118 127 byte

Trình ban đầu sử dụng một hình ảnh thực tế như là đầu vào. Điều này sử dụng một tên tệp thay thế.

Nó áp dụng hai quy tắc thay thế cho dữ liệu hình ảnh của tệp được tham chiếu:

1. Đối với mỗi hàng của ma trận dữ liệu hình ảnh, thay thế từng pixel {r, b, g} bằng một pixel màu xanh lam, {0,0, b} theo sau là một pixel màu xanh lá cây, {0, g, 0};
2. Một cách riêng biệt, đối với mỗi hàng của ma trận dữ liệu hình ảnh, thay thế từng pixel {r, b, g} bằng một pixel xanh {0, g, 0} theo sau là một pixel đỏ, {r, 0,0};

Sau đó Riffle(tức là xen kẽ) các ma trận kết quả từ 1 và 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''

Đây là một tập lệnh trong J đọc tên tệp của hình ảnh đầu vào từ stdin và đưa kết quả ra một tệp có tên o. Cả hai hình ảnh đầu vào và đầu ra sẽ có bmpđịnh dạng. Nó cũng hy vọng chỉ có tên tệp là đầu vào, có nghĩa là không nên có khoảng trắng đầu và cuối.

Sử dụng mẫu

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

Giải trình

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

Đầu tiên tôi đơn giản hóa mã gốc:

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

Sau đó rút gọn thành:

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

Kết quả trong hình ảnh o.png: