src/viktrack.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include <glib.h>
  23 #include <time.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <math.h>
  28 #include "coords.h"
  29 #include "vikcoord.h"
  30 #include "viktrack.h"
  31 #include "globals.h"
  32
  33 VikTrack *vik_track_new()
  34 {
  35   VikTrack *tr = g_malloc0 ( sizeof ( VikTrack ) );
  36   tr->ref_count = 1;
  37   return tr;
  38 }
  39
  40 void vik_track_set_comment_no_copy(VikTrack *tr, gchar *comment)
  41 {
  42   if ( tr->comment )
  43     g_free ( tr->comment );
  44   tr->comment = comment;
  45 }
  46
  47
  48 void vik_track_set_comment(VikTrack *tr, const gchar *comment)
  49 {
  50   if ( tr->comment )
  51     g_free ( tr->comment );
  52
  53   if ( comment && comment[0] != '\0' )
  54     tr->comment = g_strdup(comment);
  55   else
  56     tr->comment = NULL;
  57 }
  58
  59 void vik_track_ref(VikTrack *tr)
  60 {
  61   tr->ref_count++;
  62 }
  63
  64 void vik_track_free(VikTrack *tr)
  65 {
  66   if ( tr->ref_count-- > 1 )
  67     return;
  68
  69   if ( tr->comment )
  70     g_free ( tr->comment );
  71   g_list_foreach ( tr->trackpoints, (GFunc) g_free, NULL );
  72   g_list_free( tr->trackpoints );
  73   g_free ( tr );
  74 }
  75
  76 VikTrack *vik_track_copy ( const VikTrack *tr )
  77 {
  78   VikTrack *new_tr = vik_track_new();
  79   VikTrackpoint *new_tp;
  80   GList *tp_iter = tr->trackpoints;
  81   new_tr->visible = tr->visible;
  82   new_tr->trackpoints = NULL;
  83   while ( tp_iter )
  84   {
  85     new_tp = g_malloc ( sizeof ( VikTrackpoint ) );
  86     *new_tp = *((VikTrackpoint *)(tp_iter->data));
  87     new_tr->trackpoints = g_list_append ( new_tr->trackpoints, new_tp );
  88     tp_iter = tp_iter->next;
  89   }
  90   vik_track_set_comment(new_tr,tr->comment);
  91   return new_tr;
  92 }
  93
  94 VikTrackpoint *vik_trackpoint_new()
  95 {
  96   return g_malloc0(sizeof(VikTrackpoint));
  97 }
  98
  99 void vik_trackpoint_free(VikTrackpoint *tp)
 100 {
 101   g_free(tp);
 102 }
 103
 104 VikTrackpoint *vik_trackpoint_copy(VikTrackpoint *tp)
 105 {
 106   VikTrackpoint *rv = vik_trackpoint_new();
 107   *rv = *tp;
 108   return rv;
 109 }
 110
 111 gdouble vik_track_get_length(const VikTrack *tr)
 112 {
 113   gdouble len = 0.0;
 114   if ( tr->trackpoints )
 115   {
 116     GList *iter = tr->trackpoints->next;
 117     while (iter)
 118     {
 119       if ( ! VIK_TRACKPOINT(iter->data)->newsegment )
 120         len += vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord),
 121                                 &(VIK_TRACKPOINT(iter->prev->data)->coord) );
 122       iter = iter->next;
 123     }
 124   }
 125   return len;
 126 }
 127
 128 gdouble vik_track_get_length_including_gaps(const VikTrack *tr)
 129 {
 130   gdouble len = 0.0;
 131   if ( tr->trackpoints )
 132   {
 133     GList *iter = tr->trackpoints->next;
 134     while (iter)
 135     {
 136       len += vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord),
 137                               &(VIK_TRACKPOINT(iter->prev->data)->coord) );
 138       iter = iter->next;
 139     }
 140   }
 141   return len;
 142 }
 143
 144 gulong vik_track_get_tp_count(const VikTrack *tr)
 145 {
 146   gulong num = 0;
 147   GList *iter = tr->trackpoints;
 148   while ( iter )
 149   {
 150     num++;
 151     iter = iter->next;
 152   }
 153   return num;
 154 }
 155
 156 gulong vik_track_get_dup_point_count ( const VikTrack *tr )
 157 {
 158   gulong num = 0;
 159   GList *iter = tr->trackpoints;
 160   while ( iter )
 161   {
 162     if ( iter->next && vik_coord_equals ( &(VIK_TRACKPOINT(iter->data)->coord),
 163                        &(VIK_TRACKPOINT(iter->next->data)->coord) ) )
 164       num++;
 165     iter = iter->next;
 166   }
 167   return num;
 168 }
 169
 170 void vik_track_remove_dup_points ( VikTrack *tr )
 171 {
 172   GList *iter = tr->trackpoints;
 173   while ( iter )
 174   {
 175     if ( iter->next && vik_coord_equals ( &(VIK_TRACKPOINT(iter->data)->coord),
 176                        &(VIK_TRACKPOINT(iter->next->data)->coord) ) )
 177     {
 178       g_free ( iter->next->data );
 179       tr->trackpoints = g_list_delete_link ( tr->trackpoints, iter->next );
 180     }
 181     else
 182       iter = iter->next;
 183   }
 184 }
 185
 186 guint vik_track_get_segment_count(const VikTrack *tr)
 187 {
 188   guint num = 1;
 189   GList *iter = tr->trackpoints;
 190   if ( !iter )
 191     return 0;
 192   while ( (iter = iter->next) )
 193   {
 194     if ( VIK_TRACKPOINT(iter->data)->newsegment )
 195       num++;
 196   }
 197   return num;
 198 }
 199
 200 VikTrack **vik_track_split_into_segments(VikTrack *t, guint *ret_len)
 201 {
 202   VikTrack **rv;
 203   VikTrack *tr;
 204   guint i;
 205   guint segs = vik_track_get_segment_count(t);
 206   GList *iter;
 207
 208   if ( segs < 2 )
 209   {
 210     *ret_len = 0;
 211     return NULL;
 212   }
 213
 214   rv = g_malloc ( segs * sizeof(VikTrack *) );
 215   tr = vik_track_copy ( t );
 216   rv[0] = tr;
 217   iter = tr->trackpoints;
 218
 219   i = 1;
 220   while ( (iter = iter->next) )
 221   {
 222     if ( VIK_TRACKPOINT(iter->data)->newsegment )
 223     {
 224       iter->prev->next = NULL;
 225       iter->prev = NULL;
 226       rv[i] = vik_track_new();
 227       if ( tr->comment )
 228         vik_track_set_comment ( rv[i], tr->comment );
 229       rv[i]->visible = tr->visible;
 230       rv[i]->trackpoints = iter;
 231       i++;
 232     }
 233   }
 234   *ret_len = segs;
 235   return rv;
 236 }
 237
 238 void vik_track_reverse ( VikTrack *tr )
 239 {
 240   GList *iter;
 241   tr->trackpoints = g_list_reverse(tr->trackpoints);
 242
 243   /* fix 'newsegment' */
 244   iter = g_list_last ( tr->trackpoints );
 245   while ( iter )
 246   {
 247     if ( ! iter->next ) /* last segment, was first, cancel newsegment. */
 248       VIK_TRACKPOINT(iter->data)->newsegment = FALSE;
 249     if ( ! iter->prev ) /* first segment by convention has newsegment flag. */
 250       VIK_TRACKPOINT(iter->data)->newsegment = TRUE;
 251     else if ( VIK_TRACKPOINT(iter->data)->newsegment && iter->next )
 252     {
 253       VIK_TRACKPOINT(iter->next->data)->newsegment = TRUE;
 254       VIK_TRACKPOINT(iter->data)->newsegment = FALSE;
 255     }
 256     iter = iter->prev;
 257   }
 258 }
 259
 260 gdouble vik_track_get_average_speed(const VikTrack *tr)
 261 {
 262   gdouble len = 0.0;
 263   guint32 time = 0;
 264   if ( tr->trackpoints )
 265   {
 266     GList *iter = tr->trackpoints->next;
 267     while (iter)
 268     {
 269       if ( VIK_TRACKPOINT(iter->data)->has_timestamp &&
 270           VIK_TRACKPOINT(iter->prev->data)->has_timestamp &&
 271           (! VIK_TRACKPOINT(iter->data)->newsegment) )
 272       {
 273         len += vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord),
 274                                 &(VIK_TRACKPOINT(iter->prev->data)->coord) );
 275         time += ABS(VIK_TRACKPOINT(iter->data)->timestamp - VIK_TRACKPOINT(iter->prev->data)->timestamp);
 276       }
 277       iter = iter->next;
 278     }
 279   }
 280   return (time == 0) ? 0 : ABS(len/time);
 281 }
 282
 283 gdouble vik_track_get_max_speed(const VikTrack *tr)
 284 {
 285   gdouble maxspeed = 0.0, speed = 0.0;
 286   if ( tr->trackpoints )
 287   {
 288     GList *iter = tr->trackpoints->next;
 289     while (iter)
 290     {
 291       if ( VIK_TRACKPOINT(iter->data)->has_timestamp &&
 292           VIK_TRACKPOINT(iter->prev->data)->has_timestamp &&
 293           (! VIK_TRACKPOINT(iter->data)->newsegment) )
 294       {
 295         speed =  vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord), &(VIK_TRACKPOINT(iter->prev->data)->coord) )
 296                  / ABS(VIK_TRACKPOINT(iter->data)->timestamp - VIK_TRACKPOINT(iter->prev->data)->timestamp);
 297         if ( speed > maxspeed )
 298           maxspeed = speed;
 299       }
 300       iter = iter->next;
 301     }
 302   }
 303   return maxspeed;
 304 }
 305
 306 void vik_track_convert ( VikTrack *tr, VikCoordMode dest_mode )
 307 {
 308   GList *iter = tr->trackpoints;
 309   while (iter)
 310   {
 311     vik_coord_convert ( &(VIK_TRACKPOINT(iter->data)->coord), dest_mode );
 312     iter = iter->next;
 313   }
 314 }
 315
 316 /* I understood this when I wrote it ... maybe ... Basically it eats up the
 317  * proper amounts of length on the track and averages elevation over that. */
 318 gdouble *vik_track_make_elevation_map ( const VikTrack *tr, guint16 num_chunks )
 319 {
 320   gdouble *pts;
 321   gdouble total_length, chunk_length, current_dist, current_area_under_curve, current_seg_length, dist_along_seg = 0.0;
 322   gdouble altitude1, altitude2;
 323   guint16 current_chunk;
 324   gboolean ignore_it = FALSE;
 325
 326   GList *iter = tr->trackpoints;
 327
 328   { /* test if there's anything worth calculating */
 329     gboolean okay = FALSE;
 330     while ( iter )
 331     {
 332       if ( VIK_TRACKPOINT(iter->data)->altitude != VIK_DEFAULT_ALTITUDE ) {
 333         okay = TRUE; break;
 334       }
 335       iter = iter->next;
 336     }
 337     if ( ! okay )
 338       return NULL;
 339   }
 340
 341
 342
 343   g_assert ( num_chunks < 16000 );
 344
 345   pts = g_malloc ( sizeof(gdouble) * num_chunks );
 346
 347   total_length = vik_track_get_length_including_gaps ( tr );
 348   chunk_length = total_length / num_chunks;
 349
 350   current_dist = 0.0;
 351   current_area_under_curve = 0;
 352   current_chunk = 0;
 353   current_seg_length = 0;
 354
 355   current_seg_length = vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord),
 356       &(VIK_TRACKPOINT(iter->next->data)->coord) );
 357   altitude1 = VIK_TRACKPOINT(iter->data)->altitude;
 358   altitude2 = VIK_TRACKPOINT(iter->next->data)->altitude;
 359   dist_along_seg = 0;
 360
 361   while ( current_chunk < num_chunks ) {
 362
 363     /* go along current seg */
 364     if ( current_seg_length && (current_seg_length - dist_along_seg) > chunk_length ) {
 365       dist_along_seg += chunk_length;
 366
 367       /*        /
 368        *   pt2 *
 369        *      /x       altitude = alt_at_pt_1 + alt_at_pt_2 / 2 = altitude1 + slope * dist_value_of_pt_inbetween_pt1_and_pt2
 370        *     /xx   avg altitude = area under curve / chunk len
 371        *pt1 *xxx   avg altitude = altitude1 + (altitude2-altitude1)/(current_seg_length)*(dist_along_seg + (chunk_len/2))
 372        *   / xxx
 373        *  /  xxx
 374        **/
 375
 376       if ( ignore_it )
 377         pts[current_chunk] = VIK_DEFAULT_ALTITUDE;
 378       else
 379         pts[current_chunk] = altitude1 + (altitude2-altitude1)*((dist_along_seg - (chunk_length/2))/current_seg_length);
 380
 381       current_chunk++;
 382     } else {
 383       /* finish current seg */
 384       if ( current_seg_length ) {
 385         gdouble altitude_at_dist_along_seg = altitude1 + (altitude2-altitude1)/(current_seg_length)*dist_along_seg;
 386         current_dist = current_seg_length - dist_along_seg;
 387         current_area_under_curve = current_dist*(altitude_at_dist_along_seg + altitude2)*0.5;
 388       } else { current_dist = current_area_under_curve = 0; } /* should only happen if first current_seg_length == 0 */
 389
 390       /* get intervening segs */
 391       iter = iter->next;
 392       while ( iter && iter->next ) {
 393         current_seg_length = vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord),
 394             &(VIK_TRACKPOINT(iter->next->data)->coord) );
 395         altitude1 = VIK_TRACKPOINT(iter->data)->altitude;
 396         altitude2 = VIK_TRACKPOINT(iter->next->data)->altitude;
 397         ignore_it = VIK_TRACKPOINT(iter->next->data)->newsegment;
 398
 399         if ( chunk_length - current_dist >= current_seg_length ) {
 400           current_dist += current_seg_length;
 401           current_area_under_curve += current_seg_length * (altitude1+altitude2) * 0.5;
 402           iter = iter->next;
 403         } else {
 404           break;
 405         }
 406       }
 407
 408       /* final seg */
 409       dist_along_seg = chunk_length - current_dist;
 410       if ( ignore_it || !iter->next ) {
 411         pts[current_chunk] = current_area_under_curve / current_dist;
 412       }
 413       else {
 414         current_area_under_curve += dist_along_seg * (altitude1 + (altitude2 - altitude1)*dist_along_seg/current_seg_length);
 415         pts[current_chunk] = current_area_under_curve / chunk_length;
 416       }
 417
 418       current_dist = 0;
 419       current_chunk++;
 420     }
 421   }
 422
 423   return pts;
 424 }
 425
 426
 427 void vik_track_get_total_elevation_gain(const VikTrack *tr, gdouble *up, gdouble *down)
 428 {
 429   gdouble diff;
 430   *up = *down = 0;
 431   if ( tr->trackpoints && VIK_TRACKPOINT(tr->trackpoints->data)->altitude != VIK_DEFAULT_ALTITUDE )
 432   {
 433     GList *iter = tr->trackpoints->next;
 434     while (iter)
 435     {
 436       diff = VIK_TRACKPOINT(iter->data)->altitude - VIK_TRACKPOINT(iter->prev->data)->altitude;
 437       if ( diff > 0 )
 438         *up += diff;
 439       else
 440         *down -= diff;
 441       iter = iter->next;
 442     }
 443   } else
 444     *up = *down = VIK_DEFAULT_ALTITUDE;
 445 }
 446
 447 typedef struct {
 448   double a, b, c, d;
 449 } spline_coeff_t;
 450
 451 void compute_spline(int n, double *x, double *f, spline_coeff_t *p)
 452 {
 453   double *h, *alpha, *B, *m;
 454   int i;
 455   int orig_n = n;
 456   double new_x[3], new_f[3];
 457
 458   if (n==0) return;
 459   if (n==1) {
 460     new_x[0] = x[0];
 461     new_f[0] = f[0];
 462     new_x[1] = x[0]+0.00001;
 463     new_f[1] = f[0];
 464     x = new_x;
 465     f = new_f;
 466     n = 3;
 467   }
 468   if (n==2) {
 469     new_x[0] = x[0];
 470     new_f[0] = f[0];
 471     new_x[1] = x[1];
 472     new_f[1] = f[1];
 473     new_x[2] = x[1] + x[1]-x[0];
 474     new_f[2] = f[1] + f[1]-f[0];
 475     x = new_x;
 476     f = new_f;
 477     n = 3;
 478   }
 479
 480   /* we're solving a linear system of equations of the form Ax = B.
 481    * The matrix a is tridiagonal and consists of coefficients in
 482    * the h[] and alpha[] arrays.
 483    */
 484
 485   h = (double *)malloc(sizeof(double) * (n-1));
 486   for (i=0; i<n-1; i++) {
 487     h[i] = x[i+1]-x[i];
 488   }
 489
 490   alpha = (double *)malloc(sizeof(double) * (n-2));
 491   for (i=0; i<n-2; i++) {
 492     alpha[i] = 2 * (h[i] + h[i+1]);
 493   }
 494
 495   /* B[] is the vector on the right hand side of the equation */
 496   B = (double *)malloc(sizeof(double) * (n-2));
 497   for (i=0; i<n-2; i++) {
 498     B[i] = 6 * ((f[i+2] - f[i+1])/h[i+1] - (f[i+1] - f[i])/h[i]);
 499   }
 500
 501   /* Now solve the n-2 by n-2 system */
 502   m = (double *)malloc(sizeof(double) * (n-2));
 503   for (i=1; i<=n-3; i++) {
 504     /*
 505     d0 = alpha 0
 506     a0 = h1
 507     c0 = h1
 508
 509       di = di - (ai-1 / di-1) * ci-1
 510       bi = bi - (ai-1 / di-1) * bi-1
 511       ;
 512     */
 513     alpha[i] = alpha[i] - (h[i]/alpha[i-1]) * h[i];
 514     B[i] = B[i] - (h[i]/alpha[i-1]) * B[i-1];
 515   }
 516   /*  xn-3 = bn-3 / dn-3; */
 517   m[n-3] = B[n-3]/alpha[n-3];
 518   for (i=n-4; i>=0; i--) {
 519     m[i] = (B[i]-h[i+1]*m[i+1])/alpha[i];
 520   }
 521
 522   for (i=0; i<orig_n-1; i++) {
 523     double mi, mi1;
 524     mi = (i==(n-2)) ? 0 : m[i];
 525     mi1 = (i==0) ? 0 : m[i-1];
 526
 527     p[i].a = f[i+1];
 528     p[i].b = (f[i+1] - f[i]) / h[i]  +  h[i] * (2*mi + mi1) / 6;
 529     p[i].c = mi/2;
 530     p[i].d = (mi-mi1)/(6*h[i]);
 531   }
 532
 533   free(alpha);
 534   free(B);
 535   free(h);
 536   free(m);
 537 }
 538
 539 /* by Alex Foobarian */
 540 gdouble *vik_track_make_speed_map ( const VikTrack *tr, guint16 num_chunks )
 541 {
 542   gdouble *v, *s, *t;
 543   gdouble duration, chunk_dur, T, s_prev, s_now;
 544   time_t t1, t2;
 545   int i, pt_count, numpts, spline;
 546   GList *iter;
 547   spline_coeff_t *p;
 548   GList *mytr;
 549
 550   if ( ! tr->trackpoints )
 551     return NULL;
 552
 553   g_assert ( num_chunks < 16000 );
 554
 555   iter = tr->trackpoints;
 556   while (iter) {
 557
 558   }
 559
 560   t1 = VIK_TRACKPOINT(tr->trackpoints->data)->timestamp;
 561   t2 = VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp;
 562   duration = t2 - t1;
 563
 564   if ( !t1 || !t2 || !duration )
 565     return NULL;
 566
 567   if (duration < 0) {
 568     fprintf(stderr, "negative duration: unsorted trackpoint timestamps?\n");
 569     return NULL;
 570   }
 571   pt_count = vik_track_get_tp_count(tr);
 572
 573   v = g_malloc ( sizeof(gdouble) * num_chunks );
 574   chunk_dur = duration / num_chunks;
 575
 576   s = g_malloc(sizeof(double) * pt_count);
 577   t = g_malloc(sizeof(double) * pt_count);
 578   p = g_malloc(sizeof(spline_coeff_t) * (pt_count-1));
 579
 580   iter = tr->trackpoints->next;
 581   numpts = 0;
 582   s[0] = 0;
 583   t[0] = VIK_TRACKPOINT(iter->prev->data)->timestamp;
 584   numpts++;
 585   while (iter) {
 586     s[numpts] = s[numpts-1] + vik_coord_diff ( &(VIK_TRACKPOINT(iter->prev->data)->coord), &(VIK_TRACKPOINT(iter->data)->coord) );
 587     t[numpts] = VIK_TRACKPOINT(iter->data)->timestamp;
 588     numpts++;
 589     iter = iter->next;
 590   }
 591
 592   compute_spline(numpts, t, s, p);
 593
 594   /*
 595   printf("Got spline\n");
 596   for (i=0; i<numpts-1; i++) {
 597     printf("a = %15f  b = %15f  c = %15f  d = %15f\n", p[i].a, p[i].b, p[i].c, p[i].d);
 598   }
 599   */
 600
 601   /* the spline gives us distances at chunk_dur intervals. from these,
 602    * we obtain average speed in each interval.
 603    */
 604   spline = 0;
 605   T = t[spline];
 606   s_prev =
 607       p[spline].d * pow(T - t[spline+1], 3) +
 608       p[spline].c * pow(T - t[spline+1], 2) +
 609       p[spline].b * (T - t[spline+1]) +
 610       p[spline].a;
 611   for (i = 0; i < num_chunks; i++, T+=chunk_dur) {
 612     while (T > t[spline+1]) {
 613       spline++;
 614     }
 615     s_now =
 616       p[spline].d * pow(T - t[spline+1], 3) +
 617       p[spline].c * pow(T - t[spline+1], 2) +
 618       p[spline].b * (T - t[spline+1]) +
 619       p[spline].a;
 620     v[i] = (s_now - s_prev) / chunk_dur;
 621     s_prev = s_now;
 622     /*
 623      * old method of averages
 624     v[i] = (s[spline+1]-s[spline])/(t[spline+1]-t[spline]);
 625     */
 626   }
 627   g_free(s);
 628   g_free(t);
 629   g_free(p);
 630   return v;
 631 }
 632
 633 /* by Alex Foobarian */
 634 VikCoord *vik_track_get_closest_tp_by_percentage_dist ( VikTrack *tr, gdouble reldist )
 635 {
 636   gdouble dist = vik_track_get_length_including_gaps(tr) * reldist;
 637   gdouble current_dist = 0.0;
 638   gdouble current_inc = 0.0;
 639   VikCoord *rv;
 640   if ( tr->trackpoints )
 641   {
 642     GList *iter = tr->trackpoints->next;
 643     while (iter)
 644     {
 645       current_inc = vik_coord_diff ( &(VIK_TRACKPOINT(iter->data)->coord),
 646                                      &(VIK_TRACKPOINT(iter->prev->data)->coord) );
 647       current_dist += current_inc;
 648       if ( current_dist >= dist )
 649         break;
 650       iter = iter->next;
 651     }
 652     /* we've gone past the dist already, was prev trackpoint closer? */
 653     /* should do a vik_coord_average_weighted() thingy. */
 654     if ( iter->prev && abs(current_dist-current_inc-dist) < abs(current_dist-dist) )
 655       iter = iter->prev;
 656
 657
 658
 659     rv = g_malloc(sizeof(VikCoord));
 660     *rv = VIK_TRACKPOINT(iter->data)->coord;
 661
 662     return rv;
 663
 664   }
 665   return NULL;
 666 }
 667
 668 gboolean vik_track_get_minmax_alt ( const VikTrack *tr, gdouble *min_alt, gdouble *max_alt )
 669 {
 670   *min_alt = 25000;
 671   *max_alt = -5000;
 672   if ( tr && tr->trackpoints && tr->trackpoints->data && (VIK_TRACKPOINT(tr->trackpoints->data)->altitude != VIK_DEFAULT_ALTITUDE) ) {
 673     GList *iter = tr->trackpoints->next;
 674     gdouble tmp_alt;
 675     while (iter)
 676     {
 677       tmp_alt = VIK_TRACKPOINT(iter->data)->altitude;
 678       if ( tmp_alt > *max_alt )
 679         *max_alt = tmp_alt;
 680       if ( tmp_alt < *min_alt )
 681         *min_alt = tmp_alt;
 682       iter = iter->next;
 683     }
 684     return TRUE;
 685   }
 686   return FALSE;
 687 }
 688
 689 void vik_track_marshall ( VikTrack *tr, guint8 **data, guint *datalen)
 690 {
 691   GList *tps;
 692   GByteArray *b = g_byte_array_new();
 693   guint len;
 694   guint intp, ntp;
 695
 696   g_byte_array_append(b, (guint8 *)tr, sizeof(*tr));
 697
 698   /* we'll fill out number of trackpoints later */
 699   intp = b->len;
 700   g_byte_array_append(b, (guint8 *)&len, sizeof(len));
 701
 702   tps = tr->trackpoints;
 703   ntp = 0;
 704   while (tps) {
 705     g_byte_array_append(b, (guint8 *)tps->data, sizeof(VikTrackpoint));
 706     tps = tps->next;
 707     ntp++;
 708   }
 709   *(guint *)(b->data + intp) = ntp;
 710
 711   len = (tr->comment) ? strlen(tr->comment)+1 : 0;
 712   g_byte_array_append(b, (guint8 *)&len, sizeof(len));
 713   if (tr->comment) g_byte_array_append(b, (guint8 *)tr->comment, len);
 714
 715   *data = b->data;
 716   *datalen = b->len;
 717   g_byte_array_free(b, FALSE);
 718 }
 719
 720 VikTrack *vik_track_unmarshall (guint8 *data, guint datalen)
 721 {
 722   guint len;
 723   VikTrack *new_tr = vik_track_new();
 724   VikTrackpoint *new_tp;
 725   guint ntp;
 726   gint i;
 727
 728   /* only the visibility is needed */
 729   new_tr->visible = ((VikTrack *)data)->visible;
 730   data += sizeof(*new_tr);
 731
 732   ntp = *(guint *)data;
 733   data += sizeof(ntp);
 734
 735   for (i=0; i<ntp; i++) {
 736     new_tp = vik_trackpoint_new();
 737     memcpy(new_tp, data, sizeof(*new_tp));
 738     data += sizeof(*new_tp);
 739     new_tr->trackpoints = g_list_append(new_tr->trackpoints, new_tp);
 740   }
 741
 742   len = *(guint *)data;
 743   data += sizeof(len);
 744   if (len) {
 745     new_tr->comment = g_strdup((gchar *)data);
 746   }
 747   return new_tr;
 748 }
 749