Der RGB-Farbwert #00FF00ist ziemlich wichtig: Er wird zum Erstellen von Filmen, Fernsehsendungen, Wettermeldungen und vielem mehr verwendet. Es ist die berühmte "TV-Grün" - oder "Green-Screen" -Farbe.

Die Herausforderung

Ihre Aufgabe ist es, ein Programm zu schreiben, das zwei Eingabebilder im PNG-Format (oder im Bildobjekttyp Ihrer Bildbibliothek) mit denselben Abmessungen aufnimmt. Ein Bild kann ein beliebiges altes Bild sein. Das andere ist das Bild, das einen farbigen Hintergrund hat #00FF00. Das Ausgabebild besteht aus dem zweiten Bild, das dem ersten überlagert ist, und es ist keine #00FF00Farbe vorhanden (außer im ersten Bild). Die Ein- und Ausgabe kann mit Dateien, einer grafischen Benutzeroberfläche usw. erfolgen. Sie können eine Reihe von RGB-Werten als Eingabe verwenden, wie hier gezeigt . Sie können davon ausgehen, dass ein Bild nur Pixel mit voller Deckkraft enthält.

Grundsätzlich gilt...

Erstellen Sie ein Programm, das jedes #00FF00Pixel in einem Bild aufnimmt, und ersetzen Sie es durch das entsprechende Pixel im Hintergrundbild.

Testfälle

Großzügig zur Verfügung gestellt von @dzaima: Hintergrund: Vordergrund: Ausgabe:

Standardlücken sind natürlich strengstens untersagt . Dies beinhaltet die Verwendung einer Online-Ressource, um dies für Sie zu tun.
Das ist Code-Golf , also kann der kürzeste Code gewinnen und der beste Programmierer gedeihen ...

x86-64 (und x86-32) Maschinencode, 13 15 13 Bytes

Änderungsprotokoll:

1. Bugfix: Die erste Version überprüfte nur G = 0xff, ohne dass R und B 0 sein mussten. Ich änderte den Hintergrund, so dass ich lodsdim Vordergrund fg Pixel eaxfür die Kurzformkodierung cmp eax, imm32(5 Bytes) verwenden konnte ) anstelle von cmp dh,0xff(3 Byte).

2. Save 2 bytes (2 Byte speichern): Es wurde bemerkt, dass das Ändern des BG an Ort und Stelle die Verwendung eines Speicheroperanden zum cmovSpeichern eines 2-Byte- movLadevorgangs (und zum Speichern eines Registers, falls dies wichtig ist) ermöglicht.

Dies ist eine Funktion, die der Aufrufkonvention von x86-64 System V folgt und direkt von C oder C ++ (auf x86-64-Systemen ohne Windows) mit dieser Signatur aufgerufen werden kann:

void chromakey_blend_RGB32(uint32_t *background /*rdi*/,
                     const uint32_t *foreground /*rsi*/,
                  int dummy, size_t pixel_count /*rcx*/);

Das Bildformat ist RGB0 32bpp, wobei sich die grüne Komponente an der zweitniedrigsten Speicheradresse in jedem Pixel befindet. Das Vordergrund- Hintergrundbild wird direkt geändert. pixel_countist Zeilen * Spalten. Es kümmert sich nicht um Zeilen / Spalten; Mit chromekey können Sie beliebig viele Speicherbereiche mischen.

RGBA (wobei A 0xFF sein muss) würde die Verwendung einer anderen Konstante erfordern, jedoch keine Änderung der Funktionsgröße. Vordergrund-DWORDs werden auf exakte Gleichheit mit einer beliebigen 32-Bit-Konstante verglichen, die in 4 Bytes gespeichert ist, sodass jede Pixel- oder Chroma-Key-Farbe problemlos unterstützt werden kann.

Der gleiche Maschinencode funktioniert auch im 32-Bit-Modus. Zur Montage als 32-Bit, ändern rdizu ediin der Quelle. Alle anderen Register, die 64-Bit werden, sind implizit (lodsd / stosd und loop), und die anderen expliziten Register bleiben 32-Bit. Beachten Sie jedoch, dass Sie einen Wrapper benötigen, um von 32-Bit-C aus aufzurufen, da keine der standardmäßigen x86-32-Aufrufkonventionen dieselben Regeln wie x86-64 SysV verwendet.

NASM-Auflistung (Maschinencode + Quelle), kommentiert für Anfänger mit Beschreibungen dessen, was die komplexeren Anweisungen tun. (Das Duplizieren der Bedienungsanleitung ist bei normaler Verwendung nicht korrekt.)

 1                       ;; inputs:
 2                       ;; Background image pointed to by RDI, RGB0 format  (32bpp)
 3                       ;; Foreground image pointed to by RSI, RGBA or RGBx (32bpp)
 4          machine      ;; Pixel count in RCX
 5          code         global chromakey_blend_RGB32
 6          bytes        chromakey_blend_RGB32:
 7 address               .loop:                      ;do {
 8 00000000 AD               lodsd                   ; eax=[rsi], esi+=4. load fg++
 9 00000001 3D00FF0000       cmp    eax, 0x0000ff00  ; check for chromakey
10 00000006 0F4407           cmove  eax, [rdi]       ; eax = (fg==key) ? bg : fg
11 00000009 AB               stosd                   ; [rdi]=eax, edi+=4. store into bg++
12 0000000A E2F4             loop .loop              ;} while(--rcx)
13                       
14 0000000C C3               ret

##  next byte starts at 0x0D, function length is 0xD = 13 bytes

Um die ursprüngliche NASM-Quelle aus dieser Auflistung zu entfernen, entfernen Sie die führenden 26 Zeichen jeder Zeile mit <chromakey.lst cut -b 26- > chromakey.asm. Ich habe dies mit
nasm -felf64 chromakey-blend.asm -l /dev/stdout | cut -b -28,$((28+12))- NASM-Auflistungen generiert. Lassen Sie mehr leere Spalten zwischen dem Computercode und der Quelle, als ich möchte. Verwenden Sie zum Erstellen einer Objektdatei, die Sie mit C oder C ++ verknüpfen können nasm -felf64 chromakey.asm. (Oder yasm -felf64 chromakey.asm).

ungetestet , aber ich bin ziemlich zuversichtlich, dass die Grundidee von load / load / cmov / store solide ist, weil es so einfach ist.

Ich könnte 3 Bytes einsparen, wenn der Aufrufer die Chroma-Key-Konstante (0x00ff00) als zusätzliches Argument übergeben müsste, anstatt die Konstante fest in die Funktion zu codieren. Ich glaube nicht, dass die üblichen Regeln das Schreiben einer allgemeineren Funktion erlauben, für die der Aufrufer Konstanten eingerichtet hat. Ist dies jedoch der Fall , wird das 3. Argument (derzeit dummy) edxim x86-64-SysV-ABI übergeben. Ändern Sie einfach cmp eax, 0x0000ff00(5B) zu cmp eax, edx(2B).

Mit SSE4 oder AVX können Sie dies möglicherweise schneller (aber mit größerer Codegröße) pcmpeqdund blendvpsmit einer variablen 32-Bit-Elementgröße ausführen, die von der Vergleichsmaske gesteuert wird. (Mit pandkönnen Sie das High-Byte ignorieren). Für gepacktes RGB24 können Sie pcmpeqbund dann 2x pshufb+ verwenden pand, um WAHR in Bytes zu erhalten, bei denen dann alle 3 Komponenten dieses Pixels übereinstimmen pblendvb.

(Ich weiß, dass dies Codegolf ist, aber ich habe darüber nachgedacht, MMX zu testen, bevor ich mich für eine skalare Ganzzahl entschieden habe.)

Mathematica 57 35 Bytes

Update: Standardmäßig wird ein grüner Hintergrund mit entfernt RemoveBackground. Die erste Einreichung enthielt den unnötigen zweiten Parameter "{" Background ", Green}".

#~ImageCompose~RemoveBackground@#2&

Entfernt den Hintergrund von Bild 2 und setzt das Ergebnis mit Bild 1 zusammen.

Beispiel

Im Folgenden wird in Präfix- und nicht in Infixform die Funktionsweise des Codes deutlicher dargestellt.

Python 3 + Anzahl , 59 Bytes

lambda f,b:copyto(f,b,'no',f==[0,255,0])
from numpy import*

Probieren Sie es online!

Die Eingabe erfolgt im Format eines numpyArrays, wobei ganzzahlige Triplets Pixel darstellen (wobei #00FF00hexadezimaler Farbcode entspricht [0, 255, 0]). Das Eingabearray wird an Ort und Stelle geändert, was pro Meta zulässig ist .

Beispielbilder

Eingabe (aus der Frage)

Hintergrund:

Vordergrund:

Vordergrundbild nach dem Ausführen der Funktion:

Referenzimplementierung ( opencvzum Lesen von Bilddateien)

g = lambda f,b:copyto(f,b,'no',f==[0,255,0])
from numpy import*

import cv2

f = cv2.imread("fg.png")
b = cv2.imread("bg.png")

g(f, b)

cv2.imshow("Output", f)
cv2.imwrite("out.png", f)

Zeigt das Bild auf dem Bildschirm an und schreibt es in eine Ausgabedatei.

Verarbeitung, 116 99 Bytes

PImage f(PImage b,PImage f){int i=0;for(int c:f.pixels){if(c!=#00FF00)b.pixels[i]=c;i++;}return b;}

Leider unterstützt die Verarbeitung kein Java 8-Zeug, wie z. B. Lambdas.

Beispielimplementierung: (speichert das Bild als out.pngund zeichnet es auch auf dem Bildschirm)

PImage bg;
void settings() {
  bg = loadImage("bg.png");
  size(bg.width,bg.height);
}
void setup() {
  image(f(bg, loadImage("fg.png")), 0, 0);
  save("out.png");
}
PImage f(PImage b,PImage f){int i=0;for(int c:f.pixels){if(c!=#00FF00)b.pixels[i]=c;i++;}return b;}

Bash + ImageMagick, 45 Bytes

convert $1 $2 -transparent lime -composite x:

Nimmt zwei Bilder als Argumente und zeigt die Ausgabe auf dem Bildschirm an. Wechseln Sie x:zu $3, um stattdessen in ein drittes Dateiargument zu schreiben. Die Methode ist einfach: Lesen Sie das Hintergrundbild. Lies das Bild "Vordergrund". interpretiere die Farbe "Lime" (# 00ff00) als Transparenz im zweiten Bild; Kombinieren Sie dann das zweite Bild mit dem ersten und geben Sie es aus.

ImageMagick: 28 Bytes?

Ich hätte dies als ImageMagick-Antwort einreichen können , aber es ist nicht klar, wie mit den Argumenten umgegangen werden soll. Wenn Sie davon ausgehen möchten, dass ImageMagick eine stapelbasierte Sprache ist (was irgendwie nicht wirklich stimmt, aber fast ... seltsam ist), dann -transparent lime -compositeist dies eine Funktion, die zwei Bilder auf dem Stapel erwartet und ein zusammengeführtes Bild auf dem Stapel zurücklässt. vielleicht ist das gut genug um zu zählen

MATL , 40 37 31 Bytes

,jYio255/]tFTF1&!-&3a*5M~b*+3YG

Beispiellauf mit dem Offline-Interpreter. Die Bilder werden über ihre URLs eingegeben (lokale Dateinamen können ebenfalls angegeben werden).

Erläuterung

,        % Do this twice
  j      %   Input string with URL or filename
  Yi     %   Read image as an M×N×3 uint8 array
  o      %  Convert to double
  255/   %   Divide by 255
]        % End
t        % Duplicate the second image
FTF      % Push 1×3 vector [0 1 0]
1&!      % Permute dimensions to give a 1×1×3 vector
-        % Subtract from the second image (M×N×3 array), with broadcast
&3a      % "Any" along 3rd dim. This gives a M×N mask that contains
         % 0 for pure green and 1 for other colours
*        % Mulltiply. This sets green pixels to zero
5M       % Push mask M×N again
~        % Negate
b        % Bubble up the first image
*        % Multiply. This sets non-green pixels to zero
+        % Add the two images
3YG      % Show image in a window

Pyth , 27 Bytes

M?q(Z255Z)GHG.wmgVhded,V'E'

Es wird eine Eingabe in Anführungszeichen benötigt. Die Eingabe sind die beiden Pfade der Bilddateien. Datei o.pngausgeben Leider kann das aus Sicherheitsgründen nicht auf dem Online-Interpreter getestet werden ( 'ist darauf deaktiviert). Sie müssen Pyth auf Ihrem Computer installieren, um es zu testen.

Erläuterung

M?q(Z255Z)GHG                  # Define a function g which takes two tuples G and H and returns G if G != (0, 255, 0), H otherwise
                       V'E'    # Read the images. They are returned as lists of lists of colour tuples
                      ,        # Zip both images
               m  hded         # For each couple of lists in the zipped list...
                gV             # Zip the lists using the function g
             .w                # Write the resulting image to o.png

Matlab 2016b und Octave, 62 59 Bytes

Eingabe: A = MxNx3 Einheit8 Vordergrundmatrix, B = MxNx3 Einheit8 Hintergrundmatrix.

k=sum(A(:,:,2)-A(:,:,[1 3]),3)==510.*ones(1,1,3);A(k)=B(k);

Ausgabe: A = MxNx3 unit8 Matrix

Beispielgebrauch:

A = imread('foreground.png');
B = imread('backgroundimg.png');

k=sum(A(:,:,2)-A(:,:,[1 3]),3)==510.*ones(1,1,3);A(k)=B(k);

imshow(A)

C ++, 339 Bytes

Dies verwendet CImg und kann auch Dateien in anderen Formaten aufnehmen. Das Ergebnis wird in einem Fenster angezeigt.

#include<CImg.h>
using namespace cimg_library;
int main(int g,char** v){CImg<unsigned char> f(v[1]),b(v[2]);for(int c=0;c<f.width();c++){for(int r=0;r<f.height();r++){if((f(c,r)==0)&&(f(c,r,0,1)==255)&&(f(c,r,0,2)==0)){f(c,r)=b(c,r);f(c,r,0,1)=b(c,r,0,1);f(c,r,0,2) = b(c,r,0,2);}}}CImgDisplay dis(f);while(!dis.is_closed()){dis.wait();}}

Kompilieren mit g++ chromakey.cpp -g -L/usr/lib/i386-linux-gnu -lX11 -o chromakey -pthread.

R, 135 Bytes

function(x,y,r=png::readPNG){a=r(x);m=apply(a,1:2,function(x)all(x==0:1));for(i in 1:4)a[,,i][m]=r(y)[,,i][m];png::writePNG(a,"a.png")}

Anonyme Funktion, nimmt 2 PNG-Dateipfade als Argumente und gibt ein PNG-Bild mit dem Namen aus a.png.

Leicht ungolfed, mit erklärungen:

function(x,y){
    library(png)
    # readPNG output a 3D array corresponding to RGBA values on a [0,1] scale:
    a = readPNG(x)
    # Logical mask, telling which pixel is equal to c(0, 1, 0, 1), 
    # i.e. #00FF00 with an alpha of 1:
    m = apply(a, 1:2, function(x) all(x==0:1))
    # For each RGB layer, replace that part with the equivalent part of 2nd png:
    for(i in 1:4) a[,,i][m] = readPNG(y)[,,i][m]
    writePNG(a,"a.png")
}

SmileBASIC, 90 Bytes _{^{was ist der Schlüssel}}

DEF C I,J
DIM T[LEN(I)]ARYOP.,T,I,16711936ARYOP 2,T,T,T
ARYOP 6,T,T,0,1ARYOP 5,I,I,J,T
END

Iist der Vordergrund und die Ausgabe, Jist der Hintergrund. Beide sind Ganzzahl-Arrays von Pixeln im 32-Bit-ARGB-Format.

Ungolfed

DEF C IMAGE,BACKGROUND 'function
 DIM TEMP[LEN(IMAGE)]  'create array "temp"
 ARYOP #AOPADD,TEMP,IMAGE,-RGB(0,255,0)    'temp = image - RGB(0,255,0)
 ARYOP #AOPCLP,TEMP,TEMP,-1,1              'temp = clamp(temp, -1, 1)
 ARYOP #AOPMUL,TEMP,TEMP,TEMP              'temp = temp * temp
 ARYOP #AOPLIP,IMAGE,IMAGE,BACKGROUND,TEMP 'image = linear_interpolate(image, background, temp)
END

Erläuterung:

ARYOP ist eine Funktion, die eine einfache Operation auf jedes Element in einem Array anwendet.
Es heißt wieARYOP mode, output_array, input_array_1, input_array_2, ...

Um zu bestimmen, welche Pixel im Bild grün sind, wird zunächst -16711936(die RGBA-Darstellung der grünen Farbe) von jedem Pixel im Vordergrundbild abgezogen. Dies ergibt ein Array, in dem 0grüne Pixel und jede andere Zahl nicht grüne Pixel darstellen.

Um alle Werte ungleich Null in umzuwandeln 1, werden sie quadriert (um negative Zahlen zu entfernen) und dann zwischen 0und geklemmt 1.

Dies ergibt ein Array mit nur 0s und 1s.
0s stellen grüne Pixel im Vordergrundbild dar und sollten durch Pixel aus dem Hintergrund ersetzt werden.
1s stellen nicht-grüne Pixel dar und diese müssen durch Pixel aus dem Vordergrund ersetzt werden.

Dies kann leicht durch lineare Interpolation erfolgen.

PHP, 187 Bytes

for($y=imagesy($a=($p=imagecreatefrompng)($argv[1]))-1,$b=$p($argv[2]);$x<imagesx($a)?:$y--+$x=0;$x++)($t=imagecolorat)($b,$x,$y)-65280?:imagesetpixel($b,$x,$y,$t($a,$x,$y));imagepng($b);

geht von 24-Bit-PNG-Dateien aus; Nimmt Dateinamen von Befehlszeilenargumenten und schreibt sie nach stdout.
Laufen Sie mit -r.

Nervenzusammenbruch

for($y=imagesy(                                 # 2. set $y to image height-1
        $a=($p=imagecreatefrompng)($argv[1])    # 1. import first image to $a
    )-1,
    $b=$p($argv[2]);                            # 3. import second image to $b
    $x<imagesx($a)?:                            # Loop 1: $x from 0 to width-1
        $y--+$x=0;                              # Loop 2: $y from height-1 to 0
        $x++)
            ($t=imagecolorat)($b,$x,$y)-65280?:     # if color in $b is #00ff00
                imagesetpixel($b,$x,$y,$t($a,$x,$y));   # then copy pixel from $a to $b
imagepng($b);                                   # 5. output

JavaScript (ES6), 290 Byte

a=>b=>(c=document.createElement`canvas`,w=c.width=a.width,h=c.height=a.height,x=c.getContext`2d`,x.drawImage(a,0,0),d=x.getImageData(0,0,w,h),o=d.data,o.map((_,i)=>i%4?0:o[i+3]=o[i++]|o[i++]<255|o[i]?255:0),x.drawImage(b,0,0),createImageBitmap(d).then(m=>x.drawImage(m,0,0)||c.toDataURL()))

Nimmt Eingaben als zwei ImageObjekte (in gängiger Syntax) entgegen, die mit einem HTML- <image>Element erstellt werden können. Gibt ein Versprechen , dass Entschlüssen zum Base64 Daten URL des resultierenden Bildes, die auf die angewendet werden kann , srcder ein <image>.

Die Idee hier war, den Alpha-Wert für jedes #00FF00Pixel auf einzustellen0 und dann den Vordergrund mit ausgeblendetem Hintergrund über den Hintergrund zu malen.

Testschnipsel

Das Einbeziehen des Vordergrunds und des Hintergrunds in die Daten-URLs war zu groß, um hier veröffentlicht zu werden, und wurde daher nach CodePen verschoben:

Probieren Sie es online!

OSL , 83 Bytes

shader a(color a=0,color b=0,output color c=0){if(a==color(0,1,0)){c=b;}else{c=a;}}

Nimmt zwei Eingänge. Der erste ist der Vordergrund und der zweite der Hintergrund.