गुइलोचे पेपर मनी और अन्य प्रतिभूतियों पर एक विशिष्ट पैटर्न है। इतिहास में एक विषयांतर के साथ उनके बारे में एक विस्तृत कहानी पिछले लेख में पाई जा सकती है । एक ड्राइंग एल्गोरिदम जो बिंदुओं द्वारा गिलोय बनाता है, वहां भी दिया गया था।बहुत बेकार, यह ध्यान दिया जाना चाहिए अगर हम उन्हें केवल मनोरंजन के लिए नहीं, बल्कि व्यावहारिक उद्देश्यों के लिए खींचते हैं - उदाहरण के लिए, डिजाइन में उन बहुत ही प्रतिभूतियों को जोड़ने के लिए। हजारों अंक केवल संपादक को धीमा कर देंगे, लेकिन यह परिणाम को वैसे भी प्रदर्शित करने में सक्षम नहीं होगा - वास्तविक निरंतर लाइनों के बजाय, अंकों के औसत के कुछ प्रकार के परिणाम होंगे, जैसे कि भगवान एक आत्मा डाल देंगे।इसलिए, एक और एल्गोरिदम के बारे में सोचने का समय आ गया है - जो तुरंत वैक्टर देगा। चूंकि घुमावदार रेखाओं के लिए लोकप्रिय संपादकों में केवल बेज़ियर कर्व्स द्वारा प्रक्षेप प्रस्तावित है, हम उन पर ध्यान केंद्रित करेंगे।एल्गोरिथ्म, वास्तव में, सरल है - और पहले भाग में वर्णित की तुलना में बहुत सरल है। हम दो लिफाफा कर्व लेते हैं, तरंगों की संख्या 360 डिग्री में फिट होनी चाहिए, हम अनुमान लगाते हैं कि किस कोण और किस वक्रता के साथ वास्तविक गिलोच को वर्तमान बिंदु से अगले बिंदु तक जाना चाहिए, और इसे चार बेज़ियर ब्रेड्स के साथ प्रक्षेपित करना चाहिए।यहां असिम्पोट में एक कार्यक्रम है, जो इस तरह की चीजों के लिए बेहद सुविधाजनक है।import graph;
size(1000,1000);
xaxis(ticks=Ticks);
yaxis(ticks=Ticks);
defaultpen(2);
var zero = (0,0);
real tens(bool at_top, real angle)
{
return angle/180;
}
guide wave(path top, path bottom, int parts, real offset)
{
guide w;
real step = 1/parts;
real half = step/2;
pair[] top_pt;
pair[] bot_pt;
pair[] top_dir;
pair[] bot_dir;
real[] top_angle;
real[] bot_angle;
for(int i: sequence(0,parts-1))
{
real rel = i*step + step*offset;
real top_time = reltime(top, rel);
real bot_time = reltime(bottom, rel+half);
top_pt[i] = point(top, top_time);
bot_pt[i] = point(bottom, bot_time);
top_dir[i] = dir(top, top_time);
bot_dir[i] = dir(bottom, bot_time);
}
for(int i: sequence(0,parts-1))
{
int prev = i == 0 ? parts-1 : i-1;
int next = i == parts-1 ? 0 : i+1;
var v1 = bot_pt[i] - top_pt[i];
var v2 = bot_pt[prev] - top_pt[i];
var a = degrees(v2) - degrees(v1);
top_angle[i] = a<0 ? 360+a : a;
v1 = top_pt[i] - bot_pt[i];
v2 = top_pt[next] - bot_pt[i];
a = degrees(v2) - degrees(v1);
bot_angle[i] = a<0 ? 360+a : a;
}
for(int i: sequence(0,parts-1))
{
int next = i == parts-1 ? 0 : i+1;
var l1 = length(top_pt[i]--bot_pt[i]);
pair ctl1 = top_pt[i] + top_dir[i] * tens(true, top_angle[i]) * l1;
pair ctl2 = bot_pt[i] - bot_dir[i] * tens(false, bot_angle[i]) * l1;
w = w .. top_pt[i] .. controls ctl1 and ctl2 .. bot_pt[i];
var l2 = length(bot_pt[i]--top_pt[next]);
ctl1 = bot_pt[i] + bot_dir[i] * tens(false, bot_angle[i]) * l2;
ctl2 = top_pt[next] - top_dir[next] * tens(true, top_angle[next]) * l2;
w = w .. bot_pt[i] .. controls ctl1 and ctl2 .. top_pt[next];
}
return w;
}
void repeat(int count, path top, path bottom, int parts)
{
real step = 1/count;
for(int i: sequence(0, count-1))
{
draw(wave(top, bottom, parts, step*i));
}
}
path normalize(path p)
{
var min = min(p);
var max = max(p);
var top_center = min + ((max.x-min.x)/2, (max.y-min.y)/2);
return scale(20*1/(max-min).x)*shift(zero - top_center)*p;
}
path top = (338.499521684,-159.274266483)
..controls (327.252951684,-158.148796483) and (323.448961684,-145.618286483) .. (318.743661684,-137.260595483)
..controls (309.897671684,-123.808725483) and (292.025851684,-123.657732483) .. (278.251471684,-118.807470483)
..controls (272.669581684,-117.510629483) and (268.731931684,-109.221757483) .. (274.571781684,-105.645360483)
..controls (281.545351684,-101.031122483) and (290.488261684,-97.7906864833) .. (293.317871684,-89.0437964838)
..controls (296.611021684,-81.8498064838) and (293.894071684,-73.5853264838) .. (295.556161684,-66.3445764838)
..controls (299.563831684,-59.7686064838) and (308.181311684,-64.5344964838) .. (312.903811684,-67.4344264838)
..controls (325.368171684,-74.9872364838) and (341.157891684,-80.6126364838) .. (355.257331684,-73.9383264838)
..controls (363.506651684,-70.9246164838) and (370.115991684,-63.9703964838) .. (378.731941684,-62.0926264838)
..controls (384.688491684,-61.4010364838) and (389.980631684,-67.6129964838) .. (387.306161684,-73.3211464838)
..controls (385.256921684,-82.8346964838) and (388.441441684,-93.9447564833) .. (397.757331684,-98.3016064833)
..controls (403.144721684,-101.085582483) and (412.671611684,-104.606352483) .. (410.331551684,-112.414892483)
..controls (406.654931684,-119.718595483) and (396.921641684,-119.937732483) .. (390.144051684,-122.524267483)
..controls (378.065751684,-125.483516483) and (364.313841684,-130.717262483) .. (359.884541684,-143.562216483)
..controls (356.731021684,-151.157386483) and (350.818391684,-160.192046483) .. (341.435061684,-159.293796483)
..controls (340.456461684,-159.306096483) and (339.478031684,-159.281196483) .. (338.499521684,-159.274296483)
--cycle;
top = normalize(top);
bottom = scale(0.5)*top;
top = ellipse(zero, 4, 6);
bottom = ellipse(zero, 2, 3);
top = circle(zero, 5);
bottom = circle(zero, 3);
repeat(12, top, bottom, 8);
सबसे समझने वाला मामला तब है जब साइनसोइड्स दो सर्कल के बीच स्थित हैं।
मामला अधिक चालाक है - हलकों के बजाय दीर्घवृत्त।
और औद्योगिक उपयोग के करीब एक तस्वीर: गिलोच, एक प्रकार का कलात्मक आउटलेट।
यहाँ, हालांकि, परिणाम सही नहीं है। सबसे पहले, दसियों समारोह को समायोजित करना पड़ा ताकि यह हमेशा 0.5 के निरंतर "तनाव" को वापस कर दे। और दूसरी बात, घटता बहुत सममित नहीं है, और एक्स अक्ष के पास बाएं हिस्से में वे किसी तरह भ्रमित हैं। बेशक, यह सब हाथ से ठीक किया जा सकता है, खासकर यदि आप राज्य के लिए बैंकनोट बनाते हैं और बहुत योग्य कलाकार हैं, लेकिन आप गणना की सटीकता को बढ़ाने और बढ़ाने की कोशिश कर सकते हैं, क्योंकि वे स्पष्ट रूप से कुछ बिंदुओं पर भटक जाते हैं जहां लिफाफा वक्रता तेजी से बदलती है।चूंकि गिलोय प्रक्षेपित होते हैं, इसलिए सवाल उठता है: क्या वे मेल खाते हैं, इसलिए बोलने के लिए, "वास्तविक", अर्थात, बिंदुओं द्वारा खींचा गया है। विभेदक ज्यामिति के नए होने के कारण, मुझे यह कहना मुश्किल है, लेकिन "हाँ" के बजाय "नहीं"।लेकिन वास्तव में अंतर कौन देखता है?और व्यावहारिक लाभ निर्विवाद है - दर्जनों बेजियर घटता के एक जोड़े के साथ, काम एक हजार डॉट्स की तुलना में बहुत आसान है, और वे बहुत अधिक डिजाइन संभावनाओं को खोलते हैं।इसके अलावा, इस एल्गोरिथ्म में भी सुधार किया जा सकता है। दो विकल्प तुरंत खुद को सुझाव देते हैं:ए) बाहरी और आंतरिक वक्र पर विभिन्न बिंदुओं को निर्दिष्ट करते हैं, फिर केंद्र के करीब पैटर्न को पीसने का प्रभाव नहीं बनाया जाएगा, जैसे कि एक सर्कल और एक दीर्घवृत्त के साथ उदाहरणों में।बी) लिफाफे पर अंक समान रूप से न रखें, लेकिन, उदाहरण के लिए, उन्हें अधिक बार, कम बार, जो पैटर्न में एक नया आयाम जोड़ देगा।