ब्लैक एंड व्हाइट रेनबो

Question

एक ऐसी छवि को देखते हुए जिसमें केवल काले और सफेद पिक्सेल होते हैं और एक (x, y) स्थान जो कि एक सफेद पिक्सेल होता है, सफेद पिक्सेल को एक पथ से उनकी न्यूनतम मैनहट्टन दूरी (x, y) पर आधारित रंग में शामिल करता है, जिसमें केवल अन्य सफेद पिक्सेल शामिल होते हैं।

रंग रंग पिक्सल के से (एक्स, वाई), तो (एक्स, वाई) पर पिक्सेल उनकी दूरी के लिए आनुपातिक होना चाहिए 0 डिग्री (शुद्ध लाल) के एक रंग और पिक्सल सब से अधिक दूर से दूर करना होगा (एक्स, वाई) 360 ° (भी लाल) की एक ह्यू, अन्य hues सीमलेस और रैखिक रूप से बीच में सम्मिश्रण के साथ होगा। संतृप्ति और मूल्य दोनों 100% होना चाहिए।

यदि एक सफेद पिक्सेल अन्य सफेद पिक्सेल के माध्यम से (x, y) से जुड़ा नहीं है , तो उसे सफेद रहना चाहिए।

विवरण

• इनपुट में फ़ाइल का नाम या कच्ची छवि डेटा, प्लस x और y पूर्णांक शामिल होंगे।
• आउटपुट इमेज को किसी भी आम इमेज फाइल फॉर्मेट में स्टडआउट करने के लिए किसी फाइल या पिपल रॉ में सेव किया जा सकता है, या केवल प्रदर्शित किया जा सकता है।
• X मान बाईं ओर के पिक्सेल पर 0 है, और दाईं ओर बढ़ता है। सबसे अधिक पिक्सेल में y मान 0 है और नीचे जा रहा है। (x, y) हमेशा छवि सीमा में रहेगा।
• पूर्ण कार्यक्रमों और कार्यों दोनों की अनुमति है।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

अंतरिक्ष को बचाने के लिए इन सभी छवियों को छोटा कर दिया गया है। उन्हें पूर्ण आकार में देखने के लिए क्लिक करें।

इनपुट छवि:

(x,y) = (165,155) तथा (x,y) = (0,0)

---

इनपुट छवि और इसके साथ आउटपुट (x,y) = (0,0):

---

इनपुट छवि और इसके साथ आउटपुट (x,y) = (600,350):

---

इनपुट छवि और इसके साथ आउटपुट (x,y) = (0,0):

---

इनपुट छवि और इसके साथ आउटपुट (x,y) = (0,0):

---

वैकल्पिक -30% बोनस: यूक्लिडियन दूरी का उपयोग करें। आपके एल्गोरिथ्म के लिए एक सुझाव इस प्रकार है (सामान्य रूपरेखा):

1. प्रारंभ पिक्सेल रखें।
2. उस पिक्सेल से बाढ़-भराव।
3. बाढ़ भराव में पहुँचे हर पिक्सेल के लिए,
4. प्रारंभ पिक्सेल से उस पिक्सेल को अर्ध-इकाई चरणों में, एक सीधी रेखा में ले जाएं।
5. प्रत्येक चरण पर, int()x और y निर्देशांक पर लागू होते हैं । यदि इन निर्देशांक पर पिक्सेल काला है, तो रोकें। अन्यथा, जारी रखें। (यह एक लाइन-ऑफ़-विज़न विधि है।)
6. कोई भी पिक्सेल जो एक सफेद पिक्सेल और / या एक पिक्सेल सीमा में पहुँच जाता है, जिसे पहले एक उच्चतर दूरी (यानी, +10) के साथ लेबल किया गया था, एक आरंभिक पिक्सेल बन जाता है।

अधिक मेटा अर्थ में, यह एल्गोरिथ्म प्रारंभ / पहले से रंगीन पिक्सेल से सीधी रेखा में पहुंचने वाले प्रत्येक पिक्सेल तक फैलता है, फिर किनारों के चारों ओर "इंच"। "काफी अधिक दूरी" बिट का उद्देश्य एल्गोरिथ्म को गति देना है। ईमानदारी से, यह वास्तव में मायने नहीं रखता है कि आप यूक्लिडियन दूरी को कैसे लागू करते हैं, यह सिर्फ इस तरह से बहुत अधिक दिखना है।

यह पहला उदाहरण यूक्लिडियन दूरी के साथ जैसा दिखता है, उपरोक्त एल्गोरिथ्म का उपयोग करते हुए:

इनपुट छवि और (x,y) = (165,155)

---

इस चुनौती को लिखने में मदद करने के लिए केल्विन हॉबीज़ और ट्राइकोप्लेक्स के लिए बहुत धन्यवाद! मज़े करो!

Comments

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

— केल्विन के शौक

यह कमाल का है! मुझे संदेह है कि यह गोल्फ संस्करण के लिए एक अच्छा आधार होने के लिए बहुत ही कुशल है =)

— दोष

जब वे इस तरह से रंगीन होते हैं तो मेज़ को हल करना बहुत आसान होता है!

— mbomb007

अंतिम उदाहरण वास्तव में सुंदर है। क्या इनपुट इमेज सिर्फ शोर है?

— डाइलन

@dylnan: यदि आप बोनस से ठीक पहले के उदाहरण के बारे में बात कर रहे हैं, तो यह वास्तव में एक भूलभुलैया है। आप इसे पूर्ण आकार में देखने के लिए इस पर क्लिक कर सकते हैं।

— एलेंडिया स्ट्राटन

Answer 1

मतलाब, 255 245 231 बाइट्स

यह पहले yऔर फिर छवि नाम की उम्मीद करता है x।

I=@input;i=imread(I('','s'));[r,c]=size(i);m=zeros(r,c);m(I(''),I(''))=1;M=m;d=m;K=[1,2,1];for k=1:r*c;d(m&~M)=k;M=m;m=~~conv2(m,K'*K>1,'s');m(~i)=0;end;z=max(d(:));v=[1,1,3];imshow(ind2rgb(d,hsv(z)).*repmat(m,v)+repmat(~d&i,v),[])

मैंने बाढ़ भरना (या यदि आप चाहते हैं तो 4-पड़ोस के लिए 'डायजेस्ट्रा') लागू किया है, तो सबसे पहले एक मुखौटा बनाकर जहां बीज पिक्सेल 1 पर सेट होता है और एक दूरी संचायक (छवि के आकार दोनों) के साथ होता है और फिर उसका अनुसरण करता है। कदम:

• एक 4 पड़ोस कर्नेल के साथ मुखौटा को दृढ़ करें (यह बहुत ही अक्षम हिस्सा है)
• मास्क के सभी नॉनजरो पिक्सल को 1 पर सेट करें
• छवि के सभी काले पिक्सेल को शून्य पर सेट करें
• संचायक में सभी मान सेट करें जहां इस चरण में मुखौटा बदल गया है k
• बढ़ना k
• तब तक दोहराएं जब तक कि मास्क में और अधिक परिवर्तन न हों (मैं वास्तव में इस स्थिति की जांच नहीं करता हूं, लेकिन बस ऊपरी सीमा के रूप में छवि में पिक्सेल की संख्या का उपयोग करें, जो आमतौर पर एक बहुत ऊपरी ऊपरी सीमा होती है, लेकिन यह कोडगुल्फ़ = है)

यह हमें हर पिक्सेल के मैनहट्टन के साथ दूरी संचायक में बीज पिक्सेल तक छोड़ देता है। फिर हम रंगों की दी गई सीमा को काटते हुए एक नई छवि बनाते हैं और "शून्य" मान को शून्य तक और "अंतिम" ह्यू को अधिकतम दूरी तक ले जाते हैं।

उदाहरण

एक बोनस के रूप में, यहाँ एक सुंदर चित्र है कि दूरी की गणना कैसे की जाती है। उज्जवल = दूर।

Comments

इस तरह की सामग्री मैं अपनी बेटी को आकर्षित करने के लिए प्रिंट आउट लेना चाहता हूं।

— रेयिनेंग

@rayryeng टेम्पलेट एल'एंडिया स्ट्रैटन का काम है, मेरा नहीं))

— दोष

आप अभी भी छवियों के लिए रंग डालते हैं: डी। आपने अंतिम चरण किया।

— रेय्यरेंग

मैं प्रसन्न हूँ। मैं मुश्किल से चुनौती को समझ सकता था

— 20

ईमानदारी से, मैं इसके लिए जो उपयोग करना चाहता हूं वह परिदृश्य बना रहा है।

— corsiKa

Answer 2

ब्लिट्ज 2 डी / 3 डी , 3068 * 0.7 = 2147.6

यह यूक्लिडियन एल्गोरिथ्म, गोल्फ के लिए संदर्भ कार्यान्वयन है।

image=LoadImage("HueEverywhere_example1.png")
Graphics ImageWidth(image),ImageHeight(image)
image=LoadImage("HueEverywhere_example1.png")
x=0
y=0
w=ImageWidth(image)
h=ImageHeight(image)
Type start
Field x,y
Field dis#
Field nex.start
End Type
Type cell
Field x,y
Field dis#
End Type
Type oldCell
Field x,y
Field dis#
End Type
initCell.start=New start
initCell\x=x
initCell\y=y
initCell\dis=1
Dim array#(w,h)
imgBuff=ImageBuffer(image)
LockBuffer(imgBuff)
s.start=First start
colr=col(0,0,0)
colg=col(0,0,1)
colb=col(0,0,2)
newcol=colr*256*256+colg*256+colb
WritePixelFast(s\x,s\y,newcol,imgBuff)
While s<>Null
c.cell=New cell
c\x=s\x
c\y=s\y
c\dis=s\dis
While c<>Null
For dy=-1To 1
For dx=-1To 1
If dx*dy=0And dx+dy<>0
nx=c\x+dx
ny=c\y+dy
ndis#=s\dis+Sqr#((nx-s\x)*(nx-s\x)+(ny-s\y)*(ny-s\y))
If nx >= 0And nx<w And ny >= 0And ny<h
If KeyHit(1)End
pixcol=ReadPixelFast(nx,ny,imgBuff)
If pixcol<>-16777216
If array(nx,ny)=0Or ndis<array(nx,ny)
check=1
steps=Ceil(dis)*2
For k=0 To steps
r#=k*1./steps
offx#=Int(s\x+(c\x-s\x)*r)
offy#=Int(s\y+(c\y-s\y)*r)
pixcol2=ReadPixelFast(offx,offy,imgBuff)
If pixcol2=-16777216
check=0
Exit
EndIf
Next
If check
array(nx,ny)=ndis
newCell.cell=New cell
newCell\x=nx
newCell\y=ny
newCell\dis=ndis
EndIf
EndIf
EndIf
EndIf
EndIf
Next
Next
o.oldCell=New oldCell
o\x=c\x
o\y=c\y
o\dis=c\dis
Delete c
c=First cell
Wend
For o.oldCell=Each oldCell
bordersWhite=0
For dy=-1To 1
For dx=-1To 1
If dx<>0Or dy<>0
nx=o\x+dx
ny=o\y+dy
If nx>=0And nx<w And ny>=0And ny<h
pixcol=ReadPixelFast(nx,ny,imgBuff)
If (pixcol=-1And array(nx,ny)=0)Or array(nx,ny)>o\dis+9
bordersWhite=1
Exit
EndIf
EndIf
EndIf
Next
If bordersWhite Exit
Next
If bordersWhite
ns.start=New start
ns\x=o\x
ns\y=o\y
ns\dis=o\dis
s2.start=First start
While s2\nex<>Null
If ns\dis<s2\nex\dis
Exit
EndIf
s2=s2\nex
Wend
ns\nex=s2\nex
s2\nex=ns
EndIf
Delete o
Next
EndIf
s2=s
s=s\nex
Delete s2
Wend
maxDis=0
For j=0To h
For i=0To w
If array(i,j)>maxDis maxDis=array(i,j)
Next
Next
For j=0To h
For i=0To w
dis2#=array(i,j)*360./maxDis
If array(i,j) <> 0
colr=col(dis2,0,0)
colg=col(dis2,0,1)
colb=col(dis2,0,2)
newcol=colr*256*256+colg*256+colb
WritePixelFast(i,j,newcol,imgBuff)
EndIf
Next
Next
UnlockBuffer(imgBuff)
DrawImage image,0,0
Function col(ang1#,ang2#,kind)
While ang1>360
ang1=ang1-360
Wend
While ang1<0 
ang1=ang1+360
Wend
While ang2>180
ang2=ang2-360
Wend
While ang2<-180
ang2=ang2+360
Wend
a3#=ang2/180.
If ang1>300
diff#=(ang1-300)/60.
r=255
g=0
b=255*(1-diff)
ElseIf ang1>240
diff#=(ang1-240)/60.
r=255*diff
g=0
b=255
ElseIf ang1>180
diff#=(ang1-180)/60.
r=0
g=255*(1-diff)
b=255
ElseIf ang1>120
diff#=(ang1-120)/60.
r=0
g=255
b=255*diff
ElseIf ang1>60
diff#=(ang1-60)/60.
r=255*(1-diff)
g=255
b=0
Else
diff#=(ang1-00)/60.
r=255
g=255*diff
b=0
EndIf
If a3>0
r2=r+a3*(255-r)
g2=g+a3*(255-g)
b2=b+a3*(255-b)
Else
r2=r+a3*r
g2=g+a3*g
b2=b+a3*b
EndIf
If r2>255
r2=255
ElseIf r2<0
r2=0
EndIf
If g2>255
g2=255
ElseIf g2<0
g2=0
EndIf
If b2>255
b2=255
ElseIf b2<0
b2=0
EndIf
If kind=0
Return r2
ElseIf kind=1
Return g2
ElseIf kind=2
Return b2
Else
Return 0
EndIf
End Function

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

Answer 3

C ++ / SFML: 1271 1235 1226 बाइट्स

-36 बाइट्स के लिए धन्यवाद उपयोगकर्ता 202729 -9 बाइट्स के लिए धन्यवाद ज़ाचरी

#include<SFML\Graphics.hpp>
#include<iostream>
#define V std::vector
#define P e.push_back
#define G(d,a,b,c) case d:return C(a,b,c);
#define FI(r,s)(std::find_if(e.begin(),e.end(),[&a](const T&b){return b==T{a.x+(r),a.y+(s),0};})!=e.end())
using namespace sf;using C=Color;struct T{int x,y,c;bool operator==(const T&a)const{return x==a.x&&y==a.y;}};int max(V<V<int>>&v){int m=INT_MIN;for(auto&a:v)for(auto&b:a)m=b>m?b:m;return m;}C hsv2rgb(int t){int ti=t/60%6;float f=t/60.f-ti,m=(1.f-f)*255,n=f*255;switch(ti){G(0,255,n,0)G(1,m,255,0)G(2,0,255,n)G(3,0,m,255)G(4,n,0,255)G(5,255,0,m)default:throw std::exception();}}void r(Image&a,int x,int y){auto d=a.getSize();V<V<int>>m(d.x,V<int>(d.y));int i=0,j,c=0,t;for(;i<d.y;++i)for(j=0;j<d.x;++j)m[j][i]=a.getPixel(j,i)==C::Black?-1:0;V<T>e{{x,y,1}};while(e.size()){V<T>t=std::move(e);for(auto&a:t){m[a.x][a.y]=a.c;if(a.x>0&&m[a.x-1][a.y]==0&&!FI(-1,0))P({a.x-1,a.y,a.c+1});if(a.y>0&&m[a.x][a.y-1]==0&&!FI(0,-1))P({a.x,a.y-1,a.c+1});if(a.x<m.size()-1&&m[a.x+1][a.y]==0&&!FI(1,0))P({a.x+1,a.y,a.c+1});if(a.y<m[0].size()-1&&m[a.x][a.y+1]==0&&!FI(0,1))P({a.x,a.y+1,a.c+1});}}c=max(m)-1;for(i=0,j;i<d.y;++i)for(j=0;j<d.x;++j)if(m[j][i]>0)a.setPixel(j,i,hsv2rgb(360.f*(m[j][i]-1)/c));}

sf::Image(संशोधित किया जाएगा) पैरामीटर भी उत्पादन होता है। आप इसे इस तरह से उपयोग कर सकते हैं:

sf::Image img;
if (!img.loadFromFile(image_filename))
    return -1;

r(img, 0, 0);

if (!img.saveToFile(a_new_image_filename))
    return -2;

पहला पैरामीटर छवि इनपुट (और आउटपुट) है, दूसरा और तीसरा पैरामीटर हैं xऔर yपैरामीटर जहां इसे शुरू करने की आवश्यकता है

Comments

स्विच मामला इतना बेकार लगता है कि शायद एक स्थूल परिभाषा उपयोगी होगी ... इसके अलावा `` setPixel(j, i,hsv2और FI(xm,ym) (std::find_ifवास्तव में आवश्यक है?

— user202729

आप के बीच की जगह को हटा सकते हैं G(d,a,b,c)और case d:। इसके अलावा, के बीच की जगह case d:और return C(a,b,c)भी अनावश्यक है। संचालन के क्रम द्वारा (b>m?b:m)कोष्ठकों की आवश्यकता नहीं है, और (t/60)%6=> t/60%6।

— ज़ाचारि

आपको शायद नाम बदलना चाहिए xmऔर ymचर नामों को कम करना चाहिए

— Zacharý

मुझे लगता है कि बीच की जगह को दूर किया जा सकता है G(d,a,b,c)और case, FI, ti, और hsv2rgbप्रत्येक छोटे नाम के साथ बदला जा सकता है।

— जकार्इ

Answer 4

सी ++, 979 969 898 859 848 बाइट्स

#include<cstdio>
#include<cstdlib>
#define K 400
#define L 400
#define M (i*)malloc(sizeof(i))
#define a(C,X,Y)if(C&&b[Y][X].c){t->n=M;t=t->n;b[Y][X].d=d+1;t->n=0;t->c=X;t->d=Y;}
#define A(n,d)case n:d;break;
#define F fgetc(f)
#define W(A,B) for(A=0;A<B;A++){
struct i{int c;int d;int v;i*n;}b[L][K]={0},*h,*t;float m=0;int main(){FILE*f=fopen("d","r+b");int x,y,d=0;W(y,L)W(x,K)b[y][x].c=F<<16|F<<8|F;}}rewind(f);x=165,y=155;h=M;h->c=x;h->d=y;b[y][x].d=d;t=h;while(h){i*p=b[h->d]+h->c;if(p->v)h=h->n;else{p->v=1;x=h->c;y=h->d;d=p->d;m=d>m?d:m;a(x>0,x-1,y)a(x<K-1,x+1,y)a(y>0,x,y-1)a(y<L-1,x,y+1)}}W(y,L)W(x,K)i p=b[y][x];unsigned char n=-1,h=p.d/(m/n),R=h%43*6,Q=n*(n-(n*R>>8))>>8,t=n*(n-(n*(n-R)>>8))>>8,r,g,b;switch(h/43){A(0,n,t,0)A(1,Q,n,0)A(2,0,n,t)A(3,0,Q,n)A(4,t,0,n)A(5,n,0,Q)}d=h?r|g<<8|b<<16:p.c?-1:0;fwrite(&d,1,3,f);}}}

• इनपुट: RGB डेटा फ़ाइल (फ़ाइल में निहित)
• आउटपुट: RGBA RGB डेटा फ़ाइल (फ़ाइल में आउटपुट: d)
• उदाहरण: Convert -depth 8 -size "400x400" test.png d.rgb && mv -f d.rgb d && g ++ -o test main.c &&/test।
• नोट: छवि का आकार और प्रारंभ एक स्रोत स्तर पर नियंत्रित किया जाता है, अगर यह एक मुद्दा है 50 बाइट्स या कुछ जोड़ें - मैंने इसे ईमानदारी से बदलने के लिए परवाह नहीं की।

बिलकुल भी प्रत्यक्ष नहीं "ungolf" लेकिन यह एक C प्रोटोटाइप था जिसका मैंने पहले मजाक किया था:

#include "stdio.h"
#include "stdlib.h"

struct i{
    unsigned int c;
    int d;
    int v;
}b[400][400]={0};

typedef struct q{
    int x;
    int y;
    struct q *n;
}q;
q *qu;
q *t;
float m=0;
int get_dist(int x, int y)
{
    int d = 0;

}

void flood(int x,int y,int d){
    qu=malloc(sizeof(q));
    qu->x=x;qu->y=y;b[y][x].d=d;
    t=qu;
    while(qu){
        struct i *p = &b[qu->y][qu->x];
        if(p->v){qu=qu->n; continue;}
        p->v=1;x=qu->x;y=qu->y;d=p->d;
        #define a(C,X,Y) if(C&&b[Y][X].c){t->n=malloc(sizeof(q));t=t->n;b[Y][X].d=d+1;t->n=0;t->x=X;t->y=Y;}
        a(x>0,x-1,y);
        a(x<399,x+1,y);
        a(y>0,x,y-1);
        a(y<399,x,y+1);
        m=p->d>m?p->d:m;
    }
}

unsigned int C(int h)
{
    int r=0,g=0,b=0;
    int s=255,v=255;
    unsigned char R, qq, t;

    R = h%43*6; 

    qq = (v * (255 - ((s * R) >> 8))) >> 8;
    t = (v * (255 - ((s * (255 - R)) >> 8))) >> 8;

    switch (h / 43){
        case 0: r = v; g = t; break;
        case 1: r = qq; g = v; break;
        case 2: g = v; b = t; break;
        case 3: g = qq; b = v; break;
        case 4: r = t; b = v; break;
        case 5: r = v; b = qq; break;
    }

    return r|(g<<8)|(b<<16)|255<<24;
}

#define F fgetc(f)
int main()
{
    FILE *f=fopen("d", "r+b");
    for(int y=0; y<400; y++){
        for(int x=0; x<400; x++){
            b[y][x].c = (F<<24)|(F<<16)|(F<<8);
        }
    }
    rewind(f);
    flood(165,155,1);
    m/=255.f;
    for(int y=0; y<400; y++){
        for(int x=0; x<400; x++){
            struct i p = b[y][x];
            unsigned int h = C(p.d/m);
            int o = p.c?-1:255<<24;
            if(p.d)fwrite(&h,4,1,f);
            else fwrite(&o,4,1,f);
        }
    }
}

कई अवधारणाएं समान हैं, लेकिन निश्चित रूप से छोटे बदलावों के असंख्य हैं। यह संकलित करने के लिए कि C के रूप में आपको C11 का उपयोग करने की आवश्यकता है (C99 शायद काम करेगा लेकिन मैं केवल C11 में कड़ाई से परीक्षण किया गया है)।
मैंने इस चुनौती का भरपूर आनंद लिया, मुझे कुछ नया आजमाने का विचार देने के लिए धन्यवाद :)।
संपादित करें: गोल्फ थोड़ा बेहतर था।
Edit2: मेरी पिक्सेल संरचना और कतार दो समान हैं, थोड़ा अधिक मैक्रो एब्यूज और 255 के रिफ्लेक्ट किए गए उपयोग जैसे कि इसे 1 के रूप में परिभाषित किया जा सकता है जब अहस्ताक्षरित वर्णों की एक श्रृंखला को परिभाषित करते हैं, और अंत में एक फ़ंक्शन कॉल को हटा दिया जाता है।
Edit3: पुन: उपयोग किए गए कुछ और चर, ऑपरेटर पूर्ववर्ती ट्विक्स, और आउटपुट को बदलकर RGB चैनल को अल्फ़ा सेव कर
रहा है Edit4: मुझे लगता है कि मुझे अब इसके साथ किया गया है, कुछ पॉइंटर अंकगणितीय परिवर्तन और मामूली नियंत्रण प्रवाह ट्विक्स।

Answer 5

पायथन 3 और मैटलोट्लिब, 251 बाइट्स

from pylab import*
def f(i,p):
    h,w,_=i.shape;o=full((h,w),inf);q=[p+(0,)]
    while q:
        x,y,d=q.pop(0)
        if w>x>=0and h>y>=0and i[y,x,0]:o[y,x]=d;i[y,x]=0;d+=1;q+=[(x-1,y,d),(x+1,y,d),(x,y-1,d),(x,y+1,d)]
    imshow(i);imshow(o,'hsv')

इनपुट एक MxNx3 संख्यात्मक सारणी है जैसा कि matplotlib के imshow()फ़ंक्शन द्वारा लौटाया जाता है । इनपुट को फ़ंक्शन द्वारा संशोधित किया जाता है, इसलिए इसे पहले से कॉपी किया जाना चाहिए। यह छवि को स्वचालित रूप से प्रदर्शित करता है यदि matplotlib "इंटरैक्टिव" मोड में है; अन्यथा एक कॉल show()7 बाइट्स के लिए जोड़ा जाना चाहिए।

आउटपुट पहले मूल छवि को प्रदर्शित करने और फिर इसके ऊपर इंद्रधनुष छवि को प्रदर्शित करके बनाया गया है। Matplotlib आसानी से काले और सफेद छवि शो के माध्यम से inf और नैन को पारदर्शी मानता है।