tr->description = NULL;
}
+void vik_track_set_source(VikTrack *tr, const gchar *source)
+{
+ if ( tr->source )
+ g_free ( tr->source );
+
+ if ( source && source[0] != '\0' )
+ tr->source = g_strdup(source);
+ else
+ tr->source = NULL;
+}
+
+void vik_track_set_type(VikTrack *tr, const gchar *type)
+{
+ if ( tr->type )
+ g_free ( tr->type );
+
+ if ( type && type[0] != '\0' )
+ tr->type = g_strdup(type);
+ else
+ tr->type = NULL;
+}
+
void vik_track_ref(VikTrack *tr)
{
tr->ref_count++;
g_free ( tr->comment );
if ( tr->description )
g_free ( tr->description );
+ if ( tr->source )
+ g_free ( tr->source );
+ if ( tr->type )
+ g_free ( tr->type );
g_list_foreach ( tr->trackpoints, (GFunc) vik_trackpoint_free, NULL );
g_list_free( tr->trackpoints );
if (tr->property_dialog)
vik_track_set_name(new_tr,tr->name);
vik_track_set_comment(new_tr,tr->comment);
vik_track_set_description(new_tr,tr->description);
+ vik_track_set_source(new_tr,tr->source);
return new_tr;
}
*/
void vik_track_add_trackpoint ( VikTrack *tr, VikTrackpoint *tp, gboolean recalculate )
{
+ // When it's the first trackpoint need to ensure the bounding box is initialized correctly
+ gboolean adding_first_point = tr->trackpoints ? FALSE : TRUE;
tr->trackpoints = g_list_append ( tr->trackpoints, tp );
- if ( recalculate )
+ if ( adding_first_point )
+ vik_track_calculate_bounds ( tr );
+ else if ( recalculate )
track_recalculate_bounds_last_tp ( tr );
}
}
}
+/**
+ * vik_track_get_duration:
+ * @trk: The track
+ * @segment_gaps: Whether the duration should include gaps between segments
+ *
+ * Returns: The time in seconds
+ * NB this may be negative particularly if the track has been reversed
+ */
+time_t vik_track_get_duration(const VikTrack *trk, gboolean segment_gaps)
+{
+ time_t duration = 0;
+ if ( trk->trackpoints ) {
+ // Ensure times are available
+ if ( vik_track_get_tp_first(trk)->has_timestamp ) {
+ // Get trkpt only once - as using vik_track_get_tp_last() iterates whole track each time
+ if (segment_gaps) {
+ // Simple duration
+ VikTrackpoint *trkpt_last = vik_track_get_tp_last(trk);
+ if ( trkpt_last->has_timestamp ) {
+ time_t t1 = vik_track_get_tp_first(trk)->timestamp;
+ time_t t2 = trkpt_last->timestamp;
+ duration = t2 - t1;
+ }
+ }
+ else {
+ // Total within segments
+ GList *iter = trk->trackpoints->next;
+ while (iter) {
+ if ( VIK_TRACKPOINT(iter->data)->has_timestamp &&
+ VIK_TRACKPOINT(iter->prev->data)->has_timestamp &&
+ (!VIK_TRACKPOINT(iter->data)->newsegment) ) {
+ duration += ABS(VIK_TRACKPOINT(iter->data)->timestamp - VIK_TRACKPOINT(iter->prev->data)->timestamp);
+ }
+ iter = iter->next;
+ }
+ }
+ }
+ }
+ return duration;
+}
+
gdouble vik_track_get_average_speed(const VikTrack *tr)
{
gdouble len = 0.0;
}
/* 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 ( iter->prev && fabs(current_dist-current_inc-dist) < fabs(current_dist-dist) ) {
if (meters_from_start)
*meters_from_start = last_dist;
iter = iter->prev;
VikTrackpoint *vik_track_get_closest_tp_by_percentage_time ( VikTrack *tr, gdouble reltime, time_t *seconds_from_start )
{
+ if ( !tr->trackpoints )
+ return NULL;
+
time_t t_pos, t_start, t_end, t_total;
t_start = VIK_TRACKPOINT(tr->trackpoints->data)->timestamp;
t_end = VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp;
t_pos = t_start + t_total * reltime;
- if ( !tr->trackpoints )
- return NULL;
-
GList *iter = tr->trackpoints;
while (iter) {
return (VikTrackpoint*)g_list_last(tr->trackpoints)->data;
}
+VikTrackpoint *vik_track_get_tp_prev ( const VikTrack *tr, VikTrackpoint *tp )
+{
+ if ( !tr->trackpoints )
+ return NULL;
+
+ GList *iter = tr->trackpoints;
+ VikTrackpoint *tp_prev = NULL;
+
+ while (iter) {
+ if (iter->prev) {
+ if ( VIK_TRACKPOINT(iter->data) == tp ) {
+ tp_prev = VIK_TRACKPOINT(iter->prev->data);
+ break;
+ }
+ }
+ iter = iter->next;
+ }
+
+ return tp_prev;
+}
+
gboolean vik_track_get_minmax_alt ( const VikTrack *tr, gdouble *min_alt, gdouble *max_alt )
{
*min_alt = 25000;
vtm_append(tr->name);
vtm_append(tr->comment);
vtm_append(tr->description);
+ vtm_append(tr->source);
*data = b->data;
*datalen = b->len;
vtu_get(new_tr->name);
vtu_get(new_tr->comment);
vtu_get(new_tr->description);
+ vtu_get(new_tr->source);
return new_tr;
}
void vik_track_anonymize_times ( VikTrack *tr )
{
GTimeVal gtv;
- g_time_val_from_iso8601 ( "1901-01-01T00:00:00Z", >v );
+ // Check result just to please Coverity - even though it shouldn't fail as it's a hard coded value here!
+ if ( !g_time_val_from_iso8601 ( "1901-01-01T00:00:00Z", >v ) ) {
+ g_critical ( "Calendar time value failure" );
+ return;
+ }
time_t anon_timestamp = gtv.tv_sec;
time_t offset = 0;
}
}
+/**
+ * vik_track_interpolate_times:
+ *
+ * Interpolate the timestamps between first and last trackpoint,
+ * so that the track is driven at equal speed, regardless of the
+ * distance between individual trackpoints.
+ *
+ * NB This will overwrite any existing trackpoint timestamps
+ */
+void vik_track_interpolate_times ( VikTrack *tr )
+{
+ gdouble tr_dist, cur_dist;
+ time_t tsdiff, tsfirst;
+
+ GList *iter;
+ iter = tr->trackpoints;
+
+ VikTrackpoint *tp = VIK_TRACKPOINT(iter->data);
+ if ( tp->has_timestamp ) {
+ tsfirst = tp->timestamp;
+
+ // Find the end of the track and the last timestamp
+ while ( iter->next ) {
+ iter = iter->next;
+ }
+ tp = VIK_TRACKPOINT(iter->data);
+ if ( tp->has_timestamp ) {
+ tsdiff = tp->timestamp - tsfirst;
+
+ tr_dist = vik_track_get_length_including_gaps ( tr );
+ cur_dist = 0.0;
+
+ if ( tr_dist > 0 ) {
+ iter = tr->trackpoints;
+ // Apply the calculated timestamp to all trackpoints except the first and last ones
+ while ( iter->next && iter->next->next ) {
+ iter = iter->next;
+ tp = VIK_TRACKPOINT(iter->data);
+ cur_dist += vik_coord_diff ( &(tp->coord), &(VIK_TRACKPOINT(iter->prev->data)->coord) );
+
+ tp->timestamp = (cur_dist / tr_dist) * tsdiff + tsfirst;
+ tp->has_timestamp = TRUE;
+ }
+ // Some points may now have the same time so remove them.
+ vik_track_remove_same_time_points ( tr );
+ }
+ }
+ }
+}
/**
* vik_track_apply_dem_data:
while ( iter->prev ) {
- if ( vik_coord_equals((VikCoord *)iter->data, (VikCoord *)iter->prev->data) ) {
+ VikCoord *cur_coord = &((VikTrackpoint*)iter->data)->coord;
+ VikCoord *prev_coord = &((VikTrackpoint*)iter->prev->data)->coord;
+ if ( vik_coord_equals(cur_coord, prev_coord) ) {
GList *prev = iter->prev;
rv = g_malloc(sizeof(VikCoord));
- *rv = *((VikCoord *) iter->data);
+ *rv = *cur_coord;
/* truncate trackpoint list */
iter->prev = NULL; /* pretend it's the end */
/* no double point found! */
rv = g_malloc(sizeof(VikCoord));
- *rv = *((VikCoord *) tr->trackpoints->data);
+ *rv = ((VikTrackpoint*) tr->trackpoints->data)->coord;
g_list_foreach ( tr->trackpoints, (GFunc) g_free, NULL );
g_list_free( tr->trackpoints );
tr->trackpoints = NULL;
projects / andy / viking.git / blobdiff