python - প্রতিনিধিত্ব এবং একটি মেজাজ একটি চিত্র দেওয়া সমাধান



algorithm matlab image-processing maze (9)

একটি চিত্র দেওয়া একটি মেজাজ প্রতিনিধিত্ব এবং সমাধান করার সেরা উপায় কি?

কোন JPEG চিত্র দেওয়া হয়েছে (উপরে দেখানো হয়েছে), এটিকে পড়তে সবচেয়ে ভাল উপায় কী, কোনও তথ্য কাঠামোর মধ্যে এটি বিশ্লেষণ করে এবং বিপথগামী সমাধান? আমার প্রথম প্রবৃত্তিটি পিক্সেলের মাধ্যমে ছবিটি পিক্সেলে পড়তে এবং বুলিয়ান মানগুলির একটি তালিকা (অ্যারে) এ সংরক্ষণ করতে হয়: একটি সাদা পিক্সেলের জন্য True এবং একটি অ-সাদা পিক্সেলের জন্য False (রংগুলিকে বাদ দেওয়া যেতে পারে)। এই পদ্ধতির সমস্যাটি হল, চিত্রটি "পিক্সেল নিখুঁত" হতে পারে না। এর দ্বারা আমি কেবল বলতে পারি যে যদি কোন প্রাচীরের উপর কোনও সাদা পিক্সেল থাকে তবে এটি একটি অচেনা পথ তৈরি করতে পারে।

আরেকটি পদ্ধতি (যা একটু চিন্তা করার পরে আমার কাছে এসেছিল) একটি ছবিটিকে একটি SVG ফাইলে রূপান্তর করা হয় - যা ক্যানভাসে টানা পাথগুলির একটি তালিকা। এইভাবে, পথগুলি একই ধরণের তালিকায় (বুলিয়ান মানগুলি) পড়তে পারে যেখানে True একটি পথ বা প্রাচীরকে নির্দেশ করে, False একটি ভ্রমণ-সক্ষম স্থান নির্দেশ করে। রূপান্তরটি 100% নির্ভুল না হলে এই পদ্ধতির সাথে একটি সমস্যা দেখা দেয় এবং ফাঁকগুলি তৈরি করে দেয়ালগুলির সম্পূর্ণভাবে সংযোগ করে না।

এছাড়াও এসভিজি রূপান্তর সঙ্গে একটি সমস্যা হল যে লাইন "পুরোপুরি" সোজা নয়। এই ফলাফল কিউবিক বেজায়ার curves হচ্ছে ফলাফল। পূর্ণসংখ্যা দ্বারা সূচিবদ্ধ বুলিয়ান মানগুলির একটি তালিকা (অ্যারে) দিয়ে, ঘনকগুলি সহজেই স্থানান্তরিত হবে না এবং বক্ররেখার যে সমস্ত পয়েন্টগুলি গণনা করা হবে সেগুলি গণনা করা হবে, তবে তালিকা সূচকগুলিতে একে মিলবে না।

আমি অনুমান করি যে এই পদ্ধতিগুলির মধ্যে একটি কাজ কাজ করতে পারে (যদিও সম্ভবত এটি নয়) যে তারা বড় ধরনের চিত্রের কারণে ক্ষতিকারকভাবে অকার্যকর এবং এটি একটি আরও ভাল উপায় রয়েছে। কিভাবে এই সেরা (সবচেয়ে দক্ষতা এবং / অথবা অন্তত জটিলতা সঙ্গে) সম্পন্ন করা হয়? এমনকি একটি ভাল উপায় আছে?

তারপর মেজাজ সমাধানের আসে। যদি আমি প্রথম দুটি পদ্ধতি ব্যবহার করি, তবে অবশ্যই আমি একটি ম্যাট্রিক্সের সাথে শেষ করব। এই উত্তর অনুসারে, একটি মাজা প্রতিনিধিত্ব করার একটি ভাল উপায় একটি গাছ ব্যবহার করা হচ্ছে, এবং এটি সমাধান করার একটি ভাল উপায় A * অ্যালগরিদম ব্যবহার করা হয়। কিভাবে ইমেজ থেকে একটি গাছ তৈরি হবে? কোন ধারনা?

টি এল; ডিআর
সেরা উপায় পার্স? কি তথ্য কাঠামো মধ্যে? কিভাবে কাঠামো সাহায্য সাহায্য / বাধা বাধা দেবে?

হালনাগাদ
@ numpy সুপারিশ হিসাবে, আমি numpy ব্যবহার করে numpy লিখেছেন পাইথন কী লিখছে তা বাস্তবায়ন করার জন্য আমার হাত চেষ্টা করেছি। আমি মনে করি যে অ্যালগরিদম সঠিক, কিন্তু এটি প্রত্যাশিত হিসাবে কাজ করে না। (নীচের কোড।) পিএনজি লাইব্রেরী 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, [])

Answers

একটি থ্রেশহোল্ড অবিরাম ভরাট জন্য একটি সারি ব্যবহার করে। সারির প্রবেশদ্বারের পিক্সেলটি সারিটিতে push করে এবং তারপর লুপ শুরু করে। যদি একটি সারিবদ্ধ পিক্সেল যথেষ্ট গাঢ় হয় তবে এটি রঙিন হালকা ধূসর (ঊর্ধ্বস্থানের উপরে) এবং সমস্ত প্রতিবেশীকে সারিতে সম্মুখভাগে ধাক্কা দেওয়া হয়।

from PIL import Image
img = Image.open("/tmp/in.jpg")
(w,h) = img.size
scan = [(394,23)]
while(len(scan) > 0):
    (i,j) = scan.pop()
    (r,g,b) = img.getpixel((i,j))
    if(r*g*b < 9000000):
        img.putpixel((i,j),(210,210,210))
        for x in [i-1,i,i+1]:
            for y in [j-1,j,j+1]:
                scan.append((x,y))
img.save("/tmp/out.png")

সমাধান ধূসর প্রাচীর এবং রঙ্গিন প্রাচীর মধ্যে করিডোর। এই মেজাজ একাধিক সমাধান আছে মনে রাখবেন। এছাড়াও, এই কাজ শুধুমাত্র প্রদর্শিত হবে।


গাছ অনুসন্ধান খুব বেশী। মাজা সমাধান পথ (গুলি) সহ স্বতঃস্ফূর্তভাবে বিচ্ছিন্ন।

(ধন্যবাদ rainman002 থেকে rainman002 আমাকে এই নির্দেশ করার জন্য।)

এই কারণে, আপনি দ্রুত ঢালাই প্রাচীর সংযুক্ত বিভাগ সনাক্ত করতে সংযুক্ত উপাদান ব্যবহার করতে পারেন। এটি দুইবার পিক্সেলের উপর পুনরাবৃত্তি করে।

যদি আপনি সমাধান পথের একটি সুন্দর চিত্রটিতে এটি চালু করতে চান, তবে আপনি প্রতিটি সংযুক্ত অঞ্চলের "মৃত শেষ" পথগুলি পূরণ করতে কাঠামোর উপাদানগুলির সাথে বাইনারি ক্রিয়াকলাপগুলি ব্যবহার করতে পারেন।

MATLAB জন্য ডেমো কোড অনুসরণ করে। এটি ভাল ফলাফলটি পরিষ্কার করতে tweaking ব্যবহার করতে পারে, এটি আরো সাধারণকরণ করতে, এবং এটি দ্রুত চালাতে। (কিছুক্ষণ যখন এটি ২:30 টা নয়।)

% read in and invert the image
im = 255 - imread('maze.jpg');

% sharpen it to address small fuzzy channels
% threshold to binary 15%
% run connected components
result = bwlabel(im2bw(imfilter(im,fspecial('unsharp')),0.15));

% purge small components (e.g. letters)
for i = 1:max(reshape(result,1,1002*800))
    [count,~] = size(find(result==i));
    if count < 500
        result(result==i) = 0;
    end
end

% close dead-end channels
closed = zeros(1002,800);
for i = 1:max(reshape(result,1,1002*800))
    k = zeros(1002,800);
    k(result==i) = 1; k = imclose(k,strel('square',8));
    closed(k==1) = i;
end

% do output
out = 255 - im;
for x = 1:1002
    for y = 1:800
        if closed(x,y) == 0
            out(x,y,:) = 0;
        end
    end
end
imshow(out);


আমি matrix-of-bools বিকল্পের জন্য যেতে চাই। আপনি যদি স্ট্যান্ডার্ড পাইথন তালিকাগুলি এই জন্য খুব অকার্যকর খুঁজে পান তবে আপনি পরিবর্তে একটি numpy.bool অ্যারে ব্যবহার করতে পারেন। একটি 1000x1000 পিক্সেল মাজা জন্য সংগ্রহস্থল তারপর মাত্র 1 এমবি।

কোন গাছ বা গ্রাফ তথ্য কাঠামো তৈরি সঙ্গে বিরক্ত করবেন না। এটি কেবল এটি সম্পর্কে চিন্তা করার একটি উপায়, তবে মেমরিতে এটি প্রতিনিধিত্ব করার জন্য একটি দুর্দান্ত উপায় নয়; একটি বুলিয়ান ম্যাট্রিক্স কোড এবং আরও দক্ষ উভয় সহজ।

তারপর এটি সমাধান করতে * অ্যালগোরিদম ব্যবহার করুন। দূরত্ব নিরাময়ের জন্য, ম্যানহাটান দূরত্ব ( distance_x + distance_y দূরত্ব_y) ব্যবহার করুন।

একটি (row, column) সমন্বয় দ্বারা নোড প্রতিনিধিত্ব। যখনই অ্যালগরিদম ( উইকিপিডিয়া ছদ্দোকোড ) "প্রতিবেশীদের" জন্য আহ্বান করে, চারটি সম্ভাব্য প্রতিবেশী (ছবির প্রান্তগুলি মনে রাখুন) এর উপর লুপ করার একটি সহজ বিষয়।

যদি আপনি এটি এখনও খুব ধীরে ধীরে খুঁজে পান তবে আপনি এটি লোড করার আগে চিত্রটিকে ডাউনসক্লিক করার চেষ্টা করতে পারেন। প্রক্রিয়া কোন সংকীর্ণ পথ হারান না সতর্ক থাকুন।

সম্ভবত এটি পাইথনতে 1: 2 ডাউনসক্লিং করা সম্ভব, এটি যাচাই করে যে আপনি আসলে কোনও সম্ভাব্য পথ হারাবেন না। একটি আকর্ষণীয় বিকল্প, কিন্তু এটি একটি বিট আরো চিন্তা প্রয়োজন।


এখানে R ব্যবহার করে একটি সমাধান।

### download the image, read it into R, converting to something we can play with...
library(jpeg)
url <- "https://i.stack.imgur.com/TqKCM.jpg"
download.file(url, "./maze.jpg", mode = "wb")
jpg <- readJPEG("./maze.jpg")

### reshape array into data.frame
library(reshape2)
img3 <- melt(jpg, varnames = c("y","x","rgb"))
img3$rgb <- as.character(factor(img3$rgb, levels = c(1,2,3), labels=c("r","g","b")))

## split out rgb values into separate columns
img3 <- dcast(img3, x + y ~ rgb)

RGB থেকে গ্রেস্কেল, দেখুন: https://.com/a/27491947/2371031

# convert rgb to greyscale (0, 1)
img3$v <- img3$r*.21 + img3$g*.72 + img3$b*.07
# v: values closer to 1 are white, closer to 0 are black

## strategically fill in some border pixels so the solver doesn't "go around":
img3$v2 <- img3$v
img3[(img3$x == 300 | img3$x == 500) & (img3$y %in% c(0:23,988:1002)),"v2"]  = 0

# define some start/end point coordinates
pts_df <- data.frame(x = c(398, 399),
                     y = c(985, 26))

# set a reference value as the mean of the start and end point greyscale "v"s
ref_val <- mean(c(subset(img3, x==pts_df[1,1] & y==pts_df[1,2])$v,
                  subset(img3, x==pts_df[2,1] & y==pts_df[2,2])$v))

library(sp)
library(gdistance)
spdf3 <- SpatialPixelsDataFrame(points = img3[c("x","y")], data = img3["v2"])
r3 <- rasterFromXYZ(spdf3)

# transition layer defines a "conductance" function between any two points, and the number of connections (4 = Manhatten distances)
# x in the function represents the greyscale values ("v2") of two adjacent points (pixels), i.e., = (x1$v2, x2$v2)
# make function(x) encourages transitions between cells with small changes in greyscale compared to the reference values, such that: 
# when v2 is closer to 0 (black) = poor conductance
# when v2 is closer to 1 (white) = good conductance
tl3 <- transition(r3, function(x) (1/max( abs( (x/ref_val)-1 ) )^2)-1, 4) 

## get the shortest path between start, end points
sPath3 <- shortestPath(tl3, as.numeric(pts_df[1,]), as.numeric(pts_df[2,]), output = "SpatialLines")

## fortify for ggplot
sldf3 <- fortify(SpatialLinesDataFrame(sPath3, data = data.frame(ID = 1)))

# plot the image greyscale with start/end points (red) and shortest path (green)
ggplot(img3) +
  geom_raster(aes(x, y, fill=v2)) +
  scale_fill_continuous(high="white", low="black") +
  scale_y_reverse() +
  geom_point(data=pts_df, aes(x, y), color="red") +
  geom_path(data=sldf3, aes(x=long, y=lat), color="green")

ভাল খবর!

যদি আপনি কিছু সীমানা পিক্সেল পূরণ করবেন না (হায়!) ...

সম্পূর্ণ প্রকাশ: আমি এই একটি পাওয়া আগে আমি জিজ্ঞাসা এবং একটি খুব অনুরূপ প্রশ্ন উত্তর। তারপর এসও এর জাদু মাধ্যমে, এটি শীর্ষ "সম্পর্কিত প্রশ্ন" এক হিসাবে পাওয়া যায়। আমি ভেবেছিলাম আমি এই পরীক্ষার অতিরিক্ত পরীক্ষার ক্ষেত্রে ব্যবহার করবো ... আমি খুব খুশি হলাম যে আমার উত্তরটি খুব কম সংশোধন সহ এই অ্যাপ্লিকেশনের জন্যও কাজ করে।


এখানে একটি সমাধান।

  1. চিত্রটিকে গ্রেস্কেল (এখনো বাইনারি নয়) রূপান্তর করুন, রংগুলির জন্য ওজন সমন্বয় করুন যাতে চূড়ান্ত গ্রেস্কেল চিত্রটি প্রায় অভিন্ন। ফটোশপে ছবির স্লাইডারগুলি নিয়ন্ত্রণ করে আপনি এটি সহজেই করতে পারেন -> বিন্যাস -> কালো ও সাদা।
  2. ছবির ফটোশপের যথাযথ থ্রেশহোল্ড সেট করে ছবিটি বাইনারিতে রূপান্তর করুন -> বিন্যাস -> থ্রেশহোল্ড।
  3. নিশ্চিত থ্রেশহোল্ড ডান নির্বাচন করা হয়। 0 সহনশীলতা, বিন্দু নমুনা, সংস্পর্শী, কোনও বিরোধী-অ্যালাইজিং সহ যাদু ভাঁজ সরঞ্জামটি ব্যবহার করুন। যে প্রান্তগুলি নির্বাচন বিরতিগুলি ভুল থ্রেশহোল্ড দ্বারা মিথ্যা মিথ্যা প্রান্ত নয় তা পরীক্ষা করে দেখুন। আসলে, এই মেজাজ সব অভ্যন্তর পয়েন্ট শুরু থেকে প্রবেশযোগ্য।
  4. ভার্চুয়াল পর্যটক এটি প্রায় পায়চারি করা হবে না তা নিশ্চিত করার জন্য মেজাজ কৃত্রিম সীমানা যোগ করুন :)
  5. আপনার পছন্দের ভাষাতে প্রস্থের প্রথম অনুসন্ধান (BFS) প্রয়োগ করুন এবং এটি শুরু থেকে চালান। আমি এই কাজের জন্য MATLAB পছন্দ। যেমন @ থোমাস ইতিমধ্যে উল্লেখ করেছেন, গ্রাফগুলির নিয়মিত প্রতিনিধিত্বের সাথে জড়িয়ে পড়ার দরকার নেই। আপনি সরাসরি binarized ইমেজ সঙ্গে কাজ করতে পারেন।

এখানে BFS এর জন্য MATLAB কোড রয়েছে:

function path = solve_maze(img_file)
  %% Init data
  img = imread(img_file);
  img = rgb2gray(img);
  maze = img > 0;
  start = [985 398];
  finish = [26 399];

  %% Init BFS
  n = numel(maze);
  Q = zeros(n, 2);
  M = zeros([size(maze) 2]);
  front = 0;
  back = 1;

  function push(p, d)
    q = p + d;
    if maze(q(1), q(2)) && M(q(1), q(2), 1) == 0
      front = front + 1;
      Q(front, :) = q;
      M(q(1), q(2), :) = reshape(p, [1 1 2]);
    end
  end

  push(start, [0 0]);

  d = [0 1; 0 -1; 1 0; -1 0];

  %% Run BFS
  while back <= front
    p = Q(back, :);
    back = back + 1;
    for i = 1:4
      push(p, d(i, :));
    end
  end

  %% Extracting path
  path = finish;
  while true
    q = path(end, :);
    p = reshape(M(q(1), q(2), :), 1, 2);
    path(end + 1, :) = p;
    if isequal(p, start) 
      break;
    end
  end
end

এটি সত্যিই খুব সহজ এবং মানদণ্ড, Python বা যাই হোক না কেন এটি প্রয়োগ করতে অসুবিধা হওয়া উচিত নয়।

এবং এখানে উত্তর হল:


এই সমাধান পাইথন মধ্যে লেখা হয়। ইমেজ প্রস্তুতির পয়েন্টার জন্য ধন্যবাদ মিখাইল।

একটি অ্যানিমেটেড ব্রেস্ট-প্রথম অনুসন্ধান:

সম্পূর্ণ মেজাজ:

#!/usr/bin/env python

import sys

from Queue import Queue
from PIL import Image

start = (400,984)
end = (398,25)

def iswhite(value):
    if value == (255,255,255):
        return True

def getadjacent(n):
    x,y = n
    return [(x-1,y),(x,y-1),(x+1,y),(x,y+1)]

def BFS(start, end, pixels):

    queue = Queue()
    queue.put([start]) # Wrapping the start tuple in a list

    while not queue.empty():

        path = queue.get() 
        pixel = path[-1]

        if pixel == end:
            return path

        for adjacent in getadjacent(pixel):
            x,y = adjacent
            if iswhite(pixels[x,y]):
                pixels[x,y] = (127,127,127) # see note
                new_path = list(path)
                new_path.append(adjacent)
                queue.put(new_path)

    print "Queue has been exhausted. No answer was found."


if __name__ == '__main__':

    # invoke: python mazesolver.py <mazefile> <outputfile>[.jpg|.png|etc.]
    base_img = Image.open(sys.argv[1])
    base_pixels = base_img.load()

    path = BFS(start, end, base_pixels)

    path_img = Image.open(sys.argv[1])
    path_pixels = path_img.load()

    for position in path:
        x,y = position
        path_pixels[x,y] = (255,0,0) # red

    path_img.save(sys.argv[2])

নোট: একটি সাদা পরিদর্শন পিক্সেল ধূসর চিহ্নিত। এটি একটি পরিদর্শিত তালিকাটির প্রয়োজনীয়তা সরিয়ে দেয়, তবে এটি একটি পথ আঁকা হওয়ার আগে ডিস্ক থেকে চিত্র ফাইলের দ্বিতীয় লোডের প্রয়োজন হয় (যদি আপনি চূড়ান্ত পথের একটি যৌগিক চিত্র এবং সমস্ত পথ নেওয়া না চান)।

আমি ব্যবহৃত মেজাজ একটি ফাঁকা সংস্করণ।


আমি নিজেকে এই সমস্যার জন্য এ-স্টার অনুসন্ধান বাস্তবায়ন করার চেষ্টা করেছি। ফ্রেফওয়ার্ক এবং here প্রদত্ত অ্যালগরিদম ছদ্দিকোডের জন্য জোসেফ কার্নের দ্বারা ঘনিষ্ঠভাবে বাস্তবায়ন অনুসরণ করা here :

def AStar(start, goal, neighbor_nodes, distance, cost_estimate):
    def reconstruct_path(came_from, current_node):
        path = []
        while current_node is not None:
            path.append(current_node)
            current_node = came_from[current_node]
        return list(reversed(path))

    g_score = {start: 0}
    f_score = {start: g_score[start] + cost_estimate(start, goal)}
    openset = {start}
    closedset = set()
    came_from = {start: None}

    while openset:
        current = min(openset, key=lambda x: f_score[x])
        if current == goal:
            return reconstruct_path(came_from, goal)
        openset.remove(current)
        closedset.add(current)
        for neighbor in neighbor_nodes(current):
            if neighbor in closedset:
                continue
            if neighbor not in openset:
                openset.add(neighbor)
            tentative_g_score = g_score[current] + distance(current, neighbor)
            if tentative_g_score >= g_score.get(neighbor, float('inf')):
                continue
            came_from[neighbor] = current
            g_score[neighbor] = tentative_g_score
            f_score[neighbor] = tentative_g_score + cost_estimate(neighbor, goal)
    return []

এ-স্টার একটি হিউরিস্টিক অনুসন্ধান অ্যালগরিদম হিসাবে আপনাকে লক্ষ্যটি পৌঁছে না হওয়া পর্যন্ত অবশিষ্ট খরচ (এখানে: দূরত্ব) অনুমান করে এমন একটি ফাংশনের সাথে আসতে হবে। আপনি একটি suboptimal সমাধান সঙ্গে আরামদায়ক না হওয়া পর্যন্ত এটি খরচ অতিমাত্রায় করা উচিত নয়। একটি রক্ষণশীল পছন্দ এখানে ম্যানহাটান (বা ট্যাক্সিক্যাব) দূরত্ব হতে পারে কারণ এটি ব্যবহৃত ভন নিউম্যান আশেপাশের গ্রিডের দুটি পয়েন্টের মধ্যে সরল-লাইনের দূরত্বকে প্রতিনিধিত্ব করে। (যা, এই ক্ষেত্রে, কখনও খরচ অতিমাত্রায় না।)

এই তবে উল্লেখযোগ্যভাবে হাত দেওয়া প্রদীপ জন্য প্রকৃত খরচ কম মূল্যায়ন করবে। তাই আমি দুই অন্যান্য দূরত্ব মেট্রিক squared euclidean দূরত্ব যোগ করেছেন এবং ম্যানহাটানের দূরত্ব তুলনায় চার দ্বারা গুণিত। এইগুলি প্রকৃত খরচের অতিরিক্ত মূল্যায়ন করতে পারে এবং এর ফলে উপপাদ্যের ফলাফলগুলি উপনীত হতে পারে।

এখানে কোডটি রয়েছে:

import sys
from PIL import Image

def is_blocked(p):
    x,y = p
    pixel = path_pixels[x,y]
    if any(c < 225 for c in pixel):
        return True
def von_neumann_neighbors(p):
    x, y = p
    neighbors = [(x-1, y), (x, y-1), (x+1, y), (x, y+1)]
    return [p for p in neighbors if not is_blocked(p)]
def manhattan(p1, p2):
    return abs(p1[0]-p2[0]) + abs(p1[1]-p2[1])
def squared_euclidean(p1, p2):
    return (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2

start = (400, 984)
goal = (398, 25)

# invoke: python mazesolver.py <mazefile> <outputfile>[.jpg|.png|etc.]

path_img = Image.open(sys.argv[1])
path_pixels = path_img.load()

distance = manhattan
heuristic = manhattan

path = AStar(start, goal, von_neumann_neighbors, distance, heuristic)

for position in path:
    x,y = position
    path_pixels[x,y] = (255,0,0) # red

path_img.save(sys.argv[2])

এখানে ফলাফলগুলির কল্পনার জন্য কিছু ছবি রয়েছে ( জোসেফ কার্ন পোস্ট করেছেন এমন অনুপ্রেরণা)। মুখ্য সময়-লুপের 10000 পুনরাবৃত্তির পরে অ্যানিমেশনগুলি প্রতিটি নতুন ফ্রেম দেখায়।

রুচি প্রথম অনুসন্ধান:

এ-স্টার ম্যানহাটান দূরত্ব:

এ-স্টার স্কয়ার্ড ইউক্লিডান দূরত্ব:

এ-স্টার ম্যানহাটান দূরত্ব চার দ্বারা গুণিত:

ফলাফল দেখায় যে মস্তিষ্কের অন্বেষণকৃত অঞ্চলে হিউরিস্টিক্স ব্যবহার করা যায়। যেমন, স্কয়ারেড ইউক্লিডান দূরত্ব এমনকি অন্যান্য মেট্রিকগুলির মতো একটি ভিন্ন (উপপাদ্য) পথ তৈরি করে।

রান-টাইম সমাপ্তি না হওয়া পর্যন্ত এ-স্টার অ্যালগরিদমটির কার্য সম্পাদনের বিষয়ে, দ্রষ্টব্য করুন যে দূরত্ব এবং খরচ ফাংশনের অনেক মূল্যায়ন ব্রেড্থ-ফার্স্ট সার্চ (বিএফএস) এর তুলনায় যোগ করা যা শুধুমাত্র "লক্ষ্যবস্তু" মূল্যায়ন করতে হবে প্রতিটি প্রার্থী অবস্থান। এই অতিরিক্ত ফাংশন মূল্যায়ন (এ-স্টার) এর জন্য খরচগুলি বড় সংখ্যক নোডগুলি পরীক্ষা করতে (বিএফএস) খরচ ছাড়াই ব্যয় করে না এবং বিশেষত আপনার অ্যাপ্লিকেশনের জন্য কার্য সম্পাদন একটি সমস্যা কিনা তা নয়, ব্যক্তিগত ধারণার ব্যাপার এবং অবশ্যই উত্তর দেওয়া যাবে না।

একটি সম্পূর্ণ অনুসন্ধান (উদাহরণস্বরূপ, বিএফএস) এর তুলনায় কোনও অবহিত অনুসন্ধান অ্যালগরিদম (যেমন A-Star) কিনা বা না সে সম্পর্কে সাধারণভাবে বলা যেতে পারে এমন একটি জিনিস নিম্নলিখিত। বিভ্রান্তিকর পরিমাপের সংখ্যা, অর্থাৎ, অনুসন্ধান গাছের শাখা ফ্যাক্টর, একটি সম্পূর্ণ অনুসন্ধানের অসুবিধা (সম্পূর্ণ অনুসন্ধানের জন্য) দ্রুতগতিতে বৃদ্ধি পায়। ক্রমবর্ধমান জটিলতার সাথে এটি করার জন্য কম এবং কম সম্ভাব্য হয়ে যায় এবং কিছু সময়ে আপনি কোন ফলাফল পথের সাথে বেশ খুশি হন, এটি (আনুমানিক) অনুকূল বা না।


এখানে আপনি যান: maze-solver-python (গিথ হাব)

আমি এই সঙ্গে প্রায় বাজানো এবং জোসেফ কার্ন এর উত্তর প্রসারিত মজা ছিল। এটা থেকে বিচ্ছিন্ন না; আমি শুধু এই সঙ্গে প্রায় বাজানো আগ্রহী হতে পারে অন্য কেউ জন্য কিছু ক্ষুদ্র সংযোজন করা।

এটি একটি পাইথন-ভিত্তিক দ্রাবক যা সংক্ষিপ্ততম পথ খুঁজে পেতে BFS ব্যবহার করে। আমার প্রধান সংযোজন, সময়ে, হয়:

  1. ছবি অনুসন্ধানের আগে পরিষ্কার করা হয় (অর্থাত্ বিশুদ্ধ কালো ও সাদা রূপান্তর)
  2. স্বয়ংক্রিয়ভাবে একটি GIF জেনারেট করুন।
  3. স্বয়ংক্রিয়ভাবে একটি AVI জেনারেট করুন।

এটি যেমন দাঁড়িয়ে আছে, সূচনা / শেষ-পয়েন্টগুলি এই নমুনা মাজারের জন্য হার্ড-কোডেড, তবে আমি যথাযথ পিক্সেলগুলি চয়ন করতে পারার মতো এটি প্রসারিত করার পরিকল্পনা করছি।


যেহেতু সমস্যাটি উল্লেখ করে না যে আমাদেরকে ক্ষুদ্রতম সম্ভাব্য নম্বরটি ফাইলে নেই যা আমরা কেবল একটি ইনপুট ফাইলের চেয়ে বেশি সংখ্যায় তৈরি করতে পারি। :)





python algorithm matlab image-processing maze