Merge pull request 'Zmiana błędu w konstruktorze successor' (#37) from minor_upgrades into master

Reviewed-on: #37

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

README.md

@@ -1,2 +1,3 @@
 # sztuczna_inteligencja_2023_smieciarka
 
+Symulacja inteligentnej śmieciarki. Śmieciarka zbiera śmieci z kubłów wystawionych przez mieszkańców, samodzielnie je segreguje i zawozi na wysypisko.

agentActionType.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class AgentActionType (Enum):
+    MOVE_FORWARD = 0
+    TURN_LEFT = 1
+    TURN_RIGHT = 2
+    UNKNOWN = None

agentOrientation.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class AgentOrientation (Enum):
+    UP = 0
+    RIGHT = 1
+    DOWN = 2
+    LEFT = 3

agentState.py

@@ -0,0 +1,10 @@
+from agentOrientation import AgentOrientation
+from typing import Tuple
+
+class AgentState:
+    orientation: AgentOrientation
+    position: Tuple[int, int]
+
+    def __init__(self, position: Tuple[int, int], orientation: AgentOrientation) -> None:
+        self.orientation = orientation
+        self.position = position

bfs.py

@@ -0,0 +1,165 @@
+from agentState import AgentState
+from typing import Dict, Tuple, List
+from city import City
+from gridCellType import GridCellType
+from agentActionType import AgentActionType
+from agentOrientation import AgentOrientation
+from queue import Queue, PriorityQueue
+from turnCar import turn_left_orientation, turn_right_orientation
+
+
+class Successor:  # klasa reprezentuje sukcesora, stan i akcję którą można po nim podjąć
+
+    def __init__(self, state: AgentState, action: AgentActionType, cost: int, predicted_cost: int) -> None:
+        self.state = state
+        self.action = action
+        self.cost = cost
+        self.predicted_cost = predicted_cost
+
+
+class SuccessorList:  # lista sukcesorów, czyli możliwych ścieżek po danym stanie
+    succ_list: list[Successor]
+
+    def __init__(self, succ_list: list[Successor]) -> None:
+        self.succ_list = succ_list
+
+    def __gt__(self, other):
+        return self.succ_list[-1].predicted_cost > other.succ_list[-1].predicted_cost
+
+    def __lt__(self, other):
+        return self.succ_list[-1].predicted_cost < other.succ_list[-1].predicted_cost
+
+
+def find_path_to_nearest_can(startState: AgentState, grid: Dict[Tuple[int, int], GridCellType], city: City) -> List[
+    AgentActionType]:  # znajduje ścieżkę do najbliższego kosza na smieci
+    visited: List[AgentState] = []
+    queue: PriorityQueue[SuccessorList] = PriorityQueue()  # kolejka priorytetowa przechodująca listę sukcesorów
+    queue.put(SuccessorList([Successor(startState, AgentActionType.UNKNOWN, 0, _heuristics(startState.position, city))]))
+
+    while not queue.empty():  # dopóki kolejka nie jest pusta, pobiera z niej aktualny element
+        current = queue.get()
+        previous = current.succ_list[-1]
+        visited.append(previous.state)
+
+        if is_state_success(previous.state, grid):  # jeśli ostatni stan w liście jest stanem końcowym (agent dotarł do śmietnika)
+            return extract_actions(current)
+
+        successors = get_successors(previous, grid, city)
+        for s in successors:
+            already_visited = False
+            for v in visited:
+                if v.position == s.state.position and v.orientation == s.state.orientation:
+                    already_visited = True
+                    break
+            if already_visited:
+                continue
+            if is_state_valid(s.state, grid):
+                new_list = current.succ_list.copy()
+                new_list.append(s)
+                queue.put(SuccessorList(new_list))
+
+    return []
+
+
+def extract_actions(successors: SuccessorList) -> list[AgentActionType]:  # wyodrębnienie akcji z listy sukcesorów, z pominięciem uknown
+    output: list[AgentActionType] = []
+    for s in successors.succ_list:
+        if s.action != AgentActionType.UNKNOWN:
+            output.append(s.action)
+    return output
+
+
+def get_successors(succ: Successor, grid: Dict[Tuple[int, int], GridCellType], city: City) -> List[Successor]:
+    result: List[Successor] = []  # generuje następników dla danego stanu,
+
+    turn_left_cost = 1 + succ.cost
+    turn_left_state = AgentState(succ.state.position, turn_left_orientation(succ.state.orientation))
+    turn_left_heuristics = _heuristics(succ.state.position, city)
+    result.append(
+        Successor(turn_left_state, AgentActionType.TURN_LEFT, turn_left_cost, turn_left_cost + turn_left_heuristics))
+
+    turn_right_cost = 1 + succ.cost
+    turn_right_state = AgentState(succ.state.position, turn_right_orientation(succ.state.orientation))
+    turn_right_heuristics = _heuristics(succ.state.position, city)
+    result.append(
+        Successor(turn_right_state, AgentActionType.TURN_RIGHT, turn_right_cost,
+                  turn_right_cost + turn_right_heuristics))
+
+    state_succ = move_forward_succ(succ, city, grid)
+    if state_succ is not None:
+        result.append(state_succ)
+
+    return result
+
+
+def move_forward_succ(succ: Successor, city: City, grid: Dict[Tuple[int, int], GridCellType]) -> Successor:
+    position = get_next_cell(succ.state)
+    if position is None:
+        return None
+
+    cost = get_cost_for_action(AgentActionType.MOVE_FORWARD, grid[position]) + succ.cost
+    predicted_cost = cost + _heuristics(position, city)
+    new_state = AgentState(position, succ.state.orientation)
+    return Successor(new_state, AgentActionType.MOVE_FORWARD, cost, predicted_cost)
+
+
+def get_next_cell(state: AgentState) -> Tuple[int, int]:
+    x, y = state.position
+    orientation = state.orientation
+
+    if orientation == AgentOrientation.UP:
+        if y - 1 < 1:
+            return None
+        return x, y - 1
+    elif orientation == AgentOrientation.DOWN:
+        if y + 1 > 27:
+            return None
+        return x, y + 1
+    elif orientation == AgentOrientation.LEFT:
+        if x - 1 < 1:
+            return None
+        return x - 1, y
+    elif x + 1 > 27:
+        return None
+    else:
+        return x + 1, y
+
+
+def is_state_success(state: AgentState, grid: Dict[Tuple[int, int], GridCellType]) -> bool:
+    next_cell = get_next_cell(state)
+    try:
+        return grid[next_cell] == GridCellType.GARBAGE_CAN  # agent dotarł do śmietnika
+    except KeyError:
+        return False
+
+
+def get_cost_for_action(action: AgentActionType, cell_type: GridCellType) -> int:
+    if action in [AgentActionType.TURN_LEFT, AgentActionType.TURN_RIGHT]:
+        return 1
+    if cell_type == GridCellType.SPEED_BUMP and action == AgentActionType.MOVE_FORWARD:
+        return -10000
+    if action == AgentActionType.MOVE_FORWARD:
+        return 3
+
+
+def is_state_valid(state: AgentState, grid: Dict[Tuple[int, int], GridCellType]) -> bool:
+    try:
+        return grid[state.position] == GridCellType.STREET_HORIZONTAL or grid[
+            state.position] == GridCellType.STREET_VERTICAL or grid[state.position] == GridCellType.SPEED_BUMP
+    except KeyError:
+        return False
+
+
+def _heuristics(position: Tuple[int, int], city: City):
+    min_distance: int = 300
+    found_nonvisited: bool = False
+    for can in city.cans:
+        if can.is_visited:
+            continue
+        found_nonvisited = True
+        distance = 3 * (abs(position[0] - can.position[0]) + abs(position[1] - can.position[1]))
+        if distance < min_distance:
+            min_distance = distance
+    if found_nonvisited:
+        return min_distance
+    return -1

city.py

@@ -0,0 +1,44 @@
+from typing import List, Dict, Tuple
+from garbageCan import GarbageCan
+from speedBump import SpeedBump
+from street import Street
+from gameContext import GameContext
+
+
+class City:
+    cans: List[GarbageCan]
+    bumps: List[SpeedBump]
+    streets: List[Street]
+    cans_dict: Dict[Tuple[int, int], GarbageCan] = {}
+
+    def __init__(self) -> None:
+        self.cans = []
+        self.streets = []
+        self.bumps = []
+
+    def add_can(self, can: GarbageCan) -> None:
+        self.cans.append(can)
+        self.cans_dict[can.position] = can
+
+    def add_street(self, street: Street) -> None:
+        self.streets.append(street)
+
+    def add_bump(self, bump: SpeedBump) -> None:
+        self.streets.append(bump)
+
+    def render_city(self, game_context: GameContext) -> None:
+        self._render_streets(game_context)
+        self._render_nodes(game_context)
+        self._render_bumps(game_context)
+
+    def _render_streets(self, game_context: GameContext) -> None:
+        for street in self.streets:
+            street.render(game_context)
+
+    def _render_nodes(self, game_context: GameContext) -> None:
+        for node in self.cans:
+            node.render(game_context)
+
+    def _render_bumps(self, game_context: GameContext) -> None:
+        for bump in self.bumps:
+            bump.render(game_context)

gameContext.py

@@ -0,0 +1,36 @@
+from typing import Tuple, List, Dict
+import pygame
+from PIL import Image
+from gridCellType import GridCellType
+
+class GameContext:
+    dust_car_speed = 20
+    dust_car_position_x = 0
+    dust_car_position_y = 0
+    dust_car_pygame = None
+    dust_car_pil = None
+    canvas = None
+    _cell_size: int = 30
+    city = None
+    grid: Dict[Tuple[int, int], GridCellType] = {}
+    dust_car = None
+    landfill = None
+    
+
+
+    def __init__(self) -> None:
+        self._init_grid()
+
+    def _init_grid(self) -> None:
+        for i in range(1, 28):
+            for j in range(1, 28):
+                self.grid[(i, j)] = GridCellType.NOTHING
+
+    def render_in_cell(self, cell: Tuple[int, int], img_path: str):
+        img = Image.open(img_path)
+        pygame_img = pygame.image.frombuffer(img.tobytes(), (self._cell_size,self._cell_size), 'RGB')
+        start_x = (cell[0] - 1) * self._cell_size
+        start_y = (cell[1] - 1) * self._cell_size
+        self.canvas.blit(pygame_img, (start_x, start_y))
+
+

gameEventHandler.py

@@ -1,4 +1,5 @@
 import pygame
+from gameContext import GameContext
 
-def handle_game_event(event):
-    return
+def handle_game_event(event, game_context: GameContext):
+    pass

garbage.py

@@ -0,0 +1,41 @@
+from enum import Enum
+
+
+class GarbageType(Enum):
+    PAPER = 0,
+    PLASTIC_AND_METAL = 1
+    GLASS = 3
+    BIO = 4
+    MIXED = 5
+
+
+class Garbage:
+    img: str
+    shape: str
+    flexibility: str
+    does_smell: str
+    weight: str
+    size: str
+    color: str
+    softness: str
+    does_din: str
+
+    def __init__(self, img: str, shape: str, flexibility: str, does_smell: str, weight: str, size: str, color: str, softness: str, does_din: str) -> None:
+        self.img = img
+        self.shape = shape
+        self.flexibility = flexibility
+        self.does_smell = does_smell
+        self.weight = weight
+        self.size = size
+        self.color = color
+        self.softness = softness
+        self.does_din = does_din
+
+
+class RecognizedGarbage:
+    garbage_type: GarbageType
+    src: Garbage
+
+    def __init__(self, src: Garbage, garbage_type: GarbageType) -> None:
+        self.garbage_type = garbage_type
+        self.src = src

garbageCan.py

@@ -0,0 +1,26 @@
+from garbage import Garbage
+from typing import List, Tuple
+from gameContext import GameContext
+from gridCellType import GridCellType
+
+
+class GarbageCan:
+    position: Tuple[int, int]
+    garbage: List[Garbage]
+    is_visited: bool
+
+    def __init__(self, position: Tuple[int, int]) -> None:
+        self.position = position
+        self.garbage = []
+        self.is_visited = False
+
+    def add_garbage(self, garbage: Garbage) -> None:
+        self.garbage.append(garbage)
+
+    def remove_garbage(self, garbage: Garbage) -> None:
+        self.garbage.remove(garbage)
+
+
+    def render(self, game_context: GameContext) -> None:
+        game_context.render_in_cell(self.position, "imgs/container.png")
+        game_context.grid[self.position] = GridCellType.GARBAGE_CAN

garbageTruck.py

@@ -0,0 +1,50 @@
+from typing import List, Tuple
+from agentOrientation import AgentOrientation
+from garbage import GarbageType, RecognizedGarbage
+from gameContext import GameContext
+
+class GarbageTruck:
+    position: Tuple[int, int]
+    paper: List[RecognizedGarbage]
+    plastic_and_metal: List[RecognizedGarbage]
+    glass: List[RecognizedGarbage]
+    bio: List[RecognizedGarbage]
+    mixed: List[RecognizedGarbage]
+    orientation: AgentOrientation = AgentOrientation.RIGHT
+
+    def __init__(self, position: Tuple[int, int]) -> None:
+        self.position = position
+        self.paper = []
+        self.plastic_and_metal = []
+        self.glass = []
+        self.bio = []
+        self.mixed = []
+        
+
+    def sort_garbage(self, RecognizedGarbage) -> None:
+        if RecognizedGarbage.garbage_type == GarbageType.PAPER:
+            self.paper.append(RecognizedGarbage)
+
+        elif RecognizedGarbage.garbage_type == GarbageType.PLASTIC_AND_METAL:
+            self.plastic_and_metal.append(RecognizedGarbage)
+
+        elif RecognizedGarbage.garbage_type == GarbageType.GLASS:
+            self.glass.append(RecognizedGarbage)
+
+        elif RecognizedGarbage.garbage_type == GarbageType.BIO:
+            self.bio.append(RecognizedGarbage)
+
+        elif RecognizedGarbage.garbage_type == GarbageType.MIXED:
+            self.mixed.append(RecognizedGarbage)
+
+    def render(self, game_context: GameContext) -> None:
+        path = None
+        if self.orientation == AgentOrientation.LEFT:
+            path = 'imgs/dust_car_left.png'
+        elif self.orientation == AgentOrientation.RIGHT:
+            path = 'imgs/dust_car_right.png'
+        elif self.orientation == AgentOrientation.UP:
+            path = 'imgs/dust_car_up.png'
+        elif self.orientation == AgentOrientation.DOWN:
+            path = 'imgs/dust_car_down.png'
+        game_context.render_in_cell(self.position, path)

gridCellType.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class GridCellType(Enum):
+    NOTHING = 0
+    STREET_VERTICAL = 1
+    STREET_HORIZONTAL = 2
+    GARBAGE_CAN = 3
+    VISITED_GARBAGE_CAN = 4
+    LANDFILL = 5
+    SPEED_BUMP = 6
+    UNKNOWN = None

landfill.py

@@ -0,0 +1,39 @@
+from typing import Tuple
+from gameContext import GameContext
+from garbage import RecognizedGarbage
+from gridCellType import GridCellType
+
+class Landfill:
+    position: Tuple[int, int] = []
+    paper: list[RecognizedGarbage]
+    plastic_and_metal: list[RecognizedGarbage] = []
+    glass: list[RecognizedGarbage] = []
+    bio: list[RecognizedGarbage] = []
+    mixed: list[RecognizedGarbage] = []
+
+    def __init__(self, position: Tuple[int, int]) -> None:
+        self.position = position
+    
+    def add_paper(self, paper: list[RecognizedGarbage]) -> None:
+        for p in paper:
+            self.paper.append(p)
+
+    def add_plastic_and_metal(self, plastic_and_metal: list[RecognizedGarbage]) -> None:
+        for p in plastic_and_metal:
+            self.plastic_and_metal.append(p)
+
+    def add_glass(self, glass: list[RecognizedGarbage]) -> None:
+        for g in glass:
+            self.glass.append(g)
+
+    def add_paper(self, bio: list[RecognizedGarbage]) -> None:
+        for b in bio:
+            self.bio.append(b)
+
+    def add_mixed(self, mixed: list[RecognizedGarbage]) -> None:
+        for m in mixed:
+            self.mixed.append(m)
+
+    def render(self, game_context: GameContext) -> None:
+        game_context.render_in_cell(self.position, 'imgs/landfill.png')
+        game_context.grid[self.position] = GridCellType.LANDFILL

machine_learning/decisionTree.py

@@ -0,0 +1,95 @@
+import os
+from trainingData import TrainingData
+from sklearn import tree
+import joblib
+from sklearn.preprocessing import LabelEncoder, OneHotEncoder
+import numpy as np
+
+def _read_training_data() -> TrainingData:
+    attributes = []
+    classes = []
+    location = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
+    file = open(os.path.join(location, 'training_data.csv'))
+    lines = file.readlines()[1:]
+    file.close()
+    for line in lines:
+        actual_row = line.replace('\n', '')
+        values = actual_row.split(',')
+        line_attributes = values[:-1]
+        line_class = values[-1]
+        attributes.append(line_attributes)
+        classes.append(line_class.strip())
+    return TrainingData(attributes, classes)
+
+def _attributes_to_floats(attributes: list[str]) -> list[float]:
+    output: list[float] = []
+    if attributes[0] == 'Longitiudonal':
+        output.append(0)
+    elif attributes[0] == 'Round':
+        output.append(1)
+    elif attributes[0] == 'Flat':
+        output.append(2)
+    elif attributes[0] == 'Irregular':
+        output.append(3)
+    
+    if attributes[1] == 'Low':
+        output.append(0)
+    elif attributes[1] == 'Medium':
+        output.append(1)
+    elif attributes[1] == 'High':
+        output.append(2)
+    
+
+    if attributes[2] == "Yes":
+        output.append(0)
+    else:
+        output.append(1)
+    
+    if attributes[3] == 'Low':
+        output.append(0)
+    elif attributes[3] == 'Medium':
+        output.append(1)
+    elif attributes[3] == 'High':
+        output.append(2)
+
+    if attributes[4] == 'Low':
+        output.append(0)
+    elif attributes[4] == 'Medium':
+        output.append(1)
+    elif attributes[4] == 'High':
+        output.append(2)
+
+    if attributes[5] == 'Transparent':
+        output.append(0)
+    elif attributes[5] == 'Light':
+        output.append(1)
+    elif attributes[5] == 'Dark':
+        output.append(2)
+    elif attributes[5] == "Colorful":
+        output.append(3)
+
+    if attributes[6] == 'Low':
+        output.append(0)
+    elif attributes[6] == 'Medium':
+        output.append(1)
+    elif attributes[6] == 'High':
+        output.append(2)
+
+    if attributes[7] == "Yes":
+        output.append(0)
+    else:
+        output.append(1)
+    return output
+
+
+
+trainning_data = _read_training_data()
+
+X = trainning_data.attributes
+Y = trainning_data.classes
+
+
+model = tree.DecisionTreeClassifier()
+encoded = [_attributes_to_floats(x) for x in X]
+dtc = model.fit(encoded, Y)
+joblib.dump(model, 'model.pkl')

machine_learning/garbage_infill.csv

@@ -0,0 +1,29 @@
+Shape,Flexibility,DoesSmell,Weight,Size,Color,Softness,DoesDin
+Irregular,High,No,High,Medium,Dark,Low,Yes
+Longitiudonal,Low,No,Low,Low,Light,Medium,Yes
+Longitiudonal,Medium,No,Medium,Low,Dark,High,No
+Longitiudonal,Low,No,Medium,Low,Dark,High,Yes
+Round,Low,Yes,High,High,Transparent,High,Yes
+Irregular,Medium,Yes,High,Low,Transparent,Medium,No
+Longitiudonal,Medium,Yes,Low,High,Colorful,Medium,Yes
+Longitiudonal,Low,No,Low,Medium,Dark,Medium,Yes
+Flat,Medium,Yes,High,Low,Transparent,Low,Yes
+Irregular,Medium,Yes,High,Medium,Dark,Low,No
+Longitiudonal,High,No,Low,High,Colorful,Low,Yes
+Round,Medium,No,Medium,Medium,Dark,Low,No
+Longitiudonal,Medium,No,Medium,Medium,Transparent,High,No
+Flat,Medium,Yes,Low,Low,Light,Medium,No
+Flat,Medium,Yes,Medium,High,Light,Medium,No
+Flat,Low,No,High,Low,Dark,High,No
+Longitiudonal,Medium,Yes,High,High,Dark,Low,Yes
+Flat,Low,Yes,Low,Low,Transparent,Low,No
+Flat,Low,No,Medium,Low,Colorful,Low,No
+Longitiudonal,Low,Yes,High,Medium,Transparent,Low,No
+Longitiudonal,Low,No,Medium,High,Dark,Low,Yes
+Irregular,Medium,No,Medium,Medium,Light,Low,Yes
+Longitiudonal,High,No,High,High,Colorful,Low,No
+Flat,Low,No,Low,Low,Dark,High,No
+Flat,Low,Yes,Low,High,Dark,Low,Yes
+Irregular,Medium,Yes,High,High,Dark,Low,No
+Flat,High,No,High,Low,Dark,Medium,Yes
+Longitiudonal,High,Yes,Low,Medium,Colorful,Low,Yes