ID3.py

@@ -1,185 +0,0 @@
-import pandas as pd
-import numpy as np
-from data import dataset
-
-training_data = pd.DataFrame(data=dataset.training_data, columns=dataset.header)
-testing_data = pd.DataFrame(data=dataset.testing_data, columns=dataset.header)
-
-
-def entropy(target_col):
-    """
-    Obliczenie warości entropii dla wskazanej kolumny
-    """
-    values, counts = np.unique(target_col, return_counts=True)
-    entropy = np.sum(
-        [(-counts[i] / np.sum(counts)) * np.log2(counts[i] / np.sum(counts)) for i in range(len(values))])
-    return entropy
-
-
-def info_gain(data, split_attribute_name, target_name="label"):
-    """
-    Obliczenie wartości przyrostu informacji dla wskazanego atrybutu (split_attribute_name)
-     w podanym zbiorze (data)
-    """
-
-    # Wartość entropii zbioru
-    total_entropy = entropy(data[target_name])
-
-    # Wyodrębnienie poszczególnych "podzbiorów"
-    vals, counts = np.unique(data[split_attribute_name], return_counts=True)
-
-    # Średnia ważona entropii każdego podzbioru
-    weighted_entropy = np.sum(
-        [(counts[i] / np.sum(counts)) * entropy(data.where(data[split_attribute_name] == vals[i]).dropna()[target_name])
-         for i in range(len(vals))])
-
-    # Przyrost informacji
-    information_gain = total_entropy - weighted_entropy
-
-    return information_gain
-
-
-def ID3(data, original_data, features, target_attribute_name="label", parent_node_class=None):
-    """
-    Algorytm ID3
-
-    parametry:
-        data                    zbiór danych, dla którego poszukujemy drzewa decyzyjnego
-        original_data           oryginalny zbiór danych (zwracany gdy data == None)
-        features                lista atrybutów wejściowego zbioru
-        target_attribute_name   docelowy atrybut, który chcemy przewidzieć
-        parent_node_class       nadrzędna wartość
-    """
-
-    # Jeżeli wszystkie atrybuty są takie same, zwracamy liść z pierwszą napotkaną wartością
-
-    if len(np.unique(data[target_attribute_name])) <= 1:
-        return np.unique(data[target_attribute_name])[0]
-
-    elif len(data) == 0:
-        return np.unique(original_data[target_attribute_name])[
-            np.argmax(np.unique(original_data[target_attribute_name], return_counts=True)[1])]
-
-    elif len(features) == 0:
-        return parent_node_class
-
-    else:
-
-        # Aktualizacja nadrzędnej wartości
-        parent_node_class = np.unique(data[target_attribute_name])[
-            np.argmax(np.unique(data[target_attribute_name], return_counts=True)[1])]
-
-        # Obliczenie przyrostu informacji dla każdego potencjalnego atrybutu,
-        # według którego nastąpi podział zbioru
-        item_values = [info_gain(data, feature, target_attribute_name) for feature in
-                       features]
-
-        # Najlepszym atrybutem jest ten o największym przyroście informacji
-        best_feature_index = np.argmax(item_values)
-        best_feature = features[best_feature_index]
-
-        # Struktura drzewa
-        tree = {best_feature: {}}
-
-        # Aktualizacja zbioru atrybutów
-        features = [i for i in features if i != best_feature]
-
-        # Dla każdej wartości wybranego atrybutu budujemy kolejne poddrzewo
-        for value in np.unique(data[best_feature]):
-
-            sub_data = data.where(data[best_feature] == value).dropna()
-            subtree = ID3(sub_data, data, features, target_attribute_name, parent_node_class)
-
-            tree[best_feature][value] = subtree
-
-        return (tree)
-
-
-def predict(query, tree, default='none'):
-    """
-    Przeszukiwanie drzewa w celu przewidzenia wartości atrybutu "label".
-    W przypadku, gdy dane wejściowe nie pokrywają się z żadnymi wartościami w drzewie
-    (np pH ziemi zostanie sklasyfikowane jako 'strongly acidic', a dane uczące nie obejmują rekordów dla takiej wartości),
-    wówczas przewidywana zostaje wartość domyślna.
-    """
-
-    for key in list(query.keys()):
-        if key in list(tree.keys()):
-            try:
-                result = tree[key][query[key]]
-            except:
-                return default
-            result = tree[key][query[key]]
-            if isinstance(result, dict):
-                return predict(query, result)
-
-            else:
-                return result
-
-
-def test(data, tree):
-    # Wartości docelowych atrybutów (nazwy warzyw) zostają usunięte
-    queries = data.iloc[:, :-1].to_dict(orient="records")
-
-    # Przewidywane wartości atrybutów
-    predicted = pd.DataFrame(columns=["predicted"])
-
-    # Obliczenie precyzji przewidywań
-    for i in range(len(data)):
-        predicted.loc[i, "predicted"] = predict(queries[i], tree, 'mushroom')
-    print('Precyzja przewidywań: ', (np.sum(predicted["predicted"] == data["label"]) / len(data)) * 100, '%')
-
-
-def predict_data(data):
-    """
-    Funkcja dostosowana do formatu danych, jakimi dysponuje traktor
-    'data' jest tutaj listą, która zostaje przekonwertowana do postaci słownika,
-    aby możliwe było wywołanie procedury 'predict'.
-    Wyniki zostają zwrócone w postaci listy.
-    """
-    parse_data = [[data[0], categorize_pH(data[1]), categorize_dry_level(data[2]), '']]
-    #print(parse_data)
-
-    queries = pd.DataFrame(data=parse_data, columns=dataset.header)
-    predicted = pd.DataFrame(columns=["predicted"])
-    dict = queries.iloc[:, :-1].to_dict(orient="records")
-
-    for i in range(len(parse_data)):
-        predicted.loc[i, "predicted"] = predict(dict[i], tree, 'mushroom')
-
-    predicted_list = predicted.values.tolist()
-    print("Planted: ", predicted_list[0][0])
-    return predicted_list[0][0]
-
-
-def categorize_pH(pH):
-    if pH <= 4.5:
-        return 'strongly acidic'
-    if 4.5 < pH <= 5.5:
-        return 'acidic'
-    if 5.5 < pH <= 6.5:
-        return 'slightly acidic'
-    if 6.5 < pH <= 7.2:
-        return 'neutral'
-    if 7.2 < pH:
-        return 'alkaline'
-
-
-def categorize_dry_level(dry_level):
-    if dry_level <= 0.1:
-        return 'soaking wet'
-    if 0.1 < dry_level <= 0.4:
-        return 'wet'
-    if 0.4 < dry_level <= 0.6:
-        return 'medium wet'
-    if 0.6 < dry_level <= 0.8:
-        return 'dry'
-    if 0.8 < dry_level:
-        return 'very dry'
-
-
-# tworzenie, wyświetlanie i testowanie drzewa
-
-tree = ID3(training_data, training_data, training_data.columns[:-1])
-#pprint(tree)
-#test(testing_data, tree)

README.md

@@ -1,8 +1,5 @@
 # AIProjekt
 
-## Final
-[final-evaluation](final-evaluation.md)
-
 ## Spis treści
 * [Uruchomienie](#uruchomienie)
 * [Wykrywanie roślin](#wykrywanie-roślin)

adamski_raport.md

@@ -22,8 +22,8 @@ Klasyfikator działa w głównej pętli while w pliku main.py. Uruchamia się gd
 Gdy klasyfikator zakończy swoje działanie, w konsoli pojawia się najbardziej prawdopodobny obiekt znajdujący się na zdjęciu. Zdjęcie pojawia się w osobnym oknie. Po zamknięciu okna mozemy kontynuować sterowanie traktorem za pomocą strzałek.
 
 ## Działanie
-![uczenie](../ss/adamski2.png) <br>
+![uczenie](ss/adamski2.png) <br>
-![dzialanie](../ss/adamski1.png)
+![dzialanie](ss/adamski1.png)
 
 ## Uruchomienie
 Instalacja tensorflow <br>

beetroot.py

@@ -0,0 +1,38 @@
+from plant import Plant
+from datetime import datetime
+
+class Beetroot(Plant):
+    
+    def __init__(self):
+        super().__init__()
+        self._wasFertilized = False #roslina nie byla nawozona przy tworzeniu
+
+    def add_soil(self, soil):
+        super().add_soil()
+        self._starttime = datetime.now()
+
+    #zwraca czy zbierać rośline
+    def collect(self):
+        if self.have_soil():
+            self.__growing()
+            if self._collect < 95:
+                return 'False'
+            elif 95 <= self._collect <= 115:
+                return 'True'
+            elif self._collect > 115:
+                return 'Delete'
+
+    #zwraca czy nawozić
+    def fertillizing(self):
+        if 35 <= self._collect <= 50:
+            return True
+        else:
+            return False
+        
+    #każde iles czasu zwieksza wzrost rosliny, wywolywana w momencie sprawdzania czy roslina jest gotowa do zbiorow
+    def __growing(self):
+        checktime = datetime.now()
+        delta = checktime - self._starttime
+        a = delta // 40
+        self._collect += a
+        self._starttime = checktime

cabbage.py

@@ -0,0 +1,38 @@
+from plant import Plant
+from datetime import datetime
+
+class Cabbage(Plant):
+    
+    def __init__(self):
+        super().__init__()
+        self._wasFertilized = False #roslina nie byla nawozona przy tworzeniu
+
+    def add_soil(self, soil):
+        super().add_soil()
+        self._starttime = datetime.now()
+
+    #zwraca czy zbierać rośline
+    def collect(self):
+        if self.have_soil():
+            self.__growing()
+            if self._collect < 85:
+                return 'False'
+            elif 85 <= self._collect <= 100:
+                return 'True'
+            elif self._collect > 100:
+                return 'Delete'
+
+    #zwraca czy nawozić
+    def fertillizing(self):
+        if 30 <= self._collect <= 45:
+            return True
+        else:
+            return False
+        
+    #każde iles czasu zwieksza wzrost rosliny, wywolywana w momencie sprawdzania czy roslina jest gotowa do zbiorow
+    def __growing(self):
+        checktime = datetime.now()
+        delta = checktime - self._starttime
+        a = delta // 70
+        self._collect += a
+        self._starttime = checktime

carrot.py

@@ -0,0 +1,38 @@
+from plant import Plant
+from datetime import datetime
+
+class Carrot(Plant):
+    
+    def __init__(self, name, ID):
+        super().__init__(name, ID)
+        self._wasFertilized = False #roslina nie byla nawozona przy tworzeniu
+
+    def add_soil(self, soil):
+        super().add_soil()
+        self._starttime = datetime.now()
+
+    #zwraca czy zbierać rośline
+    def collect(self):
+        if self.have_soil():
+            self.__growing()
+            if self._collect < 90:
+                return 'False'
+            elif 90 <= self._collect <= 105:
+                return 'True'
+            elif self._collect > 105:
+                return 'Delete'
+
+    #zwraca czy nawozić
+    def fertillizing(self):
+        if 30 <= self._collect <= 50:
+            return True
+        else:
+            return False
+        
+    #każde iles czasu zwieksza wzrost rosliny, wywolywana w momencie sprawdzania czy roslina jest gotowa do zbiorow
+    def __growing(self):
+        checktime = datetime.now()
+        delta = checktime - self._starttime
+        a = delta // 60
+        self._collect += a
+        self._starttime = checktime

data.csv

@@ -1,209 +0,0 @@
-PLANT,HUMIDITY,GROWTH,DRYNESS,DEC
-CAULIFLOWER,43,94,4,YES
-CABBAGE,17,99,9,NO
-CABBAGE,25,106,11,NO
-CABBAGE,47,118,17,NO
-CABBAGE,22,103,19,NO
-CABBAGE,55,112,20,NO
-CABBAGE,13,110,22,NO
-CABBAGE,20,100,22,NO
-CABBAGE,11,113,25,NO
-CABBAGE,55,95,26,NO
-CABBAGE,12,109,27,NO
-CABBAGE,18,119,28,NO
-CABBAGE,29,90,29,NO
-CAULIFLOWER,23,99,30,NO
-MUSHROOM,53,94,30,NO
-CAULIFLOWER,28,120,31,NO
-MUSHROOM,29,91,34,NO
-CAULIFLOWER,34,121,34,NO
-CAULIFLOWER,33,110,36,NO
-MUSHROOM,52,102,36,NO
-CAULIFLOWER,52,116,36,NO
-CAULIFLOWER,26,118,37,NO
-MUSHROOM,59,112,41,NO
-MUSHROOM,51,90,42,NO
-MUSHROOM,22,91,43,NO
-CAULIFLOWER,62,114,43,NO
-CAULIFLOWER,78,97,43,NO
-MUSHROOM,60,92,44,NO
-CAULIFLOWER,88,112,44,NO
-CAULIFLOWER,12,111,45,NO
-CAULIFLOWER,53,113,48,NO
-CAULIFLOWER,68,104,51,NO
-MUSHROOM,7,117,52,NO
-CAULIFLOWER,51,113,54,NO
-PUMPKIN,20,89,69,YES
-CAULIFLOWER,16,102,55,NO
-PUMPKIN,21,63,23,YES
-MUSHROOM,13,111,56,NO
-CAULIFLOWER,22,95,57,NO
-MUSHROOM,8,104,58,NO
-PUMPKIN,23,26,19,YES
-CAULIFLOWER,58,106,62,NO
-PUMPKIN,24,68,7,YES
-PUMPKIN,25,66,96,NO
-CAULIFLOWER,55,99,63,NO
-MUSHROOM,74,104,67,NO
-PUMPKIN,28,34,68,YES
-CAULIFLOWER,57,102,68,NO
-PUMPKIN,29,29,61,YES
-PUMPKIN,46,90,70,NO
-CABBAGE,46,93,70,NO
-CAULIFLOWER,29,105,71,NO
-PUMPKIN,30,28,31,YES
-MUSHROOM,30,67,24,YES
-PUMPKIN,30,96,30,NO
-CABBAGE,30,89,30,YES
-CABBAGE,31,62,40,YES
-PUMPKIN,31,65,34,YES
-MUSHROOM,31,81,17,YES
-MUSHROOM,31,89,29,YES
-MUSHROOM,32,20,19,YES
-CABBAGE,32,25,50,YES
-MUSHROOM,32,90,22,NO
-MUSHROOM,32,56,7,YES
-CABBAGE,33,15,50,YES
-MUSHROOM,33,32,14,YES
-PUMPKIN,33,47,59,YES
-PUMPKIN,19,99,72,NO
-MUSHROOM,33,63,30,NO
-CABBAGE,33,65,64,YES
-CABBAGE,34,27,44,YES
-CABBAGE,34,44,93,NO
-MUSHROOM,34,44,22,YES
-PUMPKIN,51,99,72,NO
-CABBAGE,34,56,70,NO
-MUSHROOM,34,56,18,YES
-CABBAGE,35,21,63,YES
-PUMPKIN,35,42,48,YES
-CAULIFLOWER,35,74,12,YES
-PUMPKIN,35,76,71,NO
-CAULIFLOWER,36,58,28,YES
-CABBAGE,36,57,54,YES
-CAULIFLOWER,36,72,84,NO
-CAULIFLOWER,36,83,71,NO
-CABBAGE,36,67,64,YES
-PUMPKIN,36,82,53,YES
-CABBAGE,37,47,57,YES
-MUSHROOM,37,59,13,YES
-CAULIFLOWER,37,40,15,YES
-CAULIFLOWER,37,69,16,YES
-CABBAGE,37,63,60,YES
-PUMPKIN,37,72,46,YES
-CABBAGE,38,62,79,NO
-CAULIFLOWER,38,98,12,NO
-CAULIFLOWER,38,59,22,YES
-PUMPKIN,38,73,56,YES
-CABBAGE,38,74,52,YES
-PUMPKIN,38,90,39,NO
-MUSHROOM,38,78,9,YES
-CABBAGE,39,86,64,NO
-PUMPKIN,39,31,45,YES
-PUMPKIN,39,102,53,NO
-CAULIFLOWER,39,49,14,YES
-CAULIFLOWER,39,54,81,NO
-CABBAGE,39,87,57,NO
-CABBAGE,40,8,32,YES
-PUMPKIN,40,57,63,YES
-CABBAGE,40,92,61,NO
-CAULIFLOWER,40,52,27,YES
-PUMPKIN,41,8,29,YES
-CABBAGE,41,25,48,YES
-CABBAGE,41,43,51,YES
-CABBAGE,41,52,60,YES
-CAULIFLOWER,41,20,24,YES
-MUSHROOM,41,83,25,YES
-CABBAGE,41,85,37,YES
-CABBAGE,42,64,41,YES
-MUSHROOM,42,66,26,YES
-CABBAGE,42,69,59,YES
-CAULIFLOWER,42,38,9,YES
-MUSHROOM,43,15,9,YES
-MUSHROOM,43,93,22,NO
-CABBAGE,43,60,38,YES
-PUMPKIN,43,78,43,YES
-CAULIFLOWER,43,29,18,YES
-CAULIFLOWER,43,96,20,NO
-CAULIFLOWER,43,84,4,YES
-CABBAGE,61,130,72,NO
-CABBAGE,44,59,31,YES
-PUMPKIN,44,64,44,YES
-CAULIFLOWER,44,62,19,YES
-CABBAGE,45,35,69,YES
-MUSHROOM,45,65,27,YES
-MUSHROOM,45,71,2,YES
-PUMPKIN,45,83,57,YES
-CAULIFLOWER,45,31,26,YES
-CAULIFLOWER,45,61,10,YES
-CAULIFLOWER,45,76,85,NO
-MUSHROOM,46,48,24,YES
-MUSHROOM,10,96,73,NO
-CABBAGE,62,123,74,NO
-MUSHROOM,47,37,16,YES
-MUSHROOM,47,42,41,NO
-CAULIFLOWER,47,50,11,YES
-PUMPKIN,11,99,75,NO
-CABBAGE,16,98,75,NO
-MUSHROOM,48,77,12,YES
-CABBAGE,48,106,75,NO
-CAULIFLOWER,48,32,23,YES
-CAULIFLOWER,48,44,19,YES
-CAULIFLOWER,48,98,14,NO
-CABBAGE,8,124,76,NO
-MUSHROOM,49,64,4,YES
-PUMPKIN,59,114,76,NO
-PUMPKIN,50,119,77,NO
-CABBAGE,55,116,77,NO
-MUSHROOM,50,74,21,YES
-CAULIFLOWER,50,47,25,YES
-CABBAGE,53,117,78,NO
-PUMPKIN,55,91,78,NO
-PUMPKIN,49,91,79,NO
-CABBAGE,56,125,79,NO
-MUSHROOM,57,95,79,NO
-PUMPKIN,8,123,80,NO
-MUSHROOM,16,99,80,NO
-PUMPKIN,55,93,80,NO
-CABBAGE,60,99,80,NO
-MUSHROOM,13,114,81,NO
-CAULIFLOWER,20,100,81,NO
-CABBAGE,49,100,81,NO
-PUMPKIN,54,92,81,NO
-CABBAGE,10,94,83,NO
-PUMPKIN,17,91,83,NO
-CAULIFLOWER,17,95,84,NO
-PUMPKIN,53,92,84,NO
-MUSHROOM,65,110,85,NO
-PUMPKIN,73,101,85,NO
-PUMPKIN,18,102,88,NO
-PUMPKIN,47,120,88,NO
-PUMPKIN,48,102,89,NO
-MUSHROOM,60,98,89,NO
-CABBAGE,68,120,89,NO
-CABBAGE,58,16,26,NO
-MUSHROOM,53,107,90,NO
-CABBAGE,8,92,92,NO
-MUSHROOM,11,97,92,NO
-PUMPKIN,14,98,92,NO
-CAULIFLOWER,58,103,92,NO
-CABBAGE,59,131,92,NO
-PUMPKIN,57,104,93,NO
-MUSHROOM,67,97,93,NO
-CABBAGE,3,107,94,NO
-PUMPKIN,17,104,94,NO
-PUMPKIN,17,94,96,NO
-CABBAGE,56,101,96,NO
-PUMPKIN,58,95,97,NO
-MUSHROOM,80,93,97,NO
-PUMPKIN,10,105,99,NO
-PUMPKIN,50,121,99,NO
-PUMPKIN,9,97,100,NO
-PUMPKIN,12,95,102,NO
-PUMPKIN,16,97,103,NO
-PUMPKIN,60,107,107,NO
-PUMPKIN,58,107,109,NO
-PUMPKIN,13,96,111,NO
-PUMPKIN,61,111,113,NO
-PUMPKIN,49,110,116,NO
-PUMPKIN,64,112,120,NO

data/data.csv

@@ -1,209 +0,0 @@
-PLANT,FEED,GROWTH,DRYNESS,DEC
-BEETROOT,43,94,4,YES
-CABBAGE,17,99,9,NO
-CABBAGE,25,106,11,NO
-CABBAGE,47,118,17,NO
-CABBAGE,22,103,19,NO
-CABBAGE,55,112,20,NO
-CABBAGE,13,110,22,NO
-CABBAGE,20,100,22,NO
-CABBAGE,11,113,25,NO
-CABBAGE,55,95,26,NO
-CABBAGE,12,109,27,NO
-CABBAGE,18,119,28,NO
-CABBAGE,29,90,29,NO
-BEETROOT,23,99,30,NO
-CARROT,53,94,30,NO
-BEETROOT,28,120,31,NO
-CARROT,29,91,34,NO
-BEETROOT,34,121,34,NO
-BEETROOT,33,110,36,NO
-CARROT,52,102,36,NO
-BEETROOT,52,116,36,NO
-BEETROOT,26,118,37,NO
-CARROT,59,112,41,NO
-CARROT,51,90,42,NO
-CARROT,22,91,43,NO
-BEETROOT,62,114,43,NO
-BEETROOT,78,97,43,NO
-CARROT,60,92,44,NO
-BEETROOT,88,112,44,NO
-BEETROOT,12,111,45,NO
-BEETROOT,53,113,48,NO
-BEETROOT,68,104,51,NO
-CARROT,7,117,52,NO
-BEETROOT,51,113,54,NO
-PUMPKIN,20,89,69,YES
-BEETROOT,16,102,55,NO
-PUMPKIN,21,63,23,YES
-CARROT,13,111,56,NO
-BEETROOT,22,95,57,NO
-CARROT,8,104,58,NO
-PUMPKIN,23,26,19,YES
-BEETROOT,58,106,62,NO
-PUMPKIN,24,68,7,YES
-PUMPKIN,25,66,96,NO
-BEETROOT,55,99,63,NO
-CARROT,74,104,67,NO
-PUMPKIN,28,34,68,YES
-BEETROOT,57,102,68,NO
-PUMPKIN,29,29,61,YES
-PUMPKIN,46,90,70,NO
-CABBAGE,46,93,70,NO
-BEETROOT,29,105,71,NO
-PUMPKIN,30,28,31,YES
-CARROT,30,67,24,YES
-PUMPKIN,30,96,30,NO
-CABBAGE,30,89,30,YES
-CABBAGE,31,62,40,YES
-PUMPKIN,31,65,34,YES
-CARROT,31,81,17,YES
-CARROT,31,89,29,YES
-CARROT,32,20,19,YES
-CABBAGE,32,25,50,YES
-CARROT,32,90,22,NO
-CARROT,32,56,7,YES
-CABBAGE,33,15,50,YES
-CARROT,33,32,14,YES
-PUMPKIN,33,47,59,YES
-PUMPKIN,19,99,72,NO
-CARROT,33,63,30,NO
-CABBAGE,33,65,64,YES
-CABBAGE,34,27,44,YES
-CABBAGE,34,44,93,NO
-CARROT,34,44,22,YES
-PUMPKIN,51,99,72,NO
-CABBAGE,34,56,70,NO
-CARROT,34,56,18,YES
-CABBAGE,35,21,63,YES
-PUMPKIN,35,42,48,YES
-BEETROOT,35,74,12,YES
-PUMPKIN,35,76,71,NO
-BEETROOT,36,58,28,YES
-CABBAGE,36,57,54,YES
-BEETROOT,36,72,84,NO
-BEETROOT,36,83,71,NO
-CABBAGE,36,67,64,YES
-PUMPKIN,36,82,53,YES
-CABBAGE,37,47,57,YES
-CARROT,37,59,13,YES
-BEETROOT,37,40,15,YES
-BEETROOT,37,69,16,YES
-CABBAGE,37,63,60,YES
-PUMPKIN,37,72,46,YES
-CABBAGE,38,62,79,NO
-BEETROOT,38,98,12,NO
-BEETROOT,38,59,22,YES
-PUMPKIN,38,73,56,YES
-CABBAGE,38,74,52,YES
-PUMPKIN,38,90,39,NO
-CARROT,38,78,9,YES
-CABBAGE,39,86,64,NO
-PUMPKIN,39,31,45,YES
-PUMPKIN,39,102,53,NO
-BEETROOT,39,49,14,YES
-BEETROOT,39,54,81,NO
-CABBAGE,39,87,57,NO
-CABBAGE,40,8,32,YES
-PUMPKIN,40,57,63,YES
-CABBAGE,40,92,61,NO
-BEETROOT,40,52,27,YES
-PUMPKIN,41,8,29,YES
-CABBAGE,41,25,48,YES
-CABBAGE,41,43,51,YES
-CABBAGE,41,52,60,YES
-BEETROOT,41,20,24,YES
-CARROT,41,83,25,YES
-CABBAGE,41,85,37,YES
-CABBAGE,42,64,41,YES
-CARROT,42,66,26,YES
-CABBAGE,42,69,59,YES
-BEETROOT,42,38,9,YES
-CARROT,43,15,9,YES
-CARROT,43,93,22,NO
-CABBAGE,43,60,38,YES
-PUMPKIN,43,78,43,YES
-BEETROOT,43,29,18,YES
-BEETROOT,43,96,20,NO
-BEETROOT,43,84,4,YES
-CABBAGE,61,130,72,NO
-CABBAGE,44,59,31,YES
-PUMPKIN,44,64,44,YES
-BEETROOT,44,62,19,YES
-CABBAGE,45,35,69,YES
-CARROT,45,65,27,YES
-CARROT,45,71,2,YES
-PUMPKIN,45,83,57,YES
-BEETROOT,45,31,26,YES
-BEETROOT,45,61,10,YES
-BEETROOT,45,76,85,NO
-CARROT,46,48,24,YES
-CARROT,10,96,73,NO
-CABBAGE,62,123,74,NO
-CARROT,47,37,16,YES
-CARROT,47,42,41,NO
-BEETROOT,47,50,11,YES
-PUMPKIN,11,99,75,NO
-CABBAGE,16,98,75,NO
-CARROT,48,77,12,YES
-CABBAGE,48,106,75,NO
-BEETROOT,48,32,23,YES
-BEETROOT,48,44,19,YES
-BEETROOT,48,98,14,NO
-CABBAGE,8,124,76,NO
-CARROT,49,64,4,YES
-PUMPKIN,59,114,76,NO
-PUMPKIN,50,119,77,NO
-CABBAGE,55,116,77,NO
-CARROT,50,74,21,YES
-BEETROOT,50,47,25,YES
-CABBAGE,53,117,78,NO
-PUMPKIN,55,91,78,NO
-PUMPKIN,49,91,79,NO
-CABBAGE,56,125,79,NO
-CARROT,57,95,79,NO
-PUMPKIN,8,123,80,NO
-CARROT,16,99,80,NO
-PUMPKIN,55,93,80,NO
-CABBAGE,60,99,80,NO
-CARROT,13,114,81,NO
-BEETROOT,20,100,81,NO
-CABBAGE,49,100,81,NO
-PUMPKIN,54,92,81,NO
-CABBAGE,10,94,83,NO
-PUMPKIN,17,91,83,NO
-BEETROOT,17,95,84,NO
-PUMPKIN,53,92,84,NO
-CARROT,65,110,85,NO
-PUMPKIN,73,101,85,NO
-PUMPKIN,18,102,88,NO
-PUMPKIN,47,120,88,NO
-PUMPKIN,48,102,89,NO
-CARROT,60,98,89,NO
-CABBAGE,68,120,89,NO
-CABBAGE,58,16,26,NO
-CARROT,53,107,90,NO
-CABBAGE,8,92,92,NO
-CARROT,11,97,92,NO
-PUMPKIN,14,98,92,NO
-BEETROOT,58,103,92,NO
-CABBAGE,59,131,92,NO
-PUMPKIN,57,104,93,NO
-CARROT,67,97,93,NO
-CABBAGE,3,107,94,NO
-PUMPKIN,17,104,94,NO
-PUMPKIN,17,94,96,NO
-CABBAGE,56,101,96,NO
-PUMPKIN,58,95,97,NO
-CARROT,80,93,97,NO
-PUMPKIN,10,105,99,NO
-PUMPKIN,50,121,99,NO
-PUMPKIN,9,97,100,NO
-PUMPKIN,12,95,102,NO
-PUMPKIN,16,97,103,NO
-PUMPKIN,60,107,107,NO
-PUMPKIN,58,107,109,NO
-PUMPKIN,13,96,111,NO
-PUMPKIN,61,111,113,NO
-PUMPKIN,49,110,116,NO
-PUMPKIN,64,112,120,NO

data/dataset.py

@@ -1,71 +0,0 @@
-header = ['previous', 'soil pH', 'dry level', 'label']
-
-training_data = [
-    ['mushroom', 'alkaline', 'dry', 'cauliflower'],
-    ['mushroom', 'slightly acidic', 'dry', 'cauliflower'],
-    ['cabbage', 'alkaline', 'dry', 'cauliflower'],
-    ['none', 'alkaline', 'dry', 'cauliflower'],
-    ['mushroom', 'slightly acidic', 'medium wet', 'cauliflower'],
-    ['none', 'slightly acidic', 'dry', 'cauliflower'],
-    ['pumpkin', 'neutral', 'dry', 'cauliflower'],
-    ['cauliflower', 'neutral', 'dry', 'cauliflower'],
-    ['cabbage', 'alkaline', 'medium wet', 'cauliflower'],
-    ['none', 'slightly acidic', 'medium wet', 'cauliflower'],
-    ['cabbage', 'acidic', 'dry', 'mushroom'],
-    ['none', 'acidic', 'medium wet', 'mushroom'],
-    ['mushroom', 'neutral', 'dry', 'mushroom'],
-    ['cauliflower', 'slightly acidic', 'dry', 'mushroom'],
-    ['pumpkin', 'acidic', 'medium wet', 'mushroom'],
-    ['cauliflower', 'acidic', 'medium wet', 'mushroom'],
-    ['mushroom', 'neutral', 'dry', 'mushroom'],
-    ['pumpkin', 'slightly acidic', 'medium wet', 'mushroom'],
-    ['cauliflower', 'neutral', 'wet', 'pumpkin'],
-    ['none', 'neutral', 'wet', 'pumpkin'],
-    ['mushroom', 'slightly acidic', 'wet', 'pumpkin'],
-    ['pumpkin', 'neutral', 'wet', 'pumpkin'],
-    ['cabbage', 'slightly acidic', 'medium wet', 'pumpkin'],
-    ['mushroom', 'neutral', 'wet', 'pumpkin'],
-    ['cabbage', 'neutral', 'wet', 'pumpkin'],
-    ['none', 'slightly acidic', 'wet', 'pumpkin'],
-    ['cauliflower', 'slightly acidic', 'medium wet', 'pumpkin'],
-    ['mushroom', 'neutral', 'medium wet', 'cabbage'],
-    ['pumpkin', 'alkaline', 'wet', 'cabbage'],
-    ['none', 'alkaline', 'medium wet', 'cabbage'],
-    ['cauliflower', 'neutral', 'medium wet', 'cabbage'],
-    ['cabbage', 'slightly acidic', 'wet', 'cabbage'],
-    ['none', 'neutral', 'medium wet', 'cabbage'],
-    ['cabbage', 'neutral', 'medium wet', 'cabbage'],
-    ['mushroom', 'alkaline', 'wet', 'cabbage'],
-    ['none', 'alkaline', 'wet', 'cabbage'],
-    ['pumpkin', 'neutral', 'medium wet', 'cabbage'],
-    ['mushroom', 'neutral', 'soaking wet', 'none'],
-    ['cauliflower', 'alkaline', 'very dry', 'none'],
-    ['none', 'alkaline', 'soaking wet', 'none'],
-    ['cabbage', 'acidic', 'medium wet', 'none'],
-    ['pumpkin', 'acidic', 'soaking wet', 'none'],
-    ['cabbage', 'slightly acidic', 'soaking wet', 'none'],
-    ['none', 'slightly acidic', 'soaking wet', 'none'],
-    ['mushroom', 'neutral', 'very dry', 'none'],
-    ['mushroom', 'acidic', 'medium wet', 'none'],
-    ['pumpkin', 'neutral', 'soaking wet', 'none']
-]
-
-testing_data = [
-
-    ['cauliflower', 'neutral', 'dry', 'cauliflower'],
-    ['cabbage', 'alkaline', 'medium wet', 'cauliflower'],
-    ['none', 'slightly acidic', 'medium wet', 'cauliflower'],
-    ['cabbage', 'acidic', 'dry', 'mushroom'],
-    ['none', 'acidic', 'medium wet', 'mushroom'],
-    ['mushroom', 'neutral', 'dry', 'mushroom'],
-    ['cauliflower', 'neutral', 'wet', 'pumpkin'],
-    ['none', 'neutral', 'wet', 'pumpkin'],
-    ['mushroom', 'slightly acidic', 'wet', 'pumpkin'],
-    ['mushroom', 'neutral', 'medium wet', 'cabbage'],
-    ['pumpkin', 'alkaline', 'wet', 'cabbage'],
-    ['none', 'alkaline', 'medium wet', 'cabbage'],
-    ['mushroom', 'neutral', 'soaking wet', 'none'],
-    ['cauliflower', 'alkaline', 'very dry', 'none'],
-    ['none', 'alkaline', 'soaking wet', 'none'],
-
-]

decisiontree.py

@@ -1,51 +0,0 @@
-import pandas as pd
-#NIE AKTULAIZOWAĆ scikit / sklearn
-from sklearn import tree
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.tree.export import export_text
-from sklearn.tree import export_graphviz
-
-
-
-def decision(plant,humidity,growth,dryness):
-
-    # czytanie pliku csv 
-    df = pd.read_csv("./data.csv")
-    #print(df)
-    
-    #zmiana słów na cyfry, ponieważ drzewo decyzyjne opiera się na cyfrach
-    z = {'CABBAGE': 2, 'PUMPKIN':4, 'MUSHROOM':3, 'CAULIFLOWER': 1}
-    df['PLANT'] = df['PLANT'].map(z)
-
-    d = {'NO': 0, 'YES': 1}
-    df['DEC'] = df['DEC'].map(d)
-
-    #print(df)
-    
-    features_rest = ['PLANT','HUMIDITY','GROWTH','DRYNESS'] #dane, na których opiera się decyzja
-    features_dec = ['DEC'] #kolumna z decyją
-
-    X = df[features_rest]
-    y = df[features_dec]
-
-    #wyświetlkanie kolumn
-    #print(X)
-    #print(y)
-
-    #tworzenie drzewa
-    dtree = DecisionTreeClassifier()
-    #przypisanie danych
-    dtree = dtree.fit(X, y)
-    #eksport drzewa do tekstu
-    r = export_text(dtree, feature_names=features_rest)
-    #print("\nDrzewo decyzyjne\n")
-    #print(r)
-
-    a = dtree.predict([[plant,humidity,growth,dryness]])
-    #return a
-    #print("\n[1] means FEED THE PLANT")
-    #print("[0] means NOT FEED THE PLANT\n")
-    print ("Decision for: ",plant,", humidity: ", humidity,", growth: ", growth,", dryness:", dryness," is ", a,"\n")
-    
-
-

final-evaluation.md

@@ -1,25 +0,0 @@
-# Inteligentny traktor
-## Opis
-W finalnej wersji naszego projektu połączyliśmy wszyskie części w całość. Lista podprojektów:
-* Agata Lenz - decyzja o zebraniu i posadzeniu nowej rośliny,
-* Mikołaj Paterka - decyzja o nawozeniu rośliny,
-* Jakub Adamski - wykrywanie typu rośliny.
-
-## Działanie
-Traktorem mozemy sterować samodzielnie lub wybierając odpowiednie pola - planowanie ruchu. Agent poruszając się po planszy, polu, podejmuje następujące działania.
-1) Wykrywa typ rośliny na podstawie podanego zdjęcia;
-2) Podejmuje decyzję czy daną roślinę zebrać, jeśli tak sadzi równiez nową;
-3) Na podstawie między innymi danych o wilgotności gleby, podejmuje decyzję czy nawozić daną roślinę;
-
-Projekt spełnia zadane na początku załozenia oraz implementuje kazdy z podprojektów.
-
-## Zdjęcia
-
-Uruchomienie - wybór czy uzywamy planowania ruchu.
-
-![start](ss/final2.png)
-
-Działanie programu.<br>
-Posadzona nowa roślina - grzyb. Wykryta roślina na podstawie zdjęcia - grzyb (indeks 2 zaczynając od zera dla kategorii podanych ponizej). Roślina została nawieziona - wynik [1] na podstawie danych o statusie otoczenia i rośliny. 
-
-![dzialanie](ss/final1.png)

main.py

@@ -1,8 +1,6 @@
 import pygame, sys
 from traktor import Traktor
 import dijkstra as di
-import decisiontree as dt
-from ID3 import predict_data
 
 import matplotlib.pyplot as plt
 from tensorflow.keras.preprocessing import image
@@ -47,16 +45,12 @@ class Game(object):
 
         #ładowanie tablicy ze zdjeciami
         imgs = []
-        data_plant = []
-        data_soil = []
         img_dir = './imgs'
         for _ in lokalizacje:
-            data_plant.append([random.randrange(5, 90),random.randrange(0, 120),random.randrange(5, 90)])
-            data_soil.append([random.randrange(44, 75)/10, random.randrange(0, 100)/100])
             imgs.append(img_dir + '/' + random.choice(os.listdir(img_dir)))
 
         #model do rozpoznawania
-        model = load_model('data/moj_model.h5')
+        model = load_model('moj_model.h5')
 
         #inicjalizacja
         pygame.init()
@@ -128,7 +122,7 @@ class Game(object):
             pygame.display.update()
 
             #rysowanie
-            self.pole.fill((157, 128, 48))
+            self.pole.fill((0,0,0))
             self.krata()
             self.rysowanie()
             pygame.display.flip()
@@ -145,35 +139,10 @@ class Game(object):
                 #detektor roslin, 5 rezultatow
                 plt.imshow(img)
                 preds = model.predict(x)
-                list_of_preds = preds.tolist()[0]
-                index = list_of_preds.index(max(list_of_preds))
-                #print(index)
-
-                names = ['cabbage', 'cauliflower', 'mushroom', 'pumpkin']
-
-                # decyzja o posadzeniu nowej rośliny następuje wtedy, gdy jest ona dojrzała przynajmniej w 90%
-                if(data_plant[pt][1] > 90):
-
-                    new_plant = predict_data([names[index], data_soil[pt][0], data_soil[pt][1]])
-                    if(new_plant != 'none'):
-                        index = names.index(new_plant)
-                        imgs[pt] = img_dir + '/' + (os.listdir(img_dir))[index]
-                        data_plant[pt] = [0, 0, 50]
-                else:
-                    print("Planted: none")
-
-                if index == 0:
-                    dt.decision(4, data_plant[pt][0],data_plant[pt][1],data_plant[pt][2])
-                if index == 1:
-                    dt.decision(1, data_plant[pt][0],data_plant[pt][1],data_plant[pt][2])
-                if index == 2:
-                    dt.decision(2, data_plant[pt][0],data_plant[pt][1],data_plant[pt][2])
-                if index == 3:
-                    dt.decision(3, data_plant[pt][0],data_plant[pt][1],data_plant[pt][2])
-
                 print("kapusta, kalafior, grzyb, dynia\n {}\n".format(preds) )
                 plt.show()
                     
+
     def krata(self):
         #wymiary
         w= 500

plant.py

@@ -0,0 +1,65 @@
+from abc import ABC, abstractmethod
+
+class Plant:
+
+    #tworzymy jakas rosline co ma nazwe,i id. ID powiedzmy ze buraki beda mialy 1, marchewki 2 itd. gleby powiedzmy tez damy 4 i beda mialy id 5-8
+    def __init__(self, name, ID):
+        super().__init__()
+        self._soil = -1 #jak tworzymy rosline to nie bedzie ona miala gleby
+        self._name = name #to nazwa rosliny będzie np. burak1
+        self._id = ID #id rosliny buraki bedą mialy 1, i po tym inne obiekty beda rozpoznawac ten obiekt
+        self._collect = 0 #nowa roslina jest w 0% dojrzala
+
+    #to jest jakbysmy usuneli obiekt. zabezpieczenie, zeby gleba pozniej byla wolna
+    def __del__(self):
+        self.leave_soil()
+
+    #to sie drukuje jak zapytamy o stworzony obiekt
+    def __str__(self):
+        return f'Plant: {self._name}, Soil: {self._soil}, Status: {self.collect()}'
+
+    #metoda abstrakcyjna, kazda roslina ma inny czas rosniecia wiec pass
+    @abstractmethod
+    def collect(self):
+        pass
+    
+    @abstractmethod
+    def fertillizing(self):
+        pass
+    
+    @abstractmethod
+    def growing(self):
+        pass
+
+    #pobieramy wspolrzedne roslinki
+    def get_coordinates(self):
+        if self.have_soil():
+            a = self.get_soil()
+            a.get_coordinates(self) #get coordinates jest metoda w glebie
+
+    #pobieramy id roślinki
+    def get_id(self):
+        return self._id
+
+    #dodajemy glebe
+    def add_soil(self, soil):
+        self._soil = soil
+
+    #zwraca czy roslinka znajduje sie w ziemii obecnie - jak nie ma gleby to znaczy ze nie jest zasadzona jeszcze albo już.
+    def have_soil(self):
+        return self._soil is not -1
+    
+    #pobieramy jaka ma glebe, gleba tutaj będzie obiektem
+    def get_soil(self):
+        return self._soil
+
+    #to w przypadku jak bedziemy wyciagac z ziemii roslinke
+    def leave_soil(self):
+        if self.have_soil():
+            a = self.get_soil()
+            a.plant_remove() #to bedzie metoda w klasie Soil, bedzie usuwac roslinke z gleby
+            self._soil = -1
+            
+    
+
+

pumpkin.py

@@ -0,0 +1,38 @@
+from plant import Plant
+from datetime import datetime
+
+class Pumpkin(Plant):
+    
+    def __init__(self):
+        super().__init__()
+        self._wasFertilized = False #roslina nie byla nawozona przy tworzeniu
+
+    def add_soil(self, soil):
+        super().add_soil()
+        self._starttime = datetime.now()
+
+    #zwraca czy zbierać rośline
+    def collect(self):
+        if self.have_soil():
+            self.__growing()
+            if self._collect < 90:
+                return 'False'
+            elif 90 <= self._collect <= 110:
+                return 'True'
+            elif self._collect > 110:
+                return 'Delete'
+
+    #zwraca czy nawozić
+    def fertillizing(self):
+        if 20 <= self._collect <= 45:
+            return True
+        else:
+            return False
+        
+    #każde iles czasu zwieksza wzrost rosliny, wywolywana w momencie sprawdzania czy roslina jest gotowa do zbiorow
+    def __growing(self):
+        checktime = datetime.now()
+        delta = checktime - self._starttime
+        a = delta // 50
+        self._collect += a
+        self._starttime = checktime

raporty/lenz_raport.md

@@ -1,132 +0,0 @@
-# Agata Lenz - drzewa decyzyjne, algorytm ID3
-
-## Wymagania
-Importowane biblioteki:
-* numpy
-* pandas
-
-## Opis podprojektu
-Podprojekt implementuje algorytm ID3 pozwalający wyznaczyć drzewo decyzyjne, przy użyciu którego agent (traktor) podejmie decyzję co posadzić w danym miejscu, na podstawie:
-* *previous* - gatunku rośliny, która poprzednio rosła w danym miejscu
-* *pH* - pH gleby
-* *dry_level* - suchości gleby
-
-## Uczenie modelu
-
-### Dane
-Dane uczące jak i testowe znajdują się w pliku data.py. Dane uczące są zapisane w postaci listy, której elementy to przykładowe dane w formacie ['previous', 'pH', 'dry_level', 'label'], gdzie *label* oznacza posadzoną w wymienionych warunkach roślinę.
-Łącznie zestaw uczący zawiera 47 elementów, a zestaw testowy - 15.
-
-Przykładowe elementy zestawu uczącego:
-```
- ['pumpkin', 'neutral', 'dry', 'beetroot'],
- ['none', 'neutral', 'wet', 'pumpkin'],
- ['cabbage', 'alkaline', 'soaking wet', 'none']
-```
-
-### Implementacja algorytmu ID3
-
-Za budowę drzewa decyzyjnego odpowiada rekurencyjna funkcja *ID3(data, original_data, features, target_attribute_name="label", parent_node_class=None)*:
-
-```
-def ID3(data, original_data, features, target_attribute_name="label", parent_node_class=None):
-    """
-    Algorytm ID3
-
-    parametry:
-        data                    zbiór danych, dla którego poszukujemy drzewa decyzyjnego
-        original_data           oryginalny zbiór danych (zwracany gdy data == None)
-        features                lista atrybutów wejściowego zbioru
-        target_attribute_name   docelowy atrybut, który chcemy przewidzieć
-        parent_node_class       nadrzędna wartość
-    """
-
-    # Jeżeli wszystkie atrybuty są takie same, zwracamy liść z pierwszą napotkaną wartością
-
-    if len(np.unique(data[target_attribute_name])) <= 1:
-        return np.unique(data[target_attribute_name])[0]
-
-    elif len(data) == 0:
-        return np.unique(original_data[target_attribute_name])[
-            np.argmax(np.unique(original_data[target_attribute_name], return_counts=True)[1])]
-
-    elif len(features) == 0:
-        return parent_node_class
-
-    else:
-
-        # Aktualizacja nadrzędnej wartości
-        parent_node_class = np.unique(data[target_attribute_name])[
-            np.argmax(np.unique(data[target_attribute_name], return_counts=True)[1])]
-
-        # Obliczenie przyrostu informacji dla każdego potencjalnego atrybutu,
-        # według którego nastąpi podział zbioru
-        item_values = [info_gain(data, feature, target_attribute_name) for feature in
-                       features]
-
-        # Najlepszym atrybutem jest ten o największym przyroście informacji
-        best_feature_index = np.argmax(item_values)
-        best_feature = features[best_feature_index]
-
-        # Struktura drzewa
-        tree = {best_feature: {}}
-
-        # Aktualizacja zbioru atrybutów
-        features = [i for i in features if i != best_feature]
-
-        # Dla każdej wartości wybranego atrybutu budujemy kolejne poddrzewo
-        for value in np.unique(data[best_feature]):
-
-            sub_data = data.where(data[best_feature] == value).dropna()
-            subtree = ID3(sub_data, data, features, target_attribute_name, parent_node_class)
-
-            tree[best_feature][value] = subtree
-
-        return (tree)
-```
-
-Do obliczenia przyrostu informacji służy funkcja *info_gain(data, split_attribute_name, target_name="label")*, która dla wejściowego zestawu danych (*data*), oblicza jego entropię oraz średnią ważoną entropii każdego podzestawu (wyznaczanego przez unikalne wartości atrybutu *split_attribute_name*):
-
-```
-def info_gain(data, split_attribute_name, target_name="label"):
-
-    total_entropy = entropy(data[target_name])
-    vals, counts = np.unique(data[split_attribute_name], return_counts=True)
-
-    weighted_entropy = np.sum(
-        [(counts[i] / np.sum(counts)) * entropy(data.where(data[split_attribute_name] == vals[i]).dropna()[target_name])
-         for i in range(len(vals))])
-
-    information_gain = total_entropy - weighted_entropy
-
-    return information_gain
-```
-
-## Implementacja w projekcie głównym
-
-Funkcja, z której będzie korzystał traktor, aby podjąć decyzję o posadzeniu rośliny, to *def decide_to_plant(soil)*
-
-```
-def decide_to_plant(soil):
-
-    if soil.have_plant():
-        plant = soil.get_plant()
-        if plant.collect() == 'True':
-            info = get_info(soil)
-            plant.leave_soil()
-        else:
-            return [['none']]
-    else:
-        info = get_info(soil)
-
-    data = []
-    data.append(info)
-
-    predicted = predict_data(data)
-    grow_a_plant(soil,predicted[0][0])
-
-    return predicted
-```
-Pierwszym krokiem jest sprawdzenie, czy w danej ziemi już coś rośnie - jeżeli jest to roślina dojrzała, zostaje ona zebrana, a jej nazwa staje się wartością atrybutu *previous*. Jeżeli nie, nie przewiduje się sadzenia w tym miejscu żadnej rośliny w danym momencie.
-Funkcja *get_info(soil)* zwraca listę parametrów obiektu *Soil*, potrzebną do poszukiwań w drzewie decyzyjnym.
-W pliku *dataset.py* znajduje się funkcja *create_data_soil()* pozwalająca przetestować działanie algorytmu na obiektach typu *Soil*

raporty/route-planning.md

@@ -1,56 +0,0 @@
-# Route planning
-
-## Spis treści
-* [Informacje](#informacje)
-* [Pętla główna](#pętla%20główna)
-* [Funkcja następnika](#funkcja%20następnika)
-* [Heurystyka](#heurystyka)
-
-
-## Informacje
-
-Omawiane fragmenty kodu znajdują się w pliku ```dijkstra.py```.
-Po uruchomieniu programu, użytkownik ma do wyboru samodzielne sterowanie traktorem przy pomocy strzałek (1) lub podawanie punktów wykorzystujące planowanie ruchu (0). Przy wyborze drugiej z opcji, aby wykonać ruch, użytkownik w aktywnym oknie programu naciska spację, po czym podaje dwa punkty.
-
-## Pętla główna
-
-Implementacja algorytmu Dijkstry:
-
-```
-def dijkstra(src):
-    dist = [sys.maxsize] * len(graph)
-    dist[src] = 0
-    sptSet = [False] * len(graph)
-
-    for cout in range(len(graph)): 
-        u = minDistance(dist, sptSet) 
-        sptSet[u] = True
-        for v in range(len(graph)):
-            if graph[u][v] > 0 and sptSet[v] == False and dist[v] > dist[u] + graph[u][v]: 
-                dist[v] = dist[u] + graph[u][v]
-
-    return dist
-```
-
-Dla ```src``` będącego wierzchołkiem źródłowym, funkcja zwraca koszt przejścia do każdego punktu w grafie w postaci listy ```dist```.
-
-Dopóki nie zostaną rozpatrzone wszystkie wierzchołki, pętla:
-* za wierzchołek ```u``` przyjmuje wierzchołek najbliższy źródła, który nie został jeszcze rozważony
-* dla każdego sąsiada ```v``` wierzchołka ```u```, jeżeli przez ```u``` da się dojść do ```v``` szybciej niż dotychczasową ścieżką, to wykonuje podstawienie: ```dist[v] = dist[u] + graph[u][v]```.
-
-
-## Funkcja następnika
-
-```
-def minDistance(dist, sptSet): 
-    mini = sys.maxsize 
-    for v in range(len(graph)): 
-        if dist[v] < mini and sptSet[v] == False: 
-            mini = dist[v] 
-            min_index = v 
-    return min_index 
-```
-
-Funkcja zwraca indeks wierzchołka, który jest najbliższej źródła, a nie został jeszcze rozważony, przeszukując w tym celu pozostałe wierzchołki grafu.
-
-## Heurystyka

soil.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+
+class Soil:
+
+    def __init__(self, x, y, ID):
+        super().__init__()
+        self._id = ID
+        self._x = x
+        self._y = y
+        self._plant = -1 #nowa gleba nie ma roślinki
+        self._dry = 0 #procent wysuszenia gleby, tworząc nową jest nawodniona w 100%
+        self._starttime = datetime.now()
+
+    def __del__(self):
+        self.plant_remove()
+
+    def __str__(self):
+      return f'{self._x}, {self._y}), Plant: {self._plant}'
+
+    # współrzędne pola
+    def get_coordinates(self):
+        return self._x, self._y
+
+    # id gleby
+    def get_id(self):
+        return self._id
+
+    # zasadzenie roślinki
+    def add_plant(self, plant):
+        if not self.have_plant():
+            plant.add_soil(self)
+            self._plant = plant
+
+    # zwraca czy w ziemi znajduje się roślinka
+    def have_plant(self):
+        return self._plant is not -1
+    
+    # zwraca roślinkę znajdującą się w ziemii
+    def get_plant(self):
+        return self._soil
+
+    #sprawdza w ilu procentach ziemia jest sucha
+    def is_dry(self):
+        self.__drying()
+        if self._dry < 30:
+            return 'False'
+        elif 30 <= self._dry < 70:
+            return 'Medium'
+        else:
+            return 'True'
+
+    #metoda wysuszajaca ziemie. dodaje wysuszenie do ziemi, wywolywana w momencie sprawdzania czy ziemia jest sucha
+    def __drying(self):
+        checktime = datetime.now()
+        delta = checktime - self._starttime
+        a = delta //60
+        self._dry += a
+        self._starttime = checktime
+        self.__is_dry()
+
+
+    # usuwa roślinkę z ziemi i ją zwraca
+    def plant_remove(self):
+        if self.have_plant():
+            a = self.get_plant()
+            a.leave_soil()
+            self._plant = -1

traktor.py

@@ -10,12 +10,8 @@ class Traktor(object):
         self.y = 0
         self.punkt = 0
         self.canSteer = True
-        self.myimage = pygame.image.load("./assets/player.png").convert()
-        self.myimage = pygame.transform.scale(self.myimage, (99, 99))
-        self.screen = pygame.display.set_mode((500, 500))
             
         
     def rysowanie(self):      
-        rect = self.myimage.get_rect()
+        obje = pygame.Rect(self.x, self.y ,99,99)
-        rect.center = (self.x+50, self.y+50)
+        pygame.draw.rect(self.game.pole, (0,100,255), obje)
-        self.screen.blit(self.myimage, rect)