Reto:

Tome la entrada de dos imágenes en blanco y negro (monocromo) y xor cada píxel del primero, con cada píxel del segundo, agréguelos a una nueva imagen y envíe la nueva imagen.

Algunas aclaraciones:

El tamaño de las imágenes no importa. El formato de extensión / imagen no importa. Puede hacer que ingrese cualquier extensión y produzca cualquier extensión, siempre que la extensión se use para almacenar imágenes digitales. También puede usar gráficos para dibujar la salida en, por ejemplo, un cuadro de imagen si lo desea. De lo contrario, guarde la salida como un archivo. La entrada se puede tomar como una ruta a la imagen o url.

Sin embargo, una cosa que no puede hacer son las matrices de E / S, por ejemplo. de trillizos (R, G, B).

NO manipule alfa . No debe ser xored, debe ser 255 (valor máximo) por cada píxel.

¿Qué quieres decir con xo cada píxel?

No tiene que hacerlo de esta manera, pero una forma de xor dos píxeles es tomar sus valores RGB y xor R1 con R2, G1 con G2, B1 con B2 y tomar el resultado, que es su nuevo color

Como solo tenemos dos colores, obviamente cuando los colores son iguales, el resultado sería (0,0,0) y cuando son diferentes (el blanco es 255,255,255 y el negro es 0,0,0) en este caso, el resultado sería ser 255,255,255.

Por lo tanto, cuando dos píxeles son diferentes, el resultado es un píxel blanco, de lo contrario, un píxel negro

Ejemplo de E / S:

Entrada 1: Entrada 2:

Salida:

Este es el código de golf, por lo que gana el código más corto.

El lenguaje de expresión Fx (ImageMagick), 8 4 bytes

EDICIONES

• Simplificado a u!=v-4 bytes

Como "Fx Expression Language" aparentemente se está completando, volví a perfilar mi respuesta (fue Unix Shell + Image Magick).

Golfed

u!=v

Fx no admite XOR a nivel de bit ni NOT a nivel de bit , así que lo he usado en su !=lugar (que funciona bien para las imágenes BW puras).

u=> stands for "first image in list"
v=> "second image in list"

La entrada y la salida son implícitas (controladas por el intérprete).

Uso

La utilidad de conversión ImageMagick , sirve como el intérprete de "Lenguaje de expresión Fx", cuando se invoca con -fx, como se ilustra a continuación:

convert $1 $2 -fx u!=v $3

Los argumentos son:

1. Imagen de entrada A
2. Imagen de entrada B
3. Imagen de salida O (A ^ B).

Salida de muestra

convert a.png b.png -fx u!=v o.png

Mathematica, 37 34 15 bytes

¡Gracias a Ian Miller por reducir el número de bytes a más de la mitad!

ImageDifference

Al final, siempre hay un incorporado. Esta función toma dos imágenes como entrada y emite una imagen; hace algo más complicado para las imágenes en color, pero para blanco y negro es exactamente XOR.

Envíos anteriores:

¡Gracias a JungHwan Min por guardar 3 bytes!

Image[BitXor@@Chop[ImageData/@#]]&

Función sin nombre que toma un par ordenado de imágenes (de dimensiones compatibles) como entrada y devuelve una imagen mostrada. ImageDataobtiene solo los datos de píxeles sin todos los contenedores / metadatos; desafortunadamente, devuelve números reales, por lo que Chopes necesario para ayudar a tratarlos como enteros. BitXorhace exactamente lo que dice en la lata (y los hilos sobre listas anidadas), y Imageconvierte el RGB resultante en una imagen.

Envío original, que tomó un par ordenado de URL o nombres de archivo como entrada:

Image[BitXor@@(#~Import~"Data"&/@#)]&

Java, 336 335 328 bytes

import static javax.imageio.ImageIO.*;import java.io.*;public class M{static void main(String[]y)throws Exception{java.awt.image.BufferedImage a=read(new File("a.png"));for(int i=0,j;i<a.getHeight();i++)for(j=0;j<a.getWidth();)a.setRGB(j,i,a.getRGB(j,i)^read(new File("b.png")).getRGB(j++,i));write(a,"png",new File("c.png"));}}

Sin golf:

import static javax.imageio.ImageIO.*;

import java.io.*;

class M {
    public static void main(String[]y) throws Exception {
        java.awt.image.BufferedImage a = read(new File("a.png"));
        for (int i = 0, j; i < a.getHeight(); i++)
            for (j = 0; j < a.getWidth(); ) a.setRGB(j, i, a.getRGB(j, i) ^ read(new File("b.png")).getRGB(j++, i));
        write(a, "png", new File("c.png"));
    }
}

Python, 64 60 57 bytes

Soy nuevo en el golf, ¡así que ten piedad!

from cv2 import*
r=imread;lambda a,b:imshow('c',r(a)^r(b))

¡Gracias a @Blender y @FlipTack por salvarme 7 bytes!

Octava, 43 38 34 bytes

@(a,b)imshow(imread(a)~=imread(b))

Gracias a flawr me ahorró 5 bytes.

Gracias a Luis Mendo me ahorró 4 bytes sugeridos para usar en a~=blugar de xor(a,b).

Una función que toma como nombre de archivo de entrada las dos imágenes de entrada a,by muestra el resultado.

Respuesta anterior que escribe en un archivo:

@(a,b,c)imwrite(imread(a)~=imread(b),c)

Una función que toma como nombre de archivo de entrada las dos imágenes de entrada a,by el nombre de archivo de la imagen de salida c.

Uso:

#two test images that used in the question
#https://i.stack.imgur.com/UbbfM.png
#https://i.stack.imgur.com/YyZG2.png
A = "UbbfM.png"; 
B = "YyZG2.png"; 
C = "out.png";
(@(a,b,c)imwrite(imread(a)~=imread(b),c))(A,B,C)

El resultado se guarda en out.png

JavaScript (ES6), 333 320 308 299 297 bytes

- 12 20 bytes guardados por Ismael Miguel
- 2 bytes guardados por el usuario2428118

Espera imágenes ya cargadas, toma el tamaño de la primera entrada como tamaño de salida y devuelve un elemento de lienzo.

(i,j)=>{c=i=>{with(document.createElement(C='canvas')){width=i.width,height=i.height;return getContext`2d`}},g=i=>{x=c(i);x.drawImage(i,0,0);return x.getImageData(0,0,i.width,i.height)},a=g(i),b=g(j).data,d=a.data,r=c(i);d.forEach((e,i)=>{d[i]=i%4>2?255:e^b[i]});r.putImageData(a,0,0);return r[C]}

let func = (i,j)=>{c=i=>{with(document.createElement(C='canvas')){width=i.width,height=i.height;return getContext`2d`}},g=i=>{x=c(i);x.drawImage(i,0,0);return x.getImageData(0,0,i.width,i.height)},a=g(i),b=g(j).data,d=a.data,r=c(i);d.forEach((e,i)=>{d[i]=i%4>2?-1:e^b[i]});r.putImageData(a,0,0);return r[C]}

window.onload =_=>{
  document.body.appendChild(func(img1, img2));
  }

<img id="img1" crossOrigin="anonymous" src="https://dl.dropboxusercontent.com/s/nnfkzpvabk77pnl/UbbfM.png">
<img id="img2" crossOrigin="anonymous" src="https://dl.dropboxusercontent.com/s/58euf43vcb9pvpa/YyZG2.png">

Sin golf

(i, j) => {
  c = i => { // an helper to create a canvas object
      with(document.createElement(C='canvas')) {
        width= i.width,
        height= i.height;
        return getContext`2d`
      }
    },
    g = i => { // an helper to get an imageData object
      x = c(i);
      x.drawImage(i, 0, 0);
      return x.getImageData(0, 0, i.width, i.height)
    },
    a = g(i),
    b = g(j).data,
    d = a.data,
    r = c(i);
  d.forEach((e, i) => { // loop through all rgba values
    d[i] = i % 4 > 2 ? 255 : e ^ b[i] // we need to avoid alpha channel...
  });
  r.putImageData(a, 0, 0);
  return r[C]
}

Ps: primera vez en code-golf, por lo que probablemente se pueda jugar más y mi cuenta podría ser errónea.

PP: el contexto 2D de lienzo tiene un xor[modo de composición ( https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation ), pero funciona en valores alfa ...

Se podría jugar aún más (251 bytes) con un tamaño fijo de 300 * 150 px (todo lo que queda es negro) como en la respuesta de Procesamiento

(i,j)=>{c=i=>{return document.createElement(C='canvas').getContext('2d')},g=i=>{x=c(i);x.drawImage(i,0,0);return x.getImageData(0,0,W=300,W)},a=g(i),b=g(j).data,d=a.data,r=c(i);d.forEach((e,i)=>{d[i]=i%4>2?W:e^b[i]});r.putImageData(a,0,0);return r[C]}

let func = (i,j)=>{c=i=>{return document.createElement(C='canvas').getContext('2d')},g=i=>{x=c(i);x.drawImage(i,0,0);return x.getImageData(0,0,W=300,W)},a=g(i),b=g(j).data,d=a.data,r=c(i);d.forEach((e,i)=>{d[i]=i%4>2?W:e^b[i]});r.putImageData(a,0,0);return r[C]}

window.onload =_=>{
  document.body.appendChild(func(img1, img2));
  }

<img id="img1" crossOrigin="anonymous" src="https://dl.dropboxusercontent.com/s/nnfkzpvabk77pnl/UbbfM.png">
<img id="img2" crossOrigin="anonymous" src="https://dl.dropboxusercontent.com/s/58euf43vcb9pvpa/YyZG2.png">

Procesamiento, 124 118 117 bytes

void m(PImage a,PImage q){for(int i=0,j;i<400;i++)for(j=0;j<400;point(i,j++))stroke((a.get(i,j)^q.get(i,j))<9?0:-1);}

Uso:

Nota: este código puede admitir imágenes hasta 400px(con modificaciones puede admitir hasta 999 para el mismo bytecount). Cualquier espacio "sobrante" será de color negro, por lo que para obtener mejores resultados, el tamaño de la imagen debe ser del mismo tamaño que las dimensiones del código (también size()debe cambiarse con las dimensiones actualizadas)

m(loadImage("http://i.imgur.com/a0M6o9e.png"),loadImage("http://i.imgur.com/bP1TsjQ.png"));

m(loadImage("https://i.stack.imgur.com/UbbfM.png"),loadImage("https://i.stack.imgur.com/YyZG2.png"));

Sin golf

void Q106945(PImage a,PImage q){     // takes two images as input
  for(int i=0,j;i<400;i++)           // looping through the x-coordinates
    for(j=0;j<400;point(i,j++))      // looping through the y-coordinates
      stroke((a.get(i,j)^q.get(i,j))<9?0:-1);
/*
Here we have to colour the point according to the xor. So we do a simple 
a.get(i,j)^q.get(i,j). But since the alpha gets xored, instead of outputting white, this
outputs a colour with alpha 0 (completely invisible). So to fix this I have a ternary that
checks the value and changes the colour accordingly. At the end of all this, the third 
statement of the for-loop with j gets triggered since all this code is in this for-loop. 
Now we draw a point over the coordinate with the colour we have chosen before.
*/
}

MATL , 10 bytes

YiiYiY~1YG

Explicación

Esta es básicamente la misma respuesta, como la solución Octave existente : toma los nombres de archivo o URL de ambas imágenes como entradas y muestra el resultado en la pantalla.

Yi    % Read first image from the URL or filename (implicit input)
i     % Get the second URL or filename as input
Yi    % Read that second image
Y~    % XOR the two images
1     % Push 1 (needed to make YG act as imagesc)
YG    % Display result using the MATLAB imagesc function

Uso

>> matl
 > YiiYiY~1YG
 > 
> 'https://i.stack.imgur.com/UbbfM.png'
> 'https://i.stack.imgur.com/YyZG2.png'

Perl, 260 bytes

251 bytes de código + 9 bytes para -MImager.

($i,$j)=map{new Imager(file,pop)}0,1;$p=getpixel;for$x(0..$i->getwidth()-1){$i->setpixel(x=>$x,y=>$_,color=>[map{($j->$p(%t)->rgba)[$c++%3]^$_?0:255}($i->$p(%t=(x=>$x,y=>$_,type=>'8bit'))->rgba)[0..2]])for 0..$i->getheight()-1}$i->write(file=>'a.png')

No estoy seguro de que Perl sea el mejor lenguaje para este desafío, pero quería saber cuál fue la imagen del comentario de @ orlp. Y me hace usar un poco de esos módulos gráficos, eso es algo bueno. ¡Y disfruté codificándolo!

Una versión más legible:

usar Imager ; 
$ img1 = nuevo Imager ( archivo => $ ARGV [ 1 ] ); 
$ img2 = nuevo generador de imágenes ( archivo => $ ARGV [ 0 ] );   

para $ x ( 0 .. $ img1 -> getwidth () - 1 ) { para $ y ( 0 .. $ img1 -> getheight () - 1 ) { ( $ r1 , $ g1 , $ b1 ) = $ img1 - > getpixel ( x => $ x , y => $ y , type => "8bit" ) -> rgba (); ( $ r2 , $ g2    
        
       
    , $ b2 ) = $ img2 -> getpixel ( x => $ x , y => $ y , type => "8bit" ) -> rgba (); 
    $ r = $ r1 ^ $ r2 ? 0 : 255 ; 
    $ g = $ g1 ^ $ g2 ? 0 : 255 ; 
    $ b = $ b1 ^ $ b2 ? 0 : 255 ; 
    $ img1               -> setpixel ( x => $ x , y => $ y , color => [ $ r , $ g , $ b ] ); } } 
$ img1 -> write ( archivo => 'a.png' )  
    
  

Tendrá que instalar Imager si quiere probarlo, pero es bastante simple: simplemente ejecute (echo y;echo) | perl -MCPAN -e 'install Imager'en su terminal.

LÖVE2D , 199 bytes

u,c=... i=love.image.newImageData a=math.abs X=i(u)Y=i(c)Z=i(X:getDimensions())Z:mapPixel(function(x,y)r,g,b=X:getPixel(x,y)R,G,B=Y:getPixel(x,y)return a(r-R),a(g-G),a(b-B)end)Z:encode("png","Z")

Bastante simple, toma dos archivos de imagen en la línea de comando, emite un archivo llamado "Z" en el directorio Love. ¡También funciona para imágenes a todo color!

J, 54 bytes

load'bmp'
'o'writebmp~256#.255*~:&*&((3#256)#:readbmp)

Toma dos argumentos donde cada uno es el camino a una imagen de entrada en bmpformato. Cada imagen se lee como una matriz de enteros RGB de 24 bits y se analiza en un triplete de valores RGB de 8 bits, se toma el signo de cada uno y las dos matrices se unen en XOR. El resultado luego se escala en 255, se convierte de nuevo desde un triplete de números base 256 en un número entero y se escribe en un bmparchivo de salida llamado o.

C, 189 bytes

#include<stdio.h>
s,t[9];
#define o(f,p)int*f=fopen(p,"ab+");
#define f(p,q,r)o(a,p)o(b,q)o(c,r)fscanf(a,"%*s %*d %*d %n",&s);for(fwrite(t,1,fread(t,1,s,b),c);s=~getc(a);putc(~s^getc(b),c))

Opera en imágenes PBM. Llame f(a, b, out)con los nombres de ambos archivos de entrada y el archivo de salida.

Suposiciones

• Ambos encabezados de imagen de entrada son idénticos (espacios en blanco incluidos) y tienen menos de 9 * sizeof(int)caracteres.

• Estamos en un buen sistema operativo que descarga y cierra los archivos filtrados.

• EOF == -1

Ungolfed y explicó: (se omiten las barras invertidas)

// Scratch variable and "big enough" buffer
s, t[9];

// Opens a file in read/append binary mode
#define o(f,p)int*f=fopen(p,"ab+");

#define f(p, q, r)

    // Open the three file pointers a, b, c from the paths p, q, r
    o(a, p)
    o(b, q)
    o(c, r)

    // Read from a to locate the end of the PBM header
    fscanf(a, "%*s %*d %*d %n", &s);

    for(
        // Read the header from b into the buffer,
        // then write it back from the buffer to c
        fwrite(t, 1, fread(t, 1, s, b), c);

        // Loop condition: get the next byte from a
        // and check for EOF with a bitwise-not
        // (Assumes that EOF == -1)
        s = ~getc(a);

        // Loop increment: get the next byte from b,
        // flip s back, xor and write to c
        putc(~s ^ getc(b), c)

    ) // Snatch the semicolon from the call syntax :)

C (flexión de especificaciones), 149 bytes

#include<stdio.h>
t[7];
#define o(f,p,u)int*f=fopen(p,"ab+");u(t,1,7,f);
#define f(p,q,r)o(a,p,fread)o(b,q,fread)o(c,r,fwrite)putc(getc(a)^getc(b),c)

Todavía usa archivos PBM, pero ahora:

• La imagen tiene que tener un píxel de alto y 8 píxeles de ancho o menos, porque PBM incluye 8 píxeles en un byte.

• El encabezado debe ser de 7 bytes (por ejemplo, P4 8 1con un espacio final).

Ambos archivos se buscan hacia adelante mientras se llenan tcon su encabezado, luego los últimos bytes se leen, graban y vuelven a escribir. Aprovecha fready fwritetiene listas de parámetros similares para factorizar las tres operaciones en el encabezado detrás de la misma macro.

R, 45 bytes

p=png::readPNG;plot(as.raster(+(p(a)!=p(b))))

ay brepresentan los nombres de archivo de los dos archivos de imagen.

Ejemplo:

a <- "YyZG2.png"
b <- "UbbfM.png"
p=png::readPNG;plot(as.raster(+(p(a)!=p(b))))

Salida:

Procesamiento, 82 bytes

void x(PImage a,PImage b){int x=b.width;b.blend(a,0,0,x,x,0,0,x,x,32);set(0,0,b);}

Abusa de las amplias funciones de dibujo de Processing para evitar hacer XORing. Combina las dos imágenes con el DIFFERENCEmodo y las dibuja en la pantalla.

Uso

x(loadImage("http://i.imgur.com/a0M6o9e.png"),loadImage("http://i.imgur.com/bP1TsjQ.png"));

Sin golf

void xor(PImage a, PImage b) {
  int x = a.width;
  b.blend(a, 0, 0, x, x, 0, 0, x, x, DIFFERENCE);
  set(0, 0, b);
}

C #, 233 bytes

using System.Drawing;class C{static void Main(){Bitmap
a=new Bitmap("a"),b=new Bitmap("b");for(int
x=0,y=0;;)try{a.SetPixel(x,y,a.GetPixel(x,y)==b.GetPixel(x,y)?Color.Black:Color.White);x++;}catch{if(x<1)break;x=0;++y;}a.Save("c");}}

Gracias a Unknown6656 por el consejo de que los argumentos de la línea de comandos no son necesarios. El programa ahora lee de los archivos "a" y "b" y escribe en el archivo "c" en el mismo formato que "a". Apagado por un error solucionado también.

Establece cada píxel en negro si el color es el mismo, de lo contrario blanco.

Para guardar bytes, captura excepciones fuera de límites, en lugar de verificar las propiedades Ancho y Altura de los mapas de bits. Cada vez que x sale de los límites, se restablece a 0 ey se incrementa. Cuando y sale de los límites, x es 0 y el bucle se rompe para guardar la imagen y salir.

Ejemplo compilar usando csc y ​​ejecutar usando mono:

csc xor.cs

mono xor.exe

Clojure, 300 bytes

(ns s(:import[java.io File][java.awt.image BufferedImage][javax.imageio ImageIO]))(defn -main[](let[a(ImageIO/read(File."a.png"))](doseq[i(range(.getHeight a))j(range(.getWidth a))](.setRGB a j i(bit-xor(.getRGB a j i)(.getRGB(ImageIO/read(File."b.png")) j i))))(ImageIO/write a"png"(File."c.png"))))

Estafa flagrante de la respuesta de Java . No sabía cómo hacer el desafío, pero tenía curiosidad por saber qué tan bien se tradujo la solución Java en Clojure. Fue bastante sencillo. El código no protegido es realmente bonito.

Este fue el primer desafío de código de golf que hice que incluyó importaciones. Probablemente haya una forma de optimizarlos para guardar algunos bytes.

Sin golf:

(ns bits.golf.bit-or-picts
  (:import [java.io File]
           [java.awt.image BufferedImage]
           [javax.imageio ImageIO]))

(defn -main []
  (let [^BufferedImage a (ImageIO/read (File. "a.png"))
        ^BufferedImage b (ImageIO/read (File. "b.png"))]
    (doseq [i (range (.getHeight a))
            j (range (.getWidth a))]
      (.setRGB a j i
                (bit-xor (.getRGB a j i)
                         (.getRGB b j i))))
    (ImageIO/write a "png" (File. "c.png"))))

PHP 246 243 bytes

Probablemente pueda jugar más golf.

$o=imagecreatetruecolor($w=max(imagesx($a=($i=imagecreatefrompng)($argv[1])),imagesx($b=$i($argv[2]))),$h=max(imagesy($a),imagesy($b)));for(;$k<$w*$h;)imagesetpixel($o,$x=$k%$w,$y=$k++/$w,($t=imagecolorat)($a,$x,$y)^$t($b,$x,$y));imagepng($o);

Ejecútelo desde la línea de comando así:

php -d error_reporting=0 -r "$o=imagecreatetruecolor($w=max(imagesx($a=($i=imagecreatefrompng)($argv[1])),imagesx($b=$i($argv[2]))),$h=max(imagesy($a),imagesy($b)));for(;$k<$w*$h;)imagesetpixel($o,$x=$k%$w,$y=$k++/$w,($t=imagecolorat)($a,$x,$y)^$t($b,$x,$y));imagepng($o);" "http://i.stack.imgur.com/UbbfM.png" "http://i.stack.imgur.com/YyZG2.png" > output.png

Node.js, 156 135 bytes

(a,b)=>(f=require('fs')).writeFile(a+b,((s=f.readFileSync)(a)+'').replace(/\d+$/,(c,d)=>[...c].map((e,f)=>+!(e^(s(b)+b)[f+d])).join``))

Los archivos de imagen de entrada y salida deben estar en formato PBM (P1), donde está la primera línea P1 [width] [height], y la segunda línea son los valores ascii b / w sin espacios.

Aquí están las imágenes de entrada seguidas de la salida xor (32x32 píxeles):