Desafio:

Aceite duas imagens em preto e branco (monocromáticas) e xe cada pixel do primeiro, com cada pixel do segundo, adicione-os a uma nova imagem e produza a nova imagem.

Alguns esclarecimentos:

O tamanho das fotos não importa. O formato de extensão / imagem não importa. Você pode fazer com que você receba qualquer extensão e produza qualquer extensão, desde que a extensão seja usada para armazenar imagens digitais. Você também pode usar gráficos para desenhar a saída em, por exemplo: uma caixa de imagem, se desejar. Caso contrário, salve a saída como um arquivo. A entrada pode ser tomada como um caminho para a imagem ou URL.

Uma coisa que você não pode fazer, no entanto, são matrizes de E / S, por exemplo. de trigêmeos (R, G, B).

NÃO adultere alfa . Não deve ser xored, deve ser 255 (valor máximo) para cada pixel.

Como assim xor cada pixel?

Você não precisa fazer isso dessa maneira, mas uma maneira de x ou dois pixels é pegar seus valores RGB e xor R1 com R2, G1 com G2, B1 com B2 e pegar o resultado, que é sua nova cor

Como temos apenas duas cores, obviamente, quando as cores forem iguais, o resultado seria (0,0,0) e quando elas forem diferentes (branco é 255.255.255 e preto é 0,0,0) nesse caso, o resultado seria 255.255.255.

Assim, quando dois pixels são diferentes, o resultado é um pixel branco, senão um pixel preto

Exemplo de E / S:

Entrada 1: Entrada 2:

Saída:

Isso é código-golfe, então o código mais curto vence.

A linguagem de expressão FX (ImageMagick), 8 4 bytes

EDITS

• Simplificado para u!=v-4 bytes

Como "Fx Expression Language" está aparentemente completo de Turing, eu re-perfilei minha resposta a ela (era Unix Shell + Image Magick).

Golfe

u!=v

O Fx não suporta XOR bit a bit nem NOT bit a bit , então usei !=(o que funciona muito bem para as imagens BW puras).

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

Entrada e saída estão implícitas (controladas pelo intérprete).

Uso

O utilitário de conversão ImageMagick , serve como intérprete "Linguagem de expressão de câmbio", quando chamado com -fx, conforme ilustrado abaixo:

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

Os argumentos são:

1. Imagem de entrada A
2. Imagem de entrada B
3. Imagem de saída O (A ^ B).

Saída de amostra

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

Mathematica, 37 34 15 bytes

Agradecimentos a Ian Miller por reduzir o número de bytes em mais da metade!

ImageDifference

No final, sempre há um builtin. Esta função recebe duas imagens como entrada e produz uma imagem; faz algo mais complicado para imagens coloridas, mas para preto e branco é exatamente XOR.

Submissões anteriores:

Obrigado a JungHwan Min por salvar 3 bytes!

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

Função sem nome que recebe um par ordenado de imagens (de dimensões compatíveis) como entrada e retorna uma imagem exibida. ImageDataobtém apenas os dados de pixel sem todos os wrappers / metadados; infelizmente, ele retorna números reais, por isso Chopé necessário para ajudar a tratá-los como números inteiros. BitXorfaz exatamente o que diz na lata (e Imagepassa por cima de listas aninhadas) e transforma o RGB resultante novamente em uma imagem.

Envio original, que utilizou um par ordenado de URLs ou nomes de arquivos 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"));}}

Ungolfed:

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

Eu sou novo no golfe, então tenha piedade!

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

Obrigado ao @Blender e ao @ FlipTack por me salvarem 7 bytes!

Oitava, 43 38 34 bytes

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

Graças a flawr me salvou 5 bytes.

Graças a Luis Mendo me salvou 4 bytes sugeridos para uso em a~=bvez de xor(a,b).

Uma função que assume como nome de arquivo de entrada das duas imagens de entrada a,be mostra o resultado.

Resposta anterior que grava em um arquivo:

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

Uma função que assume como nome do arquivo de entrada das duas imagens de entrada a,be nome do arquivo da imagem de saída 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)

O resultado é salvo em out.png

JavaScript (ES6), 333 320 308 299 297 bytes

- 12 20 bytes salvos por Ismael Miguel
- 2 bytes salvos pelo usuário2428118

Espera imagens já carregadas, assume o tamanho da primeira entrada como tamanho de saída e retorna um elemento de tela.

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

Ungolfed

(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: Primeira vez no code-golf, então provavelmente ele pode jogar mais e minha contagem pode estar errada.

PPs: o contexto 2D da tela possui um xor[modo de composição ( https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation ), mas funciona com valores alfa ...

Pode ser ainda mais jogado (251 bytes) com um tamanho fixo de 300 * 150 px (o restante é preto), como na resposta de processamento

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

Processando, 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: esse código pode suportar imagens de até 400px(com modificações, até 999 para o mesmo número de conta). Qualquer espaço "restante" será colorido em preto; portanto, para obter melhores resultados, o tamanho da imagem deve ser do mesmo tamanho que as dimensões no código (também é size()necessário alterar as dimensões atualizadas)

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

Ungolfed

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

Explicação

Esta é basicamente a mesma resposta, como a solução Octave existente : Pega os nomes dos arquivos ou URLs das duas imagens como entradas e exibe o resultado na tela.

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

Não sei se o Perl é o melhor idioma para esse desafio, mas queria saber qual era a imagem do comentário do @ orlp. E isso me faz usar um pouco desses módulos gráficos, isso é uma coisa boa. E eu gostei de codificá-lo!

Uma versão mais legível:

use Imager ; 
$ img1 = novo gerador de imagens ( arquivo => $ ARGV [ 1 ] ); 
$ img2 = novo gerador de imagens ( arquivo => $ ARGV [ 0 ] );   

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

Você precisará instalar o Imager se quiser experimentá-lo, mas é bem simples: basta executar (echo y;echo) | perl -MCPAN -e 'install Imager'no seu 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")

Simples, pega dois arquivos de imagem na linha de comando e gera um arquivo chamado "Z" no diretório Love. Também funciona para imagens coloridas!

J, 54 bytes

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

Leva dois argumentos em que cada um é o caminho para uma imagem de entrada no bmpformato. Cada imagem é lida como uma matriz de números inteiros RGB de 24 bits e analisada em um trigêmeo de valores RGB de 8 bits, o sinal de cada um é obtido e as duas matrizes são XOR juntas. O resultado é redimensionado em 255, convertido novamente de um trigêmeo de 256 números base em um número inteiro e gravado em um bmparquivo de saída chamado 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 em imagens PBM. Ligue f(a, b, out)com os nomes dos arquivos de entrada e do arquivo de saída.

Suposições:

• Os dois cabeçalhos da imagem de entrada são idênticos (espaço em branco incluído) e têm menos que 9 * sizeof(int)caracteres.

• Estamos em um bom sistema operacional que libera e fecha os arquivos vazados.

• EOF == -1

Sem golfe e explicado: (barras invertidas omitidas)

// 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 (flexão de especificação), 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)

Ainda usa arquivos PBM, mas agora:

• A imagem deve ter um pixel de altura e 8 pixels de largura ou menos, porque o PBM comporta 8 pixels em um byte.

• O cabeçalho deve ter 7 bytes (por exemplo, P4 8 1com um espaço à direita).

Ambos os arquivos são procurados para a frente enquanto preenchem to cabeçalho; os últimos bytes são lidos, xor'd e gravados novamente. Aproveita freade fwritepossui listas de parâmetros semelhantes para fatorar todas as três operações no cabeçalho atrás da mesma macro.

R, 45 bytes

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

ae brepresente os nomes dos dois arquivos de imagem.

Exemplo:

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

Saída:

Processando, 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 das extensas funções de desenho do Processing para evitar a execução de qualquer XOR. Combina as duas imagens com o DIFFERENCEmodo e as desenha na tela.

Uso

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

Ungolfed

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

Obrigado a Unknown6656 pela dica de que os argumentos da linha de comando não são necessários. O programa agora lê os arquivos "a" e "b" e grava no arquivo "c" no mesmo formato que "a". Desativado por um erro corrigido também.

Ele define cada pixel como preto se a cor for a mesma, caso contrário, branca.

Para salvar bytes, ele captura exceções fora dos limites, em vez de verificar as propriedades Largura e Altura dos Bitmaps. Cada vez que x sai dos limites, é redefinido para 0 e y é incrementado. Quando y sai dos limites, x é 0 e o loop é interrompido para salvar a imagem e sair.

Exemplo de compilação usando csc e execução 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"))))

Rascunho flagrante da resposta Java . Eu não sabia como fazer o desafio, mas estava curioso para saber como a solução Java se traduzia no Clojure. Foi bem direto. O código não destruído é realmente bonito.

Este foi o primeiro desafio de código-golfe que fiz que incluiu importações. Provavelmente existe uma maneira de otimizá-los para economizar alguns bytes.

Ungolfed:

(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

Provavelmente posso jogar mais isso.

$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);

Execute-o na linha de comando da seguinte maneira:

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

Os arquivos de imagem de entrada e saída devem estar no formato PBM (P1), onde está a primeira linha P1 [width] [height]e a segunda linha são os valores ascii em preto e branco sem espaços.

Aqui estão as imagens de entrada seguidas pela saída xor (32x32 pixels):