Omvänd Bayer-filter av en bild

Nästan alla sensorer för digitalkameror är organiserade i ett rutnät med fotosensorer. Varje fotosensor är känslig för en av primärfärgerna : röd, grön och blå. Hur dessa fotosensorer är organiserade kallas Bayer-filter , efter uppfinnaren Bryce Bayer av Eastman Kodak. När en bild har tagits komponerar fyra fotosensorer RGB-värdet på en pixel i den resulterande bilden. Din uppgift är att vända den processen och färga de resulterande pixlarna enligt deras filterfärg. För enkelhets skull ignorerar vi gammakorrigering .

Till exempel: de ”normala” framåt Bayer-filterstegen är:

  • en ljusstråle med en Pantone bivaxfärg träffar sensorn;
  • BGGR (blå – grön / grön – Rött) filter sönderdelar detta i fyra strålar.
  • De fyra strålarna träffar sensorn, som lyder: 81 – 168/168 – 235 (sensorvärdena sträcker sig från 0 – 255);
  • Bayer-filtret översätter detta till en RGB-pixel med färg (235, 168, 81).

De omvända Bayer-filterstegen är:

  • RGB-pixel med färg (235, 168, 81) är uppdelad i fyra pixlar med RGB-värden: (0,0,81) – (0,168,0) / (0,168,0) – (235,0,0).

Utmaning

Du bör skriva kortast möjliga funktion eller program som gör följande:

  • Ta ett filnamn som i inmatning och utmatning av DeBayered-bilden .
  • Utdata kan skrivas till en fil eller visas på skärmen.
  • T utmatningen måste vara två gånger bredden och två gånger höjden på originalbilden.
  • Varje pixel i den inmatade bilden måste mappas enligt BGGR (blå – grön / grön – röd) Bayer-filter mönster som förklaras grafiskt i följande bild:

    Bayer Filter - BGGR - grafisk förklaring

  • Vi antar att båda gröna fotosensorerna får samma signal, så att båda G-värdena i Bayer-matrisen är lika med G-värdet i RGB-bilden.

  • Du kan inte returnera en matrisrepresentation av den resulterande bilden. Utgången måste vara en bild eller en fil (i vilket lämpligt bildformat som helst som kan visas som en bild.

Exempel

Med den här filen som inmatning:

Mona Lisa

Den resulterande bilden ska vara:

DeBayered Mona Lisa

Implementering av referenspython:

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

Kom ihåg: detta är en , så kortaste kod vinner!

Kommentarer

  • Nästan fick ett anfall när jag rullade
  • @Fatalize ledsen för det! 😉 Konstig effekt, är det inte ’?
  • Instruktionerna visar en cell med BG överst rad och GR längst ner, medan exempelbilden visar RG överst och GB på botten. Betyder det att något arrangemang som sätter de två gröna cellerna på en diagonal är acceptabelt? (de andra skulle vara GB / RG och GR / BG.)
  • @LevelRiverSt min avsikt var att följa BGGR (som anges i fjärde utmaningskulan). Mitt misstag om den verkliga exempelbilden finns i RGGB. Jag ’ kommer att korrigera det så fort jag ’ är på min bärbara dator.
  • Jag don ’ tänker inte att din exempelbild är korrekt, för en har den en konstig blå nyans

Svar

Pyth, 26 byte

[email protected],U2tU3" 

Förväntar sig inmatningsfilnamnet med citattecken på stdin och skriver till o.png. Exempel på utdata:

Kommentarer

  • Du svarar är det kortaste hittills. Jag brukar acceptera det, men det vore trevligt om du kunde lägga till en förklaring till hur ditt program fungerar.
  • Jag använde just Kronecker-produkten med ett svar från en tidigare fråga: codegolf.stackexchange.com/questions/78797/… .

Svar

Matlab, 104 92 byte

Detta använder 3D-array / matrisrepresentation av RGB-bilder i Matlab, liksom Kronecker-produkten vilket är exakt vad vi behöver för att skapa denna nya 2×2 ”metapixel” från varje källpixel. Utdata visas sedan i ett popup-fönster.

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

Ändrad storlek på skärmupptagning:

Kommentarer

  • Att [1:2;2:3]==n är smart!Kan du ’ ta bort b=[a,a;a,a];?
  • @LuisMendo Tack =) Det fungerar verkligen, jag ’ t förvänta dig det!

Svar

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

Inmatningsfilnamnet ges i standardingång. Utdata till o.png.

Exempel på användning:

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

Mona Lisa med omvänd Bayer-filter tillämpat

Kommentarer

  • Välkommen till PPCG, trevligt första svar!

Svar

Mathematica 118 127 byte

Den ursprungliga inlämningen använde en faktisk bild som inmatning. Detta använder istället ett filnamn.

Det tillämpar två ersättningsregler för bilddata för den refererade filen:

  1. För varje rad i bilddatamatrisen, ersätt varje pixel { r, b, g} med en blå pixel, {0,0, b} följt av en grön pixel, {0, g, 0};
  2. Separat, för varje rad i bilddatamatrisen, ersätt varje pixel {r, b, g} med en grön pixel {0, g, 0} följt av en röd pixel, {r, 0,0};

Sedan Riffle (dvs. interfolierar) matriserna som härrör från 1 och 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"] 

omvänd bayer

Kommentarer

  • Inte säker, men detta verkar inte ’ t tillfredsställer ” Ta ett filnamn som i ingång
  • agtoever, den använder nu som inmatning ett filnamn istället för en bild.

Svar

J, 100 9 6 90 byte

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

Detta är ett skript i J som läser filnamnet på inmatningsbilden från stdin och matar ut resultatet till en fil med namnet o. Ingångs- och utmatningsbilderna kommer båda att vara i bmp -format. Det förväntar sig också att endast filnamnet matas in, vilket innebär att ledande och efterföljande tomrum inte bör finnas.

Exempelanvändning

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

Exempel

Förklaring

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" 

Svar

Python 2, 256 275 byte

Först förenklade jag originalkoden:

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

Minifiera sedan till:

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

Resultatet i bilden o.png:

o.png-bild efter bearbetning

Lämna ett svar

Din e-postadress kommer inte publiceras. Obligatoriska fält är märkta *