From c380d75454bf3fe860131ab101f6baffbf21c264 Mon Sep 17 00:00:00 2001
From: MLErik <baerenjesus@gmail.com>
Date: Thu, 3 Oct 2019 08:49:32 -0400
Subject: [PATCH] changed all node to city
---
flatland/envs/rail_generators.py | 121 ++++++++++++++-------------
flatland/envs/schedule_generators.py | 8 +-
2 files changed, 65 insertions(+), 64 deletions(-)
diff --git a/flatland/envs/rail_generators.py b/flatland/envs/rail_generators.py
index fa18298c..bbbb2c06 100644
--- a/flatland/envs/rail_generators.py
+++ b/flatland/envs/rail_generators.py
@@ -1,7 +1,7 @@
"""Rail generators (infrastructure manager, "Infrastrukturbetreiber")."""
import time
import warnings
-from typing import Callable, Tuple, Optional, Dict, List, Any
+from typing import Callable, Tuple, Optional, Dict, List
import msgpack
import numpy as np
@@ -560,7 +560,7 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
rails_between_cities = rails_in_city if max_rails_between_cities > rails_in_city else max_rails_between_cities
# Evenly distribute cities
- node_time_start = time.time()
+ city_time_start = time.time()
if grid_mode:
city_positions, city_cells = _generate_evenly_distr_city_positions(max_num_cities, city_radius, width, height)
else:
@@ -569,15 +569,15 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
# reduce num_cities if less were generated in random mode
num_cities = len(city_positions)
if DEBUG_PRINT_TIMING:
- print("City position time", time.time() - node_time_start, "Seconds")
+ print("City position time", time.time() - city_time_start, "Seconds")
# Set up connection points for all cities
- node_connection_time = time.time()
- inner_connection_points, outer_connection_points, connection_info, city_orientations = _generate_node_connection_points(
+ city_connection_time = time.time()
+ inner_connection_points, outer_connection_points, connection_info, city_orientations = _generate_city_connection_points(
city_positions, city_radius, rails_between_cities,
rails_in_city)
if DEBUG_PRINT_TIMING:
- print("Connection points", time.time() - node_connection_time)
+ print("Connection points", time.time() - city_connection_time)
# Connect the cities through the connection points
city_connection_time = time.time()
@@ -609,14 +609,14 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
# Generate start target pairs
schedule_time = time.time()
- agent_start_targets_nodes, num_agents = _generate_start_target_pairs(num_agents, num_cities, train_stations,
- city_orientations)
+ agent_start_targets_cities, num_agents = _generate_start_target_pairs(num_agents, num_cities, train_stations,
+ city_orientations)
if DEBUG_PRINT_TIMING:
print("Schedule time", time.time() - schedule_time)
return grid_map, {'agents_hints': {
'num_agents': num_agents,
- 'agent_start_targets_nodes': agent_start_targets_nodes,
+ 'agent_start_targets_cities': agent_start_targets_cities,
'train_stations': train_stations,
'city_orientations': city_orientations
}}
@@ -632,9 +632,9 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
row = city_radius + 1 + np.random.randint(height - 2 * (city_radius + 1))
col = city_radius + 1 + np.random.randint(width - 2 * (city_radius + 1))
too_close = False
- # Check distance to nodes
- for node_pos in city_positions:
- if _are_cities_overlapping((row, col), node_pos, 2 * (city_radius + 1) + 1):
+ # Check distance to cities
+ for city_pos in city_positions:
+ if _are_cities_overlapping((row, col), city_pos, 2 * (city_radius + 1) + 1):
too_close = True
if not too_close:
@@ -665,17 +665,18 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
city_cells.extend(_get_cells_in_city(city_positions[-1], city_radius))
return city_positions, city_cells
- def _generate_node_connection_points(city_positions: List[Tuple[int, int]], city_radius: int, rails_between_cities: int, rails_in_city: int = 2):
+ def _generate_city_connection_points(city_positions: List[Tuple[int, int]], city_radius: int,
+ rails_between_cities: int, rails_in_city: int = 2):
inner_connection_points = []
outer_connection_points = []
connection_info = []
city_orientations = []
- for node_position in city_positions:
+ for city_position in city_positions:
# Chose the directions where close cities are situated
neighb_dist = []
- for neighb_node in city_positions:
- neighb_dist.append(distance_on_rail(node_position, neighb_node, metric="Manhattan"))
+ for neighb_city in city_positions:
+ neighb_dist.append(distance_on_rail(city_position, neighb_city, metric="Manhattan"))
closest_neighb_idx = argsort(neighb_dist)
# Store the directions to these neighbours and orient city to face closest neighbour
@@ -684,7 +685,7 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
if grid_mode:
current_closest_direction = np.random.randint(4)
else:
- current_closest_direction = direction_to_point(node_position, city_positions[closest_neighb_idx[idx]])
+ current_closest_direction = direction_to_point(city_position, city_positions[closest_neighb_idx[idx]])
connection_sides_idx.append(current_closest_direction)
connection_sides_idx.append((current_closest_direction + 2) % 4)
city_orientations.append(current_closest_direction)
@@ -703,16 +704,16 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
for connection_idx in range(connections_per_direction[direction]):
if direction == 0:
tmp_coordinates = (
- node_position[0] - city_radius, node_position[1] + connection_slots[connection_idx])
+ city_position[0] - city_radius, city_position[1] + connection_slots[connection_idx])
if direction == 1:
tmp_coordinates = (
- node_position[0] + connection_slots[connection_idx], node_position[1] + city_radius)
+ city_position[0] + connection_slots[connection_idx], city_position[1] + city_radius)
if direction == 2:
tmp_coordinates = (
- node_position[0] + city_radius, node_position[1] + connection_slots[connection_idx])
+ city_position[0] + city_radius, city_position[1] + connection_slots[connection_idx])
if direction == 3:
tmp_coordinates = (
- node_position[0] + connection_slots[connection_idx], node_position[1] - city_radius)
+ city_position[0] + connection_slots[connection_idx], city_position[1] - city_radius)
connection_points_coordinates_inner[direction].append(tmp_coordinates)
if connection_idx in range(start_idx, start_idx + number_of_out_rails + 1):
connection_points_coordinates_outer[direction].append(tmp_coordinates)
@@ -762,7 +763,7 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
return all_paths
- def _build_inner_cities(node_positions, inner_connection_points, outer_connection_points, node_radius, rail_trans,
+ def _build_inner_cities(city_positions, inner_connection_points, outer_connection_points, city_radius, rail_trans,
grid_map):
"""
Builds inner city tracks. This current version connects all incoming connections to all outgoing connections
@@ -773,9 +774,9 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
:param grid_map:
:return: Returns the cells of the through path which cannot be occupied by trainstations
"""
- through_path_cells = [[] for i in range(len(node_positions))]
- free_tracks = [[] for i in range(len(node_positions))]
- for current_city in range(len(node_positions)):
+ through_path_cells = [[] for i in range(len(city_positions))]
+ free_tracks = [[] for i in range(len(city_positions))]
+ for current_city in range(len(city_positions)):
all_outer_connection_points = [item for sublist in outer_connection_points[current_city] for item in
sublist]
# This part only works if we have keep same number of connection points for both directions
@@ -805,63 +806,63 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
free_tracks[current_city].append(current_track)
return through_path_cells, free_tracks
- def _set_trainstation_positions(node_positions, node_radius, free_tracks, grid_map):
+ def _set_trainstation_positions(city_positions, city_radius, free_tracks, grid_map):
"""
:param city_positions:
:param num_trainstations:
:return:
"""
- nb_nodes = len(node_positions)
- train_stations = [[] for i in range(nb_nodes)]
+ nb_cities = len(city_positions)
+ train_stations = [[] for i in range(nb_cities)]
left = 0
right = 0
built_num_trainstations = 0
- for current_city in range(len(node_positions)):
+ for current_city in range(len(city_positions)):
for track_nbr in range(len(free_tracks[current_city])):
- possible_location = free_tracks[current_city][track_nbr][node_radius]
+ possible_location = free_tracks[current_city][track_nbr][city_radius]
train_stations[current_city].append((possible_location, track_nbr))
return train_stations, built_num_trainstations
- def _generate_start_target_pairs(num_agents, nb_nodes, train_stations, city_orientation):
+ def _generate_start_target_pairs(num_agents, nb_cities, train_stations, city_orientation):
"""
Fill the trainstation positions with targets and goals
:param num_agents:
- :param nb_nodes:
+ :param nb_cities:
:param train_stations:
:return:
"""
- # Generate start and target node directory for all agents.
- # Assure that start and target are not in the same node
- agent_start_targets_nodes = []
+ # Generate start and target city directory for all agents.
+ # Assure that start and target are not in the same city
+ agent_start_targets_cities = []
- # Slot availability in node
- node_available_start = []
- node_available_target = []
- for node_idx in range(nb_nodes):
- node_available_start.append(len(train_stations[node_idx]))
- node_available_target.append(len(train_stations[node_idx]))
+ # Slot availability in city
+ city_available_start = []
+ city_available_target = []
+ for city_idx in range(nb_cities):
+ city_available_start.append(len(train_stations[city_idx]))
+ city_available_target.append(len(train_stations[city_idx]))
# Assign agents to slots
for agent_idx in range(num_agents):
- avail_start_nodes = [idx for idx, val in enumerate(node_available_start) if val > 0]
- avail_target_nodes = [idx for idx, val in enumerate(node_available_target) if val > 0]
+ avail_start_cities = [idx for idx, val in enumerate(city_available_start) if val > 0]
+ avail_target_cities = [idx for idx, val in enumerate(city_available_target) if val > 0]
# Set probability to choose start and stop from trainstations
- sum_start = sum(np.array(node_available_start)[avail_start_nodes])
- sum_target = sum(np.array(node_available_target)[avail_target_nodes])
- p_avail_start = [float(i) / sum_start for i in np.array(node_available_start)[avail_start_nodes]]
+ sum_start = sum(np.array(city_available_start)[avail_start_cities])
+ sum_target = sum(np.array(city_available_target)[avail_target_cities])
+ p_avail_start = [float(i) / sum_start for i in np.array(city_available_start)[avail_start_cities]]
- start_target_tuple = np.random.choice(avail_start_nodes, p=p_avail_start, size=2, replace=False)
- start_node = start_target_tuple[0]
- target_node = start_target_tuple[1]
- agent_start_targets_nodes.append((start_node, target_node, city_orientation[start_node]))
- return agent_start_targets_nodes, num_agents
+ start_target_tuple = np.random.choice(avail_start_cities, p=p_avail_start, size=2, replace=False)
+ start_city = start_target_tuple[0]
+ target_city = start_target_tuple[1]
+ agent_start_targets_cities.append((start_city, target_city, city_orientation[start_city]))
+ return agent_start_targets_cities, num_agents
def _fix_transitions(city_cells, inter_city_lines, grid_map):
"""
Function to fix all transition elements in environment
"""
- # Fix all nodes with illegal transition maps
+ # Fix all cities with illegal transition maps
rails_to_fix = np.zeros(2 * grid_map.height * grid_map.width * 2, dtype='int')
rails_to_fix_cnt = 0
cells_to_fix = city_cells + inter_city_lines
@@ -878,22 +879,22 @@ def sparse_rail_generator(max_num_cities: int = 5, grid_mode: bool = False, max_
for cell in range(rails_to_fix_cnt):
grid_map.fix_transitions((rails_to_fix[2 * cell], rails_to_fix[2 * cell + 1]))
- def _closest_neighbour_in_direction(current_city_idx: int, node_positions: List[Tuple[int, int]]):
+ def _closest_neighbour_in_direction(current_city_idx: int, city_positions: List[Tuple[int, int]]):
"""
Returns indices of closest neighbours in every direction NESW
- :param current_city_idx: Index of node in city_positions list
+ :param current_city_idx: Index of city in city_positions list
:param city_positions: list of all points being considered
:return: list of index of closest neighbours in all directions
"""
- node_dist = []
+ city_dist = []
closest_neighb = [None for i in range(4)]
- for av_node in range(len(node_positions)):
- node_dist.append(
- distance_on_rail(node_positions[current_city_idx], node_positions[av_node], metric="Manhattan"))
- sorted_neighbours = np.argsort(node_dist)
+ for av_city in range(len(city_positions)):
+ city_dist.append(
+ distance_on_rail(city_positions[current_city_idx], city_positions[av_city], metric="Manhattan"))
+ sorted_neighbours = np.argsort(city_dist)
direction_set = 0
for neighb in sorted_neighbours[1:]:
- direction_to_neighb = direction_to_point(node_positions[current_city_idx], node_positions[neighb])
+ direction_to_neighb = direction_to_point(city_positions[current_city_idx], city_positions[neighb])
if closest_neighb[direction_to_neighb] == None:
closest_neighb[direction_to_neighb] = neighb
direction_set += 1
diff --git a/flatland/envs/schedule_generators.py b/flatland/envs/schedule_generators.py
index c7be5f57..bdd4b48b 100644
--- a/flatland/envs/schedule_generators.py
+++ b/flatland/envs/schedule_generators.py
@@ -61,7 +61,7 @@ def sparse_schedule_generator(speed_ratio_map: Mapping[float, float] = None) ->
def generator(rail: GridTransitionMap, num_agents: int, hints: Any = None):
train_stations = hints['train_stations']
- agent_start_targets_nodes = hints['agent_start_targets_nodes']
+ agent_start_targets_cities = hints['agent_start_targets_cities']
max_num_agents = hints['num_agents']
city_orientations = hints['city_orientations']
if num_agents > max_num_agents:
@@ -73,8 +73,8 @@ def sparse_schedule_generator(speed_ratio_map: Mapping[float, float] = None) ->
agents_direction = []
for agent_idx in range(num_agents):
# Set target for agent
- start_city = agent_start_targets_nodes[agent_idx][0]
- target_city = agent_start_targets_nodes[agent_idx][1]
+ start_city = agent_start_targets_cities[agent_idx][0]
+ target_city = agent_start_targets_cities[agent_idx][1]
start = random.choice(train_stations[start_city])
target = random.choice(train_stations[target_city])
while start[1] % 2 != 0:
@@ -82,7 +82,7 @@ def sparse_schedule_generator(speed_ratio_map: Mapping[float, float] = None) ->
while target[1] % 2 != 1:
target = random.choice(train_stations[target_city])
- agent_orientation = (agent_start_targets_nodes[agent_idx][2] + 2 * start[1]) % 4
+ agent_orientation = (agent_start_targets_cities[agent_idx][2] + 2 * start[1]) % 4
if not rail.check_path_exists(start[0], agent_orientation, target[0]):
agent_orientation = (agent_orientation + 2) % 4
if not (rail.check_path_exists(start[0], agent_orientation, target[0])):
--
GitLab