trunk/src/output.c

/***************************************
 $Header: /home/amb/CVS/routino/src/output.c,v 1.17 2009-11-23 18:42:40 amb Exp $

 Routing output generator.

 Part of the Routino routing software.
 ******************/ /******************
 This file Copyright 2008,2009 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 <http://www.gnu.org/licenses/>.
 ***************************************/


#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include "types.h"
#include "functions.h"
#include "nodes.h"
#include "segments.h"
#include "ways.h"
#include "results.h"


/*+ The option to calculate the quickest route insted of the shortest. +*/
extern int option_quickest;

/*+ The files to write to. +*/
static FILE *gpxtrackfile=NULL,*gpxroutefile=NULL,*textfile=NULL,*textallfile=NULL;

/*+ The final latitude, longitude point. +*/
static double finish_latitude,finish_longitude;

/*+ Heuristics for determining if a junction is important. +*/
static char junction_other_way[Way_Count][Way_Count]=
 { /* M, T, P, S, T, U, R, S, T, C, P, S = Way type of route not taken */
  {   1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 }, /* Motorway     */
  {   1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* Trunk        */
  {   1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, /* Primary      */
  {   1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, /* Secondary    */
  {   1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 }, /* Tertiary     */
  {   1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }, /* Unclassified */
  {   1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 }, /* Residential  */
  {   1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 }, /* Service      */
  {   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* Track        */
  {   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* Cycleway     */
  {   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* Path         */
  {   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* Steps        */
 };


/*++++++++++++++++++++++++++++++++++++++
  Open the files and print the head.

  const char *copyright The name of a file that might exist and contain copyright information.
  ++++++++++++++++++++++++++++++++++++++*/

void PrintRouteHead(const char *copyright)
{
 char *source=NULL,*license=NULL;

 if(copyright)
   {
    struct stat buf;

    if(!stat(copyright,&buf))
      {
       FILE *file=fopen(copyright,"r");
       char *string=(char*)malloc(buf.st_size+1);
       char *p;

       fread(string,buf.st_size,1,file);
       string[buf.st_size]=0;

       p=string;
       while(*p)
         {
          if(!strncmp(p,"Source:",7))
            {
             p+=7;
             while(*p==' ' || *p=='t')
                p++;
             source=p;
             while(*p && *p!='\r' && *p!='\n')
                p++;
             while(*p=='\r' || *p=='\n')
                *p++=0;
            }
          else if(!strncmp(p,"License:",8) || !strncmp(p,"Licence:",8))
            {
             p+=8;
             while(*p==' ' || *p=='t')
                p++;
             license=p;
             while(*p && *p!='\r' && *p!='\n')
                p++;
             while(*p=='\r' || *p=='\n')
                *p++=0;
            }
          else
            {
             while(*p && *p!='\r' && *p!='\n')
                p++;
             while(*p=='\r' || *p=='\n')
                *p++=0;
            }
         }

       fclose(file);
      }
   }

 /* Open the files */

 if(option_quickest==0)
   {
    /* Print the result for the shortest route */

    gpxtrackfile=fopen("shortest-track.gpx","w");
    gpxroutefile=fopen("shortest-route.gpx","w");
    textfile    =fopen("shortest.txt","w");
    textallfile =fopen("shortest-all.txt","w");

    if(!gpxtrackfile)
       fprintf(stderr,"Warning: Cannot open file 'shortest-track.gpx' to write.\n");
    if(!gpxroutefile)
       fprintf(stderr,"Warning: Cannot open file 'shortest-route.gpx' to write.\n");
    if(!textfile)
       fprintf(stderr,"Warning: Cannot open file 'shortest.txt' to write.\n");
    if(!textallfile)
       fprintf(stderr,"Warning: Cannot open file 'shortest-all.txt' to write.\n");
   }
 else
   {
    /* Print the result for the quickest route */

    gpxtrackfile=fopen("quickest-track.gpx","w");
    gpxroutefile=fopen("quickest-route.gpx","w");
    textfile    =fopen("quickest.txt","w");
    textallfile =fopen("quickest-all.txt","w");

    if(!gpxtrackfile)
       fprintf(stderr,"Warning: Cannot open file 'quickest-track.gpx' to write.\n");
    if(!gpxroutefile)
       fprintf(stderr,"Warning: Cannot open file 'quickest-route.gpx' to write.\n");
    if(!textfile)
       fprintf(stderr,"Warning: Cannot open file 'quickest.txt' to write.\n");
    if(!textallfile)
       fprintf(stderr,"Warning: Cannot open file 'quickest-all.txt' to write.\n");
   }

 /* Print the head of the files */

 if(gpxtrackfile)
   {
    fprintf(gpxtrackfile,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
    fprintf(gpxtrackfile,"<gpx version=\"1.1\" creator=\"Routino\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://www.topografix.com/GPX/1/1\" xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd\">\n");

    fprintf(gpxtrackfile,"<metadata>\n");
    fprintf(gpxtrackfile,"<desc><![CDATA[%s route between 'start' and 'finish' waypoints]]></desc>\n",option_quickest?"Quickest":"Shortest");
    if(source)
       fprintf(gpxtrackfile,"<copyright author=\"%s\">\n",source);
    if(license)
       fprintf(gpxtrackfile,"<license>%s</license>\n",license);
    if(source)
       fprintf(gpxtrackfile,"</copyright>\n");
    fprintf(gpxtrackfile,"</metadata>\n");

    fprintf(gpxtrackfile,"<trk>\n");
   }

 if(gpxroutefile)
   {
    fprintf(gpxroutefile,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
    fprintf(gpxroutefile,"<gpx version=\"1.1\" creator=\"Routino\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://www.topografix.com/GPX/1/1\" xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd\">\n");

    fprintf(gpxroutefile,"<metadata>\n");
    fprintf(gpxroutefile,"<desc><![CDATA[%s route between 'start' and 'finish' waypoints]]></desc>\n",option_quickest?"Quickest":"Shortest");
    if(source)
       fprintf(gpxroutefile,"<copyright author=\"%s\">\n",source);
    if(license)
       fprintf(gpxroutefile,"<license>%s</license>\n",license);
    if(source)
       fprintf(gpxroutefile,"</copyright>\n");
    fprintf(gpxroutefile,"</metadata>\n");

    fprintf(gpxroutefile,"<rte>\n");
    fprintf(gpxroutefile,"<name>%s route</name>\n",option_quickest?"Quickest":"Shortest");
   }

 if(textfile)
   {
    if(source)
       fprintf(textfile,"# Source: %s\n",source);
    if(license)
       fprintf(textfile,"# License: %s\n",license);
    if(source || license)
       fprintf(textfile,"#\n");
    fprintf(textfile,"#Latitude\tLongitude\tSegment \tSegment \tTotal   \tTotal  \tHighway\n");
    fprintf(textfile,"#        \t         \tDistance\tDuration\tDistance\tDurat'n\t       \n");
                     /* "%10.6f\t%11.6f\t%6.3f km\t%4.1f min\t%5.1f km\t%3.0f min\t%s\n" */
   }

 if(textallfile)
   {
    if(source)
       fprintf(textallfile,"# Source: %s\n",source);
    if(license)
       fprintf(textallfile,"# License: %s\n",license);
    if(source || license)
       fprintf(textallfile,"#\n");
    fprintf(textallfile,"#Latitude\tLongitude\t    Node\tSegment\tSegment\tTotal\tTotal  \tSpeed\tHighway\n");
    fprintf(textallfile,"#        \t         \t        \tDist   \tDurat'n\tDist \tDurat'n\t     \t       \n");
                        /* "%10.6f\t%11.6f\t%8d%c\t%5.3f\t%5.2f\t%5.2f\t%5.1f\t%3d\t%s\n" */
   }
}


/*++++++++++++++++++++++++++++++++++++++
  Print the optimum route between two nodes.

  Results *results The set of results to print.

  Nodes *nodes The list of nodes.

  Segments *segments The set of segments to use.

  Ways *ways The list of ways.

  Profile *profile The profile containing the transport type, speeds and allowed highways.
  ++++++++++++++++++++++++++++++++++++++*/

void PrintRoute(Results *results,Nodes *nodes,Segments *segments,Ways *ways,Profile *profile)
{
 static distance_t cum_distance=0;
 static duration_t cum_duration=0;
 static int segment_count=0;
 static int route_count=0;
 double finish_lat,finish_lon;
 double start_lat,start_lon;
 distance_t junc_distance=0;
 duration_t junc_duration=0;
 Result *result;

 fprintf(gpxtrackfile,"<trkseg>\n");

 if(IsFakeNode(results->start))
    GetFakeLatLong(results->start,&start_lat,&start_lon);
 else
    GetLatLong(nodes,results->start,&start_lat,&start_lon);

 if(IsFakeNode(results->finish))
    GetFakeLatLong(results->finish,&finish_lat,&finish_lon);
 else
    GetLatLong(nodes,results->finish,&finish_lat,&finish_lon);

 result=FindResult(results,results->start);

 do
   {
    double latitude,longitude;

    if(result->node==results->start)
      {latitude=start_lat; longitude=start_lon;}
    else if(result->node==results->finish)
      {latitude=finish_lat; longitude=finish_lon;}
    else
       GetLatLong(nodes,result->node,&latitude,&longitude);

    if(gpxtrackfile)
       fprintf(gpxtrackfile,"<trkpt lat=\"%.6f\" lon=\"%.6f\"/>\n",
               radians_to_degrees(latitude),radians_to_degrees(longitude));

    if(result->node!=results->start)
      {
       distance_t seg_distance=0;
       duration_t seg_duration=0;
       Segment *segment;
       Way *resultway;
       int important=0;

       /* Get the properties of this segment */

       resultway=LookupWay(ways,result->segment->way);

       seg_distance+=DISTANCE(result->segment->distance);
       seg_duration+=Duration(result->segment,resultway,profile);
       junc_distance+=seg_distance;
       junc_duration+=seg_duration;
       cum_distance+=seg_distance;
       cum_duration+=seg_duration;

       /* Decide if this is an important junction */

       if(result->node==results->finish)
          important=1;
       else
         {
          segment=FirstSegment(segments,nodes,result->node);

          do
            {
             index_t othernode=OtherNode(segment,result->node);

             if(othernode!=result->prev)
                if(IsNormalSegment(segment) && (!profile->oneway || !IsOnewayTo(segment,result->node)))
                  {
                   Way *way=LookupWay(ways,segment->way);

                   if(othernode==result->next) /* the next segment that we follow */
                     {
                      if(HIGHWAY(way->type)!=HIGHWAY(resultway->type))
                        {important=1; break;}
                     }
                   else /* a segment that we don't follow */
                      if(junction_other_way[HIGHWAY(resultway->type)-1][HIGHWAY(way->type)-1])
                        {important=1; break;}
                  }

             segment=NextSegment(segments,segment,result->node);
            }
          while(segment);
         }

       /* Print out the junctions */

       if(important)
         {
          if(result->node!=results->finish)
            {
             /* Don't print the intermediate finish points (because they are also intermediate start points) */

             if(gpxroutefile)
                fprintf(gpxroutefile,"<rtept lat=\"%.6f\" lon=\"%.6f\"><name>TRIP%03d</name></rtept>\n",
                        radians_to_degrees(latitude),radians_to_degrees(longitude),
                        ++route_count);
            }
          else
            {
             finish_latitude=latitude;
             finish_longitude=longitude;
            }

          /* Do print the intermediate finish points (because they have correct junction distances) */

          if(textfile)
             fprintf(textfile,"%10.6f\t%11.6f\t%6.3f km\t%4.1f min\t%5.1f km\t%3.0f min\t%s\n",
                     radians_to_degrees(latitude),radians_to_degrees(longitude),
                     distance_to_km(junc_distance),duration_to_minutes(junc_duration),
                     distance_to_km(cum_distance),duration_to_minutes(cum_duration),
                     WayName(ways,resultway));

          junc_distance=0;
          junc_duration=0;
         }

       /* Print out all of the results */

       if(textallfile)
          fprintf(textallfile,"%10.6f\t%11.6f\t%8d%c\t%5.3f\t%5.2f\t%5.2f\t%5.1f\t%3d\t%s\n",
                  radians_to_degrees(latitude),radians_to_degrees(longitude),
                  IsFakeNode(result->node)?-(result->node&(~NODE_SUPER)):result->node,
                  (!IsFakeNode(result->node) && IsSuperNode(nodes,result->node))?'*':' ',
                  distance_to_km(seg_distance),duration_to_minutes(seg_duration),
                  distance_to_km(cum_distance),duration_to_minutes(cum_duration),
                  profile->speed[HIGHWAY(resultway->type)],WayName(ways,resultway));
      }
    else if(!cum_distance)
      {
       /* Print out the very first start point */

       if(gpxroutefile)
          fprintf(gpxroutefile,"<rtept lat=\"%.6f\" lon=\"%.6f\"><name>START</name></rtept>\n",
                  radians_to_degrees(latitude),radians_to_degrees(longitude));

       if(textfile)
          fprintf(textfile,"%10.6f\t%11.6f\t%6.3f km\t%4.1f min\t%5.1f km\t%3.0f min\t\n",
                  radians_to_degrees(latitude),radians_to_degrees(longitude),
                  0.0,0.0,0.0,0.0);

       if(textallfile)
          fprintf(textallfile,"%10.6f\t%11.6f\t%8d%c\t%5.3f\t%5.2f\t%5.2f\t%5.1f\n",
                  radians_to_degrees(latitude),radians_to_degrees(longitude),
                  IsFakeNode(result->node)?-(result->node&(~NODE_SUPER)):result->node,
                  (!IsFakeNode(result->node) && IsSuperNode(nodes,result->node))?'*':' ',
                  0.0,0.0,0.0,0.0);
      }
    else
      {
       /* Print out the intermediate start points */

       if(gpxroutefile)
          fprintf(gpxroutefile,"<rtept lat=\"%.6f\" lon=\"%.6f\"><name>INTER%d</name></rtept>\n",
                  radians_to_degrees(latitude),radians_to_degrees(longitude),
                  ++segment_count);
      }

    result=FindResult(results,result->next);
   }
    while(result);

 if(gpxtrackfile)
    fprintf(gpxtrackfile,"</trkseg>\n");
}


/*++++++++++++++++++++++++++++++++++++++
  Print the tail and close the files.
  ++++++++++++++++++++++++++++++++++++++*/

void PrintRouteTail(void)
{
 /* Print the very final point in the route */

 if(gpxroutefile)
    fprintf(gpxroutefile,"<rtept lat=\"%.6f\" lon=\"%.6f\"><name>FINISH</name></rtept>\n",
            radians_to_degrees(finish_latitude),radians_to_degrees(finish_longitude));

 /* Print the tail of the files */

 if(gpxtrackfile)
   {
    fprintf(gpxtrackfile,"</trk>\n");
    fprintf(gpxtrackfile,"</gpx>\n");
   }

 if(gpxroutefile)
   {
    fprintf(gpxroutefile,"</rte>\n");
    fprintf(gpxroutefile,"</gpx>\n");
   }

 /* Close the files */

 if(gpxtrackfile)
    fclose(gpxtrackfile);
 if(gpxroutefile)
    fclose(gpxroutefile);
 if(textfile)
    fclose(textfile);
 if(textallfile)
    fclose(textallfile);
}
1	/***************************************
2	$Header: /home/amb/CVS/routino/src/output.c,v 1.17 2009-11-23 18:42:40 amb Exp $
3
4	Routing output generator.
5
6	Part of the Routino routing software.
7	****************/ /****************
8	This file Copyright 2008,2009 Andrew M. Bishop
9
10	This program is free software: you can redistribute it and/or modify
11	it under the terms of the GNU Affero General Public License as published by
12	the Free Software Foundation, either version 3 of the License, or
13	(at your option) any later version.
14
15	This program is distributed in the hope that it will be useful,
16	but WITHOUT ANY WARRANTY; without even the implied warranty of
17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	GNU Affero General Public License for more details.
19
20	You should have received a copy of the GNU Affero General Public License
21	along with this program. If not, see <http://www.gnu.org/licenses/>.
22	***************************************/
23
24
25	#include <stdlib.h>
26	#include <string.h>
27	#include <ctype.h>
28	#include <stdio.h>
29	#include <sys/types.h>
30	#include <sys/stat.h>
31	#include <unistd.h>
32
33	#include "types.h"
34	#include "functions.h"
35	#include "nodes.h"
36	#include "segments.h"
37	#include "ways.h"
38	#include "results.h"
39
40
41	/+ The option to calculate the quickest route insted of the shortest. +/
42	extern int option_quickest;
43
44	/+ The files to write to. +/
45	static FILE gpxtrackfile=NULL,gpxroutefile=NULL,textfile=NULL,textallfile=NULL;
46
47	/+ The final latitude, longitude point. +/
48	static double finish_latitude,finish_longitude;
49
50	/+ Heuristics for determining if a junction is important. +/
51	static char junction_other_way[Way_Count][Way_Count]=
52	{ /* M, T, P, S, T, U, R, S, T, C, P, S = Way type of route not taken */
53	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 }, /* Motorway */
54	{ 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* Trunk */
55	{ 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, /* Primary */
56	{ 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, /* Secondary */
57	{ 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 }, /* Tertiary */
58	{ 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }, /* Unclassified */
59	{ 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 }, /* Residential */
60	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 }, /* Service */
61	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* Track */
62	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* Cycleway */
63	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* Path */
64	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* Steps */
65	};
66
67
68	/*++++++++++++++++++++++++++++++++++++++
69	Open the files and print the head.
70
71	const char *copyright The name of a file that might exist and contain copyright information.
72	++++++++++++++++++++++++++++++++++++++*/
73
74	void PrintRouteHead(const char *copyright)
75	{
76	char source=NULL,license=NULL;
77
78	if(copyright)
79	{
80	struct stat buf;
81
82	if(!stat(copyright,&buf))
83	{
84	FILE *file=fopen(copyright,"r");
85	char string=(char)malloc(buf.st_size+1);
86	char *p;
87
88	fread(string,buf.st_size,1,file);
89	string[buf.st_size]=0;
90
91	p=string;
92	while(*p)
93	{
94	if(!strncmp(p,"Source:",7))
95	{
96	p+=7;
97	while(p==' ' \|\| p=='t')
98	p++;
99	source=p;
100	while(p && p!='\r' && *p!='\n')
101	p++;
102	while(p=='\r' \|\| p=='\n')
103	*p++=0;
104	}
105	else if(!strncmp(p,"License:",8) \|\| !strncmp(p,"Licence:",8))
106	{
107	p+=8;
108	while(p==' ' \|\| p=='t')
109	p++;
110	license=p;
111	while(p && p!='\r' && *p!='\n')
112	p++;
113	while(p=='\r' \|\| p=='\n')
114	*p++=0;
115	}
116	else
117	{
118	while(p && p!='\r' && *p!='\n')
119	p++;
120	while(p=='\r' \|\| p=='\n')
121	*p++=0;
122	}
123	}
124
125	fclose(file);
126	}
127	}
128
129	/* Open the files */
130
131	if(option_quickest==0)
132	{
133	/* Print the result for the shortest route */
134
135	gpxtrackfile=fopen("shortest-track.gpx","w");
136	gpxroutefile=fopen("shortest-route.gpx","w");
137	textfile =fopen("shortest.txt","w");
138	textallfile =fopen("shortest-all.txt","w");
139
140	if(!gpxtrackfile)
141	fprintf(stderr,"Warning: Cannot open file 'shortest-track.gpx' to write.\n");
142	if(!gpxroutefile)
143	fprintf(stderr,"Warning: Cannot open file 'shortest-route.gpx' to write.\n");
144	if(!textfile)
145	fprintf(stderr,"Warning: Cannot open file 'shortest.txt' to write.\n");
146	if(!textallfile)
147	fprintf(stderr,"Warning: Cannot open file 'shortest-all.txt' to write.\n");
148	}
149	else
150	{
151	/* Print the result for the quickest route */
152
153	gpxtrackfile=fopen("quickest-track.gpx","w");
154	gpxroutefile=fopen("quickest-route.gpx","w");
155	textfile =fopen("quickest.txt","w");
156	textallfile =fopen("quickest-all.txt","w");
157
158	if(!gpxtrackfile)
159	fprintf(stderr,"Warning: Cannot open file 'quickest-track.gpx' to write.\n");
160	if(!gpxroutefile)
161	fprintf(stderr,"Warning: Cannot open file 'quickest-route.gpx' to write.\n");
162	if(!textfile)
163	fprintf(stderr,"Warning: Cannot open file 'quickest.txt' to write.\n");
164	if(!textallfile)
165	fprintf(stderr,"Warning: Cannot open file 'quickest-all.txt' to write.\n");
166	}
167
168	/* Print the head of the files */
169
170	if(gpxtrackfile)
171	{
172	fprintf(gpxtrackfile,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
173	fprintf(gpxtrackfile,"<gpx version=\"1.1\" creator=\"Routino\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://www.topografix.com/GPX/1/1\" xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd\">\n");
174
175	fprintf(gpxtrackfile,"<metadata>\n");
176	fprintf(gpxtrackfile,"<desc><![CDATA[%s route between 'start' and 'finish' waypoints]]></desc>\n",option_quickest?"Quickest":"Shortest");
177	if(source)
178	fprintf(gpxtrackfile,"<copyright author=\"%s\">\n",source);
179	if(license)
180	fprintf(gpxtrackfile,"<license>%s</license>\n",license);
181	if(source)
182	fprintf(gpxtrackfile,"</copyright>\n");
183	fprintf(gpxtrackfile,"</metadata>\n");
184
185	fprintf(gpxtrackfile,"<trk>\n");
186	}
187
188	if(gpxroutefile)
189	{
190	fprintf(gpxroutefile,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
191	fprintf(gpxroutefile,"<gpx version=\"1.1\" creator=\"Routino\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://www.topografix.com/GPX/1/1\" xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd\">\n");
192
193	fprintf(gpxroutefile,"<metadata>\n");
194	fprintf(gpxroutefile,"<desc><![CDATA[%s route between 'start' and 'finish' waypoints]]></desc>\n",option_quickest?"Quickest":"Shortest");
195	if(source)
196	fprintf(gpxroutefile,"<copyright author=\"%s\">\n",source);
197	if(license)
198	fprintf(gpxroutefile,"<license>%s</license>\n",license);
199	if(source)
200	fprintf(gpxroutefile,"</copyright>\n");
201	fprintf(gpxroutefile,"</metadata>\n");
202
203	fprintf(gpxroutefile,"<rte>\n");
204	fprintf(gpxroutefile,"<name>%s route</name>\n",option_quickest?"Quickest":"Shortest");
205	}
206
207	if(textfile)
208	{
209	if(source)
210	fprintf(textfile,"# Source: %s\n",source);
211	if(license)
212	fprintf(textfile,"# License: %s\n",license);
213	if(source \|\| license)
214	fprintf(textfile,"#\n");
215	fprintf(textfile,"#Latitude\tLongitude\tSegment \tSegment \tTotal \tTotal \tHighway\n");
216	fprintf(textfile,"# \t \tDistance\tDuration\tDistance\tDurat'n\t \n");
217	/* "%10.6f\t%11.6f\t%6.3f km\t%4.1f min\t%5.1f km\t%3.0f min\t%s\n" */
218	}
219
220	if(textallfile)
221	{
222	if(source)
223	fprintf(textallfile,"# Source: %s\n",source);
224	if(license)
225	fprintf(textallfile,"# License: %s\n",license);
226	if(source \|\| license)
227	fprintf(textallfile,"#\n");
228	fprintf(textallfile,"#Latitude\tLongitude\t Node\tSegment\tSegment\tTotal\tTotal \tSpeed\tHighway\n");
229	fprintf(textallfile,"# \t \t \tDist \tDurat'n\tDist \tDurat'n\t \t \n");
230	/* "%10.6f\t%11.6f\t%8d%c\t%5.3f\t%5.2f\t%5.2f\t%5.1f\t%3d\t%s\n" */
231	}
232	}
233
234
235	/*++++++++++++++++++++++++++++++++++++++
236	Print the optimum route between two nodes.
237
238	Results *results The set of results to print.
239
240	Nodes *nodes The list of nodes.
241
242	Segments *segments The set of segments to use.
243
244	Ways *ways The list of ways.
245
246	Profile *profile The profile containing the transport type, speeds and allowed highways.
247	++++++++++++++++++++++++++++++++++++++*/
248
249	void PrintRoute(Results results,Nodes nodes,Segments segments,Ways ways,Profile *profile)
250	{
251	static distance_t cum_distance=0;
252	static duration_t cum_duration=0;
253	static int segment_count=0;
254	static int route_count=0;
255	double finish_lat,finish_lon;
256	double start_lat,start_lon;
257	distance_t junc_distance=0;
258	duration_t junc_duration=0;
259	Result *result;
260
261	fprintf(gpxtrackfile,"<trkseg>\n");
262
263	if(IsFakeNode(results->start))
264	GetFakeLatLong(results->start,&start_lat,&start_lon);
265	else
266	GetLatLong(nodes,results->start,&start_lat,&start_lon);
267
268	if(IsFakeNode(results->finish))
269	GetFakeLatLong(results->finish,&finish_lat,&finish_lon);
270	else
271	GetLatLong(nodes,results->finish,&finish_lat,&finish_lon);
272
273	result=FindResult(results,results->start);
274
275	do
276	{
277	double latitude,longitude;
278
279	if(result->node==results->start)
280	{latitude=start_lat; longitude=start_lon;}
281	else if(result->node==results->finish)
282	{latitude=finish_lat; longitude=finish_lon;}
283	else
284	GetLatLong(nodes,result->node,&latitude,&longitude);
285
286	if(gpxtrackfile)
287	fprintf(gpxtrackfile,"<trkpt lat=\"%.6f\" lon=\"%.6f\"/>\n",
288	radians_to_degrees(latitude),radians_to_degrees(longitude));
289
290	if(result->node!=results->start)
291	{
292	distance_t seg_distance=0;
293	duration_t seg_duration=0;
294	Segment *segment;
295	Way *resultway;
296	int important=0;
297
298	/* Get the properties of this segment */
299
300	resultway=LookupWay(ways,result->segment->way);
301
302	seg_distance+=DISTANCE(result->segment->distance);
303	seg_duration+=Duration(result->segment,resultway,profile);
304	junc_distance+=seg_distance;
305	junc_duration+=seg_duration;
306	cum_distance+=seg_distance;
307	cum_duration+=seg_duration;
308
309	/* Decide if this is an important junction */
310
311	if(result->node==results->finish)
312	important=1;
313	else
314	{
315	segment=FirstSegment(segments,nodes,result->node);
316
317	do
318	{
319	index_t othernode=OtherNode(segment,result->node);
320
321	if(othernode!=result->prev)
322	if(IsNormalSegment(segment) && (!profile->oneway \|\| !IsOnewayTo(segment,result->node)))
323	{
324	Way *way=LookupWay(ways,segment->way);
325
326	if(othernode==result->next) /* the next segment that we follow */
327	{
328	if(HIGHWAY(way->type)!=HIGHWAY(resultway->type))
329	{important=1; break;}
330	}
331	else /* a segment that we don't follow */
332	if(junction_other_way[HIGHWAY(resultway->type)-1][HIGHWAY(way->type)-1])
333	{important=1; break;}
334	}
335
336	segment=NextSegment(segments,segment,result->node);
337	}
338	while(segment);
339	}
340
341	/* Print out the junctions */
342
343	if(important)
344	{
345	if(result->node!=results->finish)
346	{
347	/* Don't print the intermediate finish points (because they are also intermediate start points) */
348
349	if(gpxroutefile)
350	fprintf(gpxroutefile,"<rtept lat=\"%.6f\" lon=\"%.6f\"><name>TRIP%03d</name></rtept>\n",
351	radians_to_degrees(latitude),radians_to_degrees(longitude),
352	++route_count);
353	}
354	else
355	{
356	finish_latitude=latitude;
357	finish_longitude=longitude;
358	}
359
360	/* Do print the intermediate finish points (because they have correct junction distances) */
361
362	if(textfile)
363	fprintf(textfile,"%10.6f\t%11.6f\t%6.3f km\t%4.1f min\t%5.1f km\t%3.0f min\t%s\n",
364	radians_to_degrees(latitude),radians_to_degrees(longitude),
365	distance_to_km(junc_distance),duration_to_minutes(junc_duration),
366	distance_to_km(cum_distance),duration_to_minutes(cum_duration),
367	WayName(ways,resultway));
368
369	junc_distance=0;
370	junc_duration=0;
371	}
372
373	/* Print out all of the results */
374
375	if(textallfile)
376	fprintf(textallfile,"%10.6f\t%11.6f\t%8d%c\t%5.3f\t%5.2f\t%5.2f\t%5.1f\t%3d\t%s\n",
377	radians_to_degrees(latitude),radians_to_degrees(longitude),
378	IsFakeNode(result->node)?-(result->node&(~NODE_SUPER)):result->node,
379	(!IsFakeNode(result->node) && IsSuperNode(nodes,result->node))?'*':' ',
380	distance_to_km(seg_distance),duration_to_minutes(seg_duration),
381	distance_to_km(cum_distance),duration_to_minutes(cum_duration),
382	profile->speed[HIGHWAY(resultway->type)],WayName(ways,resultway));
383	}
384	else if(!cum_distance)
385	{
386	/* Print out the very first start point */
387
388	if(gpxroutefile)
389	fprintf(gpxroutefile,"<rtept lat=\"%.6f\" lon=\"%.6f\"><name>START</name></rtept>\n",
390	radians_to_degrees(latitude),radians_to_degrees(longitude));
391
392	if(textfile)
393	fprintf(textfile,"%10.6f\t%11.6f\t%6.3f km\t%4.1f min\t%5.1f km\t%3.0f min\t\n",
394	radians_to_degrees(latitude),radians_to_degrees(longitude),
395	0.0,0.0,0.0,0.0);
396
397	if(textallfile)
398	fprintf(textallfile,"%10.6f\t%11.6f\t%8d%c\t%5.3f\t%5.2f\t%5.2f\t%5.1f\n",
399	radians_to_degrees(latitude),radians_to_degrees(longitude),
400	IsFakeNode(result->node)?-(result->node&(~NODE_SUPER)):result->node,
401	(!IsFakeNode(result->node) && IsSuperNode(nodes,result->node))?'*':' ',
402	0.0,0.0,0.0,0.0);
403	}
404	else
405	{
406	/* Print out the intermediate start points */
407
408	if(gpxroutefile)
409	fprintf(gpxroutefile,"<rtept lat=\"%.6f\" lon=\"%.6f\"><name>INTER%d</name></rtept>\n",
410	radians_to_degrees(latitude),radians_to_degrees(longitude),
411	++segment_count);
412	}
413
414	result=FindResult(results,result->next);
415	}
416	while(result);
417
418	if(gpxtrackfile)
419	fprintf(gpxtrackfile,"</trkseg>\n");
420	}
421
422
423	/*++++++++++++++++++++++++++++++++++++++
424	Print the tail and close the files.
425	++++++++++++++++++++++++++++++++++++++*/
426
427	void PrintRouteTail(void)
428	{
429	/* Print the very final point in the route */
430
431	if(gpxroutefile)
432	fprintf(gpxroutefile,"<rtept lat=\"%.6f\" lon=\"%.6f\"><name>FINISH</name></rtept>\n",
433	radians_to_degrees(finish_latitude),radians_to_degrees(finish_longitude));
434
435	/* Print the tail of the files */
436
437	if(gpxtrackfile)
438	{
439	fprintf(gpxtrackfile,"</trk>\n");
440	fprintf(gpxtrackfile,"</gpx>\n");
441	}
442
443	if(gpxroutefile)
444	{
445	fprintf(gpxroutefile,"</rte>\n");
446	fprintf(gpxroutefile,"</gpx>\n");
447	}
448
449	/* Close the files */
450
451	if(gpxtrackfile)
452	fclose(gpxtrackfile);
453	if(gpxroutefile)
454	fclose(gpxroutefile);
455	if(textfile)
456	fclose(textfile);
457	if(textallfile)
458	fclose(textallfile);
459	}