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 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #include "config.h"
  28 #include "globals.h"
  29 #include "coords.h"
  30 #include "vikcoord.h"
  31 #include "download.h"
  32 #include "background.h"
  33 #include "vikwaypoint.h"
  34 #include "viktrack.h"
  35 #include "vikviewport.h"
  36 #include "viktreeview.h"
  37 #include "viklayer.h"
  38 #include "vikaggregatelayer.h"
  39 #include "viklayerspanel.h"
  40 #include "vikdemlayer.h"
  41 #include "vikdemlayer_pixmap.h"
  42 #include "vikmapslayer.h"
  43 #include "dialog.h"
  44
  45 #include "dem.h"
  46 #include "dems.h"
  47
  48 #define MAPS_CACHE_DIR maps_layer_default_dir()
  49
  50 #define SRTM_CACHE_TEMPLATE "%ssrtm3-%s%s%c%02d%c%03d.hgt.zip"
  51 #define SRTM_FTP_SITE "e0srp01u.ecs.nasa.gov"
  52 #define SRTM_FTP_URI  "/srtm/version2/SRTM3/"
  53
  54 #ifdef VIK_CONFIG_DEM24K
  55 #define DEM24K_DOWNLOAD_SCRIPT "dem24k.pl"
  56 #endif
  57
  58
  59 static void dem_layer_marshall( VikDEMLayer *vdl, guint8 **data, gint *len );
  60 static VikDEMLayer *dem_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp );
  61 static gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp );
  62 static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id );
  63 static void dem_layer_update_gc ( VikDEMLayer *vdl, VikViewport *vp, const gchar *color );
  64 static void dem_layer_post_read ( VikLayer *vl, VikViewport *vp, gboolean from_file );
  65 static void srtm_draw_existence ( VikViewport *vp );
  66
  67 #ifdef VIK_CONFIG_DEM24K
  68 static void dem24k_draw_existence ( VikViewport *vp );
  69 #endif
  70
  71 static VikLayerParamScale param_scales[] = {
  72   { 1, 10000, 10, 1 },
  73   { 1, 10000, 10, 1 },
  74   { 1, 10, 1, 0 },
  75 };
  76
  77 static gchar *params_source[] = {
  78         "SRTM Global 90m (3 arcsec)",
  79 #ifdef VIK_CONFIG_DEM24K
  80         "USA 10m (USGS 24k)",
  81 #endif
  82         "None",
  83         };
  84
  85 enum { DEM_SOURCE_SRTM,
  86 #ifdef VIK_CONFIG_DEM24K
  87        DEM_SOURCE_DEM24K,
  88 #endif
  89        DEM_SOURCE_NONE,
  90      };
  91
  92 static VikLayerParam dem_layer_params[] = {
  93   { "files", VIK_LAYER_PARAM_STRING_LIST, VIK_LAYER_GROUP_NONE, "DEM Files:", VIK_LAYER_WIDGET_FILELIST },
  94   { "source", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, "Download Source:", VIK_LAYER_WIDGET_RADIOGROUP_STATIC, params_source, NULL },
  95   { "color", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, "Color:", VIK_LAYER_WIDGET_ENTRY },
  96   { "min_elev", VIK_LAYER_PARAM_DOUBLE, VIK_LAYER_GROUP_NONE, "Min Elev:", VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 0 },
  97   { "max_elev", VIK_LAYER_PARAM_DOUBLE, VIK_LAYER_GROUP_NONE, "Max Elev:", VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 0 },
  98   { "line_thickness", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, "Line Thickness:", VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 1 },
  99 };
 100
 101
 102 enum { PARAM_FILES=0, PARAM_SOURCE, PARAM_COLOR, PARAM_MIN_ELEV, PARAM_MAX_ELEV, PARAM_LINE_THICKNESS, NUM_PARAMS };
 103
 104 static gpointer dem_layer_download_create ( VikWindow *vw, VikViewport *vvp);
 105 static gboolean dem_layer_download_release ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp );
 106 static gboolean dem_layer_download_click ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp );
 107
 108 static VikToolInterface dem_tools[] = {
 109   { "DEM Download/Import", (VikToolConstructorFunc) dem_layer_download_create, NULL, NULL, NULL,
 110     (VikToolMouseFunc) dem_layer_download_click, NULL,  (VikToolMouseFunc) dem_layer_download_release },
 111 };
 112
 113
 114 /*
 115 */
 116
 117 static gchar *dem_colors[] = {
 118 "#0000FF",
 119 "#9b793c",
 120 "#9c7d40",
 121 "#9d8144",
 122 "#9e8549",
 123 "#9f894d",
 124 "#a08d51",
 125 "#a29156",
 126 "#a3955a",
 127 "#a4995e",
 128 "#a69d63",
 129 "#a89f65",
 130 "#aaa267",
 131 "#ada569",
 132 "#afa76b",
 133 "#b1aa6d",
 134 "#b4ad6f",
 135 "#b6b071",
 136 "#b9b373",
 137 "#bcb676",
 138 "#beb978",
 139 "#c0bc7a",
 140 "#c2c07d",
 141 "#c4c37f",
 142 "#c6c681",
 143 "#c8ca84",
 144 "#cacd86",
 145 "#ccd188",
 146 "#cfd58b",
 147 "#c2ce84",
 148 "#b5c87e",
 149 "#a9c278",
 150 "#9cbb71",
 151 "#8fb56b",
 152 "#83af65",
 153 "#76a95e",
 154 "#6aa358",
 155 "#5e9d52",
 156 "#63a055",
 157 "#69a458",
 158 "#6fa85c",
 159 "#74ac5f",
 160 "#7ab063",
 161 "#80b467",
 162 "#86b86a",
 163 "#8cbc6e",
 164 "#92c072",
 165 "#94c175",
 166 "#97c278",
 167 "#9ac47c",
 168 "#9cc57f",
 169 "#9fc682",
 170 "#a2c886",
 171 "#a4c989",
 172 "#a7cb8d",
 173 "#aacd91",
 174 "#afce99",
 175 "#b5d0a1",
 176 "#bbd2aa",
 177 "#c0d3b2",
 178 "#c6d5ba",
 179 "#ccd7c3",
 180 "#d1d9cb",
 181 "#d7dbd4",
 182 "#DDDDDD",
 183 "#e0e0e0",
 184 "#e4e4e4",
 185 "#e8e8e8",
 186 "#ebebeb",
 187 "#efefef",
 188 "#f3f3f3",
 189 "#f7f7f7",
 190 "#fbfbfb",
 191 "#ffffff"
 192 };
 193
 194 /*
 195 "#9b793c",
 196 "#9e8549",
 197 "#a29156",
 198 "#a69d63",
 199 "#ada569",
 200 "#b4ad6f",
 201 "#bcb676",
 202 "#c2c07d",
 203 "#c8ca84",
 204 "#cfd58b",
 205 "#a9c278",
 206 "#83af65",
 207 "#5e9d52",
 208 "#6fa85c",
 209 "#80b467",
 210 "#92c072",
 211 "#9ac47c",
 212 "#a2c886",
 213 "#aacd91",
 214 "#bbd2aa",
 215 "#ccd7c3",
 216 "#DDDDDD",
 217 "#e8e8e8",
 218 "#f3f3f3",
 219 "#FFFFFF"
 220 };
 221 */
 222
 223 static const guint DEM_N_COLORS = sizeof(dem_colors)/sizeof(dem_colors[0]);
 224
 225
 226 VikLayerInterface vik_dem_layer_interface = {
 227   "DEM",
 228   &demlayer_pixbuf,
 229
 230   dem_tools,
 231   sizeof(dem_tools) / sizeof(dem_tools[0]),
 232
 233   dem_layer_params,
 234   NUM_PARAMS,
 235   NULL,
 236   0,
 237
 238   VIK_MENU_ITEM_ALL,
 239
 240   (VikLayerFuncCreate)                  vik_dem_layer_create,
 241   (VikLayerFuncRealize)                 NULL,
 242                                         dem_layer_post_read,
 243   (VikLayerFuncFree)                    vik_dem_layer_free,
 244
 245   (VikLayerFuncProperties)              NULL,
 246   (VikLayerFuncDraw)                    vik_dem_layer_draw,
 247   (VikLayerFuncChangeCoordMode)         NULL,
 248
 249   (VikLayerFuncSetMenuItemsSelection)   NULL,
 250   (VikLayerFuncGetMenuItemsSelection)   NULL,
 251
 252   (VikLayerFuncAddMenuItems)            NULL,
 253   (VikLayerFuncSublayerAddMenuItems)    NULL,
 254
 255   (VikLayerFuncSublayerRenameRequest)   NULL,
 256   (VikLayerFuncSublayerToggleVisible)   NULL,
 257
 258   (VikLayerFuncMarshall)                dem_layer_marshall,
 259   (VikLayerFuncUnmarshall)              dem_layer_unmarshall,
 260
 261   (VikLayerFuncSetParam)                dem_layer_set_param,
 262   (VikLayerFuncGetParam)                dem_layer_get_param,
 263
 264   (VikLayerFuncReadFileData)            NULL,
 265   (VikLayerFuncWriteFileData)           NULL,
 266
 267   (VikLayerFuncDeleteItem)              NULL,
 268   (VikLayerFuncCopyItem)                NULL,
 269   (VikLayerFuncPasteItem)               NULL,
 270   (VikLayerFuncFreeCopiedItem)          NULL,
 271   (VikLayerFuncDragDropRequest)         NULL,
 272 };
 273
 274 struct _VikDEMLayer {
 275   VikLayer vl;
 276   GdkGC *gc;
 277   GdkGC **gcs;
 278   GList *files;
 279   gdouble min_elev;
 280   gdouble max_elev;
 281   guint8 line_thickness;
 282   gchar *color;
 283   guint source;
 284 };
 285
 286 GType vik_dem_layer_get_type ()
 287 {
 288   static GType vdl_type = 0;
 289
 290   if (!vdl_type)
 291   {
 292     static const GTypeInfo vdl_info =
 293     {
 294       sizeof (VikDEMLayerClass),
 295       NULL, /* base_init */
 296       NULL, /* base_finalize */
 297       NULL, /* class init */
 298       NULL, /* class_finalize */
 299       NULL, /* class_data */
 300       sizeof (VikDEMLayer),
 301       0,
 302       NULL /* instance init */
 303     };
 304     vdl_type = g_type_register_static ( VIK_LAYER_TYPE, "VikDEMLayer", &vdl_info, 0 );
 305   }
 306
 307   return vdl_type;
 308 }
 309
 310 static void dem_layer_marshall( VikDEMLayer *vdl, guint8 **data, gint *len )
 311 {
 312   vik_layer_marshall_params ( VIK_LAYER(vdl), data, len );
 313 }
 314
 315 static VikDEMLayer *dem_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp )
 316 {
 317   VikDEMLayer *rv = vik_dem_layer_new ();
 318   gint i;
 319
 320   /* TODO: share GCS between layers */
 321   for ( i = 0; i < DEM_N_COLORS; i++ )
 322     rv->gcs[i] = vik_viewport_new_gc ( vvp, dem_colors[i], rv->line_thickness );
 323
 324   vik_layer_unmarshall_params ( VIK_LAYER(rv), data, len, vvp );
 325   return rv;
 326 }
 327
 328 gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp )
 329 {
 330   switch ( id )
 331   {
 332     case PARAM_COLOR: if ( vdl->color ) g_free ( vdl->color ); vdl->color = g_strdup ( data.s ); break;
 333     case PARAM_SOURCE: vdl->source = data.u; break;
 334     case PARAM_MIN_ELEV: vdl->min_elev = data.d; break;
 335     case PARAM_MAX_ELEV: vdl->max_elev = data.d; break;
 336     case PARAM_LINE_THICKNESS: if ( data.u >= 1 && data.u <= 15 ) vdl->line_thickness = data.u; break;
 337     case PARAM_FILES: a_dems_load_list ( &(data.sl) ); a_dems_list_free ( vdl->files ); vdl->files = data.sl; break;
 338   }
 339   return TRUE;
 340 }
 341
 342 static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id )
 343 {
 344   VikLayerParamData rv;
 345   switch ( id )
 346   {
 347     case PARAM_FILES: rv.sl = vdl->files; break;
 348     case PARAM_SOURCE: rv.u = vdl->source; break;
 349     case PARAM_COLOR: rv.s = vdl->color ? vdl->color : ""; break;
 350     case PARAM_MIN_ELEV: rv.d = vdl->min_elev; break;
 351     case PARAM_MAX_ELEV: rv.d = vdl->max_elev; break;
 352     case PARAM_LINE_THICKNESS: rv.i = vdl->line_thickness; break;
 353   }
 354   return rv;
 355 }
 356
 357 static void dem_layer_post_read ( VikLayer *vl, VikViewport *vp, gboolean from_file )
 358 {
 359   VikDEMLayer *vdl = VIK_DEM_LAYER(vl);
 360   if ( vdl->gc )
 361     g_object_unref ( G_OBJECT(vdl->gc) );
 362
 363   vdl->gc = vik_viewport_new_gc ( vp, vdl->color, vdl->line_thickness );
 364 }
 365
 366 VikDEMLayer *vik_dem_layer_new ( )
 367 {
 368   VikDEMLayer *vdl = VIK_DEM_LAYER ( g_object_new ( VIK_DEM_LAYER_TYPE, NULL ) );
 369
 370   vik_layer_init ( VIK_LAYER(vdl), VIK_LAYER_DEM );
 371
 372   vdl->files = NULL;
 373
 374
 375   vdl->gc = NULL;
 376
 377   vdl->gcs = g_malloc(sizeof(GdkGC *)*DEM_N_COLORS);
 378   /* make new gcs only if we need it (copy layer -> use old) */
 379
 380   vdl->min_elev = 0.0;
 381   vdl->max_elev = 1000.0;
 382   vdl->source = DEM_SOURCE_SRTM;
 383   vdl->line_thickness = 3;
 384   vdl->color = NULL;
 385   return vdl;
 386 }
 387
 388
 389
 390 static void vik_dem_layer_draw_dem ( VikDEMLayer *vdl, VikViewport *vp, VikDEM *dem )
 391 {
 392   VikDEMColumn *column;
 393
 394   struct LatLon dem_northeast, dem_southwest;
 395   gdouble max_lat, max_lon, min_lat, min_lon;
 396
 397   /**** Check if viewport and DEM data overlap ****/
 398
 399   /* get min, max lat/lon of viewport */
 400   vik_viewport_get_min_max_lat_lon ( vp, &min_lat, &max_lat, &min_lon, &max_lon );
 401
 402   /* get min, max lat/lon of DEM data */
 403   if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) {
 404     dem_northeast.lat = dem->max_north / 3600.0;
 405     dem_northeast.lon = dem->max_east / 3600.0;
 406     dem_southwest.lat = dem->min_north / 3600.0;
 407     dem_southwest.lon = dem->min_east / 3600.0;
 408   } else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) {
 409     struct UTM dem_northeast_utm, dem_southwest_utm;
 410     dem_northeast_utm.northing = dem->max_north;
 411     dem_northeast_utm.easting = dem->max_east;
 412     dem_southwest_utm.northing = dem->min_north;
 413     dem_southwest_utm.easting = dem->min_east;
 414     dem_northeast_utm.zone = dem_southwest_utm.zone = dem->utm_zone;
 415     dem_northeast_utm.letter = dem_southwest_utm.letter = dem->utm_letter;
 416
 417     a_coords_utm_to_latlon(&dem_northeast_utm, &dem_northeast);
 418     a_coords_utm_to_latlon(&dem_southwest_utm, &dem_southwest);
 419   }
 420
 421   if ( (max_lat > dem_northeast.lat && min_lat > dem_northeast.lat) ||
 422        (max_lat < dem_southwest.lat && min_lat < dem_southwest.lat) )
 423     return;
 424   else if ( (max_lon > dem_northeast.lon && min_lon > dem_northeast.lon) ||
 425             (max_lon < dem_southwest.lon && min_lon < dem_southwest.lon) )
 426     return;
 427   /* else they overlap */
 428
 429   /**** End Overlap Check ****/
 430   /* boxes to show where we have DEM instead of actually drawing the DEM.
 431    * useful if we want to see what areas we have coverage for (if we want
 432    * to get elevation data for a track) but don't want to cover the map.
 433    */
 434
 435   #if 0
 436   /* draw a box if a DEM is loaded. in future I'd like to add an option for this
 437    * this is useful if we want to see what areas we have dem for but don't want to
 438    * cover the map (or maybe we just need translucent DEM?) */
 439   {
 440     VikCoord demne, demsw;
 441     gint x1, y1, x2, y2;
 442     vik_coord_load_from_latlon(&demne, vik_viewport_get_coord_mode(vp), &dem_northeast);
 443     vik_coord_load_from_latlon(&demsw, vik_viewport_get_coord_mode(vp), &dem_southwest);
 444
 445     vik_viewport_coord_to_screen ( vp, &demne, &x1, &y1 );
 446     vik_viewport_coord_to_screen ( vp, &demsw, &x2, &y2 );
 447
 448     if ( x1 > vik_viewport_get_width(vp) ) x1=vik_viewport_get_width(vp);
 449     if ( y2 > vik_viewport_get_height(vp) ) y2=vik_viewport_get_height(vp);
 450     if ( x2 < 0 ) x2 = 0;
 451     if ( y1 < 0 ) y1 = 0;
 452     vik_viewport_draw_rectangle ( vp, GTK_WIDGET(vp)->style->black_gc,
 453         FALSE, x2, y1, x1-x2, y2-y1 );
 454     return;
 455   }
 456   #endif
 457
 458   if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) {
 459     VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
 460
 461     gdouble max_lat_as, max_lon_as, min_lat_as, min_lon_as;
 462     gdouble start_lat_as, end_lat_as, start_lon_as, end_lon_as;
 463
 464     gdouble start_lat, end_lat, start_lon, end_lon;
 465
 466     struct LatLon counter;
 467
 468     guint x, y, start_x, start_y;
 469
 470     gint16 elev;
 471
 472     guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 40 ); /* todo: smarter calculation. */
 473
 474     gdouble nscale_deg = dem->north_scale / ((gdouble) 3600);
 475     gdouble escale_deg = dem->east_scale / ((gdouble) 3600);
 476
 477     max_lat_as = max_lat * 3600;
 478     min_lat_as = min_lat * 3600;
 479     max_lon_as = max_lon * 3600;
 480     min_lon_as = min_lon * 3600;
 481
 482     start_lat_as = MAX(min_lat_as, dem->min_north);
 483     end_lat_as   = MIN(max_lat_as, dem->max_north);
 484     start_lon_as = MAX(min_lon_as, dem->min_east);
 485     end_lon_as   = MIN(max_lon_as, dem->max_east);
 486
 487     start_lat = floor(start_lat_as / dem->north_scale) * nscale_deg;
 488     end_lat   = ceil (end_lat_as / dem->north_scale) * nscale_deg;
 489     start_lon = floor(start_lon_as / dem->east_scale) * escale_deg;
 490     end_lon   = ceil (end_lon_as / dem->east_scale) * escale_deg;
 491
 492     vik_dem_east_north_to_xy ( dem, start_lon_as, start_lat_as, &start_x, &start_y );
 493
 494     /* verify sane elev interval */
 495     if ( vdl->max_elev <= vdl->min_elev )
 496       vdl->max_elev = vdl->min_elev + 1;
 497
 498     for ( x=start_x, counter.lon = start_lon; counter.lon <= end_lon; counter.lon += escale_deg * skip_factor, x += skip_factor ) {
 499       if ( x > 0 && x < dem->n_columns ) {
 500         column = g_ptr_array_index ( dem->columns, x );
 501         for ( y=start_y, counter.lat = start_lat; counter.lat <= end_lat; counter.lat += nscale_deg * skip_factor, y += skip_factor ) {
 502           if ( y > column->n_points )
 503             break;
 504           elev = column->points[y];
 505
 506           if ( elev != VIK_DEM_INVALID_ELEVATION && elev < vdl->min_elev )
 507             elev=vdl->min_elev;
 508           if ( elev != VIK_DEM_INVALID_ELEVATION && elev > vdl->max_elev )
 509             elev=vdl->max_elev;
 510
 511
 512           {
 513             gint a, b;
 514
 515             vik_coord_load_from_latlon(&tmp, vik_viewport_get_coord_mode(vp), &counter);
 516             vik_viewport_coord_to_screen(vp, &tmp, &a, &b);
 517             if ( elev == VIK_DEM_INVALID_ELEVATION )
 518               ; /* don't draw it */
 519             else if ( elev <= 0 )
 520               vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-2, b-2, 4, 4 );
 521             else
 522               vik_viewport_draw_rectangle(vp, vdl->gcs[(gint)floor((elev - vdl->min_elev)/(vdl->max_elev - vdl->min_elev)*(DEM_N_COLORS-2))+1], TRUE, a-2, b-2, 4, 4 );
 523           }
 524         } /* for y= */
 525       }
 526     } /* for x= */
 527   } else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) {
 528     gdouble max_nor, max_eas, min_nor, min_eas;
 529     gdouble start_nor, start_eas, end_nor, end_eas;
 530
 531     gint16 elev;
 532
 533     guint x, y, start_x, start_y;
 534
 535     VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
 536     struct UTM counter;
 537
 538     guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 10 ); /* todo: smarter calculation. */
 539
 540     VikCoord tleft, tright, bleft, bright;
 541
 542     vik_viewport_screen_to_coord ( vp, 0, 0, &tleft );
 543     vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), 0, &tright );
 544     vik_viewport_screen_to_coord ( vp, 0, vik_viewport_get_height(vp), &bleft );
 545     vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), vik_viewport_get_height(vp), &bright );
 546
 547
 548     vik_coord_convert(&tleft, VIK_COORD_UTM);
 549     vik_coord_convert(&tright, VIK_COORD_UTM);
 550     vik_coord_convert(&bleft, VIK_COORD_UTM);
 551     vik_coord_convert(&bright, VIK_COORD_UTM);
 552
 553     max_nor = MAX(tleft.north_south, tright.north_south);
 554     min_nor = MIN(bleft.north_south, bright.north_south);
 555     max_eas = MAX(bright.east_west, tright.east_west);
 556     min_eas = MIN(bleft.east_west, tleft.east_west);
 557
 558     start_nor = MAX(min_nor, dem->min_north);
 559     end_nor   = MIN(max_nor, dem->max_north);
 560     if ( tleft.utm_zone == dem->utm_zone && bleft.utm_zone == dem->utm_zone
 561          && (tleft.utm_letter >= 'N') == (dem->utm_letter >= 'N')
 562          && (bleft.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
 563       start_eas = MAX(min_eas, dem->min_east);
 564     else
 565       start_eas = dem->min_east;
 566     if ( tright.utm_zone == dem->utm_zone && bright.utm_zone == dem->utm_zone
 567          && (tright.utm_letter >= 'N') == (dem->utm_letter >= 'N')
 568          && (bright.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
 569       end_eas = MIN(max_eas, dem->max_east);
 570     else
 571       end_eas = dem->max_east;
 572
 573     start_nor = floor(start_nor / dem->north_scale) * dem->north_scale;
 574     end_nor   = ceil (end_nor / dem->north_scale) * dem->north_scale;
 575     start_eas = floor(start_eas / dem->east_scale) * dem->east_scale;
 576     end_eas   = ceil (end_eas / dem->east_scale) * dem->east_scale;
 577
 578     vik_dem_east_north_to_xy ( dem, start_eas, start_nor, &start_x, &start_y );
 579
 580     /* TODO: why start_x and start_y are -1 -- rounding error from above? */
 581
 582     counter.zone = dem->utm_zone;
 583     counter.letter = dem->utm_letter;
 584
 585     for ( x=start_x, counter.easting = start_eas; counter.easting <= end_eas; counter.easting += dem->east_scale * skip_factor, x += skip_factor ) {
 586       if ( x > 0 && x < dem->n_columns ) {
 587         column = g_ptr_array_index ( dem->columns, x );
 588         for ( y=start_y, counter.northing = start_nor; counter.northing <= end_nor; counter.northing += dem->north_scale * skip_factor, y += skip_factor ) {
 589           if ( y > column->n_points )
 590             continue;
 591           elev = column->points[y];
 592           if ( elev != VIK_DEM_INVALID_ELEVATION && elev < vdl->min_elev )
 593             elev=vdl->min_elev;
 594           if ( elev != VIK_DEM_INVALID_ELEVATION && elev > vdl->max_elev )
 595             elev=vdl->max_elev;
 596
 597           {
 598             gint a, b;
 599             vik_coord_load_from_utm(&tmp, vik_viewport_get_coord_mode(vp), &counter);
 600                     vik_viewport_coord_to_screen(vp, &tmp, &a, &b);
 601             if ( elev == VIK_DEM_INVALID_ELEVATION )
 602               ; /* don't draw it */
 603             else if ( elev <= 0 )
 604               vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-2, b-2, 4, 4 );
 605             else
 606               vik_viewport_draw_rectangle(vp, vdl->gcs[(gint)floor((elev - vdl->min_elev)/(vdl->max_elev - vdl->min_elev)*(DEM_N_COLORS-2))+1], TRUE, a-2, b-2, 4, 4 );
 607           }
 608         } /* for y= */
 609       }
 610     } /* for x= */
 611   }
 612 }
 613
 614 /* return the continent for the specified lat, lon */
 615 /* TODO */
 616 static const gchar *srtm_continent_dir ( gint lat, gint lon )
 617 {
 618   extern const char *_srtm_continent_data[];
 619   static GHashTable *srtm_continent = NULL;
 620   const gchar *continent;
 621   gchar name[16];
 622
 623   if (!srtm_continent) {
 624     const gchar **s;
 625
 626     srtm_continent = g_hash_table_new(g_str_hash, g_str_equal);
 627     s = _srtm_continent_data;
 628     while (*s != (gchar *)-1) {
 629       continent = *s++;
 630       while (*s) {
 631         g_hash_table_insert(srtm_continent, *s, continent);
 632         s++;
 633       }
 634       s++;
 635     }
 636   }
 637   g_snprintf(name, sizeof(name), "%c%02d%c%03d",
 638                   (lat >= 0) ? 'N' : 'S', ABS(lat),
 639                   (lon >= 0) ? 'E' : 'W', ABS(lon));
 640
 641   return(g_hash_table_lookup(srtm_continent, name));
 642 }
 643
 644 void vik_dem_layer_draw ( VikDEMLayer *vdl, gpointer data )
 645 {
 646   VikViewport *vp = (VikViewport *) data;
 647   GList *dems_iter = vdl->files;
 648   VikDEM *dem;
 649
 650
 651   /* search for SRTM3 90m */
 652
 653   if ( vdl->source == DEM_SOURCE_SRTM )
 654     srtm_draw_existence ( vp );
 655 #ifdef VIK_CONFIG_DEM24K
 656   else if ( vdl->source == DEM_SOURCE_DEM24K )
 657     dem24k_draw_existence ( vp );
 658 #endif
 659
 660   while ( dems_iter ) {
 661     dem = a_dems_get ( (const char *) (dems_iter->data) );
 662     if ( dem )
 663       vik_dem_layer_draw_dem ( vdl, vp, dem );
 664     dems_iter = dems_iter->next;
 665   }
 666 }
 667
 668 void vik_dem_layer_free ( VikDEMLayer *vdl )
 669 {
 670   gint i;
 671   if ( vdl->gc != NULL )
 672     g_object_unref ( G_OBJECT(vdl->gc) );
 673
 674   if ( vdl->color != NULL )
 675     g_free ( vdl->color );
 676
 677   if ( vdl->gcs )
 678     for ( i = 0; i < DEM_N_COLORS; i++ )
 679       g_object_unref ( vdl->gcs[i] );
 680   g_free ( vdl->gcs );
 681
 682   a_dems_list_free ( vdl->files );
 683 }
 684
 685 static void dem_layer_update_gc ( VikDEMLayer *vdl, VikViewport *vp, const gchar *color )
 686 {
 687   if ( vdl->color )
 688     g_free ( vdl->color );
 689
 690   vdl->color = g_strdup ( color );
 691
 692   if ( vdl->gc )
 693     g_object_unref ( G_OBJECT(vdl->gc) );
 694
 695   vdl->gc = vik_viewport_new_gc ( vp, vdl->color, vdl->line_thickness );
 696 }
 697
 698 VikDEMLayer *vik_dem_layer_create ( VikViewport *vp )
 699 {
 700   VikDEMLayer *vdl = vik_dem_layer_new ();
 701   gint i;
 702
 703   /* TODO: share GCS between layers */
 704   for ( i = 0; i < DEM_N_COLORS; i++ )
 705     vdl->gcs[i] = vik_viewport_new_gc ( vp, dem_colors[i], vdl->line_thickness );
 706
 707   dem_layer_update_gc ( vdl, vp, "red" );
 708   return vdl;
 709 }
 710 /**************************************************************
 711  **** SOURCES & DOWNLOADING
 712  **************************************************************/
 713 typedef struct {
 714   gchar *dest;
 715   gdouble lat, lon;
 716
 717   GMutex *mutex;
 718   VikDEMLayer *vdl; /* NULL if not alive */
 719
 720   guint source;
 721 } DEMDownloadParams;
 722
 723
 724 /**************************************************
 725  *  SOURCE: SRTM                                  *
 726  **************************************************/
 727
 728 static void srtm_dem_download_thread ( DEMDownloadParams *p, gpointer threaddata )
 729 {
 730   gint intlat, intlon;
 731   const gchar *continent_dir;
 732
 733   intlat = (int)floor(p->lat);
 734   intlon = (int)floor(p->lon);
 735   continent_dir = srtm_continent_dir(intlat, intlon);
 736
 737   if (!continent_dir) {
 738     g_warning("No SRTM data available for %f, %f\n", p->lat, p->lon);
 739     return;
 740   }
 741
 742   gchar *src_fn = g_strdup_printf("%s%s%s%c%02d%c%03d.hgt.zip",
 743                 SRTM_FTP_URI,
 744                 continent_dir,
 745                 G_DIR_SEPARATOR_S,
 746                 (intlat >= 0) ? 'N' : 'S',
 747                 ABS(intlat),
 748                 (intlon >= 0) ? 'E' : 'W',
 749                 ABS(intlon) );
 750
 751   DownloadOptions options = { NULL, 0 };
 752   a_ftp_download_get_url ( SRTM_FTP_SITE, src_fn, p->dest, &options );
 753   g_free ( src_fn );
 754 }
 755
 756 static gchar *srtm_lat_lon_to_dest_fn ( gdouble lat, gdouble lon )
 757 {
 758   gint intlat, intlon;
 759   const gchar *continent_dir;
 760
 761   intlat = (int)floor(lat);
 762   intlon = (int)floor(lon);
 763   continent_dir = srtm_continent_dir(intlat, intlon);
 764
 765   if (!continent_dir)
 766     continent_dir = "nowhere";
 767
 768   return g_strdup_printf("srtm3-%s%s%c%02d%c%03d.hgt.zip",
 769                 continent_dir,
 770                 G_DIR_SEPARATOR_S,
 771                 (intlat >= 0) ? 'N' : 'S',
 772                 ABS(intlat),
 773                 (intlon >= 0) ? 'E' : 'W',
 774                 ABS(intlon) );
 775
 776 }
 777
 778 /* TODO: generalize */
 779 static void srtm_draw_existence ( VikViewport *vp )
 780 {
 781   gdouble max_lat, max_lon, min_lat, min_lon;
 782   gchar buf[strlen(MAPS_CACHE_DIR)+strlen(SRTM_CACHE_TEMPLATE)+30];
 783   gint i, j;
 784
 785   vik_viewport_get_min_max_lat_lon ( vp, &min_lat, &max_lat, &min_lon, &max_lon );
 786
 787   for (i = floor(min_lat); i <= floor(max_lat); i++) {
 788     for (j = floor(min_lon); j <= floor(max_lon); j++) {
 789       const gchar *continent_dir;
 790       if ((continent_dir = srtm_continent_dir(i, j)) == NULL)
 791         continue;
 792       g_snprintf(buf, sizeof(buf), SRTM_CACHE_TEMPLATE,
 793                 MAPS_CACHE_DIR,
 794                 continent_dir,
 795                 G_DIR_SEPARATOR_S,
 796                 (i >= 0) ? 'N' : 'S',
 797                 ABS(i),
 798                 (j >= 0) ? 'E' : 'W',
 799                 ABS(j) );
 800       if ( access(buf, F_OK ) == 0 ) {
 801         VikCoord ne, sw;
 802         gint x1, y1, x2, y2;
 803         sw.north_south = i;
 804         sw.east_west = j;
 805         sw.mode = VIK_COORD_LATLON;
 806         ne.north_south = i+1;
 807         ne.east_west = j+1;
 808         ne.mode = VIK_COORD_LATLON;
 809         vik_viewport_coord_to_screen ( vp, &sw, &x1, &y1 );
 810         vik_viewport_coord_to_screen ( vp, &ne, &x2, &y2 );
 811         if ( x1 < 0 ) x1 = 0;
 812         if ( y2 < 0 ) y2 = 0;
 813         vik_viewport_draw_rectangle ( vp, GTK_WIDGET(vp)->style->black_gc,
 814                 FALSE, x1, y2, x2-x1, y1-y2 );
 815       }
 816     }
 817   }
 818 }
 819
 820
 821 /**************************************************
 822  *  SOURCE: USGS 24K                              *
 823  **************************************************/
 824
 825 #ifdef VIK_CONFIG_DEM24K
 826
 827 static void dem24k_dem_download_thread ( DEMDownloadParams *p, gpointer threaddata )
 828 {
 829   /* TODO: dest dir */
 830   gchar *cmdline = g_strdup_printf("%s %.03f %.03f",
 831         DEM24K_DOWNLOAD_SCRIPT,
 832         floor(p->lat*8)/8,
 833         ceil(p->lon*8)/8 );
 834   /* FIX: don't use system, use execv or something. check for existence */
 835   system(cmdline);
 836 }
 837
 838 static gchar *dem24k_lat_lon_to_dest_fn ( gdouble lat, gdouble lon )
 839 {
 840   return g_strdup_printf("dem24k/%d/%d/%.03f,%.03f.dem",
 841         (gint) lat,
 842         (gint) lon,
 843         floor(lat*8)/8,
 844         ceil(lon*8)/8);
 845 }
 846
 847 /* TODO: generalize */
 848 static void dem24k_draw_existence ( VikViewport *vp )
 849 {
 850   gdouble max_lat, max_lon, min_lat, min_lon;
 851   gchar buf[strlen(MAPS_CACHE_DIR)+40];
 852   gdouble i, j;
 853
 854   vik_viewport_get_min_max_lat_lon ( vp, &min_lat, &max_lat, &min_lon, &max_lon );
 855
 856   for (i = floor(min_lat*8)/8; i <= floor(max_lat*8)/8; i+=0.125) {
 857     /* check lat dir first -- faster */
 858     g_snprintf(buf, sizeof(buf), "%sdem24k/%d/",
 859         MAPS_CACHE_DIR,
 860         (gint) i );
 861     if ( access(buf, F_OK) != 0 )
 862       continue;
 863     for (j = floor(min_lon*8)/8; j <= floor(max_lon*8)/8; j+=0.125) {
 864       /* check lon dir first -- faster */
 865       g_snprintf(buf, sizeof(buf), "%sdem24k/%d/%d/",
 866         MAPS_CACHE_DIR,
 867         (gint) i,
 868         (gint) j );
 869       if ( access(buf, F_OK) != 0 )
 870         continue;
 871       g_snprintf(buf, sizeof(buf), "%sdem24k/%d/%d/%.03f,%.03f.dem",
 872                 MAPS_CACHE_DIR,
 873                 (gint) i,
 874                 (gint) j,
 875                 floor(i*8)/8,
 876                 floor(j*8)/8 );
 877       if ( access(buf, F_OK ) == 0 ) {
 878         VikCoord ne, sw;
 879         gint x1, y1, x2, y2;
 880         sw.north_south = i;
 881         sw.east_west = j-0.125;
 882         sw.mode = VIK_COORD_LATLON;
 883         ne.north_south = i+0.125;
 884         ne.east_west = j;
 885         ne.mode = VIK_COORD_LATLON;
 886         vik_viewport_coord_to_screen ( vp, &sw, &x1, &y1 );
 887         vik_viewport_coord_to_screen ( vp, &ne, &x2, &y2 );
 888         if ( x1 < 0 ) x1 = 0;
 889         if ( y2 < 0 ) y2 = 0;
 890         vik_viewport_draw_rectangle ( vp, GTK_WIDGET(vp)->style->black_gc,
 891                 FALSE, x1, y2, x2-x1, y1-y2 );
 892       }
 893     }
 894   }
 895 }
 896 #endif
 897
 898 /**************************************************
 899  *   SOURCES -- DOWNLOADING & IMPORTING TOOL      *
 900  **************************************************
 901  */
 902
 903 static void weak_ref_cb ( gpointer ptr, GObject * dead_vdl )
 904 {
 905   DEMDownloadParams *p = ptr;
 906   g_mutex_lock ( p->mutex );
 907   p->vdl = NULL;
 908   g_mutex_unlock ( p->mutex );
 909 }
 910
 911 /* Try to add file full_path.
 912  * full_path will be copied.
 913  * returns FALSE if file does not exists, TRUE otherwise.
 914  */
 915 static gboolean dem_layer_add_file ( VikDEMLayer *vdl, const gchar *full_path )
 916 {
 917   if ( access(full_path, F_OK ) == 0 ) {
 918     /* only load if file size is not 0 (not in progress */
 919     struct stat sb;
 920     stat (full_path, &sb);
 921     if ( sb.st_size ) {
 922       gchar *duped_path = g_strdup(full_path);
 923       vdl->files = g_list_prepend ( vdl->files, duped_path );
 924       a_dems_load ( duped_path );
 925       g_warning(duped_path);
 926       vik_layer_emit_update ( VIK_LAYER(vdl) );
 927     }
 928     return TRUE;
 929   } else
 930     return FALSE;
 931 }
 932
 933 static void dem_download_thread ( DEMDownloadParams *p, gpointer threaddata )
 934 {
 935   if ( p->source == DEM_SOURCE_SRTM )
 936     srtm_dem_download_thread ( p, threaddata );
 937 #ifdef VIK_CONFIG_DEM24K
 938   else if ( p->source == DEM_SOURCE_DEM24K )
 939     dem24k_dem_download_thread ( p, threaddata );
 940 #endif
 941
 942   gdk_threads_enter();
 943   g_mutex_lock ( p->mutex );
 944   if ( p->vdl ) {
 945     g_object_weak_unref ( G_OBJECT(p->vdl), weak_ref_cb, p );
 946
 947     if ( dem_layer_add_file ( p->vdl, p->dest ) )
 948       vik_layer_emit_update ( VIK_LAYER(p->vdl) );
 949   }
 950   g_mutex_unlock ( p->mutex );
 951   gdk_threads_leave();
 952 }
 953
 954
 955 static void free_dem_download_params ( DEMDownloadParams *p )
 956 {
 957   g_mutex_free ( p->mutex );
 958   g_free ( p->dest );
 959   g_free ( p );
 960 }
 961
 962 static gpointer dem_layer_download_create ( VikWindow *vw, VikViewport *vvp)
 963 {
 964   return vvp;
 965 }
 966
 967
 968 static gboolean dem_layer_download_release ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp )
 969 {
 970   VikCoord coord;
 971   struct LatLon ll;
 972
 973   gchar *full_path;
 974   gchar *dem_file = NULL;
 975
 976   if ( vdl->source == DEM_SOURCE_NONE )
 977     a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vdl), "No download source selected. Edit layer properties." );
 978
 979   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord );
 980   vik_coord_to_latlon ( &coord, &ll );
 981
 982
 983   if ( vdl->source == DEM_SOURCE_SRTM )
 984     dem_file = srtm_lat_lon_to_dest_fn ( ll.lat, ll.lon );
 985 #ifdef VIK_CONFIG_DEM24K
 986   else if ( vdl->source == DEM_SOURCE_DEM24K )
 987     dem_file = dem24k_lat_lon_to_dest_fn ( ll.lat, ll.lon );
 988 #endif
 989
 990   if ( ! dem_file )
 991     return TRUE;
 992
 993   full_path = g_strdup_printf("%s%s", MAPS_CACHE_DIR, dem_file );
 994
 995   g_warning(full_path);
 996
 997   // TODO: check if already in filelist
 998
 999   if ( ! dem_layer_add_file(vdl, full_path) ) {
1000     gchar *tmp = g_strdup_printf ( "Downloading DEM %s ", dem_file );
1001     DEMDownloadParams *p = g_malloc(sizeof(DEMDownloadParams));
1002     p->dest = g_strdup(full_path);
1003     p->lat = ll.lat;
1004     p->lon = ll.lon;
1005     p->vdl = vdl;
1006     p->mutex = g_mutex_new();
1007     p->source = vdl->source;
1008     g_object_weak_ref(G_OBJECT(p->vdl), weak_ref_cb, p );
1009
1010     a_background_thread ( VIK_GTK_WINDOW_FROM_LAYER(vdl), tmp,
1011                 (vik_thr_func) dem_download_thread, p,
1012                 (vik_thr_free_func) free_dem_download_params, NULL, 1 );
1013   }
1014
1015   g_free ( dem_file );
1016   g_free ( full_path );
1017
1018   return TRUE;
1019 }
1020
1021 static gboolean dem_layer_download_click ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp )
1022 {
1023 /* choose & keep track of cache dir
1024  * download in background thread
1025  * download over area */
1026   return TRUE;
1027 }
1028
1029