routino-2.4.1/ 40755 233 144 0 12063564162 6356 5 routino-2.4.1/src/ 40755 233 144 0 12063564022 7140 5 routino-2.4.1/src/filedumperx.c 644 233 144 24036 12063560526 11676 0 /***************************************
Memory file dumper for the intermediate files containing parsed data.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include
#include
#include "typesx.h"
#include "nodesx.h"
#include "segmentsx.h"
#include "waysx.h"
#include "relationsx.h"
#include "files.h"
#include "sorting.h"
/* Local functions */
static void print_nodes(const char *filename);
static void print_segments(const char *filename);
static void print_ways(const char *filename);
static void print_route_relations(const char *filename);
static void print_turn_relations(const char *filename);
static void print_usage(int detail,const char *argerr,const char *err);
/*++++++++++++++++++++++++++++++++++++++
The main program for the file dumper.
++++++++++++++++++++++++++++++++++++++*/
int main(int argc,char** argv)
{
int arg;
char *dirname=NULL,*prefix=NULL;
char *nodes_filename,*segments_filename,*ways_filename,*route_relations_filename,*turn_relations_filename;
int option_dump;
/* Parse the command line arguments */
for(arg=1;arg] [--prefix=]\n"
" [--dump [--nodes]\n"
" [--segments]\n"
" [--ways]\n"
" [--route-relations]\n"
" [--turn-relations]]\n");
if(argerr)
fprintf(stderr,
"\n"
"Error with command line parameter: %s\n",argerr);
if(err)
fprintf(stderr,
"\n"
"Error: %s\n",err);
if(detail)
fprintf(stderr,
"\n"
"--help Prints this information.\n"
"\n"
"--dir= The directory containing the routing database.\n"
"--prefix= The filename prefix for the routing database.\n"
"\n"
"--dump Dump the intermediate files after parsing.\n"
" --nodes * all of the nodes.\n"
" --segments * all of the segments.\n"
" --ways * all of the ways.\n"
" --route-relations * all of the route relations.\n"
" --turn-relations * all of the turn relations.\n");
exit(!detail);
}
routino-2.4.1/src/waysx.c 644 233 144 43502 12063562207 10522 0 /***************************************
Extended Way data type functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include "types.h"
#include "ways.h"
#include "typesx.h"
#include "segmentsx.h"
#include "waysx.h"
#include "files.h"
#include "logging.h"
#include "sorting.h"
/* Global variables */
/*+ The command line '--tmpdir' option or its default value. +*/
extern char *option_tmpdirname;
/* Local variables */
/*+ Temporary file-local variables for use by the sort functions. +*/
static WaysX *sortwaysx;
static SegmentsX *sortsegmentsx;
/* Local functions */
static int sort_by_id(WayX *a,WayX *b);
static int deduplicate_by_id(WayX *wayx,index_t index);
static int sort_by_name(WayX *a,WayX *b);
static int index_by_id(WayX *wayx,index_t index);
static int delete_unused(WayX *wayx,index_t index);
static int sort_by_name_and_prop_and_id(WayX *a,WayX *b);
static int deduplicate_and_index_by_compact_id(WayX *wayx,index_t index);
/*++++++++++++++++++++++++++++++++++++++
Allocate a new way list (create a new file or open an existing one).
WaysX *NewWayList Returns the way list.
int append Set to 1 if the file is to be opened for appending.
int readonly Set to 1 if the file is to be opened for reading.
++++++++++++++++++++++++++++++++++++++*/
WaysX *NewWayList(int append,int readonly)
{
WaysX *waysx;
waysx=(WaysX*)calloc(1,sizeof(WaysX));
logassert(waysx,"Failed to allocate memory (try using slim mode?)"); /* Check calloc() worked */
waysx->filename =(char*)malloc(strlen(option_tmpdirname)+32);
waysx->filename_tmp=(char*)malloc(strlen(option_tmpdirname)+32);
sprintf(waysx->filename ,"%s/waysx.parsed.mem",option_tmpdirname);
sprintf(waysx->filename_tmp,"%s/waysx.%p.tmp" ,option_tmpdirname,(void*)waysx);
if(append || readonly)
if(ExistsFile(waysx->filename))
{
off_t size,position=0;
int fd;
size=SizeFile(waysx->filename);
fd=ReOpenFile(waysx->filename);
while(positionnumber++;
position+=waysize+FILESORT_VARSIZE;
}
CloseFile(fd);
RenameFile(waysx->filename,waysx->filename_tmp);
}
if(append)
waysx->fd=OpenFileAppend(waysx->filename_tmp);
else if(!readonly)
waysx->fd=OpenFileNew(waysx->filename_tmp);
else
waysx->fd=-1;
waysx->nfilename_tmp=(char*)malloc(strlen(option_tmpdirname)+32);
sprintf(waysx->nfilename_tmp,"%s/waynames.%p.tmp",option_tmpdirname,(void*)waysx);
return(waysx);
}
/*++++++++++++++++++++++++++++++++++++++
Free a way list.
WaysX *waysx The set of ways to be freed.
int keep If set then the results file is to be kept.
++++++++++++++++++++++++++++++++++++++*/
void FreeWayList(WaysX *waysx,int keep)
{
if(keep)
RenameFile(waysx->filename_tmp,waysx->filename);
else
DeleteFile(waysx->filename_tmp);
free(waysx->filename);
free(waysx->filename_tmp);
if(waysx->idata)
free(waysx->idata);
if(waysx->cdata)
free(waysx->cdata);
DeleteFile(waysx->nfilename_tmp);
free(waysx->nfilename_tmp);
free(waysx);
}
/*++++++++++++++++++++++++++++++++++++++
Append a single way to an unsorted way list.
WaysX *waysx The set of ways to process.
way_t id The ID of the way.
Way *way The way data itself.
const char *name The name or reference of the way.
++++++++++++++++++++++++++++++++++++++*/
void AppendWayList(WaysX *waysx,way_t id,Way *way,const char *name)
{
WayX wayx;
FILESORT_VARINT size;
wayx.id=id;
wayx.way=*way;
size=sizeof(WayX)+strlen(name)+1;
WriteFile(waysx->fd,&size,FILESORT_VARSIZE);
WriteFile(waysx->fd,&wayx,sizeof(WayX));
WriteFile(waysx->fd,name,strlen(name)+1);
waysx->number++;
logassert(waysx->number!=0,"Too many ways (change index_t to 64-bits?)"); /* Zero marks the high-water mark for ways. */
}
/*++++++++++++++++++++++++++++++++++++++
Finish appending ways and change the filename over.
WaysX *waysx The ways that have been appended.
++++++++++++++++++++++++++++++++++++++*/
void FinishWayList(WaysX *waysx)
{
if(waysx->fd!=-1)
waysx->fd=CloseFile(waysx->fd);
}
/*++++++++++++++++++++++++++++++++++++++
Find a particular way index.
index_t IndexWayX Returns the index of the extended way with the specified id.
WaysX *waysx The set of ways to process.
way_t id The way id to look for.
++++++++++++++++++++++++++++++++++++++*/
index_t IndexWayX(WaysX *waysx,way_t id)
{
index_t start=0;
index_t end=waysx->number-1;
index_t mid;
if(waysx->number==0) /* There are no ways */
return(NO_WAY);
if(ididata[start]) /* Key is before start */
return(NO_WAY);
if(id>waysx->idata[end]) /* Key is after end */
return(NO_WAY);
/* Binary search - search key exact match only is required.
*
* # <- start | Check mid and move start or end if it doesn't match
* # |
* # | Since an exact match is wanted we can set end=mid-1
* # <- mid | or start=mid+1 because we know that mid doesn't match.
* # |
* # | Eventually either end=start or end=start+1 and one of
* # <- end | start or end is the wanted one.
*/
do
{
mid=(start+end)/2; /* Choose mid point */
if(waysx->idata[mid]idata[mid]>id) /* Mid point is too high */
end=mid?(mid-1):mid;
else /* Mid point is correct */
return(mid);
}
while((end-start)>1);
if(waysx->idata[start]==id) /* Start is correct */
return(start);
if(waysx->idata[end]==id) /* End is correct */
return(end);
return(NO_WAY);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the list of ways.
WaysX *waysx The set of ways to process.
++++++++++++++++++++++++++++++++++++++*/
void SortWayList(WaysX *waysx)
{
index_t xnumber;
int fd;
/* Print the start message */
printf_first("Sorting Ways");
/* Re-open the file read-only and a new file writeable */
waysx->fd=ReOpenFile(waysx->filename_tmp);
DeleteFile(waysx->filename_tmp);
fd=OpenFileNew(waysx->filename_tmp);
/* Sort the ways by ID and index them */
xnumber=waysx->number;
waysx->number=filesort_vary(waysx->fd,fd,NULL,
(int (*)(const void*,const void*))sort_by_id,
(int (*)(void*,index_t))deduplicate_by_id);
/* Close the files */
waysx->fd=CloseFile(waysx->fd);
CloseFile(fd);
/* Print the final message */
printf_last("Sorted Ways: Ways=%"Pindex_t" Duplicates=%"Pindex_t,xnumber,xnumber-waysx->number);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the ways into id order.
int sort_by_id Returns the comparison of the id fields.
WayX *a The first extended way.
WayX *b The second extended way.
++++++++++++++++++++++++++++++++++++++*/
static int sort_by_id(WayX *a,WayX *b)
{
way_t a_id=a->id;
way_t b_id=b->id;
if(a_idb_id)
return(1);
else
return(-FILESORT_PRESERVE_ORDER(a,b)); /* latest version first */
}
/*++++++++++++++++++++++++++++++++++++++
Discard duplicate ways.
int deduplicate_by_id Return 1 if the value is to be kept, otherwise 0.
WayX *wayx The extended way.
index_t index The number of sorted ways that have already been written to the output file.
++++++++++++++++++++++++++++++++++++++*/
static int deduplicate_by_id(WayX *wayx,index_t index)
{
static way_t previd=NO_WAY_ID;
if(wayx->id!=previd)
{
previd=wayx->id;
if(wayx->way.type==WAY_DELETED)
return(0);
else
return(1);
}
else
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
Extract the way names from the ways and reference the list of names from the ways.
WaysX *waysx The set of ways to process.
int keep If set to 1 then keep the old data file otherwise delete it.
++++++++++++++++++++++++++++++++++++++*/
void ExtractWayNames(WaysX *waysx,int keep)
{
index_t i;
int fd;
char *names[2]={NULL,NULL};
int namelen[2]={0,0};
int nnames=0;
uint32_t lastlength=0;
/* Print the start message */
printf_first("Sorting Ways by Name");
/* Re-open the file read-only and a new file writeable */
waysx->fd=ReOpenFile(waysx->filename_tmp);
if(keep)
RenameFile(waysx->filename_tmp,waysx->filename);
else
DeleteFile(waysx->filename_tmp);
fd=OpenFileNew(waysx->filename_tmp);
/* Sort the ways to allow separating the names */
filesort_vary(waysx->fd,fd,NULL,
(int (*)(const void*,const void*))sort_by_name,
NULL);
/* Close the files */
waysx->fd=CloseFile(waysx->fd);
CloseFile(fd);
/* Print the final message */
printf_last("Sorted Ways by Name: Ways=%"Pindex_t,waysx->number);
/* Print the start message */
printf_first("Separating Way Names: Ways=0 Names=0");
/* Re-open the file read-only and new files writeable */
waysx->fd=ReOpenFile(waysx->filename_tmp);
DeleteFile(waysx->filename_tmp);
fd=OpenFileNew(waysx->filename_tmp);
waysx->nfd=OpenFileNew(waysx->nfilename_tmp);
/* Copy from the single file into two files */
for(i=0;inumber;i++)
{
WayX wayx;
FILESORT_VARINT size;
ReadFile(waysx->fd,&size,FILESORT_VARSIZE);
if(namelen[nnames%2]fd,&wayx,sizeof(WayX));
ReadFile(waysx->fd,names[nnames%2],size-sizeof(WayX));
if(nnames==0 || strcmp(names[0],names[1]))
{
WriteFile(waysx->nfd,names[nnames%2],size-sizeof(WayX));
lastlength=waysx->nlength;
waysx->nlength+=size-sizeof(WayX);
nnames++;
}
wayx.way.name=lastlength;
WriteFile(fd,&wayx,sizeof(WayX));
if(!((i+1)%1000))
printf_middle("Separating Way Names: Ways=%"Pindex_t" Names=%"Pindex_t,i+1,nnames);
}
if(names[0]) free(names[0]);
if(names[1]) free(names[1]);
/* Close the files */
waysx->fd=CloseFile(waysx->fd);
CloseFile(fd);
waysx->nfd=CloseFile(waysx->nfd);
/* Print the final message */
printf_last("Separated Way Names: Ways=%"Pindex_t" Names=%"Pindex_t,waysx->number,nnames);
/* Print the start message */
printf_first("Sorting Ways");
/* Re-open the file read-only and a new file writeable */
waysx->fd=ReOpenFile(waysx->filename_tmp);
DeleteFile(waysx->filename_tmp);
fd=OpenFileNew(waysx->filename_tmp);
/* Allocate the array of indexes */
waysx->idata=(way_t*)malloc(waysx->number*sizeof(way_t));
logassert(waysx->idata,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Sort the ways by ID */
sortwaysx=waysx;
filesort_fixed(waysx->fd,fd,sizeof(WayX),NULL,
(int (*)(const void*,const void*))sort_by_id,
(int (*)(void*,index_t))index_by_id);
/* Close the files */
waysx->fd=CloseFile(waysx->fd);
CloseFile(fd);
/* Print the final message */
printf_last("Sorted Ways: Ways=%"Pindex_t,waysx->number);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the ways into name order and then id order.
int sort_by_name Returns the comparison of the name fields.
WayX *a The first extended Way.
WayX *b The second extended Way.
++++++++++++++++++++++++++++++++++++++*/
static int sort_by_name(WayX *a,WayX *b)
{
int compare;
char *a_name=(char*)a+sizeof(WayX);
char *b_name=(char*)b+sizeof(WayX);
compare=strcmp(a_name,b_name);
if(compare)
return(compare);
else
return(FILESORT_PRESERVE_ORDER(a,b));
}
/*++++++++++++++++++++++++++++++++++++++
Create the index of identifiers.
int index_by_id Return 1 if the value is to be kept, otherwise 0.
WayX *wayx The extended way.
index_t index The number of sorted ways that have already been written to the output file.
++++++++++++++++++++++++++++++++++++++*/
static int index_by_id(WayX *wayx,index_t index)
{
sortwaysx->idata[index]=wayx->id;
return(1);
}
/*++++++++++++++++++++++++++++++++++++++
Compact the way list, removing duplicated ways and unused ways.
WaysX *waysx The set of ways to process.
SegmentsX *segmentsx The set of segments to check.
++++++++++++++++++++++++++++++++++++++*/
void CompactWayList(WaysX *waysx,SegmentsX *segmentsx)
{
int fd;
index_t cnumber;
if(waysx->number==0)
return;
/* Print the start message */
printf_first("Sorting Ways and Compacting");
/* Allocate the array of indexes */
waysx->cdata=(index_t*)malloc(waysx->number*sizeof(index_t));
logassert(waysx->cdata,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Re-open the file read-only and a new file writeable */
waysx->fd=ReOpenFile(waysx->filename_tmp);
DeleteFile(waysx->filename_tmp);
fd=OpenFileNew(waysx->filename_tmp);
/* Sort the ways to allow compacting according to the properties */
sortwaysx=waysx;
sortsegmentsx=segmentsx;
cnumber=filesort_fixed(waysx->fd,fd,sizeof(WayX),(int (*)(void*,index_t))delete_unused,
(int (*)(const void*,const void*))sort_by_name_and_prop_and_id,
(int (*)(void*,index_t))deduplicate_and_index_by_compact_id);
/* Close the files */
waysx->fd=CloseFile(waysx->fd);
CloseFile(fd);
/* Print the final message */
printf_last("Sorted and Compacted Ways: Ways=%"Pindex_t" Unique=%"Pindex_t,waysx->number,cnumber);
waysx->number=cnumber;
free(segmentsx->usedway);
segmentsx->usedway=NULL;
}
/*++++++++++++++++++++++++++++++++++++++
Delete the ways that are no longer being used.
int delete_unused Return 1 if the value is to be kept, otherwise 0.
WayX *wayx The extended way.
index_t index The number of unsorted ways that have been read from the input file.
++++++++++++++++++++++++++++++++++++++*/
static int delete_unused(WayX *wayx,index_t index)
{
if(sortsegmentsx && !IsBitSet(sortsegmentsx->usedway,index))
{
sortwaysx->cdata[index]=NO_WAY;
return(0);
}
else
{
wayx->id=index;
return(1);
}
}
/*++++++++++++++++++++++++++++++++++++++
Sort the ways into name, properties and id order.
int sort_by_name_and_prop_and_id Returns the comparison of the name, properties and id fields.
WayX *a The first extended Way.
WayX *b The second extended Way.
++++++++++++++++++++++++++++++++++++++*/
static int sort_by_name_and_prop_and_id(WayX *a,WayX *b)
{
int compare;
index_t a_name=a->way.name;
index_t b_name=b->way.name;
if(a_nameb_name)
return(1);
compare=WaysCompare(&a->way,&b->way);
if(compare)
return(compare);
return(sort_by_id(a,b));
}
/*++++++++++++++++++++++++++++++++++++++
Create the index of compacted Way identifiers and ignore Ways with duplicated properties.
int deduplicate_and_index_by_compact_id Return 1 if the value is to be kept, otherwise 0.
WayX *wayx The extended way.
index_t index The number of sorted ways that have already been written to the output file.
++++++++++++++++++++++++++++++++++++++*/
static int deduplicate_and_index_by_compact_id(WayX *wayx,index_t index)
{
static Way lastway;
if(index==0 || wayx->way.name!=lastway.name || WaysCompare(&lastway,&wayx->way))
{
lastway=wayx->way;
sortwaysx->cdata[wayx->id]=index;
wayx->id=index;
return(1);
}
else
{
sortwaysx->cdata[wayx->id]=index-1;
return(0);
}
}
/*++++++++++++++++++++++++++++++++++++++
Save the way list to a file.
WaysX *waysx The set of ways to save.
const char *filename The name of the file to save.
++++++++++++++++++++++++++++++++++++++*/
void SaveWayList(WaysX *waysx,const char *filename)
{
index_t i;
int fd;
int position=0;
WayX wayx;
WaysFile waysfile={0};
highways_t highways=0;
transports_t allow=0;
properties_t props=0;
/* Print the start message */
printf_first("Writing Ways: Ways=0");
/* Re-open the files */
waysx->fd=ReOpenFile(waysx->filename_tmp);
waysx->nfd=ReOpenFile(waysx->nfilename_tmp);
/* Write out the ways data */
fd=OpenFileNew(filename);
SeekFile(fd,sizeof(WaysFile));
for(i=0;inumber;i++)
{
ReadFile(waysx->fd,&wayx,sizeof(WayX));
highways|=HIGHWAYS(wayx.way.type);
allow |=wayx.way.allow;
props |=wayx.way.props;
WriteFile(fd,&wayx.way,sizeof(Way));
if(!((i+1)%1000))
printf_middle("Writing Ways: Ways=%"Pindex_t,i+1);
}
/* Write out the ways names */
SeekFile(fd,sizeof(WaysFile)+(off_t)waysx->number*sizeof(Way));
while(positionnlength)
{
int len=1024;
char temp[1024];
if((waysx->nlength-position)<1024)
len=waysx->nlength-position;
ReadFile(waysx->nfd,temp,len);
WriteFile(fd,temp,len);
position+=len;
}
/* Close the files */
waysx->fd=CloseFile(waysx->fd);
waysx->nfd=CloseFile(waysx->nfd);
/* Write out the header structure */
waysfile.number =waysx->number;
waysfile.highways=highways;
waysfile.allow =allow;
waysfile.props =props;
SeekFile(fd,0);
WriteFile(fd,&waysfile,sizeof(WaysFile));
CloseFile(fd);
/* Print the final message */
printf_last("Wrote Ways: Ways=%"Pindex_t,waysx->number);
}
routino-2.4.1/src/ways.h 644 233 144 12074 12063560526 10341 0 /***************************************
A header file for the ways.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef WAYS_H
#define WAYS_H /*+ To stop multiple inclusions. +*/
#include
#include
#include "types.h"
#include "files.h"
/* Data structures */
/*+ A structure containing a single way (members ordered to minimise overall size). +*/
struct _Way
{
index_t name; /*+ The offset of the name of the way in the names array. +*/
transports_t allow; /*+ The type of traffic allowed on the way. +*/
highway_t type; /*+ The highway type of the way. +*/
properties_t props; /*+ The properties of the way. +*/
speed_t speed; /*+ The defined maximum speed limit of the way. +*/
weight_t weight; /*+ The defined maximum weight of traffic on the way. +*/
height_t height; /*+ The defined maximum height of traffic on the way. +*/
width_t width; /*+ The defined maximum width of traffic on the way. +*/
length_t length; /*+ The defined maximum length of traffic on the way. +*/
};
/*+ A structure containing the header from the file. +*/
typedef struct _WaysFile
{
index_t number; /*+ The number of ways. +*/
highways_t highways; /*+ The types of highways that were seen when parsing. +*/
transports_t allow; /*+ The types of traffic that were seen when parsing. +*/
properties_t props; /*+ The properties that were seen when parsing. +*/
}
WaysFile;
/*+ A structure containing a set of ways (and pointers to mmap file). +*/
struct _Ways
{
WaysFile file; /*+ The header data from the file. +*/
#if !SLIM
void *data; /*+ The memory mapped data. +*/
Way *ways; /*+ An array of ways. +*/
char *names; /*+ An array of characters containing the names. +*/
#else
int fd; /*+ The file descriptor for the file. +*/
off_t namesoffset; /*+ The offset of the names within the file. +*/
Way cached[3]; /*+ Two cached nodes read from the file in slim mode. +*/
index_t incache[3]; /*+ The indexes of the cached ways. +*/
char *ncached[3]; /*+ The cached way name. +*/
#endif
};
/* Functions in ways.c */
Ways *LoadWayList(const char *filename);
int WaysCompare(Way *way1p,Way *way2p);
/* Macros and inline functions */
#if !SLIM
/*+ Return a Way* pointer given a set of ways and an index. +*/
#define LookupWay(xxx,yyy,zzz) (&(xxx)->ways[yyy])
/*+ Return the name of a way given the Way pointer and a set of ways. +*/
#define WayName(xxx,yyy) (&(xxx)->names[(yyy)->name])
#else
static Way *LookupWay(Ways *ways,index_t index,int position);
static char *WayName(Ways *ways,Way *wayp);
/*++++++++++++++++++++++++++++++++++++++
Find the Way information for a particular way.
Way *LookupWay Returns a pointer to the cached way information.
Ways *ways The set of ways to use.
index_t index The index of the way.
int position The position in the cache to store the value.
++++++++++++++++++++++++++++++++++++++*/
static inline Way *LookupWay(Ways *ways,index_t index,int position)
{
if(ways->incache[position-1]!=index)
{
SeekReadFile(ways->fd,&ways->cached[position-1],sizeof(Way),sizeof(WaysFile)+(off_t)index*sizeof(Way));
ways->incache[position-1]=index;
}
return(&ways->cached[position-1]);
}
/*++++++++++++++++++++++++++++++++++++++
Find the name of a way.
char *WayName Returns a pointer to the name of the way.
Ways *ways The set of ways to use.
Way *wayp The Way pointer.
++++++++++++++++++++++++++++++++++++++*/
static inline char *WayName(Ways *ways,Way *wayp)
{
int position=wayp-&ways->cached[-1];
int n=0;
SeekFile(ways->fd,ways->namesoffset+wayp->name);
if(!ways->ncached[position-1])
ways->ncached[position-1]=(char*)malloc(32);
while(1)
{
int i;
int m=ReadFile(ways->fd,ways->ncached[position-1]+n,32);
if(m<0)
break;
for(i=n;incached[position-1][i]==0)
goto exitloop;
n+=32;
ways->ncached[position-1]=(char*)realloc((void*)ways->ncached[position-1],n+32);
}
exitloop:
return(ways->ncached[position-1]);
}
#endif
#endif /* WAYS_H */
routino-2.4.1/src/superx.h 644 233 144 2420 12063560526 10656 0 /***************************************
Header for super-node and super-segment functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2011 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef SUPERX_H
#define SUPERX_H /*+ To stop multiple inclusions. +*/
#include "typesx.h"
/* Functions in superx.c */
void ChooseSuperNodes(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx);
SegmentsX *CreateSuperSegments(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx);
SegmentsX *MergeSuperSegments(SegmentsX *segmentsx,SegmentsX *supersegmentsx);
#endif /* SUPERX_H */
routino-2.4.1/src/logging.c 644 233 144 20000 12063562163 10762 0 /***************************************
Functions to handle logging functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include
#include
#include
#include
#include "logging.h"
/* Global variables */
/*+ The option to print the output in a way that allows logging to a file. +*/
int option_loggable=0;
/*+ The option to print timestamps with the output. +*/
int option_logtime=0;
/* Local functions */
static void vfprintf_first(FILE *file,const char *format,va_list ap);
static void vfprintf_middle(FILE *file,const char *format,va_list ap);
static void vfprintf_last(FILE *file,const char *format,va_list ap);
/* Local variables */
/*+ The time that printf_first was called. +*/
static struct timeval start_time;
/*+ The length of the string printed out last time. +*/
static int printed_length=0;
/*+ The file handle for the error log file. +*/
static FILE *errorlogfile;
/*++++++++++++++++++++++++++++++++++++++
Print the first message in an overwriting sequence (to stdout).
const char *format The format string.
... The other arguments.
++++++++++++++++++++++++++++++++++++++*/
void printf_first(const char *format, ...)
{
va_list ap;
if(option_logtime)
gettimeofday(&start_time,NULL);
if(option_loggable)
return;
va_start(ap,format);
vfprintf_first(stdout,format,ap);
va_end(ap);
}
/*++++++++++++++++++++++++++++++++++++++
Print the middle message in an overwriting sequence (to stdout).
const char *format The format string.
... The other arguments.
++++++++++++++++++++++++++++++++++++++*/
void printf_middle(const char *format, ...)
{
va_list ap;
if(option_loggable)
return;
va_start(ap,format);
vfprintf_middle(stdout,format,ap);
va_end(ap);
}
/*++++++++++++++++++++++++++++++++++++++
Print the last message in an overwriting sequence (to stdout).
const char *format The format string.
... The other arguments.
++++++++++++++++++++++++++++++++++++++*/
void printf_last(const char *format, ...)
{
va_list ap;
va_start(ap,format);
vfprintf_last(stdout,format,ap);
va_end(ap);
}
/*++++++++++++++++++++++++++++++++++++++
Print the first message in an overwriting sequence to a specified file.
FILE *file The file to write to.
const char *format The format string.
... The other arguments.
++++++++++++++++++++++++++++++++++++++*/
void fprintf_first(FILE *file,const char *format, ...)
{
va_list ap;
if(option_logtime)
gettimeofday(&start_time,NULL);
if(option_loggable)
return;
va_start(ap,format);
vfprintf_first(file,format,ap);
va_end(ap);
}
/*++++++++++++++++++++++++++++++++++++++
Print the middle message in an overwriting sequence to a specified file.
FILE *file The file to write to.
const char *format The format string.
... The other arguments.
++++++++++++++++++++++++++++++++++++++*/
void fprintf_middle(FILE *file,const char *format, ...)
{
va_list ap;
if(option_loggable)
return;
va_start(ap,format);
vfprintf_middle(file,format,ap);
va_end(ap);
}
/*++++++++++++++++++++++++++++++++++++++
Print the last message in an overwriting sequence to a specified file.
FILE *file The file to write to.
const char *format The format string.
... The other arguments.
++++++++++++++++++++++++++++++++++++++*/
void fprintf_last(FILE *file,const char *format, ...)
{
va_list ap;
va_start(ap,format);
vfprintf_last(file,format,ap);
va_end(ap);
}
/*++++++++++++++++++++++++++++++++++++++
Do the work to print the first message in an overwriting sequence.
FILE *file The file to write to.
const char *format The format string.
va_list ap The other arguments.
++++++++++++++++++++++++++++++++++++++*/
static void vfprintf_first(FILE *file,const char *format,va_list ap)
{
int retval;
if(option_logtime)
fprintf_elapsed_time(file,&start_time);
retval=vfprintf(file,format,ap);
fflush(file);
if(retval>0)
printed_length=retval;
}
/*++++++++++++++++++++++++++++++++++++++
Do the work to print the middle message in an overwriting sequence.
FILE *file The file to write to.
const char *format The format string.
va_list ap The other arguments.
++++++++++++++++++++++++++++++++++++++*/
static void vfprintf_middle(FILE *file,const char *format,va_list ap)
{
int retval;
fputc('\r',file);
if(option_logtime)
fprintf_elapsed_time(file,&start_time);
retval=vfprintf(file,format,ap);
fflush(file);
if(retval>0)
{
int new_printed_length=retval;
while(retval++0)
while(retval++tv_sec;
elapsed.tv_usec=finish.tv_usec-start->tv_usec;
if(elapsed.tv_usec<0)
{
elapsed.tv_sec -=1;
elapsed.tv_usec+=1000000;
}
fprintf(file,"[%2ld:%02ld.%03ld] ",elapsed.tv_sec/60,elapsed.tv_sec%60,elapsed.tv_usec/10000);
}
/*++++++++++++++++++++++++++++++++++++++
Create the error log file.
const char *filename The name of the file to create.
int append The option to append to an existing file.
++++++++++++++++++++++++++++++++++++++*/
void open_errorlog(const char *filename,int append)
{
errorlogfile=fopen(filename,append?"a":"w");
if(!errorlogfile)
{
fprintf(stderr,"Cannot open file '%s' for writing [%s].\n",filename,strerror(errno));
exit(EXIT_FAILURE);
}
}
/*++++++++++++++++++++++++++++++++++++++
Close the error log file.
++++++++++++++++++++++++++++++++++++++*/
void close_errorlog(void)
{
if(errorlogfile)
fclose(errorlogfile);
}
/*++++++++++++++++++++++++++++++++++++++
Log a message to the error log file.
const char *format The format string.
... The other arguments.
++++++++++++++++++++++++++++++++++++++*/
void logerror(const char *format, ...)
{
va_list ap;
if(!errorlogfile)
return;
va_start(ap,format);
vfprintf(errorlogfile,format,ap);
va_end(ap);
}
/*++++++++++++++++++++++++++++++++++++++
Log a fatal error and exit
const char *message The error message.
const char *file The file in which the error occured.
int line The line number in the file at which the error occured.
++++++++++++++++++++++++++++++++++++++*/
void _logassert(const char *message,const char *file,int line)
{
fprintf(stderr,"Routino Fatal Error (%s:%d): %s\n",file,line,message);
exit(EXIT_FAILURE);
}
routino-2.4.1/src/xmlparse.h 644 233 144 10261 12063560526 11205 0 /***************************************
A simple XML parser
Part of the Routino routing software.
******************/ /******************
This file Copyright 2010-2011 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef XMLPARSE_H
#define XMLPARSE_H /*+ To stop multiple inclusions. +*/
#include
/*+ The maximum number of attributes per tag. +*/
#define XMLPARSE_MAX_ATTRS 16
/*+ The maximum number of subtags per tag. +*/
#define XMLPARSE_MAX_SUBTAGS 16
/*+ A flag to indicate the start and/or end of a tag. +*/
#define XMLPARSE_TAG_START 1
#define XMLPARSE_TAG_END 2
/*+ A forward definition of the xmltag +*/
typedef struct _xmltag xmltag;
/*+ A structure to hold the definition of a tag. +*/
struct _xmltag
{
char *name; /*+ The name of the tag. +*/
int nattributes; /*+ The number of valid attributes for the tag. +*/
char *attributes[XMLPARSE_MAX_ATTRS]; /*+ The valid attributes for the tag. +*/
int (*callback)(); /*+ The callback function when the tag is seen. +*/
xmltag *subtags[XMLPARSE_MAX_SUBTAGS]; /*+ The list of valid tags contained within this one (null terminated). +*/
};
/* XML Parser options */
#define XMLPARSE_UNKNOWN_ATTRIBUTES 0x0003
#define XMLPARSE_UNKNOWN_ATTR_ERROR 0x0000 /* Flag an error and exit. */
#define XMLPARSE_UNKNOWN_ATTR_ERRNONAME 0x0001 /* Flag an error and exit unless a namespace is specified. */
#define XMLPARSE_UNKNOWN_ATTR_WARN 0x0002 /* Warn about the problem and continue. */
#define XMLPARSE_UNKNOWN_ATTR_IGNORE 0x0003 /* Ignore the potential problem. */
#define XMLPARSE_RETURN_ATTR_ENCODED 0x0004 /* Return the XML attribute strings without decoding them. */
/* XML parser functions */
int ParseXML(FILE *file,xmltag **tags,int options);
unsigned long long ParseXML_LineNumber(void);
char *ParseXML_Decode_Entity_Ref(const char *string);
char *ParseXML_Decode_Char_Ref(const char *string);
char *ParseXML_Encode_Safe_XML(const char *string);
int ParseXML_IsInteger(const char *string);
int ParseXML_IsFloating(const char *string);
/* Macros to simplify the callback functions */
#define XMLPARSE_MESSAGE(tag,message) \
do \
{ \
fprintf(stderr,"XML Parser: Error on line %llu: " message " in <%s> tag.\n",ParseXML_LineNumber(),tag); \
return(1); \
} \
while(0)
#define XMLPARSE_INVALID(tag,attribute) \
do \
{ \
fprintf(stderr,"XML Parser: Error on line %llu: Invalid value for '" #attribute "' attribute in <%s> tag.\n",ParseXML_LineNumber(),tag); \
return(1); \
} \
while(0)
#define XMLPARSE_ASSERT_STRING(tag,attribute) \
do \
{ \
if(!attribute) \
{ \
fprintf(stderr,"XML Parser: Error on line %llu: '" #attribute "' attribute must be specified in <%s> tag.\n",ParseXML_LineNumber(),tag); \
return(1); \
} \
} \
while(0)
#define XMLPARSE_ASSERT_INTEGER(tag,attribute) \
do \
{ \
if(!attribute || !*attribute || !ParseXML_IsInteger(attribute)) \
{ \
fprintf(stderr,"XML Parser: Error on line %llu: '" #attribute "' attribute must be a integer in <%s> tag.\n",ParseXML_LineNumber(),tag); \
return(1); \
} \
} \
while(0)
#define XMLPARSE_ASSERT_FLOATING(tag,attribute) \
do \
{ \
if(!attribute || !*attribute || !ParseXML_IsFloating(attribute)) \
{ \
fprintf(stderr,"XML Parser: Error on line %llu: '" #attribute "' attribute must be a number in <%s> tag.\n",ParseXML_LineNumber(),tag); \
return(1); \
} \
} \
while(0)
#endif /* XMLPARSE_H */
routino-2.4.1/src/visualiser.c 644 233 144 63000 12063560526 11532 0 /***************************************
Extract data from Routino.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include
#include "types.h"
#include "nodes.h"
#include "segments.h"
#include "ways.h"
#include "relations.h"
#include "visualiser.h"
/*+ The maximum number of segments per node (used to size temporary storage). +*/
#define MAX_SEG_PER_NODE 32
/* Limit types */
#define SPEED_LIMIT 1
#define WEIGHT_LIMIT 2
#define HEIGHT_LIMIT 3
#define WIDTH_LIMIT 4
#define LENGTH_LIMIT 5
/* Local types */
typedef void (*callback_t)(index_t node,double latitude,double longitude);
/* Local variables */
static Nodes *OSMNodes;
static Segments *OSMSegments;
static Ways *OSMWays;
static Relations *OSMRelations;
static double LatMin;
static double LatMax;
static double LonMin;
static double LonMax;
static int limit_type=0;
static Highway highways=Highway_None;
static Transports transports=Transports_None;
/* Local functions */
static void find_all_nodes(Nodes *nodes,callback_t callback);
static void output_junctions(index_t node,double latitude,double longitude);
static void output_super(index_t node,double latitude,double longitude);
static void output_oneway(index_t node,double latitude,double longitude);
static void output_highway(index_t node,double latitude,double longitude);
static void output_transport(index_t node,double latitude,double longitude);
static void output_barrier(index_t node,double latitude,double longitude);
static void output_turnrestriction(index_t node,double latitude,double longitude);
static void output_limits(index_t node,double latitude,double longitude);
/*++++++++++++++++++++++++++++++++++++++
Output the data for junctions.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputJunctions(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
find_all_nodes(nodes,(callback_t)output_junctions);
}
/*++++++++++++++++++++++++++++++++++++++
Process a single node as a junction (called as a callback).
index_t node The node to output.
double latitude The latitude of the node.
double longitude The longitude of the node.
++++++++++++++++++++++++++++++++++++++*/
static void output_junctions(index_t node,double latitude,double longitude)
{
Node *nodep=LookupNode(OSMNodes,node,1);
Segment *segmentp;
Way *firstwayp;
int count=0,difference=0;
segmentp=FirstSegment(OSMSegments,nodep,1);
firstwayp=LookupWay(OSMWays,segmentp->way,1);
do
{
Way *wayp=LookupWay(OSMWays,segmentp->way,2);
if(IsNormalSegment(segmentp))
count++;
if(WaysCompare(firstwayp,wayp))
difference=1;
segmentp=NextSegment(OSMSegments,segmentp,node);
}
while(segmentp);
if(count!=2 || difference)
printf("%.6f %.6f %d\n",radians_to_degrees(latitude),radians_to_degrees(longitude),count);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for super-nodes and super-segments.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputSuper(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
find_all_nodes(nodes,(callback_t)output_super);
}
/*++++++++++++++++++++++++++++++++++++++
Process a single node as a super-node (called as a callback).
index_t node The node to output.
double latitude The latitude of the node.
double longitude The longitude of the node.
++++++++++++++++++++++++++++++++++++++*/
static void output_super(index_t node,double latitude,double longitude)
{
Node *nodep=LookupNode(OSMNodes,node,1);
Segment *segmentp;
if(!IsSuperNode(nodep))
return;
printf("%.6f %.6f n\n",radians_to_degrees(latitude),radians_to_degrees(longitude));
segmentp=FirstSegment(OSMSegments,nodep,1);
do
{
if(IsSuperSegment(segmentp))
{
index_t othernode=OtherNode(segmentp,node);
double lat,lon;
GetLatLong(OSMNodes,othernode,&lat,&lon);
if(node>othernode || (latLatMax || lonLonMax))
printf("%.6f %.6f s\n",radians_to_degrees(lat),radians_to_degrees(lon));
}
segmentp=NextSegment(OSMSegments,segmentp,node);
}
while(segmentp);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for one-way segments.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputOneway(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
find_all_nodes(nodes,(callback_t)output_oneway);
}
/*++++++++++++++++++++++++++++++++++++++
Process a single node and all connected one-way segments (called as a callback).
index_t node The node to output.
double latitude The latitude of the node.
double longitude The longitude of the node.
++++++++++++++++++++++++++++++++++++++*/
static void output_oneway(index_t node,double latitude,double longitude)
{
Node *nodep=LookupNode(OSMNodes,node,1);
Segment *segmentp;
segmentp=FirstSegment(OSMSegments,nodep,1);
do
{
if(IsNormalSegment(segmentp))
{
index_t othernode=OtherNode(segmentp,node);
if(node>othernode)
{
double lat,lon;
GetLatLong(OSMNodes,othernode,&lat,&lon);
if(IsOnewayFrom(segmentp,node))
printf("%.6f %.6f %.6f %.6f\n",radians_to_degrees(latitude),radians_to_degrees(longitude),radians_to_degrees(lat),radians_to_degrees(lon));
else if(IsOnewayFrom(segmentp,othernode))
printf("%.6f %.6f %.6f %.6f\n",radians_to_degrees(lat),radians_to_degrees(lon),radians_to_degrees(latitude),radians_to_degrees(longitude));
}
}
segmentp=NextSegment(OSMSegments,segmentp,node);
}
while(segmentp);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for segments of a particular highway type.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
Highway highway The type of highway.
++++++++++++++++++++++++++++++++++++++*/
void OutputHighway(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax,Highway highway)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
highways=highway;
find_all_nodes(nodes,(callback_t)output_highway);
}
/*++++++++++++++++++++++++++++++++++++++
Process a single node and all connected one-way segments (called as a callback).
index_t node The node to output.
double latitude The latitude of the node.
double longitude The longitude of the node.
++++++++++++++++++++++++++++++++++++++*/
static void output_highway(index_t node,double latitude,double longitude)
{
Node *nodep=LookupNode(OSMNodes,node,1);
Segment *segmentp;
segmentp=FirstSegment(OSMSegments,nodep,1);
do
{
if(IsNormalSegment(segmentp))
{
index_t othernode=OtherNode(segmentp,node);
if(node>othernode)
{
Way *wayp=LookupWay(OSMWays,segmentp->way,1);
if(HIGHWAY(wayp->type)==highways)
{
double lat,lon;
GetLatLong(OSMNodes,othernode,&lat,&lon);
printf("%.6f %.6f %.6f %.6f\n",radians_to_degrees(latitude),radians_to_degrees(longitude),radians_to_degrees(lat),radians_to_degrees(lon));
}
}
}
segmentp=NextSegment(OSMSegments,segmentp,node);
}
while(segmentp);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for segments allowed for a paticular type of traffic.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
Transport transport The type of transport.
++++++++++++++++++++++++++++++++++++++*/
void OutputTransport(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax,Transport transport)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
transports=TRANSPORTS(transport);
find_all_nodes(nodes,(callback_t)output_transport);
}
/*++++++++++++++++++++++++++++++++++++++
Process a single node and all connected one-way segments (called as a callback).
index_t node The node to output.
double latitude The latitude of the node.
double longitude The longitude of the node.
++++++++++++++++++++++++++++++++++++++*/
static void output_transport(index_t node,double latitude,double longitude)
{
Node *nodep=LookupNode(OSMNodes,node,1);
Segment *segmentp;
segmentp=FirstSegment(OSMSegments,nodep,1);
do
{
if(IsNormalSegment(segmentp))
{
index_t othernode=OtherNode(segmentp,node);
if(node>othernode)
{
Way *wayp=LookupWay(OSMWays,segmentp->way,1);
if(wayp->allow&transports)
{
double lat,lon;
GetLatLong(OSMNodes,othernode,&lat,&lon);
printf("%.6f %.6f %.6f %.6f\n",radians_to_degrees(latitude),radians_to_degrees(longitude),radians_to_degrees(lat),radians_to_degrees(lon));
}
}
}
segmentp=NextSegment(OSMSegments,segmentp,node);
}
while(segmentp);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for nodes disallowed for a paticular type of traffic.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
Transport transport The type of transport.
++++++++++++++++++++++++++++++++++++++*/
void OutputBarrier(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax,Transport transport)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
transports=TRANSPORTS(transport);
find_all_nodes(nodes,(callback_t)output_barrier);
}
/*++++++++++++++++++++++++++++++++++++++
Process a single node (called as a callback).
index_t node The node to output.
double latitude The latitude of the node.
double longitude The longitude of the node.
++++++++++++++++++++++++++++++++++++++*/
static void output_barrier(index_t node,double latitude,double longitude)
{
Node *nodep=LookupNode(OSMNodes,node,1);
if(!(nodep->allow&transports))
printf("%.6f %.6f\n",radians_to_degrees(latitude),radians_to_degrees(longitude));
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for turn restrictions.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputTurnRestrictions(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
find_all_nodes(nodes,(callback_t)output_turnrestriction);
}
/*++++++++++++++++++++++++++++++++++++++
Process a single node as the 'via' node for a turn restriction (called as a callback).
index_t node The node to output.
double latitude The latitude of the node.
double longitude The longitude of the node.
++++++++++++++++++++++++++++++++++++++*/
static void output_turnrestriction(index_t node,double latitude,double longitude)
{
Node *nodep=LookupNode(OSMNodes,node,1);
index_t turnrelation=NO_RELATION;
if(!IsTurnRestrictedNode(nodep))
return;
turnrelation=FindFirstTurnRelation1(OSMRelations,node);
do
{
TurnRelation *relation;
Segment *from_segmentp,*to_segmentp;
index_t from_node,to_node;
double from_lat,from_lon,to_lat,to_lon;
relation=LookupTurnRelation(OSMRelations,turnrelation,1);
from_segmentp=LookupSegment(OSMSegments,relation->from,1);
to_segmentp =LookupSegment(OSMSegments,relation->to ,2);
from_node=OtherNode(from_segmentp,node);
to_node=OtherNode(to_segmentp,node);
GetLatLong(OSMNodes,from_node,&from_lat,&from_lon);
GetLatLong(OSMNodes,to_node,&to_lat,&to_lon);
printf("%.6f %.6f %.6f %.6f %.6f %.6f\n",radians_to_degrees(from_lat),radians_to_degrees(from_lon),
radians_to_degrees(latitude),radians_to_degrees(longitude),
radians_to_degrees(to_lat),radians_to_degrees(to_lon));
turnrelation=FindNextTurnRelation1(OSMRelations,turnrelation);
}
while(turnrelation!=NO_RELATION);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for speed limits.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputSpeedLimits(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
limit_type=SPEED_LIMIT;
find_all_nodes(nodes,(callback_t)output_limits);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for weight limits.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputWeightLimits(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
limit_type=WEIGHT_LIMIT;
find_all_nodes(nodes,(callback_t)output_limits);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for height limits.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputHeightLimits(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
limit_type=HEIGHT_LIMIT;
find_all_nodes(nodes,(callback_t)output_limits);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for width limits.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputWidthLimits(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
limit_type=WIDTH_LIMIT;
find_all_nodes(nodes,(callback_t)output_limits);
}
/*++++++++++++++++++++++++++++++++++++++
Output the data for length limits.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
void OutputLengthLimits(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,double latmin,double latmax,double lonmin,double lonmax)
{
/* Use local variables so that the callback doesn't need to pass them backwards and forwards */
OSMNodes=nodes;
OSMSegments=segments;
OSMWays=ways;
OSMRelations=relations;
LatMin=latmin;
LatMax=latmax;
LonMin=lonmin;
LonMax=lonmax;
/* Iterate through the nodes and process them */
limit_type=LENGTH_LIMIT;
find_all_nodes(nodes,(callback_t)output_limits);
}
/*++++++++++++++++++++++++++++++++++++++
Process a single node as a speed, weight, height, length, width limit (called as a callback).
index_t node The node to output.
double latitude The latitude of the node.
double longitude The longitude of the node.
++++++++++++++++++++++++++++++++++++++*/
static void output_limits(index_t node,double latitude,double longitude)
{
Node *nodep=LookupNode(OSMNodes,node,1);
Segment *segmentp,segmentps[MAX_SEG_PER_NODE];
int limits[MAX_SEG_PER_NODE];
int count=0;
int i,j,same=0;
segmentp=FirstSegment(OSMSegments,nodep,1);
do
{
if(IsNormalSegment(segmentp) && countway,1);
segmentps[count]=*segmentp;
switch(limit_type)
{
case SPEED_LIMIT: limits[count]=wayp->speed; break;
case WEIGHT_LIMIT: limits[count]=wayp->weight; break;
case HEIGHT_LIMIT: limits[count]=wayp->height; break;
case WIDTH_LIMIT: limits[count]=wayp->width; break;
case LENGTH_LIMIT: limits[count]=wayp->length; break;
}
if(limits[count] || HIGHWAY(wayp->type)file.latzero;
ll_bin_t latmaxbin=latlong_to_bin(radians_to_latlong(LatMax))-nodes->file.latzero;
ll_bin_t lonminbin=latlong_to_bin(radians_to_latlong(LonMin))-nodes->file.lonzero;
ll_bin_t lonmaxbin=latlong_to_bin(radians_to_latlong(LonMax))-nodes->file.lonzero;
ll_bin_t latb,lonb;
index_t i,index1,index2;
/* Loop through all of the nodes. */
for(latb=latminbin;latb<=latmaxbin;latb++)
for(lonb=lonminbin;lonb<=lonmaxbin;lonb++)
{
ll_bin2_t llbin=lonb*nodes->file.latbins+latb;
if(llbin<0 || llbin>(nodes->file.latbins*nodes->file.lonbins))
continue;
index1=LookupNodeOffset(nodes,llbin);
index2=LookupNodeOffset(nodes,llbin+1);
for(i=index1;ifile.latzero+latb)+off_to_latlong(nodep->latoffset));
double lon=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonb)+off_to_latlong(nodep->lonoffset));
if(lat>LatMin && latLonMin && lon.
***************************************/
#include
#include
#include "types.h"
#include "nodes.h"
#include "segments.h"
#include "ways.h"
#include "fakes.h"
#include "files.h"
#include "profiles.h"
/*++++++++++++++++++++++++++++++++++++++
Load in a segment list from a file.
Segments *LoadSegmentList Returns the segment list that has just been loaded.
const char *filename The name of the file to load.
++++++++++++++++++++++++++++++++++++++*/
Segments *LoadSegmentList(const char *filename)
{
Segments *segments;
#if SLIM
int i;
#endif
segments=(Segments*)malloc(sizeof(Segments));
#if !SLIM
segments->data=MapFile(filename);
/* Copy the SegmentsFile structure from the loaded data */
segments->file=*((SegmentsFile*)segments->data);
/* Set the pointers in the Segments structure. */
segments->segments=(Segment*)(segments->data+sizeof(SegmentsFile));
#else
segments->fd=ReOpenFile(filename);
/* Copy the SegmentsFile header structure from the loaded data */
ReadFile(segments->fd,&segments->file,sizeof(SegmentsFile));
for(i=0;icached)/sizeof(segments->cached[0]);i++)
segments->incache[i]=NO_SEGMENT;
#endif
return(segments);
}
/*++++++++++++++++++++++++++++++++++++++
Find the closest segment from a specified node heading in a particular direction and optionally profile.
index_t FindClosestSegmentHeading Returns the closest heading segment index.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
index_t node1 The node to start from.
double heading The desired heading from the node.
Profile *profile The profile of the mode of transport (or NULL).
++++++++++++++++++++++++++++++++++++++*/
index_t FindClosestSegmentHeading(Nodes *nodes,Segments *segments,Ways *ways,index_t node1,double heading,Profile *profile)
{
Segment *segmentp;
index_t best_seg=NO_SEGMENT;
double best_difference=360;
if(IsFakeNode(node1))
segmentp=FirstFakeSegment(node1);
else
{
Node *nodep=LookupNode(nodes,node1,3);
segmentp=FirstSegment(segments,nodep,1);
}
while(segmentp)
{
Way *wayp;
index_t node2,seg2;
double bearing,difference;
node2=OtherNode(segmentp,node1); /* need this here because we use node2 at the end of the loop */
if(!IsNormalSegment(segmentp))
goto endloop;
if(profile->oneway && IsOnewayFrom(segmentp,node1))
goto endloop;
if(IsFakeNode(node1) || IsFakeNode(node2))
seg2=IndexFakeSegment(segmentp);
else
seg2=IndexSegment(segments,segmentp);
wayp=LookupWay(ways,segmentp->way,1);
if(!(wayp->allow&profile->allow))
goto endloop;
bearing=BearingAngle(nodes,segmentp,node1);
difference=(heading-bearing);
if(difference<-180) difference+=360;
if(difference> 180) difference-=360;
if(difference<0) difference=-difference;
if(differencespeed;
speed_t speed2=profile->speed[HIGHWAY(wayp->type)];
distance_t distance=DISTANCE(segmentp->distance);
if(speed1==0)
{
if(speed2==0)
return(hours_to_duration(10));
else
return distance_speed_to_duration(distance,speed2);
}
else /* if(speed1!=0) */
{
if(speed2==0)
return distance_speed_to_duration(distance,speed1);
else if(speed1<=speed2)
return distance_speed_to_duration(distance,speed1);
else
return distance_speed_to_duration(distance,speed2);
}
}
/*++++++++++++++++++++++++++++++++++++++
Calculate the angle to turn at a junction from segment1 to segment2 at node.
double TurnAngle Returns a value in the range -180 to +180 indicating the angle to turn.
Nodes *nodes The set of nodes to use.
Segment *segment1p The current segment.
Segment *segment2p The next segment.
index_t node The node at which they join.
Straight ahead is zero, turning to the right is positive (e.g. +90 degrees) and turning to the left is negative (e.g. -90 degrees).
Angles are calculated using flat Cartesian lat/long grid approximation (after scaling longitude due to latitude).
++++++++++++++++++++++++++++++++++++++*/
double TurnAngle(Nodes *nodes,Segment *segment1p,Segment *segment2p,index_t node)
{
double lat1,latm,lat2;
double lon1,lonm,lon2;
double angle1,angle2,angle;
index_t node1,node2;
node1=OtherNode(segment1p,node);
node2=OtherNode(segment2p,node);
if(IsFakeNode(node1))
GetFakeLatLong(node1,&lat1,&lon1);
else
GetLatLong(nodes,node1,&lat1,&lon1);
if(IsFakeNode(node))
GetFakeLatLong(node,&latm,&lonm);
else
GetLatLong(nodes,node,&latm,&lonm);
if(IsFakeNode(node2))
GetFakeLatLong(node2,&lat2,&lon2);
else
GetLatLong(nodes,node2,&lat2,&lon2);
angle1=atan2((lonm-lon1)*cos(latm),(latm-lat1));
angle2=atan2((lon2-lonm)*cos(latm),(lat2-latm));
angle=angle2-angle1;
angle=radians_to_degrees(angle);
if(angle<-180) angle+=360;
if(angle> 180) angle-=360;
return(angle);
}
/*++++++++++++++++++++++++++++++++++++++
Calculate the bearing of a segment when heading to the given node.
double BearingAngle Returns a value in the range 0 to 359 indicating the bearing.
Nodes *nodes The set of nodes to use.
Segment *segmentp The segment.
index_t node The node to finish.
Angles are calculated using flat Cartesian lat/long grid approximation (after scaling longitude due to latitude).
++++++++++++++++++++++++++++++++++++++*/
double BearingAngle(Nodes *nodes,Segment *segmentp,index_t node)
{
double lat1,lat2;
double lon1,lon2;
double angle;
index_t node1,node2;
node1=node;
node2=OtherNode(segmentp,node);
if(IsFakeNode(node1))
GetFakeLatLong(node1,&lat1,&lon1);
else
GetLatLong(nodes,node1,&lat1,&lon1);
if(IsFakeNode(node2))
GetFakeLatLong(node2,&lat2,&lon2);
else
GetLatLong(nodes,node2,&lat2,&lon2);
angle=atan2((lat2-lat1),(lon2-lon1)*cos(lat1));
angle=radians_to_degrees(angle);
angle=270-angle;
if(angle< 0) angle+=360;
if(angle>360) angle-=360;
return(angle);
}
routino-2.4.1/src/sorting.c 644 233 144 63404 12063560526 11041 0 /***************************************
Merge sort functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2009-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include
#if defined(USE_PTHREADS) && USE_PTHREADS
#include
#endif
#include "types.h"
#include "logging.h"
#include "files.h"
#include "sorting.h"
/* Global variables */
/*+ The command line '--tmpdir' option or its default value. +*/
extern char *option_tmpdirname;
/*+ The amount of RAM to use for filesorting. +*/
extern size_t option_filesort_ramsize;
/*+ The number of filesorting threads allowed. +*/
extern int option_filesort_threads;
/* Thread data type definitions */
/*+ A data type for holding data for a thread. +*/
typedef struct _thread_data
{
pthread_t thread; /*+ The thread identifier. +*/
int running; /*+ A flag indicating the current state of the thread. +*/
void *data; /*+ The main data array. +*/
void **datap; /*+ An array of pointers to the data objects. +*/
size_t n; /*+ The number of pointers. +*/
char *filename; /*+ The name of the file to write the results to. +*/
size_t itemsize; /*+ The size of each item. +*/
int (*compare)(const void*,const void*); /*+ The comparison function. +*/
}
thread_data;
/* Thread variables */
#if defined(USE_PTHREADS) && USE_PTHREADS
static pthread_mutex_t running_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t running_cond = PTHREAD_COND_INITIALIZER;
#endif
/* Thread helper functions */
static void *filesort_fixed_heapsort_thread(thread_data *thread);
static void *filesort_vary_heapsort_thread(thread_data *thread);
/*++++++++++++++++++++++++++++++++++++++
A function to sort the contents of a file of fixed length objects using a
limited amount of RAM.
The data is sorted using a "Merge sort" http://en.wikipedia.org/wiki/Merge_sort
and in particular an "external sort" http://en.wikipedia.org/wiki/External_sorting.
The individual sort steps and the merge step both use a "Heap sort"
http://en.wikipedia.org/wiki/Heapsort. The combination of the two should work well
if the data is already partially sorted.
index_t filesort_fixed Returns the number of objects kept.
int fd_in The file descriptor of the input file (opened for reading and at the beginning).
int fd_out The file descriptor of the output file (opened for writing and empty).
size_t itemsize The size of each item in the file that needs sorting.
int (*pre_sort_function)(void *,index_t) If non-NULL then this function is called for
each item before they have been sorted. The second parameter is the number of objects
previously read from the input file. If the function returns 1 then the object is kept
and it is sorted, otherwise it is ignored.
int (*compare_function)(const void*, const void*) The comparison function. This is identical
to qsort if the data to be sorted is an array of things not pointers.
int (*post_sort_function)(void *,index_t) If non-NULL then this function is called for
each item after they have been sorted. The second parameter is the number of objects
already written to the output file. If the function returns 1 then the object is written
to the output file., otherwise it is ignored.
++++++++++++++++++++++++++++++++++++++*/
index_t filesort_fixed(int fd_in,int fd_out,size_t itemsize,int (*pre_sort_function)(void*,index_t),
int (*compare_function)(const void*,const void*),
int (*post_sort_function)(void*,index_t))
{
int *fds=NULL,*heap=NULL;
int nfiles=0,ndata=0;
index_t count_out=0,count_in=0,total=0;
size_t nitems=option_filesort_ramsize/(option_filesort_threads*(itemsize+sizeof(void*)));
void *data,**datap;
thread_data *threads;
int i,more=1;
#if defined(USE_PTHREADS) && USE_PTHREADS
int nthreads=0;
#endif
/* Allocate the RAM buffer and other bits */
threads=(thread_data*)malloc(option_filesort_threads*sizeof(thread_data));
for(i=0;i1)
{
/* Find a spare slot (one *must* be unused at all times) */
pthread_mutex_lock(&running_mutex);
for(thread=0;thread1)
{
pthread_mutex_lock(&running_mutex);
while(nthreads==(option_filesort_threads-1))
{
for(i=0;i1 && nthreads)
{
pthread_mutex_lock(&running_mutex);
pthread_cond_wait(&running_cond,&running_mutex);
for(i=0;i1)
{
int newindex;
int temp;
newindex=index/2;
if(compare_function(datap[heap[index]],datap[heap[newindex]])>=0)
break;
temp=heap[index];
heap[index]=heap[newindex];
heap[newindex]=temp;
index=newindex;
}
}
/* Repeatedly pull out the root of the heap and refill from the same file */
ndata=nfiles;
do
{
int index=1;
if(!post_sort_function || post_sort_function(datap[heap[index]],count_out))
{
WriteFile(fd_out,datap[heap[index]],itemsize);
count_out++;
}
if(ReadFile(fds[heap[index]],datap[heap[index]],itemsize))
{
heap[index]=heap[ndata];
ndata--;
}
/* Bubble down the new value */
while((2*index)=0)
newindex=newindex+1;
if(compare_function(datap[heap[index]],datap[heap[newindex]])<=0)
break;
temp=heap[newindex];
heap[newindex]=heap[index];
heap[index]=temp;
index=newindex;
}
if((2*index)==ndata)
{
int newindex;
int temp;
newindex=2*index;
if(compare_function(datap[heap[index]],datap[heap[newindex]])<=0)
; /* break */
else
{
temp=heap[newindex];
heap[newindex]=heap[index];
heap[index]=temp;
}
}
}
while(ndata>0);
/* Tidy up */
tidy_and_exit:
if(fds)
{
for(i=0;i1)
{
/* Find a spare slot (one *must* be unused at all times) */
pthread_mutex_lock(&running_mutex);
for(thread=0;threadlargestitemsize)
largestitemsize=itemsize;
*(FILESORT_VARINT*)(threads[thread].data+ramused)=itemsize;
ramused+=FILESORT_VARSIZE;
ReadFile(fd_in,threads[thread].data+ramused,itemsize);
if(!pre_sort_function || pre_sort_function(threads[thread].data+ramused,count_in))
{
*--threads[thread].datap=threads[thread].data+ramused; /* points to real data */
ramused+=itemsize;
ramused =FILESORT_VARALIGN*((ramused+FILESORT_VARSIZE-1)/FILESORT_VARALIGN);
ramused+=FILESORT_VARALIGN-FILESORT_VARSIZE;
total++;
threads[thread].n++;
}
count_in++;
if(ReadFile(fd_in,&nextitemsize,FILESORT_VARSIZE))
{
more=0;
break;
}
}
/* No new data read in this time round */
if(threads[thread].n==0)
break;
/* Sort the data pointers using a heap sort (potentially in a thread) */
if(more==0 && nfiles==0)
threads[thread].filename[0]=0;
else
sprintf(threads[thread].filename,"%s/filesort.%d.tmp",option_tmpdirname,nfiles);
#if defined(USE_PTHREADS) && USE_PTHREADS
/* Shortcut if only one file, don't write to disk */
if(more==0 && nfiles==0)
filesort_heapsort(threads[thread].datap,threads[thread].n,threads[thread].compare);
else if(option_filesort_threads>1)
{
pthread_mutex_lock(&running_mutex);
while(nthreads==(option_filesort_threads-1))
{
for(i=0;i1 && nthreads)
{
pthread_mutex_lock(&running_mutex);
pthread_cond_wait(&running_cond,&running_mutex);
for(i=0;i1)
{
int newindex;
int temp;
newindex=index/2;
if(compare_function(datap[heap[index]],datap[heap[newindex]])>=0)
break;
temp=heap[index];
heap[index]=heap[newindex];
heap[newindex]=temp;
index=newindex;
}
}
/* Repeatedly pull out the root of the heap and refill from the same file */
ndata=nfiles;
do
{
int index=1;
FILESORT_VARINT itemsize;
if(!post_sort_function || post_sort_function(datap[heap[index]],count_out))
{
itemsize=*(FILESORT_VARINT*)(datap[heap[index]]-FILESORT_VARSIZE);
WriteFile(fd_out,datap[heap[index]]-FILESORT_VARSIZE,itemsize+FILESORT_VARSIZE);
count_out++;
}
if(ReadFile(fds[heap[index]],&itemsize,FILESORT_VARSIZE))
{
heap[index]=heap[ndata];
ndata--;
}
else
{
*(FILESORT_VARINT*)(datap[heap[index]]-FILESORT_VARSIZE)=itemsize;
ReadFile(fds[heap[index]],datap[heap[index]],itemsize);
}
/* Bubble down the new value */
while((2*index)=0)
newindex=newindex+1;
if(compare_function(datap[heap[index]],datap[heap[newindex]])<=0)
break;
temp=heap[newindex];
heap[newindex]=heap[index];
heap[index]=temp;
index=newindex;
}
if((2*index)==ndata)
{
int newindex;
int temp;
newindex=2*index;
if(compare_function(datap[heap[index]],datap[heap[newindex]])<=0)
; /* break */
else
{
temp=heap[newindex];
heap[newindex]=heap[index];
heap[index]=temp;
}
}
}
while(ndata>0);
/* Tidy up */
tidy_and_exit:
if(fds)
{
for(i=0;idatap,thread->n,thread->compare);
/* Create a temporary file and write the result */
fd=OpenFileNew(thread->filename);
for(i=0;in;i++)
WriteFile(fd,thread->datap[i],thread->itemsize);
CloseFile(fd);
#if defined(USE_PTHREADS) && USE_PTHREADS
if(option_filesort_threads>1)
{
pthread_mutex_lock(&running_mutex);
thread->running=2;
pthread_cond_signal(&running_cond);
pthread_mutex_unlock(&running_mutex);
}
#endif
return(NULL);
}
/*++++++++++++++++++++++++++++++++++++++
A wrapper function that can be run in a thread for variable data.
void *filesort_vary_heapsort_thread Returns NULL (required to return void*).
thread_data *thread The data to be processed in this thread.
++++++++++++++++++++++++++++++++++++++*/
static void *filesort_vary_heapsort_thread(thread_data *thread)
{
int fd,i;
/* Sort the data pointers using a heap sort */
filesort_heapsort(thread->datap,thread->n,thread->compare);
/* Create a temporary file and write the result */
fd=OpenFileNew(thread->filename);
for(i=0;in;i++)
{
FILESORT_VARINT itemsize=*(FILESORT_VARINT*)(thread->datap[i]-FILESORT_VARSIZE);
WriteFile(fd,thread->datap[i]-FILESORT_VARSIZE,itemsize+FILESORT_VARSIZE);
}
CloseFile(fd);
#if defined(USE_PTHREADS) && USE_PTHREADS
if(option_filesort_threads>1)
{
pthread_mutex_lock(&running_mutex);
thread->running=2;
pthread_cond_signal(&running_cond);
pthread_mutex_unlock(&running_mutex);
}
#endif
return(NULL);
}
/*++++++++++++++++++++++++++++++++++++++
A function to sort an array of pointers efficiently.
The data is sorted using a "Heap sort" http://en.wikipedia.org/wiki/Heapsort,
in particular, this is good because it can operate in-place and doesn't
allocate more memory like using qsort() does.
void **datap A pointer to the array of pointers to sort.
size_t nitems The number of items of data to sort.
int (*compare_function)(const void*, const void*) The comparison function. This is identical
to qsort if the data to be sorted is an array of things not pointers.
++++++++++++++++++++++++++++++++++++++*/
void filesort_heapsort(void **datap,size_t nitems,int(*compare_function)(const void*, const void*))
{
void **datap1=&datap[-1];
int i;
/* Fill the heap by pretending to insert the data that is already there */
for(i=2;i<=nitems;i++)
{
int index=i;
/* Bubble up the new value (upside-down, put largest at top) */
while(index>1)
{
int newindex;
void *temp;
newindex=index/2;
if(compare_function(datap1[index],datap1[newindex])<=0) /* reversed comparison to filesort_fixed() above */
break;
temp=datap1[index];
datap1[index]=datap1[newindex];
datap1[newindex]=temp;
index=newindex;
}
}
/* Repeatedly pull out the root of the heap and swap with the bottom item */
for(i=nitems;i>1;i--)
{
int index=1;
void *temp;
temp=datap1[index];
datap1[index]=datap1[i];
datap1[i]=temp;
/* Bubble down the new value (upside-down, put largest at top) */
while((2*index)<(i-1))
{
int newindex;
void *temp;
newindex=2*index;
if(compare_function(datap1[newindex],datap1[newindex+1])<=0) /* reversed comparison to filesort_fixed() above */
newindex=newindex+1;
if(compare_function(datap1[index],datap1[newindex])>=0) /* reversed comparison to filesort_fixed() above */
break;
temp=datap1[newindex];
datap1[newindex]=datap1[index];
datap1[index]=temp;
index=newindex;
}
if((2*index)==(i-1))
{
int newindex;
void *temp;
newindex=2*index;
if(compare_function(datap1[index],datap1[newindex])>=0) /* reversed comparison to filesort_fixed() above */
; /* break */
else
{
temp=datap1[newindex];
datap1[newindex]=datap1[index];
datap1[index]=temp;
}
}
}
}
routino-2.4.1/src/planetsplitter.c 644 233 144 45041 12063560526 12423 0 /***************************************
OSM planet file splitter.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include
#include
#include
#include "types.h"
#include "ways.h"
#include "typesx.h"
#include "nodesx.h"
#include "segmentsx.h"
#include "waysx.h"
#include "relationsx.h"
#include "superx.h"
#include "prunex.h"
#include "files.h"
#include "logging.h"
#include "functions.h"
#include "osmparser.h"
#include "tagging.h"
/* Global variables */
/*+ The name of the temporary directory. +*/
char *option_tmpdirname=NULL;
/*+ The amount of RAM to use for filesorting. +*/
size_t option_filesort_ramsize=0;
/*+ The number of threads to use for filesorting. +*/
int option_filesort_threads=1;
/* Local functions */
static void print_usage(int detail,const char *argerr,const char *err);
/*++++++++++++++++++++++++++++++++++++++
The main program for the planetsplitter.
++++++++++++++++++++++++++++++++++++++*/
int main(int argc,char** argv)
{
struct timeval start_time;
NodesX *Nodes;
SegmentsX *Segments,*SuperSegments=NULL,*MergedSegments=NULL;
WaysX *Ways;
RelationsX *Relations;
int iteration=0,quit=0;
int max_iterations=5;
char *dirname=NULL,*prefix=NULL,*tagging=NULL,*errorlog=NULL;
int option_parse_only=0,option_process_only=0;
int option_append=0,option_keep=0,option_changes=0;
int option_filenames=0;
int option_prune_isolated=500,option_prune_short=5,option_prune_straight=3;
int arg;
gettimeofday(&start_time,NULL);
/* Parse the command line arguments */
for(arg=1;arg9?"=":"");
fflush(stdout);
if(iteration==0)
{
/* Select the super-nodes */
ChooseSuperNodes(Nodes,Segments,Ways);
/* Select the super-segments */
SuperSegments=CreateSuperSegments(Nodes,Segments,Ways);
nsuper=Segments->number;
}
else
{
SegmentsX *SuperSegments2;
/* Select the super-nodes */
ChooseSuperNodes(Nodes,SuperSegments,Ways);
/* Select the super-segments */
SuperSegments2=CreateSuperSegments(Nodes,SuperSegments,Ways);
nsuper=SuperSegments->number;
FreeSegmentList(SuperSegments,0);
SuperSegments=SuperSegments2;
}
/* Sort the super-segments and remove duplicates */
DeduplicateSuperSegments(SuperSegments,Ways);
/* Index the segments */
IndexSegments(SuperSegments,Nodes,Ways);
/* Check for end condition */
if(SuperSegments->number==nsuper)
quit=1;
iteration++;
if(iteration>max_iterations)
quit=1;
}
while(!quit);
/* Combine the super-segments */
printf("\nCombine Segments and Super-Segments\n===================================\n\n");
fflush(stdout);
/* Merge the super-segments */
MergedSegments=MergeSuperSegments(Segments,SuperSegments);
FreeSegmentList(Segments,0);
FreeSegmentList(SuperSegments,0);
Segments=MergedSegments;
/* Re-index the merged segments */
IndexSegments(Segments,Nodes,Ways);
/* Cross reference the nodes and segments */
printf("\nCross-Reference Nodes and Segments\n==================================\n\n");
fflush(stdout);
/* Sort the nodes and segments geographically */
SortNodeListGeographically(Nodes);
SortSegmentListGeographically(Segments,Nodes);
/* Re-index the segments */
IndexSegments(Segments,Nodes,Ways);
/* Sort the turn relations geographically */
SortTurnRelationListGeographically(Relations,Nodes,Segments);
/* Output the results */
printf("\nWrite Out Database Files\n========================\n\n");
fflush(stdout);
/* Write out the nodes */
SaveNodeList(Nodes,FileName(dirname,prefix,"nodes.mem"),Segments);
FreeNodeList(Nodes,0);
/* Write out the segments */
SaveSegmentList(Segments,FileName(dirname,prefix,"segments.mem"));
FreeSegmentList(Segments,0);
/* Write out the ways */
SaveWayList(Ways,FileName(dirname,prefix,"ways.mem"));
FreeWayList(Ways,0);
/* Write out the relations */
SaveRelationList(Relations,FileName(dirname,prefix,"relations.mem"));
FreeRelationList(Relations,0);
/* Close the error log file */
if(errorlog)
close_errorlog();
/* Print the total time */
if(option_logtime)
{
printf("\n");
fprintf_elapsed_time(stdout,&start_time);
printf("Complete\n");
fflush(stdout);
}
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
Print out the usage information.
int detail The level of detail to use - 0 = low, 1 = high.
const char *argerr The argument that gave the error (if there is one).
const char *err Other error message (if there is one).
++++++++++++++++++++++++++++++++++++++*/
static void print_usage(int detail,const char *argerr,const char *err)
{
fprintf(stderr,
"Usage: planetsplitter [--help]\n"
" [--dir=] [--prefix=]\n"
#if defined(USE_PTHREADS) && USE_PTHREADS
" [--sort-ram-size=] [--sort-threads=]\n"
#else
" [--sort-ram-size=]\n"
#endif
" [--tmpdir=]\n"
" [--tagging=]\n"
" [--loggable] [--logtime]\n"
" [--errorlog[=]]\n"
" [--parse-only | --process-only]\n"
" [--append] [--keep] [--changes]\n"
" [--max-iterations=]\n"
" [--prune-none]\n"
" [--prune-isolated=]\n"
" [--prune-short=]\n"
" [--prune-straight=]\n"
" [ ...]\n");
if(argerr)
fprintf(stderr,
"\n"
"Error with command line parameter: %s\n",argerr);
if(err)
fprintf(stderr,
"\n"
"Error: %s\n",err);
if(detail)
fprintf(stderr,
"\n"
"--help Prints this information.\n"
"\n"
"--dir= The directory containing the routing database.\n"
"--prefix= The filename prefix for the routing database.\n"
"\n"
"--sort-ram-size= The amount of RAM (in MB) to use for data sorting\n"
#if SLIM
" (defaults to 64MB otherwise.)\n"
#else
" (defaults to 256MB otherwise.)\n"
#endif
#if defined(USE_PTHREADS) && USE_PTHREADS
"--sort-threads= The number of threads to use for data sorting.\n"
#endif
"\n"
"--tmpdir= The directory name for temporary files.\n"
" (defaults to the '--dir' option directory.)\n"
"\n"
"--tagging= The name of the XML file containing the tagging rules\n"
" (defaults to 'tagging.xml' with '--dir' and\n"
" '--prefix' options or the file installed in\n"
" '" DATADIR "').\n"
"\n"
"--loggable Print progress messages suitable for logging to file.\n"
"--logtime Print the elapsed time for each processing step.\n"
"--errorlog[=] Log parsing errors to 'error.log' or the given name\n"
" (the '--dir' and '--prefix' options are applied).\n"
"\n"
"--parse-only Parse the OSM/OSC file(s) and store the results.\n"
"--process-only Process the stored results from previous option.\n"
"--append Parse the OSM file(s) and append to existing results.\n"
"--keep Keep the intermediate files after parsing & sorting.\n"
"--changes Parse the data as an OSC file and apply the changes.\n"
"\n"
"--max-iterations= The number of iterations for finding super-nodes\n"
" (defaults to 5).\n"
"\n"
"--prune-none Disable the prune options below, they are re-enabled\n"
" by adding them to the command line after this option.\n"
"--prune-isolated= Remove access from small disconnected segment groups\n"
" (defaults to removing groups under 500m).\n"
"--prune-short= Remove short segments (defaults to removing segments\n"
" up to a maximum length of 5m).\n"
"--prune-straight= Remove nodes in almost straight highways (defaults to\n"
" removing nodes up to 3m offset from a straight line).\n"
"\n"
" ... The name(s) of the file(s) to process (by default\n"
" data is read from standard input).\n"
"\n"
" defaults to all but can be set to:\n"
"%s"
"\n"
" can be selected from:\n"
"%s"
"\n"
" can be selected from:\n"
"%s",
TransportList(),HighwayList(),PropertyList());
exit(!detail);
}
routino-2.4.1/src/nodes.h 644 233 144 11760 12063560526 10467 0 /***************************************
A header file for the nodes.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef NODES_H
#define NODES_H /*+ To stop multiple inclusions. +*/
#include
#include
#include "types.h"
#include "files.h"
#include "profiles.h"
/* Data structures */
/*+ A structure containing a single node. +*/
struct _Node
{
index_t firstseg; /*+ The index of the first segment. +*/
ll_off_t latoffset; /*+ The node latitude offset within its bin. +*/
ll_off_t lonoffset; /*+ The node longitude offset within its bin. +*/
transports_t allow; /*+ The types of transport that are allowed through the node. +*/
nodeflags_t flags; /*+ Flags containing extra information (e.g. super-node, turn restriction). +*/
};
/*+ A structure containing the header from the file. +*/
typedef struct _NodesFile
{
index_t number; /*+ The number of nodes in total. +*/
index_t snumber; /*+ The number of super-nodes. +*/
ll_bin_t latbins; /*+ The number of bins containing latitude. +*/
ll_bin_t lonbins; /*+ The number of bins containing longitude. +*/
ll_bin_t latzero; /*+ The bin number of the furthest south bin. +*/
ll_bin_t lonzero; /*+ The bin number of the furthest west bin. +*/
}
NodesFile;
/*+ A structure containing a set of nodes. +*/
struct _Nodes
{
NodesFile file; /*+ The header data from the file. +*/
#if !SLIM
void *data; /*+ The memory mapped data in the file. +*/
index_t *offsets; /*+ A pointer to the array of offsets in the file. +*/
Node *nodes; /*+ A pointer to the array of nodes in the file. +*/
#else
int fd; /*+ The file descriptor for the file. +*/
index_t *offsets; /*+ An allocated array with a copy of the file offsets. +*/
off_t nodesoffset; /*+ The offset of the nodes within the file. +*/
Node cached[6]; /*+ Some cached nodes read from the file in slim mode. +*/
index_t incache[6]; /*+ The indexes of the cached nodes. +*/
#endif
};
/* Functions in nodes.c */
Nodes *LoadNodeList(const char *filename);
index_t FindClosestNode(Nodes *nodes,Segments *segments,Ways *ways,double latitude,double longitude,
distance_t distance,Profile *profile,distance_t *bestdist);
index_t FindClosestSegment(Nodes *nodes,Segments *segments,Ways *ways,double latitude,double longitude,
distance_t distance,Profile *profile, distance_t *bestdist,
index_t *bestnode1,index_t *bestnode2,distance_t *bestdist1,distance_t *bestdist2);
void GetLatLong(Nodes *nodes,index_t index,double *latitude,double *longitude);
/* Macros and inline functions */
/*+ Return true if this is a super-node. +*/
#define IsSuperNode(xxx) (((xxx)->flags)&NODE_SUPER)
/*+ Return true if this is a turn restricted node. +*/
#define IsTurnRestrictedNode(xxx) (((xxx)->flags)&NODE_TURNRSTRCT)
/*+ Return a Segment index given a Node pointer and a set of segments. +*/
#define FirstSegment(xxx,yyy,ppp) LookupSegment((xxx),(yyy)->firstseg,ppp)
/*+ Return the offset of a geographical region given a set of nodes. +*/
#define LookupNodeOffset(xxx,yyy) ((xxx)->offsets[yyy])
#if !SLIM
/*+ Return a Node pointer given a set of nodes and an index. +*/
#define LookupNode(xxx,yyy,ppp) (&(xxx)->nodes[yyy])
#else
static Node *LookupNode(Nodes *nodes,index_t index,int position);
/*++++++++++++++++++++++++++++++++++++++
Find the Node information for a particular node.
Node *LookupNode Returns a pointer to the cached node information.
Nodes *nodes The set of nodes to use.
index_t index The index of the node.
int position The position in the cache to store the value.
++++++++++++++++++++++++++++++++++++++*/
static inline Node *LookupNode(Nodes *nodes,index_t index,int position)
{
if(nodes->incache[position-1]!=index)
{
SeekReadFile(nodes->fd,&nodes->cached[position-1],sizeof(Node),nodes->nodesoffset+(off_t)index*sizeof(Node));
nodes->incache[position-1]=index;
}
return(&nodes->cached[position-1]);
}
#endif
#endif /* NODES_H */
routino-2.4.1/src/relationsx.c 644 233 144 111345 12063562207 11560 0 /***************************************
Extended Relation data type functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2010-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include "types.h"
#include "segments.h"
#include "relations.h"
#include "nodesx.h"
#include "segmentsx.h"
#include "waysx.h"
#include "relationsx.h"
#include "files.h"
#include "logging.h"
#include "sorting.h"
/* Global variables */
/*+ The command line '--tmpdir' option or its default value. +*/
extern char *option_tmpdirname;
/* Local variables */
/*+ Temporary file-local variables for use by the sort functions. +*/
static SegmentsX *sortsegmentsx;
static NodesX *sortnodesx;
/* Local functions */
static int sort_route_by_id(RouteRelX *a,RouteRelX *b);
static int deduplicate_route_by_id(RouteRelX *relationx,index_t index);
static int sort_turn_by_id(TurnRelX *a,TurnRelX *b);
static int deduplicate_turn_by_id(TurnRelX *relationx,index_t index);
static int geographically_index(TurnRelX *relationx,index_t index);
static int sort_by_via(TurnRelX *a,TurnRelX *b);
/*++++++++++++++++++++++++++++++++++++++
Allocate a new relation list (create a new file or open an existing one).
RelationsX *NewRelationList Returns the relation list.
int append Set to 1 if the file is to be opened for appending.
int readonly Set to 1 if the file is to be opened for reading.
++++++++++++++++++++++++++++++++++++++*/
RelationsX *NewRelationList(int append,int readonly)
{
RelationsX *relationsx;
relationsx=(RelationsX*)calloc(1,sizeof(RelationsX));
logassert(relationsx,"Failed to allocate memory (try using slim mode?)"); /* Check calloc() worked */
/* Route Relations */
relationsx->rfilename =(char*)malloc(strlen(option_tmpdirname)+32);
relationsx->rfilename_tmp=(char*)malloc(strlen(option_tmpdirname)+32);
sprintf(relationsx->rfilename ,"%s/relationsx.route.parsed.mem",option_tmpdirname);
sprintf(relationsx->rfilename_tmp,"%s/relationsx.route.%p.tmp" ,option_tmpdirname,(void*)relationsx);
if(append || readonly)
if(ExistsFile(relationsx->rfilename))
{
off_t size,position=0;
int rfd;
size=SizeFile(relationsx->rfilename);
rfd=ReOpenFile(relationsx->rfilename);
while(positionrnumber++;
position+=relationsize+FILESORT_VARSIZE;
}
CloseFile(rfd);
RenameFile(relationsx->rfilename ,relationsx->rfilename_tmp);
}
if(append)
relationsx->rfd=OpenFileAppend(relationsx->rfilename_tmp);
else if(!readonly)
relationsx->rfd=OpenFileNew(relationsx->rfilename_tmp);
else
relationsx->rfd=-1;
/* Turn Restriction Relations */
relationsx->trfilename =(char*)malloc(strlen(option_tmpdirname)+32);
relationsx->trfilename_tmp=(char*)malloc(strlen(option_tmpdirname)+32);
sprintf(relationsx->trfilename ,"%s/relationsx.turn.parsed.mem",option_tmpdirname);
sprintf(relationsx->trfilename_tmp,"%s/relationsx.turn.%p.tmp" ,option_tmpdirname,(void*)relationsx);
if(append || readonly)
if(ExistsFile(relationsx->trfilename))
{
off_t size;
size=SizeFile(relationsx->trfilename);
relationsx->trnumber=size/sizeof(TurnRelX);
RenameFile(relationsx->trfilename,relationsx->trfilename_tmp);
}
if(append)
relationsx->trfd=OpenFileAppend(relationsx->trfilename_tmp);
else if(!readonly)
relationsx->trfd=OpenFileNew(relationsx->trfilename_tmp);
else
relationsx->trfd=-1;
return(relationsx);
}
/*++++++++++++++++++++++++++++++++++++++
Free a relation list.
RelationsX *relationsx The set of relations to be freed.
int keep If set then the results file is to be kept.
++++++++++++++++++++++++++++++++++++++*/
void FreeRelationList(RelationsX *relationsx,int keep)
{
/* Route relations */
if(keep)
RenameFile(relationsx->rfilename_tmp,relationsx->rfilename);
else
DeleteFile(relationsx->rfilename_tmp);
free(relationsx->rfilename);
free(relationsx->rfilename_tmp);
/* Turn Restriction relations */
if(keep)
RenameFile(relationsx->trfilename_tmp,relationsx->trfilename);
else
DeleteFile(relationsx->trfilename_tmp);
free(relationsx->trfilename);
free(relationsx->trfilename_tmp);
free(relationsx);
}
/*++++++++++++++++++++++++++++++++++++++
Append a single relation to an unsorted route relation list.
RelationsX* relationsx The set of relations to process.
relation_t id The ID of the relation.
transports_t routes The types of routes that this relation is for.
way_t *ways The array of ways that are members of the relation.
int nways The number of ways that are members of the relation.
relation_t *relations The array of relations that are members of the relation.
int nrelations The number of relations that are members of the relation.
++++++++++++++++++++++++++++++++++++++*/
void AppendRouteRelationList(RelationsX* relationsx,relation_t id,
transports_t routes,
way_t *ways,int nways,
relation_t *relations,int nrelations)
{
RouteRelX relationx={0};
FILESORT_VARINT size;
way_t noway=NO_WAY_ID;
relation_t norelation=NO_RELATION_ID;
relationx.id=id;
relationx.routes=routes;
size=sizeof(RouteRelX)+(nways+1)*sizeof(way_t)+(nrelations+1)*sizeof(relation_t);
WriteFile(relationsx->rfd,&size,FILESORT_VARSIZE);
WriteFile(relationsx->rfd,&relationx,sizeof(RouteRelX));
WriteFile(relationsx->rfd,ways ,nways*sizeof(way_t));
WriteFile(relationsx->rfd,&noway, sizeof(way_t));
WriteFile(relationsx->rfd,relations ,nrelations*sizeof(relation_t));
WriteFile(relationsx->rfd,&norelation, sizeof(relation_t));
relationsx->rnumber++;
logassert(relationsx->rnumber!=0,"Too many route relations (change index_t to 64-bits?)"); /* Zero marks the high-water mark for relations. */
}
/*++++++++++++++++++++++++++++++++++++++
Append a single relation to an unsorted turn restriction relation list.
RelationsX* relationsx The set of relations to process.
relation_t id The ID of the relation.
way_t from The way that the turn restriction starts from.
way_t to The way that the restriction finished on.
node_t via The node that the turn restriction passes through.
TurnRestriction restriction The type of restriction.
transports_t except The set of transports allowed to bypass the restriction.
++++++++++++++++++++++++++++++++++++++*/
void AppendTurnRelationList(RelationsX* relationsx,relation_t id,
way_t from,way_t to,node_t via,
TurnRestriction restriction,transports_t except)
{
TurnRelX relationx={0};
relationx.id=id;
relationx.from=from;
relationx.to=to;
relationx.via=via;
relationx.restriction=restriction;
relationx.except=except;
WriteFile(relationsx->trfd,&relationx,sizeof(TurnRelX));
relationsx->trnumber++;
logassert(relationsx->trnumber!=0,"Too many turn relations (change index_t to 64-bits?)"); /* Zero marks the high-water mark for relations. */
}
/*++++++++++++++++++++++++++++++++++++++
Finish appending relations and change the filename over.
RelationsX *relationsx The relations that have been appended.
++++++++++++++++++++++++++++++++++++++*/
void FinishRelationList(RelationsX *relationsx)
{
if(relationsx->rfd!=-1)
relationsx->rfd =CloseFile(relationsx->rfd);
if(relationsx->trfd!=-1)
relationsx->trfd=CloseFile(relationsx->trfd);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the list of relations.
RelationsX* relationsx The set of relations to process.
++++++++++++++++++++++++++++++++++++++*/
void SortRelationList(RelationsX* relationsx)
{
/* Route Relations */
if(relationsx->rnumber)
{
index_t rxnumber;
int rfd;
/* Print the start message */
printf_first("Sorting Route Relations");
/* Re-open the file read-only and a new file writeable */
relationsx->rfd=ReOpenFile(relationsx->rfilename_tmp);
DeleteFile(relationsx->rfilename_tmp);
rfd=OpenFileNew(relationsx->rfilename_tmp);
/* Sort the relations */
rxnumber=relationsx->rnumber;
relationsx->rnumber=filesort_vary(relationsx->rfd,rfd,NULL,
(int (*)(const void*,const void*))sort_route_by_id,
(int (*)(void*,index_t))deduplicate_route_by_id);
/* Close the files */
relationsx->rfd=CloseFile(relationsx->rfd);
CloseFile(rfd);
/* Print the final message */
printf_last("Sorted Route Relations: Relations=%"Pindex_t" Duplicates=%"Pindex_t,rxnumber,rxnumber-relationsx->rnumber);
}
/* Turn Restriction Relations. */
if(relationsx->trnumber)
{
index_t trxnumber;
int trfd;
/* Print the start message */
printf_first("Sorting Turn Relations");
/* Re-open the file read-only and a new file writeable */
relationsx->trfd=ReOpenFile(relationsx->trfilename_tmp);
DeleteFile(relationsx->trfilename_tmp);
trfd=OpenFileNew(relationsx->trfilename_tmp);
/* Sort the relations */
trxnumber=relationsx->trnumber;
relationsx->trnumber=filesort_fixed(relationsx->trfd,trfd,sizeof(TurnRelX),NULL,
(int (*)(const void*,const void*))sort_turn_by_id,
(int (*)(void*,index_t))deduplicate_turn_by_id);
/* Close the files */
relationsx->trfd=CloseFile(relationsx->trfd);
CloseFile(trfd);
/* Print the final message */
printf_last("Sorted Turn Relations: Relations=%"Pindex_t" Duplicates=%"Pindex_t,trxnumber,trxnumber-relationsx->trnumber);
}
}
/*++++++++++++++++++++++++++++++++++++++
Sort the route relations into id order.
int sort_route_by_id Returns the comparison of the id fields.
RouteRelX *a The first extended relation.
RouteRelX *b The second extended relation.
++++++++++++++++++++++++++++++++++++++*/
static int sort_route_by_id(RouteRelX *a,RouteRelX *b)
{
relation_t a_id=a->id;
relation_t b_id=b->id;
if(a_idb_id)
return(1);
else
return(-FILESORT_PRESERVE_ORDER(a,b)); /* latest version first */
}
/*++++++++++++++++++++++++++++++++++++++
Deduplicate the route relations using the id after sorting.
int deduplicate_route_by_id Return 1 if the value is to be kept, otherwise 0.
RouteRelX *relationx The extended relation.
index_t index The number of sorted relations that have already been written to the output file.
++++++++++++++++++++++++++++++++++++++*/
static int deduplicate_route_by_id(RouteRelX *relationx,index_t index)
{
static relation_t previd=NO_RELATION_ID;
if(relationx->id!=previd)
{
previd=relationx->id;
if(relationx->routes==RELATION_DELETED)
return(0);
else
return(1);
}
else
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the turn restriction relations into id order.
int sort_turn_by_id Returns the comparison of the id fields.
TurnRelX *a The first extended relation.
TurnRelX *b The second extended relation.
++++++++++++++++++++++++++++++++++++++*/
static int sort_turn_by_id(TurnRelX *a,TurnRelX *b)
{
relation_t a_id=a->id;
relation_t b_id=b->id;
if(a_idb_id)
return(1);
else
return(-FILESORT_PRESERVE_ORDER(a,b)); /* latest version first */
}
/*++++++++++++++++++++++++++++++++++++++
Deduplicate the turn restriction relations using the id after sorting.
int deduplicate_turn_by_id Return 1 if the value is to be kept, otherwise 0.
TurnRelX *relationx The extended relation.
index_t index The number of sorted relations that have already been written to the output file.
++++++++++++++++++++++++++++++++++++++*/
static int deduplicate_turn_by_id(TurnRelX *relationx,index_t index)
{
static relation_t previd=NO_RELATION_ID;
if(relationx->id!=previd)
{
previd=relationx->id;
if(relationx->except==RELATION_DELETED)
return(0);
else
return(1);
}
else
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
Process the route relations and apply the information to the ways.
RelationsX *relationsx The set of relations to use.
WaysX *waysx The set of ways to modify.
int keep If set to 1 then keep the old data file otherwise delete it.
++++++++++++++++++++++++++++++++++++++*/
void ProcessRouteRelations(RelationsX *relationsx,WaysX *waysx,int keep)
{
RouteRelX *unmatched=NULL,*lastunmatched=NULL;
int nunmatched=0,lastnunmatched=0,iteration=1;
if(waysx->number==0)
return;
/* Map into memory / open the files */
#if !SLIM
waysx->data=MapFileWriteable(waysx->filename_tmp);
#else
waysx->fd=ReOpenFileWriteable(waysx->filename_tmp);
#endif
/* Re-open the file read-only */
relationsx->rfd=ReOpenFile(relationsx->rfilename_tmp);
/* Read through the file. */
do
{
int ways=0,relations=0;
index_t i;
SeekFile(relationsx->rfd,0);
/* Print the start message */
printf_first("Processing Route Relations (%d): Relations=0 Modified Ways=0",iteration);
for(i=0;irnumber;i++)
{
FILESORT_VARINT size;
RouteRelX relationx;
way_t wayid;
relation_t relationid;
transports_t routes=Transports_None;
/* Read each route relation */
ReadFile(relationsx->rfd,&size,FILESORT_VARSIZE);
ReadFile(relationsx->rfd,&relationx,sizeof(RouteRelX));
/* Decide what type of route it is */
if(iteration==1)
{
relations++;
routes=relationx.routes;
}
else
{
int j;
for(j=0;jrfd,&wayid,sizeof(way_t));
/* Update the ways that are listed for the relation */
if(wayid==NO_WAY_ID)
continue;
if(routes)
{
index_t way=IndexWayX(waysx,wayid);
if(way!=NO_WAY)
{
WayX *wayx=LookupWayX(waysx,way,1);
if(routes&Transports_Foot)
{
if(!(wayx->way.allow&Transports_Foot))
{
logerror("Route Relation %"Prelation_t" for Foot contains Way %"Pway_t" that does not allow Foot transport; overriding.\n",relationx.id,wayid);
wayx->way.allow|=Transports_Foot;
}
wayx->way.props|=Properties_FootRoute;
}
if(routes&Transports_Bicycle)
{
if(!(wayx->way.allow&Transports_Bicycle))
{
logerror("Route Relation %"Prelation_t" for Bicycle contains Way %"Pway_t" that does not allow Bicycle transport; overriding.\n",relationx.id,wayid);
wayx->way.allow|=Transports_Bicycle;
}
wayx->way.props|=Properties_BicycleRoute;
}
PutBackWayX(waysx,wayx);
ways++;
}
else
logerror("Route Relation %"Prelation_t" contains Way %"Pway_t" but it does not exist in the Routino database.\n",relationx.id,wayid);
}
}
while(wayid!=NO_WAY_ID);
/* Loop through the relations */
do
{
ReadFile(relationsx->rfd,&relationid,sizeof(relation_t));
/* Add the relations that are listed for this relation to the list for next time */
if(relationid==NO_RELATION_ID)
continue;
if(relationid==relationx.id)
logerror("Relation %"Prelation_t" contains itself.\n",relationx.id);
else if(routes)
{
if(nunmatched%256==0)
unmatched=(RouteRelX*)realloc((void*)unmatched,(nunmatched+256)*sizeof(RouteRelX));
unmatched[nunmatched].id=relationid;
unmatched[nunmatched].routes=routes;
nunmatched++;
}
}
while(relationid!=NO_RELATION_ID);
if(!((i+1)%1000))
printf_middle("Processing Route Relations (%d): Relations=%"Pindex_t" Modified Ways=%"Pindex_t,iteration,relations,ways);
}
if(lastunmatched)
free(lastunmatched);
lastunmatched=unmatched;
lastnunmatched=nunmatched;
unmatched=NULL;
nunmatched=0;
/* Print the final message */
printf_last("Processed Route Relations (%d): Relations=%"Pindex_t" Modified Ways=%"Pindex_t,iteration,relations,ways);
}
while(lastnunmatched && iteration++<8);
if(lastunmatched)
free(lastunmatched);
/* Close the file */
relationsx->rfd=CloseFile(relationsx->rfd);
if(keep)
RenameFile(relationsx->rfilename_tmp,relationsx->rfilename);
/* Unmap from memory / close the files */
#if !SLIM
waysx->data=UnmapFile(waysx->data);
#else
waysx->fd=CloseFile(waysx->fd);
#endif
}
/*++++++++++++++++++++++++++++++++++++++
Process the turn relations (first part) to update them with the node/way information.
RelationsX *relationsx The set of relations to modify.
NodesX *nodesx The set of nodes to use.
WaysX *waysx The set of ways to use.
int keep If set to 1 then keep the old data file otherwise delete it.
++++++++++++++++++++++++++++++++++++++*/
void ProcessTurnRelations1(RelationsX *relationsx,NodesX *nodesx,WaysX *waysx,int keep)
{
int trfd;
index_t i,deleted=0;
/* Print the start message */
printf_first("Processing Turn Relations (1): Relations=0");
/* Re-open the file read-only and a new file writeable */
relationsx->trfd=ReOpenFile(relationsx->trfilename_tmp);
if(keep)
RenameFile(relationsx->trfilename_tmp,relationsx->trfilename);
else
DeleteFile(relationsx->trfilename_tmp);
trfd=OpenFileNew(relationsx->trfilename_tmp);
/* Process all of the relations */
for(i=0;itrnumber;i++)
{
TurnRelX relationx;
index_t via,from,to;
ReadFile(relationsx->trfd,&relationx,sizeof(TurnRelX));
via =IndexNodeX(nodesx,relationx.via);
from=IndexWayX(waysx,relationx.from);
to =IndexWayX(waysx,relationx.to);
if(via==NO_NODE)
logerror("Turn Relation %"Prelation_t" contains Node %"Pnode_t" but it does not exist in the Routino database.\n",relationx.id,relationx.via);
if(from==NO_WAY)
logerror("Turn Relation %"Prelation_t" contains Way %"Pway_t" but it does not exist in the Routino database.\n",relationx.id,relationx.from);
if(to==NO_WAY)
logerror("Turn Relation %"Prelation_t" contains Way %"Pway_t" but it does not exist in the Routino database.\n",relationx.id,relationx.to);
relationx.via =via;
relationx.from=from;
relationx.to =to;
if(relationx.via==NO_NODE || relationx.from==NO_WAY || relationx.to==NO_WAY)
deleted++;
else
WriteFile(trfd,&relationx,sizeof(TurnRelX));
if(!((i+1)%1000))
printf_middle("Processing Turn Relations (1): Relations=%"Pindex_t" Deleted=%"Pindex_t,i+1,deleted);
}
/* Close the files */
relationsx->trfd=CloseFile(relationsx->trfd);
CloseFile(trfd);
/* Print the final message */
printf_last("Processed Turn Relations (1): Relations=%"Pindex_t" Deleted=%"Pindex_t,relationsx->trnumber,deleted);
relationsx->trnumber-=deleted;
}
/*++++++++++++++++++++++++++++++++++++++
Process the turn relations (second part) to convert them to nodes.
RelationsX *relationsx The set of relations to modify.
NodesX *nodesx The set of nodes to use.
SegmentsX *segmentsx The set of segments to use.
WaysX *waysx The set of ways to use.
++++++++++++++++++++++++++++++++++++++*/
void ProcessTurnRelations2(RelationsX *relationsx,NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx)
{
TurnRelX relationx;
int trfd;
index_t total=0,deleted=0;
if(nodesx->number==0 || segmentsx->number==0)
return;
/* Print the start message */
printf_first("Processing Turn Relations (2): Relations=0");
/* Map into memory / open the files */
#if !SLIM
nodesx->data=MapFileWriteable(nodesx->filename_tmp);
segmentsx->data=MapFile(segmentsx->filename_tmp);
waysx->data=MapFile(waysx->filename_tmp);
#else
nodesx->fd=ReOpenFileWriteable(nodesx->filename_tmp);
segmentsx->fd=ReOpenFile(segmentsx->filename_tmp);
waysx->fd=ReOpenFile(waysx->filename_tmp);
#endif
/* Re-open the file read-only and a new file writeable */
relationsx->trfd=ReOpenFile(relationsx->trfilename_tmp);
DeleteFile(relationsx->trfilename_tmp);
trfd=OpenFileNew(relationsx->trfilename_tmp);
/* Process all of the relations */
while(!ReadFile(relationsx->trfd,&relationx,sizeof(TurnRelX)))
{
NodeX *nodex;
SegmentX *segmentx;
if(relationx.restriction==TurnRestrict_no_right_turn ||
relationx.restriction==TurnRestrict_no_left_turn ||
relationx.restriction==TurnRestrict_no_u_turn ||
relationx.restriction==TurnRestrict_no_straight_on)
{
index_t node_from=NO_NODE,node_to=NO_NODE;
int oneway_from=0,oneway_to=0,vehicles_from=1,vehicles_to=1;
/* Find the segments that join the node 'via' */
segmentx=FirstSegmentX(segmentsx,relationx.via,1);
while(segmentx)
{
if(segmentx->way==relationx.from)
{
WayX *wayx=LookupWayX(waysx,segmentx->way,1);
if(node_from!=NO_NODE) /* Only one segment can be on the 'from' way */
{
logerror("Turn Relation %"Prelation_t" is not stored because the 'via' node is not at the end of the 'from' way.\n",relationx.id);
deleted++;
goto endloop;
}
node_from=OtherNode(segmentx,relationx.via);
if(IsOnewayFrom(segmentx,relationx.via))
oneway_from=1; /* not allowed */
if(!(wayx->way.allow&(Transports_Bicycle|Transports_Moped|Transports_Motorbike|Transports_Motorcar|Transports_Goods|Transports_HGV|Transports_PSV)))
vehicles_from=0; /* not allowed */
}
if(segmentx->way==relationx.to)
{
WayX *wayx=LookupWayX(waysx,segmentx->way,1);
if(node_to!=NO_NODE) /* Only one segment can be on the 'to' way */
{
logerror("Turn Relation %"Prelation_t" is not stored because the 'via' node is not at the end of the 'to' way.\n",relationx.id);
deleted++;
goto endloop;
}
node_to=OtherNode(segmentx,relationx.via);
if(IsOnewayTo(segmentx,relationx.via))
oneway_to=1; /* not allowed */
if(!(wayx->way.allow&(Transports_Bicycle|Transports_Moped|Transports_Motorbike|Transports_Motorcar|Transports_Goods|Transports_HGV|Transports_PSV)))
vehicles_to=0; /* not allowed */
}
segmentx=NextSegmentX(segmentsx,segmentx,relationx.via);
}
if(node_from==NO_NODE)
logerror("Turn Relation %"Prelation_t" is not stored because the 'via' node is not part of the 'from' way.\n",relationx.id);
if(node_to==NO_NODE)
logerror("Turn Relation %"Prelation_t" is not stored because the 'via' node is not part of the 'to' way.\n",relationx.id);
if(oneway_from)
logerror("Turn Relation %"Prelation_t" is not stored because the 'from' way is oneway away from the 'via' node.\n",relationx.id);
if(oneway_to)
logerror("Turn Relation %"Prelation_t" is not needed because the 'to' way is oneway towards the 'via' node.\n",relationx.id);
if(!vehicles_from)
logerror("Turn Relation %"Prelation_t" is not stored because the 'from' way does not allow vehicles.\n",relationx.id);
if(!vehicles_to)
logerror("Turn Relation %"Prelation_t" is not needed because the 'to' way does not allow vehicles.\n",relationx.id);
if(oneway_from || oneway_to || !vehicles_from || !vehicles_to || node_from==NO_NODE || node_to==NO_NODE)
{
deleted++;
goto endloop;
}
/* Write the results */
relationx.from=node_from;
relationx.to =node_to;
WriteFile(trfd,&relationx,sizeof(TurnRelX));
total++;
if(!(total%1000))
printf_middle("Processing Turn Relations (2): Relations=%"Pindex_t" Deleted=%"Pindex_t" Added=%"Pindex_t,total,deleted,total-relationsx->trnumber+deleted);
}
else
{
index_t node_from=NO_NODE,node_to=NO_NODE,node_other[MAX_SEG_PER_NODE];
int nnodes_other=0,i;
int oneway_from=0,vehicles_from=1;
/* Find the segments that join the node 'via' */
segmentx=FirstSegmentX(segmentsx,relationx.via,1);
while(segmentx)
{
if(segmentx->way==relationx.from)
{
WayX *wayx=LookupWayX(waysx,segmentx->way,1);
if(node_from!=NO_NODE) /* Only one segment can be on the 'from' way */
{
logerror("Turn Relation %"Prelation_t" is not stored because the 'via' node is not at the end of the 'from' way.\n",relationx.id);
deleted++;
goto endloop;
}
node_from=OtherNode(segmentx,relationx.via);
if(IsOnewayFrom(segmentx,relationx.via))
oneway_from=1; /* not allowed */
if(!(wayx->way.allow&(Transports_Bicycle|Transports_Moped|Transports_Motorbike|Transports_Motorcar|Transports_Goods|Transports_HGV|Transports_PSV)))
vehicles_from=0; /* not allowed */
}
if(segmentx->way==relationx.to)
{
if(node_to!=NO_NODE) /* Only one segment can be on the 'to' way */
{
logerror("Turn Relation %"Prelation_t" is not stored because the 'via' node is not at the end of the 'to' way.\n",relationx.id);
deleted++;
goto endloop;
}
node_to=OtherNode(segmentx,relationx.via);
}
if(segmentx->way!=relationx.from && segmentx->way!=relationx.to)
{
WayX *wayx=LookupWayX(waysx,segmentx->way,1);
if(IsOnewayTo(segmentx,relationx.via))
; /* not allowed */
else if(!(wayx->way.allow&(Transports_Bicycle|Transports_Moped|Transports_Motorbike|Transports_Motorcar|Transports_Goods|Transports_HGV|Transports_PSV)))
; /* not allowed */
else
{
logassert(nnodes_othertrnumber+deleted);
}
}
/* Force super nodes on via node and adjacent nodes */
nodex=LookupNodeX(nodesx,relationx.via,1);
nodex->flags|=NODE_TURNRSTRCT;
PutBackNodeX(nodesx,nodex);
segmentx=FirstSegmentX(segmentsx,relationx.via,1);
while(segmentx)
{
index_t othernode=OtherNode(segmentx,relationx.via);
nodex=LookupNodeX(nodesx,othernode,1);
nodex->flags|=NODE_TURNRSTRCT2;
PutBackNodeX(nodesx,nodex);
segmentx=NextSegmentX(segmentsx,segmentx,relationx.via);
}
endloop: ;
}
/* Close the files */
relationsx->trfd=CloseFile(relationsx->trfd);
CloseFile(trfd);
/* Unmap from memory / close the files */
#if !SLIM
nodesx->data=UnmapFile(nodesx->data);
segmentsx->data=UnmapFile(segmentsx->data);
waysx->data=UnmapFile(waysx->data);
#else
nodesx->fd=CloseFile(nodesx->fd);
segmentsx->fd=CloseFile(segmentsx->fd);
waysx->fd=CloseFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Processed Turn Relations (2): Relations=%"Pindex_t" Deleted=%"Pindex_t" Added=%"Pindex_t,total,deleted,total-relationsx->trnumber+deleted);
relationsx->trnumber=total;
}
/*++++++++++++++++++++++++++++++++++++++
Remove pruned turn relations and update the node indexes after pruning nodes.
RelationsX *relationsx The set of relations to modify.
NodesX *nodesx The set of nodes to use.
++++++++++++++++++++++++++++++++++++++*/
void RemovePrunedTurnRelations(RelationsX *relationsx,NodesX *nodesx)
{
TurnRelX relationx;
index_t total=0,pruned=0,notpruned=0;
int trfd;
if(relationsx->trnumber==0)
return;
/* Print the start message */
printf_first("Deleting Pruned Turn Relations: Relations=0 Pruned=0");
/* Re-open the file read-only and a new file writeable */
relationsx->trfd=ReOpenFile(relationsx->trfilename_tmp);
DeleteFile(relationsx->trfilename_tmp);
trfd=OpenFileNew(relationsx->trfilename_tmp);
/* Process all of the relations */
while(!ReadFile(relationsx->trfd,&relationx,sizeof(TurnRelX)))
{
relationx.from=nodesx->pdata[relationx.from];
relationx.via =nodesx->pdata[relationx.via];
relationx.to =nodesx->pdata[relationx.to];
if(relationx.from==NO_NODE || relationx.via==NO_NODE || relationx.to==NO_NODE)
pruned++;
else
{
WriteFile(trfd,&relationx,sizeof(TurnRelX));
notpruned++;
}
total++;
if(!(total%1000))
printf_middle("Deleting Pruned Turn Relations: Relations=%"Pindex_t" Pruned=%"Pindex_t,total,pruned);
}
relationsx->trnumber=notpruned;
/* Close the files */
relationsx->trfd=CloseFile(relationsx->trfd);
CloseFile(trfd);
/* Print the final message */
printf_last("Deleted Pruned Turn Relations: Relations=%"Pindex_t" Pruned=%"Pindex_t,total,pruned);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the turn relations geographically after updating the node indexes.
RelationsX *relationsx The set of relations to modify.
NodesX *nodesx The set of nodes to use.
SegmentsX *segmentsx The set of segments to use.
++++++++++++++++++++++++++++++++++++++*/
void SortTurnRelationListGeographically(RelationsX *relationsx,NodesX *nodesx,SegmentsX *segmentsx)
{
int trfd;
if(segmentsx->number==0)
return;
/* Print the start message */
printf_first("Sorting Turn Relations Geographically");
/* Map into memory / open the files */
#if !SLIM
segmentsx->data=MapFile(segmentsx->filename_tmp);
#else
segmentsx->fd=ReOpenFile(segmentsx->filename_tmp);
#endif
/* Re-open the file read-only and a new file writeable */
relationsx->trfd=ReOpenFile(relationsx->trfilename_tmp);
DeleteFile(relationsx->trfilename_tmp);
trfd=OpenFileNew(relationsx->trfilename_tmp);
/* Update the segments with geographically sorted node indexes and sort them */
sortnodesx=nodesx;
sortsegmentsx=segmentsx;
filesort_fixed(relationsx->trfd,trfd,sizeof(TurnRelX),(int (*)(void*,index_t))geographically_index,
(int (*)(const void*,const void*))sort_by_via,
NULL);
/* Close the files */
relationsx->trfd=CloseFile(relationsx->trfd);
CloseFile(trfd);
/* Unmap from memory / close the files */
#if !SLIM
segmentsx->data=UnmapFile(segmentsx->data);
#else
segmentsx->fd=CloseFile(segmentsx->fd);
#endif
/* Print the final message */
printf_last("Sorted Turn Relations Geographically: Turn Relations=%"Pindex_t,relationsx->trnumber);
}
/*++++++++++++++++++++++++++++++++++++++
Update the turn relation indexes.
int geographically_index Return 1 if the value is to be kept, otherwise 0.
TurnRelX *relationx The extended turn relation.
index_t index The number of unsorted turn relations that have been read from the input file.
++++++++++++++++++++++++++++++++++++++*/
static int geographically_index(TurnRelX *relationx,index_t index)
{
SegmentX *segmentx;
index_t from_node,via_node,to_node;
from_node=sortnodesx->gdata[relationx->from];
via_node =sortnodesx->gdata[relationx->via];
to_node =sortnodesx->gdata[relationx->to];
segmentx=FirstSegmentX(sortsegmentsx,via_node,1);
do
{
if(OtherNode(segmentx,via_node)==from_node)
relationx->from=IndexSegmentX(sortsegmentsx,segmentx);
if(OtherNode(segmentx,via_node)==to_node)
relationx->to=IndexSegmentX(sortsegmentsx,segmentx);
segmentx=NextSegmentX(sortsegmentsx,segmentx,via_node);
}
while(segmentx);
relationx->via=via_node;
return(1);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the turn restriction relations into via index order (then by from and to segments).
int sort_by_via Returns the comparison of the via, from and to fields.
TurnRelX *a The first extended relation.
TurnRelX *b The second extended relation.
++++++++++++++++++++++++++++++++++++++*/
static int sort_by_via(TurnRelX *a,TurnRelX *b)
{
index_t a_id=a->via;
index_t b_id=b->via;
if(a_idb_id)
return(1);
else
{
index_t a_id=a->from;
index_t b_id=b->from;
if(a_idb_id)
return(1);
else
{
index_t a_id=a->to;
index_t b_id=b->to;
if(a_idb_id)
return(1);
else
return(FILESORT_PRESERVE_ORDER(a,b));
}
}
}
/*++++++++++++++++++++++++++++++++++++++
Save the relation list to a file.
RelationsX* relationsx The set of relations to save.
const char *filename The name of the file to save.
++++++++++++++++++++++++++++++++++++++*/
void SaveRelationList(RelationsX* relationsx,const char *filename)
{
index_t i;
int fd;
RelationsFile relationsfile={0};
/* Print the start message */
printf_first("Writing Relations: Turn Relations=0");
/* Re-open the file read-only */
relationsx->trfd=ReOpenFile(relationsx->trfilename_tmp);
/* Write out the relations data */
fd=OpenFileNew(filename);
SeekFile(fd,sizeof(RelationsFile));
for(i=0;itrnumber;i++)
{
TurnRelX relationx;
TurnRelation relation={0};
ReadFile(relationsx->trfd,&relationx,sizeof(TurnRelX));
relation.from=relationx.from;
relation.via=relationx.via;
relation.to=relationx.to;
relation.except=relationx.except;
WriteFile(fd,&relation,sizeof(TurnRelation));
if(!((i+1)%1000))
printf_middle("Writing Relations: Turn Relations=%"Pindex_t,i+1);
}
/* Write out the header structure */
relationsfile.trnumber=relationsx->trnumber;
SeekFile(fd,0);
WriteFile(fd,&relationsfile,sizeof(RelationsFile));
CloseFile(fd);
/* Close the file */
relationsx->trfd=CloseFile(relationsx->trfd);
/* Print the final message */
printf_last("Wrote Relations: Turn Relations=%"Pindex_t,relationsx->trnumber);
}
routino-2.4.1/src/profiles.h 644 233 144 5432 12063560526 11161 0 /***************************************
A header file for the profiles.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef PROFILES_H
#define PROFILES_H /*+ To stop multiple inclusions. +*/
#include "types.h"
/* Data structures */
/*+ A data structure to hold a transport type profile. +*/
typedef struct _Profile
{
char *name; /*+ The name of the profile. +*/
Transport transport; /*+ The type of transport. +*/
transports_t allow; /*+ The type of transport expressed as a bitmask. +*/
score_t highway[Highway_Count]; /*+ A floating point preference for travel on the highway. +*/
score_t max_pref; /*+ The maximum preference for any highway type. +*/
speed_t speed[Highway_Count]; /*+ The maximum speed on each type of highway. +*/
speed_t max_speed; /*+ The maximum speed for any highway type. +*/
score_t props_yes[Property_Count]; /*+ A floating point preference for ways with this attribute. +*/
score_t props_no [Property_Count]; /*+ A floating point preference for ways without this attribute. +*/
int oneway; /*+ A flag to indicate if one-way restrictions apply. +*/
int turns; /*+ A flag to indicate if turn restrictions apply. +*/
weight_t weight; /*+ The minimum weight of the route. +*/
height_t height; /*+ The minimum height of vehicles on the route. +*/
width_t width; /*+ The minimum width of vehicles on the route. +*/
length_t length; /*+ The minimum length of vehicles on the route. +*/
}
Profile;
/* Functions in profiles.c */
int ParseXMLProfiles(const char *filename);
Profile *GetProfile(const char *name);
int UpdateProfile(Profile *profile,Ways *ways);
void PrintProfile(const Profile *profile);
void PrintProfilesXML(void);
void PrintProfilesJSON(void);
void PrintProfilesPerl(void);
#endif /* PROFILES_H */
routino-2.4.1/src/tagmodifier.c 644 233 144 57221 12063560526 11646 0 /***************************************
Test application for OSM XML file parser / tagging rule testing.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2010-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include
#include
#include
#include "files.h"
#include "logging.h"
#include "xmlparse.h"
#include "tagging.h"
/* Local variables */
static unsigned long nnodes=0;
static unsigned long nways=0;
static unsigned long nrelations=0;
TagList *current_tags=NULL;
/* Local functions */
static void print_usage(int detail);
/* The XML tag processing function prototypes */
static int xmlDeclaration_function(const char *_tag_,int _type_,const char *version,const char *encoding);
static int osmType_function(const char *_tag_,int _type_,const char *version,const char *generator);
static int relationType_function(const char *_tag_,int _type_,const char *id,const char *timestamp,const char *uid,const char *user,const char *visible,const char *version,const char *action);
static int wayType_function(const char *_tag_,int _type_,const char *id,const char *timestamp,const char *uid,const char *user,const char *visible,const char *version,const char *action);
static int memberType_function(const char *_tag_,int _type_,const char *type,const char *ref,const char *role);
static int ndType_function(const char *_tag_,int _type_,const char *ref);
static int nodeType_function(const char *_tag_,int _type_,const char *id,const char *lat,const char *lon,const char *timestamp,const char *uid,const char *user,const char *visible,const char *version,const char *action);
static int tagType_function(const char *_tag_,int _type_,const char *k,const char *v);
static int boundType_function(const char *_tag_,int _type_,const char *box,const char *origin);
static int boundsType_function(const char *_tag_,int _type_,const char *minlat,const char *minlon,const char *maxlat,const char *maxlon,const char *origin);
/* The XML tag definitions */
/*+ The boundsType type tag. +*/
static xmltag boundsType_tag=
{"bounds",
5, {"minlat","minlon","maxlat","maxlon","origin"},
boundsType_function,
{NULL}};
/*+ The boundType type tag. +*/
static xmltag boundType_tag=
{"bound",
2, {"box","origin"},
boundType_function,
{NULL}};
/*+ The tagType type tag. +*/
static xmltag tagType_tag=
{"tag",
2, {"k","v"},
tagType_function,
{NULL}};
/*+ The nodeType type tag. +*/
static xmltag nodeType_tag=
{"node",
9, {"id","lat","lon","timestamp","uid","user","visible","version","action"},
nodeType_function,
{&tagType_tag,NULL}};
/*+ The ndType type tag. +*/
static xmltag ndType_tag=
{"nd",
1, {"ref"},
ndType_function,
{NULL}};
/*+ The memberType type tag. +*/
static xmltag memberType_tag=
{"member",
3, {"type","ref","role"},
memberType_function,
{NULL}};
/*+ The wayType type tag. +*/
static xmltag wayType_tag=
{"way",
7, {"id","timestamp","uid","user","visible","version","action"},
wayType_function,
{&ndType_tag,&tagType_tag,NULL}};
/*+ The relationType type tag. +*/
static xmltag relationType_tag=
{"relation",
7, {"id","timestamp","uid","user","visible","version","action"},
relationType_function,
{&memberType_tag,&tagType_tag,NULL}};
/*+ The osmType type tag. +*/
static xmltag osmType_tag=
{"osm",
2, {"version","generator"},
osmType_function,
{&boundsType_tag,&boundType_tag,&nodeType_tag,&wayType_tag,&relationType_tag,NULL}};
/*+ The xmlDeclaration type tag. +*/
static xmltag xmlDeclaration_tag=
{"xml",
2, {"version","encoding"},
xmlDeclaration_function,
{NULL}};
/*+ The complete set of tags at the top level. +*/
static xmltag *xml_toplevel_tags[]={&xmlDeclaration_tag,&osmType_tag,NULL};
/* The XML tag processing functions */
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the boundsType XSD type is seen
int boundsType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *minlat The contents of the 'minlat' attribute (or NULL if not defined).
const char *minlon The contents of the 'minlon' attribute (or NULL if not defined).
const char *maxlat The contents of the 'maxlat' attribute (or NULL if not defined).
const char *maxlon The contents of the 'maxlon' attribute (or NULL if not defined).
const char *origin The contents of the 'origin' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int boundsType_function(const char *_tag_,int _type_,const char *minlat,const char *minlon,const char *maxlat,const char *maxlon,const char *origin)
{
printf(" <%s%s",(_type_==XMLPARSE_TAG_END)?"/":"",_tag_);
if(minlat) printf(" minlat=\"%s\"",ParseXML_Encode_Safe_XML(minlat));
if(minlon) printf(" minlon=\"%s\"",ParseXML_Encode_Safe_XML(minlon));
if(maxlat) printf(" maxlat=\"%s\"",ParseXML_Encode_Safe_XML(maxlat));
if(maxlon) printf(" maxlon=\"%s\"",ParseXML_Encode_Safe_XML(maxlon));
if(origin) printf(" origin=\"%s\"",ParseXML_Encode_Safe_XML(origin));
printf("%s>\n",(_type_==(XMLPARSE_TAG_START|XMLPARSE_TAG_END))?" /":"");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the boundType XSD type is seen
int boundType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *box The contents of the 'box' attribute (or NULL if not defined).
const char *origin The contents of the 'origin' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int boundType_function(const char *_tag_,int _type_,const char *box,const char *origin)
{
printf(" <%s%s",(_type_==XMLPARSE_TAG_END)?"/":"",_tag_);
if(box) printf(" box=\"%s\"",ParseXML_Encode_Safe_XML(box));
if(origin) printf(" origin=\"%s\"",ParseXML_Encode_Safe_XML(origin));
printf("%s>\n",(_type_==(XMLPARSE_TAG_START|XMLPARSE_TAG_END))?" /":"");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the tagType XSD type is seen
int tagType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *k The contents of the 'k' attribute (or NULL if not defined).
const char *v The contents of the 'v' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int tagType_function(const char *_tag_,int _type_,const char *k,const char *v)
{
if(_type_&XMLPARSE_TAG_START)
{
XMLPARSE_ASSERT_STRING(_tag_,k);
XMLPARSE_ASSERT_STRING(_tag_,v);
AppendTag(current_tags,k,v);
}
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the nodeType XSD type is seen
int nodeType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *id The contents of the 'id' attribute (or NULL if not defined).
const char *lat The contents of the 'lat' attribute (or NULL if not defined).
const char *lon The contents of the 'lon' attribute (or NULL if not defined).
const char *timestamp The contents of the 'timestamp' attribute (or NULL if not defined).
const char *uid The contents of the 'uid' attribute (or NULL if not defined).
const char *user The contents of the 'user' attribute (or NULL if not defined).
const char *visible The contents of the 'visible' attribute (or NULL if not defined).
const char *version The contents of the 'version' attribute (or NULL if not defined).
const char *action The contents of the 'action' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int nodeType_function(const char *_tag_,int _type_,const char *id,const char *lat,const char *lon,const char *timestamp,const char *uid,const char *user,const char *visible,const char *version,const char *action)
{
static node_t node_id;
if(_type_&XMLPARSE_TAG_START)
{
long long llid;
nnodes++;
if(!(nnodes%10000))
fprintf_middle(stderr,"Reading: Lines=%llu Nodes=%lu Ways=%lu Relations=%lu",ParseXML_LineNumber(),nnodes,nways,nrelations);
current_tags=NewTagList();
/* Handle the node information */
XMLPARSE_ASSERT_INTEGER(_tag_,id); llid=atoll(id); /* need long long conversion */
node_id=(node_t)llid;
logassert((long long)node_id==llid,"Node ID too large (change node_t to 64-bits?)"); /* check node id can be stored in node_t data type. */
}
if(_type_&XMLPARSE_TAG_END)
{
TagList *result=ApplyTaggingRules(&NodeRules,current_tags,node_id);
int i;
for(i=0;intags;i++)
{
printf(" k[i]));
printf(" v=\"%s\"",ParseXML_Encode_Safe_XML(result->v[i]));
printf(" />\n");
}
DeleteTagList(current_tags);
DeleteTagList(result);
}
printf(" <%s%s",(_type_==XMLPARSE_TAG_END)?"/":"",_tag_);
if(id) printf(" id=\"%s\"",ParseXML_Encode_Safe_XML(id));
if(lat) printf(" lat=\"%s\"",ParseXML_Encode_Safe_XML(lat));
if(lon) printf(" lon=\"%s\"",ParseXML_Encode_Safe_XML(lon));
if(timestamp) printf(" timestamp=\"%s\"",ParseXML_Encode_Safe_XML(timestamp));
if(uid) printf(" uid=\"%s\"",ParseXML_Encode_Safe_XML(uid));
if(user) printf(" user=\"%s\"",ParseXML_Encode_Safe_XML(user));
if(visible) printf(" visible=\"%s\"",ParseXML_Encode_Safe_XML(visible));
if(version) printf(" version=\"%s\"",ParseXML_Encode_Safe_XML(version));
if(action) printf(" action=\"%s\"",ParseXML_Encode_Safe_XML(action));
printf("%s>\n",(_type_==(XMLPARSE_TAG_START|XMLPARSE_TAG_END))?" /":"");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the ndType XSD type is seen
int ndType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *ref The contents of the 'ref' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int ndType_function(const char *_tag_,int _type_,const char *ref)
{
printf(" <%s%s",(_type_==XMLPARSE_TAG_END)?"/":"",_tag_);
if(ref) printf(" ref=\"%s\"",ParseXML_Encode_Safe_XML(ref));
printf("%s>\n",(_type_==(XMLPARSE_TAG_START|XMLPARSE_TAG_END))?" /":"");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the memberType XSD type is seen
int memberType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *type The contents of the 'type' attribute (or NULL if not defined).
const char *ref The contents of the 'ref' attribute (or NULL if not defined).
const char *role The contents of the 'role' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int memberType_function(const char *_tag_,int _type_,const char *type,const char *ref,const char *role)
{
printf(" <%s%s",(_type_==XMLPARSE_TAG_END)?"/":"",_tag_);
if(type) printf(" type=\"%s\"",ParseXML_Encode_Safe_XML(type));
if(ref) printf(" ref=\"%s\"",ParseXML_Encode_Safe_XML(ref));
if(role) printf(" role=\"%s\"",ParseXML_Encode_Safe_XML(role));
printf("%s>\n",(_type_==(XMLPARSE_TAG_START|XMLPARSE_TAG_END))?" /":"");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the wayType XSD type is seen
int wayType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *id The contents of the 'id' attribute (or NULL if not defined).
const char *timestamp The contents of the 'timestamp' attribute (or NULL if not defined).
const char *uid The contents of the 'uid' attribute (or NULL if not defined).
const char *user The contents of the 'user' attribute (or NULL if not defined).
const char *visible The contents of the 'visible' attribute (or NULL if not defined).
const char *version The contents of the 'version' attribute (or NULL if not defined).
const char *action The contents of the 'action' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int wayType_function(const char *_tag_,int _type_,const char *id,const char *timestamp,const char *uid,const char *user,const char *visible,const char *version,const char *action)
{
static way_t way_id;
if(_type_&XMLPARSE_TAG_START)
{
long long llid;
nways++;
if(!(nways%1000))
fprintf_middle(stderr,"Reading: Lines=%llu Nodes=%lu Ways=%lu Relations=%lu",ParseXML_LineNumber(),nnodes,nways,nrelations);
current_tags=NewTagList();
/* Handle the way information */
XMLPARSE_ASSERT_INTEGER(_tag_,id); llid=atoll(id); /* need long long conversion */
way_id=(way_t)llid;
logassert((long long)way_id==llid,"Way ID too large (change way_t to 64-bits?)"); /* check way id can be stored in way_t data type. */
}
if(_type_&XMLPARSE_TAG_END)
{
TagList *result=ApplyTaggingRules(&WayRules,current_tags,way_id);
int i;
for(i=0;intags;i++)
{
printf(" k[i]));
printf(" v=\"%s\"",ParseXML_Encode_Safe_XML(result->v[i]));
printf(" />\n");
}
DeleteTagList(current_tags);
DeleteTagList(result);
}
printf(" <%s%s",(_type_==XMLPARSE_TAG_END)?"/":"",_tag_);
if(id) printf(" id=\"%s\"",ParseXML_Encode_Safe_XML(id));
if(timestamp) printf(" timestamp=\"%s\"",ParseXML_Encode_Safe_XML(timestamp));
if(uid) printf(" uid=\"%s\"",ParseXML_Encode_Safe_XML(uid));
if(user) printf(" user=\"%s\"",ParseXML_Encode_Safe_XML(user));
if(visible) printf(" visible=\"%s\"",ParseXML_Encode_Safe_XML(visible));
if(version) printf(" version=\"%s\"",ParseXML_Encode_Safe_XML(version));
if(action) printf(" action=\"%s\"",ParseXML_Encode_Safe_XML(action));
printf("%s>\n",(_type_==(XMLPARSE_TAG_START|XMLPARSE_TAG_END))?" /":"");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the relationType XSD type is seen
int relationType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *id The contents of the 'id' attribute (or NULL if not defined).
const char *timestamp The contents of the 'timestamp' attribute (or NULL if not defined).
const char *uid The contents of the 'uid' attribute (or NULL if not defined).
const char *user The contents of the 'user' attribute (or NULL if not defined).
const char *visible The contents of the 'visible' attribute (or NULL if not defined).
const char *version The contents of the 'version' attribute (or NULL if not defined).
const char *action The contents of the 'action' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int relationType_function(const char *_tag_,int _type_,const char *id,const char *timestamp,const char *uid,const char *user,const char *visible,const char *version,const char *action)
{
static relation_t relation_id;
if(_type_&XMLPARSE_TAG_START)
{
long long llid;
nrelations++;
if(!(nrelations%1000))
fprintf_middle(stderr,"Reading: Lines=%llu Nodes=%lu Ways=%lu Relations=%lu",ParseXML_LineNumber(),nnodes,nways,nrelations);
current_tags=NewTagList();
/* Handle the relation information */
XMLPARSE_ASSERT_INTEGER(_tag_,id); llid=atoll(id); /* need long long conversion */
relation_id=(relation_t)llid;
logassert((long long)relation_id==llid,"Relation ID too large (change relation_t to 64-bits?)"); /* check relation id can be stored in relation_t data type. */
}
if(_type_&XMLPARSE_TAG_END)
{
TagList *result=ApplyTaggingRules(&RelationRules,current_tags,relation_id);
int i;
for(i=0;intags;i++)
{
printf(" k[i]));
printf(" v=\"%s\"",ParseXML_Encode_Safe_XML(result->v[i]));
printf(" />\n");
}
DeleteTagList(current_tags);
DeleteTagList(result);
}
printf(" <%s%s",(_type_==XMLPARSE_TAG_END)?"/":"",_tag_);
if(id) printf(" id=\"%s\"",ParseXML_Encode_Safe_XML(id));
if(timestamp) printf(" timestamp=\"%s\"",ParseXML_Encode_Safe_XML(timestamp));
if(uid) printf(" uid=\"%s\"",ParseXML_Encode_Safe_XML(uid));
if(user) printf(" user=\"%s\"",ParseXML_Encode_Safe_XML(user));
if(visible) printf(" visible=\"%s\"",ParseXML_Encode_Safe_XML(visible));
if(version) printf(" version=\"%s\"",ParseXML_Encode_Safe_XML(version));
if(action) printf(" action=\"%s\"",ParseXML_Encode_Safe_XML(action));
printf("%s>\n",(_type_==(XMLPARSE_TAG_START|XMLPARSE_TAG_END))?" /":"");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the osmType XSD type is seen
int osmType_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *version The contents of the 'version' attribute (or NULL if not defined).
const char *generator The contents of the 'generator' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int osmType_function(const char *_tag_,int _type_,const char *version,const char *generator)
{
printf("<%s%s",(_type_==XMLPARSE_TAG_END)?"/":"",_tag_);
if(version) printf(" version=\"%s\"",ParseXML_Encode_Safe_XML(version));
if(generator) printf(" generator=\"%s\"",ParseXML_Encode_Safe_XML(generator));
printf("%s>\n",(_type_==(XMLPARSE_TAG_START|XMLPARSE_TAG_END))?" /":"");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The function that is called when the XML declaration is seen
int xmlDeclaration_function Returns 0 if no error occured or something else otherwise.
const char *_tag_ Set to the name of the element tag that triggered this function call.
int _type_ Set to XMLPARSE_TAG_START at the start of a tag and/or XMLPARSE_TAG_END at the end of a tag.
const char *version The contents of the 'version' attribute (or NULL if not defined).
const char *encoding The contents of the 'encoding' attribute (or NULL if not defined).
++++++++++++++++++++++++++++++++++++++*/
static int xmlDeclaration_function(const char *_tag_,int _type_,const char *version,const char *encoding)
{
printf("\n");
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
The main program for the tagmodifier.
++++++++++++++++++++++++++++++++++++++*/
int main(int argc,char **argv)
{
char *tagging=NULL,*filename=NULL;
FILE *file;
int arg,retval;
/* Parse the command line arguments */
for(arg=1;arg]\n"
" []\n");
if(detail)
fprintf(stderr,
"\n"
"--help Prints this information.\n"
"\n"
"--loggable Print progress messages suitable for logging to file.\n"
"\n"
"--tagging= The name of the XML file containing the tagging rules\n"
" (defaults to 'tagging.xml' in current directory).\n"
"\n"
" The name of the file to process (by default data is\n"
" read from standard input).\n");
exit(!detail);
}
routino-2.4.1/src/results.h 644 233 144 10116 12063560526 11052 0 /***************************************
A header file for the results.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2011 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef RESULTS_H
#define RESULTS_H /*+ To stop multiple inclusions. +*/
#include
#include "types.h"
/* Constants */
/*+ A result is not currently queued. +*/
#define NOT_QUEUED (uint32_t)(0)
/* Data structures */
typedef struct _Result Result;
/*+ The result for a node. +*/
struct _Result
{
index_t node; /*+ The node for which this result applies. +*/
index_t segment; /*+ The segmemt used to get to the node for which this result applies. +*/
Result *prev; /*+ The previous result following the best path to get to this node via the segment. +*/
Result *next; /*+ The next result following the best path from this node that was reached via the segment. +*/
score_t score; /*+ The best actual weighted distance or duration score from the start to the node. +*/
score_t sortby; /*+ The best possible weighted distance or duration score from the start to the finish. +*/
uint32_t queued; /*+ The position of this result in the queue. +*/
};
/*+ A list of results. +*/
typedef struct _Results
{
uint32_t nbins; /*+ The number of bins. +*/
uint32_t mask; /*+ A bit mask to select the bottom 'nbins' bits. +*/
uint32_t number; /*+ The total number of occupied results. +*/
uint8_t npoint1; /*+ The amount of space allocated for results
(the first dimension of the 'point' array). +*/
uint8_t *count; /*+ An array of nbins counters of results in each array. +*/
Result ***point; /*+ An array of nbins arrays of pointers to actual results. +*/
uint32_t ndata1; /*+ The size of the first dimension of the 'data' array. +*/
uint32_t ndata2; /*+ The size of the second dimension of the 'data' array. +*/
Result **data; /*+ An array of arrays containing the actual results, the first
dimension is reallocated but the second dimension is not.
Most importantly pointers into the real data don't change
as more space is allocated (since realloc is not being used). +*/
index_t start_node; /*+ The start node. +*/
index_t prev_segment; /*+ The previous segment to get to the start node (if any). +*/
index_t finish_node; /*+ The finish node. +*/
index_t last_segment; /*+ The last segment (to arrive at the finish node). +*/
}
Results;
/* Forward definition for opaque type */
typedef struct _Queue Queue;
/* Results functions in results.c */
Results *NewResultsList(int nbins);
void FreeResultsList(Results *results);
Result *InsertResult(Results *results,index_t node,index_t segment);
Result *FindResult1(Results *results,index_t node);
Result *FindResult(Results *results,index_t node,index_t segment);
Result *FirstResult(Results *results);
Result *NextResult(Results *results,Result *result);
/* Queue functions in queue.c */
Queue *NewQueueList(void);
void FreeQueueList(Queue *queue);
void InsertInQueue(Queue *queue,Result *result);
Result *PopFromQueue(Queue *queue);
#endif /* RESULTS_H */
routino-2.4.1/src/prunex.c 644 233 144 116570 12063562207 10716 0 /***************************************
Data pruning functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2011-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include "types.h"
#include "segments.h"
#include "typesx.h"
#include "nodesx.h"
#include "segmentsx.h"
#include "waysx.h"
#include "prunex.h"
#include "files.h"
#include "logging.h"
/* Global variables */
/*+ The command line '--tmpdir' option or its default value. +*/
extern char *option_tmpdirname;
/* Local functions */
static void prune_segment(SegmentsX *segmentsx,SegmentX *segmentx);
static void modify_segment(SegmentsX *segmentsx,SegmentX *segmentx,index_t newnode1,index_t newnode2);
static void unlink_segment_node1_refs(SegmentsX *segmentsx,SegmentX *segmentx);
static void unlink_segment_node2_refs(SegmentsX *segmentsx,SegmentX *segmentx);
static double distance(double lat1,double lon1,double lat2,double lon2);
/*++++++++++++++++++++++++++++++++++++++
Initialise the data structures needed for pruning.
NodesX *nodesx The set of nodes to use.
SegmentsX *segmentsx The set of segments to use.
WaysX *waysx The set of ways to use.
++++++++++++++++++++++++++++++++++++++*/
void StartPruning(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx)
{
SegmentX segmentx;
index_t index=0,lastnode1=NO_NODE;
if(segmentsx->number==0)
return;
/* Print the start message */
printf_first("Adding Extra Segment Indexes: Segments=0");
/* Allocate the array of next segment */
segmentsx->next1=(index_t*)calloc(segmentsx->number,sizeof(index_t));
logassert(segmentsx->next1,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Open the file read-only */
segmentsx->fd=ReOpenFile(segmentsx->filename_tmp);
/* Read the on-disk image */
while(!ReadFile(segmentsx->fd,&segmentx,sizeof(SegmentX)))
{
index_t node1=segmentx.node1;
if(index==0)
;
else if(lastnode1==node1)
segmentsx->next1[index-1]=index;
else
segmentsx->next1[index-1]=NO_SEGMENT;
lastnode1=node1;
index++;
if(!(index%10000))
printf_middle("Added Extra Segment Indexes: Segments=%"Pindex_t,index);
}
segmentsx->next1[index-1]=NO_SEGMENT;
/* Close the file */
segmentsx->fd=CloseFile(segmentsx->fd);
/* Print the final message */
printf_last("Added Extra Segment Indexes: Segments=%"Pindex_t,segmentsx->number);
}
/*++++++++++++++++++++++++++++++++++++++
Delete the data structures needed for pruning.
NodesX *nodesx The set of nodes to use.
SegmentsX *segmentsx The set of segments to use.
WaysX *waysx The set of ways to use.
++++++++++++++++++++++++++++++++++++++*/
void FinishPruning(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx)
{
if(segmentsx->next1)
free(segmentsx->next1);
segmentsx->next1=NULL;
}
/*++++++++++++++++++++++++++++++++++++++
Prune out any groups of nodes and segments whose total length is less than a
specified minimum.
NodesX *nodesx The set of nodes to use.
SegmentsX *segmentsx The set of segments to use.
WaysX *waysx The set of ways to use.
distance_t minimum The minimum distance to keep.
++++++++++++++++++++++++++++++++++++++*/
void PruneIsolatedRegions(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx,distance_t minimum)
{
transport_t transport;
BitMask *connected,*region;
index_t *regionsegments,*othersegments;
int nallocregionsegments,nallocothersegments;
index_t nnewways=0;
int fd;
if(nodesx->number==0 || segmentsx->number==0)
return;
/* Map into memory / open the files */
#if !SLIM
nodesx->data=MapFile(nodesx->filename_tmp);
segmentsx->data=MapFileWriteable(segmentsx->filename_tmp);
waysx->data=MapFile(waysx->filename_tmp);
#else
nodesx->fd=ReOpenFile(nodesx->filename_tmp);
segmentsx->fd=ReOpenFileWriteable(segmentsx->filename_tmp);
waysx->fd=ReOpenFile(waysx->filename_tmp);
#endif
fd=ReOpenFileWriteable(waysx->filename_tmp);
connected=AllocBitMask(segmentsx->number);
region =AllocBitMask(segmentsx->number);
logassert(connected,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */
logassert(region,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */
regionsegments=(index_t*)malloc((nallocregionsegments=1024)*sizeof(index_t));
othersegments =(index_t*)malloc((nallocothersegments =1024)*sizeof(index_t));
logassert(regionsegments,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
logassert(othersegments,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Loop through the transport types */
for(transport=Transport_None+1;transportnumber);
ClearAllBits(region ,segmentsx->number);
for(i=0;inumber;i++)
{
int nregionsegments=0,nothersegments=0;
distance_t total=0;
SegmentX *segmentx;
WayX *wayx,tmpwayx;
if(IsBitSet(connected,i))
goto endloop;
segmentx=LookupSegmentX(segmentsx,i,1);
if(IsPrunedSegmentX(segmentx))
goto endloop;
if(segmentx->waynumber)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SeekReadFile(fd,(wayx=&tmpwayx),sizeof(WayX),segmentx->way*sizeof(WayX));
if(!(wayx->way.allow&transports))
goto endloop;
othersegments[nothersegments++]=i;
SetBit(region,i);
do
{
index_t thissegment,nodes[2];
thissegment=othersegments[--nothersegments];
if(nregionsegments==nallocregionsegments)
regionsegments=(index_t*)realloc(regionsegments,(nallocregionsegments+=1024)*sizeof(index_t));
regionsegments[nregionsegments++]=thissegment;
segmentx=LookupSegmentX(segmentsx,thissegment,1);
nodes[0]=segmentx->node1;
nodes[1]=segmentx->node2;
total+=DISTANCE(segmentx->distance);
for(j=0;j<2;j++)
{
NodeX *nodex=LookupNodeX(nodesx,nodes[j],1);
if(!(nodex->allow&transports))
continue;
segmentx=FirstSegmentX(segmentsx,nodes[j],1);
while(segmentx)
{
index_t segment=IndexSegmentX(segmentsx,segmentx);
if(segment!=thissegment)
{
if(segmentx->waynumber)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SeekReadFile(fd,(wayx=&tmpwayx),sizeof(WayX),segmentx->way*sizeof(WayX));
if(wayx->way.allow&transports)
{
/* Already connected - finish */
if(IsBitSet(connected,segment))
{
total=minimum;
goto foundconnection;
}
/* Not in region - add to list */
if(!IsBitSet(region,segment))
{
if(nothersegments==nallocothersegments)
othersegments=(index_t*)realloc(othersegments,(nallocothersegments+=1024)*sizeof(index_t));
othersegments[nothersegments++]=segment;
SetBit(region,segment);
}
}
}
segmentx=NextSegmentX(segmentsx,segmentx,nodes[j]);
}
}
}
while(nothersegments>0 && totalwaynumber)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SeekReadFile(fd,(wayx=&tmpwayx),sizeof(WayX),segmentx->way*sizeof(WayX));
if(wayx->way.allow==transports)
{
prune_segment(segmentsx,segmentx);
npruned++;
}
else
{
if(segmentx->waynumber) /* create a new way */
{
tmpwayx=*wayx;
tmpwayx.way.allow&=~transports;
segmentx->way=waysx->number+nnewways;
SeekWriteFile(fd,&tmpwayx,sizeof(WayX),segmentx->way*sizeof(WayX));
nnewways++;
PutBackSegmentX(segmentsx,segmentx);
}
else /* modify the existing one */
{
tmpwayx.way.allow&=~transports;
SeekWriteFile(fd,&tmpwayx,sizeof(WayX),segmentx->way*sizeof(WayX));
}
nadjusted++;
}
}
}
else /* connected - mark as part of the main region */
{
for(j=0;jnumber,nadjusted,npruned,nregions);
}
/* Unmap from memory / close the files */
free(region);
free(connected);
free(regionsegments);
free(othersegments);
#if !SLIM
nodesx->data=UnmapFile(nodesx->data);
segmentsx->data=UnmapFile(segmentsx->data);
waysx->data=UnmapFile(waysx->data);
#else
nodesx->fd=CloseFile(nodesx->fd);
segmentsx->fd=CloseFile(segmentsx->fd);
waysx->fd=CloseFile(waysx->fd);
#endif
CloseFile(fd);
waysx->number+=nnewways;
}
/*++++++++++++++++++++++++++++++++++++++
Prune out any segments that are shorter than a specified minimum.
NodesX *nodesx The set of nodes to use.
SegmentsX *segmentsx The set of segments to use.
WaysX *waysx The set of ways to use.
distance_t minimum The maximum length to remove or one less than the minimum length to keep.
++++++++++++++++++++++++++++++++++++++*/
void PruneShortSegments(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx,distance_t minimum)
{
index_t i;
index_t nshort=0,npruned=0;
if(nodesx->number==0 || segmentsx->number==0 || waysx->number==0)
return;
/* Print the start message */
printf_first("Pruning Short Segments: Segments=0 Short=0 Pruned=0");
/* Map into memory / open the files */
#if !SLIM
nodesx->data=MapFileWriteable(nodesx->filename_tmp);
segmentsx->data=MapFileWriteable(segmentsx->filename_tmp);
waysx->data=MapFile(waysx->filename_tmp);
#else
nodesx->fd=ReOpenFileWriteable(nodesx->filename_tmp);
segmentsx->fd=ReOpenFileWriteable(segmentsx->filename_tmp);
waysx->fd=ReOpenFile(waysx->filename_tmp);
#endif
/* Loop through the segments and find the short ones for possible modification */
for(i=0;inumber;i++)
{
SegmentX *segmentx2=LookupSegmentX(segmentsx,i,2);
if(IsPrunedSegmentX(segmentx2))
goto endloop;
/*
:
Initial state: ..N3 -------- N2
: S2
:
Final state: ..N3 N2 --
: S2
= OR =
: :
Initial state: ..N1 -------- N2 ---- N3 -------- N4..
: S1 S2 S3 :
: :
Final state: ..N1 ------------ N3 ------------ N4.. N2 --
: S1 S3 : S2
Not if N1 is the same as N4.
Not if S2 has different one-way properties from S1 and S3.
Must combine N2, S2 and N3 disallowed transports into new N3.
Must not delete N2 or N3 if they are mini-roundabouts.
Must not delete N2 or N3 if they are part of turn relations.
= OR =
: :
Initial state: ..N1 -------- N2 ---- N3..
: S1 S2 :
: :
Final state: ..N1 ------------ N3.. N2 --
: S1 : S2
Not if N1 is the same as N3.
Not if S1 has different one-way properties from S2.
Not if S1 has different highway properties from S2.
Not if N2 disallows transports allowed on S1 and S2.
Not if N2 is a mini-roundabouts.
Not if N2 is involved in a turn restriction.
*/
if(DISTANCE(segmentx2->distance)<=minimum)
{
index_t node1=NO_NODE,node2,node3,node4=NO_NODE;
index_t segment1=NO_SEGMENT,segment2=i,segment3=NO_SEGMENT;
SegmentX *segmentx;
int segcount2=0,segcount3=0;
nshort++;
node2=segmentx2->node1;
node3=segmentx2->node2;
/* Count the segments connected to N2 and N3 */
segmentx=FirstSegmentX(segmentsx,node2,4);
while(segmentx)
{
segcount2++;
if(segment1==NO_SEGMENT)
{
index_t segment=IndexSegmentX(segmentsx,segmentx);
if(segment!=segment2)
{
segment1=segment;
node1=OtherNode(segmentx,node2);
}
}
else if(segcount2>2)
break;
segmentx=NextSegmentX(segmentsx,segmentx,node2);
}
segmentx=FirstSegmentX(segmentsx,node3,4);
while(segmentx)
{
segcount3++;
if(segment3==NO_SEGMENT)
{
index_t segment=IndexSegmentX(segmentsx,segmentx);
if(segment!=segment2)
{
segment3=segment;
node4=OtherNode(segmentx,node3);
}
}
else if(segcount3>2)
break;
segmentx=NextSegmentX(segmentsx,segmentx,node3);
}
/* Check which case we are handling (and canonicalise) */
if(segcount2>2 && segcount3>2) /* none of the cases in diagram - too complicated */
{
goto endloop;
}
else if(segcount2==1 || segcount3==1) /* first case in diagram - prune segment */
{
prune_segment(segmentsx,segmentx2);
}
else if(segcount2==2 && segcount3==2) /* second case in diagram - modify one segment and prune segment */
{
SegmentX *segmentx1,*segmentx3;
WayX *wayx1,*wayx2,*wayx3;
NodeX *nodex2,*nodex3,*newnodex;
index_t newnode;
int join12=1,join23=1;
/* Check if pruning would collapse a loop */
if(node1==node4)
goto endloop;
/* Check if allowed due to one-way properties */
segmentx1=LookupSegmentX(segmentsx,segment1,1);
segmentx3=LookupSegmentX(segmentsx,segment3,3);
if(!IsOneway(segmentx1) && !IsOneway(segmentx2))
;
else if(IsOneway(segmentx1) && IsOneway(segmentx2))
{
if(IsOnewayTo(segmentx1,node2) && !IsOnewayFrom(segmentx2,node2)) /* S1 is one-way but S2 doesn't continue */
join12=0;
if(IsOnewayFrom(segmentx1,node2) && !IsOnewayTo(segmentx2,node2)) /* S1 is one-way but S2 doesn't continue */
join12=0;
}
else
join12=0;
if(!IsOneway(segmentx3) && !IsOneway(segmentx2))
;
else if(IsOneway(segmentx3) && IsOneway(segmentx2))
{
if(IsOnewayTo(segmentx3,node3) && !IsOnewayFrom(segmentx2,node3)) /* S3 is one-way but S2 doesn't continue */
join23=0;
if(IsOnewayFrom(segmentx3,node3) && !IsOnewayTo(segmentx2,node3)) /* S3 is one-way but S2 doesn't continue */
join23=0;
}
else
join23=0;
if(!join12 && !join23)
goto endloop;
/* Check if allowed due to mini-roundabout and turn restriction */
nodex2=LookupNodeX(nodesx,node2,2);
nodex3=LookupNodeX(nodesx,node3,3);
if(nodex2->flags&NODE_MINIRNDBT)
join12=0;
if(nodex3->flags&NODE_MINIRNDBT)
join23=0;
if(nodex2->flags&NODE_TURNRSTRCT2 || nodex2->flags&NODE_TURNRSTRCT)
join12=0;
if(nodex3->flags&NODE_TURNRSTRCT2 || nodex3->flags&NODE_TURNRSTRCT)
join23=0;
if(!join12 && !join23)
goto endloop;
/* New node properties */
if(join12)
{
newnode=node3;
newnodex=nodex3;
}
else /* if(join23) */
{
newnode=node2;
newnodex=nodex2;
}
wayx1=LookupWayX(waysx,segmentx1->way,1);
wayx2=LookupWayX(waysx,segmentx2->way,2);
wayx3=LookupWayX(waysx,segmentx3->way,3);
newnodex->allow=nodex2->allow&nodex3->allow; /* combine the restrictions of the two nodes */
newnodex->allow&=~((~wayx2->way.allow)&wayx3->way.allow); /* disallow anything blocked by segment2 */
newnodex->allow&=~((~wayx2->way.allow)&wayx1->way.allow); /* disallow anything blocked by segment2 */
newnodex->latitude =(nodex2->latitude +nodex3->latitude )/2;
newnodex->longitude=(nodex2->longitude+nodex3->longitude)/2;
PutBackNodeX(nodesx,newnodex);
/* Modify segments */
segmentx1->distance+=DISTANCE(segmentx2->distance)/2;
segmentx3->distance+=DISTANCE(segmentx2->distance)-DISTANCE(segmentx2->distance)/2;
if(segmentx1->node1==node1)
{
if(segmentx1->node2!=newnode)
modify_segment(segmentsx,segmentx1,node1,newnode);
else
PutBackSegmentX(segmentsx,segmentx1);
}
else /* if(segmentx1->node2==node1) */
{
if(segmentx1->node1!=newnode)
modify_segment(segmentsx,segmentx1,newnode,node1);
else
PutBackSegmentX(segmentsx,segmentx1);
}
if(segmentx3->node1==node4)
{
if(segmentx3->node2!=newnode)
modify_segment(segmentsx,segmentx3,node4,newnode);
else
PutBackSegmentX(segmentsx,segmentx3);
}
else /* if(segmentx3->node2==node4) */
{
if(segmentx3->node1!=newnode)
modify_segment(segmentsx,segmentx3,newnode,node4);
else
PutBackSegmentX(segmentsx,segmentx3);
}
ReLookupSegmentX(segmentsx,segmentx2);
prune_segment(segmentsx,segmentx2);
}
else /* third case in diagram - prune one segment */
{
SegmentX *segmentx1;
WayX *wayx1,*wayx2;
NodeX *nodex2;
if(segcount3==2) /* not as in diagram, shuffle things round */
{
index_t temp;
temp=segment1; segment1=segment3; segment3=temp;
temp=node1; node1=node4; node4=temp;
temp=node2; node2=node3; node3=temp;
}
/* Check if pruning would collapse a loop */
if(node1==node3)
goto endloop;
/* Check if allowed due to one-way properties */
segmentx1=LookupSegmentX(segmentsx,segment1,1);
if(!IsOneway(segmentx1) && !IsOneway(segmentx2))
;
else if(IsOneway(segmentx1) && IsOneway(segmentx2))
{
if(IsOnewayTo(segmentx1,node2) && !IsOnewayFrom(segmentx2,node2)) /* S1 is one-way but S2 doesn't continue */
goto endloop;
if(IsOnewayFrom(segmentx1,node2) && !IsOnewayTo(segmentx2,node2)) /* S1 is one-way but S2 doesn't continue */
goto endloop;
}
else
goto endloop;
/* Check if allowed due to highway properties */
wayx1=LookupWayX(waysx,segmentx1->way,1);
wayx2=LookupWayX(waysx,segmentx2->way,2);
if(WaysCompare(&wayx1->way,&wayx2->way))
goto endloop;
/* Check if allowed due to mini-roundabout and turn restriction */
nodex2=LookupNodeX(nodesx,node2,2);
if(nodex2->flags&NODE_MINIRNDBT)
goto endloop;
if(nodex2->flags&NODE_TURNRSTRCT2 || nodex2->flags&NODE_TURNRSTRCT)
goto endloop;
/* Check if allowed due to node restrictions */
if((nodex2->allow&wayx1->way.allow)!=wayx1->way.allow)
goto endloop;
if((nodex2->allow&wayx2->way.allow)!=wayx2->way.allow)
goto endloop;
/* Modify segments */
segmentx1->distance+=DISTANCE(segmentx2->distance);
if(segmentx1->node1==node1)
modify_segment(segmentsx,segmentx1,node1,node3);
else /* if(segmentx1->node2==node1) */
modify_segment(segmentsx,segmentx1,node3,node1);
ReLookupSegmentX(segmentsx,segmentx2);
prune_segment(segmentsx,segmentx2);
}
npruned++;
}
endloop:
if(!((i+1)%10000))
printf_middle("Pruning Short Segments: Segments=%"Pindex_t" Short=%"Pindex_t" Pruned=%"Pindex_t,i+1,nshort,npruned);
}
/* Unmap from memory / close the files */
#if !SLIM
nodesx->data=UnmapFile(nodesx->data);
segmentsx->data=UnmapFile(segmentsx->data);
waysx->data=UnmapFile(waysx->data);
#else
nodesx->fd=CloseFile(nodesx->fd);
segmentsx->fd=CloseFile(segmentsx->fd);
waysx->fd=CloseFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Pruned Short Segments: Segments=%"Pindex_t" Short=%"Pindex_t" Pruned=%"Pindex_t,segmentsx->number,nshort,npruned);
}
/*++++++++++++++++++++++++++++++++++++++
Prune out any nodes from straight highways where the introduced error is smaller than a specified maximum.
NodesX *nodesx The set of nodes to use.
SegmentsX *segmentsx The set of segments to use.
WaysX *waysx The set of ways to use.
distance_t maximum The maximum error to introduce.
++++++++++++++++++++++++++++++++++++++*/
void PruneStraightHighwayNodes(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx,distance_t maximum)
{
index_t i;
index_t npruned=0;
BitMask *checked;
int nalloc;
index_t *nodes,*segments;
double *lats,*lons;
double maximumf;
if(nodesx->number==0 || segmentsx->number==0 || waysx->number==0)
return;
maximumf=distance_to_km(maximum);
/* Print the start message */
printf_first("Pruning Straight Highway Nodes: Nodes=0 Pruned=0");
/* Map into memory / open the files */
#if !SLIM
nodesx->data=MapFile(nodesx->filename_tmp);
segmentsx->data=MapFileWriteable(segmentsx->filename_tmp);
waysx->data=MapFile(waysx->filename_tmp);
#else
nodesx->fd=ReOpenFile(nodesx->filename_tmp);
segmentsx->fd=ReOpenFileWriteable(segmentsx->filename_tmp);
waysx->fd=ReOpenFile(waysx->filename_tmp);
#endif
checked=AllocBitMask(nodesx->number);
logassert(checked,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */
nodes =(index_t*)malloc((nalloc=1024)*sizeof(index_t));
segments=(index_t*)malloc( nalloc *sizeof(index_t));
logassert(nodes,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
logassert(segments,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
lats=(double*)malloc(nalloc*sizeof(double));
lons=(double*)malloc(nalloc*sizeof(double));
logassert(lats,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
logassert(lons,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Loop through the nodes and find stretchs of simple highway for possible modification */
for(i=0;inumber;i++)
{
int lowerbounded=0,upperbounded=0;
index_t lower=nalloc/2,current=nalloc/2,upper=nalloc/2;
if(IsBitSet(checked,i))
goto endloop;
if(segmentsx->firstnode[i]==NO_SEGMENT)
goto endloop;
/* Find all connected nodes */
nodes[current]=i;
do
{
index_t node1=NO_NODE,node2=NO_NODE;
index_t segment1=NO_SEGMENT,segment2=NO_SEGMENT;
index_t way1=NO_WAY,way2=NO_WAY;
int segcount=0;
NodeX *nodex;
/* Get the node data */
nodex=LookupNodeX(nodesx,nodes[current],1);
lats[current]=latlong_to_radians(nodex->latitude);
lons[current]=latlong_to_radians(nodex->longitude);
/* Count the segments at the node if not forced to be an end node */
if(IsBitSet(checked,nodes[current]))
;
else if(nodex->flags&NODE_MINIRNDBT)
;
else if(nodex->flags&NODE_TURNRSTRCT2 || nodex->flags&NODE_TURNRSTRCT)
;
else
{
SegmentX *segmentx;
/* Count the segments connected to the node */
segmentx=FirstSegmentX(segmentsx,nodes[current],1);
while(segmentx)
{
segcount++;
if(node1==NO_NODE)
{
segment1=IndexSegmentX(segmentsx,segmentx);
node1=OtherNode(segmentx,nodes[current]);
way1=segmentx->way;
}
else if(node2==NO_NODE)
{
segment2=IndexSegmentX(segmentsx,segmentx);
node2=OtherNode(segmentx,nodes[current]);
way2=segmentx->way;
}
else
break;
segmentx=NextSegmentX(segmentsx,segmentx,nodes[current]);
}
}
/* Check if allowed due to one-way properties */
if(segcount==2)
{
SegmentX *segmentx1,*segmentx2;
segmentx1=LookupSegmentX(segmentsx,segment1,1);
segmentx2=LookupSegmentX(segmentsx,segment2,2);
if(!IsOneway(segmentx1) && !IsOneway(segmentx2))
;
else if(IsOneway(segmentx1) && IsOneway(segmentx2))
{
if(IsOnewayTo(segmentx1,nodes[current]) && !IsOnewayFrom(segmentx2,nodes[current])) /* S1 is one-way but S2 doesn't continue */
segcount=0;
if(IsOnewayFrom(segmentx1,nodes[current]) && !IsOnewayTo(segmentx2,nodes[current])) /* S1 is one-way but S2 doesn't continue */
segcount=0;
}
else
segcount=0;
}
/* Check if allowed due to highway properties and node restrictions */
if(segcount==2)
{
WayX *wayx1,*wayx2;
wayx1=LookupWayX(waysx,way1,1);
wayx2=LookupWayX(waysx,way2,2);
if(WaysCompare(&wayx1->way,&wayx2->way))
segcount=0;
if(wayx1->way.name!=wayx2->way.name)
segcount=0;
if((nodex->allow&wayx1->way.allow)!=wayx1->way.allow)
segcount=0;
if((nodex->allow&wayx2->way.allow)!=wayx2->way.allow)
segcount=0;
}
/* Update the lists */
if(segcount==2)
{
if(upper==(nalloc-1))
{
nodes =(index_t*)realloc(nodes ,(nalloc+=1024)*sizeof(index_t));
segments=(index_t*)realloc(segments, nalloc *sizeof(index_t));
lats=(double*)realloc(lats,nalloc*sizeof(double));
lons=(double*)realloc(lons,nalloc*sizeof(double));
}
if(lower==0) /* move everything up by one */
{
memmove(nodes+1 ,nodes ,(1+upper-lower)*sizeof(index_t));
memmove(segments+1,segments,(1+upper-lower)*sizeof(index_t));
memmove(lats+1,lats,(1+upper-lower)*sizeof(double));
memmove(lons+1,lons,(1+upper-lower)*sizeof(double));
current++;
lower++;
upper++;
}
if(lower==upper) /* first */
{
lower--;
nodes[lower]=node1;
segments[lower]=segment1;
upper++;
nodes[upper]=node2;
segments[upper-1]=segment2;
current--;
}
else if(current==lower)
{
lower--;
if(nodes[current+1]==node2)
{
nodes[lower]=node1;
segments[lower]=segment1;
}
else /* if(nodes[current+1]==node1) */
{
nodes[lower]=node2;
segments[lower]=segment2;
}
current--;
}
else /* if(current==upper) */
{
upper++;
if(nodes[current-1]==node2)
{
nodes[upper]=node1;
segments[upper-1]=segment1;
}
else /* if(nodes[current-1]==node1) */
{
nodes[upper]=node2;
segments[upper-1]=segment2;
}
current++;
}
if(nodes[upper]==nodes[lower])
{
lowerbounded=1;
upperbounded=1;
}
}
else
{
if(current==upper)
upperbounded=1;
if(current==lower)
{
lowerbounded=1;
current=upper;
}
}
}
while(!(lowerbounded && upperbounded));
/* Mark the nodes */
for(current=lower;current<=upper;current++)
SetBit(checked,nodes[current]);
/* Check for straight highway */
while((upper-lower)>=2)
{
index_t bestc=lower;
for(current=lower+2;current<=upper;current++)
{
double dist1,dist2,dist3,dist3a,dist3b,distp;
index_t c;
dist3=distance(lats[lower],lons[lower],lats[current],lons[current]);
for(c=lower+1;c=0 && dist3b>=0)
distp=sqrt(dist1*dist1-dist3a*dist3a);
else if(dist3a>0)
distp=dist2;
else /* if(dist3b>0) */
distp=dist1;
if(distp>maximumf) /* gone too far */
break;
}
if(c>bestc)
bestc=c;
if(bestc>c)
c=bestc;
if(c==current && current!=upper) /* Can replace at least this far (not finished yet) */
continue;
if((c-lower)<2) /* first three points are not straight */
{
lower=c;
break;
}
else /* delete some segments and shift along */
{
SegmentX *segmentx;
distance_t distance=0;
current=c;
for(c=lower+1;cdistance);
prune_segment(segmentsx,segmentx);
npruned++;
}
segmentx=LookupSegmentX(segmentsx,segments[lower],1);
if(nodes[lower]==nodes[current]) /* loop; all within maximum distance */
{
prune_segment(segmentsx,segmentx);
npruned++;
}
else
{
segmentx->distance+=distance;
if(segmentx->node1==nodes[lower])
modify_segment(segmentsx,segmentx,nodes[lower],nodes[current]);
else /* if(segmentx->node2==nodes[lower]) */
modify_segment(segmentsx,segmentx,nodes[current],nodes[lower]);
}
lower=current;
break;
}
}
}
endloop:
if(!((i+1)%10000))
printf_middle("Pruning Straight Highway Nodes: Nodes=%"Pindex_t" Pruned=%"Pindex_t,i+1,npruned);
}
/* Unmap from memory / close the files */
free(checked);
free(nodes);
free(segments);
free(lats);
free(lons);
#if !SLIM
nodesx->data=UnmapFile(nodesx->data);
segmentsx->data=UnmapFile(segmentsx->data);
waysx->data=UnmapFile(waysx->data);
#else
nodesx->fd=CloseFile(nodesx->fd);
segmentsx->fd=CloseFile(segmentsx->fd);
waysx->fd=CloseFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Pruned Straight Highway Nodes: Nodes=%"Pindex_t" Pruned=%"Pindex_t,nodesx->number,npruned);
}
/*++++++++++++++++++++++++++++++++++++++
Prune a segment; unused nodes and ways will get marked for pruning later.
SegmentsX *segmentsx The set of segments to use.
SegmentX *segmentx The segment to be pruned.
++++++++++++++++++++++++++++++++++++++*/
static void prune_segment(SegmentsX *segmentsx,SegmentX *segmentx)
{
unlink_segment_node1_refs(segmentsx,segmentx);
unlink_segment_node2_refs(segmentsx,segmentx);
segmentx->node1=NO_NODE;
segmentx->node2=NO_NODE;
segmentx->next2=NO_SEGMENT;
PutBackSegmentX(segmentsx,segmentx);
}
/*++++++++++++++++++++++++++++++++++++++
Modify a segment's nodes; unused nodes will get marked for pruning later.
SegmentsX *segmentsx The set of segments to use.
SegmentX *segmentx The segment to be modified.
index_t newnode1 The new value of node1.
index_t newnode2 The new value of node2.
++++++++++++++++++++++++++++++++++++++*/
static void modify_segment(SegmentsX *segmentsx,SegmentX *segmentx,index_t newnode1,index_t newnode2)
{
index_t thissegment=IndexSegmentX(segmentsx,segmentx);
if(newnode1>newnode2) /* rotate the segment around */
{
index_t temp;
if(segmentx->distance&(ONEWAY_2TO1|ONEWAY_1TO2))
segmentx->distance^=ONEWAY_2TO1|ONEWAY_1TO2;
temp=newnode1;
newnode1=newnode2;
newnode2=temp;
}
if(newnode1!=segmentx->node1)
unlink_segment_node1_refs(segmentsx,segmentx);
if(newnode2!=segmentx->node2)
unlink_segment_node2_refs(segmentsx,segmentx);
if(newnode1!=segmentx->node1) /* only modify it if the node has changed */
{
segmentx->node1=newnode1;
segmentsx->next1[thissegment]=segmentsx->firstnode[newnode1];
segmentsx->firstnode[newnode1]=thissegment;
}
if(newnode2!=segmentx->node2) /* only modify it if the node has changed */
{
segmentx->node2=newnode2;
segmentx->next2=segmentsx->firstnode[newnode2];
segmentsx->firstnode[newnode2]=thissegment;
}
PutBackSegmentX(segmentsx,segmentx);
}
/*++++++++++++++++++++++++++++++++++++++
Unlink a node1 from a segment by modifying the linked list type arrangement of node references.
SegmentsX *segmentsx The set of segments to use.
SegmentX *segmentx The segment to be modified.
++++++++++++++++++++++++++++++++++++++*/
static void unlink_segment_node1_refs(SegmentsX *segmentsx,SegmentX *segmentx)
{
index_t segment,thissegment;
thissegment=IndexSegmentX(segmentsx,segmentx);
segment=segmentsx->firstnode[segmentx->node1];
if(segment==thissegment)
segmentsx->firstnode[segmentx->node1]=segmentsx->next1[thissegment];
else
{
do
{
index_t nextsegment;
SegmentX *segx=LookupSegmentX(segmentsx,segment,4);
if(segx->node1==segmentx->node1)
{
nextsegment=segmentsx->next1[segment];
if(nextsegment==thissegment)
segmentsx->next1[segment]=segmentsx->next1[thissegment];
}
else /* if(segx->node2==segmentx->node1) */
{
nextsegment=segx->next2;
if(nextsegment==thissegment)
{
segx->next2=segmentsx->next1[thissegment];
PutBackSegmentX(segmentsx,segx);
}
}
segment=nextsegment;
}
while(segment!=thissegment && segment!=NO_SEGMENT);
}
}
/*++++++++++++++++++++++++++++++++++++++
Unlink a node2 from a segment by modifying the linked list type arrangement of node references.
SegmentsX *segmentsx The set of segments to use.
SegmentX *segmentx The segment to be modified.
++++++++++++++++++++++++++++++++++++++*/
static void unlink_segment_node2_refs(SegmentsX *segmentsx,SegmentX *segmentx)
{
index_t segment,thissegment;
thissegment=IndexSegmentX(segmentsx,segmentx);
segment=segmentsx->firstnode[segmentx->node2];
if(segment==thissegment)
segmentsx->firstnode[segmentx->node2]=segmentx->next2;
else
{
do
{
index_t nextsegment;
SegmentX *segx=LookupSegmentX(segmentsx,segment,4);
if(segx->node1==segmentx->node2)
{
nextsegment=segmentsx->next1[segment];
if(nextsegment==thissegment)
segmentsx->next1[segment]=segmentx->next2;
}
else /* if(segx->node2==segmentx->node2) */
{
nextsegment=segx->next2;
if(nextsegment==thissegment)
{
segx->next2=segmentx->next2;
PutBackSegmentX(segmentsx,segx);
}
}
segment=nextsegment;
}
while(segment!=thissegment && segment!=NO_SEGMENT);
}
}
/*++++++++++++++++++++++++++++++++++++++
Calculate the distance between two locations.
double distance Returns the distance between the locations.
double lat1 The latitude of the first location.
double lon1 The longitude of the first location.
double lat2 The latitude of the second location.
double lon2 The longitude of the second location.
++++++++++++++++++++++++++++++++++++++*/
static double distance(double lat1,double lon1,double lat2,double lon2)
{
double dlon = lon1 - lon2;
double dlat = lat1 - lat2;
double a1,a2,a,sa,c,d;
if(dlon==0 && dlat==0)
return 0;
a1 = sin (dlat / 2);
a2 = sin (dlon / 2);
a = (a1 * a1) + cos (lat1) * cos (lat2) * a2 * a2;
sa = sqrt (a);
if (sa <= 1.0)
{c = 2 * asin (sa);}
else
{c = 2 * asin (1.0);}
d = 6378.137 * c;
return(d);
}
routino-2.4.1/src/types.c 644 233 144 32155 12063560526 10517 0 /***************************************
Functions for handling the data types.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include "types.h"
/*++++++++++++++++++++++++++++++++++++++
Decide on the type of a way given the "highway" parameter.
Highway HighwayType Returns the highway type of the way.
const char *highway The string containing the type of the way.
++++++++++++++++++++++++++++++++++++++*/
Highway HighwayType(const char *highway)
{
switch(*highway)
{
case 'c':
if(!strcmp(highway,"cycleway")) return(Highway_Cycleway);
break;
case 'f':
if(!strcmp(highway,"ferry")) return(Highway_Ferry);
break;
case 'm':
if(!strcmp(highway,"motorway")) return(Highway_Motorway);
break;
case 'p':
if(!strcmp(highway,"primary")) return(Highway_Primary);
if(!strcmp(highway,"path")) return(Highway_Path);
break;
case 'r':
if(!strcmp(highway,"residential")) return(Highway_Residential);
break;
case 's':
if(!strcmp(highway,"secondary")) return(Highway_Secondary);
if(!strcmp(highway,"service")) return(Highway_Service);
if(!strcmp(highway,"steps")) return(Highway_Steps);
break;
case 't':
if(!strcmp(highway,"trunk")) return(Highway_Trunk);
if(!strcmp(highway,"tertiary")) return(Highway_Tertiary);
if(!strcmp(highway,"track")) return(Highway_Track);
break;
case 'u':
if(!strcmp(highway,"unclassified")) return(Highway_Unclassified);
break;
default:
;
}
return(Highway_None);
}
/*++++++++++++++++++++++++++++++++++++++
Decide on the type of transport given the name of it.
Transport TransportType Returns the type of the transport.
const char *transport The string containing the method of transport.
++++++++++++++++++++++++++++++++++++++*/
Transport TransportType(const char *transport)
{
switch(*transport)
{
case 'b':
if(!strcmp(transport,"bicycle"))
return(Transport_Bicycle);
break;
case 'f':
if(!strcmp(transport,"foot"))
return(Transport_Foot);
break;
case 'g':
if(!strcmp(transport,"goods"))
return(Transport_Goods);
break;
case 'h':
if(!strcmp(transport,"horse"))
return(Transport_Horse);
if(!strcmp(transport,"hgv"))
return(Transport_HGV);
break;
case 'm':
if(!strcmp(transport,"moped"))
return(Transport_Moped);
if(!strcmp(transport,"motorbike"))
return(Transport_Motorbike);
if(!strcmp(transport,"motorcar"))
return(Transport_Motorcar);
break;
case 'p':
if(!strcmp(transport,"psv"))
return(Transport_PSV);
break;
case 'w':
if(!strcmp(transport,"wheelchair"))
return(Transport_Wheelchair);
break;
default:
return(Transport_None);
}
return(Transport_None);
}
/*++++++++++++++++++++++++++++++++++++++
Decide on the type of property given the name of it.
Property PropertyType Returns the type of the property.
const char *property The string containing the method of property.
++++++++++++++++++++++++++++++++++++++*/
Property PropertyType(const char *property)
{
switch(*property)
{
case 'b':
if(!strcmp(property,"bicycleroute"))
return(Property_BicycleRoute);
if(!strcmp(property,"bridge"))
return(Property_Bridge);
break;
case 'f':
if(!strcmp(property,"footroute"))
return(Property_FootRoute);
break;
case 'm':
if(!strcmp(property,"multilane"))
return(Property_Multilane);
break;
case 'p':
if(!strcmp(property,"paved"))
return(Property_Paved);
break;
case 't':
if(!strcmp(property,"tunnel"))
return(Property_Tunnel);
break;
default:
return(Property_None);
}
return(Property_None);
}
/*++++++++++++++++++++++++++++++++++++++
A string containing the name of a type of highway.
const char *HighwayName Returns the name.
Highway highway The highway type.
++++++++++++++++++++++++++++++++++++++*/
const char *HighwayName(Highway highway)
{
switch(highway)
{
case Highway_None:
return("NONE");
case Highway_Motorway:
return("motorway");
case Highway_Trunk:
return("trunk");
case Highway_Primary:
return("primary");
case Highway_Secondary:
return("secondary");
case Highway_Tertiary:
return("tertiary");
case Highway_Unclassified:
return("unclassified");
case Highway_Residential:
return("residential");
case Highway_Service:
return("service");
case Highway_Track:
return("track");
case Highway_Cycleway:
return("cycleway");
case Highway_Path:
return("path");
case Highway_Steps:
return("steps");
case Highway_Ferry:
return("ferry");
case Highway_Count:
;
case Highway_OneWay:
;
case Highway_Roundabout:
;
}
return(NULL);
}
/*++++++++++++++++++++++++++++++++++++++
A string containing the name of a type of transport.
const char *TransportName Returns the name.
Transport transport The transport type.
++++++++++++++++++++++++++++++++++++++*/
const char *TransportName(Transport transport)
{
switch(transport)
{
case Transport_None:
return("NONE");
case Transport_Foot:
return("foot");
case Transport_Horse:
return("horse");
case Transport_Wheelchair:
return("wheelchair");
case Transport_Bicycle:
return("bicycle");
case Transport_Moped:
return("moped");
case Transport_Motorbike:
return("motorbike");
case Transport_Motorcar:
return("motorcar");
case Transport_Goods:
return("goods");
case Transport_HGV:
return("hgv");
case Transport_PSV:
return("psv");
case Transport_Count:
;
}
return(NULL);
}
/*++++++++++++++++++++++++++++++++++++++
A string containing the name of a highway property.
const char *PropertyName Returns the name.
Property property The property type.
++++++++++++++++++++++++++++++++++++++*/
const char *PropertyName(Property property)
{
switch(property)
{
case Property_None:
return("NONE");
case Property_Paved:
return("paved");
case Property_Multilane:
return("multilane");
case Property_Bridge:
return("bridge");
case Property_Tunnel:
return("tunnel");
case Property_FootRoute:
return("footroute");
case Property_BicycleRoute:
return("bicycleroute");
case Property_Count:
;
}
return(NULL);
}
/*++++++++++++++++++++++++++++++++++++++
A string containing the names of highways.
const char *HighwaysNameList Returns the list of names.
highways_t highways The highways type.
++++++++++++++++++++++++++++++++++++++*/
const char *HighwaysNameList(highways_t highways)
{
static char string[256];
string[0]=0;
if(highways & Highways_Motorway)
strcat(string,"motorway");
if(highways & Highways_Trunk)
{
if(*string) strcat(string,", ");
strcat(string,"trunk");
}
if(highways & Highways_Primary)
{
if(*string) strcat(string,", ");
strcat(string,"primary");
}
if(highways & Highways_Tertiary)
{
if(*string) strcat(string,", ");
strcat(string,"tertiary");
}
if(highways & Highways_Unclassified)
{
if(*string) strcat(string,", ");
strcat(string,"unclassified");
}
if(highways & Highways_Residential)
{
if(*string) strcat(string,", ");
strcat(string,"residential");
}
if(highways & Highways_Service)
{
if(*string) strcat(string,", ");
strcat(string,"service");
}
if(highways & Highways_Track)
{
if(*string) strcat(string,", ");
strcat(string,"track");
}
if(highways & Highways_Cycleway)
{
if(*string) strcat(string,", ");
strcat(string,"cycleway");
}
if(highways & Highways_Path)
{
if(*string) strcat(string,", ");
strcat(string,"path");
}
if(highways & Highways_Steps)
{
if(*string) strcat(string,", ");
strcat(string,"steps");
}
if(highways & Highways_Ferry)
{
if(*string) strcat(string,", ");
strcat(string,"ferry");
}
return(string);
}
/*++++++++++++++++++++++++++++++++++++++
A string containing the names of allowed transports on a way.
const char *AllowedNameList Returns the list of names.
transports_t allowed The allowed type.
++++++++++++++++++++++++++++++++++++++*/
const char *AllowedNameList(transports_t allowed)
{
static char string[256];
string[0]=0;
if(allowed & Transports_Foot)
strcat(string,"foot");
if(allowed & Transports_Horse)
{
if(*string) strcat(string,", ");
strcat(string,"horse");
}
if(allowed & Transports_Wheelchair)
{
if(*string) strcat(string,", ");
strcat(string,"wheelchair");
}
if(allowed & Transports_Bicycle)
{
if(*string) strcat(string,", ");
strcat(string,"bicycle");
}
if(allowed & Transports_Moped)
{
if(*string) strcat(string,", ");
strcat(string,"moped");
}
if(allowed & Transports_Motorbike)
{
if(*string) strcat(string,", ");
strcat(string,"motorbike");
}
if(allowed & Transports_Motorcar)
{
if(*string) strcat(string,", ");
strcat(string,"motorcar");
}
if(allowed & Transports_Goods)
{
if(*string) strcat(string,", ");
strcat(string,"goods");
}
if(allowed & Transports_HGV)
{
if(*string) strcat(string,", ");
strcat(string,"hgv");
}
if(allowed & Transports_PSV)
{
if(*string) strcat(string,", ");
strcat(string,"psv");
}
return(string);
}
/*++++++++++++++++++++++++++++++++++++++
A string containing the names of the properties of a way.
const char *PropertiesNameList Returns the list of names.
properties_t properties The properties of the way.
++++++++++++++++++++++++++++++++++++++*/
const char *PropertiesNameList(properties_t properties)
{
static char string[256];
string[0]=0;
if(properties & Properties_Paved)
{
if(*string) strcat(string,", ");
strcat(string,"paved");
}
if(properties & Properties_Multilane)
{
if(*string) strcat(string,", ");
strcat(string,"multilane");
}
if(properties & Properties_Bridge)
{
if(*string) strcat(string,", ");
strcat(string,"bridge");
}
if(properties & Properties_Tunnel)
{
if(*string) strcat(string,", ");
strcat(string,"tunnel");
}
if(properties & Properties_FootRoute)
{
if(*string) strcat(string,", ");
strcat(string,"footroute");
}
if(properties & Properties_BicycleRoute)
{
if(*string) strcat(string,", ");
strcat(string,"bicycleroute");
}
return(string);
}
/*++++++++++++++++++++++++++++++++++++++
Returns a list of all the highway types.
const char *HighwayList Return a list of all the highway types.
++++++++++++++++++++++++++++++++++++++*/
const char *HighwayList(void)
{
return " motorway = Motorway\n"
" trunk = Trunk\n"
" primary = Primary\n"
" secondary = Secondary\n"
" tertiary = Tertiary\n"
" unclassified = Unclassified\n"
" residential = Residential\n"
" service = Service\n"
" track = Track\n"
" cycleway = Cycleway\n"
" path = Path\n"
" steps = Steps\n"
" ferry = Ferry\n"
;
}
/*++++++++++++++++++++++++++++++++++++++
Returns a list of all the transport types.
const char *TransportList Return a list of all the transport types.
++++++++++++++++++++++++++++++++++++++*/
const char *TransportList(void)
{
return " foot = Foot\n"
" bicycle = Bicycle\n"
" wheelchair = Wheelchair\n"
" horse = Horse\n"
" moped = Moped (Small motorbike, limited speed)\n"
" motorbike = Motorbike\n"
" motorcar = Motorcar\n"
" goods = Goods (Small lorry, van)\n"
" hgv = HGV (Heavy Goods Vehicle - large lorry)\n"
" psv = PSV (Public Service Vehicle - bus, coach)\n"
;
}
/*++++++++++++++++++++++++++++++++++++++
Returns a list of all the property types.
const char *PropertyList Return a list of all the highway proprties.
++++++++++++++++++++++++++++++++++++++*/
const char *PropertyList(void)
{
return " paved = Paved (suitable for normal wheels)\n"
" multilane = Multiple lanes\n"
" bridge = Bridge\n"
" tunnel = Tunnel\n"
" footroute = A route marked for foot travel\n"
" bicycleroute = A route marked for bicycle travel\n"
;
}
routino-2.4.1/src/typesx.h 644 233 144 6646 12063560526 10702 0 /***************************************
Type definitions for eXtended types.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef TYPESX_H
#define TYPESX_H /*+ To stop multiple inclusions. +*/
#include
#include
#include
#include
/* Constants and macros for handling them */
/*+ An undefined node ID. +*/
#define NO_NODE_ID ((node_t)~0)
/*+ An undefined way ID. +*/
#define NO_WAY_ID ((way_t)~0)
/*+ An undefined relation ID. +*/
#define NO_RELATION_ID ((relation_t)~0)
/*+ The maximum number of segments per node (used to size temporary storage). +*/
#define MAX_SEG_PER_NODE 32
/* Bit mask macro types and functions */
#define BitMask uint32_t
#define AllocBitMask(xx) (BitMask*)calloc((1+(xx)/32),sizeof(BitMask))
#define ClearAllBits(xx,yy) memset((xx), 0,(1+(yy)/32)*sizeof(BitMask))
#define SetAllBits(xx,yy) memset((xx),~0,(1+(yy)/32)*sizeof(BitMask))
#define ClearBit(xx,yy) (xx)[(yy)/32]&=~(((BitMask)1)<<((yy)%32))
#define SetBit(xx,yy) (xx)[(yy)/32]|= (((BitMask)1)<<((yy)%32))
#define IsBitSet(xx,yy) ((xx)[(yy)/32]& (((BitMask)1)<<((yy)%32)))
/* Simple Types */
/*+ A node identifier - must be at least as large as index_t. +*/
typedef uint32_t node_t;
/*+ A way identifier - must be at least as large as index_t. +*/
typedef uint32_t way_t;
/*+ A relation identifier - must be at least as large as index_t. +*/
typedef uint32_t relation_t;
/*+ A printf formatting string for a node_t type (this should match the node_t definition above). +*/
#define Pnode_t PRIu32 /* PRIu32 and PRIu64 are defined in intypes.h */
/*+ A printf formatting string for a way_t type (this should match the way_t definition above). +*/
#define Pway_t PRIu32 /* PRIu32 and PRIu64 are defined in intypes.h */
/*+ A printf formatting string for a relation_t type (this should match the relation_t definition above). +*/
#define Prelation_t PRIu32 /* PRIu32 and PRIu64 are defined in intypes.h */
/* Enumerated types */
/*+ Turn restrictions. +*/
typedef enum _TurnRestriction
{
TurnRestrict_None =0,
TurnRestrict_no_right_turn,
TurnRestrict_no_left_turn,
TurnRestrict_no_u_turn,
TurnRestrict_no_straight_on,
TurnRestrict_only_right_turn,
TurnRestrict_only_left_turn,
TurnRestrict_only_straight_on
}
TurnRestriction;
/* Data structures */
typedef struct _NodeX NodeX;
typedef struct _NodesX NodesX;
typedef struct _SegmentX SegmentX;
typedef struct _SegmentsX SegmentsX;
typedef struct _WayX WayX;
typedef struct _WaysX WaysX;
typedef struct _RouteRelX RouteRelX;
typedef struct _TurnRelX TurnRelX;
typedef struct _RelationsX RelationsX;
#endif /* TYPESX_H */
routino-2.4.1/src/segments.h 644 233 144 16341 12063560526 11204 0 /***************************************
$Header: /home/amb/CVS/routino/src/segments.h,v 1.38 2010-12-21 17:18:41 amb Exp $
A header file for the segments.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef SEGMENTS_H
#define SEGMENTS_H /*+ To stop multiple inclusions. +*/
#include
#include "types.h"
#include "files.h"
#include "profiles.h"
/* Data structures */
/*+ A structure containing a single segment. +*/
struct _Segment
{
index_t node1; /*+ The index of the starting node. +*/
index_t node2; /*+ The index of the finishing node. +*/
index_t next2; /*+ The index of the next segment sharing node2. +*/
index_t way; /*+ The index of the way associated with the segment. +*/
distance_t distance; /*+ The distance between the nodes. +*/
};
/*+ A structure containing the header from the file. +*/
typedef struct _SegmentsFile
{
index_t number; /*+ The number of segments in total. +*/
index_t snumber; /*+ The number of super-segments. +*/
index_t nnumber; /*+ The number of normal segments. +*/
}
SegmentsFile;
/*+ A structure containing a set of segments (and pointers to mmap file). +*/
struct _Segments
{
SegmentsFile file; /*+ The header data from the file. +*/
#if !SLIM
void *data; /*+ The memory mapped data. +*/
Segment *segments; /*+ An array of segments. +*/
#else
int fd; /*+ The file descriptor for the file. +*/
Segment cached[3]; /*+ Three cached segments read from the file in slim mode. +*/
index_t incache[3]; /*+ The indexes of the cached segments. +*/
#endif
};
/* Functions in segments.c */
Segments *LoadSegmentList(const char *filename);
index_t FindClosestSegmentHeading(Nodes *nodes,Segments *segments,Ways *ways,index_t node1,double heading,Profile *profile);
distance_t Distance(double lat1,double lon1,double lat2,double lon2);
duration_t Duration(Segment *segmentp,Way *wayp,Profile *profile);
double TurnAngle(Nodes *nodes,Segment *segment1p,Segment *segment2p,index_t node);
double BearingAngle(Nodes *nodes,Segment *segmentp,index_t node);
static inline Segment *NextSegment(Segments *segments,Segment *segmentp,index_t node);
/* Macros and inline functions */
/*+ Return true if this is a normal segment. +*/
#define IsNormalSegment(xxx) (((xxx)->distance)&SEGMENT_NORMAL)
/*+ Return true if this is a super-segment. +*/
#define IsSuperSegment(xxx) (((xxx)->distance)&SEGMENT_SUPER)
/*+ Return true if the segment is oneway. +*/
#define IsOneway(xxx) ((xxx)->distance&(ONEWAY_2TO1|ONEWAY_1TO2))
/*+ Return true if the segment is oneway towards the specified node. +*/
#define IsOnewayTo(xxx,yyy) ((xxx)->node1==(yyy)?((xxx)->distance&ONEWAY_2TO1):((xxx)->distance&ONEWAY_1TO2))
/*+ Return true if the segment is oneway from the specified node. +*/
#define IsOnewayFrom(xxx,yyy) ((xxx)->node2==(yyy)?((xxx)->distance&ONEWAY_2TO1):((xxx)->distance&ONEWAY_1TO2))
/*+ Return the other node in the segment that is not the specified node. +*/
#define OtherNode(xxx,yyy) ((xxx)->node1==(yyy)?(xxx)->node2:(xxx)->node1)
#if !SLIM
/*+ Return a segment pointer given a set of segments and an index. +*/
#define LookupSegment(xxx,yyy,ppp) (&(xxx)->segments[yyy])
/*+ Return a segment index given a set of segments and a pointer. +*/
#define IndexSegment(xxx,yyy) (index_t)((yyy)-&(xxx)->segments[0])
/*++++++++++++++++++++++++++++++++++++++
Find the next segment with a particular starting node.
Segment *NextSegment Returns a pointer to the next segment.
Segments *segments The set of segments to use.
Segment *segmentp The current segment.
index_t node The wanted node.
++++++++++++++++++++++++++++++++++++++*/
static inline Segment *NextSegment(Segments *segments,Segment *segmentp,index_t node)
{
if(segmentp->node1==node)
{
segmentp++;
if(IndexSegment(segments,segmentp)>=segments->file.number || segmentp->node1!=node)
return(NULL);
else
return(segmentp);
}
else
{
if(segmentp->next2==NO_SEGMENT)
return(NULL);
else
return(LookupSegment(segments,segmentp->next2,1));
}
}
#else
static Segment *LookupSegment(Segments *segments,index_t index,int position);
static index_t IndexSegment(Segments *segments,Segment *segmentp);
/*++++++++++++++++++++++++++++++++++++++
Find the Segment information for a particular segment.
Segment *LookupSegment Returns a pointer to the cached segment information.
Segments *segments The set of segments to use.
index_t index The index of the segment.
int position The position in the cache to store the value.
++++++++++++++++++++++++++++++++++++++*/
static inline Segment *LookupSegment(Segments *segments,index_t index,int position)
{
if(segments->incache[position-1]!=index)
{
SeekReadFile(segments->fd,&segments->cached[position-1],sizeof(Segment),sizeof(SegmentsFile)+(off_t)index*sizeof(Segment));
segments->incache[position-1]=index;
}
return(&segments->cached[position-1]);
}
/*++++++++++++++++++++++++++++++++++++++
Find the segment index for a particular segment pointer.
index_t IndexSegment Returns the index of the segment in the list.
Segments *segments The set of segments to use.
Segment *segmentp The segment whose index is to be found.
++++++++++++++++++++++++++++++++++++++*/
static inline index_t IndexSegment(Segments *segments,Segment *segmentp)
{
int position1=segmentp-&segments->cached[0];
return(segments->incache[position1]);
}
/*++++++++++++++++++++++++++++++++++++++
Find the next segment with a particular starting node.
Segment *NextSegment Returns a pointer to the next segment.
Segments *segments The set of segments to use.
Segment *segmentp The current segment.
index_t node The wanted node.
++++++++++++++++++++++++++++++++++++++*/
static inline Segment *NextSegment(Segments *segments,Segment *segmentp,index_t node)
{
int position=segmentp-&segments->cached[-1];
if(segmentp->node1==node)
{
index_t index=IndexSegment(segments,segmentp);
index++;
if(index>=segments->file.number)
return(NULL);
segmentp=LookupSegment(segments,index,position);
if(segmentp->node1!=node)
return(NULL);
else
return(segmentp);
}
else
{
if(segmentp->next2==NO_SEGMENT)
return(NULL);
else
return(LookupSegment(segments,segmentp->next2,position));
}
}
#endif
#endif /* SEGMENTS_H */
routino-2.4.1/src/filedumper.c 644 233 144 100530 12063560526 11520 0 /***************************************
Memory file dumper.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include
#include
#include
#include
#include
#include "types.h"
#include "nodes.h"
#include "segments.h"
#include "ways.h"
#include "relations.h"
#include "files.h"
#include "visualiser.h"
#include "xmlparse.h"
/* Local functions */
static void print_node(Nodes *nodes,index_t item);
static void print_segment(Segments *segments,index_t item);
static void print_way(Ways *ways,index_t item);
static void print_turn_relation(Relations *relations,index_t item,Segments *segments,Nodes *nodes);
static void print_head_osm(int coordcount,double latmin,double latmax,double lonmin,double lonmax);
static void print_region_osm(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,
double latmin,double latmax,double lonmin,double lonmax,int option_no_super);
static void print_node_osm(Nodes *nodes,index_t item);
static void print_segment_osm(Segments *segments,index_t item,Ways *ways);
static void print_turn_relation_osm(Relations *relations,index_t item,Segments *segments,Nodes *nodes);
static void print_tail_osm(void);
static char *RFC822Date(time_t t);
static void print_usage(int detail,const char *argerr,const char *err);
/*++++++++++++++++++++++++++++++++++++++
The main program for the file dumper.
++++++++++++++++++++++++++++++++++++++*/
int main(int argc,char** argv)
{
Nodes *OSMNodes;
Segments *OSMSegments;
Ways *OSMWays;
Relations*OSMRelations;
int arg;
char *dirname=NULL,*prefix=NULL;
char *nodes_filename,*segments_filename,*ways_filename,*relations_filename;
int option_statistics=0;
int option_visualiser=0,coordcount=0;
double latmin=0,latmax=0,lonmin=0,lonmax=0;
char *option_data=NULL;
int option_dump=0;
int option_dump_osm=0,option_no_super=0;
/* Parse the command line arguments */
for(arg=1;argfile.number);
printf("Number(super)=%9"Pindex_t"\n",OSMNodes->file.snumber);
printf("\n");
printf("Lat bins= %4d\n",(int)OSMNodes->file.latbins);
printf("Lon bins= %4d\n",(int)OSMNodes->file.lonbins);
printf("\n");
printf("Lat zero=%5d (%8.4f deg)\n",(int)OSMNodes->file.latzero,radians_to_degrees(latlong_to_radians(bin_to_latlong(OSMNodes->file.latzero))));
printf("Lon zero=%5d (%8.4f deg)\n",(int)OSMNodes->file.lonzero,radians_to_degrees(latlong_to_radians(bin_to_latlong(OSMNodes->file.lonzero))));
/* Examine the segments */
printf("\n");
printf("Segments\n");
printf("--------\n");
printf("\n");
printf("sizeof(Segment)=%9lu Bytes\n",(unsigned long)sizeof(Segment));
printf("Number(total) =%9"Pindex_t"\n",OSMSegments->file.number);
printf("Number(super) =%9"Pindex_t"\n",OSMSegments->file.snumber);
printf("Number(normal) =%9"Pindex_t"\n",OSMSegments->file.nnumber);
/* Examine the ways */
printf("\n");
printf("Ways\n");
printf("----\n");
printf("\n");
printf("sizeof(Way)=%9lu Bytes\n",(unsigned long)sizeof(Way));
printf("Number =%9"Pindex_t"\n",OSMWays->file.number);
printf("\n");
stat(ways_filename,&buf);
printf("Total names=%9lu Bytes\n",(unsigned long)buf.st_size-(unsigned long)sizeof(Ways)-(unsigned long)OSMWays->file.number*(unsigned long)sizeof(Way));
printf("\n");
printf("Included highways : %s\n",HighwaysNameList(OSMWays->file.highways));
printf("Included transports: %s\n",AllowedNameList(OSMWays->file.allow));
printf("Included properties: %s\n",PropertiesNameList(OSMWays->file.props));
/* Examine the relations */
printf("\n");
printf("Relations\n");
printf("---------\n");
printf("\n");
printf("sizeof(TurnRelation)=%9lu Bytes\n",(unsigned long)sizeof(TurnRelation));
printf("Number =%9"Pindex_t"\n",OSMRelations->file.trnumber);
}
/* Print out internal data (in plain text format) */
if(option_dump)
{
index_t item;
for(arg=1;argfile.number;item++)
print_node(OSMNodes,item);
}
else if(!strncmp(argv[arg],"--node=",7))
{
item=atoi(&argv[arg][7]);
if(item>=0 && itemfile.number)
print_node(OSMNodes,item);
else
printf("Invalid node number; minimum=0, maximum=%"Pindex_t".\n",OSMNodes->file.number-1);
}
else if(!strcmp(argv[arg],"--segment=all"))
{
for(item=0;itemfile.number;item++)
print_segment(OSMSegments,item);
}
else if(!strncmp(argv[arg],"--segment=",10))
{
item=atoi(&argv[arg][10]);
if(item>=0 && itemfile.number)
print_segment(OSMSegments,item);
else
printf("Invalid segment number; minimum=0, maximum=%"Pindex_t".\n",OSMSegments->file.number-1);
}
else if(!strcmp(argv[arg],"--way=all"))
{
for(item=0;itemfile.number;item++)
print_way(OSMWays,item);
}
else if(!strncmp(argv[arg],"--way=",6))
{
item=atoi(&argv[arg][6]);
if(item>=0 && itemfile.number)
print_way(OSMWays,item);
else
printf("Invalid way number; minimum=0, maximum=%"Pindex_t".\n",OSMWays->file.number-1);
}
else if(!strcmp(argv[arg],"--turn-relation=all"))
{
for(item=0;itemfile.trnumber;item++)
print_turn_relation(OSMRelations,item,OSMSegments,OSMNodes);
}
else if(!strncmp(argv[arg],"--turn-relation=",16))
{
item=atoi(&argv[arg][16]);
if(item>=0 && itemfile.trnumber)
print_turn_relation(OSMRelations,item,OSMSegments,OSMNodes);
else
printf("Invalid turn relation number; minimum=0, maximum=%"Pindex_t".\n",OSMRelations->file.trnumber-1);
}
}
/* Print out internal data (in OSM XML format) */
if(option_dump_osm)
{
if(coordcount>0 && coordcount!=4)
print_usage(0,NULL,"The --dump-osm option must have all of --latmin, --latmax, --lonmin, --lonmax or none.\n");
print_head_osm(coordcount,latmin,latmax,lonmin,lonmax);
if(coordcount)
print_region_osm(OSMNodes,OSMSegments,OSMWays,OSMRelations,latmin,latmax,lonmin,lonmax,option_no_super);
else
{
index_t item;
for(item=0;itemfile.number;item++)
print_node_osm(OSMNodes,item);
for(item=0;itemfile.number;item++)
if(!option_no_super || IsNormalSegment(LookupSegment(OSMSegments,item,1)))
print_segment_osm(OSMSegments,item,OSMWays);
for(item=0;itemfile.trnumber;item++)
print_turn_relation_osm(OSMRelations,item,OSMSegments,OSMNodes);
}
print_tail_osm();
}
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
Print out the contents of a node from the routing database (as plain text).
Nodes *nodes The set of nodes to use.
index_t item The node index to print.
++++++++++++++++++++++++++++++++++++++*/
static void print_node(Nodes *nodes,index_t item)
{
Node *nodep=LookupNode(nodes,item,1);
double latitude,longitude;
GetLatLong(nodes,item,&latitude,&longitude);
printf("Node %"Pindex_t"\n",item);
printf(" firstseg=%"Pindex_t"\n",nodep->firstseg);
printf(" latoffset=%d lonoffset=%d (latitude=%.6f longitude=%.6f)\n",nodep->latoffset,nodep->lonoffset,radians_to_degrees(latitude),radians_to_degrees(longitude));
printf(" allow=%02x (%s)\n",nodep->allow,AllowedNameList(nodep->allow));
if(IsSuperNode(nodep))
printf(" Super-Node\n");
}
/*++++++++++++++++++++++++++++++++++++++
Print out the contents of a segment from the routing database (as plain text).
Segments *segments The set of segments to use.
index_t item The segment index to print.
++++++++++++++++++++++++++++++++++++++*/
static void print_segment(Segments *segments,index_t item)
{
Segment *segmentp=LookupSegment(segments,item,1);
printf("Segment %"Pindex_t"\n",item);
printf(" node1=%"Pindex_t" node2=%"Pindex_t"\n",segmentp->node1,segmentp->node2);
printf(" next2=%"Pindex_t"\n",segmentp->next2);
printf(" way=%"Pindex_t"\n",segmentp->way);
printf(" distance=%d (%.3f km)\n",DISTANCE(segmentp->distance),distance_to_km(DISTANCE(segmentp->distance)));
if(IsSuperSegment(segmentp) && IsNormalSegment(segmentp))
printf(" Super-Segment AND normal Segment\n");
else if(IsSuperSegment(segmentp) && !IsNormalSegment(segmentp))
printf(" Super-Segment\n");
if(IsOnewayTo(segmentp,segmentp->node1))
printf(" One-Way from node2 to node1\n");
if(IsOnewayTo(segmentp,segmentp->node2))
printf(" One-Way from node1 to node2\n");
}
/*++++++++++++++++++++++++++++++++++++++
Print out the contents of a way from the routing database (as plain text).
Ways *ways The set of ways to use.
index_t item The way index to print.
++++++++++++++++++++++++++++++++++++++*/
static void print_way(Ways *ways,index_t item)
{
Way *wayp=LookupWay(ways,item,1);
char *name=WayName(ways,wayp);
printf("Way %"Pindex_t"\n",item);
if(*name)
printf(" name=%s\n",name);
printf(" type=%02x (%s%s%s)\n",wayp->type,HighwayName(HIGHWAY(wayp->type)),wayp->type&Highway_OneWay?",One-Way":"",wayp->type&Highway_Roundabout?",Roundabout":"");
printf(" allow=%02x (%s)\n",wayp->allow,AllowedNameList(wayp->allow));
if(wayp->props)
printf(" props=%02x (%s)\n",wayp->props,PropertiesNameList(wayp->props));
if(wayp->speed)
printf(" speed=%d (%d km/hr)\n",wayp->speed,speed_to_kph(wayp->speed));
if(wayp->weight)
printf(" weight=%d (%.1f tonnes)\n",wayp->weight,weight_to_tonnes(wayp->weight));
if(wayp->height)
printf(" height=%d (%.1f m)\n",wayp->height,height_to_metres(wayp->height));
if(wayp->width)
printf(" width=%d (%.1f m)\n",wayp->width,width_to_metres(wayp->width));
if(wayp->length)
printf(" length=%d (%.1f m)\n",wayp->length,length_to_metres(wayp->length));
}
/*++++++++++++++++++++++++++++++++++++++
Print out the contents of a turn relation from the routing database (as plain text).
Relations *relations The set of relations to use.
index_t item The turn relation index to print.
Segments *segments The set of segments to use.
Nodes *nodes The set of nodes to use.
++++++++++++++++++++++++++++++++++++++*/
static void print_turn_relation(Relations *relations,index_t item,Segments *segments,Nodes *nodes)
{
Segment *segmentp;
TurnRelation *relationp=LookupTurnRelation(relations,item,1);
Node *nodep=LookupNode(nodes,relationp->via,1);
index_t from_way=NO_WAY,to_way=NO_WAY;
index_t from_node=NO_NODE,to_node=NO_NODE;
segmentp=FirstSegment(segments,nodep,1);
do
{
index_t seg=IndexSegment(segments,segmentp);
if(seg==relationp->from)
{
from_node=OtherNode(segmentp,relationp->from);
from_way=segmentp->way;
}
if(seg==relationp->to)
{
to_node=OtherNode(segmentp,relationp->to);
to_way=segmentp->way;
}
segmentp=NextSegment(segments,segmentp,relationp->via);
}
while(segmentp);
printf("Relation %"Pindex_t"\n",item);
printf(" from=%"Pindex_t" (segment) = %"Pindex_t" (way) = %"Pindex_t" (node)\n",relationp->from,from_way,from_node);
printf(" via=%"Pindex_t" (node)\n",relationp->via);
printf(" to=%"Pindex_t" (segment) = %"Pindex_t" (way) = %"Pindex_t" (node)\n",relationp->to,to_way,to_node);
if(relationp->except)
printf(" except=%02x (%s)\n",relationp->except,AllowedNameList(relationp->except));
}
/*++++++++++++++++++++++++++++++++++++++
Print out a header in OSM XML format.
int coordcount If true then include a bounding box.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
++++++++++++++++++++++++++++++++++++++*/
static void print_head_osm(int coordcount,double latmin,double latmax,double lonmin,double lonmax)
{
printf("\n");
printf("\n");
if(coordcount)
printf(" \n",
radians_to_degrees(latmin),radians_to_degrees(latmax),radians_to_degrees(lonmin),radians_to_degrees(lonmax));
}
/*++++++++++++++++++++++++++++++++++++++
Print a region of the database in OSM XML format.
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
Relations *relations The set of relations to use.
double latmin The minimum latitude.
double latmax The maximum latitude.
double lonmin The minimum longitude.
double lonmax The maximum longitude.
int option_no_super The option to print no super-segments.
++++++++++++++++++++++++++++++++++++++*/
static void print_region_osm(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,
double latmin,double latmax,double lonmin,double lonmax,int option_no_super)
{
ll_bin_t latminbin=latlong_to_bin(radians_to_latlong(latmin))-nodes->file.latzero;
ll_bin_t latmaxbin=latlong_to_bin(radians_to_latlong(latmax))-nodes->file.latzero;
ll_bin_t lonminbin=latlong_to_bin(radians_to_latlong(lonmin))-nodes->file.lonzero;
ll_bin_t lonmaxbin=latlong_to_bin(radians_to_latlong(lonmax))-nodes->file.lonzero;
ll_bin_t latb,lonb;
index_t item,index1,index2;
if(latminbin<0) latminbin=0;
if(latmaxbin>nodes->file.latbins) latmaxbin=nodes->file.latbins-1;
if(lonminbin<0) lonminbin=0;
if(lonmaxbin>nodes->file.lonbins) lonmaxbin=nodes->file.lonbins-1;
/* Loop through all of the nodes. */
for(latb=latminbin;latb<=latmaxbin;latb++)
for(lonb=lonminbin;lonb<=lonmaxbin;lonb++)
{
ll_bin2_t llbin=lonb*nodes->file.latbins+latb;
if(llbin<0 || llbin>(nodes->file.latbins*nodes->file.lonbins))
continue;
index1=LookupNodeOffset(nodes,llbin);
index2=LookupNodeOffset(nodes,llbin+1);
for(item=index1;itemfile.latzero+latb)+off_to_latlong(nodep->latoffset));
double lon=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonb)+off_to_latlong(nodep->lonoffset));
if(lat>latmin && latlonmin && lonlatmin && olatlonmin && olonoitem)
if(!option_no_super || IsNormalSegment(segmentp))
print_segment_osm(segments,IndexSegment(segments,segmentp),ways);
segmentp=NextSegment(segments,segmentp,item);
}
if(IsTurnRestrictedNode(nodep))
{
index_t relindex=FindFirstTurnRelation1(relations,item);
while(relindex!=NO_RELATION)
{
print_turn_relation_osm(relations,relindex,segments,nodes);
relindex=FindNextTurnRelation1(relations,relindex);
}
}
}
}
}
}
/*++++++++++++++++++++++++++++++++++++++
Print out the contents of a node from the routing database (in OSM XML format).
Nodes *nodes The set of nodes to use.
index_t item The node index to print.
++++++++++++++++++++++++++++++++++++++*/
static void print_node_osm(Nodes *nodes,index_t item)
{
Node *nodep=LookupNode(nodes,item,1);
double latitude,longitude;
int i;
GetLatLong(nodes,item,&latitude,&longitude);
if(nodep->allow==Transports_ALL && nodep->flags==0)
printf(" \n",(unsigned long)item+1,radians_to_degrees(latitude),radians_to_degrees(longitude));
else
{
printf(" \n",(unsigned long)item+1,radians_to_degrees(latitude),radians_to_degrees(longitude));
if(nodep->flags & NODE_SUPER)
printf(" \n");
if(nodep->flags & NODE_UTURN)
printf(" \n");
if(nodep->flags & NODE_MINIRNDBT)
printf(" \n");
if(nodep->flags & NODE_TURNRSTRCT)
printf(" \n");
for(i=1;iallow & TRANSPORTS(i)))
printf(" \n",TransportName(i));
printf(" \n");
}
}
/*++++++++++++++++++++++++++++++++++++++
Print out the contents of a segment from the routing database (as a way in OSM XML format).
Segments *segments The set of segments to use.
index_t item The segment index to print.
Ways *ways The set of ways to use.
++++++++++++++++++++++++++++++++++++++*/
static void print_segment_osm(Segments *segments,index_t item,Ways *ways)
{
Segment *segmentp=LookupSegment(segments,item,1);
Way *wayp=LookupWay(ways,segmentp->way,1);
char *name=WayName(ways,wayp);
int i;
printf(" \n",(unsigned long)item+1);
if(IsOnewayTo(segmentp,segmentp->node1))
{
printf(" \n",(unsigned long)segmentp->node2+1);
printf(" \n",(unsigned long)segmentp->node1+1);
}
else
{
printf(" \n",(unsigned long)segmentp->node1+1);
printf(" \n",(unsigned long)segmentp->node2+1);
}
if(IsSuperSegment(segmentp))
printf(" \n");
if(IsNormalSegment(segmentp))
printf(" \n");
printf(" \n",distance_to_km(DISTANCE(segmentp->distance)));
if(wayp->type & Highway_OneWay)
printf(" \n");
if(wayp->type & Highway_Roundabout)
printf(" \n");
printf(" \n",HighwayName(HIGHWAY(wayp->type)));
if(IsNormalSegment(segmentp) && *name)
printf(" \n",ParseXML_Encode_Safe_XML(name));
for(i=1;iallow & TRANSPORTS(i))
printf(" \n",TransportName(i));
for(i=1;iprops & PROPERTIES(i))
printf(" \n",PropertyName(i));
if(wayp->speed)
printf(" \n",speed_to_kph(wayp->speed));
if(wayp->weight)
printf(" \n",weight_to_tonnes(wayp->weight));
if(wayp->height)
printf(" \n",height_to_metres(wayp->height));
if(wayp->width)
printf(" \n",width_to_metres(wayp->width));
if(wayp->length)
printf(" \n",length_to_metres(wayp->length));
printf(" \n");
}
/*++++++++++++++++++++++++++++++++++++++
Print out the contents of a turn relation from the routing database (in OSM XML format).
Relations *relations The set of relations to use.
index_t item The relation index to print.
Segments *segments The set of segments to use.
Nodes *nodes The set of nodes to use.
++++++++++++++++++++++++++++++++++++++*/
static void print_turn_relation_osm(Relations *relations,index_t item,Segments *segments,Nodes *nodes)
{
TurnRelation *relationp=LookupTurnRelation(relations,item,1);
Segment *segmentp_from=LookupSegment(segments,relationp->from,1);
Segment *segmentp_to =LookupSegment(segments,relationp->to ,2);
double angle=TurnAngle(nodes,segmentp_from,segmentp_to,relationp->via);
char *restriction;
if(angle>150 || angle<-150)
restriction="no_u_turn";
else if(angle>30)
restriction="no_right_turn";
else if(angle<-30)
restriction="no_left_turn";
else
restriction="no_straight_on";
printf(" \n",(unsigned long)item+1);
printf(" \n");
printf(" \n",restriction);
if(relationp->except)
printf(" \n",AllowedNameList(relationp->except));
printf(" \n",(unsigned long)relationp->from+1);
printf(" \n",(unsigned long)relationp->via+1);
printf(" \n",(unsigned long)relationp->to+1);
printf(" \n");
}
/*++++++++++++++++++++++++++++++++++++++
Print out a tail in OSM XML format.
++++++++++++++++++++++++++++++++++++++*/
static void print_tail_osm(void)
{
printf("\n");
}
/*+ Conversion from time_t to date string (day of week). +*/
static const char* const weekdays[7]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
/*+ Conversion from time_t to date string (month of year). +*/
static const char* const months[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
/*++++++++++++++++++++++++++++++++++++++
Convert the time into an RFC 822 compliant date.
char *RFC822Date Returns a pointer to a fixed string containing the date.
time_t t The time.
++++++++++++++++++++++++++++++++++++++*/
static char *RFC822Date(time_t t)
{
static char value[32];
char weekday[4];
char month[4];
struct tm *tim;
tim=gmtime(&t);
strcpy(weekday,weekdays[tim->tm_wday]);
strcpy(month,months[tim->tm_mon]);
/* Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123 */
sprintf(value,"%3s, %02d %3s %4d %02d:%02d:%02d %s",
weekday,
tim->tm_mday,
month,
tim->tm_year+1900,
tim->tm_hour,
tim->tm_min,
tim->tm_sec,
"GMT"
);
return(value);
}
/*++++++++++++++++++++++++++++++++++++++
Print out the usage information.
int detail The level of detail to use - 0 = low, 1 = high.
const char *argerr The argument that gave the error (if there is one).
const char *err Other error message (if there is one).
++++++++++++++++++++++++++++++++++++++*/
static void print_usage(int detail,const char *argerr,const char *err)
{
fprintf(stderr,
"Usage: filedumper [--help]\n"
" [--dir=] [--prefix=]\n"
" [--statistics]\n"
" [--visualiser --latmin= --latmax=\n"
" --lonmin= --lonmax=\n"
" --data=]\n"
" [--dump [--node= ...]\n"
" [--segment= ...]\n"
" [--way= ...]\n"
" [--turn-relation= ...]]\n"
" [--dump-osm [--no-super]\n"
" [--latmin= --latmax=\n"
" --lonmin= --lonmax=]]\n");
if(argerr)
fprintf(stderr,
"\n"
"Error with command line parameter: %s\n",argerr);
if(err)
fprintf(stderr,
"\n"
"Error: %s\n",err);
if(detail)
fprintf(stderr,
"\n"
"--help Prints this information.\n"
"\n"
"--dir= The directory containing the routing database.\n"
"--prefix= The filename prefix for the routing database.\n"
"\n"
"--statistics Print statistics about the routing database.\n"
"\n"
"--visualiser Extract selected data from the routing database:\n"
" --latmin= * the minimum latitude (degrees N).\n"
" --latmax= * the maximum latitude (degrees N).\n"
" --lonmin= * the minimum longitude (degrees E).\n"
" --lonmax= * the maximum longitude (degrees E).\n"
" --data= * the type of data to select.\n"
"\n"
" can be selected from:\n"
" junctions = segment count at each junction.\n"
" super = super-node and super-segments.\n"
" oneway = oneway segments.\n"
" highway-* = segments of the specified highway type.\n"
" transport-* = segments allowing the specified transport type.\n"
" barrier-* = nodes disallowing the specified transport type.\n"
" turns = turn restrictions.\n"
" speed = speed limits.\n"
" weight = weight limits.\n"
" height = height limits.\n"
" width = width limits.\n"
" length = length limits.\n"
"\n"
"--dump Dump selected contents of the database.\n"
" --node= * the node with the selected index.\n"
" --segment= * the segment with the selected index.\n"
" --way= * the way with the selected index.\n"
" --turn-relation= * the turn relation with the selected index.\n"
" Use 'all' instead of a number to get all of them.\n"
"\n"
"--dump-osm Dump all or part of the database as an XML file.\n"
" --no-super * exclude the super-segments.\n"
" --latmin= * the minimum latitude (degrees N).\n"
" --latmax= * the maximum latitude (degrees N).\n"
" --lonmin= * the minimum longitude (degrees E).\n"
" --lonmax= * the maximum longitude (degrees E).\n");
exit(!detail);
}
routino-2.4.1/src/relationsx.h 644 233 144 10067 12063560526 11546 0 /***************************************
A header file for the extended Relations structure.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2010-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef RELATIONSX_H
#define RELATIONSX_H /*+ To stop multiple inclusions. +*/
#include
#include "types.h"
#include "typesx.h"
/* Data structures */
/*+ An extended structure containing a single route relation. +*/
struct _RouteRelX
{
relation_t id; /*+ The relation identifier. +*/
transports_t routes; /*+ The types of transports that that this relation is for. +*/
};
/*+ An extended structure containing a single turn restriction relation. +*/
struct _TurnRelX
{
relation_t id; /*+ The relation identifier. +*/
way_t from; /*+ The id of the starting way; initially the OSM value, later the NodeX index then the SegmentX index. +*/
node_t via; /*+ The id of the via node; initially the OSM value, later the NodeX index. +*/
way_t to; /*+ The id of the ending way; initially the OSM value, later the NodeX index then the SegmentX index. +*/
TurnRestriction restriction; /*+ The type of restriction. +*/
transports_t except; /*+ The types of transports that that this relation does not apply to. +*/
};
/*+ A structure containing a set of relations. +*/
struct _RelationsX
{
/* Route relations */
char *rfilename; /*+ The name of the intermediate file (for the RouteRelX). +*/
char *rfilename_tmp; /*+ The name of the temporary file (for the RouteRelX). +*/
int rfd; /*+ The file descriptor of the open file (for the RouteRelX). +*/
index_t rnumber; /*+ The number of extended route relations. +*/
/* Turn restriction relations */
char *trfilename; /*+ The name of the intermediate file (for the TurnRelX). +*/
char *trfilename_tmp; /*+ The name of the temporary file (for the TurnRelX). +*/
int trfd; /*+ The file descriptor of the temporary file (for the TurnRelX). +*/
index_t trnumber; /*+ The number of extended turn restriction relations. +*/
};
/* Functions in relationsx.c */
RelationsX *NewRelationList(int append,int readonly);
void FreeRelationList(RelationsX *relationsx,int keep);
void AppendRouteRelationList(RelationsX* relationsx,relation_t id,
transports_t routes,
way_t *ways,int nways,
relation_t *relations,int nrelations);
void AppendTurnRelationList(RelationsX* relationsx,relation_t id,
way_t from,way_t to,node_t via,
TurnRestriction restriction,transports_t except);
void FinishRelationList(RelationsX *relationsx);
void SortRelationList(RelationsX *relationsx);
void ProcessRouteRelations(RelationsX *relationsx,WaysX *waysx,int keep);
void ProcessTurnRelations1(RelationsX *relationsx,NodesX *nodesx,WaysX *waysx,int keep);
void ProcessTurnRelations2(RelationsX *relationsx,NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx);
void RemovePrunedTurnRelations(RelationsX *relationsx,NodesX *nodesx);
void SortTurnRelationListGeographically(RelationsX *relationsx,NodesX *nodesx,SegmentsX *segmentsx);
void SaveRelationList(RelationsX* relationsx,const char *filename);
#endif /* RELATIONSX_H */
routino-2.4.1/src/ways.c 644 233 144 6070 12063560526 10313 0 /***************************************
Way data type functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include "ways.h"
#include "files.h"
/*++++++++++++++++++++++++++++++++++++++
Load in a way list from a file.
Ways *LoadWayList Returns the way list.
const char *filename The name of the file to load.
++++++++++++++++++++++++++++++++++++++*/
Ways *LoadWayList(const char *filename)
{
Ways *ways;
#if SLIM
int i;
#endif
ways=(Ways*)malloc(sizeof(Ways));
#if !SLIM
ways->data=MapFile(filename);
/* Copy the WaysFile structure from the loaded data */
ways->file=*((WaysFile*)ways->data);
/* Set the pointers in the Ways structure. */
ways->ways =(Way *)(ways->data+sizeof(WaysFile));
ways->names=(char*)(ways->data+sizeof(WaysFile)+ways->file.number*sizeof(Way));
#else
ways->fd=ReOpenFile(filename);
/* Copy the WaysFile header structure from the loaded data */
ReadFile(ways->fd,&ways->file,sizeof(WaysFile));
for(i=0;icached)/sizeof(ways->cached[0]);i++)
ways->incache[i]=NO_WAY;
ways->namesoffset=sizeof(WaysFile)+ways->file.number*sizeof(Way);
for(i=0;icached)/sizeof(ways->cached[0]);i++)
ways->ncached[i]=NULL;
#endif
return(ways);
}
/*++++++++++++++++++++++++++++++++++++++
Return 0 if the two ways are the same (in respect of their types and limits),
otherwise return positive or negative to allow sorting.
int WaysCompare Returns a comparison.
Way *way1p The first way.
Way *way2p The second way.
++++++++++++++++++++++++++++++++++++++*/
int WaysCompare(Way *way1p,Way *way2p)
{
if(way1p==way2p)
return(0);
if(way1p->type!=way2p->type)
return((int)way1p->type - (int)way2p->type);
if(way1p->allow!=way2p->allow)
return((int)way1p->allow - (int)way2p->allow);
if(way1p->props!=way2p->props)
return((int)way1p->props - (int)way2p->props);
if(way1p->speed!=way2p->speed)
return((int)way1p->speed - (int)way2p->speed);
if(way1p->weight!=way2p->weight)
return((int)way1p->weight - (int)way2p->weight);
if(way1p->height!=way2p->height)
return((int)way1p->height - (int)way2p->height);
if(way1p->width!=way2p->width)
return((int)way1p->width - (int)way2p->width);
if(way1p->length!=way2p->length)
return((int)way1p->length - (int)way2p->length);
return(0);
}
routino-2.4.1/src/types.h 644 233 144 32115 12063560526 10520 0 /***************************************
Type definitions
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef TYPES_H
#define TYPES_H /*+ To stop multiple inclusions. +*/
#include
#include
#include
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
/* Constants and macros for handling them */
/*+ The number of waypoints allowed to be specified. +*/
#define NWAYPOINTS 99
/*+ An undefined node index. +*/
#define NO_NODE ((index_t)~0)
/*+ An undefined segment index. +*/
#define NO_SEGMENT ((index_t)~0)
/*+ An undefined way index. +*/
#define NO_WAY ((index_t)~0)
/*+ An undefined relation index. +*/
#define NO_RELATION ((index_t)~0)
/*+ An undefined location. +*/
#define NO_LATLONG ((latlong_t)0x80000000)
/*+ The lowest number allowed for a fake node. +*/
#define NODE_FAKE ((index_t)0xffff0000)
/*+ The lowest number allowed for a fake segment. +*/
#define SEGMENT_FAKE ((index_t)0xffff0000)
/*+ The latitude and longitude conversion factor from floating point (radians) to integer. +*/
#define LAT_LONG_SCALE (1024*65536)
/*+ The latitude and longitude integer range within each bin. +*/
#define LAT_LONG_BIN 65536
/*+ A flag to mark a node as a super-node. +*/
#define NODE_SUPER ((nodeflags_t)0x8000)
/*+ A flag to mark a node as suitable for a U-turn. +*/
#define NODE_UTURN ((nodeflags_t)0x4000)
/*+ A flag to mark a node as a mini-roundabout. +*/
#define NODE_MINIRNDBT ((nodeflags_t)0x2000)
/*+ A flag to mark a node as a turn relation via node. +*/
#define NODE_TURNRSTRCT ((nodeflags_t)0x1000)
/*+ A flag to mark a node as adjacent to a turn relation via node. +*/
#define NODE_TURNRSTRCT2 ((nodeflags_t)0x0800)
/*+ A flag to mark a node as deleted. +*/
#define NODE_DELETED ((nodeflags_t)0x0400)
/*+ A flag to mark a segment as being part of an area (must be the highest valued flag). +*/
#define SEGMENT_AREA ((distance_t)0x80000000)
/*+ A flag to mark a segment as one-way from node1 to node2. +*/
#define ONEWAY_1TO2 ((distance_t)0x40000000)
/*+ A flag to mark a segment as one-way from node2 to node1. +*/
#define ONEWAY_2TO1 ((distance_t)0x20000000)
/*+ A flag to mark a segment as a super-segment. +*/
#define SEGMENT_SUPER ((distance_t)0x10000000)
/*+ A flag to mark a segment as a normal segment. +*/
#define SEGMENT_NORMAL ((distance_t)0x08000000)
/*+ The real distance ignoring the other flags. +*/
#define DISTANCE(xx) ((distance_t)((xx)&(~(SEGMENT_AREA|ONEWAY_1TO2|ONEWAY_2TO1|SEGMENT_SUPER|SEGMENT_NORMAL))))
/*+ The distance flags selecting only the flags. +*/
#define DISTFLAG(xx) ((distance_t)((xx)&(SEGMENT_AREA|ONEWAY_1TO2|ONEWAY_2TO1|SEGMENT_SUPER|SEGMENT_NORMAL)))
/*+ A very large almost infinite distance. +*/
#define INF_DISTANCE DISTANCE(~0)
/*+ A very large almost infinite score. +*/
#define INF_SCORE (score_t)1E30
/*+ A flag to mark a deleted way. +*/
#define WAY_DELETED ((highway_t)~0)
/*+ A flag to mark a deleted relation. +*/
#define RELATION_DELETED ((transports_t)~0)
/* Simple Types */
/*+ A node, segment, way or relation index. +*/
typedef uint32_t index_t;
/*+ A printf formatting string for an index_t type (this should match the index_t definition above). +*/
#define Pindex_t PRIu32 /* PRIu32 and PRIu64 are defined in intypes.h */
/*+ A node latitude or longitude (range: +/-pi*LAT_LONG_SCALE = +/-3.14*1024*65536 = ~29 bits). +*/
typedef int32_t latlong_t;
/*+ A node latitude or longitude bin number (range: +/-pi*LAT_LONG_SCALE/LAT_LONG_BIN = +/-3.14*1024 = ~13 bits). +*/
typedef int16_t ll_bin_t;
/*+ A node latitude and longitude bin number (range: +/-(pi*LAT_LONG_SCALE/LAT_LONG_BIN)^2 = +/-(3.14*1024)^2 = ~26 bits). +*/
typedef int32_t ll_bin2_t;
/*+ A node latitude or longitude offset (range: 0 -> LAT_LONG_BIN-1 = 0 -> 65535 = 16 bits). +*/
typedef uint16_t ll_off_t;
/*+ Conversion from a latlong (integer latitude or longitude) to a bin number. +*/
#define latlong_to_bin(xxx) (ll_bin_t)((latlong_t)((xxx)&~(LAT_LONG_BIN-1))/LAT_LONG_BIN)
/*+ Conversion from a bin number to a latlong (integer latitude or longitude). +*/
#define bin_to_latlong(xxx) ((latlong_t)(xxx)*LAT_LONG_BIN)
/*+ Conversion from a latlong (integer latitude or longitude) to a bin offset. +*/
#define latlong_to_off(xxx) (ll_off_t)((latlong_t)(xxx)&(LAT_LONG_BIN-1))
/*+ Conversion from a bin offset to a latlong (integer latitude or longitude). +*/
#define off_to_latlong(xxx) ((latlong_t)(xxx))
/*+ Conversion from a latitude or longitude in radians to a latlong (integer latitude or longitude). +*/
#define radians_to_latlong(xxx) ((latlong_t)floor((xxx)*LAT_LONG_SCALE+0.5))
/*+ Conversion from a latlong (integer latitude or longitude) to a latitude or longitude in radians. +*/
#define latlong_to_radians(xxx) ((double)(xxx)/LAT_LONG_SCALE)
/*+ Conversion from radians to degrees. +*/
#define radians_to_degrees(xxx) ((xxx)*(180.0/M_PI))
/*+ Conversion from degrees to radians. +*/
#define degrees_to_radians(xxx) ((xxx)*(M_PI/180.0))
/*+ Node flags. +*/
typedef uint16_t nodeflags_t;
/*+ A distance, measured in metres. +*/
typedef uint32_t distance_t;
/*+ A duration, measured in 1/10th seconds. +*/
typedef uint32_t duration_t;
/*+ A routing optimisation score. +*/
typedef float score_t;
/*+ Conversion from distance_t to kilometres. +*/
#define distance_to_km(xx) ((double)(xx)/1000.0)
/*+ Conversion from kilometres to distance_t. +*/
#define km_to_distance(xx) ((distance_t)((double)(xx)*1000.0))
/*+ Conversion from duration_t to minutes. +*/
#define duration_to_minutes(xx) ((double)(xx)/600.0)
/*+ Conversion from duration_t to hours. +*/
#define duration_to_hours(xx) ((double)(xx)/36000.0)
/*+ Conversion from hours to duration_t. +*/
#define hours_to_duration(xx) ((duration_t)((double)(xx)*36000.0))
/*+ Conversion from distance_t and speed_t to duration_t. +*/
#define distance_speed_to_duration(xx,yy) ((duration_t)(((double)(xx)/(double)(yy))*(36000.0/1000.0)))
/*+ The type of a highway. +*/
typedef uint8_t highway_t;
/*+ The different types of a highway. +*/
typedef enum _Highway
{
Highway_None = 0,
Highway_Motorway = 1,
Highway_Trunk = 2,
Highway_Primary = 3,
Highway_Secondary = 4,
Highway_Tertiary = 5,
Highway_Unclassified = 6,
Highway_Residential = 7,
Highway_Service = 8,
Highway_Track = 9,
Highway_Cycleway = 10,
Highway_Path = 11,
Highway_Steps = 12,
Highway_Ferry = 13,
Highway_Count = 14, /* One more than the number of highway types. */
Highway_OneWay = 32,
Highway_Roundabout = 64
}
Highway;
#define HIGHWAY(xx) ((xx)&0x1f)
/*+ A bitmask of multiple highway types. +*/
typedef uint16_t highways_t;
#define HIGHWAYS(xx) (1<<(HIGHWAY(xx)-1))
/*+ The different types of a highway as a bitmask. +*/
typedef enum _Highways
{
Highways_None = 0,
Highways_Motorway = HIGHWAYS(Highway_Motorway ),
Highways_Trunk = HIGHWAYS(Highway_Trunk ),
Highways_Primary = HIGHWAYS(Highway_Primary ),
Highways_Secondary = HIGHWAYS(Highway_Secondary ),
Highways_Tertiary = HIGHWAYS(Highway_Tertiary ),
Highways_Unclassified = HIGHWAYS(Highway_Unclassified),
Highways_Residential = HIGHWAYS(Highway_Residential ),
Highways_Service = HIGHWAYS(Highway_Service ),
Highways_Track = HIGHWAYS(Highway_Track ),
Highways_Cycleway = HIGHWAYS(Highway_Cycleway ),
Highways_Path = HIGHWAYS(Highway_Path ),
Highways_Steps = HIGHWAYS(Highway_Steps ),
Highways_Ferry = HIGHWAYS(Highway_Ferry )
}
Highways;
/*+ The type of a transport. +*/
typedef uint8_t transport_t;
/*+ The different types of transport. +*/
typedef enum _Transport
{
Transport_None = 0,
Transport_Foot = 1,
Transport_Horse = 2,
Transport_Wheelchair = 3,
Transport_Bicycle = 4,
Transport_Moped = 5,
Transport_Motorbike = 6,
Transport_Motorcar = 7,
Transport_Goods = 8,
Transport_HGV = 9,
Transport_PSV = 10,
Transport_Count = 11 /*+ One more than the number of transport types. +*/
}
Transport;
/*+ A bitmask of multiple transport types. +*/
typedef uint16_t transports_t;
#define TRANSPORTS(xx) (1<<((xx)-1))
/*+ The different types of transport as a bitmask. +*/
typedef enum _Transports
{
Transports_None = 0,
Transports_Foot = TRANSPORTS(Transport_Foot ),
Transports_Horse = TRANSPORTS(Transport_Horse ),
Transports_Wheelchair = TRANSPORTS(Transport_Wheelchair),
Transports_Bicycle = TRANSPORTS(Transport_Bicycle ),
Transports_Moped = TRANSPORTS(Transport_Moped ),
Transports_Motorbike = TRANSPORTS(Transport_Motorbike ),
Transports_Motorcar = TRANSPORTS(Transport_Motorcar ),
Transports_Goods = TRANSPORTS(Transport_Goods ),
Transports_HGV = TRANSPORTS(Transport_HGV ),
Transports_PSV = TRANSPORTS(Transport_PSV ),
Transports_ALL = TRANSPORTS(Transport_Count )-1
}
Transports;
/*+ The type of a property. +*/
typedef uint8_t property_t;
/*+ The different types of property. +*/
typedef enum _Property
{
Property_None = 0,
Property_Paved = 1,
Property_Multilane = 2,
Property_Bridge = 3,
Property_Tunnel = 4,
Property_FootRoute = 5,
Property_BicycleRoute = 6,
Property_Count = 7 /* One more than the number of property types. */
}
Property;
/*+ A bitmask of multiple properties. +*/
typedef uint8_t properties_t;
#define PROPERTIES(xx) (1<<((xx)-1))
/*+ The different properties as a bitmask. +*/
typedef enum _Properties
{
Properties_None = 0,
Properties_Paved = PROPERTIES(Property_Paved ),
Properties_Multilane = PROPERTIES(Property_Multilane ),
Properties_Bridge = PROPERTIES(Property_Bridge ),
Properties_Tunnel = PROPERTIES(Property_Tunnel ),
Properties_FootRoute = PROPERTIES(Property_FootRoute ),
Properties_BicycleRoute = PROPERTIES(Property_BicycleRoute),
Properties_ALL = PROPERTIES(Property_Count )-1
}
Properties;
/*+ The speed limit of a way, measured in km/hour. +*/
typedef uint8_t speed_t;
/*+ The maximum weight of a way, measured in multiples of 0.2 tonnes. +*/
typedef uint8_t weight_t;
/*+ The maximum height of a way, measured in multiples of 0.1 metres. +*/
typedef uint8_t height_t;
/*+ The maximum width of a way, measured in multiples of 0.1 metres. +*/
typedef uint8_t width_t;
/*+ The maximum length of a way, measured in multiples of 0.1 metres. +*/
typedef uint8_t length_t;
/*+ Conversion of km/hr to speed_t. +*/
#define kph_to_speed(xxx) (speed_t)(xxx)
/*+ Conversion of speed_t to km/hr. +*/
#define speed_to_kph(xxx) (int)(xxx)
/*+ Conversion of tonnes to weight_t. +*/
#define tonnes_to_weight(xxx) (weight_t)((xxx)*5)
/*+ Conversion of weight_t to tonnes. +*/
#define weight_to_tonnes(xxx) ((double)(xxx)/5.0)
/*+ Conversion of metres to height_t. +*/
#define metres_to_height(xxx) (height_t)((xxx)*10)
/*+ Conversion of height_t to metres. +*/
#define height_to_metres(xxx) ((double)(xxx)/10.0)
/*+ Conversion of metres to width_t. +*/
#define metres_to_width(xxx) (width_t)((xxx)*10)
/*+ Conversion of width_t to metres. +*/
#define width_to_metres(xxx) ((double)(xxx)/10.0)
/*+ Conversion of metres to length_t. +*/
#define metres_to_length(xxx) (length_t)((xxx)*10)
/*+ Conversion of length_t to metres. +*/
#define length_to_metres(xxx) ((double)(xxx)/10.0)
/* Data structures */
typedef struct _Node Node;
typedef struct _Nodes Nodes;
typedef struct _Segment Segment;
typedef struct _Segments Segments;
typedef struct _Way Way;
typedef struct _Ways Ways;
typedef struct _TurnRelation TurnRelation;
typedef struct _Relations Relations;
/* Functions in types.c */
Highway HighwayType(const char *highway);
Transport TransportType(const char *transport);
Property PropertyType(const char *property);
const char *HighwayName(Highway highway);
const char *TransportName(Transport transport);
const char *PropertyName(Property property);
const char *HighwaysNameList(highways_t highways);
const char *AllowedNameList(transports_t allowed);
const char *PropertiesNameList(properties_t properties);
const char *HighwayList(void);
const char *TransportList(void);
const char *PropertyList(void);
#endif /* TYPES_H */
routino-2.4.1/src/segmentsx.h 644 233 144 15551 12063560526 11376 0 /***************************************
A header file for the extended segments.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef SEGMENTSX_H
#define SEGMENTSX_H /*+ To stop multiple inclusions. +*/
#include
#include "types.h"
#include "typesx.h"
#include "files.h"
/* Data structures */
/*+ An extended structure used for processing. +*/
struct _SegmentX
{
node_t node1; /*+ The id of the starting node; initially the OSM value, later the NodeX index. +*/
node_t node2; /*+ The id of the finishing node; initially the OSM value, later the NodeX index. +*/
index_t next2; /*+ The index of the next segment with the same node2. +*/
way_t way; /*+ The id of the way; initially the OSM value, later the WayX index. +*/
distance_t distance; /*+ The distance between the nodes. +*/
};
/*+ A structure containing a set of segments (memory format). +*/
struct _SegmentsX
{
char *filename; /*+ The name of the intermediate file (for the SegmentsX). +*/
char *filename_tmp; /*+ The name of the temporary file (for the SegmentsX). +*/
int fd; /*+ The file descriptor of the open file (for the SegmentsX). +*/
index_t number; /*+ The number of extended segments still being considered. +*/
#if !SLIM
SegmentX *data; /*+ The extended segment data (when mapped into memory). +*/
#else
SegmentX cached[4]; /*+ Four cached extended segments read from the file in slim mode. +*/
index_t incache[4]; /*+ The indexes of the cached extended segments. +*/
#endif
index_t *firstnode; /*+ The first segment index for each node. +*/
index_t *next1; /*+ The index of the next segment with the same node1 (used while pruning). +*/
BitMask *usednode; /*+ A flag to indicate if a node is used (used for removing bad segments). +*/
BitMask *usedway; /*+ A flag to indicate if a way is used (used for removing pruned ways). +*/
};
/* Functions in segmentsx.c */
SegmentsX *NewSegmentList(int append,int readonly);
void FreeSegmentList(SegmentsX *segmentsx,int keep);
void AppendSegmentList(SegmentsX *segmentsx,way_t way,node_t node1,node_t node2,distance_t distance);
void FinishSegmentList(SegmentsX *segmentsx);
SegmentX *FirstSegmentX(SegmentsX *segmentsx,index_t nodeindex,int position);
SegmentX *NextSegmentX(SegmentsX *segmentsx,SegmentX *segmentx,index_t nodeindex);
void ApplySegmentChanges(SegmentsX *segmentsx);
void SortSegmentList(SegmentsX *segmentsx);
void IndexSegments(SegmentsX *segmentsx,NodesX *nodesx,WaysX *waysx);
void RemoveBadSegments(SegmentsX *segmentsx,NodesX *nodesx,WaysX *waysx,int keep);
void MeasureSegments(SegmentsX *segmentsx,NodesX *nodesx,WaysX *waysx);
void RemovePrunedSegments(SegmentsX *segmentsx,WaysX *waysx);
void DeduplicateSuperSegments(SegmentsX *segmentsx,WaysX *waysx);
void SortSegmentListGeographically(SegmentsX *segmentsx,NodesX *nodesx);
void SaveSegmentList(SegmentsX *segmentsx,const char *filename);
/* Macros / inline functions */
/*+ Return true if this is a pruned segment. +*/
#define IsPrunedSegmentX(xxx) ((xxx)->node1==NO_NODE)
#if !SLIM
#define LookupSegmentX(segmentsx,index,position) &(segmentsx)->data[index]
#define IndexSegmentX(segmentsx,segmentx) (index_t)((segmentx)-&(segmentsx)->data[0])
#define PutBackSegmentX(segmentsx,segmentx) /* nop */
#define ReLookupSegmentX(segmentsx,segmentx) /* nop */
#else
static SegmentX *LookupSegmentX(SegmentsX *segmentsx,index_t index,int position);
static index_t IndexSegmentX(SegmentsX *segmentsx,SegmentX *segmentx);
static void PutBackSegmentX(SegmentsX *segmentsx,SegmentX *segmentx);
static void ReLookupSegmentX(SegmentsX *segmentsx,SegmentX *segmentx);
/*++++++++++++++++++++++++++++++++++++++
Lookup a particular extended segment with the specified id from the file on disk.
SegmentX *LookupSegmentX Returns a pointer to a cached copy of the extended segment.
SegmentsX *segmentsx The set of segments to use.
index_t index The segment index to look for.
int position The position in the cache to use.
++++++++++++++++++++++++++++++++++++++*/
static inline SegmentX *LookupSegmentX(SegmentsX *segmentsx,index_t index,int position)
{
SeekReadFile(segmentsx->fd,&segmentsx->cached[position-1],sizeof(SegmentX),(off_t)index*sizeof(SegmentX));
segmentsx->incache[position-1]=index;
return(&segmentsx->cached[position-1]);
}
/*++++++++++++++++++++++++++++++++++++++
Find the extended segment index for a particular extended segment pointer.
index_t IndexSegmentX Returns the index of the extended segment.
SegmentsX *segmentsx The set of segments to use.
SegmentX *segmentx The extended segment whose index is to be found.
++++++++++++++++++++++++++++++++++++++*/
static inline index_t IndexSegmentX(SegmentsX *segmentsx,SegmentX *segmentx)
{
int position1=segmentx-&segmentsx->cached[0];
return(segmentsx->incache[position1]);
}
/*++++++++++++++++++++++++++++++++++++++
Put back an extended segment's data into the file on disk.
SegmentsX *segmentsx The set of segments to use.
SegmentX *segmentx The extended segment to be put back.
++++++++++++++++++++++++++++++++++++++*/
static inline void PutBackSegmentX(SegmentsX *segmentsx,SegmentX *segmentx)
{
int position1=segmentx-&segmentsx->cached[0];
SeekWriteFile(segmentsx->fd,&segmentsx->cached[position1],sizeof(SegmentX),(off_t)segmentsx->incache[position1]*sizeof(SegmentX));
}
/*++++++++++++++++++++++++++++++++++++++
Lookup an extended segment's data from the disk into file again after the disk was updated.
SegmentsX *segmentsx The set of segments to use.
SegmentX *segmentx The extended segment to refresh.
++++++++++++++++++++++++++++++++++++++*/
static inline void ReLookupSegmentX(SegmentsX *segmentsx,SegmentX *segmentx)
{
int position1=segmentx-&segmentsx->cached[0];
SeekReadFile(segmentsx->fd,&segmentsx->cached[position1],sizeof(SegmentX),(off_t)segmentsx->incache[position1]*sizeof(SegmentX));
}
#endif /* SLIM */
#endif /* SEGMENTSX_H */
routino-2.4.1/src/fakes.h 644 233 144 3552 12063560526 10430 0 /***************************************
Header file for fake node and segment function prototypes
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef FAKES_H
#define FAKES_H /*+ To stop multiple inclusions. +*/
#include "types.h"
/* Macros */
/*+ Return true if this is a fake node. +*/
#define IsFakeNode(xxx) ((xxx)>=NODE_FAKE && (xxx)!=NO_NODE)
/*+ Return true if this is a fake segment. +*/
#define IsFakeSegment(xxx) ((xxx)>=SEGMENT_FAKE && (xxx)!=NO_SEGMENT)
/* Functions in fakes.c */
index_t CreateFakes(Nodes *nodes,Segments *segments,int point,Segment *segmentp,index_t node1,index_t node2,distance_t dist1,distance_t dist2);
void GetFakeLatLong(index_t fakenode, double *latitude,double *longitude);
Segment *FirstFakeSegment(index_t fakenode);
Segment *NextFakeSegment(Segment *fakesegmentp,index_t fakenode);
Segment *ExtraFakeSegment(index_t realnode,index_t fakenode);
Segment *LookupFakeSegment(index_t index);
index_t IndexFakeSegment(Segment *fakesegmentp);
index_t IndexRealSegment(index_t fakesegment);
int IsFakeUTurn(index_t fakesegment1,index_t fakesegment2);
#endif /* FAKES_H */
routino-2.4.1/src/fakes.c 644 233 144 25043 12063560526 10442 0 /***************************************
Fake node and segment generation.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include "types.h"
#include "nodes.h"
#include "segments.h"
#include "fakes.h"
/*+ The minimum distance along a segment from a node to insert a fake node. (in km). +*/
#define MINSEGMENT 0.005
/*+ A set of fake segments to allow start/finish in the middle of a segment. +*/
static Segment fake_segments[4*NWAYPOINTS+1];
/*+ A set of pointers to the real segments underlying the fake segments. +*/
static index_t real_segments[4*NWAYPOINTS+1];
/*+ A set of fake node latitudes and longitudes. +*/
static double fake_lon[NWAYPOINTS+1],fake_lat[NWAYPOINTS+1];
/*+ The previous waypoint. +*/
static int prevpoint=0;
/*++++++++++++++++++++++++++++++++++++++
Create a pair of fake segments corresponding to the given segment split in two
(and will create an extra two fake segments if adjacent waypoints are on the
same segment).
index_t CreateFakes Returns the fake node index (or a real one in special cases).
Nodes *nodes The set of nodes to use.
Segments *segments The set of segments to use.
int point Which of the waypoints this is.
Segment *segmentp The segment to split.
index_t node1 The first node at the end of this segment.
index_t node2 The second node at the end of this segment.
distance_t dist1 The distance to the first node.
distance_t dist2 The distance to the second node.
++++++++++++++++++++++++++++++++++++++*/
index_t CreateFakes(Nodes *nodes,Segments *segments,int point,Segment *segmentp,index_t node1,index_t node2,distance_t dist1,distance_t dist2)
{
index_t fakenode;
double lat1,lon1,lat2,lon2;
/* Initialise the segments to fake values */
fake_segments[4*point-4].node1=NO_NODE;
fake_segments[4*point-4].node2=NO_NODE;
fake_segments[4*point-3].node1=NO_NODE;
fake_segments[4*point-3].node2=NO_NODE;
fake_segments[4*point-2].node1=NO_NODE;
fake_segments[4*point-2].node2=NO_NODE;
fake_segments[4*point-1].node1=NO_NODE;
fake_segments[4*point-1].node2=NO_NODE;
/* Check if we are actually close enough to an existing node */
if(dist1km_to_distance(MINSEGMENT))
{
prevpoint=point;
return(node1);
}
if(dist2km_to_distance(MINSEGMENT))
{
prevpoint=point;
return(node2);
}
if(dist13 && lat2<-3)
lat2+=2*M_PI;
else if(lat1<-3 && lat2>3)
lat1+=2*M_PI;
fake_lat[point]=lat1+(lat2-lat1)*(double)dist1/(double)(dist1+dist2);
fake_lon[point]=lon1+(lon2-lon1)*(double)dist1/(double)(dist1+dist2);
if(fake_lat[point]>M_PI) fake_lat[point]-=2*M_PI;
/*
* node1 fakenode node2
* #----------*----------------------------# real_segments[4*point-{4,3}]
*
* #----------* fake_segments[4*point-4]
* *----------------------------# fake_segments[4*point-3]
*
*
* node1 fakenode[prevpoint] node2
* #----------*------------------%---------# real_segments[4*prevpoint-{4,3,1}], real_segments[4*point-{4,3,2}]
* fakenode[point]
* #----------* fake_segments[4*prevpoint-4]
* *----------------------------# fake_segments[4*prevpoint-3]
* *------------------% fake_segments[4*prevpoint-1]
* #-----------------------------% fake_segments[4*point-4]
* %---------# fake_segments[4*point-3]
* *------------------% fake_segments[4*point-2]
*/
/* Create the first fake segment */
fake_segments[4*point-4]=*segmentp;
fake_segments[4*point-4].node2=fakenode;
fake_segments[4*point-4].distance=DISTANCE(dist1)|DISTFLAG(segmentp->distance);
real_segments[4*point-4]=IndexSegment(segments,segmentp);
/* Create the second fake segment */
fake_segments[4*point-3]=*segmentp;
fake_segments[4*point-3].node1=fakenode;
fake_segments[4*point-3].distance=DISTANCE(dist2)|DISTFLAG(segmentp->distance);
real_segments[4*point-3]=IndexSegment(segments,segmentp);
/* Create a third fake segment to join adjacent points if both are fake and on the same real segment */
if(prevpoint>0 && fake_segments[4*prevpoint-4].node1==node1 && fake_segments[4*prevpoint-3].node2==node2)
{
if(DISTANCE(dist1)>DISTANCE(fake_segments[4*prevpoint-4].distance)) /* point is further from node1 than prevpoint */
{
fake_segments[4*point-2]=fake_segments[4*prevpoint-3];
fake_segments[4*point-2].node2=fakenode;
fake_segments[4*point-2].distance=(DISTANCE(dist1)-DISTANCE(fake_segments[4*prevpoint-4].distance))|DISTFLAG(segmentp->distance);
}
else
{
fake_segments[4*point-2]=fake_segments[4*prevpoint-4];
fake_segments[4*point-2].node1=fakenode;
fake_segments[4*point-2].distance=(DISTANCE(fake_segments[4*prevpoint-4].distance)-DISTANCE(dist1))|DISTFLAG(segmentp->distance);
}
real_segments[4*point-2]=IndexSegment(segments,segmentp);
fake_segments[4*prevpoint-1]=fake_segments[4*point-2];
real_segments[4*prevpoint-1]=real_segments[4*point-2];
}
/* Return the fake node */
prevpoint=point;
return(fakenode);
}
/*++++++++++++++++++++++++++++++++++++++
Lookup the latitude and longitude of a fake node.
index_t fakenode The fake node to lookup.
double *latitude Returns the latitude
double *longitude Returns the longitude.
++++++++++++++++++++++++++++++++++++++*/
void GetFakeLatLong(index_t fakenode, double *latitude,double *longitude)
{
index_t whichnode=fakenode-NODE_FAKE;
*latitude =fake_lat[whichnode];
*longitude=fake_lon[whichnode];
}
/*++++++++++++++++++++++++++++++++++++++
Finds the first fake segment associated to a fake node.
Segment *FirstFakeSegment Returns a pointer to the first fake segment.
index_t fakenode The fake node to lookup.
++++++++++++++++++++++++++++++++++++++*/
Segment *FirstFakeSegment(index_t fakenode)
{
index_t whichnode=fakenode-NODE_FAKE;
return(&fake_segments[4*whichnode-4]);
}
/*++++++++++++++++++++++++++++++++++++++
Finds the next fake segment associated to a fake node.
Segment *NextFakeSegment Returns a pointer to the next fake segment.
Segment *fakesegmentp The first fake segment.
index_t fakenode The node to lookup.
++++++++++++++++++++++++++++++++++++++*/
Segment *NextFakeSegment(Segment *fakesegmentp,index_t fakenode)
{
index_t whichnode=fakenode-NODE_FAKE;
if(fakesegmentp==&fake_segments[4*whichnode-4])
return(&fake_segments[4*whichnode-3]);
if(fakesegmentp==&fake_segments[4*whichnode-3] && fake_segments[4*whichnode-2].node1!=NO_NODE)
return(&fake_segments[4*whichnode-2]);
if(fakesegmentp==&fake_segments[4*whichnode-3] && fake_segments[4*whichnode-1].node1!=NO_NODE)
return(&fake_segments[4*whichnode-1]);
if(fakesegmentp==&fake_segments[4*whichnode-2] && fake_segments[4*whichnode-1].node1!=NO_NODE)
return(&fake_segments[4*whichnode-1]);
return(NULL);
}
/*++++++++++++++++++++++++++++++++++++++
Finds the fake segment between a real node and a fake node.
Segment *ExtraFakeSegment Returns a segment between the two specified nodes if it exists.
index_t realnode The real node.
index_t fakenode The fake node.
++++++++++++++++++++++++++++++++++++++*/
Segment *ExtraFakeSegment(index_t realnode,index_t fakenode)
{
index_t whichnode=fakenode-NODE_FAKE;
if(fake_segments[4*whichnode-4].node1==realnode || fake_segments[4*whichnode-4].node2==realnode)
return(&fake_segments[4*whichnode-4]);
if(fake_segments[4*whichnode-3].node1==realnode || fake_segments[4*whichnode-3].node2==realnode)
return(&fake_segments[4*whichnode-3]);
return(NULL);
}
/*++++++++++++++++++++++++++++++++++++++
Lookup a fake segment given its index.
Segment *LookupFakeSegment Returns a pointer to the fake segment.
index_t fakesegment The index of the fake segment.
++++++++++++++++++++++++++++++++++++++*/
Segment *LookupFakeSegment(index_t fakesegment)
{
index_t whichsegment=fakesegment-SEGMENT_FAKE;
return(&fake_segments[whichsegment]);
}
/*++++++++++++++++++++++++++++++++++++++
Find the fake index of a fake segment.
index_t IndexFakeSegment Returns the fake segment.
Segment *fakesegmentp The fake segment to look for.
++++++++++++++++++++++++++++++++++++++*/
index_t IndexFakeSegment(Segment *fakesegmentp)
{
index_t whichsegment=fakesegmentp-&fake_segments[0];
return(whichsegment+SEGMENT_FAKE);
}
/*++++++++++++++++++++++++++++++++++++++
Find the real segment underlying a fake segment.
index_t IndexRealSegment Returns the index of the real segment.
index_t fakesegment The index of the fake segment.
++++++++++++++++++++++++++++++++++++++*/
index_t IndexRealSegment(index_t fakesegment)
{
index_t whichsegment=fakesegment-SEGMENT_FAKE;
return(real_segments[whichsegment]);
}
/*++++++++++++++++++++++++++++++++++++++
Determine if a route between two fake segments is valid or a U-turn.
int IsFakeUTurn Returns true for a U-turn.
index_t fakesegment1 The first fake segment.
index_t fakesegment2 The second fake segment.
++++++++++++++++++++++++++++++++++++++*/
int IsFakeUTurn(index_t fakesegment1,index_t fakesegment2)
{
index_t whichsegment1=fakesegment1-SEGMENT_FAKE;
index_t whichsegment2=fakesegment2-SEGMENT_FAKE;
if(fake_segments[whichsegment1].node1==fake_segments[whichsegment2].node1)
return(1);
if(fake_segments[whichsegment1].node2==fake_segments[whichsegment2].node2)
return(1);
return(0);
}
routino-2.4.1/src/nodes.c 644 233 144 44434 12063560526 10466 0 /***************************************
Node data type functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include "types.h"
#include "nodes.h"
#include "segments.h"
#include "ways.h"
#include "files.h"
#include "profiles.h"
/* Local functions */
static int valid_segment_for_profile(Ways *ways,Segment *segmentp,Profile *profile);
/*++++++++++++++++++++++++++++++++++++++
Load in a node list from a file.
Nodes *LoadNodeList Returns the node list.
const char *filename The name of the file to load.
++++++++++++++++++++++++++++++++++++++*/
Nodes *LoadNodeList(const char *filename)
{
Nodes *nodes;
#if SLIM
size_t sizeoffsets;
int i;
#endif
nodes=(Nodes*)malloc(sizeof(Nodes));
#if !SLIM
nodes->data=MapFile(filename);
/* Copy the NodesFile header structure from the loaded data */
nodes->file=*((NodesFile*)nodes->data);
/* Set the pointers in the Nodes structure. */
nodes->offsets=(index_t*)(nodes->data+sizeof(NodesFile));
nodes->nodes =(Node* )(nodes->data+sizeof(NodesFile)+(nodes->file.latbins*nodes->file.lonbins+1)*sizeof(index_t));
#else
nodes->fd=ReOpenFile(filename);
/* Copy the NodesFile header structure from the loaded data */
ReadFile(nodes->fd,&nodes->file,sizeof(NodesFile));
sizeoffsets=(nodes->file.latbins*nodes->file.lonbins+1)*sizeof(index_t);
nodes->offsets=(index_t*)malloc(sizeoffsets);
ReadFile(nodes->fd,nodes->offsets,sizeoffsets);
nodes->nodesoffset=sizeof(NodesFile)+sizeoffsets;
for(i=0;icached)/sizeof(nodes->cached[0]);i++)
nodes->incache[i]=NO_NODE;
#endif
return(nodes);
}
/*++++++++++++++++++++++++++++++++++++++
Find the closest node given its latitude, longitude and the profile of the
mode of transport that must be able to move to/from this node.
index_t FindClosestNode Returns the closest node.
Nodes *nodes The set of nodes to search.
Segments *segments The set of segments to use.
Ways *ways The set of ways to use.
double latitude The latitude to look for.
double longitude The longitude to look for.
distance_t distance The maximum distance to look from the specified coordinates.
Profile *profile The profile of the mode of transport.
distance_t *bestdist Returns the distance to the best node.
++++++++++++++++++++++++++++++++++++++*/
index_t FindClosestNode(Nodes *nodes,Segments *segments,Ways *ways,double latitude,double longitude,
distance_t distance,Profile *profile,distance_t *bestdist)
{
ll_bin_t latbin=latlong_to_bin(radians_to_latlong(latitude ))-nodes->file.latzero;
ll_bin_t lonbin=latlong_to_bin(radians_to_latlong(longitude))-nodes->file.lonzero;
int delta=0,count;
index_t i,index1,index2;
index_t bestn=NO_NODE;
distance_t bestd=INF_DISTANCE;
/* Start with the bin containing the location, then spiral outwards. */
do
{
ll_bin_t latb,lonb;
ll_bin2_t llbin;
count=0;
for(latb=latbin-delta;latb<=latbin+delta;latb++)
{
if(latb<0 || latb>=nodes->file.latbins)
continue;
for(lonb=lonbin-delta;lonb<=lonbin+delta;lonb++)
{
if(lonb<0 || lonb>=nodes->file.lonbins)
continue;
if(abs(latb-latbin)file.latbins+latb;
/* Check if this grid square has any hope of being close enough */
if(delta>0)
{
double lat1=latlong_to_radians(bin_to_latlong(nodes->file.latzero+latb));
double lon1=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonb));
double lat2=latlong_to_radians(bin_to_latlong(nodes->file.latzero+latb+1));
double lon2=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonb+1));
if(latb==latbin)
{
distance_t dist1=Distance(latitude,lon1,latitude,longitude);
distance_t dist2=Distance(latitude,lon2,latitude,longitude);
if(dist1>distance && dist2>distance)
continue;
}
else if(lonb==lonbin)
{
distance_t dist1=Distance(lat1,longitude,latitude,longitude);
distance_t dist2=Distance(lat2,longitude,latitude,longitude);
if(dist1>distance && dist2>distance)
continue;
}
else
{
distance_t dist1=Distance(lat1,lon1,latitude,longitude);
distance_t dist2=Distance(lat2,lon1,latitude,longitude);
distance_t dist3=Distance(lat2,lon2,latitude,longitude);
distance_t dist4=Distance(lat1,lon2,latitude,longitude);
if(dist1>distance && dist2>distance && dist3>distance && dist4>distance)
continue;
}
}
/* Check every node in this grid square. */
index1=LookupNodeOffset(nodes,llbin);
index2=LookupNodeOffset(nodes,llbin+1);
for(i=index1;ifile.latzero+latb)+off_to_latlong(nodep->latoffset));
double lon=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonb)+off_to_latlong(nodep->lonoffset));
distance_t dist=Distance(lat,lon,latitude,longitude);
if(distfile.latzero;
ll_bin_t lonbin=latlong_to_bin(radians_to_latlong(longitude))-nodes->file.lonzero;
int delta=0,count;
index_t i,index1,index2;
index_t bestn1=NO_NODE,bestn2=NO_NODE;
distance_t bestd=INF_DISTANCE,bestd1=INF_DISTANCE,bestd2=INF_DISTANCE;
index_t bests=NO_SEGMENT;
/* Start with the bin containing the location, then spiral outwards. */
do
{
ll_bin_t latb,lonb;
ll_bin2_t llbin;
count=0;
for(latb=latbin-delta;latb<=latbin+delta;latb++)
{
if(latb<0 || latb>=nodes->file.latbins)
continue;
for(lonb=lonbin-delta;lonb<=lonbin+delta;lonb++)
{
if(lonb<0 || lonb>=nodes->file.lonbins)
continue;
if(abs(latb-latbin)file.latbins+latb;
/* Check if this grid square has any hope of being close enough */
if(delta>0)
{
double lat1=latlong_to_radians(bin_to_latlong(nodes->file.latzero+latb));
double lon1=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonb));
double lat2=latlong_to_radians(bin_to_latlong(nodes->file.latzero+latb+1));
double lon2=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonb+1));
if(latb==latbin)
{
distance_t dist1=Distance(latitude,lon1,latitude,longitude);
distance_t dist2=Distance(latitude,lon2,latitude,longitude);
if(dist1>distance && dist2>distance)
continue;
}
else if(lonb==lonbin)
{
distance_t dist1=Distance(lat1,longitude,latitude,longitude);
distance_t dist2=Distance(lat2,longitude,latitude,longitude);
if(dist1>distance && dist2>distance)
continue;
}
else
{
distance_t dist1=Distance(lat1,lon1,latitude,longitude);
distance_t dist2=Distance(lat2,lon1,latitude,longitude);
distance_t dist3=Distance(lat2,lon2,latitude,longitude);
distance_t dist4=Distance(lat1,lon2,latitude,longitude);
if(dist1>distance && dist2>distance && dist3>distance && dist4>distance)
continue;
}
}
/* Check every node in this grid square. */
index1=LookupNodeOffset(nodes,llbin);
index2=LookupNodeOffset(nodes,llbin+1);
for(i=index1;ifile.latzero+latb)+off_to_latlong(nodep->latoffset));
double lon1=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonb)+off_to_latlong(nodep->lonoffset));
distance_t dist1;
dist1=Distance(lat1,lon1,latitude,longitude);
if(dist1=0 && dist3b>=0)
distp=sqrt((double)dist1*(double)dist1-dist3a*dist3a);
else if(dist3a>0)
{
distp=dist2;
dist3a=dist3;
dist3b=0;
}
else /* if(dist3b>0) */
{
distp=dist1;
dist3a=0;
dist3b=dist3;
}
if(distp<(double)bestd)
{
bests=IndexSegment(segments,segmentp);
if(segmentp->node1==i)
{
bestn1=i;
bestn2=OtherNode(segmentp,i);
bestd1=(distance_t)dist3a;
bestd2=(distance_t)dist3b;
}
else
{
bestn1=OtherNode(segmentp,i);
bestn2=i;
bestd1=(distance_t)dist3b;
bestd2=(distance_t)dist3a;
}
bestd=(distance_t)distp;
}
}
segmentp=NextSegment(segments,segmentp,i);
}
while(segmentp);
}
} /* dist1 < distance */
count++;
}
}
delta++;
}
while(count);
*bestdist=bestd;
*bestnode1=bestn1;
*bestnode2=bestn2;
*bestdist1=bestd1;
*bestdist2=bestd2;
return(bests);
}
/*++++++++++++++++++++++++++++++++++++++
Check if the transport defined by the profile is allowed on the segment.
int valid_segment_for_profile Return 1 if it is or 0 if not.
Ways *ways The set of ways to use.
Segment *segmentp The segment to check.
Profile *profile The profile to check.
++++++++++++++++++++++++++++++++++++++*/
static int valid_segment_for_profile(Ways *ways,Segment *segmentp,Profile *profile)
{
Way *wayp=LookupWay(ways,segmentp->way,1);
score_t segment_pref;
int i;
/* mode of transport must be allowed on the highway */
if(!(wayp->allow&profile->allow))
return(0);
/* must obey weight restriction (if exists) */
if(wayp->weight && wayp->weightweight)
return(0);
/* must obey height/width/length restriction (if exists) */
if((wayp->height && wayp->heightheight) ||
(wayp->width && wayp->width width ) ||
(wayp->length && wayp->lengthlength))
return(0);
segment_pref=profile->highway[HIGHWAY(wayp->type)];
for(i=1;ifile.props & PROPERTIES(i))
{
if(wayp->props & PROPERTIES(i))
segment_pref*=profile->props_yes[i];
else
segment_pref*=profile->props_no[i];
}
/* profile preferences must allow this highway */
if(segment_pref==0)
return(0);
/* Must be OK */
return(1);
}
/*++++++++++++++++++++++++++++++++++++++
Get the latitude and longitude associated with a node.
Nodes *nodes The set of nodes to use.
index_t index The node index.
double *latitude Returns the latitude.
double *longitude Returns the logitude.
++++++++++++++++++++++++++++++++++++++*/
void GetLatLong(Nodes *nodes,index_t index,double *latitude,double *longitude)
{
Node *nodep=LookupNode(nodes,index,4);
ll_bin_t latbin=-1,lonbin=-1;
ll_bin_t start,end,mid;
index_t offset;
/* Binary search - search key nearest match below is required.
*
* # <- start | Check mid and move start or end if it doesn't match
* # |
* # | A lower bound match is wanted we can set end=mid-1 or
* # <- mid | start=mid because we know that mid doesn't match.
* # |
* # | Eventually either end=start or end=start+1 and one of
* # <- end | start or end is the wanted one.
*/
/* Search for longitude */
start=0;
end=nodes->file.lonbins-1;
do
{
mid=(start+end)/2; /* Choose mid point */
offset=LookupNodeOffset(nodes,nodes->file.latbins*mid);
if(offsetindex) /* Mid point is too high */
end=mid?(mid-1):mid;
else /* Mid point is correct */
{lonbin=mid;break;}
}
while((end-start)>1);
if(lonbin==-1)
{
offset=LookupNodeOffset(nodes,nodes->file.latbins*end);
if(offset>index)
lonbin=start;
else
lonbin=end;
}
while(lonbinfile.lonbins &&
LookupNodeOffset(nodes,lonbin*nodes->file.latbins)==LookupNodeOffset(nodes,(lonbin+1)*nodes->file.latbins))
lonbin++;
/* Search for latitude */
start=0;
end=nodes->file.latbins-1;
do
{
mid=(start+end)/2; /* Choose mid point */
offset=LookupNodeOffset(nodes,lonbin*nodes->file.latbins+mid);
if(offsetindex) /* Mid point is too high */
end=mid?(mid-1):mid;
else /* Mid point is correct */
{latbin=mid;break;}
}
while((end-start)>1);
if(latbin==-1)
{
offset=LookupNodeOffset(nodes,lonbin*nodes->file.latbins+end);
if(offset>index)
latbin=start;
else
latbin=end;
}
while(latbinfile.latbins &&
LookupNodeOffset(nodes,lonbin*nodes->file.latbins+latbin)==LookupNodeOffset(nodes,lonbin*nodes->file.latbins+latbin+1))
latbin++;
/* Return the values */
*latitude =latlong_to_radians(bin_to_latlong(nodes->file.latzero+latbin)+off_to_latlong(nodep->latoffset));
*longitude=latlong_to_radians(bin_to_latlong(nodes->file.lonzero+lonbin)+off_to_latlong(nodep->lonoffset));
}
routino-2.4.1/src/logging.h 644 233 144 5051 12063560526 10761 0 /***************************************
Header file for logging function prototypes
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef LOGGING_H
#define LOGGING_H /*+ To stop multiple inclusions. +*/
#include
#include
/* Variables */
extern int option_loggable;
extern int option_logtime;
/* Runtime progress logging functions in logging.c */
#ifdef __GNUC__
void printf_first(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
void printf_middle(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
void printf_last(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
void fprintf_first(FILE *file,const char *format, ...) __attribute__ ((format (printf, 2, 3)));
void fprintf_middle(FILE *file,const char *format, ...) __attribute__ ((format (printf, 2, 3)));
void fprintf_last(FILE *file,const char *format, ...) __attribute__ ((format (printf, 2, 3)));
#else
void printf_first(const char *format, ...);
void printf_middle(const char *format, ...);
void printf_last(const char *format, ...);
void fprintf_first(FILE *file,const char *format, ...);
void fprintf_middle(FILE *file,const char *format, ...);
void fprintf_last(FILE *file,const char *format, ...);
#endif
void fprintf_elapsed_time(FILE *file,struct timeval *start);
/* Parsing/processing error logging functions in logging.c */
void open_errorlog(const char *filename,int append);
void close_errorlog(void);
#ifdef __GNUC__
void logerror(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
#else
void logerror(const char *format, ...);
#endif
/* Runtime fatal error assertion */
#define logassert(xx,yy) do{ if(!(xx)) _logassert(yy,__FILE__,__LINE__); } while(0);
void _logassert(const char *message,const char *file,int line);
#endif /* LOGGING_H */
routino-2.4.1/src/queue.c 644 233 144 11241 12063560526 10470 0 /***************************************
Queue data type functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include "results.h"
/*+ The size of the increment to the allocated memory. +*/
#define QUEUE_INCREMENT 1024
/*+ A queue of results. +*/
struct _Queue
{
int nallocated; /*+ The number of entries allocated. +*/
int noccupied; /*+ The number of entries occupied. +*/
Result **data; /*+ The queue of pointers to results. +*/
};
/*++++++++++++++++++++++++++++++++++++++
Allocate a new queue.
Queue *NewQueueList Returns the queue.
++++++++++++++++++++++++++++++++++++++*/
Queue *NewQueueList(void)
{
Queue *queue;
queue=(Queue*)malloc(sizeof(Queue));
queue->nallocated=QUEUE_INCREMENT;
queue->noccupied=0;
queue->data=(Result**)malloc(queue->nallocated*sizeof(Result*));
return(queue);
}
/*++++++++++++++++++++++++++++++++++++++
Free a queue.
Queue *queue The queue to be freed.
++++++++++++++++++++++++++++++++++++++*/
void FreeQueueList(Queue *queue)
{
free(queue->data);
free(queue);
}
/*++++++++++++++++++++++++++++++++++++++
Insert a new item into the queue in the right place.
The data is stored in a "Binary Heap" http://en.wikipedia.org/wiki/Binary_heap
and this operation is adding an item to the heap.
Queue *queue The queue to insert the result into.
Result *result The result to insert into the queue.
++++++++++++++++++++++++++++++++++++++*/
void InsertInQueue(Queue *queue,Result *result)
{
int index;
if(result->queued==NOT_QUEUED)
{
queue->noccupied++;
index=queue->noccupied;
if(queue->noccupied==queue->nallocated)
{
queue->nallocated=queue->nallocated+QUEUE_INCREMENT;
queue->data=(Result**)realloc((void*)queue->data,queue->nallocated*sizeof(Result*));
}
queue->data[index]=result;
queue->data[index]->queued=index;
}
else
{
index=result->queued;
}
/* Bubble up the new value */
while(index>1 &&
queue->data[index]->sortbydata[index/2]->sortby)
{
int newindex;
Result *temp;
newindex=index/2;
temp=queue->data[index];
queue->data[index]=queue->data[newindex];
queue->data[newindex]=temp;
queue->data[index]->queued=index;
queue->data[newindex]->queued=newindex;
index=newindex;
}
}
/*++++++++++++++++++++++++++++++++++++++
Pop an item from the front of the queue.
The data is stored in a "Binary Heap" http://en.wikipedia.org/wiki/Binary_heap
and this operation is deleting the root item from the heap.
Result *PopFromQueue Returns the top item.
Queue *queue The queue to remove the result from.
++++++++++++++++++++++++++++++++++++++*/
Result *PopFromQueue(Queue *queue)
{
int index;
Result *retval;
if(queue->noccupied==0)
return(NULL);
retval=queue->data[1];
retval->queued=NOT_QUEUED;
index=1;
queue->data[index]=queue->data[queue->noccupied];
queue->noccupied--;
/* Bubble down the newly promoted value */
while((2*index)noccupied &&
(queue->data[index]->sortby>queue->data[2*index ]->sortby ||
queue->data[index]->sortby>queue->data[2*index+1]->sortby))
{
int newindex;
Result *temp;
if(queue->data[2*index]->sortbydata[2*index+1]->sortby)
newindex=2*index;
else
newindex=2*index+1;
temp=queue->data[newindex];
queue->data[newindex]=queue->data[index];
queue->data[index]=temp;
queue->data[index]->queued=index;
queue->data[newindex]->queued=newindex;
index=newindex;
}
if((2*index)==queue->noccupied &&
queue->data[index]->sortby>queue->data[2*index]->sortby)
{
int newindex;
Result *temp;
newindex=2*index;
temp=queue->data[newindex];
queue->data[newindex]=queue->data[index];
queue->data[index]=temp;
queue->data[index]->queued=index;
queue->data[newindex]->queued=newindex;
}
return(retval);
}
routino-2.4.1/src/translations.h 644 233 144 4553 12063560526 12062 0 /***************************************
Load the translations from a file and the functions for handling them.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2010-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#ifndef TRANSLATIONS_H
#define TRANSLATIONS_H /*+ To stop multiple inclusions. +*/
#include "types.h"
/* Global variable declarations */
extern char *translate_raw_copyright_creator[2];
extern char *translate_raw_copyright_source[2];
extern char *translate_raw_copyright_license[2];
extern char *translate_xml_copyright_creator[2];
extern char *translate_xml_copyright_source[2];
extern char *translate_xml_copyright_license[2];
extern char *translate_xml_heading[9];
extern char *translate_xml_turn[9];
extern char *translate_xml_ordinal[10];
extern char *translate_raw_highway[Highway_Count];
extern char *translate_xml_route_shortest;
extern char *translate_xml_route_quickest;
extern char *translate_html_waypoint;
extern char *translate_html_junction;
extern char *translate_html_roundabout;
extern char *translate_html_title;
extern char *translate_html_start[2];
extern char *translate_html_segment[2];
extern char *translate_html_node[2];
extern char *translate_html_rbnode[2];
extern char *translate_html_stop[2];
extern char *translate_html_total[2];
extern char *translate_gpx_desc;
extern char *translate_gpx_name;
extern char *translate_gpx_step;
extern char *translate_gpx_final;
extern char *translate_gpx_start;
extern char *translate_gpx_inter;
extern char *translate_gpx_trip;
extern char *translate_gpx_finish;
/* Functions in translations.c */
int ParseXMLTranslations(const char *filename,const char *language);
#endif /* TRANSLATIONS_H */
routino-2.4.1/src/test/ 40755 233 144 0 12063560525 10123 5 routino-2.4.1/src/test/oneway-loop.sh 777 233 144 0 12063560525 15766 2start-1-finish.sh routino-2.4.1/src/test/waypoints.pl 755 233 144 1761 12063560525 12541 0 #!/usr/bin/perl
# Command line
if($#ARGV<1 || $ARGV>2 || ! -f $ARGV[0])
{
die "Usage: waypoints.pl list\n".
" waypoints.pl \n";
}
# Parse the file
open(FILE,"<$ARGV[0]") || die "Cannot open '$ARGV[0]'\n";
%waypoints=();
@waypoints=();
@waypoint_lat=();
@waypoint_lon=();
$innode=0;
while()
{
if($innode)
{
if(m%%);
}
elsif(m%%)
{
$innode=1;
push(@waypoint_lat,$1);
push(@waypoint_lon,$2);
}
}
close(FILE);
# Perform the action
if($ARGV[1] eq "list")
{
print join(" ",sort @waypoints)."\n";
exit 0;
}
if($waypoints{$ARGV[1]} ne "")
{
print "--lat$ARGV[2]=$waypoint_lat[$waypoints{$ARGV[1]}] --lon$ARGV[2]=$waypoint_lon[$waypoints{$ARGV[1]}]\n";
exit 0;
}
exit 1;
routino-2.4.1/src/test/dead-ends.osm 644 233 144 16762 12063560525 12537 0
routino-2.4.1/src/test/oneway-loop.osm 644 233 144 10301 12063560525 13143 0
routino-2.4.1/src/test/no-super.osm 644 233 144 11616 12063560525 12454 0
routino-2.4.1/src/test/only-split.sh 755 233 144 2255 12063560525 12614 0 #!/bin/sh
# Exit on error
set -e
# Test name
name=`basename $0 .sh`
# Slim or non-slim
if [ "$1" = "slim" ]; then
slim="-slim"
dir="slim"
else
slim=""
dir="fat"
fi
# Pruned or non-pruned
if [ "$2" = "prune" ]; then
prune=""
pruned="-pruned"
else
prune="--prune-none"
pruned=""
fi
# Create the output directory
dir="$dir$pruned"
[ -d $dir ] || mkdir $dir
# Run the programs under a run-time debugger
debugger=valgrind
debugger=
# Name related options
osm=$name.osm
log=$name$slim$pruned.log
option_prefix="--prefix=$name"
option_dir="--dir=$dir"
# Generic program options
option_planetsplitter="--loggable --tagging=../../xml/routino-tagging.xml --errorlog $prune"
option_filedumper="--dump-osm"
# Run planetsplitter
echo "Running planetsplitter"
echo ../planetsplitter$slim $option_dir $option_prefix $option_planetsplitter $osm > $log
$debugger ../planetsplitter$slim $option_dir $option_prefix $option_planetsplitter $osm >> $log
# Run filedumper
echo "Running filedumper"
echo ../filedumper$slim $option_dir $option_prefix $option_filedumper >> $log
$debugger ../filedumper$slim $option_dir $option_prefix $option_filedumper > $dir/$osm
routino-2.4.1/src/test/turns.osm 644 233 144 43517 12063560525 12064 0
routino-2.4.1/src/test/turns.sh 777 233 144 0 12063560525 14670 2start-1-finish.sh routino-2.4.1/src/test/invalid-turn-relations.osm 644 233 144 22476 12063560525 15324 0
routino-2.4.1/src/test/loops.sh 777 233 144 0 12063560525 14651 2start-1-finish.sh routino-2.4.1/src/test/Makefile 644 233 144 6033 12063560525 11601 0 # Test cases Makefile
#
# Part of the Routino routing software.
#
# This file Copyright 2011-2012 Andrew M. Bishop
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see .
#
# Routino executables
EXE=../planetsplitter ../planetsplitter-slim \
../router ../router-slim \
../filedumper ../filedumper-slim
# Compilation targets
O=$(notdir $(wildcard *.osm))
S=$(foreach f,$(O),$(addsuffix .sh,$(basename $f)))
########
all :
@true
########
exe :
cd .. && $(MAKE)
########
test : exe
@status=true ;\
for script in $(S); do \
echo "" ;\
echo "Testing: $$script (non-slim, no pruning) ... " ;\
if ./$$script fat; then echo "... passed"; else echo "... FAILED"; status=false; fi ;\
done ;\
for script in $(S); do \
echo "" ;\
echo "Testing: $$script (slim, no pruning) ... " ;\
if ./$$script slim; then echo "... passed"; else echo "... FAILED"; status=false; fi ;\
done ;\
echo "" ;\
if $$status; then echo "Success: all tests passed"; else echo "Warning: Some tests FAILED"; fi ;\
$$status || exit 1 ;\
echo "" ;\
echo "Comparing: slim and non-slim results ... " ;\
if diff -q -r slim fat; then echo "... matched"; else echo "... match FAILED"; status=false; fi ;\
echo "" ;\
if $$status; then echo "Success: slim and non-slim results match"; else echo "Warning: slim and non-slim results are different - FAILED"; fi ;\
for script in $(S); do \
echo "" ;\
echo "Testing: $$script (non-slim, pruning) ... " ;\
if ./$$script fat prune; then echo "... passed"; else echo "... FAILED"; status=false; fi ;\
done ;\
for script in $(S); do \
echo "" ;\
echo "Testing: $$script (slim, pruning) ... " ;\
if ./$$script slim prune; then echo "... passed"; else echo "... FAILED"; status=false; fi ;\
done ;\
echo "" ;\
if $$status; then echo "Success: all tests passed"; else echo "Warning: Some tests FAILED"; fi ;\
$$status || exit 1 ;\
echo "" ;\
echo "Comparing: slim and non-slim results ... " ;\
if diff -q -r slim-pruned fat-pruned; then echo "... matched"; else echo "... match FAILED"; status=false; fi ;\
echo "" ;\
if $$status; then echo "Success: slim and non-slim results match"; else echo "Warning: slim and non-slim results are different - FAILED"; fi ;\
$$status
########
clean:
rm -rf fat
rm -rf slim
rm -rf fat-pruned
rm -rf slim-pruned
rm -f *.log
rm -f *~
rm -f core
rm -f *.gcda *.gcno *.gcov gmon.out
########
distclean: clean
@true
########
.PHONY:: all test install clean distclean
routino-2.4.1/src/test/node-restrictions.sh 777 233 144 0 12063560525 17170 2start-1-finish.sh routino-2.4.1/src/test/copyright.xml 644 233 144 2363 12063560525 12675 0
routino-2.4.1/src/test/super-or-not.osm 644 233 144 4757 12063560525 13246 0
routino-2.4.1/src/test/node-restrictions.osm 644 233 144 16654 12063560525 14366 0
routino-2.4.1/src/test/super-or-not.sh 777 233 144 0 12063560525 13755 2a-b.sh routino-2.4.1/src/test/loops.osm 644 233 144 16247 12063560525 12045 0
routino-2.4.1/src/test/dead-ends.sh 777 233 144 0 12063560525 15341 2start-1-finish.sh routino-2.4.1/src/test/a-b.sh 755 233 144 4330 12063560525 11135 0 #!/bin/sh
# Exit on error
set -e
# Test name
name=`basename $0 .sh`
# Slim or non-slim
if [ "$1" = "slim" ]; then
slim="-slim"
dir="slim"
else
slim=""
dir="fat"
fi
# Pruned or non-pruned
if [ "$2" = "prune" ]; then
prune=""
pruned="-pruned"
else
prune="--prune-none"
pruned=""
fi
# Create the output directory
dir="$dir$pruned"
[ -d $dir ] || mkdir $dir
# Run the programs under a run-time debugger
debugger=valgrind
debugger=
# Name related options
osm=$name.osm
log=$name$slim$pruned.log
option_prefix="--prefix=$name"
option_dir="--dir=$dir"
# Generic program options
option_planetsplitter="--loggable --tagging=../../xml/routino-tagging.xml --errorlog $prune"
option_filedumper="--dump-osm"
option_router="--loggable --transport=motorcar --profiles=../../xml/routino-profiles.xml --translations=copyright.xml"
# Run planetsplitter
echo "Running planetsplitter"
echo ../planetsplitter$slim $option_dir $option_prefix $option_planetsplitter $osm > $log
$debugger ../planetsplitter$slim $option_dir $option_prefix $option_planetsplitter $osm >> $log
# Run filedumper
echo "Running filedumper"
echo ../filedumper$slim $option_dir $option_prefix $option_filedumper >> $log
$debugger ../filedumper$slim $option_dir $option_prefix $option_filedumper > $dir/$osm
# Waypoints
waypoints=`perl waypoints.pl $osm list`
# Run the router for each waypoint
for waypoint in $waypoints; do
case $waypoint in
*a) waypoint=`echo $waypoint | sed -e 's%a$%%'` ;;
*) continue ;;
esac
echo "Running router : $waypoint"
waypoint_a=`perl waypoints.pl $osm ${waypoint}a 1`
waypoint_b=`perl waypoints.pl $osm ${waypoint}b 2`
[ -d $dir/$name-$waypoint ] || mkdir $dir/$name-$waypoint
echo ../router$slim $option_dir $option_prefix $option_osm $option_router $waypoint_a $waypoint_b >> $log
$debugger ../router$slim $option_dir $option_prefix $option_osm $option_router $waypoint_a $waypoint_b >> $log
mv shortest* $dir/$name-$waypoint
if [ "$pruned" = "" ]; then
echo diff -u expected/$name-$waypoint.txt $dir/$name-$waypoint/shortest-all.txt >> $log
diff -u expected/$name-$waypoint.txt $dir/$name-$waypoint/shortest-all.txt >> $log
fi
done
routino-2.4.1/src/test/expected/ 40755 233 144 0 12063560525 11724 5 routino-2.4.1/src/test/expected/dead-ends-WP03.txt 644 233 144 3017 12063560525 15015 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220263 -0.519309 14* Junct- 0.052 0.07 0.35 0.4 48 21 dead-end 1
-0.219924 -0.519179 15 Inter 0.040 0.05 0.39 0.4 48 20 dead-end 1
-0.219567 -0.519373 -2 Waypt 0.045 0.06 0.44 0.5 48 331 dead-end 1
-0.219924 -0.519179 15 Inter 0.045 0.06 0.48 0.5 48 151 dead-end 1
-0.220263 -0.519309 14* Junct- 0.040 0.05 0.52 0.6 48 200 dead-end 1
-0.220702 -0.519478 12* Junct 0.052 0.07 0.57 0.6 48 201 dead-end 1
-0.220739 -0.517804 19* Junct 0.186 0.23 0.76 0.9 48 91 high street
-0.220782 -0.516137 25* Junct 0.185 0.23 0.95 1.1 48 91 high street
-0.220817 -0.514062 33* Junct 0.230 0.29 1.18 1.4 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.23 1.4 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.32 1.5 96 2 main 2
routino-2.4.1/src/test/expected/node-restrictions-WP01.txt 644 233 144 3420 12063560525 16640 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220682 -0.520141 9* Junct 0.083 0.08 0.20 0.2 64 91 high street
-0.220695 -0.519489 12* Change 0.072 0.07 0.28 0.2 64 91 high street
-0.221123 -0.519360 13 Inter 0.049 0.06 0.33 0.3 48 163 somepass road
-0.221156 -0.518615 19* Waypt 0.082 0.10 0.41 0.4 48 92 somepass road
-0.221123 -0.519360 13 Inter 0.082 0.10 0.49 0.5 48 272 somepass road
-0.220695 -0.519489 12* Junct 0.049 0.06 0.54 0.5 48 343 somepass road
-0.220694 -0.519227 15 Inter 0.029 0.04 0.57 0.6 48 89 long road
-0.220386 -0.519076 16 Inter 0.038 0.05 0.61 0.6 48 26 long road
-0.220961 -0.518928 17 Inter 0.066 0.08 0.67 0.7 48 165 long road
-0.220427 -0.518622 18 Inter 0.068 0.09 0.74 0.8 48 29 long road
-0.220949 -0.518422 21 Inter 0.062 0.08 0.80 0.9 48 159 long road
-0.220455 -0.518238 22 Inter 0.058 0.07 0.86 0.9 48 20 long road
-0.220746 -0.518070 23 Inter 0.037 0.04 0.90 1.0 48 149 long road
-0.220739 -0.517801 26* Junct 0.029 0.04 0.93 1.0 48 88 long road
-0.220784 -0.516035 31* Junct 0.196 0.18 1.12 1.2 64 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.25 1.3 96 2 main 2
routino-2.4.1/src/test/expected/no-super-WP03.txt 644 233 144 1541 12063560525 14741 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.217185 -0.519054 5 Waypt 0.000 0.00 0.00 0.0
-0.217382 -0.518273 8 Inter 0.089 0.11 0.09 0.1 48 104 road3
-0.217219 -0.517733 11 Inter 0.062 0.08 0.15 0.2 48 73 road3
-0.217399 -0.516857 14 Inter 0.099 0.12 0.25 0.3 48 101 road3
-0.217202 -0.515964 17 Waypt 0.101 0.12 0.35 0.4 48 77 road3
-0.217399 -0.516857 14 Inter 0.101 0.12 0.45 0.6 48 257 road3
-0.217219 -0.517733 11 Waypt 0.099 0.12 0.55 0.7 48 281 road3
routino-2.4.1/src/test/expected/node-restrictions-WP08.txt 644 233 144 3144 12063560525 16652 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220682 -0.520141 9* Junct 0.083 0.08 0.20 0.2 64 91 high street
-0.219054 -0.520077 -2 Waypt 0.180 0.17 0.39 0.3 64 2 dead end road
-0.220682 -0.520141 9* Junct 0.180 0.17 0.56 0.5 64 182 dead end road
-0.220695 -0.519489 12* Change 0.072 0.07 0.64 0.6 64 91 high street
-0.220694 -0.519227 15 Inter 0.029 0.04 0.67 0.6 48 89 long road
-0.220386 -0.519076 16 Inter 0.038 0.05 0.70 0.6 48 26 long road
-0.220961 -0.518928 17 Inter 0.066 0.08 0.77 0.7 48 165 long road
-0.220427 -0.518622 18 Inter 0.068 0.09 0.84 0.8 48 29 long road
-0.220949 -0.518422 21 Inter 0.062 0.08 0.90 0.9 48 159 long road
-0.220455 -0.518238 22 Inter 0.058 0.07 0.96 1.0 48 20 long road
-0.220746 -0.518070 23 Inter 0.037 0.04 0.99 1.0 48 149 long road
-0.220739 -0.517801 26* Junct 0.029 0.04 1.02 1.0 48 88 long road
-0.220784 -0.516035 31* Junct 0.196 0.18 1.22 1.2 64 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.35 1.3 96 2 main 2
routino-2.4.1/src/test/expected/dead-ends-WP04.txt 644 233 144 3533 12063560525 15021 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220263 -0.519309 14* Junct- 0.052 0.07 0.35 0.4 48 21 dead-end 1
-0.219924 -0.519179 15 Inter 0.040 0.05 0.39 0.4 48 20 dead-end 1
-0.219235 -0.519555 11 Inter 0.087 0.11 0.48 0.5 48 331 dead-end 1
-0.218878 -0.519379 13 Inter 0.044 0.06 0.52 0.6 48 26 dead-end 1
-0.218387 -0.519137 16 Waypt 0.060 0.07 0.58 0.7 48 26 dead-end 1
-0.218878 -0.519379 13 Inter 0.060 0.07 0.64 0.7 48 206 dead-end 1
-0.219235 -0.519555 11 Inter 0.044 0.06 0.69 0.8 48 206 dead-end 1
-0.219924 -0.519179 15 Inter 0.087 0.11 0.78 0.9 48 151 dead-end 1
-0.220263 -0.519309 14* Junct- 0.040 0.05 0.81 0.9 48 200 dead-end 1
-0.220702 -0.519478 12* Junct 0.052 0.07 0.87 1.0 48 201 dead-end 1
-0.220739 -0.517804 19* Junct 0.186 0.23 1.05 1.2 48 91 high street
-0.220782 -0.516137 25* Junct 0.185 0.23 1.24 1.5 48 91 high street
-0.220817 -0.514062 33* Junct 0.230 0.29 1.47 1.8 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.52 1.8 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.61 1.8 96 2 main 2
routino-2.4.1/src/test/expected/turns-WP13.txt 644 233 144 6651 12063560525 14354 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 0.54 0.6 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 0.56 0.6 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 0.58 0.7 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 0.59 0.7 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 0.61 0.7 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 0.65 0.8 48 269 top road
-0.218619 -0.517921 32* Inter 0.067 0.08 0.72 0.8 48 330 loop 5
-0.218431 -0.518243 28 Inter 0.041 0.05 0.76 0.9 48 300 loop 5
-0.218600 -0.518557 25* Inter 0.039 0.05 0.80 0.9 48 241 loop 5
-0.218691 -0.518602 -2 Waypt 0.011 0.01 0.81 1.0 48 206 loop 5
-0.219135 -0.518823 23* Junct 0.054 0.07 0.86 1.0 48 206 loop 5
-0.219145 -0.517626 33* Junct 0.133 0.17 1.00 1.2 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 1.04 1.2 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 1.05 1.3 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 1.07 1.3 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 1.09 1.3 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 1.11 1.3 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 1.13 1.3 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 1.15 1.4 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 1.16 1.4 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 1.18 1.4 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 1.22 1.5 48 269 top road
-0.219135 -0.518823 23* Junct 0.133 0.17 1.35 1.6 48 270 top road
-0.219131 -0.519426 20* Junct 0.067 0.08 1.42 1.7 48 270 top road
-0.219123 -0.520207 12* Junct 0.086 0.11 1.51 1.8 48 270 top road
-0.219107 -0.520828 6* Junct 0.069 0.09 1.58 1.9 48 271 top road
-0.220666 -0.520893 5* Junct- 0.173 0.11 1.75 2.0 96 182 main 1
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.82 2.0 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.85 2.1 96 181 main 1
routino-2.4.1/src/test/expected/turns-WP06.txt 644 233 144 3642 12063560525 14353 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct- 0.072 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 5* Junct 0.173 0.11 0.24 0.2 96 182 main 1
-0.220671 -0.520223 11* Junct 0.074 0.09 0.32 0.2 48 90 high street
-0.220691 -0.519461 19* Junct 0.084 0.10 0.40 0.3 48 91 high street
-0.220708 -0.518842 22* Junct 0.069 0.09 0.47 0.4 48 91 high street
-0.220724 -0.518071 31* Junct 0.085 0.10 0.56 0.5 48 91 high street
-0.220143 -0.518162 30 Inter 0.065 0.08 0.62 0.6 48 351 loop 2
-0.219850 -0.518416 27 Waypt 0.043 0.05 0.67 0.7 48 319 loop 2
-0.220100 -0.518718 24* Inter 0.043 0.05 0.71 0.7 48 230 loop 2
-0.220708 -0.518842 22* Junct 0.069 0.09 0.78 0.8 48 191 loop 2
-0.220724 -0.518071 31* Junct 0.085 0.10 0.86 0.9 48 91 high street
-0.220739 -0.517425 34* Junct 0.071 0.09 0.93 1.0 48 91 high street
-0.220760 -0.516647 48* Junct 0.086 0.11 1.02 1.1 48 91 high street
-0.220784 -0.516035 54* Junct 0.068 0.09 1.09 1.2 48 92 high street
-0.221431 -0.516056 53* Junct 0.072 0.04 1.16 1.2 96 181 main 2
-0.221376 -0.518235 29* Junct 0.242 0.30 1.40 1.5 48 271 bottom road
-0.221360 -0.518860 21* Junct 0.069 0.09 1.47 1.6 48 271 bottom road
-0.221308 -0.520914 4* Junct 0.228 0.28 1.70 1.9 48 271 bottom road
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.73 1.9 96 181 main 1
routino-2.4.1/src/test/expected/turns-WP12.txt 644 233 144 4573 12063560525 14354 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 0.54 0.6 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 0.56 0.6 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 0.58 0.7 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 0.59 0.7 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 0.61 0.7 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 0.65 0.8 48 269 top road
-0.219135 -0.518823 23* Junct 0.133 0.17 0.79 0.9 48 270 top road
-0.219131 -0.519426 20* Junct 0.067 0.08 0.85 1.0 48 270 top road
-0.218482 -0.519542 18* Inter 0.073 0.09 0.93 1.1 48 349 loop 4
-0.218258 -0.519789 16 Waypt 0.037 0.04 0.96 1.1 48 312 loop 4
-0.218474 -0.520060 14* Inter 0.038 0.05 1.00 1.2 48 231 loop 4
-0.219123 -0.520207 12* Junct 0.074 0.09 1.07 1.3 48 192 loop 4
-0.219107 -0.520828 6* Junct 0.069 0.09 1.14 1.4 48 271 top road
-0.220666 -0.520893 5* Junct- 0.173 0.11 1.32 1.5 96 182 main 1
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.39 1.5 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.41 1.5 96 181 main 1
routino-2.4.1/src/test/expected/node-restrictions-WP05.txt 644 233 144 3410 12063560525 16643 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220682 -0.520141 9* Junct 0.083 0.08 0.20 0.2 64 91 high street
-0.220695 -0.519489 12* Change 0.072 0.07 0.28 0.2 64 91 high street
-0.220140 -0.519342 14 Inter 0.063 0.08 0.34 0.3 48 14 nopass road
-0.220170 -0.518653 -2 Waypt 0.075 0.09 0.41 0.4 48 92 nopass road
-0.220140 -0.519342 14 Inter 0.075 0.09 0.49 0.5 48 272 nopass road
-0.220695 -0.519489 12* Junct 0.063 0.08 0.55 0.6 48 194 nopass road
-0.220694 -0.519227 15 Inter 0.029 0.04 0.58 0.6 48 89 long road
-0.220386 -0.519076 16 Inter 0.038 0.05 0.62 0.6 48 26 long road
-0.220961 -0.518928 17 Inter 0.066 0.08 0.69 0.7 48 165 long road
-0.220427 -0.518622 18 Inter 0.068 0.09 0.75 0.8 48 29 long road
-0.220949 -0.518422 21 Inter 0.062 0.08 0.82 0.9 48 159 long road
-0.220455 -0.518238 22 Inter 0.058 0.07 0.87 1.0 48 20 long road
-0.220746 -0.518070 23 Inter 0.037 0.04 0.91 1.0 48 149 long road
-0.220739 -0.517801 26* Junct 0.029 0.04 0.94 1.0 48 88 long road
-0.220784 -0.516035 31* Junct 0.196 0.18 1.14 1.2 64 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.27 1.3 96 2 main 2
routino-2.4.1/src/test/expected/loops-WP01.txt 644 233 144 3216 12063560525 14324 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220280 -0.519256 15* Waypt 0.052 0.07 0.33 0.3 48 29 loop 1
-0.219910 -0.519112 17 Inter 0.044 0.06 0.37 0.4 48 21 loop 1
-0.219237 -0.519286 13* Junct 0.077 0.10 0.45 0.5 48 345 loop 1
-0.218764 -0.519471 12 Inter 0.056 0.07 0.51 0.6 48 338 loop 1
-0.218380 -0.519134 16 Inter 0.056 0.07 0.56 0.6 48 41 loop 1
-0.218776 -0.518838 18 Inter 0.055 0.07 0.62 0.7 48 143 loop 1
-0.219237 -0.519286 13* Junct 0.071 0.09 0.69 0.8 48 224 loop 1
-0.219910 -0.519112 17 Inter 0.077 0.10 0.77 0.9 48 165 loop 1
-0.220695 -0.519489 11* Junct 0.052 0.07 0.82 0.9 48 209 loop 1
-0.220739 -0.517801 19* Junct 0.187 0.23 1.00 1.2 48 91 high street
-0.220784 -0.516035 30* Junct 0.196 0.24 1.20 1.4 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.25 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.33 1.5 96 2 main 2
routino-2.4.1/src/test/expected/turns-WP14.txt 644 233 144 6532 12063560525 14353 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 0.54 0.6 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 0.56 0.6 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 0.58 0.7 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 0.59 0.7 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 0.61 0.7 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 0.65 0.8 48 269 top road
-0.218619 -0.517921 32* Inter 0.067 0.08 0.72 0.8 48 330 loop 5
-0.218431 -0.518243 28 Inter 0.041 0.05 0.76 0.9 48 300 loop 5
-0.218600 -0.518557 25* Waypt 0.039 0.05 0.80 0.9 48 241 loop 5
-0.219135 -0.518823 23* Junct 0.066 0.08 0.86 1.0 48 206 loop 5
-0.219145 -0.517626 33* Junct 0.133 0.17 1.00 1.2 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 1.04 1.2 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 1.06 1.3 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 1.07 1.3 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 1.09 1.3 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 1.11 1.3 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 1.13 1.3 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 1.15 1.4 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 1.17 1.4 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 1.18 1.4 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 1.22 1.5 48 269 top road
-0.219135 -0.518823 23* Junct 0.133 0.17 1.36 1.6 48 270 top road
-0.219131 -0.519426 20* Junct 0.067 0.08 1.42 1.7 48 270 top road
-0.219123 -0.520207 12* Junct 0.086 0.11 1.51 1.8 48 270 top road
-0.219107 -0.520828 6* Junct 0.069 0.09 1.58 1.9 48 271 top road
-0.220666 -0.520893 5* Junct- 0.173 0.11 1.75 2.0 96 182 main 1
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.82 2.0 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.85 2.1 96 181 main 1
routino-2.4.1/src/test/expected/dead-ends-WP08.txt 644 233 144 2301 12063560525 15015 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220739 -0.517804 19* Junct 0.186 0.23 0.49 0.5 48 91 high street
-0.220782 -0.516137 25* Junct 0.185 0.23 0.67 0.8 48 91 high street
-0.220361 -0.515961 26* Waypt 0.050 0.06 0.72 0.8 48 22 dead-end 3
-0.220782 -0.516137 25* Junct 0.050 0.06 0.77 0.9 48 202 dead-end 3
-0.220817 -0.514062 33* Junct 0.230 0.29 1.00 1.2 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.05 1.2 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.14 1.3 96 2 main 2
routino-2.4.1/src/test/expected/loops-WP06.txt 644 233 144 3217 12063560525 14332 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220739 -0.517801 19* Junct 0.187 0.23 0.47 0.5 48 91 high street
-0.220301 -0.517576 22* Waypt 0.054 0.07 0.52 0.6 48 27 loop 2
-0.219946 -0.517397 24 Inter 0.044 0.06 0.56 0.6 48 26 loop 2
-0.219266 -0.517579 21* Junct 0.078 0.10 0.64 0.7 48 345 loop 2
-0.218794 -0.517763 20 Inter 0.056 0.07 0.70 0.8 48 338 loop 2
-0.218417 -0.517462 23* Junct- 0.053 0.07 0.75 0.9 48 38 loop 2
-0.218805 -0.517131 25 Inter 0.056 0.07 0.81 0.9 48 139 loop 2
-0.219266 -0.517579 21* Junct 0.071 0.09 0.88 1.0 48 224 loop 2
-0.219946 -0.517397 24 Inter 0.078 0.10 0.95 1.1 48 165 loop 2
-0.220739 -0.517801 19* Junct 0.054 0.07 1.01 1.2 48 207 loop 2
-0.220784 -0.516035 30* Junct 0.196 0.24 1.21 1.4 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.26 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.34 1.5 96 2 main 2
routino-2.4.1/src/test/expected/super-or-not-WP01.txt 644 233 144 1577 12063560525 15552 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.216158 -0.518809 -1 Waypt 0.000 0.00 0.00 0.0
-0.216435 -0.518515 4 Inter 0.044 0.06 0.04 0.1 48 133 Local road
-0.215866 -0.517931 5 Inter 0.090 0.11 0.13 0.2 48 45 Local road
-0.216470 -0.517412 6 Inter 0.088 0.11 0.22 0.3 48 139 Local road
-0.215930 -0.516823 7 Inter 0.088 0.11 0.31 0.4 48 47 Local road
-0.216451 -0.516221 8 Inter 0.088 0.11 0.40 0.5 48 130 Local road
-0.216158 -0.515870 -2 Waypt 0.050 0.06 0.45 0.6 48 50 Local road
routino-2.4.1/src/test/expected/loops-WP10.txt 644 233 144 3340 12063560525 14322 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220739 -0.517801 19* Junct 0.187 0.23 0.47 0.5 48 91 high street
-0.220301 -0.517576 22* Junct- 0.054 0.07 0.52 0.6 48 27 loop 2
-0.219946 -0.517397 24 Inter 0.044 0.06 0.56 0.6 48 26 loop 2
-0.219266 -0.517579 21* Junct 0.078 0.10 0.64 0.7 48 345 loop 2
-0.218805 -0.517131 25 Waypt 0.071 0.09 0.71 0.8 48 44 loop 2
-0.218417 -0.517462 23* Junct- 0.056 0.07 0.77 0.9 48 319 loop 2
-0.218794 -0.517763 20 Inter 0.053 0.07 0.82 0.9 48 218 loop 2
-0.219266 -0.517579 21* Junct 0.056 0.07 0.88 1.0 48 158 loop 2
-0.219946 -0.517397 24 Inter 0.078 0.10 0.95 1.1 48 165 loop 2
-0.220301 -0.517576 22* Junct- 0.044 0.06 1.00 1.2 48 206 loop 2
-0.220739 -0.517801 19* Junct 0.054 0.07 1.05 1.2 48 207 loop 2
-0.220784 -0.516035 30* Junct 0.196 0.24 1.25 1.5 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.30 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.38 1.6 96 2 main 2
routino-2.4.1/src/test/expected/node-restrictions-WP06.txt 644 233 144 3410 12063560525 16644 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220682 -0.520141 9* Junct 0.083 0.08 0.20 0.2 64 91 high street
-0.220695 -0.519489 12* Change 0.072 0.07 0.28 0.2 64 91 high street
-0.220694 -0.519227 15 Inter 0.029 0.04 0.31 0.3 48 89 long road
-0.220386 -0.519076 16 Inter 0.038 0.05 0.34 0.3 48 26 long road
-0.220961 -0.518928 17 Inter 0.066 0.08 0.41 0.4 48 165 long road
-0.220427 -0.518622 18 Inter 0.068 0.09 0.48 0.5 48 29 long road
-0.220949 -0.518422 21 Inter 0.062 0.08 0.54 0.5 48 159 long road
-0.220455 -0.518238 22 Inter 0.058 0.07 0.60 0.6 48 20 long road
-0.220746 -0.518070 23 Inter 0.037 0.04 0.64 0.7 48 149 long road
-0.220739 -0.517801 26* Junct 0.029 0.04 0.66 0.7 48 88 long road
-0.220212 -0.517903 25 Inter 0.059 0.07 0.72 0.8 48 349 nopass road
-0.220176 -0.518543 -2 Waypt 0.070 0.09 0.79 0.9 48 273 nopass road
-0.220212 -0.517903 25 Inter 0.070 0.09 0.86 0.9 48 93 nopass road
-0.220739 -0.517801 26* Junct 0.059 0.07 0.92 1.0 48 169 nopass road
-0.220784 -0.516035 31* Junct 0.196 0.18 1.12 1.2 64 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.25 1.3 96 2 main 2
routino-2.4.1/src/test/expected/loops-WP05.txt 644 233 144 3337 12063560525 14334 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220280 -0.519256 15* Junct- 0.052 0.07 0.33 0.3 48 29 loop 1
-0.219910 -0.519112 17 Inter 0.044 0.06 0.37 0.4 48 21 loop 1
-0.219237 -0.519286 13* Junct 0.077 0.10 0.45 0.5 48 345 loop 1
-0.218764 -0.519471 12 Inter 0.056 0.07 0.51 0.6 48 338 loop 1
-0.218380 -0.519134 16 Waypt 0.056 0.07 0.56 0.6 48 41 loop 1
-0.218776 -0.518838 18 Inter 0.055 0.07 0.62 0.7 48 143 loop 1
-0.219237 -0.519286 13* Junct 0.071 0.09 0.69 0.8 48 224 loop 1
-0.219910 -0.519112 17 Inter 0.077 0.10 0.77 0.9 48 165 loop 1
-0.220280 -0.519256 15* Junct- 0.044 0.06 0.81 0.9 48 201 loop 1
-0.220695 -0.519489 11* Junct 0.052 0.07 0.86 1.0 48 209 loop 1
-0.220739 -0.517801 19* Junct 0.187 0.23 1.05 1.2 48 91 high street
-0.220784 -0.516035 30* Junct 0.196 0.24 1.25 1.5 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.30 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.38 1.6 96 2 main 2
routino-2.4.1/src/test/expected/oneway-loop-WP01.txt 644 233 144 2317 12063560525 15442 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220695 -0.519489 9* Inter 0.156 0.20 0.28 0.3 48 91 high street
-0.220739 -0.517801 12* Junct 0.187 0.23 0.47 0.5 48 91 high street
-0.220405 -0.517799 13 Inter 0.037 0.04 0.50 0.5 48 0 reverse loop
-0.220210 -0.518605 11 Waypt 0.092 0.12 0.59 0.7 48 283 reverse loop
-0.220333 -0.519485 10 Inter 0.098 0.12 0.69 0.8 48 262 reverse loop
-0.220695 -0.519489 9* Inter 0.040 0.05 0.73 0.8 48 180 reverse loop
-0.220739 -0.517801 12* Junct 0.187 0.23 0.92 1.1 48 91 high street
-0.220784 -0.516035 18* Junct 0.196 0.24 1.11 1.3 48 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.25 1.4 96 2 main 2
routino-2.4.1/src/test/expected/turns-WP09.txt 644 233 144 4461 12063560525 14356 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct 0.018 0.02 0.54 0.6 48 27 roundabout
-0.219184 -0.515968 55* Junct 0.095 0.12 0.63 0.7 48 92 top road
-0.220784 -0.516035 54* Junct 0.178 0.11 0.81 0.8 96 182 main 2
-0.220760 -0.516647 48* Junct 0.068 0.09 0.88 0.9 48 272 high street
-0.220097 -0.516762 47* Inter 0.074 0.09 0.95 1.0 48 350 loop 3
-0.219872 -0.517009 43 Waypt 0.037 0.04 0.99 1.1 48 312 loop 3
-0.220089 -0.517279 35* Inter 0.038 0.05 1.03 1.1 48 231 loop 3
-0.220739 -0.517425 34* Junct 0.074 0.09 1.10 1.2 48 192 loop 3
-0.220724 -0.518071 31* Junct 0.071 0.09 1.17 1.3 48 271 high street
-0.220708 -0.518842 22* Junct 0.085 0.10 1.26 1.4 48 271 high street
-0.220691 -0.519461 19* Junct 0.069 0.09 1.33 1.5 48 271 high street
-0.220671 -0.520223 11* Junct 0.084 0.10 1.41 1.6 48 271 high street
-0.220666 -0.520893 5* Junct 0.074 0.09 1.48 1.7 48 270 high street
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.55 1.7 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.58 1.7 96 181 main 1
routino-2.4.1/src/test/expected/dead-ends-WP07.txt 644 233 144 3017 12063560525 15021 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220739 -0.517804 19* Junct 0.186 0.23 0.49 0.5 48 91 high street
-0.220296 -0.517634 21* Junct- 0.052 0.07 0.54 0.6 48 21 dead-end 2
-0.219991 -0.517512 22 Inter 0.036 0.04 0.57 0.6 48 21 dead-end 2
-0.219635 -0.517707 -2 Waypt 0.045 0.06 0.62 0.7 48 331 dead-end 2
-0.219991 -0.517512 22 Inter 0.045 0.06 0.67 0.7 48 151 dead-end 2
-0.220296 -0.517634 21* Junct- 0.036 0.04 0.70 0.8 48 201 dead-end 2
-0.220739 -0.517804 19* Junct 0.052 0.07 0.75 0.9 48 201 dead-end 2
-0.220782 -0.516137 25* Junct 0.185 0.23 0.94 1.1 48 91 high street
-0.220817 -0.514062 33* Junct 0.230 0.29 1.17 1.4 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.22 1.4 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.31 1.5 96 2 main 2
routino-2.4.1/src/test/expected/no-super-WP04.txt 644 233 144 2231 12063560525 14737 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.217903 -0.519035 6 Waypt 0.000 0.00 0.00 0.0
-0.218100 -0.518253 9 Inter 0.089 0.11 0.09 0.1 48 104 road4
-0.217937 -0.517713 12 Inter 0.062 0.08 0.15 0.2 48 73 road4
-0.218117 -0.516837 16 Inter 0.099 0.12 0.25 0.3 48 101 road4
-0.217920 -0.515945 18 Inter 0.101 0.12 0.35 0.4 48 77 road4
-0.218143 -0.515189 21 Inter 0.087 0.11 0.44 0.5 48 106 road4
-0.217911 -0.514640 26 Waypt 0.066 0.08 0.50 0.6 48 67 road4
-0.218143 -0.515189 21 Inter 0.066 0.08 0.57 0.7 48 247 road4
-0.217920 -0.515945 18 Inter 0.087 0.11 0.66 0.8 48 286 road4
-0.218117 -0.516837 16 Inter 0.101 0.12 0.76 0.9 48 257 road4
-0.217937 -0.517713 12 Waypt 0.099 0.12 0.86 1.1 48 281 road4
routino-2.4.1/src/test/expected/turns-WP16.txt 644 233 144 2145 12063560525 14351 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct- 0.072 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 5* Junct- 0.173 0.11 0.24 0.2 96 182 main 1
-0.221308 -0.520914 4* Junct 0.071 0.04 0.32 0.2 96 181 main 1
-0.221360 -0.518860 21* Junct 0.228 0.28 0.54 0.5 48 91 bottom road
-0.221711 -0.518511 26* Waypt 0.055 0.07 0.60 0.5 48 135 loop 6
-0.221376 -0.518235 29* Junct 0.048 0.06 0.65 0.6 48 39 loop 6
-0.221360 -0.518860 21* Junct 0.069 0.09 0.72 0.7 48 271 bottom road
-0.221308 -0.520914 4* Junct 0.228 0.28 0.94 1.0 48 271 bottom road
-0.221561 -0.520922 -3 Waypt 0.027 0.02 0.97 1.0 96 181 main 1
routino-2.4.1/src/test/expected/super-or-not-WP02.txt 644 233 144 1205 12063560525 15537 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.216828 -0.519457 -1 Waypt 0.000 0.00 0.00 0.0
-0.217245 -0.519637 2* Junct 0.050 0.06 0.05 0.1 48 203 Local road
-0.217248 -0.515206 10* Junct 0.493 0.31 0.54 0.4 96 90 Main road
-0.216919 -0.515308 -2 Waypt 0.038 0.05 0.58 0.4 48 342 Local road
routino-2.4.1/src/test/expected/dead-ends-WP05.txt 644 233 144 2301 12063560525 15012 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220739 -0.517804 19* Junct 0.186 0.23 0.49 0.5 48 91 high street
-0.220296 -0.517634 21* Waypt 0.052 0.07 0.54 0.6 48 21 dead-end 2
-0.220739 -0.517804 19* Junct 0.052 0.07 0.59 0.7 48 201 dead-end 2
-0.220782 -0.516137 25* Junct 0.185 0.23 0.78 0.9 48 91 high street
-0.220817 -0.514062 33* Junct 0.230 0.29 1.01 1.2 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.06 1.2 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.15 1.3 96 2 main 2
routino-2.4.1/src/test/expected/dead-ends-WP02.txt 644 233 144 2551 12063560525 15016 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220263 -0.519309 14* Junct- 0.052 0.07 0.35 0.4 48 21 dead-end 1
-0.219924 -0.519179 15 Waypt 0.040 0.05 0.39 0.4 48 20 dead-end 1
-0.220263 -0.519309 14* Junct- 0.040 0.05 0.43 0.5 48 200 dead-end 1
-0.220702 -0.519478 12* Junct 0.052 0.07 0.48 0.5 48 201 dead-end 1
-0.220739 -0.517804 19* Junct 0.186 0.23 0.67 0.8 48 91 high street
-0.220782 -0.516137 25* Junct 0.185 0.23 0.86 1.0 48 91 high street
-0.220817 -0.514062 33* Junct 0.230 0.29 1.09 1.3 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.14 1.3 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.23 1.4 96 2 main 2
routino-2.4.1/src/test/expected/node-restrictions-WP07.txt 644 233 144 3144 12063560525 16651 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220682 -0.520141 9* Junct 0.083 0.08 0.20 0.2 64 91 high street
-0.219009 -0.520075 10* Waypt 0.186 0.17 0.39 0.3 64 2 dead end road
-0.220682 -0.520141 9* Junct 0.186 0.17 0.58 0.5 64 182 dead end road
-0.220695 -0.519489 12* Change 0.072 0.07 0.65 0.6 64 91 high street
-0.220694 -0.519227 15 Inter 0.029 0.04 0.68 0.6 48 89 long road
-0.220386 -0.519076 16 Inter 0.038 0.05 0.72 0.6 48 26 long road
-0.220961 -0.518928 17 Inter 0.066 0.08 0.78 0.7 48 165 long road
-0.220427 -0.518622 18 Inter 0.068 0.09 0.85 0.8 48 29 long road
-0.220949 -0.518422 21 Inter 0.062 0.08 0.91 0.9 48 159 long road
-0.220455 -0.518238 22 Inter 0.058 0.07 0.97 1.0 48 20 long road
-0.220746 -0.518070 23 Inter 0.037 0.04 1.01 1.0 48 149 long road
-0.220739 -0.517801 26* Junct 0.029 0.04 1.04 1.0 48 88 long road
-0.220784 -0.516035 31* Junct 0.196 0.18 1.23 1.2 64 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.36 1.3 96 2 main 2
routino-2.4.1/src/test/expected/node-restrictions-WP03.txt 644 233 144 3420 12063560525 16642 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220682 -0.520141 9* Junct 0.083 0.08 0.20 0.2 64 91 high street
-0.220695 -0.519489 12* Change 0.072 0.07 0.28 0.2 64 91 high street
-0.220694 -0.519227 15 Inter 0.029 0.04 0.31 0.3 48 89 long road
-0.220386 -0.519076 16 Inter 0.038 0.05 0.34 0.3 48 26 long road
-0.220961 -0.518928 17 Inter 0.066 0.08 0.41 0.4 48 165 long road
-0.220427 -0.518622 18 Inter 0.068 0.09 0.48 0.5 48 29 long road
-0.220949 -0.518422 21 Inter 0.062 0.08 0.54 0.5 48 159 long road
-0.220455 -0.518238 22 Inter 0.058 0.07 0.60 0.6 48 20 long road
-0.220746 -0.518070 23 Inter 0.037 0.04 0.64 0.7 48 149 long road
-0.220739 -0.517801 26* Junct 0.029 0.04 0.66 0.7 48 88 long road
-0.221166 -0.517916 24 Inter 0.049 0.06 0.71 0.8 48 195 somepass road
-0.221157 -0.518560 -2 Waypt 0.070 0.09 0.78 0.8 48 270 somepass road
-0.221166 -0.517916 24 Inter 0.070 0.09 0.85 0.9 48 90 somepass road
-0.220739 -0.517801 26* Junct 0.049 0.06 0.90 1.0 48 15 somepass road
-0.220784 -0.516035 31* Junct 0.196 0.18 1.10 1.2 64 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.23 1.3 96 2 main 2
routino-2.4.1/src/test/expected/no-super-WP01.txt 644 233 144 2113 12063560525 14733 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.215814 -0.519419 -1 Waypt 0.000 0.00 0.00 0.0
-0.215737 -0.519035 7 Inter 0.043 0.05 0.04 0.1 48 78 road1
-0.215935 -0.518253 10 Inter 0.089 0.11 0.13 0.2 48 104 road1
-0.215772 -0.517713 13 Inter 0.062 0.08 0.19 0.2 48 73 road1
-0.215952 -0.516838 15 Inter 0.099 0.12 0.29 0.4 48 101 road1
-0.215755 -0.515945 19 Inter 0.101 0.12 0.39 0.5 48 77 road1
-0.215897 -0.515462 -2 Waypt 0.055 0.07 0.45 0.6 48 106 road1
-0.215755 -0.515945 19 Inter 0.055 0.07 0.50 0.6 48 286 road1
-0.215952 -0.516838 15 Inter 0.101 0.12 0.60 0.8 48 257 road1
-0.215868 -0.517244 -3 Waypt 0.046 0.06 0.65 0.8 48 281 road1
routino-2.4.1/src/test/expected/turns-WP05.txt 644 233 144 3642 12063560525 14352 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct- 0.072 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 5* Junct 0.173 0.11 0.24 0.2 96 182 main 1
-0.220671 -0.520223 11* Junct 0.074 0.09 0.32 0.2 48 90 high street
-0.220691 -0.519461 19* Junct 0.084 0.10 0.40 0.3 48 91 high street
-0.220708 -0.518842 22* Junct 0.069 0.09 0.47 0.4 48 91 high street
-0.220724 -0.518071 31* Junct 0.085 0.10 0.56 0.5 48 91 high street
-0.220143 -0.518162 30 Inter 0.065 0.08 0.62 0.6 48 351 loop 2
-0.219850 -0.518416 27 Inter 0.043 0.05 0.67 0.7 48 319 loop 2
-0.220100 -0.518718 24* Waypt 0.043 0.05 0.71 0.7 48 230 loop 2
-0.220708 -0.518842 22* Junct 0.069 0.09 0.78 0.8 48 191 loop 2
-0.220724 -0.518071 31* Junct 0.085 0.10 0.86 0.9 48 91 high street
-0.220739 -0.517425 34* Junct 0.071 0.09 0.93 1.0 48 91 high street
-0.220760 -0.516647 48* Junct 0.086 0.11 1.02 1.1 48 91 high street
-0.220784 -0.516035 54* Junct 0.068 0.09 1.09 1.2 48 92 high street
-0.221431 -0.516056 53* Junct 0.072 0.04 1.16 1.2 96 181 main 2
-0.221376 -0.518235 29* Junct 0.242 0.30 1.40 1.5 48 271 bottom road
-0.221360 -0.518860 21* Junct 0.069 0.09 1.47 1.6 48 271 bottom road
-0.221308 -0.520914 4* Junct 0.228 0.28 1.70 1.9 48 271 bottom road
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.73 1.9 96 181 main 1
routino-2.4.1/src/test/expected/node-restrictions-WP04.txt 644 233 144 3410 12063560525 16642 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220682 -0.520141 9* Junct 0.083 0.08 0.20 0.2 64 91 high street
-0.220695 -0.519489 12* Change 0.072 0.07 0.28 0.2 64 91 high street
-0.220140 -0.519342 14 Inter 0.063 0.08 0.34 0.3 48 14 nopass road
-0.220173 -0.518597 20 Waypt 0.082 0.10 0.42 0.4 48 92 nopass road
-0.220140 -0.519342 14 Inter 0.082 0.10 0.50 0.5 48 272 nopass road
-0.220695 -0.519489 12* Junct 0.063 0.08 0.57 0.6 48 194 nopass road
-0.220694 -0.519227 15 Inter 0.029 0.04 0.60 0.6 48 89 long road
-0.220386 -0.519076 16 Inter 0.038 0.05 0.63 0.7 48 26 long road
-0.220961 -0.518928 17 Inter 0.066 0.08 0.70 0.7 48 165 long road
-0.220427 -0.518622 18 Inter 0.068 0.09 0.77 0.8 48 29 long road
-0.220949 -0.518422 21 Inter 0.062 0.08 0.83 0.9 48 159 long road
-0.220455 -0.518238 22 Inter 0.058 0.07 0.89 1.0 48 20 long road
-0.220746 -0.518070 23 Inter 0.037 0.04 0.93 1.0 48 149 long road
-0.220739 -0.517801 26* Junct 0.029 0.04 0.95 1.1 48 88 long road
-0.220784 -0.516035 31* Junct 0.196 0.18 1.15 1.2 64 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.28 1.3 96 2 main 2
routino-2.4.1/src/test/expected/loops-WP07.txt 644 233 144 3221 12063560525 14326 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220739 -0.517801 19* Junct 0.187 0.23 0.47 0.5 48 91 high street
-0.220301 -0.517576 22* Junct- 0.054 0.07 0.52 0.6 48 27 loop 2
-0.219946 -0.517397 24 Waypt 0.044 0.06 0.56 0.6 48 26 loop 2
-0.219266 -0.517579 21* Junct 0.078 0.10 0.64 0.7 48 345 loop 2
-0.218794 -0.517763 20 Inter 0.056 0.07 0.70 0.8 48 338 loop 2
-0.218417 -0.517462 23* Junct- 0.053 0.07 0.75 0.9 48 38 loop 2
-0.218805 -0.517131 25 Inter 0.056 0.07 0.81 0.9 48 139 loop 2
-0.219266 -0.517579 21* Junct 0.071 0.09 0.88 1.0 48 224 loop 2
-0.220301 -0.517576 22* Junct- 0.044 0.06 0.92 1.1 48 206 loop 2
-0.220739 -0.517801 19* Junct 0.054 0.07 0.97 1.1 48 207 loop 2
-0.220784 -0.516035 30* Junct 0.196 0.24 1.17 1.4 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.22 1.4 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.30 1.5 96 2 main 2
routino-2.4.1/src/test/expected/turns-WP10.txt 644 233 144 5154 12063560525 14346 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 0.54 0.6 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 0.56 0.6 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 0.58 0.7 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 0.59 0.7 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 0.61 0.7 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 0.65 0.8 48 269 top road
-0.219135 -0.518823 23* Junct 0.133 0.17 0.79 0.9 48 270 top road
-0.219131 -0.519426 20* Junct 0.067 0.08 0.85 1.0 48 270 top road
-0.219123 -0.520207 12* Junct 0.086 0.11 0.94 1.1 48 270 top road
-0.218605 -0.520090 -2 Waypt 0.059 0.07 1.00 1.2 48 12 loop 4
-0.218474 -0.520060 14* Inter 0.015 0.02 1.01 1.2 48 12 loop 4
-0.218258 -0.519789 16 Inter 0.038 0.05 1.05 1.2 48 51 loop 4
-0.218482 -0.519542 18* Inter 0.037 0.04 1.09 1.3 48 132 loop 4
-0.219131 -0.519426 20* Junct 0.073 0.09 1.16 1.4 48 169 loop 4
-0.219123 -0.520207 12* Junct 0.086 0.11 1.25 1.5 48 270 top road
-0.219107 -0.520828 6* Junct 0.069 0.09 1.31 1.6 48 271 top road
-0.220666 -0.520893 5* Junct- 0.173 0.11 1.49 1.7 96 182 main 1
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.56 1.7 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.59 1.7 96 181 main 1
routino-2.4.1/src/test/expected/turns-WP04.txt 644 233 144 3761 12063560525 14353 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct- 0.072 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 5* Junct 0.173 0.11 0.24 0.2 96 182 main 1
-0.220671 -0.520223 11* Junct 0.074 0.09 0.32 0.2 48 90 high street
-0.220691 -0.519461 19* Junct 0.084 0.10 0.40 0.3 48 91 high street
-0.220708 -0.518842 22* Junct 0.069 0.09 0.47 0.4 48 91 high street
-0.220724 -0.518071 31* Junct 0.085 0.10 0.56 0.5 48 91 high street
-0.220143 -0.518162 30 Inter 0.065 0.08 0.62 0.6 48 351 loop 2
-0.219850 -0.518416 27 Inter 0.043 0.05 0.67 0.7 48 319 loop 2
-0.220100 -0.518718 24* Inter 0.043 0.05 0.71 0.7 48 230 loop 2
-0.220206 -0.518739 -2 Waypt 0.012 0.01 0.72 0.7 48 191 loop 2
-0.220708 -0.518842 22* Junct 0.057 0.07 0.78 0.8 48 191 loop 2
-0.220724 -0.518071 31* Junct 0.085 0.10 0.86 0.9 48 91 high street
-0.220739 -0.517425 34* Junct 0.071 0.09 0.93 1.0 48 91 high street
-0.220760 -0.516647 48* Junct 0.086 0.11 1.02 1.1 48 91 high street
-0.220784 -0.516035 54* Junct 0.068 0.09 1.09 1.2 48 92 high street
-0.221431 -0.516056 53* Junct 0.072 0.04 1.16 1.2 96 181 main 2
-0.221376 -0.518235 29* Junct 0.242 0.30 1.40 1.5 48 271 bottom road
-0.221360 -0.518860 21* Junct 0.069 0.09 1.47 1.6 48 271 bottom road
-0.221308 -0.520914 4* Junct 0.228 0.28 1.70 1.9 48 271 bottom road
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.73 1.9 96 181 main 1
routino-2.4.1/src/test/expected/turns-WP15.txt 644 233 144 6532 12063560525 14354 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 0.54 0.6 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 0.56 0.6 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 0.58 0.7 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 0.59 0.7 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 0.61 0.7 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 0.65 0.8 48 269 top road
-0.218619 -0.517921 32* Inter 0.067 0.08 0.72 0.8 48 330 loop 5
-0.218431 -0.518243 28 Waypt 0.041 0.05 0.76 0.9 48 300 loop 5
-0.218600 -0.518557 25* Inter 0.039 0.05 0.80 0.9 48 241 loop 5
-0.219135 -0.518823 23* Junct 0.066 0.08 0.86 1.0 48 206 loop 5
-0.219145 -0.517626 33* Junct 0.133 0.17 1.00 1.2 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 1.04 1.2 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 1.06 1.3 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 1.07 1.3 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 1.09 1.3 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 1.11 1.3 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 1.13 1.3 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 1.15 1.4 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 1.17 1.4 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 1.18 1.4 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 1.22 1.5 48 269 top road
-0.219135 -0.518823 23* Junct 0.133 0.17 1.36 1.6 48 270 top road
-0.219131 -0.519426 20* Junct 0.067 0.08 1.42 1.7 48 270 top road
-0.219123 -0.520207 12* Junct 0.086 0.11 1.51 1.8 48 270 top road
-0.219107 -0.520828 6* Junct 0.069 0.09 1.58 1.9 48 271 top road
-0.220666 -0.520893 5* Junct- 0.173 0.11 1.75 2.0 96 182 main 1
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.82 2.0 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.85 2.1 96 181 main 1
routino-2.4.1/src/test/expected/loops-WP03.txt 644 233 144 3456 12063560525 14334 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220280 -0.519256 15* Junct- 0.052 0.07 0.33 0.3 48 29 loop 1
-0.219910 -0.519112 17 Inter 0.044 0.06 0.37 0.4 48 21 loop 1
-0.219578 -0.519198 -2 Waypt 0.038 0.05 0.41 0.4 48 345 loop 1
-0.219237 -0.519286 13* Junct 0.039 0.05 0.45 0.5 48 345 loop 1
-0.218764 -0.519471 12 Inter 0.056 0.07 0.51 0.6 48 338 loop 1
-0.218380 -0.519134 16 Inter 0.056 0.07 0.56 0.6 48 41 loop 1
-0.218776 -0.518838 18 Inter 0.055 0.07 0.62 0.7 48 143 loop 1
-0.219237 -0.519286 13* Junct 0.071 0.09 0.69 0.8 48 224 loop 1
-0.219910 -0.519112 17 Inter 0.077 0.10 0.77 0.9 48 165 loop 1
-0.220280 -0.519256 15* Junct- 0.044 0.06 0.81 0.9 48 201 loop 1
-0.220695 -0.519489 11* Junct 0.052 0.07 0.86 1.0 48 209 loop 1
-0.220739 -0.517801 19* Junct 0.187 0.23 1.05 1.2 48 91 high street
-0.220784 -0.516035 30* Junct 0.196 0.24 1.25 1.5 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.30 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.38 1.6 96 2 main 2
routino-2.4.1/src/test/expected/loops-WP08.txt 644 233 144 3457 12063560525 14342 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220739 -0.517801 19* Junct 0.187 0.23 0.47 0.5 48 91 high street
-0.220301 -0.517576 22* Junct- 0.054 0.07 0.52 0.6 48 27 loop 2
-0.219946 -0.517397 24 Inter 0.044 0.06 0.56 0.6 48 26 loop 2
-0.219597 -0.517490 -2 Waypt 0.040 0.05 0.60 0.7 48 345 loop 2
-0.219266 -0.517579 21* Junct 0.038 0.05 0.64 0.7 48 345 loop 2
-0.218794 -0.517763 20 Inter 0.056 0.07 0.70 0.8 48 338 loop 2
-0.218417 -0.517462 23* Junct- 0.053 0.07 0.75 0.9 48 38 loop 2
-0.218805 -0.517131 25 Inter 0.056 0.07 0.81 0.9 48 139 loop 2
-0.219266 -0.517579 21* Junct 0.071 0.09 0.88 1.0 48 224 loop 2
-0.219946 -0.517397 24 Inter 0.078 0.10 0.95 1.1 48 165 loop 2
-0.220301 -0.517576 22* Junct- 0.044 0.06 1.00 1.2 48 206 loop 2
-0.220739 -0.517801 19* Junct 0.054 0.07 1.05 1.2 48 207 loop 2
-0.220784 -0.516035 30* Junct 0.196 0.24 1.25 1.5 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.30 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.38 1.6 96 2 main 2
routino-2.4.1/src/test/expected/loops-WP09.txt 644 233 144 3457 12063560525 14343 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220739 -0.517801 19* Junct 0.187 0.23 0.47 0.5 48 91 high street
-0.220301 -0.517576 22* Junct- 0.054 0.07 0.52 0.6 48 27 loop 2
-0.219946 -0.517397 24 Inter 0.044 0.06 0.56 0.6 48 26 loop 2
-0.219266 -0.517579 21* Junct 0.078 0.10 0.64 0.7 48 345 loop 2
-0.219013 -0.517333 -2 Waypt 0.039 0.05 0.68 0.8 48 44 loop 2
-0.218805 -0.517131 25 Inter 0.032 0.04 0.71 0.8 48 44 loop 2
-0.218417 -0.517462 23* Junct- 0.056 0.07 0.77 0.9 48 319 loop 2
-0.218794 -0.517763 20 Inter 0.053 0.07 0.82 0.9 48 218 loop 2
-0.219266 -0.517579 21* Junct 0.056 0.07 0.88 1.0 48 158 loop 2
-0.219946 -0.517397 24 Inter 0.078 0.10 0.95 1.1 48 165 loop 2
-0.220301 -0.517576 22* Junct- 0.044 0.06 1.00 1.2 48 206 loop 2
-0.220739 -0.517801 19* Junct 0.054 0.07 1.05 1.2 48 207 loop 2
-0.220784 -0.516035 30* Junct 0.196 0.24 1.25 1.5 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.30 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.38 1.6 96 2 main 2
routino-2.4.1/src/test/expected/loops-WP11.txt 644 233 144 3337 12063560525 14331 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220739 -0.517801 19* Junct 0.187 0.23 0.47 0.5 48 91 high street
-0.220301 -0.517576 22* Junct- 0.054 0.07 0.52 0.6 48 27 loop 2
-0.219946 -0.517397 24 Inter 0.044 0.06 0.56 0.6 48 26 loop 2
-0.219266 -0.517579 21* Junct 0.078 0.10 0.64 0.7 48 345 loop 2
-0.218794 -0.517763 20 Inter 0.056 0.07 0.70 0.8 48 338 loop 2
-0.218417 -0.517462 23* Waypt 0.053 0.07 0.75 0.9 48 38 loop 2
-0.218805 -0.517131 25 Inter 0.056 0.07 0.81 0.9 48 139 loop 2
-0.219266 -0.517579 21* Junct 0.071 0.09 0.88 1.0 48 224 loop 2
-0.219946 -0.517397 24 Inter 0.078 0.10 0.95 1.1 48 165 loop 2
-0.220301 -0.517576 22* Junct- 0.044 0.06 1.00 1.2 48 206 loop 2
-0.220739 -0.517801 19* Junct 0.054 0.07 1.05 1.2 48 207 loop 2
-0.220784 -0.516035 30* Junct 0.196 0.24 1.25 1.5 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.30 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.38 1.6 96 2 main 2
routino-2.4.1/src/test/expected/turns-WP03.txt 644 233 144 2403 12063560525 14342 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct- 0.072 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 5* Junct 0.173 0.11 0.24 0.2 96 182 main 1
-0.220671 -0.520223 11* Junct 0.074 0.09 0.32 0.2 48 90 high street
-0.220691 -0.519461 19* Junct 0.084 0.10 0.40 0.3 48 91 high street
-0.220111 -0.519553 17 Inter 0.065 0.08 0.47 0.4 48 351 loop 1
-0.219817 -0.519807 15 Waypt 0.043 0.05 0.51 0.5 48 319 loop 1
-0.220067 -0.520109 13* Inter 0.043 0.05 0.55 0.5 48 230 loop 1
-0.220671 -0.520223 11* Junct 0.068 0.09 0.62 0.6 48 190 loop 1
-0.220666 -0.520893 5* Junct 0.074 0.09 0.70 0.7 48 270 high street
-0.221308 -0.520914 4* Junct- 0.071 0.04 0.77 0.8 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 0.79 0.8 96 181 main 1
routino-2.4.1/src/test/expected/dead-ends-WP10.txt 644 233 144 3017 12063560525 15013 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220739 -0.517804 19* Junct 0.186 0.23 0.49 0.5 48 91 high street
-0.220782 -0.516137 25* Junct 0.185 0.23 0.67 0.8 48 91 high street
-0.220361 -0.515961 26* Junct- 0.050 0.06 0.72 0.8 48 22 dead-end 3
-0.220019 -0.515847 27 Inter 0.040 0.05 0.76 0.9 48 18 dead-end 3
-0.219672 -0.516031 -2 Waypt 0.043 0.05 0.81 0.9 48 332 dead-end 3
-0.220019 -0.515847 27 Inter 0.043 0.05 0.85 1.0 48 152 dead-end 3
-0.220361 -0.515961 26* Junct- 0.040 0.05 0.89 1.0 48 198 dead-end 3
-0.220782 -0.516137 25* Junct 0.050 0.06 0.94 1.1 48 202 dead-end 3
-0.220817 -0.514062 33* Junct 0.230 0.29 1.17 1.4 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.22 1.4 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.31 1.5 96 2 main 2
routino-2.4.1/src/test/expected/turns-WP07.txt 644 233 144 5050 12063560525 14347 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct 0.018 0.02 0.54 0.6 48 27 roundabout
-0.219184 -0.515968 55* Junct 0.095 0.12 0.63 0.7 48 92 top road
-0.220784 -0.516035 54* Junct 0.178 0.11 0.81 0.8 96 182 main 2
-0.220760 -0.516647 48* Junct 0.068 0.09 0.88 0.9 48 272 high street
-0.220739 -0.517425 34* Junct 0.086 0.11 0.96 1.0 48 271 high street
-0.220238 -0.517313 -2 Waypt 0.057 0.07 1.02 1.1 48 12 loop 3
-0.220089 -0.517279 35* Inter 0.017 0.02 1.04 1.1 48 12 loop 3
-0.219872 -0.517009 43 Inter 0.038 0.05 1.08 1.2 48 51 loop 3
-0.220097 -0.516762 47* Inter 0.037 0.04 1.11 1.2 48 132 loop 3
-0.220760 -0.516647 48* Junct 0.074 0.09 1.19 1.3 48 170 loop 3
-0.220739 -0.517425 34* Junct 0.086 0.11 1.27 1.4 48 271 high street
-0.220724 -0.518071 31* Junct 0.071 0.09 1.34 1.5 48 271 high street
-0.220708 -0.518842 22* Junct 0.085 0.10 1.43 1.6 48 271 high street
-0.220691 -0.519461 19* Junct 0.069 0.09 1.50 1.7 48 271 high street
-0.220671 -0.520223 11* Junct 0.084 0.10 1.58 1.8 48 271 high street
-0.220666 -0.520893 5* Junct 0.074 0.09 1.66 1.9 48 270 high street
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.73 1.9 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.75 2.0 96 181 main 1
routino-2.4.1/src/test/expected/dead-ends-WP11.txt 644 233 144 3265 12063560525 15021 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220739 -0.517804 19* Junct 0.186 0.23 0.49 0.5 48 91 high street
-0.220782 -0.516137 25* Junct 0.185 0.23 0.67 0.8 48 91 high street
-0.220361 -0.515961 26* Junct- 0.050 0.06 0.72 0.8 48 22 dead-end 3
-0.220019 -0.515847 27 Inter 0.040 0.05 0.76 0.9 48 18 dead-end 3
-0.219341 -0.516206 24 Inter 0.085 0.10 0.85 1.0 48 332 dead-end 3
-0.218493 -0.515789 28* Waypt 0.105 0.13 0.95 1.1 48 26 dead-end 3
-0.219341 -0.516206 24 Inter 0.105 0.13 1.06 1.2 48 206 dead-end 3
-0.220019 -0.515847 27 Inter 0.085 0.10 1.14 1.3 48 152 dead-end 3
-0.220361 -0.515961 26* Junct- 0.040 0.05 1.18 1.4 48 198 dead-end 3
-0.220782 -0.516137 25* Junct 0.050 0.06 1.23 1.5 48 202 dead-end 3
-0.220817 -0.514062 33* Junct 0.230 0.29 1.46 1.7 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.51 1.8 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.60 1.8 96 2 main 2
routino-2.4.1/src/test/expected/node-restrictions-WP02.txt 644 233 144 3420 12063560525 16641 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219564 -0.520846 -1 Waypt 0.000 0.00 0.00 0.0
-0.220666 -0.520893 4* Junct 0.122 0.07 0.12 0.1 96 182 main 1
-0.220682 -0.520141 9* Junct 0.083 0.08 0.20 0.2 64 91 high street
-0.220695 -0.519489 12* Change 0.072 0.07 0.28 0.2 64 91 high street
-0.221123 -0.519360 13 Inter 0.049 0.06 0.33 0.3 48 163 somepass road
-0.221154 -0.518671 -2 Waypt 0.075 0.09 0.40 0.4 48 92 somepass road
-0.221123 -0.519360 13 Inter 0.075 0.09 0.48 0.5 48 272 somepass road
-0.220695 -0.519489 12* Junct 0.049 0.06 0.53 0.5 48 343 somepass road
-0.220694 -0.519227 15 Inter 0.029 0.04 0.55 0.6 48 89 long road
-0.220386 -0.519076 16 Inter 0.038 0.05 0.59 0.6 48 26 long road
-0.220961 -0.518928 17 Inter 0.066 0.08 0.66 0.7 48 165 long road
-0.220427 -0.518622 18 Inter 0.068 0.09 0.73 0.8 48 29 long road
-0.220949 -0.518422 21 Inter 0.062 0.08 0.79 0.8 48 159 long road
-0.220455 -0.518238 22 Inter 0.058 0.07 0.85 0.9 48 20 long road
-0.220746 -0.518070 23 Inter 0.037 0.04 0.88 1.0 48 149 long road
-0.220739 -0.517801 26* Junct 0.029 0.04 0.91 1.0 48 88 long road
-0.220784 -0.516035 31* Junct 0.196 0.18 1.11 1.2 64 91 high street
-0.219593 -0.515985 -3 Waypt 0.132 0.08 1.24 1.3 96 2 main 2
routino-2.4.1/src/test/expected/dead-ends-WP06.txt 644 233 144 2551 12063560525 15022 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220739 -0.517804 19* Junct 0.186 0.23 0.49 0.5 48 91 high street
-0.220296 -0.517634 21* Junct- 0.052 0.07 0.54 0.6 48 21 dead-end 2
-0.219991 -0.517512 22 Waypt 0.036 0.04 0.57 0.6 48 21 dead-end 2
-0.220296 -0.517634 21* Junct- 0.036 0.04 0.61 0.7 48 201 dead-end 2
-0.220739 -0.517804 19* Junct 0.052 0.07 0.66 0.7 48 201 dead-end 2
-0.220782 -0.516137 25* Junct 0.185 0.23 0.85 1.0 48 91 high street
-0.220817 -0.514062 33* Junct 0.230 0.29 1.08 1.3 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.13 1.3 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.22 1.4 96 2 main 2
routino-2.4.1/src/test/expected/dead-ends-WP01.txt 644 233 144 2301 12063560525 15006 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220263 -0.519309 14* Waypt 0.052 0.07 0.35 0.4 48 21 dead-end 1
-0.220702 -0.519478 12* Junct 0.052 0.07 0.41 0.4 48 201 dead-end 1
-0.220739 -0.517804 19* Junct 0.186 0.23 0.59 0.7 48 91 high street
-0.220782 -0.516137 25* Junct 0.185 0.23 0.78 0.9 48 91 high street
-0.220817 -0.514062 33* Junct 0.230 0.29 1.01 1.2 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.06 1.2 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.15 1.3 96 2 main 2
routino-2.4.1/src/test/expected/no-super-WP02.txt 644 233 144 1051 12063560525 14734 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.216472 -0.519026 -1 Waypt 0.000 0.00 0.00 0.0
-0.216671 -0.515660 -2 Waypt 0.374 0.47 0.37 0.5 48 93 road2
-0.216579 -0.517212 -3 Waypt 0.172 0.21 0.55 0.7 48 273 road2
routino-2.4.1/src/test/expected/dead-ends-WP09.txt 644 233 144 2551 12063560525 15025 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219535 -0.521016 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.521052 5* Junct- 0.076 0.05 0.08 0.0 96 182 main 1
-0.220666 -0.521060 4* Junct 0.049 0.03 0.12 0.1 96 180 main 1
-0.220702 -0.519478 12* Junct 0.176 0.22 0.30 0.3 48 91 high street
-0.220739 -0.517804 19* Junct 0.186 0.23 0.49 0.5 48 91 high street
-0.220782 -0.516137 25* Junct 0.185 0.23 0.67 0.8 48 91 high street
-0.220361 -0.515961 26* Junct- 0.050 0.06 0.72 0.8 48 22 dead-end 3
-0.220019 -0.515847 27 Waypt 0.040 0.05 0.76 0.9 48 18 dead-end 3
-0.220361 -0.515961 26* Junct- 0.040 0.05 0.80 0.9 48 198 dead-end 3
-0.220782 -0.516137 25* Junct 0.050 0.06 0.85 1.0 48 202 dead-end 3
-0.220817 -0.514062 33* Junct 0.230 0.29 1.08 1.3 48 90 high street
-0.220344 -0.514042 34* Junct- 0.052 0.03 1.13 1.3 96 2 main 2
-0.219539 -0.514007 -3 Waypt 0.089 0.06 1.22 1.4 96 2 main 2
routino-2.4.1/src/test/expected/loops-WP04.txt 644 233 144 3456 12063560525 14335 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220280 -0.519256 15* Junct- 0.052 0.07 0.33 0.3 48 29 loop 1
-0.219910 -0.519112 17 Inter 0.044 0.06 0.37 0.4 48 21 loop 1
-0.219237 -0.519286 13* Junct 0.077 0.10 0.45 0.5 48 345 loop 1
-0.218997 -0.519053 -2 Waypt 0.037 0.04 0.49 0.5 48 44 loop 1
-0.218776 -0.518838 18 Inter 0.034 0.04 0.52 0.6 48 44 loop 1
-0.218380 -0.519134 16 Inter 0.055 0.07 0.58 0.6 48 323 loop 1
-0.218764 -0.519471 12 Inter 0.056 0.07 0.63 0.7 48 221 loop 1
-0.219237 -0.519286 13* Junct 0.056 0.07 0.69 0.8 48 158 loop 1
-0.219910 -0.519112 17 Inter 0.077 0.10 0.77 0.9 48 165 loop 1
-0.220280 -0.519256 15* Junct- 0.044 0.06 0.81 0.9 48 201 loop 1
-0.220695 -0.519489 11* Junct 0.052 0.07 0.86 1.0 48 209 loop 1
-0.220739 -0.517801 19* Junct 0.187 0.23 1.05 1.2 48 91 high street
-0.220784 -0.516035 30* Junct 0.196 0.24 1.25 1.5 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.30 1.5 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.38 1.6 96 2 main 2
routino-2.4.1/src/test/expected/turns-WP01.txt 644 233 144 2522 12063560525 14342 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct- 0.072 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 5* Junct 0.173 0.11 0.24 0.2 96 182 main 1
-0.220671 -0.520223 11* Junct 0.074 0.09 0.32 0.2 48 90 high street
-0.220691 -0.519461 19* Junct 0.084 0.10 0.40 0.3 48 91 high street
-0.220111 -0.519553 17 Inter 0.065 0.08 0.47 0.4 48 351 loop 1
-0.219817 -0.519807 15 Inter 0.043 0.05 0.51 0.5 48 319 loop 1
-0.220067 -0.520109 13* Inter 0.043 0.05 0.55 0.5 48 230 loop 1
-0.220191 -0.520132 -2 Waypt 0.014 0.02 0.57 0.6 48 190 loop 1
-0.220671 -0.520223 11* Junct 0.054 0.07 0.62 0.6 48 190 loop 1
-0.220666 -0.520893 5* Junct 0.074 0.09 0.70 0.7 48 270 high street
-0.221308 -0.520914 4* Junct- 0.071 0.04 0.77 0.8 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 0.79 0.8 96 181 main 1
routino-2.4.1/src/test/expected/super-or-not-WP03.txt 644 233 144 1206 12063560525 15541 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.217245 -0.519637 2* Waypt 0.000 0.00 0.00 0.0
-0.215919 -0.519064 3 Inter 0.160 0.20 0.16 0.2 48 23 Local road
-0.216435 -0.518515 4 Inter 0.083 0.10 0.24 0.3 48 133 Local road
-0.215866 -0.517931 5 Waypt 0.090 0.11 0.33 0.4 48 45 Local road
routino-2.4.1/src/test/expected/loops-WP02.txt 644 233 144 3220 12063560525 14320 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.219562 -0.520851 -1 Waypt 0.000 0.00 0.00 0.0
-0.220223 -0.520885 5* Junct- 0.073 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 4* Junct 0.049 0.03 0.12 0.1 96 181 main 1
-0.220695 -0.519489 11* Junct 0.156 0.20 0.28 0.3 48 91 high street
-0.220280 -0.519256 15* Junct- 0.052 0.07 0.33 0.3 48 29 loop 1
-0.219910 -0.519112 17 Waypt 0.044 0.06 0.37 0.4 48 21 loop 1
-0.219237 -0.519286 13* Junct 0.077 0.10 0.45 0.5 48 345 loop 1
-0.218764 -0.519471 12 Inter 0.056 0.07 0.51 0.6 48 338 loop 1
-0.218380 -0.519134 16 Inter 0.056 0.07 0.56 0.6 48 41 loop 1
-0.218776 -0.518838 18 Inter 0.055 0.07 0.62 0.7 48 143 loop 1
-0.219237 -0.519286 13* Junct 0.071 0.09 0.69 0.8 48 224 loop 1
-0.220280 -0.519256 15* Junct- 0.044 0.06 0.73 0.8 48 201 loop 1
-0.220695 -0.519489 11* Junct 0.052 0.07 0.79 0.9 48 209 loop 1
-0.220739 -0.517801 19* Junct 0.187 0.23 0.97 1.1 48 91 high street
-0.220784 -0.516035 30* Junct 0.196 0.24 1.17 1.4 48 91 high street
-0.220311 -0.516015 31* Junct- 0.052 0.03 1.22 1.4 96 2 main 2
-0.219596 -0.515984 -3 Waypt 0.079 0.05 1.30 1.5 96 2 main 2
routino-2.4.1/src/test/expected/turns-WP11.txt 644 233 144 4573 12063560525 14353 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct- 0.018 0.02 0.54 0.6 48 27 roundabout
-0.218966 -0.516910 44 Inter 0.022 0.03 0.56 0.6 48 335 roundabout
-0.218923 -0.517072 39 Junct- 0.018 0.02 0.58 0.7 48 284 roundabout
-0.218998 -0.517207 37 Inter 0.017 0.02 0.59 0.7 48 240 roundabout
-0.219144 -0.517257 36* Junct 0.017 0.02 0.61 0.7 48 199 roundabout
-0.219145 -0.517626 33* Junct 0.041 0.05 0.65 0.8 48 269 top road
-0.219135 -0.518823 23* Junct 0.133 0.17 0.79 0.9 48 270 top road
-0.219131 -0.519426 20* Junct 0.067 0.08 0.85 1.0 48 270 top road
-0.218482 -0.519542 18* Inter 0.073 0.09 0.93 1.1 48 349 loop 4
-0.218258 -0.519789 16 Inter 0.037 0.04 0.96 1.1 48 312 loop 4
-0.218474 -0.520060 14* Waypt 0.038 0.05 1.00 1.2 48 231 loop 4
-0.219123 -0.520207 12* Junct 0.074 0.09 1.07 1.3 48 192 loop 4
-0.219107 -0.520828 6* Junct 0.069 0.09 1.14 1.4 48 271 top road
-0.220666 -0.520893 5* Junct- 0.173 0.11 1.32 1.5 96 182 main 1
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.39 1.5 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.41 1.5 96 181 main 1
routino-2.4.1/src/test/expected/turns-WP02.txt 644 233 144 2403 12063560525 14341 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct- 0.072 0.04 0.07 0.0 96 182 main 1
-0.220666 -0.520893 5* Junct 0.173 0.11 0.24 0.2 96 182 main 1
-0.220671 -0.520223 11* Junct 0.074 0.09 0.32 0.2 48 90 high street
-0.220691 -0.519461 19* Junct 0.084 0.10 0.40 0.3 48 91 high street
-0.220111 -0.519553 17 Inter 0.065 0.08 0.47 0.4 48 351 loop 1
-0.219817 -0.519807 15 Inter 0.043 0.05 0.51 0.5 48 319 loop 1
-0.220067 -0.520109 13* Waypt 0.043 0.05 0.55 0.5 48 230 loop 1
-0.220671 -0.520223 11* Junct 0.068 0.09 0.62 0.6 48 190 loop 1
-0.220666 -0.520893 5* Junct 0.074 0.09 0.70 0.7 48 270 high street
-0.221308 -0.520914 4* Junct- 0.071 0.04 0.77 0.8 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 0.79 0.8 96 181 main 1
routino-2.4.1/src/test/expected/turns-WP08.txt 644 233 144 4461 12063560525 14355 0 # Creator : Routino - http://www.routino.org/
# Source : Routino test cases - (c) Andrew M. Bishop
# License : GNU Affero General Public License v3 or later
#
#Latitude Longitude Node Type Segment Segment Total Total Speed Bearing Highway
# Dist Durat'n Dist Durat'n
-0.218453 -0.520799 -1 Waypt 0.000 0.00 0.00 0.0
-0.219107 -0.520828 6* Junct 0.072 0.04 0.07 0.0 96 182 main 1
-0.219123 -0.520207 12* Junct 0.069 0.09 0.14 0.1 48 91 top road
-0.219131 -0.519426 20* Junct 0.086 0.11 0.23 0.2 48 90 top road
-0.219135 -0.518823 23* Junct 0.067 0.08 0.29 0.3 48 90 top road
-0.219145 -0.517626 33* Junct 0.133 0.17 0.43 0.5 48 90 top road
-0.219144 -0.517257 36* Junct 0.041 0.05 0.47 0.5 48 89 top road
-0.219291 -0.517193 38 Inter 0.017 0.02 0.48 0.6 48 156 roundabout
-0.219352 -0.517060 42 Junct- 0.016 0.02 0.50 0.6 48 114 roundabout
-0.219304 -0.516904 45 Inter 0.018 0.02 0.52 0.6 48 72 roundabout
-0.219153 -0.516826 46* Junct 0.018 0.02 0.54 0.6 48 27 roundabout
-0.219184 -0.515968 55* Junct 0.095 0.12 0.63 0.7 48 92 top road
-0.220784 -0.516035 54* Junct 0.178 0.11 0.81 0.8 96 182 main 2
-0.220760 -0.516647 48* Junct 0.068 0.09 0.88 0.9 48 272 high street
-0.220097 -0.516762 47* Inter 0.074 0.09 0.95 1.0 48 350 loop 3
-0.219872 -0.517009 43 Inter 0.037 0.04 0.99 1.1 48 312 loop 3
-0.220089 -0.517279 35* Waypt 0.038 0.05 1.03 1.1 48 231 loop 3
-0.220739 -0.517425 34* Junct 0.074 0.09 1.10 1.2 48 192 loop 3
-0.220724 -0.518071 31* Junct 0.071 0.09 1.17 1.3 48 271 high street
-0.220708 -0.518842 22* Junct 0.085 0.10 1.26 1.4 48 271 high street
-0.220691 -0.519461 19* Junct 0.069 0.09 1.33 1.5 48 271 high street
-0.220671 -0.520223 11* Junct 0.084 0.10 1.41 1.6 48 271 high street
-0.220666 -0.520893 5* Junct 0.074 0.09 1.48 1.7 48 270 high street
-0.221308 -0.520914 4* Junct- 0.071 0.04 1.55 1.7 96 181 main 1
-0.221561 -0.520922 -3 Waypt 0.027 0.02 1.58 1.7 96 181 main 1
routino-2.4.1/src/test/start-1-finish.sh 755 233 144 4441 12063560525 13252 0 #!/bin/sh
# Exit on error
set -e
# Test name
name=`basename $0 .sh`
# Slim or non-slim
if [ "$1" = "slim" ]; then
slim="-slim"
dir="slim"
else
slim=""
dir="fat"
fi
# Pruned or non-pruned
if [ "$2" = "prune" ]; then
prune=""
pruned="-pruned"
else
prune="--prune-none"
pruned=""
fi
# Create the output directory
dir="$dir$pruned"
[ -d $dir ] || mkdir $dir
# Run the programs under a run-time debugger
debugger=valgrind
debugger=
# Name related options
osm=$name.osm
log=$name$slim$pruned.log
option_prefix="--prefix=$name"
option_dir="--dir=$dir"
# Generic program options
option_planetsplitter="--loggable --tagging=../../xml/routino-tagging.xml --errorlog $prune"
option_filedumper="--dump-osm"
option_router="--loggable --transport=motorcar --profiles=../../xml/routino-profiles.xml --translations=copyright.xml"
# Run planetsplitter
echo "Running planetsplitter"
echo ../planetsplitter$slim $option_dir $option_prefix $option_planetsplitter $osm > $log
$debugger ../planetsplitter$slim $option_dir $option_prefix $option_planetsplitter $osm >> $log
# Run filedumper
echo "Running filedumper"
echo ../filedumper$slim $option_dir $option_prefix $option_filedumper >> $log
$debugger ../filedumper$slim $option_dir $option_prefix $option_filedumper > $dir/$osm
# Waypoints
waypoints=`perl waypoints.pl $osm list`
waypoint_start=`perl waypoints.pl $osm WPstart 1`
waypoint_finish=`perl waypoints.pl $osm WPfinish 3`
# Run the router for each waypoint
for waypoint in $waypoints; do
[ ! $waypoint = "WPstart" ] || continue
[ ! $waypoint = "WPfinish" ] || continue
echo "Running router : $waypoint"
waypoint_test=`perl waypoints.pl $osm $waypoint 2`
[ -d $dir/$name-$waypoint ] || mkdir $dir/$name-$waypoint
echo ../router$slim $option_dir $option_prefix $option_osm $option_router $waypoint_start $waypoint_test $waypoint_finish >> $log
$debugger ../router$slim $option_dir $option_prefix $option_osm $option_router $waypoint_start $waypoint_test $waypoint_finish >> $log
mv shortest* $dir/$name-$waypoint
if [ "$pruned" = "" ]; then
echo diff -u expected/$name-$waypoint.txt $dir/$name-$waypoint/shortest-all.txt >> $log
diff -u expected/$name-$waypoint.txt $dir/$name-$waypoint/shortest-all.txt >> $log
fi
done
routino-2.4.1/src/test/no-super.sh 777 233 144 0 12063560525 13373 2a-b-c.sh routino-2.4.1/src/test/invalid-turn-relations.sh 777 233 144 0 12063560525 17470 2only-split.sh routino-2.4.1/src/test/a-b-c.sh 755 233 144 4447 12063560525 11366 0 #!/bin/sh
# Exit on error
set -e
# Test name
name=`basename $0 .sh`
# Slim or non-slim
if [ "$1" = "slim" ]; then
slim="-slim"
dir="slim"
else
slim=""
dir="fat"
fi
# Pruned or non-pruned
if [ "$2" = "prune" ]; then
prune=""
pruned="-pruned"
else
prune="--prune-none"
pruned=""
fi
# Create the output directory
dir="$dir$pruned"
[ -d $dir ] || mkdir $dir
# Run the programs under a run-time debugger
debugger=valgrind
debugger=
# Name related options
osm=$name.osm
log=$name$slim$pruned.log
option_prefix="--prefix=$name"
option_dir="--dir=$dir"
# Generic program options
option_planetsplitter="--loggable --tagging=../../xml/routino-tagging.xml --errorlog $prune"
option_filedumper="--dump-osm"
option_router="--loggable --transport=motorcar --profiles=../../xml/routino-profiles.xml --translations=copyright.xml"
# Run planetsplitter
echo "Running planetsplitter"
echo ../planetsplitter$slim $option_dir $option_prefix $option_planetsplitter $osm > $log
$debugger ../planetsplitter$slim $option_dir $option_prefix $option_planetsplitter $osm >> $log
# Run filedumper
echo "Running filedumper"
echo ../filedumper$slim $option_dir $option_prefix $option_filedumper >> $log
$debugger ../filedumper$slim $option_dir $option_prefix $option_filedumper > $dir/$osm
# Waypoints
waypoints=`perl waypoints.pl $osm list`
# Run the router for each waypoint
for waypoint in $waypoints; do
case $waypoint in
*a) waypoint=`echo $waypoint | sed -e 's%a$%%'` ;;
*) continue ;;
esac
echo "Running router : $waypoint"
waypoint_a=`perl waypoints.pl $osm ${waypoint}a 1`
waypoint_b=`perl waypoints.pl $osm ${waypoint}b 2`
waypoint_c=`perl waypoints.pl $osm ${waypoint}c 3`
[ -d $dir/$name-$waypoint ] || mkdir $dir/$name-$waypoint
echo ../router$slim $option_dir $option_prefix $option_osm $option_router $waypoint_a $waypoint_b $waypoint_c >> $log
$debugger ../router$slim $option_dir $option_prefix $option_osm $option_router $waypoint_a $waypoint_b $waypoint_c >> $log
mv shortest* $dir/$name-$waypoint
if [ "$pruned" = "" ]; then
echo diff -u expected/$name-$waypoint.txt $dir/$name-$waypoint/shortest-all.txt >> $log
diff -u expected/$name-$waypoint.txt $dir/$name-$waypoint/shortest-all.txt >> $log
fi
done
routino-2.4.1/src/results.c 644 233 144 16515 12063560526 11056 0 /***************************************
Result data type functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include "results.h"
#include "logging.h"
/*+ The maximum number of collisions in a bin for the Results 'point' arrays before worrying. +*/
#define MAX_COLLISIONS 32
/*++++++++++++++++++++++++++++++++++++++
Allocate a new results list.
Results *NewResultsList Returns the results list.
int nbins The initial number of bins in the results array.
++++++++++++++++++++++++++++++++++++++*/
Results *NewResultsList(int nbins)
{
Results *results;
results=(Results*)malloc(sizeof(Results));
results->nbins=1;
results->mask=~0;
while(nbins>>=1)
{
results->mask<<=1;
results->nbins<<=1;
}
results->mask=~results->mask;
results->number=0;
results->npoint1=0;
results->count=(uint8_t*)calloc(results->nbins,sizeof(uint8_t));
results->point=(Result***)malloc(MAX_COLLISIONS*sizeof(Result**));
results->ndata1=0;
results->ndata2=results->nbins;
results->data=NULL;
results->start_node=NO_NODE;
results->prev_segment=NO_SEGMENT;
results->finish_node=NO_NODE;
results->last_segment=NO_SEGMENT;
return(results);
}
/*++++++++++++++++++++++++++++++++++++++
Free a results list.
Results *results The results list to be destroyed.
++++++++++++++++++++++++++++++++++++++*/
void FreeResultsList(Results *results)
{
int i;
for(i=0;indata1;i++)
free(results->data[i]);
free(results->data);
for(i=0;inpoint1;i++)
free(results->point[i]);
free(results->point);
free(results->count);
free(results);
}
/*++++++++++++++++++++++++++++++++++++++
Insert a new result into the results data structure in the right order.
Result *InsertResult Returns the result that has been inserted.
Results *results The results structure to insert into.
index_t node The node that is to be inserted into the results.
index_t segment The segment that is to be inserted into the results.
++++++++++++++++++++++++++++++++++++++*/
Result *InsertResult(Results *results,index_t node,index_t segment)
{
Result *result;
int bin=node&results->mask;
/* Check if we have hit the limit on the number of collisions per bin */
if(results->count[bin]>MAX_COLLISIONS && results->count[bin]==results->npoint1)
{
int i,j,k;
results->nbins<<=1;
results->mask=(results->mask<<1)|1;
results->count=(uint8_t*)realloc((void*)results->count,results->nbins*sizeof(uint8_t));
for(i=0;inpoint1;i++)
results->point[i]=(Result**)realloc((void*)results->point[i],results->nbins*sizeof(Result*));
for(i=0;inbins/2;i++)
{
int c=results->count[i];
results->count[i+results->nbins/2]=0;
for(j=0,k=0;jpoint[j][i]->node&results->mask;
if(newbin==i)
{
if(k!=j)
results->point[k][i]=results->point[j][i];
k++;
}
else
{
results->point[results->count[newbin]][newbin]=results->point[j][i];
results->count[newbin]++;
results->count[i]--;
}
}
}
bin=node&results->mask;
}
/* Check that the arrays have enough space or allocate more. */
if(results->count[bin]==results->npoint1)
{
logassert(results->npoint1<255,"Results are more numerous than expected (report a bug)");
results->npoint1++;
if(results->npoint1>MAX_COLLISIONS)
results->point=(Result***)realloc((void*)results->point,results->npoint1*sizeof(Result**));
results->point[results->npoint1-1]=(Result**)malloc(results->nbins*sizeof(Result*));
}
if((results->number%results->ndata2)==0)
{
results->ndata1++;
results->data=(Result**)realloc((void*)results->data,results->ndata1*sizeof(Result*));
results->data[results->ndata1-1]=(Result*)malloc(results->ndata2*sizeof(Result));
}
/* Insert the new entry */
results->point[results->count[bin]][bin]=&results->data[results->ndata1-1][results->number%results->ndata2];
results->number++;
results->count[bin]++;
/* Initialise the result */
result=results->point[results->count[bin]-1][bin];
result->node=node;
result->segment=segment;
result->prev=NULL;
result->next=NULL;
result->score=0;
result->sortby=0;
result->queued=NOT_QUEUED;
return(result);
}
/*++++++++++++++++++++++++++++++++++++++
Find a result; search by node only (don't care about the segment but find the shortest).
Result *FindResult1 Returns the result that has been found.
Results *results The results structure to search.
index_t node The node that is to be found.
++++++++++++++++++++++++++++++++++++++*/
Result *FindResult1(Results *results,index_t node)
{
int bin=node&results->mask;
score_t best_score=INF_SCORE;
Result *best_result=NULL;
int i;
for(i=results->count[bin]-1;i>=0;i--)
if(results->point[i][bin]->node==node && results->point[i][bin]->scorepoint[i][bin]->score;
best_result=results->point[i][bin];
}
return(best_result);
}
/*++++++++++++++++++++++++++++++++++++++
Find a result; search by node and segment.
Result *FindResult Returns the result that has been found.
Results *results The results structure to search.
index_t node The node that is to be found.
index_t segment The segment that was used to reach this node.
++++++++++++++++++++++++++++++++++++++*/
Result *FindResult(Results *results,index_t node,index_t segment)
{
int bin=node&results->mask;
int i;
for(i=results->count[bin]-1;i>=0;i--)
if(results->point[i][bin]->segment==segment && results->point[i][bin]->node==node)
return(results->point[i][bin]);
return(NULL);
}
/*++++++++++++++++++++++++++++++++++++++
Find the first result from a set of results.
Result *FirstResult Returns the first result.
Results *results The set of results.
++++++++++++++++++++++++++++++++++++++*/
Result *FirstResult(Results *results)
{
return(&results->data[0][0]);
}
/*++++++++++++++++++++++++++++++++++++++
Find the next result from a set of results.
Result *NextResult Returns the next result.
Results *results The set of results.
Result *result The previous result.
++++++++++++++++++++++++++++++++++++++*/
Result *NextResult(Results *results,Result *result)
{
int i,j=0;
for(i=0;indata1;i++)
{
j=result-results->data[i];
if(j>=0 && jndata2)
break;
}
if(++j>=results->ndata2)
{i++;j=0;}
if((i*results->ndata2+j)>=results->number)
return(NULL);
return(&results->data[i][j]);
}
routino-2.4.1/src/Makefile 644 233 144 12566 12063560526 10653 0 # Source code Makefile
#
# Part of the Routino routing software.
#
# This file Copyright 2008-2012 Andrew M. Bishop
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see .
#
# Web file paths
WEBDIR=../web/bin
# Compilation programs
CC=gcc
LD=gcc
LEX=flex
# Compilation program options
CFLAGS=-Wall -Wmissing-prototypes -std=c99
#CFLAGS+=-Wextra -pedantic
LDFLAGS=-lm
CFLAGS+=-O3
#CFLAGS+=-O0 -g
#CFLAGS+=-pg
#CFLAGS+=-fprofile-arcs -ftest-coverage
#LDFLAGS+=-pg -static
#LDFLAGS+=-fprofile-arcs -ftest-coverage
LEXFLAGS=
# Required for multi-threaded support
CFLAGS+=-pthread -DUSE_PTHREADS
LDFLAGS+=-pthread -lpthread
# Required to use stdio with files > 2GiB on 32-bit system.
CFLAGS+=-D_FILE_OFFSET_BITS=64
# Required to compile on Linux without a warning about pread() and pwrite() functions.
CFLAGS+=-D_POSIX_C_SOURCE=200809L
# Compilation targets
C=$(wildcard *.c)
D=$(wildcard .deps/*.d)
EXE=planetsplitter planetsplitter-slim router router-slim filedumperx filedumper filedumper-slim tagmodifier
########
all: $(EXE)
-@[ -d $(WEBDIR) ] && \
for file in $(EXE); do \
if [ ! -f $(WEBDIR)/$$file ] || [ $$file -nt $(WEBDIR)/$$file ]; then \
echo cp $$file $(WEBDIR) ;\
cp -f $$file $(WEBDIR) ;\
fi ;\
done
@cd xml && $(MAKE) CC="$(CC)" LD="$(LD)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS)"
@cd test && $(MAKE) CC="$(CC)" LD="$(LD)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS)"
########
PLANETSPLITTER_OBJ=planetsplitter.o \
nodesx.o segmentsx.o waysx.o relationsx.o superx.o prunex.o \
ways.o types.o \
files.o logging.o \
results.o queue.o sorting.o \
xmlparse.o tagging.o osmparser.o
planetsplitter : $(PLANETSPLITTER_OBJ)
$(LD) $(PLANETSPLITTER_OBJ) -o $@ $(LDFLAGS)
########
PLANETSPLITTER_SLIM_OBJ=planetsplitter-slim.o \
nodesx-slim.o segmentsx-slim.o waysx-slim.o relationsx-slim.o superx-slim.o prunex-slim.o \
ways.o types.o \
files.o logging.o \
results.o queue.o sorting.o \
xmlparse.o tagging.o osmparser.o
planetsplitter-slim : $(PLANETSPLITTER_SLIM_OBJ)
$(LD) $(PLANETSPLITTER_SLIM_OBJ) -o $@ $(LDFLAGS)
########
ROUTER_OBJ=router.o \
nodes.o segments.o ways.o relations.o types.o fakes.o \
optimiser.o output.o \
files.o logging.o profiles.o xmlparse.o \
results.o queue.o translations.o
router : $(ROUTER_OBJ)
$(LD) $(ROUTER_OBJ) -o $@ $(LDFLAGS)
########
ROUTER_SLIM_OBJ=router-slim.o \
nodes-slim.o segments-slim.o ways-slim.o relations-slim.o types.o fakes-slim.o \
optimiser-slim.o output-slim.o \
files.o logging.o profiles.o xmlparse.o \
results.o queue.o translations.o
router-slim : $(ROUTER_SLIM_OBJ)
$(LD) $(ROUTER_SLIM_OBJ) -o $@ $(LDFLAGS)
########
FILEDUMPERX_OBJ=filedumperx.o \
files.o logging.o
filedumperx : $(FILEDUMPERX_OBJ)
$(LD) $(FILEDUMPERX_OBJ) -o $@ $(LDFLAGS)
########
FILEDUMPER_OBJ=filedumper.o \
nodes.o segments.o ways.o relations.o types.o fakes.o \
visualiser.o \
files.o logging.o xmlparse.o
filedumper : $(FILEDUMPER_OBJ)
$(LD) $(FILEDUMPER_OBJ) -o $@ $(LDFLAGS)
########
FILEDUMPER_SLIM_OBJ=filedumper-slim.o \
nodes-slim.o segments-slim.o ways-slim.o relations-slim.o types.o fakes-slim.o \
visualiser-slim.o \
files.o logging.o xmlparse.o
filedumper-slim : $(FILEDUMPER_SLIM_OBJ)
$(LD) $(FILEDUMPER_SLIM_OBJ) -o $@ $(LDFLAGS)
########
TAGMODIFIER_OBJ=tagmodifier.o \
files.o logging.o \
xmlparse.o tagging.o
tagmodifier : $(TAGMODIFIER_OBJ)
$(LD) $(TAGMODIFIER_OBJ) -o $@ $(LDFLAGS)
########
xmlparse.c : xmlparse.l
$(LEX) $(LEXFLAGS) $<
-@mv lex.yy.c xmlparse.c
@echo Created xmlparse.c
########
%.o : %.c
@[ -d .deps ] || mkdir .deps
$(CC) -c $(CFLAGS) -DSLIM=0 -DDATADIR=\"$(datadir)\" $< -o $@ -MMD -MP -MF $(addprefix .deps/,$(addsuffix .d,$(basename $@)))
%-slim.o : %.c
@[ -d .deps ] || mkdir .deps
$(CC) -c $(CFLAGS) -DSLIM=1 -DDATADIR=\"$(datadir)\" $< -o $@ -MMD -MP -MF $(addprefix .deps/,$(addsuffix .d,$(basename $@)))
########
test:
cd xml && $(MAKE) test
cd test && $(MAKE) test
########
install: all
-[ -d $(DESTDIR)$(bindir) ] || mkdir -p $(DESTDIR)$(bindir)
@[ -d $(DESTDIR)$(bindir) ] && \
for file in $(EXE); do \
echo cp $$file $(DESTDIR)$(bindir) ;\
cp -f $$file $(DESTDIR)$(bindir) ;\
done
########
clean:
rm -f *~
rm -f *.o
rm -f core
rm -f *.gcda *.gcno *.gcov gmon.out
rm -f xmlparse.c
cd xml && $(MAKE) clean
cd test && $(MAKE) clean
########
distclean: clean
-[ -d ../web/bin ] && cd ../web/bin/ && rm -f $(EXE)
-rm -f $(EXE)
-rm -f $(D)
-rm -fr .deps
cd xml && $(MAKE) distclean
cd test && $(MAKE) distclean
########
include $(D)
########
top=-top
include ../Makefile
routino-2.4.1/src/nodesx.c 644 233 144 44332 12063562207 10651 0 /***************************************
Extented Node data type functions.
Part of the Routino routing software.
******************/ /******************
This file Copyright 2008-2012 Andrew M. Bishop
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
***************************************/
#include
#include
#include "types.h"
#include "nodes.h"
#include "typesx.h"
#include "nodesx.h"
#include "segmentsx.h"
#include "waysx.h"
#include "files.h"
#include "logging.h"
#include "sorting.h"
/* Global variables */
/*+ The command line '--tmpdir' option or its default value. +*/
extern char *option_tmpdirname;
/* Local variables */
/*+ Temporary file-local variables for use by the sort functions. +*/
static NodesX *sortnodesx;
static latlong_t lat_min,lat_max,lon_min,lon_max;
/* Local functions */
static int sort_by_id(NodeX *a,NodeX *b);
static int deduplicate_and_index_by_id(NodeX *nodex,index_t index);
static int sort_by_lat_long(NodeX *a,NodeX *b);
static int index_by_lat_long(NodeX *nodex,index_t index);
/*++++++++++++++++++++++++++++++++++++++
Allocate a new node list (create a new file or open an existing one).
NodesX *NewNodeList Returns a pointer to the node list.
int append Set to 1 if the file is to be opened for appending.
int readonly Set to 1 if the file is to be opened for reading.
++++++++++++++++++++++++++++++++++++++*/
NodesX *NewNodeList(int append,int readonly)
{
NodesX *nodesx;
nodesx=(NodesX*)calloc(1,sizeof(NodesX));
logassert(nodesx,"Failed to allocate memory (try using slim mode?)"); /* Check calloc() worked */
nodesx->filename =(char*)malloc(strlen(option_tmpdirname)+32);
nodesx->filename_tmp=(char*)malloc(strlen(option_tmpdirname)+32);
sprintf(nodesx->filename ,"%s/nodesx.parsed.mem",option_tmpdirname);
sprintf(nodesx->filename_tmp,"%s/nodesx.%p.tmp" ,option_tmpdirname,(void*)nodesx);
if(append || readonly)
if(ExistsFile(nodesx->filename))
{
off_t size;
size=SizeFile(nodesx->filename);
nodesx->number=size/sizeof(NodeX);
RenameFile(nodesx->filename,nodesx->filename_tmp);
}
if(append)
nodesx->fd=OpenFileAppend(nodesx->filename_tmp);
else if(!readonly)
nodesx->fd=OpenFileNew(nodesx->filename_tmp);
else
nodesx->fd=-1;
return(nodesx);
}
/*++++++++++++++++++++++++++++++++++++++
Free a node list.
NodesX *nodesx The set of nodes to be freed.
int keep If set then the results file is to be kept.
++++++++++++++++++++++++++++++++++++++*/
void FreeNodeList(NodesX *nodesx,int keep)
{
if(keep)
RenameFile(nodesx->filename_tmp,nodesx->filename);
else
DeleteFile(nodesx->filename_tmp);
free(nodesx->filename);
free(nodesx->filename_tmp);
if(nodesx->idata)
free(nodesx->idata);
if(nodesx->gdata)
free(nodesx->gdata);
if(nodesx->pdata)
free(nodesx->pdata);
if(nodesx->super)
free(nodesx->super);
free(nodesx);
}
/*++++++++++++++++++++++++++++++++++++++
Append a single node to an unsorted node list.
NodesX *nodesx The set of nodes to modify.
node_t id The node identifier from the original OSM data.
double latitude The latitude of the node.
double longitude The longitude of the node.
transports_t allow The allowed traffic types through the node.
nodeflags_t flags The flags to set for this node.
++++++++++++++++++++++++++++++++++++++*/
void AppendNodeList(NodesX *nodesx,node_t id,double latitude,double longitude,transports_t allow,nodeflags_t flags)
{
NodeX nodex;
nodex.id=id;
nodex.latitude =radians_to_latlong(latitude);
nodex.longitude=radians_to_latlong(longitude);
nodex.allow=allow;
nodex.flags=flags;
WriteFile(nodesx->fd,&nodex,sizeof(NodeX));
nodesx->number++;
logassert(nodesx->numberfd!=-1)
nodesx->fd=CloseFile(nodesx->fd);
}
/*++++++++++++++++++++++++++++++++++++++
Find a particular node index.
index_t IndexNodeX Returns the index of the extended node with the specified id.
NodesX *nodesx The set of nodes to use.
node_t id The node id to look for.
++++++++++++++++++++++++++++++++++++++*/
index_t IndexNodeX(NodesX *nodesx,node_t id)
{
index_t start=0;
index_t end=nodesx->number-1;
index_t mid;
if(nodesx->number==0) /* No nodes */
return(NO_NODE);
if(ididata[start]) /* Key is before start */
return(NO_NODE);
if(id>nodesx->idata[end]) /* Key is after end */
return(NO_NODE);
/* Binary search - search key exact match only is required.
*
* # <- start | Check mid and move start or end if it doesn't match
* # |
* # | Since an exact match is wanted we can set end=mid-1
* # <- mid | or start=mid+1 because we know that mid doesn't match.
* # |
* # | Eventually either end=start or end=start+1 and one of
* # <- end | start or end is the wanted one.
*/
do
{
mid=(start+end)/2; /* Choose mid point */
if(nodesx->idata[mid]idata[mid]>id) /* Mid point is too high */
end=mid?(mid-1):mid;
else /* Mid point is correct */
return(mid);
}
while((end-start)>1);
if(nodesx->idata[start]==id) /* Start is correct */
return(start);
if(nodesx->idata[end]==id) /* End is correct */
return(end);
return(NO_NODE);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the node list.
NodesX *nodesx The set of nodes to modify.
++++++++++++++++++++++++++++++++++++++*/
void SortNodeList(NodesX *nodesx)
{
int fd;
index_t xnumber;
/* Print the start message */
printf_first("Sorting Nodes");
/* Re-open the file read-only and a new file writeable */
nodesx->fd=ReOpenFile(nodesx->filename_tmp);
DeleteFile(nodesx->filename_tmp);
fd=OpenFileNew(nodesx->filename_tmp);
/* Allocate the array of indexes */
nodesx->idata=(node_t*)malloc(nodesx->number*sizeof(node_t));
logassert(nodesx->idata,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Sort the nodes by ID and index them */
xnumber=nodesx->number;
sortnodesx=nodesx;
nodesx->number=filesort_fixed(nodesx->fd,fd,sizeof(NodeX),NULL,
(int (*)(const void*,const void*))sort_by_id,
(int (*)(void*,index_t))deduplicate_and_index_by_id);
/* Close the files */
nodesx->fd=CloseFile(nodesx->fd);
CloseFile(fd);
/* Print the final message */
printf_last("Sorted Nodes: Nodes=%"Pindex_t" Duplicates=%"Pindex_t,xnumber,xnumber-nodesx->number);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the nodes into id order.
int sort_by_id Returns the comparison of the id fields.
NodeX *a The first extended node.
NodeX *b The second extended node.
++++++++++++++++++++++++++++++++++++++*/
static int sort_by_id(NodeX *a,NodeX *b)
{
node_t a_id=a->id;
node_t b_id=b->id;
if(a_idb_id)
return(1);
else
return(-FILESORT_PRESERVE_ORDER(a,b)); /* latest version first */
}
/*++++++++++++++++++++++++++++++++++++++
Create the index of identifiers and discard duplicate nodes.
int deduplicate_and_index_by_id Return 1 if the value is to be kept, otherwise 0.
NodeX *nodex The extended node.
index_t index The number of sorted nodes that have already been written to the output file.
++++++++++++++++++++++++++++++++++++++*/
static int deduplicate_and_index_by_id(NodeX *nodex,index_t index)
{
static node_t previd=NO_NODE_ID;
if(nodex->id!=previd)
{
previd=nodex->id;
if(nodex->flags&NODE_DELETED)
return(0);
else
{
sortnodesx->idata[index]=nodex->id;
return(1);
}
}
else
return(0);
}
/*++++++++++++++++++++++++++++++++++++++
Remove any nodes that are not part of a highway.
NodesX *nodesx The set of nodes to modify.
SegmentsX *segmentsx The set of segments to use.
int keep If set to 1 then keep the old data file otherwise delete it.
++++++++++++++++++++++++++++++++++++++*/
void RemoveNonHighwayNodes(NodesX *nodesx,SegmentsX *segmentsx,int keep)
{
NodeX nodex;
index_t total=0,highway=0,nothighway=0;
int fd;
/* Print the start message */
printf_first("Checking Nodes: Nodes=0");
/* Re-open the file read-only and a new file writeable */
nodesx->fd=ReOpenFile(nodesx->filename_tmp);
if(keep)
RenameFile(nodesx->filename_tmp,nodesx->filename);
else
DeleteFile(nodesx->filename_tmp);
fd=OpenFileNew(nodesx->filename_tmp);
/* Modify the on-disk image */
while(!ReadFile(nodesx->fd,&nodex,sizeof(NodeX)))
{
if(!IsBitSet(segmentsx->usednode,total))
nothighway++;
else
{
nodex.id=highway;
nodesx->idata[highway]=nodesx->idata[total];
WriteFile(fd,&nodex,sizeof(NodeX));
highway++;
}
total++;
if(!(total%10000))
printf_middle("Checking Nodes: Nodes=%"Pindex_t" Highway=%"Pindex_t" not-Highway=%"Pindex_t,total,highway,nothighway);
}
nodesx->number=highway;
/* Close the files */
nodesx->fd=CloseFile(nodesx->fd);
CloseFile(fd);
/* Free the now-unneeded index */
free(segmentsx->usednode);
segmentsx->usednode=NULL;
/* Print the final message */
printf_last("Checked Nodes: Nodes=%"Pindex_t" Highway=%"Pindex_t" not-Highway=%"Pindex_t,total,highway,nothighway);
}
/*++++++++++++++++++++++++++++++++++++++
Remove any nodes that have been pruned.
NodesX *nodesx The set of nodes to prune.
SegmentsX *segmentsx The set of segments to use.
++++++++++++++++++++++++++++++++++++++*/
void RemovePrunedNodes(NodesX *nodesx,SegmentsX *segmentsx)
{
NodeX nodex;
index_t total=0,pruned=0,notpruned=0;
int fd;
if(nodesx->number==0)
return;
/* Print the start message */
printf_first("Deleting Pruned Nodes: Nodes=0 Pruned=0");
/* Allocate the array of indexes */
nodesx->pdata=(index_t*)malloc(nodesx->number*sizeof(index_t));
logassert(nodesx->pdata,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Re-open the file read-only and a new file writeable */
nodesx->fd=ReOpenFile(nodesx->filename_tmp);
DeleteFile(nodesx->filename_tmp);
fd=OpenFileNew(nodesx->filename_tmp);
/* Modify the on-disk image */
while(!ReadFile(nodesx->fd,&nodex,sizeof(NodeX)))
{
if(segmentsx->firstnode[total]==NO_SEGMENT)
{
pruned++;
nodesx->pdata[total]=NO_NODE;
}
else
{
nodex.id=notpruned;
nodesx->pdata[total]=notpruned;
WriteFile(fd,&nodex,sizeof(NodeX));
notpruned++;
}
total++;
if(!(total%10000))
printf_middle("Deleting Pruned Nodes: Nodes=%"Pindex_t" Pruned=%"Pindex_t,total,pruned);
}
nodesx->number=notpruned;
/* Close the files */
nodesx->fd=CloseFile(nodesx->fd);
CloseFile(fd);
/* Print the final message */
printf_last("Deleted Pruned Nodes: Nodes=%"Pindex_t" Pruned=%"Pindex_t,total,pruned);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the node list geographically.
NodesX *nodesx The set of nodes to modify.
++++++++++++++++++++++++++++++++++++++*/
void SortNodeListGeographically(NodesX *nodesx)
{
int fd;
ll_bin_t lat_min_bin,lat_max_bin,lon_min_bin,lon_max_bin;
if(nodesx->number==0)
return;
/* While we are here we can work out the range of data */
lat_min=radians_to_latlong( 2);
lat_max=radians_to_latlong(-2);
lon_min=radians_to_latlong( 4);
lon_max=radians_to_latlong(-4);
/* Print the start message */
printf_first("Sorting Nodes Geographically");
/* Allocate the memory for the geographical index array */
nodesx->gdata=(index_t*)malloc(nodesx->number*sizeof(index_t));
logassert(nodesx->gdata,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Re-open the file read-only and a new file writeable */
nodesx->fd=ReOpenFile(nodesx->filename_tmp);
DeleteFile(nodesx->filename_tmp);
fd=OpenFileNew(nodesx->filename_tmp);
/* Sort nodes geographically and index them */
sortnodesx=nodesx;
filesort_fixed(nodesx->fd,fd,sizeof(NodeX),NULL,
(int (*)(const void*,const void*))sort_by_lat_long,
(int (*)(void*,index_t))index_by_lat_long);
/* Close the files */
nodesx->fd=CloseFile(nodesx->fd);
CloseFile(fd);
/* Free the memory */
free(nodesx->super);
nodesx->super=NULL;
/* Work out the number of bins */
lat_min_bin=latlong_to_bin(lat_min);
lon_min_bin=latlong_to_bin(lon_min);
lat_max_bin=latlong_to_bin(lat_max);
lon_max_bin=latlong_to_bin(lon_max);
nodesx->latzero=lat_min_bin;
nodesx->lonzero=lon_min_bin;
nodesx->latbins=(lat_max_bin-lat_min_bin)+1;
nodesx->lonbins=(lon_max_bin-lon_min_bin)+1;
/* Print the final message */
printf_last("Sorted Nodes Geographically: Nodes=%"Pindex_t,nodesx->number);
}
/*++++++++++++++++++++++++++++++++++++++
Sort the nodes into latitude and longitude order (first by longitude bin
number, then by latitude bin number and then by exact longitude and then by
exact latitude).
int sort_by_lat_long Returns the comparison of the latitude and longitude fields.
NodeX *a The first extended node.
NodeX *b The second extended node.
++++++++++++++++++++++++++++++++++++++*/
static int sort_by_lat_long(NodeX *a,NodeX *b)
{
ll_bin_t a_lon=latlong_to_bin(a->longitude);
ll_bin_t b_lon=latlong_to_bin(b->longitude);
if(a_lon