diff --git a/.idea/AI.iml b/.idea/AI.iml
new file mode 100644
index 0000000..bf708e3
--- /dev/null
+++ b/.idea/AI.iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/encodings.xml b/.idea/encodings.xml
new file mode 100644
index 0000000..15a15b2
--- /dev/null
+++ b/.idea/encodings.xml
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/.idea/libraries/R_User_Library.xml b/.idea/libraries/R_User_Library.xml
new file mode 100644
index 0000000..71f5ff7
--- /dev/null
+++ b/.idea/libraries/R_User_Library.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..a2e120d
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000..1872027
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..94a25f7
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
new file mode 100644
index 0000000..c3df9f9
--- /dev/null
+++ b/.idea/workspace.xml
@@ -0,0 +1,662 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ tmp
+ global
+ cop
+ jakLiczycKoszt
+ jakLiczyc
+ eve
+ doW
+ self
+ gen
+ data.geny
+ crosso
+ fitness
+ wybierzUnbox
+ genRandomPop
+ cro
+ moves
+ genPop
+ wybierzUn
+ cros
+ cross
+ cr
+ genpo
+ random
+ wybierz
+ update
+ za
+ data.gen
+ muta
+ mutate
+ od tego mom
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1588070561873
+
+
+ 1588070561873
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ file://$PROJECT_DIR$/genetyczne.py
+ 94
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/AStar.py b/AStar.py
index 13407c0..d0ecf9c 100644
--- a/AStar.py
+++ b/AStar.py
@@ -16,8 +16,8 @@ class AStar:
result[path[i][0]][path[i][1]] = startValue
startValue+=1
return result
-
- def search(self, start, end, grid, cost):
+######################################################### w current jest koszt do przebycia
+ def search(self, start, end, grid, cost, flaga): #start to kordy wózka, end miejsce podjęcia paczki
noRows, noColumns = numpy.shape(grid)
startNode = AStarState(None, tuple(start))
endNode = AStarState(None, tuple(end))
@@ -41,32 +41,51 @@ class AStar:
if item.gmax and flaga == 0: #podprojekt genetyczne
+ return current.g
if iterations>max:
return self.returnPath(current, grid)
visited.append(current)
toVisit.pop(currentIndeks)
+ if current==endNode and flaga == 0:
+ return current.g
if current==endNode:
- return self.returnPath(current, grid)
+ return self.returnPath(current, grid) #zwracanie wagi przejscia
children = []
for new in moves:
positions = (current.position[0]+new[0], current.position[1]+new[1])
+
if (positions[0] > (noRows - 1) or
positions[0] < 0 or
positions[1] > (noColumns - 1) or
positions[1] < 0):
continue
+ """ podprojekt genetyczne"""
+ if grid[positions[0]][positions[1]] == 2 and flaga == 0:
+ children.append(AStarState(current, positions))
+ continue
+
if grid[positions[0]][positions[1]]!=0:
continue
+
children.append(AStarState(current, positions))
for child in children:
+
if len([visitedChild for visitedChild in visited if visitedChild==child])>0:
continue
+
if child.position[0]<=(len(grid)-4) and child.position[0]>=3 and child.position[1]>=4 and child.position[1]<=(len(grid[0])-1):
child.g = current.g + (10 * cost)
else:
child.g = current.g + cost
child.h = (((child.position[0]-endNode.position[0]) ** 2) + ((child.position[1]-endNode.position[1]) ** 2))
child.f = child.g + child.h
+
if len([i for i in toVisit if child==i and child.g>i.g])>0:
continue
+
toVisit.append(child)
+
+
+
+
diff --git a/Data.py b/Data.py
new file mode 100644
index 0000000..3e26c82
--- /dev/null
+++ b/Data.py
@@ -0,0 +1,22 @@
+
+
+
+class Data:
+
+ def __init__(self):
+ self.zajeteRegaly = [] #krotka (x,y)
+ self.mapa = []
+ self.unbox = []
+ self.astarMap = []
+ self.geny = []
+ self.kordyWozka = None
+ self.jakLiczycKoszt = None
+ self.best = None
+ self.histZmian = []
+ self.doWykresu = []
+
+ def genMap(self, mapa):
+ tmpMap = mapa.copy()
+ for regal in self.zajeteRegaly:
+ tmpMap[regal[0]][regal[1]] = 2
+ return tmpMap
diff --git a/Gene.py b/Gene.py
new file mode 100644
index 0000000..4950105
--- /dev/null
+++ b/Gene.py
@@ -0,0 +1,9 @@
+
+
+class Gene:
+ def __init__(self):
+ self.kordy = None
+ self.unbox1 = None
+ self.unbox2 = None
+ self.unboxWczesniejszegoGenu = None
+ self.kordyUnboxa = None
\ No newline at end of file
diff --git a/LechT.md b/LechT.md
new file mode 100644
index 0000000..579b8a3
--- /dev/null
+++ b/LechT.md
@@ -0,0 +1,320 @@
+## Raport z części indywidualnej - podprojektu
+## Tomasz Lech
+
+### Omówienie projektu
+
+
+Celem projektu jest znalezienie najoptymalniejszej drogi między zajętymi regałami a miejscami odbioru paczki.
+Projekt wykorzystuje wcześniej opracowany algorytm AStar, który jest opisany w pliku [route-planning](https://git.wmi.amu.edu.pl/s444399/AI/src/master/route-planning.md).
+Moduł podprojektu uruchamia się po uruchomieniu programu oraz kliknięciu **g** na klawiaturze. Omawiany moduł genetyczny podprojektu w dalszej części raportu będzie się pojawiał w skrócie jako **mdg**.
+
+### Opis składowych elementów wykorzystanych w **mdg**
+* Gen - jest to najmniejszy wykorzystywany obiekt, reprezentujący zajęty regał, kóry ma określony koszt do danego miejsca odbioru
+* Chromosom - jest to uporządkowany zbiór Genów, który reprezentuje kolejność odbioru paczek, końcowa długość wynika z ilości paczek na magazynie.
+* Populacja - jest to zbiór chromosomów.
+* Funkcja fitness - funkcja obliczająca całkowity koszt chromosomu.
+* Selekcja - składowa odpowiedzialna za wybór najlepszych chromosomów z pośród populacji.
+* Crossover - składowa odpowiedzialna za generowanie nowej populacji uwzględniając współczynnik mutacji, wielkość dziedziczonego fragmentu oraz otrzymane podczas selekcji chromosomy.
+
+
+
+### Dane wejściowe
+
+Podane przez urzydkownika przed uruchomieniem programu:
+
+* ileGeneracji - wartość, która definiuje ile generacji ma się wykonać po uruchomieniu modułu **mdg**,
+* ileWPopulacji - wartość, która definiuje ile chromosomów ma się znajdować w Populacji
+* fragment - wartość z zakresu (0,1), która względnie do długości chromosomu określa fragment, który będzie dziedziczony, przy tworzeniu nowego chromosomu.
+* mutacja - wartość z zakresu (0,1), która określa jaka część nowo tworzonego chromosomu, po dziedziczeniu, ma zostać losowo zmieniona.
+* unbox - wartość określająca do jakiego miejsca odbioru ma się kierować wózek
+
+0 - losowe miejsce odbioru
+1 - miejsce odbioru tylko po lewej stronie mapy
+2 - miejsce odbioru tylko po prawej stronie mapy
+3 - miejsce odbioru wybierane korzystniej na podstawie kosztu
+
+Po uruchomieniu programu:
+
+* generowanie losowo rozmieszczonych paczek na regałach - za przycisku **r** na klawiaturze.
+
+
+### Integracja
+
+
+
+*W pliku program.py*
+Uruchomienie **mdg**:
+
+ if event.key == pygame.K_g:
+ start(self.data,self.wheel)
+
+Po zakończeniu algorytmu, uruchaminy modul który rozwiezie paczki do miejsca odbioru:
+
+ for gen in self.data.best[0]:
+ if(gen.unboxWczesniejszegoGenu == None):
+ kordStartowy = (self.wheel.ns, self.wheel.we)
+ else:
+ kordStartowy = self.data.unbox[gen.unboxWczesniejszegoGenu]
+
+ zbierzBox(gen,self.data, self.moves, kordStartowy)
+
+*W pliku genetyczne.py*
+
+ def start(data, wheel):
+
+ ileGeneracji = 20
+ ileWPopulacji = 16
+ fragment = 0.5
+ mutacja = 0.05
+ unbox = 3
+
+ data.kordyWozka = (wheel.ns, wheel.we)
+ data.jakLiczycKoszt = unbox
+
+ randomPopulation = genRandomPopulation(data, ileWPopulacji)
+ for i in range(ileGeneracji):
+ if i == 0:
+ best2 = dwieNajlepsze(randomPopulation, data)
+ else:
+ x = genPopulacje(data,best2[0], best2[1], ileWPopulacji, fragment, mutacja)
+ best2 = dwieNajlepsze(x, data)
+ del x
+
+ data.histZmian.append(data.best[1])
+
+
+ rysujWykres(data, ileGeneracji, 0, 2000)
+
+W celu modyfikacji danych wejściowych należy zmienić wartości zmiennych, pamiętając o podanych powyrzej ograniczeniach.
+
+Powyżej fragment kodu reprezentujący działanie pętli, której iteracje odpowiadają tworzeniom nowych generacji.
+
+###Sposób działania algorytmu:
+
+```mermaid
+graph TD
+A[ Generowanie
losowego
chromosomu]
+B[ Generowanie
losowej
populacji ]
+
+C[ Selekcyjny
wybór najlepszych chromosomów
z pośród populacji ]
+D[Generowanie nowej populacji z podanych chromosomów]
+E[Ilość generacji]
+
+ A --> B
+ B --> C
+ C --> D
+ D --> E
+ E --> C
+```
+###Implementacja
+#### Generowanie losowego chromosomu
+*W pliku Gene.py*
+
+Klasa Gene:
+
+ class Gene:
+ def __init__(self):
+ self.kordy = None
+ self.unbox1 = None
+ self.unbox2 = None
+ self.unboxWczesniejszegoGenu = None
+ self.kordyUnboxa = None
+
+Odpowiednio:
+* kordy - krotka z koordynatami regału
+* unbox1 - koszt potrzebny do przejazdu z miejsca regału do miejsca oddania paczki po lewej stronie mapy
+* unbox2 - koszty potrzebny do przejazdu z miejsca regału do miejsca oddania paczki po prawej stronie mapy
+* unboxWczesniejszegoGenu - wartość (0 lub 1) która definiuje z jakiego miejsca oddania paczki jechał wózek do regału reprezentowanego przez ten gen
+* kordyUnboxa - koordynaty miejsca oddania paczki do którego będzie jechać wózek
+
+Od tego momentu miejsce oddania paczki będzie określane jako **unbox**
+
+*W pliku genetyczne.py*
+
+ def generateGeny(data):
+ geny = []
+ zajeteRegaly = data.zajeteRegaly[:]
+ for r in zajeteRegaly:
+ g = Gene()
+ g.kordy = r
+ g.unbox1 = policzCost(data.astarMap,r,data.unbox[0])
+ if(len(data.unbox) > 1):
+ g.unbox2 = policzCost(data.astarMap,r,data.unbox[1])
+ geny.append(g)
+ return geny
+
+ def genRandomChromosome(data):
+ chromosome = generateGeny(data)
+ random.shuffle(chromosome)
+ unboxLastGen = None
+
+ for gen in chromosome:
+ gen.unboxWczesniejszegoGenu = unboxLastGen
+ krotkaKosztJakiUnbox = wybierzUnbox(gen, data.jakLiczycKoszt)
+ unboxLastGen = krotkaKosztJakiUnbox[1]
+ gen.kordyUnboxa = data.unbox[krotkaKosztJakiUnbox[1]]
+ return chromosome
+
+Odpowiednio:
+* Funkcja *generateGeny* generuje oraz oblicza wartości unboxów dla danego regału oraz zwraca je jako listę genów
+* Funkcja *genRandomChromosome* losowo miesza wygenerowane geny oraz dla podanej wartości **unbox** (podanej przy uruchomieniu programu) zapisuje w genach wartości odpowiadające koodrynatom unboxa oraz z jakiego unboxa wózek przyjedzie. W przypadku pierwszego genu, do którego wózek będzie jechać z określonego miejsca ta wartość pozostaje *None*. Funkcja zwraca spójny chromosom.
+
+#### Generowanie Losowej populacji
+*W pliku genetyczne.py*
+
+ def genRandomPopulation(data, ileWPopulacji):
+ populacja = []
+ for i in range(ileWPopulacji):
+ populacja.append(genRandomChromosome(data))
+ return populacja
+Odpowiednio:
+* Dla podanej wartości *ileWPopulacji* funkcja generuje losową populację wykorzystując metodę losowego chromosomu, wykonując tyle iteracji ile wynosi wartość.
+
+#### Selekcyjny wybór najlepszych chromosomów z pośród populacji na podstawie funkcji fitness
+*W pliku genetyczne.py*
+
+ def fitness(chromosome, data):
+ koszt = 0
+ unboxPoprzedniegoGenu = None
+
+ for item, gen in enumerate(chromosome):
+ if(item == 0):
+ koszt += policzCost(data.astarMap, data.kordyWozka, gen.kordy)
+ krotkaKosztJakiUnbox = wybierzUnbox(gen, data.jakLiczycKoszt)
+ koszt += krotkaKosztJakiUnbox[0]
+ unboxPoprzedniegoGenu = krotkaKosztJakiUnbox[1]
+
+ else:
+ if unboxPoprzedniegoGenu == 0:
+ koszt += gen.unbox1
+ elif unboxPoprzedniegoGenu == 1:
+ koszt += gen.unbox2
+
+ krotkaKosztJakiUnbox = wybierzUnbox(gen, data.jakLiczycKoszt)
+ koszt += krotkaKosztJakiUnbox[0]
+ unboxPoprzedniegoGenu = krotkaKosztJakiUnbox[1]
+
+
+ return koszt
+
+Odpowiednio:
+* Zmienna *koszt* jest sumą całkowitą kosztów przejechania trasy.
+* Pętla *for* iteruje się tyle razy ile jest genów w chromosomie.
+* W pierwszej iteracji koszt jest liczony dla pierwszego genu w chromosomie wywołując AStar, z pozycji początkowej wózka do miejsca regału.
+* Dla reszty iteracji jest sprawdzane do którego unboxa będzie jechać wózek, i taka wartość kosztu jest dodawana co całkowitej sumy oraz koszt przejechania od unboxa poprzedniego genu do regału (zmienna *unboxPoprzedniegoGenu*)
+
+
+ def dwieNajlepsze(populacja, data):
+ tmpPopulacja = populacja[:]
+ chromFitness = []
+
+ for chrom in populacja:
+ chromFitness.append(fitness(chrom,data))
+
+ bestValue = min(chromFitness)
+ bestChromIndex = chromFitness.index(bestValue)
+ pierwsza = tmpPopulacja[bestChromIndex]
+ if (data.best == None):
+ data.best = (pierwsza[:],bestValue)
+ elif(data.best[1] > bestValue):
+ data.best = (pierwsza[:],bestValue)
+ data.doWykresu.append(bestValue)
+
+ tmpPopulacja.pop(bestChromIndex)
+ chromFitness.pop(bestChromIndex)
+
+ bestValue = min(chromFitness)
+ bestChromIndex = chromFitness.index(bestValue)
+ druga = tmpPopulacja[bestChromIndex]
+ tmpPopulacja.pop(bestChromIndex)
+ chromFitness.pop(bestChromIndex)
+
+
+ return (pierwsza, druga)
+
+Funkcja selekcji dla której odpowiednio:
+* W pierwszej pętli *for* tworzy się lista *chromFitness* przetrzymująca wartości kosztów dla danego chromosomu. Wartości w *chromFitness* odpowiadają chromosomom na tych samych indeksach w liście populacja.
+* Zmienna *bestValue* reprezentuje najlepszy koszt z danej populacji
+* Zmienna *pierwsza* reprezentuje chromosom o najkorzystniejszym koszcie.
+* Zmienna *druga* reprezentuje chromosom o drugim co do wartości najkorzystniejszym koszcie.
+* W zmiennej *best* klasy obiektu *data* zapisywana jest krotka odpowiednio (chromosom,koszt) najlepszego chromosomu.
+* Funkcja zwraca krotkę z dwoma najlepszymi chromosomami w populacji.
+
+#### Generowanie nowej populacji - Crossover
+*W pliku genetyczne.py*
+
+ def crossover(data,pierwszy, drugi, fragmentLiczba, wspMutacji):
+ ileWChrom = len(pierwszy)
+ tmp = random.randint(0, ileWChrom-fragmentLiczba)
+ kordyFragment = (tmp,tmp+fragmentLiczba)
+ nowyChrom = [Gene() for q in range(ileWChrom)]
+ iterator = kordyFragment[1]
+ pomIterator = kordyFragment[1]
+ usedKordy = []
+ for i in range(kordyFragment[0],kordyFragment[1]):
+ nowyChrom[i].kordy = pierwszy[i].kordy
+ nowyChrom[i].unbox1 = pierwszy[i].unbox1
+ nowyChrom[i].unbox2 = pierwszy[i].unbox2
+ usedKordy.append(pierwszy[i].kordy)
+
+ for x in range(ileWChrom):
+ if(iterator > ileWChrom - 1):
+ iterator = 0
+ if(pomIterator > ileWChrom - 1):
+ pomIterator = 0
+ if(nowyChrom[iterator].kordy == None and drugi[pomIterator].kordy not in usedKordy):
+ nowyChrom[iterator].kordy = drugi[pomIterator].kordy
+ nowyChrom[iterator].kordy = drugi[pomIterator].kordy
+ nowyChrom[iterator].unbox1 = drugi[pomIterator].unbox1
+ nowyChrom[iterator].unbox2 = drugi[pomIterator].unbox2
+ iterator += 1
+ pomIterator += 1
+ else:
+ pomIterator +=1
+
+ nowyChrom = mutate(wspMutacji, nowyChrom)
+ unboxLastGen = None
+
+ for gen in nowyChrom:
+ gen.unboxWczesniejszegoGenu = unboxLastGen
+ krotkaKosztJakiUnbox = wybierzUnbox(gen, data.jakLiczycKoszt)
+ unboxLastGen = krotkaKosztJakiUnbox[1]
+ gen.kordyUnboxa = data.unbox[krotkaKosztJakiUnbox[1]]
+
+ return nowyChrom
+
+Odpowiednio:
+* Dane wejściowe są to:
+ * *pierwszy*, *drugi* - wybrane najkorzystniejsze chromosomy, z których ma powstać nowy chromosom
+ * *fragmentLiczba* - jest to liczba reprezentująca jaki fragment z **pierwszego** chromosomu zostanie bezpośrednio skopiowany do nowego chromosomu, ten fragment jest wybierany losowo spośród chromosomu natomiast jego długość jest określona procentowo i zależy od podanej wartości (oraz ilości genów w chromosomoie)
+ * *wspMutacji* - jest to liczba reprezentująca jak wiele par w chromosomie zostanie zamienionych miejscami.
+* Zmienne pomocnicze:
+ * *iterator*, *pomIterator* - w pierwszych dwóch instrukcjach warunkowych jest pilnowane aby iterując się nie przekroczyły dopuszczalnej wartości (odpowiadają one indeksom w kolejce). *Iterato* jest indeksem w nowym, tworzonym chromosomie. *pomIterator* jest indeksem który przechodzi przez **drugi** podany chromosom.
+ * lista *usedKordy* - do niej są dodawane koordynaty genów, które zostały skopiowane z **pierwszego** chromosomu, aby geny o tych samych koordynatach z **drugiego** chromosomu nie zostały zapisane w nowym chromosomie.
+* Następuje skopiowanie fagmentu z **pierwszego** chromosomu, w pierwszej pętli *for* wykonuje się przepisanie wartości do powstającego chromosomu. W drugiej pętli *for* następuje przepisanie pozostałych wartości z **drugiego** chromosomu do powstającego chromosomu.
+* Po przepisaniu wartości według wspMutacji jest dokonywana zamiana genów w nowym chromosomie.
+* Ostatnia pętla **for** łączy geny ze sobą (zapisując unbox poprzedniego genu)
+
+*W pliku genetyczne.py*
+
+ def genPopulacje(data,pierwszy, drugi, ileWPopulacji, fragmentLiczba, wspMutacji):
+ ileWChrom = len(pierwszy)
+ fragment = round(fragmentLiczba*ileWChrom)
+ if(fragment == 1):
+ fragment +=1
+ nowaPopulacja = []
+
+ for i in range(ileWPopulacji):
+ nowaPopulacja.append(crossover(data,pierwszy,drugi,fragment, wspMutacji))
+
+ return nowaPopulacja
+Odpowiednio:
+* W pętli *for* tworzone są nowe chromosomy z **pierwszego** oraz **drugiego** najlepszego chromosomu z poprzedniej generacji.
+* Nowe chromosomy zapisywane są do *nowaPopulacja*
+* Z powstałej populacji na nowo selekcjonowane są dwa najlepsze, z których będą powstawać nowe populacje w zależności od wartości podanych generacji.
+
+### Dalsze działanie programu
+
+Po wykonaniu iteracji uruchamia się okienko pokazujące wykres najlepszych wag otrzymywanych w danej populacji.
+
+Po zamknięciu okienka wózek zaczyna rozwozić paczki do miejsc oddania paczki.
\ No newline at end of file
diff --git a/__pycache__/AStar.cpython-37.pyc b/__pycache__/AStar.cpython-37.pyc
new file mode 100644
index 0000000..d63b879
Binary files /dev/null and b/__pycache__/AStar.cpython-37.pyc differ
diff --git a/__pycache__/AStarState.cpython-37.pyc b/__pycache__/AStarState.cpython-37.pyc
new file mode 100644
index 0000000..fae2672
Binary files /dev/null and b/__pycache__/AStarState.cpython-37.pyc differ
diff --git a/__pycache__/Data.cpython-37.pyc b/__pycache__/Data.cpython-37.pyc
new file mode 100644
index 0000000..c68d306
Binary files /dev/null and b/__pycache__/Data.cpython-37.pyc differ
diff --git a/__pycache__/Evencik.cpython-37.pyc b/__pycache__/Evencik.cpython-37.pyc
new file mode 100644
index 0000000..cef7b92
Binary files /dev/null and b/__pycache__/Evencik.cpython-37.pyc differ
diff --git a/__pycache__/Gene.cpython-37.pyc b/__pycache__/Gene.cpython-37.pyc
new file mode 100644
index 0000000..b2d700f
Binary files /dev/null and b/__pycache__/Gene.cpython-37.pyc differ
diff --git a/__pycache__/box.cpython-37.pyc b/__pycache__/box.cpython-37.pyc
new file mode 100644
index 0000000..8945628
Binary files /dev/null and b/__pycache__/box.cpython-37.pyc differ
diff --git a/__pycache__/boxOnTheFloor.cpython-37.pyc b/__pycache__/boxOnTheFloor.cpython-37.pyc
new file mode 100644
index 0000000..cc9785e
Binary files /dev/null and b/__pycache__/boxOnTheFloor.cpython-37.pyc differ
diff --git a/__pycache__/floor.cpython-37.pyc b/__pycache__/floor.cpython-37.pyc
new file mode 100644
index 0000000..8c496c9
Binary files /dev/null and b/__pycache__/floor.cpython-37.pyc differ
diff --git a/__pycache__/funkcje.cpython-37.pyc b/__pycache__/funkcje.cpython-37.pyc
new file mode 100644
index 0000000..c015eca
Binary files /dev/null and b/__pycache__/funkcje.cpython-37.pyc differ
diff --git a/__pycache__/generate.cpython-37.pyc b/__pycache__/generate.cpython-37.pyc
new file mode 100644
index 0000000..e71c35c
Binary files /dev/null and b/__pycache__/generate.cpython-37.pyc differ
diff --git a/__pycache__/genetyczne.cpython-37.pyc b/__pycache__/genetyczne.cpython-37.pyc
new file mode 100644
index 0000000..2dc837d
Binary files /dev/null and b/__pycache__/genetyczne.cpython-37.pyc differ
diff --git a/__pycache__/neurons.cpython-37.pyc b/__pycache__/neurons.cpython-37.pyc
new file mode 100644
index 0000000..fc8415c
Binary files /dev/null and b/__pycache__/neurons.cpython-37.pyc differ
diff --git a/__pycache__/program.cpython-37.pyc b/__pycache__/program.cpython-37.pyc
new file mode 100644
index 0000000..9c2d0b0
Binary files /dev/null and b/__pycache__/program.cpython-37.pyc differ
diff --git a/__pycache__/shelf.cpython-37.pyc b/__pycache__/shelf.cpython-37.pyc
new file mode 100644
index 0000000..d284192
Binary files /dev/null and b/__pycache__/shelf.cpython-37.pyc differ
diff --git a/__pycache__/unboxOnTheFloor.cpython-37.pyc b/__pycache__/unboxOnTheFloor.cpython-37.pyc
new file mode 100644
index 0000000..c042f9e
Binary files /dev/null and b/__pycache__/unboxOnTheFloor.cpython-37.pyc differ
diff --git a/__pycache__/wall.cpython-37.pyc b/__pycache__/wall.cpython-37.pyc
new file mode 100644
index 0000000..9d8d09a
Binary files /dev/null and b/__pycache__/wall.cpython-37.pyc differ
diff --git a/__pycache__/wheel.cpython-37.pyc b/__pycache__/wheel.cpython-37.pyc
new file mode 100644
index 0000000..97489f7
Binary files /dev/null and b/__pycache__/wheel.cpython-37.pyc differ
diff --git a/__pycache__/whereDecision.cpython-37.pyc b/__pycache__/whereDecision.cpython-37.pyc
new file mode 100644
index 0000000..ae4c5c2
Binary files /dev/null and b/__pycache__/whereDecision.cpython-37.pyc differ
diff --git a/funkcje.py b/funkcje.py
new file mode 100644
index 0000000..4df211d
--- /dev/null
+++ b/funkcje.py
@@ -0,0 +1,224 @@
+from unboxOnTheFloor import UnboxOnTheFloor
+from box import Box
+from AStar import AStar
+import random
+from easygui import *
+import matplotlib.pyplot as plt
+
+
+
+
+def zbierzBox(gen,data, moves, kordStartowy):
+ regalKordy = gen.kordy
+ star = AStar()
+ mapForAStar = data.astarMap[:]
+ mapForAStar[regalKordy[0]][regalKordy[1]] = 0
+ path = star.search([kordStartowy[0], kordStartowy[1]], regalKordy, mapForAStar, 1, 1)
+ cns = kordStartowy[0]
+ cwe = kordStartowy[1]
+ value = path[cns][cwe]
+
+ while True:
+ if cns > 0 and path[cns - 1][cwe] == (value + 1):
+ cns = cns - 1
+ moves.append(1)
+ value = value + 1
+ continue
+ if cns < (len(mapForAStar) - 1) and path[cns + 1][cwe] == (value + 1):
+ cns = cns + 1
+ moves.append(2)
+ value = value + 1
+ continue
+ if cwe > 0 and path[cns][cwe - 1] == (value + 1):
+ cwe = cwe - 1
+ moves.append(3)
+ value = value + 1
+ continue
+ if cwe < (len(mapForAStar[0]) - 1) and path[cns][cwe + 1] == (value + 1):
+ cwe = cwe + 1
+ moves.append(4)
+ value = value + 1
+ continue
+ break
+ mapForAStar[regalKordy[0]][regalKordy[1]] = 1
+ # wyszukiwanie ścieżki z miejsca podjęcia paczki do regału
+ # zmienna path posiada macierz oraz kroki podjęte przez wózek
+ path = star.search([regalKordy[0], regalKordy[1]], gen.kordyUnboxa, mapForAStar, 1, 1)
+ #mapForAStar[where[0]][where[1]] = 1
+ value = path[cns][cwe]
+ while True:
+ if(value == 0):
+ if(path[cns - 1][cwe] == 1):
+ cns = cns - 1
+ elif(path[cns + 1][cwe] == 1):
+ cns = cns + 1
+ elif(path[cns][cwe - 1] == 1):
+ cwe = cwe - 1
+ elif(path[cns][cwe + 1] == 1):
+ cwe = cwe + 1
+ value = path[cns][cwe]
+ continue
+ if cns > 0 and path[cns - 1][cwe] == (value + 1):
+ cns = cns - 1
+ moves.append(1)
+ value = value + 1
+ continue
+ if cns < (len(mapForAStar) - 1) and path[cns + 1][cwe] == (value + 1):
+ cns = cns + 1
+ moves.append(2)
+ value = value + 1
+ continue
+ if cwe > 0 and path[cns][cwe - 1] == (value + 1):
+ cwe = cwe - 1
+ moves.append(3)
+ value = value + 1
+ continue
+ if cwe < (len(mapForAStar[0]) - 1) and path[cns][cwe + 1] == (value + 1):
+ cwe = cwe + 1
+ moves.append(4)
+ value = value + 1
+ continue
+ break
+
+
+def rysujWykres(data, x, yStart, yEnd):
+
+ plt.axis([0, x,yStart, yEnd])
+
+ for i in range(0, len(data.doWykresu) - 1):
+ y = data.doWykresu[i]
+ x = i
+ plt.scatter(x, y)
+ plt.pause(0.0001)
+
+ plt.show()
+
+
+def znajdzUnbox(data,mapa):
+ unboxy = []
+ iterator = 0
+ ostatniWiersz = len(mapa) -1
+ for x in mapa[ostatniWiersz]:
+ if (isinstance(x, UnboxOnTheFloor)):
+ unboxy.append((ostatniWiersz, iterator))
+ iterator += 1
+
+ data.unbox = unboxy
+
+
+
+def policzCost(mapaBoxy, poczatek, koniec):
+ astar = AStar()
+ koszt = astar.search(poczatek, koniec, mapaBoxy, 1, 0)
+ return koszt
+
+
+
+def wybierzUnbox(gen, jakLiczycKoszt): #funkcja ustawiajaca jaki unbox
+ if(jakLiczycKoszt == 0):
+ x = random.choice([gen.unbox1, gen.unbox2])
+ if(x == gen.unbox1):
+ y = 0
+ else:
+ y= 1
+ return (x,y)
+ elif(jakLiczycKoszt == 1):
+ return (gen.unbox1,0)
+ elif(jakLiczycKoszt == 2):
+ return (gen.unbox2,1)
+ elif(jakLiczycKoszt == 3):
+ x = min(gen.unbox1,gen.unbox2)
+ if(x == gen.unbox1):
+ y = 0
+ else:
+ y = 1
+ return (x,y)
+
+def randomBox(mapa, regals, ile):
+
+ regals = regals
+ mapa = mapa
+ tupleList = []
+ ileRegalow = len(regals)
+ iteration = 0
+
+ while iteration < ileRegalow and iteration < ile:
+ regal = random.choice(regals)
+ if regal in tupleList:
+ continue
+ else:
+ tupleList.append(regal)
+ iteration+=1
+
+ for (i,j,x) in tupleList:
+ box = Box()
+ mapa[i][j].put(box)
+ """
+ for t in tupleList:
+ listaRegalow.append((t[0],t[1]))
+ data.zajeteRegaly = listaRegalow
+ """
+ return mapa
+
+def znajdzBox(mapa, regals):
+ zajeteRegaly = []
+
+ for (x,y,z) in regals:
+ shelf = mapa[x][y]
+ tmp = shelf.occupied
+ if(tmp == True):
+ zajeteRegaly.append((x,y))
+ return zajeteRegaly
+
+#wybiera z populacji dwa najlepsze chromosomy
+
+
+
+def updateMap(data, map, mapForAstar, regals):
+ data.mapa = map
+
+ znajdzUnbox(data, map)
+ data.zajeteRegaly = znajdzBox(map, regals)
+ data.astarMap = data.genMap(mapForAstar)
+
+
+
+
+
+
+def okno():
+ good = True
+ fieldValues = multenterbox("Wprowadź warunki początkowe", "Start algorytmu genetycznego", ["Ile chrom. w generacji", "Wielkosc dziedziczonego fragmentu (x>0 and x<1)", "Wartosc mutacji (x>0 and x<1)", "Unbox: (0or 1 or 2 or 2)", "Ile generacji"])
+ if(fieldValues[0].isnumeric() and (fieldValues[0]!="")):
+ good = False
+ elif(good==True):
+ msgbox("Wartość nie jest liczbą", "Błąd")
+ good = False
+ if(fieldValues[1].isnumeric() and (fieldValues[1]!="")):
+ if((int(fieldValues[1])<=0) and (good==True) and (int(fieldValues[1])>= 1)):
+ msgbox("Zla wartosc fragmentu")
+ good = False
+ elif (good == True):
+ msgbox("Wartość nie jest liczbą", "Błąd")
+ good = False
+ if(fieldValues[2].isnumeric() and (fieldValues[2]!="")):
+ if((int(fieldValues[1])<=0) and (good==True) and (int(fieldValues[1])>= 1)):
+ msgbox("Zla wartosc mutacji")
+ good = False
+ elif (good == True):
+ msgbox("Wartość nie jest liczbą", "Błąd")
+ good = False
+ if(fieldValues[3].isnumeric() and (fieldValues[3]!="")):
+ if(((int(fieldValues[3]) != 0) or (int(fieldValues[3]) != 1) or (int(fieldValues[3]) != 2) or (int(fieldValues[3]) != 3)) and (good==True)):
+ msgbox("Zla wartosc unboxa")
+ good = False
+ elif (good == True):
+ msgbox("Wartość nie jest liczbą", "Błąd")
+ good = False
+ if(fieldValues[4].isnumeric() and (fieldValues[4]!="")):
+ pass
+ else:
+ msgbox("Wartość nie jest liczbą", "Błąd")
+ good = False
+ if(good == True):
+ return [fieldValues[0], fieldValues[1], fieldValues[2],fieldValues[3]]
\ No newline at end of file
diff --git a/generate.py b/generate.py
index 65ad33c..46f2e55 100644
--- a/generate.py
+++ b/generate.py
@@ -168,7 +168,15 @@ class Generate:
all[wysokosc-2][szerokosc-2] = 1
all[0][2] = 2
all[1][2] = 2
+#zmiana miejsca zrzutu paczki, unboxOnTheFloor
all[wysokosc-2][szerokosc-3] = 2
all[wysokosc-1][szerokosc-3] = 23
all[wysokosc-2][szerokosc-4] = 1
- return all
\ No newline at end of file
+
+
+ all[wysokosc-2][2] = 2
+ all[wysokosc-1][2] = 23
+ all[wysokosc-2][3] = 1
+
+ return all
+
diff --git a/genetyczne.py b/genetyczne.py
new file mode 100644
index 0000000..7812d5e
--- /dev/null
+++ b/genetyczne.py
@@ -0,0 +1,183 @@
+from funkcje import *
+from Gene import Gene
+
+def start(data, wheel):
+
+ ileGeneracji = 20
+ ileWPopulacji = 16
+ fragment = 0.5
+ mutacja = 0.05
+ unbox = 3
+
+ data.kordyWozka = (wheel.ns, wheel.we)
+ data.jakLiczycKoszt = unbox
+
+ randomPopulation = genRandomPopulation(data, ileWPopulacji)
+ for i in range(ileGeneracji):
+ if i == 0:
+ best2 = dwieNajlepsze(randomPopulation, data)
+ else:
+ x = genPopulacje(data,best2[0], best2[1], ileWPopulacji, fragment, mutacja)
+ best2 = dwieNajlepsze(x, data)
+ del x
+
+ data.histZmian.append(data.best[1])
+
+
+ rysujWykres(data, ileGeneracji, 0, 2000)
+
+
+
+
+def generateGeny(data):
+ geny = []
+ zajeteRegaly = data.zajeteRegaly[:]
+ for r in zajeteRegaly:
+ g = Gene()
+ g.kordy = r
+ g.unbox1 = policzCost(data.astarMap,r,data.unbox[0])
+ if(len(data.unbox) > 1):
+ g.unbox2 = policzCost(data.astarMap,r,data.unbox[1])
+ geny.append(g)
+ return geny
+
+
+
+def genRandomChromosome(data):
+ chromosome = generateGeny(data)
+ random.shuffle(chromosome)
+ unboxLastGen = None
+
+ for gen in chromosome:
+ gen.unboxWczesniejszegoGenu = unboxLastGen
+ krotkaKosztJakiUnbox = wybierzUnbox(gen, data.jakLiczycKoszt)
+ unboxLastGen = krotkaKosztJakiUnbox[1]
+ gen.kordyUnboxa = data.unbox[krotkaKosztJakiUnbox[1]]
+ return chromosome
+
+def genRandomPopulation(data, ileWPopulacji):
+ populacja = []
+ for i in range(ileWPopulacji):
+ populacja.append(genRandomChromosome(data))
+ return populacja
+
+
+def fitness(chromosome, data):
+ koszt = 0
+ unboxPoprzedniegoGenu = None
+
+ for item, gen in enumerate(chromosome):
+ if(item == 0):
+ koszt += policzCost(data.astarMap, data.kordyWozka, gen.kordy)
+ krotkaKosztJakiUnbox = wybierzUnbox(gen, data.jakLiczycKoszt)
+ koszt += krotkaKosztJakiUnbox[0]
+ unboxPoprzedniegoGenu = krotkaKosztJakiUnbox[1]
+
+ else:
+ if unboxPoprzedniegoGenu == 0:
+ koszt += gen.unbox1
+ elif unboxPoprzedniegoGenu == 1:
+ koszt += gen.unbox2
+
+ krotkaKosztJakiUnbox = wybierzUnbox(gen, data.jakLiczycKoszt)
+ koszt += krotkaKosztJakiUnbox[0]
+ unboxPoprzedniegoGenu = krotkaKosztJakiUnbox[1]
+
+
+ return koszt
+
+
+def dwieNajlepsze(populacja, data):
+ tmpPopulacja = populacja[:]
+ chromFitness = []
+
+ for chrom in populacja:
+ chromFitness.append(fitness(chrom,data))
+
+ bestValue = min(chromFitness)
+ bestChromIndex = chromFitness.index(bestValue)
+ pierwsza = tmpPopulacja[bestChromIndex]
+ if (data.best == None):
+ data.best = (pierwsza[:],bestValue)
+ elif(data.best[1] > bestValue):
+ data.best = (pierwsza[:],bestValue)
+ data.doWykresu.append(bestValue)
+
+ tmpPopulacja.pop(bestChromIndex)
+ chromFitness.pop(bestChromIndex)
+
+ bestValue = min(chromFitness)
+ bestChromIndex = chromFitness.index(bestValue)
+ druga = tmpPopulacja[bestChromIndex]
+ tmpPopulacja.pop(bestChromIndex)
+ chromFitness.pop(bestChromIndex)
+
+
+ return (pierwsza, druga)
+
+def crossover(data,pierwszy, drugi, fragmentLiczba, wspMutacji):
+ ileWChrom = len(pierwszy)
+ tmp = random.randint(0, ileWChrom-fragmentLiczba)
+ kordyFragment = (tmp,tmp+fragmentLiczba)
+ nowyChrom = [Gene() for q in range(ileWChrom)]
+ iterator = kordyFragment[1]
+ pomIterator = kordyFragment[1]
+ usedKordy = []
+ for i in range(kordyFragment[0],kordyFragment[1]):
+ nowyChrom[i].kordy = pierwszy[i].kordy
+ nowyChrom[i].unbox1 = pierwszy[i].unbox1
+ nowyChrom[i].unbox2 = pierwszy[i].unbox2
+ usedKordy.append(pierwszy[i].kordy)
+
+ for x in range(ileWChrom):
+ if(iterator > ileWChrom - 1):
+ iterator = 0
+ if(pomIterator > ileWChrom - 1):
+ pomIterator = 0
+ if(nowyChrom[iterator].kordy == None and drugi[pomIterator].kordy not in usedKordy):
+ nowyChrom[iterator].kordy = drugi[pomIterator].kordy
+ nowyChrom[iterator].kordy = drugi[pomIterator].kordy
+ nowyChrom[iterator].unbox1 = drugi[pomIterator].unbox1
+ nowyChrom[iterator].unbox2 = drugi[pomIterator].unbox2
+ iterator += 1
+ pomIterator += 1
+ else:
+ pomIterator +=1
+
+ nowyChrom = mutate(wspMutacji, nowyChrom)
+ unboxLastGen = None
+
+
+
+ for gen in nowyChrom:
+ gen.unboxWczesniejszegoGenu = unboxLastGen
+ krotkaKosztJakiUnbox = wybierzUnbox(gen, data.jakLiczycKoszt)
+ unboxLastGen = krotkaKosztJakiUnbox[1]
+ gen.kordyUnboxa = data.unbox[krotkaKosztJakiUnbox[1]]
+
+ return nowyChrom
+
+
+def genPopulacje(data,pierwszy, drugi, ileWPopulacji, fragmentLiczba, wspMutacji):
+ ileWChrom = len(pierwszy)
+ fragment = round(fragmentLiczba*ileWChrom)
+ if(fragment == 1):
+ fragment +=1
+ nowaPopulacja = []
+
+ for i in range(ileWPopulacji):
+ nowaPopulacja.append(crossover(data,pierwszy,drugi,fragment, wspMutacji))
+
+ return nowaPopulacja
+
+def mutate(wspMutacji, chrom): #w zaleznosci od tego jak wiele mutwac wybierz pary i zamien miejscami
+ ileWChrom = len(chrom)
+ ileZmian = round(ileWChrom * wspMutacji)
+ for i in range(ileZmian):
+ pom = None
+ pierw = random.randint(0,ileWChrom - 1)
+ drug = random.randint(0,ileWChrom - 1)
+ pom = chrom[pierw]
+ chrom[pierw] = chrom[drug]
+ chrom[drug] = pom
+ return chrom
\ No newline at end of file
diff --git a/main.py b/main.py
index 263fa26..a2fb1cf 100644
--- a/main.py
+++ b/main.py
@@ -6,6 +6,7 @@ def main():
good = False
while (True):
good = True
+ """
fieldValues = multenterbox("Wprowadź warunki początkowe", "Start programu", ["Szerekość kraty (>=6)", "Wysokość kraty (>=7)", "Ilość regałów kruchych", "Ilość regałów łatwopalnych", "Ilość regałów radioaktywnych", "Ilość regałów niebezpiecznych"])
if(fieldValues[0].isnumeric() and (fieldValues[0]!="")):
if(int(fieldValues[0])<=5):
@@ -30,7 +31,14 @@ def main():
elif (good == True):
msgbox("Wartość nie jest liczbą", "Błąd")
good = False
+ """
if good:
- window = MainWindow(int(fieldValues[0]), int(fieldValues[1]), int(fieldValues[2]), int(fieldValues[3]), int(fieldValues[4]), int(fieldValues[5]));
+ szerokosc = 15#min 6
+ wysokosc = 10 #min 7
+ kruche = 1
+ latwopalne = 1
+ radioaktywne = 1
+ niebezpieczne= 1
+ window = MainWindow(szerokosc, wysokosc, kruche, latwopalne, radioaktywne, niebezpieczne);
break
main()
\ No newline at end of file
diff --git a/program.py b/program.py
index 852ae65..c37522c 100644
--- a/program.py
+++ b/program.py
@@ -15,6 +15,8 @@ from neurons import Neurons
from whereDecision import WhereDecision
from Evencik import Evencik
import pathlib
+from Data import Data
+from genetyczne import *
class MainWindow:
def __init__(self, szerokosc, wysokosc, kruche, latwopalne, radioaktywne, niebezpieczne):
@@ -25,6 +27,7 @@ class MainWindow:
pygame.display.set_caption('Inteligentny wózek widłowy')
self.clock = pygame.time.Clock()
self.ticks = 0
+ self.data = Data()
self.moves = []
self.regals = []
self.map = Generate.generate(szerokosc+2, wysokosc+2, kruche, latwopalne, radioaktywne, niebezpieczne)
@@ -44,12 +47,21 @@ class MainWindow:
self.mapForAStar[i][j] = 0
elif (self.map[i][j]==23):
self.map[i][j] = UnboxOnTheFloor(self.screen, self.cell, i, j)
- self.mapForAStar[i][j] = 1
+ self.mapForAStar[i][j] = 0
+
else:
+ #regals (kordy i,j oraz rodzaj regału)
self.regals.append((i, j, (self.map[i][j]-3)//4))
self.map[i][j] = Shelf(self.screen, self.cell, i, j, (self.map[i][j]-3)%4, (self.map[i][j]-3)//4)
self.mapForAStar[i][j] = 1
- #loop
+
+
+
+
+
+
+ #################################################
+#loop
while True:
self.events()
self.draw()
@@ -66,14 +78,30 @@ class MainWindow:
self.wheel.move(Evencik(pygame.K_LEFT), self.map)
elif (self.moves[0]==4):
self.wheel.move(Evencik(pygame.K_RIGHT), self.map)
+
self.moves.pop(0)
+
def events(self):
for event in pygame.event.get():
if(event.type==pygame.QUIT):
sys.exit()
+
elif(event.type==pygame.KEYDOWN):
- if len(self.moves)==0:
+ if event.key == pygame.K_g:
+ start(self.data,self.wheel)
+ for gen in self.data.best[0]:
+ if(gen.unboxWczesniejszegoGenu == None):
+ kordStartowy = (self.wheel.ns, self.wheel.we)
+ else:
+ kordStartowy = self.data.unbox[gen.unboxWczesniejszegoGenu]
+
+ zbierzBox(gen,self.data, self.moves, kordStartowy)
+ elif(event.key== pygame.K_r):
+ self.map = randomBox(self.map, self.regals, 15)
+ updateMap(self.data, self.map, self.mapForAStar, self.regals)
+ elif len(self.moves)==0:
self.wheel.move(event, self.map)
+
elif(event.type==pygame.MOUSEBUTTONDOWN):
if (type(self.map[0][2]) == Floor):
meh = easygui.fileopenbox("Wybierz zdjęcie paczki", "Wybierz zdjęcie paczki", filetypes = [["*.jpg", "*.jpeg", "*.png", "Pliki graficzne"]])
@@ -86,8 +114,9 @@ class MainWindow:
whatIsIt = self.neurons.whatIsIt(meh)
where = self.whereDecision.recognize(whatIsIt, self.regalsik())
self.map[0][2] = BoxOnTheFloor(self.screen, self.cell, 0, 2, Box())
+
star = AStar()
- path = star.search([self.wheel.ns, self.wheel.we], [0, 2], self.mapForAStar, 1)
+ path = star.search([self.wheel.ns, self.wheel.we], [0, 2], self.mapForAStar, 1, 1)
cns = self.wheel.ns
cwe = self.wheel.we
value = path[cns][cwe]
@@ -114,7 +143,9 @@ class MainWindow:
continue
break
self.mapForAStar[where[0]][where[1]] = 0
- path = star.search([0, 2], where, self.mapForAStar, 1)
+ # wyszukiwanie ścieżki z miejsca podjęcia paczki do regału
+ # zmienna path posiada macierz oraz kroki podjęte przez wózek
+ path = star.search([0, 2], where, self.mapForAStar, 1, 1)
self.mapForAStar[where[0]][where[1]] = 1
value = path[cns][cwe]
while True:
@@ -139,6 +170,8 @@ class MainWindow:
value=value+1
continue
break
+ self.data.zajeteRegaly = znajdzBox(self.map, self.regals)
+
def draw(self):
self.screen.fill((33,69,108))
for i in range(len(self.map)):
diff --git a/unboxOnTheFloor.py b/unboxOnTheFloor.py
index 8e2ab0e..3f2013a 100644
--- a/unboxOnTheFloor.py
+++ b/unboxOnTheFloor.py
@@ -6,5 +6,6 @@ class UnboxOnTheFloor:
self.ns = ns
self.we = we
self.screen = screen
+
def draw(self):
pass
\ No newline at end of file
diff --git a/wheel.py b/wheel.py
index 32fe8b1..9f7ebbf 100644
--- a/wheel.py
+++ b/wheel.py
@@ -7,6 +7,7 @@ from shelf import Shelf
class Wheel:
def __init__(self, screen, cell):
self.cell = cell
+ #kordy wozka
self.ns = 1
self.we = 2
self.direction = 3
@@ -55,7 +56,7 @@ class Wheel:
elif(self.occupied==False and krata[self.ns+1][self.we].isOccupied()==True and krata[self.ns+1][self.we].kierunek==1):
self.putBox(krata[self.ns+1][self.we].get())
self.direction = 3
- elif(type(krata[self.ns+1][self.we])==UnboxOnTheFloor):
+ elif(type(krata[self.ns+1][self.we])==UnboxOnTheFloor): # Aktywacja unBoxOnTheFloor jak wózek najedzie na pole przed nim
if(self.ns+1==len(krata)-1):
self.ns+=1
self.m_ns=self.cell*(-1)
diff --git a/whereDecision.py b/whereDecision.py
index 1962e3a..4d0c95c 100644
--- a/whereDecision.py
+++ b/whereDecision.py
@@ -59,4 +59,5 @@ class WhereDecision:
y = prenumeratorzy["lokacja"]
drzewko = DecisionTreeClassifier(criterion="entropy")
drzewko.fit(X=z, y=y)
- return list(make_tuple(lokacja_kody[drzewko.predict(recognize)][0]))
\ No newline at end of file
+ tmp = list(make_tuple(lokacja_kody[drzewko.predict(recognize)][0]))
+ return tmp
\ No newline at end of file