लक्सर

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

चेतावनी! साइकेडेलिक अंडों और चार-आयामी वस्तुओं का चित्रण करने वाले 8.5 एमबी के हल्के चित्रों और जीआईएफ के तहत, जिसके देखने से मन के हल्के बादल पैदा हो सकते हैं!

स्थापना

https://julialang.org - आधिकारिक साइट से जूलिया वितरण डाउनलोड करें। फिर, दुभाषिया को शुरू करते हुए, हम कमांड को उसके कंसोल में चलाते हैं:

using Pkg Pkg.add("Colors") Pkg.add("ColorSchemes") Pkg.add("Luxor") 

यह रंग और लक्सर के साथ उन्नत काम के लिए पैकेज स्थापित करेगा।

संभावित समस्याएं

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

इसलिए, ImageMagick.jl फ़ाइलों को डाउनलोड और सहेजना नहीं चाहता था। मूल पृष्ठ पर समाधान पाया गया - यह पता चला कि वह साइरिलिक वर्णमाला को पसंद नहीं करता है।
समस्या संख्या दो विंडोज 7 पर काहिरा निम्न-स्तरीय ग्राफिक्स पैकेज के साथ उठी। मैं यहां समाधान छिपाऊंगा:

अगर आप एनीमेशन आजमाना चाहते हैं

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

• डाउनलोड ffmpeg ऑफसाइट। मेरे मामले में, यह विंडोज़ के लिए एक डाउनलोड है
• पथ चर में ffmpeg.exe के लिए पथ को अनपैक करें और लिखें।

नमस्ते दुनिया

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

 using Luxor cd("C:\\Users\\User\\Desktop\\mycop") 

पहली ड्राइंग बनाएं

 Drawing(220, 220, "hw.png") origin() background("white") sethue("black") text("Hello world") circle(Point(0, 0), 100, :stroke) finish() preview() 

Drawing() पीएनजी प्रारूप में डिफ़ॉल्ट रूप से एक ड्राइंग बनाता है, डिफ़ॉल्ट फ़ाइल नाम 'लक्सर-ड्राइंग.पिंग' है, डिफ़ॉल्ट आकार 800x800 है, सभी प्रारूपों के लिए, केवल पीएनजी को छोड़कर आप गैर-पूर्णांक आकार निर्दिष्ट कर सकते हैं, और आप पेपर आकार भी कर सकते हैं ("ए 0) "," ए 1 "," ए 2 "," ए 3 "," ए 4 "...)
finish() - ड्राइंग को पूरा करता है और फाइल को बंद करता है। आप इसे preview() का उपयोग करके एक बाहरी देखने वाले एप्लिकेशन में खोल सकते हैं, जो कि ज्यूपिटर (IJulia) में काम करते समय नोटपैड में PNG या SVG फ़ाइल प्रदर्शित करेगा। जूनो में काम करते समय, यह ग्राफ़ पैनल में PNG या SVG फ़ाइल प्रदर्शित करेगा। प्रतिकृति में, आपके ओएस में इस प्रारूप के लिए सेट की गई छवियों के साथ काम करने का उपकरण कहा जाता है।
मैक्रोज़ का उपयोग करके इसे संक्षिप्त रूप में लिखा जा सकता है

 @png begin text("Hello world") circle(Point(0, 0), 100, :stroke) end 

वेक्टर फॉर्मेट के लिए EPS, SVG, PDF, सब कुछ उसी तरह से काम करता है।

यूक्लिडियन अंडा

यह एक अंडा खींचने का एक दिलचस्प तरीका है, और यदि आप मुख्य बिंदुओं को जोड़ते हैं और प्राप्त लाइनों के साथ काटते हैं, तो एक उत्कृष्ट टेंगरम बाहर आ जाएगा

चलो सर्कल से शुरू करते हैं:

 @png begin radius=80 setdash("dot") sethue("gray30") A, B = [Point(x, 0) for x in [-radius, radius]] line(A, B, :stroke) circle(O, radius, :stroke) end 200 200 "egg0" #     

सब कुछ बेहद सरल है: setdash("dot") - डॉट्स, sethue("gray30") साथ ड्रा करें - लाइन का रंग: छोटा, गहरा, 100 sethue("gray30") के करीब। बिंदु वर्ग हमारे बिना परिभाषित किया गया है, और निर्देशांक के केंद्र (0,0) को O अक्षर द्वारा निर्दिष्ट किया जा सकता है O दो मंडलियां जोड़ें और बिंदुओं पर हस्ताक्षर करें:

 @png begin radius=80 setdash("dot") sethue("gray30") A, B = [Point(x, 0) for x in [-radius, radius]] line(A, B, :stroke) circle(O, radius, :stroke) label("A", :NW, A) label("O", :N, O) label("B", :NE, B) circle.([A, O, B], 2, :fill) circle.([A, B], 2radius, :stroke) end 600 400 "egg2" 

चौराहे बिंदुओं की खोज करने के लिए, एक फ़ंक्शन है जिसे intersectionlinecircle() कहा जाता है जो बिंदु या बिंदुओं को ढूंढता है जहां रेखा सर्कल को काटती है। इस प्रकार, हम दो बिंदुओं का पता लगा सकते हैं जहां एक सर्कल O के माध्यम से खींची गई एक काल्पनिक ऊर्ध्वाधर रेखा को काटता है। समरूपता के कारण, हम केवल सर्कल A को संसाधित कर सकते हैं।

 @png begin radius=80 setdash("dot") sethue("gray30") A, B = [Point(x, 0) for x in [-radius, radius]] line(A, B, :stroke) circle(O, radius, :stroke) label("A", :NW, A) label("O", :N, O) label("B", :NE, B) circle.([A, O, B], 2, :fill) circle.([A, B], 2radius, :stroke) # >>>> nints, C, D = intersectionlinecircle(Point(0, -2radius), Point(0, 2radius), A, 2radius) if nints == 2 circle.([C, D], 2, :fill) label.(["D", "C"], :N, [D, C]) end end 600 400 "egg3" 

ऊपरी सर्कल के केंद्र को निर्धारित करने के लिए हम चौराहे को OD पाते हैं

 @png begin radius=80 setdash("dot") sethue("gray30") A, B = [Point(x, 0) for x in [-radius, radius]] line(A, B, :stroke) circle(O, radius, :stroke) label("A", :NW, A) label("O", :N, O) label("B", :NE, B) circle.([A, O, B], 2, :fill) circle.([A, B], 2radius, :stroke) # >>>> nints, C1, C2 = intersectionlinecircle(O, D, O, radius) if nints == 2 circle(C1, 3, :fill) label("C1", :N, C1) end end 600 400 "egg4" 

अधीनस्थ सर्कल की त्रिज्या दो बड़े सर्कल के प्रतिबंध द्वारा निर्धारित की जाती है:

 @png begin radius=80 setdash("dot") sethue("gray30") A, B = [Point(x, 0) for x in [-radius, radius]] line(A, B, :stroke) circle(O, radius, :stroke) label("A", :NW, A) label("O", :N, O) label("B", :NE, B) circle.([A, O, B], 2, :fill) circle.([A, B], 2radius, :stroke) # >>>> nints, C1, C2 = intersectionlinecircle(O, D, O, radius) if nints == 2 circle(C1, 3, :fill) label("C1", :N, C1) end # >>>> nints, I3, I4 = intersectionlinecircle(A, C1, A, 2radius) nints, I1, I2 = intersectionlinecircle(B, C1, B, 2radius) circle.([I1, I2, I3, I4], 2, :fill) # >>>> if distance(C1, I1) < distance(C1, I2) ip1 = I1 else ip1 = I2 end if distance(C1, I3) < distance(C1, I4) ip2 = I3 else ip2 = I4 end label("ip1", :N, ip1) label("ip2", :N, ip2) circle(C1, distance(C1, ip1), :stroke) end 600 400 "egg5" 

अंडा तैयार है! यह आर्क 2 arc2r() फ़ंक्शन द्वारा निर्दिष्ट चार आर्क से इसे इकट्ठा करने और क्षेत्र में भरने के लिए बनी हुई है:

 @png begin radius=80 setdash("dot") sethue("gray30") A, B = [Point(x, 0) for x in [-radius, radius]] line(A, B, :stroke) circle(O, radius, :stroke) label("A", :NW, A) label("O", :N, O) label("B", :NE, B) circle.([A, O, B], 2, :fill) circle.([A, B], 2radius, :stroke) # >>>> nints, C1, C2 = intersectionlinecircle(O, D, O, radius) if nints == 2 circle(C1, 3, :fill) label("C1", :N, C1) end # >>>> nints, I3, I4 = intersectionlinecircle(A, C1, A, 2radius) nints, I1, I2 = intersectionlinecircle(B, C1, B, 2radius) circle.([I1, I2, I3, I4], 2, :fill) # >>>> if distance(C1, I1) < distance(C1, I2) ip1 = I1 else ip1 = I2 end if distance(C1, I3) < distance(C1, I4) ip2 = I3 else ip2 = I4 end label("ip1", :N, ip1) label("ip2", :N, ip2) circle(C1, distance(C1, ip1), :stroke) # >>>> setline(5) setdash("solid") arc2r(B, A, ip1, :path) # centered at B, from A to ip1 arc2r(C1, ip1, ip2, :path) arc2r(A, ip2, B, :path) arc2r(O, B, A, :path) strokepreserve() setopacity(0.8) sethue("ivory") fillpath() end 600 400 "egg6" 

और अब, ठीक से लिप्त होने के लिए, हम अपनी उपलब्धियों को लाएंगे

 function egg(radius, action=:none) A, B = [Point(x, 0) for x in [-radius, radius]] nints, C, D = intersectionlinecircle(Point(0, -2radius), Point(0, 2radius), A, 2radius) flag, C1 = intersectionlinecircle(C, D, O, radius) nints, I3, I4 = intersectionlinecircle(A, C1, A, 2radius) nints, I1, I2 = intersectionlinecircle(B, C1, B, 2radius) if distance(C1, I1) < distance(C1, I2) ip1 = I1 else ip1 = I2 end if distance(C1, I3) < distance(C1, I4) ip2 = I3 else ip2 = I4 end newpath() arc2r(B, A, ip1, :path) arc2r(C1, ip1, ip2, :path) arc2r(A, ip2, B, :path) arc2r(O, B, A, :path) closepath() do_action(action) end 

हम यादृच्छिक रंगों, परत पेंटिंग और विभिन्न प्रारंभिक स्थितियों का उपयोग करते हैं:

 @png begin setopacity(0.7) for θ in range(0, step=π/6, length=12) @layer begin rotate(θ) translate(100, 50) # translate(0, -150) #rulers() egg(50, :path) setline(10) randomhue() fillpreserve() randomhue() strokepath() end end end 400 400 "eggs2" 

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

 @png begin egg(160, :path) pgon = first(pathtopoly()) pc = polycentroid(pgon) circle(pc, 5, :fill) for pt in 1:2:length(pgon) pgon[pt] = between(pc, pgon[pt], 0.5) end poly(pgon, :stroke) end 350 500 "polyegg" 

डिफ़ॉल्ट बिंदु कनेक्शन सेटिंग्स के परिणामस्वरूप यहां आंतरिक बिंदुओं की असमान उपस्थिति सामने आती है। यह देखने के लिए कि क्या यह ज्यामिति बदलता है, setlinejoin("round") साथ प्रयोग करें। ठीक है, अब चलो एक मौजूदा बहुभुज के बाहर या अंदर एक बहुभुज समोच्च बनाने की offsetpoly() ।

 @png begin egg(80, :path) pgon = first(pathtopoly()) pc = polycentroid(pgon) for pt in 1:2:length(pgon) pgon[pt] = between(pc, pgon[pt], 0.9) end for i in 30:-3:-8 randomhue() op = offsetpoly(pgon, i) poly(op, :stroke, close=true) end end 350 500 "polyeggs" 

एक बहुभुज के लिए मार्ग परिवर्तित करके बनाए गए बिंदुओं की नियमितता में छोटे परिवर्तन, और इसके द्वारा किए गए नमूनों की अलग-अलग संख्या लगातार क्रमिक रूप से बढ़ाई जाती है।

एनीमेशन

सबसे पहले, हम उन कार्यों को परिभाषित करते हैं जो फ्रेम संख्या के आधार पर, अंडे की पृष्ठभूमि और प्रतिपादन को लागू करते हैं:

 using Colors demo = Movie(400, 400, "test") function backdrop(scene, framenumber) background("black") end function frame(scene, framenumber) setopacity(0.7) θ = framenumber * π/6 @layer begin rotate(θ) translate(100, 50) egg(50, :path) setline(10) randomhue() fillpreserve() randomhue() strokepath() end end 

एनिमेशन को साधारण सेट द्वारा कार्यान्वित किया जाता है:

 animate(demo, [ Scene(demo, backdrop, 0:12), Scene(demo, frame, 0:12, easingfunction=easeinoutcubic, optarg="made with Julia") ], framerate=10, tempdirectory="C:\\Users\\User\\Desktop\\mycop", creategif=true) 

क्या वास्तव में हमारे ffmpeg का कारण बनता है

 run(`ffmpeg -f image2 -i $(tempdirectory)/%10d.png -vf palettegen -y $(seq.stitle)-palette.png`) run(`ffmpeg -framerate 30 -f image2 -i $(tempdirectory)/%10d.png -i $(seq.stitle)-palette.png -lavfi paletteuse -y /tmp/$(seq.stitle).gif`) 

अर्थात्, चित्रों की एक श्रृंखला बनाई जाती है, और फिर इन फ़्रेमों से एक जीआईएफ इकट्ठा किया जाता है:

Pentahor

वह एक पाँच कोर है - सही चार आयामी सिंप्लेक्स। दो-आयामी छवियों पर 4-आयामी वस्तुओं को खींचने और हेरफेर करने के लिए, हम पहले परिभाषित करते हैं

 struct Point4D <: AbstractArray{Float64, 1} x::Float64 y::Float64 z::Float64 w::Float64 end Point4D(a::Array{Float64, 1}) = Point4D(a...) Base.size(pt::Point4D) = (4, ) Base.getindex(pt::Point4D, i) = [pt.x, pt.y, pt.z, pt.w][i] struct Point3D <: AbstractArray{Float64, 1} x::Float64 y::Float64 z::Float64 end Base.size(pt::Point3D) = (3, ) 

मैन्युअल रूप से कई परिचालनों को परिभाषित करने के बजाय, हम अपनी संरचना को AbstractArray के उपप्रकार के रूप में परिभाषित कर सकते हैं ( इंटरफेस के रूप में कक्षाओं के बारे में अधिक )

मुख्य कार्य जिसे हमें हल करना चाहिए वह है कि 4 डी बिंदु को 2 डी बिंदु में कैसे परिवर्तित किया जाए। आइए एक सरल कार्य से शुरू करें: 3 डी बिंदु को 2 डी बिंदु में कैसे परिवर्तित करें, अर्थात्। हम समतल सतह पर 3D आकृति कैसे बना सकते हैं? एक साधारण घन पर विचार करें। आगे और पीछे की सतहों में समान X और Y निर्देशांक हो सकते हैं और केवल उनके Z मानों में भिन्न हो सकते हैं।

 @png begin fontface("Menlo") fontsize(8) setblend(blend( boxtopcenter(BoundingBox()), boxmiddlecenter(BoundingBox()), "skyblue", "white")) box(boxtopleft(BoundingBox()), boxmiddleright(BoundingBox()), :fill) setblend(blend( boxmiddlecenter(BoundingBox()), boxbottomcenter(BoundingBox()), "grey95", "grey45" )) box(boxmiddleleft(BoundingBox()), boxbottomright(BoundingBox()), :fill) sethue("black") setline(2) bx1 = box(O, 250, 250, vertices=true) poly(bx1, :stroke, close=true) label.(["-1 1 1", "-1 -1 1", "1 -1 1", "1 1 1"], slope.(O, bx1), bx1) setline(1) bx2 = box(O, 150, 150, vertices=true) poly(bx2, :stroke, close=true) label.(["-1 1 0", "-1 -1 0", "1 -1 0", "1 1 0"], slope.(O, bx2), bx2, offset=-45) map((x, y) -> line(x, y, :stroke), bx1, bx2) end 400 400 "cube.png" 

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

 const K = 4.0 function convert(Point, pt3::Point3D) k = 1/(K - pt3.z) return Point(pt3.x * k, pt3.y * k) end @png begin cube = Point3D[ Point3D(-1, -1, 1), Point3D(-1, 1, 1), Point3D( 1, -1, 1), Point3D( 1, 1, 1), Point3D(-1, -1, -1), Point3D(-1, 1, -1), Point3D( 1, -1, -1), Point3D( 1, 1, -1), ] circle.(convert.(Point, cube) * 300, 5, :fill) end 220 220 "points" 

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

 function convert(Point3D, pt4::Point4D) k = 1/(K - pt4.w) return Point3D(pt4.x * k, pt4.y * k, pt4.z * k) end function flatten(shape4) return map(pt3 -> convert(Point, pt3), map(pt4 -> convert(Point3D, pt4), shape4)) end 

अगला, कोने और चेहरे सेट करें और जांचें कि यह रंग में कैसे काम करता है

 const n = -1/√5 const pentachoron = [Point4D(vertex...) for vertex in [ [ 1.0, 1.0, 1.0, n], [ 1.0, -1.0, -1.0, n], [-1.0, 1.0, -1.0, n], [-1.0, -1.0, 1.0, n], [ 0.0, 0.0, 0.0, n + √5]]]; const pentachoronfaces = [ [1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 4], [1, 3, 5], [1, 4, 5], [2, 3, 4], [2, 3, 5], [2, 4, 5], [3, 4, 5]]; @png begin setopacity(0.2) pentachoron2D = flatten(pentachoron) for (n, face) in enumerate(pentachoronfaces) randomhue() poly(1500 * pentachoron2D[face], :fillpreserve, close=true) sethue("black") strokepath() end end 300 250 "5ceil" 

प्रत्येक स्वाभिमानी गेम डेवलपर को मशीन ग्राफिक्स के गणितीय मूल सिद्धांतों को जानना चाहिए। यदि आपने कभी भी ओपन करने की कोशिश नहीं की, घूमना, ओपनग्लास में चायदानी को प्रतिबिंबित करना - चिंता मत करो, सब कुछ काफी सरल है। एक बिंदु को एक सीधी रेखा तक अपेक्षाकृत प्रतिबिंबित करने के लिए, या एक निश्चित अक्ष के चारों ओर एक विमान को घुमाने के लिए, आपको एक विशेष मैट्रिक्स द्वारा निर्देशांक को गुणा करना होगा। वास्तव में आगे, हम परिवर्तन मेट्रिक्स का निर्धारण करेंगे जिनकी हमें आवश्यकता है:

 function XY(θ) [cos(θ) -sin(θ) 0 0; sin(θ) cos(θ) 0 0; 0 0 1 0; 0 0 0 1] end function XW(θ) [cos(θ) 0 0 -sin(θ); 0 1 0 0; 0 0 1 0; sin(θ) 0 0 cos(θ)] end function XZ(θ) [cos(θ) 0 -sin(θ) 0; 0 1 0 0; sin(θ) 0 cos(θ) 0; 0 0 0 1] end function YZ(θ) [1 0 0 0; 0 cos(θ) -sin(θ) 0; 0 sin(θ) cos(θ) 0; 0 0 0 1] end function YW(θ) [1 0 0 0; 0 cos(θ) 0 -sin(θ); 0 0 1 0; 0 sin(θ) 0 cos(θ)] end function ZW(θ) [1 0 0 0; 0 1 0 0; 0 0 cos(θ) -sin(θ); 0 0 sin(θ) cos(θ)]; end function rotate4(A, matrixfunction) return map(A) do pt4 Point4D(matrixfunction * pt4) end end 

आमतौर पर आप एक आयामी वस्तु के सापेक्ष एक समतल पर बिंदुओं को घुमाते हैं। 3 डी अंक एक 2 डी लाइन के आसपास हैं (अक्सर यह एक्सवाईजेड कुल्हाड़ियों में से एक है)। इस प्रकार, यह तर्कसंगत है कि 3 डी विमान के सापेक्ष 4D अंक घूमते हैं। हमने उन मैट्रिसेस की पहचान की है जो दो अक्षों X, Y, Z और W द्वारा परिभाषित विमान के बारे में चार-आयामी घुमाव का कार्य करते हैं। XY विमान आमतौर पर ड्राइंग सतह का विमान होता है। यदि आप XY प्लेन को कंप्यूटर स्क्रीन के रूप में देखते हैं, तो XZ प्लेन आपकी टेबल या फर्श के समानांतर है, और YZ प्लेन आपकी टेबल के बगल में दाईं या बाईं ओर की दीवार है। लेकिन XW, YW और ZW के बारे में क्या? यह चार-आयामी आंकड़ों का रहस्य है: हम इन विमानों को नहीं देख सकते हैं, हम केवल उनके अस्तित्व के बारे में देख कर कल्पना कर सकते हैं कि कैसे रूप उनके और उनके आसपास चलते हैं।

अब हम फ़्रेम के लिए फ़ंक्शन सेट करते हैं और एनीमेशन को सीवे करते हैं:

 using ColorSchemes function frame(scene, framenumber, scalefactor=1000) background("white") # antiquewhite setlinejoin("bevel") setline(1.0) sethue("black") eased_n = scene.easingfunction(framenumber, 0, 1, scene.framerange.stop) pentachoron′ = rotate4(pentachoron, XZ(eased_n * 2π)) pentachoron2D = flatten(pentachoron′) setopacity(0.2) for (n, face) in enumerate(pentachoronfaces) sethue(get(ColorSchemes.diverging_rainbow_bgymr_45_85_c67_n256, n/length(pentachoronfaces))) poly(scalefactor * pentachoron2D[face], :fillpreserve, close=true) sethue("black") strokepath() end end function makemovie(w, h, fname; scalefactor=1000) movie1 = Movie(w, h, "4D movie") animate(movie1, Scene(movie1, (s, f) -> frame(s, f, scalefactor), 1:300, easingfunction=easeinoutsine), #framerate=10, tempdirectory="C:\\Users\\User\\Desktop\\mycop", creategif=true, pathname="C:\\Users\\User\\Desktop\\mycop\\$(fname)") end makemovie(320, 320, "pentachoron-xz.gif", scalefactor=2000) 

खैर, और दूसरा कोण:

 function frame(scene, framenumber, scalefactor=1000) background("antiquewhite") setlinejoin("bevel") setline(1.0) setopacity(0.2) eased_n = scene.easingfunction(framenumber, 0, 1, scene.framerange.stop) pentachoron2D = flatten( rotate4( pentachoron, XZ(eased_n * 2π) * YW(eased_n * 2π))) for (n, face) in enumerate(pentachoronfaces) sethue(get(ColorSchemes.diverging_rainbow_bgymr_45_85_c67_n256, n/length(pentachoronfaces))) poly(scalefactor * pentachoron2D[face], :fillpreserve, close=true) sethue("black") strokepath() end end makemovie(500, 500, "pentachoron-xz-yw.gif", scalefactor=2000) 

एक अधिक लोकप्रिय चार-आयामी वस्तु, टेसरैक्ट को महसूस करने की इच्छा , पूरी तरह से प्राकृतिक है।

 const tesseract = [Point4D(vertex...) for vertex in [ [-1, -1, -1, 1], [ 1, -1, -1, 1], [ 1, 1, -1, 1], [-1, 1, -1, 1], [-1, -1, 1, 1], [ 1, -1, 1, 1], [ 1, 1, 1, 1], [-1, 1, 1, 1], [-1, -1, -1, -1], [ 1, -1, -1, -1], [ 1, 1, -1, -1], [-1, 1, -1, -1], [-1, -1, 1, -1], [ 1, -1, 1, -1], [ 1, 1, 1, -1], [-1, 1, 1, -1]]] const tesseractfaces = [ [1, 2, 3, 4], [1, 2, 10, 9], [1, 4, 8, 5], [1, 5, 6, 2], [1, 9, 12, 4], [2, 3, 11, 10], [2, 3, 7, 6], [3, 4, 8, 7], [5, 6, 14, 13], [5, 6, 7, 8], [5, 8, 16, 13], [6, 7, 15, 14], [7, 8, 16, 15], [9, 10, 11, 12], [9, 10, 14, 13], [9, 13, 16, 12], [10, 11, 15, 14], [13, 14, 15, 16]]; 

 function frame(scene, framenumber, scalefactor=1000) background("black") setlinejoin("bevel") setline(10.0) setopacity(0.7) eased_n = scene.easingfunction(framenumber, 0, 1, scene.framerange.stop) tesseract2D = flatten( rotate4( tesseract, XZ(eased_n * 2π) * YW(eased_n * 2π))) for (n, face) in enumerate(tesseractfaces) sethue([Luxor.lighter_blue, Luxor.lighter_green, Luxor.lighter_purple, Luxor.lighter_red][mod1(n, 4)]...) poly(scalefactor * tesseract2D[face], :fillpreserve, close=true) sethue([Luxor.darker_blue, Luxor.darker_green, Luxor.darker_purple, Luxor.darker_red][mod1(n, 4)]...) strokepath() end end makemovie(500, 500, "tesseract-xz-yw.gif", scalefactor=1000) 

होमवर्क: निर्देशांक और शीर्ष संख्या ( क्रमशः दोहराव के साथ और पुनरावृत्ति के बिना क्रमपरिवर्तन ) के सरणियों के निर्माण को स्वचालित करें। इसके अलावा, हमने सभी अनुवाद करने वाले मेट्रिक्स का उपयोग नहीं किया; प्रत्येक नया दृष्टिकोण एक नया "वाह!" लाता है, लेकिन मैंने पृष्ठ को अधिभार नहीं देने का फैसला किया। खैर, आप बहुत सारे चेहरे और आयामों के साथ प्रयोग कर सकते हैं।

संदर्भ

• लक्सर - जीथूब पेज
• लक्सर डॉक्स - उदाहरण के साथ एक गाइड
• काहिरा - एक निम्न-स्तरीय ग्राफिक्स लाइब्रेरी; एक पर्यावरण के रूप में लक्सर द्वारा उपयोग किया जाता है
• लेखक का पुस्तकालय का ब्लॉग - चार आयामी आंकड़ों सहित बहुत अधिक ठंडक और अधिक उन्नत उदाहरण हैं।