trunk/src/planetsplitter.c

/***************************************
 $Header: /home/amb/CVS/routino/src/planetsplitter.c,v 1.74 2010-07-12 17:59:41 amb Exp $

 OSM planet file splitter.

 Part of the Routino routing software.
 ******************/ /******************
 This file Copyright 2008-2010 Andrew M. Bishop

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Affero General Public License for more details.

 You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ***************************************/


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

#include "types.h"
#include "ways.h"

#include "typesx.h"
#include "nodesx.h"
#include "segmentsx.h"
#include "waysx.h"
#include "superx.h"

#include "files.h"
#include "functions.h"
#include "functionsx.h"
#include "tagging.h"


/* Global variables */

/*+ The option to use a slim mode with file-backed read-only intermediate storage. +*/
int option_slim=0;

/*+ The name of the temporary directory. +*/
char *option_tmpdirname=NULL;

/*+ The amount of RAM to use for filesorting. +*/
size_t option_filesort_ramsize=0;


/* Local functions */

static void print_usage(int detail);


/*++++++++++++++++++++++++++++++++++++++
  The main program for the planetsplitter.
  ++++++++++++++++++++++++++++++++++++++*/

int main(int argc,char** argv)
{
 NodesX    *Nodes;
 SegmentsX *Segments,*SuperSegments=NULL,*MergedSegments=NULL;
 WaysX     *Ways;
 int        iteration=0,quit=0;
 int        max_iterations=10;
 char      *dirname=NULL,*prefix=NULL,*tagging=NULL;
 int        option_parse_only=0,option_process_only=0;
 int        option_filenames=0;
 int        arg;

 /* Parse the command line arguments */

 for(arg=1;arg<argc;arg++)
   {
    if(!strcmp(argv[arg],"--help"))
       print_usage(1);
    else if(!strcmp(argv[arg],"--slim"))
       option_slim=1;
    else if(!strncmp(argv[arg],"--sort-ram-size=",16))
       option_filesort_ramsize=atoi(&argv[arg][16]);
    else if(!strncmp(argv[arg],"--dir=",6))
       dirname=&argv[arg][6];
    else if(!strncmp(argv[arg],"--tmpdir=",9))
       option_tmpdirname=&argv[arg][9];
    else if(!strncmp(argv[arg],"--prefix=",9))
       prefix=&argv[arg][9];
    else if(!strcmp(argv[arg],"--parse-only"))
       option_parse_only=1;
    else if(!strcmp(argv[arg],"--process-only"))
       option_process_only=1;
    else if(!strncmp(argv[arg],"--max-iterations=",17))
       max_iterations=atoi(&argv[arg][17]);
    else if(!strncmp(argv[arg],"--tagging=",10))
       tagging=&argv[arg][10];
    else if(argv[arg][0]=='-' && argv[arg][1]=='-')
       print_usage(0);
    else
       option_filenames++;
   }

 /* Check the specified command line options */

 if(option_parse_only && option_process_only)
    print_usage(0);

 if(option_filenames && option_process_only)
    print_usage(0);

 if(!option_filesort_ramsize)
   {
    if(option_slim)
       option_filesort_ramsize=64*1024*1024;
    else
       option_filesort_ramsize=256*1024*1024;
   }
 else
    option_filesort_ramsize*=1024*1024;

 if(!option_tmpdirname)
   {
    if(!dirname)
       option_tmpdirname=".";
    else
       option_tmpdirname=dirname;
   }

 if(tagging && ExistsFile(tagging))
    ;
 else if(!tagging && ExistsFile(FileName(dirname,prefix,"tagging.xml")))
    tagging=FileName(dirname,prefix,"tagging.xml");

 if(tagging && ParseXMLTaggingRules(tagging))
   {
    fprintf(stderr,"Error: Cannot read the tagging rules in the file '%s'.\n",tagging);
    return(1);
   }

 if(!tagging)
   {
    fprintf(stderr,"Error: Cannot run without reading some tagging rules.\n");
    return(1);
   }

 /* Create new node, segment and way variables */

 Nodes=NewNodeList(option_parse_only||option_process_only);

 Segments=NewSegmentList(option_parse_only||option_process_only);

 Ways=NewWayList(option_parse_only||option_process_only);

 /* Parse the file */

 if(option_filenames)
   {
    for(arg=1;arg<argc;arg++)
      {
       FILE *file;

       if(argv[arg][0]=='-' && argv[arg][1]=='-')
          continue;

       file=fopen(argv[arg],"rb");

       if(!file)
         {
          fprintf(stderr,"Cannot open file '%s' for reading [%s].\n",argv[arg],strerror(errno));
          exit(EXIT_FAILURE);
         }

       printf("\nParse OSM Data [%s]\n==============\n\n",argv[arg]);
       fflush(stdout);

       if(ParseOSM(file,Nodes,Segments,Ways))
          exit(EXIT_FAILURE);

       fclose(file);
      }
   }
 else if(!option_process_only)
   {
    printf("\nParse OSM Data\n==============\n\n");
    fflush(stdout);

    if(ParseOSM(stdin,Nodes,Segments,Ways))
       exit(EXIT_FAILURE);
   }

 if(option_parse_only)
   {
    FreeNodeList(Nodes,1);
    FreeSegmentList(Segments,1);
    FreeWayList(Ways,1);

    return(0);
   }

 /* Process the data */

 printf("\nProcess OSM Data\n================\n\n");
 fflush(stdout);

 /* Sort the nodes, segments and ways */

 SortNodeList(Nodes);

 SortSegmentList(Segments);

 SortWayList(Ways);

 /* Remove bad segments (must be after sorting the nodes and segments) */

 RemoveBadSegments(Nodes,Segments);

 /* Remove non-highway nodes (must be after removing the bad segments) */

 RemoveNonHighwayNodes(Nodes,Segments);

 /* Measure the segments and replace node/way id with index (must be after removing non-highway nodes) */

 UpdateSegments(Segments,Nodes,Ways);


 /* Repeated iteration on Super-Nodes and Super-Segments */

 do
   {
    printf("\nProcess Super-Data (iteration %d)\n================================%s\n\n",iteration,iteration>9?"=":"");
    fflush(stdout);

    if(iteration==0)
      {
       /* Select the super-nodes */

       ChooseSuperNodes(Nodes,Segments,Ways);

       /* Select the super-segments */

       SuperSegments=CreateSuperSegments(Nodes,Segments,Ways,iteration);
      }
    else
      {
       SegmentsX *SuperSegments2;

       /* Select the super-nodes */

       ChooseSuperNodes(Nodes,SuperSegments,Ways);

       /* Select the super-segments */

       SuperSegments2=CreateSuperSegments(Nodes,SuperSegments,Ways,iteration);

       if(SuperSegments->xnumber==SuperSegments2->xnumber)
          quit=1;

       FreeSegmentList(SuperSegments,0);

       SuperSegments=SuperSegments2;
      }

    /* Sort the super-segments */

    SortSegmentList(SuperSegments);

    /* Remove duplicated super-segments */

    DeduplicateSegments(SuperSegments,Nodes,Ways);

    iteration++;

    if(iteration>max_iterations)
       quit=1;
   }
 while(!quit);

 /* Combine the super-segments */

 printf("\nCombine Segments and Super-Segments\n===================================\n\n");
 fflush(stdout);

 /* Merge the super-segments */

 MergedSegments=MergeSuperSegments(Segments,SuperSegments);

 FreeSegmentList(Segments,0);

 FreeSegmentList(SuperSegments,0);

 Segments=MergedSegments;

 /* Rotate segments so that node1<node2 */

 RotateSegments(Segments);

 /* Sort the segments */

 SortSegmentList(Segments);

 /* Remove duplicated segments */

 DeduplicateSegments(Segments,Nodes,Ways);

 /* Cross reference the nodes and segments */

 printf("\nCross-Reference Nodes and Segments\n==================================\n\n");
 fflush(stdout);

 /* Sort the node list geographically */

 SortNodeListGeographically(Nodes);

 /* Create the real segments and nodes */

 CreateRealNodes(Nodes,iteration);

 CreateRealSegments(Segments,Ways);

 /* Fix the segment and node indexes */

 IndexNodes(Nodes,Segments);

 IndexSegments(Segments,Nodes);

 /* Output the results */

 printf("\nWrite Out Database Files\n========================\n\n");
 fflush(stdout);

 /* Write out the nodes */

 SaveNodeList(Nodes,FileName(dirname,prefix,"nodes.mem"));

 FreeNodeList(Nodes,0);

 /* Write out the segments */

 SaveSegmentList(Segments,FileName(dirname,prefix,"segments.mem"));

 FreeSegmentList(Segments,0);

 /* Write out the ways */

 SaveWayList(Ways,FileName(dirname,prefix,"ways.mem"));

 FreeWayList(Ways,0);

 return(0);
}


/*++++++++++++++++++++++++++++++++++++++
  Print out the usage information.

  int detail The level of detail to use - 0 = low, 1 = high.
  ++++++++++++++++++++++++++++++++++++++*/

static void print_usage(int detail)
{
 fprintf(stderr,
         "Usage: planetsplitter [--help]\n"
         "                      [--dir=<dirname>] [--prefix=<name>]\n"
         "                      [--slim] [--sort-ram-size=<size>]\n"
         "                      [--tmpdir=<dirname>]\n"
         "                      [--parse-only | --process-only]\n"
         "                      [--max-iterations=<number>]\n"
         "                      [--tagging=<filename>]\n"
         "                      [<filename.osm> ...]\n");

 if(detail)
    fprintf(stderr,
            "\n"
            "--help                    Prints this information.\n"
            "\n"
            "--dir=<dirname>           The directory containing the routing database.\n"
            "--prefix=<name>           The filename prefix for the routing database.\n"
            "\n"
            "--slim                    Use less RAM and more temporary files.\n"
            "--sort-ram-size=<size>    The amount of RAM (in MB) to use for data sorting\n"
            "                          (defaults to 64MB with '--slim' or 256MB otherwise.)\n"
            "--tmpdir=<dirname>        The directory name for temporary files.\n"
            "                          (defaults to the '--dir' option directory.)\n"
            "\n"
            "--parse-only              Parse the input OSM files and store the results.\n"
            "--process-only            Process the stored results from previous option.\n"
            "\n"
            "--max-iterations=<number> The number of iterations for finding super-nodes.\n"
            "\n"
            "--tagging=<filename>      The name of the XML file containing the tagging rules\n"
            "                          (defaults to 'tagging.xml' with '--dirname' and\n"
            "                           '--prefix' options).\n"
            "\n"
            "<filename.osm> ...        The name(s) of the file(s) to process (by default\n"
            "                          data is read from standard input).\n"
            "\n"
            "<transport> defaults to all but can be set to:\n"
            "%s"
            "\n"
            "<highway> can be selected from:\n"
            "%s"
            "\n"
            "<property> can be selected from:\n"
            "%s",
            TransportList(),HighwayList(),PropertyList());

 exit(!detail);
}
1	amb	2	/***************************************
2	amb	449	$Header: /home/amb/CVS/routino/src/planetsplitter.c,v 1.74 2010-07-12 17:59:41 amb Exp $
3	amb	2
4			OSM planet file splitter.
5	amb	151
6			Part of the Routino routing software.
7	amb	2	****************/ /****************
8	amb	326	This file Copyright 2008-2010 Andrew M. Bishop
9	amb	2
10	amb	151	This program is free software: you can redistribute it and/or modify
11			it under the terms of the GNU Affero General Public License as published by
12			the Free Software Foundation, either version 3 of the License, or
13			(at your option) any later version.
14
15			This program is distributed in the hope that it will be useful,
16			but WITHOUT ANY WARRANTY; without even the implied warranty of
17			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			GNU Affero General Public License for more details.
19
20			You should have received a copy of the GNU Affero General Public License
21			along with this program. If not, see <http://www.gnu.org/licenses/>.
22	amb	2	***************************************/
23
24
25			#include <stdio.h>
26			#include <stdlib.h>
27	amb	60	#include <string.h>
28	amb	330	#include <errno.h>
29	amb	2
30	amb	449	#include "types.h"
31			#include "ways.h"
32
33	amb	199	#include "typesx.h"
34	amb	109	#include "nodesx.h"
35			#include "segmentsx.h"
36			#include "waysx.h"
37			#include "superx.h"
38	amb	449
39			#include "files.h"
40			#include "functions.h"
41			#include "functionsx.h"
42	amb	395	#include "tagging.h"
43	amb	2
44
45	amb	395	/* Global variables */
46	amb	284
47	amb	249	/+ The option to use a slim mode with file-backed read-only intermediate storage. +/
48			int option_slim=0;
49
50	amb	256	/+ The name of the temporary directory. +/
51	amb	284	char *option_tmpdirname=NULL;
52	amb	249
53	amb	358	/+ The amount of RAM to use for filesorting. +/
54			size_t option_filesort_ramsize=0;
55	amb	284
56	amb	358
57	amb	342	/* Local functions */
58
59			static void print_usage(int detail);
60
61
62			/*++++++++++++++++++++++++++++++++++++++
63	amb	395	The main program for the planetsplitter.
64	amb	342	++++++++++++++++++++++++++++++++++++++*/
65
66	amb	2	int main(int argc,char** argv)
67			{
68	amb	327	NodesX *Nodes;
69	amb	256	SegmentsX Segments,SuperSegments=NULL,*MergedSegments=NULL;
70	amb	327	WaysX *Ways;
71			int iteration=0,quit=0;
72			int max_iterations=10;
73	amb	395	char dirname=NULL,prefix=NULL,*tagging=NULL;
74	amb	327	int option_parse_only=0,option_process_only=0;
75			int option_filenames=0;
76	amb	398	int arg;
77	amb	26
78	amb	82	/* Parse the command line arguments */
79
80	amb	327	for(arg=1;arg<argc;arg++)
81	amb	60	{
82	amb	327	if(!strcmp(argv[arg],"--help"))
83	amb	342	print_usage(1);
84	amb	327	else if(!strcmp(argv[arg],"--slim"))
85	amb	249	option_slim=1;
86	amb	358	else if(!strncmp(argv[arg],"--sort-ram-size=",16))
87			option_filesort_ramsize=atoi(&argv[arg][16]);
88	amb	327	else if(!strncmp(argv[arg],"--dir=",6))
89			dirname=&argv[arg][6];
90			else if(!strncmp(argv[arg],"--tmpdir=",9))
91			option_tmpdirname=&argv[arg][9];
92			else if(!strncmp(argv[arg],"--prefix=",9))
93			prefix=&argv[arg][9];
94			else if(!strcmp(argv[arg],"--parse-only"))
95	amb	326	option_parse_only=1;
96	amb	327	else if(!strcmp(argv[arg],"--process-only"))
97	amb	326	option_process_only=1;
98	amb	327	else if(!strncmp(argv[arg],"--max-iterations=",17))
99			max_iterations=atoi(&argv[arg][17]);
100	amb	395	else if(!strncmp(argv[arg],"--tagging=",10))
101			tagging=&argv[arg][10];
102	amb	327	else if(argv[arg][0]=='-' && argv[arg][1]=='-')
103	amb	342	print_usage(0);
104	amb	327	else
105			option_filenames++;
106	amb	60	}
107	amb	26
108	amb	395	/* Check the specified command line options */
109
110	amb	326	if(option_parse_only && option_process_only)
111	amb	342	print_usage(0);
112	amb	326
113	amb	327	if(option_filenames && option_process_only)
114	amb	342	print_usage(0);
115	amb	327
116	amb	358	if(!option_filesort_ramsize)
117			{
118			if(option_slim)
119			option_filesort_ramsize=6410241024;
120			else
121			option_filesort_ramsize=25610241024;
122			}
123			else
124			option_filesort_ramsize=10241024;
125
126	amb	284	if(!option_tmpdirname)
127	amb	252	{
128			if(!dirname)
129	amb	284	option_tmpdirname=".";
130	amb	252	else
131	amb	284	option_tmpdirname=dirname;
132	amb	252	}
133
134	amb	395	if(tagging && ExistsFile(tagging))
135			;
136			else if(!tagging && ExistsFile(FileName(dirname,prefix,"tagging.xml")))
137			tagging=FileName(dirname,prefix,"tagging.xml");
138
139			if(tagging && ParseXMLTaggingRules(tagging))
140			{
141			fprintf(stderr,"Error: Cannot read the tagging rules in the file '%s'.\n",tagging);
142			return(1);
143			}
144
145			if(!tagging)
146			{
147			fprintf(stderr,"Error: Cannot run without reading some tagging rules.\n");
148			return(1);
149			}
150
151	amb	275	/* Create new node, segment and way variables */
152	amb	82
153	amb	326	Nodes=NewNodeList(option_parse_only\|\|option_process_only);
154	amb	275
155	amb	326	Segments=NewSegmentList(option_parse_only\|\|option_process_only);
156	amb	275
157	amb	326	Ways=NewWayList(option_parse_only\|\|option_process_only);
158	amb	26
159	amb	89	/* Parse the file */
160	amb	2
161	amb	327	if(option_filenames)
162	amb	326	{
163	amb	327	for(arg=1;arg<argc;arg++)
164			{
165			FILE *file;
166
167			if(argv[arg][0]=='-' && argv[arg][1]=='-')
168			continue;
169
170			file=fopen(argv[arg],"rb");
171
172			if(!file)
173			{
174	amb	330	fprintf(stderr,"Cannot open file '%s' for reading [%s].\n",argv[arg],strerror(errno));
175	amb	327	exit(EXIT_FAILURE);
176			}
177
178			printf("\nParse OSM Data [%s]\n==============\n\n",argv[arg]);
179			fflush(stdout);
180
181	amb	398	if(ParseOSM(file,Nodes,Segments,Ways))
182	amb	395	exit(EXIT_FAILURE);
183	amb	327
184			fclose(file);
185			}
186			}
187			else if(!option_process_only)
188			{
189	amb	326	printf("\nParse OSM Data\n==============\n\n");
190			fflush(stdout);
191	amb	2
192	amb	398	if(ParseOSM(stdin,Nodes,Segments,Ways))
193	amb	395	exit(EXIT_FAILURE);
194	amb	326	}
195	amb	80
196	amb	326	if(option_parse_only)
197			{
198			FreeNodeList(Nodes,1);
199			FreeSegmentList(Segments,1);
200			FreeWayList(Ways,1);
201
202			return(0);
203			}
204
205	amb	229	/* Process the data */
206
207			printf("\nProcess OSM Data\n================\n\n");
208	amb	227	fflush(stdout);
209	amb	8
210	amb	275	/* Sort the nodes, segments and ways */
211	amb	263
212			SortNodeList(Nodes);
213
214	amb	275	SortSegmentList(Segments);
215	amb	80
216	amb	256	SortWayList(Ways);
217	amb	87
218	amb	279	/* Remove bad segments (must be after sorting the nodes and segments) */
219	amb	247
220	amb	256	RemoveBadSegments(Nodes,Segments);
221	amb	87
222	amb	247	/* Remove non-highway nodes (must be after removing the bad segments) */
223	amb	66
224	amb	256	RemoveNonHighwayNodes(Nodes,Segments);
225	amb	247
226	amb	279	/* Measure the segments and replace node/way id with index (must be after removing non-highway nodes) */
227	amb	247
228	amb	279	UpdateSegments(Segments,Nodes,Ways);
229	amb	66
230
231	amb	258	/* Repeated iteration on Super-Nodes and Super-Segments */
232	amb	58
233			do
234			{
235	amb	229	printf("\nProcess Super-Data (iteration %d)\n================================%s\n\n",iteration,iteration>9?"=":"");
236	amb	227	fflush(stdout);
237	amb	80
238	amb	90	if(iteration==0)
239			{
240			/* Select the super-nodes */
241	amb	58
242	amb	256	ChooseSuperNodes(Nodes,Segments,Ways);
243	amb	58
244	amb	90	/* Select the super-segments */
245	amb	58
246	amb	256	SuperSegments=CreateSuperSegments(Nodes,Segments,Ways,iteration);
247	amb	90	}
248			else
249			{
250	amb	97	SegmentsX *SuperSegments2;
251	amb	58
252	amb	90	/* Select the super-nodes */
253
254	amb	256	ChooseSuperNodes(Nodes,SuperSegments,Ways);
255	amb	90
256			/* Select the super-segments */
257
258	amb	256	SuperSegments2=CreateSuperSegments(Nodes,SuperSegments,Ways,iteration);
259	amb	90
260	amb	282	if(SuperSegments->xnumber==SuperSegments2->xnumber)
261	amb	104	quit=1;
262
263	amb	326	FreeSegmentList(SuperSegments,0);
264	amb	90
265	amb	97	SuperSegments=SuperSegments2;
266	amb	90	}
267
268	amb	275	/* Sort the super-segments */
269	amb	58
270	amb	275	SortSegmentList(SuperSegments);
271	amb	58
272	amb	229	/* Remove duplicated super-segments */
273
274	amb	279	DeduplicateSegments(SuperSegments,Nodes,Ways);
275	amb	229
276	amb	89	iteration++;
277	amb	58
278	amb	89	if(iteration>max_iterations)
279			quit=1;
280			}
281			while(!quit);
282	amb	58
283	amb	229	/* Combine the super-segments */
284
285			printf("\nCombine Segments and Super-Segments\n===================================\n\n");
286	amb	227	fflush(stdout);
287	amb	58
288	amb	104	/* Merge the super-segments */
289
290	amb	256	MergedSegments=MergeSuperSegments(Segments,SuperSegments);
291	amb	104
292	amb	326	FreeSegmentList(Segments,0);
293	amb	256
294	amb	326	FreeSegmentList(SuperSegments,0);
295	amb	58
296	amb	256	Segments=MergedSegments;
297	amb	90
298	amb	275	/* Rotate segments so that node1<node2 */
299	amb	256
300	amb	275	RotateSegments(Segments);
301	amb	256
302	amb	275	/* Sort the segments */
303	amb	258
304	amb	275	SortSegmentList(Segments);
305	amb	258
306	amb	275	/* Remove duplicated segments */
307
308	amb	279	DeduplicateSegments(Segments,Nodes,Ways);
309	amb	275
310	amb	229	/* Cross reference the nodes and segments */
311	amb	90
312	amb	229	printf("\nCross-Reference Nodes and Segments\n==================================\n\n");
313			fflush(stdout);
314	amb	90
315	amb	212	/* Sort the node list geographically */
316	amb	209
317	amb	256	SortNodeListGeographically(Nodes);
318	amb	212
319			/* Create the real segments and nodes */
320
321	amb	256	CreateRealNodes(Nodes,iteration);
322	amb	212
323	amb	256	CreateRealSegments(Segments,Ways);
324	amb	209
325	amb	104	/* Fix the segment and node indexes */
326
327	amb	256	IndexNodes(Nodes,Segments);
328	amb	104
329	amb	256	IndexSegments(Segments,Nodes);
330	amb	104
331	amb	229	/* Output the results */
332
333			printf("\nWrite Out Database Files\n========================\n\n");
334			fflush(stdout);
335
336	amb	89	/* Write out the nodes */
337	amb	58
338	amb	256	SaveNodeList(Nodes,FileName(dirname,prefix,"nodes.mem"));
339	amb	95
340	amb	326	FreeNodeList(Nodes,0);
341	amb	226
342	amb	89	/* Write out the segments */
343	amb	58
344	amb	256	SaveSegmentList(Segments,FileName(dirname,prefix,"segments.mem"));
345	amb	58
346	amb	326	FreeSegmentList(Segments,0);
347	amb	226
348	amb	89	/* Write out the ways */
349	amb	58
350	amb	398	SaveWayList(Ways,FileName(dirname,prefix,"ways.mem"));
351	amb	58
352	amb	326	FreeWayList(Ways,0);
353	amb	226
354	amb	2	return(0);
355			}
356	amb	342
357
358			/*++++++++++++++++++++++++++++++++++++++
359			Print out the usage information.
360
361			int detail The level of detail to use - 0 = low, 1 = high.
362			++++++++++++++++++++++++++++++++++++++*/
363
364			static void print_usage(int detail)
365			{
366			fprintf(stderr,
367			"Usage: planetsplitter [--help]\n"
368			" [--dir=<dirname>] [--prefix=<name>]\n"
369	amb	358	" [--slim] [--sort-ram-size=<size>]\n"
370			" [--tmpdir=<dirname>]\n"
371	amb	342	" [--parse-only \| --process-only]\n"
372			" [--max-iterations=<number>]\n"
373	amb	395	" [--tagging=<filename>]\n"
374	amb	342	" [<filename.osm> ...]\n");
375
376			if(detail)
377			fprintf(stderr,
378			"\n"
379			"--help Prints this information.\n"
380			"\n"
381			"--dir=<dirname> The directory containing the routing database.\n"
382			"--prefix=<name> The filename prefix for the routing database.\n"
383			"\n"
384			"--slim Use less RAM and more temporary files.\n"
385	amb	358	"--sort-ram-size=<size> The amount of RAM (in MB) to use for data sorting\n"
386			" (defaults to 64MB with '--slim' or 256MB otherwise.)\n"
387	amb	342	"--tmpdir=<dirname> The directory name for temporary files.\n"
388	amb	358	" (defaults to the '--dir' option directory.)\n"
389	amb	342	"\n"
390			"--parse-only Parse the input OSM files and store the results.\n"
391			"--process-only Process the stored results from previous option.\n"
392			"\n"
393			"--max-iterations=<number> The number of iterations for finding super-nodes.\n"
394			"\n"
395	amb	395	"--tagging=<filename> The name of the XML file containing the tagging rules\n"
396			" (defaults to 'tagging.xml' with '--dirname' and\n"
397			" '--prefix' options).\n"
398			"\n"
399	amb	358	"<filename.osm> ... The name(s) of the file(s) to process (by default\n"
400			" data is read from standard input).\n"
401	amb	342	"\n"
402			"<transport> defaults to all but can be set to:\n"
403			"%s"
404			"\n"
405			"<highway> can be selected from:\n"
406			"%s"
407			"\n"
408			"<property> can be selected from:\n"
409			"%s",
410			TransportList(),HighwayList(),PropertyList());
411
412			exit(!detail);
413			}