trunk/src/planetsplitter.c

/***************************************
 $Header: /home/amb/CVS/routino/src/planetsplitter.c,v 1.17 2009-01-24 17:29:46 amb Exp $

 OSM planet file splitter.
 ******************/ /******************
 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 <stdlib.h>
#include <string.h>

#include "nodes.h"
#include "ways.h"
#include "segments.h"
#include "functions.h"


int main(int argc,char** argv)
{
 NodesMem *OSMNodesMem;
 SegmentsMem *OSMSegmentsMem;
 WaysMem *OSMWaysMem;
 NodesMem *SuperNodesMem,*SuperNodesMem2;
 SegmentsMem *SuperSegmentsMem,*SuperSegmentsMem2;
 WaysMem *SuperWaysMem,*SuperWaysMem2;
 Nodes *OSMNodes;
 Segments *OSMSegments;
 Ways *OSMWays;
 Nodes *SuperNodes,*SuperNodes2;
 Segments *SuperSegments,*SuperSegments2;
 Ways *SuperWays,*SuperWays2;
 int iteration=0,quit=0;
 int skip_parsing=0,max_iterations=5;
 Transport transport=0;
 int highways[Way_Unknown+1];
 int i;

 /* Parse the command line arguments */

 for(i=0;i<Way_Unknown;i++)
    highways[i]=1;

 highways[Way_Unknown]=0;

 while(--argc>=1)
   {
    if(!strcmp(argv[argc],"-help"))
       goto usage;
    else if(!strcmp(argv[argc],"-skip-parsing"))
       skip_parsing=1;
    else if(!strncmp(argv[argc],"-max-iterations=",16))
       max_iterations=atoi(&argv[argc][16]);
    else if(!strncmp(argv[argc],"-transport=",11))
       transport=TransportType(&argv[argc][11]);
    else if(!strncmp(argv[argc],"-not-highway=",13))
      {
       Highway highway=HighwayType(&argv[argc][13]);
       highways[highway]=0;
      }
    else
      {
      usage:

       fprintf(stderr,"Usage: planetsplitter\n"
                      "                      [-help]\n"
                      "                      [-skip-parsing]\n"
                      "                      [-max-iterations=<number>]\n"
                      "                      [-transport=<transport>]\n"
                      "                      [-not-highway=<highway> ...]\n"
                      "\n"
                      "<transport> can be:\n"
                      "%s"
                      "\n"
                      "<highway> can be:\n"
                      "%s",
                      TransportList(),HighwayList());

       return(1);
      }
   }

 if(!skip_parsing)
   {
    /* Create new variables */

    OSMNodesMem=NewNodeList();
    OSMSegmentsMem=NewSegmentList();
    OSMWaysMem=NewWayList();

    /* Parse the file */

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

    ParseXML(stdin,OSMNodesMem,OSMSegmentsMem,OSMWaysMem,transport,highways);

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

    /* Sort the variables */

    printf("Sorting All Nodes"); fflush(stdout);
    SortNodeList(OSMNodesMem);
    printf("\rSorted All Nodes \n"); fflush(stdout);

    printf("Sorting Segments"); fflush(stdout);
    SortSegmentList(OSMSegmentsMem);
    printf("\rSorted Segments \n"); fflush(stdout);

    printf("Sorting Ways"); fflush(stdout);
    SortWayList(OSMWaysMem);
    printf("\rSorted Ways \n"); fflush(stdout);

    /* Write out all the nodes */

    printf("Saving All Nodes"); fflush(stdout);
    OSMNodes=SaveNodeList(OSMNodesMem,"data/all-nodes.mem");
    printf("\rSaved All Nodes: %d\n",OSMNodes->number); fflush(stdout);

    /* Remove bad segments */

    RemoveBadSegments(OSMSegmentsMem);

    printf("Sorting Segments"); fflush(stdout);
    SortSegmentList(OSMSegmentsMem);
    printf("\rSorted Segments \n"); fflush(stdout);

    /* Fix the segment lengths */

    FixupSegmentLengths(OSMSegmentsMem,OSMNodes,OSMWays);

    /* Write out the segments */

    printf("Saving Segments"); fflush(stdout);
    OSMSegments=SaveSegmentList(OSMSegmentsMem,"data/segments.mem");
    printf("\rSaved Segments: %d\n",OSMSegments->number); fflush(stdout);

    /* Write out the ways */

    printf("Saving Ways"); fflush(stdout);
    OSMWays=SaveWayList(OSMWaysMem,"data/ways.mem");
    printf("\rSaved Ways: %d\n",OSMWays->number); fflush(stdout);

    /* Remove non-way nodes */

    OSMNodesMem=OnlyHighwayNodes(OSMNodes,OSMSegments);

    UnMapFile(OSMNodes);

    /* Sort the nodes */

    printf("Sorting Way Nodes"); fflush(stdout);
    SortNodeList(OSMNodesMem);
    printf("\rSorted Way Nodes \n"); fflush(stdout);

    /* Write out the nodes */

    printf("Saving Way Nodes"); fflush(stdout);
    OSMNodes=SaveNodeList(OSMNodesMem,"data/nodes.mem");
    printf("\rSaved Way Nodes: %d\n",OSMNodes->number); fflush(stdout);
   }
else
  {
   /* Load in the data */

   OSMNodes=LoadNodeList("data/nodes.mem");
   OSMSegments=LoadSegmentList("data/segments.mem");
   OSMWays=LoadWayList("data/ways.mem");
  }

 printf("\nProcessing Super-Data\n=====================\n\n"); fflush(stdout);

 /* Select the super-nodes */

 SuperNodesMem=ChooseSuperNodes(OSMNodes,OSMSegments,OSMWays);

 /* Sort the super-nodes */

 printf("Sorting Super-Nodes"); fflush(stdout);
 SortNodeList(SuperNodesMem);
 printf("\rSorted Super-Nodes \n"); fflush(stdout);

 /* Write out the super-nodes */

 printf("Saving Super-Nodes"); fflush(stdout);
 SuperNodes=SaveNodeList(SuperNodesMem,"data/super-nodes.mem");
 printf("\rSaved Super-Nodes: %d\n",SuperNodes->number); fflush(stdout);

 /* Select the super-segments */

 SuperSegmentsMem=CreateSuperSegments(OSMNodes,OSMSegments,OSMWays,SuperNodes);

 /* Sort the super-segments */

 printf("Sorting Super-Segments"); fflush(stdout);
 SortSegmentList(SuperSegmentsMem);
 printf("\rSorted Super-Segments \n"); fflush(stdout);

 /* Select the super-ways */

 SuperWaysMem=CreateSuperWays(OSMWays,SuperSegmentsMem);

 /* Write out the super-segments */

 printf("Saving Super-Segments"); fflush(stdout);
 SuperSegments=SaveSegmentList(SuperSegmentsMem,"data/super-segments.mem");
 printf("\rSaved Super-Segments: %d\n",SuperSegments->number); fflush(stdout);

 /* Sort the super-ways */

 printf("Sorting Super-Ways"); fflush(stdout);
 SortWayList(SuperWaysMem);
 printf("\rSorted Super-Ways \n"); fflush(stdout);

 /* Write out the super-ways */

 printf("Saving Super-Ways"); fflush(stdout);
 SuperWays=SaveWayList(SuperWaysMem,"data/super-ways.mem");
 printf("\rSaved Super-Ways: %d\n",SuperWays->number); fflush(stdout);

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

 UnMapFile(SuperNodes);
 UnMapFile(SuperSegments);
 UnMapFile(SuperWays);

 do
   {
    iteration++;

    if(iteration>max_iterations)
       break;

    /* Load the previous iteration */

    SuperNodes=LoadNodeList("data/super-nodes.mem");
    SuperWays=LoadWayList("data/super-ways.mem");
    SuperSegments=LoadSegmentList("data/super-segments.mem");

    printf("\nProcessing Super-Data (iteration %d)\n===================================%s\n\n",iteration,iteration>10?"=":""); fflush(stdout);

    /* Select the super-nodes */

    SuperNodesMem2=ChooseSuperNodes(SuperNodes,SuperSegments,SuperWays);

    /* Sort the super-nodes */

    printf("Sorting Super-Nodes"); fflush(stdout);
    SortNodeList(SuperNodesMem2);
    printf("\rSorted Super-Nodes \n"); fflush(stdout);

    /* Write out the super-nodes */

    printf("Saving Super-Nodes"); fflush(stdout);
    SuperNodes2=SaveNodeList(SuperNodesMem2,"data/super-nodes2.mem");
    printf("\rSaved Super-Nodes: %d\n",SuperNodes2->number); fflush(stdout);

    /* Select the super-segments */

    SuperSegmentsMem2=CreateSuperSegments(SuperNodes,SuperSegments,SuperWays,SuperNodes2);

    /* Sort the super-segments */

    printf("Sorting Super-Segments"); fflush(stdout);
    SortSegmentList(SuperSegmentsMem2);
    printf("\rSorted Super-Segments \n"); fflush(stdout);

    /* Select the super-ways */

    SuperWaysMem2=CreateSuperWays(SuperWays,SuperSegmentsMem2);

    /* Write out the super-segments */

    printf("Saving Super-Segments"); fflush(stdout);
    SuperSegments2=SaveSegmentList(SuperSegmentsMem2,"data/super-segments2.mem");
    printf("\rSaved Super-Segments: %d\n",SuperSegments2->number); fflush(stdout);

    /* Sort the super-ways */

    printf("Sorting Super-Ways"); fflush(stdout);
    SortWayList(SuperWaysMem2);
    printf("\rSorted Super-Ways \n"); fflush(stdout);

    /* Write out the super-ways */

    printf("Saving Super-Ways"); fflush(stdout);
    SuperWays2=SaveWayList(SuperWaysMem2,"data/super-ways2.mem");
    printf("\rSaved Super-Ways: %d\n",SuperWays2->number); fflush(stdout);

    /* Decide when to quit */

    quit=0;
    if(SuperNodes2->number>(0.999*SuperNodes->number))       quit=1;
    if(SuperSegments2->number>(0.999*SuperSegments->number)) quit=1;

    /* Unmap the data and Rename the files */

    UnMapFile(SuperNodes);
    UnMapFile(SuperSegments);
    UnMapFile(SuperWays);

    UnMapFile(SuperNodes2);
    UnMapFile(SuperSegments2);
    UnMapFile(SuperWays2);

    rename("data/super-nodes2.mem","data/super-nodes.mem");
    rename("data/super-segments2.mem","data/super-segments.mem");
    rename("data/super-ways2.mem","data/super-ways.mem");
   }
 while(!quit);

 UnMapFile(OSMNodes);
 UnMapFile(OSMSegments);
 UnMapFile(OSMWays);

 return(0);
}
1	amb	2	/***************************************
2	amb	80	$Header: /home/amb/CVS/routino/src/planetsplitter.c,v 1.17 2009-01-24 17:29:46 amb Exp $
3	amb	2
4			OSM planet file splitter.
5			****************/ /****************
6			Written by Andrew M. Bishop
7
8	amb	4	This file Copyright 2008,2009 Andrew M. Bishop
9	amb	2	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 <stdlib.h>
17	amb	60	#include <string.h>
18	amb	2
19	amb	26	#include "nodes.h"
20			#include "ways.h"
21			#include "segments.h"
22	amb	2	#include "functions.h"
23
24
25			int main(int argc,char** argv)
26			{
27	amb	26	NodesMem *OSMNodesMem;
28	amb	66	SegmentsMem *OSMSegmentsMem;
29	amb	31	WaysMem *OSMWaysMem;
30	amb	58	NodesMem SuperNodesMem,SuperNodesMem2;
31			SegmentsMem SuperSegmentsMem,SuperSegmentsMem2;
32			WaysMem SuperWaysMem,SuperWaysMem2;
33	amb	26	Nodes *OSMNodes;
34	amb	66	Segments *OSMSegments;
35	amb	26	Ways *OSMWays;
36	amb	58	Nodes SuperNodes,SuperNodes2;
37			Segments SuperSegments,SuperSegments2;
38			Ways SuperWays,SuperWays2;
39			int iteration=0,quit=0;
40	amb	60	int skip_parsing=0,max_iterations=5;
41	amb	78	Transport transport=0;
42	amb	75	int highways[Way_Unknown+1];
43			int i;
44	amb	26
45	amb	60	/* Parse the command line arguments */
46	amb	31
47	amb	75	for(i=0;i<Way_Unknown;i++)
48			highways[i]=1;
49
50			highways[Way_Unknown]=0;
51
52	amb	60	while(--argc>=1)
53			{
54	amb	75	if(!strcmp(argv[argc],"-help"))
55			goto usage;
56			else if(!strcmp(argv[argc],"-skip-parsing"))
57	amb	60	skip_parsing=1;
58			else if(!strncmp(argv[argc],"-max-iterations=",16))
59			max_iterations=atoi(&argv[argc][16]);
60	amb	75	else if(!strncmp(argv[argc],"-transport=",11))
61			transport=TransportType(&argv[argc][11]);
62			else if(!strncmp(argv[argc],"-not-highway=",13))
63			{
64			Highway highway=HighwayType(&argv[argc][13]);
65			highways[highway]=0;
66			}
67	amb	60	else
68			{
69	amb	75	usage:
70
71			fprintf(stderr,"Usage: planetsplitter\n"
72			" [-help]\n"
73			" [-skip-parsing]\n"
74			" [-max-iterations=<number>]\n"
75			" [-transport=<transport>]\n"
76			" [-not-highway=<highway> ...]\n"
77			"\n"
78			"<transport> can be:\n"
79			"%s"
80			"\n"
81			"<highway> can be:\n"
82			"%s",
83			TransportList(),HighwayList());
84
85	amb	60	return(1);
86			}
87			}
88	amb	26
89	amb	60	if(!skip_parsing)
90			{
91			/* Create new variables */
92	amb	26
93	amb	60	OSMNodesMem=NewNodeList();
94	amb	66	OSMSegmentsMem=NewSegmentList();
95	amb	60	OSMWaysMem=NewWayList();
96	amb	2
97	amb	60	/* Parse the file */
98	amb	2
99	amb	80	printf("\nParsing OSM Data\n================\n\n"); fflush(stdout);
100
101	amb	75	ParseXML(stdin,OSMNodesMem,OSMSegmentsMem,OSMWaysMem,transport,highways);
102	amb	8
103	amb	80	printf("\nProcessing OSM Data\n===================\n\n"); fflush(stdout);
104
105	amb	60	/* Sort the variables */
106	amb	8
107	amb	60	printf("Sorting All Nodes"); fflush(stdout);
108			SortNodeList(OSMNodesMem);
109			printf("\rSorted All Nodes \n"); fflush(stdout);
110	amb	8
111	amb	66	printf("Sorting Segments"); fflush(stdout);
112			SortSegmentList(OSMSegmentsMem);
113			printf("\rSorted Segments \n"); fflush(stdout);
114
115	amb	60	printf("Sorting Ways"); fflush(stdout);
116			SortWayList(OSMWaysMem);
117			printf("\rSorted Ways \n"); fflush(stdout);
118	amb	8
119	amb	66	/* Write out all the nodes */
120	amb	26
121	amb	60	printf("Saving All Nodes"); fflush(stdout);
122			OSMNodes=SaveNodeList(OSMNodesMem,"data/all-nodes.mem");
123			printf("\rSaved All Nodes: %d\n",OSMNodes->number); fflush(stdout);
124	amb	26
125	amb	60	/* Remove bad segments */
126	amb	41
127	amb	60	RemoveBadSegments(OSMSegmentsMem);
128	amb	41
129	amb	60	printf("Sorting Segments"); fflush(stdout);
130			SortSegmentList(OSMSegmentsMem);
131			printf("\rSorted Segments \n"); fflush(stdout);
132	amb	41
133	amb	66	/* Fix the segment lengths */
134
135			FixupSegmentLengths(OSMSegmentsMem,OSMNodes,OSMWays);
136
137			/* Write out the segments */
138
139			printf("Saving Segments"); fflush(stdout);
140			OSMSegments=SaveSegmentList(OSMSegmentsMem,"data/segments.mem");
141			printf("\rSaved Segments: %d\n",OSMSegments->number); fflush(stdout);
142
143			/* Write out the ways */
144
145			printf("Saving Ways"); fflush(stdout);
146			OSMWays=SaveWayList(OSMWaysMem,"data/ways.mem");
147			printf("\rSaved Ways: %d\n",OSMWays->number); fflush(stdout);
148
149	amb	60	/* Remove non-way nodes */
150	amb	41
151	amb	66	OSMNodesMem=OnlyHighwayNodes(OSMNodes,OSMSegments);
152	amb	41
153	amb	60	UnMapFile(OSMNodes);
154	amb	41
155	amb	66	/* Sort the nodes */
156
157	amb	60	printf("Sorting Way Nodes"); fflush(stdout);
158			SortNodeList(OSMNodesMem);
159			printf("\rSorted Way Nodes \n"); fflush(stdout);
160	amb	41
161	amb	66	/* Write out the nodes */
162
163	amb	60	printf("Saving Way Nodes"); fflush(stdout);
164			OSMNodes=SaveNodeList(OSMNodesMem,"data/nodes.mem");
165			printf("\rSaved Way Nodes: %d\n",OSMNodes->number); fflush(stdout);
166			}
167			else
168			{
169			/* Load in the data */
170	amb	26
171	amb	60	OSMNodes=LoadNodeList("data/nodes.mem");
172	amb	66	OSMSegments=LoadSegmentList("data/segments.mem");
173	amb	60	OSMWays=LoadWayList("data/ways.mem");
174			}
175	amb	26
176	amb	80	printf("\nProcessing Super-Data\n=====================\n\n"); fflush(stdout);
177
178	amb	33	/* Select the super-nodes */
179	amb	31
180	amb	33	SuperNodesMem=ChooseSuperNodes(OSMNodes,OSMSegments,OSMWays);
181	amb	31
182	amb	33	/* Sort the super-nodes */
183	amb	31
184	amb	80	printf("Sorting Super-Nodes"); fflush(stdout);
185	amb	33	SortNodeList(SuperNodesMem);
186	amb	80	printf("\rSorted Super-Nodes \n"); fflush(stdout);
187	amb	31
188	amb	66	/* Write out the super-nodes */
189	amb	31
190	amb	80	printf("Saving Super-Nodes"); fflush(stdout);
191	amb	33	SuperNodes=SaveNodeList(SuperNodesMem,"data/super-nodes.mem");
192	amb	80	printf("\rSaved Super-Nodes: %d\n",SuperNodes->number); fflush(stdout);
193	amb	31
194	amb	26	/* Select the super-segments */
195
196	amb	76	SuperSegmentsMem=CreateSuperSegments(OSMNodes,OSMSegments,OSMWays,SuperNodes);
197	amb	15
198	amb	66	/* Sort the super-segments */
199	amb	15
200	amb	80	printf("Sorting Super-Segments"); fflush(stdout);
201	amb	26	SortSegmentList(SuperSegmentsMem);
202	amb	80	printf("\rSorted Super-Segments \n"); fflush(stdout);
203	amb	15
204	amb	54	/* Select the super-ways */
205
206			SuperWaysMem=CreateSuperWays(OSMWays,SuperSegmentsMem);
207
208	amb	66	/* Write out the super-segments */
209	amb	54
210	amb	80	printf("Saving Super-Segments"); fflush(stdout);
211	amb	66	SuperSegments=SaveSegmentList(SuperSegmentsMem,"data/super-segments.mem");
212	amb	80	printf("\rSaved Super-Segments: %d\n",SuperSegments->number); fflush(stdout);
213	amb	66
214			/* Sort the super-ways */
215
216	amb	80	printf("Sorting Super-Ways"); fflush(stdout);
217	amb	54	SortWayList(SuperWaysMem);
218	amb	80	printf("\rSorted Super-Ways \n"); fflush(stdout);
219	amb	54
220	amb	66	/* Write out the super-ways */
221	amb	2
222	amb	80	printf("Saving Super-Ways"); fflush(stdout);
223	amb	54	SuperWays=SaveWayList(SuperWaysMem,"data/super-ways.mem");
224	amb	80	printf("\rSaved Super-Ways: %d\n",SuperWays->number); fflush(stdout);
225	amb	54
226	amb	58	/* Repeated iteration on Super-Nodes, Super-Segments and Super-Ways */
227
228			UnMapFile(SuperNodes);
229			UnMapFile(SuperSegments);
230			UnMapFile(SuperWays);
231
232			do
233			{
234			iteration++;
235
236	amb	60	if(iteration>max_iterations)
237	amb	58	break;
238
239	amb	66	/* Load the previous iteration */
240
241	amb	58	SuperNodes=LoadNodeList("data/super-nodes.mem");
242			SuperWays=LoadWayList("data/super-ways.mem");
243			SuperSegments=LoadSegmentList("data/super-segments.mem");
244
245	amb	80	printf("\nProcessing Super-Data (iteration %d)\n===================================%s\n\n",iteration,iteration>10?"=":""); fflush(stdout);
246
247	amb	58	/* Select the super-nodes */
248
249			SuperNodesMem2=ChooseSuperNodes(SuperNodes,SuperSegments,SuperWays);
250
251			/* Sort the super-nodes */
252
253	amb	80	printf("Sorting Super-Nodes"); fflush(stdout);
254	amb	58	SortNodeList(SuperNodesMem2);
255	amb	80	printf("\rSorted Super-Nodes \n"); fflush(stdout);
256	amb	58
257	amb	66	/* Write out the super-nodes */
258	amb	58
259	amb	80	printf("Saving Super-Nodes"); fflush(stdout);
260	amb	58	SuperNodes2=SaveNodeList(SuperNodesMem2,"data/super-nodes2.mem");
261	amb	80	printf("\rSaved Super-Nodes: %d\n",SuperNodes2->number); fflush(stdout);
262	amb	58
263			/* Select the super-segments */
264
265	amb	76	SuperSegmentsMem2=CreateSuperSegments(SuperNodes,SuperSegments,SuperWays,SuperNodes2);
266	amb	58
267	amb	66	/* Sort the super-segments */
268	amb	58
269	amb	80	printf("Sorting Super-Segments"); fflush(stdout);
270	amb	58	SortSegmentList(SuperSegmentsMem2);
271	amb	80	printf("\rSorted Super-Segments \n"); fflush(stdout);
272	amb	58
273			/* Select the super-ways */
274
275			SuperWaysMem2=CreateSuperWays(SuperWays,SuperSegmentsMem2);
276
277	amb	66	/* Write out the super-segments */
278	amb	58
279	amb	80	printf("Saving Super-Segments"); fflush(stdout);
280	amb	66	SuperSegments2=SaveSegmentList(SuperSegmentsMem2,"data/super-segments2.mem");
281	amb	80	printf("\rSaved Super-Segments: %d\n",SuperSegments2->number); fflush(stdout);
282	amb	66
283			/* Sort the super-ways */
284
285	amb	80	printf("Sorting Super-Ways"); fflush(stdout);
286	amb	58	SortWayList(SuperWaysMem2);
287	amb	80	printf("\rSorted Super-Ways \n"); fflush(stdout);
288	amb	58
289	amb	66	/* Write out the super-ways */
290	amb	58
291	amb	80	printf("Saving Super-Ways"); fflush(stdout);
292	amb	58	SuperWays2=SaveWayList(SuperWaysMem2,"data/super-ways2.mem");
293	amb	80	printf("\rSaved Super-Ways: %d\n",SuperWays2->number); fflush(stdout);
294	amb	58
295			/* Decide when to quit */
296
297			quit=0;
298	amb	80	if(SuperNodes2->number>(0.999*SuperNodes->number)) quit=1;
299			if(SuperSegments2->number>(0.999*SuperSegments->number)) quit=1;
300	amb	58
301	amb	66	/* Unmap the data and Rename the files */
302	amb	58
303			UnMapFile(SuperNodes);
304			UnMapFile(SuperSegments);
305			UnMapFile(SuperWays);
306
307			UnMapFile(SuperNodes2);
308			UnMapFile(SuperSegments2);
309			UnMapFile(SuperWays2);
310
311			rename("data/super-nodes2.mem","data/super-nodes.mem");
312			rename("data/super-segments2.mem","data/super-segments.mem");
313			rename("data/super-ways2.mem","data/super-ways.mem");
314			}
315			while(!quit);
316
317			UnMapFile(OSMNodes);
318			UnMapFile(OSMSegments);
319			UnMapFile(OSMWays);
320
321	amb	2	return(0);
322			}