distance_label_t *graph_find_path(graph_t *g,char *time, void *from, void *to)
{
assert(graph_has_node(g, from) && graph_has_node(g, to));
list_t *visited = list_new();
list_t *distanceLabels = list_new();
iter_t *it;
for (it = iter(g->nodes); !iter_done(it); iter_next(it))
{
distance_label_t *dl = calloc(1, sizeof(distance_label_t));
dl->dist = -1;
dl->label = iter_get(it);
dl->path = NULL;
dl->path_edges = NULL;
dl->arrival_time = time;
list_add(distanceLabels, dl);
}
iter_free(it);
get_distance_label(distanceLabels, from, g->comp)->path = list_new();
get_distance_label(distanceLabels, from, g->comp)->path_edges = list_new();
dijkstra(g, from, to, visited, distanceLabels);
distance_label_t *best = get_distance_label(distanceLabels, to, g->comp);
assert(best);
free_distancelabels(g->comp,distanceLabels,best);
list_free(visited);
graph_print_trip(g,time,from,best);
return best;
}
void *get_min_distance_node(list_t *distanceLabels, comparator_t comp,
list_t *visited)
{
assert(distanceLabels);
int minDist = -1;
void *minLabel = NULL;
iter_t *it;
for (it = iter(distanceLabels); !iter_done(it); iter_next(it))
{
distance_label_t *itdl = iter_get(it);
if (itdl->dist == -1) // inte varit där
{
continue;
}
if (list_has(visited, comp, itdl->label)) // finns redan i visited, abort
{
continue;
}
if (minDist == -1 || itdl->dist < minDist)// om inte ändrats en enda gång eller nya distansen 'r mindre än förra minsta distans.
{
minDist = itdl->dist;
minLabel = itdl->label;
}
}
iter_free(it);
return minLabel;
}
void graph_foreach_edge(graph_t *g, void_fun3_t f)
{
iter_t *it;
for (it = iter(g->edges); !iter_done(it); iter_next(it))
{
edge_t *e = iter_get(it);
f(e->from, e->to, e->label);
}
iter_free(it);
}
void dijkstra(graph_t *g, void *current, void *to, list_t *visited,
list_t *distanceLabels)
{
assert(g);
assert(current);
assert(to);
assert(visited);
assert(distanceLabels);
while (true)
{
if (!list_has(visited, g->comp, current))
{
list_t *unvisited_neighs = unvisited_neighbors(g, current, visited);
distance_label_t *here =
get_distance_label(distanceLabels, current, g->comp);
iter_t *it;
for (it = iter(unvisited_neighs); !iter_done(it); iter_next(it))
{
void *neigh = iter_get(it);
int line = list_quickest_line(g->nodes, current, neigh, here->arrival_time);
// printf("med linje:%i i dijkstra\n",line);
assert(line);
edge_t *edge = graph_get_edge(g,line,current,here->path_edges);
assert(edge);
list_t *tentativePath = list_clone(here->path);
list_t *tentativeEdgePath = list_clone(here->path_edges);
list_add(tentativePath, neigh);
list_add(tentativeEdgePath, edge);
char *bussDepart = list_next_dep_time(g->nodes,current,neigh,line,here->arrival_time);
assert(bussDepart);
int total_distance = graph_add_penalty(edge, here->arrival_time, bussDepart);// egen rad
char *new_arrival_time = add_duration(bussDepart, network_get_dur(edge->label)); //egen rad
//free(bussDepart);
update_distance(distanceLabels, neigh, g->comp, here->dist + total_distance,
tentativePath, tentativeEdgePath, new_arrival_time); //la till new_arrival_tim. ost-bågen borde gå in här!!
}
iter_free(it);
list_free(unvisited_neighs);
}
list_add(visited, current);
if (g->comp(current, to))
{
return;
}
current = get_min_distance_node(distanceLabels, g->comp, visited);
assert(current);
}
}
void graph_print_trip (graph_t *g, char *time,char *from, distance_label_t *dl)
{
printf("\nTrip start:%s\n",time);
char *tmp_t = time;
iter_t *it;
char*tmp_fr;
char*tmp_to;
/*iter_t *it2;
for (it2 = iter(dl->path_edges); !iter_done(it2); iter_next(it2))
{
void *tmp_v = iter_get(it2);
edge_t *tmp_e = tmp_v;
puts(tmp_e->from);
puts(tmp_e->to);
}
iter_free(it2);
*/
for (it = iter(dl->path_edges); !iter_done(it); iter_next(it))
{
void *tmp_v = iter_get(it);
edge_t *tmp_e = tmp_v;
int line = network_get_line(tmp_e->label);
// printf("\n\n\n%s\n",tmp_e->to);
if(!tmp_fr) tmp_fr = from;
// printf("linje:%i !%s!",line,tmp_fr);
if(g->comp(tmp_fr,tmp_e->from))tmp_to = tmp_e->to;
else{tmp_to = tmp_e->from;}
//printf(" - !%s! - tid:%s\n",tmp_to,tmp_t);
char *buss_dep = list_next_dep_time(g->nodes,tmp_fr,tmp_to,line,tmp_t);
char *arr_time = add_duration(buss_dep, network_get_dur(tmp_e->label));
int durr = network_get_dur(tmp_e->label);
printf("@ %s: #%i %s --(%i)--> %s\n",buss_dep ,line ,tmp_fr ,durr ,tmp_to );
tmp_fr = tmp_to;
tmp_t = arr_time;
assert(tmp_fr);
assert(tmp_t);
}
puts("_____________________________________________________________");
printf("this trip took from:%s to:%s and %i minutes to complete.\n",time,dl->arrival_time,dl->dist+1);
iter_free(it);
}
bool graph_is_edge_visited(list_t *visited_edges, comparator_t comp, edge_t *edge)
{
iter_t *it;
for (it = iter(visited_edges); !iter_done(it); iter_next(it))
{
edge_t *temp_edge = iter_get(it);
if (comp(temp_edge, edge))
{
iter_free(it);
return true;
}
}
iter_free(it);
return false;
}
bool graph_has_edge(graph_t *g, void *from, void *to, void **label)
{
iter_t *it;
for (it = iter(g->edges); !iter_done(it); iter_next(it))
{
edge_t *e = iter_get(it);
if ((g->comp(from, e->from) && g->comp(to, e->to)) || (g->comp(from, e->to) && g->comp(to, e->from)))
{
*label = e->label;
iter_free(it);
return true;
}
}
*label = NULL;
iter_free(it);
return false;
}
list_t *unvisited_neighbors(graph_t *g, void *current, list_t *visited)
{
list_t *neighs = graph_find_neighbors(g, current);
list_t *unvisited_neighs = list_new();
iter_t *nit;
for (nit = iter(neighs); !iter_done(nit); iter_next(nit))
{
void *neigh = iter_get(nit);
if (!list_has(visited, g->comp, neigh))
{
list_add(unvisited_neighs, neigh);
}
}
iter_free(nit);
list_free(neighs);
return unvisited_neighs;
}
list_t *graph_find_neighbors(graph_t *g, void *node)
{
list_t *ret = list_new();
iter_t *eit;
for (eit = iter(g->edges); !iter_done(eit); iter_next(eit))
{
edge_t *e = iter_get(eit);
if (g->comp(e->from, node))
{
list_add(ret, e->to);
}
else if (g->comp(e->to, node))
{
list_add(ret, e->from);
}
}
iter_free(eit);
return ret;
}
distance_label_t *get_distance_label(list_t *distanceLabels, void *lbl,
comparator_t comp)
{
assert(distanceLabels);
assert(lbl);
assert(comp);
iter_t *dliter;
for (dliter = iter(distanceLabels); !iter_done(dliter); iter_next(dliter))
{
distance_label_t *dl = iter_get(dliter);
if (comp(dl->label, lbl))
{
//printf("Did find distance label for %s: path is: %p\n", lbl, dl->path);
iter_free(dliter);
return dl;
}
}
// printf("did not find distance label for %s\n", lbl);
iter_free(dliter);
return NULL;
}
void testITERATION()
{
list_t *l = list_new();
for (int i = 0; i < 3; ++i)
{
int *x = malloc(sizeof(int));
*x = i;
list_add(l, x);
}
int count = 0;
iter_t *it;
for (it = iter(l); !iter_done(it); iter_next(it))
{
count++;
}
iter_free(it);
CU_ASSERT_EQUAL(count, list_len(l));
list_foreach(l, free);
list_free(l);
}
void *graph_get_edge(graph_t *g,int line, void *node_el, list_t *visited_edges)// Egen Funktion
{
iter_t *it;
for (it = iter(g->edges); !iter_done(it); iter_next(it))
{
edge_t *e = iter_get(it);
if(
( (g->comp(node_el,e->from) || g->comp(node_el,e->to) )
&&
(!graph_is_edge_visited(visited_edges, g->comp, e))
&&
(network_comp_line(e->label,line))
))
{
void *temp_edge = e;
iter_free(it);
assert(temp_edge);
return temp_edge;
}
}
iter_free(it);
return NULL;
}
