2 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
4 * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
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.
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.
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
22 #include <sys/types.h>
32 #include "background.h"
33 #include "vikwaypoint.h"
35 #include "vikviewport.h"
36 #include "viktreeview.h"
38 #include "vikaggregatelayer.h"
39 #include "viklayerspanel.h"
40 #include "vikdemlayer.h"
41 #include "vikdemlayer_pixmap.h"
42 #include "vikmapslayer.h"
48 #include "icons/icons.h"
50 #define MAPS_CACHE_DIR maps_layer_default_dir()
52 #define SRTM_CACHE_TEMPLATE "%ssrtm3-%s%s%c%02d%c%03d.hgt.zip"
53 #define SRTM_FTP_SITE "e0srp01u.ecs.nasa.gov"
54 #define SRTM_FTP_URI "/srtm/version2/SRTM3/"
56 #ifdef VIK_CONFIG_DEM24K
57 #define DEM24K_DOWNLOAD_SCRIPT "dem24k.pl"
61 static void dem_layer_marshall( VikDEMLayer *vdl, guint8 **data, gint *len );
62 static VikDEMLayer *dem_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp );
63 static gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp );
64 static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id );
65 static void dem_layer_update_gc ( VikDEMLayer *vdl, VikViewport *vp, const gchar *color );
66 static void dem_layer_post_read ( VikLayer *vl, VikViewport *vp, gboolean from_file );
67 static void srtm_draw_existence ( VikViewport *vp );
69 #ifdef VIK_CONFIG_DEM24K
70 static void dem24k_draw_existence ( VikViewport *vp );
73 static VikLayerParamScale param_scales[] = {
79 static gchar *params_source[] = {
80 "SRTM Global 90m (3 arcsec)",
81 #ifdef VIK_CONFIG_DEM24K
88 enum { DEM_SOURCE_SRTM,
89 #ifdef VIK_CONFIG_DEM24K
95 static VikLayerParam dem_layer_params[] = {
96 { "files", VIK_LAYER_PARAM_STRING_LIST, VIK_LAYER_GROUP_NONE, "DEM Files:", VIK_LAYER_WIDGET_FILELIST },
97 { "source", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, "Download Source:", VIK_LAYER_WIDGET_RADIOGROUP_STATIC, params_source, NULL },
98 { "color", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, "Color:", VIK_LAYER_WIDGET_ENTRY },
99 { "min_elev", VIK_LAYER_PARAM_DOUBLE, VIK_LAYER_GROUP_NONE, "Min Elev:", VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 0 },
100 { "max_elev", VIK_LAYER_PARAM_DOUBLE, VIK_LAYER_GROUP_NONE, "Max Elev:", VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 0 },
101 { "line_thickness", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, "Line Thickness:", VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 1 },
105 enum { PARAM_FILES=0, PARAM_SOURCE, PARAM_COLOR, PARAM_MIN_ELEV, PARAM_MAX_ELEV, PARAM_LINE_THICKNESS, NUM_PARAMS };
107 static gpointer dem_layer_download_create ( VikWindow *vw, VikViewport *vvp);
108 static gboolean dem_layer_download_release ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp );
109 static gboolean dem_layer_download_click ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp );
111 static VikToolInterface dem_tools[] = {
112 { "DEM Download/Import", (VikToolConstructorFunc) dem_layer_download_create, NULL, NULL, NULL,
113 (VikToolMouseFunc) dem_layer_download_click, NULL, (VikToolMouseFunc) dem_layer_download_release,
114 (VikToolKeyFunc) NULL, &cursor_demdl },
121 static gchar *dem_colors[] = {
227 static const guint DEM_N_COLORS = sizeof(dem_colors)/sizeof(dem_colors[0]);
230 VikLayerInterface vik_dem_layer_interface = {
235 sizeof(dem_tools) / sizeof(dem_tools[0]),
244 (VikLayerFuncCreate) vik_dem_layer_create,
245 (VikLayerFuncRealize) NULL,
247 (VikLayerFuncFree) vik_dem_layer_free,
249 (VikLayerFuncProperties) NULL,
250 (VikLayerFuncDraw) vik_dem_layer_draw,
251 (VikLayerFuncChangeCoordMode) NULL,
253 (VikLayerFuncSetMenuItemsSelection) NULL,
254 (VikLayerFuncGetMenuItemsSelection) NULL,
256 (VikLayerFuncAddMenuItems) NULL,
257 (VikLayerFuncSublayerAddMenuItems) NULL,
259 (VikLayerFuncSublayerRenameRequest) NULL,
260 (VikLayerFuncSublayerToggleVisible) NULL,
262 (VikLayerFuncMarshall) dem_layer_marshall,
263 (VikLayerFuncUnmarshall) dem_layer_unmarshall,
265 (VikLayerFuncSetParam) dem_layer_set_param,
266 (VikLayerFuncGetParam) dem_layer_get_param,
268 (VikLayerFuncReadFileData) NULL,
269 (VikLayerFuncWriteFileData) NULL,
271 (VikLayerFuncDeleteItem) NULL,
272 (VikLayerFuncCopyItem) NULL,
273 (VikLayerFuncPasteItem) NULL,
274 (VikLayerFuncFreeCopiedItem) NULL,
275 (VikLayerFuncDragDropRequest) NULL,
278 struct _VikDEMLayer {
285 guint8 line_thickness;
290 GType vik_dem_layer_get_type ()
292 static GType vdl_type = 0;
296 static const GTypeInfo vdl_info =
298 sizeof (VikDEMLayerClass),
299 NULL, /* base_init */
300 NULL, /* base_finalize */
301 NULL, /* class init */
302 NULL, /* class_finalize */
303 NULL, /* class_data */
304 sizeof (VikDEMLayer),
306 NULL /* instance init */
308 vdl_type = g_type_register_static ( VIK_LAYER_TYPE, "VikDEMLayer", &vdl_info, 0 );
314 static void dem_layer_marshall( VikDEMLayer *vdl, guint8 **data, gint *len )
316 vik_layer_marshall_params ( VIK_LAYER(vdl), data, len );
319 static VikDEMLayer *dem_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp )
321 VikDEMLayer *rv = vik_dem_layer_new ();
324 /* TODO: share GCS between layers */
325 for ( i = 0; i < DEM_N_COLORS; i++ )
326 rv->gcs[i] = vik_viewport_new_gc ( vvp, dem_colors[i], rv->line_thickness );
328 vik_layer_unmarshall_params ( VIK_LAYER(rv), data, len, vvp );
332 gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp )
336 case PARAM_COLOR: if ( vdl->color ) g_free ( vdl->color ); vdl->color = g_strdup ( data.s ); break;
337 case PARAM_SOURCE: vdl->source = data.u; break;
338 case PARAM_MIN_ELEV: vdl->min_elev = data.d; break;
339 case PARAM_MAX_ELEV: vdl->max_elev = data.d; break;
340 case PARAM_LINE_THICKNESS: if ( data.u >= 1 && data.u <= 15 ) vdl->line_thickness = data.u; break;
341 case PARAM_FILES: a_dems_load_list ( &(data.sl) ); a_dems_list_free ( vdl->files ); vdl->files = data.sl; break;
346 static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id )
348 VikLayerParamData rv;
351 case PARAM_FILES: rv.sl = vdl->files; break;
352 case PARAM_SOURCE: rv.u = vdl->source; break;
353 case PARAM_COLOR: rv.s = vdl->color ? vdl->color : ""; break;
354 case PARAM_MIN_ELEV: rv.d = vdl->min_elev; break;
355 case PARAM_MAX_ELEV: rv.d = vdl->max_elev; break;
356 case PARAM_LINE_THICKNESS: rv.i = vdl->line_thickness; break;
361 static void dem_layer_post_read ( VikLayer *vl, VikViewport *vp, gboolean from_file )
363 VikDEMLayer *vdl = VIK_DEM_LAYER(vl);
365 g_object_unref ( G_OBJECT(vdl->gc) );
367 vdl->gc = vik_viewport_new_gc ( vp, vdl->color, vdl->line_thickness );
370 VikDEMLayer *vik_dem_layer_new ( )
372 VikDEMLayer *vdl = VIK_DEM_LAYER ( g_object_new ( VIK_DEM_LAYER_TYPE, NULL ) );
374 vik_layer_init ( VIK_LAYER(vdl), VIK_LAYER_DEM );
381 vdl->gcs = g_malloc(sizeof(GdkGC *)*DEM_N_COLORS);
382 /* make new gcs only if we need it (copy layer -> use old) */
385 vdl->max_elev = 1000.0;
386 vdl->source = DEM_SOURCE_SRTM;
387 vdl->line_thickness = 3;
394 static void vik_dem_layer_draw_dem ( VikDEMLayer *vdl, VikViewport *vp, VikDEM *dem )
396 VikDEMColumn *column;
398 struct LatLon dem_northeast, dem_southwest;
399 gdouble max_lat, max_lon, min_lat, min_lon;
401 /**** Check if viewport and DEM data overlap ****/
403 /* get min, max lat/lon of viewport */
404 vik_viewport_get_min_max_lat_lon ( vp, &min_lat, &max_lat, &min_lon, &max_lon );
406 /* get min, max lat/lon of DEM data */
407 if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) {
408 dem_northeast.lat = dem->max_north / 3600.0;
409 dem_northeast.lon = dem->max_east / 3600.0;
410 dem_southwest.lat = dem->min_north / 3600.0;
411 dem_southwest.lon = dem->min_east / 3600.0;
412 } else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) {
413 struct UTM dem_northeast_utm, dem_southwest_utm;
414 dem_northeast_utm.northing = dem->max_north;
415 dem_northeast_utm.easting = dem->max_east;
416 dem_southwest_utm.northing = dem->min_north;
417 dem_southwest_utm.easting = dem->min_east;
418 dem_northeast_utm.zone = dem_southwest_utm.zone = dem->utm_zone;
419 dem_northeast_utm.letter = dem_southwest_utm.letter = dem->utm_letter;
421 a_coords_utm_to_latlon(&dem_northeast_utm, &dem_northeast);
422 a_coords_utm_to_latlon(&dem_southwest_utm, &dem_southwest);
425 if ( (max_lat > dem_northeast.lat && min_lat > dem_northeast.lat) ||
426 (max_lat < dem_southwest.lat && min_lat < dem_southwest.lat) )
428 else if ( (max_lon > dem_northeast.lon && min_lon > dem_northeast.lon) ||
429 (max_lon < dem_southwest.lon && min_lon < dem_southwest.lon) )
431 /* else they overlap */
433 /**** End Overlap Check ****/
434 /* boxes to show where we have DEM instead of actually drawing the DEM.
435 * useful if we want to see what areas we have coverage for (if we want
436 * to get elevation data for a track) but don't want to cover the map.
440 /* draw a box if a DEM is loaded. in future I'd like to add an option for this
441 * this is useful if we want to see what areas we have dem for but don't want to
442 * cover the map (or maybe we just need translucent DEM?) */
444 VikCoord demne, demsw;
446 vik_coord_load_from_latlon(&demne, vik_viewport_get_coord_mode(vp), &dem_northeast);
447 vik_coord_load_from_latlon(&demsw, vik_viewport_get_coord_mode(vp), &dem_southwest);
449 vik_viewport_coord_to_screen ( vp, &demne, &x1, &y1 );
450 vik_viewport_coord_to_screen ( vp, &demsw, &x2, &y2 );
452 if ( x1 > vik_viewport_get_width(vp) ) x1=vik_viewport_get_width(vp);
453 if ( y2 > vik_viewport_get_height(vp) ) y2=vik_viewport_get_height(vp);
454 if ( x2 < 0 ) x2 = 0;
455 if ( y1 < 0 ) y1 = 0;
456 vik_viewport_draw_rectangle ( vp, GTK_WIDGET(vp)->style->black_gc,
457 FALSE, x2, y1, x1-x2, y2-y1 );
462 if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) {
463 VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
465 gdouble max_lat_as, max_lon_as, min_lat_as, min_lon_as;
466 gdouble start_lat_as, end_lat_as, start_lon_as, end_lon_as;
468 gdouble start_lat, end_lat, start_lon, end_lon;
470 struct LatLon counter;
472 guint x, y, start_x, start_y;
476 guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 40 ); /* todo: smarter calculation. */
478 gdouble nscale_deg = dem->north_scale / ((gdouble) 3600);
479 gdouble escale_deg = dem->east_scale / ((gdouble) 3600);
481 max_lat_as = max_lat * 3600;
482 min_lat_as = min_lat * 3600;
483 max_lon_as = max_lon * 3600;
484 min_lon_as = min_lon * 3600;
486 start_lat_as = MAX(min_lat_as, dem->min_north);
487 end_lat_as = MIN(max_lat_as, dem->max_north);
488 start_lon_as = MAX(min_lon_as, dem->min_east);
489 end_lon_as = MIN(max_lon_as, dem->max_east);
491 start_lat = floor(start_lat_as / dem->north_scale) * nscale_deg;
492 end_lat = ceil (end_lat_as / dem->north_scale) * nscale_deg;
493 start_lon = floor(start_lon_as / dem->east_scale) * escale_deg;
494 end_lon = ceil (end_lon_as / dem->east_scale) * escale_deg;
496 vik_dem_east_north_to_xy ( dem, start_lon_as, start_lat_as, &start_x, &start_y );
498 /* verify sane elev interval */
499 if ( vdl->max_elev <= vdl->min_elev )
500 vdl->max_elev = vdl->min_elev + 1;
502 for ( x=start_x, counter.lon = start_lon; counter.lon <= end_lon; counter.lon += escale_deg * skip_factor, x += skip_factor ) {
503 if ( x > 0 && x < dem->n_columns ) {
504 column = g_ptr_array_index ( dem->columns, x );
505 for ( y=start_y, counter.lat = start_lat; counter.lat <= end_lat; counter.lat += nscale_deg * skip_factor, y += skip_factor ) {
506 if ( y > column->n_points )
508 elev = column->points[y];
510 if ( elev != VIK_DEM_INVALID_ELEVATION && elev < vdl->min_elev )
512 if ( elev != VIK_DEM_INVALID_ELEVATION && elev > vdl->max_elev )
519 vik_coord_load_from_latlon(&tmp, vik_viewport_get_coord_mode(vp), &counter);
520 vik_viewport_coord_to_screen(vp, &tmp, &a, &b);
521 if ( elev == VIK_DEM_INVALID_ELEVATION )
522 ; /* don't draw it */
523 else if ( elev <= 0 )
524 vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-2, b-2, 4, 4 );
526 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 );
531 } else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) {
532 gdouble max_nor, max_eas, min_nor, min_eas;
533 gdouble start_nor, start_eas, end_nor, end_eas;
537 guint x, y, start_x, start_y;
539 VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
542 guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 10 ); /* todo: smarter calculation. */
544 VikCoord tleft, tright, bleft, bright;
546 vik_viewport_screen_to_coord ( vp, 0, 0, &tleft );
547 vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), 0, &tright );
548 vik_viewport_screen_to_coord ( vp, 0, vik_viewport_get_height(vp), &bleft );
549 vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), vik_viewport_get_height(vp), &bright );
552 vik_coord_convert(&tleft, VIK_COORD_UTM);
553 vik_coord_convert(&tright, VIK_COORD_UTM);
554 vik_coord_convert(&bleft, VIK_COORD_UTM);
555 vik_coord_convert(&bright, VIK_COORD_UTM);
557 max_nor = MAX(tleft.north_south, tright.north_south);
558 min_nor = MIN(bleft.north_south, bright.north_south);
559 max_eas = MAX(bright.east_west, tright.east_west);
560 min_eas = MIN(bleft.east_west, tleft.east_west);
562 start_nor = MAX(min_nor, dem->min_north);
563 end_nor = MIN(max_nor, dem->max_north);
564 if ( tleft.utm_zone == dem->utm_zone && bleft.utm_zone == dem->utm_zone
565 && (tleft.utm_letter >= 'N') == (dem->utm_letter >= 'N')
566 && (bleft.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
567 start_eas = MAX(min_eas, dem->min_east);
569 start_eas = dem->min_east;
570 if ( tright.utm_zone == dem->utm_zone && bright.utm_zone == dem->utm_zone
571 && (tright.utm_letter >= 'N') == (dem->utm_letter >= 'N')
572 && (bright.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
573 end_eas = MIN(max_eas, dem->max_east);
575 end_eas = dem->max_east;
577 start_nor = floor(start_nor / dem->north_scale) * dem->north_scale;
578 end_nor = ceil (end_nor / dem->north_scale) * dem->north_scale;
579 start_eas = floor(start_eas / dem->east_scale) * dem->east_scale;
580 end_eas = ceil (end_eas / dem->east_scale) * dem->east_scale;
582 vik_dem_east_north_to_xy ( dem, start_eas, start_nor, &start_x, &start_y );
584 /* TODO: why start_x and start_y are -1 -- rounding error from above? */
586 counter.zone = dem->utm_zone;
587 counter.letter = dem->utm_letter;
589 for ( x=start_x, counter.easting = start_eas; counter.easting <= end_eas; counter.easting += dem->east_scale * skip_factor, x += skip_factor ) {
590 if ( x > 0 && x < dem->n_columns ) {
591 column = g_ptr_array_index ( dem->columns, x );
592 for ( y=start_y, counter.northing = start_nor; counter.northing <= end_nor; counter.northing += dem->north_scale * skip_factor, y += skip_factor ) {
593 if ( y > column->n_points )
595 elev = column->points[y];
596 if ( elev != VIK_DEM_INVALID_ELEVATION && elev < vdl->min_elev )
598 if ( elev != VIK_DEM_INVALID_ELEVATION && elev > vdl->max_elev )
603 vik_coord_load_from_utm(&tmp, vik_viewport_get_coord_mode(vp), &counter);
604 vik_viewport_coord_to_screen(vp, &tmp, &a, &b);
605 if ( elev == VIK_DEM_INVALID_ELEVATION )
606 ; /* don't draw it */
607 else if ( elev <= 0 )
608 vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-2, b-2, 4, 4 );
610 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 );
618 /* return the continent for the specified lat, lon */
620 static const gchar *srtm_continent_dir ( gint lat, gint lon )
622 extern const char *_srtm_continent_data[];
623 static GHashTable *srtm_continent = NULL;
624 const gchar *continent;
627 if (!srtm_continent) {
630 srtm_continent = g_hash_table_new(g_str_hash, g_str_equal);
631 s = _srtm_continent_data;
632 while (*s != (gchar *)-1) {
635 g_hash_table_insert(srtm_continent, *s, continent);
641 g_snprintf(name, sizeof(name), "%c%02d%c%03d",
642 (lat >= 0) ? 'N' : 'S', ABS(lat),
643 (lon >= 0) ? 'E' : 'W', ABS(lon));
645 return(g_hash_table_lookup(srtm_continent, name));
648 void vik_dem_layer_draw ( VikDEMLayer *vdl, gpointer data )
650 VikViewport *vp = (VikViewport *) data;
651 GList *dems_iter = vdl->files;
655 /* search for SRTM3 90m */
657 if ( vdl->source == DEM_SOURCE_SRTM )
658 srtm_draw_existence ( vp );
659 #ifdef VIK_CONFIG_DEM24K
660 else if ( vdl->source == DEM_SOURCE_DEM24K )
661 dem24k_draw_existence ( vp );
664 while ( dems_iter ) {
665 dem = a_dems_get ( (const char *) (dems_iter->data) );
667 vik_dem_layer_draw_dem ( vdl, vp, dem );
668 dems_iter = dems_iter->next;
672 void vik_dem_layer_free ( VikDEMLayer *vdl )
675 if ( vdl->gc != NULL )
676 g_object_unref ( G_OBJECT(vdl->gc) );
678 if ( vdl->color != NULL )
679 g_free ( vdl->color );
682 for ( i = 0; i < DEM_N_COLORS; i++ )
683 g_object_unref ( vdl->gcs[i] );
686 a_dems_list_free ( vdl->files );
689 static void dem_layer_update_gc ( VikDEMLayer *vdl, VikViewport *vp, const gchar *color )
692 g_free ( vdl->color );
694 vdl->color = g_strdup ( color );
697 g_object_unref ( G_OBJECT(vdl->gc) );
699 vdl->gc = vik_viewport_new_gc ( vp, vdl->color, vdl->line_thickness );
702 VikDEMLayer *vik_dem_layer_create ( VikViewport *vp )
704 VikDEMLayer *vdl = vik_dem_layer_new ();
707 /* TODO: share GCS between layers */
708 for ( i = 0; i < DEM_N_COLORS; i++ )
709 vdl->gcs[i] = vik_viewport_new_gc ( vp, dem_colors[i], vdl->line_thickness );
711 dem_layer_update_gc ( vdl, vp, "red" );
714 /**************************************************************
715 **** SOURCES & DOWNLOADING
716 **************************************************************/
722 VikDEMLayer *vdl; /* NULL if not alive */
728 /**************************************************
730 **************************************************/
732 static void srtm_dem_download_thread ( DEMDownloadParams *p, gpointer threaddata )
735 const gchar *continent_dir;
737 intlat = (int)floor(p->lat);
738 intlon = (int)floor(p->lon);
739 continent_dir = srtm_continent_dir(intlat, intlon);
741 if (!continent_dir) {
742 g_warning("No SRTM data available for %f, %f\n", p->lat, p->lon);
746 gchar *src_fn = g_strdup_printf("%s%s%s%c%02d%c%03d.hgt.zip",
750 (intlat >= 0) ? 'N' : 'S',
752 (intlon >= 0) ? 'E' : 'W',
755 DownloadOptions options = { NULL, 0 };
756 a_ftp_download_get_url ( SRTM_FTP_SITE, src_fn, p->dest, &options );
760 static gchar *srtm_lat_lon_to_dest_fn ( gdouble lat, gdouble lon )
763 const gchar *continent_dir;
765 intlat = (int)floor(lat);
766 intlon = (int)floor(lon);
767 continent_dir = srtm_continent_dir(intlat, intlon);
770 continent_dir = "nowhere";
772 return g_strdup_printf("srtm3-%s%s%c%02d%c%03d.hgt.zip",
775 (intlat >= 0) ? 'N' : 'S',
777 (intlon >= 0) ? 'E' : 'W',
782 /* TODO: generalize */
783 static void srtm_draw_existence ( VikViewport *vp )
785 gdouble max_lat, max_lon, min_lat, min_lon;
786 gchar buf[strlen(MAPS_CACHE_DIR)+strlen(SRTM_CACHE_TEMPLATE)+30];
789 vik_viewport_get_min_max_lat_lon ( vp, &min_lat, &max_lat, &min_lon, &max_lon );
791 for (i = floor(min_lat); i <= floor(max_lat); i++) {
792 for (j = floor(min_lon); j <= floor(max_lon); j++) {
793 const gchar *continent_dir;
794 if ((continent_dir = srtm_continent_dir(i, j)) == NULL)
796 g_snprintf(buf, sizeof(buf), SRTM_CACHE_TEMPLATE,
800 (i >= 0) ? 'N' : 'S',
802 (j >= 0) ? 'E' : 'W',
804 if ( access(buf, F_OK ) == 0 ) {
809 sw.mode = VIK_COORD_LATLON;
810 ne.north_south = i+1;
812 ne.mode = VIK_COORD_LATLON;
813 vik_viewport_coord_to_screen ( vp, &sw, &x1, &y1 );
814 vik_viewport_coord_to_screen ( vp, &ne, &x2, &y2 );
815 if ( x1 < 0 ) x1 = 0;
816 if ( y2 < 0 ) y2 = 0;
817 vik_viewport_draw_rectangle ( vp, GTK_WIDGET(vp)->style->black_gc,
818 FALSE, x1, y2, x2-x1, y1-y2 );
825 /**************************************************
827 **************************************************/
829 #ifdef VIK_CONFIG_DEM24K
831 static void dem24k_dem_download_thread ( DEMDownloadParams *p, gpointer threaddata )
834 gchar *cmdline = g_strdup_printf("%s %.03f %.03f",
835 DEM24K_DOWNLOAD_SCRIPT,
838 /* FIX: don't use system, use execv or something. check for existence */
842 static gchar *dem24k_lat_lon_to_dest_fn ( gdouble lat, gdouble lon )
844 return g_strdup_printf("dem24k/%d/%d/%.03f,%.03f.dem",
851 /* TODO: generalize */
852 static void dem24k_draw_existence ( VikViewport *vp )
854 gdouble max_lat, max_lon, min_lat, min_lon;
855 gchar buf[strlen(MAPS_CACHE_DIR)+40];
858 vik_viewport_get_min_max_lat_lon ( vp, &min_lat, &max_lat, &min_lon, &max_lon );
860 for (i = floor(min_lat*8)/8; i <= floor(max_lat*8)/8; i+=0.125) {
861 /* check lat dir first -- faster */
862 g_snprintf(buf, sizeof(buf), "%sdem24k/%d/",
865 if ( access(buf, F_OK) != 0 )
867 for (j = floor(min_lon*8)/8; j <= floor(max_lon*8)/8; j+=0.125) {
868 /* check lon dir first -- faster */
869 g_snprintf(buf, sizeof(buf), "%sdem24k/%d/%d/",
873 if ( access(buf, F_OK) != 0 )
875 g_snprintf(buf, sizeof(buf), "%sdem24k/%d/%d/%.03f,%.03f.dem",
881 if ( access(buf, F_OK ) == 0 ) {
885 sw.east_west = j-0.125;
886 sw.mode = VIK_COORD_LATLON;
887 ne.north_south = i+0.125;
889 ne.mode = VIK_COORD_LATLON;
890 vik_viewport_coord_to_screen ( vp, &sw, &x1, &y1 );
891 vik_viewport_coord_to_screen ( vp, &ne, &x2, &y2 );
892 if ( x1 < 0 ) x1 = 0;
893 if ( y2 < 0 ) y2 = 0;
894 vik_viewport_draw_rectangle ( vp, GTK_WIDGET(vp)->style->black_gc,
895 FALSE, x1, y2, x2-x1, y1-y2 );
902 /**************************************************
903 * SOURCES -- DOWNLOADING & IMPORTING TOOL *
904 **************************************************
907 static void weak_ref_cb ( gpointer ptr, GObject * dead_vdl )
909 DEMDownloadParams *p = ptr;
910 g_mutex_lock ( p->mutex );
912 g_mutex_unlock ( p->mutex );
915 /* Try to add file full_path.
916 * full_path will be copied.
917 * returns FALSE if file does not exists, TRUE otherwise.
919 static gboolean dem_layer_add_file ( VikDEMLayer *vdl, const gchar *full_path )
921 if ( access(full_path, F_OK ) == 0 ) {
922 /* only load if file size is not 0 (not in progress */
924 stat (full_path, &sb);
926 gchar *duped_path = g_strdup(full_path);
927 vdl->files = g_list_prepend ( vdl->files, duped_path );
928 a_dems_load ( duped_path );
929 g_warning(duped_path);
930 vik_layer_emit_update ( VIK_LAYER(vdl) );
937 static void dem_download_thread ( DEMDownloadParams *p, gpointer threaddata )
939 if ( p->source == DEM_SOURCE_SRTM )
940 srtm_dem_download_thread ( p, threaddata );
941 #ifdef VIK_CONFIG_DEM24K
942 else if ( p->source == DEM_SOURCE_DEM24K )
943 dem24k_dem_download_thread ( p, threaddata );
947 g_mutex_lock ( p->mutex );
949 g_object_weak_unref ( G_OBJECT(p->vdl), weak_ref_cb, p );
951 if ( dem_layer_add_file ( p->vdl, p->dest ) )
952 vik_layer_emit_update ( VIK_LAYER(p->vdl) );
954 g_mutex_unlock ( p->mutex );
959 static void free_dem_download_params ( DEMDownloadParams *p )
961 g_mutex_free ( p->mutex );
966 static gpointer dem_layer_download_create ( VikWindow *vw, VikViewport *vvp)
972 static gboolean dem_layer_download_release ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp )
978 gchar *dem_file = NULL;
980 if ( vdl->source == DEM_SOURCE_NONE )
981 a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vdl), "No download source selected. Edit layer properties." );
983 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord );
984 vik_coord_to_latlon ( &coord, &ll );
987 if ( vdl->source == DEM_SOURCE_SRTM )
988 dem_file = srtm_lat_lon_to_dest_fn ( ll.lat, ll.lon );
989 #ifdef VIK_CONFIG_DEM24K
990 else if ( vdl->source == DEM_SOURCE_DEM24K )
991 dem_file = dem24k_lat_lon_to_dest_fn ( ll.lat, ll.lon );
997 full_path = g_strdup_printf("%s%s", MAPS_CACHE_DIR, dem_file );
999 g_warning(full_path);
1001 // TODO: check if already in filelist
1003 if ( ! dem_layer_add_file(vdl, full_path) ) {
1004 gchar *tmp = g_strdup_printf ( "Downloading DEM %s ", dem_file );
1005 DEMDownloadParams *p = g_malloc(sizeof(DEMDownloadParams));
1006 p->dest = g_strdup(full_path);
1010 p->mutex = g_mutex_new();
1011 p->source = vdl->source;
1012 g_object_weak_ref(G_OBJECT(p->vdl), weak_ref_cb, p );
1014 a_background_thread ( VIK_GTK_WINDOW_FROM_LAYER(vdl), tmp,
1015 (vik_thr_func) dem_download_thread, p,
1016 (vik_thr_free_func) free_dem_download_params, NULL, 1 );
1019 g_free ( dem_file );
1020 g_free ( full_path );
1025 static gboolean dem_layer_download_click ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp )
1027 /* choose & keep track of cache dir
1028 * download in background thread
1029 * download over area */