दो-रंग ओवरलैपिंग सर्किल


22

अपनी पसंद के एक उचित प्रारूप में निम्नलिखित इनपुट में एक प्रोग्राम या फ़ंक्शन लिखें:

  • दो सकारात्मक पूर्णांक डब्ल्यू और एच जो आपके द्वारा बनाई जा रही छवि की चौड़ाई और ऊंचाई को परिभाषित करते हैं।

  • दो RGB रंग C1 और C2 जिनका उपयोग छवि को रंग देने के लिए किया जाएगा।

  • प्रपत्र के 3-टुपल्स की एक सूची जो छवि के विमान में (r, x, y)त्रिज्या rऔर केंद्र के साथ हलकों को परिभाषित करती है x, yrएक सकारात्मक पूर्णांक और है xऔर yकिसी भी पूर्णांक हैं। छवि का शीर्ष बाएँ पिक्सेल है 0, 0और x- अक्ष दाईं ओर बढ़ता है और y- अक्ष नीचे की ओर बढ़ता है।

W द्वारा H के आयाम W के साथ एक छवि आउटपुट करें जो C1 और C2 के साथ रंगी हो जैसे कि सभी अतिव्यापी हलकों द्वारा परिभाषित कोई भी दो पड़ोसी क्षेत्र एक ही रंग के नहीं हैं।

उदाहरण के लिए: यदि इनपुट है

W = 300
H = 200
C1 = (255, 200, 0)
C2 = (128, 0, 255)
Circles = (25, 50, 80), (40, 80, 120), (300, -100, 6), (17, 253, 162)

तब सर्कल की सीमाएं इस तरह दिखती हैं:

उदाहरण 1 सर्कल की सीमाएं

मंडलियों द्वारा बनाई गई छवि में छह विशिष्ट, सन्निहित क्षेत्र हैं। प्रत्येक क्षेत्र को C1 (पीला) या C2 (बैंगनी) के साथ रंगीन होना चाहिए ताकि कोई भी दो पड़ोसी क्षेत्र एक ही रंग के न हों।

ऐसा करने के दो तरीके हैं, उनका एकमात्र अंतर यह है कि रंगों की अदला-बदली की जाती है:

उदाहरण 1 आउटपुट 1 उदाहरण 1 आउटपुट 2

इस प्रकार, उदाहरण इनपुट के लिए इन दो चित्रों में से कोई भी मान्य आउटपुट होगा।

कुछ इस तरह इस के बाद से दो पीले क्षेत्रों को एक दूसरे के पड़ोसी अवैध उत्पादन होगा।

आपकी आउटपुट छवियों को इन दिशानिर्देशों का पालन करना चाहिए:

  • C1 और C2 के अलावा, एक तीसरा, तटस्थ रंग जैसे काले या सफेद का उपयोग सर्कल की सीमाओं के लिए किया जा सकता है जब तक कि वे 5 पिक्सेल से अधिक मोटी न हों। (ब्लैक, 1-पिक्सेल मोटी सीमाएं ऊपर दिए गए उदाहरण में मौजूद हैं।)

  • हालांकि, मंडलियों की सीमाओं की आवश्यकता नहीं है। क्षेत्र सीधे एक दूसरे के पड़ोसी हो सकते हैं:

    उदाहरण 1 आउटपुट 3 उदाहरण 1 आउटपुट 4

    उपरोक्त उदाहरण के लिए ये दोनों एक और वैध आउटपुट है।

  • सर्कल ड्राइंग एल्गोरिदम का उपयोग करके सर्किल को यथासंभव सटीक होना चाहिए या आपके ग्राफिक्स लाइब्रेरी जो भी प्रदान करता ।

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

  • एंटी-अलियासिंग की अनुमति है लेकिन आवश्यक नहीं है।

  • पृष्ठभूमि में ग्रिडलाइन या अक्ष लेबल आदि की अनुमति नहीं है।

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

और ज्यादा उदाहरण

हलकों के विभिन्न सेटों के साथ इन इनपुटों का उपयोग करते हुए:

W = 100
H = 60
C1 = (255, 0, 0)
C2 = (0, 0, 255)

किसी भी उदाहरण में रंगों की अदला-बदली की जा सकती है और वे वैध बने रहेंगे।

Circles =
A. empty list
B. (13, 16, 20)
C. (30, 16, 20)
D. (200, 16, 20)
E. (42, 50, 20)
F. (42, 50, 20), (17, 40, 30)
G. (42, 50, 20), (17, 20, 30)
H. (42, 50, 20), (17, 10, 30), (10, 50, 30)
I. (42, 50, 20), (17, 10, 30), (35, 50, 20)
J. (18, 36, 40), (18, 63, 40), (18, 50, 20)
K. (100, -10, -20), (60, 50, -10)
L. (18, 36, 40), (18, 63, 40), (18, 50, 20), (14, 50, 20), (5, 50, 18), (20, 0, 0), (70, 22, 0), (10000, -9970, 0), (135, 100, -80) 

A. पूर्व ए B. पूर्व बी C. पूर्व सी D. पूर्व डी
E. प्रोग्राम फ़ाइल F. पूर्व एफ G. पूर्व जी H. पूर्व ज
I. पूर्व मैं J. पूर्व जे K. पूर्व के L. पूर्व एल

सुनिश्चित करें कि आपका आउटपुट इन सभी उदाहरणों के समान है।


यह अच्छा लग रहा है, क्या हम एससीआई में आउटपुट कर सकते हैं, उदाहरण के लिए सी 1 1 है और सी 2 0 है?
मैथ्यू रो

@MatthewRoh नहीं। मुझे पता है कि सुविधाजनक होगा लेकिन छवियों की आवश्यकता है।
केल्विन के

1
ठीक है, फिर मुझे लगता है कि मैं बाहर गिन सकता हूंtikz
गेहूं जादूगर

1
@MatthewRoh, netpbm इस साइट पर आमतौर पर इस्तेमाल किया जाने वाला इमेज फॉर्मेट है।
पीटर टेलर

2
@ लिस ठीक है। छोटे इनपुट विविधताएँ जैसे कि या y अक्ष का ऊपर जाना ठीक है।
केल्विन के शौक

जवाबों:


14

मैथमेटिका, 165 बाइट्स

ContourPlot[Cos@Tr[Boole[Norm[{x,y}-#2]<#]Pi&@@@#4],{x,0,#},{y,0,#2},PlotPoints->5!,AspectRatio->Automatic,Frame->False,ContourShading->RGBColor@@@#3,Contours->{0}]&

चार तर्कों को लेते हुए शुद्ध कार्य: चौड़ाई, ऊँचाई (दोनों पूर्णांक), 0 और 1 के बीच संख्याओं के क्रमबद्ध युग्म (दो RGB रंगों का प्रतिनिधित्व), और {r, {x, y}}रेडी और केंद्रों को रिकॉर्ड करने के लिए प्रपत्र की वस्तुओं की सूची मंडलियां। उदाहरण के लिए, ओपी में पहला उदाहरण तर्कों के साथ कहा जाएगा[300, 200, {{1, 0.784, 0}, {0.5, 0, 1}}, {{25, {50, 80}}, {40, {80, 120}}, {300, {-100, 6}}, {17, {253, 162}}}] । माथेमेटिका में सकारात्मक y- अक्ष ऊपर की ओर इंगित करता है।

Norm[{x,y}-#2]<#पता लगाता है कि एक बिंदु किसी दिए गए सर्कल के अंदर है या नहीं; Boole[...]Piधर्मान्तरित कि Trueया Falseकरने के लिए πया 0। सभी इनपुट सर्किलों पर उन circless / 0s की गणना करने के बाद, Trउन्हें जोड़ा जाता है और Cosπ-1 के विषम गुणकों को भी ts से 1 के गुणक में परिवर्तित करता है। ContourPlot[...,Contours->{0}]फिर दो रंगों में विमान का उपयुक्त क्षेत्र इस बात पर निर्भर करता है कि मूल्य उससे अधिक है या कम 0AspectRatio->Automaticमंडलियां मंडलियों की तरह दिखती हैं; PlotPoints->5!एक सभ्य सटीकता देता है (इसे बढ़ाएं 9!यदि आप वास्तव में एक अद्भुत तस्वीर चाहते हैं, भविष्य में दूर!); Frame->Falseकुल्हाड़ियों से छुटकारा; और ContourShading->RGBColor@@@#3आकृति के लिए इनपुट रंगों का उपयोग करता है।

नमूना उत्पादन, रंगों की पहली जोड़ी के साथ (क्योंकि वे अच्छे हैं) लेकिन मंडलियों का अंतिम सेट:

नमूना उत्पादन


11

जावास्क्रिप्ट / एसवीजी / एचटीएमएल 5, 219 बाइट्स

f=// for demo
(w,h,b,f,a)=>`<svg width=${w} height=${h}><rect width=${w} height=${h} fill=rgb(${b}) /><path fill=rgb(${f}) fill-rule=evenodd d=${a.map(([r,x,y])=>[`M`+x,y-r+`a`+r,r,0,0,0,0,r+r+`a`+r,r,0,0,0,0,-r-r]).join``} /></svg>`
;//demo
[[`A`, []],
 [`B`, [[13, 16, 20]]],
 [`C`, [[30, 16, 20]]],
 [`D`, [[200, 16, 20]]],
 [`E`, [[42, 50, 20]]],
 [`F`, [[42, 50, 20], [17, 40, 30]]],
 [`G`, [[42, 50, 20], [17, 20, 30]]],
 [`H`, [[42, 50, 20], [17, 10, 30], [10, 50, 30]]],
 [`I`, [[42, 50, 20], [17, 10, 30], [35, 50, 20]]],
 [`J`, [[18, 36, 40], [18, 63, 40], [18, 50, 20]]],
 [`K`, [[100, -10, -20], [60, 50, -10]]],
 [`L`, [[18, 36, 40], [18, 63, 40], [18, 50, 20], [14, 50, 20], [5, 50, 18], [20, 0, 0], [70, 22, 0], [10000, -9970, 0], [135, 100, -80]]]
 ].forEach(([c, a])=>document.write(`<nobr><tt>&nbsp;${c}.&nbsp;</tt>${f(100, 60, [255, 0, 0], [0, 0, 255], a)}</nobr><wbr>`));


10

बीबीसी बेसिक, 120 117 बाइट्स

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर दुभाषिए को डाउनलोड करें

I.w,h,R,G,B,r,g,b:V.22,4,19;16,r,g,b,275;16,R EORr,G EORg,B EORb,24,0;0;w;h;16
5I.r,x,y:V.25,4,x;h-y;25,154,r;0;:G.5

BBC बेसिक में कई रंग मोड हैं जो आपको मूल तर्क संचालन के अनुसार रेखापुंज ग्राफिक्स को प्लॉट करने की अनुमति देते हैं: OR, AND, XOR आदि।

यह पैलेट रिप्रोग्रामिंग का भी समर्थन करता है, जिसका अर्थ है कि उदाहरण के लिए यहां 2 रंग की छवि 4096 रंगों में से किसी भी रंग को रिप्रोग्राम कर सकती है। यहां उपयोग किए जाने वाले कार्यान्वयन में मूल बीबीसी कार्यान्वयन से कुछ (अनिर्दिष्ट) अंतर हैं, जिसमें ईओआर ऑपरेटर आवश्यक नहीं होंगे।

Ungolfed

  INPUTw,h,R,G,B,r,g,b:                           :REM Input size and colours
  VDU22,4                                         :REM Change to MODE 4 (2 colours) as the default mode gives odd behaviour
  VDU19,0,16,r,g,b,19,1,16,R EORr,G EORg,B EORb   :REM Reprogram the colours to R,G,B and R^r,G^g,B^b
  VDU24,0;0;w;h;16                                :REM Setup a graphics viewport of the right size, and "clear" it to change background colour
5 INPUTr,x,y                                      :REM take input coordinates
  VDU25,4,x;h-y;                                  :REM move to x,y (h-y required as BBC BASIC y axis increases upward, reverse of spec)
  VDU25,154,r;0;                                  :REM draw circle in "logical inverse colour" of existing pixels (this implementation seems however to XOR with colour 1 instead)
  GOTO5                                           :REM repeat infinitely until user presses escape

विशिष्ट आउटपुट स्क्रीन

उदाहरण छवि को 10 इकाइयों के कारक / पिक्सल में 5 के कारक (बीबीसी बेसिक 1 पिक्सेल = 2 इकाइयों का उपयोग करता है) द्वारा बढ़ाया गया है।

यहां छवि विवरण दर्ज करें


10

MATL , 30 29 25 बाइट्स

2ZG:i:!J*+2&!-|i<so2&!1YG

इनपुट प्रारूप:

  • Colormap 0 और 255 के बीच मूल्यों के एक मैट्रिक्स के रूप में, जहां प्रत्येक पंक्ति एक रंग को परिभाषित करती है
  • डब्ल्यू
  • एच
  • 1-आधारित केंद्र के स्तंभ वेक्टर जटिल मानों के रूप में समन्वयित करते हैं ( x वास्तविक भाग है, y काल्पनिक भाग है)
  • रेडियम का कॉलम वेक्टर।

MATL ऑनलाइन पर कोशिश करो ! या अंतिम परीक्षण मामले को सत्यापित करें । (दुभाषिया अभी भी प्रायोगिक है। आपको पृष्ठ को रीफ्रेश करने और यदि यह काम नहीं करता है तो पुन: प्रयास करने की आवश्यकता हो सकती है)।

व्याख्या

कोड अंकों की ग्रिड को परिभाषित करने और दूरी की गणना करने के लिए जटिल संख्याओं का उपयोग करता है, और प्रसारण के साथ सरणी संचालन का भारी उपयोग करता है

2ZG    % Implicitly input matrix of colors. Set as colormap
:      % Implicitly input W. Push [1 2 ... W]
i:     % Input H. Push [1 2 ... H]
!J*    % Transpose, multiply by 1i
+      % Add element-wise with broadcast. Gives H×W grid of points as
       % complex numbers, 1-based 
2&!    % Permute first dimension with the third. Gives a 1×W×H array
-|     % Implicitly input center coordinates. Subtract grid from them,
       % element-wise with broadcast. Gives a C×H×W array, where C is the
       % number of circles
i      % Input column vector of circle radii
<      % Less than, element-wise with broadcast
so     % Sum along first dimension, modulo 2. Gives a 1×W×H array
2&!    % Permute first dimension with the third. Gives a a H×W array
1YG    % Display as scaled image

2
मैं कहता हूँ कि उन बाइट्स बचाओ! : डी
ग्रेग मार्टिन

1
@GregMartin आप सही हैं। जब 4 बाइट्स को बचाया जा सकता है तो कौन लालित्य की परवाह करता है! :-) संपन्न
लुइस मेंडो

1
@LuisMendo कोडगुल्फ़ के साथ जितना छोटा होगा, चाहे कितना भी बदसूरत हो जाए। ;)
केविन क्रूज़सेन

6

अजगर का उपयोग कर pypng , 140 138 बाइट्स

import png
f=lambda W,H,c,d,C:png.from_array([[[c,d][sum(abs(x-X+1j*(y-Y))<r for r,x,y in C)%2]for X in range(W)]for Y in range(H)],'RGB')

उदाहरण का उपयोग:

W = 100
H = 60
C1 = (255, 0, 0)
C2 = (0, 0, 255)
Circles = (18, 36, 40), (18, 63, 40), (18, 50, 20), (14, 50, 20), (5, 50, 18), (20, 0, 0), (70, 22, 0), (10000, -9970, 0), (135, 100, -80)
f(W, H, C1, C2, Circles).save('test.png')

2 बाइट बचाने के लिए xnor का धन्यवाद।


गोल्फ में आपका स्वागत है! जाँच करने के लिए कि कोई बिंदु एक सर्कल में है, जटिल चाल का उपयोग करने के लिए एक चाल है abs(x-X+1j*(y-Y))<r:।
एक्सनोर

3

गणित (गैर-प्रतिस्पर्धात्मक)

(आईडीसी PPCG में कैसे करें, इसलिए मैंने टूल का उपयोग करने के लिए LaTeX का उपयोग किया)

व्याख्या

कई सर्कल समीकरणों का उत्पाद ((x-a)^2+(y-b)^2-r^2 )> = 0 एक ग्राफ बनाएगा जिसे इस प्रश्न की आवश्यकता है। समीकरण में, nसरणी के आकार है, और (x, y or r)_kहै kवें (x, y, or r)तत्व।

उदाहरण

(0,0,2),(2,2,2)

(साभार वुल्फरामअल्फा)

(वोल्फ्रामअल्फा द्वारा असमानता की साजिश)

WolframAlpha के लिए / रन समीकरण प्राप्त करें

स्क्रिप्ट प्राप्त करना: पूर्ण

रनिंग स्क्रिप्ट: अभी तक नहीं किया गया

अब इसे गणितज्ञ के साथ काम करें ...


मुझे आश्चर्य है कि क्या यह वैध है?
मैथ्यू रो

आपको एक विशिष्ट पूर्व-मौजूदा दुभाषिया को सूचीबद्ध करने की आवश्यकता होगी जो उस इनपुट को दिए गए फॉर्म में आउटपुट को प्लॉट करेगा। कि इसमें बाइट्स को गिनना संभव होगा। वर्तमान में, मुद्दा यह है कि क्योंकि यह एक दुभाषिया से बंधा हुआ नहीं है, यह समीकरण का प्रतिनिधित्व करने के लिए एक विशिष्ट प्रारूप से बंधा हुआ नहीं है, और इस प्रकार यह संकेतन अनौपचारिक रूप से गिनने के लिए अनौपचारिक और असंभव है। चारों ओर समीकरणों के रेखांकन की साजिश रचने के लिए बहुत सारे कार्यक्रम हैं, इसलिए हो सकता है कि यह एक ट्रिक इनपुट प्रारूप के साथ एक खोजने की कोशिश कर रहा हो।

@ ais523 ओह। मैं इसे वुल्फरामअल्फा के साथ काम करने की कोशिश करूंगा।
मैथ्यू रो

1

पायथन 2.x, 166 158

import re;def f(W,H,c,d,C):print'P3',W,H,255,re.sub('[^0-9]',' ',repr([[d,c][sum([abs(x-X+1j*(y-Y))<r for r,x,y in C])%2]for Y in range(H)for X in range(W)]))

फ़ंक्शन मानक आउटपुट पर एक PPM फ़ाइल बनाता है।

उदाहरण:

W = 300
H = 200
C1 = (255, 200, 0)
C2 = (128, 0, 255)
Circles = [(25, 50, 80), (40, 80, 120), (300, -100, 6), (17, 253, 162)]

f(W, H, C1, C2, Circles)

उदाहरण


1

आम लिस्प + क्विकलिस्प + ZPNG 260 + 20 = 280 चार्ट

यह मैंने कभी सीएल में लिखे गए सबसे व्यापक कोड में से कुछ है, और अगर मैं एक कोड गोल्फ नहीं कर रहा था, तो मैंने इसे पुनर्गठन किया होगा ताकि इसे पढ़ने में बहुत आसान हो ...

प्रस्तावना (20 वर्ण)

(ql:quickload 'zpng)

गोल्फ (260 वर्ण)

(lambda(w h g b c)(make-instance'zpng:png :image-data(coerce(loop :for j :below h :nconc(loop :for i :below w :append(if(evenp(count t(mapcar(lambda(c)(<(abs(complex(-(cadr c)i)(-(caddr c)j)))(car c)))c)))g b)))'(array(unsigned-byte 8)(*))):width w :height h))

Ungolfed:

(परीक्षणनीयता और पठनीयता के लिए लंबे चर नामों की अनुमति देने के लिए डिफॉन का उपयोग करता है)

(defun mk-png (width height color1 color2 circles)
  (make-instance 'zpng:png
                 :image-data (coerce (loop :for j :below height
                                           :nconc (loop :for i :below width
                                                        :append (if (evenp (count t (mapcar (lambda (circ)
                                                                                              (< (abs (complex (- (cadr circ) i) (- (caddr circ) j)))
                                                                                                 (car circ)))
                                                                                            circles)))
                                                                    color1 color2)))
                                     '(array (unsigned-byte 8) (*)))
                 :width width
                 :height height))

उदाहरण उपयोग:

(let ((png (mk-png 300 200 '(255 200 0) '(128 0 255) '((25 50 80) (40 80 120) (300 -100 6) (17 253 162)))))
  (zpng:write-png png #p"path/to/file.png"))

explaination

(lambda (circ)
   (< (abs (complex (- (cadr circ) i) (- (caddr circ) j)))
      (car circ)))

यदि बिंदु (i, j) दिए गए सर्कल सर्किल के भीतर आता है, तो सही है। यूक्लिडियन दूरी की गणना उस जटिल संख्या के निरपेक्ष मान के द्वारा की जाती है जो परिमण्डल के केंद्र (i, j) से सदिश का प्रतिनिधित्व करती है।

(evenp (count t (mapcar ___
                         circles)))

उन मंडलियों पर कार्य करने वाले नक्शे को सूचीबद्ध करें और जांचें कि दिए गए बिंदु (i, j) एक सम संख्या में मंडलियों के भीतर हैं या नहीं।

(if ____
     color1 color2)

उस टेस्ट के आधार पर रंग का चयन करें।

(loop :for j :below height
       :nconc (loop :for i :below width
                    :append ____))

छवि में प्रत्येक (i, j) पर लूप करके और परिणामी सूचियों को एक साथ जोड़कर सभी आरजीबी बाइट्स की एक फ्लैट सूची एकत्र करें।

(coerce ____
         '(array (unsigned-byte 8) (*)))

बाइट्स की सूची को बाइट्स के एक उचित सरणी में परिवर्तित करें, ताकि zpng इसे ठीक से निगलना कर सके।

(make-instance 'zpng:png
                :image-data ____
                :width width
                :height height)

Png ऑब्जेक्ट बनाएँ।

(defun mk-png (width height color1 color2 circles)
   ___)

चौड़ाई, ऊँचाई, दो रंग और हलकों की सूची लेने के लिए फ़ंक्शन बनाएँ और बनाई गई png ऑब्जेक्ट वापस करें।


0

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

मैंने JS + SVG समाधान देखा, लेकिन मुझे बस एक कैनवास-आधारित समाधान बनाना था ;-) यह एक फ़ंक्शन है जो एक कैनवास तत्व देता है। यदि एक मौजूदा कैनवास तत्व प्रदान किया जा सकता है, तो 40 बाइट हटा दें।

जैसे बुलाओ f(width, height, [[r1, g1, b1], [r2, g2, b2]], [[r1, x1, y1], [r2, x2, y2], ...])

let f =
(w,h,a,c,O=document.createElement`canvas`)=>{O.width=w;O.height=h;C=O.getContext`2d`;for(y=0;y<h;y++)for(x=0;x<w;x++)C.fillStyle=`rgb(${a[c.filter(([R,X,Y])=>(X-x)**2+(Y-y)**2<R**2).length%2]})`,C.fillRect(x,y,1,1);return O}

let tests = A.innerHTML.match(/.+/g);
A.innerHTML = "";
for (let i of tests) {
  let p = document.createElement("span");
  p.innerHTML = "<br>" + i.slice(0, 3);
  p.style["font-family"] = "monospace";
  A.append(p);
  A.append(f(100, 60, [[255,0,0], [0,0,255]],
    eval(`[${ i.slice(3).replace(/\(/g, "[").replace(/\)/g, "]") }]`)
  ));
}
<div id=A>
A. 
B. (13, 16, 20)
C. (30, 16, 20)
D. (200, 16, 20)
E. (42, 50, 20)
F. (42, 50, 20), (17, 40, 30)
G. (42, 50, 20), (17, 20, 30)
H. (42, 50, 20), (17, 10, 30), (10, 50, 30)
I. (42, 50, 20), (17, 10, 30), (35, 50, 20)
J. (18, 36, 40), (18, 63, 40), (18, 50, 20)
K. (100, -10, -20), (60, 50, -10)
L. (18, 36, 40), (18, 63, 40), (18, 50, 20), (14, 50, 20), (5, 50, 18), (20, 0, 0), (70, 22, 0), (10000, -9970, 0), (135, 100, -80)
</div>

उदाहरण आउटपुट:

दो रंगों वाला मंडलियां


0

Löve2D , 353 बाइट्स।

o=love.graphics
a=arg
w,h,r,g,b,R,G,B=...c={}for i=9,#a,3 do
c[#c+1]={a[i],a[i+1],a[i+2]}end
C=o.newCanvas(w,h)o.setCanvas(C)o.clear(R,G,B)for k,v in pairs(c)do
o.stencil(function()o.circle("fill",v[2],v[3],v[1],9^3)end,"invert",1,true)end
o.setStencilTest("greater",0)o.setColor(r,g,b)o.rectangle("fill",0,0,w,h)local
C:newImageData():encode("png","c")
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.