Check out the latest version of Routino: svn co http://routino.org/svn/trunk routino
Annotation of /trunk/src/segmentsx.c
Parent Directory
|
Revision Log
Revision 1231 -
(hide annotations)
(download)
(as text)
Thu Dec 27 14:00:23 2012 UTC (12 years, 2 months ago) by amb
File MIME type: text/x-csrc
File size: 31670 byte(s)
Thu Dec 27 14:00:23 2012 UTC (12 years, 2 months ago) by amb
File MIME type: text/x-csrc
File size: 31670 byte(s)
Don't append segments if they are duplicates within a way or have duplicated nodes. Log errors for middle nodes that repeat within a way (can be non-trivial unintentional loops).
1 | amb | 110 | /*************************************** |
2 | Extended Segment data type functions. | ||
3 | amb | 151 | |
4 | Part of the Routino routing software. | ||
5 | amb | 110 | ******************/ /****************** |
6 | amb | 949 | This file Copyright 2008-2012 Andrew M. Bishop |
7 | amb | 110 | |
8 | amb | 151 | This program is free software: you can redistribute it and/or modify |
9 | it under the terms of the GNU Affero General Public License as published by | ||
10 | the Free Software Foundation, either version 3 of the License, or | ||
11 | (at your option) any later version. | ||
12 | |||
13 | This program is distributed in the hope that it will be useful, | ||
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
16 | GNU Affero General Public License for more details. | ||
17 | |||
18 | You should have received a copy of the GNU Affero General Public License | ||
19 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
20 | amb | 110 | ***************************************/ |
21 | |||
22 | |||
23 | #include <math.h> | ||
24 | #include <stdlib.h> | ||
25 | amb | 955 | #include <string.h> |
26 | amb | 110 | |
27 | #include "types.h" | ||
28 | amb | 228 | #include "segments.h" |
29 | #include "ways.h" | ||
30 | amb | 110 | |
31 | amb | 955 | #include "typesx.h" |
32 | amb | 449 | #include "nodesx.h" |
33 | #include "segmentsx.h" | ||
34 | #include "waysx.h" | ||
35 | amb | 110 | |
36 | amb | 449 | #include "files.h" |
37 | amb | 519 | #include "logging.h" |
38 | amb | 532 | #include "sorting.h" |
39 | amb | 449 | |
40 | |||
41 | amb | 680 | /* Global variables */ |
42 | amb | 110 | |
43 | amb | 289 | /*+ The command line '--tmpdir' option or its default value. +*/ |
44 | amb | 284 | extern char *option_tmpdirname; |
45 | amb | 110 | |
46 | amb | 1100 | /* Local variables */ |
47 | |||
48 | amb | 1107 | /*+ Temporary file-local variables for use by the sort functions. +*/ |
49 | amb | 1132 | static NodesX *sortnodesx; |
50 | amb | 1100 | static SegmentsX *sortsegmentsx; |
51 | amb | 1132 | static WaysX *sortwaysx; |
52 | amb | 1100 | |
53 | amb | 680 | /* Local functions */ |
54 | amb | 110 | |
55 | amb | 1140 | static int sort_by_way_id(SegmentX *a,SegmentX *b); |
56 | static int apply_changes(SegmentX *segmentx,index_t index); | ||
57 | amb | 1160 | |
58 | amb | 275 | static int sort_by_id(SegmentX *a,SegmentX *b); |
59 | amb | 1155 | static int deduplicate(SegmentX *segmentx,index_t index); |
60 | amb | 1160 | |
61 | amb | 949 | static int delete_pruned(SegmentX *segmentx,index_t index); |
62 | amb | 1160 | |
63 | amb | 1132 | static int deduplicate_super(SegmentX *segmentx,index_t index); |
64 | amb | 275 | |
65 | amb | 1160 | static int geographically_index(SegmentX *segmentx,index_t index); |
66 | |||
67 | amb | 1168 | static distance_t DistanceX(NodeX *nodex1,NodeX *nodex2); |
68 | amb | 110 | |
69 | |||
70 | /*++++++++++++++++++++++++++++++++++++++ | ||
71 | amb | 326 | Allocate a new segment list (create a new file or open an existing one). |
72 | amb | 110 | |
73 | SegmentsX *NewSegmentList Returns the segment list. | ||
74 | amb | 326 | |
75 | amb | 1123 | int append Set to 1 if the file is to be opened for appending. |
76 | |||
77 | amb | 1139 | int readonly Set to 1 if the file is to be opened for reading. |
78 | amb | 110 | ++++++++++++++++++++++++++++++++++++++*/ |
79 | |||
80 | amb | 1123 | SegmentsX *NewSegmentList(int append,int readonly) |
81 | amb | 110 | { |
82 | SegmentsX *segmentsx; | ||
83 | |||
84 | amb | 213 | segmentsx=(SegmentsX*)calloc(1,sizeof(SegmentsX)); |
85 | amb | 110 | |
86 | amb | 1166 | logassert(segmentsx,"Failed to allocate memory (try using slim mode?)"); /* Check calloc() worked */ |
87 | amb | 243 | |
88 | amb | 1120 | segmentsx->filename =(char*)malloc(strlen(option_tmpdirname)+32); |
89 | segmentsx->filename_tmp=(char*)malloc(strlen(option_tmpdirname)+32); | ||
90 | amb | 216 | |
91 | amb | 1120 | sprintf(segmentsx->filename ,"%s/segmentsx.parsed.mem",option_tmpdirname); |
92 | sprintf(segmentsx->filename_tmp,"%s/segmentsx.%p.tmp" ,option_tmpdirname,(void*)segmentsx); | ||
93 | amb | 256 | |
94 | amb | 1123 | if(append || readonly) |
95 | if(ExistsFile(segmentsx->filename)) | ||
96 | { | ||
97 | off_t size; | ||
98 | amb | 326 | |
99 | amb | 1123 | size=SizeFile(segmentsx->filename); |
100 | amb | 326 | |
101 | amb | 1123 | segmentsx->number=size/sizeof(SegmentX); |
102 | amb | 1139 | |
103 | RenameFile(segmentsx->filename,segmentsx->filename_tmp); | ||
104 | amb | 1123 | } |
105 | amb | 326 | |
106 | amb | 1123 | if(append) |
107 | amb | 1139 | segmentsx->fd=OpenFileAppend(segmentsx->filename_tmp); |
108 | amb | 1123 | else if(!readonly) |
109 | amb | 1139 | segmentsx->fd=OpenFileNew(segmentsx->filename_tmp); |
110 | amb | 326 | else |
111 | amb | 1123 | segmentsx->fd=-1; |
112 | amb | 326 | |
113 | amb | 110 | return(segmentsx); |
114 | } | ||
115 | |||
116 | |||
117 | /*++++++++++++++++++++++++++++++++++++++ | ||
118 | amb | 226 | Free a segment list. |
119 | amb | 110 | |
120 | amb | 681 | SegmentsX *segmentsx The set of segments to be freed. |
121 | amb | 1151 | |
122 | amb | 1167 | int keep If set then the results file is to be kept. |
123 | amb | 110 | ++++++++++++++++++++++++++++++++++++++*/ |
124 | |||
125 | amb | 1167 | void FreeSegmentList(SegmentsX *segmentsx,int keep) |
126 | amb | 110 | { |
127 | amb | 1167 | if(keep) |
128 | amb | 1151 | RenameFile(segmentsx->filename_tmp,segmentsx->filename); |
129 | else | ||
130 | DeleteFile(segmentsx->filename_tmp); | ||
131 | amb | 1120 | |
132 | amb | 283 | free(segmentsx->filename); |
133 | amb | 1120 | free(segmentsx->filename_tmp); |
134 | amb | 256 | |
135 | amb | 949 | if(segmentsx->firstnode) |
136 | free(segmentsx->firstnode); | ||
137 | |||
138 | if(segmentsx->next1) | ||
139 | free(segmentsx->next1); | ||
140 | |||
141 | amb | 643 | if(segmentsx->usednode) |
142 | free(segmentsx->usednode); | ||
143 | |||
144 | amb | 110 | free(segmentsx); |
145 | } | ||
146 | |||
147 | |||
148 | /*++++++++++++++++++++++++++++++++++++++ | ||
149 | amb | 493 | Append a single segment to an unsorted segment list. |
150 | amb | 110 | |
151 | amb | 681 | SegmentsX *segmentsx The set of segments to modify. |
152 | amb | 110 | |
153 | amb | 285 | way_t way The way that the segment belongs to. |
154 | |||
155 | node_t node1 The first node in the segment. | ||
156 | |||
157 | node_t node2 The second node in the segment. | ||
158 | |||
159 | amb | 1168 | distance_t distance The distance between the nodes (or just the flags). |
160 | amb | 110 | ++++++++++++++++++++++++++++++++++++++*/ |
161 | |||
162 | amb | 1168 | void AppendSegmentList(SegmentsX *segmentsx,way_t way,node_t node1,node_t node2,distance_t distance) |
163 | amb | 110 | { |
164 | amb | 285 | SegmentX segmentx; |
165 | amb | 110 | |
166 | amb | 643 | if(node1>node2) |
167 | { | ||
168 | node_t temp; | ||
169 | |||
170 | temp=node1; | ||
171 | node1=node2; | ||
172 | node2=temp; | ||
173 | |||
174 | amb | 1168 | if(distance&(ONEWAY_2TO1|ONEWAY_1TO2)) |
175 | distance^=ONEWAY_2TO1|ONEWAY_1TO2; | ||
176 | amb | 643 | } |
177 | |||
178 | amb | 285 | segmentx.node1=node1; |
179 | segmentx.node2=node2; | ||
180 | amb | 643 | segmentx.next2=NO_SEGMENT; |
181 | amb | 285 | segmentx.way=way; |
182 | amb | 1168 | segmentx.distance=distance; |
183 | amb | 110 | |
184 | amb | 285 | WriteFile(segmentsx->fd,&segmentx,sizeof(SegmentX)); |
185 | amb | 281 | |
186 | amb | 650 | segmentsx->number++; |
187 | amb | 466 | |
188 | amb | 1166 | logassert(segmentsx->number<SEGMENT_FAKE,"Too many segments (change index_t to 64-bits?)"); /* SEGMENT_FAKE marks the high-water mark for real segments. */ |
189 | amb | 285 | } |
190 | amb | 227 | |
191 | amb | 281 | |
192 | amb | 285 | /*++++++++++++++++++++++++++++++++++++++ |
193 | amb | 1120 | Finish appending segments and change the filename over. |
194 | |||
195 | SegmentsX *segmentsx The segments that have been appended. | ||
196 | ++++++++++++++++++++++++++++++++++++++*/ | ||
197 | |||
198 | amb | 1151 | void FinishSegmentList(SegmentsX *segmentsx) |
199 | amb | 1120 | { |
200 | amb | 1136 | if(segmentsx->fd!=-1) |
201 | segmentsx->fd=CloseFile(segmentsx->fd); | ||
202 | amb | 1120 | } |
203 | |||
204 | |||
205 | /*++++++++++++++++++++++++++++++++++++++ | ||
206 | amb | 1160 | Find the first extended segment with a particular starting node index. |
207 | |||
208 | SegmentX *FirstSegmentX Returns a pointer to the first extended segment with the specified id. | ||
209 | |||
210 | SegmentsX *segmentsx The set of segments to use. | ||
211 | |||
212 | index_t nodeindex The node index to look for. | ||
213 | |||
214 | int position A flag to pass through. | ||
215 | ++++++++++++++++++++++++++++++++++++++*/ | ||
216 | |||
217 | SegmentX *FirstSegmentX(SegmentsX *segmentsx,index_t nodeindex,int position) | ||
218 | { | ||
219 | index_t index=segmentsx->firstnode[nodeindex]; | ||
220 | SegmentX *segmentx; | ||
221 | |||
222 | if(index==NO_SEGMENT) | ||
223 | return(NULL); | ||
224 | |||
225 | segmentx=LookupSegmentX(segmentsx,index,position); | ||
226 | |||
227 | return(segmentx); | ||
228 | } | ||
229 | |||
230 | |||
231 | /*++++++++++++++++++++++++++++++++++++++ | ||
232 | Find the next segment with a particular starting node index. | ||
233 | |||
234 | SegmentX *NextSegmentX Returns a pointer to the next segment with the same id. | ||
235 | |||
236 | SegmentsX *segmentsx The set of segments to use. | ||
237 | |||
238 | SegmentX *segmentx The current segment. | ||
239 | |||
240 | index_t nodeindex The node index. | ||
241 | ++++++++++++++++++++++++++++++++++++++*/ | ||
242 | |||
243 | SegmentX *NextSegmentX(SegmentsX *segmentsx,SegmentX *segmentx,index_t nodeindex) | ||
244 | { | ||
245 | #if SLIM | ||
246 | int position=1+(segmentx-&segmentsx->cached[0]); | ||
247 | #endif | ||
248 | |||
249 | if(segmentx->node1==nodeindex) | ||
250 | { | ||
251 | if(segmentsx->next1) | ||
252 | { | ||
253 | index_t index=IndexSegmentX(segmentsx,segmentx); | ||
254 | |||
255 | if(segmentsx->next1[index]==NO_SEGMENT) | ||
256 | return(NULL); | ||
257 | |||
258 | segmentx=LookupSegmentX(segmentsx,segmentsx->next1[index],position); | ||
259 | |||
260 | return(segmentx); | ||
261 | } | ||
262 | else | ||
263 | { | ||
264 | #if SLIM | ||
265 | index_t index=IndexSegmentX(segmentsx,segmentx); | ||
266 | index++; | ||
267 | |||
268 | if(index>=segmentsx->number) | ||
269 | return(NULL); | ||
270 | |||
271 | segmentx=LookupSegmentX(segmentsx,index,position); | ||
272 | #else | ||
273 | segmentx++; | ||
274 | |||
275 | if(IndexSegmentX(segmentsx,segmentx)>=segmentsx->number) | ||
276 | return(NULL); | ||
277 | #endif | ||
278 | |||
279 | if(segmentx->node1!=nodeindex) | ||
280 | return(NULL); | ||
281 | |||
282 | return(segmentx); | ||
283 | } | ||
284 | } | ||
285 | else | ||
286 | { | ||
287 | if(segmentx->next2==NO_SEGMENT) | ||
288 | return(NULL); | ||
289 | |||
290 | return(LookupSegmentX(segmentsx,segmentx->next2,position)); | ||
291 | } | ||
292 | } | ||
293 | |||
294 | |||
295 | /*++++++++++++++++++++++++++++++++++++++ | ||
296 | amb | 1140 | Apply the changes to the segments (no unique id to use). |
297 | |||
298 | SegmentsX *segmentsx The set of segments to sort and modify. | ||
299 | ++++++++++++++++++++++++++++++++++++++*/ | ||
300 | |||
301 | void ApplySegmentChanges(SegmentsX *segmentsx) | ||
302 | { | ||
303 | int fd; | ||
304 | index_t xnumber; | ||
305 | |||
306 | /* Print the start message */ | ||
307 | |||
308 | printf_first("Applying Segment Changes"); | ||
309 | |||
310 | /* Re-open the file read-only and a new file writeable */ | ||
311 | |||
312 | segmentsx->fd=ReOpenFile(segmentsx->filename_tmp); | ||
313 | |||
314 | DeleteFile(segmentsx->filename_tmp); | ||
315 | |||
316 | fd=OpenFileNew(segmentsx->filename_tmp); | ||
317 | |||
318 | /* Sort by node indexes */ | ||
319 | |||
320 | xnumber=segmentsx->number; | ||
321 | |||
322 | segmentsx->number=filesort_fixed(segmentsx->fd,fd,sizeof(SegmentX),NULL, | ||
323 | (int (*)(const void*,const void*))sort_by_way_id, | ||
324 | (int (*)(void*,index_t))apply_changes); | ||
325 | |||
326 | /* Close the files */ | ||
327 | |||
328 | segmentsx->fd=CloseFile(segmentsx->fd); | ||
329 | CloseFile(fd); | ||
330 | |||
331 | /* Print the final message */ | ||
332 | |||
333 | printf_last("Applying Segment Changes: Segments=%"Pindex_t" Changed=%"Pindex_t,xnumber,xnumber-segmentsx->number); | ||
334 | } | ||
335 | |||
336 | |||
337 | /*++++++++++++++++++++++++++++++++++++++ | ||
338 | amb | 1160 | Sort the segments into way id order. |
339 | amb | 232 | |
340 | amb | 1160 | int sort_by_way_id Returns the comparison of the way fields. |
341 | |||
342 | SegmentX *a The first segment. | ||
343 | |||
344 | SegmentX *b The second segment. | ||
345 | amb | 1100 | ++++++++++++++++++++++++++++++++++++++*/ |
346 | amb | 949 | |
347 | amb | 1160 | static int sort_by_way_id(SegmentX *a,SegmentX *b) |
348 | amb | 1100 | { |
349 | amb | 1160 | way_t a_id=a->way; |
350 | way_t b_id=b->way; | ||
351 | amb | 1100 | |
352 | amb | 1160 | if(a_id<b_id) |
353 | return(-1); | ||
354 | else if(a_id>b_id) | ||
355 | return(1); | ||
356 | else /* if(a_id==b_id) */ | ||
357 | return(-FILESORT_PRESERVE_ORDER(a,b)); /* latest version first */ | ||
358 | } | ||
359 | amb | 1100 | |
360 | |||
361 | amb | 1160 | /*++++++++++++++++++++++++++++++++++++++ |
362 | Apply the changes to the segments. | ||
363 | amb | 1100 | |
364 | amb | 1160 | int apply_changes Return 1 if the value is to be kept, otherwise 0. |
365 | amb | 1100 | |
366 | amb | 1160 | SegmentX *segmentx The extended segment. |
367 | amb | 1100 | |
368 | amb | 1160 | index_t index The number of sorted segments that have already been written to the output file. |
369 | ++++++++++++++++++++++++++++++++++++++*/ | ||
370 | amb | 1100 | |
371 | amb | 1160 | static int apply_changes(SegmentX *segmentx,index_t index) |
372 | { | ||
373 | static way_t prevway=NO_WAY_ID; | ||
374 | static int deleted=0; | ||
375 | amb | 1100 | |
376 | amb | 1160 | if(prevway!=segmentx->way) |
377 | { | ||
378 | prevway=segmentx->way; | ||
379 | deleted=0; | ||
380 | } | ||
381 | amb | 1131 | |
382 | amb | 1160 | if(!deleted) |
383 | if(segmentx->node1==NO_NODE_ID) | ||
384 | deleted=1; | ||
385 | amb | 1131 | |
386 | amb | 1160 | if(deleted) |
387 | return(0); | ||
388 | else | ||
389 | return(1); | ||
390 | amb | 1131 | } |
391 | |||
392 | |||
393 | /*++++++++++++++++++++++++++++++++++++++ | ||
394 | amb | 1160 | Sort the segment list and deduplicate it. |
395 | amb | 1100 | |
396 | SegmentsX *segmentsx The set of segments to sort and modify. | ||
397 | amb | 285 | ++++++++++++++++++++++++++++++++++++++*/ |
398 | amb | 110 | |
399 | amb | 1160 | void SortSegmentList(SegmentsX *segmentsx) |
400 | amb | 285 | { |
401 | int fd; | ||
402 | amb | 1132 | index_t xnumber; |
403 | amb | 243 | |
404 | amb | 285 | /* Print the start message */ |
405 | amb | 232 | |
406 | amb | 1160 | printf_first("Sorting Segments"); |
407 | amb | 110 | |
408 | amb | 555 | /* Re-open the file read-only and a new file writeable */ |
409 | |||
410 | amb | 1120 | segmentsx->fd=ReOpenFile(segmentsx->filename_tmp); |
411 | amb | 110 | |
412 | amb | 1120 | DeleteFile(segmentsx->filename_tmp); |
413 | amb | 110 | |
414 | amb | 1120 | fd=OpenFileNew(segmentsx->filename_tmp); |
415 | amb | 110 | |
416 | amb | 285 | /* Sort by node indexes */ |
417 | amb | 132 | |
418 | amb | 1132 | xnumber=segmentsx->number; |
419 | |||
420 | amb | 1160 | segmentsx->number=filesort_fixed(segmentsx->fd,fd,sizeof(SegmentX),NULL, |
421 | amb | 1132 | (int (*)(const void*,const void*))sort_by_id, |
422 | amb | 1160 | (int (*)(void*,index_t))deduplicate); |
423 | amb | 1100 | |
424 | amb | 555 | /* Close the files */ |
425 | amb | 285 | |
426 | amb | 612 | segmentsx->fd=CloseFile(segmentsx->fd); |
427 | amb | 281 | CloseFile(fd); |
428 | |||
429 | /* Print the final message */ | ||
430 | |||
431 | amb | 1160 | printf_last("Sorted Segments: Segments=%"Pindex_t" Duplicates=%"Pindex_t,xnumber,xnumber-segmentsx->number); |
432 | amb | 110 | } |
433 | |||
434 | |||
435 | /*++++++++++++++++++++++++++++++++++++++ | ||
436 | amb | 680 | Sort the segments into id order, first by node1 then by node2, finally by distance. |
437 | amb | 110 | |
438 | amb | 285 | int sort_by_id Returns the comparison of the node fields. |
439 | amb | 110 | |
440 | amb | 285 | SegmentX *a The first segment. |
441 | amb | 110 | |
442 | amb | 285 | SegmentX *b The second segment. |
443 | amb | 256 | ++++++++++++++++++++++++++++++++++++++*/ |
444 | |||
445 | amb | 285 | static int sort_by_id(SegmentX *a,SegmentX *b) |
446 | amb | 256 | { |
447 | amb | 285 | node_t a_id1=a->node1; |
448 | node_t b_id1=b->node1; | ||
449 | amb | 256 | |
450 | amb | 285 | if(a_id1<b_id1) |
451 | return(-1); | ||
452 | else if(a_id1>b_id1) | ||
453 | return(1); | ||
454 | else /* if(a_id1==b_id1) */ | ||
455 | amb | 256 | { |
456 | amb | 285 | node_t a_id2=a->node2; |
457 | node_t b_id2=b->node2; | ||
458 | amb | 256 | |
459 | amb | 285 | if(a_id2<b_id2) |
460 | return(-1); | ||
461 | else if(a_id2>b_id2) | ||
462 | return(1); | ||
463 | else | ||
464 | { | ||
465 | amb | 1168 | distance_t a_distance=DISTANCE(a->distance); |
466 | distance_t b_distance=DISTANCE(b->distance); | ||
467 | amb | 256 | |
468 | amb | 1168 | if(a_distance<b_distance) |
469 | amb | 285 | return(-1); |
470 | amb | 1168 | else if(a_distance>b_distance) |
471 | amb | 285 | return(1); |
472 | else | ||
473 | amb | 1153 | { |
474 | amb | 1168 | distance_t a_distflag=DISTFLAG(a->distance); |
475 | distance_t b_distflag=DISTFLAG(b->distance); | ||
476 | amb | 1153 | |
477 | amb | 1168 | if(a_distflag<b_distflag) |
478 | amb | 1153 | return(-1); |
479 | amb | 1168 | else if(a_distflag>b_distflag) |
480 | amb | 1153 | return(1); |
481 | else | ||
482 | return(FILESORT_PRESERVE_ORDER(a,b)); /* preserve order */ | ||
483 | } | ||
484 | amb | 285 | } |
485 | amb | 256 | } |
486 | } | ||
487 | |||
488 | |||
489 | /*++++++++++++++++++++++++++++++++++++++ | ||
490 | amb | 1155 | Discard duplicate segments. |
491 | amb | 1131 | |
492 | amb | 1155 | int deduplicate Return 1 if the value is to be kept, otherwise 0. |
493 | amb | 1131 | |
494 | SegmentX *segmentx The extended segment. | ||
495 | |||
496 | index_t index The number of sorted segments that have already been written to the output file. | ||
497 | ++++++++++++++++++++++++++++++++++++++*/ | ||
498 | |||
499 | amb | 1155 | static int deduplicate(SegmentX *segmentx,index_t index) |
500 | amb | 1131 | { |
501 | static node_t prevnode1=NO_NODE_ID,prevnode2=NO_NODE_ID; | ||
502 | amb | 1155 | static way_t prevway=NO_WAY_ID; |
503 | amb | 1168 | static distance_t prevdist=0; |
504 | amb | 1131 | |
505 | amb | 1168 | if(prevnode1!=segmentx->node1 || prevnode2!=segmentx->node2 || prevway!=segmentx->way || prevdist!=segmentx->distance) |
506 | amb | 1131 | { |
507 | prevnode1=segmentx->node1; | ||
508 | prevnode2=segmentx->node2; | ||
509 | amb | 1155 | prevway=segmentx->way; |
510 | amb | 1168 | prevdist=segmentx->distance; |
511 | amb | 1131 | |
512 | return(1); | ||
513 | } | ||
514 | else | ||
515 | return(0); | ||
516 | } | ||
517 | |||
518 | |||
519 | /*++++++++++++++++++++++++++++++++++++++ | ||
520 | amb | 680 | Remove bad segments (duplicated, zero length or with missing nodes). |
521 | amb | 110 | |
522 | amb | 1136 | SegmentsX *segmentsx The set of segments to modify. |
523 | |||
524 | amb | 681 | NodesX *nodesx The set of nodes to use. |
525 | amb | 195 | |
526 | amb | 1140 | WaysX *waysx The set of ways to use. |
527 | |||
528 | amb | 1167 | int keep If set to 1 then keep the old data file otherwise delete it. |
529 | amb | 110 | ++++++++++++++++++++++++++++++++++++++*/ |
530 | |||
531 | amb | 1167 | void RemoveBadSegments(SegmentsX *segmentsx,NodesX *nodesx,WaysX *waysx,int keep) |
532 | amb | 110 | { |
533 | amb | 1231 | index_t noway=0,nonode=0,duplicate=0,good=0,total=0; |
534 | amb | 1155 | node_t prevnode1=NO_NODE_ID,prevnode2=NO_NODE_ID; |
535 | amb | 1173 | way_t prevway=NO_WAY_ID; |
536 | amb | 1168 | distance_t prevdist=0; |
537 | amb | 275 | SegmentX segmentx; |
538 | int fd; | ||
539 | amb | 110 | |
540 | amb | 275 | /* Print the start message */ |
541 | |||
542 | amb | 1231 | printf_first("Checking Segments: Segments=0 No-Way=0 No-Node=0 Duplicate=0"); |
543 | amb | 227 | |
544 | amb | 1100 | /* Allocate the node usage bitmask */ |
545 | amb | 643 | |
546 | amb | 950 | segmentsx->usednode=AllocBitMask(nodesx->number); |
547 | amb | 643 | |
548 | amb | 1166 | logassert(segmentsx->usednode,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */ |
549 | amb | 643 | |
550 | amb | 555 | /* Re-open the file read-only and a new file writeable */ |
551 | amb | 275 | |
552 | amb | 1120 | segmentsx->fd=ReOpenFile(segmentsx->filename_tmp); |
553 | amb | 555 | |
554 | amb | 1167 | if(keep) |
555 | amb | 1136 | RenameFile(segmentsx->filename_tmp,segmentsx->filename); |
556 | else | ||
557 | DeleteFile(segmentsx->filename_tmp); | ||
558 | amb | 275 | |
559 | amb | 1120 | fd=OpenFileNew(segmentsx->filename_tmp); |
560 | amb | 275 | |
561 | amb | 555 | /* Modify the on-disk image */ |
562 | |||
563 | amb | 275 | while(!ReadFile(segmentsx->fd,&segmentx,sizeof(SegmentX))) |
564 | amb | 110 | { |
565 | amb | 643 | index_t index1=IndexNodeX(nodesx,segmentx.node1); |
566 | index_t index2=IndexNodeX(nodesx,segmentx.node2); | ||
567 | amb | 1140 | index_t indexw=IndexWayX(waysx,segmentx.way); |
568 | amb | 643 | |
569 | amb | 1140 | if(indexw==NO_WAY) |
570 | amb | 812 | { |
571 | amb | 1228 | logerror("Segment belongs to way %"Pway_t" that does not exist in the Routino database (not a highway?).\n",segmentx.way); |
572 | amb | 1140 | |
573 | noway++; | ||
574 | } | ||
575 | amb | 643 | else if(index1==NO_NODE || index2==NO_NODE) |
576 | amb | 812 | { |
577 | if(index1==NO_NODE && index2==NO_NODE) | ||
578 | amb | 1228 | logerror("Segment connects nodes %"Pnode_t" and %"Pnode_t" that do not exist in the Routino database (not highway nodes?).\n",segmentx.node1,segmentx.node2); |
579 | amb | 812 | |
580 | if(index1==NO_NODE && index2!=NO_NODE) | ||
581 | amb | 1228 | logerror("Segment contains node %"Pnode_t" that does not exist in the Routino database (not a highway node?).\n",segmentx.node1); |
582 | amb | 812 | |
583 | if(index1!=NO_NODE && index2==NO_NODE) | ||
584 | amb | 1231 | logerror("Segment contains node %"Pnode_t" that does not exist in the Routino database (not a highway node?).\n",segmentx.node2); |
585 | amb | 812 | |
586 | amb | 761 | nonode++; |
587 | amb | 812 | } |
588 | amb | 1155 | else if(prevnode1==segmentx.node1 && prevnode2==segmentx.node2) |
589 | { | ||
590 | amb | 1173 | if(prevway==segmentx.way) |
591 | ; /* already logged an error - only possible to get here for oneway opposite direction segments */ | ||
592 | else | ||
593 | { | ||
594 | if(!(prevdist&SEGMENT_AREA) && !(segmentx.distance&SEGMENT_AREA)) | ||
595 | logerror("Segment connecting nodes %"Pnode_t" and %"Pnode_t" is duplicated.\n",segmentx.node1,segmentx.node2); | ||
596 | amb | 1155 | |
597 | amb | 1173 | if(!(prevdist&SEGMENT_AREA) && (segmentx.distance&SEGMENT_AREA)) |
598 | logerror("Segment connecting nodes %"Pnode_t" and %"Pnode_t" is duplicated (discarded the area).\n",segmentx.node1,segmentx.node2); | ||
599 | amb | 1155 | |
600 | amb | 1173 | if((prevdist&SEGMENT_AREA) && !(segmentx.distance&SEGMENT_AREA)) |
601 | logerror("Segment connecting nodes %"Pnode_t" and %"Pnode_t" is duplicated (discarded the non-area).\n",segmentx.node1,segmentx.node2); | ||
602 | amb | 1155 | |
603 | amb | 1173 | if((prevdist&SEGMENT_AREA) && (segmentx.distance&SEGMENT_AREA)) |
604 | logerror("Segment connecting nodes %"Pnode_t" and %"Pnode_t" is duplicated (both are areas).\n",segmentx.node1,segmentx.node2); | ||
605 | } | ||
606 | amb | 1155 | |
607 | duplicate++; | ||
608 | } | ||
609 | amb | 275 | else |
610 | amb | 257 | { |
611 | amb | 275 | WriteFile(fd,&segmentx,sizeof(SegmentX)); |
612 | |||
613 | amb | 655 | SetBit(segmentsx->usednode,index1); |
614 | SetBit(segmentsx->usednode,index2); | ||
615 | amb | 643 | |
616 | amb | 1155 | prevnode1=segmentx.node1; |
617 | prevnode2=segmentx.node2; | ||
618 | amb | 1173 | prevway=segmentx.way; |
619 | amb | 1168 | prevdist=DISTANCE(segmentx.distance); |
620 | amb | 1155 | |
621 | amb | 275 | good++; |
622 | amb | 110 | } |
623 | |||
624 | amb | 275 | total++; |
625 | amb | 256 | |
626 | amb | 275 | if(!(total%10000)) |
627 | amb | 1231 | printf_middle("Checking Segments: Segments=%"Pindex_t" No-Way=%"Pindex_t" No-Node=%"Pindex_t" Duplicate=%"Pindex_t,total,noway,nonode,duplicate); |
628 | amb | 110 | } |
629 | |||
630 | amb | 555 | segmentsx->number=good; |
631 | amb | 275 | |
632 | amb | 555 | /* Close the files */ |
633 | |||
634 | amb | 612 | segmentsx->fd=CloseFile(segmentsx->fd); |
635 | amb | 275 | CloseFile(fd); |
636 | |||
637 | /* Print the final message */ | ||
638 | |||
639 | amb | 1231 | printf_last("Checked Segments: Segments=%"Pindex_t" No-Way=%"Pindex_t" No-Node=%"Pindex_t" Duplicate=%"Pindex_t,total,noway,nonode,duplicate); |
640 | amb | 110 | } |
641 | |||
642 | |||
643 | /*++++++++++++++++++++++++++++++++++++++ | ||
644 | amb | 285 | Measure the segments and replace node/way ids with indexes. |
645 | amb | 110 | |
646 | amb | 681 | SegmentsX *segmentsx The set of segments to process. |
647 | amb | 110 | |
648 | amb | 680 | NodesX *nodesx The set of nodes to use. |
649 | amb | 279 | |
650 | amb | 680 | WaysX *waysx The set of ways to use. |
651 | amb | 110 | ++++++++++++++++++++++++++++++++++++++*/ |
652 | |||
653 | amb | 681 | void MeasureSegments(SegmentsX *segmentsx,NodesX *nodesx,WaysX *waysx) |
654 | amb | 110 | { |
655 | amb | 279 | index_t index=0; |
656 | amb | 643 | int fd; |
657 | amb | 256 | SegmentX segmentx; |
658 | amb | 110 | |
659 | amb | 1208 | if(segmentsx->number==0) |
660 | return; | ||
661 | |||
662 | amb | 275 | /* Print the start message */ |
663 | |||
664 | amb | 519 | printf_first("Measuring Segments: Segments=0"); |
665 | amb | 227 | |
666 | amb | 555 | /* Map into memory / open the file */ |
667 | amb | 257 | |
668 | amb | 452 | #if !SLIM |
669 | amb | 1120 | nodesx->data=MapFile(nodesx->filename_tmp); |
670 | amb | 555 | #else |
671 | amb | 1120 | nodesx->fd=ReOpenFile(nodesx->filename_tmp); |
672 | amb | 452 | #endif |
673 | amb | 258 | |
674 | amb | 1100 | /* Allocate the way usage bitmask */ |
675 | |||
676 | segmentsx->usedway=AllocBitMask(waysx->number); | ||
677 | |||
678 | amb | 1166 | logassert(segmentsx->usedway,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */ |
679 | amb | 1100 | |
680 | amb | 555 | /* Re-open the file read-only and a new file writeable */ |
681 | amb | 275 | |
682 | amb | 1120 | segmentsx->fd=ReOpenFile(segmentsx->filename_tmp); |
683 | amb | 555 | |
684 | amb | 1120 | DeleteFile(segmentsx->filename_tmp); |
685 | amb | 256 | |
686 | amb | 1120 | fd=OpenFileNew(segmentsx->filename_tmp); |
687 | amb | 256 | |
688 | amb | 555 | /* Modify the on-disk image */ |
689 | |||
690 | amb | 256 | while(!ReadFile(segmentsx->fd,&segmentx,sizeof(SegmentX))) |
691 | amb | 110 | { |
692 | amb | 279 | index_t node1=IndexNodeX(nodesx,segmentx.node1); |
693 | index_t node2=IndexNodeX(nodesx,segmentx.node2); | ||
694 | index_t way =IndexWayX (waysx ,segmentx.way); | ||
695 | amb | 110 | |
696 | amb | 279 | NodeX *nodex1=LookupNodeX(nodesx,node1,1); |
697 | NodeX *nodex2=LookupNodeX(nodesx,node2,2); | ||
698 | |||
699 | /* Replace the node and way ids with their indexes */ | ||
700 | |||
701 | segmentx.node1=node1; | ||
702 | segmentx.node2=node2; | ||
703 | segmentx.way =way; | ||
704 | |||
705 | amb | 1100 | SetBit(segmentsx->usedway,segmentx.way); |
706 | |||
707 | amb | 1167 | /* Set the distance but keep the other flags except for area */ |
708 | amb | 275 | |
709 | amb | 1168 | segmentx.distance=DISTANCE(DistanceX(nodex1,nodex2))|DISTFLAG(segmentx.distance); |
710 | amb | 1169 | segmentx.distance&=~SEGMENT_AREA; |
711 | amb | 275 | |
712 | amb | 279 | /* Write the modified segment */ |
713 | |||
714 | amb | 275 | WriteFile(fd,&segmentx,sizeof(SegmentX)); |
715 | |||
716 | amb | 279 | index++; |
717 | amb | 275 | |
718 | amb | 279 | if(!(index%10000)) |
719 | amb | 790 | printf_middle("Measuring Segments: Segments=%"Pindex_t,index); |
720 | amb | 275 | } |
721 | amb | 110 | |
722 | amb | 555 | /* Close the files */ |
723 | amb | 257 | |
724 | amb | 612 | segmentsx->fd=CloseFile(segmentsx->fd); |
725 | amb | 275 | CloseFile(fd); |
726 | |||
727 | amb | 280 | /* Free the other now-unneeded indexes */ |
728 | amb | 279 | |
729 | free(nodesx->idata); | ||
730 | nodesx->idata=NULL; | ||
731 | |||
732 | free(waysx->idata); | ||
733 | waysx->idata=NULL; | ||
734 | |||
735 | amb | 555 | /* Unmap from memory / close the file */ |
736 | amb | 275 | |
737 | amb | 452 | #if !SLIM |
738 | amb | 1122 | nodesx->data=UnmapFile(nodesx->data); |
739 | amb | 555 | #else |
740 | amb | 612 | nodesx->fd=CloseFile(nodesx->fd); |
741 | amb | 452 | #endif |
742 | amb | 275 | |
743 | /* Print the final message */ | ||
744 | |||
745 | amb | 790 | printf_last("Measured Segments: Segments=%"Pindex_t,segmentsx->number); |
746 | amb | 275 | } |
747 | |||
748 | |||
749 | /*++++++++++++++++++++++++++++++++++++++ | ||
750 | amb | 1160 | Index the segments by creating the firstnode index and filling in the segment next2 parameter. |
751 | |||
752 | SegmentsX *segmentsx The set of segments to modify. | ||
753 | |||
754 | NodesX *nodesx The set of nodes to use. | ||
755 | |||
756 | WaysX *waysx The set of ways to use. | ||
757 | ++++++++++++++++++++++++++++++++++++++*/ | ||
758 | |||
759 | void IndexSegments(SegmentsX *segmentsx,NodesX *nodesx,WaysX *waysx) | ||
760 | { | ||
761 | index_t index,i; | ||
762 | |||
763 | if(segmentsx->number==0) | ||
764 | return; | ||
765 | |||
766 | /* Print the start message */ | ||
767 | |||
768 | printf_first("Indexing Segments: Segments=0"); | ||
769 | |||
770 | /* Allocate the array of indexes */ | ||
771 | |||
772 | if(segmentsx->firstnode) | ||
773 | free(segmentsx->firstnode); | ||
774 | |||
775 | segmentsx->firstnode=(index_t*)malloc(nodesx->number*sizeof(index_t)); | ||
776 | |||
777 | amb | 1166 | logassert(segmentsx->firstnode,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */ |
778 | amb | 1160 | |
779 | for(i=0;i<nodesx->number;i++) | ||
780 | segmentsx->firstnode[i]=NO_SEGMENT; | ||
781 | |||
782 | /* Map into memory / open the files */ | ||
783 | |||
784 | #if !SLIM | ||
785 | segmentsx->data=MapFileWriteable(segmentsx->filename_tmp); | ||
786 | #else | ||
787 | segmentsx->fd=ReOpenFileWriteable(segmentsx->filename_tmp); | ||
788 | #endif | ||
789 | |||
790 | /* Read through the segments in reverse order */ | ||
791 | |||
792 | for(index=segmentsx->number-1;index!=NO_SEGMENT;index--) | ||
793 | { | ||
794 | SegmentX *segmentx=LookupSegmentX(segmentsx,index,1); | ||
795 | |||
796 | if(nodesx->pdata) | ||
797 | { | ||
798 | segmentx->node1=nodesx->pdata[segmentx->node1]; | ||
799 | segmentx->node2=nodesx->pdata[segmentx->node2]; | ||
800 | } | ||
801 | |||
802 | if(waysx->cdata) | ||
803 | segmentx->way=waysx->cdata[segmentx->way]; | ||
804 | |||
805 | segmentx->next2=segmentsx->firstnode[segmentx->node2]; | ||
806 | |||
807 | PutBackSegmentX(segmentsx,segmentx); | ||
808 | |||
809 | segmentsx->firstnode[segmentx->node1]=index; | ||
810 | segmentsx->firstnode[segmentx->node2]=index; | ||
811 | |||
812 | if(!(index%10000)) | ||
813 | printf_middle("Indexing Segments: Segments=%"Pindex_t,segmentsx->number-index); | ||
814 | } | ||
815 | |||
816 | /* Unmap from memory / close the files */ | ||
817 | |||
818 | #if !SLIM | ||
819 | segmentsx->data=UnmapFile(segmentsx->data); | ||
820 | #else | ||
821 | segmentsx->fd=CloseFile(segmentsx->fd); | ||
822 | #endif | ||
823 | |||
824 | /* Free the memory */ | ||
825 | |||
826 | if(nodesx->pdata) | ||
827 | { | ||
828 | free(nodesx->pdata); | ||
829 | nodesx->pdata=NULL; | ||
830 | } | ||
831 | |||
832 | if(waysx->cdata) | ||
833 | { | ||
834 | free(waysx->cdata); | ||
835 | waysx->cdata=NULL; | ||
836 | } | ||
837 | |||
838 | /* Print the final message */ | ||
839 | |||
840 | printf_last("Indexed Segments: Segments=%"Pindex_t,segmentsx->number); | ||
841 | } | ||
842 | |||
843 | |||
844 | /*++++++++++++++++++++++++++++++++++++++ | ||
845 | Prune the deleted segments while resorting the list. | ||
846 | |||
847 | SegmentsX *segmentsx The set of segments to sort and modify. | ||
848 | |||
849 | WaysX *waysx The set of ways to check. | ||
850 | ++++++++++++++++++++++++++++++++++++++*/ | ||
851 | |||
852 | void RemovePrunedSegments(SegmentsX *segmentsx,WaysX *waysx) | ||
853 | { | ||
854 | int fd; | ||
855 | index_t xnumber; | ||
856 | |||
857 | amb | 1208 | if(segmentsx->number==0) |
858 | return; | ||
859 | |||
860 | amb | 1160 | /* Print the start message */ |
861 | |||
862 | printf_first("Sorting and Pruning Segments"); | ||
863 | |||
864 | /* Allocate the way usage bitmask */ | ||
865 | |||
866 | segmentsx->usedway=AllocBitMask(waysx->number); | ||
867 | |||
868 | amb | 1166 | logassert(segmentsx->usedway,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */ |
869 | amb | 1160 | |
870 | /* Re-open the file read-only and a new file writeable */ | ||
871 | |||
872 | segmentsx->fd=ReOpenFile(segmentsx->filename_tmp); | ||
873 | |||
874 | DeleteFile(segmentsx->filename_tmp); | ||
875 | |||
876 | fd=OpenFileNew(segmentsx->filename_tmp); | ||
877 | |||
878 | /* Sort by node indexes */ | ||
879 | |||
880 | xnumber=segmentsx->number; | ||
881 | |||
882 | sortsegmentsx=segmentsx; | ||
883 | |||
884 | segmentsx->number=filesort_fixed(segmentsx->fd,fd,sizeof(SegmentX),(int (*)(void*,index_t))delete_pruned, | ||
885 | (int (*)(const void*,const void*))sort_by_id, | ||
886 | NULL); | ||
887 | |||
888 | /* Close the files */ | ||
889 | |||
890 | segmentsx->fd=CloseFile(segmentsx->fd); | ||
891 | CloseFile(fd); | ||
892 | |||
893 | /* Print the final message */ | ||
894 | |||
895 | printf_last("Sorted and Pruned Segments: Segments=%"Pindex_t" Deleted=%"Pindex_t,xnumber,xnumber-segmentsx->number); | ||
896 | } | ||
897 | |||
898 | |||
899 | /*++++++++++++++++++++++++++++++++++++++ | ||
900 | Delete the pruned segments. | ||
901 | |||
902 | int delete_pruned Return 1 if the value is to be kept, otherwise 0. | ||
903 | |||
904 | SegmentX *segmentx The extended segment. | ||
905 | |||
906 | index_t index The number of unsorted segments that have been read from the input file. | ||
907 | ++++++++++++++++++++++++++++++++++++++*/ | ||
908 | |||
909 | static int delete_pruned(SegmentX *segmentx,index_t index) | ||
910 | { | ||
911 | if(IsPrunedSegmentX(segmentx)) | ||
912 | return(0); | ||
913 | |||
914 | SetBit(sortsegmentsx->usedway,segmentx->way); | ||
915 | |||
916 | return(1); | ||
917 | } | ||
918 | |||
919 | |||
920 | /*++++++++++++++++++++++++++++++++++++++ | ||
921 | amb | 1132 | Remove the duplicate super-segments. |
922 | amb | 110 | |
923 | amb | 1132 | SegmentsX *segmentsx The set of super-segments to modify. |
924 | amb | 110 | |
925 | amb | 680 | WaysX *waysx The set of ways to use. |
926 | amb | 110 | ++++++++++++++++++++++++++++++++++++++*/ |
927 | |||
928 | amb | 1132 | void DeduplicateSuperSegments(SegmentsX *segmentsx,WaysX *waysx) |
929 | amb | 110 | { |
930 | amb | 1132 | int fd; |
931 | index_t xnumber; | ||
932 | amb | 110 | |
933 | amb | 1208 | if(waysx->number==0) |
934 | return; | ||
935 | |||
936 | amb | 275 | /* Print the start message */ |
937 | |||
938 | amb | 1132 | printf_first("Sorting and Deduplicating Super-Segments"); |
939 | amb | 227 | |
940 | amb | 555 | /* Map into memory / open the file */ |
941 | amb | 256 | |
942 | amb | 452 | #if !SLIM |
943 | amb | 1120 | waysx->data=MapFile(waysx->filename_tmp); |
944 | amb | 555 | #else |
945 | amb | 1120 | waysx->fd=ReOpenFile(waysx->filename_tmp); |
946 | amb | 452 | #endif |
947 | amb | 275 | |
948 | amb | 555 | /* Re-open the file read-only and a new file writeable */ |
949 | amb | 275 | |
950 | amb | 1120 | segmentsx->fd=ReOpenFile(segmentsx->filename_tmp); |
951 | amb | 555 | |
952 | amb | 1120 | DeleteFile(segmentsx->filename_tmp); |
953 | amb | 275 | |
954 | amb | 1120 | fd=OpenFileNew(segmentsx->filename_tmp); |
955 | amb | 275 | |
956 | amb | 1132 | /* Sort by node indexes */ |
957 | amb | 555 | |
958 | amb | 1132 | xnumber=segmentsx->number; |
959 | amb | 256 | |
960 | amb | 1132 | sortsegmentsx=segmentsx; |
961 | sortwaysx=waysx; | ||
962 | amb | 110 | |
963 | amb | 1132 | segmentsx->number=filesort_fixed(segmentsx->fd,fd,sizeof(SegmentX),NULL, |
964 | (int (*)(const void*,const void*))sort_by_id, | ||
965 | (int (*)(void*,index_t))deduplicate_super); | ||
966 | amb | 264 | |
967 | amb | 555 | /* Close the files */ |
968 | |||
969 | amb | 612 | segmentsx->fd=CloseFile(segmentsx->fd); |
970 | amb | 275 | CloseFile(fd); |
971 | |||
972 | amb | 555 | /* Unmap from memory / close the file */ |
973 | amb | 275 | |
974 | amb | 452 | #if !SLIM |
975 | amb | 1122 | waysx->data=UnmapFile(waysx->data); |
976 | amb | 555 | #else |
977 | amb | 612 | waysx->fd=CloseFile(waysx->fd); |
978 | amb | 452 | #endif |
979 | amb | 275 | |
980 | /* Print the final message */ | ||
981 | |||
982 | amb | 1132 | printf_last("Sorted and Deduplicated Super-Segments: Super-Segments=%"Pindex_t" Duplicate=%"Pindex_t,xnumber,xnumber-segmentsx->number); |
983 | amb | 110 | } |
984 | |||
985 | |||
986 | /*++++++++++++++++++++++++++++++++++++++ | ||
987 | amb | 1132 | De-duplicate super-segments. |
988 | |||
989 | int deduplicate_super Return 1 if the value is to be kept, otherwise 0. | ||
990 | |||
991 | SegmentX *segmentx The extended super-segment. | ||
992 | |||
993 | index_t index The number of sorted super-segments that have already been written to the output file. | ||
994 | ++++++++++++++++++++++++++++++++++++++*/ | ||
995 | |||
996 | static int deduplicate_super(SegmentX *segmentx,index_t index) | ||
997 | { | ||
998 | static int nprev=0; | ||
999 | static index_t prevnode1=NO_NODE,prevnode2=NO_NODE; | ||
1000 | static SegmentX prevsegx[MAX_SEG_PER_NODE]; | ||
1001 | static Way prevway[MAX_SEG_PER_NODE]; | ||
1002 | |||
1003 | WayX *wayx=LookupWayX(sortwaysx,segmentx->way,1); | ||
1004 | int isduplicate=0; | ||
1005 | |||
1006 | if(index==0 || segmentx->node1!=prevnode1 || segmentx->node2!=prevnode2) | ||
1007 | { | ||
1008 | nprev=1; | ||
1009 | prevnode1=segmentx->node1; | ||
1010 | prevnode2=segmentx->node2; | ||
1011 | prevsegx[0]=*segmentx; | ||
1012 | prevway[0] =wayx->way; | ||
1013 | } | ||
1014 | else | ||
1015 | { | ||
1016 | int offset; | ||
1017 | |||
1018 | for(offset=0;offset<nprev;offset++) | ||
1019 | { | ||
1020 | amb | 1168 | if(DISTFLAG(segmentx->distance)==DISTFLAG(prevsegx[offset].distance)) |
1021 | amb | 1132 | if(!WaysCompare(&prevway[offset],&wayx->way)) |
1022 | { | ||
1023 | isduplicate=1; | ||
1024 | break; | ||
1025 | } | ||
1026 | } | ||
1027 | |||
1028 | if(isduplicate) | ||
1029 | { | ||
1030 | nprev--; | ||
1031 | |||
1032 | for(;offset<nprev;offset++) | ||
1033 | { | ||
1034 | prevsegx[offset]=prevsegx[offset+1]; | ||
1035 | prevway[offset] =prevway[offset+1]; | ||
1036 | } | ||
1037 | } | ||
1038 | else | ||
1039 | { | ||
1040 | amb | 1166 | logassert(nprev<MAX_SEG_PER_NODE,"Too many segments for one node (increase MAX_SEG_PER_NODE?)"); /* Only a limited amount of information stored. */ |
1041 | amb | 1132 | |
1042 | prevsegx[nprev]=*segmentx; | ||
1043 | prevway[nprev] =wayx->way; | ||
1044 | |||
1045 | nprev++; | ||
1046 | } | ||
1047 | } | ||
1048 | |||
1049 | return(!isduplicate); | ||
1050 | } | ||
1051 | |||
1052 | |||
1053 | /*++++++++++++++++++++++++++++++++++++++ | ||
1054 | amb | 1160 | Sort the segments geographically after updating the node indexes. |
1055 | amb | 209 | |
1056 | amb | 681 | SegmentsX *segmentsx The set of segments to modify. |
1057 | amb | 209 | |
1058 | amb | 1100 | NodesX *nodesx The set of nodes to use. |
1059 | amb | 209 | ++++++++++++++++++++++++++++++++++++++*/ |
1060 | |||
1061 | amb | 1160 | void SortSegmentListGeographically(SegmentsX *segmentsx,NodesX *nodesx) |
1062 | amb | 209 | { |
1063 | amb | 1160 | int fd; |
1064 | amb | 209 | |
1065 | amb | 1208 | if(segmentsx->number==0) |
1066 | return; | ||
1067 | |||
1068 | amb | 275 | /* Print the start message */ |
1069 | |||
1070 | amb | 1160 | printf_first("Sorting Segments Geographically"); |
1071 | amb | 227 | |
1072 | amb | 1160 | /* Re-open the file read-only and a new file writeable */ |
1073 | amb | 643 | |
1074 | amb | 1160 | segmentsx->fd=ReOpenFile(segmentsx->filename_tmp); |
1075 | amb | 643 | |
1076 | amb | 1160 | DeleteFile(segmentsx->filename_tmp); |
1077 | amb | 643 | |
1078 | amb | 1160 | fd=OpenFileNew(segmentsx->filename_tmp); |
1079 | amb | 1102 | |
1080 | amb | 1160 | /* Update the segments with geographically sorted node indexes and sort them */ |
1081 | amb | 643 | |
1082 | amb | 1160 | sortnodesx=nodesx; |
1083 | amb | 209 | |
1084 | amb | 1160 | filesort_fixed(segmentsx->fd,fd,sizeof(SegmentX),(int (*)(void*,index_t))geographically_index, |
1085 | (int (*)(const void*,const void*))sort_by_id, | ||
1086 | NULL); | ||
1087 | /* Close the files */ | ||
1088 | amb | 275 | |
1089 | amb | 1160 | segmentsx->fd=CloseFile(segmentsx->fd); |
1090 | CloseFile(fd); | ||
1091 | amb | 280 | |
1092 | amb | 1160 | /* Print the final message */ |
1093 | amb | 209 | |
1094 | amb | 1160 | printf_last("Sorted Segments Geographically: Segments=%"Pindex_t,segmentsx->number); |
1095 | } | ||
1096 | amb | 1098 | |
1097 | amb | 1100 | |
1098 | amb | 1160 | /*++++++++++++++++++++++++++++++++++++++ |
1099 | Update the segment indexes. | ||
1100 | amb | 209 | |
1101 | amb | 1160 | int geographically_index Return 1 if the value is to be kept, otherwise 0. |
1102 | amb | 448 | |
1103 | amb | 1160 | SegmentX *segmentx The extended segment. |
1104 | amb | 558 | |
1105 | amb | 1160 | index_t index The number of unsorted segments that have been read from the input file. |
1106 | ++++++++++++++++++++++++++++++++++++++*/ | ||
1107 | amb | 209 | |
1108 | amb | 1160 | static int geographically_index(SegmentX *segmentx,index_t index) |
1109 | { | ||
1110 | segmentx->node1=sortnodesx->gdata[segmentx->node1]; | ||
1111 | segmentx->node2=sortnodesx->gdata[segmentx->node2]; | ||
1112 | amb | 275 | |
1113 | amb | 1160 | if(segmentx->node1>segmentx->node2) |
1114 | { | ||
1115 | index_t temp; | ||
1116 | amb | 275 | |
1117 | amb | 1160 | temp=segmentx->node1; |
1118 | segmentx->node1=segmentx->node2; | ||
1119 | segmentx->node2=temp; | ||
1120 | amb | 1100 | |
1121 | amb | 1168 | if(segmentx->distance&(ONEWAY_2TO1|ONEWAY_1TO2)) |
1122 | segmentx->distance^=ONEWAY_2TO1|ONEWAY_1TO2; | ||
1123 | amb | 1100 | } |
1124 | |||
1125 | amb | 1160 | return(1); |
1126 | amb | 209 | } |
1127 | |||
1128 | |||
1129 | /*++++++++++++++++++++++++++++++++++++++ | ||
1130 | amb | 285 | Save the segment list to a file. |
1131 | |||
1132 | amb | 681 | SegmentsX *segmentsx The set of segments to save. |
1133 | amb | 285 | |
1134 | const char *filename The name of the file to save. | ||
1135 | ++++++++++++++++++++++++++++++++++++++*/ | ||
1136 | |||
1137 | amb | 681 | void SaveSegmentList(SegmentsX *segmentsx,const char *filename) |
1138 | amb | 285 | { |
1139 | index_t i; | ||
1140 | int fd; | ||
1141 | amb | 500 | SegmentsFile segmentsfile={0}; |
1142 | amb | 780 | index_t super_number=0,normal_number=0; |
1143 | amb | 285 | |
1144 | /* Print the start message */ | ||
1145 | |||
1146 | amb | 519 | printf_first("Writing Segments: Segments=0"); |
1147 | amb | 285 | |
1148 | amb | 558 | /* Re-open the file */ |
1149 | |||
1150 | amb | 1120 | segmentsx->fd=ReOpenFile(segmentsx->filename_tmp); |
1151 | amb | 558 | |
1152 | amb | 461 | /* Write out the segments data */ |
1153 | amb | 285 | |
1154 | amb | 502 | fd=OpenFileNew(filename); |
1155 | amb | 461 | |
1156 | SeekFile(fd,sizeof(SegmentsFile)); | ||
1157 | |||
1158 | amb | 285 | for(i=0;i<segmentsx->number;i++) |
1159 | { | ||
1160 | amb | 643 | SegmentX segmentx; |
1161 | amb | 944 | Segment segment={0}; |
1162 | amb | 448 | |
1163 | amb | 643 | ReadFile(segmentsx->fd,&segmentx,sizeof(SegmentX)); |
1164 | amb | 558 | |
1165 | amb | 1168 | segment.node1 =segmentx.node1; |
1166 | segment.node2 =segmentx.node2; | ||
1167 | segment.next2 =segmentx.next2; | ||
1168 | segment.way =segmentx.way; | ||
1169 | segment.distance=segmentx.distance; | ||
1170 | amb | 643 | |
1171 | amb | 558 | if(IsSuperSegment(&segment)) |
1172 | amb | 285 | super_number++; |
1173 | amb | 558 | if(IsNormalSegment(&segment)) |
1174 | amb | 285 | normal_number++; |
1175 | |||
1176 | amb | 558 | WriteFile(fd,&segment,sizeof(Segment)); |
1177 | amb | 448 | |
1178 | amb | 285 | if(!((i+1)%10000)) |
1179 | amb | 790 | printf_middle("Writing Segments: Segments=%"Pindex_t,i+1); |
1180 | amb | 285 | } |
1181 | |||
1182 | amb | 461 | /* Write out the header structure */ |
1183 | |||
1184 | segmentsfile.number=segmentsx->number; | ||
1185 | segmentsfile.snumber=super_number; | ||
1186 | segmentsfile.nnumber=normal_number; | ||
1187 | |||
1188 | SeekFile(fd,0); | ||
1189 | WriteFile(fd,&segmentsfile,sizeof(SegmentsFile)); | ||
1190 | |||
1191 | amb | 285 | CloseFile(fd); |
1192 | |||
1193 | amb | 558 | /* Close the file */ |
1194 | |||
1195 | amb | 643 | segmentsx->fd=CloseFile(segmentsx->fd); |
1196 | amb | 558 | |
1197 | amb | 285 | /* Print the final message */ |
1198 | |||
1199 | amb | 790 | printf_last("Wrote Segments: Segments=%"Pindex_t,segmentsx->number); |
1200 | amb | 285 | } |
1201 | |||
1202 | |||
1203 | /*++++++++++++++++++++++++++++++++++++++ | ||
1204 | amb | 110 | Calculate the distance between two nodes. |
1205 | |||
1206 | amb | 1168 | distance_t DistanceX Returns the distance between the extended nodes. |
1207 | amb | 110 | |
1208 | NodeX *nodex1 The starting node. | ||
1209 | |||
1210 | NodeX *nodex2 The end node. | ||
1211 | ++++++++++++++++++++++++++++++++++++++*/ | ||
1212 | |||
1213 | amb | 1168 | static distance_t DistanceX(NodeX *nodex1,NodeX *nodex2) |
1214 | amb | 110 | { |
1215 | amb | 223 | double dlon = latlong_to_radians(nodex1->longitude) - latlong_to_radians(nodex2->longitude); |
1216 | double dlat = latlong_to_radians(nodex1->latitude) - latlong_to_radians(nodex2->latitude); | ||
1217 | double lat1 = latlong_to_radians(nodex1->latitude); | ||
1218 | double lat2 = latlong_to_radians(nodex2->latitude); | ||
1219 | amb | 110 | |
1220 | amb | 219 | double a1,a2,a,sa,c,d; |
1221 | amb | 110 | |
1222 | if(dlon==0 && dlat==0) | ||
1223 | return 0; | ||
1224 | |||
1225 | amb | 219 | a1 = sin (dlat / 2); |
1226 | a2 = sin (dlon / 2); | ||
1227 | a = (a1 * a1) + cos (lat1) * cos (lat2) * a2 * a2; | ||
1228 | sa = sqrt (a); | ||
1229 | amb | 110 | if (sa <= 1.0) |
1230 | amb | 219 | {c = 2 * asin (sa);} |
1231 | amb | 110 | else |
1232 | amb | 219 | {c = 2 * asin (1.0);} |
1233 | amb | 110 | d = 6378.137 * c; |
1234 | |||
1235 | return km_to_distance(d); | ||
1236 | } |
Properties
Name | Value |
---|---|
cvs:description | Extended segments functions. |