🧕🏾 📛 🏨 एक षट्कोणीय रेखापुंज में सीधे 👨🏽‍🔧 🏇🏾 👃🏿

यह अध्ययन मूल होने का दिखावा नहीं करता है, मेरा मानना है कि मैं वास्तव में एक साइकिल का आविष्कार करता हूं, लेकिन मैं इसके दौरान (मैं मानता हूं, काफी सतही) इंटरनेट शोध से कोई विवरण नहीं मिला।

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

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

शुरुआत के लिए, यह एक समन्वय प्रणाली चुनने के लिए सुविधाजनक हो जाता है जो विशिष्ट रूप से रेखापुंज के प्रत्येक "पिक्सेल" की पहचान करता है। कई विकल्पों पर विचार करने के बाद, मैं सबसे सरल पर बस गया।

हेक्सागोन्स में से प्रत्येक में निर्देशांक - x और y शामिल हैं - जो सुविधा के लिए मैं "रेखापुंज" को उन बिंदुओं के निर्देशांक से अलग करने के लिए कहूंगा जिन्हें आसानी से "ज्यामितीय" कहा जाता है।

समस्या को हल करने की प्रक्रिया में, इसे दो मामलों में विभाजित किया गया था, जिनमें से अलग होने की स्थिति मुझे हल करने की प्रक्रिया में मिली थी। नीचे यह स्पष्ट हो जाएगा कि ऐसा क्यों होता है, लेकिन अभी के लिए मैं एक शर्त दूंगा। यदि हम (0, 0) और अंत के रूप में (x, y) खंड की शुरुआत के निर्देशांक लेते हैं, तो पहला मामला तब प्राप्त होता है जब स्थिति x ≥ [y / 2] और तदनुसार x <[y / 2], जहां वर्ग कोष्ठक होते हैं। पूरे भाग पर कब्जा करने का संकेत दें। ये स्थितियाँ मोज़ेक को दो असमान वर्गों में विभाजित करती हैं, जिनमें से सीमा इस प्रकार से गुजरती है:

पहला मामला: x case [y / 2]

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

और अस्थायी रूप से निर्देशांक भी बदल सकते हैं:

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

लाइन की लंबाई (निर्माण में शामिल हेक्सागोन्स की संख्या) x + [(y + 1) / 2] + 1 है। चौकोर कोष्ठक पूरे भाग को ले रहे हैं। ज्यामितीय रूप से, यह क्षैतिज बिंदुओं की संख्या है और संख्याओं को विषम रेखाओं से बदलकर (शीर्ष रेखा संख्या 0 है, इसलिए यह सम है)।

दूसरा मामला: x <[y / 2]

दूसरे मामले में, यह स्पष्ट है कि लाइन की लंबाई y + 1 से अधिक नहीं होनी चाहिए। शास्त्रीय ब्रेसेनहैम एल्गोरिथ्म के विपरीत, यह मामला पहले के सममित नहीं है, हालांकि प्रक्रिया समान है - ऊपर वर्णित विरूपण को निष्पादित करने और एक रेखा खींचने के लिए, लेकिन एक अन्य ओकटेट के नियमों के अनुसार, जहां मुख्य परिवर्तन होते हैं। वाई अक्ष के साथ होते हैं।

जावा कोड

public final class Line implements Iterable<Point> { private final Point begin; private final int dx; private final int dy; private final int sx; private final int sy; public Line(final Point begin, final Point end) { this.begin = begin; int dx = end.x - begin.x; int dy = end.y - begin.y; if (dx < 0) { dx = -dx; sx = -1; } else { sx = 1; } if (dy < 0) { dy = -dy; sy = -1; } else { sy = 1; } this.dx = dx + (dy + 1) / 2; this.dy = dy; } @Override public Iterator<Point> iterator() { return dx > dy ? new LineIterator1() : new LineIterator2(); } private final class LineIterator1 implements Iterator<Point> { private int x = 0; private int y = 0; private int error = 0; @Override public boolean hasNext() { return x <= dx; } @Override public Point next() { if (x > dx) return null; Point point = new Point(begin.x + (x - (y + 1) / 2) * sx, begin.y + y * sy); x++; if (x <= dx) { error += dy; if (2 * error >= dx) { y++; error -= dx; } } return point; } @Override public void remove() { throw new UnsupportedOperationException(); } } private final class LineIterator2 implements Iterator<Point> { private int x = 0; private int y = 0; private int error = 0; @Override public boolean hasNext() { return y <= dy; } @Override public Point next() { if (y > dy) return null; Point point = new Point(begin.x + (x - (y + 1) / 2) * sx, begin.y + y * sy); y++; if (y <= dy) { error = error + dx; if (2 * error >= dy) { error -= dy; x++; } } return point; } @Override public void remove() { throw new UnsupportedOperationException(); } } }

कक्षा बिंदु

 public final class Point { public final int x; public final int y; public Point(final int x, final int y) { this.x = x; this.y = y; } }

एक बार फिर, मैं स्वीकार करता हूं कि यह साइकिल का एक आविष्कार है, और मैं इस मामले में लिए गए समय के लिए माफी चाहता हूं।

एक षट्कोणीय रेखापुंज में सीधे

पहला मामला: x case [y / 2]

दूसरा मामला: x <[y / 2]

More articles: