ForkliftAgent.py

@@ -1,10 +1,8 @@
-from copy import deepcopy
 from typing import Tuple, List
 
 from AgentBase import AgentBase
 from PatchAgent import PatchAgent
 from PatchType import PatchType
-from data.GameConstants import GameConstants
 from data.Item import Item
 from data.Order import Order
 from data.enum.Direction import Direction
@@ -18,7 +16,7 @@ from util.PathDefinitions import GridLocation, GridWithWeights
 
 class ForkliftAgent(AgentBase):
 
-    def __init__(self, model, game_constants: GameConstants, client_delivery: PatchAgent, drop_off: PatchAgent,
+    def __init__(self, model, game_constants, client_delivery: PatchAgent, drop_off: PatchAgent,
                  graph: GridWithWeights):
         super().__init__(model)
         self.action_queue: List[Action] = []
@@ -30,20 +28,11 @@ class ForkliftAgent(AgentBase):
         self.drop_off: PatchAgent = drop_off
         self.graph = graph
         self.game_constants = game_constants
+        self.current_order: Order = None
+        self.current_item = None
         self.item_station_completed = False
-        self.current_order_delivered_items: List[Item] = []
+        self.provided_items: List[Item] = []
         self.ready_for_execution = False
-        self.last_delviered_item = None
-
-        self.current_item: Item = None
-        self.current_order = None
-        self.base: GridLocation = None
-        self.goal: GridLocation = None
-
-    def set_base(self, drop_off: PatchAgent):
-        self.drop_off = drop_off
-        self.base = self.drop_off.location
-        self.goal = self.base
 
     def queue_movement_actions(self, movement_actions: List[Action]):
         self.action_queue.extend(movement_actions)
@@ -54,94 +43,120 @@ class ForkliftAgent(AgentBase):
             action_type = action.action_type
 
             if action_type == ActionType.ROTATE_UP:
-                # print("rotate {} --> {}".format(self.current_rotation, action_type))
+                print("rotate {} --> {}".format(self.current_rotation, action_type))
                 self.current_rotation = Direction.top
 
             elif action_type == ActionType.ROTATE_RIGHT:
-                # print("rotate {} --> {}".format(self.current_rotation, action_type))
+                print("rotate {} --> {}".format(self.current_rotation, action_type))
                 self.current_rotation = Direction.right
 
             elif action_type == ActionType.ROTATE_DOWN:
-                # print("rotate {} --> {}".format(self.current_rotation, action_type))
+                print("rotate {} --> {}".format(self.current_rotation, action_type))
                 self.current_rotation = Direction.down
 
             elif action_type == ActionType.ROTATE_LEFT:
-                # print("rotate {} --> {}".format(self.current_rotation, action_type))
+                print("rotate {} --> {}".format(self.current_rotation, action_type))
                 self.current_rotation = Direction.left
 
             elif action_type == ActionType.MOVE:
                 if self.current_rotation == Direction.top:
-                    # print("move {} --> {}".format(self.current_position, action_type))
+                    print("move {} --> {}".format(self.current_position, action_type))
                     self.current_position = (self.current_position[0], self.current_position[1] + 1)
 
                 elif self.current_rotation == Direction.down:
-                    # print("move {} --> {}".format(self.current_position, action_type))
+                    print("move {} --> {}".format(self.current_position, action_type))
                     self.current_position = (self.current_position[0], self.current_position[1] - 1)
 
                 elif self.current_rotation == Direction.right:
-                    # print("move {} --> {}".format(self.current_position, action_type))
+                    print("move {} --> {}".format(self.current_position, action_type))
                     self.current_position = (self.current_position[0] + 1, self.current_position[1])
 
                 elif self.current_rotation == Direction.left:
-                    # print("move {} --> {}".format(self.current_position, action_type))
+                    print("move {} --> {}".format(self.current_position, action_type))
                     self.current_position = (self.current_position[0] - 1, self.current_position[1])
 
-    def step(self) -> None:
-        if len(self.action_queue) > 0:
-            self.move()
-        elif self.ready_for_execution:
-            if self.current_position != self.goal:
+    def plan_actions(self):
+        if len(self.current_order.items) > 0:
+            i = self.current_order.items.pop(0)
+            if self.current_item is None:
+                self.provided_items.clear()
+                self.current_item = i
+                print("PLAN MOVEMENT")
+
+                # get item
                 pathFinder = PathFinderOnStates(
                     self.game_constants,
-                    self.goal,
+                    self.drop_off.location,
+                    PathFinderState(self.current_position,
+                                    self.current_rotation,
+                                    0,
+                                    Action(ActionType.NONE),
+                                    [])
+                )
+                actions = pathFinder.get_action_list()
+                self.queue_movement_actions(actions)
+
+            elif not self.item_station_completed:
+                # go through station
+
+                packing_station: GridLocation = None
+                stations = dict(self.graph.packingStations)
+                if i.real_type == ItemType.SHELF:
+                    packing_station = stations[PatchType.packingA]
+                elif i.real_type == ItemType.REFRIGERATOR:
+                    packing_station = stations[PatchType.packingB]
+                elif i.real_type == ItemType.DOOR:
+                    packing_station = stations[PatchType.packingC]
+
+                pathFinder = PathFinderOnStates(
+                    self.game_constants,
+                    packing_station,
                     PathFinderState(self.current_position,
                                     self.current_rotation,
                                     0,
                                     Action(
-                                        desired_item=None,
+                                        desired_item=i,
                                         action_type=ActionType.PICK_ITEM
                                     ),
                                     [])
                 )
                 actions = pathFinder.get_action_list()
                 self.queue_movement_actions(actions)
+                self.item_station_completed = True
+
             else:
-                if self.current_order is not None and self.goal == self.base:
-                    self.current_item = self.current_order.items.pop(0)
-                    packing_station: GridLocation = None
-                    stations = dict(self.graph.packingStations)
-
-                    if self.current_item.real_type == ItemType.SHELF:
-                        packing_station = stations[PatchType.packingShelf]
-                    elif self.current_item.real_type == ItemType.REFRIGERATOR:
-                        packing_station = stations[PatchType.packingRefrigerator]
-                    elif self.current_item.real_type == ItemType.DOOR:
-                        packing_station = stations[PatchType.packingDoor]
-
-                    self.goal = packing_station
-
-                elif self.goal in [i[1] for i in self.graph.packingStations]:
-                    self.goal = self.client_delivery.location
-
-                elif self.goal == self.client_delivery.location:
-                    if self.current_order is not None and len(self.current_order.items) == 0:
-
-                        self.current_order_delivered_items.append(self.current_item)
-                        self.current_order.items = deepcopy(self.current_order_delivered_items)
-                        self.fulfilled_orders.append(self.current_order)
+                # go to client delivery area
+                pathFinder = PathFinderOnStates(
+                    self.game_constants,
+                    self.client_delivery.location,
+                    PathFinderState(self.current_position,
+                                    self.current_rotation,
+                                    0,
+                                    Action(ActionType.NONE),
+                                    [])
+                )
+                actions = pathFinder.get_action_list()
+                self.queue_movement_actions(actions)
+                self.queue_movement_actions(
+                    [Action(ActionType.DROP_ITEM)]
+                )
 
                 self.current_item = None
+                self.provided_items.append(self.current_item)
+                self.item_station_completed = False
+
+    def step(self) -> None:
+        if len(self.action_queue) > 0:
+            self.move()
+        elif self.ready_for_execution and len(self.orderList) > 0:
+            if (self.current_order is not None and len(self.current_order.items)) == 0:
+                self.fulfilled_orders.append(self.current_order)
                 self.current_order = None
 
-                        self.goal = self.base
-                    else:
-                        self.current_order_delivered_items.append(self.current_item)
-                        self.goal = self.base
-                        self.current_item = None
-
-                elif self.goal == self.base and self.current_order is None:
-                    self.current_order_delivered_items.clear()
+            if self.current_order is None:
                 self.current_order = self.orderList.pop(0)
 
+            self.plan_actions()
+
     def creation_log(self):
         print("Created Forklift Agent [id: {}]".format(self.unique_id))

GameModel.py

@@ -9,7 +9,6 @@ from mesa.time import RandomActivation
 from AgentBase import AgentBase
 from ForkliftAgent import ForkliftAgent
 from InitialStateFactory import InitialStateFactory
-from ItemDisplayAgent import ItemDisplayAgent
 from PatchAgent import PatchAgent
 from PatchType import PatchType
 from PictureVisualizationAgent import PictureVisualizationAgent
@@ -19,12 +18,11 @@ from data.Order import Order
 from data.enum.ItemType import ItemType
 from decision.Action import Action
 from decision.ActionType import ActionType
-from genetic_order.GeneticOrder import GeneticOrder
-from imageClasification.Classificator import image_classification
 from pathfinding.PathfinderOnStates import PathFinderOnStates, PathFinderState
-from tree.DecisionTree import DecisionTree
 from util.PathByEnum import PathByEnum
 from util.PathDefinitions import GridLocation, GridWithWeights
+from imageClasification.Classificator import image_clasification
+
 
 
 class Phase(Enum):
@@ -37,9 +35,7 @@ class Phase(Enum):
 
 class GameModel(Model):
 
-    def __init__(self, width, height, graph: GridWithWeights, items: int, orders: int, classificator,
-                 item_display_pos: List[GridLocation]):
-
+    def __init__(self, width, height, graph: GridWithWeights, items: int, orders: int, classificator):
         # self.num_agents = 5
         self.first = True
         self.item_recognised = False
@@ -47,12 +43,10 @@ class GameModel(Model):
         self.grid = MultiGrid(height, width, True)
         self.schedule = RandomActivation(self)
         self.current_item_recognition = None
-        self.current_item = None
 
         self.client_delivery: PatchAgent = None
         self.drop_off: PatchAgent = None
         self.graph = graph
-        self.cut_orders : List[Order] = []
 
         self.game_constants = GameConstants(
             width,
@@ -73,16 +67,15 @@ class GameModel(Model):
 
         self.schedule.add(self.forklift_agent)
         self.agents.append(self.forklift_agent)
-        self.item_display_agents: List[ItemDisplayAgent] = []
 
         # INITIALIZATION #
         print("############## INITIALIZATION ##############")
         self.phase = Phase.INIT
-        self.initialize_grid(graph, item_display_pos)
+        self.initialize_grid(graph)
         self.orderList: List[Order] = InitialStateFactory.generate_order_list(orders)
         self.fulfilled_orders: List[Order] = []
+        self.forklift_agent.orderList = self.orderList
         self.forklift_agent.fulfilled_orders = self.fulfilled_orders
-        self.forklift_agent.set_base(self.drop_off)
         self.classificator = classificator
 
         print("############## RECOGNISE ITEMS ##############")
@@ -91,8 +84,6 @@ class GameModel(Model):
         self.items_for_recognization = copy.deepcopy(self.provided_items)
         self.recognised_items: List[Item] = []
 
-        self.current_order_delivered_items = self.forklift_agent.current_order_delivered_items
-
         print("Relocate forklift agent to loading area for item recognition")
 
         pathFinder = PathFinderOnStates(
@@ -106,9 +97,8 @@ class GameModel(Model):
         print("PATHFINDING")
         print(actions)
         self.forklift_agent.queue_movement_actions(actions)
-        self.current_order = self.forklift_agent.current_order
 
-    def initialize_grid(self, graph: GridWithWeights, item_display_pos):
+    def initialize_grid(self, graph: GridWithWeights):
         print("INITIALIZING GRID")
         # Add the agent to a random grid cell
         x = 5
@@ -129,7 +119,6 @@ class GameModel(Model):
         self.place_walls_agents(graph.walls)
         self.place_puddles(graph.puddles)
         self.place_packing_stations(graph.packingStations)
-        self.place_order_items_display(item_display_pos)
 
     def place_dividers(self):
         for i in range(0, 10):
@@ -170,24 +159,10 @@ class GameModel(Model):
             self.agents.append(agent)
             self.grid.place_agent(agent, p[1])
 
-    def place_order_items_display(self, item_positions: List[GridLocation]):
-        for p in item_positions:
-            agent = ItemDisplayAgent(self, p)
-            self.item_display_agents.append(agent)
-            self.grid.place_agent(agent, p)
-
-    def update_item_display(self):
-        self.current_item = self.forklift_agent.current_item
-        for i in range(4):
-            self.item_display_agents[i].image = None
-            if len(self.forklift_agent.current_order_delivered_items) > i:
-                self.item_display_agents[i].image = self.forklift_agent.current_order_delivered_items[i].image
-
     def step(self):
         self.schedule.step()
         self.grid.remove_agent(self.forklift_agent)
         self.grid.place_agent(self.forklift_agent, self.forklift_agent.current_position)
-        self.update_item_display()
 
         if self.phase == Phase.ITEM_RECOGNITION:
             if not self.item_recognised and self.forklift_agent.current_position == self.drop_off.location:
@@ -205,90 +180,17 @@ class GameModel(Model):
                     self.recognised_items.append(recognised)
 
         if self.phase == Phase.CLIENT_SORTING:
-            orders: [Order] = self.orderList
-            tree: DecisionTree = DecisionTree()
-
-            # CLIENT RECOGNITION
-            orders_with_prio = tree.get_data_good(orders)
-
-            # print("before:" )
-            # for i in range(len(orders_with_prio)):
-            #     print("ORDER {}, PRIO: {}".format(orders_with_prio[i].id, orders_with_prio[i].priority))
-
-            # GENERICS SORTING
-            genericOrder: GeneticOrder = GeneticOrder(orders_with_prio)
-            new_orders = genericOrder.get_orders_sorted(orders)
-
-            # print("after:" )
-            # for i in range(len(new_orders)):
-            #     print("ORDER {}, PRIO: {}".format(new_orders[i].id, new_orders[i].priority))
-
-            self.orderList = new_orders
-            self.count_recognised_items()
-
-            self.sort_orders()
-
-            self.forklift_agent.orderList = self.orderList
-
+            # TODO GENERICS SORTING
+            sorted(self.orderList, key=lambda x: len(x.items))
             print("FINISHED CLIENT ORDER SORTING")
             self.phase = Phase.EXECUTION
 
         if self.phase == Phase.EXECUTION:
-            self.current_order = self.forklift_agent.current_order
-            pass
-            # print("Execution")
-
-    def sort_orders(self):
-        orders_to_fill: [Order] = []
-        cut_orders: [Order] = []
-
-        for i in range(len(self.orderList)):
-            o: Order = self.orderList[i]
-            refrige = self.count_item_type(o, ItemType.REFRIGERATOR)
-            shelf = self.count_item_type(o, ItemType.SHELF)
-            door = self.count_item_type(o, ItemType.DOOR)
-
-            if self.count_shelf - shelf >= 0 and self.count_refrige - refrige >= 0 and self.count_door - door >= 0:
-                self.count_shelf -= shelf
-                self.count_door -= door
-                self.count_refrige -= refrige
-                orders_to_fill.append(o)
-            else:
-                cut_orders.append(o)
-
-        self.cut_orders = cut_orders
-        self.orderList = orders_to_fill
-        self.forklift_agent.orderList = orders_to_fill
-
-    def count_item_type(self, o: Order, itemType: ItemType) -> int:
-        res = 0
-        for i in range(len(o.items)):
-            it: Item = o.items[i]
-            if it.guessed_type == itemType:
-               res += 1
-
-        return res
-
-    def count_recognised_items(self):
-        count_refrige: int = 0
-        count_door: int = 0
-        count_shelf: int = 0
-
-        for i in range(len(self.recognised_items)):
-            item: Item = self.recognised_items[i]
-            if item.guessed_type == ItemType.DOOR:
-                count_door += 1
-            elif item.guessed_type == ItemType.SHELF:
-                count_shelf += 1
-            else:
-                count_refrige += 1
-
-        self.count_door = count_door
-        self.count_shelf = count_shelf
-        self.count_refrige = count_refrige
+            print("Execution")
 
     def recognise_item(self, item: Item):
-        val = image_classification(self.picture_visualization.img, self.classificator)
+        # TODO IMAGE PROCESSING
+        val = image_clasification(self.picture_visualization.img, self.classificator)
         print("VAL: {}".format(val))
 
         if val == ItemType.DOOR:

InitialStateFactory.py

@@ -3,9 +3,7 @@ import random
 from data.Item import Item
 from data.Order import Order
 from data.enum.ItemType import ItemType
-from data.enum.Priority import Priority
 from util.ClientParamsFactory import ClientParamsFactory
-from util.PathByEnum import PathByEnum
 
 
 class InitialStateFactory:
@@ -26,38 +24,6 @@ class InitialStateFactory:
 
         return order_list
 
-    @staticmethod
-    def generate_order_list_XD(output_order_list_size: int):
-        order_list: [Order] = []
-        for i in range(output_order_list_size):
-            order_list.append(InitialStateFactory.__generate_order_XD())
-
-        return order_list
-
-    @staticmethod
-    def __generate_order_XD() -> Order:
-        order_size = random.randint(1, 4)
-
-        items: [Item] = []
-        for i in range(order_size):
-            items.append(InitialStateFactory.__generate_item())
-
-        time_base = random.randint(8, 20)
-        final_time = time_base * order_size
-
-        client_params = ClientParamsFactory.get_client_params()
-
-        x = random.randint(0, 3)
-        type = Priority.LOW
-        if x == 0:
-            type = Priority.MEDIUM
-        elif x == 1:
-            type = Priority.HIGH
-
-        x = random.randint(20, 300)
-
-        return Order(final_time, items, type, x, client_params)
-
     @staticmethod
     def __generate_order() -> Order:
         order_size = random.randint(1, 4)
@@ -71,7 +37,7 @@ class InitialStateFactory:
 
         client_params = ClientParamsFactory.get_client_params()
 
-        return Order(final_time, items, Priority.LOW, 0, client_params)
+        return Order(final_time, items, None, client_params)
 
     @staticmethod
     def generate_input_sequence(self, input_sequence_size):
@@ -84,6 +50,4 @@ class InitialStateFactory:
     @staticmethod
     def __generate_item() -> Item:
         randomly_picked_type = random.choice(list(ItemType))
-        item = Item(randomly_picked_type, PathByEnum.get_random_path(randomly_picked_type))
-        item.guessed_type = item.real_type
-        return item
+        return Item(randomly_picked_type)

ItemDisplayAgent.py

@@ -1,10 +0,0 @@
-from PatchAgent import PatchAgent
-from PatchType import PatchType
-from util.PathDefinitions import GridLocation
-
-
-class ItemDisplayAgent(PatchAgent):
-
-    def __init__(self, model, location: GridLocation):
-        self.image = None
-        super().__init__(model, location, patch_type=PatchType.itemDisplay)

PatchType.py

@@ -7,8 +7,7 @@ class PatchType(enum.Enum):
     item = 3
     wall = 4
     diffTerrain = 5
-    packingShelf = 6
-    packingRefrigerator = 7
-    packingDoor = 8
+    packingA = 6
+    packingB = 7
+    packingC = 8
     divider = 9
-    itemDisplay = 10

data/GameConstants.py

@@ -1,7 +1,5 @@
 from typing import Dict
 
-from data.Item import Item
-from data.Order import Order
 from data.enum.ItemType import ItemType
 from util.PathDefinitions import GridLocation
 
@@ -11,10 +9,16 @@ class GameConstants:
             self,
             grid_width: int,
             grid_height: int,
+            # delivery_pos: GridLocation,
+            # order_pos: GridLocation,
+            # special_positions: Dict[ItemType, GridLocation],
             walls: [GridLocation],
             diffTerrain: [GridLocation]
     ):
         self.grid_width = grid_width
         self.grid_height = grid_height
+        # self.delivery_pos = delivery_pos
+        # self.order_pos = order_pos
+        # self.special_positions = special_positions
         self.walls = walls
         self.diffTerrain = diffTerrain

data/Item.py

@@ -6,10 +6,9 @@ from data.enum.ItemType import ItemType
 class Item:
     id_counter = count(start=0)
 
-    def __init__(self, item_type: ItemType, image):
+    def __init__(self, item_type: ItemType):
         self.id = next(self.id_counter)
         self.real_type = item_type
-        self.image = image
         self.guessed_type = None
 
     def __repr__(self) -> str:

data/Order.py

@@ -9,18 +9,12 @@ from data.enum.Priority import Priority
 class Order:
     id_counter = count(start=0)
 
-    def __init__(self, time: int, items: [Item], priority: Priority, sum: int, client_params: ClientParams):
+    def __init__(self, time: int, items: [Item], priority: Priority, client_params: ClientParams):
         self.id = next(self.id_counter)
         self.time = time
         self.items: List[Item] = items
         self.client_params = client_params
         self.priority = priority
-        self.sum = sum
-
-    # def sum_items(self, items: [Item]):
-    #     result = 0
-    #     for i in range(len(items)):
-    #         result += items[i]
 
     def __repr__(self) -> str:
         return "items: {} priority: {}".format(self.items, self.priority)

data/enum/GeneticMutationType.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-
-class GeneticMutationType(Enum):
-    MUTATION = 1
-    CROSS = 2
-    REVERSE = 3

decision/State.py

@@ -1,7 +1,6 @@
 from data.enum.Direction import Direction
 from data.Item import Item
 from data.Order import Order
-from data.enum.Priority import Priority
 from decision.ActionType import ActionType
 from util.PathDefinitions import GridLocation
 
@@ -11,7 +10,7 @@ class State:
                  action_taken: ActionType,
                  forklift_position: GridLocation,
                  forklift_rotation: Direction,
-                 pending_orders: [Priority, [Order]],
+                 pending_orders: [Order],
                  filled_orders: [Order],
                  input_items: [Item]
                  ):

decision/test/ForkliftActions.py

@@ -1,9 +0,0 @@
-from data.GameConstants import GameConstants
-
-
-class ForkliftActions:
-
-    def __init__(self, game: GameConstants,
-                 ) -> None:
-        self.game = game
-

genetic_order/GeneticOrder.py

@@ -1,218 +0,0 @@
-import itertools
-import random
-
-from data.Order import Order
-from data.enum.GeneticMutationType import GeneticMutationType
-from data.enum.Priority import Priority
-
-
-class GeneticOrder:
-    mutation_chance = 10
-    reverse_chance = 60
-    cross_chance = 5
-
-    best_fit_special = 50
-    best_fit_super_special = 20
-
-    population_size = 200
-    number_of_populations = 1000
-
-    punish_low = 500
-    punish_med = 300
-
-    punish_sum = 50
-
-    def __init__(self, orders: [Order]) -> None:
-        self.orders = orders
-
-    def get_mutation_type(self) -> GeneticMutationType:
-        x = random.randint(0, self.mutation_chance + self.cross_chance + self.reverse_chance)
-
-        if x < self.mutation_chance:
-            return GeneticMutationType.MUTATION
-
-        if x > self.mutation_chance + self.cross_chance:
-            return GeneticMutationType.REVERSE
-
-        return GeneticMutationType.CROSS
-
-    def mutation(self, population: [int]) -> [int]:
-        x = random.randint(0, len(population) - 1)
-        y = random.randint(0, len(population) - 1)
-        while x == y:
-            y = random.randint(0, len(population) - 1)
-
-        result = population
-
-        pom = population[x]
-        result[x] = population[y]
-        result[y] = pom
-
-        if (result[x] == result[y]):
-            print("PIZDA I CHUJ")
-
-        return result
-
-    def cross(self, population: [int]) -> [int]:
-        x = random.randint(1, len(population) - 1)
-
-        result = []
-
-        for i in range(len(population)):
-            result.append(population[(i + x) % len(population)])
-
-        return result
-
-    def reverse(self, population: [int]) -> [int]:
-        x = random.randint(0, len(population))
-        y = random.randint(0, len(population) - 1)
-        while y - x > 2 or x >= y:
-            x = random.randint(0, len(population))
-            y = random.randint(0, len(population) - 1)
-
-        result = []
-        # print("X: ", x, " y: ", y)
-
-        for i in range(len(population)):
-            if x <= i <= y:
-                new_i = i - x
-                # print("len:", len(population), " new_i: ", new_i)
-                result.append(population[y - new_i])
-            else:
-                result.append(population[i])
-
-        return result
-
-    def generate_first_population(self, k: int) -> [[int]]:
-        result = []
-
-        s = range(len(self.orders))
-        p = itertools.permutations(s)
-        while len(result) < k:
-            n = p.__next__()
-            if n not in result:
-                result.append(n)
-
-        return [list(x) for x in result]
-
-        # result = itertools.permutations(range(len(self.orders)))
-        #
-        # return [list(x) for x in result]
-
-    def correct_sum(self, last_prio: Priority, last_sum: float, o: Order) -> bool:
-        if o.priority == last_prio:
-            return last_sum > o.sum / o.time
-        return True
-
-    def sum_wrong(self, member: [int]) -> int:
-        last_high = 0
-        last_med = 0
-        last_prio = Priority.HIGH
-        last_sum = 0
-        counter = 0
-
-        for i in range(len(member)):
-            o: Order = self.orders[member[i]]
-            if o.priority == Priority.HIGH:
-                last_high = i
-            elif o.priority == Priority.MEDIUM:
-                last_med = i
-
-            if not self.correct_sum(last_prio, last_sum, o):
-                counter += int(last_sum - (o.sum / o.time))
-            last_prio = o.priority
-            last_sum = o.sum / o.time
-
-        for i in range(last_high):
-            o: Order = self.orders[member[i]]
-            if o.priority == Priority.MEDIUM:
-                counter += self.punish_med
-            elif o.priority == Priority.LOW:
-                counter += self.punish_low
-
-        for i in range(last_med):
-            o: Order = self.orders[member[i]]
-            if o.priority == Priority.LOW:
-                counter += self.punish_low
-
-        return counter
-
-    def evaluate(self, member: [int]) -> int:
-        # result = 0
-        # for i in range(len(self.orders) - 1):
-        #     x: Order = self.orders[member[i]]
-        #     y: Order = self.orders[member[i + 1]]
-        #
-        #     if ((x.priority == Priority.MEDIUM or x.priority == Priority.LOW) and y.priority == Priority.HIGH) or (x.priority == Priority.LOW and y.priority == Priority.MEDIUM):
-        #         result += 30
-        #
-        #     if x.sum / x.time < y.sum / y.time:
-        #         result += int(y.sum / y.time)
-
-        # return result
-
-        return self.sum_wrong(member)
-
-    def mutate_population(self, order_population: [[int]]) -> [[int]]:
-        result = []
-
-        for i in range(len(order_population)):
-            member: [int] = order_population[i]
-            operation: GeneticMutationType = self.get_mutation_type()
-
-            if operation == GeneticMutationType.MUTATION:
-                member = self.mutation(member)
-            elif operation == GeneticMutationType.REVERSE:
-                member = self.reverse(member)
-            else:
-                member = self.cross(member)
-
-            result.append(member)
-
-        return result
-
-    def get_next_population(self, population: [[int]]) -> [[int]]:
-        result = []
-
-        for i in range(len(population) - self.best_fit_special - self.best_fit_super_special):
-            result.append(population[i])
-
-        for i in range(self.best_fit_special):
-            x = random.randint(0, self.best_fit_special)
-            result.append(population[x])
-
-        for i in range(self.best_fit_super_special):
-            x = random.randint(0, self.best_fit_super_special)
-            result.append(population[x])
-
-        return result
-
-    def get_orders_sorted(self, orders: [Order]) -> [Order]:
-        self.orders = orders
-
-        population: [[int]] = self.generate_first_population(self.population_size)
-        # print(population)
-
-        population.sort(key=self.evaluate)
-        best_fit: [int] = population[0]
-
-        for i in range(self.number_of_populations):
-            # print("population: ", i)
-            population = self.mutate_population(population)
-            population.sort(key=self.evaluate)
-
-            if self.evaluate(best_fit) > self.evaluate(population[0]):
-                best_fit = population[0]
-
-            # population = self.get_next_population(population).sort(key=self.evaluate)
-
-            if self.evaluate(best_fit) < self.evaluate(population[0]):
-                population[0] = best_fit
-
-        best: [int] = population[0]
-        result: [Order] = []
-
-        for i in range(len(best)):
-            result.append(self.orders[best[i]])
-
-        return result

imageClasification/Classificator.py

@@ -1,22 +1,23 @@
 import numpy as np
 import tensorflow as tf
-from tensorflow import keras
 
 
+def image_clasification(image_path, model):
     # loaded_model = keras.models.load_model("my_model")
-
-def image_classification(path, model):
     class_names = ['door', 'refrigerator', 'shelf']
 
     img = tf.keras.utils.load_img(
-        path, target_size=(180, 180)
+        image_path, target_size=(180, 180)
     )
     img_array = tf.keras.utils.img_to_array(img)
     img_array = tf.expand_dims(img_array, 0)  # Create a batch
 
     predictions = model.predict(img_array)
     score = tf.nn.softmax(predictions[0])
-    # print(class_names[np.argmax(score)])
+    # print(
+    #     "This image most likely belongs to {} with a {:.2f} percent confidence."
+    #         .format(class_names[np.argmax(score)], 100 * np.max(score))
+    # )
     return class_names[np.argmax(score)]
 
 

imageClasification/usedAssets/ClassificatorInside.py

@@ -9,7 +9,7 @@ from tensorflow.keras import layers
 from tensorflow.keras.models import Sequential
 
 
-class TrainClassificator():
+class ClassificatorInside():
 
     def __init__(self, data_dir: str) -> None:
         super().__init__()

main.py

@@ -6,7 +6,6 @@ from tensorflow import keras
 
 from ForkliftAgent import ForkliftAgent
 from GameModel import GameModel
-from ItemDisplayAgent import ItemDisplayAgent
 from PatchAgent import PatchAgent
 from PatchType import PatchType
 from PictureVisualizationAgent import PictureVisualizationAgent
@@ -14,7 +13,6 @@ from data.enum.Direction import Direction
 from util.PathDefinitions import GridWithWeights
 from visualization.DisplayAttributeElement import DisplayAttributeElement
 from visualization.DisplayItemListAttribute import DisplayItemListAttributeElement
-from visualization.DisplayOrder import DisplayOrder
 from visualization.DisplayOrderList import DisplayOrderList
 
 colors = [
@@ -35,7 +33,7 @@ def agent_portrayal(agent):
         elif agent.current_rotation == Direction.left:
             shape = "img/image_left.png"
 
-        portrayal = {"Shape": shape, "scale": 1.0, "Layer": 2}
+        portrayal = {"Shape": shape, "scale": 1.0, "Layer": 0}
 
     if isinstance(agent, PatchAgent):
         color = colors[0]
@@ -47,13 +45,6 @@ def agent_portrayal(agent):
             portrayal = {"Shape": "img/okB00mer.png", "scale": 1.0, "Layer": 0}
         elif agent.patch_type == PatchType.diffTerrain:
             portrayal = {"Shape": "img/puddle.png", "scale": 1.0, "Layer": 0}
-        elif agent.patch_type == PatchType.packingShelf:
-            portrayal = {"Shape": "img/shelf_s.jpg", "scale": 1.0, "Layer": 1}
-        elif agent.patch_type == PatchType.packingRefrigerator:
-            portrayal = {"Shape": "img/fridge_f.jpg", "scale": 1.0, "Layer": 1}
-        elif agent.patch_type == PatchType.packingDoor:
-            portrayal = {"Shape": "img/door_d.jpg", "scale": 1.0, "Layer": 1}
-
         elif agent.patch_type == PatchType.divider:
             portrayal = \
                 {"Shape": "rect",
@@ -74,18 +65,6 @@ def agent_portrayal(agent):
     if isinstance(agent, PictureVisualizationAgent):
         portrayal = {"Shape": f"{agent.img}", "scale": 3.0, "Layer": 0}
 
-    if isinstance(agent, ItemDisplayAgent):
-        if agent is not None and agent.image is not None:
-            portrayal = {"Shape": f"{agent.image}", "scale": 1.0, "Layer": 0}
-        else:
-            portrayal = \
-                {"Shape": "rect",
-                 "Filled": "true",
-                 "Layer": 0,
-                 "Color": "black",
-                 "w": 1,
-                 "h": 1}
-
     return portrayal
 
 
@@ -96,32 +75,26 @@ if __name__ == '__main__':
     scale = base / gridWidth
 
     diagram = GridWithWeights(gridWidth, gridHeight)
-    diagram.walls = [(6, 5), (6, 6), (6, 7), (6, 8), (2, 3), (2, 4), (2, 6), (4, 7), (3, 4), (4, 4), (6, 4)]
-    diagram.puddles = [(2, 2), (2, 5), (5, 4), (4, 8), (4, 6), (4, 2)]
-    diagram.packingStations = [(PatchType.packingShelf, (4, 8)), (PatchType.packingRefrigerator, (4, 6)),
-                               (PatchType.packingDoor, (4, 2))]
+    diagram.walls = [(6, 5), (6, 6), (6, 7), (6, 8), (2, 3), (2, 4), (3, 4), (4, 4), (6, 4)]
+    diagram.puddles = [(2, 2), (2, 5), (2, 6), (5, 4)]
+    diagram.packingStations = [(PatchType.packingA, (4, 8)), (PatchType.packingB, (4, 6)), (PatchType.packingC, (4, 2))]
 
     grid = CanvasGrid(agent_portrayal, gridWidth, gridHeight, scale * gridWidth, scale * gridHeight)
 
-    display_items = [(6, 11), (7, 11), (8, 11), (9, 11)]
-
     readyText = DisplayAttributeElement("phase")
+    # current_item = DisplayPictureElement("current_item_recognition")
     provided_itesm = DisplayItemListAttributeElement("provided_items")
     recognised_items = DisplayItemListAttributeElement("recognised_items")
-    current_order = DisplayOrder("current_order")
-    current_item = DisplayAttributeElement("current_item")
     ordersText = DisplayOrderList("orderList")
     fulfilled_orders = DisplayOrderList("fulfilled_orders")
-    cut_orders = DisplayOrderList("cut_orders")  # MTR!
 
-    model = keras.models.load_model("imageClasification/my_model")
+    loaded_model = keras.models.load_model("./imageClasification/my_model")
 
     server = ModularServer(GameModel,
-                           [grid, readyText, current_item, current_order, fulfilled_orders, ordersText, provided_itesm,
-                            recognised_items, cut_orders],
+                           [grid, readyText, provided_itesm, recognised_items, ordersText,
+                            fulfilled_orders],
                            "Automatyczny Wózek Widłowy",
-                           dict(width=gridHeight, height=gridWidth, graph=diagram, items=60, orders=20,
-                                classificator=model, item_display_pos=display_items))
+                           dict(width=gridHeight, height=gridWidth, graph=diagram, items=50, orders=3, classificator=loaded_model))
 
     server.port = 8888
     server.launch()

pathfinding/PathfinderOnStates.py

@@ -57,7 +57,7 @@ class PathFinderOnStates:
 
         if action == action.action_type.MOVE:
             if curr_state.agent_position in self.game_constants.diffTerrain:
-                cost = curr_state.cost + 45
+                cost = curr_state.cost + 20
             # tutaj koszt kaluzy
             else:
                 cost = curr_state.cost + 1

tree/DecisionTree.py

@@ -1,17 +1,11 @@
 import csv
 
-import numpy as np
 import pandas
 import sklearn
 from sklearn import metrics, preprocessing
 from sklearn.model_selection import train_test_split
 from sklearn.tree import DecisionTreeClassifier
 
-from InitialStateFactory import InitialStateFactory
-from data.ClientParams import ClientParams
-from data.Order import Order
-from data.enum.CompanySize import CompanySize
-from data.enum.Priority import Priority
 from util.ClientParamsFactory import ClientParamsFactory
 
 
@@ -64,63 +58,6 @@ class DecisionTree:
         print("\nDecisionTrees's Accuracy: ", metrics.accuracy_score(y, prediction))
 
 
-    def get_data_good(self, orders: [Order]) -> [Order]:
-
-        n_array_input = []
-        for i in range(len(orders)):
-            o:Order = orders[i]
-            cp: ClientParams = o.client_params
-            pom = []
-
-            pom.append(cp.payment_delay)
-            pom.append(cp.payed)
-            pom.append(cp.net_worth)
-            pom.append(cp.infuence_rate)
-            pom.append(cp.is_skarbowka)
-            pom.append(cp.membership)
-            pom.append(cp.is_hat)
-
-            size: CompanySize = cp.company_size
-            if(size == CompanySize.NO):
-                pom.append(0)
-            if (size == CompanySize.SMALL):
-                pom.append(1)
-            if (size == CompanySize.NORMAL):
-                pom.append(2)
-            if (size == CompanySize.BIG):
-                pom.append(3)
-            if (size == CompanySize.HUGE):
-                pom.append(4)
-            if (size == CompanySize.GIGANTISHE):
-                pom.append(5)
-
-
-
-            n_array_input.append(pom)
-
-        n_array = np.array(n_array_input)
-        # print(n_array)
-
-        # print(n_array[0])
-        tree = self.get_decision_tree()
-        priority = tree.predict(n_array)
-
-
-        for i in range(len(orders)):
-            print(orders[i].priority)
-            orders[i].priority = priority[i]
-
-            if priority[i] == "LOW":
-                orders[i].priority = Priority.LOW
-            if priority[i] == "MEDIUM":
-                orders[i].priority = Priority.MEDIUM
-            if priority[i] == "HIGH":
-                orders[i].priority = Priority.HIGH
-
-            print(orders[i].priority)
-
-
-        return orders
 
 
     def get_decision_tree(self) -> DecisionTreeClassifier:
@@ -135,25 +72,15 @@ class DecisionTree:
 
         X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, train_size=0.8)
 
-        # print(len(X_train[0]))
-        # print(X_train[0])
-
         drugTree = DecisionTreeClassifier(criterion="entropy", max_depth=4)
 
         clf = drugTree.fit(X_train, y_train)
         predicted = drugTree.predict(X_test)
 
-        # print(type(X_test))
-
         y_test = y_test.to_list()
 
-        # self.print_logs(X_test, y_test, predicted)
+        self.print_logs(X_test, y_test, predicted)
 
-        # print(sklearn.tree.export_text(clf, feature_names=X_headers))
+        print(sklearn.tree.export_text(clf, feature_names=X_headers))
 
         return drugTree
-
-
-
-# kurwa = DecisionTree()
-# kurwa.get_data_good(InitialStateFactory.generate_order_list(50))

visualization/DisplayOrder.py

@@ -1,46 +0,0 @@
-from collections import Counter
-from typing import List
-
-from mesa.visualization.modules import TextElement
-
-from data.Order import Order
-
-
-class DisplayOrder(TextElement):
-    def __init__(self, attr_name):
-        '''
-        Create a new text attribute element.
-
-        Args:
-            attr_name: The name of the attribute to extract from the model.
-
-        Example return: "happy: 10"
-        '''
-        self.attr_name = attr_name
-
-    def render(self, model):
-        val = getattr(model, self.attr_name)
-        res = self.attr_name
-        if val is not None:
-            o = val
-            itemList = map(lambda x: x.real_type, o.items)
-            itemCounter = Counter(itemList)
-
-            item_str = "<ul>"
-            for e in itemCounter:
-                key = e
-                val = itemCounter[key]
-
-                # key_str = ""
-                # if key == ItemType.DOOR:
-                #     key_str = "Door"
-                # elif key == ItemType.SHELF:
-                #     key_str = "Shelf"
-
-                item_str += f"<li>{str(key)}:{str(val)}</li>"
-
-            item_str += "</ul>"
-
-            res += f"<li> items: {item_str} priority: {o.priority} <br> Client: {vars(o.client_params)} </li>"
-
-        return res

visualization/DisplayOrderList.py

@@ -4,6 +4,7 @@ from typing import List
 from mesa.visualization.modules import TextElement
 
 from data.Order import Order
+from data.enum.ItemType import ItemType
 
 
 class DisplayOrderList(TextElement):
@@ -20,8 +21,7 @@ class DisplayOrderList(TextElement):
 
     def render(self, model):
         val = getattr(model, self.attr_name)
-        res = ""
-        if val is not None:
+
         orderList: List[Order] = val
 
         res = self.attr_name + ": <ol>"