src/vikdemlayer.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 #include <math.h>
  22
  23 #include "globals.h"
  24 #include "coords.h"
  25 #include "vikcoord.h"
  26 #include "download.h"
  27 #include "vikwaypoint.h"
  28 #include "viktrack.h"
  29 #include "vikviewport.h"
  30 #include "viktreeview.h"
  31 #include "viklayer.h"
  32 #include "vikaggregatelayer.h"
  33 #include "viklayerspanel.h"
  34 #include "vikdemlayer.h"
  35 #include "vikdemlayer_pixmap.h"
  36
  37 #include "dem.h"
  38 #include "dems.h"
  39
  40 static VikDEMLayer *dem_layer_copy ( VikDEMLayer *vdl, gpointer vp );
  41 static void dem_layer_marshall( VikDEMLayer *vdl, guint8 **data, gint *len );
  42 static VikDEMLayer *dem_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp );
  43 static gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp );
  44 static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id );
  45 static void dem_layer_update_gc ( VikDEMLayer *vdl, VikViewport *vp, const gchar *color );
  46 static void dem_layer_post_read ( VikDEMLayer *vdl, VikViewport *vp );
  47
  48 static VikLayerParamScale param_scales[] = {
  49   { 1, 10000, 10, 1 },
  50   { 1, 10, 1, 0 },
  51 };
  52
  53 static VikLayerParam dem_layer_params[] = {
  54   { "files", VIK_LAYER_PARAM_STRING_LIST, VIK_LAYER_GROUP_NONE, "DEM Files:", VIK_LAYER_WIDGET_FILELIST },
  55   { "color", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, "Color:", VIK_LAYER_WIDGET_ENTRY },
  56   { "max_elev", VIK_LAYER_PARAM_DOUBLE, VIK_LAYER_GROUP_NONE, "Max Elev:", VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 0 },
  57   { "line_thickness", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, "Line Thickness:", VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 1 },
  58 };
  59
  60 /*
  61 */
  62
  63
  64 static gchar *dem_colors[] = {
  65 "#0000FF",
  66 "#9b793c",
  67 "#9c7d40",
  68 "#9d8144",
  69 "#9e8549",
  70 "#9f894d",
  71 "#a08d51",
  72 "#a29156",
  73 "#a3955a",
  74 "#a4995e",
  75 "#a69d63",
  76 "#a89f65",
  77 "#aaa267",
  78 "#ada569",
  79 "#afa76b",
  80 "#b1aa6d",
  81 "#b4ad6f",
  82 "#b6b071",
  83 "#b9b373",
  84 "#bcb676",
  85 "#beb978",
  86 "#c0bc7a",
  87 "#c2c07d",
  88 "#c4c37f",
  89 "#c6c681",
  90 "#c8ca84",
  91 "#cacd86",
  92 "#ccd188",
  93 "#cfd58b",
  94 "#c2ce84",
  95 "#b5c87e",
  96 "#a9c278",
  97 "#9cbb71",
  98 "#8fb56b",
  99 "#83af65",
 100 "#76a95e",
 101 "#6aa358",
 102 "#5e9d52",
 103 "#63a055",
 104 "#69a458",
 105 "#6fa85c",
 106 "#74ac5f",
 107 "#7ab063",
 108 "#80b467",
 109 "#86b86a",
 110 "#8cbc6e",
 111 "#92c072",
 112 "#94c175",
 113 "#97c278",
 114 "#9ac47c",
 115 "#9cc57f",
 116 "#9fc682",
 117 "#a2c886",
 118 "#a4c989",
 119 "#a7cb8d",
 120 "#aacd91",
 121 "#afce99",
 122 "#b5d0a1",
 123 "#bbd2aa",
 124 "#c0d3b2",
 125 "#c6d5ba",
 126 "#ccd7c3",
 127 "#d1d9cb",
 128 "#d7dbd4",
 129 "#DDDDDD",
 130 "#e0e0e0",
 131 "#e4e4e4",
 132 "#e8e8e8",
 133 "#ebebeb",
 134 "#efefef",
 135 "#f3f3f3",
 136 "#f7f7f7",
 137 "#fbfbfb",
 138 "#ffffff"
 139 };
 140
 141 /*
 142 "#9b793c",
 143 "#9e8549",
 144 "#a29156",
 145 "#a69d63",
 146 "#ada569",
 147 "#b4ad6f",
 148 "#bcb676",
 149 "#c2c07d",
 150 "#c8ca84",
 151 "#cfd58b",
 152 "#a9c278",
 153 "#83af65",
 154 "#5e9d52",
 155 "#6fa85c",
 156 "#80b467",
 157 "#92c072",
 158 "#9ac47c",
 159 "#a2c886",
 160 "#aacd91",
 161 "#bbd2aa",
 162 "#ccd7c3",
 163 "#DDDDDD",
 164 "#e8e8e8",
 165 "#f3f3f3",
 166 "#FFFFFF"
 167 };
 168 */
 169
 170 static const guint dem_n_colors = sizeof(dem_colors)/sizeof(dem_colors[0]);
 171
 172 enum { PARAM_FILES=0, PARAM_COLOR, PARAM_MAX_ELEV, PARAM_LINE_THICKNESS, NUM_PARAMS };
 173
 174 VikLayerInterface vik_dem_layer_interface = {
 175   "DEM",
 176   &demlayer_pixbuf,
 177
 178   NULL,
 179   0,
 180
 181   dem_layer_params,
 182   NUM_PARAMS,
 183   NULL,
 184   0,
 185
 186   VIK_MENU_ITEM_ALL,
 187
 188   (VikLayerFuncCreate)                  vik_dem_layer_create,
 189   (VikLayerFuncRealize)                 NULL,
 190   (VikLayerFuncPostRead)                dem_layer_post_read,
 191   (VikLayerFuncFree)                    vik_dem_layer_free,
 192
 193   (VikLayerFuncProperties)              NULL,
 194   (VikLayerFuncDraw)                    vik_dem_layer_draw,
 195   (VikLayerFuncChangeCoordMode)         NULL,
 196
 197   (VikLayerFuncSetMenuItemsSelection)   NULL,
 198   (VikLayerFuncGetMenuItemsSelection)   NULL,
 199
 200   (VikLayerFuncAddMenuItems)            NULL,
 201   (VikLayerFuncSublayerAddMenuItems)    NULL,
 202
 203   (VikLayerFuncSublayerRenameRequest)   NULL,
 204   (VikLayerFuncSublayerToggleVisible)   NULL,
 205
 206   (VikLayerFuncCopy)                    dem_layer_copy,
 207   (VikLayerFuncMarshall)                dem_layer_marshall,
 208   (VikLayerFuncUnmarshall)              dem_layer_unmarshall,
 209
 210   (VikLayerFuncSetParam)                dem_layer_set_param,
 211   (VikLayerFuncGetParam)                dem_layer_get_param,
 212
 213   (VikLayerFuncReadFileData)            NULL,
 214   (VikLayerFuncWriteFileData)           NULL,
 215
 216   (VikLayerFuncDeleteItem)              NULL,
 217   (VikLayerFuncCopyItem)                NULL,
 218   (VikLayerFuncPasteItem)               NULL,
 219   (VikLayerFuncFreeCopiedItem)          NULL,
 220   (VikLayerFuncDragDropRequest)         NULL,
 221 };
 222
 223 struct _VikDEMLayer {
 224   VikLayer vl;
 225   GdkGC *gc;
 226   GdkGC **gcs;
 227   GList *files;
 228   gdouble max_elev;
 229   guint8 line_thickness;
 230   gchar *color;
 231 };
 232
 233 GType vik_dem_layer_get_type ()
 234 {
 235   static GType vdl_type = 0;
 236
 237   if (!vdl_type)
 238   {
 239     static const GTypeInfo vdl_info =
 240     {
 241       sizeof (VikDEMLayerClass),
 242       NULL, /* base_init */
 243       NULL, /* base_finalize */
 244       NULL, /* class init */
 245       NULL, /* class_finalize */
 246       NULL, /* class_data */
 247       sizeof (VikDEMLayer),
 248       0,
 249       NULL /* instance init */
 250     };
 251     vdl_type = g_type_register_static ( VIK_LAYER_TYPE, "VikDEMLayer", &vdl_info, 0 );
 252   }
 253
 254   return vdl_type;
 255 }
 256
 257 static VikDEMLayer *dem_layer_copy ( VikDEMLayer *vdl, gpointer vp )
 258 {
 259   VikDEMLayer *rv = vik_dem_layer_new ( );
 260
 261
 262   /* TODO -- FIX for files */
 263
 264   rv->color = g_strdup ( vdl->color );
 265   rv->max_elev = vdl->max_elev;
 266   rv->line_thickness = vdl->line_thickness;
 267   rv->gc = vdl->gc;
 268   g_object_ref ( rv->gc );
 269   return rv;
 270 }
 271
 272 static void dem_layer_marshall( VikDEMLayer *vdl, guint8 **data, gint *len )
 273 {
 274   vik_layer_marshall_params ( VIK_LAYER(vdl), data, len );
 275 }
 276
 277 static VikDEMLayer *dem_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp )
 278 {
 279   VikDEMLayer *rv = vik_dem_layer_new ( vvp );
 280   vik_layer_unmarshall_params ( VIK_LAYER(rv), data, len, vvp );
 281   return rv;
 282 }
 283
 284 gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp )
 285 {
 286   switch ( id )
 287   {
 288     case PARAM_COLOR: if ( vdl->color ) g_free ( vdl->color ); vdl->color = g_strdup ( data.s ); break;
 289     case PARAM_MAX_ELEV: vdl->max_elev = data.d; break;
 290     case PARAM_LINE_THICKNESS: if ( data.u >= 1 && data.u <= 15 ) vdl->line_thickness = data.u; break;
 291     case PARAM_FILES: a_dems_load_list ( &(data.sl) ); a_dems_list_free ( vdl->files ); vdl->files = data.sl; break;
 292   }
 293   return TRUE;
 294 }
 295
 296 static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id )
 297 {
 298   VikLayerParamData rv;
 299   switch ( id )
 300   {
 301     case PARAM_FILES: rv.sl = vdl->files; break;
 302     case PARAM_COLOR: rv.s = vdl->color ? vdl->color : ""; break;
 303     case PARAM_MAX_ELEV: rv.d = vdl->max_elev; break;
 304     case PARAM_LINE_THICKNESS: rv.i = vdl->line_thickness; break;
 305   }
 306   return rv;
 307 }
 308
 309 static void dem_layer_post_read ( VikDEMLayer *vdl, VikViewport *vp )
 310 {
 311   if ( vdl->gc )
 312     g_object_unref ( G_OBJECT(vdl->gc) );
 313
 314   vdl->gc = vik_viewport_new_gc ( vp, vdl->color, vdl->line_thickness );
 315 }
 316
 317 VikDEMLayer *vik_dem_layer_new ( )
 318 {
 319   VikDEMLayer *vdl = VIK_DEM_LAYER ( g_object_new ( VIK_DEM_LAYER_TYPE, NULL ) );
 320   vik_layer_init ( VIK_LAYER(vdl), VIK_LAYER_DEM );
 321
 322   vdl->files = NULL;
 323
 324
 325   vdl->gc = NULL;
 326
 327   vdl->gcs = g_malloc(sizeof(GdkGC *)*dem_n_colors);
 328
 329   vdl->max_elev = 1000.0;
 330   vdl->line_thickness = 3;
 331   vdl->color = NULL;
 332   return vdl;
 333 }
 334
 335
 336 static void vik_dem_layer_draw_dem ( VikDEMLayer *vdl, VikViewport *vp, VikDEM *dem )
 337 {
 338   VikCoord tleft, tright, bleft, bright;
 339   VikDEMColumn *column;
 340
 341   struct LatLon dem_northeast, dem_southwest;
 342   gdouble max_lat, max_lon, min_lat, min_lon;
 343
 344
 345   /**** Check if viewport and DEM data overlap ****/
 346
 347   /* get min, max lat/lon of viewport */
 348   vik_viewport_screen_to_coord ( vp, 0, 0, &tleft );
 349   vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), 0, &tright );
 350   vik_viewport_screen_to_coord ( vp, 0, vik_viewport_get_height(vp), &bleft );
 351   vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), vik_viewport_get_height(vp), &bright );
 352
 353   vik_coord_convert(&tleft, VIK_COORD_LATLON);
 354   vik_coord_convert(&tright, VIK_COORD_LATLON);
 355   vik_coord_convert(&bleft, VIK_COORD_LATLON);
 356   vik_coord_convert(&bright, VIK_COORD_LATLON);
 357
 358   max_lat = MAX(tleft.north_south, tright.north_south);
 359   min_lat = MIN(bleft.north_south, bright.north_south);
 360   max_lon = MAX(tright.east_west, bright.east_west);
 361   min_lon = MIN(tleft.east_west, bleft.east_west);
 362
 363   /* get min, max lat/lon of DEM data */
 364   if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) {
 365     dem_northeast.lat = dem->max_north / 3600.0;
 366     dem_northeast.lon = dem->max_east / 3600.0;
 367     dem_southwest.lat = dem->min_north / 3600.0;
 368     dem_southwest.lon = dem->min_east / 3600.0;
 369   } else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) {
 370     struct UTM dem_northeast_utm, dem_southwest_utm;
 371     dem_northeast_utm.northing = dem->max_north;
 372     dem_northeast_utm.easting = dem->max_east;
 373     dem_southwest_utm.northing = dem->min_north;
 374     dem_southwest_utm.easting = dem->min_east;
 375     dem_northeast_utm.zone = dem_southwest_utm.zone = dem->utm_zone;
 376     dem_northeast_utm.letter = dem_southwest_utm.letter = dem->utm_letter;
 377
 378     a_coords_utm_to_latlon(&dem_northeast_utm, &dem_northeast);
 379     a_coords_utm_to_latlon(&dem_southwest_utm, &dem_southwest);
 380   }
 381
 382   if ( (max_lat > dem_northeast.lat && min_lat > dem_northeast.lat) ||
 383        (max_lat < dem_southwest.lat && min_lat < dem_southwest.lat) )
 384     return;
 385   else if ( (max_lon > dem_northeast.lon && min_lon > dem_northeast.lon) ||
 386             (max_lon < dem_southwest.lon && min_lon < dem_southwest.lon) )
 387     return;
 388   /* else they overlap */
 389
 390   /**** End Overlap Check ****/
 391
 392   if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) {
 393     VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
 394
 395     gdouble max_lat_as, max_lon_as, min_lat_as, min_lon_as;
 396     gdouble start_lat_as, end_lat_as, start_lon_as, end_lon_as;
 397
 398     gdouble start_lat, end_lat, start_lon, end_lon;
 399
 400     struct LatLon counter;
 401
 402     guint x, y, start_x, start_y;
 403
 404     gint16 elev;
 405
 406     guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 40 ); /* todo: smarter calculation. */
 407
 408     gdouble nscale_deg = dem->north_scale / ((gdouble) 3600);
 409     gdouble escale_deg = dem->east_scale / ((gdouble) 3600);
 410
 411     max_lat_as = max_lat * 3600;
 412     min_lat_as = min_lat * 3600;
 413     max_lon_as = max_lon * 3600;
 414     min_lon_as = min_lon * 3600;
 415
 416     start_lat_as = MAX(min_lat_as, dem->min_north);
 417     end_lat_as   = MIN(max_lat_as, dem->max_north);
 418     start_lon_as = MAX(min_lon_as, dem->min_east);
 419     end_lon_as   = MIN(max_lon_as, dem->max_east);
 420
 421     start_lat = floor(start_lat_as / dem->north_scale) * nscale_deg;
 422     end_lat   = ceil (end_lat_as / dem->north_scale) * nscale_deg;
 423     start_lon = floor(start_lon_as / dem->east_scale) * escale_deg;
 424     end_lon   = ceil (end_lon_as / dem->east_scale) * escale_deg;
 425
 426     vik_dem_east_north_to_xy ( dem, start_lon_as, start_lat_as, &start_x, &start_y );
 427
 428     for ( x=start_x, counter.lon = start_lon; counter.lon <= end_lon; counter.lon += escale_deg * skip_factor, x += skip_factor ) {
 429       if ( x > 0 && x < dem->n_columns ) {
 430         column = g_ptr_array_index ( dem->columns, x );
 431         for ( y=start_y, counter.lat = start_lat; counter.lat <= end_lat; counter.lat += nscale_deg * skip_factor, y += skip_factor ) {
 432           if ( y > column->n_points )
 433             break;
 434           elev = column->points[y];
 435           if ( elev > vdl->max_elev ) elev=vdl->max_elev;
 436           {
 437             gint a, b;
 438
 439             vik_coord_load_from_latlon(&tmp, vik_viewport_get_coord_mode(vp), &counter);
 440             vik_viewport_coord_to_screen(vp, &tmp, &a, &b);
 441             if ( elev == VIK_DEM_INVALID_ELEVATION )
 442               ; /* don't draw it */
 443             else if ( elev <= 0 )
 444               vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-2, b-2, 4, 4 );
 445             else
 446               vik_viewport_draw_rectangle(vp, vdl->gcs[(gint)floor(elev/vdl->max_elev*(dem_n_colors-2))+1], TRUE, a-2, b-2, 4, 4 );
 447           }
 448         } /* for y= */
 449       }
 450     } /* for x= */
 451   } else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) {
 452     gdouble max_nor, max_eas, min_nor, min_eas;
 453     gdouble start_nor, start_eas, end_nor, end_eas;
 454
 455     gint16 elev;
 456
 457     guint x, y, start_x, start_y;
 458
 459     VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
 460     struct UTM counter;
 461
 462     guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 10 ); /* todo: smarter calculation. */
 463
 464     vik_coord_convert(&tleft, VIK_COORD_UTM);
 465     vik_coord_convert(&tright, VIK_COORD_UTM);
 466     vik_coord_convert(&bleft, VIK_COORD_UTM);
 467     vik_coord_convert(&bright, VIK_COORD_UTM);
 468
 469     max_nor = MAX(tleft.north_south, tright.north_south);
 470     min_nor = MIN(bleft.north_south, bright.north_south);
 471     max_eas = MAX(bright.east_west, tright.east_west);
 472     min_eas = MIN(bleft.east_west, tleft.east_west);
 473
 474     start_nor = MAX(min_nor, dem->min_north);
 475     end_nor   = MIN(max_nor, dem->max_north);
 476     if ( tleft.utm_zone == dem->utm_zone && bleft.utm_zone == dem->utm_zone
 477          && (tleft.utm_letter >= 'N') == (dem->utm_letter >= 'N')
 478          && (bleft.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
 479       start_eas = MAX(min_eas, dem->min_east);
 480     else
 481       start_eas = dem->min_east;
 482     if ( tright.utm_zone == dem->utm_zone && bright.utm_zone == dem->utm_zone
 483          && (tright.utm_letter >= 'N') == (dem->utm_letter >= 'N')
 484          && (bright.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
 485       end_eas = MIN(max_eas, dem->max_east);
 486     else
 487       end_eas = dem->max_east;
 488
 489     start_nor = floor(start_nor / dem->north_scale) * dem->north_scale;
 490     end_nor   = ceil (end_nor / dem->north_scale) * dem->north_scale;
 491     start_eas = floor(start_eas / dem->east_scale) * dem->east_scale;
 492     end_eas   = ceil (end_eas / dem->east_scale) * dem->east_scale;
 493
 494     vik_dem_east_north_to_xy ( dem, start_eas, start_nor, &start_x, &start_y );
 495
 496     /* TODO: why start_x and start_y are -1 -- rounding error from above? */
 497
 498     counter.zone = dem->utm_zone;
 499     counter.letter = dem->utm_letter;
 500
 501     for ( x=start_x, counter.easting = start_eas; counter.easting <= end_eas; counter.easting += dem->east_scale * skip_factor, x += skip_factor ) {
 502       if ( x > 0 && x < dem->n_columns ) {
 503         column = g_ptr_array_index ( dem->columns, x );
 504         for ( y=start_y, counter.northing = start_nor; counter.northing <= end_nor; counter.northing += dem->north_scale * skip_factor, y += skip_factor ) {
 505           if ( y > column->n_points )
 506             continue;
 507           elev = column->points[y];
 508           if ( elev > vdl->max_elev ) elev=vdl->max_elev;
 509           {
 510             gint a, b;
 511             vik_coord_load_from_utm(&tmp, vik_viewport_get_coord_mode(vp), &counter);
 512                     vik_viewport_coord_to_screen(vp, &tmp, &a, &b);
 513             if ( elev == VIK_DEM_INVALID_ELEVATION )
 514               ; /* don't draw it */
 515             else if ( elev <= 0 )
 516               vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-2, b-2, 4, 4 );
 517             else
 518               vik_viewport_draw_rectangle(vp, vdl->gcs[(gint)floor(elev/vdl->max_elev*(dem_n_colors-2))+1], TRUE, a-2, b-2, 4, 4 );
 519           }
 520         } /* for y= */
 521       }
 522     } /* for x= */
 523   }
 524 }
 525
 526 void vik_dem_layer_draw ( VikDEMLayer *vdl, gpointer data )
 527 {
 528   VikViewport *vp = (VikViewport *) data;
 529   GList *dems_iter = vdl->files;
 530   VikDEM *dem;
 531   while ( dems_iter ) {
 532     dem = a_dems_get ( (const char *) (dems_iter->data) );
 533     if ( dem )
 534       vik_dem_layer_draw_dem ( vdl, vp, dem );
 535     dems_iter = dems_iter->next;
 536   }
 537 }
 538
 539 void vik_dem_layer_free ( VikDEMLayer *vdl )
 540 {
 541   if ( vdl->gc != NULL )
 542     g_object_unref ( G_OBJECT(vdl->gc) );
 543
 544   if ( vdl->color != NULL )
 545     g_free ( vdl->color );
 546
 547   a_dems_list_free ( vdl->files );
 548 }
 549
 550 static void dem_layer_update_gc ( VikDEMLayer *vdl, VikViewport *vp, const gchar *color )
 551 {
 552   guint i;
 553
 554   if ( vdl->color )
 555     g_free ( vdl->color );
 556
 557   vdl->color = g_strdup ( color );
 558
 559   if ( vdl->gc )
 560     g_object_unref ( G_OBJECT(vdl->gc) );
 561
 562   vdl->gc = vik_viewport_new_gc ( vp, vdl->color, vdl->line_thickness );
 563
 564   for ( i = 0 ; i < dem_n_colors; i++ )
 565     vdl->gcs[i] = vik_viewport_new_gc ( vp, dem_colors[i], vdl->line_thickness );
 566
 567 }
 568
 569 VikDEMLayer *vik_dem_layer_create ( VikViewport *vp )
 570 {
 571   VikDEMLayer *vdl = vik_dem_layer_new ();
 572   dem_layer_update_gc ( vdl, vp, "red" );
 573   return vdl;
 574 }
 575