Add application file

A_Star.py

@@ -0,0 +1,39 @@
+from heapq import *
+
+# A* algoritmasında kullanılacak olan heuristik fonksiyon
+def heuristic(a, b):
+    return abs(a[0] - b[0]) + abs(a[1] - b[1])  # A ile B arasındaki Manhattan mesafesi
+
+# Yolu geri döndürmek için kullanılan fonksiyon
+def reconstruct_path(came_from, current):
+    total_path = [current]
+    while current in came_from and came_from[current] is not None:
+        current = came_from[current]
+        total_path.append(current)  # Yolun parçalarını sırayla ekle
+    return total_path[::-1]  # Yolu ters çevir, böylece başlangıç -> hedef sırası olur
+
+def a_star(graph, start, goal):
+    queue = []
+    heappush(queue, (0, start))  # Başlangıç düğümünü maliyet 0 ile kuyruğa ekle
+    g_score = {start: 0}  # Başlangıç düğümünün maliyeti 0
+    came_from = {start: None}  # Her düğümün nereden geldiğini takip etmek için
+
+    while queue:
+        _, current = heappop(queue)  # En düşük maliyetli düğümü al
+
+        if current == goal:
+            return reconstruct_path(came_from, goal)  # Hedefe ulaşıldıysa yolu geri döndür
+
+        # Mevcut düğümün komşularını dolaş
+        for neighbor_cost, neighbor in graph[current]:
+            tentative_g_score = g_score[current] + neighbor_cost  # Komşuya ulaşmanın maliyetini hesapla
+
+            # Daha düşük maliyet bulunursa güncelle
+            if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
+                g_score[neighbor] = tentative_g_score  # En iyi g_score güncelle
+                f_score = tentative_g_score + heuristic(neighbor, goal)  # Toplam maliyeti hesapla (g + h)
+                heappush(queue, (f_score, neighbor))  # Komşuyu öncelik sırasına ekle
+                came_from[neighbor] = current  # Bu komşuya, mevcut düğümden gelindi
+
+    return None  # Eğer hedefe ulaşılamazsa None döndür
+

Bellman_Ford.py

@@ -0,0 +1,44 @@
+# kaynak: https://www.youtube.com/watch?v=24HziTZ8_xo
+
+def bellman_ford(graph,başlangıç,hedef):
+   # Mesafeleri sonsuz olarak başlat
+   mesafeler = {node: float('infinity') for node in graph}
+   önceki = {node: None for node in graph}  # Her düğümün öncesini kaydet
+
+   # Başlangıç düğümünün mesafesini sıfır olarak ayarla
+   mesafeler[başlangıç] = 0
+
+   # Döngü graftaki düğümlerin sayısının 1 eksiği kadar devam etmeli.
+   for _ in range(len(graph) - 1):  # Düğüm sayısı - 1 kadar tekrar et
+       for i in graph:  # Her düğüm üzerinde dolaş
+           for j in graph[i]:  # Düğümün komşularına bak
+               hedef_dugum = j[1]  # Hedef düğümü al
+               maliyet = j[0]  # Kenar maliyetini al
+
+               # Eğer mevcut düğümün mesafesi sonsuz değilse ve komşuya olan mesafe daha düşükse güncelle
+               if mesafeler[i] != float('infinity') and (mesafeler[i] + maliyet < mesafeler[hedef_dugum]):
+                   mesafeler[hedef_dugum] = mesafeler[i] + maliyet
+                   önceki[hedef_dugum] = i  # Önceki düğümü güncelle
+
+   # Negatif ağırlıklı döngü kontrolü
+   for i in graph:
+       for j in graph[i]:
+           hedef_dugum = j[1]
+           maliyet = j[0]
+
+           # Eğer hala bir iyileştirme yapılabiliyorsa negatif döngü vardır
+           if mesafeler[i] != float('infinity') and (mesafeler[i] + maliyet < mesafeler[hedef_dugum]):
+               return None  # Negatif döngü bulunduktan sonra işlevi sonlandırın.
+
+
+   # En kısa yolu bulmak için hedeften başlangıca doğru git
+   yol = []
+   geçerli_dugum = hedef
+
+   while geçerli_dugum is not None:
+       yol.append(geçerli_dugum)
+       geçerli_dugum = önceki[geçerli_dugum]
+
+   # Yolu ters çevir ve döndür.
+   yol.reverse()
+   return yol

Dijkstra.py

@@ -0,0 +1,49 @@
+def get_shortest_path(previous_nodes, start, target):
+    path = []
+    current_node = target
+    
+    while current_node is not None:
+        path.insert(0, current_node)  # Düğümü başa ekle
+        current_node = previous_nodes[current_node]  # Bir önceki düğüme git
+    
+    if path[0] == start:
+        return path
+    else:
+        return []  # Eğer yol yoksa boş liste döner
+
+def dijkstra(graph, start,target):
+    # 1. Mesafe tablosu: Başlangıç düğümünden diğer düğümlere olan mesafeleri tutar
+    mesafeler = {node: float('infinity') for node in graph}
+    mesafeler[start] = 0
+
+    # 2. Ziyaret edilen düğümleri tutan liste
+    ziyaret_edilen = []
+
+    # 3. Önceki düğümleri tutan tablo: En kısa yolu oluşturmak için
+    önceki_düğümler = {node: None for node in graph}
+
+    while len(ziyaret_edilen) < len(graph):
+        # 4. Ziyaret edilmemiş düğümler arasında en kısa mesafeye sahip olanı seç
+        en_kısa_yol_düğümü = None
+        for node in mesafeler:
+            if node not in ziyaret_edilen:
+                if en_kısa_yol_düğümü is None:
+                    en_kısa_yol_düğümü = node
+                elif mesafeler[node] < mesafeler[en_kısa_yol_düğümü]:
+                    en_kısa_yol_düğümü = node
+        
+        if en_kısa_yol_düğümü is None:
+            break  # Tüm düğümler ziyaret edilmişse ya da ulaşılamayan düğümler kalmışsa döngüyü sonlandır
+
+        # 5. Seçilen düğümün komşularının mesafelerini güncelle
+        for ağırlık,komşu in graph[en_kısa_yol_düğümü]:
+
+            yeni_mesafe = mesafeler[en_kısa_yol_düğümü] + ağırlık
+            if yeni_mesafe < mesafeler[komşu]:
+                mesafeler[komşu] = yeni_mesafe
+                önceki_düğümler[komşu] = en_kısa_yol_düğümü
+
+        # 6. Seçilen düğümü ziyaret edilmiş olarak işaretle
+        ziyaret_edilen.append(en_kısa_yol_düğümü)
+
+    return get_shortest_path(önceki_düğümler, start, target)

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Sistem bağımlılıklarını kur
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python paketlerini kur
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Uygulama dosyalarını kopyala
+COPY app.py .
+
+# Port
+EXPOSE 7860
+
+# Uygulamayı başlat
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,284 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+from heapq import heappush, heappop
+import io
+from PIL import Image
+
+# Grid tanımı
+GRID = [[4, 4, 4, 4, 4, 4, 4, 2, 3, 2, 4, 2], 
+        [4, 4, 4, 4, 9, 9, 3, 2, 2, 4, 4, 4], 
+        [4, 4, 2, 4, 2, 2, 2, 1, 1, 9, 9, 4], 
+        [4, 2, 2, 4, 2, 2, 1, 1, 1, 4, 4, 2], 
+        [1, 1, 2, 1, 1, 1, 1, 9, 1, 1, 1, 1], 
+        [4, 1, 2, 1, 9, 2, 1, 1, 1, 9, 2, 2], 
+        [4, 1, 4, 1, 2, 4, 4, 1, 1, 4, 4, 2], 
+        [1, 1, 1, 1, 2, 4, 2, 2, 1, 2, 3, 2]]
+
+COLS, ROWS = 12, 8
+
+# Graph oluştur
+def create_graph(grid):
+    graph = {}
+    for y in range(len(grid)):
+        for x in range(len(grid[0])):
+            neighbors = []
+            for dx, dy in [(-1, 0), (0, -1), (1, 0), (0, 1)]:
+                nx, ny = x + dx, y + dy
+                if 0 <= nx < len(grid[0]) and 0 <= ny < len(grid):
+                    neighbors.append((grid[ny][nx], (nx, ny)))
+            graph[(x, y)] = neighbors
+    return graph
+
+GRAPH = create_graph(GRID)
+
+# A* Algoritması
+def heuristic(a, b):
+    return abs(a[0] - b[0]) + abs(a[1] - b[1])
+
+def a_star(graph, start, goal):
+    queue = []
+    heappush(queue, (0, start))
+    g_score = {start: 0}
+    came_from = {start: None}
+    
+    while queue:
+        _, current = heappop(queue)
+        
+        if current == goal:
+            path = []
+            while current:
+                path.append(current)
+                current = came_from[current]
+            return path[::-1]
+        
+        for neighbor_cost, neighbor in graph[current]:
+            tentative_g_score = g_score[current] + neighbor_cost
+            
+            if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
+                g_score[neighbor] = tentative_g_score
+                f_score = tentative_g_score + heuristic(neighbor, goal)
+                heappush(queue, (f_score, neighbor))
+                came_from[neighbor] = current
+    
+    return None
+
+# Dijkstra Algoritması
+def dijkstra(graph, start, goal):
+    distances = {node: float('infinity') for node in graph}
+    distances[start] = 0
+    visited = []
+    previous = {node: None for node in graph}
+    
+    while len(visited) < len(graph):
+        current = None
+        for node in distances:
+            if node not in visited:
+                if current is None or distances[node] < distances[current]:
+                    current = node
+        
+        if current is None:
+            break
+        
+        for weight, neighbor in graph[current]:
+            new_distance = distances[current] + weight
+            if new_distance < distances[neighbor]:
+                distances[neighbor] = new_distance
+                previous[neighbor] = current
+        
+        visited.append(current)
+    
+    path = []
+    current = goal
+    while current is not None:
+        path.insert(0, current)
+        current = previous[current]
+    
+    return path if path[0] == start else None
+
+# Bellman-Ford Algoritması
+def bellman_ford(graph, start, goal):
+    distances = {node: float('infinity') for node in graph}
+    previous = {node: None for node in graph}
+    distances[start] = 0
+    
+    for _ in range(len(graph) - 1):
+        for node in graph:
+            for cost, neighbor in graph[node]:
+                if distances[node] != float('infinity') and distances[node] + cost < distances[neighbor]:
+                    distances[neighbor] = distances[node] + cost
+                    previous[neighbor] = node
+    
+    path = []
+    current = goal
+    while current is not None:
+        path.append(current)
+        current = previous[current]
+    
+    path.reverse()
+    return path if path and path[0] == start else None
+
+# Görselleştirme
+def visualize_path(start_x, start_y, goal_x, goal_y, algorithm):
+    start = (start_x, start_y)
+    goal = (goal_x, goal_y)
+    
+    # Algoritma seçimi
+    if algorithm == "A*":
+        path = a_star(GRAPH, start, goal)
+        color = '#2196F3'
+        title = "A* Algorithm"
+    elif algorithm == "Dijkstra":
+        path = dijkstra(GRAPH, start, goal)
+        color = '#FF9800'
+        title = "Dijkstra Algorithm"
+    else:  # Bellman-Ford
+        path = bellman_ford(GRAPH, start, goal)
+        color = '#F44336'
+        title = "Bellman-Ford Algorithm"
+    
+    # Matplotlib ile görselleştirme
+    fig, ax = plt.subplots(figsize=(14, 8))
+    
+    # Grid çiz
+    for y in range(ROWS):
+        for x in range(COLS):
+            cost = GRID[y][x]
+            # Maliyet değerine göre renk
+            if cost == 1:
+                cell_color = '#E8F5E9'
+            elif cost <= 3:
+                cell_color = '#FFF9C4'
+            elif cost <= 6:
+                cell_color = '#FFE0B2'
+            else:
+                cell_color = '#FFCDD2'
+            
+            rect = Rectangle((x, ROWS - y - 1), 1, 1, 
+                           facecolor=cell_color, 
+                           edgecolor='gray', 
+                           linewidth=0.5)
+            ax.add_patch(rect)
+            
+            # Maliyet değerini yaz
+            ax.text(x + 0.5, ROWS - y - 0.5, str(cost),
+                   ha='center', va='center', 
+                   fontsize=10, color='#424242', weight='bold')
+    
+    # Yolu çiz
+    if path:
+        for i, (x, y) in enumerate(path):
+            if (x, y) == start:
+                circle_color = '#4CAF50'
+                label = 'Start'
+            elif (x, y) == goal:
+                circle_color = '#F44336'
+                label = 'Goal'
+            else:
+                circle_color = color
+                label = 'Path'
+            
+            circle = plt.Circle((x + 0.5, ROWS - y - 0.5), 0.3,
+                              color=circle_color, zorder=10)
+            ax.add_patch(circle)
+        
+        path_length = sum(GRID[y][x] for x, y in path[1:])
+        info_text = f"Path Length: {len(path)} nodes\nTotal Cost: {path_length}"
+    else:
+        info_text = "No path found!"
+    
+    ax.set_xlim(0, COLS)
+    ax.set_ylim(0, ROWS)
+    ax.set_aspect('equal')
+    ax.axis('off')
+    ax.set_title(f'{title}\n{info_text}', fontsize=16, weight='bold', pad=20)
+    
+    # Legend
+    from matplotlib.patches import Patch
+    legend_elements = [
+        Patch(facecolor='#4CAF50', label='Start'),
+        Patch(facecolor='#F44336', label='Goal'),
+        Patch(facecolor=color, label='Path'),
+        Patch(facecolor='#E8F5E9', label='Low Cost (1)'),
+        Patch(facecolor='#FFF9C4', label='Medium Cost (2-3)'),
+        Patch(facecolor='#FFE0B2', label='High Cost (4-6)'),
+        Patch(facecolor='#FFCDD2', label='Very High Cost (7-9)')
+    ]
+    ax.legend(handles=legend_elements, loc='upper left', bbox_to_anchor=(1, 1))
+    
+    plt.tight_layout()
+    
+    # PIL Image'e çevir
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()
+    
+    return img
+
+# Gradio Arayüzü
+with gr.Blocks(title="Path Finding Algorithms", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🗺️ Path Finding Algorithms Visualizer
+    
+    Select start and goal positions, choose an algorithm, and visualize the shortest path!
+    
+    ### 📊 Algorithms:
+    - **A\***: Heuristic-based, fastest with known goal
+    - **Dijkstra**: Classic shortest path algorithm
+    - **Bellman-Ford**: Handles negative weights, detects negative cycles
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚙️ Settings")
+            
+            algorithm = gr.Radio(
+                choices=["A*", "Dijkstra", "Bellman-Ford"],
+                value="A*",
+                label="Algorithm"
+            )
+            
+            with gr.Row():
+                start_x = gr.Slider(0, 11, value=0, step=1, label="Start X")
+                start_y = gr.Slider(0, 7, value=7, step=1, label="Start Y")
+            
+            with gr.Row():
+                goal_x = gr.Slider(0, 11, value=11, step=1, label="Goal X")
+                goal_y = gr.Slider(0, 7, value=0, step=1, label="Goal Y")
+            
+            find_btn = gr.Button("🔍 Find Path", variant="primary", size="lg")
+            
+            gr.Markdown("""
+            ### 📝 Info:
+            - **Grid Size**: 12x8
+            - **Cost Range**: 1-9
+            - **Green**: Start point
+            - **Red**: Goal point
+            - **Blue/Orange/Red**: Path (depends on algorithm)
+            """)
+        
+        with gr.Column(scale=2):
+            output_image = gr.Image(label="Visualization", type="pil")
+    
+    find_btn.click(
+        fn=visualize_path,
+        inputs=[start_x, start_y, goal_x, goal_y, algorithm],
+        outputs=output_image
+    )
+    
+    # İlk yükleme
+    demo.load(
+        fn=visualize_path,
+        inputs=[gr.Number(value=0, visible=False), 
+                gr.Number(value=7, visible=False),
+                gr.Number(value=11, visible=False),
+                gr.Number(value=0, visible=False),
+                gr.Textbox(value="A*", visible=False)],
+        outputs=output_image
+    )
+
+if __name__ == "__main__":
+    demo.launch()

docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3.8'
+
+services:
+  pathfinding:
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      - GRADIO_SERVER_NAME=0.0.0.0
+      - GRADIO_SERVER_PORT=7860
+    restart: unless-stopped

main.py

@@ -0,0 +1,87 @@
+import pygame as pg
+from heapq import *
+from A_Star import a_star
+from Dijkstra import dijkstra
+from Bellman_Ford import bellman_ford
+
+# Konumun merkezine yerleştirilen çemberin pozisyonunu döndürüyor
+def get_circle(x, y):
+    return (x * TILE + TILE // 2, y * TILE + TILE // 2), TILE // 7  # Çemberin merkezini ve yarıçapını döndür
+
+# Komşu hücreleri kontrol ediyor
+def neighbor_control(x, y):
+    # Komşuların hangi yönlerde olduğunu belirleyen liste (sol, yukarı, sağ, aşağı)
+    ways = [-1, 0], [0, -1], [1, 0], [0, 1]
+    neighbor = []
+
+    for dx, dy in ways:
+        new_dx, new_dy = x + dx, y + dy
+        # Komşu hücrelerin oyun alanı sınırları içinde olup olmadığını kontrol et
+        if cols > new_dx >= 0 and rows > new_dy >= 0:
+            neighbor.append((grid[new_dy][new_dx], (new_dx, new_dy)))  # Geçerli komşuyu listeye ekle
+    return neighbor
+
+# Fare ile tıklanan hücreyi seçiyor.
+def get_click_mouse_pos():
+    x, y = pg.mouse.get_pos()  # Fare imlecinin konumunu al
+    grid_x, grid_y = x // TILE, y // TILE  # Imlecin bulunduğu grid hücresini bul
+    pg.draw.circle(sc, pg.Color('black'), * ((grid_x * TILE + TILE // 2, grid_y * TILE + TILE // 2), TILE // 7))  # Hücrede kırmızı çember çiz
+    click = pg.mouse.get_pressed()  # Fare tıklaması kontrolü
+    return (grid_x, grid_y) if click[0] else False  # Sol tıklama yapılmışsa pozisyonu döndür, aksi halde False döndür
+
+# Oyun alanının boyutları (kolonlar, satırlar ve hücre boyutu)
+cols, rows = 12, 8
+TILE = 70  # Her bir hücrenin piksel boyutu
+
+# Pygame başlatma ve ekran ayarlama
+pg.init()
+sc = pg.display.set_mode([cols * TILE, rows * TILE])  
+clock = pg.time.Clock()
+
+# Oyun alanı için grid oluşturma (her hücrede maliyetler)
+grid = [[4, 4, 4, 4, 4, 4, 4, 2, 3, 2, 4, 2], 
+        [4, 4, 4, 4, 9, 9, 3, 2, 2, 4, 4, 4], 
+        [4, 4, 2, 4, 2, 2, 2, 1, 1, 9, 9, 4], 
+        [4, 2, 2, 4, 2, 2, 1, 1, 1, 4, 4, 2], 
+        [1, 1, 2, 1, 1, 1, 1, 9, 1, 1, 1, 1], 
+        [4, 1, 2, 1, 9, 2, 1, 1, 1, 9, 2, 2], 
+        [4, 1, 4, 1, 2, 4, 4, 1, 1, 4, 4, 2], 
+        [1, 1, 1, 1, 2, 4, 2, 2, 1, 2, 3, 2]]
+
+# Oyun alanı için graph oluşturma (komşuluk ilişkileri ile)
+graph = {}
+for y, row in enumerate(grid):
+    for x, col in enumerate(row):
+        graph[(x, y)] = graph.get((x, y), []) + neighbor_control(x, y)
+
+# Başlangıç ve hedef konum
+start = (0, 7)
+goal = start
+visited = []
+
+# Arka plan resmi yükleme ve ölçeklendirme
+bg = pg.image.load('./resim/map.jpg').convert()
+bg = pg.transform.scale(bg, (cols * TILE, rows * TILE))
+
+# Oyun döngüsü
+while True:
+
+    sc.blit(bg, (0, 0))  
+    mouse_pos = get_click_mouse_pos() 
+    if mouse_pos:
+        #visited = a_star(graph, start, mouse_pos)  # A* algoritmasını çalıştır ve yolu bul
+        #visited = dijkstra(graph, start, mouse_pos)  # dijkstra algoritmasını çalıştır ve yolu bul
+        visited = bellman_ford(graph, start, mouse_pos)  # bellman_ford algoritmasını çalıştır ve yolu bul
+
+
+        goal = mouse_pos  # Hedefi fare ile tıklanan pozisyona ayarla
+
+    if visited:
+        for path_segment in visited:
+            pg.draw.circle(sc, pg.Color('blue'), *get_circle(*path_segment))  # Bulunan yol üzerindeki hücreleri maviyle işaretle
+    pg.draw.circle(sc, pg.Color('green'), *get_circle(*start))  # Başlangıç hücresini yeşille işaretle
+    pg.draw.circle(sc, pg.Color('red'), *get_circle(*goal))  # Hedef hücresini kırmızı işaretle
+
+    [exit() for event in pg.event.get() if event.type == pg.QUIT]  
+    pg.display.flip()  
+    clock.tick(30) 

requirements.txt

@@ -0,0 +1,4 @@
+gradio==4.16.0
+numpy==1.24.3
+matplotlib==3.7.1
+Pillow==10.2.0

run_local.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+echo "🚀 Starting Path Finding Algorithms Visualizer..."
+echo ""
+
+# Check if Docker is installed
+if ! command -v docker &> /dev/null; then
+    echo "❌ Docker is not installed. Please install Docker first."
+    echo "Visit: https://docs.docker.com/get-docker/"
+    exit 1
+fi
+
+# Build Docker image
+echo "📦 Building Docker image..."
+docker build -t pathfinding-app .
+
+if [ $? -ne 0 ]; then
+    echo "❌ Docker build failed!"
+    exit 1
+fi
+
+echo "✅ Docker image built successfully!"
+echo ""
+
+# Run container
+echo "🏃 Running container..."
+docker run -p 7860:7860 pathfinding-app
+
+# Or use docker-compose
+# docker-compose up