/** * Based on a simple average speed, but with a twist - to give a moving average. * . GPSs often report a moving average in their statistics output * . bicycle speedos often don't factor in time when stopped - hence reporting a moving average for speed * * Often GPS track will record every second but not when stationary * This method doesn't use samples that differ over the specified time limit - effectively skipping that time chunk from the total time * * Suggest to use 60 seconds as the stop length (as the default used in the TrackWaypoint draw stops factor) */ gdouble vik_track_get_average_speed_moving (const VikTrack *tr, int stop_length_seconds) { gdouble len = 0.0; guint32 time = 0; if ( tr->trackpoints ) { GList *iter = tr->trackpoints->next; while (iter) { if ( VIK_TRACKPOINT(iter->data)->has_timestamp && VIK_TRACKPOINT(iter->prev->data)->has_timestamp && (! VIK_TRACKPOINT(iter->data)->newsegment) ) { if ( ( VIK_TRACKPOINT(iter->data)->timestamp - VIK_TRACKPOINT(iter->prev->data)->timestamp ) < stop_length_seconds ) { len += vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord), &(VIK_TRACKPOINT(iter->prev->data)->coord) ); time += ABS(VIK_TRACKPOINT(iter->data)->timestamp - VIK_TRACKPOINT(iter->prev->data)->timestamp); } } iter = iter->next; } } return (time == 0) ? 0 : ABS(len/time); }
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; }
static void datasource_gc_draw_circle ( datasource_gc_widgets_t *widgets ) { gdouble lat, lon; if ( widgets->circle_onscreen ) { vik_viewport_draw_arc ( widgets->vvp, widgets->circle_gc, FALSE, widgets->circle_x - widgets->circle_width/2, widgets->circle_y - widgets->circle_width/2, widgets->circle_width, widgets->circle_width, 0, 360*64 ); } /* calculate widgets circle_x and circle_y */ /* split up lat,lon into lat and lon */ if ( 2 == sscanf ( gtk_entry_get_text ( GTK_ENTRY(widgets->center_entry) ), "%lf,%lf", &lat, &lon ) ) { struct LatLon ll; VikCoord c; gint x, y; ll.lat = lat; ll.lon = lon; vik_coord_load_from_latlon ( &c, vik_viewport_get_coord_mode ( widgets->vvp ), &ll ); vik_viewport_coord_to_screen ( widgets->vvp, &c, &x, &y ); /* TODO: real calculation */ if ( x > -1000 && y > -1000 && x < (vik_viewport_get_width(widgets->vvp) + 1000) && y < (vik_viewport_get_width(widgets->vvp) + 1000) ) { VikCoord c1, c2; gdouble pixels_per_meter; widgets->circle_x = x; widgets->circle_y = y; /* determine miles per pixel */ vik_viewport_screen_to_coord ( widgets->vvp, 0, vik_viewport_get_height(widgets->vvp)/2, &c1 ); vik_viewport_screen_to_coord ( widgets->vvp, vik_viewport_get_width(widgets->vvp), vik_viewport_get_height(widgets->vvp)/2, &c2 ); pixels_per_meter = ((gdouble)vik_viewport_get_width(widgets->vvp)) / vik_coord_diff(&c1, &c2); /* this is approximate */ widgets->circle_width = gtk_spin_button_get_value_as_float ( GTK_SPIN_BUTTON(widgets->miles_radius_spin) ) * METERSPERMILE * pixels_per_meter * 2; vik_viewport_draw_arc ( widgets->vvp, widgets->circle_gc, FALSE, widgets->circle_x - widgets->circle_width/2, widgets->circle_y - widgets->circle_width/2, widgets->circle_width, widgets->circle_width, 0, 360*64 ); widgets->circle_onscreen = TRUE; } else widgets->circle_onscreen = FALSE; } /* see if onscreen */ /* okay */ vik_viewport_sync ( widgets->vvp ); }
gdouble vik_track_get_length_including_gaps(const VikTrack *tr) { gdouble len = 0.0; if ( tr->trackpoints ) { GList *iter = tr->trackpoints->next; while (iter) { len += vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord), &(VIK_TRACKPOINT(iter->prev->data)->coord) ); iter = iter->next; } } return len; }
/* by Alex Foobarian */ VikTrackpoint *vik_track_get_closest_tp_by_percentage_dist ( VikTrack *tr, gdouble reldist, gdouble *meters_from_start ) { gdouble dist = vik_track_get_length_including_gaps(tr) * reldist; gdouble current_dist = 0.0; gdouble current_inc = 0.0; if ( tr->trackpoints ) { GList *iter = tr->trackpoints->next; GList *last_iter = NULL; gdouble last_dist = 0.0; while (iter) { current_inc = vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord), &(VIK_TRACKPOINT(iter->prev->data)->coord) ); last_dist = current_dist; current_dist += current_inc; if ( current_dist >= dist ) break; last_iter = iter; iter = iter->next; } if (!iter) { /* passing the end the track */ if (last_iter) { if (meters_from_start) *meters_from_start = last_dist; return(VIK_TRACKPOINT(last_iter->data)); } else return NULL; } /* we've gone past the dist already, was prev trackpoint closer? */ /* should do a vik_coord_average_weighted() thingy. */ if ( iter->prev && abs(current_dist-current_inc-dist) < abs(current_dist-dist) ) { if (meters_from_start) *meters_from_start = last_dist; iter = iter->prev; } else if (meters_from_start) *meters_from_start = current_dist; return VIK_TRACKPOINT(iter->data); } return NULL; }
static void tpwin_sync_ll_to_tp ( VikTrwLayerTpwin *tpwin ) { if ( tpwin->cur_tp && (!tpwin->sync_to_tp_block) ) { struct LatLon ll; VikCoord coord; ll.lat = gtk_spin_button_get_value ( tpwin->lat ); ll.lon = gtk_spin_button_get_value ( tpwin->lon ); vik_coord_load_from_latlon ( &coord, tpwin->cur_tp->coord.mode, &ll ); /* don't redraw unless we really have to */ if ( vik_coord_diff(&(tpwin->cur_tp->coord), &coord) > 0.05 ) /* may not be exact due to rounding */ { tpwin->cur_tp->coord = coord; gtk_dialog_response ( GTK_DIALOG(tpwin), VIK_TRW_LAYER_TPWIN_DATA_CHANGED ); } } }
gdouble vik_track_get_max_speed(const VikTrack *tr) { gdouble maxspeed = 0.0, speed = 0.0; if ( tr->trackpoints ) { GList *iter = tr->trackpoints->next; while (iter) { 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; } iter = iter->next; } } return maxspeed; }
/** * vik_trw_layer_tpwin_set_tp: * @tpwin: The Trackpoint Edit Window * @tpl: The #Glist of trackpoints pointing at the current trackpoint * @track_name: The name of the track in which the trackpoint belongs * @is_route: Is the track of the trackpoint actually a route? * * Sets the Trackpoint Edit Window to the values of the current trackpoint given in @tpl. * */ void vik_trw_layer_tpwin_set_tp ( VikTrwLayerTpwin *tpwin, GList *tpl, const gchar *track_name, gboolean is_route ) { static char tmp_str[64]; static struct LatLon ll; VikTrackpoint *tp = VIK_TRACKPOINT(tpl->data); if ( tp->name ) gtk_entry_set_text ( GTK_ENTRY(tpwin->trkpt_name), tp->name ); else gtk_editable_delete_text ( GTK_EDITABLE(tpwin->trkpt_name), 0, -1 ); gtk_widget_set_sensitive ( tpwin->trkpt_name, TRUE ); /* Only can insert if not at the end (otherwise use extend track) */ gtk_widget_set_sensitive ( tpwin->button_insert, (gboolean) GPOINTER_TO_INT (tpl->next) ); gtk_widget_set_sensitive ( tpwin->button_delete, TRUE ); /* We can only split up a track if it's not an endpoint. Makes sense to me. */ gtk_widget_set_sensitive ( tpwin->button_split, tpl->next && tpl->prev ); gtk_widget_set_sensitive ( tpwin->button_forward, (gboolean) GPOINTER_TO_INT (tpl->next) ); gtk_widget_set_sensitive ( tpwin->button_back, (gboolean) GPOINTER_TO_INT (tpl->prev) ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->lat), TRUE ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->lon), TRUE ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->alt), TRUE ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->ts), tp->has_timestamp ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->time), tp->has_timestamp ); // Enable adding timestamps - but not on routepoints if ( !tp->has_timestamp && !is_route ) { gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->time), TRUE ); GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU ); gtk_button_set_image ( GTK_BUTTON(tpwin->time), img ); } else vik_trw_layer_tpwin_set_track_name ( tpwin, track_name ); tpwin->sync_to_tp_block = TRUE; /* don't update while setting data. */ vik_coord_to_latlon ( &(tp->coord), &ll ); gtk_spin_button_set_value ( tpwin->lat, ll.lat ); gtk_spin_button_set_value ( tpwin->lon, ll.lon ); vik_units_height_t height_units = a_vik_get_units_height (); switch (height_units) { case VIK_UNITS_HEIGHT_METRES: gtk_spin_button_set_value ( tpwin->alt, tp->altitude ); break; case VIK_UNITS_HEIGHT_FEET: gtk_spin_button_set_value ( tpwin->alt, VIK_METERS_TO_FEET(tp->altitude) ); break; default: gtk_spin_button_set_value ( tpwin->alt, tp->altitude ); g_critical("Houston, we've had a problem. height=%d", height_units); } tpwin_update_times ( tpwin, tp ); tpwin->sync_to_tp_block = FALSE; // don't update while setting data. vik_units_speed_t speed_units = a_vik_get_units_speed (); vik_units_distance_t dist_units = a_vik_get_units_distance (); if ( tpwin->cur_tp ) { switch (dist_units) { case VIK_UNITS_DISTANCE_KILOMETRES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f m", vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord))); break; case VIK_UNITS_DISTANCE_MILES: case VIK_UNITS_DISTANCE_NAUTICAL_MILES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f yards", vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord))*1.0936133); break; default: g_critical("Houston, we've had a problem. distance=%d", dist_units); } gtk_label_set_text ( tpwin->diff_dist, tmp_str ); if ( tp->has_timestamp && tpwin->cur_tp->has_timestamp ) { g_snprintf ( tmp_str, sizeof(tmp_str), "%ld s", tp->timestamp - tpwin->cur_tp->timestamp); gtk_label_set_text ( tpwin->diff_time, tmp_str ); if ( tp->timestamp == tpwin->cur_tp->timestamp ) gtk_label_set_text ( tpwin->diff_speed, "--" ); else { switch (speed_units) { case VIK_UNITS_SPEED_KILOMETRES_PER_HOUR: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f km/h", VIK_MPS_TO_KPH(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_MILES_PER_HOUR: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f mph", VIK_MPS_TO_MPH(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_METRES_PER_SECOND: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f m/s", vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / ABS(tp->timestamp - tpwin->cur_tp->timestamp) ); break; case VIK_UNITS_SPEED_KNOTS: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f knots", VIK_MPS_TO_KNOTS(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_SECONDS_PER_KM: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f s/km", VIK_MPS_TO_PACE_SPK(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_MINUTES_PER_KM: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f min/km", VIK_MPS_TO_PACE_MPK(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_SECONDS_PER_MILE: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f sec/mi", VIK_MPS_TO_PACE_SPM(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_MINUTES_PER_MILE: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f min/mi", VIK_MPS_TO_PACE_MPM(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; default: g_snprintf ( tmp_str, sizeof(tmp_str), "--" ); g_critical("Houston, we've had a problem. speed=%d", speed_units); } gtk_label_set_text ( tpwin->diff_speed, tmp_str ); } } else { gtk_label_set_text ( tpwin->diff_time, NULL ); gtk_label_set_text ( tpwin->diff_speed, NULL ); } } if ( isnan(tp->course) ) g_snprintf ( tmp_str, sizeof(tmp_str), "--" ); else g_snprintf ( tmp_str, sizeof(tmp_str), "%05.1f\302\260", tp->course ); gtk_label_set_text ( tpwin->course, tmp_str ); if ( isnan(tp->speed) ) g_snprintf ( tmp_str, sizeof(tmp_str), "--" ); else { switch (speed_units) { case VIK_UNITS_SPEED_MILES_PER_HOUR: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f mph", VIK_MPS_TO_MPH(tp->speed) ); break; case VIK_UNITS_SPEED_METRES_PER_SECOND: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f m/s", tp->speed ); break; case VIK_UNITS_SPEED_KNOTS: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f knots", VIK_MPS_TO_KNOTS(tp->speed) ); break; case VIK_UNITS_SPEED_SECONDS_PER_KM: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f s/km", VIK_MPS_TO_PACE_SPK(tp->speed) ); break; case VIK_UNITS_SPEED_MINUTES_PER_KM: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f min/km", VIK_MPS_TO_PACE_MPK(tp->speed) ); break; case VIK_UNITS_SPEED_SECONDS_PER_MILE: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f s/mi", VIK_MPS_TO_PACE_SPM(tp->speed) ); break; case VIK_UNITS_SPEED_MINUTES_PER_MILE: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f min/mi", VIK_MPS_TO_PACE_MPM(tp->speed) ); break; default: // VIK_UNITS_SPEED_KILOMETRES_PER_HOUR: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f km/h", VIK_MPS_TO_KPH(tp->speed) ); break; } } gtk_label_set_text ( tpwin->speed, tmp_str ); switch (dist_units) { case VIK_UNITS_DISTANCE_KILOMETRES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f m", tp->hdop ); gtk_label_set_text ( tpwin->hdop, tmp_str ); g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f m", tp->pdop ); gtk_label_set_text ( tpwin->pdop, tmp_str ); break; case VIK_UNITS_DISTANCE_NAUTICAL_MILES: case VIK_UNITS_DISTANCE_MILES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f yards", tp->hdop*1.0936133 ); gtk_label_set_text ( tpwin->hdop, tmp_str ); g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f yards", tp->pdop*1.0936133 ); gtk_label_set_text ( tpwin->pdop, tmp_str ); break; default: g_critical("Houston, we've had a problem. distance=%d", dist_units); } switch (height_units) { case VIK_UNITS_HEIGHT_METRES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f m", tp->vdop ); break; case VIK_UNITS_HEIGHT_FEET: g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f feet", VIK_METERS_TO_FEET(tp->vdop) ); break; default: g_snprintf ( tmp_str, sizeof(tmp_str), "--" ); g_critical("Houston, we've had a problem. height=%d", height_units); } gtk_label_set_text ( tpwin->vdop, tmp_str ); g_snprintf ( tmp_str, sizeof(tmp_str), "%d / %d", tp->nsats, tp->fix_mode ); gtk_label_set_text ( tpwin->sat, tmp_str ); tpwin->cur_tp = tp; }
/** * 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; }
/** * 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; } } g_free(s); g_free(t); return v; }
/** * 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; time_t t1, t2; int i, pt_count, numpts, index; GList *iter; 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; } pt_count = vik_track_get_tp_count(tr); v = g_malloc ( sizeof(gdouble) * num_chunks ); chunk_dur = duration / num_chunks; s = g_malloc(sizeof(double) * pt_count); t = g_malloc(sizeof(double) * pt_count); 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; } /* 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; }
/* I understood this when I wrote it ... maybe ... Basically it eats up the * proper amounts of length on the track and averages elevation over that. */ gdouble *vik_track_make_elevation_map ( const VikTrack *tr, guint16 num_chunks ) { gdouble *pts; gdouble total_length, chunk_length, current_dist, current_area_under_curve, current_seg_length, dist_along_seg = 0.0; gdouble altitude1, altitude2; guint16 current_chunk; gboolean ignore_it = FALSE; GList *iter = tr->trackpoints; if (!iter || !iter->next) /* zero- or one-point track */ return NULL; { /* 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; } iter = tr->trackpoints; g_assert ( num_chunks < 16000 ); pts = g_malloc ( sizeof(gdouble) * num_chunks ); total_length = vik_track_get_length_including_gaps ( tr ); 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) { g_free(pts); return NULL; } current_dist = 0.0; current_area_under_curve = 0; current_chunk = 0; current_seg_length = 0; current_seg_length = vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord), &(VIK_TRACKPOINT(iter->next->data)->coord) ); altitude1 = VIK_TRACKPOINT(iter->data)->altitude; altitude2 = VIK_TRACKPOINT(iter->next->data)->altitude; dist_along_seg = 0; while ( current_chunk < num_chunks ) { /* go along current seg */ if ( current_seg_length && (current_seg_length - dist_along_seg) > chunk_length ) { dist_along_seg += chunk_length; /* / * pt2 * * /x altitude = alt_at_pt_1 + alt_at_pt_2 / 2 = altitude1 + slope * dist_value_of_pt_inbetween_pt1_and_pt2 * /xx avg altitude = area under curve / chunk len *pt1 *xxx avg altitude = altitude1 + (altitude2-altitude1)/(current_seg_length)*(dist_along_seg + (chunk_len/2)) * / xxx * / xxx **/ if ( ignore_it ) // 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); current_chunk++; } else { /* finish current seg */ if ( current_seg_length ) { gdouble altitude_at_dist_along_seg = altitude1 + (altitude2-altitude1)/(current_seg_length)*dist_along_seg; current_dist = current_seg_length - dist_along_seg; current_area_under_curve = current_dist*(altitude_at_dist_along_seg + altitude2)*0.5; } else { current_dist = current_area_under_curve = 0; } /* should only happen if first current_seg_length == 0 */ /* get intervening segs */ iter = iter->next; while ( iter && iter->next ) { current_seg_length = vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord), &(VIK_TRACKPOINT(iter->next->data)->coord) ); altitude1 = VIK_TRACKPOINT(iter->data)->altitude; altitude2 = VIK_TRACKPOINT(iter->next->data)->altitude; ignore_it = VIK_TRACKPOINT(iter->next->data)->newsegment; if ( chunk_length - current_dist >= current_seg_length ) { current_dist += current_seg_length; current_area_under_curve += current_seg_length * (altitude1+altitude2) * 0.5; iter = iter->next; } else { break; } } /* final seg */ dist_along_seg = chunk_length - current_dist; if ( ignore_it || ( iter && !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); pts[current_chunk] = current_area_under_curve / chunk_length; } current_dist = 0; current_chunk++; } } return pts; }
void vik_viewport_draw_scale ( VikViewport *vvp ) { g_return_if_fail ( vvp != NULL ); if ( vvp->draw_scale ) { VikCoord left, right; gdouble unit, base, diff, old_unit, old_diff, ratio; gint odd, len, SCSIZE = 5, HEIGHT=10; PangoLayout *pl; gchar s[128]; vik_viewport_screen_to_coord ( vvp, 0, vvp->height, &left ); vik_viewport_screen_to_coord ( vvp, vvp->width/SCSIZE, vvp->height, &right ); vik_units_distance_t dist_units = a_vik_get_units_distance (); switch (dist_units) { case VIK_UNITS_DISTANCE_KILOMETRES: base = vik_coord_diff ( &left, &right ); // in meters break; case VIK_UNITS_DISTANCE_MILES: // in 0.1 miles (copes better when zoomed in as 1 mile can be too big) base = VIK_METERS_TO_MILES(vik_coord_diff ( &left, &right )) * 10.0; break; default: base = 1; // Keep the compiler happy g_critical("Houston, we've had a problem. distance=%d", dist_units); } ratio = (vvp->width/SCSIZE)/base; unit = 1; diff = fabs(base-unit); old_unit = unit; old_diff = diff; odd = 1; while (diff <= old_diff) { old_unit = unit; old_diff = diff; unit = unit * (odd%2 ? 5 : 2); diff = fabs(base-unit); odd++; } unit = old_unit; len = unit * ratio; /* white background */ vik_viewport_draw_line(vvp, vvp->scale_bg_gc, PAD, vvp->height-PAD, PAD + len, vvp->height-PAD); vik_viewport_draw_line(vvp, vvp->scale_bg_gc, PAD, vvp->height-PAD, PAD, vvp->height-PAD-HEIGHT); vik_viewport_draw_line(vvp, vvp->scale_bg_gc, PAD + len, vvp->height-PAD, PAD + len, vvp->height-PAD-HEIGHT); /* black scale */ vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD, vvp->height-PAD, PAD + len, vvp->height-PAD); vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD, vvp->height-PAD, PAD, vvp->height-PAD-HEIGHT); vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD + len, vvp->height-PAD, PAD + len, vvp->height-PAD-HEIGHT); if (odd%2) { int i; for (i=1; i<5; i++) { vik_viewport_draw_line(vvp, vvp->scale_bg_gc, PAD+i*len/5, vvp->height-PAD, PAD+i*len/5, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2))); vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD+i*len/5, vvp->height-PAD, PAD+i*len/5, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2))); } } else { int i; for (i=1; i<10; i++) { vik_viewport_draw_line(vvp, vvp->scale_bg_gc, PAD+i*len/10, vvp->height-PAD, PAD+i*len/10, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2))); vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD+i*len/10, vvp->height-PAD, PAD+i*len/10, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2))); } } pl = gtk_widget_create_pango_layout (GTK_WIDGET(&vvp->drawing_area), NULL); pango_layout_set_font_description (pl, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->font_desc); switch (dist_units) { case VIK_UNITS_DISTANCE_KILOMETRES: if (unit >= 1000) { sprintf(s, "%d km", (int)unit/1000); } else { sprintf(s, "%d m", (int)unit); } break; case VIK_UNITS_DISTANCE_MILES: // Handle units in 0.1 miles if (unit < 10.0) { sprintf(s, "%0.1f miles", unit/10.0); } else if ((int)unit == 10.0) { sprintf(s, "1 mile"); } else { sprintf(s, "%d miles", (int)(unit/10.0)); } break; default: g_critical("Houston, we've had a problem. distance=%d", dist_units); } pango_layout_set_text(pl, s, -1); vik_viewport_draw_layout(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD + len + PAD, vvp->height - PAD - 10, pl); g_object_unref(pl); pl = NULL; } }