Presque tous les capteurs d'appareils photo numériques sont organisés dans une grille de photocapteurs. Chaque capteur photo est sensible à l'une des couleurs primaires : rouge, vert et bleu. La façon dont ces photodétecteurs sont organisés s'appelle le filtre Bayer , d'après son inventeur, Bryce Bayer d'Eastman Kodak. Après la prise d'une image, quatre photocapteurs composent la valeur RVB d'un pixel dans l'image résultante. Votre tâche consiste à inverser ce processus et à coloriser les pixels résultants en fonction de leur couleur de filtre. Par souci de simplicité, nous ignorerons la correction gamma .

Par exemple: les étapes du filtre Bayer "normal" vers l'avant sont les suivantes:

• un rayon de lumière avec une couleur de cire d'abeille Pantone frappe le capteur;
• le filtre BGGR (Bleu - Vert / Vert - Rouge) le décompose en quatre rayons.
• Les quatre rayons frappent le capteur, qui se lit comme suit: 81 - 168/168 - 235 (les valeurs du capteur vont de 0 à 255);
• Le filtre Bayer traduit cela en un pixel RVB avec couleur (235, 168, 81).

Les étapes du filtre Bayer inversé sont les suivantes:

• Le pixel RVB avec couleur (235, 168, 81) est divisé en quatre pixels avec des valeurs RVB: (0,0,81) - (0,168,0) / (0,168,0) - (235,0,0).

Défi

Vous devez écrire la fonction ou le programme le plus court possible qui effectue les opérations suivantes:

• Prenez un nom de fichier comme en entrée et sortez l'image DeBayered.
• La sortie peut être écrite dans un fichier ou affichée à l'écran.
• La sortie doit être deux fois la largeur et deux fois la hauteur de l'image d'origine.

• Chaque pixel de l'image d'entrée doit être mappé selon le modèle de filtre Bayer BGGR (Bleu - Vert / Vert - Rouge) comme expliqué graphiquement dans l'image suivante:

  

• Nous supposerons que les deux photocapteurs verts reçoivent le même signal, donc les deux valeurs G dans la matrice Bayer sont égales à la valeur G dans l'image RVB.

• Vous ne pouvez pas renvoyer une représentation de tableau de l'image résultante. La sortie doit être une image ou un fichier (dans n'importe quel format d'image approprié ) pouvant être affiché sous forme d'image.

Exemple

Étant donné ce fichier en entrée:

L'image résultante doit être:

Implémentation de référence de 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")

Rappelez-vous: c'est un code-golf , donc le code le plus court gagne!

Pyth, 26 octets

[email protected],U2tU3'

Attend le nom du fichier d'entrée avec des guillemets sur stdin et écrit dans o.png. Exemple de sortie:

Matlab, 104 92 octets

Cela utilise la représentation matricielle / matricielle 3D des images RVB dans Matlab, ainsi que le produit Kronecker qui est exactement ce dont nous avons besoin pour créer ce nouveau "métapixel" 2x2 pour chaque pixel source. La sortie est ensuite affichée dans une fenêtre contextuelle.

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

Capture d'écran redimensionnée:

Python 3, 259 254 octets

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

Le nom du fichier d'entrée est donné en entrée standard. Sorties vers o.png.

Exemple d'utilisation:

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

Mathematica 118 127 octets

La soumission originale utilisait une image réelle comme entrée. Cela utilise un nom de fichier à la place.

Il applique deux règles de remplacement aux données d'image du fichier référencé:

1. Pour chaque ligne de la matrice de données d'image, remplacez chaque pixel {r, b, g} par un pixel bleu, {0,0, b} suivi d'un pixel vert, {0, g, 0};
2. Séparément, pour chaque ligne de la matrice de données d'image, remplacez chaque pixel {r, b, g} par un pixel vert {0, g, 0} suivi d'un pixel rouge, {r, 0,0};

Puis Riffle(c'est-à-dire entrelacé) les matrices résultant de 1 et 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 octets

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

Il s'agit d'un script en J qui lit le nom de fichier de l'image d'entrée depuis stdin et renvoie le résultat dans un fichier nommé o. Les images d'entrée et de sortie seront toutes deux au bmpformat. Il s'attend également à ce que seul le nom de fichier soit entré, ce qui signifie que les espaces de début et de fin ne doivent pas être présents.

Exemple d'utilisation

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

Explication

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 octets

J'ai d'abord simplifié le code d'origine:

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

Ensuite, réduisez pour:

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

Résultat dans l'image o.png: