आरजीबी रंग का मूल्य #00FF00एक महत्वपूर्ण है: इसका उपयोग फिल्मों, टीवी शो, मौसम की घोषणाओं, और बहुत कुछ करने के लिए किया जाता है। यह प्रसिद्ध "टीवी ग्रीन" या "ग्रीन स्क्रीन" रंग है।

चुनौती

आपका कार्य एक प्रोग्राम लिखना है जो दो इनपुट चित्र लेता है, दोनों पीएनजी प्रारूप में (या आपकी छवि लाइब्रेरी की छवि ऑब्जेक्ट प्रकार में) और समान आयामों में। एक छवि किसी भी पुरानी छवि हो सकती है। अन्य एक छवि है जिसमें रंग की पृष्ठभूमि होगी #00FF00। आउटपुट छवि में पहले से अधिक दूसरी छवि शामिल होगी, जिसमें कोई #00FF00रंग मौजूद नहीं है (पहली छवि को छोड़कर)। इनपुट और आउटपुट फाइलों, एक जीयूआई, आदि के साथ किया जा सकता है। आपको इनपुट के रूप में RGB मानों की एक सरणी लेने की अनुमति है, जैसा कि यहां देखा गया है । आप मान सकते हैं कि किसी छवि में केवल पूर्ण अस्पष्टता के पिक्सेल होते हैं।

मूल रूप से ...

एक प्रोग्राम बनाएं जो प्रत्येक #00FF00पिक्सेल को एक छवि में लेता है और इसे पृष्ठभूमि छवि में संबंधित पिक्सेल के साथ बदल देता है।

परीक्षण के मामलों

सामान्य रूप से @ दज़िमा द्वारा प्रदान की गई: पृष्ठभूमि: अग्रभूमि: आउटपुट:

बेशक, मानक खामियों को सख्ती से मना किया जाता है । इसमें आपके लिए करने के लिए ऑनलाइन संसाधन का उपयोग करना शामिल है।
यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीत और सबसे अच्छा प्रोग्रामर समृद्ध हो सकता है ...

code-golf graphical-output image-processing

— ckjbgames
स्रोत

2

क्या हम इनपुट के रूप में भाषा / पुस्तकालय के मूल प्रारूप में एक छवि वस्तु लेते हैं, या क्या हमें फ़ाइल नाम के माध्यम से छवि को पढ़ना है?

— नॉटजैगन

@ नोटजैन आप इमेज ऑब्जेक्ट को इनपुट के रूप में ले सकते हैं।

— ckjbgames

3

क्या पूर्णांक के सरणियों के सरणियों के I / O स्वीकार्य हैं या क्या हम वास्तव में छवि I / O के किसी अन्य सेट तक सीमित हैं?

— जोनाथन एलन

1

@PeterCordes मैं इसकी अनुमति दूंगा।

— cjjbgames

1

@PeterCordes ठीक है

— cjjbgames

14

x86-64 (और x86-32) मशीन कोड, 13 15 13 बाइट्स

चैंज:

बगफिक्स: पहला संस्करण केवल G = 0xff की जाँच कर रहा था, R और B की आवश्यकता नहीं थी। 0. मैंने जगह में बैकग्राउंड को संशोधित करने के लिए बदल दिया, इसलिए मैं शॉर्ट-फॉर्म एन्कोडिंग के लिए lodsdfg पिक्सल के eaxलिए अग्रभूमि पर उपयोग कर सकता था cmp eax, imm32(5 बाइट्स) ), के बजाय cmp dh,0xff(3 बाइट्स)।
2 बाइट्स सहेजें: ध्यान दें कि cmov2-बाइट movलोड (और उस स्थिति में, मामले में एक रजिस्टर को बचाने) के लिए मेमोरी ऑपरेंड का उपयोग करने की अनुमति दी गई जगह में बीजी को संशोधित करना ।

यह x86-64 सिस्टम V कॉलिंग कन्वेंशन का अनुसरण करने वाला एक फ़ंक्शन है, इस हस्ताक्षर के साथ C या C ++ (x86-64 गैर-विंडोज सिस्टम पर) से सीधे कॉल करने योग्य है:

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

छवि प्रारूप RGB0 32bpp है, जिसमें प्रत्येक पिक्सेल के भीतर 2 सबसे कम मेमोरी पते पर हरे रंग का घटक है। ~~अग्रभूमि~~ पृष्ठभूमि छवि में जगह संशोधित किया गया है। pixel_countपंक्तियाँ है * कॉलम। यह पंक्तियों / स्तंभों की परवाह नहीं करता है; यह सिर्फ क्रोमकेई मिश्रणों को निर्दिष्ट करता है जो आपके द्वारा निर्दिष्ट मेमोरी के बहुत सारे पासवर्ड हैं।

RGBA (A के लिए 0xFF होना आवश्यक है) को एक अलग स्थिरांक का उपयोग करने की आवश्यकता होगी, लेकिन फ़ंक्शन आकार में कोई परिवर्तन नहीं। फोरग्राउंड DWORD की तुलना 4 बाइट्स में संग्रहीत एक मनमानी 32-बिट स्थिरांक के खिलाफ सटीक समानता के लिए की जाती है, इसलिए किसी भी पिक्सेल-ऑर्डर या क्रोमा-की रंग को आसानी से समर्थित किया जा सकता है।

एक ही मशीन कोड 32-बिट मोड में भी काम करता है। के रूप में 32-बिट, परिवर्तन इकट्ठा करने के लिए rdiकरने के लिए ediस्रोत में। अन्य सभी रजिस्टर जो 64-बिट बनते हैं वे निहित (लॉस्ड / स्टोसड, और लूप) हैं, और अन्य स्पष्ट रजिस्टरों में 32-बिट रहते हैं। लेकिन ध्यान दें कि आपको 32-बिट C से कॉल करने के लिए एक रैपर की आवश्यकता होगी, क्योंकि मानक x86-32 में से कोई भी कॉलिंग कन्वेंशन x86-64 SysV के समान ही उपयोग नहीं करता है।

NASM लिस्टिंग (मशीन-कोड + स्रोत), अधिक शुरुआती निर्देशों के विवरण के साथ asm शुरुआती के लिए टिप्पणी करता है। (निर्देश संदर्भ मैनुअल की नकल करना सामान्य उपयोग में खराब शैली है।)

 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

इस सूची से मूल NASM स्रोत प्राप्त करने के लिए, प्रत्येक पंक्ति के प्रमुख 26 वर्णों को पट्टी करें <chromakey.lst cut -b 26- > chromakey.asm। मैंने इसे
nasm -felf64 chromakey-blend.asm -l /dev/stdout | cut -b -28,$((28+12))- मशीन-कोड और स्रोत के बीच की तुलना में NASM लिस्टिंग के साथ अधिक खाली कॉलम छोड़ दिया। ऑब्जेक्ट फ़ाइल बनाने के लिए आप C या C ++ से लिंक कर सकते हैं, उपयोग कर सकते हैं nasm -felf64 chromakey.asm। (या yasm -felf64 chromakey.asm)

निष्कलंक , लेकिन मुझे पूरा विश्वास है कि लोड / लोड / सेमीोव / स्टोर का मूल विचार ध्वनि है, क्योंकि यह बहुत सरल है।

मैं 3 बाइट्स बचा सकता था अगर मुझे फ़ंक्शन में निरंतर हार्ड-कोडिंग के बजाय एक अतिरिक्त arg के रूप में क्रोमा-कुंजी स्थिरांक (0x00ff00) को पास करने के लिए कॉलर की आवश्यकता हो सकती है। मुझे नहीं लगता कि सामान्य नियम एक अधिक सामान्य फ़ंक्शन लिखने की अनुमति देते हैं जिसके लिए कॉलर ने इसके लिए स्थिरांक स्थापित किया है। लेकिन अगर ऐसा किया गया, तो x86-64 SysV ABI में 3rd arg (वर्तमान में dummy) पास किया edxगया। बस cmp eax, 0x0000ff00(5B) से cmp eax, edx(2B) बदलें ।

SSE4 या AVX के साथ, आप इस तेज़ (लेकिन बड़े कोड आकार) के साथ pcmpeqdऔर blendvpsतुलना मास्क द्वारा नियंत्रित 32-बिट तत्व आकार चर-मिश्रण करने के लिए कर सकते हैं। (के साथ pand, आप उच्च बाइट को नजरअंदाज कर सकते हैं)। पैक RGB24 के लिए, आप बाइट्स में TRUE प्राप्त करने के लिए pcmpeqb2x और फिर 2x pshufb+ pandका उपयोग कर सकते हैं, जहाँ उस पिक्सेल के सभी 3 घटक मेल खाते हैं, फिर pblendvb।

(मुझे पता है कि यह कोड-गोल्फ है, लेकिन मैंने स्केलर पूर्णांक के साथ जाने से पहले MMX की कोशिश करने पर विचार किया था।)

— पीटर कॉर्डेस
स्रोत

क्या आप मुझे इस मशीन कोड के साथ एक निष्पादन योग्य बना सकते हैं?

— cjjbgames

x86_32, कृपया।

— cjjbgames

@ckjbgames: मैंने एक कॉलर नहीं लिखा है जो छवियों को लोड / सहेजता है, बस संशोधित-पिक्सेल-इन-प्लेस भाग। मुझे लगता है कि इससे पहले कि यह एक निष्पादन योग्य बनाने के लिए कोई मतलब होगा। लेकिन अगर मैंने किया, तो किस तरह का अमल? विंडोज PE32? लिनक्स ELF32? FreeBSD ??

— पीटर कॉर्डेस

ELF32, यदि आप करेंगे

— ckjbgames

@ckjbgames: अगर मुझे समय मिलता है, तो मैं एक इमेज-लोडिंग लाइब्रेरी की तलाश करूंगा और कुछ लिखूंगा। मैंने एक पैराग्राफ जोड़ा कि कैसे लिस्टिंग को कोड में वापस लाया जाए जिसे आप इकट्ठा कर सकते हैं nasm -felf32। (32-बिट के लिए, आपको C से कॉल करने के लिए एक रैपर फ़ंक्शन की भी आवश्यकता होगी, क्योंकि यह अभी भी x86-64 SysV ABI के समान रजिस्टरों का उपयोग कर रहा है।)

— पीटर कॉर्ड्स

13

मैथेमेटिका 57 35 बाइट्स

अद्यतन: डिफ़ॉल्ट रूप से, एक हरे रंग की पृष्ठभूमि का उपयोग करके हटा दिया जाता है RemoveBackground। पहले सबमिशन में अनावश्यक दूसरा पैरामीटर, `{" बैकग्राउंड ", ग्रीन}" शामिल था।

#~ImageCompose~RemoveBackground@#2&

छवि 2 की पृष्ठभूमि को हटाता है और छवि 1 के साथ परिणाम तैयार करता है।

उदाहरण

निम्नलिखित, इन्फिक्स फॉर्म के बजाय उपसर्ग में, अधिक स्पष्ट रूप से दिखाता है कि कोड कैसे काम करता है।

— DavidC
स्रोत

4

क्या यह उन छवियों के लिए काम करेगा जहां यह "पृष्ठभूमि" नहीं है जो हरे रंग की है? (आपके आउटपुट में बचे हरे रंग का एक छोटा पैच लगता है)

— DBS

यदि चित्र में हरे रंग का "द्वीप" होता, तो अतिरिक्त पैरामीटर, `{" बैकग्राउंड ", ग्रीन}", की आवश्यकता होगी, जो कुल 57 बाइट्स बढ़ाएगा। यह मेरा पहला सबमिशन था। क्योंकि मुझे कोई हरा दिखाई नहीं देता। तस्वीर के अग्रभूमि में अलग, उस पैरामीटर को गिरा दिया गया था।

— डेविड जूल

11

पायथन 3 + सुन्न , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट एक numpyसरणी के प्रारूप में दिया गया है , जिसमें पूर्णांक तीनों पिक्सेल का प्रतिनिधित्व करते हैं (जहां #00FF00हेक्स रंग कोड के बराबर है [0, 255, 0])। इनपुट ऐरे को संशोधित किया गया है, जिसे प्रति मेटा की अनुमति है ।

उदाहरण छवियाँ

इनपुट (प्रश्न से)

पृष्ठभूमि:

अग्रभूमि:

फ़ंक्शन चलाने के बाद फ़ोरग्राउंड छवि:

संदर्भ कार्यान्वयन ( `opencv`छवि फ़ाइलों को पढ़ने के लिए उपयोग करता है)

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)

छवि को स्क्रीन पर प्रदर्शित करता है और इसे आउटपुट फ़ाइल में लिखता है।

— notjagan
स्रोत

17

परिणामी छवि पर सभी लाल बिंदुओं के साथ क्या है?

— यति

1

मैंने I / O के बारे में पूछा है - यह मौजूदा शब्दांकन (अर्थात "आपकी लाइब्रेरी") का अनुपालन करता है, यदि ऐसा है, तो क्या cv2 को केवल खस्ता आयात की आवश्यकता है? यदि नहीं तो आप किसी भी numpy कार्यों का उपयोग नहीं है, और numpy आयात नहीं द्वारा 54 में यह कर सकता है: lambda f,b:[x[list(x[0])==[0,255,0]]for x in zip(f,b)]। यदि पूर्णांकों की सूचियों की सूची वास्तव में स्वीकार्य है, तो आप इसे 48 में कर सकते हैंlambda f,b:[x[x[0]==[0,255,0]]for x in zip(f,b)]

— जोनाथन एलन

..in तथ्य भले ही numpy है , CV2 रूपांतरण मैं अब भी लगता है कि आप 54 बाइट संस्करण कर सकता है प्रदर्शन करने के लिए आवश्यक हैं क्योंकि हम चुनौती के लिए आयात CV2 की जरूरत नहीं है।

— जोनाथन एलन

5

यदि G == 255, R और B शून्य नहीं हैं, तो भी मूल्य बदल जाता है, जो लाल बिंदुओं की ओर जाता है। यह अन्य बैंड के लिए भी कठिन होता है जो कम दिखाई देता है। तो यह एक-दूसरे से स्वतंत्र रूप से तर्क की जाँच करता है और एकल चैनलों को स्वैप करता है, भले ही शर्तों में से केवल एक ही पूरा हो। उदाहरण के लिए, यदि कोई पिक्सेल [0 255 37]लाल और हरे रंग की पट्टी है, तो उसे बदल दिया जाएगा।

— लिएंडर मोइंसिंगर

2

@LeanderMoesinger: अच्छी तरह से देखा। मैं उस बग में मेरा था, भी> <; आईडीके ने क्यों सोचा कि आर और बी को नजरअंदाज करते हुए केवल ग्रीन = 0xFF की जाँच करना सही था!

— पीटर कॉर्ड्स

9

प्रसंस्करण, 116 99 बाइट्स

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

दुर्भाग्य से, प्रसंस्करण java 8 सामान का समर्थन नहीं करता है, जैसे लैम्ब्डा।

उदाहरण कार्यान्वयन: (छवि को out.pngस्क्रीन पर भी खींचता है और सहेजता है )

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

— dzaima
स्रोत

आप settings()और setup()कार्यों से छुटकारा पा सकते हैं और सीधे कोड चला सकते हैं।

— केविन वर्कमैन

@ केविनवॉर्कमैन मेरे पास सेटिंग और सेटअप है इसलिए यह स्क्रीन पर छवि प्रदर्शित करेगा, जो अन्यथा संभव नहीं होगा

— dzima

है #ff00या 0xff00के रूप में ही #00ff00प्रसंस्करण में?

— पीटर कॉर्डेस

@PeterCordes # FF00 सिंटैक्स त्रुटि देता है, दुख की बात है, और # 00FF00 == 0xFF00FF00, इसलिए 0xFF00 अल्फा वैल्यू 0 के लिए जांच के रूप में काम नहीं करता है

— dzaima

@dzaima: क्या आप अपनी तस्वीरों को RGB0 फॉर्मेट में ले सकते हैं, तो 0x0000FF00आप जिस बिट-पैटर्न की तलाश कर रहे हैं?

— पीटर कॉर्डेस

6

बैश + इमेजमैजिक, 45 बाइट्स

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

दो छवियों को तर्क के रूप में लेता है और स्क्रीन पर आउटपुट प्रदर्शित करता है। बदलें x:करने $3के बजाय एक तिहाई फ़ाइल तर्क को लिखने के लिए। विधि सरल है: "पृष्ठभूमि" छवि पढ़ें; "अग्रभूमि" इमेजक पढ़ें; दूसरी छवि में पारदर्शिता के रूप में रंग "लाइम" (# 00ff00) की पुनर्व्याख्या करें; फिर पहली और आउटपुट पर दूसरी छवि को मिलाएं।

ImageMagick: 28 बाइट्स?

मैं इसे एक ImageMagick जवाब के रूप में प्रस्तुत कर सकता था लेकिन यह स्पष्ट नहीं है कि तर्कों से कैसे निपटा जाए। यदि आप यह बताना चाहते हैं कि ImageMagick एक स्टैक-आधारित भाषा है (जो थोड़े सॉर्टा वास्तव में सच नहीं है, लेकिन लगभग ... यह अजीब है) तो -transparent lime -compositeएक फ़ंक्शन है जो स्टैक पर दो छवियों की उम्मीद करता है और स्टैक पर एक मर्ज की गई छवि को छोड़ देता है ।। शायद यह गिनती करने के लिए काफी अच्छा है?

— हॉब्स
स्रोत

3

MATL , 40 37 31 बाइट्स

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

उदाहरण ऑफ़लाइन दुभाषिया के साथ चलता है। चित्र उनके URL द्वारा इनपुट हैं (स्थानीय फ़ाइलनाम भी प्रदान किए जा सकते हैं)।

व्याख्या

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

— लुइस मेंडो
स्रोत

3

पायथ , 27 बाइट्स

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

यह उद्धृत इनपुट लेता है। इनपुट छवि फ़ाइलों के दो पथ हैं। एक फ़ाइल को आउटपुट करें o.pngदुर्भाग्य से सुरक्षा कारण के लिए ऑनलाइन दुभाषिया पर परीक्षण नहीं किया जा सकता है ( 'उस पर अक्षम है)। इसका परीक्षण करने के लिए आपको अपने कंप्यूटर पर पायथ प्राप्त करना होगा ।

व्याख्या

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

— जिम
स्रोत

क्रोमा-की ब्लेंड फंक्शन अपने आप में 13 बाइट्स है, जो मेरे x86 मशीन-कोड उत्तर के समान है। मुझे पहले महसूस नहीं हुआ था कि यह एक पूर्ण कार्यक्रम छवि I / O भी सौंप रहा था।

— पीटर कॉर्डेस

2

मतलाब 2016 बी और ऑक्टेव, 62 59 बाइट्स

इनपुट: A = MxNx3 unit8 अग्रभूमि मैट्रिक्स, B = MxNx3 unit8 पृष्ठभूमि मैट्रिक्स।

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

आउटपुट: A = MxNx3 unit8 मैट्रिक्स

नमूना उपयोग:

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)

— लिएंडर मोइस्िंगर
स्रोत

1

सी ++, 339 बाइट्स

यह CImg का उपयोग करता है, और यह अन्य स्वरूपों में भी फाइल ले सकता है। परिणाम एक विंडो में प्रदर्शित किया जाता है।

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

के साथ संकलित करें g++ chromakey.cpp -g -L/usr/lib/i386-linux-gnu -lX11 -o chromakey -pthread।

— ckjbgames
स्रोत

1

आर, 135 बाइट्स

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

अनाम फ़ंक्शन, तर्क के रूप में 2 png फ़ाइल पथ लेता है और एक png चित्र को आउटपुट करता है जिसे कहा जाता है a.png।

स्पष्टीकरण के साथ थोड़ा असंतुष्ट:

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

— plannapus
स्रोत

1

SmileBASIC, 90 बाइट्स _{_{_{^{^{^{कुंजी}}}}}}

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

Iअग्रभूमि और आउटपुट Jहै, पृष्ठभूमि है। दोनों 32 बिट ARGB प्रारूप में, पिक्सेल के पूर्णांक सरणियाँ हैं।

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

स्पष्टीकरण:

ARYOP एक ऐसा फंक्शन है जो एक एरे में हर एलिमेंट पर एक सिंपल ऑपरेशन को लागू करता है।
इसे कहा जाता हैARYOP mode, output_array, input_array_1, input_array_2, ...

सबसे पहले, यह निर्धारित करने के लिए कि छवि में कौन से पिक्सेल हरे हैं, -16711936(अग्रभूमि के हरे रंग का आरजीबीए प्रतिनिधित्व) को प्रत्येक पिक्सेल से अग्रभूमि छवि में घटाया जाता है। इससे जहां एक सरणी मिलती है0 हरे रंग के पिक्सेल का प्रतिनिधित्व करता है, और कोई अन्य संख्या गैर-हरे रंग के पिक्सेल का प्रतिनिधित्व करती है।

सभी नॉनज़रो मानों को परिवर्तित करने के लिए 1, उन्हें चुकता किया जाता है (ऋणात्मक संख्याओं को हटाने के लिए), फिर बीच में 0और के लिए clamped 1।

यह केवल 0और 1एस के साथ एक सरणी में परिणाम है ।
0s अग्रभूमि छवि में हरे रंग के पिक्सेल का प्रतिनिधित्व करते हैं, और पृष्ठभूमि से पिक्सेल के साथ प्रतिस्थापित किया जाना चाहिए।
1गैर-हरे रंग के पिक्सेल का प्रतिनिधित्व करते हैं, और उन्हें अग्रभूमि से पिक्सेल के साथ बदलना होगा।

यह रैखिक प्रक्षेप का उपयोग करके आसानी से किया जा सकता है।

— 12Me21
स्रोत

0

PHP, 187 बाइट्स

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

24bit PNG फ़ाइलों को मानता है; कमांड लाइन तर्कों से फ़ाइल नाम लेता है, stdout को लिखता है।
साथ चलाना -r।

टूट - फूट

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

— टाइटस
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 290 बाइट्स

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

इनपुट को दो Imageऑब्जेक्ट के रूप में लेता है (सिंटैक्सिंग सिंटैक्स में), जिसे HTML <image>एलिमेंट के साथ बनाया जा सकता है। रिटर्न एक वादा है कि जिसके परिणामस्वरूप छवि के Base64 डेटा यूआरएल है, जो करने के लिए लागू किया जा सकता पर ले कर srcएक की<image> ।

यहाँ विचार प्रत्येक #00FF00पिक्सेल के लिए अल्फा मान को सेट करना था 0और फिर अग्रभूमि को चित्रित करना था, जिसकी पृष्ठभूमि के ऊपर की पृष्ठभूमि थी।

टेस्ट स्निपेट

उनके डेटा URL द्वारा अग्रभूमि और पृष्ठभूमि को शामिल करना यहाँ पोस्ट करने के लिए बहुत बड़ा था, इसलिए इसे CodePen में ले जाया गया:

इसे ऑनलाइन आज़माएं!

— जस्टिन मेरिनर
स्रोत

0

ओएसएल , 83 बाइट्स

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

दो इनपुट लेता है। पहला अग्रभूमि है, और दूसरा, पृष्ठभूमि।

— स्कॉट मिलनर
स्रोत

क्रोमा सफलता की कुंजी

चुनौती

मूल रूप से ...

परीक्षण के मामलों

x86-64 (और x86-32) मशीन कोड, 13 15 13 बाइट्स

मैथेमेटिका 57 35 बाइट्स

पायथन 3 + सुन्न , 59 बाइट्स

उदाहरण छवियाँ

इनपुट (प्रश्न से)

संदर्भ कार्यान्वयन ( opencvछवि फ़ाइलों को पढ़ने के लिए उपयोग करता है)

प्रसंस्करण, 116 99 बाइट्स

बैश + इमेजमैजिक, 45 बाइट्स

ImageMagick: 28 बाइट्स?

MATL , 40 37 31 बाइट्स

व्याख्या

पायथ , 27 बाइट्स

मतलाब 2016 बी और ऑक्टेव, 62 59 बाइट्स

सी ++, 339 बाइट्स

आर, 135 बाइट्स

SmileBASIC, 90 बाइट्स कुंजी

Ungolfed

स्पष्टीकरण:

PHP, 187 बाइट्स

जावास्क्रिप्ट (ईएस 6), 290 बाइट्स

टेस्ट स्निपेट

ओएसएल , 83 बाइट्स

संदर्भ कार्यान्वयन ( `opencv`छवि फ़ाइलों को पढ़ने के लिए उपयोग करता है)

SmileBASIC, 90 बाइट्स _{_{_{^{^{^{कुंजी}}}}}}