Guarda queste fotografie di scene naturali, con uno dei canali RGB estratti da esse:

Fonte (con rosso): https://en.wikipedia.org/wiki/File:Altja_j%C3%B5gi_Lahemaal.jpg

Fonte (con il verde): https://commons.wikimedia.org/wiki/File:2007_mather-lake_hg.jpg

Fonte (con il blu): https://commons.wikimedia.org/wiki/File:Fox_01.jpg

Anche senza uno dei canali, probabilmente puoi capire di che colore dovrebbero essere determinate cose, o almeno avere una buona idea se una ricostruzione del canale mancante è accurata.

Ad esempio, ecco la prima immagine con un canale rosso aggiunto su di essa che è solo rumore casuale:

Questa immagine chiaramente non è una ricostruzione accurata del canale rosso. Questo perché le foto naturalistiche generalmente non utilizzano l'intero spettro RGB, ma solo un sottoinsieme di "colori dall'aspetto naturale". Inoltre, le sfumature del rosso seguiranno determinati gradienti correlati agli altri.

Il tuo compito è costruire un programma che scatta una fotografia a cui è stato rimosso un canale e provare ad approssimare l'immagine originale il più vicino possibile ricostruendo quello che ritiene sia il canale mancante.

Il tuo programma verrà valutato in base alla corrispondenza del canale mancante con il canale dell'immagine originale, contando la percentuale di pixel i cui valori di quel canale si trovano entro ± 15 (incluso) del valore effettivo nell'immagine originale (dove i valori va da 0 a 255 come in un canale di colore standard a 8 bit).

I casi di test su cui verrà assegnato un punteggio al programma sono disponibili qui (file zip 9,04 MB, 6 immagini). Attualmente contiene solo le tre immagini di esempio sopra e i loro originali, ma ne aggiungerò alcune in seguito per creare la suite completa una volta che le ho fatte.

Ogni immagine viene ridimensionata e ritagliata a 1024 x 768, quindi avranno lo stesso peso nel punteggio. Vince il programma in grado di prevedere la maggior parte dei pixel entro la tolleranza data.

Python 3 + scikit-image

Imposta semplicemente il colore del canale mancante sulla media degli altri due.

import sys
from skimage import io, color

im = io.imread(sys.argv[1])
h, w, c = im.shape

removed_channel_options = {0, 1, 2}
for y in range(h):
    for x in range(w):
        if len(removed_channel_options) == 1: break
        removed_channel_options -= {i for i, c in enumerate(im[y][x]) if c > 0}
removed_channel = removed_channel_options.pop()

for y in range(h):
    for x in range(w):
        p = [float(c) / 255 for c in im[y][x][:3]]
        p = [sum(p)/2 if i == removed_channel else p[i]
             for i in range(3)]
        im[y][x] = [int(c*255) for c in p] + [255]*(c == 4)

io.imsave(sys.argv[2], im)

E le immagini ripristinate:

Lua, Love2D

Imposta semplicemente il canale mancante sul più piccolo dei due canali rimanenti.

local inp = love.image.newImageData(arg[2])

local channels = {1, 2, 3}
local removed = nil
local removed_options = {true,true,true}

inp:mapPixel(function(x,y,r,g,b)
    local o = {r,g,b}
    for k,v in pairs(o) do
        if v > 0 then
            removed_options[k] = false
        end
    end
    return r,g,b
end)

for k,v in pairs(removed_options) do
    if v then
        removed = k
        break
    end
end
inp:mapPixel(function(x,y,r,g,b)
    local o = {r,g,b}
    o[removed] = math.min(o[removed%3+1], o[(removed+1)%3 + 1])
    return unpack(o)
end)

inp:encode('png', IMAGE:gsub("%.png", "2.png"))

Accetta un nome file come argomento sulla riga di comando.

indennità

Ho provato a impostare il canale mancante su 255- (a + b), bloccando il valore. Quanto a "colmare il divario". I risultati sono inutili ma gloriosi.

E con 255- (a + b) / 2