dataset for project presentation (#35) from wozek_works_in_a_loop into master

Reviewed-on: #35

NeuralNetwork/prediction.py

@@ -0,0 +1,147 @@
+import torch
+import torch.nn as nn
+from torchvision.transforms import transforms
+import numpy as np
+from torch.autograd import Variable
+from torchvision.models import squeezenet1_1
+import torch.functional as F
+from io import open
+import os
+from PIL import Image
+import pathlib
+import glob
+from tkinter import Tk, Label
+from PIL import Image, ImageTk
+
+absolute_path = os.path.abspath('NeuralNetwork/src/train_images')
+train_path = absolute_path
+absolute_path = os.path.abspath('Images/Items_test')
+pred_path = absolute_path
+
+root=pathlib.Path(train_path)
+classes=sorted([j.name.split('/')[-1] for j in root.iterdir()])
+
+
+class DataModel(nn.Module):
+    def __init__(self, num_classes):
+        super(DataModel, self).__init__()
+        #input (batch=256, nr of channels rgb=3 , size=244x244)
+
+        # convolution
+        self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=3, stride=1, padding=1)
+        #shape (256, 12, 224x224)
+
+        # batch normalization
+        self.bn1 = nn.BatchNorm2d(num_features=12)
+        #shape (256, 12, 224x224)
+        self.reul1 = nn.ReLU()
+
+        self.pool=nn.MaxPool2d(kernel_size=2, stride=2)
+        # reduce image size by factor 2
+        # pooling window moves by 2 pixels at a time instead of 1
+        # shape (256, 12, 112x112)
+
+
+
+        self.conv2 = nn.Conv2d(in_channels=12, out_channels=24, kernel_size=3, stride=1, padding=1)
+        self.bn2 = nn.BatchNorm2d(num_features=24)
+        self.reul2 = nn.ReLU()
+        # shape (256, 24, 112x112)
+
+        self.conv3 = nn.Conv2d(in_channels=24, out_channels=48, kernel_size=3, stride=1, padding=1)
+        #shape (256, 48, 112x112)
+        self.bn3 = nn.BatchNorm2d(num_features=48)
+        #shape (256, 48, 112x112)
+        self.reul3 = nn.ReLU()
+
+        # connected layer
+        self.fc = nn.Linear(in_features=48*112*112, out_features=num_classes)
+
+    def forward(self, input):
+            output = self.conv1(input)
+            output = self.bn1(output)
+            output = self.reul1(output)
+
+            output = self.pool(output)
+            output = self.conv2(output)
+            output  = self.bn2(output)
+            output = self.reul2(output)
+            
+            output = self.conv3(output)
+            output = self.bn3(output)
+            output = self.reul3(output)
+
+            # output shape matrix (256, 48, 112x112)
+            #print(output.shape)
+            #print(self.fc.weight.shape)
+
+            output = output.view(-1, 48*112*112)
+            output = self.fc(output)
+            
+            return output
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+file_path = os.path.join(script_dir, 'best_model.pth')
+checkpoint=torch.load(file_path)
+model = DataModel(num_classes=2)
+model.load_state_dict(checkpoint)
+model.eval()
+
+transformer = transforms.Compose([
+    transforms.Resize((224, 224)),  # Resize images to (224, 224)
+    transforms.ToTensor(),  # Convert images to tensors, 0-255 to 0-1
+    # transforms.RandomHorizontalFlip(),  # 0.5 chance to flip the image
+    transforms.Normalize([0.5,0.5,0.5], [0.5,0.5,0.5]) 
+])
+
+def prediction(img_path,transformer):
+    
+    image=Image.open(img_path)
+    
+    image_tensor=transformer(image).float()
+    
+    image_tensor=image_tensor.unsqueeze_(0)
+    
+    if torch.cuda.is_available():
+        image_tensor.cuda()
+        
+    input=Variable(image_tensor)
+    
+    output=model(input)
+    
+    index=output.data.numpy().argmax()
+    
+    pred=classes[index]
+    
+    return pred
+
+def prediction_keys():
+
+    #funkcja zwracajaca sciezki do kazdego pliku w folderze w postaci listy
+
+    images_path=glob.glob(pred_path+'/*.jpg')
+
+    pred_list=[]
+
+    for i in images_path:
+        pred_list.append(i)
+
+    return pred_list
+
+def predict_one(path):
+
+    #wyswietlanie obrazka po kazdym podniesieniu itemu
+    root = Tk()
+    root.title("Okno z obrazkiem")
+
+    image = Image.open(path)
+    photo = ImageTk.PhotoImage(image)
+    label = Label(root, image=photo)
+    label.pack()
+
+    root.mainloop()
+
+    #uruchamia sie funkcja spr czy obrazek to paczka czy list
+    pred_print = prediction(path,transformer)
+    print('Zdjecie jest: '+pred_print)
+    return pred_print

algorytm_genetyczny.py

@@ -0,0 +1,109 @@
+import random
+
+EKRAN_SZEROKOSC = 770
+EKRAN_WYSOKOSC = 770
+blockSize = 70
+LICZBA_REGALOW = 4
+LICZBA_MIEJSC_NA_PACZKE = 1
+LICZBA_SKRZYNEK_NA_LISTY = 1
+
+ROZMIAR_POPULACJI = 100
+LICZBA_GENERACJI = 100
+
+
+def wygeneruj_osobnika(zasieg_wspolrzednych, ilosc_wspolrzednych):
+    osobnik = list()
+    for j in range(ilosc_wspolrzednych):
+        x = random.randint(1, zasieg_wspolrzednych)
+        y = random.randint(1, zasieg_wspolrzednych)
+        e = (x, y)
+        osobnik.append(e)
+    return osobnik
+
+
+def wygeneruj_populacje_poczatkowa(liczebnosc_populacji):
+    populacja = list()
+    zasieg = int((EKRAN_WYSOKOSC / blockSize) - 3)
+    ilosc_wspolrzednych = (LICZBA_REGALOW + LICZBA_MIEJSC_NA_PACZKE + LICZBA_SKRZYNEK_NA_LISTY)
+    for i in range(liczebnosc_populacji):
+        osobnik = wygeneruj_osobnika(zasieg, ilosc_wspolrzednych)
+        while osobnik in populacja:
+            osobnik = wygeneruj_osobnika(zasieg, ilosc_wspolrzednych)
+        populacja.append(osobnik)
+    return populacja
+
+
+def ocena_osobnika(osobnik):
+    ocena = 0
+
+    # Czy koordynaty sie nie powtarzaja
+    if len(osobnik) == len(set(osobnik)):
+        ocena += 10
+    else:
+        ocena -= 10
+
+    # Czy zachowany jest minimalny dystans miedzy koordynatami
+    for i in range(len(osobnik)):
+        for j in range(i + 1, len(osobnik)):
+            x1, y1 = osobnik[i]
+            x2, y2 = osobnik[j]
+            distance = max(abs(x2 - x1), abs(y2 - y1))
+            if distance >= 3:
+                ocena += 10
+            else: 
+                ocena -= 10
+
+    return ocena
+
+def mutacja(osobnik):
+    # mutacja poprzez zamiane randomowej pary koordynatow
+    index_osobnika = random.randint(0, len(osobnik) - 1)
+    x = random.randint(1, (EKRAN_SZEROKOSC / blockSize) - 3)
+    y = random.randint(1, (EKRAN_WYSOKOSC / blockSize) - 3)
+    osobnik[index_osobnika] = (x, y)
+
+def krzyzowanie(rodzic1, rodzic2):
+    # krzyzowanie pomiedzy dwojka rodzicow i tworzenie dziecka
+    dziecko = []
+    for i in range(len(rodzic1)):
+        dziecko.append(rodzic1[i] if random.random() < 0.5 else rodzic2[i])
+    return dziecko
+
+def ewolucja():
+
+    populacja = (wygeneruj_populacje_poczatkowa(ROZMIAR_POPULACJI))
+
+    for i in range(LICZBA_GENERACJI):
+
+        # sortowanie populacji wynikami oceny osobnikow
+        populacja = sorted(populacja, key=lambda x: ocena_osobnika(x), reverse=True)
+
+        # wybranie jedynie najlepszych osobnikow
+        rodzice = populacja[:int(ROZMIAR_POPULACJI * 0.2)]
+
+        # stworz nowa generacje poprzez krzyzowanie i mutacje
+        potomek = rodzice[:]
+        while len(potomek) < ROZMIAR_POPULACJI:
+            rodzic1 = random.choice(rodzice)
+            rodzic2 = random.choice(rodzice)
+            dziecko = krzyzowanie(rodzic1, rodzic2)
+            mutacja(dziecko)
+            potomek.append(dziecko)
+
+        populacja = potomek
+
+    return populacja[0]
+
+def print_board(osobnik):
+    board = [['-' for _ in range(EKRAN_SZEROKOSC // blockSize)] for _ in range(EKRAN_WYSOKOSC // blockSize)]
+
+    for x, y in osobnik:
+        if 0 <= x < EKRAN_SZEROKOSC // blockSize and 0 <= y < EKRAN_WYSOKOSC // blockSize:
+            board[y][x] = 'X'
+
+    for row in board:
+        print(' '.join(row))
+
+# uruchomienie algorytmu genetycznego
+# najlepszy_osobnik = ewolucja()
+# print_board(najlepszy_osobnik)

drzewo_decyzyjne.py

@@ -46,4 +46,4 @@ def stworz_plik_drzewa_w_pdf(clf, feature_names, class_names):
     graph = graphviz.Source(dot_data)
 
     # Wyświetlanie drzewa
-    graph.view()
+    graph.view()

ekran.py

@@ -108,4 +108,8 @@ def dodaj_na_rampe(p1, p2, l1, l2):
     p1.update_position(plansza.a_pix, plansza.b_pix)
     p2.update_position(plansza.a_pix, plansza.b_pix)
     l1.update_position(plansza.a_pix, plansza.b_pix)
-    l2.update_position(plansza.a_pix, plansza.b_pix)
+    l2.update_position(plansza.a_pix, plansza.b_pix)
+
+def dodaj_na_rampe_jedno(order):
+    lista_itemow.append(order)
+    order.update_position(plansza.a_pix, plansza.b_pix)

grid.py

@@ -9,16 +9,9 @@ class GridCellType(Enum):
     RACK = 1
     PLACE = 2
 
-# class RackCellType(Enum):
-#     OGROD = 0
-#     NARZEDZIA = 1
-#     KUCHNIA = 2
-#     MOTORYZACJA = 3
-
 
 class SearchGrid:
     grid: Dict[Tuple[int, int], GridCellType] = {}
-    # rack_grid : Dict[Tuple[int, int], GridCellType] = {}
 
     def __init__(self) -> None:
         self._init_grid()
@@ -31,6 +24,4 @@ class SearchGrid:
                      (x3, y3), (x3+1, y3), (x3, y3+1), (x3+1, y3+1), (x4, y4), (x4+1, y4), (x4, y4+1), (x4+1, y4+1),]:
             self.grid[(c,d)] = GridCellType.RACK
         for e, f in [(plansza.a, plansza.b),(plansza.c, plansza.d)]:
-            self.grid[(e,f)] = GridCellType.PLACE
-
-
+            self.grid[(e,f)] = GridCellType.PLACE

itemList.py

@@ -1,7 +1,5 @@
 import pygame
 
-# from paczka import Paczka
-
 class listOfItems:
     list = []
     item_group = pygame.sprite.Group()
@@ -12,15 +10,4 @@ class listOfItems:
 
     def remove(self):
         last_item = self.list.pop()
-        self.item_group.remove(last_item)
-
-
-# def zainicjuj_liste_paczek(init_x, init_y):
-#     packageList = listOfPackages()
-#     demo_paczka = Paczka('duzy', 10, any, False, True, False, any, any, any, any, any)
-#     demo_paczka.update_position(init_x, init_y)
-#     packageList.add(demo_paczka)
-#     return packageList
-
-
-
+        self.item_group.remove(last_item)

letter.py

@@ -3,9 +3,9 @@ import pygame
 letter_pic = pygame.image.load("images/letter.png")
 
 class Letter(pygame.sprite.Sprite):
-    def __init__(self, id):
+    def __init__(self, img_path):
         super().__init__()
-        self.id = id
+        self.img_path = img_path
         self.image = pygame.transform.scale(letter_pic, (40, 40))
         self.rect = self.image.get_rect()
         self.x = 430

main.py

@@ -1,4 +1,5 @@
 import sys
+import random
 
 import joblib
 import pygame
@@ -9,6 +10,7 @@ import wyszukiwanie
 import ekran
 from grid import GridCellType, SearchGrid
 import plansza
+import NeuralNetwork.prediction as prediction
 
 
 from plansza import a_pix, b_pix
@@ -17,10 +19,13 @@ pygame.init()
 
 def main():
     wozek = Wozek()
-    p1 = Paczka('duzy', 12, 'narzedzia', False, True, False, any, any, any, any, any)
-    p2 = Paczka('maly', 1, 'ogród', False, True, False, any, any, any, any, any)
-    l1 = Letter(1)
-    l2 = Letter(2)
+    pred_list = prediction.prediction_keys()
+    p1 = Paczka('duzy', 12, 'narzedzia', False, True, False,
+                any, any, any, any, any, pred_list[3])
+    p2 = Paczka('maly', 1, 'ogród', False, True, False,
+                any, any, any, any, any, pred_list[1])
+    l1 = Letter(pred_list[0])
+    l2 = Letter(pred_list[2])
     ekran.dodaj_na_rampe(p2, l1, p1, l2)
     grid_points = SearchGrid()
 
@@ -33,61 +38,18 @@ def main():
                 sys.exit(0)
             if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                 sys.exit(0)
+
             if event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_SPACE:
-                        
-                    ## wozek jedzie po itemy
-                    wiersz = ekran.sprawdz_ktory_wiersz(a_pix)
-                    kolumna = ekran.sprawdz_ktora_kolumna(b_pix)
-                    docelowy_stan = wyszukiwanie.Stan(wiersz * 70, kolumna * 70, 1)
-                    
-                    #wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan, grid_points)
-                    wezel = wyszukiwanie.wyszukiwanie_a_star(wozek.obecnyStan, docelowy_stan, grid_points)
-                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
-                    wozek.przemiesc_wozek_po_sciezce(sciezka)
+                    while len(ekran.lista_itemow) > 0:
+                        wozek_serves_orders(wozek, grid_points, drzewo)
 
-                    ## sprawdzenie czy lista itemow nie jest pusta
-                    if ekran.lista_itemow:
-                        if grid_points.grid[(wiersz, kolumna)] is GridCellType.PLACE:   #picks up item
-                            if wozek.ln == 0:
-                                wozek.picks_up_item()
-                                wozek.dynamic_wozek_picture()
-                                                      
-                                przenoszony_item = wozek.storage[-1]
-                                if isinstance(przenoszony_item,Paczka):
-                                ## wozek jedzie odlozyc paczke na regal
-                                    przenoszona_paczka = przenoszony_item
-
-                                    array, reg = przenoszona_paczka.tablica_do_drzewa(przenoszona_paczka.kategoria)
-
-                                    predictions = drzewo.predict([array])
-
-                                    if predictions == 0:
-                                        print('odklada na dolna polke!')
-                                    else:
-                                        print('odklada na gorna polke!')
-
-                                    docelowy_stan = wyszukiwanie.Stan(reg.numerWiersza * 70, reg.numerKolumny * 70, 1)
-                                    wezel = wyszukiwanie.wyszukiwanie_a_star(wozek.obecnyStan, docelowy_stan, grid_points)
-                                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
-                                    wozek.przemiesc_wozek_po_sciezce(sciezka)
-
-                                    if wozek.ln != 0:   # drops package
-                                        wozek.drops_package(przenoszona_paczka, reg, predictions)
-                                        wozek.dynamic_wozek_picture()
-                                else:
-                                #list przenoszony do skrzynki
-                                    docelowy_stan = wyszukiwanie.Stan(plansza.c_pix, plansza.d_pix, 1)
-                                    wezel = wyszukiwanie.wyszukiwanie_a_star(wozek.obecnyStan, docelowy_stan, grid_points)
-                                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
-                                    wozek.przemiesc_wozek_po_sciezce(sciezka)
-
-                                    if wozek.ln != 0:   # drops letter
-                                        wozek.drops_letter(przenoszony_item)
-                                        wozek.dynamic_wozek_picture()
+                if event.key == pygame.K_n:
+                    add_another_order(ekran, pred_list)
+                    wozek_serves_orders(wozek, grid_points, drzewo)
 
 
-            if event.type == pygame.MOUSEBUTTONDOWN: 
+            if event.type == pygame.MOUSEBUTTONDOWN:
                 # lewy przycisk myszy
                 if event.button == 1:
                     x = pygame.mouse.get_pos()[0]
@@ -95,33 +57,94 @@ def main():
                     wiersz = ekran.sprawdz_ktory_wiersz(x)
                     kolumna = ekran.sprawdz_ktora_kolumna(y)
 
-                    docelowy_stan = wyszukiwanie.Stan(wiersz * 70, kolumna * 70, 1)
-                    
-                    #wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan, grid_points)
-                    wezel = wyszukiwanie.wyszukiwanie_a_star(wozek.obecnyStan, docelowy_stan, grid_points)
+                    docelowy_stan = wyszukiwanie.Stan(
+                        wiersz * 70, kolumna * 70, 1)
+
+                    # wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan, grid_points)
+                    wezel = wyszukiwanie.wyszukiwanie_a_star(
+                        wozek.obecnyStan, docelowy_stan, grid_points)
                     sciezka = wyszukiwanie.znajdz_sciezke(wezel)
                     wozek.przemiesc_wozek_po_sciezce(sciezka)
 
-                    # if grid_points.grid[(wiersz, kolumna)] is GridCellType.PLACE:   #picks up package
-                    #     if wozek.ln == 0:
-                    #         wozek.load_package()
-                    #         wozek.dynamic_wozek_picture
-                    # else:
-                    #     if wozek.ln != 0:   # drops package
-                    #         wozek.drop_package()
-                    #         wozek.dynamic_wozek_picture()
-
-            # if event.type == pygame.KEYDOWN:
-            #     if event.key == pygame.K_SPACE:
-            #         if wozek.ln == 0:
-            #             wozek.load_package()
-            #             wozek.dynamic_wozek_picture()
-            #         else:
-            #             wozek.drop_package()
-            #             wozek.dynamic_wozek_picture()
-
         ekran.odswiez_ekran(wozek)
 
 
+
+
+def wozek_serves_orders(wozek, grid_points, drzewo):
+    # wozek jedzie po itemy
+    wiersz = ekran.sprawdz_ktory_wiersz(a_pix)
+    kolumna = ekran.sprawdz_ktora_kolumna(b_pix)
+    docelowy_stan = wyszukiwanie.Stan(wiersz * 70, kolumna * 70, 1)
+
+    # wezel = wyszukiwanie.wyszukiwanie_bfs(wozek.obecnyStan, docelowy_stan, grid_points)
+    wezel = wyszukiwanie.wyszukiwanie_a_star(
+        wozek.obecnyStan, docelowy_stan, grid_points)
+    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
+    wozek.przemiesc_wozek_po_sciezce(sciezka)
+
+    # sprawdzenie czy lista itemow nie jest pusta
+    if ekran.lista_itemow:
+        if grid_points.grid[(wiersz, kolumna)] is GridCellType.PLACE:  # picks up item
+            if wozek.ln == 0:
+                wozek.picks_up_item()
+                wozek.dynamic_wozek_picture()
+
+                przenoszony_item = wozek.storage[-1]
+                if (prediction.predict_one(przenoszony_item.img_path) == 'package'):
+                    # wozek jedzie odlozyc paczke na regal
+                    przenoszona_paczka = przenoszony_item
+
+                    array, reg = przenoszona_paczka.tablica_do_drzewa(
+                        przenoszona_paczka.kategoria)
+
+                    predictions = drzewo.predict([array])
+
+                    if predictions == 0:
+                        print('odklada na dolna polke!')
+                    else:
+                        print('odklada na gorna polke!')
+
+                    docelowy_stan = wyszukiwanie.Stan(
+                        reg.numerWiersza * 70, reg.numerKolumny * 70, 1)
+                    wezel = wyszukiwanie.wyszukiwanie_a_star(
+                        wozek.obecnyStan, docelowy_stan, grid_points)
+                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
+                    wozek.przemiesc_wozek_po_sciezce(sciezka)
+
+                    if wozek.ln != 0:   # drops package
+                        wozek.drops_package(
+                            przenoszona_paczka, reg, predictions)
+                        wozek.dynamic_wozek_picture()
+                else:
+                    # list przenoszony do skrzynki
+                    docelowy_stan = wyszukiwanie.Stan(
+                        plansza.c_pix, plansza.d_pix, 1)
+                    wezel = wyszukiwanie.wyszukiwanie_a_star(
+                        wozek.obecnyStan, docelowy_stan, grid_points)
+                    sciezka = wyszukiwanie.znajdz_sciezke(wezel)
+                    wozek.przemiesc_wozek_po_sciezce(sciezka)
+
+                    if wozek.ln != 0:   # drops letter
+                        wozek.drops_letter(przenoszony_item)
+                        wozek.dynamic_wozek_picture()
+
+def add_another_order(ekran, pred_list):
+    if random.random() < 0.5:
+        if random.random() < 0.5:
+            order = Paczka('duzy', 12, 'motoryzacja', False, True, False,
+                any, any, any, any, any, pred_list[6])
+        else:
+            order = Paczka('maly', 1, 'kuchnia', False, True, False,
+                any, any, any, any, any, pred_list[7])
+    else:
+        if random.random() < 0.5:
+            order = Letter(pred_list[5])
+        else:
+            order = Letter(pred_list[4])
+    
+    ekran.dodaj_na_rampe_jedno(order)
+        
+
 if __name__ == "__main__":
     main()

paczka.py

@@ -4,7 +4,7 @@ import ekran
 
 
 class Paczka(pygame.sprite.Sprite):
-    def __init__(self, rozmiar, waga, kategoria, priorytet, ksztalt, kruchosc, nadawca, adres, imie, nazwisko, telefon):
+    def __init__(self, rozmiar, waga, kategoria, priorytet, ksztalt, kruchosc, nadawca, adres, imie, nazwisko, telefon, img_path):
         super().__init__()
         self.rozmiar = rozmiar
         self.image = pygame.image.load("images/paczka.png")
@@ -31,6 +31,7 @@ class Paczka(pygame.sprite.Sprite):
         self.priorytet = priorytet
         self.ksztalt = ksztalt
         self.kruchosc = kruchosc
+        self.img_path = img_path
         self.x = 430
         self.y = 400
         self.label = Etykieta(nadawca, adres, imie, nazwisko, telefon, priorytet)

plansza.py

@@ -1,4 +1,4 @@
-import random
+import algorytm_genetyczny as genetic
 
 def obliczPixeleNaPodstawieKratek(wymiar): #Przeliczanie współrzędnych podanych w kratkach na pixele
     i = 1
@@ -17,45 +17,11 @@ blockSize = 70
 
 x1, y1, x2, y2, x3, y3, x4, y4 = [None] * 8
 
-while True:
+najlepszy_osobnik = genetic.ewolucja()
+print("Generowana plansza:")
+genetic.print_board(najlepszy_osobnik)
 
-    #wspolrzedne regalow
-    x1 = random.randint(1, 3)
-    x2 = random.randint(1, 3)
-    x3 = random.randint(6, 8)
-    x4 = random.randint(6, 8)
-
-    y1 = random.randint(1, 3)
-    y2 = random.randint(6, 8)
-    y3 = random.randint(1, 3)
-    y4 = random.randint(6, 8)
-
-    #wspolrzedne miejsca paczek
-    a = 5
-    b = 5
-
-    #wspolrzedne skrzynki na listy
-    c = 5
-    d = 0
-    
-    #dodane wspolrzedne (0, 0), (4, 4), (4, 6), (6, 4), (6, 6) zeby regaly sie nie stykaly
-    table = [(0, 0), (4, 4), (4, 6), (6, 4), (6, 6),
-              (x1, y1), (x1+1, y1), (x1, y1+1), (x1+1, y1+1),
-              (x2, y2), (x2+1, y2), (x2, y2+1), (x2+1, y2+1),
-              (x3, y3), (x3+1, y3), (x3, y3+1), (x3+1, y3+1),
-              (x4, y4), (x4+1, y4), (x4, y4+1), (x4+1, y4+1)]
-    
-    #sprawdzenie czy jakies wspolrzedne sie pokrywaja
-    if len(table) == len(set(table)):
-        break
-
-coordinates = [(x1, y1), (x2, y2), (x3, y3), (x4, y4)]
-
-#przemieszanie koordynatów w parach
-random.shuffle(coordinates)
-
-#przypisanie przemieszanych wartości do zmiennych
-(x1, y1), (x2, y2), (x3, y3), (x4, y4) = coordinates
+(x1, y1), (x2, y2), (x3, y3), (x4, y4), (a, b), (c, d) = najlepszy_osobnik[:6] 
 
 x1, x2, x3, x4, y1, y2, y3, y4 = map(int, [x1, x2, x3, x4, y1, y2, y3, y4])
 

regal.py

@@ -4,7 +4,6 @@ MAX_STORAGE = 3
 
 def obliczPixeleNaPodstawieKratek(wymiar): #Przeliczanie współrzędnych podanych w kratkach na pixele
     i = 1
-    # pixele = 100
     pixele = 73
     while (i < wymiar):
         pixele = pixele + 70
@@ -33,13 +32,6 @@ class Regal(pygame.sprite.Sprite):
         self.kolumna = obliczPixeleNaPodstawieKratek(numerKolumny)
         self.dlugosc = obliczPixeleDlugosciRegalu(self)
 
-        package_storage = []
-        shelfs = {                      # here packages are stored 
-            "dolna": package_storage,
-            "gorna": package_storage
-        }
-        
-        
         storage_dolna = []
         storage_gorna = []
 
@@ -89,7 +81,4 @@ class Regal(pygame.sprite.Sprite):
         if(where == 0):
             self.dolna.append(package)
         else:
-            self.gorna.append(package)
-    
-    
-
+            self.gorna.append(package)

wozek.py

@@ -1,6 +1,5 @@
 import ekran
-import pygame,math
-# from packageList import listOfPackages
+import pygame
 from ekran import lista_itemow
 from letter import Letter
 import plansza
@@ -13,40 +12,19 @@ class Wozek(pygame.sprite.Sprite):
         self.obecnyStan = None
         self.height = 64
         self.width = 64
-        self.image = pygame.image.load("images/pusty_wozek.png")
-        self.rect = self.image.get_rect()
         # Credit: Forklift icons created by Smashicons - Flaticon
         # https://www.flaticon.com/free-icons/forklift
+        self.image = pygame.image.load("images/pusty_wozek.png")
+        self.rect = self.image.get_rect()
         self.__zainicjuj_stan_poczatkowy()
 
     def draw(self):
         ekran.screen.blit(self.image, (self.obecnyStan.x, self.obecnyStan.y))
-        # self.update_position(self.obecnyStan.x, self.obecnyStan.y)
 
-    #storage = ["none"] * 10 
     storage = []
     max_size = 10
     ln = len(storage)
 
-    def add_element(self, element):
-        if self.ln < self.max_size:
-            self.storage.append(element)
-            self.ln=self.ln+1
-        else:
-            print("I'm full!")
-    def remove_element(self):
-        if self.ln > 0:
-            element = self.storage.pop()
-            self.ln=self.ln-1
-            return element
-        else:
-            print("I'm empty!")
-    
-    def update_position(self, x, y):
-        self.obecnyStan.x = x
-        self.obecnyStan.y = y
-        self.rect.topleft = (x, y)
-    
     def dynamic_wozek_picture(self):
         if self.ln == 0:
             self.image = pygame.image.load("images/pusty_wozek.png")
@@ -57,38 +35,7 @@ class Wozek(pygame.sprite.Sprite):
         elif (self.ln == 10):
             self.image = pygame.image.load("images/pelny_wozek_full_3_crates.png")
         
-        self.rect = self.image.get_rect()
-
-
-    def load_package(self):
-        #for package in listOfPackages.list:
-        # for package in listOfPackages:
-        #     dist = math.sqrt((self.obecnyStan.x - package.x)**2 + (self.obecnyStan.y - package.y)**2)
-        #     if dist <= 50:
-        #         self.add_element(package)
-        #         # listOfPackages.list.pop()
-        #         listOfPackages.pop()
-        package = listOfPackages.pop()
-        dist = math.sqrt((self.obecnyStan.x - package.x)**2 + (self.obecnyStan.y - package.y)**2)
-        if dist <= 50:
-            self.add_element(package)
-                # listOfPackages.list.pop()               
-
-    def load_packages_collision(self):
-        pass
-        # packages_collision = pygame.sprite.spritecollide(self, listOfPackages.package_group, False)
-        # if packages_collision:
-        #     for package in packages_collision:
-        #         self.add_element(package)
-        #         listOfPackages.list.remove(package)       # collision doesn't work, collision always happens
-
-    def drop_package(self):
-        package = self.remove_element()
-        if package is not None:
-            package.x = self.obecnyStan.x
-            package.y = self.obecnyStan.y
-            # listOfPackages.list.append(package)
-            listOfPackages.append(package)
+        self.rect = self.image.get_rect()           
 
     def __zainicjuj_stan_poczatkowy(self):
         from wyszukiwanie import Stan