22

एक छवि को देखते हुए, या तो इनपुट के रूप में (संभवतः आरजीबी ट्रिपल में) या इनपुट के रूप में फ़ाइलनाम के साथ (आप मान सकते हैं कि छवि का एक विशिष्ट फ़ाइल नाम है, संभवतः एक विस्तार के बिना), छवि के एकल रंग चैनल का प्रतिनिधित्व करने वाले छवि का उत्पादन करता है।

आप एक और इनपुट भी लेंगे, जो चैनल को आउटपुट के लिए दर्शाता है। इनपुट किसी भी 3 अलग प्रतीकों में से एक हो सकता है। हालांकि, प्रतीकों को एक स्ट्रिंग या एक संख्या होना चाहिए। हालाँकि, इनपुट के रूप में सरणी पर लागू होने के लिए आप मैट्रिस नहीं ले सकते। (जैसे {1, 0, 0}, या {0, 1, 0})।

आप <input>इनपुट छवि के चैनल को आउटपुट करेंगे । आप या तो इसे फ़ाइल में सहेज सकते हैं या RGB जोड़े का एक सेट आउटपुट कर सकते हैं।

आपके कार्यक्रम की छवि के आकार (px में) पर कोई सीमा नहीं होनी चाहिए, और छवि प्रारूप के रूप में या तो .png, .jpg/ .jpeg/ .JPGया RGB तिहरे का समर्थन करना चाहिए । (यह हालांकि आप जितना चाहें उतना समर्थन कर सकते हैं)

परीक्षण का मामला:

लाल चैनल:

ग्रीन चैनल:

ब्लू चैनल:

और एक और परीक्षण का मामला, पूरी तरह से लाल। मूल फोटो , लाल , हरा और नीला । (चेतावनी: बहुत लंबा दिखने के लिए सादा और लाल चैनल चोटिल हुआ)

2 और परीक्षण मामले:

मूल , लाल , हरा , नीला ।

बाद के दो परीक्षण मामले सभी रंगों के साथ छवियों से हैं ।

— Rɪᴋᴇʀ
स्रोत

यह एक गोल्फ भाषा के लिए अच्छी प्रेरणा है जो OpenCV परिचालनों के लिए ट्रांसपाइल्स / संकलन करता है।

— मोनिका को बहाल करना - Mar--

2

एपीएल (डायलॉग) , 7 बाइट्स

I / O: आरजीबी ट्रिपल की सरणी

⎕×⊂⎕=⍳3

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

⍳3 पहले तीन पूर्णांक

⎕= संख्यात्मक इनपुट (चुना चैनल) की तुलना करें

⊂ संलग्न करें (ताकि प्रत्येक छवि ट्रिपल जोड़े इस पूरे ट्रिपल को जोड़े)

⎕× उस के साथ संख्यात्मक इनपुट (तिगुने का सरणी) को गुणा करें

— एडम
स्रोत

12

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

a=>n=>a.map(b=>b.map(c=>c&n))

इनपुट 24-बिट पूर्णांक (जैसे [[0x0000ff,0x00ff00],[0xff0000,0xffffff]]) का 2 डी सरणी है और 16711680लाल के लिए, 65280हरे रंग के लिए, 255नीले रंग के लिए है। यदि यह मान्य नहीं है, तो इसके बजाय यह प्रयास करें:

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

a=>n=>a.map(b=>b.map(c=>c.map((d,i)=>i==n?d:0)))

इनपुट रंग मूल्यों का एक 3 डी सरणी है और 0लाल के लिए, 1हरे रंग के लिए, 2नीले रंग के लिए है।

— ETHproductions
स्रोत

1

चीक इनपुट प्रारूप हाहा

— कॉनर ओ'ब्रायन

10

गणितज्ञ, १३ बाइट्स

ImageMultiply

यह जुंगह्वान मिन के जवाब का वैध संस्करण होना चाहिए। इस समारोह छवि और में से एक लेता है Red, Green, Blueइनपुट के रूप में। उदाहरण के लिए:

एक मज़ेदार तथ्य के रूप में, यह भी है ColorSeparateजो आपको अलग-अलग चैनल देता है, लेकिन यह उन्हें एकल-चैनल / ग्रेस्केल छवियों के रूप में लौटाता है, इसलिए आपको उन्हें बाद में रंग द्वारा गुणा करना होगा।

— मार्टिन एंडर
स्रोत

क्या ऐसा कुछ भी है जो गणितज्ञ के लिए बिल्ट-इन नहीं है?

— ब्रायन मिंटन

8

बैश + इमेजमैजिक, 35 32 27 बाइट्स

mogrify -channel $1 -fx 0 i

मान लिया गया छवि फ़ाइल में है iऔर स्क्रिप्ट में से एक लेता है RG, BG, BRनीला, लाल, हरे और क्रमशः के लिए; फ़ाइल के लिए आउटपुट i।

— betseg
स्रोत

मुझे इससे हराएं। मैंने नीचे एक अलग बैश + IM उत्तर पोस्ट किया है, एक अनुकूलन के साथ आप चोरी कर सकते हैं

— स्पार्ट

@ सपर I ने एक अलग गोल्फ बनाया

— शर्त

आप अभी भी mogrify के साथ दो बाइट्स बचा सकते हैं और कोई 'o' नहीं है?

— स्पैर

7

स्पेक्ट्रम , नॉनकमेटिंग, 1 बाइट

(गैर-प्रतिस्पर्धात्मक क्योंकि इस चुनौती ने इस भाषा को प्रेरित किया।) वास्तव में, स्पेक्ट्रम एक एनपीएम लाइब्रेरी है जिसमें कमांड के लिए एक भाषा इंटरफ़ेस है।

इनपुट के रूप में लेता है:

<filename>
channel

प्रोग्राम को इस रूप में कॉल करें:

cat input.txt | node spectrum.js "I"

वैकल्पिक रूप से, आप संकेतों को जानकारी प्रदान कर सकते हैं:

λ node spectrum.js "I"
input> Ov3Gm.png
input> r
[ Image { 512x512 } ]

यह छवि को स्टैक पर छोड़ देता है। इसे देखने के लिए, Oअंत में इस तरह जोड़ें :

λ node spectrum.js "IO"
input> Ov3Gm.png
input> r
[]

कुछ अतिरिक्त मज़ा के लिए, प्रयास करें echo filename | node spectrum.js "wO"। यह एक साथ सभी तीन चैनल अलगाव करता है:

— कोनोर ओ ब्रायन
स्रोत

1

@ThisGuy हाँ, यह प्रायोगिक जाँच कर सकता है:n[d1=`[d1-P*][],.g!]#Pdd1-P~%-1=p

— Conor O'Brien

1

@ ConorO'Brien क्या आपने ImageMagick के fx ऑपरेटर के लिए मेरा प्रायोगिक परीक्षक देखा?

— स्पर्म

@ नहीं, मैं नहीं। संपर्क?

— कॉनर ओ'ब्रायन

@ ConorO'Brien codegolf.meta.stackexchange.com/questions/8828/…

— स्पर्स

7

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

a=>b=>a.map((v,i)=>i%3^b?0:v)

के समान ETHproductions के जवाब की लेकिन पहली विधि की तुलना में अधिक लचीले इनपुट के साथ और दूसरे से छोटा है।

यह एक फ़ंक्शन को परिभाषित करता है जो छवि को संख्यात्मक रंग तीव्रता के 1-आयामी सरणी के रूप में स्वीकार करता है। यह फ़ंक्शन तब एक और फ़ंक्शन देता है जो वांछित रंग चैनल का प्रतिनिधित्व करने वाले पूर्णांक मान को स्वीकार करता है।

रंगों को किसी भी संख्यात्मक सीमा द्वारा दर्शाया जा सकता है जब तक कि 0 रंग की पूर्ण अनुपस्थिति को इंगित करता है। जैसे 0.0 - 1.0या0 - 255

उदाहरण:

यदि छवि डेटा आरजीबी प्रारूप में है, तो फ़ंक्शन को तर्कों के साथ बुला रहा है (imageData)(0) से छवि केवल लाल चैनल के साथ वापस आ जाएगी।

यदि छवि डेटा BGR प्रारूप में है, तो तर्कों के साथ फ़ंक्शन को कॉल करने (imageData)(2)से भी छवि केवल लाल चैनल के साथ वापस आ जाएगी।

— PragmaticProgrammer
स्रोत

मुझे लगता है कि i%3==b&&vयह भी काम करता है।

— नील

6

पायथन 2, 69 बाइट्स

from cv2 import*
def f(s,i):k=imread(s);k[:,:,[i,i-1]]=0;imwrite(s,k)

फिर भी गोल्फ।

इनपुट के रूप में लेता है filename, n(जहां n0, 1, या 2 है)। पुराने पर नई छवि बचाता है। 0हरा है, 1लाल है, और 2नीला है। बाइट्स के लिए @ovs, @ मिखाइल और @ रोड का धन्यवाद।

— Rɪᴋᴇʀ
स्रोत

एक्स छोड़ने से बदलकर इसे कुछ बाइट्स सहेजें k[:,:,x[i][0]]=k[:,:,x[i][1]]=0के साथk[:,:,[1,2,0][i]]=k[:,:,i]=0

— OVS

@ovs धन्यवाद! ... मैं वास्तव में आपके साथ खिलवाड़ करने के बाद, खुद दूसरे सुझाव के साथ आया था। तुम मुझे निंजा हालांकि यह है।

— R

आप from cv2 import*कुछ बाइट्स बचाने के लिए उपयोग कर सकते हैं

— रॉड

लगता है कि आप के k[:,:,i-1]=k[:,:,i]=0साथ बदल सकते हैंk[:,:,[i,i-1]]=0

— मिखाइल वी

5

CJam , 12 बाइट्स

{3,f=f{f.*}}

एक अनाम ब्लॉक जो आरजीबी ट्रिपल के 3 डी सरणी और स्टैक पर 0 और 2 के बीच की संख्या की अपेक्षा करता है। बाद में ढेर पर निकाले गए सरणी को छोड़ देता है।

Red   -> 0
Green -> 1
Blue  -> 2

संभवतः एक विचित्र इनपुट प्रारूप का उपयोग करके गोल्फ हो सकता है, लेकिन मुझे ऐसा लगता है कि यह थोड़ा धोखा है।

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

परीक्षण का मामला सिर्फ प्रदर्शन करने के लिए बनाया गया है, वास्तविक छवि से ट्रिपल का उपयोग करना बहुत बड़ा होगा।

व्याख्या

3,          e# The range [0 1 2]
  f=        e# Check each for equality with the RGB indicator, gives the indicator array:
            e#  [1 0 0] for 0, [0 1 0] for 1, [0 0 1] for 2
    f{      e# Map on each row of the array using the indicator array as an extra parameter
      f.*   e#  Perform vectorized multiplication of the indicator array with each triplet.
            e#   For red, multiplies red by 1, and green and blue by 0. Does similarly
            e#   for green and blue.
         }  e# (end of block)

— बिजनेस कैट
स्रोत

5

पॉवरशेल , 282 बाइट्स

$x,$y=$args;1..($a=New-Object System.Drawing.Bitmap $x).Height|%{$h=--$_;1..$a.Width|%{$i=("$($a.GetPixel(--$_,$h)|select R,G,B)"|iex)[$y];$r,$g,$b=(((0,0,$i),(0,$i,0))[$y-eq'G'],($i,0,0))[$y-eq'R'];$a.SetPixel($_,$h,[system.drawing.color]::fromargb($r,$g,$b))}};$a.save("$x$y.png")

इस फैंसी "इनपुट गोल्फिंग" या "बिल्ट-इन का उपयोग करके" में से कोई भी नहीं। उस पर फूि। ;-)

यह यहाँ एक इनपुट PNG का पूर्ण पथ लेता है (हालाँकि, कड़ाई से बोलते हुए, इसे PNG होने की आवश्यकता नहीं है , क्योंकि JPG, BMP, आदि .NET द्वारा समर्थित हैं, लेकिन मैंने इसे केवल PNG पर आज़माया है) और (R, G, B)रंग चैनल के लिए एक , फिर उन में संग्रहीत करता है $xऔर $y। हम फिर एक New-Objectप्रकार System.Drawing.Bitmapका $xस्टोर बनाते हैं और उसमें स्टोर करते हैं$a ।

फिर हम सभी पिक्सल पर डबल लूप करते हैं। पहले से1 अप करने के लिए $aकी .Height, की स्थापना $hप्रत्येक यात्रा (यह शून्य अनुक्रमित है, इसलिए यही कारण है कि हम के --$_है, जो बचाता अधिक बाइट्स ( .height-1)। के अंदर, हम से पाश 1करने के लिए $aकी .Width।

प्रत्येक पुनरावृत्ति, हम .GetPixelविशेष पर प्रदर्शन कर रहे हैंw,h निर्देशांक , जो एक System.Drawing.Colorवस्तु लौटाता है । हम selectइसके R G Bमूल्यों को देखते हैं। iexयहाँ एक साफ चाल है कि एक hashtable में इस बदल जाता है (उदाहरण के लिए, की तरह कुछ @{R=34; G=177; B=76}) तो हम कर सकते इच्छित रंग चैनल के साथ सीधे उस में सूचकांक [$y]। उस मान में संग्रहीत किया जाता है$i ।

इसके बाद, हम तीन मान निर्धारित करते हैं $r, $g, $b करते हैं जो कि पत्र के मूल्य के आधार पर कुछ छद्म-टर्नरी ऑपरेटरों के परिणाम हैं $y। इसलिए, उदाहरण के लिए, यदि $yहै R, तो यहां परिणाम है $r=$i, $g=0, $b=0।

फिर, हम .SetPixelउस विशेष w,hसमन्वय पर एक बैक करते हैं , जो System.Drawing.Colorस्थिर का उपयोग करके एक नया निर्माण करता है FromARGB(जो अल्फा को पूरी तरह से अपारदर्शी होने का अनुमान लगाता है)। एक बार जब हमने लूपिंग खत्म कर ली, तो हम बस.Save पीएनजी को एक नई फाइल में बदल देते हैं।

नोट: यह एक लंबा समय लेता है, क्योंकि यह पूरी तरह से स्वतंत्र रूप से हर पिक्सेल के माध्यम से लूपिंग और गणना का एक गुच्छा प्रदर्शन करता है और प्रत्येक पुनरावृत्ति को कॉल करता है।

टेस्ट:

— AdmBorkBork
स्रोत

3

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

C="RGB"
mogrify -channel ${C//$1} -fx 0 x

इनपुट नाम की एक फ़ाइल है x, में से एक पैरामीटर कमांड लाइन RयाG याB

आउटपुट इनपुट फ़ाइल को अधिलेखित करता है

अधिक प्राकृतिक सिंगल-लेटर चैनल पैरामीटर लेने में betseg के उत्तर से मुश्किल। इसके अलावा एक नई फाइल को आउटपुट करने के बजाय ओवरराइट करना, जो कि विश्वासघात चोरी करने के लिए स्वतंत्र है :)

— Sparr
स्रोत

$1उद्धरण चिह्नों की जरूरत है, फ़ाइल नाम रिक्त स्थान हो सकता है

— betseg

@ फैबसेग वास्तव में नहीं है, मैंने कहा कि आप मान सकते हैं कि इसका एक विशिष्ट नाम है। वह चाहे तो x1 बाइट के लिए फ़ाइल नाम से पढ़ने के लिए इसे बदल भी सकता है।

— आरए

@ रिकर ओह, मैंने ध्यान नहीं दिया कि, इससे मुझे भी मदद मिलती है: D

— betseg

3

चिप , 78 बाइट्स

 ~Z~vS
f/F,^-.
e/E|,-Z.
d/D|>zz^.
a/AMx-x-].
b/BMx-]v-'
c/CM]v-'
 >--v'
G/gh/H

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

चिप एक 2D भाषा है जो एक बाइट स्ट्रीम में प्रत्येक बाइट के घटक बिट्स पर संचालित होती है।

अवलोकन

यह विशेष समाधान इनपुट के पहले बाइट को नियंत्रित करने वाले चरित्र की अपेक्षा करता है - यह निर्धारित करने के लिए कि कौन सा चैनल (ओं) को रखने के लिए - और निम्नलिखित छवि डेटा का बाइट्स है। छवि डेटा RGB ट्रिपल होना चाहिए, प्रति चैनल एक बाइट, 24 बिट प्रति पिक्सेल:

|  1  |  2  |  3  |  4  |  5  |  6  |  7  | ... | 3n-2 |  3n  | 3n+1 |
|     |   First Pixel   |   Second Pixel  | ... |      nth Pixel     |
| Ctl | Red | Grn | Blu | Red | Grn | Blu | ... |  Red |  Grn |  Blu |

नियंत्रण वर्ण की व्याख्या बिट फ़ील्ड के रूप में की जाती है, हालांकि केवल तीन सबसे कम बिट्स का अर्थ है:

0x1  keep Red channel
0x2  keep Green channel
0x4  keep Blue channel

इसका अर्थ है कि हम ASCII वर्णों का उपयोग कर सकते हैं कि हमें कौन सा चैनल चुनना है:

1मतलब लाल
2का मतलब होता है नीला
4मतलब हरा

या कुछ कट्टरता से करें:

5लाल और नीला रखें, लेकिन हरा न
7रखें सभी चैनल (छवि अपरिवर्तित है)
0 सभी चैनल छोड़ें (छवि काली है)

यह काम किस प्रकार करता है

इस समाधान को गोल्फिंग की वजह से उछाला जाता है, लेकिन यहाँ जाता है:

के साथ पहली बाइट के तीन कम बिट्स पढ़ें C, B, और A, और उनके इसी में उन बिट्स की दुकान Mएमोरी कोशिकाओं। इसके अलावा, Sपहले चक्र के लिए ऊपरवाला उत्पादन।
बार-बार उन तीन बिटों पर लूप। यदि चालू बिट यह /चालू है, तो वर्तमान इनपुट बाइट को आउटपुट करने के लिए स्विच को बंद करें , यदि यह बंद है, तो स्विच खोलें ताकि हम एक शून्य बाइट का उत्पादन करें।
इनपुट समाप्त होने तक जारी रखें।

परिणाम देखना

ज़रूर, आप हेक्सडंप या कुछ उबाऊ उपयोग कर सकते हैं, लेकिन यह पता चला है कि यह (लगभग) एक वास्तविक वैध छवि प्रारूप है: बाइनरी पोर्टेबल डेस्कटॉप ।

बस ऊपर से छवि डेटा (नीचे नियंत्रण बाइट, निश्चित रूप से) को नीचे फ़ाइल में प्लॉप करें, मान्य होने के लिए चौड़ाई / ऊँचाई समायोजित करें, और आप इरफ़ानव्यू जैसे उचित दर्शक में छवि देख सकते हैं, हालांकि सरल (अधिकांश ब्राउज़र की तरह) बिल्ट-इन) इसे संभाल नहीं सकते।

P6
{width as ASCII} {height as ASCII}
255
{binary image data here}

उदाहरण के लिए (कच्चे डेटा के लिए पलायन):

P6
3 1
255
\xff\x00\x00\x00\xff\x00\x00\x00\xff

— Phlarx
स्रोत

3

MATL, 21 13 बाइट्स

Yi3:iml&!*3YG

रंग चैनल को निम्नलिखित मानचित्रण का उपयोग करके निर्दिष्ट किया जाना चाहिए: 1:red , 2:green,3:blue

ऑनलाइन दुभाषियों का उपयोग करने में असमर्थ हैं imread छवियों को पढ़ने के करने में इसलिए यहां थोड़ा संशोधित संस्करण है जहां मेरे पास स्रोत में एक यादृच्छिक छवि हार्ड-कोडित है ।

व्याख्या

        % Implicitly grab first input as a string (filename)
Yi      % Read the image in from a filename or URL
3:      % Push the string literal 'rgb' to the stack
i       % Grab the second input as a number
m       % Check for membership. So for example 2 will yield [false, true, false]
l&!     % Permute the dimensions to turn this 1 x 3 array into a 1 x 1 x 3 array
*       % Multiply this with the input RGB image. It will maintain the channel which
        % corresponds with the TRUE values and zero-out the channels that corresponded to
        % the FALSE values
3YG     % Display the image

— Suever
स्रोत

2

05AB1E , 16 बाइट्स

vyvy2ô²è}})¹0ègô

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

प्रत्येक चैनल के लिए 2 डी सरणी प्रारूप और [0,1,2] में हेक्स रंगों का उपयोग करता है।

— जादू ऑक्टोपस Urn
स्रोत

2

क्लोजर, 421 332 बाइट्स

-89 बाइट्स सब कुछ आक्रामक रूप से, चैनलों को अलग करने की मेरी हास्यास्पद पुरानी पद्धति से बदलकर, और एक अनावश्यक आकस्मिक आयात से छुटकारा पाने के द्वारा।

(import '(java.awt.image BufferedImage)'(clojure.lang Keyword)'(javax.imageio ImageIO)'(java.io File)'(java.awt Color))(fn[p i](doseq[y(range(.getHeight p))x(range(.getWidth p))](.setRGB p x y(.getRGB(apply #(Color. % %2 %3)(#(let[c(Color. %)](assoc [0 0 0]i(([(.getRed c)(.getGreen c)(.getBlue c)]%)i)))(.getRGB p x y))))))(ImageIO/write p"jpg"(File."./o.jpg")))

मेरी शिफ्ट शुरू होने के आधे घंटे पहले मुझे पता ही नहीं चला कि मैं क्या कर रहा था। मेरे पास बहुत कम अनुभव है BufferedImage, इसलिए इस बारे में बेहतर तरीका हो सकता है। मैं Colorपूर्णांक और अलग-अलग चैनल रंगों के प्रतिनिधित्व के बीच आगे-पीछे होने का भी दुरुपयोग कर रहा हूं ।

यह दो कारणों से अन्य उत्तरों की तुलना में बहुत बड़ा है (स्पष्ट है कि क्लूजुर एक गोल्फ भाषा नहीं है):

सिर्फ एक बाइट सरणी में हेरफेर करने के बजाय, यह वास्तव में एक तस्वीर के रूप में लेता है, इसे बदल देता है, और इसे आउटपुट करता है।
मैं जावा-इंटरोप का उपयोग कर रहा हूं, जो कई बार काम में आता है। अकेले आयात कई जवाबों से बड़ा है।

ब्रेक डाउन के लिए नीचे दिया गया कोड देखें।

(ns bits.restrict-channel
  (:import (java.awt.image BufferedImage)
           (clojure.lang Keyword)
           (javax.imageio ImageIO)
           (java.io File)
           (java.awt Color)))

(defn restrict-channel
  "Accepts a BufferedImage and a index between 0 and 2 (inclusive).
  Removes color from all channels EXCEPT the channel indicated by color-i.
  color-i of 0 = keep red
  color-i of 1 = keep green
  color-i of 2 = keep blue"
  [^BufferedImage image ^long color-i]
  (let [; Turn a number representing RGB into a triplet representing [R G B]
        channels #(let [c (Color. %)]
                    [(.getRed c) (.getGreen c) (.getBlue c)])

        ; Create a new triplet that only contains color in the color-i channel
        zero-channels #(assoc [0 0 0] color-i ((channels %) color-i))]

    ; Loop over each pixel
    (doseq [y (range (.getHeight image))
            x (range (.getWidth image))]

      ; Grab the current color...
      (let [cur-color (.getRGB image x y)]

        ; ... setting it to stripped color triplet returned by zero-channels
        (.setRGB image x y

                          ; This "apply" part is just applying the stripped triplet to the Color constructor
                         ;  This is needed to convert the separate channels into the integer representation that `BufferedImage` uses. 

                 (.getRGB (apply #(Color. % %2 %3) (zero-channels cur-color))))))

    ; Save the result to file
    (ImageIO/write image "jpg" (File. "./o.jpg"))))

— Carcigenicate
स्रोत

यह या तो सबसे शानदार या भयावह चीज है जिसे मैंने कभी देखा है। मैं पूर्व के साथ जा रहा हूं।

— आरए

@ रिकर निश्चित रूप से पूर्व। मैंने अपनी पारी शुरू होने से आधे घंटे पहले ही यह लिखना शुरू कर दिया था कि मैं कैसे यह करने जा रहा हूं। लेकिन यह काम करता है!

— कैरिजिनेट

* मैं वास्तव में उत्तरार्द्ध का मतलब था, लेकिन शानदार गड़बड़ियां भी एक चीज हैं।

— कार्सिनजिनेट

1

लुआ (लव 2 डी फ्रेमवर्क), 498 बाइट्स

मैंने इसे अपने लिए एक अभ्यास के रूप में अधिक किया, इसलिए यह उतना छोटा नहीं है जितना कि यह हो सकता है (हालांकि मैंने गोल्फ की कोशिश की), लेकिन मैं इसे यहां जोड़ना चाहता था क्योंकि मुझे लगता है कि मैंने अच्छा किया। भले ही मैं बहुत देर हो चुकी हूँ।

यहाँ गोल्फ कोड, इसके अंतर्गत समझाया गया और बिना उलझा हुआ संस्करण है।

l=love g,p,rm,bm,gm,s=l.graphics,0,1,1,1,[[uniform float m[4];vec4 effect(vec4 co,Image t,vec2 c,vec2 s){vec4 p=Texel(t,c);p.r=p.r*m[0];p.b=p.b*m[1];p.g=p.g*m[2];return p;}]]t=g.setShader h=g.newShader(s)function l.draw()h:send("m",rm,gm,bm)if p~=0 then t(h)g.draw(p)t()end end function l.filedropped(f)a=f:getFilename()p=g.newImage(f)end function l.keypressed(k)if k=="0"then rm,gm,bm=1,1,1 end if k=="1"then rm,gm,bm=1,0,0 end if k=="2"then rm,gm,bm=0,1,0 end if k=="3"then rm,gm,bm=0,0,1 end end

यहाँ एक कोड है जिसे * .jpg फ़ाइल को इसमें प्राप्त करना है। छवि सम्मिलित होने के बाद आप लाल (1) हरा (2) या नीला (3) चैनलों के लिए संख्या बटन दबा सकते हैं। डिफ़ॉल्ट चित्र को फिर से देखने के लिए फिर से 0. दबाएं। वास्तव में यह केवल चित्र को खिड़की में दिखाता है।

l=love
g=l.graphics
p=0
rm,bm,gm=1,1,1
s = [[uniform float m[4];
vec4 effect(vec4 co,Image t,vec2 c,vec2 s){vec4 p=Texel(t,c);p.r = p.r * m[0];p.b = p.b * m[1]; p.g = p.g * m[2]; return p;}
]]
sh=g.newShader(s)

function l.draw()
  sh:send("m",rm,gm,bm)
  if p~=0 then
    g.setShader(sh)
    g.draw(p)
    g.setShader()
  end
end

function l.filedropped(f)
  a=f:getFilename()
  p=g.newImage(f)
end

function l.keypressed(k)
  if k=="0"then rm,gm,bm=1,1,1 end
  if k=="1"then rm,gm,bm=1,0,0 end
  if k=="2"then rm,gm,bm=0,1,0 end
  if k=="3"then rm,gm,bm=0,0,1 end
end

महत्वपूर्ण कार्य जो सभी काम करता है वह है जो शुरुआत में छोटी स्ट्रिंग घोषणा या असंगठित है:

uniform float m[4];
vec4 effect(vec4 co,Image t,vec2 c,vec2 s)
{
    vec4 p=Texel(t,c);
    p.r = p.r * m[0];
    p.b = p.b * m[1];
    p.g = p.g * m[2]; 
    return p;
}

जो छवि का वास्तविक पिक्सेल प्राप्त करता है और आवश्यकतानुसार चैनल दिखाता है।

मेरी परीक्षण छवि और चैनलों के लिए अलग-अलग आउटपुट (अन्य लोगों के लिए भी सुनिश्चित करें)

— Lycea
स्रोत

आपके संकेत के लिए धन्यवाद, मैंने इसे ठीक कर दिया, अगली बार मुझे पता है :)

— लाइकिया

कोई बात नहीं! पीपीसी में आपका स्वागत है, आशा है कि आप चारों ओर चिपकेंगे!

— R

इसके अलावा, आप अभी भी इसे गोल्फ कर सकते हैं। आपको बटन और ऐसे शामिल करने की आवश्यकता नहीं है।

— R

0

सी, 60 58 बाइट्स

main(a,b)char**b;{while(scanf(b[1],&a)>0)printf("%d ",a);}

इमेज इनपुट 0 और 255 के बीच की संख्या (दशमलव में) की एक सूची है stdin, जैसे

255 0 0  192 192 192  31 41 59 ...

चैनल कार्यक्रम के पहले तर्क के रूप में निर्दिष्ट है, और इनमें से एक है

red   -> "%d%*d%*d"
green -> "%*d%d%*d"
blue  -> "%*d%*d%d"

उदाहरण:

$ echo "255 0 0" | ./extract "%d%*d%*d"
255

— nneonneo
स्रोत

किसी छवि का RGB चैनल निकालें

एपीएल (डायलॉग) , 7 बाइट्स

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

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

गणितज्ञ, १३ बाइट्स

बैश + इमेजमैजिक, 35 32 27 बाइट्स

स्पेक्ट्रम , नॉनकमेटिंग, 1 बाइट

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

पायथन 2, 69 बाइट्स

CJam , 12 बाइट्स

पॉवरशेल , 282 बाइट्स

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

चिप , 78 बाइट्स

अवलोकन

यह काम किस प्रकार करता है

परिणाम देखना

MATL, 21 13 बाइट्स

05AB1E , 16 बाइट्स

क्लोजर, 421 332 बाइट्स

लुआ (लव 2 डी फ्रेमवर्क), 498 बाइट्स

सी, 60 58 बाइट्स