Veja estas fotografias de cenas naturais, com um dos canais RGB retirados:

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

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

Fonte (com azul): https://commons.wikimedia.org/wiki/File:Fox_01.jpg

Mesmo sem um dos canais, você provavelmente pode descobrir quais cores certas coisas deveriam ter ou pelo menos ter uma boa idéia se uma reconstrução do canal ausente for precisa.

Por exemplo, aqui está a primeira imagem com um canal vermelho adicionado a ele, que é apenas um ruído aleatório:

Esta imagem claramente não é uma reconstrução precisa do canal vermelho. Isso ocorre porque as fotos da natureza geralmente não usam todo o espectro RGB, mas apenas um subconjunto de "cores naturais". Além disso, os tons de vermelho seguirão certos gradientes que se correlacionam com os outros.

Sua tarefa é criar um programa que tire uma fotografia com um canal removido e tente aproximar a imagem original o mais próximo possível, reconstruindo o que acredita ser o canal ausente.

Seu programa será pontuado com a proximidade entre o canal ausente e o canal da imagem original, contando a porcentagem de pixels cujos valores desse canal estão dentro de ± 15 (inclusive) do valor real na imagem original (onde os valores de 0 a 255, como em um canal de cores padrão de 8 bits).

Os casos de teste nos quais seu programa será classificado podem ser encontrados aqui (arquivo zip de 9,04 MB, 6 imagens). Atualmente, ele contém apenas as três imagens de exemplo acima e seus originais, mas adicionarei mais algumas depois para compor o conjunto completo depois que as tiver feito.

Cada imagem é reduzida e cortada para 1024 x 768, para que tenham o mesmo peso na sua pontuação. O programa que pode prever o maior número de pixels dentro da tolerância fornecida vence.

Imagem do scikit do Python 3 +

Simplesmente define a cor do canal ausente como a média dos outros dois.

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 as imagens restauradas:

Lua, Love2D

Apenas define o canal ausente para o menor dos dois canais restantes.

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

Leva um nome de arquivo como argumento na linha de comando.

Bônus

Tentei definir o canal ausente como 255- (a + b), fixando o valor. Quanto a "preencher a lacuna". Os resultados são inúteis, mas gloriosos.

E com 255- (a + b) / 2