Simplemente tomaría esta imagen y haría que cada color se agregara uno a cada dígito hexadecimal. Por ejemplo, #49de5fse convertiría #5aef60(con el 9bucle a un a, y el fbucle a un 0.)

Esto también significaría que todo el blanco ( #ffffff) se volvería negro ( #000000) porque todos los fbucles vuelven a 0, pero todo el negro se convertirá en un tono más claro de negro ( #111111).

La puntuación se basa en el menor número de bytes utilizados, ya que esta es una pregunta de código de golf .

Use la imagen de abajo como la imagen de entrada para su código, y ponga la imagen de salida de su código en su respuesta.

Si lo desea, también puede usar esta otra imagen del arco iris:

Pyke, 17 13 bytes

.Fh16j%ijcjs 8{

Pruébalo aquí!

.F            - for i in deep_for(input):
  h16%        -    (i+1)%16
          +   -   ^+V
      i16+    -    (i+16)
           8{ -  unset_bit(8, ^)

Toma la entrada como una matriz de píxeles enteros en 3D y las salidas en el mismo formato

Mathematica, 78 bytes

Image@Apply[16#+#2&,Mod[IntegerDigits[#~ImageData~"Byte",16,2]+1,16]/255,{3}]&

Toma y devuelve un objeto de imagen (para crear un objeto de imagen, simplemente pegue la imagen en Mathematica).

Resultado para el caso de prueba:

Tomando la entrada y la salida de retorno como una matriz 3D de valores de canales enteros, esto se reduce a 51 bytes :

Apply[16#+#2&,Mod[IntegerDigits[#,16,2]+1,16],{3}]&

Pero esas meta publicaciones aún no tienen una cantidad abrumadora de soporte, por lo que voy con la versión de 78 bytes por ahora.

Verilog, 220 bytes:

• Los programas pueden tomar datos como una matriz de valores de píxeles RGB con dimensiones
• Los programas pueden emitirse a través de una matriz de valores de píxeles RGB con dimensiones

Actualmente no está claro cómo se deben proporcionar las dimensiones y si la matriz se debe transmitir o proporcionar de una vez. Voy a transmitirlo 8 bits a la vez usando una señal de reloj (con un indicador de datos válidos que baja cuando se procesa toda la imagen) e ingresar / emitir las dimensiones como enteros de 32 bits:

module a(input[31:0]w,input[31:0]h,input[7:0]d,input c,output[31:0]W,output[31:0]H,output reg[7:0]D,output reg v=0);assign W=w;assign H=h;reg[65:0]p=1;always@(posedge c) begin v<=(p<3*w*h); p<=p+v; D<=d+17; end endmodule

Python, 226 bytes

¡Ahora es válido!

Usa la biblioteca Pillow.

from PIL import Image
m=Image.open(input()).convert("RGB")
for y in range(m.size[1]):
 for x in range(m.size[0]):
    t=m.getpixel((x,y))
    h=t[0]+(t[1]<<8)+(t[2]<<16)+1118481
    m.putpixel((x,y),(h&255,h>>8&255,h>>16&255))
m.show()

Salida:

¡Gracias a @TuukkaX por guardar 9 bytes!
¡Gracias a @ mbomb007 por guardar 18 bytes!

Dyalog APL , 21 15 bytes

Los programas pueden salir como una matriz de valores de píxeles RGB

Supongo que la salida puede estar en el mismo formato.

La nueva solución toma una matriz de valores [[ r , g , b , r , g , b ], [ r , g , b , ...

16⊥16|1+16 16⊤⎕

Explicación

⎕obtener entrada numérica
16 16⊤convertir a base de 2 dígitos 16
1+sumar 1, es decir 0 → 1, 1 → 2, 15 → 16
16|módulo 16, es decir 16 → 0
16⊥convertir de base 16

Ejemplo

      ⊢m←2 6⍴90 239 96 255 255 255 0 0 0 239 239 239
90 239 96 255 255 255
 0   0  0 239 239 239
      16⊥16|1+⎕⊤⍨2/16
⎕:
      m
107 240 113   0   0   0
 17  17  17 240 240 240

La solución antigua de 21 bytes toma la matriz de [["RRGGBB", "RRGGBB"], ["RRGGBB", ...

{n[16|1+⍵⍳⍨n←⎕D,⎕A]}¨

Necesidades ⎕IO←0, lo cual es predeterminado en muchos sistemas.

Explicación

{... }¨para cada cadena RGB de 6 caracteres, se representa como ⍵y se hace:
n←⎕D,⎕Aasigne "0 ... 9A ... Z" para n
⍵⍳⍨ encontrar índices de los caracteres individuales en n
1+ agregue uno al índice, es decir, 0 → 1, 1 → 2, 15 → 16
16|módulo 16, es decir 16 → 0
n[... ]use eso para indexar en n

Ejemplo

      f←{n[16|1+⍵⍳⍨n←⎕D,⎕A]}¨ 
      ⊢p←2 2⍴'5AEF60' 'FFFFFF' '000000' 'EFEFEF'
┌──────┬──────┐
│5AEF60│FFFFFF│
├──────┼──────┤
│000000│EFEFEF│
└──────┴──────┘
      f p           
┌──────┬──────┐
│6BF071│000000│
├──────┼──────┤
│111111│F0F0F0│
└──────┴──────┘

C - 114 113 70 66 61 72 67 bytes

Aquí está el código (con soporte para el caso de prueba de Martin Ender (sin que sea 60b)):

main(c,b){for(;~(b=getchar());putchar(c++<54?b:b+16&240|b+1&15));}

Y aquí hay una versión menos ofuscada:

main( c, b ) //Defaults to int
{
    //Get characters until EOF occurs
    //Copy first 54 bytes of header, later add 1 to each hexadecimal digit
    for ( ; ~( b = getchar( ) ); putchar( c++ < 54 ? b: b + 16 & 240 | b + 1 & 15 ) ); 
}

Compilar y ejecutar con gcc -o color colorgolf.c && cat a.bmp | ./color > b.bmp

Este código admite trabajos con mapas de bits . Para convertir pngarchivos bmp, utilicé el siguiente comando:convert -flatten -alpha off png.png a.bmp

El código asume que el bmpencabezado tiene 54 bytes de longitud, en este caso funciona, pero no estoy seguro si no estoy rompiendo algo discretamente.

Además, este es el arcoiris:

Java 142 bytes

public BufferedImage translateColor(BufferedImage image){
  for(int i=-1;++i<image.getWidth();)
    for(int j=-1;++<image.getHeight();)
      image.setRGB(i,j,image.getRGB(i,j)+1118481);
  return image;
}

Golfizado:

BufferedImage t(BufferedImage i){for(int x=-1;++x<i.getWidth();)for(int y=-1;++y<i.getHeight();)i.setRGB(x,y,i.getRGB(x,y)+1118481);return i;}

R, 302 bytes

Lejos de ser perfecto, pero aquí va:

a<-as.raster(imager::load.image(file.choose()));l=letters;n=as.numeric;d=a;f=function(x){if(suppressWarnings(is.na(n(x)))){if(x=="F")"0" else{l[match(x,toupper(l))+1]}}else{if(x==9)"A" else as.character(n(x)+1)}};for(o in 1:90){for(g in 1:200){for(h in 2:7){substr(d[o,g],h,h)<-f(substr(a[o,g],h,h))}}}

Explicación:

a<-as.raster(imager::load.image(file.choose()));  //chooses file
l=letters;n=as.numeric;d=a;                      //shortens some names and creates
                                                   duplicate variable to modify

f=function(x){                                //creates a function that takes in a
   if(suppressWarnings(is.na(n(x)))){            character type and checks whether it is
      if(x=="F")"0"                              a number or letter.
      else{l[match(x,toupper(l))+1]}}            Returns the converted letter or number.                               
   else{                                   
      if(x==9)"A"                         
      else as.character(n(x)+1)}         
};                                      

for(o in 1:90){                       //loops through every single hex digit and applies
   for(g in 1:200){                     the converting function, modifying the duplicate
      for(h in 2:7){                    variable. Now you have 2 images =D

         substr(d[o,g],h,h)<-f(substr(a[o,g],h,h))

      }
   }
}