def build_abstract_dict(Roads, k=0.005, m=0.1):
#getting the first k*N nodes to build the space for them
with open("centrality.csv", 'rt') as c:
N_tag = math.floor(len(Roads) * k)
it = itertools.islice(c, N_tag)
centers = [int(row[0]) for row in csv.reader(it)]
abstract_dict = {}
#for each node in the best K*N nodes for centerality file calculate UFS paths+cost to M*K*N closet nodes
for center in centers:
#potential neighbors which are M*k*N
potential_neighbors = [ele for ele in centers if ele != center]
#run ufs from center to potential_neighbors
(neighbors, num_developed_nodes) = normal_ucs(Roads.junctions(),
center,
potential_neighbors, m)
#sort the result by distance
sorted_nodes = sorted(neighbors, key=operator.itemgetter(1))
#get closet m*k*n nodes
neighbors = sorted_nodes[0:math.floor((len(potential_neighbors) + 1) *
m)]
abstract_links = []
#for each neighbor create the abstract linkes list to return in junction
for neighbor in neighbors:
abstract_links.append(
AbstractLink(neighbor[2], neighbor[0], neighbor[1], -1))
#store center's junction in the abs space dict
abstract_dict[center] = Junction(center, Roads[center].lat,
Roads[center].lon, abstract_links)
neighbors = []
sorted_nodes = []
abstract_links = []
potential_neighbors = []
#dump the dict to .pkl file for future use
with open("abstractSpace.pkl", 'wb') as p:
pickle.dump(abstract_dict, p)
def uc_time_exp(Roads, source, target):
(ucs_path, num_developed_nodes) = ucs.normal_ucs(Roads,
source, [target],
1,
cost_func=expected_time)
ucs_path = ucs_path[0]
return (num_developed_nodes, ucs_path[1])
def base(source, target):
'call function to find path using uniform cost, and return list of indices'
Roads = ways.graph.load_map_from_csv("tlv.csv")
(ucs_path, num_developed_nodes) = ucs.normal_ucs(Roads, source, [target],
1)
ucs_path = ucs_path[0]
return ucs_path[2]
def uc_time(source, target):
Roads = ways.graph.load_map_from_csv()
(ucs_path, num_developed_nodes) = ucs.normal_ucs(Roads,
source, [target],
1,
cost_func=expected_time)
ucs_path = ucs_path[0]
return ucs_path[2]
def betterWaze_exp(Roads, source, target, abstractMap=None):
'call function to find path using better ways algorithm, and return list of indices'
if not abstractMap:
raise NotImplementedError # You should load the map you were asked to pickle
# Note: pickle might give you an error for the namedtuples, even if they
# are imported indirectly from ways.graph. You might need to declare, for
# example: Link = ways.graph.Link
develped_a = 0
develped_b = 0
develped_c = 0
cost = 0
final_list = []
try:
# phase a
(ucs_paths, develped_a) = ucs.normal_ucs(Roads, source,
list(abstractMap.keys()),
float(1) / len(abstractMap))
if ucs_paths:
ucs_path = ucs_paths[0]
junc1_path = ucs_path[2]
junc1_index = ucs_path[0]
cost += ucs_path[1]
else:
raise Exception("Phase a failed")
# phase b
junc2_index = -1
junc2_min_distance = sys.maxsize
for center in list(abstractMap.keys()):
current_distance = tools.compute_distance(Roads[center].lat,
Roads[center].lon,
Roads[target].lat,
Roads[target].lon)
if current_distance < junc2_min_distance:
junc2_index = center
junc2_min_distance = current_distance
(ucs_paths, develped_b) = ucs.normal_ucs(Roads, junc2_index, [target],
1)
if ucs_paths:
ucs_path = ucs_paths[0]
junc2_path = ucs_path[2]
cost += ucs_path[1]
else:
raise Exception("Phase b failed")
# phase c
(ucs_paths, develped_c) = ucs.normal_ucs(abstractMap, junc1_index,
[junc2_index], 1,
lambda x: x.cost)
if ucs_paths:
ucs_path = ucs_paths[0]
abstract_index_list = ucs_path[2]
cost += ucs_path[1]
expanded_index_list = []
if junc1_index == junc2_index:
junc_1_2_path = [junc1_index]
else:
expanded_tuple_list = []
for i in range(1, len(abstract_index_list)):
# should return single value
abstact_link_list = [
lnk.path
for lnk in abstractMap[abstract_index_list[i -
1]].links
if lnk.target == abstract_index_list[i]
]
abstact_link_list = abstact_link_list[0]
expanded_tuple_list = expanded_tuple_list + abstact_link_list[
1:len(abstact_link_list)]
junc_1_2_path = expanded_tuple_list
else:
raise Exception("Phase c failed")
return (develped_a + develped_b + develped_c, cost)
except:
print("Exception")
(develped_base, cost) = base_exp(Roads, source, target)
return (develped_base + develped_a + develped_b + develped_c, cost)
def base_exp(Roads, source, target):
'call function to find path using uniform cost, and return list of indices'
(ucs_path, num_developed_nodes) = ucs.normal_ucs(Roads, source, [target],
1)
ucs_path = ucs_path[0]
return (num_developed_nodes, ucs_path[1])
def betterWaze(source, target, abstractMap=None):
'call function to find path using better ways algorithm, and return list of indices'
if not abstractMap:
raise NotImplementedError # You should load the map you were asked to pickle
# Note: pickle might give you an error for the namedtuples, even if they
# are imported indirectly from ways.graph. You might need to declare, for
# example: Link = ways.graph.Link
Roads = ways.graph.load_map_from_csv("tlv.csv")
final_list = []
try:
#phase a
#runs normal ucs from source all abstract space nodes
(ucs_paths, temp) = ucs.normal_ucs(Roads, source,
list(abstractMap.keys()),
float(1) / len(abstractMap))
#if there is such paths get the first one which is to the closet node = junc1
if ucs_paths:
ucs_path = ucs_paths[0]
#get the path
junc1_path = ucs_path[2]
#get the index of junc1
junc1_index = ucs_path[0]
# if this phace failed run normal ucs from A to B by throwing exception that is dealt after
else:
raise Exception("Phase a failed")
#phase b
#find the closet abstract space node to B by air distance
junc2_index = -1
junc2_min_distance = sys.maxsize
#iterate over all possible nodes
for center in list(abstractMap.keys()):
#compute the distance using provided func
current_distance = tools.compute_distance(Roads[center].lat,
Roads[center].lon,
Roads[target].lat,
Roads[target].lon)
#update if new node is closer to B
if current_distance < junc2_min_distance:
junc2_index = center
junc2_min_distance = current_distance
#run ucs from junc2 to B to get the path
(ucs_paths, temp) = ucs.normal_ucs(Roads, junc2_index, [target], 1)
if ucs_paths:
ucs_path = ucs_paths[0]
junc2_path = ucs_path[2]
#if this phace failed run normal ucs from A to B by throwing exception that is dealt after
else:
raise Exception("Phase b failed")
#phase c
#run ucs from junc1 to junc2 in normal search space
(ucs_paths, temp) = ucs.normal_ucs(abstractMap, junc1_index,
[junc2_index], 1, lambda x: x.cost)
if ucs_paths:
#path for j1 to j2
ucs_path = ucs_paths[0]
abstract_index_list = ucs_path[2]
expanded_index_list = []
if junc1_index == junc2_index:
junc_1_2_path = [junc1_index]
else:
expanded_tuple_list = []
for i in range(1, len(abstract_index_list)):
# should return single value
#get the the links list which ucs returned
abstact_link_list = [
lnk.path
for lnk in abstractMap[abstract_index_list[i -
1]].links
if lnk.target == abstract_index_list[i]
]
abstact_link_list = abstact_link_list[0]
#extracth the path from junc1 to junc2 from the link
expanded_tuple_list = expanded_tuple_list + abstact_link_list[
1:len(abstact_link_list)]
junc_1_2_path = expanded_tuple_list
# if this phace failed run normal ucs from A to B by throwing exception that is dealt after
else:
raise Exception("Phase c failed")
#append all three paths from phases a,b,c respectively
return junc1_path + junc_1_2_path + junc2_path[1:len(junc2_path)]
# exception is caught therefor we need to run norma ucs from A to B
except:
return base(source, target)