छवि को देखते हुए भूलभुलैया को दर्शाने और हल करने का सबसे अच्छा तरीका क्या है?
जेपीईजी छवि को देखते हुए (जैसा कि ऊपर देखा गया है), इसे पढ़ने का सबसे अच्छा तरीका क्या है, इसे कुछ डेटा संरचना में पार्स करें और भूलभुलैया को हल करें? मेरी पहली वृत्ति पिक्सेल द्वारा पिक्सेल में छवि को पढ़ने और बूलियन मूल्यों की एक सूची (सरणी) में संग्रहीत करने के Trueलिए है : एक सफेद पिक्सेल के लिए, और Falseएक गैर-सफेद पिक्सेल (रंगों को त्याग दिया जा सकता है) के लिए। इस पद्धति के साथ समस्या यह है कि छवि "पिक्सेल परफेक्ट" नहीं हो सकती है। उसके द्वारा मेरा सीधा मतलब है कि अगर एक दीवार पर कहीं एक सफेद पिक्सेल है तो यह एक अनपेक्षित मार्ग बना सकता है।
एक अन्य विधि (जो थोड़े विचार के बाद मेरे पास आई) छवि को एसवीजी फ़ाइल में बदलना है - जो कि एक कैनवास पर खींचे गए रास्तों की सूची है। इस तरह, रास्तों को एक ही तरह की सूची (बूलियन मान) में पढ़ा जा सकता है जहां Trueएक पथ या दीवार को इंगित करता है, Falseजो एक यात्रा-सक्षम स्थान को दर्शाता है। इस पद्धति के साथ एक समस्या उत्पन्न होती है यदि रूपांतरण 100% सटीक नहीं है, और अंतराल को बनाते हुए सभी दीवारों को पूरी तरह से जोड़ता नहीं है।
इसके अलावा एसवीजी में परिवर्तित करने के साथ एक मुद्दा यह है कि लाइनें "पूरी तरह से" सीधे नहीं हैं। इससे रास्ते में क्यूबिक बीज़ियर घटता है। पूर्णांक द्वारा अनुक्रमित बूलियन मूल्यों की एक सूची (सरणी) के साथ, वक्र आसानी से स्थानांतरित नहीं होंगे, और वक्र पर मौजूद सभी बिंदुओं की गणना की जाएगी, लेकिन सूचियों को सूचीबद्ध करने के लिए बिल्कुल मेल नहीं खाएगा।
मुझे लगता है कि जबकि इनमें से एक विधि काम कर सकती है (हालांकि शायद नहीं) कि वे इतनी बड़ी छवि को ध्यान में रखते हुए अक्षम हैं, और यह एक बेहतर तरीका है। यह सबसे अच्छा (सबसे कुशलता से और / या कम से कम जटिलता के साथ) कैसे किया जाता है? वहाँ भी एक सबसे अच्छा तरीका है?
फिर भूलभुलैया का हल आता है। यदि मैं पहले दो तरीकों में से किसी एक का उपयोग करता हूं, तो मैं अनिवार्य रूप से एक मैट्रिक्स के साथ समाप्त हो जाऊंगा। इस उत्तर के अनुसार , भूलभुलैया का प्रतिनिधित्व करने का एक अच्छा तरीका एक पेड़ का उपयोग करना है, और इसे हल करने का एक अच्छा तरीका ए * एल्गोरिथ्म का उपयोग करना है । छवि से एक पेड़ कैसे बनेगा? कोई विचार?
TL, डॉ।
पार्स करने का सबसे अच्छा तरीका? क्या डेटा संरचना में? कैसे कहा जाएगा ढांचा मदद / बाधा को हल करने में?
अद्यतन
मैंने numpy@Tikomas की सिफारिश के रूप में, पायथन में @Mikhail ने जो लिखा है, उसे लागू करने में अपना हाथ आजमाया है। मुझे लगता है कि एल्गोरिथ्म सही है, लेकिन यह आशा के अनुरूप काम नहीं कर रहा है। (नीचे कोड।) PNG लाइब्रेरी PyPNG है ।
import png, numpy, Queue, operator, itertools
def is_white(coord, image):
""" Returns whether (x, y) is approx. a white pixel."""
a = True
for i in xrange(3):
if not a: break
a = image[coord[1]][coord[0] * 3 + i] > 240
return a
def bfs(s, e, i, visited):
""" Perform a breadth-first search. """
frontier = Queue.Queue()
while s != e:
for d in [(-1, 0), (0, -1), (1, 0), (0, 1)]:
np = tuple(map(operator.add, s, d))
if is_white(np, i) and np not in visited:
frontier.put(np)
visited.append(s)
s = frontier.get()
return visited
def main():
r = png.Reader(filename = "thescope-134.png")
rows, cols, pixels, meta = r.asDirect()
assert meta['planes'] == 3 # ensure the file is RGB
image2d = numpy.vstack(itertools.imap(numpy.uint8, pixels))
start, end = (402, 985), (398, 27)
print bfs(start, end, image2d, [])visited.append(s)एक के तहत स्थानांतरित करना चाहिए for.ifऔर इसे प्रतिस्थापित करना चाहिए visited.append(np)। कतार में जुड़ने के बाद एक शीर्ष का दौरा किया जाता है। वास्तव में, इस सरणी को "कतारबद्ध" नाम दिया जाना चाहिए। एक बार समाप्त होने पर आप BFS को समाप्त भी कर सकते हैं।
