Routino SVN Repository Browser

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

/[routino]/trunk/src/nodesx.c
ViewVC logotype

Contents of /trunk/src/nodesx.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 463 - (show annotations) (download) (as text)
Sat Jul 31 10:28:52 2010 UTC (14 years, 8 months ago) by amb
File MIME type: text/x-csrc
File size: 19430 byte(s) 
Remove the assert statements that check the order of calling the functions.
1 /***************************************
2 $Header: /home/amb/CVS/routino/src/nodesx.c,v 1.64 2010-07-31 10:28:52 amb Exp $
3
4 Extented Node data type functions.
5
6 Part of the Routino routing software.
7 ******************/ /******************
8 This file Copyright 2008-2010 Andrew M. Bishop
9
10 This program is free software: you can redistribute it and/or modify
11 it under the terms of the GNU Affero General Public License as published by
12 the Free Software Foundation, either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU Affero General Public License for more details.
19
20 You should have received a copy of the GNU Affero General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 ***************************************/
23
24
25 #include <assert.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <sys/stat.h>
30
31 #include "types.h"
32 #include "nodes.h"
33 #include "segments.h"
34
35 #include "nodesx.h"
36 #include "segmentsx.h"
37 #include "waysx.h"
38
39 #include "files.h"
40 #include "functions.h"
41
42
43 /* Variables */
44
45 /*+ The command line '--tmpdir' option or its default value. +*/
46 extern char *option_tmpdirname;
47
48 /*+ A temporary file-local variable for use by the sort functions. +*/
49 static NodesX *sortnodesx;
50
51 /* Functions */
52
53 static int sort_by_id(NodeX *a,NodeX *b);
54 static int index_by_id(NodeX *nodex,index_t index);
55
56 static int sort_by_lat_long(NodeX *a,NodeX *b);
57 static int index_by_lat_long(NodeX *nodex,index_t index);
58
59
60 /*++++++++++++++++++++++++++++++++++++++
61 Allocate a new node list (create a new file or open an existing one).
62
63 NodesX *NewNodeList Returns the node list.
64
65 int append Set to 1 if the file is to be opened for appending (now or later).
66 ++++++++++++++++++++++++++++++++++++++*/
67
68 NodesX *NewNodeList(int append)
69 {
70 NodesX *nodesx;
71
72 nodesx=(NodesX*)calloc(1,sizeof(NodesX));
73
74 assert(nodesx); /* Check calloc() worked */
75
76 nodesx->filename=(char*)malloc(strlen(option_tmpdirname)+32);
77
78 if(append)
79 sprintf(nodesx->filename,"%s/nodesx.input.tmp",option_tmpdirname);
80 else
81 sprintf(nodesx->filename,"%s/nodesx.%p.tmp",option_tmpdirname,nodesx);
82
83 #if SLIM
84 nodesx->nfilename=(char*)malloc(strlen(option_tmpdirname)+32);
85
86 sprintf(nodesx->nfilename,"%s/nodes.%p.tmp",option_tmpdirname,nodesx);
87 #endif
88
89 if(append)
90 {
91 off_t size;
92
93 nodesx->fd=AppendFile(nodesx->filename);
94
95 size=SizeFile(nodesx->filename);
96
97 nodesx->xnumber=size/sizeof(NodeX);
98 }
99 else
100 nodesx->fd=OpenFile(nodesx->filename);
101
102 return(nodesx);
103 }
104
105
106 /*++++++++++++++++++++++++++++++++++++++
107 Free a node list.
108
109 NodesX *nodesx The list to be freed.
110
111 int keep Set to 1 if the file is to be kept.
112 ++++++++++++++++++++++++++++++++++++++*/
113
114 void FreeNodeList(NodesX *nodesx,int keep)
115 {
116 if(!keep)
117 DeleteFile(nodesx->filename);
118
119 free(nodesx->filename);
120
121 if(nodesx->idata)
122 free(nodesx->idata);
123
124 #if !SLIM
125 if(nodesx->ndata)
126 free(nodesx->ndata);
127 #endif
128
129 #if SLIM
130 DeleteFile(nodesx->nfilename);
131
132 free(nodesx->nfilename);
133 #endif
134
135 if(nodesx->super)
136 free(nodesx->super);
137
138 if(nodesx->offsets)
139 free(nodesx->offsets);
140
141 free(nodesx);
142 }
143
144
145 /*++++++++++++++++++++++++++++++++++++++
146 Append a node to a newly created node list (unsorted).
147
148 NodesX* nodesx The set of nodes to process.
149
150 node_t id The node identification.
151
152 double latitude The latitude of the node.
153
154 double longitude The longitude of the node.
155 ++++++++++++++++++++++++++++++++++++++*/
156
157 void AppendNode(NodesX* nodesx,node_t id,double latitude,double longitude)
158 {
159 NodeX nodex;
160
161 nodex.id=id;
162 nodex.latitude =radians_to_latlong(latitude);
163 nodex.longitude=radians_to_latlong(longitude);
164
165 WriteFile(nodesx->fd,&nodex,sizeof(NodeX));
166
167 nodesx->xnumber++;
168 }
169
170
171 /*++++++++++++++++++++++++++++++++++++++
172 Sort the node list (i.e. create the sortable indexes).
173
174 NodesX* nodesx The set of nodes to process.
175 ++++++++++++++++++++++++++++++++++++++*/
176
177 void SortNodeList(NodesX* nodesx)
178 {
179 int fd;
180
181 /* Print the start message */
182
183 printf("Sorting Nodes");
184 fflush(stdout);
185
186 /* Close the files and re-open them (finished appending) */
187
188 CloseFile(nodesx->fd);
189 nodesx->fd=ReOpenFile(nodesx->filename);
190
191 DeleteFile(nodesx->filename);
192
193 fd=OpenFile(nodesx->filename);
194
195 /* Allocate the array of indexes */
196
197 nodesx->idata=(node_t*)malloc(nodesx->xnumber*sizeof(node_t));
198
199 assert(nodesx->idata); /* Check malloc() worked */
200
201 /* Sort by node indexes */
202
203 sortnodesx=nodesx;
204
205 filesort_fixed(nodesx->fd,fd,sizeof(NodeX),(int (*)(const void*,const void*))sort_by_id,(int (*)(void*,index_t))index_by_id);
206
207 /* Close the files and re-open them */
208
209 CloseFile(nodesx->fd);
210 CloseFile(fd);
211
212 nodesx->fd=ReOpenFile(nodesx->filename);
213
214 /* Print the final message */
215
216 printf("\rSorted Nodes: Nodes=%d Duplicates=%d\n",nodesx->xnumber,nodesx->xnumber-nodesx->number);
217 fflush(stdout);
218 }
219
220
221 /*++++++++++++++++++++++++++++++++++++++
222 Sort the nodes into id order.
223
224 int sort_by_id Returns the comparison of the id fields.
225
226 NodeX *a The first extended node.
227
228 NodeX *b The second extended node.
229 ++++++++++++++++++++++++++++++++++++++*/
230
231 static int sort_by_id(NodeX *a,NodeX *b)
232 {
233 node_t a_id=a->id;
234 node_t b_id=b->id;
235
236 if(a_id<b_id)
237 return(-1);
238 else if(a_id>b_id)
239 return(1);
240 else
241 return(0);
242 }
243
244
245 /*++++++++++++++++++++++++++++++++++++++
246 Index the nodes after sorting.
247
248 int index_by_id Return 1 if the value is to be kept, otherwise zero.
249
250 NodeX *nodex The extended node.
251
252 index_t index The index of this node in the total.
253 ++++++++++++++++++++++++++++++++++++++*/
254
255 static int index_by_id(NodeX *nodex,index_t index)
256 {
257 if(index==0 || sortnodesx->idata[index-1]!=nodex->id)
258 {
259 sortnodesx->idata[index]=nodex->id;
260
261 sortnodesx->number++;
262
263 return(1);
264 }
265
266 return(0);
267 }
268
269
270 /*++++++++++++++++++++++++++++++++++++++
271 Sort the node list geographically.
272
273 NodesX* nodesx The set of nodes to process.
274 ++++++++++++++++++++++++++++++++++++++*/
275
276 void SortNodeListGeographically(NodesX* nodesx)
277 {
278 int fd;
279
280 /* Print the start message */
281
282 printf("Sorting Nodes Geographically");
283 fflush(stdout);
284
285 /* Allocate the memory for the geographical offsets array */
286
287 nodesx->offsets=(index_t*)malloc((nodesx->latbins*nodesx->lonbins+1)*sizeof(index_t));
288
289 nodesx->latlonbin=0;
290
291 /* Close the files and re-open them */
292
293 CloseFile(nodesx->fd);
294 nodesx->fd=ReOpenFile(nodesx->filename);
295
296 DeleteFile(nodesx->filename);
297
298 fd=OpenFile(nodesx->filename);
299
300 /* Sort geographically */
301
302 sortnodesx=nodesx;
303
304 filesort_fixed(nodesx->fd,fd,sizeof(NodeX),(int (*)(const void*,const void*))sort_by_lat_long,(int (*)(void*,index_t))index_by_lat_long);
305
306 /* Close the files and re-open them */
307
308 CloseFile(nodesx->fd);
309 CloseFile(fd);
310
311 nodesx->fd=ReOpenFile(nodesx->filename);
312
313 /* Finish off the indexing */
314
315 for(;nodesx->latlonbin<=(nodesx->latbins*nodesx->lonbins);nodesx->latlonbin++)
316 nodesx->offsets[nodesx->latlonbin]=nodesx->number;
317
318 /* Print the final message */
319
320 printf("\rSorted Nodes Geographically \n");
321 fflush(stdout);
322 }
323
324
325 /*++++++++++++++++++++++++++++++++++++++
326 Sort the nodes into latitude and longitude order.
327
328 int sort_by_lat_long Returns the comparison of the latitude and longitude fields.
329
330 NodeX *a The first extended node.
331
332 NodeX *b The second extended node.
333 ++++++++++++++++++++++++++++++++++++++*/
334
335 static int sort_by_lat_long(NodeX *a,NodeX *b)
336 {
337 ll_bin_t a_lon=latlong_to_bin(a->longitude);
338 ll_bin_t b_lon=latlong_to_bin(b->longitude);
339
340 if(a_lon<b_lon)
341 return(-1);
342 else if(a_lon>b_lon)
343 return(1);
344 else
345 {
346 ll_bin_t a_lat=latlong_to_bin(a->latitude);
347 ll_bin_t b_lat=latlong_to_bin(b->latitude);
348
349 if(a_lat<b_lat)
350 return(-1);
351 else if(a_lat>b_lat)
352 return(1);
353 else
354 {
355 #ifdef REGRESSION_TESTING
356 // Need this for regression testing because heapsort() is not order
357 // preserving like qsort() is (or was when tested).
358
359 index_t a_id=a->id;
360 index_t b_id=b->id;
361
362 if(a_id<b_id)
363 return(-1);
364 else if(a_id>b_id)
365 return(1);
366 else
367 #endif
368 return(0);
369 }
370 }
371 }
372
373
374 /*++++++++++++++++++++++++++++++++++++++
375 Index the nodes after sorting.
376
377 int index_by_lat_long Return 1 if the value is to be kept, otherwise zero.
378
379 NodeX *nodex The extended node.
380
381 index_t index The index of this node in the total.
382 ++++++++++++++++++++++++++++++++++++++*/
383
384 static int index_by_lat_long(NodeX *nodex,index_t index)
385 {
386 /* Work out the offsets */
387
388 ll_bin_t latbin=latlong_to_bin(nodex->latitude )-sortnodesx->latzero;
389 ll_bin_t lonbin=latlong_to_bin(nodex->longitude)-sortnodesx->lonzero;
390 int llbin=lonbin*sortnodesx->latbins+latbin;
391
392 for(;sortnodesx->latlonbin<=llbin;sortnodesx->latlonbin++)
393 sortnodesx->offsets[sortnodesx->latlonbin]=index;
394
395 return(1);
396 }
397
398
399 /*++++++++++++++++++++++++++++++++++++++
400 Find a particular node index.
401
402 index_t IndexNodeX Returns the index of the extended node with the specified id.
403
404 NodesX* nodesx The set of nodes to process.
405
406 node_t id The node id to look for.
407 ++++++++++++++++++++++++++++++++++++++*/
408
409 index_t IndexNodeX(NodesX* nodesx,node_t id)
410 {
411 int start=0;
412 int end=nodesx->number-1;
413 int mid;
414
415 /* Binary search - search key exact match only is required.
416 *
417 * # <- start | Check mid and move start or end if it doesn't match
418 * # |
419 * # | Since an exact match is wanted we can set end=mid-1
420 * # <- mid | or start=mid+1 because we know that mid doesn't match.
421 * # |
422 * # | Eventually either end=start or end=start+1 and one of
423 * # <- end | start or end is the wanted one.
424 */
425
426 if(end<start) /* There are no nodes */
427 return(NO_NODE);
428 else if(id<nodesx->idata[start]) /* Check key is not before start */
429 return(NO_NODE);
430 else if(id>nodesx->idata[end]) /* Check key is not after end */
431 return(NO_NODE);
432 else
433 {
434 do
435 {
436 mid=(start+end)/2; /* Choose mid point */
437
438 if(nodesx->idata[mid]<id) /* Mid point is too low */
439 start=mid+1;
440 else if(nodesx->idata[mid]>id) /* Mid point is too high */
441 end=mid-1;
442 else /* Mid point is correct */
443 return(mid);
444 }
445 while((end-start)>1);
446
447 if(nodesx->idata[start]==id) /* Start is correct */
448 return(start);
449
450 if(nodesx->idata[end]==id) /* End is correct */
451 return(end);
452 }
453
454 return(NO_NODE);
455 }
456
457
458 /*++++++++++++++++++++++++++++++++++++++
459 Remove any nodes that are not part of a highway.
460
461 NodesX *nodesx The complete node list.
462
463 SegmentsX *segmentsx The list of segments.
464 ++++++++++++++++++++++++++++++++++++++*/
465
466 void RemoveNonHighwayNodes(NodesX *nodesx,SegmentsX *segmentsx)
467 {
468 NodeX nodex;
469 int total=0,highway=0,nothighway=0;
470 ll_bin_t lat_min_bin,lat_max_bin,lon_min_bin,lon_max_bin;
471 latlong_t lat_min,lat_max,lon_min,lon_max;
472 int fd;
473
474 /* Print the start message */
475
476 printf("Checking: Nodes=0");
477 fflush(stdout);
478
479 /* While we are here we can work out the range of data */
480
481 lat_min=radians_to_latlong( 2);
482 lat_max=radians_to_latlong(-2);
483 lon_min=radians_to_latlong( 4);
484 lon_max=radians_to_latlong(-4);
485
486 /* Modify the on-disk image */
487
488 DeleteFile(nodesx->filename);
489
490 fd=OpenFile(nodesx->filename);
491 SeekFile(nodesx->fd,0);
492
493 while(!ReadFile(nodesx->fd,&nodex,sizeof(NodeX)))
494 {
495 if(IndexFirstSegmentX(segmentsx,nodex.id)==NO_SEGMENT)
496 nothighway++;
497 else
498 {
499 nodex.id=highway;
500
501 WriteFile(fd,&nodex,sizeof(NodeX));
502
503 nodesx->idata[highway]=nodesx->idata[total];
504 highway++;
505
506 if(nodex.latitude<lat_min)
507 lat_min=nodex.latitude;
508 if(nodex.latitude>lat_max)
509 lat_max=nodex.latitude;
510 if(nodex.longitude<lon_min)
511 lon_min=nodex.longitude;
512 if(nodex.longitude>lon_max)
513 lon_max=nodex.longitude;
514 }
515
516 total++;
517
518 if(!(total%10000))
519 {
520 printf("\rChecking: Nodes=%d Highway=%d not-Highway=%d",total,highway,nothighway);
521 fflush(stdout);
522 }
523 }
524
525 /* Close the files and re-open them */
526
527 CloseFile(nodesx->fd);
528 CloseFile(fd);
529
530 nodesx->fd=ReOpenFile(nodesx->filename);
531
532 nodesx->number=highway;
533
534 /* Work out the number of bins */
535
536 lat_min_bin=latlong_to_bin(lat_min);
537 lon_min_bin=latlong_to_bin(lon_min);
538 lat_max_bin=latlong_to_bin(lat_max);
539 lon_max_bin=latlong_to_bin(lon_max);
540
541 nodesx->latzero=lat_min_bin;
542 nodesx->lonzero=lon_min_bin;
543
544 nodesx->latbins=(lat_max_bin-lat_min_bin)+1;
545 nodesx->lonbins=(lon_max_bin-lon_min_bin)+1;
546
547 /* Allocate and clear the super-node markers */
548
549 nodesx->super=(uint8_t*)calloc(nodesx->number,sizeof(uint8_t));
550
551 assert(nodesx->super); /* Check calloc() worked */
552
553 /* Print the final message */
554
555 printf("\rChecked: Nodes=%d Highway=%d not-Highway=%d \n",total,highway,nothighway);
556 fflush(stdout);
557 }
558
559
560 /*++++++++++++++++++++++++++++++++++++++
561 Create the real node data.
562
563 NodesX *nodesx The set of nodes to use.
564
565 int iteration The final super-node iteration.
566 ++++++++++++++++++++++++++++++++++++++*/
567
568 void CreateRealNodes(NodesX *nodesx,int iteration)
569 {
570 index_t i;
571
572 /* Print the start message */
573
574 printf("Creating Real Nodes: Nodes=0");
575 fflush(stdout);
576
577 /* Map into memory */
578
579 #if !SLIM
580 nodesx->xdata=MapFile(nodesx->filename);
581 #endif
582
583 /* Allocate the memory (or open the file) */
584
585 #if !SLIM
586 nodesx->ndata=(Node*)malloc(nodesx->number*sizeof(Node));
587
588 assert(nodesx->ndata); /* Check malloc() worked */
589 #else
590 nodesx->nfd=OpenFile(nodesx->nfilename);
591 #endif
592
593 /* Loop through and allocate. */
594
595 for(i=0;i<nodesx->number;i++)
596 {
597 NodeX *nodex=LookupNodeX(nodesx,i,1);
598 Node *node =LookupNodeXNode(nodesx,nodex->id,1);
599
600 node->latoffset=latlong_to_off(nodex->latitude);
601 node->lonoffset=latlong_to_off(nodex->longitude);
602 node->firstseg=SEGMENT(NO_SEGMENT);
603
604 if(nodesx->super[nodex->id]==iteration)
605 node->firstseg|=NODE_SUPER;
606
607 #if SLIM
608 PutBackNodeXNode(nodesx,nodex->id,1);
609 #endif
610
611 if(!((i+1)%10000))
612 {
613 printf("\rCreating Real Nodes: Nodes=%d",i+1);
614 fflush(stdout);
615 }
616 }
617
618 /* Free the unneeded memory */
619
620 free(nodesx->super);
621 nodesx->super=NULL;
622
623 /* Unmap from memory */
624
625 #if !SLIM
626 nodesx->xdata=UnmapFile(nodesx->filename);
627 #endif
628
629 /* Print the final message */
630
631 printf("\rCreating Real Nodes: Nodes=%d \n",nodesx->number);
632 fflush(stdout);
633 }
634
635
636 /*++++++++++++++++++++++++++++++++++++++
637 Assign the segment indexes to the nodes.
638
639 NodesX *nodesx The list of nodes to process.
640
641 SegmentsX* segmentsx The set of segments to use.
642 ++++++++++++++++++++++++++++++++++++++*/
643
644 void IndexNodes(NodesX *nodesx,SegmentsX *segmentsx)
645 {
646 index_t i;
647
648 /* Print the start message */
649
650 printf("Indexing Segments: Segments=0");
651 fflush(stdout);
652
653 /* Map into memory */
654
655 #if !SLIM
656 nodesx->xdata=MapFile(nodesx->filename);
657 segmentsx->xdata=MapFile(segmentsx->filename);
658 #endif
659
660 /* Index the nodes */
661
662 for(i=0;i<segmentsx->number;i++)
663 {
664 SegmentX *segmentx=LookupSegmentX(segmentsx,i,1);
665 node_t id1=segmentx->node1;
666 node_t id2=segmentx->node2;
667 Node *node1=LookupNodeXNode(nodesx,id1,1);
668 Node *node2=LookupNodeXNode(nodesx,id2,2);
669
670 /* Check node1 */
671
672 if(SEGMENT(node1->firstseg)==SEGMENT(NO_SEGMENT))
673 {
674 node1->firstseg^=SEGMENT(NO_SEGMENT);
675 node1->firstseg|=i;
676
677 #if SLIM
678 PutBackNodeXNode(nodesx,id1,1);
679 #endif
680 }
681 else
682 {
683 index_t index=SEGMENT(node1->firstseg);
684
685 do
686 {
687 segmentx=LookupSegmentX(segmentsx,index,1);
688
689 if(segmentx->node1==id1)
690 {
691 index++;
692
693 if(index>=segmentsx->number)
694 break;
695
696 segmentx=LookupSegmentX(segmentsx,index,1);
697
698 if(segmentx->node1!=id1)
699 break;
700 }
701 else
702 {
703 Segment *segment=LookupSegmentXSegment(segmentsx,index,1);
704
705 if(segment->next2==NO_NODE)
706 {
707 segment->next2=i;
708
709 #if SLIM
710 PutBackSegmentXSegment(segmentsx,index,1);
711 #endif
712
713 break;
714 }
715 else
716 index=segment->next2;
717 }
718 }
719 while(1);
720 }
721
722 /* Check node2 */
723
724 if(SEGMENT(node2->firstseg)==SEGMENT(NO_SEGMENT))
725 {
726 node2->firstseg^=SEGMENT(NO_SEGMENT);
727 node2->firstseg|=i;
728
729 #if SLIM
730 PutBackNodeXNode(nodesx,id2,2);
731 #endif
732 }
733 else
734 {
735 index_t index=SEGMENT(node2->firstseg);
736
737 do
738 {
739 segmentx=LookupSegmentX(segmentsx,index,1);
740
741 if(segmentx->node1==id2)
742 {
743 index++;
744
745 if(index>=segmentsx->number)
746 break;
747
748 segmentx=LookupSegmentX(segmentsx,index,1);
749
750 if(segmentx->node1!=id2)
751 break;
752 }
753 else
754 {
755 Segment *segment=LookupSegmentXSegment(segmentsx,index,1);
756
757 if(segment->next2==NO_NODE)
758 {
759 segment->next2=i;
760
761 #if SLIM
762 PutBackSegmentXSegment(segmentsx,index,1);
763 #endif
764
765 break;
766 }
767 else
768 index=segment->next2;
769 }
770 }
771 while(1);
772 }
773
774 if(!((i+1)%10000))
775 {
776 printf("\rIndexing Segments: Segments=%d",i+1);
777 fflush(stdout);
778 }
779 }
780
781 /* Unmap from memory */
782
783 #if !SLIM
784 nodesx->xdata=UnmapFile(nodesx->filename);
785 segmentsx->xdata=UnmapFile(segmentsx->filename);
786 #endif
787
788 /* Print the final message */
789
790 printf("\rIndexed Segments: Segments=%d \n",segmentsx->number);
791 fflush(stdout);
792 }
793
794
795 /*++++++++++++++++++++++++++++++++++++++
796 Save the node list to a file.
797
798 NodesX* nodesx The set of nodes to save.
799
800 const char *filename The name of the file to save.
801 ++++++++++++++++++++++++++++++++++++++*/
802
803 void SaveNodeList(NodesX* nodesx,const char *filename)
804 {
805 index_t i;
806 int fd;
807 NodesFile nodesfile;
808 int super_number=0;
809
810 /* Print the start message */
811
812 printf("Writing Nodes: Nodes=0");
813 fflush(stdout);
814
815 /* Map into memory */
816
817 #if !SLIM
818 nodesx->xdata=MapFile(nodesx->filename);
819 #endif
820
821 /* Write out the nodes data */
822
823 fd=OpenFile(filename);
824
825 SeekFile(fd,sizeof(NodesFile));
826 WriteFile(fd,nodesx->offsets,(nodesx->latbins*nodesx->lonbins+1)*sizeof(index_t));
827
828 for(i=0;i<nodesx->number;i++)
829 {
830 NodeX *nodex=LookupNodeX(nodesx,i,1);
831 Node *node=LookupNodeXNode(nodesx,nodex->id,1);
832
833 if(node->firstseg&NODE_SUPER)
834 super_number++;
835
836 WriteFile(fd,node,sizeof(Node));
837
838 if(!((i+1)%10000))
839 {
840 printf("\rWriting Nodes: Nodes=%d",i+1);
841 fflush(stdout);
842 }
843 }
844
845 /* Write out the header structure */
846
847 nodesfile.number=nodesx->number;
848 nodesfile.snumber=super_number;
849
850 nodesfile.latbins=nodesx->latbins;
851 nodesfile.lonbins=nodesx->lonbins;
852
853 nodesfile.latzero=nodesx->latzero;
854 nodesfile.lonzero=nodesx->lonzero;
855
856 SeekFile(fd,0);
857 WriteFile(fd,&nodesfile,sizeof(NodesFile));
858
859 CloseFile(fd);
860
861 /* Unmap from memory */
862
863 #if !SLIM
864 nodesx->xdata=UnmapFile(nodesx->filename);
865 #endif
866
867 /* Print the final message */
868
869 printf("\rWrote Nodes: Nodes=%d \n",nodesx->number);
870 fflush(stdout);
871 }

Properties

Name Value
cvs:description Extended nodes functions.
Index: This Site Routino Software Download Source Code Documentation XML Files Links
Index: View SVN Development Recent changes Development (destination-access branch) Version 3.4.2 (destination-access branch) Version 3.4.2 Version 3.4.1 (destination-access branch) Version 3.4.1 Version 3.4 (destination-access branch) Version 3.4 Version 3.3.3 (destination-access branch) Version 3.3.3 Version 3.3.2 (destination-access branch) Version 3.3.2 Version 3.3.1 (destination-access branch) Version 3.3.1 Version 3.3 (destination-access branch) Version 3.3 Version 3.2 Version 3.1.1 Version 3.1 Version 3.0 Version 2.7.3 Version 2.7.2 Version 2.7.1 Version 2.7 Version 2.6 Version 2.5.1 Version 2.5 Version 2.4.1 Version 2.4 Version 2.3.2 Version 2.3.1 Version 2.3 Version 2.2 Version 2.1.2 Version 2.1.1 Version 2.1 Version 2.0.3 Version 2.0.2 Version 2.0.1 Version 2.0 Version 1.5.1 Version 1.5 Version 1.4.1 Version 1.4 Version 1.3 Version 1.2 Version 1.1 Version 1.0
Powered by ViewVC 1.3.0-dev ViewVC Help
© Andrew M. Bishop = < amb @ ... >
Root