Routino SVN Repository Browser

Check out the latest version of Routino: svn co http://routino.org/svn/trunk routino

ViewVC logotype

Annotation of /trunk/src/segmentsx.c

Parent Directory Parent Directory | Revision Log 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)
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.