[andy/viking.git] / src / vikutils.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
 *
 * Copyright (C) 2013, Rob Norris <rw_norris@hotmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#include <math.h>
#include <glib/gi18n.h>

#include "viking.h"
#include "vikutils.h"

#define FMT_MAX_NUMBER_CODES 9

/**
 * vu_trackpoint_formatted_message:
 * @format_code:  String describing the message to generate
 * @trkpt:        The trackpoint for which the message is generated about
 * @trkpt_prev:   A trackpoint (presumed previous) for interpolating values with the other trackpoint (such as speed)
 * @trk:          The track in which the trackpoints reside
 *
 *  TODO: One day replace this cryptic format code with some kind of tokenizer parsing
 *    thus would make it more user friendly and maybe even GUI controlable.
 * However for now at least there is some semblance of user control
 */
gchar* vu_trackpoint_formatted_message ( gchar *format_code, VikTrackpoint *trkpt, VikTrackpoint *trkpt_prev, VikTrack *trk )
{
	if ( !trkpt )
		return NULL;

	gint len = 0;
	if ( format_code )
		len = strlen ( format_code );
	if ( len > FMT_MAX_NUMBER_CODES )
		len = FMT_MAX_NUMBER_CODES;

	gchar* values[FMT_MAX_NUMBER_CODES];
	int i;
	for ( i = 0; i < FMT_MAX_NUMBER_CODES; i++ ) {
		values[i] = '\0';
	}

	gchar *speed_units_str = NULL;
	vik_units_speed_t speed_units = a_vik_get_units_speed ();
	switch (speed_units) {
	case VIK_UNITS_SPEED_MILES_PER_HOUR:
		speed_units_str = g_strdup ( _("mph") );
		break;
	case VIK_UNITS_SPEED_METRES_PER_SECOND:
		speed_units_str = g_strdup ( _("m/s") );
		break;
	case VIK_UNITS_SPEED_KNOTS:
		speed_units_str = g_strdup ( _("knots") );
		break;
	default:
		// VIK_UNITS_SPEED_KILOMETRES_PER_HOUR:
		speed_units_str = g_strdup ( _("km/h") );
		break;
	}

	gchar *separator = g_strdup ( " | " );

	for ( i = 0; i < len; i++ ) {
		switch ( g_ascii_toupper ( format_code[i] ) ) {
		case 'G': values[i] = g_strdup ( _("GPSD") ); break; // GPS Preamble
		case 'K': values[i] = g_strdup ( _("Trkpt") ); break; // Trkpt Preamble

		case 'S': {
			gdouble speed = 0.0;
			gchar *speedtype = NULL;
			if ( !isnan(trkpt->speed) && trkpt_prev ) {
				if ( trkpt->has_timestamp && trkpt_prev->has_timestamp ) {
					if ( trkpt->timestamp == trkpt_prev->timestamp ) {

						// Work out from previous trackpoint location and time difference
						speed = vik_coord_diff(&(trkpt->coord), &(trkpt_prev->coord)) / ABS(trkpt->timestamp - trkpt_prev->timestamp);

						switch (speed_units) {
						case VIK_UNITS_SPEED_KILOMETRES_PER_HOUR:
							speed = VIK_MPS_TO_KPH(speed);
							break;
						case VIK_UNITS_SPEED_MILES_PER_HOUR:
							speed = VIK_MPS_TO_MPH(speed);
							break;
						case VIK_UNITS_SPEED_KNOTS:
							speed = VIK_MPS_TO_KNOTS(speed);
							break;
						default:
							// VIK_UNITS_SPEED_METRES_PER_SECOND:
							// Already in m/s so nothing to do
							break;
						}
						speedtype = g_strdup ( "*" ); // Interpolated
					}
					else
						speedtype = g_strdup ( "**" );
				}
				else
					speedtype = g_strdup ( "**" );
			}
			else {
				speed = trkpt->speed;
				speedtype = g_strdup ( "" );
			}

			values[i] = g_strdup_printf ( _("%sSpeed%s %.1f%s"), separator, speedtype, speed, speed_units_str );
			g_free ( speedtype );
			break;
		}

		case 'A': {
			vik_units_height_t height_units = a_vik_get_units_height ();
			switch (height_units) {
			case VIK_UNITS_HEIGHT_FEET:
				values[i] = g_strdup_printf ( _("%sAlt %dfeet"), separator, (int)round(VIK_METERS_TO_FEET(trkpt->altitude)) );
				break;
			default:
				//VIK_UNITS_HEIGHT_METRES:
				values[i] = g_strdup_printf ( _("%sAlt %dm"), separator, (int)round(trkpt->altitude) );
				break;
			}
			break;
		}

		case 'C': {
			gint heading = isnan(trkpt->course) ? 0 : (gint)round(trkpt->course);
			values[i] = g_strdup_printf ( _("%sCourse %03d\302\260" ), separator, heading );
			break;
		}

		case 'P': {
			if ( trkpt_prev ) {
				gint diff = (gint) round ( vik_coord_diff ( &(trkpt->coord), &(trkpt_prev->coord) ) );

				gchar *dist_units_str = NULL;
				vik_units_distance_t dist_units = a_vik_get_units_distance ();
				// expect the difference between track points to be small hence use metres or yards
				switch (dist_units) {
				case VIK_UNITS_DISTANCE_MILES:
					dist_units_str = g_strdup ( _("yards") );
					break;
				default:
					// VIK_UNITS_DISTANCE_KILOMETRES:
					dist_units_str = g_strdup ( _("m") );
					break;
				}

				values[i] = g_strdup_printf ( _("%sDistance diff %d%s"), separator, diff, dist_units_str );

				g_free ( dist_units_str );
			}
			break;
		}

		case 'T': {
			gchar tmp[64];
			tmp[0] = '\0';
			if ( trkpt->has_timestamp ) {
				// Compact date time format
				strftime (tmp, sizeof(tmp), "%x %X", localtime(&(trkpt->timestamp)));
			}
			else
				g_snprintf (tmp, sizeof(tmp), "--");
			values[i] = g_strdup_printf ( _("%sTime %s"), separator, tmp );
			break;
		}

		case 'M': {
			if ( trkpt_prev ) {
				if ( trkpt->has_timestamp && trkpt_prev->has_timestamp ) {
					time_t t_diff = trkpt->timestamp - trkpt_prev->timestamp;
					values[i] = g_strdup_printf ( _("%sTime diff %lds"), separator, t_diff );
				}
			}
			break;
		}

		case 'X': values[i] = g_strdup_printf ( _("%sNo. of Sats %d"), separator, trkpt->nsats ); break;

		case 'D': {
			if ( trk ) {
				// Distance from start (along the track)
				gdouble distd =	vik_track_get_length_to_trackpoint (trk, trkpt);
				gchar *dist_units_str = NULL;
				vik_units_distance_t dist_units = a_vik_get_units_distance ();
				// expect the difference between track points to be small hence use metres or yards
				switch (dist_units) {
				case VIK_UNITS_DISTANCE_MILES:
					dist_units_str = g_strdup ( _("miles") );
					distd = VIK_METERS_TO_MILES(distd);
					break;
				default:
					// VIK_UNITS_DISTANCE_KILOMETRES:
					dist_units_str = g_strdup ( _("km") );
					distd = distd / 1000.0;
					break;
				}
				values[i] = g_strdup_printf ( _("%sDistance along %.2f%s"), separator, distd, dist_units_str );
				g_free ( dist_units_str );
			}
			break;
		}

		case 'L': {
			// Location (Lat/Long)
			gchar *lat = NULL, *lon = NULL;
			struct LatLon ll;
			vik_coord_to_latlon (&(trkpt->coord), &ll);
			a_coords_latlon_to_string ( &ll, &lat, &lon );
			values[i] = g_strdup_printf ( "%s%s %s", separator, lat, lon );
			g_free ( lat );
			g_free ( lon );
			break;
		}

		case 'N': // Name of track
			values[i] = g_strdup_printf ( _("%sTrack: %s"), separator, trk->name );
			break;

		case 'E': // Name of trackpoint if available
			if ( trkpt->name )
				values[i] = g_strdup_printf ( "%s%s", separator, trkpt->name );
			else
				values[i] = g_strdup ( "" );
			break;

		default:
			break;
		}
	}

	g_free ( separator );
	g_free ( speed_units_str );

	gchar *msg = g_strconcat ( values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], NULL );

	for ( i = 0; i < FMT_MAX_NUMBER_CODES; i++ ) {
		if ( values[i] != '\0' )
			g_free ( values[i] );
	}
	
	return msg;
}
Commit	Line	Data
f93e0210 RN	1	/* -- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -- */
	2	/*
	3	* viking -- GPS Data and Topo Analyzer, Explorer, and Manager
	4	*
	5	* Copyright (C) 2013, Rob Norris <rw_norris@hotmail.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*
	21	*/
	22	#include <math.h>
	23	#include <glib/gi18n.h>
	24
	25	#include "viking.h"
	26	#include "vikutils.h"
	27
	28	#define FMT_MAX_NUMBER_CODES 9
	29
	30	/**
	31	* vu_trackpoint_formatted_message:
	32	* @format_code: String describing the message to generate
	33	* @trkpt: The trackpoint for which the message is generated about
	34	* @trkpt_prev: A trackpoint (presumed previous) for interpolating values with the other trackpoint (such as speed)
	35	* @trk: The track in which the trackpoints reside
	36	*
	37	* TODO: One day replace this cryptic format code with some kind of tokenizer parsing
	38	* thus would make it more user friendly and maybe even GUI controlable.
	39	* However for now at least there is some semblance of user control
	40	*/
	41	gchar* vu_trackpoint_formatted_message ( gchar format_code, VikTrackpoint trkpt, VikTrackpoint trkpt_prev, VikTrack trk )
	42	{
	43	if ( !trkpt )
	44	return NULL;
	45
	46	gint len = 0;
	47	if ( format_code )
	48	len = strlen ( format_code );
	49	if ( len > FMT_MAX_NUMBER_CODES )
	50	len = FMT_MAX_NUMBER_CODES;
	51
	52	gchar* values[FMT_MAX_NUMBER_CODES];
	53	int i;
	54	for ( i = 0; i < FMT_MAX_NUMBER_CODES; i++ ) {
	55	values[i] = '\0';
	56	}
	57
	58	gchar *speed_units_str = NULL;
	59	vik_units_speed_t speed_units = a_vik_get_units_speed ();
	60	switch (speed_units) {
	61	case VIK_UNITS_SPEED_MILES_PER_HOUR:
	62	speed_units_str = g_strdup ( _("mph") );
	63	break;
	64	case VIK_UNITS_SPEED_METRES_PER_SECOND:
65	speed_units_str = g_strdup ( _("m/s") );
66	break;
67	case VIK_UNITS_SPEED_KNOTS:
68	speed_units_str = g_strdup ( _("knots") );
69	break;
70	default:
71	// VIK_UNITS_SPEED_KILOMETRES_PER_HOUR:
72	speed_units_str = g_strdup ( _("km/h") );
73	break;
74	}
75
76	gchar *separator = g_strdup ( " \| " );
77
78	for ( i = 0; i < len; i++ ) {
79	switch ( g_ascii_toupper ( format_code[i] ) ) {
80	case 'G': values[i] = g_strdup ( _("GPSD") ); break; // GPS Preamble
81	case 'K': values[i] = g_strdup ( _("Trkpt") ); break; // Trkpt Preamble
82
83	case 'S': {
84	gdouble speed = 0.0;
85	gchar *speedtype = NULL;
86	if ( !isnan(trkpt->speed) && trkpt_prev ) {
87	if ( trkpt->has_timestamp && trkpt_prev->has_timestamp ) {
88	if ( trkpt->timestamp == trkpt_prev->timestamp ) {
89
90	// Work out from previous trackpoint location and time difference
91	speed = vik_coord_diff(&(trkpt->coord), &(trkpt_prev->coord)) / ABS(trkpt->timestamp - trkpt_prev->timestamp);
92
93	switch (speed_units) {
94	case VIK_UNITS_SPEED_KILOMETRES_PER_HOUR:
95	speed = VIK_MPS_TO_KPH(speed);
96	break;
97	case VIK_UNITS_SPEED_MILES_PER_HOUR:
98	speed = VIK_MPS_TO_MPH(speed);
99	break;
100	case VIK_UNITS_SPEED_KNOTS:
101	speed = VIK_MPS_TO_KNOTS(speed);
102	break;
103	default:
104	// VIK_UNITS_SPEED_METRES_PER_SECOND:
105	// Already in m/s so nothing to do
106	break;
107	}
108	speedtype = g_strdup ( "*" ); // Interpolated
109	}
110	else
111	speedtype = g_strdup ( "**" );
112	}
113	else
114	speedtype = g_strdup ( "**" );
115	}
116	else {
117	speed = trkpt->speed;
118	speedtype = g_strdup ( "" );
119	}
120
121	values[i] = g_strdup_printf ( _("%sSpeed%s %.1f%s"), separator, speedtype, speed, speed_units_str );
122	g_free ( speedtype );
123	break;
124	}
125
126	case 'A': {
127	vik_units_height_t height_units = a_vik_get_units_height ();
128	switch (height_units) {
129	case VIK_UNITS_HEIGHT_FEET:
130	values[i] = g_strdup_printf ( _("%sAlt %dfeet"), separator, (int)round(VIK_METERS_TO_FEET(trkpt->altitude)) );
131	break;
132	default:
133	//VIK_UNITS_HEIGHT_METRES:
134	values[i] = g_strdup_printf ( _("%sAlt %dm"), separator, (int)round(trkpt->altitude) );
135	break;
136	}
137	break;
138	}
139
140	case 'C': {
141	gint heading = isnan(trkpt->course) ? 0 : (gint)round(trkpt->course);
142	values[i] = g_strdup_printf ( _("%sCourse %03d\302\260" ), separator, heading );
143	break;
144	}
145
146	case 'P': {
147	if ( trkpt_prev ) {
148	gint diff = (gint) round ( vik_coord_diff ( &(trkpt->coord), &(trkpt_prev->coord) ) );
149
150	gchar *dist_units_str = NULL;
151	vik_units_distance_t dist_units = a_vik_get_units_distance ();
152	// expect the difference between track points to be small hence use metres or yards
153	switch (dist_units) {
154	case VIK_UNITS_DISTANCE_MILES:
155	dist_units_str = g_strdup ( _("yards") );
156	break;
157	default:
158	// VIK_UNITS_DISTANCE_KILOMETRES:
159	dist_units_str = g_strdup ( _("m") );
160	break;
161	}
162
163	values[i] = g_strdup_printf ( _("%sDistance diff %d%s"), separator, diff, dist_units_str );
164
165	g_free ( dist_units_str );
166	}
167	break;
168	}
169
170	case 'T': {
171	gchar tmp[64];
172	tmp[0] = '\0';
173	if ( trkpt->has_timestamp ) {
174	// Compact date time format
175	strftime (tmp, sizeof(tmp), "%x %X", localtime(&(trkpt->timestamp)));
176	}
177	else
178	g_snprintf (tmp, sizeof(tmp), "--");
179	values[i] = g_strdup_printf ( _("%sTime %s"), separator, tmp );
180	break;
181	}
182
183	case 'M': {
184	if ( trkpt_prev ) {
185	if ( trkpt->has_timestamp && trkpt_prev->has_timestamp ) {
186	time_t t_diff = trkpt->timestamp - trkpt_prev->timestamp;
187	values[i] = g_strdup_printf ( _("%sTime diff %lds"), separator, t_diff );
188	}
189	}
190	break;
191	}
192
193	case 'X': values[i] = g_strdup_printf ( _("%sNo. of Sats %d"), separator, trkpt->nsats ); break;
194
195	case 'D': {
196	if ( trk ) {
bb77b487	197	// Distance from start (along the track)
f93e0210 RN	198	gdouble distd = vik_track_get_length_to_trackpoint (trk, trkpt);
	199	gchar *dist_units_str = NULL;
	200	vik_units_distance_t dist_units = a_vik_get_units_distance ();
	201	// expect the difference between track points to be small hence use metres or yards
	202	switch (dist_units) {
	203	case VIK_UNITS_DISTANCE_MILES:
	204	dist_units_str = g_strdup ( _("miles") );
	205	distd = VIK_METERS_TO_MILES(distd);
	206	break;
	207	default:
	208	// VIK_UNITS_DISTANCE_KILOMETRES:
	209	dist_units_str = g_strdup ( _("km") );
	210	distd = distd / 1000.0;
	211	break;
	212	}
	213	values[i] = g_strdup_printf ( _("%sDistance along %.2f%s"), separator, distd, dist_units_str );
	214	g_free ( dist_units_str );
	215	}
	216	break;
	217	}
	218
	219	case 'L': {
	220	// Location (Lat/Long)
	221	gchar lat = NULL, lon = NULL;
	222	struct LatLon ll;
	223	vik_coord_to_latlon (&(trkpt->coord), &ll);
	224	a_coords_latlon_to_string ( &ll, &lat, &lon );
	225	values[i] = g_strdup_printf ( "%s%s %s", separator, lat, lon );
	226	g_free ( lat );
	227	g_free ( lon );
	228	break;
	229	}
	230
	231	case 'N': // Name of track
	232	values[i] = g_strdup_printf ( _("%sTrack: %s"), separator, trk->name );
	233	break;
	234
b45865b4 RN	235	case 'E': // Name of trackpoint if available
	236	if ( trkpt->name )
	237	values[i] = g_strdup_printf ( "%s%s", separator, trkpt->name );
	238	else
	239	values[i] = g_strdup ( "" );
	240	break;
	241
f93e0210 RN	242	default:
	243	break;
	244	}
	245	}
	246
	247	g_free ( separator );
	248	g_free ( speed_units_str );
	249
bb77b487	250	gchar *msg = g_strconcat ( values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], NULL );
f93e0210 RN	251
	252	for ( i = 0; i < FMT_MAX_NUMBER_CODES; i++ ) {
	253	if ( values[i] != '\0' )
	254	g_free ( values[i] );
	255	}
	256
	257	return msg;
	258	}