Compare commits
2 Commits
Author | SHA1 | Date | |
---|---|---|---|
d82a3483d9 | |||
7c2f48fbfb |
@ -4,7 +4,7 @@
|
||||
<content url="file://$MODULE_DIR$">
|
||||
<excludeFolder url="file://$MODULE_DIR$/venv" />
|
||||
</content>
|
||||
<orderEntry type="jdk" jdkName="Python 3.8 (Sztuczna_Inteligencja_Gr16)" jdkType="Python SDK" />
|
||||
<orderEntry type="jdk" jdkName="Python 3.9 (jakiesvirtualneenv)" jdkType="Python SDK" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
@ -1,4 +1,4 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8 (Sztuczna_Inteligencja_Gr16)" project-jdk-type="Python SDK" />
|
||||
<component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (jakiesvirtualneenv)" project-jdk-type="Python SDK" />
|
||||
</project>
|
BIN
Ikony/auto.png
Normal file
After Width: | Height: | Size: 657 B |
BIN
Ikony/auto2.png
Normal file
After Width: | Height: | Size: 644 B |
BIN
Ikony/bieg.png
Before Width: | Height: | Size: 694 B |
BIN
Ikony/dywan.png
Before Width: | Height: | Size: 384 KiB |
BIN
Ikony/kaluza.png
Before Width: | Height: | Size: 13 KiB |
BIN
Ikony/osoba2.png
Before Width: | Height: | Size: 377 B |
BIN
Ikony/paczka.png
Before Width: | Height: | Size: 87 KiB |
Before Width: | Height: | Size: 39 KiB |
124
a_gwiazdka.py
@ -1,124 +0,0 @@
|
||||
from collections import deque
|
||||
from queue import PriorityQueue
|
||||
|
||||
from stan_nastepnik import *
|
||||
|
||||
|
||||
class NastepnikZKosztemSciezki:
|
||||
def __init__(self, kosztSciezki: int, nastepnik: Nastepnik):
|
||||
self.kosztSciezki = kosztSciezki
|
||||
self.nastepnik = nastepnik
|
||||
|
||||
def skopiuj(self):
|
||||
return NastepnikZKosztemSciezki(self.kosztSciezki, self.nastepnik.skopiuj())
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.kosztSciezki <= other.kosztSciezki
|
||||
|
||||
|
||||
def goaltest(stan: Stan, cel: Stan):
|
||||
if stan.poleStartoweGorne.wiersz != cel.poleStartoweGorne.wiersz:
|
||||
return False
|
||||
elif stan.poleStartoweGorne.kolumna != cel.poleStartoweGorne.kolumna:
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
def stan_w_liscie_nastepnikow(stan: Stan, lista_nastepnikow):
|
||||
for i in lista_nastepnikow:
|
||||
if i.stan.kierunek != stan.kierunek:
|
||||
continue
|
||||
elif i.stan.poleStartoweGorne.wiersz != stan.poleStartoweGorne.wiersz:
|
||||
continue
|
||||
elif i.stan.poleStartoweGorne.kolumna != stan.poleStartoweGorne.kolumna:
|
||||
continue
|
||||
else:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def stan_w_kolejce_nastepnikow(stan: Stan, kolejka_nastepnikow: PriorityQueue):
|
||||
pom = []
|
||||
znaleziono = False
|
||||
while not kolejka_nastepnikow.empty():
|
||||
element = kolejka_nastepnikow.get()
|
||||
pom.append(element)
|
||||
nastepnik_z_kosztem_sciezki: NastepnikZKosztemSciezki = element[1]
|
||||
n = nastepnik_z_kosztem_sciezki.nastepnik
|
||||
if n.stan.kierunek != stan.kierunek:
|
||||
continue
|
||||
elif n.stan.poleStartoweGorne.wiersz != stan.poleStartoweGorne.wiersz:
|
||||
continue
|
||||
elif n.stan.poleStartoweGorne.kolumna != stan.poleStartoweGorne.kolumna:
|
||||
continue
|
||||
else:
|
||||
znaleziono = True
|
||||
break
|
||||
for e in pom:
|
||||
kolejka_nastepnikow.put(e)
|
||||
return znaleziono
|
||||
|
||||
|
||||
def stos_akcji(stan_koncowy: Nastepnik):
|
||||
stos = deque()
|
||||
while stan_koncowy.poprzednik is not None:
|
||||
stos.append(stan_koncowy.akcja)
|
||||
stan_koncowy = stan_koncowy.poprzednik
|
||||
return stos
|
||||
|
||||
|
||||
def heurystyka(z: Stan, cel: Stan):
|
||||
kroki_w_pionie = abs(cel.poleStartoweGorne.wiersz - z.poleStartoweGorne.wiersz)
|
||||
kroki_w_poziomie = abs(cel.poleStartoweGorne.kolumna - z.poleStartoweGorne.kolumna)
|
||||
return kroki_w_pionie + kroki_w_poziomie
|
||||
|
||||
|
||||
def koszt_wjechania(z: Stan, do: Stan):
|
||||
z_wiersz = z.poleStartoweGorne.wiersz
|
||||
z_kolumna = z.poleStartoweGorne.kolumna
|
||||
do_wiersz = do.poleStartoweGorne.wiersz
|
||||
do_kolumna = do.poleStartoweGorne.kolumna
|
||||
krata = z.poleStartoweGorne.krata.krata
|
||||
if z_wiersz == do_wiersz and z_kolumna == do_kolumna and z.kierunek == do.kierunek:
|
||||
return 0
|
||||
elif z_wiersz == do_wiersz and z_kolumna == do_kolumna and z.kierunek != do.kierunek:
|
||||
return ZawartoscPolaNaKosztObrotu[krata[do_wiersz][do_kolumna]]
|
||||
elif z.kierunek == do.kierunek:
|
||||
krok_w_pionie = (abs(z_wiersz - do_wiersz) == 1 and z_kolumna == do_kolumna)
|
||||
krok_w_poziomie = (abs(z_kolumna - do_kolumna) == 1 and z_kolumna == z_kolumna)
|
||||
if krok_w_pionie or krok_w_poziomie:
|
||||
return ZawartoscPolaNaKosztWjechania[krata[do_wiersz][do_kolumna]]
|
||||
else:
|
||||
raise "Stany nie są połączone."
|
||||
|
||||
|
||||
def priorytet(koszt_sciezki: int, z: Stan, do: Stan, cel: Stan):
|
||||
return koszt_sciezki + koszt_wjechania(z, do) + heurystyka(do, cel)
|
||||
|
||||
|
||||
def graphsearch(istate: Stan, cel: Stan):
|
||||
fringe = PriorityQueue()
|
||||
explored = []
|
||||
pom = NastepnikZKosztemSciezki(0, Nastepnik(None, istate, None))
|
||||
fringe.put((priorytet(0, istate, istate, cel), pom))
|
||||
# fringe.append(Nastepnik(None, istate, None))
|
||||
while not fringe.empty():
|
||||
# for i in fringe:
|
||||
# print("F",i.stan.kierunek,i.stan.poleStartoweGorne.wiersz,i.stan.poleStartoweGorne.kolumna,end=" ")
|
||||
# print()
|
||||
element: NastepnikZKosztemSciezki = fringe.get()[1]
|
||||
koszt_sciezki = element.kosztSciezki
|
||||
nastepnik = element.nastepnik
|
||||
if goaltest(nastepnik.stan, cel):
|
||||
return stos_akcji(nastepnik)
|
||||
explored.append(nastepnik)
|
||||
for nowy in succ(nastepnik):
|
||||
if not stan_w_kolejce_nastepnikow(nowy.stan, fringe) and not stan_w_liscie_nastepnikow(nowy.stan, explored):
|
||||
z = nastepnik.stan
|
||||
do = nowy.stan
|
||||
pom = NastepnikZKosztemSciezki(koszt_sciezki + koszt_wjechania(z, do), nowy)
|
||||
pom2 = (priorytet(koszt_sciezki, z, do, cel), pom)
|
||||
fringe.put(pom2)
|
||||
# print("dodano",pom.nastepnik.stan.kierunek,pom.nastepnik.stan.poleStartoweGorne.wiersz,pom.nastepnik.stan.poleStartoweGorne.kolumna)
|
||||
return False
|
189
agent.py
@ -1,189 +0,0 @@
|
||||
import random
|
||||
from collections import deque
|
||||
|
||||
# from bfs import graphsearch
|
||||
from a_gwiazdka import graphsearch
|
||||
from krata import *
|
||||
from obserwacja import *
|
||||
from stan_nastepnik import Stan, Akcja
|
||||
|
||||
|
||||
class Agent(Obserwowany):
|
||||
bok = BOK_AGENTA1
|
||||
bokWPolach = BOK_AGENTA1_W_POLACH
|
||||
cel: Stan or None
|
||||
kierunek: Kierunek
|
||||
# droga: int
|
||||
hitbox: pygame.Rect
|
||||
poleKoncoweDolne: PoleKraty
|
||||
|
||||
def __init__(self, krata: Krata, poleStartoweGorne: PoleKraty, tekstura):
|
||||
self.krata = krata
|
||||
self.poleStartoweGorne = poleStartoweGorne
|
||||
self.tekstura = tekstura
|
||||
self.okreslPolozenie()
|
||||
self.obierzLosowyKierunek()
|
||||
# self.okreslDlugoscDrogi()
|
||||
krata.agent = self
|
||||
self.cel = None
|
||||
|
||||
# def ruszSie(self):
|
||||
# if self.droga <= 0:
|
||||
# self.obierzLosowyKierunek()
|
||||
# self.okreslDlugoscDrogi()
|
||||
# self.zrobKrokWMoimKierunku()
|
||||
# self.droga -= 1
|
||||
# self.okreslPolozenie()
|
||||
# if self.wyszedlemPozaKrate() or self.wszedlemWSciane():
|
||||
# self.cofnijSie()
|
||||
# self.zawroc()
|
||||
# self.okreslDlugoscDrogi()
|
||||
|
||||
def obierzLosowyKierunek(self):
|
||||
self.kierunek = Kierunek(random.randint(0, 3))
|
||||
# if self.maxDlugoscDrogiWMoimKierunku() < 1:
|
||||
# self.obierzLosowyKierunek()
|
||||
|
||||
# def okreslDlugoscDrogi(self):
|
||||
# self.droga = random.randint(1, self.maxDlugoscDrogiWMoimKierunku())
|
||||
|
||||
def cofnijSie(self):
|
||||
self.zrobKrokWOdwrotnymKierunku()
|
||||
self.okreslPolozenie()
|
||||
|
||||
def okreslPolozenie(self):
|
||||
self.okreslPoleKoncoweDolne()
|
||||
self.okreslHitbox()
|
||||
self.powiadomObserwatorow()
|
||||
|
||||
def okreslHitbox(self):
|
||||
self.hitbox = pygame.Rect(self.poleStartoweGorne.start, self.poleStartoweGorne.gora, self.bok, self.bok)
|
||||
|
||||
def okreslPoleKoncoweDolne(self):
|
||||
wiersz = self.poleStartoweGorne.wiersz + self.bokWPolach - 1
|
||||
kolumna = self.poleStartoweGorne.kolumna + self.bokWPolach - 1
|
||||
self.poleKoncoweDolne = PoleKraty(self.krata, wiersz, kolumna)
|
||||
|
||||
def wyszedlemPozaKrate(self):
|
||||
if self.poleStartoweGorne.wiersz < 0:
|
||||
return True
|
||||
elif self.poleKoncoweDolne.wiersz > self.krata.liczbaPolPionowo - 1:
|
||||
return True
|
||||
elif self.poleStartoweGorne.kolumna < 0:
|
||||
return True
|
||||
elif self.poleKoncoweDolne.kolumna > self.krata.liczbaPolPoziomo - 1:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def wszedlemWSciane(self):
|
||||
for wiersz in range(self.poleStartoweGorne.wiersz, self.poleKoncoweDolne.wiersz + 1):
|
||||
for kolumna in range(self.poleStartoweGorne.kolumna, self.poleKoncoweDolne.kolumna + 1):
|
||||
if self.krata.krata[wiersz][kolumna] == ZawartoscPola.SCIANA:
|
||||
return True
|
||||
return False
|
||||
|
||||
def zawroc(self):
|
||||
if self.kierunek == Kierunek.POLNOC:
|
||||
self.kierunek = Kierunek.POLUDNIE
|
||||
elif self.kierunek == Kierunek.POLUDNIE:
|
||||
self.kierunek = Kierunek.POLNOC
|
||||
elif self.kierunek == Kierunek.ZACHOD:
|
||||
self.kierunek = Kierunek.WSCHOD
|
||||
elif self.kierunek == Kierunek.WSCHOD:
|
||||
self.kierunek = Kierunek.ZACHOD
|
||||
|
||||
def maxDlugoscDrogiWMoimKierunku(self):
|
||||
if self.kierunek == Kierunek.POLNOC:
|
||||
return self.poleStartoweGorne.wiersz
|
||||
elif self.kierunek == Kierunek.POLUDNIE:
|
||||
return self.krata.liczbaPolPionowo - self.poleKoncoweDolne.wiersz - 1
|
||||
elif self.kierunek == Kierunek.ZACHOD:
|
||||
return self.poleStartoweGorne.kolumna
|
||||
elif self.kierunek == Kierunek.WSCHOD:
|
||||
return self.krata.liczbaPolPoziomo - self.poleKoncoweDolne.kolumna - 1
|
||||
|
||||
def zrobKrokWMoimKierunku(self):
|
||||
if self.kierunek == Kierunek.POLNOC:
|
||||
self.idzNaPolnoc()
|
||||
elif self.kierunek == Kierunek.POLUDNIE:
|
||||
self.idzNaPoludnie()
|
||||
elif self.kierunek == Kierunek.ZACHOD:
|
||||
self.idzNaZachod()
|
||||
elif self.kierunek == Kierunek.WSCHOD:
|
||||
self.idzNaWschod()
|
||||
|
||||
def zrobKrokWOdwrotnymKierunku(self):
|
||||
if self.kierunek == Kierunek.POLNOC:
|
||||
self.idzNaPoludnie()
|
||||
elif self.kierunek == Kierunek.POLUDNIE:
|
||||
self.idzNaPolnoc()
|
||||
elif self.kierunek == Kierunek.ZACHOD:
|
||||
self.idzNaWschod()
|
||||
elif self.kierunek == Kierunek.WSCHOD:
|
||||
self.idzNaZachod()
|
||||
|
||||
def idzNaPolnoc(self):
|
||||
self.poleStartoweGorne.wiersz -= 1
|
||||
|
||||
def idzNaPoludnie(self):
|
||||
self.poleStartoweGorne.wiersz += 1
|
||||
|
||||
def idzNaZachod(self):
|
||||
self.poleStartoweGorne.kolumna -= 1
|
||||
|
||||
def idzNaWschod(self):
|
||||
self.poleStartoweGorne.kolumna += 1
|
||||
|
||||
def idzDoCelu(self):
|
||||
stan_poczatkowy = Stan(self.kierunek, self.poleStartoweGorne)
|
||||
stos_akcji = graphsearch(stan_poczatkowy, self.cel)
|
||||
if not stos_akcji:
|
||||
print("Nie można dotrzeć.")
|
||||
else:
|
||||
self.wykonaj_stos_akcji(stos_akcji)
|
||||
print("Dotarłem.")
|
||||
self.usunCel()
|
||||
|
||||
def ustawCel(self, cel):
|
||||
self.cel = cel
|
||||
wiersz = self.cel.poleStartoweGorne.wiersz
|
||||
kolumna = self.cel.poleStartoweGorne.kolumna
|
||||
if self.krata.krata[wiersz][kolumna] == ZawartoscPola.PUSTE:
|
||||
self.krata.krata[wiersz][kolumna] = ZawartoscPola.CEL
|
||||
|
||||
def usunCel(self):
|
||||
wiersz = self.cel.poleStartoweGorne.wiersz
|
||||
kolumna = self.cel.poleStartoweGorne.kolumna
|
||||
if self.krata.krata[wiersz][kolumna] == ZawartoscPola.CEL:
|
||||
self.krata.krata[wiersz][kolumna] = ZawartoscPola.PUSTE
|
||||
self.cel = None
|
||||
|
||||
def wykonaj_stos_akcji(self, stos_akcji: deque):
|
||||
while stos_akcji:
|
||||
akcja = stos_akcji.pop()
|
||||
# print(akcja.name, end=" ")
|
||||
if akcja == Akcja.KROK_W_PRZOD:
|
||||
self.zrobKrokWMoimKierunku()
|
||||
# self.okreslPolozenie()
|
||||
elif akcja == Akcja.OBROT_W_LEWO:
|
||||
self.obrocSieWLewo()
|
||||
elif akcja == Akcja.OBROT_W_PRAWO:
|
||||
self.obrocSieWPrawo()
|
||||
self.okreslPolozenie()
|
||||
# print()
|
||||
|
||||
def obrocSieWLewo(self):
|
||||
self.kierunek = self.kierunek.kierunekNaLewo()
|
||||
self.tekstura = pygame.transform.rotate(self.tekstura, 90)
|
||||
|
||||
def obrocSieWPrawo(self):
|
||||
self.kierunek = self.kierunek.kierunekNaPrawo()
|
||||
self.tekstura = pygame.transform.rotate(self.tekstura, 270)
|
||||
|
||||
def narysujAgenta(self):
|
||||
self.krata.okno.blit(self.tekstura, (self.hitbox.x, self.hitbox.y))
|
||||
|
||||
def powiadomObserwatorow(self):
|
||||
for obserwator in self.obserwatorzy:
|
||||
obserwator.odbierzPowiadomienie(self)
|
@ -1,374 +0,0 @@
|
||||
|
||||
import numpy as np
|
||||
from .decay import GeomDecay
|
||||
|
||||
|
||||
def hill_climb(problem, max_iters=np.inf, restarts=0, init_state=None,
|
||||
curve=False, random_state=None):
|
||||
"""
|
||||
best_state array containing state that optimizes the fitness function.
|
||||
best_fitness Value of fitness function at best state.
|
||||
fitness_curve array containing the fitness at every iteration.
|
||||
"""
|
||||
if (not isinstance(max_iters, int) and max_iters != np.inf
|
||||
and not max_iters.is_integer()) or (max_iters < 0):
|
||||
raise Exception("""max_iters must be a positive integer.""")
|
||||
|
||||
if (not isinstance(restarts, int) and not restarts.is_integer()) \
|
||||
or (restarts < 0):
|
||||
raise Exception("""restarts must be a positive integer.""")
|
||||
|
||||
if init_state is not None and len(init_state) != problem.get_length():
|
||||
raise Exception("""init_state must have same length as problem.""")
|
||||
|
||||
# Set random seed
|
||||
if isinstance(random_state, int) and random_state > 0:
|
||||
np.random.seed(random_state)
|
||||
|
||||
best_fitness = -1*np.inf
|
||||
best_state = None
|
||||
|
||||
if curve:
|
||||
fitness_curve = []
|
||||
|
||||
for _ in range(restarts + 1):
|
||||
# Initialize optimization problem
|
||||
if init_state is None:
|
||||
problem.reset()
|
||||
else:
|
||||
problem.set_state(init_state)
|
||||
|
||||
iters = 0
|
||||
|
||||
while iters < max_iters:
|
||||
iters += 1
|
||||
|
||||
# Find neighbors and determine best neighbor
|
||||
problem.find_neighbors()
|
||||
next_state = problem.best_neighbor()
|
||||
next_fitness = problem.eval_fitness(next_state)
|
||||
|
||||
# If best neighbor is an improvement, move to that state
|
||||
if next_fitness > problem.get_fitness():
|
||||
problem.set_state(next_state)
|
||||
|
||||
else:
|
||||
break
|
||||
|
||||
if curve:
|
||||
fitness_curve.append(problem.get_fitness())
|
||||
|
||||
# Update best state and best fitness
|
||||
if problem.get_fitness() > best_fitness:
|
||||
best_fitness = problem.get_fitness()
|
||||
best_state = problem.get_state()
|
||||
|
||||
best_fitness = problem.get_maximize()*best_fitness
|
||||
|
||||
if curve:
|
||||
return best_state, best_fitness, np.asarray(fitness_curve)
|
||||
|
||||
return best_state, best_fitness
|
||||
|
||||
|
||||
def random_hill_climb(problem, max_attempts=10, max_iters=np.inf, restarts=0,
|
||||
init_state=None, curve=False, random_state=None):
|
||||
|
||||
if (not isinstance(max_attempts, int) and not max_attempts.is_integer()) \
|
||||
or (max_attempts < 0):
|
||||
raise Exception("""max_attempts must be a positive integer.""")
|
||||
|
||||
if (not isinstance(max_iters, int) and max_iters != np.inf
|
||||
and not max_iters.is_integer()) or (max_iters < 0):
|
||||
raise Exception("""max_iters must be a positive integer.""")
|
||||
|
||||
if (not isinstance(restarts, int) and not restarts.is_integer()) \
|
||||
or (restarts < 0):
|
||||
raise Exception("""restarts must be a positive integer.""")
|
||||
|
||||
if init_state is not None and len(init_state) != problem.get_length():
|
||||
raise Exception("""init_state must have same length as problem.""")
|
||||
|
||||
# Set random seed
|
||||
if isinstance(random_state, int) and random_state > 0:
|
||||
np.random.seed(random_state)
|
||||
|
||||
best_fitness = -1*np.inf
|
||||
best_state = None
|
||||
|
||||
if curve:
|
||||
fitness_curve = []
|
||||
|
||||
for _ in range(restarts + 1):
|
||||
# Initialize optimization problem and attempts counter
|
||||
if init_state is None:
|
||||
problem.reset()
|
||||
else:
|
||||
problem.set_state(init_state)
|
||||
|
||||
attempts = 0
|
||||
iters = 0
|
||||
|
||||
while (attempts < max_attempts) and (iters < max_iters):
|
||||
iters += 1
|
||||
|
||||
# Find random neighbor and evaluate fitness
|
||||
next_state = problem.random_neighbor()
|
||||
next_fitness = problem.eval_fitness(next_state)
|
||||
|
||||
# If best neighbor is an improvement,
|
||||
# move to that state and reset attempts counter
|
||||
if next_fitness > problem.get_fitness():
|
||||
problem.set_state(next_state)
|
||||
attempts = 0
|
||||
|
||||
else:
|
||||
attempts += 1
|
||||
|
||||
if curve:
|
||||
fitness_curve.append(problem.get_fitness())
|
||||
|
||||
# Update best state and best fitness
|
||||
if problem.get_fitness() > best_fitness:
|
||||
best_fitness = problem.get_fitness()
|
||||
best_state = problem.get_state()
|
||||
|
||||
best_fitness = problem.get_maximize()*best_fitness
|
||||
|
||||
if curve:
|
||||
return best_state, best_fitness, np.asarray(fitness_curve)
|
||||
|
||||
return best_state, best_fitness
|
||||
|
||||
|
||||
def simulated_annealing(problem, schedule=GeomDecay(), max_attempts=10,
|
||||
max_iters=np.inf, init_state=None, curve=False,
|
||||
random_state=None):
|
||||
|
||||
if (not isinstance(max_attempts, int) and not max_attempts.is_integer()) \
|
||||
or (max_attempts < 0):
|
||||
raise Exception("""max_attempts must be a positive integer.""")
|
||||
|
||||
if (not isinstance(max_iters, int) and max_iters != np.inf
|
||||
and not max_iters.is_integer()) or (max_iters < 0):
|
||||
raise Exception("""max_iters must be a positive integer.""")
|
||||
|
||||
if init_state is not None and len(init_state) != problem.get_length():
|
||||
raise Exception("""init_state must have same length as problem.""")
|
||||
|
||||
# Set random seed
|
||||
if isinstance(random_state, int) and random_state > 0:
|
||||
np.random.seed(random_state)
|
||||
|
||||
# Initialize problem, time and attempts counter
|
||||
if init_state is None:
|
||||
problem.reset()
|
||||
else:
|
||||
problem.set_state(init_state)
|
||||
|
||||
if curve:
|
||||
fitness_curve = []
|
||||
|
||||
attempts = 0
|
||||
iters = 0
|
||||
|
||||
while (attempts < max_attempts) and (iters < max_iters):
|
||||
temp = schedule.evaluate(iters)
|
||||
iters += 1
|
||||
|
||||
if temp == 0:
|
||||
break
|
||||
|
||||
else:
|
||||
# Find random neighbor and evaluate fitness
|
||||
next_state = problem.random_neighbor()
|
||||
next_fitness = problem.eval_fitness(next_state)
|
||||
|
||||
# Calculate delta E and change prob
|
||||
delta_e = next_fitness - problem.get_fitness()
|
||||
prob = np.exp(delta_e/temp)
|
||||
|
||||
# If best neighbor is an improvement or random value is less
|
||||
# than prob, move to that state and reset attempts counter
|
||||
if (delta_e > 0) or (np.random.uniform() < prob):
|
||||
problem.set_state(next_state)
|
||||
attempts = 0
|
||||
|
||||
else:
|
||||
attempts += 1
|
||||
|
||||
if curve:
|
||||
fitness_curve.append(problem.get_fitness())
|
||||
|
||||
best_fitness = problem.get_maximize()*problem.get_fitness()
|
||||
best_state = problem.get_state()
|
||||
|
||||
if curve:
|
||||
return best_state, best_fitness, np.asarray(fitness_curve)
|
||||
|
||||
return best_state, best_fitness
|
||||
|
||||
|
||||
def genetic_alg(problem, pop_size=200, mutation_prob=0.1, max_attempts=10,
|
||||
max_iters=np.inf, curve=False, random_state=None):
|
||||
|
||||
if pop_size < 0:
|
||||
raise Exception("""pop_size must be a positive integer.""")
|
||||
elif not isinstance(pop_size, int):
|
||||
if pop_size.is_integer():
|
||||
pop_size = int(pop_size)
|
||||
else:
|
||||
raise Exception("""pop_size must be a positive integer.""")
|
||||
|
||||
if (mutation_prob < 0) or (mutation_prob > 1):
|
||||
raise Exception("""mutation_prob must be between 0 and 1.""")
|
||||
|
||||
if (not isinstance(max_attempts, int) and not max_attempts.is_integer()) \
|
||||
or (max_attempts < 0):
|
||||
raise Exception("""max_attempts must be a positive integer.""")
|
||||
|
||||
if (not isinstance(max_iters, int) and max_iters != np.inf
|
||||
and not max_iters.is_integer()) or (max_iters < 0):
|
||||
raise Exception("""max_iters must be a positive integer.""")
|
||||
|
||||
# Set random seed
|
||||
if isinstance(random_state, int) and random_state > 0:
|
||||
np.random.seed(random_state)
|
||||
|
||||
if curve:
|
||||
fitness_curve = []
|
||||
|
||||
# Initialize problem, population and attempts counter
|
||||
problem.reset()
|
||||
problem.random_pop(pop_size)
|
||||
attempts = 0
|
||||
iters = 0
|
||||
|
||||
while (attempts < max_attempts) and (iters < max_iters):
|
||||
iters += 1
|
||||
|
||||
# Calculate breeding probabilities
|
||||
problem.eval_mate_probs()
|
||||
|
||||
# Create next generation of population
|
||||
next_gen = []
|
||||
|
||||
for _ in range(pop_size):
|
||||
# Select parents
|
||||
selected = np.random.choice(pop_size, size=2,
|
||||
p=problem.get_mate_probs())
|
||||
parent_1 = problem.get_population()[selected[0]]
|
||||
parent_2 = problem.get_population()[selected[1]]
|
||||
|
||||
# Create offspring
|
||||
child = problem.reproduce(parent_1, parent_2, mutation_prob)
|
||||
next_gen.append(child)
|
||||
|
||||
next_gen = np.array(next_gen)
|
||||
problem.set_population(next_gen)
|
||||
|
||||
next_state = problem.best_child()
|
||||
next_fitness = problem.eval_fitness(next_state)
|
||||
|
||||
# If best child is an improvement,
|
||||
# move to that state and reset attempts counter
|
||||
if next_fitness > problem.get_fitness():
|
||||
problem.set_state(next_state)
|
||||
attempts = 0
|
||||
|
||||
else:
|
||||
attempts += 1
|
||||
|
||||
if curve:
|
||||
fitness_curve.append(problem.get_fitness())
|
||||
|
||||
best_fitness = problem.get_maximize()*problem.get_fitness()
|
||||
best_state = problem.get_state()
|
||||
|
||||
if curve:
|
||||
return best_state, best_fitness, np.asarray(fitness_curve)
|
||||
|
||||
return best_state, best_fitness
|
||||
|
||||
|
||||
def mimic(problem, pop_size=200, keep_pct=0.2, max_attempts=10,
|
||||
max_iters=np.inf, curve=False, random_state=None, fast_mimic=False):
|
||||
"""Use MIMIC to find the optimum for a given optimization problem.
|
||||
|
||||
"""
|
||||
if problem.get_prob_type() == 'continuous':
|
||||
raise Exception("""problem type must be discrete or tsp.""")
|
||||
|
||||
if pop_size < 0:
|
||||
raise Exception("""pop_size must be a positive integer.""")
|
||||
elif not isinstance(pop_size, int):
|
||||
if pop_size.is_integer():
|
||||
pop_size = int(pop_size)
|
||||
else:
|
||||
raise Exception("""pop_size must be a positive integer.""")
|
||||
|
||||
if (keep_pct < 0) or (keep_pct > 1):
|
||||
raise Exception("""keep_pct must be between 0 and 1.""")
|
||||
|
||||
if (not isinstance(max_attempts, int) and not max_attempts.is_integer()) \
|
||||
or (max_attempts < 0):
|
||||
raise Exception("""max_attempts must be a positive integer.""")
|
||||
|
||||
if (not isinstance(max_iters, int) and max_iters != np.inf
|
||||
and not max_iters.is_integer()) or (max_iters < 0):
|
||||
raise Exception("""max_iters must be a positive integer.""")
|
||||
|
||||
# Set random seed
|
||||
if isinstance(random_state, int) and random_state > 0:
|
||||
np.random.seed(random_state)
|
||||
|
||||
if curve:
|
||||
fitness_curve = []
|
||||
|
||||
if fast_mimic not in (True, False):
|
||||
raise Exception("""fast_mimic mode must be a boolean.""")
|
||||
else:
|
||||
problem.mimic_speed = fast_mimic
|
||||
|
||||
# Initialize problem, population and attempts counter
|
||||
problem.reset()
|
||||
problem.random_pop(pop_size)
|
||||
attempts = 0
|
||||
iters = 0
|
||||
|
||||
while (attempts < max_attempts) and (iters < max_iters):
|
||||
iters += 1
|
||||
|
||||
# Get top n percent of population
|
||||
problem.find_top_pct(keep_pct)
|
||||
|
||||
# Update probability estimates
|
||||
problem.eval_node_probs()
|
||||
|
||||
# Generate new sample
|
||||
new_sample = problem.sample_pop(pop_size)
|
||||
problem.set_population(new_sample)
|
||||
|
||||
next_state = problem.best_child()
|
||||
|
||||
next_fitness = problem.eval_fitness(next_state)
|
||||
|
||||
# If best child is an improvement,
|
||||
# move to that state and reset attempts counter
|
||||
if next_fitness > problem.get_fitness():
|
||||
problem.set_state(next_state)
|
||||
attempts = 0
|
||||
|
||||
else:
|
||||
attempts += 1
|
||||
|
||||
if curve:
|
||||
fitness_curve.append(problem.get_fitness())
|
||||
|
||||
best_fitness = problem.get_maximize()*problem.get_fitness()
|
||||
best_state = problem.get_state().astype(int)
|
||||
|
||||
if curve:
|
||||
return best_state, best_fitness, np.asarray(fitness_curve)
|
||||
|
||||
return best_state, best_fitness
|
52
bfs.py
@ -1,52 +0,0 @@
|
||||
from collections import deque
|
||||
|
||||
from stan_nastepnik import *
|
||||
|
||||
|
||||
def goaltest(stan: Stan, cel: Stan):
|
||||
if stan.poleStartoweGorne.wiersz != cel.poleStartoweGorne.wiersz:
|
||||
return False
|
||||
elif stan.poleStartoweGorne.kolumna != cel.poleStartoweGorne.kolumna:
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
def stan_w_liscie_nastepnikow(stan: Stan, lista_nastepnikow):
|
||||
for i in lista_nastepnikow:
|
||||
if i.stan.kierunek != stan.kierunek:
|
||||
continue
|
||||
elif i.stan.poleStartoweGorne.wiersz != stan.poleStartoweGorne.wiersz:
|
||||
continue
|
||||
elif i.stan.poleStartoweGorne.kolumna != stan.poleStartoweGorne.kolumna:
|
||||
continue
|
||||
else:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def stos_akcji(stan_koncowy: Nastepnik):
|
||||
stos = deque()
|
||||
while stan_koncowy.poprzednik is not None:
|
||||
stos.append(stan_koncowy.akcja)
|
||||
stan_koncowy = stan_koncowy.poprzednik
|
||||
return stos
|
||||
|
||||
|
||||
def graphsearch(istate: Stan, cel: Stan):
|
||||
fringe = deque()
|
||||
explored = []
|
||||
fringe.append(Nastepnik(None, istate, None))
|
||||
while fringe:
|
||||
# for i in fringe:
|
||||
# print("F",i.stan.kierunek,i.stan.poleStartoweGorne.wiersz,i.stan.poleStartoweGorne.kolumna,end=" ")
|
||||
# print()
|
||||
element: Nastepnik = fringe.popleft()
|
||||
if goaltest(element.stan, cel):
|
||||
return stos_akcji(element)
|
||||
explored.append(element)
|
||||
for nastepnik in succ(element):
|
||||
if not stan_w_liscie_nastepnikow(nastepnik.stan, fringe) and not stan_w_liscie_nastepnikow(nastepnik.stan,
|
||||
explored):
|
||||
fringe.append(nastepnik)
|
||||
return False
|
201
dataset.csv
@ -1,201 +0,0 @@
|
||||
plec;wiek;czas_w_pom;temp_w_pom;poziom_kurzu;poziom_oswietlenia;niebezp_towary;decyzja
|
||||
2;54;40;0;60;59;0;1
|
||||
2;55;40;0;60;59;0;1
|
||||
2;25;40;0;60;59;0;1
|
||||
2;60;40;0;60;59;0;1
|
||||
2;25;50;0;60;59;0;1
|
||||
2;55;50;0;60;59;0;1
|
||||
2;54;40;0;87;32;0;1
|
||||
2;55;40;0;87;32;0;1
|
||||
2;19;51;0;71;48;0;1
|
||||
2;68;51;0;62;48;0;1
|
||||
2;54;40;0;59;59;1;1
|
||||
2;55;40;0;60;60;1;1
|
||||
2;25;40;0;59;59;1;1
|
||||
2;60;40;0;60;60;1;1
|
||||
2;25;50;0;45;45;1;1
|
||||
2;55;50;0;71;71;1;1
|
||||
2;54;40;0;33;33;1;1
|
||||
2;55;40;0;87;87;1;1
|
||||
2;19;51;0;50;50;1;1
|
||||
2;68;51;0;62;62;1;1
|
||||
2;54;40;0;59;59;0;0
|
||||
2;55;40;0;60;60;0;0
|
||||
2;25;40;0;59;59;0;0
|
||||
2;60;40;0;60;60;0;0
|
||||
2;25;50;0;45;45;0;0
|
||||
2;55;50;0;71;71;0;0
|
||||
2;54;40;0;33;33;0;0
|
||||
2;55;40;0;87;87;0;0
|
||||
2;19;51;0;50;50;0;0
|
||||
2;68;51;0;62;62;0;0
|
||||
2;54;40;0;59;60;0;0
|
||||
2;55;40;0;59;60;0;0
|
||||
2;25;40;0;59;60;0;0
|
||||
2;60;40;0;59;60;0;0
|
||||
2;25;50;0;59;60;0;0
|
||||
2;55;50;0;59;60;0;0
|
||||
2;54;40;0;32;87;0;0
|
||||
2;55;40;0;32;87;0;0
|
||||
2;19;51;0;45;71;0;0
|
||||
2;68;51;0;47;62;0;0
|
||||
1;54;40;0;59;59;0;1
|
||||
1;55;40;0;60;60;0;1
|
||||
1;25;40;0;59;59;0;1
|
||||
1;60;40;0;60;60;0;1
|
||||
1;25;50;0;45;45;0;1
|
||||
1;55;50;0;71;71;0;1
|
||||
1;54;40;0;33;33;0;1
|
||||
1;55;40;0;87;87;0;1
|
||||
1;19;51;0;50;50;0;1
|
||||
1;68;51;0;62;62;0;1
|
||||
2;54;39;0;60;59;1;1
|
||||
2;55;39;0;60;59;1;1
|
||||
2;25;39;0;60;59;1;1
|
||||
2;60;39;0;60;59;1;1
|
||||
2;25;20;0;60;59;1;1
|
||||
2;55;20;0;60;59;1;1
|
||||
2;54;39;0;87;32;1;1
|
||||
2;55;39;0;87;32;1;1
|
||||
2;19;24;0;71;48;1;1
|
||||
2;68;24;0;62;48;1;1
|
||||
2;54;39;0;60;60;1;1
|
||||
2;55;39;0;59;59;1;1
|
||||
2;25;39;0;60;60;1;1
|
||||
2;60;39;0;59;59;1;1
|
||||
2;25;20;0;71;71;1;1
|
||||
2;55;20;0;45;45;1;1
|
||||
2;54;39;0;87;87;1;1
|
||||
2;55;39;0;33;33;1;1
|
||||
2;19;24;0;62;62;1;1
|
||||
2;68;24;0;50;50;1;1
|
||||
2;54;39;0;59;59;1;0
|
||||
2;55;39;0;60;60;1;0
|
||||
2;25;39;0;59;59;1;0
|
||||
2;60;39;0;60;60;1;0
|
||||
2;25;20;0;45;45;1;0
|
||||
2;55;20;0;71;71;1;0
|
||||
2;54;39;0;33;33;1;0
|
||||
2;55;39;0;87;87;1;0
|
||||
2;19;24;0;50;50;1;0
|
||||
2;68;24;0;62;62;1;0
|
||||
2;54;39;0;59;60;1;0
|
||||
2;55;39;0;59;60;1;0
|
||||
2;25;39;0;59;60;1;0
|
||||
2;60;39;0;59;60;1;0
|
||||
2;25;20;0;59;60;1;0
|
||||
2;55;20;0;59;60;1;0
|
||||
2;54;39;0;32;87;1;0
|
||||
2;55;39;0;32;87;1;0
|
||||
2;19;24;0;45;71;1;0
|
||||
2;68;24;0;47;62;1;0
|
||||
1;54;39;0;59;59;1;1
|
||||
1;55;39;0;60;60;1;1
|
||||
1;25;39;0;59;59;1;1
|
||||
1;60;39;0;60;60;1;1
|
||||
1;25;20;0;45;45;1;1
|
||||
1;55;20;0;71;71;1;1
|
||||
1;54;39;0;33;33;1;1
|
||||
1;55;39;0;87;87;1;1
|
||||
1;19;24;0;50;50;1;1
|
||||
1;68;24;0;62;62;1;1
|
||||
1;54;39;0;60;59;0;0
|
||||
1;55;39;0;60;59;0;0
|
||||
1;25;39;0;60;59;0;0
|
||||
1;60;39;0;60;59;0;0
|
||||
1;25;20;0;60;59;0;0
|
||||
1;55;20;0;60;59;0;0
|
||||
1;54;39;0;87;32;0;0
|
||||
1;55;39;0;87;32;0;0
|
||||
1;19;24;0;71;48;0;0
|
||||
1;68;24;0;62;48;0;0
|
||||
2;54;40;1;60;59;1;1
|
||||
2;55;40;1;60;59;1;1
|
||||
2;25;40;1;60;59;1;1
|
||||
2;60;40;1;60;59;1;1
|
||||
2;25;50;1;60;59;1;1
|
||||
2;55;50;1;60;59;1;1
|
||||
2;54;40;1;87;32;1;1
|
||||
2;55;40;1;87;32;1;1
|
||||
2;19;51;1;71;48;1;1
|
||||
2;68;51;1;62;48;1;1
|
||||
2;54;40;1;60;60;1;1
|
||||
2;55;40;1;59;59;1;1
|
||||
2;25;40;1;60;60;1;1
|
||||
2;60;40;1;59;59;1;1
|
||||
2;25;50;1;71;71;1;1
|
||||
2;55;50;1;45;45;1;1
|
||||
2;54;40;1;87;87;1;1
|
||||
2;55;40;1;33;33;1;1
|
||||
2;19;51;1;62;62;1;1
|
||||
2;68;51;1;50;50;1;1
|
||||
2;54;40;1;59;59;1;0
|
||||
2;55;40;1;60;60;1;0
|
||||
2;25;40;1;59;59;1;0
|
||||
2;60;40;1;60;60;1;0
|
||||
2;25;50;1;45;45;1;0
|
||||
2;55;50;1;71;71;1;0
|
||||
2;54;40;1;33;33;1;0
|
||||
2;55;40;1;87;87;1;0
|
||||
2;19;51;1;50;50;1;0
|
||||
2;68;51;1;62;62;1;0
|
||||
1;54;40;1;59;59;1;1
|
||||
1;55;40;1;60;60;1;1
|
||||
1;25;40;1;59;59;1;1
|
||||
1;60;40;1;60;60;1;1
|
||||
1;25;50;1;45;45;1;1
|
||||
1;55;50;1;71;71;1;1
|
||||
1;54;40;1;33;33;1;1
|
||||
1;55;40;1;87;87;1;1
|
||||
1;19;51;1;50;50;1;1
|
||||
1;68;51;1;62;62;1;1
|
||||
1;54;40;1;59;60;1;1
|
||||
1;55;40;1;59;60;1;1
|
||||
1;25;40;1;59;60;1;1
|
||||
1;60;40;1;59;60;1;1
|
||||
1;25;50;1;59;60;1;1
|
||||
1;55;50;1;59;60;1;1
|
||||
1;54;40;1;32;87;1;1
|
||||
1;55;40;1;32;87;1;1
|
||||
1;19;51;1;45;71;1;1
|
||||
1;68;51;1;47;62;1;1
|
||||
1;54;40;1;60;59;0;0
|
||||
1;55;40;1;60;59;0;0
|
||||
1;25;40;1;60;59;0;0
|
||||
1;60;40;1;60;59;0;0
|
||||
1;25;50;1;60;59;0;0
|
||||
1;55;50;1;60;59;0;0
|
||||
1;54;40;1;87;32;0;0
|
||||
1;55;40;1;87;32;0;0
|
||||
1;19;51;1;71;48;0;0
|
||||
1;68;51;1;62;48;0;0
|
||||
2;54;39;1;60;59;1;0
|
||||
2;55;39;1;60;59;1;0
|
||||
2;25;39;1;60;59;1;0
|
||||
2;60;39;1;60;59;1;0
|
||||
2;25;20;1;60;59;1;0
|
||||
2;55;20;1;60;59;1;0
|
||||
2;54;39;1;87;32;1;0
|
||||
2;55;39;1;87;32;1;0
|
||||
2;19;24;1;71;48;1;0
|
||||
2;68;24;1;62;48;1;0
|
||||
1;54;39;1;60;59;1;0
|
||||
1;55;39;1;60;59;1;0
|
||||
1;25;39;1;60;59;1;0
|
||||
1;60;39;1;60;59;1;0
|
||||
1;25;20;1;60;59;1;0
|
||||
1;55;20;1;60;59;1;0
|
||||
1;54;39;1;87;32;1;0
|
||||
1;55;39;1;87;32;1;0
|
||||
1;19;24;1;71;48;1;0
|
||||
1;68;24;1;62;48;1;0
|
||||
1;54;19;0;60;59;1;0
|
||||
1;55;19;0;60;59;1;0
|
||||
1;25;19;0;60;59;1;0
|
||||
1;60;5;0;60;59;1;0
|
||||
1;25;5;0;60;59;1;0
|
||||
1;55;10;0;60;59;1;0
|
||||
1;54;18;0;87;32;1;0
|
||||
1;55;18;0;87;32;1;0
|
||||
1;19;3;0;71;48;1;0
|
||||
1;68;12;0;62;48;1;0
|
|
Before Width: | Height: | Size: 195 B |
Before Width: | Height: | Size: 282 B |
Before Width: | Height: | Size: 245 B |
Before Width: | Height: | Size: 348 B |
Before Width: | Height: | Size: 207 B |
Before Width: | Height: | Size: 258 B |
Before Width: | Height: | Size: 234 B |
Before Width: | Height: | Size: 166 B |
Before Width: | Height: | Size: 218 B |
Before Width: | Height: | Size: 236 B |
Before Width: | Height: | Size: 250 B |
Before Width: | Height: | Size: 254 B |
Before Width: | Height: | Size: 247 B |
Before Width: | Height: | Size: 281 B |
Before Width: | Height: | Size: 204 B |
Before Width: | Height: | Size: 192 B |
Before Width: | Height: | Size: 202 B |
Before Width: | Height: | Size: 207 B |
Before Width: | Height: | Size: 265 B |
BIN
drzewo.png
Before Width: | Height: | Size: 160 KiB |
@ -3,69 +3,27 @@ from enum import Enum
|
||||
from stale import *
|
||||
|
||||
|
||||
class Kierunek(Enum):
|
||||
POLNOC = 0
|
||||
POLUDNIE = 1
|
||||
ZACHOD = 2
|
||||
WSCHOD = 3
|
||||
|
||||
def kierunekNaLewo(self):
|
||||
if self == Kierunek.POLNOC:
|
||||
return Kierunek.ZACHOD
|
||||
elif self == Kierunek.POLUDNIE:
|
||||
return Kierunek.WSCHOD
|
||||
elif self == Kierunek.ZACHOD:
|
||||
return Kierunek.POLUDNIE
|
||||
elif self == Kierunek.WSCHOD:
|
||||
return Kierunek.POLNOC
|
||||
|
||||
def kierunekNaPrawo(self):
|
||||
if self == Kierunek.POLNOC:
|
||||
return Kierunek.WSCHOD
|
||||
elif self == Kierunek.POLUDNIE:
|
||||
return Kierunek.ZACHOD
|
||||
elif self == Kierunek.ZACHOD:
|
||||
return Kierunek.POLNOC
|
||||
elif self == Kierunek.WSCHOD:
|
||||
return Kierunek.POLUDNIE
|
||||
|
||||
|
||||
class ZawartoscPola(Enum):
|
||||
PUSTE = 0
|
||||
SCIANA = 1
|
||||
CEL = 2
|
||||
DYWAN = 3
|
||||
KALUZA = 4
|
||||
SCIANA2 = 5
|
||||
OSOBA = 6
|
||||
SCIANA2 = 2
|
||||
SYGNALIZATOR_CZERWONY = 3
|
||||
SYGNALIZATOR_ZOLTY = 4
|
||||
SYGNALIZATOR_ZIELONY = 5
|
||||
|
||||
|
||||
class Swiatlo(Enum):
|
||||
CZERWONE = 0
|
||||
CZERWONE_Z_ZOLTYM = 1
|
||||
ZIELONE = 2
|
||||
ZOLTE = 3
|
||||
|
||||
|
||||
ZawartoscPolaNaKolorPola = {
|
||||
ZawartoscPola.PUSTE: BIALY,
|
||||
ZawartoscPola.SCIANA: CIEMNY_BRAZOWY1,
|
||||
ZawartoscPola.CEL: PACZKA,
|
||||
ZawartoscPola.DYWAN: DYWAN,
|
||||
ZawartoscPola.KALUZA: KALUZA,
|
||||
ZawartoscPola.SCIANA2: SZARY1,
|
||||
ZawartoscPola.OSOBA: IKONA
|
||||
}
|
||||
|
||||
ZawartoscPolaNaKosztObrotu = {
|
||||
ZawartoscPola.PUSTE: 1,
|
||||
ZawartoscPola.SCIANA: None,
|
||||
ZawartoscPola.CEL: 1,
|
||||
ZawartoscPola.DYWAN: 5,
|
||||
ZawartoscPola.KALUZA: 3,
|
||||
ZawartoscPola.SCIANA2: None,
|
||||
ZawartoscPola.OSOBA: None
|
||||
}
|
||||
|
||||
ZawartoscPolaNaKosztWjechania = {
|
||||
ZawartoscPola.PUSTE: 2,
|
||||
ZawartoscPola.SCIANA: None,
|
||||
ZawartoscPola.CEL: 2,
|
||||
ZawartoscPola.DYWAN: 5,
|
||||
ZawartoscPola.KALUZA: 35,
|
||||
ZawartoscPola.SCIANA2: None,
|
||||
ZawartoscPola.OSOBA: None
|
||||
ZawartoscPola.PUSTE: CZARNY,
|
||||
ZawartoscPola.SCIANA: JASNOSZARY,
|
||||
ZawartoscPola.SCIANA2: SZARY,
|
||||
ZawartoscPola.SYGNALIZATOR_CZERWONY: CZERWONY,
|
||||
ZawartoscPola.SYGNALIZATOR_ZOLTY: ZOLTY,
|
||||
ZawartoscPola.SYGNALIZATOR_ZIELONY: ZIELONY
|
||||
}
|
||||
|
@ -1,7 +0,0 @@
|
||||
class Etykieta:
|
||||
def __init__(self, nazwa_paczki, producent, numer_paczki, cecha_paczki, data_wysylki):
|
||||
self.nazwa_paczki = nazwa_paczki
|
||||
self.producent = producent
|
||||
self.numer_paczki = numer_paczki
|
||||
self.cecha_paczki = cecha_paczki
|
||||
self.data_wysylki = data_wysylki
|
@ -1,14 +0,0 @@
|
||||
import mlrose
|
||||
|
||||
def best_route (lista_paczek):
|
||||
|
||||
koordynaty_paczek = mlrose.TravellingSales(coords = lista_paczek)
|
||||
|
||||
#length oznacza liczbe paczek w naszej liscie
|
||||
problem_fit = mlrose.TSPOpt(length = 5, fitness_fn = koordynaty_paczek, maximize = False)
|
||||
|
||||
# Znalesc najlepsza paczke za pomocy algorytmu genetycznego
|
||||
best_state, best_fitness = mlrose.genetic_alg(problem_fit, mutation_prob = 0.2, max_attempts = 200, random_state = 2)
|
||||
|
||||
print('Najlepsza sciezka: ', best_state)
|
||||
return best_state
|
103
krata.py
@ -1,103 +0,0 @@
|
||||
import pygame
|
||||
|
||||
from enumy_i_slowniki import *
|
||||
from obserwacja import *
|
||||
from stale import *
|
||||
|
||||
|
||||
class PoleKraty:
|
||||
gora: any
|
||||
start: any
|
||||
|
||||
def __init__(self, krata, wiersz, kolumna):
|
||||
self.krata = krata
|
||||
self.bok = self.krata.bokPola
|
||||
self._wiersz = wiersz
|
||||
self._kolumna = kolumna
|
||||
self.okreslGore()
|
||||
self.okreslStart()
|
||||
|
||||
def okreslGore(self):
|
||||
self.gora = (self.bok + self.krata.odstepMiedzyPolami) * self.wiersz + self.krata.odstepMiedzyPolami
|
||||
|
||||
def okreslStart(self):
|
||||
self.start = (self.bok + self.krata.odstepMiedzyPolami) * self.kolumna + self.krata.odstepMiedzyPolami
|
||||
|
||||
def getWiersz(self):
|
||||
return self._wiersz
|
||||
|
||||
def setWiersz(self, x):
|
||||
self._wiersz = x
|
||||
self.okreslGore()
|
||||
|
||||
def getKolumna(self):
|
||||
return self._kolumna
|
||||
|
||||
def setKolumna(self, x):
|
||||
self._kolumna = x
|
||||
self.okreslStart()
|
||||
|
||||
wiersz = property(getWiersz, setWiersz)
|
||||
kolumna = property(getKolumna, setKolumna)
|
||||
|
||||
def skopiuj(self):
|
||||
return PoleKraty(self.krata, self.wiersz, self.kolumna)
|
||||
|
||||
|
||||
class Krata(Obserwowany):
|
||||
krata: []
|
||||
|
||||
def __init__(self, okno):
|
||||
self.okno = okno
|
||||
self.liczbaPolPoziomo = LICZBA_POL_W_POZIOMIE
|
||||
self.liczbaPolPionowo = LICZBA_POL_W_PIONIE
|
||||
self.bokPola = BOK_POLA
|
||||
self.odstepMiedzyPolami = ODSTEP_MIEDZY_POLAMI
|
||||
self.utworzPustaKrate()
|
||||
self.agent = None
|
||||
|
||||
def utworzPustaKrate(self):
|
||||
self.krata = []
|
||||
for wiersz in range(self.liczbaPolPionowo):
|
||||
self.krata.append([])
|
||||
for kolumna in range(self.liczbaPolPoziomo):
|
||||
zawartosc_pola = ZawartoscPola.PUSTE
|
||||
self.krata[wiersz].append(zawartosc_pola)
|
||||
|
||||
def narysujKrate(self):
|
||||
self.okno.fill(SZARY1)
|
||||
for wiersz in range(self.liczbaPolPionowo):
|
||||
for kolumna in range(self.liczbaPolPoziomo):
|
||||
start = (self.odstepMiedzyPolami + self.bokPola) * kolumna + self.odstepMiedzyPolami
|
||||
gora = (self.odstepMiedzyPolami + self.bokPola) * wiersz + self.odstepMiedzyPolami
|
||||
kolor_pola = ZawartoscPolaNaKolorPola[self.krata[wiersz][kolumna]]
|
||||
if kolor_pola == IKONA:
|
||||
osoba_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'osoba2.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
self.okno.blit(osoba_ikona, [start, gora, self.bokPola, self.bokPola])
|
||||
elif kolor_pola == KALUZA:
|
||||
osoba_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'kaluza.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
self.okno.blit(osoba_ikona, [start, gora, self.bokPola, self.bokPola])
|
||||
elif kolor_pola == DYWAN:
|
||||
osoba_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'dywan.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
self.okno.blit(osoba_ikona, [start, gora, self.bokPola, self.bokPola])
|
||||
elif kolor_pola == PACZKA:
|
||||
osoba_ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'paczka.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
self.okno.blit(osoba_ikona, [start, gora, self.bokPola, self.bokPola])
|
||||
else:
|
||||
pygame.draw.rect(self.okno, kolor_pola, [start, gora, self.bokPola, self.bokPola])
|
||||
|
||||
def narysujKrateAlternatywnie(self):
|
||||
self.okno.fill(SZARY1)
|
||||
for i in range(LICZBA_POL_W_POZIOMIE + 1):
|
||||
new_height = i * (BOK_POLA + ODSTEP_MIEDZY_POLAMI)
|
||||
new_width = i * (BOK_POLA + ODSTEP_MIEDZY_POLAMI)
|
||||
pygame.draw.line(self.okno, CZARNY, (0, new_height), (SZEROKOSC_OKNA, new_height), ODSTEP_MIEDZY_POLAMI)
|
||||
pygame.draw.line(self.okno, CZARNY, (new_width, 0), (new_width, WYSOKOSC_OKNA), ODSTEP_MIEDZY_POLAMI)
|
||||
|
||||
def powiadomObserwatorow(self):
|
||||
for obserwator in self.obserwatorzy:
|
||||
obserwator.odbierzPowiadomienie(self)
|
578
main.py
@ -1,263 +1,369 @@
|
||||
import ctypes
|
||||
import os
|
||||
import random
|
||||
import threading
|
||||
|
||||
import pygame.transform
|
||||
import pygame
|
||||
|
||||
import szafka2
|
||||
from agent import *
|
||||
from neural_network import *
|
||||
from okno import *
|
||||
from ramy_czyli_wiedza_agenta import *
|
||||
from rescue import *
|
||||
from genetyczny import *
|
||||
from enumy_i_slowniki import *
|
||||
|
||||
# aby działalo w oknie + rozdzielczość ekranu
|
||||
# ctypes.windll.shcore.SetProcessDpiAwareness(1)
|
||||
|
||||
okno_pygame = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
|
||||
pygame.display.set_caption("Okno1")
|
||||
krata_magazynu = Krata(okno_pygame)
|
||||
Pomieszczenie = Pomieszczenie(WarunkiPowietrza(0, 0), 0)
|
||||
#
|
||||
okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
|
||||
#
|
||||
droga_A = [[False, w, 7] for w in range(LICZBA_POL_W_PIONIE)]
|
||||
swiatlo_A = Swiatlo.CZERWONE
|
||||
pole_postojowe_A = (9, 7)
|
||||
sygnalizator_A = ((10, 9), (11, 9), (12, 9))
|
||||
indeks_petli_A = None
|
||||
for i in range(len(droga_A)):
|
||||
x = droga_A[i]
|
||||
if x[1] == pole_postojowe_A[0] and x[2] == pole_postojowe_A[1]:
|
||||
indeks_petli_A = i
|
||||
#
|
||||
droga_B = [[False, w, 7] for w in range(0, 7)] + [[False, 7, k] for k in range(7, LICZBA_POL_W_POZIOMIE)]
|
||||
swiatlo_B = Swiatlo.ZIELONE
|
||||
pole_postojowe_B = (7, 8)
|
||||
sygnalizator_B = ((3, 10), (4, 10), (5, 10))
|
||||
indeks_petli_B = None
|
||||
for i in range(len(droga_B)):
|
||||
x = droga_B[i]
|
||||
if x[1] == pole_postojowe_B[0] and x[2] == pole_postojowe_B[1]:
|
||||
indeks_petli_B = i
|
||||
#
|
||||
krata = [[_ for _ in range(LICZBA_POL_W_POZIOMIE)] for _ in range(LICZBA_POL_W_PIONIE)]
|
||||
#
|
||||
for w in range(LICZBA_POL_W_PIONIE):
|
||||
for k in range(LICZBA_POL_W_POZIOMIE):
|
||||
krata[w][k] = ZawartoscPola.SCIANA2
|
||||
#
|
||||
for w in range(LICZBA_POL_W_PIONIE):
|
||||
krata[w][5] = ZawartoscPola.SCIANA
|
||||
krata[w][6] = ZawartoscPola.PUSTE
|
||||
krata[w][7] = ZawartoscPola.PUSTE
|
||||
krata[w][8] = ZawartoscPola.SCIANA
|
||||
#
|
||||
krata[7][8] = ZawartoscPola.PUSTE
|
||||
krata[8][8] = ZawartoscPola.PUSTE
|
||||
#
|
||||
for w in [7, 8]:
|
||||
for k in range(8, LICZBA_POL_W_POZIOMIE):
|
||||
krata[w][k] = ZawartoscPola.PUSTE
|
||||
#
|
||||
for k in range(8, LICZBA_POL_W_POZIOMIE):
|
||||
krata[6][k] = ZawartoscPola.SCIANA
|
||||
for k in range(8, LICZBA_POL_W_POZIOMIE):
|
||||
krata[9][k] = ZawartoscPola.SCIANA
|
||||
|
||||
|
||||
def dodaj_agenta():
|
||||
# pole_lewe_gorne = PoleKraty(krata_magazynu, random.randint(0, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH),
|
||||
# random.randint(0, LICZBA_POL_W_POZIOMIE - BOK_AGENTA1_W_POLACH))
|
||||
# pole_lewe_gorne = PoleKraty(krata_magazynu, LICZBA_POL_W_PIONIE - BOK_AGENTA1_W_POLACH, int(LICZBA_POL_W_POZIOMIE / 2))
|
||||
pole_lewe_gorne = PoleKraty(krata_magazynu, 0, 0)
|
||||
pom = 'wozek_widlowy.png'
|
||||
ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', pom)),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
Agent(krata_magazynu, pole_lewe_gorne, ikona)
|
||||
# zawsze na poczatku polnoc
|
||||
krata_magazynu.agent.kierunek = Kierunek.POLNOC
|
||||
def wyswietl_okno():
|
||||
pygame.time.Clock().tick(FPS)
|
||||
for event in pygame.event.get():
|
||||
if event.type == pygame.QUIT:
|
||||
# print("Użytkownik spróbował zamknąć okno.")
|
||||
pygame.quit()
|
||||
narysuj_krate()
|
||||
narysuj_pojazdy()
|
||||
pygame.display.update()
|
||||
|
||||
|
||||
def dodaj_szafke(numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz, poczatek_kolumna):
|
||||
wymiary_szafki = Wymiary(0, 0, 0)
|
||||
szafka = Szafka(numerSzafki, wymiary_szafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz,
|
||||
poczatek_kolumna, krata_magazynu)
|
||||
Pomieszczenie.dodajSzafke(szafka)
|
||||
def narysuj_krate():
|
||||
okno.fill(SZARY)
|
||||
for wiersz in range(LICZBA_POL_W_PIONIE):
|
||||
for kolumna in range(LICZBA_POL_W_POZIOMIE):
|
||||
start = (ODSTEP_MIEDZY_POLAMI + BOK_POLA) * kolumna + ODSTEP_MIEDZY_POLAMI
|
||||
gora = (ODSTEP_MIEDZY_POLAMI + BOK_POLA) * wiersz + ODSTEP_MIEDZY_POLAMI
|
||||
kolor_pola = ZawartoscPolaNaKolorPola[krata[wiersz][kolumna]]
|
||||
pygame.draw.rect(okno, kolor_pola, [start, gora, BOK_POLA, BOK_POLA])
|
||||
|
||||
|
||||
def gdzie_paczka(numerSzafki):
|
||||
global kolumna, wiersz
|
||||
if numerSzafki == 1:
|
||||
kolumna = random.randint(1, 2)
|
||||
if kolumna == 1:
|
||||
wiersz = random.randint(2, 13)
|
||||
else:
|
||||
wiersz = random.choice([1, 14])
|
||||
if numerSzafki == 2:
|
||||
kolumna = random.randint(3, 4)
|
||||
if kolumna == 3:
|
||||
wiersz = random.choice([1, 14])
|
||||
else:
|
||||
wiersz = random.randint(2, 13)
|
||||
if numerSzafki == 3:
|
||||
kolumna = random.randint(5, 8)
|
||||
if kolumna == 5:
|
||||
wiersz = random.randint(1, 5)
|
||||
if kolumna == 6:
|
||||
wiersz = random.choice([0, 6])
|
||||
if kolumna == 7:
|
||||
wiersz = random.choice([0, 7])
|
||||
if kolumna == 8:
|
||||
wiersz = random.randint(1, 6)
|
||||
if numerSzafki == 4:
|
||||
kolumna = random.randint(5, 8)
|
||||
if kolumna == 5:
|
||||
wiersz = random.randint(9, 12)
|
||||
if kolumna == 6:
|
||||
wiersz = random.choice([8, 13])
|
||||
if kolumna == 7:
|
||||
wiersz = random.choice([9, 13])
|
||||
if kolumna == 8:
|
||||
wiersz = random.randint(10, 12)
|
||||
if numerSzafki == 5:
|
||||
kolumna = random.randint(10, 12)
|
||||
if kolumna == 11:
|
||||
wiersz = random.choice([2, 11])
|
||||
else:
|
||||
wiersz = random.randint(3, 10)
|
||||
if numerSzafki == 6:
|
||||
kolumna = random.randint(12, 14)
|
||||
if kolumna == 13:
|
||||
wiersz = random.choice([1, 12])
|
||||
else:
|
||||
wiersz = random.randint(2, 11)
|
||||
if numerSzafki == 7:
|
||||
kolumna = random.randint(17, 19)
|
||||
if kolumna == 18:
|
||||
wiersz = random.choice([0, 13])
|
||||
else:
|
||||
wiersz = random.randint(1, 12)
|
||||
if numerSzafki == 8:
|
||||
kolumna = random.randint(22, 24)
|
||||
if kolumna == 23:
|
||||
wiersz = random.choice([4, 12])
|
||||
else:
|
||||
wiersz = random.randint(5, 11)
|
||||
if numerSzafki == 9:
|
||||
kolumna = random.randint(24, 26)
|
||||
if kolumna == 25:
|
||||
wiersz = random.choice([0, 13])
|
||||
else:
|
||||
wiersz = random.randint(1, 12)
|
||||
if numerSzafki == 10:
|
||||
kolumna = random.randint(27, 29)
|
||||
if kolumna == 28:
|
||||
wiersz = random.choice([4, 14])
|
||||
else:
|
||||
wiersz = random.randint(5, 13)
|
||||
if numerSzafki == 11:
|
||||
kolumna = 0
|
||||
wiersz = 0
|
||||
print(wiersz, kolumna)
|
||||
return wiersz, kolumna
|
||||
def narysuj_pojazdy():
|
||||
ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'auto.png')), (BOK_AGENTA, BOK_AGENTA))
|
||||
for x in droga_A:
|
||||
if x[0]:
|
||||
okno.blit(ikona, ((BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[2] + ODSTEP_MIEDZY_POLAMI,
|
||||
(BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[1] + ODSTEP_MIEDZY_POLAMI))
|
||||
ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'auto2.png')), (BOK_AGENTA, BOK_AGENTA))
|
||||
for x in droga_B:
|
||||
if x[0]:
|
||||
okno.blit(ikona, ((BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[2] + ODSTEP_MIEDZY_POLAMI,
|
||||
(BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[1] + ODSTEP_MIEDZY_POLAMI))
|
||||
|
||||
|
||||
def ustawienie():
|
||||
ostatnia = recognition()
|
||||
print(ostatnia)
|
||||
kierunek = Kierunek(random.randint(0, 3))
|
||||
wiersz, kolumna = gdzie_paczka(ostatnia + 1)
|
||||
return Stan(kierunek, PoleKraty(krata_magazynu, wiersz, kolumna))
|
||||
def rusz_pojazdy_na_drodze(droga, pole_postojowe, swiatlo):
|
||||
nowa_droga = [[False, x[1], x[2]] for x in droga]
|
||||
for i in range(len(droga) - 1, 0, -1):
|
||||
x = droga[i]
|
||||
if x[0]:
|
||||
if x[1] == pole_postojowe[0] and x[2] == pole_postojowe[1] and swiatlo != Swiatlo.ZIELONE:
|
||||
nowa_droga[i][0] = True
|
||||
else:
|
||||
if not droga[i - 1][0]:
|
||||
nowa_droga[i][0] = False
|
||||
nowa_droga[i - 1][0] = True
|
||||
else:
|
||||
nowa_droga[i][0] = True
|
||||
return nowa_droga
|
||||
|
||||
|
||||
def wroc():
|
||||
kierunek = Kierunek(random.randint(0, 3))
|
||||
wiersz, kolumna = gdzie_paczka(11)
|
||||
return Stan(kierunek, PoleKraty(krata_magazynu, wiersz, kolumna))
|
||||
def ustaw_czerwone(sygnalizator):
|
||||
krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SYGNALIZATOR_CZERWONY
|
||||
krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SCIANA2
|
||||
krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
|
||||
|
||||
|
||||
def zaznacz_cel_na_mapie(cel: Stan):
|
||||
wiersz = cel.poleStartoweGorne.wiersz
|
||||
kolumna = cel.poleStartoweGorne.kolumna
|
||||
if krata_magazynu.krata[wiersz][kolumna] == ZawartoscPola.PUSTE:
|
||||
krata_magazynu.krata[wiersz][kolumna] = ZawartoscPola.CEL
|
||||
def ustaw_czerwone_z_zoltym(sygnalizator):
|
||||
krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SYGNALIZATOR_CZERWONY
|
||||
krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SYGNALIZATOR_ZOLTY
|
||||
krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
|
||||
|
||||
|
||||
def nadaj_cel_agentowi(agent: Agent, cel: Stan):
|
||||
agent.cel = cel
|
||||
zaznacz_cel_na_mapie(agent.cel)
|
||||
print("CEL:", agent.cel.poleStartoweGorne.wiersz, agent.cel.poleStartoweGorne.kolumna)
|
||||
def ustaw_zolte(sygnalizator):
|
||||
krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SCIANA2
|
||||
krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SYGNALIZATOR_ZOLTY
|
||||
krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2
|
||||
|
||||
|
||||
def zdarzenie_osoba():
|
||||
global flaga1
|
||||
flaga1 = 1
|
||||
def ustaw_zielone(sygnalizator):
|
||||
krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SCIANA2
|
||||
krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SCIANA2
|
||||
krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SYGNALIZATOR_ZIELONY
|
||||
|
||||
|
||||
def losowa_osoba():
|
||||
wiersz = random.randint(0, krata_magazynu.liczbaPolPionowo - 1)
|
||||
kolumna = random.randint(0, krata_magazynu.liczbaPolPoziomo - 1)
|
||||
osoba = PoleKraty(krata_magazynu, wiersz, kolumna)
|
||||
return osoba
|
||||
def Czerwone_Czerwone_do_Zielone_Czerwone():
|
||||
return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"
|
||||
|
||||
|
||||
def main():
|
||||
# dla kraty 30 x 15
|
||||
dodaj_szafke("A", 2, 12, "P", 2, 2)
|
||||
dodaj_szafke("B", 2, 12, "L", 2, 3)
|
||||
dodaj_szafke("C", 2, 5, "P", 1, 6)
|
||||
dodaj_szafke("D", 2, 6, "L", 1, 7)
|
||||
dodaj_szafke("C", 2, 4, "P", 9, 6)
|
||||
dodaj_szafke("D", 2, 3, "L", 10, 7)
|
||||
dodaj_szafke("E", 2, 8, "P", 3, 11)
|
||||
dodaj_szafke("F", 2, 10, "L", 2, 13)
|
||||
dodaj_szafke("H", 2, 12, "L", 1, 18)
|
||||
dodaj_szafke("I", 2, 7, "P", 5, 23)
|
||||
dodaj_szafke("J", 2, 12, "L", 1, 25)
|
||||
dodaj_szafke("G", 2, 9, "P", 5, 28)
|
||||
|
||||
# # dla kraty 10 x 10
|
||||
# dodaj_szafke("A", 1, 8, "P", 1, 1)
|
||||
# dodaj_szafke("B", 1, 8, "L", 1, 4)
|
||||
# dodaj_szafke("C", 1, 8, "P", 1, 6)
|
||||
# dodaj_szafke("C", 1, 8, "P", 1, 8)
|
||||
|
||||
# # dla kraty 5 x 5
|
||||
# dodaj_szafke("A", 1, 3, "P", 1, 1)
|
||||
# dodaj_szafke("B", 1, 3, "L", 1, 3)
|
||||
|
||||
for i in (
|
||||
(1, 10), (1, 3), (3, 23), (2, 23), (5, 15), (4, 15), (9, 12), (11, 20), (11, 27), (11, 26), (14, 19),
|
||||
(14, 18),
|
||||
(14, 20), (8, 29), (9, 29)):
|
||||
krata_magazynu.krata[i[0]][i[1]] = ZawartoscPola.DYWAN
|
||||
for i in (
|
||||
(0, 10), (13, 20), (13, 6), (13, 14), (14, 13), (9, 26), (9, 16), (9, 15), (9, 27), (9, 16), (9, 26),
|
||||
(5, 8),
|
||||
(5, 9), (7, 9), (7, 10)):
|
||||
krata_magazynu.krata[i[0]][i[1]] = ZawartoscPola.KALUZA
|
||||
|
||||
for i in range(LICZBA_POL_W_PIONIE):
|
||||
krata_magazynu.krata[i][21] = ZawartoscPola.SCIANA2
|
||||
krata_magazynu.krata[0][21] = ZawartoscPola.PUSTE
|
||||
krata_magazynu.krata[7][21] = ZawartoscPola.PUSTE
|
||||
krata_magazynu.krata[14][21] = ZawartoscPola.PUSTE
|
||||
|
||||
dodaj_agenta()
|
||||
okno1 = Okno(krata_magazynu, krata_magazynu.agent)
|
||||
okno1.wyswietlOkno()
|
||||
|
||||
t = threading.Timer(5.0, zdarzenie_osoba).start()
|
||||
osoba = PoleKraty(krata_magazynu, 0, 0)
|
||||
clf = drzewo_decyzyjne()
|
||||
global flaga1
|
||||
flaga1 = 0
|
||||
|
||||
while True:
|
||||
# cel to Stan (pole kraty gdzie ma stać agent, aby położyć paczkę na półkę, w obiekcie klasy Miejsce jest to artybut dostęp + kierunek <-na razie niepotrzebny)
|
||||
if krata_magazynu.agent.cel is None:
|
||||
lista_paczek = []
|
||||
#cyfra 5 oznacza ilosc paczek
|
||||
for i in range(5):
|
||||
cel = ustawienie()
|
||||
wiersz_paczki = cel.poleStartoweGorne.wiersz
|
||||
kolumna_paczki = cel.poleStartoweGorne.kolumna
|
||||
lista_paczek.append((wiersz_paczki, kolumna_paczki))
|
||||
print(lista_paczek)
|
||||
|
||||
algorytm = best_route(lista_paczek)
|
||||
for j in range(5):
|
||||
wiersz_cel = lista_paczek[algorytm[j]][0]
|
||||
kolumna_cel = lista_paczek[algorytm[j]][1]
|
||||
cel_po_algorytmu = Stan(Kierunek(random.randint(0, 3)), PoleKraty(krata_magazynu, wiersz_cel, kolumna_cel))
|
||||
nadaj_cel_agentowi(krata_magazynu.agent, cel_po_algorytmu)
|
||||
krata_magazynu.agent.idzDoCelu()
|
||||
|
||||
cel = wroc()
|
||||
nadaj_cel_agentowi(krata_magazynu.agent, cel)
|
||||
krata_magazynu.agent.idzDoCelu()
|
||||
|
||||
|
||||
if flaga1 == 1:
|
||||
osoba.krata.krata[osoba.wiersz][osoba.kolumna] = ZawartoscPola.PUSTE
|
||||
okno1.wyswietlOkno()
|
||||
osoba = losowa_osoba()
|
||||
while osoba.krata.krata[osoba.wiersz][osoba.kolumna] != ZawartoscPola.PUSTE:
|
||||
osoba = losowa_osoba()
|
||||
osoba.krata.krata[osoba.wiersz][osoba.kolumna] = ZawartoscPola.OSOBA
|
||||
okno1.wyswietlOkno()
|
||||
pygame.time.wait(1000)
|
||||
answer = decyzja_osoba(osoba, clf)
|
||||
if answer == 1:
|
||||
osoba.krata.krata[osoba.wiersz][osoba.kolumna] = ZawartoscPola.PUSTE
|
||||
okno1.wyswietlOkno()
|
||||
bieg = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'bieg.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
okno_pygame.blit(bieg, (osoba.kolumna * (BOK_POLA + 1) + 1, osoba.wiersz * (BOK_POLA + 1) + 1))
|
||||
pygame.display.flip()
|
||||
pygame.time.wait(1500)
|
||||
flaga1 = 0
|
||||
t = threading.Timer(5.0, zdarzenie_osoba).start()
|
||||
def Czerwone_Czerwone_do_Czerwone_Zielone():
|
||||
return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"
|
||||
|
||||
|
||||
try:
|
||||
main()
|
||||
except pygame.error:
|
||||
pygame.quit()
|
||||
def CzerwoneZZoltym_Czerwone():
|
||||
return swiatlo_A == Swiatlo.CZERWONE_Z_ZOLTYM and swiatlo_B == Swiatlo.CZERWONE
|
||||
|
||||
|
||||
def Zielone_Czerwone_1():
|
||||
return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"
|
||||
|
||||
|
||||
def Zielone_Czerwone_2():
|
||||
return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"
|
||||
|
||||
|
||||
def Zolte_Czerwone():
|
||||
return swiatlo_A == Swiatlo.ZOLTE and swiatlo_B == Swiatlo.CZERWONE
|
||||
|
||||
|
||||
def Czerwone_CzerwoneZZoltym():
|
||||
return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE_Z_ZOLTYM
|
||||
|
||||
|
||||
def Czerwone_Zielone():
|
||||
return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.ZIELONE
|
||||
|
||||
|
||||
def Czerwone_Zolte():
|
||||
return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.ZOLTE
|
||||
|
||||
|
||||
def O_O():
|
||||
return (not droga_A[indeks_petli_A][0]) and (not droga_B[indeks_petli_B][0])
|
||||
|
||||
|
||||
def A_O():
|
||||
return (droga_A[indeks_petli_A][0]) and (not droga_B[indeks_petli_B][0])
|
||||
|
||||
|
||||
def O_B():
|
||||
return (not droga_A[indeks_petli_A][0]) and (droga_B[indeks_petli_B][0])
|
||||
|
||||
|
||||
def A_B():
|
||||
return (droga_A[indeks_petli_A][0]) and (droga_B[indeks_petli_B][0])
|
||||
|
||||
|
||||
def ustaw_Czerwone_Czerwone_do_Czerwone_Zielone():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_B)
|
||||
global poprzednio
|
||||
poprzednio = "A"
|
||||
|
||||
|
||||
def ustaw_Czerwone_Czerwone_do_Zielone_Czerwone():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_B)
|
||||
global poprzednio
|
||||
poprzednio = "B"
|
||||
|
||||
|
||||
def ustaw_CzerwoneZZoltym_Czerwone():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.CZERWONE_Z_ZOLTYM
|
||||
ustaw_czerwone_z_zoltym(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_B)
|
||||
|
||||
|
||||
def ustaw_Zielone_Czerwone_1():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.ZIELONE
|
||||
ustaw_zielone(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_B)
|
||||
global poprzednio
|
||||
poprzednio = "B"
|
||||
|
||||
|
||||
def ustaw_Zielone_Czerwone_2():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.ZIELONE
|
||||
ustaw_zielone(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_B)
|
||||
global poprzednio
|
||||
poprzednio = "A"
|
||||
|
||||
|
||||
def ustaw_Zolte_Czerwone():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.ZOLTE
|
||||
ustaw_zolte(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_B)
|
||||
|
||||
|
||||
def ustaw_Czerwone_CzerwoneZZoltym():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.CZERWONE_Z_ZOLTYM
|
||||
ustaw_czerwone_z_zoltym(sygnalizator_B)
|
||||
|
||||
|
||||
def ustaw_Czerwone_Zielone():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.ZIELONE
|
||||
ustaw_zielone(sygnalizator_B)
|
||||
|
||||
|
||||
def ustaw_Czerwone_Zolte():
|
||||
global swiatlo_A
|
||||
swiatlo_A = Swiatlo.CZERWONE
|
||||
ustaw_czerwone(sygnalizator_A)
|
||||
global swiatlo_B
|
||||
swiatlo_B = Swiatlo.ZOLTE
|
||||
ustaw_zolte(sygnalizator_B)
|
||||
|
||||
|
||||
droga_A[14][0] = True
|
||||
droga_A[12][0] = True
|
||||
droga_A[10][0] = True
|
||||
droga_A[9][0] = True
|
||||
droga_B[len(droga_B) - 1][0] = True
|
||||
droga_B[len(droga_B) - 2][0] = True
|
||||
droga_B[len(droga_B) - 6][0] = True
|
||||
droga_B[5][0] = True
|
||||
|
||||
czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
|
||||
ustaw_Czerwone_Czerwone_do_Zielone_Czerwone()
|
||||
poprzednio = "B"
|
||||
|
||||
while True:
|
||||
# print(droga_A[indeks_petli_A][0],droga_B[indeks_petli_B][0])
|
||||
if O_O():
|
||||
print("O - O")
|
||||
elif A_O():
|
||||
print("A - O")
|
||||
elif A_B():
|
||||
print("A - B")
|
||||
elif O_B():
|
||||
print("O - B")
|
||||
czas_od_ostatniej_zmiany_swiatel = pygame.time.get_ticks() - czas_ostatniej_zmiany_swiatel
|
||||
if Czerwone_Czerwone_do_Zielone_Czerwone():
|
||||
print("Czerwone - Czerwone do Zielone - Czerwone")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
|
||||
czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
|
||||
if O_O() or A_O() or A_B():
|
||||
ustaw_CzerwoneZZoltym_Czerwone()
|
||||
elif O_B():
|
||||
ustaw_Czerwone_CzerwoneZZoltym()
|
||||
elif CzerwoneZZoltym_Czerwone():
|
||||
print("Czerwone z Zoltym - Czerwone")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
|
||||
ustaw_Zielone_Czerwone_1()
|
||||
elif Zielone_Czerwone_1():
|
||||
print("Zielone - Czerwone 1")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
|
||||
czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
|
||||
if O_O() or A_O() or A_B():
|
||||
ustaw_Zielone_Czerwone_2()
|
||||
elif O_B():
|
||||
ustaw_Zolte_Czerwone()
|
||||
elif Zielone_Czerwone_2():
|
||||
print("Zielone - Czerwone 2")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
|
||||
czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
|
||||
if O_O() or A_O():
|
||||
pass
|
||||
elif O_B() or A_B():
|
||||
ustaw_Zolte_Czerwone()
|
||||
elif Zolte_Czerwone():
|
||||
print("Zolte - Czerwone")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
|
||||
czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
|
||||
ustaw_Czerwone_Czerwone_do_Czerwone_Zielone()
|
||||
elif Czerwone_CzerwoneZZoltym():
|
||||
print("Czerwone - Czerwone z Zoltym")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
|
||||
ustaw_Czerwone_Zielone()
|
||||
elif Czerwone_Zielone():
|
||||
print("Czerwone - Zielone")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
|
||||
czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
|
||||
if O_B():
|
||||
pass
|
||||
elif O_O() or A_O() or A_B():
|
||||
ustaw_Czerwone_Zolte()
|
||||
elif Czerwone_Zolte():
|
||||
print("Czerwone - Zolte")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
|
||||
czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
|
||||
ustaw_Czerwone_Czerwone_do_Zielone_Czerwone()
|
||||
elif Czerwone_Czerwone_do_Czerwone_Zielone():
|
||||
print("Czerwone - Czerwone do Czerwone - Zielone")
|
||||
if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
|
||||
czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
|
||||
if A_O():
|
||||
ustaw_CzerwoneZZoltym_Czerwone()
|
||||
elif O_O() or O_B() or A_B():
|
||||
ustaw_Czerwone_CzerwoneZZoltym()
|
||||
#
|
||||
wyswietl_okno()
|
||||
droga_A = rusz_pojazdy_na_drodze(droga_A, pole_postojowe_A, swiatlo_A)
|
||||
droga_B = rusz_pojazdy_na_drodze(droga_B, pole_postojowe_B, swiatlo_B)
|
||||
#
|
||||
los = random.random()
|
||||
liczba_samochodow = len([x for x in droga_A if x[0]])
|
||||
maks_samochodow = 7
|
||||
szansa = (maks_samochodow - liczba_samochodow) / maks_samochodow -0.7
|
||||
if los < szansa:
|
||||
droga_A[len(droga_A) - 1][0] = True
|
||||
#
|
||||
liczba_samochodow = len([x for x in droga_B if x[0]])
|
||||
maks_samochodow = 6
|
||||
szansa = (maks_samochodow - liczba_samochodow) / maks_samochodow - 0.4
|
||||
if los < szansa:
|
||||
droga_B[len(droga_B) - 1][0] = True
|
||||
|
@ -1,8 +0,0 @@
|
||||
class Miejsce:
|
||||
def __init__(self, name, polka, miejsceNaPolce):
|
||||
self.numer = name
|
||||
# self.rozmiar = rozmiar
|
||||
self.polka = polka
|
||||
self.miejsceNaPolce = miejsceNaPolce
|
||||
self.status = 'wolne'
|
||||
self.numerUmieszczonejPaczki = ''
|
@ -1,59 +0,0 @@
|
||||
import os
|
||||
import random
|
||||
|
||||
import cv2
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import tensorflow as tf
|
||||
|
||||
mnist = tf.keras.datasets.mnist
|
||||
(x_train, y_train), (x_test, y_test) = mnist.load_data()
|
||||
|
||||
x_train = tf.keras.utils.normalize(x_train, axis=1)
|
||||
x_test = tf.keras.utils.normalize(x_test, axis=1)
|
||||
|
||||
model = tf.keras.models.Sequential()
|
||||
model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))
|
||||
model.add(tf.keras.layers.Dense(128, activation='relu'))
|
||||
model.add(tf.keras.layers.Dense(128, activation='relu'))
|
||||
model.add(tf.keras.layers.Dense(10, activation='softmax'))
|
||||
|
||||
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
|
||||
|
||||
model.fit(x_train, y_train, epochs=3)
|
||||
model.save('handwritten.model')
|
||||
|
||||
model = tf.keras.models.load_model('handwritten.model')
|
||||
numery_paczek = []
|
||||
|
||||
|
||||
def liczby():
|
||||
digits = []
|
||||
for i in range(0, 3):
|
||||
image_number = random.randint(1, 19)
|
||||
img = cv2.imread(f"digits/digit{image_number}.png")[:, :, 0]
|
||||
img = np.invert(np.array([img]))
|
||||
prediction = model.predict(img)
|
||||
print(f"This digit is probably a {np.argmax(prediction)}")
|
||||
digits.append(np.argmax(prediction))
|
||||
plt.imshow(img[0], cmap=plt.cm.binary)
|
||||
plt.show()
|
||||
liczba = int(str(digits[0]) + str(digits[1]) + str(digits[2]))
|
||||
if liczba in numery_paczek or liczba < 100:
|
||||
liczby()
|
||||
else:
|
||||
numery_paczek.append(liczba)
|
||||
return numery_paczek[-1]
|
||||
|
||||
|
||||
def recognition():
|
||||
try:
|
||||
liczba = liczby()
|
||||
except:
|
||||
print("Error!")
|
||||
ostatnia = liczba % 10
|
||||
loss, accuracy = model.evaluate(x_test, y_test)
|
||||
print(loss)
|
||||
print(accuracy)
|
||||
print(numery_paczek)
|
||||
return ostatnia
|
@ -1,31 +0,0 @@
|
||||
# https://refactoring.guru/pl/design-patterns/observer/python/example
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from abc import ABC, abstractmethod
|
||||
|
||||
|
||||
class Obserwowany(ABC):
|
||||
obserwatorzy = []
|
||||
|
||||
def dolaczObserwatora(self, obserwator: Obserwator):
|
||||
self.obserwatorzy.append(obserwator)
|
||||
|
||||
def odlaczObserwatora(self, obserwator: Obserwator):
|
||||
self.obserwatorzy.remove(obserwator)
|
||||
|
||||
@abstractmethod
|
||||
def powiadomObserwatorow(self):
|
||||
"""
|
||||
Notify all observers about an event.
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class Obserwator(ABC):
|
||||
@abstractmethod
|
||||
def odbierzPowiadomienie(self, obserwowany: Obserwowany):
|
||||
"""
|
||||
Receive update from subject.
|
||||
"""
|
||||
pass
|
23
okno.py
@ -1,23 +0,0 @@
|
||||
from krata import *
|
||||
|
||||
|
||||
class Okno(Obserwator):
|
||||
def __init__(self, krata, agent):
|
||||
self.krata = krata
|
||||
self.agent = agent
|
||||
self.krata.dolaczObserwatora(self)
|
||||
self.agent.dolaczObserwatora(self)
|
||||
self.klatkaz = pygame.time.Clock()
|
||||
|
||||
def wyswietlOkno(self):
|
||||
self.klatkaz.tick(FPS)
|
||||
for event in pygame.event.get():
|
||||
if event.type == pygame.QUIT:
|
||||
# print("Użytkownik spróbował zamknąć okno.")
|
||||
pygame.quit()
|
||||
self.krata.narysujKrate()
|
||||
self.agent.narysujAgenta()
|
||||
pygame.display.update()
|
||||
|
||||
def odbierzPowiadomienie(self, obserwowany: Obserwowany):
|
||||
self.wyswietlOkno()
|
@ -1,170 +0,0 @@
|
||||
from krata import *
|
||||
|
||||
|
||||
class Wymiary:
|
||||
def __init__(self, dlugosc, szerokosc, wysokosc):
|
||||
self.dlugosc = dlugosc
|
||||
self.szerokosc = szerokosc
|
||||
self.wysokosc = wysokosc
|
||||
|
||||
|
||||
class Mapa:
|
||||
mapa: []
|
||||
|
||||
def __init__(self):
|
||||
self.liczbaPolPoziomo = LICZBA_POL_W_POZIOMIE
|
||||
self.liczbaPolPionowo = LICZBA_POL_W_PIONIE
|
||||
self.bokPola = BOK_POLA
|
||||
self.odstepMiedzyPolami = ODSTEP_MIEDZY_POLAMI
|
||||
self.utworzPustaMape()
|
||||
self.agent = None
|
||||
|
||||
def utworzPustaMape(self):
|
||||
self.mapa = []
|
||||
for wiersz in range(self.liczbaPolPionowo):
|
||||
self.mapa.append([])
|
||||
for kolumna in range(self.liczbaPolPoziomo):
|
||||
zawartosc_pola = ZawartoscPola.PUSTE
|
||||
nowe_pole = PoleMapy(self, wiersz, kolumna, zawartosc_pola)
|
||||
self.mapa[wiersz].append(nowe_pole)
|
||||
|
||||
|
||||
class PoleMapy:
|
||||
def __init__(self, mapa: Mapa, wiersz, kolumna, zawartosc: ZawartoscPola):
|
||||
self.mapa = mapa
|
||||
self.bok = self.mapa.bokPola
|
||||
self.wiersz = wiersz
|
||||
self.kolumna = kolumna
|
||||
self.zawartosc = zawartosc
|
||||
|
||||
|
||||
class WarunkiPowietrza:
|
||||
def __init__(self, temperatura, wilgotnosc):
|
||||
self.temperatura = temperatura
|
||||
self.wilgotnosc = wilgotnosc
|
||||
|
||||
|
||||
class Miejsce: # wcześniej półka
|
||||
def __init__(self, numer, wymiary: Wymiary, udzwig, wysokoscOdPodlogi):
|
||||
self.numer = numer
|
||||
self.wymiary = wymiary
|
||||
self.udzwig = udzwig
|
||||
self.wysokoscOdPodlogi = wysokoscOdPodlogi
|
||||
# self.status = 'wolne'
|
||||
self.dostep = []
|
||||
self.zajmowanePola = []
|
||||
|
||||
def dodajPole(self, pole: PoleKraty):
|
||||
self.zajmowanePola.append(pole)
|
||||
|
||||
def dodajDostep(self, pole: PoleKraty):
|
||||
self.dostep.append(pole)
|
||||
|
||||
|
||||
class Szafka:
|
||||
def __init__(self, numerSzafki, wymiary: Wymiary, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna,
|
||||
poczatek_wiersz1, krata: Krata):
|
||||
self.numerSzafki = numerSzafki
|
||||
self.wymiary = wymiary
|
||||
self.iloscPolek = iloscPolek
|
||||
self.iloscMiejscNaPolce = iloscMiejscNaPolce
|
||||
self.dostepZeStrony = dostepZeStrony
|
||||
self.Miejsca = []
|
||||
self.zajmowanePola = []
|
||||
self.utworzPustaSzafke(numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_kolumna,
|
||||
poczatek_wiersz1, krata)
|
||||
|
||||
def dodajMiejsce(self, miejsce: Miejsce):
|
||||
self.Miejsca.append(miejsce)
|
||||
|
||||
def dodajPole(self, pole: PoleKraty):
|
||||
self.zajmowanePola.append(pole)
|
||||
|
||||
def utworzPustaSzafke(self, numerSzafki, iloscPolek, iloscMiejscNaPolce, dostepZeStrony, poczatek_wiersz1,
|
||||
poczatek_kolumna, krata: Krata):
|
||||
for i in range(iloscPolek):
|
||||
for j in range(iloscMiejscNaPolce):
|
||||
wymiar_miejsca = Wymiary(0, 0, 0)
|
||||
numerMiejsca = self.numerSzafki + "/" + str(i) + "/" + str(j)
|
||||
miejsce = Miejsce(numerMiejsca, wymiar_miejsca, 0, 0)
|
||||
# wypełnianie pól "zajmowane miejsca" i "dostęp"
|
||||
for m in range(DUZA_SZAFA): # wiersz
|
||||
poczatek_wiersz = poczatek_wiersz1 + j * DUZA_SZAFA + m
|
||||
for n in range(DUZA_SZAFA): # kolumna
|
||||
krata.krata[poczatek_wiersz][poczatek_kolumna + n] = ZawartoscPola.SCIANA
|
||||
pole = PoleKraty(krata, poczatek_wiersz, poczatek_kolumna + n)
|
||||
miejsce.dodajPole(pole)
|
||||
self.dodajPole(pole)
|
||||
if dostepZeStrony == "L":
|
||||
pole_dostepu = PoleKraty(krata, poczatek_wiersz,
|
||||
poczatek_kolumna + n - BOK_AGENTA1_W_POLACH) # dostęp z lewej strony
|
||||
miejsce.dodajDostep(pole_dostepu)
|
||||
elif dostepZeStrony == "P":
|
||||
pole_dostepu = PoleKraty(krata, poczatek_wiersz,
|
||||
poczatek_kolumna + n + BOK_AGENTA1_W_POLACH) # dostęp z prawej strony strony
|
||||
miejsce.dodajDostep(pole_dostepu)
|
||||
self.dodajMiejsce(miejsce)
|
||||
|
||||
|
||||
class Pomieszczenie:
|
||||
def __init__(self, warunkiPowietrza: WarunkiPowietrza, wysokoscSufitu):
|
||||
self.warunkiPowietrza = warunkiPowietrza
|
||||
self.wysokoscSufitu = wysokoscSufitu
|
||||
self.Szafki = []
|
||||
self.zajmowanePola = []
|
||||
|
||||
def dodajSzafke(self, szafka: Szafka):
|
||||
self.Szafki.append(szafka)
|
||||
|
||||
def dodajPole(self, pole: PoleMapy):
|
||||
self.zajmowanePola.append(pole)
|
||||
|
||||
|
||||
class Etykieta:
|
||||
def __init__(self, nazwaTowaru, nazwaNadawcy, dataZapakowania, iD, niePietrowac, zachowacSuchosc, ostroznie,
|
||||
uwagaSzklo):
|
||||
# realistyczne? informacje na paczce
|
||||
# kategoryzowanie towaru może odbywać się na podstawie jego nazwy
|
||||
self.nazwaTowaru = nazwaTowaru
|
||||
self.nazwaNadawcy = nazwaNadawcy
|
||||
self.dataZapakowania = dataZapakowania
|
||||
self.id = iD
|
||||
# nalepki na paczce - być może nie będą na etykiecie, a trzeba je będzie rozpoznać na obrazie
|
||||
self.niePietrowac = niePietrowac
|
||||
self.zachowacSuchosc = zachowacSuchosc
|
||||
self.ostroznie = ostroznie
|
||||
self.uwagaSzklo = uwagaSzklo
|
||||
|
||||
|
||||
class Paczka:
|
||||
def __init__(self, wymiary: Wymiary, waga, etykieta: Etykieta):
|
||||
self.wymiary = wymiary
|
||||
self.waga = waga
|
||||
self.etykieta = etykieta
|
||||
|
||||
|
||||
class Paleta:
|
||||
def __init__(self):
|
||||
self.Paczki = []
|
||||
|
||||
def dodajPaczke(self, paczka: Paczka):
|
||||
self.Paczki.append(paczka)
|
||||
|
||||
|
||||
class Nadawca:
|
||||
def __init__(self, nazwa, iD):
|
||||
self.nazwa = nazwa
|
||||
self.id = iD
|
||||
# plus dodatkowe informacje mogące wpływać na priorytet rozpakowania transportu / miejsce składowania paczek?
|
||||
|
||||
|
||||
class Transport:
|
||||
def __init__(self, dataPrzyjecia, nadawca: Nadawca, iD):
|
||||
Palety = []
|
||||
self.dataPrzyjecia = dataPrzyjecia
|
||||
self.nadawca = nadawca
|
||||
self.id = iD
|
||||
|
||||
# wyliczanie priorytetu rozpakowania transportu ?
|
||||
# def okrescPriorytet(self):
|
||||
# self.priorytet =
|
53
rescue.py
@ -1,53 +0,0 @@
|
||||
import random
|
||||
|
||||
import pandas as pd
|
||||
import pydotplus
|
||||
from sklearn import metrics, tree
|
||||
from sklearn.tree import DecisionTreeClassifier
|
||||
|
||||
from krata import *
|
||||
|
||||
|
||||
def drzewo_decyzyjne():
|
||||
columns = ['plec', 'wiek', 'czas_w_pom', 'temp_w_pom', 'poziom_kurzu', 'poziom_oswietlenia', 'niebezp_towary',
|
||||
'decyzja']
|
||||
df = pd.read_csv("dataset.csv", header=0, sep=";", names=columns)
|
||||
kolumny_x = ['plec', 'wiek', 'czas_w_pom', 'temp_w_pom', 'poziom_kurzu', 'poziom_oswietlenia', 'niebezp_towary']
|
||||
x = df[kolumny_x]
|
||||
y = df.decyzja
|
||||
# df.info()
|
||||
# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
|
||||
clf = DecisionTreeClassifier()
|
||||
clf = clf.fit(x, y)
|
||||
# print("Dokładność: ", metrics.accuracy_score(y_test, y_pred))
|
||||
|
||||
# dot_data = tree.export_graphviz(clf, out_file=None, feature_names=kolumny_x, class_names=['0', '1'])
|
||||
# graph = pydotplus.graph_from_dot_data(dot_data)
|
||||
# graph.write_png('drzewo.png')
|
||||
|
||||
return clf
|
||||
|
||||
|
||||
def decyzja_osoba(osoba: PoleKraty, clf: DecisionTreeClassifier):
|
||||
z = []
|
||||
z.extend(random.choices([1, 2], weights=[1, 2], k=1)) # 1 kobieta, 2 mężczyzna
|
||||
z.append(random.randint(18, 75)) # od 55 osoba starsza
|
||||
z.append(random.randint(1,
|
||||
60)) # jak długo przebywa w pomieszczeniu, od 40 min długo, od 20 min średnio, do 20 min krótko
|
||||
if osoba.kolumna > 21:
|
||||
z.append(0) # zimne pomieszczenie
|
||||
else:
|
||||
z.append(1) # normalne pomieszczenie
|
||||
z.append(random.randint(20, 100)) # poziom kurzu
|
||||
z.append(random.randint(20, 100)) # poziom oświetlenia
|
||||
if (0 <= osoba.wiersz or osoba.wiersz <= 13) and (
|
||||
17 <= osoba.kolumna or osoba.kolumna <= 19): # obok szafki z niebezpiecznymi towarami
|
||||
z.append(1)
|
||||
else:
|
||||
z.append(0)
|
||||
columns = ['plec', 'wiek', 'czas_w_pom', 'temp_w_pom', 'poziom_kurzu', 'poziom_oswietlenia', 'niebezp_towary']
|
||||
z1 = pd.DataFrame([z], columns=columns)
|
||||
z_pred = clf.predict(z1)
|
||||
# print(z)
|
||||
# print(z_pred)
|
||||
return (z_pred)
|
60
stale.py
@ -1,11 +1,4 @@
|
||||
import os
|
||||
|
||||
import pygame
|
||||
|
||||
FPS = 20
|
||||
#
|
||||
# SZEROKOSC_OKNA = 1500
|
||||
# WYSOKOSC_OKNA = 750
|
||||
FPS = 2
|
||||
#
|
||||
LICZBA_POL_W_POZIOMIE = 30
|
||||
LICZBA_POL_W_PIONIE = 15
|
||||
@ -14,50 +7,17 @@ ODSTEP_MIEDZY_POLAMI = 1
|
||||
SZEROKOSC_OKNA = LICZBA_POL_W_POZIOMIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
|
||||
WYSOKOSC_OKNA = LICZBA_POL_W_PIONIE * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) + ODSTEP_MIEDZY_POLAMI
|
||||
#
|
||||
BOK_AGENTA1_W_POLACH = 1
|
||||
BOK_AGENTA1 = BOK_AGENTA1_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
|
||||
#
|
||||
DUZA_SZAFA = 1
|
||||
BOK_AGENTA_W_POLACH = 1
|
||||
BOK_AGENTA = BOK_AGENTA_W_POLACH * (BOK_POLA + ODSTEP_MIEDZY_POLAMI) - ODSTEP_MIEDZY_POLAMI
|
||||
#
|
||||
BIALY = (255, 255, 255)
|
||||
JASNOSZARY1 = (200, 200, 200)
|
||||
SZARY1 = (150, 150, 150)
|
||||
JASNOSZARY = (200, 200, 200)
|
||||
SZARY = (150, 150, 150)
|
||||
CZARNY = (0, 0, 0)
|
||||
CIEMNY_BRAZOWY1 = (60, 19, 33)
|
||||
ZOLTY1 = (231, 213, 69)
|
||||
NIEBIESKI1 = (65, 125, 225)
|
||||
IKONA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'osoba2.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
KALUZA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'kaluza.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
DYWAN = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'dywan.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
PACZKA = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'paczka.png')),
|
||||
(BOK_AGENTA1, BOK_AGENTA1))
|
||||
###
|
||||
|
||||
###
|
||||
GREY = (150, 150, 150)
|
||||
RED = (255, 0, 0)
|
||||
BLUE = (55, 55, 255)
|
||||
BLACK = (0, 0, 0)
|
||||
GREEN = (0, 200, 0)
|
||||
DARKGREY = (150, 150, 150)
|
||||
UGLY_PINK = (255, 0, 255)
|
||||
BROWN = (153, 76, 0)
|
||||
GOLD = (153, 153, 0)
|
||||
DARKGREEN = (0, 102, 0)
|
||||
DARKORANGE = (255, 128, 0)
|
||||
#
|
||||
# NUMBER_OF_BLOCKS_WIDE=8
|
||||
# NUMBER_OF_BLOCKS_HIGH=8
|
||||
# BLOCK_HEIGHT=round(SZEROKOSC_OKNA/NUMBER_OF_BLOCKS_HIGH)
|
||||
# BLOCK_WIDTH=round(WYSOKOSC_OKNA/NUMBER_OF_BLOCKS_WIDE)
|
||||
CZERWONY = (255, 0, 0)
|
||||
ZOLTY = (255, 255, 0)
|
||||
ZIELONY = (0, 255, 0)
|
||||
#
|
||||
MAPFILE = "map.txt"
|
||||
TITLE = "Gierka"
|
||||
#
|
||||
NUMBER_OF_BLOCKS_WIDE = LICZBA_POL_W_POZIOMIE
|
||||
NUMBER_OF_BLOCKS_HIGH = LICZBA_POL_W_PIONIE
|
||||
BLOCK_HEIGHT = BOK_POLA
|
||||
BLOCK_WIDTH = BOK_POLA
|
||||
CZAS_ZMIANY_NA_SYGNALIZATORZE = 1500
|
||||
CZAS_CYKLU = 6000
|
||||
|
@ -1,99 +0,0 @@
|
||||
from krata import *
|
||||
|
||||
|
||||
class Akcja(Enum):
|
||||
OBROT_W_LEWO = 0
|
||||
OBROT_W_PRAWO = 1
|
||||
KROK_W_PRZOD = 2
|
||||
|
||||
|
||||
class Stan:
|
||||
def __init__(self, kierunek: Kierunek, poleStartoweGorne: PoleKraty):
|
||||
self.kierunek = kierunek
|
||||
self.poleStartoweGorne = poleStartoweGorne
|
||||
|
||||
def skopiuj(self):
|
||||
return Stan(self.kierunek, self.poleStartoweGorne.skopiuj())
|
||||
|
||||
|
||||
class Nastepnik:
|
||||
def __init__(self, akcja: Akcja or None, stan: Stan, poprzednik):
|
||||
self.akcja = akcja
|
||||
self.stan = stan
|
||||
self._poprzednik = poprzednik
|
||||
|
||||
def getPoprzednik(self):
|
||||
return self._poprzednik
|
||||
|
||||
def setPoprzednik(self, x):
|
||||
raise Exception
|
||||
|
||||
poprzednik = property(getPoprzednik, setPoprzednik)
|
||||
|
||||
def skopiuj(self):
|
||||
return Nastepnik(self.akcja, self.stan.skopiuj(), self.poprzednik)
|
||||
|
||||
|
||||
def nastepnik_obrotu_w_lewo(nastepnik: Nastepnik):
|
||||
akcja = Akcja.OBROT_W_LEWO
|
||||
stan = Stan(nastepnik.stan.kierunek.kierunekNaLewo(), nastepnik.stan.poleStartoweGorne)
|
||||
return Nastepnik(akcja, stan, nastepnik)
|
||||
|
||||
|
||||
def nastepnik_obrotu_w_prawo(nastepnik: Nastepnik):
|
||||
akcja = Akcja.OBROT_W_PRAWO
|
||||
stan = Stan(nastepnik.stan.kierunek.kierunekNaPrawo(), nastepnik.stan.poleStartoweGorne)
|
||||
return Nastepnik(akcja, stan, nastepnik)
|
||||
|
||||
|
||||
def nastepnik_kroku_w_przod(nastepnik: Nastepnik):
|
||||
akcja = Akcja.KROK_W_PRZOD
|
||||
stan = Stan(nastepnik.stan.kierunek, nastepnik.stan.poleStartoweGorne)
|
||||
if stan.kierunek == Kierunek.POLNOC:
|
||||
stan.poleStartoweGorne.wiersz -= 1
|
||||
elif stan.kierunek == Kierunek.POLUDNIE:
|
||||
stan.poleStartoweGorne.wiersz += 1
|
||||
elif stan.kierunek == Kierunek.ZACHOD:
|
||||
stan.poleStartoweGorne.kolumna -= 1
|
||||
elif stan.kierunek == Kierunek.WSCHOD:
|
||||
stan.poleStartoweGorne.kolumna += 1
|
||||
return Nastepnik(akcja, stan, nastepnik)
|
||||
|
||||
|
||||
def pole_w_granicach_kraty(pole: PoleKraty):
|
||||
if pole.wiersz not in range(0, pole.krata.liczbaPolPionowo):
|
||||
return False
|
||||
elif pole.kolumna not in range(0, pole.krata.liczbaPolPoziomo):
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
def mozna_wjechac_na_pole(pole: PoleKraty):
|
||||
if pole.krata.krata[pole.wiersz][pole.kolumna] != ZawartoscPola.SCIANA and pole.krata.krata[pole.wiersz][
|
||||
pole.kolumna] != ZawartoscPola.SCIANA2 and pole.krata.krata[pole.wiersz][pole.kolumna] != ZawartoscPola.OSOBA:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
def mozna_zrobic_krok_w_przod(nastepnik: Nastepnik):
|
||||
nastepnik = nastepnik_kroku_w_przod(nastepnik)
|
||||
if pole_w_granicach_kraty(nastepnik.stan.poleStartoweGorne) and mozna_wjechac_na_pole(
|
||||
nastepnik.stan.poleStartoweGorne):
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
def succ(nastepnik: Nastepnik):
|
||||
wynik = []
|
||||
pom = nastepnik.skopiuj()
|
||||
wynik.append(nastepnik_obrotu_w_lewo(pom))
|
||||
pom = nastepnik.skopiuj()
|
||||
wynik.append(nastepnik_obrotu_w_prawo(pom))
|
||||
pom = nastepnik.skopiuj()
|
||||
if mozna_zrobic_krok_w_przod(pom):
|
||||
pom = nastepnik.skopiuj()
|
||||
wynik.append(nastepnik_kroku_w_przod(pom))
|
||||
return wynik
|
37
szafka2.py
@ -1,37 +0,0 @@
|
||||
import random
|
||||
|
||||
import miejsce
|
||||
|
||||
|
||||
class Szafka:
|
||||
def __init__(self, numerSzafki, rozmiar, iloscPolek, iloscMiejscNaPolce):
|
||||
self.numer = numerSzafki
|
||||
# np. A
|
||||
self.rozmiarMiejsc = rozmiar
|
||||
# średni, duży, mały
|
||||
# self.iloscWolnychMiejsc = iloscPolek*iloscMiejscNaPolce
|
||||
self.iloscPolek = iloscPolek
|
||||
self.iloscMiejscNaPolce = iloscMiejscNaPolce
|
||||
self.listaMiejsc = []
|
||||
self.listaWolnychMiejsc = []
|
||||
self.stworzMiejsca()
|
||||
|
||||
def stworzMiejsca(self):
|
||||
j = 0 # półka
|
||||
k = 0
|
||||
while j < self.iloscPolek:
|
||||
name = self.numer + "/" + str(j) + "/" + str(k)
|
||||
nowe_miejsce = miejsce.Miejsce(name, j, k)
|
||||
self.listaMiejsc.append(nowe_miejsce)
|
||||
k = k + 1
|
||||
if k > self.iloscMiejscNaPolce - 1:
|
||||
j = j + 1
|
||||
k = 0
|
||||
|
||||
self.listaWolnychMiejsc = self.listaMiejsc.copy()
|
||||
|
||||
def polozPaczke(self, numerPaczki):
|
||||
if len(self.listaWolnychMiejsc) != 0:
|
||||
self.listaWolnychMiejsc[0].numerUmieszczonejPaczki = numerPaczki
|
||||
self.listaWolnychMiejsc[0].status = "zajęte"
|
||||
self.listaWolnychMiejsc.pop(0)
|