trunk/src/planetsplitter.c

/***************************************
 $Header: /home/amb/CVS/routino/src/planetsplitter.c,v 1.65 2009-12-11 19:27:39 amb Exp $

 OSM planet file splitter.

 Part of the Routino routing software.
 ******************/ /******************
 This file Copyright 2008,2009 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 "typesx.h"
#include "types.h"
#include "functionsx.h"
#include "functions.h"
#include "nodesx.h"
#include "segmentsx.h"
#include "waysx.h"
#include "superx.h"
#include "profiles.h"
#include "ways.h"


/* 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;


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;
 Profile profile={0};
 int i;

 /* Fill in the default profile. */

 profile.transport=Transport_None; /* Not used by planetsplitter */

 profile.allow=0;

 for(i=1;i<Way_Count;i++)
    profile.highway[i]=1;

 for(i=1;i<Property_Count;i++)
    profile.props_yes[i]=1;

 profile.oneway=1; /* Not used by planetsplitter */

 /* Parse the command line arguments */

 while(--argc>=1)
   {
    if(!strcmp(argv[argc],"--help"))
       goto usage;
    else if(!strcmp(argv[argc],"--slim"))
       option_slim=1;
    else if(!strncmp(argv[argc],"--dir=",6))
       dirname=&argv[argc][6];
    else if(!strncmp(argv[argc],"--tmpdir=",9))
       option_tmpdirname=&argv[argc][9];
    else if(!strncmp(argv[argc],"--prefix=",9))
       prefix=&argv[argc][9];
    else if(!strncmp(argv[argc],"--max-iterations=",17))
       max_iterations=atoi(&argv[argc][17]);
    else if(!strncmp(argv[argc],"--transport=",12))
      {
       Transport transport=TransportType(&argv[argc][12]);
       if(transport==Transport_None)
          goto usage;
       profile.allow|=ALLOWED(transport);
      }
    else if(!strncmp(argv[argc],"--not-highway=",14))
      {
       Highway highway=HighwayType(&argv[argc][14]);
       if(highway==Way_Count)
          goto usage;
       profile.highway[highway]=0;
      }
    else if(!strncmp(argv[argc],"--not-property=",15))
      {
       Property property=PropertyType(&argv[argc][15]);
       if(property==Property_Count)
          goto usage;
       profile.props_yes[property]=0;
      }
    else
      {
      usage:

       fprintf(stderr,"Usage: planetsplitter\n"
                      "                      [--help]\n"
                      "                      [--dir=<name>] [--prefix=<name>]\n"
                      "                      [--slim] [--tmpdir=<name>]\n"
                      "                      [--max-iterations=<number>]\n"
                      "                      [--transport=<transport> ...]\n"
                      "                      [--not-highway=<highway> ...]\n"
                      "                      [--not-property=<property> ...]\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());

       return(1);
      }
   }

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

 if(!profile.allow)
    profile.allow=Allow_ALL;

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

 Nodes=NewNodeList();

 Segments=NewSegmentList();

 Ways=NewWayList();

 /* Parse the file */

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

 ParseXML(stdin,Nodes,Segments,Ways,&profile);

 /* 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);

       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);

 FreeSegmentList(SuperSegments);

 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);

 /* Write out the segments */

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

 FreeSegmentList(Segments);

 /* Write out the ways */

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

 FreeWayList(Ways);

 return(0);
}
1	/***************************************
2	$Header: /home/amb/CVS/routino/src/planetsplitter.c,v 1.65 2009-12-11 19:27:39 amb Exp $
3
4	OSM planet file splitter.
5
6	Part of the Routino routing software.
7	****************/ /****************
8	This file Copyright 2008,2009 Andrew M. Bishop
9
10	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	***************************************/
23
24
25	#include <stdio.h>
26	#include <stdlib.h>
27	#include <string.h>
28
29	#include "typesx.h"
30	#include "types.h"
31	#include "functionsx.h"
32	#include "functions.h"
33	#include "nodesx.h"
34	#include "segmentsx.h"
35	#include "waysx.h"
36	#include "superx.h"
37	#include "profiles.h"
38	#include "ways.h"
39
40
41	/* Variables */
42
43	/+ The option to use a slim mode with file-backed read-only intermediate storage. +/
44	int option_slim=0;
45
46	/+ The name of the temporary directory. +/
47	char *option_tmpdirname=NULL;
48
49
50	int main(int argc,char** argv)
51	{
52	NodesX *Nodes;
53	SegmentsX Segments,SuperSegments=NULL,*MergedSegments=NULL;
54	WaysX *Ways;
55	int iteration=0,quit=0;
56	int max_iterations=10;
57	char dirname=NULL,prefix=NULL;
58	Profile profile={0};
59	int i;
60
61	/* Fill in the default profile. */
62
63	profile.transport=Transport_None; /* Not used by planetsplitter */
64
65	profile.allow=0;
66
67	for(i=1;i<Way_Count;i++)
68	profile.highway[i]=1;
69
70	for(i=1;i<Property_Count;i++)
71	profile.props_yes[i]=1;
72
73	profile.oneway=1; /* Not used by planetsplitter */
74
75	/* Parse the command line arguments */
76
77	while(--argc>=1)
78	{
79	if(!strcmp(argv[argc],"--help"))
80	goto usage;
81	else if(!strcmp(argv[argc],"--slim"))
82	option_slim=1;
83	else if(!strncmp(argv[argc],"--dir=",6))
84	dirname=&argv[argc][6];
85	else if(!strncmp(argv[argc],"--tmpdir=",9))
86	option_tmpdirname=&argv[argc][9];
87	else if(!strncmp(argv[argc],"--prefix=",9))
88	prefix=&argv[argc][9];
89	else if(!strncmp(argv[argc],"--max-iterations=",17))
90	max_iterations=atoi(&argv[argc][17]);
91	else if(!strncmp(argv[argc],"--transport=",12))
92	{
93	Transport transport=TransportType(&argv[argc][12]);
94	if(transport==Transport_None)
95	goto usage;
96	profile.allow\|=ALLOWED(transport);
97	}
98	else if(!strncmp(argv[argc],"--not-highway=",14))
99	{
100	Highway highway=HighwayType(&argv[argc][14]);
101	if(highway==Way_Count)
102	goto usage;
103	profile.highway[highway]=0;
104	}
105	else if(!strncmp(argv[argc],"--not-property=",15))
106	{
107	Property property=PropertyType(&argv[argc][15]);
108	if(property==Property_Count)
109	goto usage;
110	profile.props_yes[property]=0;
111	}
112	else
113	{
114	usage:
115
116	fprintf(stderr,"Usage: planetsplitter\n"
117	" [--help]\n"
118	" [--dir=<name>] [--prefix=<name>]\n"
119	" [--slim] [--tmpdir=<name>]\n"
120	" [--max-iterations=<number>]\n"
121	" [--transport=<transport> ...]\n"
122	" [--not-highway=<highway> ...]\n"
123	" [--not-property=<property> ...]\n"
124	"\n"
125	"<transport> defaults to all but can be set to:\n"
126	"%s"
127	"\n"
128	"<highway> can be selected from:\n"
129	"%s"
130	"\n"
131	"<property> can be selected from:\n"
132	"%s",
133	TransportList(),HighwayList(),PropertyList());
134
135	return(1);
136	}
137	}
138
139	if(!option_tmpdirname)
140	{
141	if(!dirname)
142	option_tmpdirname=".";
143	else
144	option_tmpdirname=dirname;
145	}
146
147	if(!profile.allow)
148	profile.allow=Allow_ALL;
149
150	/* Create new node, segment and way variables */
151
152	Nodes=NewNodeList();
153
154	Segments=NewSegmentList();
155
156	Ways=NewWayList();
157
158	/* Parse the file */
159
160	printf("\nParse OSM Data\n==============\n\n");
161	fflush(stdout);
162
163	ParseXML(stdin,Nodes,Segments,Ways,&profile);
164
165	/* Process the data */
166
167	printf("\nProcess OSM Data\n================\n\n");
168	fflush(stdout);
169
170	/* Sort the nodes, segments and ways */
171
172	SortNodeList(Nodes);
173
174	SortSegmentList(Segments);
175
176	SortWayList(Ways);
177
178	/* Remove bad segments (must be after sorting the nodes and segments) */
179
180	RemoveBadSegments(Nodes,Segments);
181
182	/* Remove non-highway nodes (must be after removing the bad segments) */
183
184	RemoveNonHighwayNodes(Nodes,Segments);
185
186	/* Measure the segments and replace node/way id with index (must be after removing non-highway nodes) */
187
188	UpdateSegments(Segments,Nodes,Ways);
189
190
191	/* Repeated iteration on Super-Nodes and Super-Segments */
192
193	do
194	{
195	printf("\nProcess Super-Data (iteration %d)\n================================%s\n\n",iteration,iteration>9?"=":"");
196	fflush(stdout);
197
198	if(iteration==0)
199	{
200	/* Select the super-nodes */
201
202	ChooseSuperNodes(Nodes,Segments,Ways);
203
204	/* Select the super-segments */
205
206	SuperSegments=CreateSuperSegments(Nodes,Segments,Ways,iteration);
207	}
208	else
209	{
210	SegmentsX *SuperSegments2;
211
212	/* Select the super-nodes */
213
214	ChooseSuperNodes(Nodes,SuperSegments,Ways);
215
216	/* Select the super-segments */
217
218	SuperSegments2=CreateSuperSegments(Nodes,SuperSegments,Ways,iteration);
219
220	if(SuperSegments->xnumber==SuperSegments2->xnumber)
221	quit=1;
222
223	FreeSegmentList(SuperSegments);
224
225	SuperSegments=SuperSegments2;
226	}
227
228	/* Sort the super-segments */
229
230	SortSegmentList(SuperSegments);
231
232	/* Remove duplicated super-segments */
233
234	DeduplicateSegments(SuperSegments,Nodes,Ways);
235
236	iteration++;
237
238	if(iteration>max_iterations)
239	quit=1;
240	}
241	while(!quit);
242
243	/* Combine the super-segments */
244
245	printf("\nCombine Segments and Super-Segments\n===================================\n\n");
246	fflush(stdout);
247
248	/* Merge the super-segments */
249
250	MergedSegments=MergeSuperSegments(Segments,SuperSegments);
251
252	FreeSegmentList(Segments);
253
254	FreeSegmentList(SuperSegments);
255
256	Segments=MergedSegments;
257
258	/* Rotate segments so that node1<node2 */
259
260	RotateSegments(Segments);
261
262	/* Sort the segments */
263
264	SortSegmentList(Segments);
265
266	/* Remove duplicated segments */
267
268	DeduplicateSegments(Segments,Nodes,Ways);
269
270	/* Cross reference the nodes and segments */
271
272	printf("\nCross-Reference Nodes and Segments\n==================================\n\n");
273	fflush(stdout);
274
275	/* Sort the node list geographically */
276
277	SortNodeListGeographically(Nodes);
278
279	/* Create the real segments and nodes */
280
281	CreateRealNodes(Nodes,iteration);
282
283	CreateRealSegments(Segments,Ways);
284
285	/* Fix the segment and node indexes */
286
287	IndexNodes(Nodes,Segments);
288
289	IndexSegments(Segments,Nodes);
290
291	/* Output the results */
292
293	printf("\nWrite Out Database Files\n========================\n\n");
294	fflush(stdout);
295
296	/* Write out the nodes */
297
298	SaveNodeList(Nodes,FileName(dirname,prefix,"nodes.mem"));
299
300	FreeNodeList(Nodes);
301
302	/* Write out the segments */
303
304	SaveSegmentList(Segments,FileName(dirname,prefix,"segments.mem"));
305
306	FreeSegmentList(Segments);
307
308	/* Write out the ways */
309
310	SaveWayList(Ways,FileName(dirname,prefix,"ways.mem"),&profile);
311
312	FreeWayList(Ways);
313
314	return(0);
315	}