Quase todos os sensores de câmera digital estão organizados em uma grade de fotosensores. Cada sensor fotográfico é sensível a uma das cores principais : vermelho, verde e azul. A maneira como esses sensores fotográficos são organizados é chamada de filtro Bayer , em homenagem a seu inventor, Bryce Bayer, da Eastman Kodak. Depois que uma imagem é tirada, quatro sensores fotográficos compõem o valor RGB de um pixel na imagem resultante. Sua tarefa é reverter esse processo e colorir os pixels resultantes de acordo com a cor do filtro. Por uma questão de simplicidade, ignoraremos a correção gama .

Por exemplo: as etapas do filtro Bayer para a frente "normal" são:

• uma bandeja de luz com uma cor de cera de abelha Pantone atinge o sensor;
• o filtro BGGR (azul - verde / verde - vermelho) decompõe isso em quatro raios.
• Os quatro raios atingem o sensor, que lê: 81 - 168/168 - 235 (os valores do sensor variam de 0 a 255);
• O filtro Bayer converte isso em um pixel RGB com cores (235, 168, 81).

As etapas reversas do filtro Bayer são:

• O pixel RGB com cores (235, 168, 81) é dividido em quatro pixels com valores RGB: (0,0,81) - (0,168,0) / (0,168,0) - (235,0,0).

Desafio

Você deve escrever a função ou programa mais curto possível que faça o seguinte:

• Pegue um nome de arquivo como na entrada e emita a imagem DeBayered.
• A saída pode ser gravada em um arquivo ou exibida na tela.
• A saída deve ter o dobro da largura e o dobro da altura da imagem original.

• Cada pixel da imagem de entrada deve ser mapeado de acordo com o padrão de filtro Bayer BGGR (Azul - Verde / Verde - Vermelho), conforme explicado graficamente na figura a seguir:

  

• Assumiremos que os dois fotossensores verdes recebem o mesmo sinal; portanto, os valores G na matriz Bayer são iguais ao valor G na imagem RGB.

• Você não pode retornar uma representação de matriz da imagem resultante. A saída deve ser uma imagem ou um arquivo (em qualquer formato de imagem adequado ) que possa ser exibido como uma imagem.

Exemplo

Dado este arquivo como uma entrada:

A imagem resultante deve ser:

Implementação python de referência:

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

Lembre-se: este é um código de golfe , então o código mais curto vence!

Pitão, 26 bytes

[email protected],U2tU3'

Espera o nome do arquivo de entrada com aspas em stdin e grava em o.png. Exemplo de saída:

Matlab, 104 92 bytes

Isso faz uso da representação em matriz / matriz 3d de imagens RGB no Matlab, bem como do produto Kronecker, que é exatamente o que precisamos para criar esse novo "metapixel" 2x2 de cada pixel de origem. A saída é exibida em uma janela pop-up.

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

Captura de tela redimensionada:

Python 3, 259 254 bytes

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 nome do arquivo de entrada é fornecido na entrada padrão. Saídas para o.png.

Exemplo de uso:

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

Mathematica 118 127 bytes

O envio original usou uma imagem real como entrada. Isso usa um nome de arquivo.

Aplica duas regras de substituição aos dados da imagem do arquivo referenciado:

1. Para cada linha da matriz de dados da imagem, substitua cada pixel {r, b, g} por um pixel azul, {0,0, b}, seguido por um pixel verde {0, g, 0};
2. Separadamente, para cada linha da matriz de dados da imagem, substitua cada pixel {r, b, g} por um pixel verde {0, g, 0} seguido por um pixel vermelho {r, 0,0};

Então Riffle(ou seja, intercalar) as matrizes resultantes de 1 e 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 bytes

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

Este é um script em J que lê o nome do arquivo da imagem de entrada de stdin e gera o resultado em um arquivo chamado o. As imagens de entrada e saída estarão no bmpformato. Ele também espera que apenas o nome do arquivo seja inserido, significando que os espaços em branco à esquerda e à direita não devem estar presentes.

Uso da amostra

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

Explicação

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 bytes

Primeiro, simplifiquei o código original:

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

Minimize para:

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

Resultando na imagem o.png: