Results *CombineRoutes(Results *results,Nodes *nodes,Segments *segments,Ways *ways,Profile *profile) { Result *result1,*result2,*result3,*result4; Results *combined; combined=NewResultsList(64); combined->start=results->start; combined->finish=results->finish; /* Sort out the combined route */ result1=FindResult(results,results->start); result3=InsertResult(combined,results->start); ZeroResult(result3); do { if(result1->next!=NO_NODE) { Results *results2=FindNormalRoute(nodes,segments,ways,result1->node,result1->next,profile); result2=FindResult(results2,result1->node); result3->next=result2->next; result2=FindResult(results2,result2->next); do { result4=InsertResult(combined,result2->node); *result4=*result2; result4->score+=result3->score; if(result2->next!=NO_NODE) result2=FindResult(results2,result2->next); else result2=NULL; } while(result2); FreeResultsList(results2); result1=FindResult(results,result1->next); result3=result4; } else result1=NULL; } while(result1); return(combined); }
static index_t FindSuperSegment(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,Profile *profile,index_t endnode,index_t endsegment) { Segment *segment; if(IsFakeSegment(endsegment)) endsegment=IndexRealSegment(endsegment); segment=LookupSegment(segments,endsegment,2); if(IsSuperSegment(segment)) return(endsegment); /* Loop across all segments */ segment=FirstSegment(segments,nodes,endnode,3); /* endnode cannot be a fake node (must be a super-node) */ while(segment) { if(IsSuperSegment(segment)) { Results *results; index_t startnode; startnode=OtherNode(segment,endnode); results=FindNormalRoute(nodes,segments,ways,relations,profile,startnode,NO_SEGMENT,endnode); if(results && results->last_segment==endsegment) { FreeResultsList(results); return(IndexSegment(segments,segment)); } if(results) FreeResultsList(results); } segment=NextSegment(segments,segment,endnode); /* endnode cannot be a fake node (must be a super-node) */ } return(endsegment); }
int main(int argc,char** argv) { Nodes *OSMNodes; Segments *OSMSegments; Ways *OSMWays; Relations *OSMRelations; Results *results[NWAYPOINTS+1]={NULL}; int point_used[NWAYPOINTS+1]={0}; double point_lon[NWAYPOINTS+1],point_lat[NWAYPOINTS+1]; index_t point_node[NWAYPOINTS+1]={NO_NODE}; double heading=-999; int help_profile=0,help_profile_xml=0,help_profile_json=0,help_profile_pl=0; char *dirname=NULL,*prefix=NULL; char *profiles=NULL,*profilename=NULL; char *translations=NULL,*language=NULL; int exactnodes=0,reverse=0,loop=0; Transport transport=Transport_None; Profile *profile=NULL; Translation *translation=NULL; index_t start_node,finish_node=NO_NODE; index_t join_segment=NO_SEGMENT; int arg,nresults=0; waypoint_t start_waypoint,finish_waypoint=NO_WAYPOINT; waypoint_t first_waypoint=NWAYPOINTS,last_waypoint=1,waypoint; int inc_dec_waypoint=1; printf_program_start(); /* Parse the command line arguments */ if(argc<2) print_usage(0,NULL,NULL); /* Get the non-routing, general program options */ for(arg=1;arg<argc;arg++) { if(!strcmp(argv[arg],"--version")) print_usage(-1,NULL,NULL); else if(!strcmp(argv[arg],"--help")) print_usage(1,NULL,NULL); else if(!strcmp(argv[arg],"--help-profile")) help_profile=1; else if(!strcmp(argv[arg],"--help-profile-xml")) help_profile_xml=1; else if(!strcmp(argv[arg],"--help-profile-json")) help_profile_json=1; else if(!strcmp(argv[arg],"--help-profile-perl")) help_profile_pl=1; else if(!strncmp(argv[arg],"--dir=",6)) dirname=&argv[arg][6]; else if(!strncmp(argv[arg],"--prefix=",9)) prefix=&argv[arg][9]; else if(!strncmp(argv[arg],"--profiles=",11)) profiles=&argv[arg][11]; else if(!strncmp(argv[arg],"--translations=",15)) translations=&argv[arg][15]; else if(!strcmp(argv[arg],"--exact-nodes-only")) exactnodes=1; else if(!strncmp(argv[arg],"--reverse",9)) { if(argv[arg][9]=='=') reverse=atoi(&argv[arg][10]); else reverse=1; } else if(!strncmp(argv[arg],"--loop",6)) { if(argv[arg][6]=='=') loop=atoi(&argv[arg][7]); else loop=1; } else if(!strcmp(argv[arg],"--quiet")) option_quiet=1; else if(!strcmp(argv[arg],"--loggable")) option_loggable=1; else if(!strcmp(argv[arg],"--logtime")) option_logtime=2; else if(!strcmp(argv[arg],"--logmemory")) option_logmemory=1; else if(!strcmp(argv[arg],"--output-html")) option_file_html=1; else if(!strcmp(argv[arg],"--output-gpx-track")) option_file_gpx_track=1; else if(!strcmp(argv[arg],"--output-gpx-route")) option_file_gpx_route=1; else if(!strcmp(argv[arg],"--output-text")) option_file_text=1; else if(!strcmp(argv[arg],"--output-text-all")) option_file_text_all=1; else if(!strcmp(argv[arg],"--output-none")) option_file_none=1; else if(!strcmp(argv[arg],"--output-stdout")) { option_file_stdout=1; option_quiet=1; } else if(!strncmp(argv[arg],"--profile=",10)) profilename=&argv[arg][10]; else if(!strncmp(argv[arg],"--language=",11)) language=&argv[arg][11]; else if(!strcmp(argv[arg],"--shortest")) option_quickest=0; else if(!strcmp(argv[arg],"--quickest")) option_quickest=1; else if(!strncmp(argv[arg],"--lon",5) && isdigit(argv[arg][5])) { int point; char *p=&argv[arg][6]; while(isdigit(*p)) p++; if(*p++!='=') print_usage(0,argv[arg],NULL); point=atoi(&argv[arg][5]); if(point>NWAYPOINTS || point_used[point]&1) print_usage(0,argv[arg],NULL); point_lon[point]=degrees_to_radians(atof(p)); point_used[point]+=1; if(point<first_waypoint) first_waypoint=point; if(point>last_waypoint) last_waypoint=point; } else if(!strncmp(argv[arg],"--lat",5) && isdigit(argv[arg][5])) { int point; char *p=&argv[arg][6]; while(isdigit(*p)) p++; if(*p++!='=') print_usage(0,argv[arg],NULL); point=atoi(&argv[arg][5]); if(point>NWAYPOINTS || point_used[point]&2) print_usage(0,argv[arg],NULL); point_lat[point]=degrees_to_radians(atof(p)); point_used[point]+=2; if(point<first_waypoint) first_waypoint=point; if(point>last_waypoint) last_waypoint=point; } else if(!strncmp(argv[arg],"--heading=",10)) { double h=atof(&argv[arg][10]); if(h>=-360 && h<=360) { heading=h; if(heading<0) heading+=360; } } else if(!strncmp(argv[arg],"--transport=",12)) { transport=TransportType(&argv[arg][12]); if(transport==Transport_None) print_usage(0,argv[arg],NULL); } else continue; argv[arg]=NULL; } /* Check the specified command line options */ if(option_file_stdout && (option_file_html+option_file_gpx_track+option_file_gpx_route+option_file_text+option_file_text_all)!=1) { fprintf(stderr,"Error: The '--output-stdout' option requires exactly one other output option (but not '--output-none').\n"); exit(EXIT_FAILURE); } if(option_file_html==0 && option_file_gpx_track==0 && option_file_gpx_route==0 && option_file_text==0 && option_file_text_all==0 && option_file_none==0) option_file_html=option_file_gpx_track=option_file_gpx_route=option_file_text=option_file_text_all=1; /* Load in the selected profiles */ if(transport==Transport_None) transport=Transport_Motorcar; if(profiles) { if(!ExistsFile(profiles)) { fprintf(stderr,"Error: The '--profiles' option specifies a file '%s' that does not exist.\n",profiles); exit(EXIT_FAILURE); } } else { profiles=FileName(dirname,prefix,"profiles.xml"); if(!ExistsFile(profiles)) { char *defaultprofiles=FileName(ROUTINO_DATADIR,NULL,"profiles.xml"); if(!ExistsFile(defaultprofiles)) { fprintf(stderr,"Error: The '--profiles' option was not used and the files '%s' and '%s' do not exist.\n",profiles,defaultprofiles); exit(EXIT_FAILURE); } free(profiles); profiles=defaultprofiles; } } if(!profilename) profilename=(char*)TransportName(transport); if(ParseXMLProfiles(profiles,profilename,(help_profile_xml|help_profile_json|help_profile_pl))) { fprintf(stderr,"Error: Cannot read the profiles in the file '%s'.\n",profiles); exit(EXIT_FAILURE); } profile=GetProfile(profilename); if(!profile) { fprintf(stderr,"Error: Cannot find a profile called '%s' in the file '%s'.\n",profilename,profiles); profile=(Profile*)calloc(1,sizeof(Profile)); profile->transport=transport; } /* Parse the other command line arguments that modify the profile */ for(arg=1;arg<argc;arg++) { if(!argv[arg]) continue; else if(!strncmp(argv[arg],"--highway-",10)) { Highway highway; char *equal=strchr(argv[arg],'='); char *string; double p; if(!equal) print_usage(0,argv[arg],NULL); string=strcpy((char*)malloc(strlen(argv[arg])),argv[arg]+10); string[equal-argv[arg]-10]=0; highway=HighwayType(string); if(highway==Highway_None) print_usage(0,argv[arg],NULL); p=atof(equal+1); if(p<0 || p>100) print_usage(0,argv[arg],NULL); profile->highway[highway]=(score_t)(p/100); free(string); } else if(!strncmp(argv[arg],"--speed-",8)) { Highway highway; char *equal=strchr(argv[arg],'='); char *string; double s; if(!equal) print_usage(0,argv[arg],NULL); string=strcpy((char*)malloc(strlen(argv[arg])),argv[arg]+8); string[equal-argv[arg]-8]=0; highway=HighwayType(string); if(highway==Highway_None) print_usage(0,argv[arg],NULL); s=atof(equal+1); if(s<0) print_usage(0,argv[arg],NULL); profile->speed[highway]=kph_to_speed(s); free(string); } else if(!strncmp(argv[arg],"--property-",11)) { Property property; char *equal=strchr(argv[arg],'='); char *string; double p; if(!equal) print_usage(0,argv[arg],NULL); string=strcpy((char*)malloc(strlen(argv[arg])),argv[arg]+11); string[equal-argv[arg]-11]=0; property=PropertyType(string); if(property==Property_None) print_usage(0,argv[arg],NULL); p=atof(equal+1); if(p<0 || p>100) print_usage(0,argv[arg],NULL); profile->props[property]=(score_t)(p/100); free(string); } else if(!strncmp(argv[arg],"--oneway=",9)) profile->oneway=!!atoi(&argv[arg][9]); else if(!strncmp(argv[arg],"--turns=",8)) profile->turns=!!atoi(&argv[arg][8]); else if(!strncmp(argv[arg],"--weight=",9)) profile->weight=tonnes_to_weight(atof(&argv[arg][9])); else if(!strncmp(argv[arg],"--height=",9)) profile->height=metres_to_height(atof(&argv[arg][9])); else if(!strncmp(argv[arg],"--width=",8)) profile->width=metres_to_width(atof(&argv[arg][8])); else if(!strncmp(argv[arg],"--length=",9)) profile->length=metres_to_length(atof(&argv[arg][9])); else print_usage(0,argv[arg],NULL); } /* Print one of the profiles if requested */ if(help_profile) { PrintProfile(profile); exit(EXIT_SUCCESS); } else if(help_profile_xml) { PrintProfilesXML(); exit(EXIT_SUCCESS); } else if(help_profile_json) { PrintProfilesJSON(); exit(EXIT_SUCCESS); } else if(help_profile_pl) { PrintProfilesPerl(); exit(EXIT_SUCCESS); } /* Load in the selected translation */ if(option_file_html || option_file_gpx_route || option_file_gpx_track || option_file_text || option_file_text_all) { if(translations) { if(!ExistsFile(translations)) { fprintf(stderr,"Error: The '--translations' option specifies a file '%s' that does not exist.\n",translations); exit(EXIT_FAILURE); } } else { translations=FileName(dirname,prefix,"translations.xml"); if(!ExistsFile(translations)) { char *defaulttranslations=FileName(ROUTINO_DATADIR,NULL,"translations.xml"); if(!ExistsFile(defaulttranslations)) { fprintf(stderr,"Error: The '--translations' option was not used and the files '%s' and '%s' do not exist.\n",translations,defaulttranslations); exit(EXIT_FAILURE); } free(translations); translations=defaulttranslations; } } if(ParseXMLTranslations(translations,language,0)) { fprintf(stderr,"Error: Cannot read the translations in the file '%s'.\n",translations); exit(EXIT_FAILURE); } if(language) { translation=GetTranslation(language); if(!translation) { fprintf(stderr,"Warning: Cannot find a translation called '%s' in the file '%s'.\n",language,translations); exit(EXIT_FAILURE); } } else { translation=GetTranslation(""); if(!translation) { fprintf(stderr,"Warning: No translations in '%s'.\n",translations); exit(EXIT_FAILURE); } } } /* Check the waypoints are valid */ for(waypoint=1;waypoint<=NWAYPOINTS;waypoint++) if(point_used[waypoint]==1 || point_used[waypoint]==2) print_usage(0,NULL,"All waypoints must have latitude and longitude."); if(first_waypoint>=last_waypoint) print_usage(0,NULL,"At least two waypoints must be specified."); /* Load in the data - Note: No error checking because Load*List() will call exit() in case of an error. */ if(!option_quiet) printf_first("Loading Files:"); OSMNodes=LoadNodeList(FileName(dirname,prefix,"nodes.mem")); OSMSegments=LoadSegmentList(FileName(dirname,prefix,"segments.mem")); OSMWays=LoadWayList(FileName(dirname,prefix,"ways.mem")); OSMRelations=LoadRelationList(FileName(dirname,prefix,"relations.mem")); if(!option_quiet) printf_last("Loaded Files: nodes, segments, ways & relations"); /* Check the profile is valid for use with this database */ if(UpdateProfile(profile,OSMWays)) { fprintf(stderr,"Error: Profile is invalid or not compatible with database.\n"); exit(EXIT_FAILURE); } /* Find all waypoints */ for(waypoint=first_waypoint;waypoint<=last_waypoint;waypoint++) { distance_t distmax=km_to_distance(MAXSEARCH); distance_t distmin; index_t segment=NO_SEGMENT; index_t node1,node2,node=NO_NODE; if(point_used[waypoint]!=3) continue; /* Find the closest point */ if(!option_quiet) printf_first("Finding Closest Point: Waypoint %d",waypoint); if(exactnodes) node=FindClosestNode(OSMNodes,OSMSegments,OSMWays,point_lat[waypoint],point_lon[waypoint],distmax,profile,&distmin); else { distance_t dist1,dist2; segment=FindClosestSegment(OSMNodes,OSMSegments,OSMWays,point_lat[waypoint],point_lon[waypoint],distmax,profile,&distmin,&node1,&node2,&dist1,&dist2); if(segment!=NO_SEGMENT) node=CreateFakes(OSMNodes,OSMSegments,waypoint,LookupSegment(OSMSegments,segment,1),node1,node2,dist1,dist2); } if(!option_quiet) printf_last("Found Closest Point: Waypoint %d",waypoint); if(node==NO_NODE) { fprintf(stderr,"Error: Cannot find node close to specified point %d.\n",waypoint); exit(EXIT_FAILURE); } if(!option_quiet) { double lat,lon; if(IsFakeNode(node)) GetFakeLatLong(node,&lat,&lon); else GetLatLong(OSMNodes,node,NULL,&lat,&lon); if(IsFakeNode(node)) printf("Waypoint %d is segment %"Pindex_t" (node %"Pindex_t" -> %"Pindex_t"): %3.6f %4.6f = %2.3f km\n",waypoint,segment,node1,node2, radians_to_degrees(lon),radians_to_degrees(lat),distance_to_km(distmin)); else printf("Waypoint %d is node %"Pindex_t": %3.6f %4.6f = %2.3f km\n",waypoint,node, radians_to_degrees(lon),radians_to_degrees(lat),distance_to_km(distmin)); } point_node[waypoint]=node; } /* Check for reverse direction */ if(reverse) { waypoint_t temp; temp=first_waypoint; first_waypoint=last_waypoint; last_waypoint=temp; inc_dec_waypoint=-1; } /* Loop through all pairs of waypoints */ if(loop && reverse) { finish_node=point_node[last_waypoint]; finish_waypoint=last_waypoint; } for(waypoint=first_waypoint;waypoint!=(last_waypoint+inc_dec_waypoint);waypoint+=inc_dec_waypoint) { if(point_used[waypoint]!=3) continue; start_node=finish_node; finish_node=point_node[waypoint]; start_waypoint=finish_waypoint; finish_waypoint=waypoint; if(start_node==NO_NODE) continue; if(heading!=-999 && join_segment==NO_SEGMENT) join_segment=FindClosestSegmentHeading(OSMNodes,OSMSegments,OSMWays,start_node,heading,profile); /* Calculate the route */ if(!option_quiet) printf("Routing from waypoint %d to waypoint %d\n",start_waypoint,finish_waypoint); results[nresults]=CalculateRoute(OSMNodes,OSMSegments,OSMWays,OSMRelations,profile,start_node,join_segment,finish_node,start_waypoint,finish_waypoint); if(!results[nresults]) exit(EXIT_FAILURE); join_segment=results[nresults]->last_segment; nresults++; } if(loop && !reverse) { start_node=finish_node; finish_node=point_node[first_waypoint]; start_waypoint=finish_waypoint; finish_waypoint=first_waypoint; /* Calculate the route */ if(!option_quiet) printf("Routing from waypoint %d to waypoint %d\n",start_waypoint,finish_waypoint); results[nresults]=CalculateRoute(OSMNodes,OSMSegments,OSMWays,OSMRelations,profile,start_node,join_segment,finish_node,start_waypoint,finish_waypoint); if(!results[nresults]) exit(EXIT_FAILURE); nresults++; } if(!option_quiet) { printf("Routed OK\n"); fflush(stdout); } /* Print out the combined route */ if(!option_quiet) printf_first("Generating Result Outputs"); if(!option_file_none) PrintRoute(results,nresults,OSMNodes,OSMSegments,OSMWays,OSMRelations,profile,translation); if(!option_quiet) printf_last("Generated Result Outputs"); /* Destroy the remaining results lists and data structures */ #ifdef DEBUG_MEMORY_LEAK for(waypoint=0;waypoint<nresults;waypoint++) FreeResultsList(results[waypoint]); DestroyNodeList(OSMNodes); DestroySegmentList(OSMSegments); DestroyWayList(OSMWays); DestroyRelationList(OSMRelations); FreeXMLProfiles(); FreeXMLTranslations(); #endif if(!option_quiet) printf_program_end(); exit(EXIT_SUCCESS); }
SegmentsX *CreateSuperSegments(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx) { index_t i; SegmentsX *supersegmentsx; index_t sn=0,ss=0; supersegmentsx=NewSegmentList(0); if(segmentsx->number==0 || waysx->number==0) return(supersegmentsx); /* Print the start message */ printf_first("Creating Super-Segments: Super-Nodes=0 Super-Segments=0"); /* Map into memory / open the files */ #if !SLIM segmentsx->data=MapFile(segmentsx->filename); waysx->data=MapFile(waysx->filename); #else segmentsx->fd=ReOpenFile(segmentsx->filename); waysx->fd=ReOpenFile(waysx->filename); #endif /* Create super-segments for each super-node. */ for(i=0;i<nodesx->number;i++) { if(IsBitSet(nodesx->super,i)) { SegmentX *segmentx; int count=0,match; Way prevway[MAX_SEG_PER_NODE]; segmentx=FirstSegmentX(segmentsx,i,1); while(segmentx) { WayX *wayx=LookupWayX(waysx,segmentx->way,1); /* Check that this type of way hasn't already been routed */ match=0; if(count>0) { int j; for(j=0;j<count;j++) if(!WaysCompare(&prevway[j],&wayx->way)) { match=1; break; } } assert(count<MAX_SEG_PER_NODE); /* Only a limited amount of history stored. */ prevway[count++]=wayx->way; /* Route the way and store the super-segments. */ if(!match) { Results *results=FindRoutesWay(nodesx,segmentsx,waysx,i,&wayx->way); Result *result=FirstResult(results); while(result) { if(IsBitSet(nodesx->super,result->node) && result->segment!=NO_SEGMENT) { if(wayx->way.type&Way_OneWay && result->node!=i) AppendSegment(supersegmentsx,segmentx->way,i,result->node,DISTANCE((distance_t)result->score)|ONEWAY_1TO2); else AppendSegment(supersegmentsx,segmentx->way,i,result->node,DISTANCE((distance_t)result->score)); ss++; } result=NextResult(results,result); } FreeResultsList(results); } segmentx=NextSegmentX(segmentsx,segmentx,i); } sn++; if(!(sn%10000)) printf_middle("Creating Super-Segments: Super-Nodes=%"Pindex_t" Super-Segments=%"Pindex_t,sn,ss); } } /* Unmap from memory / close the files */ #if !SLIM segmentsx->data=UnmapFile(segmentsx->filename); waysx->data=UnmapFile(waysx->filename); #else segmentsx->fd=CloseFile(segmentsx->fd); waysx->fd=CloseFile(waysx->fd); #endif /* Print the final message */ printf_last("Created Super-Segments: Super-Nodes=%"Pindex_t" Super-Segments=%"Pindex_t,sn,ss); return(supersegmentsx); }
Results *FindFinishRoutes(Nodes *nodes,Segments *segments,Ways *ways,index_t finish,Profile *profile) { Results *results; Queue *queue; index_t node1,node2; Result *result1,*result2; Segment *segment; Way *way; /* Insert the first node into the queue */ results=NewResultsList(8); results->finish=finish; result1=InsertResult(results,finish); ZeroResult(result1); queue=NewQueueList(); InsertInQueue(queue,result1); /* Loop across all nodes in the queue */ while((result1=PopFromQueue(queue))) { node1=result1->node; if(IsFakeNode(node1)) segment=FirstFakeSegment(node1); else segment=FirstSegment(segments,nodes,node1); while(segment) { score_t segment_pref,segment_score,cumulative_score; int i; if(!IsNormalSegment(segment)) goto endloop; if(profile->oneway && IsOnewayFrom(segment,node1)) goto endloop; node2=OtherNode(segment,node1); if(result1->next==node2) goto endloop; way=LookupWay(ways,segment->way); if(!(way->allow&profile->allow)) goto endloop; if(!profile->highway[HIGHWAY(way->type)]) goto endloop; if(way->weight && way->weight<profile->weight) goto endloop; if((way->height && way->height<profile->height) || (way->width && way->width <profile->width ) || (way->length && way->length<profile->length)) goto endloop; segment_pref=profile->highway[HIGHWAY(way->type)]; for(i=1;i<Property_Count;i++) if(ways->props & PROPERTIES(i)) { if(way->props & PROPERTIES(i)) segment_pref*=profile->props_yes[i]; else segment_pref*=profile->props_no[i]; } if(segment_pref==0) goto endloop; if(option_quickest==0) segment_score=(score_t)DISTANCE(segment->distance)/segment_pref; else segment_score=(score_t)Duration(segment,way,profile)/segment_pref; cumulative_score=result1->score+segment_score; result2=FindResult(results,node2); if(!result2) /* New end node */ { result2=InsertResult(results,node2); result2->prev=NO_NODE; result2->next=node1; result2->score=cumulative_score; result2->segment=segment; if(!IsFakeNode(node2) && !IsSuperNode(nodes,node2)) { result2->sortby=result2->score; InsertInQueue(queue,result2); } } else if(cumulative_score<result2->score) /* New end node is better */ { result2->next=node1; result2->score=cumulative_score; result2->segment=segment; if(!IsFakeNode(node2) && !IsSuperNode(nodes,node2)) { result2->sortby=result2->score; InsertInQueue(queue,result2); } } endloop: if(IsFakeNode(node1)) segment=NextFakeSegment(segment,node1); else segment=NextSegment(segments,segment,node1); } } FreeQueueList(queue); /* Check it worked */ if(results->number==1) { FreeResultsList(results); return(NULL); } return(results); }
Results *FindNormalRoute(Nodes *nodes,Segments *segments,Ways *ways,index_t start,index_t finish,Profile *profile) { Results *results; Queue *queue; index_t node1,node2; score_t finish_score; double finish_lat,finish_lon; Result *result1,*result2; Segment *segment; Way *way; /* Set up the finish conditions */ finish_score=INF_SCORE; if(IsFakeNode(finish)) GetFakeLatLong(finish,&finish_lat,&finish_lon); else GetLatLong(nodes,finish,&finish_lat,&finish_lon); /* Create the list of results and insert the first node into the queue */ results=NewResultsList(8); results->start=start; results->finish=finish; result1=InsertResult(results,start); ZeroResult(result1); queue=NewQueueList(); InsertInQueue(queue,result1); /* Loop across all nodes in the queue */ while((result1=PopFromQueue(queue))) { if(result1->score>finish_score) continue; node1=result1->node; if(IsFakeNode(node1)) segment=FirstFakeSegment(node1); else segment=FirstSegment(segments,nodes,node1); while(segment) { score_t segment_pref,segment_score,cumulative_score; int i; node2=OtherNode(segment,node1); /* need this here because we use node2 later */ if(!IsNormalSegment(segment)) goto endloop; if(profile->oneway && IsOnewayTo(segment,node1)) goto endloop; if(result1->prev==node2) goto endloop; if(node2!=finish && !IsFakeNode(node2) && IsSuperNode(nodes,node2)) goto endloop; way=LookupWay(ways,segment->way); if(!(way->allow&profile->allow)) goto endloop; if(!profile->highway[HIGHWAY(way->type)]) goto endloop; if(way->weight && way->weight<profile->weight) goto endloop; if((way->height && way->height<profile->height) || (way->width && way->width <profile->width ) || (way->length && way->length<profile->length)) goto endloop; segment_pref=profile->highway[HIGHWAY(way->type)]; for(i=1;i<Property_Count;i++) if(ways->props & PROPERTIES(i)) { if(way->props & PROPERTIES(i)) segment_pref*=profile->props_yes[i]; else segment_pref*=profile->props_no[i]; } if(segment_pref==0) goto endloop; if(option_quickest==0) segment_score=(score_t)DISTANCE(segment->distance)/segment_pref; else segment_score=(score_t)Duration(segment,way,profile)/segment_pref; cumulative_score=result1->score+segment_score; if(cumulative_score>finish_score) goto endloop; result2=FindResult(results,node2); if(!result2) /* New end node */ { result2=InsertResult(results,node2); result2->prev=node1; result2->next=NO_NODE; result2->score=cumulative_score; result2->segment=segment; if(node2==finish) { finish_score=cumulative_score; } else { result2->sortby=result2->score; InsertInQueue(queue,result2); } } else if(cumulative_score<result2->score) /* New end node is better */ { result2->prev=node1; result2->score=cumulative_score; result2->segment=segment; if(node2==finish) { finish_score=cumulative_score; } else { result2->sortby=result2->score; if(result2->score<finish_score) InsertInQueue(queue,result2); } } endloop: if(IsFakeNode(node1)) segment=NextFakeSegment(segment,node1); else if(IsFakeNode(node2)) segment=NULL; /* cannot call NextSegment() with a fake segment */ else { segment=NextSegment(segments,segment,node1); if(!segment && IsFakeNode(finish)) segment=ExtraFakeSegment(node1,finish); } } } FreeQueueList(queue); /* Check it worked */ if(!FindResult(results,finish)) { FreeResultsList(results); return(NULL); } FixForwardRoute(results,finish); return(results); }
Results *FindMiddleRoute(Nodes *nodes,Segments *segments,Ways *ways,Results *begin,Results *end,Profile *profile) { Results *results; Queue *queue; index_t node1,node2; index_t end_prev; score_t finish_score; double finish_lat,finish_lon; Result *result1,*result2,*result3; Segment *segment; Way *way; if(!option_quiet) { printf("Routing: Super-Nodes checked = 0"); fflush(stdout); } /* Set up the finish conditions */ finish_score=INF_DISTANCE; end_prev=NO_NODE; if(IsFakeNode(end->finish)) GetFakeLatLong(end->finish,&finish_lat,&finish_lon); else GetLatLong(nodes,end->finish,&finish_lat,&finish_lon); /* Create the list of results and insert the first node into the queue */ results=NewResultsList(2048); results->start=begin->start; results->finish=end->finish; result1=InsertResult(results,begin->start); result3=FindResult(begin,begin->start); *result1=*result3; queue=NewQueueList(); /* Insert the finish points of the beginning part of the path into the queue */ result3=FirstResult(begin); while(result3) { if(result3->node!=begin->start && !IsFakeNode(result3->node) && IsSuperNode(nodes,result3->node)) { result2=InsertResult(results,result3->node); *result2=*result3; result2->prev=begin->start; result2->sortby=result2->score; InsertInQueue(queue,result2); } result3=NextResult(begin,result3); } if(begin->number==1) InsertInQueue(queue,result1); /* Loop across all nodes in the queue */ while((result1=PopFromQueue(queue))) { if(result1->score>finish_score) continue; node1=result1->node; segment=FirstSegment(segments,nodes,node1); while(segment) { score_t segment_pref,segment_score,cumulative_score; int i; if(!IsSuperSegment(segment)) goto endloop; if(profile->oneway && IsOnewayTo(segment,node1)) goto endloop; node2=OtherNode(segment,node1); if(result1->prev==node2) goto endloop; way=LookupWay(ways,segment->way); if(!(way->allow&profile->allow)) goto endloop; if(!profile->highway[HIGHWAY(way->type)]) goto endloop; if(way->weight && way->weight<profile->weight) goto endloop; if((way->height && way->height<profile->height) || (way->width && way->width <profile->width ) || (way->length && way->length<profile->length)) goto endloop; segment_pref=profile->highway[HIGHWAY(way->type)]; for(i=1;i<Property_Count;i++) if(ways->props & PROPERTIES(i)) { if(way->props & PROPERTIES(i)) segment_pref*=profile->props_yes[i]; else segment_pref*=profile->props_no[i]; } if(segment_pref==0) goto endloop; if(option_quickest==0) segment_score=(score_t)DISTANCE(segment->distance)/segment_pref; else segment_score=(score_t)Duration(segment,way,profile)/segment_pref; cumulative_score=result1->score+segment_score; if(cumulative_score>finish_score) goto endloop; result2=FindResult(results,node2); if(!result2) /* New end node */ { result2=InsertResult(results,node2); result2->prev=node1; result2->next=NO_NODE; result2->score=cumulative_score; result2->segment=segment; if((result3=FindResult(end,node2))) { if((result2->score+result3->score)<finish_score) { finish_score=result2->score+result3->score; end_prev=node2; } } else { double lat,lon; distance_t direct; GetLatLong(nodes,node2,&lat,&lon); direct=Distance(lat,lon,finish_lat,finish_lon); if(option_quickest==0) result2->sortby=result2->score+(score_t)direct/profile->max_pref; else result2->sortby=result2->score+(score_t)distance_speed_to_duration(direct,profile->max_speed)/profile->max_pref; InsertInQueue(queue,result2); } } else if(cumulative_score<result2->score) /* New end node is better */ { result2->prev=node1; result2->score=cumulative_score; result2->segment=segment; if((result3=FindResult(end,node2))) { if((result2->score+result3->score)<finish_score) { finish_score=result2->score+result3->score; end_prev=node2; } } else if(result2->score<finish_score) { double lat,lon; distance_t direct; GetLatLong(nodes,node2,&lat,&lon); direct=Distance(lat,lon,finish_lat,finish_lon); if(option_quickest==0) result2->sortby=result2->score+(score_t)direct/profile->max_pref; else result2->sortby=result2->score+(score_t)distance_speed_to_duration(direct,profile->max_speed)/profile->max_pref; InsertInQueue(queue,result2); } } endloop: if(!option_quiet && !(results->number%10000)) { printf("\rRouting: Super-Nodes checked = %d",results->number); fflush(stdout); } segment=NextSegment(segments,segment,node1); } } if(!option_quiet) { printf("\rRouting: Super-Nodes checked = %d\n",results->number); fflush(stdout); } /* Finish off the end part of the route. */ if(!FindResult(results,end->finish) && end_prev!=NO_NODE) { result2=InsertResult(results,end->finish); result3=FindResult(end,end->finish); *result2=*result3; result2->prev=end_prev; result2->score=finish_score; } FreeQueueList(queue); /* Check it worked */ if(end_prev==NO_NODE) { FreeResultsList(results); return(NULL); } FixForwardRoute(results,end->finish); return(results); }
Results *FindFinishRoutes(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,Profile *profile,index_t finish_node) { Results *results,*results2; Queue *queue; Result *result1,*result2,*result3; /* Create the results and insert the finish node */ results=NewResultsList(64); results->finish_node=finish_node; result1=InsertResult(results,finish_node,NO_SEGMENT); /* Insert the first node into the queue */ queue=NewQueueList(); InsertInQueue(queue,result1); /* Loop across all nodes in the queue */ while((result1=PopFromQueue(queue))) { index_t node1,seg1,seg1r; Segment *segment; index_t turnrelation=NO_RELATION; node1=result1->node; seg1=result1->segment; if(IsFakeSegment(seg1)) seg1r=IndexRealSegment(seg1); else seg1r=seg1; /* lookup if a turn restriction applies */ if(profile->turns && !IsFakeNode(node1) && IsTurnRestrictedNode(LookupNode(nodes,node1,1))) turnrelation=FindFirstTurnRelation1(relations,node1); /* working backwards => turn relation sort order doesn't help */ /* Loop across all segments */ if(IsFakeNode(node1)) segment=FirstFakeSegment(node1); else segment=FirstSegment(segments,nodes,node1,1); while(segment) { Way *way; index_t node2,seg2,seg2r; score_t segment_pref,segment_score,cumulative_score; int i; /* must be a normal segment */ if((IsFakeNode(node1) || !IsSuperNode(LookupNode(nodes,node1,1))) && !IsNormalSegment(segment)) goto endloop; /* must obey one-way restrictions (unless profile allows) */ if(profile->oneway && IsOnewayFrom(segment,node1)) /* Disallow oneway from node2 *to* node1 */ goto endloop; node2=OtherNode(segment,node1); if(IsFakeNode(node1) || IsFakeNode(node2)) { seg2 =IndexFakeSegment(segment); seg2r=IndexRealSegment(seg2); } else { seg2 =IndexSegment(segments,segment); seg2r=seg2; } /* must not perform U-turn (unless profile allows) */ if(profile->turns && (seg1==seg2 || seg1==seg2r || seg1r==seg2 || (seg1r==seg2r && IsFakeUTurn(seg1,seg2)))) goto endloop; /* must obey turn relations */ if(turnrelation!=NO_RELATION) { index_t turnrelation2=FindFirstTurnRelation2(relations,node1,seg2r); /* node2 -> node1 -> result1->next->node */ if(turnrelation2!=NO_RELATION && !IsTurnAllowed(relations,turnrelation2,node1,seg2r,seg1r,profile->allow)) goto endloop; } way=LookupWay(ways,segment->way,1); /* mode of transport must be allowed on the highway */ if(!(way->allow&profile->allow)) goto endloop; /* must obey weight restriction (if exists) */ if(way->weight && way->weight<profile->weight) goto endloop; /* must obey height/width/length restriction (if exists) */ if((way->height && way->height<profile->height) || (way->width && way->width <profile->width ) || (way->length && way->length<profile->length)) goto endloop; segment_pref=profile->highway[HIGHWAY(way->type)]; for(i=1;i<Property_Count;i++) if(ways->file.props & PROPERTIES(i)) { if(way->props & PROPERTIES(i)) segment_pref*=profile->props_yes[i]; else segment_pref*=profile->props_no[i]; } /* profile preferences must allow this highway */ if(segment_pref==0) goto endloop; /* mode of transport must be allowed through node2 */ if(!IsFakeNode(node2)) { Node *node=LookupNode(nodes,node2,2); if(!(node->allow&profile->allow)) goto endloop; } if(option_quickest==0) segment_score=(score_t)DISTANCE(segment->distance)/segment_pref; else segment_score=(score_t)Duration(segment,way,profile)/segment_pref; cumulative_score=result1->score+segment_score; result2=FindResult(results,node2,seg2); if(!result2) /* New end node */ { result2=InsertResult(results,node2,seg2); result2->next=result1; /* working backwards */ result2->score=cumulative_score; if(IsFakeNode(node1) || (!IsFakeNode(node1) && !IsSuperNode(LookupNode(nodes,node1,1)))) /* Overshoot by one segment */ { result2->sortby=result2->score; InsertInQueue(queue,result2); } } else if(cumulative_score<result2->score) /* New end node is better */ { result2->next=result1; /* working backwards */ result2->score=cumulative_score; if(IsFakeNode(node1) || (!IsFakeNode(node1) && !IsSuperNode(LookupNode(nodes,node1,1)))) /* Overshoot by one segment */ { result2->sortby=result2->score; InsertInQueue(queue,result2); } } endloop: if(IsFakeNode(node1)) segment=NextFakeSegment(segment,node1); else segment=NextSegment(segments,segment,node1); } } FreeQueueList(queue); /* Check it worked */ if(results->number==1) { FreeResultsList(results); return(NULL); } /* Create a results structure with the node at the end of the segment opposite the start */ results2=NewResultsList(64); results2->finish_node=results->finish_node; result3=FirstResult(results); while(result3) { if(result3->next) { result2=InsertResult(results2,result3->next->node,result3->segment); result2->score=result3->next->score; } result3=NextResult(results,result3); } /* Fix up the result->next pointers */ result3=FirstResult(results); while(result3) { if(result3->next && result3->next->next) { result1=FindResult(results2,result3->next->node,result3->segment); result2=FindResult(results2,result3->next->next->node,result3->next->segment); result1->next=result2; } result3=NextResult(results,result3); } FreeResultsList(results); return(results2); }
Results *FindNormalRoute(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,Profile *profile,index_t start_node,index_t prev_segment,index_t finish_node) { Results *results; Queue *queue; score_t finish_score; double finish_lat,finish_lon; Result *finish_result; Result *result1,*result2; /* Set up the finish conditions */ finish_score=INF_SCORE; finish_result=NULL; if(IsFakeNode(finish_node)) GetFakeLatLong(finish_node,&finish_lat,&finish_lon); else GetLatLong(nodes,finish_node,&finish_lat,&finish_lon); /* Create the list of results and insert the first node into the queue */ results=NewResultsList(64); results->start_node=start_node; results->prev_segment=prev_segment; result1=InsertResult(results,results->start_node,results->prev_segment); queue=NewQueueList(); InsertInQueue(queue,result1); /* Loop across all nodes in the queue */ while((result1=PopFromQueue(queue))) { Segment *segment; index_t node1,seg1,seg1r; index_t turnrelation=NO_RELATION; /* score must be better than current best score */ if(result1->score>finish_score) continue; node1=result1->node; seg1=result1->segment; if(IsFakeSegment(seg1)) seg1r=IndexRealSegment(seg1); else seg1r=seg1; /* lookup if a turn restriction applies */ if(profile->turns && !IsFakeNode(node1) && IsTurnRestrictedNode(LookupNode(nodes,node1,1))) turnrelation=FindFirstTurnRelation2(relations,node1,seg1r); /* Loop across all segments */ if(IsFakeNode(node1)) segment=FirstFakeSegment(node1); else segment=FirstSegment(segments,nodes,node1,1); while(segment) { Way *way; index_t node2,seg2,seg2r; score_t segment_pref,segment_score,cumulative_score; int i; node2=OtherNode(segment,node1); /* need this here because we use node2 at the end of the loop */ /* must be a normal segment */ if(!IsNormalSegment(segment)) goto endloop; /* must obey one-way restrictions (unless profile allows) */ if(profile->oneway && IsOnewayTo(segment,node1)) goto endloop; if(IsFakeNode(node1) || IsFakeNode(node2)) { seg2 =IndexFakeSegment(segment); seg2r=IndexRealSegment(seg2); } else { seg2 =IndexSegment(segments,segment); seg2r=seg2; } /* must not perform U-turn (unless profile allows) */ if(profile->turns && (seg1==seg2 || seg1==seg2r || seg1r==seg2 || (seg1r==seg2r && IsFakeUTurn(seg1,seg2)))) goto endloop; /* must obey turn relations */ if(turnrelation!=NO_RELATION && !IsTurnAllowed(relations,turnrelation,node1,seg1r,seg2r,profile->allow)) goto endloop; /* must not pass over super-node */ if(node2!=finish_node && !IsFakeNode(node2) && IsSuperNode(LookupNode(nodes,node2,2))) goto endloop; way=LookupWay(ways,segment->way,1); /* mode of transport must be allowed on the highway */ if(!(way->allow&profile->allow)) goto endloop; /* must obey weight restriction (if exists) */ if(way->weight && way->weight<profile->weight) goto endloop; /* must obey height/width/length restriction (if exists) */ if((way->height && way->height<profile->height) || (way->width && way->width <profile->width ) || (way->length && way->length<profile->length)) goto endloop; segment_pref=profile->highway[HIGHWAY(way->type)]; for(i=1;i<Property_Count;i++) if(ways->file.props & PROPERTIES(i)) { if(way->props & PROPERTIES(i)) segment_pref*=profile->props_yes[i]; else segment_pref*=profile->props_no[i]; } /* profile preferences must allow this highway */ if(segment_pref==0) goto endloop; /* mode of transport must be allowed through node2 */ if(!IsFakeNode(node2)) { Node *node=LookupNode(nodes,node2,2); if(!(node->allow&profile->allow)) goto endloop; } if(option_quickest==0) segment_score=(score_t)DISTANCE(segment->distance)/segment_pref; else segment_score=(score_t)Duration(segment,way,profile)/segment_pref; cumulative_score=result1->score+segment_score; /* score must be better than current best score */ if(cumulative_score>finish_score) goto endloop; result2=FindResult(results,node2,seg2); if(!result2) /* New end node/segment combination */ { result2=InsertResult(results,node2,seg2); result2->prev=result1; result2->score=cumulative_score; if(node2==finish_node) { if(cumulative_score<finish_score) { finish_score=cumulative_score; finish_result=result2; } } else { result2->sortby=result2->score; InsertInQueue(queue,result2); } } else if(cumulative_score<result2->score) /* New score for end node/segment combination is better */ { result2->prev=result1; result2->score=cumulative_score; result2->segment=seg2; if(node2==finish_node) { if(cumulative_score<finish_score) { finish_score=cumulative_score; finish_result=result2; } } else { result2->sortby=result2->score; if(result2->score<finish_score) InsertInQueue(queue,result2); } } endloop: if(IsFakeNode(node1)) segment=NextFakeSegment(segment,node1); else if(IsFakeNode(node2)) segment=NULL; /* cannot call NextSegment() with a fake segment */ else { segment=NextSegment(segments,segment,node1); if(!segment && IsFakeNode(finish_node)) segment=ExtraFakeSegment(node1,finish_node); } } } FreeQueueList(queue); /* Check it worked */ if(!finish_result) { FreeResultsList(results); return(NULL); } FixForwardRoute(results,finish_result); return(results); }
Results *FindMiddleRoute(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,Profile *profile,Results *begin,Results *end) { Results *results; Queue *queue; Result *finish_result; score_t finish_score; double finish_lat,finish_lon; Result *result1,*result2,*result3,*result4; if(!option_quiet) printf_first("Routing: Super-Nodes checked = 0"); /* Set up the finish conditions */ finish_score=INF_DISTANCE; finish_result=NULL; if(IsFakeNode(end->finish_node)) GetFakeLatLong(end->finish_node,&finish_lat,&finish_lon); else GetLatLong(nodes,end->finish_node,&finish_lat,&finish_lon); /* Create the list of results and insert the first node into the queue */ results=NewResultsList(65536); results->start_node=begin->start_node; results->prev_segment=begin->prev_segment; if(begin->number==1) { if(begin->prev_segment==NO_SEGMENT) results->prev_segment=NO_SEGMENT; else { index_t superseg=FindSuperSegment(nodes,segments,ways,relations,profile,begin->start_node,begin->prev_segment); results->prev_segment=superseg; } } result1=InsertResult(results,results->start_node,results->prev_segment); queue=NewQueueList(); /* Insert the finish points of the beginning part of the path into the queue, translating the segments into super-segments. */ result3=FirstResult(begin); while(result3) { if((results->start_node!=result3->node || results->prev_segment!=result3->segment) && !IsFakeNode(result3->node) && IsSuperNode(LookupNode(nodes,result3->node,1))) { Result *result5=result1; index_t superseg=FindSuperSegment(nodes,segments,ways,relations,profile,result3->node,result3->segment); if(superseg!=result3->segment) { result5=InsertResult(results,result3->node,result3->segment); result5->prev=result1; } if(!FindResult(results,result3->node,superseg)) { result2=InsertResult(results,result3->node,superseg); result2->prev=result5; result2->score=result3->score; result2->sortby=result3->score; InsertInQueue(queue,result2); if((result4=FindResult(end,result2->node,result2->segment))) { if((result2->score+result4->score)<finish_score) { finish_score=result2->score+result4->score; finish_result=result2; } } } } result3=NextResult(begin,result3); } if(begin->number==1) InsertInQueue(queue,result1); /* Loop across all nodes in the queue */ while((result1=PopFromQueue(queue))) { index_t node1,seg1; Segment *segment; index_t turnrelation=NO_RELATION; /* score must be better than current best score */ if(result1->score>finish_score) continue; node1=result1->node; seg1=result1->segment; /* lookup if a turn restriction applies */ if(profile->turns && IsTurnRestrictedNode(LookupNode(nodes,node1,1))) /* node1 cannot be a fake node (must be a super-node) */ turnrelation=FindFirstTurnRelation2(relations,node1,seg1); /* Loop across all segments */ segment=FirstSegment(segments,nodes,node1,1); /* node1 cannot be a fake node (must be a super-node) */ while(segment) { Way *way; Node *node; index_t node2,seg2; score_t segment_pref,segment_score,cumulative_score; int i; /* must be a super segment */ if(!IsSuperSegment(segment)) goto endloop; /* must obey one-way restrictions (unless profile allows) */ if(profile->oneway && IsOnewayTo(segment,node1)) goto endloop; node2=OtherNode(segment,node1); seg2=IndexSegment(segments,segment); /* node2 cannot be a fake node (must be a super-node) */ /* must not perform U-turn */ if(seg1==seg2) /* No fake segments, applies to all profiles */ goto endloop; /* must obey turn relations */ if(turnrelation!=NO_RELATION && !IsTurnAllowed(relations,turnrelation,node1,seg1,seg2,profile->allow)) goto endloop; way=LookupWay(ways,segment->way,1); /* transport must be allowed on the highway */ if(!(way->allow&profile->allow)) goto endloop; /* must obey weight restriction (if exists) */ if(way->weight && way->weight<profile->weight) goto endloop; /* must obey height/width/length restriction (if exists) */ if((way->height && way->height<profile->height) || (way->width && way->width <profile->width ) || (way->length && way->length<profile->length)) goto endloop; segment_pref=profile->highway[HIGHWAY(way->type)]; for(i=1;i<Property_Count;i++) if(ways->file.props & PROPERTIES(i)) { if(way->props & PROPERTIES(i)) segment_pref*=profile->props_yes[i]; else segment_pref*=profile->props_no[i]; } /* profile preferences must allow this highway */ if(segment_pref==0) goto endloop; node=LookupNode(nodes,node2,2); /* node2 cannot be a fake node (must be a super-node) */ /* mode of transport must be allowed through node2 */ if(!(node->allow&profile->allow)) goto endloop; if(option_quickest==0) segment_score=(score_t)DISTANCE(segment->distance)/segment_pref; else segment_score=(score_t)Duration(segment,way,profile)/segment_pref; cumulative_score=result1->score+segment_score; /* score must be better than current best score */ if(cumulative_score>finish_score) goto endloop; result2=FindResult(results,node2,seg2); if(!result2) /* New end node/segment pair */ { result2=InsertResult(results,node2,seg2); result2->prev=result1; result2->score=cumulative_score; if((result3=FindResult(end,node2,seg2))) { if((result2->score+result3->score)<finish_score) { finish_score=result2->score+result3->score; finish_result=result2; } } else { double lat,lon; distance_t direct; GetLatLong(nodes,node2,&lat,&lon); /* node2 cannot be a fake node (must be a super-node) */ direct=Distance(lat,lon,finish_lat,finish_lon); if(option_quickest==0) result2->sortby=result2->score+(score_t)direct/profile->max_pref; else result2->sortby=result2->score+(score_t)distance_speed_to_duration(direct,profile->max_speed)/profile->max_pref; InsertInQueue(queue,result2); } } else if(cumulative_score<result2->score) /* New end node/segment pair is better */ { result2->prev=result1; result2->score=cumulative_score; if((result3=FindResult(end,node2,seg2))) { if((result2->score+result3->score)<finish_score) { finish_score=result2->score+result3->score; finish_result=result2; } } else if(result2->score<finish_score) { double lat,lon; distance_t direct; GetLatLong(nodes,node2,&lat,&lon); /* node2 cannot be a fake node (must be a super-node) */ direct=Distance(lat,lon,finish_lat,finish_lon); if(option_quickest==0) result2->sortby=result2->score+(score_t)direct/profile->max_pref; else result2->sortby=result2->score+(score_t)distance_speed_to_duration(direct,profile->max_speed)/profile->max_pref; InsertInQueue(queue,result2); } } if(!option_quiet && !(results->number%1000)) printf_middle("Routing: Super-Nodes checked = %d",results->number); endloop: segment=NextSegment(segments,segment,node1); /* node1 cannot be a fake node (must be a super-node) */ } } if(!option_quiet) printf_last("Routing: Super-Nodes checked = %d",results->number); FreeQueueList(queue); /* Check it worked */ if(!finish_result) { FreeResultsList(results); return(NULL); } /* Finish off the end part of the route */ if(finish_result->node!=end->finish_node) { result3=InsertResult(results,end->finish_node,NO_SEGMENT); result3->prev=finish_result; result3->score=finish_score; finish_result=result3; } FixForwardRoute(results,finish_result); return(results); }
Results *CombineRoutes(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,Profile *profile,Results *begin,Results *middle) { Result *midres,*comres1; Results *combined; combined=NewResultsList(256); combined->start_node=begin->start_node; combined->prev_segment=begin->prev_segment; /* Insert the start point */ midres=FindResult(middle,middle->start_node,middle->prev_segment); comres1=InsertResult(combined,combined->start_node,combined->prev_segment); /* Insert the start of the route */ if(begin->number>1 && midres->next) { Result *begres; midres=FindResult(middle,midres->next->node,midres->next->segment); begres=FindResult(begin,midres->node,midres->segment); FixForwardRoute(begin,begres); if(midres->next && midres->next->node==midres->node) midres=midres->next; begres=FindResult(begin,begin->start_node,begin->prev_segment); begres=begres->next; do { Result *comres2; comres2=InsertResult(combined,begres->node,begres->segment); comres2->score=begres->score+comres1->score; comres2->prev=comres1; begres=begres->next; comres1=comres2; } while(begres); } /* Sort out the combined route */ do { Result *result; if(midres->next) { Results *results=FindNormalRoute(nodes,segments,ways,relations,profile,comres1->node,comres1->segment,midres->next->node); if(!results) return(NULL); result=FindResult(results,midres->node,comres1->segment); result=result->next; /* * midres midres->next * = = * ---*----------------------------------* = middle * * ---*----.----.----.----.----.----.----* = results * = * result * * ---*----.----.----.----.----.----.----* = combined * = = * comres1 comres2 */ do { Result *comres2; comres2=InsertResult(combined,result->node,result->segment); comres2->score=result->score+comres1->score; comres2->prev=comres1; result=result->next; comres1=comres2; } while(result); FreeResultsList(results); } midres=midres->next; } while(midres); FixForwardRoute(combined,comres1); return(combined); }