trunk/src/router.c

/***************************************
 $Header: /home/amb/CVS/routino/src/router.c,v 1.30 2009-02-07 11:50:37 amb Exp $

 OSM router.
 ******************/ /******************
 Written by Andrew M. Bishop

 This file Copyright 2008,2009 Andrew M. Bishop
 It may be distributed under the GNU Public License, version 2, or
 any higher version.  See section COPYING of the GNU Public license
 for conditions under which this file may be redistributed.
 ***************************************/


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "types.h"
#include "functions.h"
#include "profiles.h"


/*+ The option not to print anything progress information. +*/
int option_quiet=0;


int main(int argc,char** argv)
{
 Nodes    *OSMNodes;
 Segments *OSMSegments;
 Ways     *OSMWays;
 node_t    start,finish;
 int       help_profile=0,all=0,only_super=0,no_print=0;
 char     *dirname=NULL,*prefix=NULL,*filename;
 Transport transport=Transport_None;
 Profile   profile;
 int i;

 /* Parse the command line arguments */

 if(argc<5)
   {
   usage:

    fprintf(stderr,"Usage: router <start-lat> <start-lon> <finish-lat> <finish-lon>\n"
                   "              [--help] [--help-profile]\n"
                   "              [--dir=<name>] [--prefix=<name>]\n"
                   "              [--all] [--only-super]\n"
                   "              [--no-print] [--quiet]\n"
                   "              [--transport=<transport>]\n"
                   "              [--not-highway=<highway> ...]\n"
                   "              [--speed-<highway>=<speed> ...]\n"
                   "              [--ignore-oneway]\n"
                   "\n"
                   "<transport> defaults to motorcar but can be set to:\n"
                   "%s"
                   "\n"
                   "<highway> can be selected from:\n"
                   "%s"
                   "\n"
                   "<speed> is a speed in km/hour\n"
                   "\n",
                   TransportList(),HighwayList());

    return(1);
   }

 /* Get the transport type if specified and fill in the profile */

 for(i=3;i<argc;i++)
    if(!strncmp(argv[i],"--transport=",12))
      {
       transport=TransportType(&argv[i][12]);

       if(transport==Transport_None)
          goto usage;
      }

 if(transport==Transport_None)
    transport=Transport_Motorcar;

 profile=*GetProfile(transport);

 /* Parse the other command line arguments */

 while(--argc>=5)
   {
    if(!strcmp(argv[argc],"--help"))
       goto usage;
    else if(!strcmp(argv[argc],"--help-profile"))
       help_profile=1;
    else if(!strncmp(argv[argc],"--dir=",6))
       dirname=&argv[argc][6];
    else if(!strncmp(argv[argc],"--prefix=",9))
       prefix=&argv[argc][9];
    else if(!strcmp(argv[argc],"--all"))
       all=1;
    else if(!strcmp(argv[argc],"--only-super"))
       only_super=1;
    else if(!strcmp(argv[argc],"--no-print"))
       no_print=1;
    else if(!strcmp(argv[argc],"--quiet"))
       option_quiet=1;
    else if(!strncmp(argv[argc],"--transport=",12))
       ; /* Done this already*/
    else if(!strncmp(argv[argc],"--not-highway=",14))
      {
       Highway highway=HighwayType(&argv[argc][14]);

       if(highway==Way_Unknown)
          goto usage;

       profile.highways[highway]=0;
      }
    else if(!strncmp(argv[argc],"--speed-",8))
      {
       Highway highway;
       char *equal=strchr(argv[argc],'=');
       char *string;

       if(!equal)
          goto usage;

       string=strcpy((char*)malloc(strlen(argv[argc])),argv[argc]+8);
       string[equal-argv[argc]]=0;

       highway=HighwayType(string);

       free(string);

       if(highway==Way_Unknown)
          goto usage;

       profile.speed[highway]=atoi(equal+1);
      }
    else if(!strcmp(argv[argc],"-ignore-oneway"))
       profile.oneway=0;
    else
       goto usage;
   }

 if(help_profile)
   {
    PrintProfile(&profile);

    return(0);
   }

 /* Load in the data */

 filename=(char*)malloc((dirname?strlen(dirname):0)+(prefix?strlen(prefix):0)+16);

 sprintf(filename,"%s%s%s%snodes.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":"");
 OSMNodes=LoadNodeList(filename);

 if(!OSMNodes)
   {
    fprintf(stderr,"Cannot open nodes file '%s'.\n",filename);
    return(1);
   }

 sprintf(filename,"%s%s%s%ssegments.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":"");
 OSMSegments=LoadSegmentList(filename);

 if(!OSMSegments)
   {
    fprintf(stderr,"Cannot open segments file '%s'.\n",filename);
    return(1);
   }

 sprintf(filename,"%s%s%s%sways.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":"");
 OSMWays=LoadWayList(filename);

 if(!OSMWays)
   {
    fprintf(stderr,"Cannot open ways file '%s'.\n",filename);
    return(1);
   }

 /* Get the start and finish */

   {
    float lat_start =atof(argv[1]);
    float lon_start =atof(argv[2]);
    float lat_finish=atof(argv[3]);
    float lon_finish=atof(argv[4]);

    Node *start_node =FindNode(OSMNodes,lat_start ,lon_start );
    Node *finish_node=FindNode(OSMNodes,lat_finish,lon_finish);

    if(!start_node)
      {
       fprintf(stderr,"Cannot find start node.\n");
       return(1);
      }

    if(!finish_node)
      {
       fprintf(stderr,"Cannot find finish node.\n");
       return(1);
      }

    if(!option_quiet)
      {
       float lat,lon;
       distance_t dist;

       GetLatLong(OSMNodes,start_node,&lat,&lon);
       dist=Distance(lat_start,lon_start,lat,lon);

       printf("Start node : %3.6f %4.6f = %2.3f km\n",lat,lon,distance_to_km(dist));

       GetLatLong(OSMNodes,finish_node,&lat,&lon);
       dist=Distance(lat_finish,lon_finish,lat,lon);

       printf("Finish node: %3.6f %4.6f = %2.3f km\n",lat,lon,distance_to_km(dist));
      }

    start =IndexNode(OSMNodes,start_node );
    finish=IndexNode(OSMNodes,finish_node);
   }

 /* Calculate the route. */

 if(all)
   {
    Results *results;

    /* Calculate the route */

    results=FindRoute(OSMNodes,OSMSegments,OSMWays,start,finish,&profile,all);

    /* Print the route */

    if(!results)
      {
       fprintf(stderr,"No route found.\n");
       return(1);
      }
    else if(!no_print)
       PrintRoute(results,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
   }
 else
   {
    Results *begin,*end;

    /* Calculate the beginning of the route */

    if(IsSuperNode(LookupNode(OSMNodes,start)))
      {
       Result *result;

       begin=NewResultsList(1);

       result=InsertResult(begin,start);

       result->node=start;
       result->shortest.prev=0;
       result->shortest.next=0;
       result->shortest.distance=0;
       result->shortest.duration=0;
       result->quickest.prev=0;
       result->quickest.next=0;
       result->quickest.distance=0;
       result->quickest.duration=0;
      }
    else
       begin=FindRoutes(OSMNodes,OSMSegments,OSMWays,start,&profile);

    if(FindResult(begin,finish))
      {
       /* Print the route */

       if(!no_print)
          PrintRoute(begin,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
      }
    else
      {
       Results *superresults;

       /* Calculate the end of the route */

       if(IsSuperNode(LookupNode(OSMNodes,finish)))
         {
          Result *result;

          end=NewResultsList(1);

          result=InsertResult(end,finish);

          result->node=finish;
          result->shortest.prev=0;
          result->shortest.next=0;
          result->shortest.distance=0;
          result->shortest.duration=0;
          result->quickest.prev=0;
          result->quickest.next=0;
          result->quickest.distance=0;
          result->quickest.duration=0;
         }
       else
          end=FindReverseRoutes(OSMNodes,OSMSegments,OSMWays,finish,&profile);

       /* Calculate the middle of the route */

       superresults=FindRoute3(OSMNodes,OSMSegments,OSMWays,start,finish,begin,end,&profile);

       /* Print the route */

       if(!superresults)
         {
          fprintf(stderr,"No route found.\n");
          return(1);
         }
       else if(!no_print)
         {
          if(only_super)
            {
             PrintRoute(superresults,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
            }
          else
            {
             Results *results=CombineRoutes(superresults,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);

             PrintRoute(results,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
            }
         }
      }
   }

 return(0);
}
1	/***************************************
2	$Header: /home/amb/CVS/routino/src/router.c,v 1.30 2009-02-07 11:50:37 amb Exp $
3
4	OSM router.
5	****************/ /****************
6	Written by Andrew M. Bishop
7
8	This file Copyright 2008,2009 Andrew M. Bishop
9	It may be distributed under the GNU Public License, version 2, or
10	any higher version. See section COPYING of the GNU Public license
11	for conditions under which this file may be redistributed.
12	***************************************/
13
14
15	#include <stdio.h>
16	#include <string.h>
17	#include <stdlib.h>
18
19	#include "types.h"
20	#include "functions.h"
21	#include "profiles.h"
22
23
24	/+ The option not to print anything progress information. +/
25	int option_quiet=0;
26
27
28	int main(int argc,char** argv)
29	{
30	Nodes *OSMNodes;
31	Segments *OSMSegments;
32	Ways *OSMWays;
33	node_t start,finish;
34	int help_profile=0,all=0,only_super=0,no_print=0;
35	char dirname=NULL,prefix=NULL,*filename;
36	Transport transport=Transport_None;
37	Profile profile;
38	int i;
39
40	/* Parse the command line arguments */
41
42	if(argc<5)
43	{
44	usage:
45
46	fprintf(stderr,"Usage: router <start-lat> <start-lon> <finish-lat> <finish-lon>\n"
47	" [--help] [--help-profile]\n"
48	" [--dir=<name>] [--prefix=<name>]\n"
49	" [--all] [--only-super]\n"
50	" [--no-print] [--quiet]\n"
51	" [--transport=<transport>]\n"
52	" [--not-highway=<highway> ...]\n"
53	" [--speed-<highway>=<speed> ...]\n"
54	" [--ignore-oneway]\n"
55	"\n"
56	"<transport> defaults to motorcar but can be set to:\n"
57	"%s"
58	"\n"
59	"<highway> can be selected from:\n"
60	"%s"
61	"\n"
62	"<speed> is a speed in km/hour\n"
63	"\n",
64	TransportList(),HighwayList());
65
66	return(1);
67	}
68
69	/* Get the transport type if specified and fill in the profile */
70
71	for(i=3;i<argc;i++)
72	if(!strncmp(argv[i],"--transport=",12))
73	{
74	transport=TransportType(&argv[i][12]);
75
76	if(transport==Transport_None)
77	goto usage;
78	}
79
80	if(transport==Transport_None)
81	transport=Transport_Motorcar;
82
83	profile=*GetProfile(transport);
84
85	/* Parse the other command line arguments */
86
87	while(--argc>=5)
88	{
89	if(!strcmp(argv[argc],"--help"))
90	goto usage;
91	else if(!strcmp(argv[argc],"--help-profile"))
92	help_profile=1;
93	else if(!strncmp(argv[argc],"--dir=",6))
94	dirname=&argv[argc][6];
95	else if(!strncmp(argv[argc],"--prefix=",9))
96	prefix=&argv[argc][9];
97	else if(!strcmp(argv[argc],"--all"))
98	all=1;
99	else if(!strcmp(argv[argc],"--only-super"))
100	only_super=1;
101	else if(!strcmp(argv[argc],"--no-print"))
102	no_print=1;
103	else if(!strcmp(argv[argc],"--quiet"))
104	option_quiet=1;
105	else if(!strncmp(argv[argc],"--transport=",12))
106	; /* Done this already*/
107	else if(!strncmp(argv[argc],"--not-highway=",14))
108	{
109	Highway highway=HighwayType(&argv[argc][14]);
110
111	if(highway==Way_Unknown)
112	goto usage;
113
114	profile.highways[highway]=0;
115	}
116	else if(!strncmp(argv[argc],"--speed-",8))
117	{
118	Highway highway;
119	char *equal=strchr(argv[argc],'=');
120	char *string;
121
122	if(!equal)
123	goto usage;
124
125	string=strcpy((char*)malloc(strlen(argv[argc])),argv[argc]+8);
126	string[equal-argv[argc]]=0;
127
128	highway=HighwayType(string);
129
130	free(string);
131
132	if(highway==Way_Unknown)
133	goto usage;
134
135	profile.speed[highway]=atoi(equal+1);
136	}
137	else if(!strcmp(argv[argc],"-ignore-oneway"))
138	profile.oneway=0;
139	else
140	goto usage;
141	}
142
143	if(help_profile)
144	{
145	PrintProfile(&profile);
146
147	return(0);
148	}
149
150	/* Load in the data */
151
152	filename=(char*)malloc((dirname?strlen(dirname):0)+(prefix?strlen(prefix):0)+16);
153
154	sprintf(filename,"%s%s%s%snodes.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":"");
155	OSMNodes=LoadNodeList(filename);
156
157	if(!OSMNodes)
158	{
159	fprintf(stderr,"Cannot open nodes file '%s'.\n",filename);
160	return(1);
161	}
162
163	sprintf(filename,"%s%s%s%ssegments.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":"");
164	OSMSegments=LoadSegmentList(filename);
165
166	if(!OSMSegments)
167	{
168	fprintf(stderr,"Cannot open segments file '%s'.\n",filename);
169	return(1);
170	}
171
172	sprintf(filename,"%s%s%s%sways.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":"");
173	OSMWays=LoadWayList(filename);
174
175	if(!OSMWays)
176	{
177	fprintf(stderr,"Cannot open ways file '%s'.\n",filename);
178	return(1);
179	}
180
181	/* Get the start and finish */
182
183	{
184	float lat_start =atof(argv[1]);
185	float lon_start =atof(argv[2]);
186	float lat_finish=atof(argv[3]);
187	float lon_finish=atof(argv[4]);
188
189	Node *start_node =FindNode(OSMNodes,lat_start ,lon_start );
190	Node *finish_node=FindNode(OSMNodes,lat_finish,lon_finish);
191
192	if(!start_node)
193	{
194	fprintf(stderr,"Cannot find start node.\n");
195	return(1);
196	}
197
198	if(!finish_node)
199	{
200	fprintf(stderr,"Cannot find finish node.\n");
201	return(1);
202	}
203
204	if(!option_quiet)
205	{
206	float lat,lon;
207	distance_t dist;
208
209	GetLatLong(OSMNodes,start_node,&lat,&lon);
210	dist=Distance(lat_start,lon_start,lat,lon);
211
212	printf("Start node : %3.6f %4.6f = %2.3f km\n",lat,lon,distance_to_km(dist));
213
214	GetLatLong(OSMNodes,finish_node,&lat,&lon);
215	dist=Distance(lat_finish,lon_finish,lat,lon);
216
217	printf("Finish node: %3.6f %4.6f = %2.3f km\n",lat,lon,distance_to_km(dist));
218	}
219
220	start =IndexNode(OSMNodes,start_node );
221	finish=IndexNode(OSMNodes,finish_node);
222	}
223
224	/* Calculate the route. */
225
226	if(all)
227	{
228	Results *results;
229
230	/* Calculate the route */
231
232	results=FindRoute(OSMNodes,OSMSegments,OSMWays,start,finish,&profile,all);
233
234	/* Print the route */
235
236	if(!results)
237	{
238	fprintf(stderr,"No route found.\n");
239	return(1);
240	}
241	else if(!no_print)
242	PrintRoute(results,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
243	}
244	else
245	{
246	Results begin,end;
247
248	/* Calculate the beginning of the route */
249
250	if(IsSuperNode(LookupNode(OSMNodes,start)))
251	{
252	Result *result;
253
254	begin=NewResultsList(1);
255
256	result=InsertResult(begin,start);
257
258	result->node=start;
259	result->shortest.prev=0;
260	result->shortest.next=0;
261	result->shortest.distance=0;
262	result->shortest.duration=0;
263	result->quickest.prev=0;
264	result->quickest.next=0;
265	result->quickest.distance=0;
266	result->quickest.duration=0;
267	}
268	else
269	begin=FindRoutes(OSMNodes,OSMSegments,OSMWays,start,&profile);
270
271	if(FindResult(begin,finish))
272	{
273	/* Print the route */
274
275	if(!no_print)
276	PrintRoute(begin,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
277	}
278	else
279	{
280	Results *superresults;
281
282	/* Calculate the end of the route */
283
284	if(IsSuperNode(LookupNode(OSMNodes,finish)))
285	{
286	Result *result;
287
288	end=NewResultsList(1);
289
290	result=InsertResult(end,finish);
291
292	result->node=finish;
293	result->shortest.prev=0;
294	result->shortest.next=0;
295	result->shortest.distance=0;
296	result->shortest.duration=0;
297	result->quickest.prev=0;
298	result->quickest.next=0;
299	result->quickest.distance=0;
300	result->quickest.duration=0;
301	}
302	else
303	end=FindReverseRoutes(OSMNodes,OSMSegments,OSMWays,finish,&profile);
304
305	/* Calculate the middle of the route */
306
307	superresults=FindRoute3(OSMNodes,OSMSegments,OSMWays,start,finish,begin,end,&profile);
308
309	/* Print the route */
310
311	if(!superresults)
312	{
313	fprintf(stderr,"No route found.\n");
314	return(1);
315	}
316	else if(!no_print)
317	{
318	if(only_super)
319	{
320	PrintRoute(superresults,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
321	}
322	else
323	{
324	Results *results=CombineRoutes(superresults,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
325
326	PrintRoute(results,OSMNodes,OSMSegments,OSMWays,start,finish,&profile);
327	}
328	}
329	}
330	}
331
332	return(0);
333	}