Check out the latest version of Routino: svn co http://routino.org/svn/trunk routino
Annotation of /trunk/src/planetsplitter.c
Parent Directory
|
Revision Log
Revision 95 -
(hide annotations)
(download)
(as text)
Sat Jan 31 14:53:29 2009 UTC (16 years, 1 month ago) by amb
File MIME type: text/x-csrc
File size: 6525 byte(s)
Sat Jan 31 14:53:29 2009 UTC (16 years, 1 month ago) by amb
File MIME type: text/x-csrc
File size: 6525 byte(s)
Intermediate checkin, routing now working.
1 | amb | 2 | /*************************************** |
2 | amb | 95 | $Header: /home/amb/CVS/routino/src/planetsplitter.c,v 1.26 2009-01-31 14:53:29 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 | amb | 82 | #include "segments.h" |
21 | amb | 26 | #include "ways.h" |
22 | amb | 82 | #include "profiles.h" |
23 | amb | 2 | #include "functions.h" |
24 | |||
25 | |||
26 | int main(int argc,char** argv) | ||
27 | { | ||
28 | amb | 26 | NodesMem *OSMNodesMem; |
29 | amb | 92 | SegmentsMem *OSMSegmentsMem,*SuperSegmentsMem=NULL; |
30 | amb | 31 | WaysMem *OSMWaysMem; |
31 | amb | 58 | int iteration=0,quit=0; |
32 | amb | 89 | int help_profile=0,max_iterations=5; |
33 | amb | 93 | char *dirname=NULL,*prefix=NULL,*filename; |
34 | amb | 82 | Profile profile; |
35 | amb | 75 | int i; |
36 | amb | 26 | |
37 | amb | 82 | /* Fill in the default profile. */ |
38 | amb | 31 | |
39 | amb | 82 | profile.transport=Transport_None; /* Not used by planetsplitter */ |
40 | amb | 75 | |
41 | amb | 82 | profile.allow=Allow_ALL; |
42 | amb | 75 | |
43 | amb | 82 | for(i=1;i<Way_Unknown;i++) |
44 | profile.highways[i]=1; | ||
45 | |||
46 | for(i=1;i<Way_Unknown;i++) | ||
47 | profile.speed[i]=0; /* Not used by planetsplitter */ | ||
48 | |||
49 | profile.oneway=1; /* Not used by planetsplitter */ | ||
50 | |||
51 | /* Parse the command line arguments */ | ||
52 | |||
53 | amb | 60 | while(--argc>=1) |
54 | { | ||
55 | amb | 75 | if(!strcmp(argv[argc],"-help")) |
56 | goto usage; | ||
57 | amb | 93 | else if(!strcmp(argv[argc],"-help-profile")) |
58 | amb | 82 | help_profile=1; |
59 | amb | 93 | else if(!strncmp(argv[argc],"-dir=",5)) |
60 | dirname=&argv[argc][5]; | ||
61 | else if(!strncmp(argv[argc],"-prefix=",8)) | ||
62 | prefix=&argv[argc][8]; | ||
63 | amb | 60 | else if(!strncmp(argv[argc],"-max-iterations=",16)) |
64 | max_iterations=atoi(&argv[argc][16]); | ||
65 | amb | 75 | else if(!strncmp(argv[argc],"-transport=",11)) |
66 | amb | 82 | { |
67 | profile.transport=TransportType(&argv[argc][11]); | ||
68 | profile.allow=1<<(profile.transport-1); | ||
69 | } | ||
70 | amb | 75 | else if(!strncmp(argv[argc],"-not-highway=",13)) |
71 | { | ||
72 | Highway highway=HighwayType(&argv[argc][13]); | ||
73 | amb | 82 | profile.highways[highway]=0; |
74 | amb | 75 | } |
75 | amb | 60 | else |
76 | { | ||
77 | amb | 75 | usage: |
78 | |||
79 | fprintf(stderr,"Usage: planetsplitter\n" | ||
80 | amb | 82 | " [-help] [-help-profile]\n" |
81 | amb | 93 | " [-dir=<name>] [-prefix=<name>]\n" |
82 | amb | 75 | " [-max-iterations=<number>]\n" |
83 | " [-transport=<transport>]\n" | ||
84 | " [-not-highway=<highway> ...]\n" | ||
85 | "\n" | ||
86 | amb | 82 | "<transport> defaults to all but can be set to:\n" |
87 | amb | 75 | "%s" |
88 | "\n" | ||
89 | amb | 82 | "<highway> can be selected from:\n" |
90 | amb | 75 | "%s", |
91 | TransportList(),HighwayList()); | ||
92 | |||
93 | amb | 60 | return(1); |
94 | } | ||
95 | } | ||
96 | amb | 26 | |
97 | amb | 82 | if(help_profile) |
98 | { | ||
99 | PrintProfile(&profile); | ||
100 | |||
101 | return(0); | ||
102 | } | ||
103 | |||
104 | amb | 89 | /* Create new variables */ |
105 | amb | 82 | |
106 | amb | 89 | OSMNodesMem=NewNodeList(); |
107 | OSMSegmentsMem=NewSegmentList(); | ||
108 | OSMWaysMem=NewWayList(); | ||
109 | amb | 26 | |
110 | amb | 89 | /* Parse the file */ |
111 | amb | 2 | |
112 | amb | 89 | printf("\nParsing OSM Data\n================\n\n"); fflush(stdout); |
113 | amb | 2 | |
114 | amb | 89 | ParseXML(stdin,OSMNodesMem,OSMSegmentsMem,OSMWaysMem,&profile); |
115 | amb | 80 | |
116 | amb | 89 | printf("\nProcessing OSM Data\n===================\n\n"); fflush(stdout); |
117 | amb | 8 | |
118 | amb | 89 | /* Sort the ways */ |
119 | amb | 80 | |
120 | amb | 89 | printf("Sorting Ways"); fflush(stdout); |
121 | SortWayList(OSMWaysMem); | ||
122 | printf("\rSorted Ways \n"); fflush(stdout); | ||
123 | amb | 87 | |
124 | amb | 89 | /* Sort the segments */ |
125 | amb | 87 | |
126 | amb | 89 | printf("Sorting Segments"); fflush(stdout); |
127 | SortSegmentList(OSMSegmentsMem); | ||
128 | printf("\rSorted Segments \n"); fflush(stdout); | ||
129 | amb | 84 | |
130 | amb | 89 | /* Remove bad segments */ |
131 | amb | 84 | |
132 | amb | 89 | RemoveBadSegments(OSMSegmentsMem); |
133 | amb | 87 | |
134 | amb | 89 | printf("Sorting Segments"); fflush(stdout); |
135 | SortSegmentList(OSMSegmentsMem); | ||
136 | printf("\rSorted Segments \n"); fflush(stdout); | ||
137 | amb | 87 | |
138 | amb | 89 | /* Remove non-way nodes */ |
139 | amb | 41 | |
140 | amb | 89 | RemoveNonHighwayNodes(OSMNodesMem,OSMSegmentsMem); |
141 | amb | 41 | |
142 | amb | 89 | printf("Sorting Nodes"); fflush(stdout); |
143 | SortNodeList(OSMNodesMem); | ||
144 | printf("\rSorted Nodes \n"); fflush(stdout); | ||
145 | amb | 41 | |
146 | amb | 89 | /* Measure the segments */ |
147 | amb | 66 | |
148 | amb | 89 | MeasureSegments(OSMSegmentsMem,OSMNodesMem); |
149 | amb | 66 | |
150 | |||
151 | amb | 58 | /* Repeated iteration on Super-Nodes, Super-Segments and Super-Ways */ |
152 | |||
153 | do | ||
154 | { | ||
155 | amb | 80 | printf("\nProcessing Super-Data (iteration %d)\n===================================%s\n\n",iteration,iteration>10?"=":""); fflush(stdout); |
156 | |||
157 | amb | 90 | if(iteration==0) |
158 | { | ||
159 | /* Select the super-nodes */ | ||
160 | amb | 58 | |
161 | amb | 90 | ChooseSuperNodes(OSMNodesMem,OSMSegmentsMem,OSMWaysMem,iteration); |
162 | amb | 58 | |
163 | amb | 90 | /* Select the super-segments */ |
164 | amb | 58 | |
165 | amb | 90 | SuperSegmentsMem=CreateSuperSegments(OSMNodesMem,OSMSegmentsMem,OSMWaysMem,iteration); |
166 | } | ||
167 | else | ||
168 | { | ||
169 | SegmentsMem *SuperSegmentsMem2; | ||
170 | amb | 58 | |
171 | amb | 90 | /* Select the super-nodes */ |
172 | |||
173 | ChooseSuperNodes(OSMNodesMem,SuperSegmentsMem,OSMWaysMem,iteration); | ||
174 | |||
175 | /* Select the super-segments */ | ||
176 | |||
177 | SuperSegmentsMem2=CreateSuperSegments(OSMNodesMem,SuperSegmentsMem,OSMWaysMem,iteration); | ||
178 | |||
179 | FreeSegmentList(SuperSegmentsMem); | ||
180 | |||
181 | SuperSegmentsMem=SuperSegmentsMem2; | ||
182 | } | ||
183 | |||
184 | amb | 66 | /* Sort the super-segments */ |
185 | amb | 58 | |
186 | amb | 80 | printf("Sorting Super-Segments"); fflush(stdout); |
187 | amb | 90 | SortSegmentList(SuperSegmentsMem); |
188 | amb | 80 | printf("\rSorted Super-Segments \n"); fflush(stdout); |
189 | amb | 58 | |
190 | amb | 89 | iteration++; |
191 | amb | 58 | |
192 | amb | 89 | if(iteration>max_iterations) |
193 | quit=1; | ||
194 | } | ||
195 | while(!quit); | ||
196 | amb | 58 | |
197 | |||
198 | amb | 90 | /* Fix the node indexes */ |
199 | amb | 66 | |
200 | amb | 90 | FixupSegments(OSMSegmentsMem,OSMNodesMem,SuperSegmentsMem); |
201 | amb | 66 | |
202 | amb | 90 | FreeSegmentList(SuperSegmentsMem); |
203 | amb | 58 | |
204 | amb | 90 | /* Sort the segments */ |
205 | amb | 58 | |
206 | amb | 90 | printf("Sorting Segments"); fflush(stdout); |
207 | SortSegmentList(OSMSegmentsMem); | ||
208 | printf("\rSorted Segments \n"); fflush(stdout); | ||
209 | |||
210 | /* Fix the segment indexes */ | ||
211 | |||
212 | FixupNodes(OSMNodesMem,OSMSegmentsMem,iteration); | ||
213 | |||
214 | amb | 89 | /* Write out the nodes */ |
215 | amb | 58 | |
216 | amb | 95 | filename=(char*)malloc((dirname?strlen(dirname):0)+(prefix?strlen(prefix):0)+16); |
217 | |||
218 | amb | 89 | printf("Saving Nodes"); fflush(stdout); |
219 | amb | 93 | sprintf(filename,"%s%s%s%snodes.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":""); |
220 | SaveNodeList(OSMNodesMem,filename); | ||
221 | amb | 89 | printf("\rSaved Nodes: %d\n",OSMNodesMem->number); fflush(stdout); |
222 | amb | 58 | |
223 | amb | 89 | /* Write out the segments */ |
224 | amb | 58 | |
225 | amb | 89 | printf("Saving Segments"); fflush(stdout); |
226 | amb | 93 | sprintf(filename,"%s%s%s%ssegments.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":""); |
227 | SaveSegmentList(OSMSegmentsMem,filename); | ||
228 | amb | 89 | printf("\rSaved Segments: %d\n",OSMSegmentsMem->number); fflush(stdout); |
229 | amb | 58 | |
230 | amb | 89 | /* Write out the ways */ |
231 | amb | 58 | |
232 | amb | 89 | printf("Saving Ways"); fflush(stdout); |
233 | amb | 93 | sprintf(filename,"%s%s%s%sways.mem",dirname?dirname:"",dirname?"/":"",prefix?prefix:"",prefix?"-":""); |
234 | SaveWayList(OSMWaysMem,filename); | ||
235 | amb | 89 | printf("\rSaved Ways: %d\n",OSMWaysMem->number); fflush(stdout); |
236 | amb | 58 | |
237 | amb | 2 | return(0); |
238 | } |
Properties
Name | Value |
---|---|
cvs:description | Planet file splitter. |