static int relationType_function(const char *_tag_,int _type_,const char *id)
{
static int64_t llid; /* static variable to store attributes from <relation> tag until </relation> tag */
if(_type_&XMLPARSE_TAG_START)
{
nrelations++;
if(!(nrelations%1000))
printf_middle("Reading: Lines=%"PRIu64" Nodes=%"PRIu64" Ways=%"PRIu64" Relations=%"PRIu64,ParseXML_LineNumber(),nnodes,nways,nrelations);
current_tags=NewTagList();
AddRelationRefs(0,0,0,NULL);
/* Handle the relation information */
XMLPARSE_ASSERT_INTEGER(_tag_,id); llid=atoll(id); /* need int64_t conversion */
}
if(_type_&XMLPARSE_TAG_END)
{
TagList *result=ApplyRelationTaggingRules(current_tags,llid);
ProcessRelationTags(result,llid,current_mode);
DeleteTagList(current_tags); current_tags=NULL;
DeleteTagList(result);
}
return(0);
}
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=ReOpenFileBuffered(segmentsx->filename_tmp);
/* Read the on-disk image */
while(!ReadFileBuffered(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=CloseFileBuffered(segmentsx->fd);
/* Print the final message */
printf_last("Added Extra Segment Indexes: Segments=%"Pindex_t,segmentsx->number);
}
void UpdateNodes(NodesX *nodesx,SegmentsX *segmentsx)
{
index_t i;
int fd;
/* Print the start message */
printf_first("Updating Super Nodes: Nodes=0");
/* Re-open the file read-only and a new file writeable */
nodesx->fd=ReOpenFile(nodesx->filename);
DeleteFile(nodesx->filename);
fd=OpenFileNew(nodesx->filename);
/* Modify the on-disk image */
for(i=0;i<nodesx->number;i++)
{
NodeX nodex;
ReadFile(nodesx->fd,&nodex,sizeof(NodeX));
if(IsBitSet(nodesx->super,nodex.id))
nodex.flags|=NODE_SUPER;
nodex.id=segmentsx->firstnode[nodesx->gdata[nodex.id]];
WriteFile(fd,&nodex,sizeof(NodeX));
if(!((i+1)%10000))
printf_middle("Updating Super Nodes: Nodes=%"Pindex_t,i+1);
}
/* Close the files */
nodesx->fd=CloseFile(nodesx->fd);
CloseFile(fd);
/* Print the final message */
printf_last("Updated Super Nodes: Nodes=%"Pindex_t,nodesx->number);
}
void print_tree(Type tree[],int size,int total_width,char fill)
{
int row,columns,col_width,i;
int last_row = -1;
for(i = 0; i < size; ++i)
{
row = (int)(floor(log_base(i+1, 2)));
if(row != last_row)
{
printf("\n");
}
columns = (int)(pow(2,row));
col_width = (int)(floor(total_width * 1.0 / columns));
printf_middle(tree[i],col_width,fill);
last_row = row;
}
}
static int nodeType_function(const char *_tag_,int _type_,const char *id,const char *lat,const char *lon)
{
static int64_t llid; /* static variable to store attributes from <node> tag until </node> tag */
static double latitude,longitude; /* static variable to store attributes from <node> tag until </node> tag */
if(_type_&XMLPARSE_TAG_START)
{
nnodes++;
if(!(nnodes%10000))
printf_middle("Reading: Lines=%"PRIu64" Nodes=%"PRIu64" Ways=%"PRIu64" Relations=%"PRIu64,ParseXML_LineNumber(),nnodes,nways,nrelations);
current_tags=NewTagList();
/* Handle the node information */
XMLPARSE_ASSERT_INTEGER(_tag_,id); llid=atoll(id); /* need int64_t conversion */
if(current_mode!=MODE_DELETE)
{
XMLPARSE_ASSERT_FLOATING(_tag_,lat); latitude =atof(lat);
XMLPARSE_ASSERT_FLOATING(_tag_,lon); longitude=atof(lon);
}
}
if(_type_&XMLPARSE_TAG_END)
{
TagList *result=ApplyNodeTaggingRules(current_tags,llid);
ProcessNodeTags(result,llid,latitude,longitude,current_mode);
DeleteTagList(current_tags); current_tags=NULL;
DeleteTagList(result);
}
return(0);
}
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=SlimMapFileWriteable(nodesx->filename_tmp);
segmentsx->fd=SlimMapFileWriteable(segmentsx->filename_tmp);
waysx->fd=SlimMapFile(waysx->filename_tmp);
InvalidateNodeXCache(nodesx->cache);
InvalidateSegmentXCache(segmentsx->cache);
InvalidateWayXCache(waysx->cache);
#endif
/* Loop through the segments and find the short ones for possible modification */
for(i=0;i<segmentsx->number;i++)
{
SegmentX *segmentx2=LookupSegmentX(segmentsx,i,2);
if(IsPrunedSegmentX(segmentx2))
goto endloop;
/*
:
Initial state: ..N3 -------- N2
: S2
:
Final state: ..N3
:
= OR =
: :
Initial state: ..N1 -------- N2 ---- N3 -------- N4..
: S1 S2 S3 :
: :
Final state: ..N1 ------------ N3 ------------ N4..
: S1 S3 :
Not if N1 is the same as N4.
Must not delete N2 (or N3) if S2 (or S3) has different one-way properties from S1.
Must not delete N2 (or N3) if S2 (or S3) has different highway properties from S1.
Must combine N2, S2 and N3 disallowed transports into new N3.
Must not delete N2 (or N3) if it is a mini-roundabout.
Must not delete N2 (or N3) if it is involved in a turn restriction.
= OR =
: :
Initial state: ..N1 -------- N2 ---- N3..
: S1 S2 :
: :
Final state: ..N1 ------------ N3..
: S1 :
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-roundabout.
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 */
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);
}
/* Count the segments connected to N3 */
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 highway properties */
wayx1=LookupWayX(waysx,segmentx1->way,1);
wayx2=LookupWayX(waysx,segmentx2->way,2);
wayx3=LookupWayX(waysx,segmentx3->way,3);
if(WaysCompare(&wayx1->way,&wayx2->way))
join12=0;
if(WaysCompare(&wayx3->way,&wayx2->way))
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(!join12 && !join23)
goto endloop;
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;
}
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=SlimUnmapFile(nodesx->fd);
segmentsx->fd=SlimUnmapFile(segmentsx->fd);
waysx->fd=SlimUnmapFile(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);
}
void PruneIsolatedRegions(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx,distance_t minimum)
{
WaysX *newwaysx;
WayX tmpwayx;
transport_t transport;
BitMask *connected,*region;
index_t *regionsegments,*othersegments;
index_t nallocregionsegments,nallocothersegments;
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=SlimMapFile(nodesx->filename_tmp);
segmentsx->fd=SlimMapFileWriteable(segmentsx->filename_tmp);
waysx->fd=SlimMapFile(waysx->filename_tmp);
InvalidateNodeXCache(nodesx->cache);
InvalidateSegmentXCache(segmentsx->cache);
InvalidateWayXCache(waysx->cache);
#endif
newwaysx=NewWayList(0,0);
CloseFileBuffered(newwaysx->fd);
newwaysx->fd=SlimMapFileWriteable(newwaysx->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;transport<Transport_Count;transport++)
{
index_t i,j;
index_t nregions=0,npruned=0,nadjusted=0;
const char *transport_str=TransportName(transport);
transports_t transports=TRANSPORTS(transport);
if(!(waysx->allow&transports))
continue;
/* Print the start message */
printf_first("Pruning Isolated Regions (%s): Segments=0 Adjusted=0 Pruned=0",transport_str);
/* Loop through the segments and find the disconnected ones */
ClearAllBits(connected,segmentsx->number);
ClearAllBits(region ,segmentsx->number);
for(i=0;i<segmentsx->number;i++)
{
index_t nregionsegments=0,nothersegments=0;
distance_t total=0;
SegmentX *segmentx;
WayX *wayx;
if(IsBitSet(connected,i))
goto endloop;
segmentx=LookupSegmentX(segmentsx,i,1);
if(IsPrunedSegmentX(segmentx))
goto endloop;
if(segmentx->way<waysx->number)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SlimFetch(newwaysx->fd,(wayx=&tmpwayx),sizeof(WayX),(segmentx->way-waysx->number)*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->way<waysx->number)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SlimFetch(newwaysx->fd,(wayx=&tmpwayx),sizeof(WayX),(segmentx->way-waysx->number)*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 && total<minimum);
foundconnection:
/* Prune the segments or mark them as connected */
if(total<minimum) /* not connected - delete them */
{
nregions++;
for(j=0;j<nregionsegments;j++)
{
SegmentX *segmentx;
WayX *wayx,tmpwayx;
SetBit(connected,regionsegments[j]); /* not really connected, but don't need to check again */
ClearBit(region,regionsegments[j]);
segmentx=LookupSegmentX(segmentsx,regionsegments[j],1);
if(segmentx->way<waysx->number)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SlimFetch(newwaysx->fd,(wayx=&tmpwayx),sizeof(WayX),(segmentx->way-waysx->number)*sizeof(WayX));
if(wayx->way.allow==transports)
{
prune_segment(segmentsx,segmentx);
npruned++;
}
else
{
if(segmentx->way<waysx->number) /* create a new way */
{
tmpwayx=*wayx;
tmpwayx.way.allow&=~transports;
segmentx->way=waysx->number+newwaysx->number;
SlimReplace(newwaysx->fd,&tmpwayx,sizeof(WayX),(segmentx->way-waysx->number)*sizeof(WayX));
newwaysx->number++;
PutBackSegmentX(segmentsx,segmentx);
}
else /* modify the existing one */
{
tmpwayx.way.allow&=~transports;
SlimReplace(newwaysx->fd,&tmpwayx,sizeof(WayX),(segmentx->way-waysx->number)*sizeof(WayX));
}
nadjusted++;
}
}
}
else /* connected - mark as part of the main region */
{
for(j=0;j<nregionsegments;j++)
{
SetBit(connected,regionsegments[j]);
ClearBit(region,regionsegments[j]);
}
for(j=0;j<nothersegments;j++)
{
SetBit(connected,othersegments[j]);
ClearBit(region,othersegments[j]);
}
}
endloop:
if(!((i+1)%10000))
printf_middle("Pruning Isolated Regions (%s): Segments=%"Pindex_t" Adjusted=%"Pindex_t" Pruned=%"Pindex_t" (%"Pindex_t" Regions)",transport_str,i+1,nadjusted,npruned,nregions);
}
/* Print the final message */
printf_last("Pruned Isolated Regions (%s): Segments=%"Pindex_t" Adjusted=%"Pindex_t" Pruned=%"Pindex_t" (%"Pindex_t" Regions)",transport_str,segmentsx->number,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=SlimUnmapFile(nodesx->fd);
segmentsx->fd=SlimUnmapFile(segmentsx->fd);
waysx->fd=SlimUnmapFile(waysx->fd);
#endif
SlimUnmapFile(newwaysx->fd);
waysx->number+=newwaysx->number;
waysx->fd=OpenFileBufferedAppend(waysx->filename_tmp);
newwaysx->fd=ReOpenFileBuffered(newwaysx->filename_tmp);
while(!ReadFileBuffered(newwaysx->fd,&tmpwayx,sizeof(WayX)))
WriteFileBuffered(waysx->fd,&tmpwayx,sizeof(WayX));
CloseFileBuffered(waysx->fd);
CloseFileBuffered(newwaysx->fd);
FreeWayList(newwaysx,0);
}
void SaveNodeList(NodesX *nodesx,const char *filename)
{
index_t i;
int fd;
NodesFile nodesfile={0};
index_t super_number=0;
ll_bin2_t latlonbin=0,maxlatlonbins;
index_t *offsets;
/* Print the start message */
printf_first("Writing Nodes: Nodes=0");
/* Allocate the memory for the geographical offsets array */
offsets=(index_t*)malloc((nodesx->latbins*nodesx->lonbins+1)*sizeof(index_t));
assert(offsets); /* Check malloc() worked */
latlonbin=0;
/* Re-open the file */
nodesx->fd=ReOpenFile(nodesx->filename);
/* Write out the nodes data */
fd=OpenFileNew(filename);
SeekFile(fd,sizeof(NodesFile)+(nodesx->latbins*nodesx->lonbins+1)*sizeof(index_t));
for(i=0;i<nodesx->number;i++)
{
NodeX nodex;
Node node;
ll_bin_t latbin,lonbin;
ll_bin2_t llbin;
ReadFile(nodesx->fd,&nodex,sizeof(NodeX));
/* Create the Node */
node.latoffset=latlong_to_off(nodex.latitude);
node.lonoffset=latlong_to_off(nodex.longitude);
node.firstseg=nodex.id;
node.allow=nodex.allow;
node.flags=nodex.flags;
if(node.flags&NODE_SUPER)
super_number++;
/* Work out the offsets */
latbin=latlong_to_bin(nodex.latitude )-nodesx->latzero;
lonbin=latlong_to_bin(nodex.longitude)-nodesx->lonzero;
llbin=lonbin*nodesx->latbins+latbin;
for(;latlonbin<=llbin;latlonbin++)
offsets[latlonbin]=i;
/* Write the data */
WriteFile(fd,&node,sizeof(Node));
if(!((i+1)%10000))
printf_middle("Writing Nodes: Nodes=%"Pindex_t,i+1);
}
/* Close the file */
nodesx->fd=CloseFile(nodesx->fd);
/* Finish off the offset indexing and write them out */
maxlatlonbins=nodesx->latbins*nodesx->lonbins;
for(;latlonbin<=maxlatlonbins;latlonbin++)
offsets[latlonbin]=nodesx->number;
SeekFile(fd,sizeof(NodesFile));
WriteFile(fd,offsets,(nodesx->latbins*nodesx->lonbins+1)*sizeof(index_t));
free(offsets);
/* Write out the header structure */
nodesfile.number=nodesx->number;
nodesfile.snumber=super_number;
nodesfile.latbins=nodesx->latbins;
nodesfile.lonbins=nodesx->lonbins;
nodesfile.latzero=nodesx->latzero;
nodesfile.lonzero=nodesx->lonzero;
SeekFile(fd,0);
WriteFile(fd,&nodesfile,sizeof(NodesFile));
CloseFile(fd);
/* Print the final message */
printf_last("Wrote Nodes: Nodes=%"Pindex_t,nodesx->number);
}
SegmentsX *SplitWays(WaysX *waysx,NodesX *nodesx,int keep)
{
SegmentsX *segmentsx;
index_t i;
int fd,nfd;
char *name=NULL;
int namelen=0;
/* Print the start message */
printf_first("Splitting Ways: Ways=0 Segments=0");
segmentsx=NewSegmentList();
/* Re-open the file read-only and a new file writeable */
waysx->fd=ReOpenFileBuffered(waysx->filename_tmp);
if(keep)
RenameFile(waysx->filename_tmp,waysx->filename);
else
DeleteFile(waysx->filename_tmp);
fd=OpenFileBufferedNew(waysx->filename_tmp);
nfd=OpenFileBufferedNew(waysx->nfilename_tmp);
/* Loop through the ways and create the segments and way names */
for(i=0;i<waysx->number;i++)
{
WayX wayx;
FILESORT_VARINT size;
node_t node,prevnode=NO_NODE_ID;
index_t index,previndex=NO_NODE;
ReadFileBuffered(waysx->fd,&size,FILESORT_VARSIZE);
ReadFileBuffered(waysx->fd,&wayx,sizeof(WayX));
waysx->allow|=wayx.way.allow;
while(!ReadFileBuffered(waysx->fd,&node,sizeof(node_t)) && node!=NO_NODE_ID)
{
index=IndexNodeX(nodesx,node);
if(prevnode==node)
{
logerror("Way %"Pway_t" contains node %"Pnode_t" that is connected to itself.\n",logerror_way(wayx.id),logerror_node(node));
}
else if(index==NO_NODE)
{
logerror("Way %"Pway_t" contains node %"Pnode_t" that does not exist in the Routino database.\n",logerror_way(wayx.id),logerror_node(node));
}
else if(previndex==NO_NODE)
;
else
{
distance_t segment_flags=0;
if(wayx.way.type&Highway_OneWay)
segment_flags|=ONEWAY_1TO2;
if(wayx.way.type&Highway_Area)
segment_flags|=SEGMENT_AREA;
AppendSegmentList(segmentsx,i,previndex,index,segment_flags);
}
prevnode=node;
previndex=index;
size-=sizeof(node_t);
}
size-=sizeof(node_t)+sizeof(WayX);
if(namelen<size)
name=(char*)realloc((void*)name,namelen=size);
ReadFileBuffered(waysx->fd,name,size);
WriteFileBuffered(fd,&wayx,sizeof(WayX));
size+=sizeof(index_t);
WriteFileBuffered(nfd,&size,FILESORT_VARSIZE);
WriteFileBuffered(nfd,&i,sizeof(index_t));
WriteFileBuffered(nfd,name,size-sizeof(index_t));
if(!((i+1)%1000))
printf_middle("Splitting Ways: Ways=%"Pindex_t" Segments=%"Pindex_t,i+1,segmentsx->number);
}
FinishSegmentList(segmentsx);
if(name) free(name);
/* Close the files */
waysx->fd=CloseFileBuffered(waysx->fd);
CloseFileBuffered(fd);
CloseFileBuffered(nfd);
/* Print the final message */
printf_last("Split Ways: Ways=%"Pindex_t" Segments=%"Pindex_t,waysx->number,segmentsx->number);
return(segmentsx);
}
void ChooseSuperNodes(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx)
{
index_t i;
index_t nnodes=0;
if(nodesx->number==0 || segmentsx->number==0 || waysx->number==0)
return;
/* Print the start message */
printf_first("Finding Super-Nodes: Nodes=0 Super-Nodes=0");
/* Allocate and set the super-node markers */
if(!nodesx->super)
{
nodesx->super=AllocBitMask(nodesx->number);
assert(nodesx->super); /* Check AllocBitMask() worked */
SetAllBits1(nodesx->super,nodesx->number);
}
/* Map into memory / open the files */
#if !SLIM
nodesx->data=MapFile(nodesx->filename);
segmentsx->data=MapFile(segmentsx->filename);
waysx->data=MapFile(waysx->filename);
#else
nodesx->fd=ReOpenFile(nodesx->filename);
segmentsx->fd=ReOpenFile(segmentsx->filename);
waysx->fd=ReOpenFile(waysx->filename);
#endif
/* Find super-nodes */
for(i=0;i<nodesx->number;i++)
{
if(IsBitSet(nodesx->super,i))
{
int issuper=0;
NodeX *nodex=LookupNodeX(nodesx,i,1);
if(IsPrunedNodeX(nodex))
issuper=0;
else if(nodex->flags&(NODE_TURNRSTRCT|NODE_TURNRSTRCT2))
issuper=1;
else
{
int count=0,j;
Way segmentway[MAX_SEG_PER_NODE];
int segmentweight[MAX_SEG_PER_NODE];
SegmentX *segmentx=FirstSegmentX(segmentsx,i,1);
while(segmentx)
{
WayX *wayx=LookupWayX(waysx,segmentx->way,1);
int nsegments;
/* Segments that are loops count twice */
assert(count<MAX_SEG_PER_NODE); /* Only a limited amount of information stored. */
if(segmentx->node1==segmentx->node2)
segmentweight[count]=2;
else
segmentweight[count]=1;
segmentway[count]=wayx->way;
/* If the node allows less traffic types than any connecting way then it is super */
if((wayx->way.allow&nodex->allow)!=wayx->way.allow)
{
issuper=1;
break;
}
nsegments=segmentweight[count];
for(j=0;j<count;j++)
if(wayx->way.allow & segmentway[j].allow)
{
/* If two ways are different in any attribute and there is a type of traffic that can use both then it is super */
if(WaysCompare(&segmentway[j],&wayx->way))
{
issuper=1;
break;
}
/* If there are two other segments that can be used by the same types of traffic as this one then it is super */
nsegments+=segmentweight[j];
if(nsegments>2)
{
issuper=1;
break;
}
}
if(issuper)
break;
segmentx=NextSegmentX(segmentsx,segmentx,i);
count++;
}
}
/* Mark the node as super if it is. */
if(issuper)
nnodes++;
else
ClearBit(nodesx->super,i);
}
if(!((i+1)%10000))
printf_middle("Finding Super-Nodes: Nodes=%"Pindex_t" Super-Nodes=%"Pindex_t,i+1,nnodes);
}
/* Unmap from memory / close the files */
#if !SLIM
nodesx->data=UnmapFile(nodesx->filename);
segmentsx->data=UnmapFile(segmentsx->filename);
waysx->data=UnmapFile(waysx->filename);
#else
nodesx->fd=CloseFile(nodesx->fd);
segmentsx->fd=CloseFile(segmentsx->fd);
waysx->fd=CloseFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Found Super-Nodes: Nodes=%"Pindex_t" Super-Nodes=%"Pindex_t,nodesx->number,nnodes);
}
SegmentsX *MergeSuperSegments(SegmentsX *segmentsx,SegmentsX *supersegmentsx)
{
index_t i,j;
index_t merged=0,added=0;
SegmentsX *mergedsegmentsx;
mergedsegmentsx=NewSegmentList(0);
if(segmentsx->number==0)
return(mergedsegmentsx);
/* Print the start message */
printf_first("Merging Segments: Segments=0 Super=0 Merged=0 Added=0");
/* Map into memory / open the files */
#if !SLIM
segmentsx->data=MapFile(segmentsx->filename);
if(supersegmentsx->number>0)
supersegmentsx->data=MapFile(supersegmentsx->filename);
#else
segmentsx->fd=ReOpenFile(segmentsx->filename);
if(supersegmentsx->number>0)
supersegmentsx->fd=ReOpenFile(supersegmentsx->filename);
#endif
/* Loop through and create a new list of combined segments */
for(i=0,j=0;i<segmentsx->number;i++)
{
int super=0;
SegmentX *segmentx=LookupSegmentX(segmentsx,i,1);
while(j<supersegmentsx->number)
{
SegmentX *supersegmentx=LookupSegmentX(supersegmentsx,j,1);
if(segmentx->node1 ==supersegmentx->node1 &&
segmentx->node2 ==supersegmentx->node2 &&
segmentx->distance==supersegmentx->distance)
{
merged++;
j++;
/* mark as super-segment and normal segment */
super=1;
break;
}
else if((segmentx->node1==supersegmentx->node1 &&
segmentx->node2==supersegmentx->node2) ||
(segmentx->node1==supersegmentx->node1 &&
segmentx->node2>supersegmentx->node2) ||
(segmentx->node1>supersegmentx->node1))
{
/* mark as super-segment */
AppendSegment(mergedsegmentsx,supersegmentx->way,supersegmentx->node1,supersegmentx->node2,supersegmentx->distance|SEGMENT_SUPER);
added++;
j++;
}
else
{
/* mark as normal segment */
break;
}
}
if(super)
AppendSegment(mergedsegmentsx,segmentx->way,segmentx->node1,segmentx->node2,segmentx->distance|SEGMENT_SUPER|SEGMENT_NORMAL);
else
AppendSegment(mergedsegmentsx,segmentx->way,segmentx->node1,segmentx->node2,segmentx->distance|SEGMENT_NORMAL);
if(!((i+1)%10000))
printf_middle("Merging Segments: Segments=%"Pindex_t" Super=%"Pindex_t" Merged=%"Pindex_t" Added=%"Pindex_t,i+1,j,merged,added);
}
/* Unmap from memory / close the files */
#if !SLIM
segmentsx->data=UnmapFile(segmentsx->filename);
if(supersegmentsx->number>0)
supersegmentsx->data=UnmapFile(supersegmentsx->filename);
#else
segmentsx->fd=CloseFile(segmentsx->fd);
if(supersegmentsx->number>0)
supersegmentsx->fd=CloseFile(supersegmentsx->fd);
#endif
/* Print the final message */
printf_last("Merged Segments: Segments=%"Pindex_t" Super=%"Pindex_t" Merged=%"Pindex_t" Added=%"Pindex_t,segmentsx->number,supersegmentsx->number,merged,added);
return(mergedsegmentsx);
}
SegmentsX *CreateSuperSegments(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx)
{
index_t i;
SegmentsX *supersegmentsx;
index_t sn=0,ss=0;
supersegmentsx=NewSegmentList(0);
if(segmentsx->number==0 || waysx->number==0)
return(supersegmentsx);
/* Print the start message */
printf_first("Creating Super-Segments: Super-Nodes=0 Super-Segments=0");
/* Map into memory / open the files */
#if !SLIM
segmentsx->data=MapFile(segmentsx->filename);
waysx->data=MapFile(waysx->filename);
#else
segmentsx->fd=ReOpenFile(segmentsx->filename);
waysx->fd=ReOpenFile(waysx->filename);
#endif
/* Create super-segments for each super-node. */
for(i=0;i<nodesx->number;i++)
{
if(IsBitSet(nodesx->super,i))
{
SegmentX *segmentx;
int count=0,match;
Way prevway[MAX_SEG_PER_NODE];
segmentx=FirstSegmentX(segmentsx,i,1);
while(segmentx)
{
WayX *wayx=LookupWayX(waysx,segmentx->way,1);
/* Check that this type of way hasn't already been routed */
match=0;
if(count>0)
{
int j;
for(j=0;j<count;j++)
if(!WaysCompare(&prevway[j],&wayx->way))
{
match=1;
break;
}
}
assert(count<MAX_SEG_PER_NODE); /* Only a limited amount of history stored. */
prevway[count++]=wayx->way;
/* Route the way and store the super-segments. */
if(!match)
{
Results *results=FindRoutesWay(nodesx,segmentsx,waysx,i,&wayx->way);
Result *result=FirstResult(results);
while(result)
{
if(IsBitSet(nodesx->super,result->node) && result->segment!=NO_SEGMENT)
{
if(wayx->way.type&Way_OneWay && result->node!=i)
AppendSegment(supersegmentsx,segmentx->way,i,result->node,DISTANCE((distance_t)result->score)|ONEWAY_1TO2);
else
AppendSegment(supersegmentsx,segmentx->way,i,result->node,DISTANCE((distance_t)result->score));
ss++;
}
result=NextResult(results,result);
}
FreeResultsList(results);
}
segmentx=NextSegmentX(segmentsx,segmentx,i);
}
sn++;
if(!(sn%10000))
printf_middle("Creating Super-Segments: Super-Nodes=%"Pindex_t" Super-Segments=%"Pindex_t,sn,ss);
}
}
/* Unmap from memory / close the files */
#if !SLIM
segmentsx->data=UnmapFile(segmentsx->filename);
waysx->data=UnmapFile(waysx->filename);
#else
segmentsx->fd=CloseFile(segmentsx->fd);
waysx->fd=CloseFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Created Super-Segments: Super-Nodes=%"Pindex_t" Super-Segments=%"Pindex_t,sn,ss);
return(supersegmentsx);
}
void SaveWayList(WaysX *waysx,const char *filename)
{
index_t i;
int fd;
index_t 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=ReOpenFileBuffered(waysx->filename_tmp);
waysx->nfd=ReOpenFileBuffered(waysx->nfilename_tmp);
/* Write out the ways data */
fd=OpenFileBufferedNew(filename);
SeekFileBuffered(fd,sizeof(WaysFile));
for(i=0;i<waysx->number;i++)
{
ReadFileBuffered(waysx->fd,&wayx,sizeof(WayX));
highways|=HIGHWAYS(wayx.way.type);
allow |=wayx.way.allow;
props |=wayx.way.props;
WriteFileBuffered(fd,&wayx.way,sizeof(Way));
if(!((i+1)%1000))
printf_middle("Writing Ways: Ways=%"Pindex_t,i+1);
}
/* Write out the ways names */
SeekFileBuffered(fd,sizeof(WaysFile)+(off_t)waysx->number*sizeof(Way));
while(position<waysx->nlength)
{
size_t len=1024;
char temp[1024];
if((waysx->nlength-position)<1024)
len=waysx->nlength-position;
ReadFileBuffered(waysx->nfd,temp,len);
WriteFileBuffered(fd,temp,len);
position+=len;
}
/* Close the files */
waysx->fd=CloseFileBuffered(waysx->fd);
waysx->nfd=CloseFileBuffered(waysx->nfd);
/* Write out the header structure */
waysfile.number =waysx->number;
waysfile.highways=highways;
waysfile.allow =allow;
waysfile.props =props;
SeekFileBuffered(fd,0);
WriteFileBuffered(fd,&waysfile,sizeof(WaysFile));
CloseFileBuffered(fd);
/* Print the final message */
printf_last("Wrote Ways: Ways=%"Pindex_t,waysx->number);
}
void SortWayNames(WaysX *waysx)
{
index_t i;
int nfd;
char *names[2]={NULL,NULL};
int namelen[2]={0,0};
int nnames=0;
uint32_t lastlength=0;
/* Print the start message */
printf_first("Sorting Way Names");
/* Re-open the file read-only and new file writeable */
waysx->nfd=ReOpenFileBuffered(waysx->nfilename_tmp);
DeleteFile(waysx->nfilename_tmp);
nfd=OpenFileBufferedNew(waysx->nfilename_tmp);
/* Sort the way names */
waysx->nlength=0;
filesort_vary(waysx->nfd,nfd,NULL,
(int (*)(const void*,const void*))sort_by_name,
NULL);
/* Close the files */
waysx->nfd=CloseFileBuffered(waysx->nfd);
CloseFileBuffered(nfd);
/* Print the final message */
printf_last("Sorted Way Names: Ways=%"Pindex_t,waysx->number);
/* Print the start message */
printf_first("Updating Ways with Names: Ways=0 Names=0");
/* Map into memory / open the file */
#if !SLIM
waysx->data=MapFileWriteable(waysx->filename_tmp);
#else
waysx->fd=SlimMapFileWriteable(waysx->filename_tmp);
#endif
/* Re-open the file read-only and new file writeable */
waysx->nfd=ReOpenFileBuffered(waysx->nfilename_tmp);
DeleteFile(waysx->nfilename_tmp);
nfd=OpenFileBufferedNew(waysx->nfilename_tmp);
/* Update the ways and de-duplicate the names */
for(i=0;i<waysx->number;i++)
{
WayX *wayx;
index_t index;
FILESORT_VARINT size;
ReadFileBuffered(waysx->nfd,&size,FILESORT_VARSIZE);
if(namelen[nnames%2]<size)
names[nnames%2]=(char*)realloc((void*)names[nnames%2],namelen[nnames%2]=size);
ReadFileBuffered(waysx->nfd,&index,sizeof(index_t));
ReadFileBuffered(waysx->nfd,names[nnames%2],size-sizeof(index_t));
if(nnames==0 || strcmp(names[0],names[1]))
{
WriteFileBuffered(nfd,names[nnames%2],size-sizeof(index_t));
lastlength=waysx->nlength;
waysx->nlength+=size-sizeof(index_t);
nnames++;
}
wayx=LookupWayX(waysx,index,1);
wayx->way.name=lastlength;
PutBackWayX(waysx,wayx);
if(!((i+1)%1000))
printf_middle("Updating Ways with 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->nfd=CloseFileBuffered(waysx->nfd);
CloseFileBuffered(nfd);
/* Unmap from memory / close the files */
#if !SLIM
waysx->data=UnmapFile(waysx->data);
#else
waysx->fd=SlimUnmapFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Updated Ways with Names: Ways=%"Pindex_t" Names=%"Pindex_t,waysx->number,nnames);
}
void RemoveNonHighwayNodes(NodesX *nodesx,SegmentsX *segmentsx)
{
NodeX nodex;
index_t total=0,highway=0,nothighway=0;
ll_bin_t lat_min_bin,lat_max_bin,lon_min_bin,lon_max_bin;
latlong_t lat_min,lat_max,lon_min,lon_max;
int fd;
/* Print the start message */
printf_first("Checking Nodes: Nodes=0");
/* 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);
/* Re-open the file read-only and a new file writeable */
nodesx->fd=ReOpenFile(nodesx->filename);
DeleteFile(nodesx->filename);
fd=OpenFileNew(nodesx->filename);
/* Modify the on-disk image */
while(!ReadFile(nodesx->fd,&nodex,sizeof(NodeX)))
{
if(!IsBitSet(segmentsx->usednode,total))
nothighway++;
else
{
nodex.id=highway;
WriteFile(fd,&nodex,sizeof(NodeX));
nodesx->idata[highway]=nodesx->idata[total];
highway++;
if(nodex.latitude<lat_min)
lat_min=nodex.latitude;
if(nodex.latitude>lat_max)
lat_max=nodex.latitude;
if(nodex.longitude<lon_min)
lon_min=nodex.longitude;
if(nodex.longitude>lon_max)
lon_max=nodex.longitude;
}
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);
/* 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;
/* Free the now-unneeded index */
free(segmentsx->usednode);
segmentsx->usednode=NULL;
/* Allocate and set the super-node markers */
nodesx->super=(uint8_t*)malloc((1+nodesx->number/8)*sizeof(uint8_t));
assert(nodesx->super); /* Check calloc() worked */
memset(nodesx->super,~0,(1+nodesx->number/8));
/* Print the final message */
printf_last("Checked Nodes: Nodes=%"Pindex_t" Highway=%"Pindex_t" not-Highway=%"Pindex_t,total,highway,nothighway);
}
void PruneStraightHighwayNodes(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx,distance_t maximum)
{
index_t i;
index_t npruned=0;
index_t nalloc;
BitMask *checked;
index_t *nodes,*segments;
double *lats,*lons;
double maximumf;
if(nodesx->number==0 || segmentsx->number==0 || waysx->number==0)
return;
/* 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=SlimMapFile(nodesx->filename_tmp);
segmentsx->fd=SlimMapFileWriteable(segmentsx->filename_tmp);
waysx->fd=SlimMapFile(waysx->filename_tmp);
InvalidateNodeXCache(nodesx->cache);
InvalidateSegmentXCache(segmentsx->cache);
InvalidateWayXCache(waysx->cache);
#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 stretches of simple highway for possible modification */
maximumf=distance_to_km(maximum);
for(i=0;i<nodesx->number;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],3);
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)
{
/* Make space in the lists */
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;
segments[upper]=NO_SEGMENT;
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;
}
segments[upper]=NO_SEGMENT;
current++;
}
if(nodes[upper]==nodes[lower])
{
if(!lowerbounded && !upperbounded)
{
nodex=LookupNodeX(nodesx,nodes[lower],1);
lats[lower]=latlong_to_radians(nodex->latitude);
lons[lower]=latlong_to_radians(nodex->longitude);
}
lats[upper]=lats[lower];
lons[upper]=lons[lower];
lowerbounded=1;
upperbounded=1;
}
}
else /* if(segment!=2) */
{
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 */
for(;lower<(upper-1);lower++)
{
for(current=upper;current>(lower+1);current--)
{
SegmentX *segmentx;
distance_t dist=0;
double dist1,dist2,dist3,distp;
index_t c;
dist3=distance(lats[lower],lons[lower],lats[current],lons[current]);
for(c=lower+1;c<current;c++)
{
dist1=distance(lats[lower] ,lons[lower] ,lats[c],lons[c]);
dist2=distance(lats[current],lons[current],lats[c],lons[c]);
/* Use law of cosines (assume flat Earth) */
if(dist3==0)
distp=dist1; /* == dist2 */
else if((dist1+dist2)<dist3)
distp=0;
else
{
double dist3a=(dist1*dist1-dist2*dist2+dist3*dist3)/(2.0*dist3);
double dist3b=dist3-dist3a;
if(dist3a>=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<current) /* not finished */
continue;
/* Delete some segments and shift along */
for(c=lower+1;c<current;c++)
{
segmentx=LookupSegmentX(segmentsx,segments[c],1);
dist+=DISTANCE(segmentx->distance);
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+=dist;
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-1;
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=SlimUnmapFile(nodesx->fd);
segmentsx->fd=SlimUnmapFile(segmentsx->fd);
waysx->fd=SlimUnmapFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Pruned Straight Highway Nodes: Nodes=%"Pindex_t" Pruned=%"Pindex_t,nodesx->number,npruned);
}
Results *FindMiddleRoute(Nodes *nodes,Segments *segments,Ways *ways,Relations *relations,Profile *profile,Results *begin,Results *end)
{
Results *results;
Queue *queue;
Result *finish_result;
score_t finish_score;
double finish_lat,finish_lon;
Result *result1,*result2,*result3,*result4;
if(!option_quiet)
printf_first("Routing: Super-Nodes checked = 0");
/* Set up the finish conditions */
finish_score=INF_DISTANCE;
finish_result=NULL;
if(IsFakeNode(end->finish_node))
GetFakeLatLong(end->finish_node,&finish_lat,&finish_lon);
else
GetLatLong(nodes,end->finish_node,&finish_lat,&finish_lon);
/* Create the list of results and insert the first node into the queue */
results=NewResultsList(65536);
results->start_node=begin->start_node;
results->prev_segment=begin->prev_segment;
if(begin->number==1)
{
if(begin->prev_segment==NO_SEGMENT)
results->prev_segment=NO_SEGMENT;
else
{
index_t superseg=FindSuperSegment(nodes,segments,ways,relations,profile,begin->start_node,begin->prev_segment);
results->prev_segment=superseg;
}
}
result1=InsertResult(results,results->start_node,results->prev_segment);
queue=NewQueueList();
/* Insert the finish points of the beginning part of the path into the queue,
translating the segments into super-segments. */
result3=FirstResult(begin);
while(result3)
{
if((results->start_node!=result3->node || results->prev_segment!=result3->segment) &&
!IsFakeNode(result3->node) && IsSuperNode(LookupNode(nodes,result3->node,1)))
{
Result *result5=result1;
index_t superseg=FindSuperSegment(nodes,segments,ways,relations,profile,result3->node,result3->segment);
if(superseg!=result3->segment)
{
result5=InsertResult(results,result3->node,result3->segment);
result5->prev=result1;
}
if(!FindResult(results,result3->node,superseg))
{
result2=InsertResult(results,result3->node,superseg);
result2->prev=result5;
result2->score=result3->score;
result2->sortby=result3->score;
InsertInQueue(queue,result2);
if((result4=FindResult(end,result2->node,result2->segment)))
{
if((result2->score+result4->score)<finish_score)
{
finish_score=result2->score+result4->score;
finish_result=result2;
}
}
}
}
result3=NextResult(begin,result3);
}
if(begin->number==1)
InsertInQueue(queue,result1);
/* Loop across all nodes in the queue */
while((result1=PopFromQueue(queue)))
{
index_t node1,seg1;
Segment *segment;
index_t turnrelation=NO_RELATION;
/* score must be better than current best score */
if(result1->score>finish_score)
continue;
node1=result1->node;
seg1=result1->segment;
/* lookup if a turn restriction applies */
if(profile->turns && IsTurnRestrictedNode(LookupNode(nodes,node1,1))) /* node1 cannot be a fake node (must be a super-node) */
turnrelation=FindFirstTurnRelation2(relations,node1,seg1);
/* Loop across all segments */
segment=FirstSegment(segments,nodes,node1,1); /* node1 cannot be a fake node (must be a super-node) */
while(segment)
{
Way *way;
Node *node;
index_t node2,seg2;
score_t segment_pref,segment_score,cumulative_score;
int i;
/* must be a super segment */
if(!IsSuperSegment(segment))
goto endloop;
/* must obey one-way restrictions (unless profile allows) */
if(profile->oneway && IsOnewayTo(segment,node1))
goto endloop;
node2=OtherNode(segment,node1);
seg2=IndexSegment(segments,segment); /* node2 cannot be a fake node (must be a super-node) */
/* must not perform U-turn */
if(seg1==seg2) /* No fake segments, applies to all profiles */
goto endloop;
/* must obey turn relations */
if(turnrelation!=NO_RELATION && !IsTurnAllowed(relations,turnrelation,node1,seg1,seg2,profile->allow))
goto endloop;
way=LookupWay(ways,segment->way,1);
/* transport must be allowed on the highway */
if(!(way->allow&profile->allow))
goto endloop;
/* must obey weight restriction (if exists) */
if(way->weight && way->weight<profile->weight)
goto endloop;
/* must obey height/width/length restriction (if exists) */
if((way->height && way->height<profile->height) ||
(way->width && way->width <profile->width ) ||
(way->length && way->length<profile->length))
goto endloop;
segment_pref=profile->highway[HIGHWAY(way->type)];
for(i=1;i<Property_Count;i++)
if(ways->file.props & PROPERTIES(i))
{
if(way->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)
goto endloop;
node=LookupNode(nodes,node2,2); /* node2 cannot be a fake node (must be a super-node) */
/* mode of transport must be allowed through node2 */
if(!(node->allow&profile->allow))
goto endloop;
if(option_quickest==0)
segment_score=(score_t)DISTANCE(segment->distance)/segment_pref;
else
segment_score=(score_t)Duration(segment,way,profile)/segment_pref;
cumulative_score=result1->score+segment_score;
/* score must be better than current best score */
if(cumulative_score>finish_score)
goto endloop;
result2=FindResult(results,node2,seg2);
if(!result2) /* New end node/segment pair */
{
result2=InsertResult(results,node2,seg2);
result2->prev=result1;
result2->score=cumulative_score;
if((result3=FindResult(end,node2,seg2)))
{
if((result2->score+result3->score)<finish_score)
{
finish_score=result2->score+result3->score;
finish_result=result2;
}
}
else
{
double lat,lon;
distance_t direct;
GetLatLong(nodes,node2,&lat,&lon); /* node2 cannot be a fake node (must be a super-node) */
direct=Distance(lat,lon,finish_lat,finish_lon);
if(option_quickest==0)
result2->sortby=result2->score+(score_t)direct/profile->max_pref;
else
result2->sortby=result2->score+(score_t)distance_speed_to_duration(direct,profile->max_speed)/profile->max_pref;
InsertInQueue(queue,result2);
}
}
else if(cumulative_score<result2->score) /* New end node/segment pair is better */
{
result2->prev=result1;
result2->score=cumulative_score;
if((result3=FindResult(end,node2,seg2)))
{
if((result2->score+result3->score)<finish_score)
{
finish_score=result2->score+result3->score;
finish_result=result2;
}
}
else if(result2->score<finish_score)
{
double lat,lon;
distance_t direct;
GetLatLong(nodes,node2,&lat,&lon); /* node2 cannot be a fake node (must be a super-node) */
direct=Distance(lat,lon,finish_lat,finish_lon);
if(option_quickest==0)
result2->sortby=result2->score+(score_t)direct/profile->max_pref;
else
result2->sortby=result2->score+(score_t)distance_speed_to_duration(direct,profile->max_speed)/profile->max_pref;
InsertInQueue(queue,result2);
}
}
if(!option_quiet && !(results->number%1000))
printf_middle("Routing: Super-Nodes checked = %d",results->number);
endloop:
segment=NextSegment(segments,segment,node1); /* node1 cannot be a fake node (must be a super-node) */
}
}
if(!option_quiet)
printf_last("Routing: Super-Nodes checked = %d",results->number);
FreeQueueList(queue);
/* Check it worked */
if(!finish_result)
{
FreeResultsList(results);
return(NULL);
}
/* Finish off the end part of the route */
if(finish_result->node!=end->finish_node)
{
result3=InsertResult(results,end->finish_node,NO_SEGMENT);
result3->prev=finish_result;
result3->score=finish_score;
finish_result=result3;
}
FixForwardRoute(results,finish_result);
return(results);
}
