187 lines
7.2 KiB
Python
187 lines
7.2 KiB
Python
import numpy as np
|
|
import random
|
|
import pygame
|
|
from constant import width, height, size, rows, cols
|
|
from board import Board
|
|
from tractor import Tractor
|
|
|
|
routes_num = 20 # Ilość ścieżek
|
|
board = Board()
|
|
weed_positions = board.get_weed_positions()
|
|
weed_count = len(weed_positions)
|
|
|
|
def manhattan(a, b):
|
|
return abs(a[0] - b[0]) + abs(a[1] - b[1])
|
|
|
|
def find_routes(routes_num):
|
|
population_set = [] # zapisujemy trasy - losowe ułóżenia
|
|
for i in range(routes_num):
|
|
# losowo wygenerowane kolejności na trasie
|
|
single_route = np.random.choice(list(range(weed_count)), weed_count, replace=False)
|
|
population_set.append(single_route)
|
|
return np.array(population_set) #zwracamy 20 roznych losowych tras
|
|
|
|
def sum_up_for_route(route_indices):
|
|
|
|
sum = 0
|
|
for i in range(len(route_indices) - 1):
|
|
current_weed = weed_positions[route_indices[i]]
|
|
next_weed = weed_positions[route_indices[i + 1]]
|
|
sum += manhattan(current_weed, next_weed)
|
|
return sum #zwracamy odleglosc (ilosc pol) dla danej trasy manhatanem
|
|
|
|
def routes_sum(population_set): # zapisujemy na liście finalne sumy odległości dla każdej z tras
|
|
list_of_sums = np.zeros(routes_num)
|
|
for i in range(routes_num):
|
|
list_of_sums[i] = sum_up_for_route(population_set[i]) # wywołujemy dla każdej trasy na liście
|
|
|
|
return list_of_sums
|
|
|
|
|
|
def calculate_fitness(distances):
|
|
# odwrotność odległości jako fitness
|
|
# dodajemy małą wartość (np. 1) aby uniknąć dzielenia przez zero
|
|
return 1 / (distances + 1)
|
|
|
|
|
|
def selection(population_set, list_of_sums):
|
|
#RULETKA - czesciowo faworyzuje rozwiaznaia, wiekszy fitness wieksze szanse
|
|
# obliczamy wartości fitness (przystosowania) dla każdej trasy
|
|
fitness_values = calculate_fitness(list_of_sums)#krotsze trasy maja miec wyzsze wartosci
|
|
# normalizujemy wartości fitness, aby sumowały się do 1 (wymagane dla np.random.choice)
|
|
probabilities = fitness_values / fitness_values.sum()
|
|
# wybieramy indeksy rodziców na podstawie prawdopodobieństw
|
|
progenitor_indices_a = np.random.choice(range(len(population_set)), len(population_set), p=probabilities, replace=True)
|
|
progenitor_indices_b = np.random.choice(range(len(population_set)), len(population_set), p=probabilities, replace=True)
|
|
# finalne trasy
|
|
progenitor_a = population_set[progenitor_indices_a]
|
|
progenitor_b = population_set[progenitor_indices_b]
|
|
|
|
return np.array([progenitor_a, progenitor_b]) #zwracami listy przodkow-rodzicow
|
|
|
|
def one_point_crossover(parent_a, parent_b): #krzyzowanie jednopunktowe
|
|
crossover_point = np.random.randint(1, len(parent_a))
|
|
child = np.concatenate((parent_a[:crossover_point], [x for x in parent_b if x not in parent_a[:crossover_point]]))
|
|
return child #loosyw punkt przeciecia ktory skleja nam nowa trase, wieksza szans na lepsza tarse
|
|
|
|
def population_mating(progenitor_list):
|
|
new_population_set = []
|
|
for i in range(len(progenitor_list[0])):
|
|
progenitor_a, progenitor_b = progenitor_list[0][i], progenitor_list[1][i]
|
|
child = one_point_crossover(progenitor_a, progenitor_b)
|
|
new_population_set.append(child)
|
|
return new_population_set # lista potomkow po krzyzowaniu
|
|
|
|
|
|
|
|
def mutation_of_child(child, mutation_rate=0.2):#procent moze pomoc w niezaklucaniu trasy gdy jesy duza trasa ale idk
|
|
num_mutations = int(len(child) * mutation_rate)
|
|
for _ in range(num_mutations):
|
|
x = np.random.randint(0, len(child))#losowa szansa zamiany - mutacja
|
|
y = np.random.randint(0, len(child))
|
|
child[x], child[y] = child[y], child[x]
|
|
return child#zwrocenie bardziej roznorodnych potomkow
|
|
|
|
|
|
def mutate_population(new_population_set):
|
|
final_mutated_population = []
|
|
for child in new_population_set:
|
|
final_mutated_population.append(mutation_of_child(child)) # dodajemy zmutowane dziecko do finalnej listy
|
|
return final_mutated_population
|
|
|
|
|
|
if __name__ == '__main__':
|
|
pygame.init()
|
|
WIN = pygame.display.set_mode((width, height))
|
|
pygame.display.set_caption('Trasa Traktora')
|
|
clock = pygame.time.Clock()
|
|
|
|
board = Board()
|
|
board.load_images()
|
|
weed_positions = [(col, row) for col in range(cols) for row in range(rows) if board.is_weed(col, row)]
|
|
weed_count = len(weed_positions)
|
|
|
|
board.set_grass(9, 9) # pozycja startowa
|
|
tractor = Tractor(9, 9) # Start traktora
|
|
|
|
|
|
# Inicjalizacja final_route
|
|
final_route = [0, float('inf'), np.array([])]
|
|
# [0]: indeks iteracji, [1]: najlepsza suma odległości, [2]: najlepsza trasa
|
|
|
|
population_set = find_routes(routes_num)
|
|
list_of_sums = routes_sum(population_set)
|
|
progenitor_list = selection(population_set, list_of_sums)
|
|
new_population_set = population_mating(progenitor_list)
|
|
final_mutated_population = mutate_population(new_population_set)
|
|
final_route = [-1, np.inf, np.array([])] # format listy
|
|
|
|
for i in range(20):
|
|
list_of_sums = routes_sum(final_mutated_population)
|
|
# zapisujemy najlepsze rozwiązanie
|
|
if list_of_sums.min() < final_route[1]:
|
|
final_route[0] = i
|
|
final_route[1] = list_of_sums.min()
|
|
final_route[2] = np.array(final_mutated_population)[list_of_sums.min() == list_of_sums]
|
|
|
|
progenitor_list = selection(population_set, list_of_sums)
|
|
new_population_set = population_mating(progenitor_list)
|
|
final_mutated_population = mutate_population(new_population_set)
|
|
|
|
print(f"Najlepsza trasa znaleziona w iteracji: {final_route[0]}")
|
|
print(f"Minimalna suma odległości: {final_route[1]}")
|
|
|
|
|
|
run = True
|
|
current_target_index = 0
|
|
best_routes = final_route[2] #tablica z najlepszymi trasami
|
|
visited_fields = []
|
|
while run:
|
|
clock.tick(2) # FPS
|
|
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
run = False
|
|
|
|
for route in best_routes:
|
|
if current_target_index < len(route):
|
|
current_weed = weed_positions[route[current_target_index]]
|
|
|
|
|
|
# ruch w kierunku bieżącego celu
|
|
if tractor.col < current_weed[0]:
|
|
tractor.col += 1
|
|
tractor.direction = "right"
|
|
elif tractor.col > current_weed[0]:
|
|
tractor.col -= 1
|
|
tractor.direction = "left"
|
|
elif tractor.row < current_weed[1]:
|
|
tractor.row += 1
|
|
tractor.direction = "down"
|
|
elif tractor.row > current_weed[1]:
|
|
tractor.row -= 1
|
|
tractor.direction = "up"
|
|
|
|
current_position = (tractor.col, tractor.row)
|
|
if current_position not in visited_fields:
|
|
visited_fields.append(current_position)
|
|
|
|
# Jeśli traktor dotarł do celu
|
|
if (tractor.col, tractor.row) == current_weed:
|
|
current_target_index += 1
|
|
|
|
# Aktualizacja planszy
|
|
if board.is_weed(tractor.col, tractor.row):
|
|
board.set_carrot(tractor.col, tractor.row)
|
|
|
|
|
|
|
|
board.draw_cubes(WIN)
|
|
tractor.draw(WIN)
|
|
pygame.display.update()
|
|
|
|
print("Odwiedzone pola:")
|
|
for field in visited_fields:
|
|
print(field)
|
|
|
|
pygame.quit() |