def greedy_path(self, points):
gr = solve_tsp(self.matrix)
init_path = gr.copy()
for el in points:
num = el.index
init_path[gr.index(num)] = el
return init_path
def make_traversal_plan(region_ids_yx, initial_id):
id_to_neighbours_map = make_region_neighbours_map(region_ids_yx)
max_id = 0
for row in region_ids_yx:
for _id in row:
if _id > max_id:
max_id = _id
# TODO: try using this library instead:
# https://github.com/jvkersch/pyconcorde
unreachable = 1000
distance_half_matrix = []
for a in range(1, max_id + 1):
row = []
for b in range(1, a):
if b in id_to_neighbours_map[a]:
row.append(1)
else:
row.append(unreachable)
distance_half_matrix.append(row)
last_row = [unreachable] * (max_id)
distance_half_matrix.append(last_row)
true_initial_id = initial_id - 1
path = tsp.solve_tsp(distance_half_matrix,
optim_steps=10,
endpoints=(initial_id - 1, max_id))
path.pop()
return list(map(lambda x: x + 1, path))
def tsp_solver(assigned_students):
route = []
for s in assigned_students:
points = s['points']
final = []
results = []
for p in points:
results.append(
[p["latitude"], p["longitude"], p['student_id']])
adjacency_matrix = optimizePickupSequence.generate_graph(results)
sequence = solve_tsp(adjacency_matrix)
tsp_dis = optimizePickupSequence.cal_totaldis(results, sequence)
# When there is only one student, not need to find route
if (len(sequence) == 1):
final.append({
'student_id': results[0][2],
'latitude': results[0][0],
'longitude': results[0][1]
})
else:
for k in sequence:
final.append({
'student_id': results[k][2],
'latitude': results[k][0],
'longitude': results[k][1]
})
route.append({
'mean': s['mean'],
'school': s['school'],
'location': s['location'],
'pickup_sequence': final
})
return route
def handle_startboats(arg=0):
global boat_speed
global boat_capacity
boat_speed = random.uniform(.2,1.0)
boat_capacity = random.uniform(10,150)
rospy.Rate(30)
human_boat_check_sub()
boat_location_sub()
human_boat_check_pub()
command = boat_auction__info_pub()
ugvnav()
time.sleep(2)
resp = call_auctioning_service_client()
metacluster_location_array = resp.metaclusters
auction_info = resp.auction_assignments
print "before if", auction_info, metacluster_location_array
if ((metacluster_location_array != []) and (auction_info != [])):
print "entered if"
assigned_clusters_locations = get_relevant_clusters(auction_info,metacluster_location_array)
print "got assigned clusters"
cost_mat = setup_tsp(assigned_clusters_locations)
print "got cost mat"
path = solve_tsp( cost_mat )
print "solved tsp"
travel_using_tsp(path,assigned_clusters_locations)
print "after travling"
return True
def makePath(points):
def to_key(p1, p2):
p1, p2 = sorted([p1, p2])
return (p1['local_idx'], p2['local_idx'])
all_paths = make_all_paths(points)
matrix = [[0] * len(points) for _ in range(len(points))]
for (idx1, idx2), (path, size) in all_paths.items():
matrix[idx1][idx2] = size
matrix[idx2][idx1] = size
indexes = solve_tsp(matrix)
points_dict = {p['local_idx']: p for p in points}
points_path = [points_dict[idx] for idx in indexes]
print(indexes)
full_path = []
for p1, p2 in zip(points_path[:-1], points_path[1:]):
path, _ = all_paths[to_key(p1, p2)]
path = path[:]
if path[0] != p1:
path = list(reversed(path))
full_path.extend(path)
indexes = [p['index'] for p in points_path]
return [(p['lat'], p['lon']) for p in full_path], indexes
def corrsort(features, use_tsp=False):
"""
Given a features array, one feature per axis=0 entry, return axis=0 indices
such that adjacent indices correspond to features that are correlated.
cf. Traveling Salesman Problem. Not an optimal solution.
use_tsp:
Use tsp solver. See tsp_solver.greedy module that is used for this.
Slows run-time considerably: O(N^4) computation, O(N^2) memory.
Without use_tsp, both computation and memory are O(N^2).
"""
correlations = np.ma.corrcoef(arrays.plane(features))
if use_tsp: return tsp.solve_tsp(-correlations)
size = features.shape[0]
correlations.mask[np.diag_indices(size)] = True
# initialize results with the pair with the highest correlations.
largest = np.argmax(correlations)
results = [int(largest / size), largest % size]
correlations.mask[:, results[0]] = True
while len(results) < size:
correlations.mask[:, results[-1]] = True
results.append(np.argmax(correlations[results[-1]]))
return results
def connect_dots_with_lines(dots):
#
lines = []
#
#
# build upper triangular distance matrix between dots
distance_matrix = [[0] * len(dots) for x in range(len(dots))]
for i in range(len(dots)):
for j in range(i + 1, len(dots)):
d = distance_between(dots[i], dots[j])
distance_matrix[i][j] = d
distance_matrix[j][i] = d
#
#
# ask for TSP solution
path = solve_tsp(distance_matrix)
#
#
# create lines
last_node = dots[path[0]]
for x in range(1, len(path)):
next_node = dots[path[x]]
lines.append((last_node, next_node))
last_node = next_node
#
return lines
def label_images(n_splits=4):
# Extract image features
print('extract_features')
if not os.path.exists(VGG16_FEATURES):
files = _img_json_files()
_extract_features(files)
print('load feature')
vgg16_features = np.load(VGG16_FEATURES)
print('Loaded VGG16 features: ', vgg16_features.shape)
print('sort images')
# Sort images by similarity
pdists = distance.pdist(vgg16_features)
D = distance.squareform(pdists)
path = solve_tsp(D)
# Debug
if False:
import matplotlib.pyplot as plt
files = _img_json_files()
for p in path:
img = cv2.imread(files[p])
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.show()
# Make n_splits labels
labels = np.zeros(vgg16_features.shape[0]).astype(int)
for idx, p in enumerate(path):
labels[p] = idx % n_splits
print(np.unique(labels))
return labels
def run(self, parameters):
self.send_feedback('Waiting for task to start')
yield self.wait_for_task_such_that(lambda task: task.state in ['ready', 'running'])
path_msg = yield self.get_latching_msg(self.wayfinding_path_sub)
poses = [ (yield self.geo_pose_to_enu_pose(geo_pose.pose)) for geo_pose in path_msg.poses]
position = self.pose[0]
#initialize distance matrix
poses = poses + [position]
array_size = len(poses)
start_pose_index = array_size - 1
dist_matrix = np.zeros( (array_size, array_size) )
#fill up distance matrix
for i in range(array_size):
for j in range(array_size):
dist_matrix[i][j] = np.linalg.norm(poses[i][0] - poses[j][0])
#solve tsp algorithm (ensure start point is where boat is located) & remove current position from pose list
path = solve_tsp(dist_matrix, endpoints=(start_pose_index,None))
poses = poses[:start_pose_index]
path = path[1:]
#self.send_feedback('Sorted poses' + str(poses))
yield self.wait_for_task_such_that(lambda task: task.state in ['running'])
#do movements
for index in path:
self.send_feedback('Going to {}'.format(poses[index]))
#Go to goal
yield self.send_trajectory_without_path(poses[index])
def optimal_solution(self):
if self.n > 9:
adj_matrix = nx.adjacency_matrix(self.graph)
best_path = solve_tsp(adj_matrix.todense().tolist())
if best_path[-1] == 0:
best_path.pop()
else:
best_path = best_path[best_path.index(0) + 1:] + best_path[:best_path.index(0)]
best_score = self.path_pay(best_path)
return best_score, best_path
optimal_path = None
optimal_cost = float('inf')
# brute force
path = np.arange(self.n)[1:]
for permutation in permutations(path):
cost = self.path_pay(permutation)
if cost < optimal_cost:
optimal_cost = cost
optimal_path = permutation
return (optimal_cost, optimal_path)
def tsp_solver(clusters): cost_mat = setup_tsp(clusters) path = solve_tsp( cost_mat ) path_array = [] for index in path: path_array.append(clusters[index-1]) #print(path_array) return path_array
def opt_tours(self, dt):
start = time.time()
tour = path = solve_tsp(self.adjacency)
cost = self.tour_length(tour)
if cost < self.lowest_cost:
print(cost)
self.lowest_cost = cost
self.shortest_tour = [self.targets[t] for t in tour]
def generate_routes(self):
# changing naN (that file input not have route) to a bigger number to not influence in better way
mat = self.df.fillna(10000).values
return solve_tsp(mat,
endpoints=(self.get_position_by_name(self.origin),
self.get_position_by_name(
self.destination)))
def traveling_salesman(colors, alg):
# build a full matrix of cie2000 distances
len_colors = len(colors)
matrix = [[0 for i in range(len_colors)] for j in range(len_colors)]
for x in range(len_colors):
(x_red, x_green, x_blue) = colors[x]
x_rgb = colors[x]
x_lab = rgb2lab((x_red, x_green, x_blue))
x_hsv = colorsys.rgb_to_hsv(x_red / 255.0, x_green / 255.0,
x_blue / 255.0)
x_hls = colorsys.rgb_to_hls(x_red / 255.0, x_green / 255.0,
x_blue / 255.0)
for y in range(len_colors):
if x == y:
matrix[x][y] = 0
matrix[y][x] = 0
continue
if matrix[x][y] or matrix[y][x]:
continue
(y_red, y_green, y_blue) = colors[y]
y_rgb = colors[y]
if alg == "cie2000":
y_lab = rgb2lab((y_red, y_green, y_blue))
distance = delta_e_cie2000(x_lab, y_lab)
elif alg == "HSV":
y_hsv = colorsys.rgb_to_hsv(y_red / 255.0, y_green / 255.0,
y_blue / 255.0)
distance = get_hsv_distance(x_hsv, y_hsv)
elif alg == "HLS":
y_hls = colorsys.rgb_to_hls(y_red / 255.0, y_green / 255.0,
y_blue / 255.0)
distance = get_hls_distance(x_hls, y_hls)
elif alg == "Lab":
y_lab = rgb2lab((y_red, y_green, y_blue))
distance = get_euclidean_lab_distance(x_lab, y_lab)
elif alg == "RGB":
distance = get_euclidean_distance_two_points(x_rgb, y_rgb)
else:
raise Exception("Implement {}".format(alg))
matrix[x][y] = distance
matrix[y][x] = distance
#path = solve_tsp(matrix, endpoints=(0, -1))
path = solve_tsp(matrix)
return [colors[x] for x in path]
def tsp_solver(x):
# reorder the trajectory according to the TSP solution
shape = x.shape
x = x.reshape(-1, 3)
d = distance_matrix(x, x)
t = solve_tsp(d)
x = x[t, :]
x = x.reshape(shape)
return x
def kmeans_tsp(x):
# reorder the trajectory according to the TSP solution
shape = x.shape
x = x.reshape(-1, 3)
x = balanced_kmeans(shape[0], torch.from_numpy(x).float()).numpy()
for i in range(shape[0]):
d = distance_matrix(x[i, :, :], x[i, :, :])
t = solve_tsp(d)
x[i, :, :] = x[i, t, :]
return x
def compute_tsp(self):
max_value = 30000
if (self.data != None):
if (len(self.features) > 0):
if (len(self.features) <= 2):
order = range(0, len(self.features))
else:
matData = 1 - cosine_similarity(np.transpose(self.data))
cities = solve_tsp(matData)
return {"cities": cities, "groupId": 0, "offset": 0}
def giveDistanceIndiv(self, pop):
N = len(pop)
D = np.zeros((N, N), np.float32)
for i, iIndiv in enumerate(pop):
for j, jIndiv in enumerate(pop):
D[i, j] = D[j, i] = np.count_nonzero(iIndiv - jIndiv)
print(D)
from tsp_solver.greedy import solve_tsp
path = solve_tsp(D)
for i in path[1::]:
print(D[i, path[i - 1]] / float(len(iIndiv)))
def day9_1(data):
#data = read_input(2015, "901")
graph, cities = processInputAndBuildGraph(data)
#print(cities)
#for ds in graph:
# print(ds)
path = solve_tsp(graph)
print(path)
result = path_cost(graph, path)
AssertExpectedResult(207, result, 1)
return result
def nextGeneration(currentGen, eliteSize, mutationRate, greedy=False):
popRanked = rankRoutes(currentGen)
selectionResults = selection(popRanked, eliteSize)
matingpool = matingPool(currentGen, selectionResults)
children = breedPopulation(matingpool, eliteSize)
nextGeneration = mutatePopulation(children, mutationRate)
if not greedy:
return nextGeneration
path = solve_tsp(temp)
nextGeneration.pop()
nextGeneration.append(path)
return nextGeneration
def main():
'''Run tsp calc on address file.'''
parser = argparse.ArgumentParser(description='TSP for addresses.')
parser.add_argument('address_file', help='File with one address per line')
parser.add_argument('api_key', help='Google Maps Distance Matrix API key')
args = parser.parse_args()
addresses = read_addresses(args.address_file)
distances_dict = get_distances(addresses, args.api_key)
distance_matrix = parse_distance_dict(distances_dict)
path = solve_tsp(distance_matrix)
print 'path:'
for idx in path:
print addresses[idx]
print
print 'cycle duration (sec):', calc_duration(path, distance_matrix)
def tsp_solver_master(sku_pick_seq, slots, graph, depot_node_id):
from tsp_solver.greedy import solve_tsp
from pickseq.py import sku_to_node_pick
from graph.py import nx_dijkstra_dm
global distance_matrix
node_pick_seq = sku_to_node_pick(sku_pick_seq, slots)
node_pick_seq = [depot_node_id] + node_pick_seq + [depot_node_id]
distance_matrix = nx_dijkstra_dm(graph, node_pick_seq)
route = solve_tsp(distance_matrix)
result = []
for stop in route:
stop_node_id = node_pick_seq[stop]
stop_slot_id = slot_pick_seq[stop]
stop_sku_id = sku_pick_seq[stop]
pick = {'SKU': stop_sku_id, 'Slot': stop_slot_id, 'Node': stop_node_id}
result.append(pick)
return result
def tsp_solver_master(sku_pick_seq,slots,graph,depot_node_id):
from tsp_solver.greedy import solve_tsp
from pickseq.py import sku_to_node_pick
from graph.py import nx_dijkstra_dm
global distance_matrix
node_pick_seq = sku_to_node_pick(sku_pick_seq,slots)
node_pick_seq = [depot_node_id] + node_pick_seq + [depot_node_id]
distance_matrix = nx_dijkstra_dm(graph,node_pick_seq)
route = solve_tsp(distance_matrix)
result = []
for stop in route:
stop_node_id = node_pick_seq[stop]
stop_slot_id = slot_pick_seq[stop]
stop_sku_id = sku_pick_seq[stop]
pick = {'SKU':stop_sku_id,'Slot':stop_slot_id,'Node':stop_node_id}
result.append(pick)
return result
def shortest_path(list_of_orders):
master_ans = []
print(list_of_orders)
a = [(i.destination, i.priority) for i in list_of_orders]
list_of_dest = [i[0] for i in a]
list_of_dest = list(set(list_of_dest))
print(list_of_dest)
dis_mat = [[]]
starting_pt = pick_shortest(Hospital.objects.get(id=1), list_of_dest)
for i in range(1, len(list_of_dest)):
dis_mat.append([dis_2_pt( list_of_dest[i] , list_of_dest[j]) for j in range(0, i)])
print(dis_mat)
master_ans += [list_of_dest[i] for i in solve_tsp(dis_mat)]
return master_ans
def callback(data):
# Read node distances from file
# File location is in Home
roomlist = [508, 507, 510]
pub = rospy.Publisher('solvedPath', String, queue_size=10)
csvPath = "~/Documents/catkin_ws/src/mailbot/"
d = pd.read_csv("/".join([csvPath, "/config/weights.csv"]), header=None)
d = d.values
rospy.loginfo("Received locations")
# get nodes to traverse
# node_list = np.asarray(data.data.split(), int)
node_list = np.asarray(data.data.split(), int)
nodes = rm.arrayToIndex(node_list)
# nodes = np.empty((node_list.shape))
#
# for i in range(len(node_list)):
# try:
# nodes[i] = np.argwhere(roomlist == node_list[i])
# except IndexError:
# print('Room ', node_list[i], ' not valid.')
# nodes[i] = -1
#print(nodes)
# create a smaller distance matrix to solve from nodes to traverse
row_idx = np.array(nodes)
col_idx = np.array(nodes)
dsub = d[row_idx[:, None], col_idx]
# solve the tsp for the nodes desired
relpath = solve_tsp(dsub)
# stating a start and finish point solves our tour issue
# relpath = solve_tsp(dsub, endpoints = (0,1)))
# convert the solution path back to index of full matrix
path = [0]*len(nodes)
for j in range(0, len(relpath)):
path[j] = nodes[relpath[j]]
print("path: ", path)
# print the path cost
# print(path_cost(d, path))
# print(path)
pub.publish(str(path))
def make_path1(points):
distances = []
for i in range(0, len(points)):
sub_distances = []
for j in range(0, len(points)):
distance = ((points[j].x - points[i].x)**2 +
(points[j].y - points[i].y)**2)**0.5
sub_distances.append(distance)
distances.append(sub_distances)
last_index = len(points) - 1
path_indexes = solve_tsp(distances, endpoints=(0, last_index))
path = []
for i in range(1, len(points)):
index = path_indexes[i - 1]
path.append(points[index])
return path
def solve(person_list, table_types):
# Create a distance matrix of persons
num_people = len(person_list)
a = zeros((num_people, num_people))
a[:] = 1.0
fill_diagonal(a, 0.0)
# Set distance to friends very small (0.0)
for person in person_list:
if person.friend is None: continue
a[person_list.index(person), person_list.index(person.friend)] = 0.0
a[person_list.index(person.friend), person_list.index(person)] = 0.0
# print a
# print spatial.distance.squareform(a)
# Solve the TSP for the distance matrix
path = solve_tsp(a)
# print path
# Create the ordered seating list
seating_list = []
for segment in path:
seating_list.append(person_list[segment])
# Create a table list
table_list = []
for key, value in table_types.items():
for i in range(0, value):
table_list.append(Table(i, num_seats=key))
# Assign people to tables
person_iter = iter(seating_list)
for table in table_list:
while len(table.occupant_list) < table.seats:
try:
table.occupant_list.append(next(person_iter))
except:
break
return table_list
def q9_2015_part1():
input = get_input('9', '2015').splitlines()
dist_matrix = []
line_index = -1
for row in range(8): ##build the distance matrix
dist_list = []
for index in range(row):
data = input[line_index].split()
dist_list.append(int(data[4]))
line_index -= 1
dist_matrix.append(dist_list)
## solve the best path
path = solve_tsp(dist_matrix)
## calculate total distance
total_dist = 0
for index in range(1, len(path)):
total_dist += dist_matrix[max(path[index - 1], path[index])][min(
path[index - 1], path[index])]
return total_dist
def tsp(graph):
matrix = []
line = []
for n in graph.nodes:
for m in graph.nodes:
if n == m:
line.append(0)
else:
line.append(graph.distances[(n, m)])
matrix.append(line)
line = []
path = solve_tsp(matrix)
# print(path)
# path.append(path[0])
# print(path)
# ToDo: count the distance in a proper way
distance = 1000
return distance, [str(p) for p in path]
def new_board(self, start_node):
"""
Returns a new game board for TSP
- A game board is a tuple containing a distance matrix (ndarray) representation of a graph
- A Path (list) for the current player
"""
graph = np.zeros(shape=(self.nodes, self.nodes), dtype=np.float32)
path = [start_node]
for src in range(self.nodes):
for dst in range(self.nodes):
# nodes cannot connect to themselves
if src != dst:
if graph[dst][src] != 0:
graph[src][dst] = graph[dst][src]
else:
graph[src][dst] = random.randint(0, 100)
# get optimal solution
self.solution = solve_tsp(graph)
# print('sol', self.solution)
self.optimal_path_length = self.get_path_length((graph, self.solution))
return graph, path
def permutateFramesWithinScenes(distances_dict):
'''
Finds permutation of frames within a scene
that minimizes the total optical flow distance
Solver used is greedy traveling salesman
or 2-opt heuristic
'''
solution = {}
for scene in distances_dict:
nbNodes = len(distances_dict[scene])
if cfg.USE_DUMMY_NODE:
scratch = range(nbNodes + 1)
distance_matrix = np.zeros((nbNodes + 1, nbNodes + 1))
distance_matrix[:nbNodes, :nbNodes] = distances_dict[scene]
else:
scratch = range(nbNodes)
distance_matrix = distances_dict[scene]
if cfg.TSP_SOLVER == 'greedy':
solution[scene] = solve_tsp(distance_matrix)
elif cfg.TSP_SOLVER == '2opt':
solution[scene] = two_opt_refine(distance_matrix, scratch)
if cfg.USE_DUMMY_NODE:
solution[scene].remove(nbNodes)
for scene in distances_dict:
print "TSP distances for scene", scene, ":",\
evaluate_distance(distances_dict[scene], solution[scene])
# Further refine:
if cfg.TSP_SOLVER == 'greedy' and cfg.REFINE_GREEDY_WITH_2OPT:
solution[scene] = two_opt_refine(distance_matrix, solution[scene])
for scene in distances_dict:
print "TSP distances for scene", scene, ":",\
evaluate_distance(distances_dict[scene], solution[scene])
return solution
def main():
path = []
nation_name = [
'Orvars', 'VG', 'GH', 'Hyttan', 'OG', 'Stocken', 'Wermlands', 'Glenns',
'Snerikes', 'Bettys', 'Svantes', 'Kronan', 'VDala'
]
def make_symetric_matrix(nation_name):
"""A function that makes a symetric matrix of the
distances between the nations"""
matrix = []
for i in range(len(nation_name)):
row = []
for j in range(len(nation_name)):
row.append(nations[nation_name[i]][nation_name[j]][0])
matrix.append(row)
return matrix
def readable_information(path_i):
"""Turns the information into something readable"""
path_distance = 0
path_time = 0
for i in path_i:
path.append(nation_name[i])
for i in range(len(path) - 1):
path_distance += nations[path[i]][path[i + 1]][0]
path_time += nations[path[i]][path[i + 1]][1]
# path_time += 30
print(path)
print(path_distance, " meters")
print(path_time, " minutes")
matrix = make_symetric_matrix(nation_name) # Get the matrix
path_i = solve_tsp(matrix) # Solves the ts-problem
readable_information(path_i) # Get the information
def main():
path = []
nation_name = ['Orvars', 'VG', 'GH', 'Hyttan', 'OG', 'Stocken',
'Wermlands', 'Glenns', 'Snerikes', 'Bettys',
'Svantes', 'Kronan', 'VDala']
def make_symetric_matrix(nation_name):
"""A function that makes a symetric matrix of the
distances between the nations"""
matrix = []
for i in range(len(nation_name)):
row = []
for j in range(len(nation_name)):
row.append(nations[nation_name[i]][nation_name[j]][0])
matrix.append(row)
return matrix
def readable_information(path_i):
"""Turns the information into something readable"""
path_distance = 0
path_time = 0
for i in path_i:
path.append(nation_name[i])
for i in range(len(path) - 1):
path_distance += nations[path[i]][path[i+1]][0]
path_time += nations[path[i]][path[i+1]][1]
# path_time += 30
print(path)
print(path_distance, " meters")
print(path_time, " minutes")
matrix = make_symetric_matrix(nation_name) # Get the matrix
path_i = solve_tsp(matrix) # Solves the ts-problem
readable_information(path_i) # Get the information
def main():
if len(sys.argv) > 1 and sys.argv[1] == "genres":
genres = True
else:
genres = False
## get subset of db based on input.txt
db, unfound_tracks = hlpr.processInput(genres = genres)
cols = ['tempo', 'mode', 'acousticness', 'danceability', 'energy',
'instrumentalness', 'liveness', 'speechiness', 'valence']
if genres:
cols = cols + GENRE_AGGREGATES
X = hlpr.dataFrameToMatrix(db, cols_to_keep = cols)
# X = X.fillna(0)
X = dam.minMaxScaleData(X)
# X2 = dam.transformPCA(X, 2)
# clusters2 = dam.classifyUnsupervised(X2, 3)
# clusters1 = dam.classifyUnsupervised(X, 3)
method = raw_input(
"Which method: Start and end? Enter 'both'.\nJust start song? Enter 'start'. >> "
)
if method == "both":
D = sc.pdist(X.copy())
D = sc.squareform(D)
db_dict = db.to_dict('index')
D_dict = dict(zip(db_dict, D))
G = {}
for k1 in db_dict:
G[k1] = dict(zip(db_dict, D_dict[k1]))
tspg.solve_tsp(D)
def find_all_paths(graph, start, end, path=[]):
path = path + [start]
if start == end:
return [path]
if not graph.has_key(start):
return []
paths = []
for node in graph[start]:
if node not in path:
newpaths = find_all_paths(graph, node, end, path)
for newpath in newpaths:
paths.append(newpath)
return paths
start_artist = raw_input('Enter artist name of song to start with: ')
start_title = raw_input('Enter title of song to start with: ')
end_artist = raw_input('Enter artist name of song to end with: ')
end_title = raw_input('Enter title of song to end with: ')
df = db
start = np.where((df.artist.str.lower() == start_artist.lower()) &
(df.title.str.lower() == start_title.lower()))[0][0]
end = np.where((df.artist.str.lower() == end_artist.lower()) &
(df.title.str.lower() == end_title.lower()))[0][0]
row = np.repeat(999, len(D))
col = np.append(row, 0)
col.shape = (len(col), 1)
col[start] = 0
col[end] = 0
row[start] = 0
row[end] = 0
DD = np.append(D, [row], 0)
DD = np.append(DD, col, 1)
tsp = tspg.solve_tsp(DD)
with open(os.path.join("../output", "walk.txt"), "w") as f:
mid = np.where(np.array(tsp) == (len(DD) - 1))[0][0]
if db.iloc[tsp[mid + 1], ].title.lower() == start_title:
walk = np.concatenate([tsp[(mid + 1):len(tsp)], tsp[0:mid]])
elif db.iloc[tsp[mid - 1], ].title.lower() == start_title:
walk = np.concatenate([tsp[0:(mid)][::-1], tsp[(mid + 1):len(tsp)][::-1]])
for w in walk:
if w == tsp[0]:
print "----------------------------------------"
print "{} - {}".format(db.iloc[w, ].artist,
db.iloc[w, ].title)
print("\n")
for w in walk:
print "spotify:track:{}".format(db.iloc[w, ].spotify_id)
f.write("spotify:track:%s\n" % w)
if method == "start":
strategy = raw_input("Join songs by 'link' or by 'center'? ")
artist = raw_input('Enter artist name: ')
song = raw_input('Enter song name: ')
## center means songs are sorted/ordered by proximity to centroid song
if strategy == "center":
expanse = dam.expandToPoints(X.copy(), db, artist, song)
ids = expanse.spotify_id.tolist()
sptfy.writeIDsToURI(ids, "../output", "walk.txt")
for i in ids:
print "{} - {}".format(
db.artist.values[db.spotify_id.values == i][0],
db.title.values[db.spotify_id.values == i][0]
)
print("\n")
for i in ids:
print "spotify:track:{}".format(i)
## link means songs are strung together finding the next closest song to
## the previously added node
elif strategy == "link":
walk = dam.walkPoints(X.copy(), db, artist, song)
hlpr.writeTextFile(walk, "../output", "walk.txt")
for w in walk:
print "{} - {}".format(
db.artist.values[
db.spotify_id.values == sptfy.stripSpotifyURI(w)
][0],
db.title.values[
db.spotify_id.values == sptfy.stripSpotifyURI(w)
][0]
)
print("\n")
for w in walk:
print w
# cluster_groups1 = hlpr.separateMatrixClusters(X2, clusters1)
# cluster_groups2 = hlpr.separateDataFrameClusters(db_subset, clusters2)
# cluster_groups3 = hlpr.separateDataFrameClusters(db_subset, clusters1)
# scatterplot(X, "fit_predict")
## open file in sublime text
# call(["subl", "output/walk.txt"])
if len(unfound_tracks) > 0:
print "\nThese songs weren't found..."
print "Please add them back to your playlist manually:"
for item in unfound_tracks:
print item.strip()
print "\n"
#!/usr/bin/env python
import argparse
from numpy import loadtxt, genfromtxt, corrcoef, sum, log, arange
from numpy.random import rand
from scipy.spatial.distance import cdist
from pylab import pcolor, show, colorbar, xticks, yticks, savefig
from tsp_solver.greedy import solve_tsp
parser = argparse.ArgumentParser(
description='Plot tsne output.')
parser.add_argument('-i', '--input', default='data')
args = parser.parse_args()
data = loadtxt('{0}/vectors'.format(args.input))
labels = []
with open('{}/words'.format(args.input)) as f:
for line in f:
labels.append(line.strip())
distanceMatrix = cdist(data, data, 'euclidean')
path = solve_tsp(distanceMatrix)
pcolor(data[path], cmap='binary')
savefig('{}/correlation.png'.format(args.input), figsize=(4,4), dpi=600)
for i in path:
print(labels[i])
def answer_tsp(seq):
'''Top level function for TSP'''
graph = create_graph(seq)
path = solve_tsp(graph)
return path_to_weight(path, graph)
from tsp_solver.greedy import solve_tsp
#Prepare the square symmetric distance matrix for 3 nodes:
# Distance from 0 to 1 is 1.0
# 1 to 2 is 3.0
# 0 to 2 is 2.0
D = [[ 0, 1.0, 2.0],
[ 1.0, 0, 3.0],
[ 2.0, 3.0, 0]]
path = solve_tsp( D )
# will print [1,0,2], path with total length of 3.0 units
print path
l[n].append(b)
m = {}
for key, value in cnt.iteritems():
# print key, value
m[key] = [[0 for x in range(value)] for x in range(value)]
hits = {}
for key, value in cnt.iteritems():
for i in range(0,value):
for j in range(0,value):
m[key][i][j] = math.hypot(l[key][i][0] - l[key][j][0], l[key][i][1] - l[key][j][1])
path = solve_tsp( m[key] )
# print path
hits[key] = []
for p in path:
# print l[key][p]
hits[key].append((t[key][0], l[key][p]))
print """
M48
FMAT,2
METRIC,TZ
"""
for i in t.keys():
station_2_index = {}
for index, station in enumerate(stations):
station_2_index[station] = index
# Build our matrix.
matrix = []
for _ in range(len(stations)):
matrix.append([longest_possiable_trip] * len(stations))
for ((start, end), time) in times.items():
start = station_2_index[start]
end = station_2_index[end]
matrix[start][end] = time
def pairs(i):
i = iter(i)
last_item = i.next()
for item in i:
yield last_item, item
last_item = item
path = solve_tsp(matrix, optim_steps=10000)
path = [stations[index] for index in path]
print >>sys.stderr, "Total time:", sum(times.get(pair, longest_possiable_trip) for pair in pairs(path))
print " ".join(map(str, path))
positions[tool_num].append(hit.position)
hits = []
# Optimize tool path for each tool
for tool, count in iter(hit_counts.items()):
# Calculate distance matrix
distance_matrix = [[math.hypot(*tuple(map(sub,
positions[tool][i],
positions[tool][j])))
for j in iter(range(count))]
for i in iter(range(count))]
# Calculate new path
path = solve_tsp(distance_matrix, 50)
# Create new hits list
hits += [DrillHit(f.tools[tool], positions[tool][p]) for p in path]
# Update the file
f.hits = hits
f.filename = f.filename + '.optimized'
f.write()
# Print drill report
print(f.report())
print('Original path length: %1.4f' % oldpath)
print('Optimized path length: %1.4f' % sum(f.path_length().values()))
cycleOffset1, cycleOffset2 = part1[1], part2[1]
overLapSize = getOverlapSize(frac1, frac2, cycleOffset1, cycleOffset2, lenOfCycle)
overlap = (np.array(frac1[-overLapSize:]) + np.array(frac2[:overLapSize]))/2
overlap = overlap.tolist()
newFrac = pe.toList(frac1[:-overLapSize]) + overlap + pe.toList(frac2[overLapSize:])
return (newFrac, cycleOffset1)
mat = []
for p1 in minedParts:
row=[]
for p2 in minedParts:
dis = getDistanceBetweenFracs(p1, p2, lenOfCycle)
row.append(dis)
mat.append(row)
print mat
path = solve_tsp( mat )
print path
#whole = qu.orderWithCost(minedParts, getDistanceBetweenFracs, appendFracs)
whole = minedParts[path[0]]
for i in path[1:]:
whole = appendFracs(whole, minedParts[path[i]], lenOfCycle)
whole = whole[0]
plt.figure()
whole = ma.movingAverage(whole, 10, 1.3)
plt.plot(whole)
#plt.plot()
#plt.show()
periods =[]
strides = []
stances = []
lookup[track] = x
track += 1
elements = [[100000 for y in range(track)] for x in range(track)]
# print elements
for x in range(track):
elements[x][x] = 0
for path in paths:
coord_1 = rename[path.node_1]
coord_2 = rename[path.node_2]
elements[coord_1][coord_2] = -int(path.distance)
elements[coord_2][coord_1] = -int(path.distance)
solution = solve_tsp(elements)
# print solution
print lookup
readable = []
for x in solution:
# print lookup[x]
readable.append(lookup[x])
# pass
print readable
tot_dist = 0
for i in range(len(readable)-1):
pass_one = []
pass_one += (get_all_containing(readable[i], paths))
pass_two = []
