order_visualization #5

Merged
s464919 merged 7 commits from order_visualization into master 2022-06-10 08:56:02 +02:00
10 changed files with 267 additions and 190 deletions

View File

@ -1,8 +1,10 @@
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
@ -16,7 +18,7 @@ from util.PathDefinitions import GridLocation, GridWithWeights
class ForkliftAgent(AgentBase):
def __init__(self, model, game_constants, client_delivery: PatchAgent, drop_off: PatchAgent,
def __init__(self, model, game_constants: GameConstants, client_delivery: PatchAgent, drop_off: PatchAgent,
graph: GridWithWeights):
super().__init__(model)
self.action_queue: List[Action] = []
@ -28,11 +30,20 @@ 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.provided_items: List[Item] = []
self.current_order_delivered_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)
@ -43,120 +54,94 @@ 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 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
def step(self) -> None:
if len(self.action_queue) > 0:
self.move()
elif self.ready_for_execution:
if self.current_position != self.goal:
pathFinder = PathFinderOnStates(
self.game_constants,
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.packingShelf]
elif i.real_type == ItemType.REFRIGERATOR:
packing_station = stations[PatchType.packingRefrigerator]
elif i.real_type == ItemType.DOOR:
packing_station = stations[PatchType.packingC]
pathFinder = PathFinderOnStates(
self.game_constants,
packing_station,
self.goal,
PathFinderState(self.current_position,
self.current_rotation,
0,
Action(
desired_item=i,
desired_item=None,
action_type=ActionType.PICK_ITEM
),
[])
)
actions = pathFinder.get_action_list()
self.queue_movement_actions(actions)
self.item_station_completed = True
else:
# 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)]
)
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)
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
if self.current_order is None:
self.current_order = self.orderList.pop(0)
self.goal = self.base
else:
self.current_order_delivered_items.append(self.current_item)
self.goal = self.base
self.current_item = None
self.plan_actions()
elif self.goal == self.base and self.current_order is None:
self.current_order_delivered_items.clear()
self.current_order = self.orderList.pop(0)
def creation_log(self):
print("Created Forklift Agent [id: {}]".format(self.unique_id))

View File

@ -9,6 +9,7 @@ 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
@ -36,7 +37,9 @@ class Phase(Enum):
class GameModel(Model):
def __init__(self, width, height, graph: GridWithWeights, items: int, orders: int, classificator):
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
@ -44,10 +47,12 @@ 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,
@ -68,15 +73,16 @@ 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)
self.initialize_grid(graph, item_display_pos)
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 ##############")
@ -85,6 +91,8 @@ 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(
@ -98,8 +106,9 @@ 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):
def initialize_grid(self, graph: GridWithWeights, item_display_pos):
print("INITIALIZING GRID")
# Add the agent to a random grid cell
x = 5
@ -120,6 +129,7 @@ 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):
@ -160,10 +170,24 @@ 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:
@ -200,15 +224,70 @@ class GameModel(Model):
# 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:
print("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):
# TODO IMAGE PROCESSING
val = image_classification(self.picture_visualization.img, self.classificator)
print("VAL: {}".format(val))

View File

@ -5,6 +5,7 @@ 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:
@ -83,4 +84,6 @@ class InitialStateFactory:
@staticmethod
def __generate_item() -> Item:
randomly_picked_type = random.choice(list(ItemType))
return Item(randomly_picked_type)
item = Item(randomly_picked_type, PathByEnum.get_random_path(randomly_picked_type))
item.guessed_type = item.real_type
return item

10
ItemDisplayAgent.py Normal file
View File

@ -0,0 +1,10 @@
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)

View File

@ -11,3 +11,4 @@ class PatchType(enum.Enum):
packingRefrigerator = 7
packingDoor = 8
divider = 9
itemDisplay = 10

View File

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

112
main.py
View File

@ -1,24 +1,20 @@
import math
import random
from mesa.visualization.ModularVisualization import ModularServer
from mesa.visualization.modules import CanvasGrid
from tensorflow import keras
from ForkliftAgent import ForkliftAgent
from GameModel import GameModel
from InitialStateFactory import InitialStateFactory
from ItemDisplayAgent import ItemDisplayAgent
from PatchAgent import PatchAgent
from PatchType import PatchType
from PictureVisualizationAgent import PictureVisualizationAgent
from data.Order import Order
from data.enum.Direction import Direction
from tensorflow import keras
from data.enum.Priority import Priority
from genetic_order.GeneticOrder import GeneticOrder
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 = [
@ -39,7 +35,7 @@ def agent_portrayal(agent):
elif agent.current_rotation == Direction.left:
shape = "img/image_left.png"
portrayal = {"Shape": shape, "scale": 1.0, "Layer": 0}
portrayal = {"Shape": shape, "scale": 1.0, "Layer": 2}
if isinstance(agent, PatchAgent):
color = colors[0]
@ -52,11 +48,11 @@ def agent_portrayal(agent):
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": 0}
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": 0}
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": 0}
portrayal = {"Shape": "img/door_d.jpg", "scale": 1.0, "Layer": 1}
elif agent.patch_type == PatchType.divider:
portrayal = \
@ -78,6 +74,18 @@ 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
@ -88,88 +96,32 @@ if __name__ == '__main__':
scale = base / gridWidth
diagram = GridWithWeights(gridWidth, gridHeight)
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.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), (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))]
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")
server = ModularServer(GameModel,
[grid, readyText, provided_itesm, recognised_items, ordersText,
fulfilled_orders],
[grid, readyText, current_item, current_order, fulfilled_orders, ordersText, provided_itesm,
recognised_items, cut_orders],
"Automatyczny Wózek Widłowy",
dict(width=gridHeight, height=gridWidth, graph=diagram, items=50, orders=20, classificator=model))
# def order_rule(order: Order):
# return order.id
#
#
# punish_low = 500
# punish_med = 300
# def sum_wrong(member: [Order]) -> int:
# last_high = 0
# last_med = 0
#
# sum_high = 0
# sum_med = 0
# sum_low = 0
#
# counter = 0
#
# for i in range(len(member)):
# o: Order = member[i]
# if o.priority == Priority.HIGH :
# sum_high += 1
# last_high = i
# elif o.priority == Priority.MEDIUM:
# sum_med += 1
# last_med = i
# else:
# sum_low += 1
#
# for i in range(last_high):
# o: Order = member[i]
# if o.priority == Priority.MEDIUM:
# counter += punish_med
# elif o.priority == Priority.LOW:
# counter += punish_low
#
# for i in range(last_med):
# o: Order = member[i]
# if o.priority == Priority.LOW:
# counter += punish_low
#
# print("sum: high:", sum_high, "med:", sum_med, "low:", sum_low)
# print("last_high:", last_high, "last_med:", last_med, "sum:", counter)
# return counter
#
# orders = InitialStateFactory.generate_order_list_XD(20)
# test: GeneticOrder = GeneticOrder(orders)
# punish_low = test.punish_low
# punish_med = test.punish_med
#
# print("SIEMA before: ")
# sum_wrong(orders)
# for i in orders:
# print("id:", i.id, "priority:", i.priority, "sum/time:", i.sum/i.time)
# # print("id:", i.id, "priority:", i.priority)
#
# newOrders = test.get_orders_sorted(orders)
#
# print("NAURA after:")
# sum_wrong(newOrders)
# for i in newOrders:
# print("id:", i.id, "priority:", i.priority, "sum/time:", i.sum/i.time)
# # print("id:", i.id, "priority:", i.priority)
dict(width=gridHeight, height=gridWidth, graph=diagram, items=60, orders=20,
classificator=model, item_display_pos=display_items))
server.port = 8888
server.launch()

View File

@ -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 + 20
cost = curr_state.cost + 45
# tutaj koszt kaluzy
else:
cost = curr_state.cost + 1

View File

@ -0,0 +1,46 @@
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

View File

@ -4,7 +4,6 @@ from typing import List
from mesa.visualization.modules import TextElement
from data.Order import Order
from data.enum.ItemType import ItemType
class DisplayOrderList(TextElement):
@ -21,7 +20,8 @@ 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>"