X-Git-Url: https://git.street.me.uk/andy/viking.git/blobdiff_plain/6374e157c07cc11ea6258aec7502c675f76bbecb..4a050412da32aa6f237c358cfa0c5a3775f21e9a:/src/viktrack.c diff --git a/src/viktrack.c b/src/viktrack.c index 84914a98..6eb685ad 100644 --- a/src/viktrack.c +++ b/src/viktrack.c @@ -18,13 +18,20 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif #include #include -#include #include +#ifdef HAVE_STRING_H #include +#endif +#ifdef HAVE_MATH_H #include +#endif + #include "coords.h" #include "vikcoord.h" #include "viktrack.h" @@ -83,7 +90,8 @@ void vik_track_free(VikTrack *tr) g_list_foreach ( tr->trackpoints, (GFunc) g_free, NULL ); g_list_free( tr->trackpoints ); if (tr->property_dialog) - gtk_widget_destroy ( GTK_WIDGET(tr->property_dialog) ); + if ( GTK_IS_WIDGET(tr->property_dialog) ) + gtk_widget_destroy ( GTK_WIDGET(tr->property_dialog) ); g_free ( tr ); } @@ -108,9 +116,12 @@ VikTrack *vik_track_copy ( const VikTrack *tr ) VikTrackpoint *vik_trackpoint_new() { VikTrackpoint *tp = g_malloc0(sizeof(VikTrackpoint)); - tp->extended = FALSE; tp->speed = NAN; tp->course = NAN; + tp->altitude = VIK_DEFAULT_ALTITUDE; + tp->hdop = VIK_DEFAULT_DOP; + tp->vdop = VIK_DEFAULT_DOP; + tp->pdop = VIK_DEFAULT_DOP; return tp; } @@ -369,8 +380,10 @@ gdouble *vik_track_make_elevation_map ( const VikTrack *tr, guint16 num_chunks ) chunk_length = total_length / num_chunks; /* Zero chunk_length (eg, track of 2 tp with the same loc) will cause crash */ - if (chunk_length <= 0) + if (chunk_length <= 0) { + g_free(pts); return NULL; + } current_dist = 0.0; current_area_under_curve = 0; @@ -399,7 +412,8 @@ gdouble *vik_track_make_elevation_map ( const VikTrack *tr, guint16 num_chunks ) **/ if ( ignore_it ) - pts[current_chunk] = VIK_DEFAULT_ALTITUDE; + // Seemly can't determine average for this section - so use last known good value (much better than just sticking in zero) + pts[current_chunk] = altitude1; else pts[current_chunk] = altitude1 + (altitude2-altitude1)*((dist_along_seg - (chunk_length/2))/current_seg_length); @@ -434,6 +448,12 @@ gdouble *vik_track_make_elevation_map ( const VikTrack *tr, guint16 num_chunks ) dist_along_seg = chunk_length - current_dist; if ( ignore_it || !iter->next ) { pts[current_chunk] = current_area_under_curve / current_dist; + if (!iter->next) { + int i; + for (i = current_chunk + 1; i < num_chunks; i++) + pts[i] = pts[current_chunk]; + break; + } } else { current_area_under_curve += dist_along_seg * (altitude1 + (altitude2 - altitude1)*dist_along_seg/current_seg_length); @@ -469,120 +489,95 @@ void vik_track_get_total_elevation_gain(const VikTrack *tr, gdouble *up, gdouble *up = *down = VIK_DEFAULT_ALTITUDE; } -typedef struct { - double a, b, c, d; -} spline_coeff_t; -void compute_spline(int n, double *x, double *f, spline_coeff_t *p) +/* by Alex Foobarian */ +gdouble *vik_track_make_speed_map ( const VikTrack *tr, guint16 num_chunks ) { - double *h, *alpha, *B, *m; - int i; - int orig_n = n; - double new_x[3], new_f[3]; - - if (n==0) return; - if (n==1) { - new_x[0] = x[0]; - new_f[0] = f[0]; - new_x[1] = x[0]+0.00001; - new_f[1] = f[0]; - x = new_x; - f = new_f; - n = 3; - } - if (n==2) { - new_x[0] = x[0]; - new_f[0] = f[0]; - new_x[1] = x[1]; - new_f[1] = f[1]; - new_x[2] = x[1] + x[1]-x[0]; - new_f[2] = f[1] + f[1]-f[0]; - x = new_x; - f = new_f; - n = 3; - } - - /* we're solving a linear system of equations of the form Ax = B. - * The matrix a is tridiagonal and consists of coefficients in - * the h[] and alpha[] arrays. - */ + gdouble *v, *s, *t; + gdouble duration, chunk_dur; + time_t t1, t2; + int i, pt_count, numpts, index; + GList *iter; - h = (double *)malloc(sizeof(double) * (n-1)); - for (i=0; itrackpoints ) + return NULL; - alpha = (double *)malloc(sizeof(double) * (n-2)); - for (i=0; itrackpoints->data)->timestamp; + t2 = VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp; + duration = t2 - t1; - /* Now solve the n-2 by n-2 system */ - m = (double *)malloc(sizeof(double) * (n-2)); - for (i=1; i<=n-3; i++) { - /* - d0 = alpha 0 - a0 = h1 - c0 = h1 + if ( !t1 || !t2 || !duration ) + return NULL; - di = di - (ai-1 / di-1) * ci-1 - bi = bi - (ai-1 / di-1) * bi-1 - ; - */ - alpha[i] = alpha[i] - (h[i]/alpha[i-1]) * h[i]; - B[i] = B[i] - (h[i]/alpha[i-1]) * B[i-1]; - } - /* xn-3 = bn-3 / dn-3; */ - m[n-3] = B[n-3]/alpha[n-3]; - for (i=n-4; i>=0; i--) { - m[i] = (B[i]-h[i+1]*m[i+1])/alpha[i]; + if (duration < 0) { + g_warning("negative duration: unsorted trackpoint timestamps?"); + return NULL; } + pt_count = vik_track_get_tp_count(tr); - for (i=0; itrackpoints->next; + numpts = 0; + s[0] = 0; + t[0] = VIK_TRACKPOINT(iter->prev->data)->timestamp; + numpts++; + while (iter) { + s[numpts] = s[numpts-1] + vik_coord_diff ( &(VIK_TRACKPOINT(iter->prev->data)->coord), &(VIK_TRACKPOINT(iter->data)->coord) ); + t[numpts] = VIK_TRACKPOINT(iter->data)->timestamp; + numpts++; + iter = iter->next; } - free(alpha); - free(B); - free(h); - free(m); + /* In the following computation, we iterate through periods of time of duration chunk_dur. + * The first period begins at the beginning of the track. The last period ends at the end of the track. + */ + index = 0; /* index of the current trackpoint. */ + for (i = 0; i < num_chunks; i++) { + /* we are now covering the interval from t[0] + i*chunk_dur to t[0] + (i+1)*chunk_dur. + * find the first trackpoint outside the current interval, averaging the speeds between intermediate trackpoints. + */ + if (t[0] + i*chunk_dur >= t[index]) { + gdouble acc_t = 0, acc_s = 0; + while (t[0] + i*chunk_dur >= t[index]) { + acc_s += (s[index+1]-s[index]); + acc_t += (t[index+1]-t[index]); + index++; + } + v[i] = acc_s/acc_t; + } + else if (i) { + v[i] = v[i-1]; + } + else { + v[i] = 0; + } + } + g_free(s); + g_free(t); + return v; } -/* by Alex Foobarian */ -gdouble *vik_track_make_speed_map ( const VikTrack *tr, guint16 num_chunks ) +/** + * Make a distance/time map, heavily based on the vik_track_make_speed_map method + */ +gdouble *vik_track_make_distance_map ( const VikTrack *tr, guint16 num_chunks ) { gdouble *v, *s, *t; - gdouble duration, chunk_dur, T, s_prev, s_now; + gdouble duration, chunk_dur; time_t t1, t2; - int i, pt_count, numpts, spline; + int i, pt_count, numpts, index; GList *iter; - spline_coeff_t *p; if ( ! tr->trackpoints ) return NULL; - g_assert ( num_chunks < 16000 ); - -#ifdef XXXXXXXXXXXXXXXXXX - iter = tr->trackpoints; - while (iter) { - - } -#endif /*XXXXXXXXXXXXXXXXXX*/ - t1 = VIK_TRACKPOINT(tr->trackpoints->data)->timestamp; t2 = VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp; duration = t2 - t1; @@ -591,7 +586,7 @@ gdouble *vik_track_make_speed_map ( const VikTrack *tr, guint16 num_chunks ) return NULL; if (duration < 0) { - g_warning("negative duration: unsorted trackpoint timestamps?\n"); + g_warning("negative duration: unsorted trackpoint timestamps?"); return NULL; } pt_count = vik_track_get_tp_count(tr); @@ -601,7 +596,6 @@ gdouble *vik_track_make_speed_map ( const VikTrack *tr, guint16 num_chunks ) s = g_malloc(sizeof(double) * pt_count); t = g_malloc(sizeof(double) * pt_count); - p = g_malloc(sizeof(spline_coeff_t) * (pt_count-1)); iter = tr->trackpoints->next; numpts = 0; @@ -615,37 +609,199 @@ gdouble *vik_track_make_speed_map ( const VikTrack *tr, guint16 num_chunks ) iter = iter->next; } - compute_spline(numpts, t, s, p); + /* In the following computation, we iterate through periods of time of duration chunk_dur. + * The first period begins at the beginning of the track. The last period ends at the end of the track. + */ + index = 0; /* index of the current trackpoint. */ + for (i = 0; i < num_chunks; i++) { + /* we are now covering the interval from t[0] + i*chunk_dur to t[0] + (i+1)*chunk_dur. + * find the first trackpoint outside the current interval, averaging the distance between intermediate trackpoints. + */ + if (t[0] + i*chunk_dur >= t[index]) { + gdouble acc_s = 0; // No need for acc_t + while (t[0] + i*chunk_dur >= t[index]) { + acc_s += (s[index+1]-s[index]); + index++; + } + // The only bit that's really different from the speed map - just keep an accululative record distance + v[i] = i ? v[i-1]+acc_s : acc_s; + } + else if (i) { + v[i] = v[i-1]; + } + else { + v[i] = 0; + } + } + g_free(s); + g_free(t); + return v; +} + +/** + * This uses the 'time' based method to make the graph, (which is a simpler compared to the elevation/distance) + * This results in a slightly blocky graph when it does not have many trackpoints: <60 + * NB Somehow the elevation/distance applies some kind of smoothing algorithm, + * but I don't think any one understands it any more (I certainly don't ATM) + */ +gdouble *vik_track_make_elevation_time_map ( const VikTrack *tr, guint16 num_chunks ) +{ + time_t t1, t2; + gdouble duration, chunk_dur; + GList *iter = tr->trackpoints; + + if (!iter || !iter->next) /* zero- or one-point track */ + return NULL; - /* the spline gives us distances at chunk_dur intervals. from these, - * we obtain average speed in each interval. + /* test if there's anything worth calculating */ + gboolean okay = FALSE; + while ( iter ) { + if ( VIK_TRACKPOINT(iter->data)->altitude != VIK_DEFAULT_ALTITUDE ) { + okay = TRUE; + break; + } + iter = iter->next; + } + if ( ! okay ) + return NULL; + + t1 = VIK_TRACKPOINT(tr->trackpoints->data)->timestamp; + t2 = VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp; + duration = t2 - t1; + + if ( !t1 || !t2 || !duration ) + return NULL; + + if (duration < 0) { + g_warning("negative duration: unsorted trackpoint timestamps?"); + return NULL; + } + gint pt_count = vik_track_get_tp_count(tr); + + // Reset iterator back to the beginning + iter = tr->trackpoints; + + gdouble *pts = g_malloc ( sizeof(gdouble) * num_chunks ); // The return altitude values + gdouble *s = g_malloc(sizeof(double) * pt_count); // calculation altitudes + gdouble *t = g_malloc(sizeof(double) * pt_count); // calculation times + + chunk_dur = duration / num_chunks; + + s[0] = VIK_TRACKPOINT(iter->data)->altitude; + t[0] = VIK_TRACKPOINT(iter->data)->timestamp; + iter = tr->trackpoints->next; + gint numpts = 1; + while (iter) { + s[numpts] = VIK_TRACKPOINT(iter->data)->altitude; + t[numpts] = VIK_TRACKPOINT(iter->data)->timestamp; + numpts++; + iter = iter->next; + } + + /* In the following computation, we iterate through periods of time of duration chunk_dur. + * The first period begins at the beginning of the track. The last period ends at the end of the track. */ - spline = 0; - T = t[spline]; - s_prev = - p[spline].d * pow(T - t[spline+1], 3) + - p[spline].c * pow(T - t[spline+1], 2) + - p[spline].b * (T - t[spline+1]) + - p[spline].a; - for (i = 0; i < num_chunks; i++, T+=chunk_dur) { - while (T > t[spline+1]) { - spline++; + gint index = 0; /* index of the current trackpoint. */ + gint i; + for (i = 0; i < num_chunks; i++) { + /* we are now covering the interval from t[0] + i*chunk_dur to t[0] + (i+1)*chunk_dur. + * find the first trackpoint outside the current interval, averaging the heights between intermediate trackpoints. + */ + if (t[0] + i*chunk_dur >= t[index]) { + gdouble acc_s = s[index]; // initialise to first point + while (t[0] + i*chunk_dur >= t[index]) { + acc_s += (s[index+1]-s[index]); + index++; + } + pts[i] = acc_s; + } + else if (i) { + pts[i] = pts[i-1]; + } + else { + pts[i] = 0; + } + } + g_free(s); + g_free(t); + + return pts; +} + +/** + * Make a speed/distance map + */ +gdouble *vik_track_make_speed_dist_map ( const VikTrack *tr, guint16 num_chunks ) +{ + gdouble *v, *s, *t; + time_t t1, t2; + gint i, pt_count, numpts, index; + GList *iter; + gdouble duration, total_length, chunk_length; + + if ( ! tr->trackpoints ) + return NULL; + + t1 = VIK_TRACKPOINT(tr->trackpoints->data)->timestamp; + t2 = VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp; + duration = t2 - t1; + + if ( !t1 || !t2 || !duration ) + return NULL; + + if (duration < 0) { + g_warning("negative duration: unsorted trackpoint timestamps?"); + return NULL; + } + + total_length = vik_track_get_length_including_gaps ( tr ); + chunk_length = total_length / num_chunks; + pt_count = vik_track_get_tp_count(tr); + + if (chunk_length <= 0) { + return NULL; + } + + v = g_malloc ( sizeof(gdouble) * num_chunks ); + s = g_malloc ( sizeof(double) * pt_count ); + t = g_malloc ( sizeof(double) * pt_count ); + + // No special handling of segments ATM... + iter = tr->trackpoints->next; + numpts = 0; + s[0] = 0; + t[0] = VIK_TRACKPOINT(iter->prev->data)->timestamp; + numpts++; + while (iter) { + s[numpts] = s[numpts-1] + vik_coord_diff ( &(VIK_TRACKPOINT(iter->prev->data)->coord), &(VIK_TRACKPOINT(iter->data)->coord) ); + t[numpts] = VIK_TRACKPOINT(iter->data)->timestamp; + numpts++; + iter = iter->next; + } + + // Iterate through a portion of the track to get an average speed for that part + // This will essentially interpolate between segments, which I think is right given the usage of 'get_length_including_gaps' + index = 0; /* index of the current trackpoint. */ + for (i = 0; i < num_chunks; i++) { + // Similar to the make_speed_map, but instead of using a time chunk, use a distance chunk + if (s[0] + i*chunk_length >= s[index]) { + gdouble acc_t = 0, acc_s = 0; + while (s[0] + i*chunk_length >= s[index]) { + acc_s += (s[index+1]-s[index]); + acc_t += (t[index+1]-t[index]); + index++; + } + v[i] = acc_s/acc_t; + } + else if (i) { + v[i] = v[i-1]; + } + else { + v[i] = 0; } - s_now = - p[spline].d * pow(T - t[spline+1], 3) + - p[spline].c * pow(T - t[spline+1], 2) + - p[spline].b * (T - t[spline+1]) + - p[spline].a; - v[i] = (s_now - s_prev) / chunk_dur; - s_prev = s_now; - /* - * old method of averages - v[i] = (s[spline+1]-s[spline])/(t[spline+1]-t[spline]); - */ } g_free(s); g_free(t); - g_free(p); return v; } @@ -735,6 +891,84 @@ VikTrackpoint *vik_track_get_closest_tp_by_percentage_time ( VikTrack *tr, gdoub return VIK_TRACKPOINT(iter->data); } +VikTrackpoint* vik_track_get_tp_by_max_speed ( const VikTrack *tr ) +{ + gdouble maxspeed = 0.0, speed = 0.0; + + if ( !tr->trackpoints ) + return NULL; + + GList *iter = tr->trackpoints; + VikTrackpoint *max_speed_tp = NULL; + + while (iter) { + if (iter->prev) { + if ( VIK_TRACKPOINT(iter->data)->has_timestamp && + VIK_TRACKPOINT(iter->prev->data)->has_timestamp && + (! VIK_TRACKPOINT(iter->data)->newsegment) ) { + speed = vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord), &(VIK_TRACKPOINT(iter->prev->data)->coord) ) + / ABS(VIK_TRACKPOINT(iter->data)->timestamp - VIK_TRACKPOINT(iter->prev->data)->timestamp); + if ( speed > maxspeed ) { + maxspeed = speed; + max_speed_tp = VIK_TRACKPOINT(iter->data); + } + } + } + iter = iter->next; + } + + if (!max_speed_tp) + return NULL; + + return max_speed_tp; +} + +VikTrackpoint* vik_track_get_tp_by_max_alt ( const VikTrack *tr ) +{ + gdouble maxalt = -5000.0; + if ( !tr->trackpoints ) + return NULL; + + GList *iter = tr->trackpoints; + VikTrackpoint *max_alt_tp = NULL; + + while (iter) { + if ( VIK_TRACKPOINT(iter->data)->altitude > maxalt ) { + maxalt = VIK_TRACKPOINT(iter->data)->altitude; + max_alt_tp = VIK_TRACKPOINT(iter->data); + } + iter = iter->next; + } + + if (!max_alt_tp) + return NULL; + + return max_alt_tp; +} + +VikTrackpoint* vik_track_get_tp_by_min_alt ( const VikTrack *tr ) +{ + gdouble minalt = 25000.0; + if ( !tr->trackpoints ) + return NULL; + + GList *iter = tr->trackpoints; + VikTrackpoint *min_alt_tp = NULL; + + while (iter) { + if ( VIK_TRACKPOINT(iter->data)->altitude < minalt ) { + minalt = VIK_TRACKPOINT(iter->data)->altitude; + min_alt_tp = VIK_TRACKPOINT(iter->data); + } + iter = iter->next; + } + + if (!min_alt_tp) + return NULL; + + return min_alt_tp; +} + gboolean vik_track_get_minmax_alt ( const VikTrack *tr, gdouble *min_alt, gdouble *max_alt ) { *min_alt = 25000; @@ -833,6 +1067,20 @@ void vik_track_apply_dem_data ( VikTrack *tr ) } } +/* + * Apply DEM data (if available) - to only the last trackpoint + */ +void vik_track_apply_dem_data_last_trackpoint ( VikTrack *tr ) +{ + gint16 elev; + if ( tr->trackpoints ) { + /* As in vik_track_apply_dem_data above - use 'best' interpolation method */ + elev = a_dems_get_elev_by_coord ( &(VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->coord), VIK_DEM_INTERPOL_BEST ); + if ( elev != VIK_DEM_INVALID_ELEVATION ) + VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->altitude = elev; + } +} + /* appends t2 to t1, leaving t2 with no trackpoints */ void vik_track_steal_and_append_trackpoints ( VikTrack *t1, VikTrack *t2 ) { @@ -848,9 +1096,8 @@ void vik_track_steal_and_append_trackpoints ( VikTrack *t1, VikTrack *t2 ) } /* starting at the end, looks backwards for the last "double point", a duplicate trackpoint. - * this is indicative of magic scissors continued use. If there is no double point, - * deletes all the trackpoints. Returns the new end of the track (or the start if - * there are no double points + * If there is no double point, deletes all the trackpoints. + * Returns the new end of the track (or the start if there are no double points) */ VikCoord *vik_track_cut_back_to_double_point ( VikTrack *tr ) {