Quasi tutti i sensori per fotocamere digitali sono organizzati in una griglia di fotosensori. Ogni sensore fotografico è sensibile per uno dei colori primari : rosso, verde e blu. Il modo in cui sono organizzati quei sensori fotografici è chiamato filtro Bayer , dal suo inventore, Bryce Bayer di Eastman Kodak. Dopo aver scattato un'immagine, quattro sensori fotografici compongono il valore RGB di un pixel nell'immagine risultante. Il tuo compito è di invertire tale processo e colorare i pixel risultanti in base al colore del filtro. Per semplicità, ignoreremo la correzione gamma .

Ad esempio: i "normali" passaggi del filtro Bayer in avanti sono:

• un raggio di luce con un colore di cera d'api Pantone colpisce il sensore;
• il filtro BGGR (Blu - Verde / Verde - Rosso) lo decompone in quattro raggi.
• I quattro raggi colpiscono il sensore, che recita: 81 - 168/168 - 235 (i valori del sensore vanno da 0 a 255);
• Il filtro Bayer lo traduce in un pixel RGB con colore (235, 168, 81).

I passaggi del filtro Bayer inverso sono:

• Il pixel RGB con colore (235, 168, 81) è diviso in quattro pixel con valori RGB: (0,0,81) - (0,168,0) / (0,168,0) - (235,0,0).

Sfida

È necessario scrivere la funzione o il programma più breve possibile che procede come segue:

• Prendi un nome file come in input e genera l'immagine DeBayered.
• L'output può essere scritto in un file o visualizzato sullo schermo.
• L'output deve essere il doppio della larghezza e il doppio dell'altezza dell'immagine originale.

• Ogni pixel dell'immagine di input deve essere mappato secondo il modello di filtro Bayer BGGR (Blu - Verde / Verde - Rosso) come spiegato graficamente nella seguente immagine:

  

• Supponiamo che entrambi i fotosensori verdi ricevano lo stesso segnale, quindi entrambi i valori G nella matrice Bayer sono uguali al valore G nell'immagine RGB.

• Si può non restituire una rappresentazione di matrice dell'immagine risultante. L'output deve essere un'immagine o un file (in qualsiasi formato immagine adatto ) che può essere visualizzato come immagine.

Esempio

Dato questo file come input:

L'immagine risultante dovrebbe essere:

Implementazione di Python di riferimento:

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

Ricorda: questo è un codice-golf , quindi vince il codice più corto!

Pyth, 26 byte

MXm03H@GH.wsMsgLRRR,U2tU3'

Si aspetta il nome file di input tra virgolette su stdin e scrive su o.png. Esempio di output:

Matlab, 104 92 byte

Questo utilizza la rappresentazione 3d-array / matrice di immagini RGB in Matlab, così come il prodotto Kronecker che è esattamente ciò di cui abbiamo bisogno per creare questo nuovo "metapixel" 2x2 da ciascun pixel sorgente. L'output viene quindi visualizzato in una finestra popup.

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

Screencapture ridimensionato:

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

Il nome file di input è fornito in input standard. Uscite a o.png.

Esempio di utilizzo:

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

Mathematica 118 127 byte

L'invio originale utilizzava un'immagine reale come input. Questo utilizza invece un nome file.

Applica due regole di sostituzione ai dati di immagine del file di riferimento:

1. Per ogni riga della matrice di dati immagine, sostituisci ogni pixel {r, b, g} con un pixel blu, {0,0, b} seguito da un pixel verde, {0, g, 0};
2. Separatamente, per ogni riga della matrice di dati immagine, sostituisci ogni pixel {r, b, g} con un pixel verde {0, g, 0} seguito da un pixel rosso, {r, 0,0};

Quindi Riffle(cioè interleave) le matrici risultanti da 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 byte

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

Questo è uno script in J che legge il nome file dell'immagine di input da stdin e genera il risultato in un file chiamato o. Le immagini di input e output saranno entrambe in bmpformato. Si aspetta inoltre che venga inserito solo il nome file, il che significa che gli spazi bianchi iniziali e finali non dovrebbero essere presenti.

Esempio di utilizzo

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

Spiegazione

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

Innanzitutto ho semplificato il codice originale:

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

Quindi minimizza per:

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

Risultato nell'immagine o.png: