Wyzwanie:

Wprowadź dwa czarno-białe (monochromatyczne) obrazy i xor każdego piksela pierwszego, z każdym pikselem drugiego, dodaj je do nowego obrazu i wyślij nowy obraz.

Kilka wyjaśnień:

Rozmiar zdjęć nie ma znaczenia. Format rozszerzenia / obrazu nie ma znaczenia. Możesz wprowadzić dowolne rozszerzenie i wyprowadzić dowolne rozszerzenie, o ile rozszerzenie jest używane do przechowywania obrazów cyfrowych. Możesz także użyć grafiki, aby narysować dane wyjściowe np. W ramce obrazu, jeśli chcesz. W przeciwnym razie zapisz wynik jako plik. Dane wejściowe można traktować jako ścieżkę do obrazu lub adresu URL.

Jedną rzeczą, której nie możesz zrobić, są tablice I / O, np. trypletów (R, G, B).

NIE manipuluj przy alfa . Nie powinien być xoredowany, powinien wynosić 255 (maksymalna wartość) na każdy piksel.

Co masz na myśli xor każdego piksela?

Nie musisz tego robić w ten sposób, ale jednym ze sposobów na xor dwa piksele jest pobranie ich wartości RGB i xor R1 z R2, G1 z G2, B1 z B2 i przyjęcie wyniku, który jest twoim nowym kolorem

Ponieważ mamy tylko dwa kolory, oczywiście gdy kolory są takie same, wynik byłby (0,0,0), a gdy są one różne (biały to 255,255,255, a czarny to 0,0,0) w tym przypadku wynik byłby być 255,255,255.

Zatem, gdy dwa piksele są różne, wynikiem jest biały piksel, w przeciwnym razie czarny piksel

Przykład I / O:

Wejście 1: Wejście 2:

Wydajność:

To jest golf golfowy, więc wygrywa najkrótszy kod.

The Fx Expression Language (ImageMagick), 8 4 bajty

EDYCJE

• Uproszczony do u!=v-4 bajtów

Ponieważ „Fx Expression Language” najwyraźniej jest już ukończony, zmieniłem profil mojej odpowiedzi (była to Unix Shell + Image Magick).

Grał w golfa

u!=v

Fx nie obsługuje bitowego XOR ani bitowego NIE , więc użyłem go !=(co działa dobrze dla czystych obrazów BW).

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

Wejście i wyjście są niejawne (kontrolowane przez tłumacza).

Stosowanie

Narzędzie do konwersji ImageMagick , służy jako interpreter „Fx Expression Language”, gdy jest wywoływany -fx, jak pokazano poniżej:

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

Argumenty są następujące:

1. Obraz wejściowy A
2. Wprowadź obraz B
3. Obraz wyjściowy O (A ^ B).

Próbka wyjściowa

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

Mathematica, 37 34 15 bajtów

Dziękujemy Ianowi Millerowi za zmniejszenie liczby bajtów o ponad połowę!

ImageDifference

W końcu zawsze jest wbudowane. Ta funkcja pobiera dwa obrazy jako dane wejściowe i wysyła obraz; robi coś bardziej skomplikowanego dla kolorowych obrazów, ale dla czarno-białych jest to dokładnie XOR.

Poprzednie zgłoszenia:

Dzięki JungHwan Min za oszczędność 3 bajtów!

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

Nienazwana funkcja, która pobiera na wejściu uporządkowaną parę obrazów (o zgodnych wymiarach) i zwraca wyświetlany obraz. ImageDatapobiera tylko dane pikseli bez wszystkich opakowań / metadanych; niestety zwraca liczby rzeczywiste, więc Chopjest potrzebne, aby traktować je jako liczby całkowite. BitXorrobi dokładnie to, co jest napisane na puszce (i wątki nad listami zagnieżdżonymi) i Imagezamienia otrzymany RGB z powrotem w obraz.

Oryginalne zgłoszenie, które zawierało uporządkowaną parę adresów URL lub nazw plików:

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

Java, 336 335 328 bajtów

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

Nie golfowany:

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 bajtów

Jestem nowym golfistą, więc zmiłuj się!

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

Dzięki @Blender i @FlipTack za uratowanie mnie 7 bajtów!

Oktawa, 43 38 34 bajtów

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

Dzięki flawr zaoszczędziłem 5 bajtów.

Dzięki Luis Mendo zaoszczędziłem 4 bajty, a~=bzamiast których sugerowałem użycie xor(a,b).

Funkcja, która przyjmuje jako nazwę pliku wejściowego dwóch obrazów wejściowych a,bi pokazuje wynik.

Poprzednia odpowiedź, która zapisuje do pliku:

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

Funkcja, która przyjmuje jako nazwę pliku wejściowego dwóch obrazów wejściowych a,bi nazwę pliku obrazu wyjściowego c.

Stosowanie:

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

Wynik zostanie zapisany w out.png

JavaScript (ES6), 333 320 308 299 297 bajtów

- 12 20 bajtów zapisanych przez Ismaela Miguela
- 2 bajty zapisane przez użytkownika 2428118

Oczekuje już załadowanych obrazów, przyjmuje rozmiar pierwszego wejścia jako rozmiar wyjściowy i zwraca element canvas.

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

Nie golfił

(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: Pierwszy raz w golfa kodowego, więc prawdopodobnie można go bardziej pograć w golfa, a moja liczba może być błędna.

PPs: kontekst 2D kanwy ma xor[tryb komponowania ( https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation ), ale działa na wartości alfa ...

Może być jeszcze bardziej golfowy (251 bajtów) ze stałym rozmiarem 300 * 150 pikseli (wszystkie pozostałe są czarne), jak w odpowiedzi Przetwarzanie

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

Przetwarzanie, 124 118 117 bajtów

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

Stosowanie:

Uwaga: ten kod może obsługiwać obrazy do 400px(z modyfikacjami może obsługiwać do 999 dla tego samego bajtu). Wszelkie „pozostałe” miejsca zostaną zabarwione na czarno, więc w celu uzyskania najlepszych rezultatów rozmiar obrazu powinien być taki sam, jak wymiary w kodzie ( size()należy go również zmienić za pomocą zaktualizowanych wymiarów)

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

Nie golfił

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 bajtów

YiiYiY~1YG

Wyjaśnienie

Jest to w zasadzie ta sama odpowiedź, co istniejące rozwiązanie Octave : pobiera nazwy plików lub adresy URL obu obrazów jako dane wejściowe i wyświetla wynik na ekranie.

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

Stosowanie

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

Perl, 260 bajtów

251 bajtów kodu + 9 bajtów dla -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')

Nie jestem pewien, czy Perl jest najlepszym językiem dla tego wyzwania, ale chciałem wiedzieć, jaki był obraz komentarza @ orlp. I to sprawia, że ​​używam trochę tych modułów graficznych, to dobrze. I podobało mi się kodowanie!

Bardziej czytelna wersja:

użyj termowizora ; 
$ img1 = nowy termowizor ( plik => $ ARGV [ 1 ] ); 
$ img2 = nowy termowizor ( plik => $ ARGV [ 0 ] );   

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

Musisz zainstalować Imager, jeśli chcesz go wypróbować, ale jest to dość proste: po prostu uruchom (echo y;echo) | perl -MCPAN -e 'install Imager'terminal.

LÖVE2D , 199 bajtów

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

To proste: pobiera dwa pliki obrazu z wiersza poleceń, wysyła plik o nazwie „Z” do katalogu Love. Działa również w przypadku obrazów pełnokolorowych!

J, 54 bajty

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

Bierze dwa argumenty, z których każdy jest ścieżką do obrazu wejściowego w bmpformacie. Każdy obraz jest odczytywany jako macierz 24-bitowych liczb całkowitych RGB i parsowany w triplet 8-bitowych wartości RGB, znak każdego z nich jest pobierany, a dwie macierze są razem XOR. Wynik jest następnie skalowany o 255, ponownie konwertowany z trypletu bazowej liczby 256 na liczbę całkowitą i zapisywany w bmppliku wyjściowym o nazwie o.

C, 189 bajtów

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

Działa na obrazach PBM. Wywołaj f(a, b, out)z nazwami obu plików wejściowych i pliku wyjściowego.

Założenia:

• Oba nagłówki obrazu wejściowego są identyczne (łącznie z białymi odstępami) i mają mniej niż 9 * sizeof(int)znaki.

• Mamy dobry system operacyjny, który opróżnia i zamyka wyciekające pliki.

• EOF == -1

Nie golfił i wyjaśnił: (pominięto ukośniki odwrotne)

// 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 (gięcie specjalne), 149 bajtów

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

Nadal używa plików PBM, ale teraz:

• Obraz musi mieć wysokość jednego piksela i szerokość 8 pikseli lub mniej, ponieważ PBM pakuje 8 pikseli w bajt.

• Nagłówek musi mieć 7 bajtów (np P4 8 1 spacją końcową).

Oba pliki są wyszukiwane do przodu podczas wypełniania tich nagłówkiem, a następnie ostatnie bajty są odczytywane, zapisywane lub zapisywane ponownie. Wykorzystuje freadi fwritemające podobne listy parametrów do czynnika wszystkie trzy operacje w nagłówku za samego makra.

R, 45 bajtów

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

ai b reprezentują nazwy dwóch plików obrazów.

Przykład:

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

Wydajność:

Przetwarzanie, 82 bajty

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

Nadużywa rozbudowanych funkcji rysowania, aby uniknąć faktycznego wykonywania XOR-ów. Łączy dwa obrazy z DIFFERENCEtrybem i rysuje je na ekranie.

Stosowanie

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

Nie golfił

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 bajty

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

Dzięki Unknown6656 za wskazówkę, że argumenty wiersza poleceń nie są konieczne. Program odczytuje teraz z plików „a” i „b” i zapisuje do pliku „c” w tym samym formacie co „a”. Naprawiono również jeden błąd.

Ustawia każdy piksel na czarny, jeśli kolor jest taki sam, w przeciwnym razie biały.

Aby zapisać bajty, wychwytuje wyjątki poza granicami, zamiast sprawdzać właściwości Szerokość i Wysokość map bitowych. Za każdym razem, gdy x wykracza poza granice, jest resetowane do 0, a y jest zwiększane. Kiedy y wykracza poza granice, x wynosi 0, a pętla pęka, aby zapisać obraz i wyjść.

Przykład kompilacji przy użyciu csc i uruchomienia przy użyciu mono:

csc xor.cs

mono xor.exe

Clojure, 300 bajtów

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

Rażące zdzierstwo odpowiedzi Java . Nie wiedziałem, jak wykonać to wyzwanie, ale byłem ciekawy, jak dobrze rozwiązanie Java przełożyło się na Clojure. To było całkiem proste. Niegolfowany kod jest właściwie całkiem ładny.

To było pierwsze wyzwanie, jakie podjąłem w golfa, które obejmowało import. Prawdopodobnie istnieje sposób na ich optymalizację w celu zaoszczędzenia niektórych bajtów.

Nie golfowany:

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

Prawdopodobnie mogę bardziej zagrać w golfa.

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

Uruchom go z wiersza poleceń w następujący sposób:

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 bajtów

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

Pliki obrazów wejściowych i wyjściowych powinny mieć format PBM (P1), w którym znajduje się pierwsza linia P1 [width] [height], a druga linia to czarno-białe wartości ascii bez spacji.

Oto obrazy wejściowe, a następnie wyjście xor (32 x 32 piksele):