302 lines
11 KiB
Python
302 lines
11 KiB
Python
import copy
|
|
from enum import Enum
|
|
from typing import List, Tuple
|
|
|
|
from mesa import Model
|
|
from mesa.space import MultiGrid
|
|
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
|
|
from data.GameConstants import GameConstants
|
|
from data.Item import Item
|
|
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
|
|
|
|
|
|
class Phase(Enum):
|
|
INIT = 1
|
|
ITEM_RECOGNITION = 2
|
|
CLIENT_SORTING = 3
|
|
PLAN_MOVEMENT = 4
|
|
EXECUTION = 5
|
|
|
|
|
|
class GameModel(Model):
|
|
|
|
def __init__(self, width, height, graph: GridWithWeights, items: int, orders: int, classificator,
|
|
item_display_pos: List[GridLocation]):
|
|
|
|
# self.num_agents = 5
|
|
self.first = True
|
|
self.item_recognised = False
|
|
self.running = True
|
|
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,
|
|
height,
|
|
graph.walls,
|
|
graph.puddles
|
|
)
|
|
|
|
self.agents = [AgentBase]
|
|
|
|
self.forklift_agent = ForkliftAgent(
|
|
self,
|
|
self.game_constants,
|
|
self.client_delivery,
|
|
self.drop_off,
|
|
self.graph
|
|
)
|
|
|
|
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.orderList: List[Order] = InitialStateFactory.generate_order_list(orders)
|
|
self.fulfilled_orders: List[Order] = []
|
|
self.forklift_agent.fulfilled_orders = self.fulfilled_orders
|
|
self.forklift_agent.set_base(self.drop_off)
|
|
self.classificator = classificator
|
|
|
|
print("############## RECOGNISE ITEMS ##############")
|
|
self.phase = Phase.ITEM_RECOGNITION
|
|
self.provided_items = InitialStateFactory.generate_item_list(items)
|
|
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(
|
|
self.game_constants,
|
|
self.drop_off.location,
|
|
PathFinderState(self.forklift_agent.current_position, self.forklift_agent.current_rotation, 0,
|
|
Action(ActionType.NONE), [])
|
|
)
|
|
|
|
actions = pathFinder.get_action_list()
|
|
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):
|
|
print("INITIALIZING GRID")
|
|
# Add the agent to a random grid cell
|
|
x = 5
|
|
y = 5
|
|
self.grid.place_agent(self.forklift_agent, (x, y))
|
|
self.forklift_agent.current_position = (x, y)
|
|
|
|
self.picture_visualization = PictureVisualizationAgent(
|
|
self,
|
|
(1, 11),
|
|
)
|
|
self.schedule.add(self.picture_visualization)
|
|
self.grid.place_agent(self.picture_visualization, self.picture_visualization.location)
|
|
self.agents.append(self.picture_visualization)
|
|
|
|
self.place_logistics()
|
|
self.place_dividers()
|
|
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):
|
|
for j in range(10, 13):
|
|
agent = PatchAgent(self, (i, j), PatchType.divider)
|
|
self.agents.append(agent)
|
|
self.grid.place_agent(agent, (i, j))
|
|
|
|
def place_logistics(self):
|
|
agent = PatchAgent(self, (self.grid.width - 1, int(self.grid.height / 2)), PatchType.pickUp)
|
|
self.schedule.add(agent)
|
|
self.grid.place_agent(agent, agent.location)
|
|
self.agents.append(agent)
|
|
self.client_delivery = agent
|
|
self.forklift_agent.client_delivery = self.client_delivery
|
|
|
|
agent = PatchAgent(self, (0, int(self.grid.height / 2)), PatchType.dropOff)
|
|
self.grid.place_agent(agent, agent.location)
|
|
self.agents.append(agent)
|
|
self.drop_off = agent
|
|
self.forklift_agent.drop_off = self.drop_off
|
|
|
|
def place_walls_agents(self, walls: List[GridLocation]):
|
|
for w in walls:
|
|
agent = PatchAgent(self, w, PatchType.wall)
|
|
self.agents.append(agent)
|
|
self.grid.place_agent(agent, w)
|
|
|
|
def place_puddles(self, puddles: List[GridLocation]):
|
|
for p in puddles:
|
|
agent = PatchAgent(self, p, PatchType.diffTerrain)
|
|
self.agents.append(agent)
|
|
self.grid.place_agent(agent, p)
|
|
|
|
def place_packing_stations(self, packing_stations: List[Tuple[PatchType, GridLocation]]):
|
|
for p in packing_stations:
|
|
agent = PatchAgent(self, p[1], p[0])
|
|
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:
|
|
|
|
if len(self.items_for_recognization) == 0:
|
|
print("FINISHED ITEM RECOGNITION")
|
|
self.item_recognised = True
|
|
self.phase = Phase.CLIENT_SORTING
|
|
self.forklift_agent.ready_for_execution = True
|
|
else:
|
|
print("BEGIN ITEM RECOGNITION, left: {}".format(len(self.items_for_recognization)))
|
|
item_to_recognise = self.items_for_recognization.pop()
|
|
self.picture_visualization.img = PathByEnum.get_random_path(item_to_recognise.real_type)
|
|
recognised = self.recognise_item(item_to_recognise)
|
|
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
|
|
|
|
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
|
|
|
|
def recognise_item(self, item: Item):
|
|
val = image_classification(self.picture_visualization.img, self.classificator)
|
|
print("VAL: {}".format(val))
|
|
|
|
if val == ItemType.DOOR:
|
|
item.guessed_type = ItemType.DOOR
|
|
elif val == ItemType.REFRIGERATOR:
|
|
item.guessed_type = ItemType.REFRIGERATOR
|
|
elif val == ItemType.SHELF:
|
|
item.guessed_type = ItemType.SHELF
|
|
|
|
return item
|