La valeur de couleur RVB #00FF00est assez importante: elle est utilisée pour faire des films, des émissions de télévision, des annonces météo, etc. C'est la fameuse couleur "vert TV" ou "écran vert".

Le défi

Votre tâche consiste à écrire un programme qui prend deux images d'entrée, à la fois au format PNG (ou dans le type d'objet image de votre bibliothèque d'images) et de mêmes dimensions. Une image peut être n'importe quelle image ancienne. L'autre est l'image qui aura un fond de couleur #00FF00. L'image de sortie sera constituée de la deuxième image superposée sur la première, sans #00FF00couleur présente (sauf dans la première image). L'entrée et la sortie peuvent être effectuées avec des fichiers, une interface graphique, etc. Vous êtes autorisé à prendre un tableau de valeurs RVB en entrée, comme on le voit ici . Vous pouvez supposer qu'une image n'a que des pixels de pleine opacité.

Fondamentalement...

Créez un programme qui prend chaque #00FF00pixel d'une image et remplacez-le par le pixel correspondant dans l'image d'arrière-plan.

Cas de test

Généreusement fourni par @dzaima: Contexte: Premier plan: Sortie:

Bien sûr, les failles standard sont strictement interdites . Cela comprend l'utilisation d'une ressource en ligne pour le faire pour vous.
C'est du code-golf , alors que le code le plus court gagne et que le meilleur programmeur prospère ...

code machine x86-64 (et x86-32), 13 15 13 octets

journal des modifications:

1. Bugfix: la première version vérifiait seulement G = 0xff, ne nécessitant pas que R et B soient 0. J'ai changé pour modifier l'arrière-plan en place afin que je puisse utiliser lodsdau premier plan pour avoir des pixels fg eaxpour l' cmp eax, imm32encodage court (5 octets) ), au lieu de cmp dh,0xff(3 octets).

2. Enregistrer 2 octets: a remarqué que la modification du bg en place permettait d'utiliser un opérande de mémoire pour cmov, l'enregistrement d'une movcharge de 2 octets (et l'enregistrement d'un registre, au cas où cela importait).

Il s'agit d'une fonction suivant la convention d'appel System V x86-64, appelable directement à partir de C ou C ++ (sur les systèmes x86-64 non Windows) avec cette signature:

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

Le format d'image est RGB0 32bpp, avec le composant vert à la 2ème adresse mémoire la plus basse dans chaque pixel. L' image d'arrière- plan de premier plan est modifiée sur place. pixel_countest lignes * colonnes. Il ne se soucie pas des lignes / colonnes; il suffit que chromekey mélange les nombreux mots de mémoire que vous spécifiez.

RGBA (avec A requis pour être 0xFF) nécessiterait l'utilisation d'une constante différente, mais aucun changement dans la taille de la fonction. Les DWORD de premier plan sont comparés pour une égalité exacte avec une constante arbitraire de 32 bits stockée sur 4 octets, de sorte que toute couleur d'ordre des pixels ou de chrominance peut être facilement prise en charge.

Le même code machine fonctionne également en mode 32 bits. Pour assembler en 32 bits, passez rdià edidans la source. Tous les autres registres qui deviennent 64 bits sont implicites (lodsd / stosd et boucle), et les autres regs explicites restent 32 bits. Mais notez que vous aurez besoin d'un wrapper pour appeler à partir de C 32 bits, car aucune des conventions d'appel x86-32 standard n'utilise les mêmes paramètres que x86-64 SysV.

Liste NASM (code machine + source), commentée pour les débutants asm avec des descriptions de ce que font les instructions les plus complexes. (La duplication du manuel de référence des instructions est un mauvais style en utilisation normale.)

 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

Pour obtenir la source NASM d'origine de cette liste, supprimez les 26 premiers caractères de chaque ligne avec <chromakey.lst cut -b 26- > chromakey.asm. J'ai généré cela avec des
nasm -felf64 chromakey-blend.asm -l /dev/stdout | cut -b -28,$((28+12))- listes NASM laissant plus de colonnes vides que je ne le souhaite entre le code machine et la source. Pour créer un fichier objet que vous pouvez lier avec C ou C ++, utilisez nasm -felf64 chromakey.asm. (Ou yasm -felf64 chromakey.asm).

non testé , mais je suis assez confiant que l'idée de base de load / load / cmov / store est bonne, car c'est si simple.

Je pourrais économiser 3 octets si je pouvais exiger que l'appelant passe la constante de chrominance (0x00ff00) comme argument supplémentaire, au lieu de coder en dur la constante dans la fonction. Je ne pense pas que les règles habituelles permettent d'écrire une fonction plus générique pour laquelle l'appelant a configuré des constantes. Mais si c'est le cas, le 3ème argument (actuellement dummy) est passé edxdans l'ABI SysV x86-64. Changez simplement cmp eax, 0x0000ff00(5B) en cmp eax, edx(2B).

Avec SSE4 ou AVX, vous pouvez le faire plus rapidement (mais avec une taille de code plus grande) avec pcmpeqdet blendvpspour effectuer un mélange variable de taille d'élément 32 bits contrôlé par le masque de comparaison. (Avec pand, vous pouvez ignorer l'octet de poids fort). Pour RGB24 compressé, vous pouvez utiliser pcmpeqbpuis 2x pshufb+ pandpour obtenir VRAI en octets où les 3 composants de ce pixel correspondent, alors pblendvb.

(Je sais que c'est du code-golf, mais j'ai envisagé d'essayer MMX avant de choisir un entier scalaire.)

Mathematica 57 35 octets

mise à jour: par défaut, un fond vert est supprimé à l'aide de RemoveBackground. La première communication comprenait le deuxième paramètre inutile, `{" Background ", Green}".

#~ImageCompose~RemoveBackground@#2&

Supprime l'arrière-plan de l'image 2 et compose le résultat avec l'image 1.

Exemple

Ce qui suit, sous forme de préfixe plutôt que d'infixe, montre plus clairement comment fonctionne le code.

Python 3 + numpy , 59 octets

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

Essayez-le en ligne!

L'entrée est donnée sous la forme d'un numpytableau, avec des triplets entiers représentant des pixels (où #00FF00en code couleur hex équivaut à [0, 255, 0]). Le tableau d'entrée est modifié sur place, ce qui est autorisé par méta .

Exemples d'images

Entrée (de la question)

Contexte:

Premier plan:

Image de premier plan après l'exécution de la fonction:

Implémentation de référence (permet opencvde lire les fichiers image)

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)

Affiche l'image à l'écran et l'écrit dans un fichier de sortie.

Traitement, 116 99 octets

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

Malheureusement, le traitement ne prend pas en charge les éléments Java 8, comme les lambdas.

Exemple d'implémentation: (enregistre l'image sous out.pnget la dessine également à l'écran)

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 octets

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

Prend deux images comme arguments et affiche la sortie à l'écran. Remplacez x:par $3pour écrire dans un troisième argument de fichier à la place. La méthode est simple: lire l'image "d'arrière-plan"; lire l'image "au premier plan"; réinterpréter la couleur "chaux" (# 00ff00) comme transparence dans la deuxième image; puis composez la seconde image sur la première et sortez.

ImageMagick: 28 octets?

J'aurais pu soumettre cela comme une réponse ImageMagick mais il n'est pas clair comment gérer les arguments. Si vous voulez affirmer qu'ImageMagick est un langage basé sur la pile (ce qui n'est pas vraiment vrai, mais presque ... c'est bizarre), -transparent lime -compositec'est une fonction qui attend deux images sur la pile et laisse une image fusionnée sur la pile .. Peut-être que c'est assez bon pour compter?

MATL , 40 37 31 octets

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

Exemple exécuté avec l'interpréteur hors ligne. Les images sont saisies par leur URL (des noms de fichiers locaux peuvent également être fournis).

Explication

,        % 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 octets

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

Il faut une entrée entre guillemets. L'entrée sont les deux chemins des fichiers image. Sortie d'un fichier o.pngMalheureusement qui ne peut pas être testé sur l'interpréteur en ligne pour des raisons de sécurité ( 'est désactivé dessus). Vous devrez télécharger Pyth sur votre ordinateur pour le tester.

Explication

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 et Octave, 62 59 octets

Entrée: A = matrice de premier plan MxNx3 unit8, B = matrice de fond MxNx3 unit8.

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

Sortie: A = matrice MxNx3 unit8

Exemple d'utilisation:

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 octets

Cela utilise CImg et peut également prendre des fichiers dans d'autres formats. Le résultat est affiché dans une fenêtre.

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

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

R, 135 octets

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

Fonction anonyme, prend 2 chemins de fichier png comme arguments et génère une image png appelée a.png.

Légèrement non golfé, avec explications:

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 octets _{^{quelle est la clé}}

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

Iest le premier plan et la sortie, Jest l'arrière-plan. Les deux sont des tableaux entiers de pixels, au format ARGB 32 bits.

Non golfé

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

Explication:

ARYOP est une fonction qui applique une opération simple à chaque élément d'un tableau.
Il s'appelle commeARYOP mode, output_array, input_array_1, input_array_2, ...

Premièrement, pour déterminer quels pixels de l'image sont verts, -16711936(la représentation RGBA de la couleur verte) est soustraite de chaque pixel de l'image de premier plan. Cela donne un tableau où 0représente les pixels verts, et tout autre nombre représente les pixels non verts.

Pour convertir toutes les valeurs non nulles en 1, elles sont au carré (pour supprimer les nombres négatifs), puis fixées entre 0et 1.

Il en résulte un tableau avec uniquement 0s et 1s.
0s représentent des pixels verts dans l'image de premier plan et doivent être remplacés par des pixels de l'arrière-plan.
1s représentent des pixels non verts, et ceux-ci devront être remplacés par des pixels du premier plan.

Cela peut facilement être fait en utilisant une interpolation linéaire.

PHP, 187 octets

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

suppose des fichiers PNG 24 bits; prend les noms de fichiers des arguments des lignes de commande, écrit dans stdout.
Courez avec -r.

panne

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 octets

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

Prend l'entrée comme deux Imageobjets (dans la syntaxe de curry), qui peuvent être créés avec un <image>élément HTML . Renvoie une promesse qui se résout à l'URL de données Base64 de l'image résultante, qui peut être appliquée à celle srcd'un <image>.

L'idée ici était de définir la valeur alpha pour chaque #00FF00pixel 0, puis de peindre le premier plan, avec son arrière-plan masqué, au-dessus de l'arrière-plan.

Extrait de test

Inclure le premier plan et l'arrière-plan par leurs URL de données était trop volumineux pour être publié ici, il a donc été déplacé vers CodePen:

Essayez-le en ligne!

OSL , 83 octets

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

Prend deux entrées. Le premier est le premier plan et le second l'arrière-plan.