एक और सप्ताहांत आ गया है, जिसका मतलब है कि मैं कोड की एक और दो दर्जन पंक्तियाँ लिख रहा हूं और एक या दो चित्रण कर रहा हूं। पिछले लेखों में मैंने बताया है कि रे ट्रेसिंग कैसे करें और सामान भी उड़ाएँ । यह आपको आश्चर्यचकित कर सकता है, लेकिन कंप्यूटर ग्राफिक्स काफी आसान है: यहां तक ​​कि नंगे सी ++ की कुछ सौ लाइनें कुछ बहुत ही रोमांचक कल्पना पैदा कर सकती हैं।

आज का विषय दूरबीन दृष्टि है, और हम इसे करने वाली 100 लाइनों के अवरोध को भी नहीं तोड़ेंगे। चूँकि हम 3 डी दृश्यों को आकर्षित कर सकते हैं, इसलिए स्टीरियो जोड़ियों को अनदेखा करना मूर्खतापूर्ण होगा, इसलिए आज हम कुछ ऐसा करेंगे:




मैजिक कार्पेट के रचनाकारों का सरासर पागलपन अभी भी मेरे दिमाग को उड़ा रहा है। उन अनजान लोगों के लिए, इस गेम ने आपको मुख्य सेटिंग्स मेनू से anaglyph और स्टीरियोग्राम मोड दोनों में एक 3D रेंडर करने की अनुमति दी! मेरे लिए वह जंगली था।

लंबन

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



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

आइए कल्पना करें कि हमारा मॉनिटर आभासी दुनिया के लिए एक खिड़की है :)



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

मान लेते हैं कि कोण नहीं बदलता है और यह (0,0, -1) वेक्टर है। चलो मान लेते हैं कि हम कैमरे को आंखों के बीच के क्षेत्र में स्थानांतरित कर सकते हैं, लेकिन फिर क्या? एक छोटा विवरण: हमारे "विंडो" के माध्यम से दृश्य को असममित है। लेकिन हमारे किरण अनुरेखक केवल एक सममित फ्रुम प्रस्तुत कर सकते हैं:



और अब हम क्या करें? धोखा :)

हम अपनी आवश्यकता से थोड़ी व्यापक छवियों को प्रस्तुत कर सकते हैं और फिर अतिरिक्त भागों को काट सकते हैं:

anaglyph

मुझे लगता है कि हमने बुनियादी प्रतिपादन तंत्र को कवर किया है, और अब हम छवि को हमारे मस्तिष्क तक पहुंचाने के मुद्दे से निपटते हैं। इस तरह का चश्मा सबसे सरल तरीका है:



हम दो ग्रेस्केल रेंडर बनाते हैं और क्रमशः लाल और नीले चैनलों को बाएं और दाएं चित्र प्रदान करते हैं। यह वही है जो हमें मिलता है:



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

Anaglyph रेंडरर्स (कंप्यूटर-जनरेटेड) स्टीरियो इमेज देखने का सबसे पुराना तरीका है। इसमें बहुत सारे डाउनसाइड हैं, उदाहरण के लिए, खराब रंग संचरण। लेकिन दूसरी तरफ, ये घर पर बनाना बहुत आसान है।

यदि आपके कंप्यूटर पर कंपाइलर नहीं है, तो यह कोई समस्या नहीं है। यदि आपके पास एक गाइथब खाता है, तो आप अपने ब्राउज़र में एक क्लिक में कोड (sic!) को देख, संपादित और चला सकते हैं।



जब आप इस लिंक को खोलते हैं, तो gitpod आपके लिए एक वर्चुअल मशीन बनाता है, VS कोड लॉन्च करता है, और रिमोट मशीन पर एक टर्मिनल खोलता है। कमांड इतिहास में (कंसोल पर क्लिक करें और अप की दबाएं) कमांड का एक पूरा सेट है जो आपको कोड संकलित करने, इसे लॉन्च करने और परिणामस्वरूप छवि खोलने की अनुमति देता है।

स्टिरियोस्कोप

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



वे AliExpress पर बहुत सारे हैं और $ 3 एक जोड़ी की तरह खर्च करते हैं। अनाग्लिफ़ रेंडरिंग की तुलना में हमारे पास करने के लिए बहुत अधिक नहीं है: बस दो चित्र लें और उन्हें एक तरफ रख दें। यहाँ कमिट है ।



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



यहाँ gitpod लिंक दिया गया है:

Autostereograms

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



यदि हम स्क्रीन पर ध्यान केंद्रित करते हैं, तो चार छवियां दो में संयोजित होती हैं। यदि हम आँखें पार करते हैं, या किसी दूर की वस्तु पर ध्यान केंद्रित करते हैं, तो मस्तिष्क को "तीन" चित्र खिलाना संभव है। केंद्रीय छवियां ओवरलैप करती हैं, जो स्टीरियो प्रभाव पैदा करती हैं।

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



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

एक अधूरा 3 डी प्रभाव पर रोक नहीं है। यदि आप अस्पष्ट रूप से गोल आकार देखते हैं, और 3 डी प्रभाव कमजोर है, तो भ्रम की अपूर्णता है। दर्शकों के लिए स्क्रीन के बाहर "कूद" करने के लिए क्षेत्रों को माना जाता है, प्रभाव स्थिर और टिकाऊ होना चाहिए। स्टीरियॉप्सिस में एक ग्रैस्टिसिस होता है: एक बार जब आप एक स्थिर छवि प्राप्त करते हैं, तो यह अधिक विस्तृत हो जाता है जितना लंबे समय तक आप इसका निरीक्षण करते हैं। आँखें स्क्रीन से जितनी दूर हैं, गहराई धारणा प्रभाव उतना ही बड़ा है।

इस लेख में 25 साल पहले सुझाई गई एक विधि का उपयोग करके यह स्टिरियोग्राम तैयार किया गया था: " 3 डी छवियां प्रदर्शित करना: एकल छवि रैंडम डॉट स्टेरियोग्राम के लिए एल्गोरिदम ।"

हमें शुरू करते हैं

ऑटोस्टेरोग्राम के प्रतिपादन के लिए शुरुआती बिंदु गहराई का नक्शा है (क्योंकि हम रंगों को छोड़ देते हैं)। यह कमेटी निम्नलिखित छवि बनाती है:



नज़दीकी और आगे के विमान हमारी गहराई तय करते हैं: मेरे नक्शे में सबसे दूर के बिंदु की गहराई 0 है, जबकि सबसे नज़दीकी में 1 की गहराई है।

मूल सिद्धांत

मान लीजिए कि हमारी आँखें स्क्रीन से दूरी पर हैं। हम अपने (काल्पनिक) दूर के विमान (z = 0) को स्क्रीन के पीछे एक ही दूरी पर रखते हैं। हम μ चर चुनते हैं, जो निकट विमान (z = 1) के स्थान को निर्धारित करता है, जो सुदूर विमान से μd दूरी पर होगा। मेरे कोड के लिए मैंने μ = μ चुना। कुल मिलाकर, हमारी पूरी "दुनिया" स्क्रीन के पीछे d-μd से d की दूरी पर रहती है। मान लें कि हम आँखों के बीच की दूरी जानते हैं (पिक्सेल में, मैंने 400 पिक्सेल चुने):



यदि हम लाल बिंदु को देखते हैं, तो हरे रंग में चिह्नित दो पिक्सेल को स्टिरोग्राम में एक ही रंग होना चाहिए। उनके बीच की दूरी की गणना कैसे करें? आसान। यदि वर्तमान अनुमानित डॉट में z की गहराई है, तो आंखों के बीच की दूरी से विभाजित लंबन इसी गहराई के बीच अंश को बराबर करता है: p / e = (d-dμz) / (2d-dμz)। वैसे, ध्यान दें कि डी बाहर सरलीकृत है और कहीं और दिखाई नहीं देता है! फिर p / e = (1-μz) / (2-μz), जिसका अर्थ लंबन p = e * (1-μz) / (2-μz) पिक्सल के बराबर होता है।

ऑटोस्टेरोग्राम के पीछे मुख्य विचार यह है: हम पूरे गहराई के नक्शे से गुजरते हैं, प्रत्येक गहराई मूल्य के लिए हम यह निर्धारित करते हैं कि कौन सा पिक्सेल एक ही रंग का होगा और इसे हमारी बाधाओं में डाल देगा। फिर हम यादृच्छिक छवि से शुरू करते हैं और उन सभी बाधाओं को संतुष्ट करने का प्रयास करते हैं जो हमने पहले निर्धारित किए हैं।

स्रोत छवि तैयार करना

यहां हम उस छवि को तैयार करते हैं जो बाद में लंबन बाधाओं से विवश होगी। यहाँ कमिट है , और यह इसे ड्रॉ करता है:



ध्यान दें कि रंग ज्यादातर यादृच्छिक होते हैं, लाल चैनल के अलावा जहां मैं एक आवधिक पैटर्न बनाने के लिए रैंड () * पाप करता हूं। धारियाँ 200 पिक्सेल के अलावा हैं, जो कि (μ = 1/3 और e = 400 दिया गया है) हमारी दुनिया में अधिकतम लंबन मान (दूर का विमान) है। पैटर्न तकनीकी रूप से आवश्यक नहीं है, लेकिन यह आंखों पर ध्यान केंद्रित करने में मदद करेगा।

ऑटोस्टेरोग्राम रेंडरिंग

दरअसल, ऑटोस्टेरोग्राम को खींचने वाला पूरा कोड कुछ इस तरह दिखता है:

int parallax(const float z) { const float eye_separation = 400.; // interpupillary distance in pixels const float mu = .33; // if the far plane is a distance D behind the screen, then the near plane is a distance mu*D in front of the far plane return static_cast<int>(eye_separation*((1.-z*mu)/(2.-z*mu))+.5); } size_t uf_find(std::vector<size_t> &same, size_t x) { return same[x]==x ? x : uf_find(same, same[x]); } void uf_union(std::vector<size_t> &same, size_t x, size_t y) { if ((x=uf_find(same, x)) != (y=uf_find(same, y))) same[x] = y; } int main() { [...] for (size_t j=0; j<height; j++) { // autostereogram rendering loop std::vector<size_t> same(width); std::iota(same.begin(), same.end(), 0); // initialize the union-find data structure (same[i]=i) for (size_t i=0; i<width; i++) { // put the constraints int par = parallax(zbuffer[i+j*width]); int left = i - par/2; int right = left + par; // works better than i+par/2 for odd values of par if (left>=0 && right<(int)width) uf_union(same, left, right); // left and right pixels will have the same color } for (size_t i=0; i<width; i++) { // resolve the constraints size_t root = uf_find(same, i); for (size_t c=0; c<3; c++) framebuffer[(i+j*width)*3+c] = framebuffer[(root+j*width)*3+c]; } } [...] 

यहाँ कमिट है , int parallax (const float z) फंक्शन हमें एक ही रंग के पिक्सल के बीच वर्तमान गहराई मान के लिए दूरी प्रदान करता है। हम स्ट्रीोग्राम लाइन को लाइन द्वारा प्रस्तुत करते हैं, क्योंकि लाइनें एक दूसरे से स्वतंत्र होती हैं (हमारे पास लंबवत लंबन नहीं है)। मुख्य लूप बस प्रत्येक पंक्ति के माध्यम से पुनरावृत्त होता है; हर बार यह पिक्सेल के असीमित सेट के साथ शुरू होता है, और फिर प्रत्येक पिक्सेल के लिए यह एक समानता की बाधा जोड़ता है। अंत में, यह हमें एक ही रंग के पिक्सल्स की एक निश्चित संख्या प्रदान करता है। उदाहरण के लिए, बाएँ और दाएँ अनुक्रमित वाले पिक्सेल समरूप होने चाहिए।

बाधाओं के इस सेट को कैसे स्टोर करें? सबसे सरल तरीका संघ-खोज डेटा संरचना है । मैं विस्तार में नहीं जाऊँगा, बस विकिपीडिया पर जाऊँगा, यह सचमुच कोड की तीन पंक्तियाँ हैं। मुख्य बिंदु यह है कि प्रत्येक क्लस्टर के लिए क्लस्टर के लिए एक निश्चित "रूट" पिक्सेल है। रूट पिक्सेल अपना प्रारंभिक रंग रखता है, और क्लस्टर के अन्य सभी पिक्सेल अपडेट किए जाने हैं:

  for (size_t i=0; i<width; i++) { // resolve the constraints size_t root = uf_find(same, i); for (size_t c=0; c<3; c++) framebuffer[(i+j*width)*3+c] = framebuffer[(root+j*width)*3+c]; } 

निष्कर्ष

वास्तव में यही है। आपके लिए अपनी आँखें तोड़ने के लिए कोड की बीस पंक्तियाँ और हमारा ऑटोस्टेरोग्राम तैयार है। वैसे, यदि हम पर्याप्त प्रयास करते हैं, तो रंग जानकारी प्रसारित करना संभव है।

मैंने ध्रुवीकृत 3 डी सिस्टम जैसे अन्य स्टीरियोस्कोपिक सिस्टम को कवर नहीं किया, क्योंकि वे बनाने के लिए बहुत अधिक महंगे हैं। अगर मुझे कुछ याद आया, तो मुझे ठीक करने के लिए स्वतंत्र महसूस करें