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
28 #ifdef HAVE_SYS_TYPES_H
29 #include <sys/types.h>
31 #ifdef HAVE_SYS_STAT_H
38 #include <glib/gi18n.h>
45 #include "background.h"
46 #include "vikwaypoint.h"
48 #include "vikviewport.h"
49 #include "viktreeview.h"
51 #include "vikaggregatelayer.h"
52 #include "viklayerspanel.h"
53 #include "vikmapslayer.h"
54 #include "vikdemlayer.h"
60 #include "icons/icons.h"
62 #define MAPS_CACHE_DIR maps_layer_default_dir()
64 #define SRTM_CACHE_TEMPLATE "%ssrtm3-%s%s%c%02d%c%03d.hgt.zip"
65 #define SRTM_HTTP_SITE "dds.cr.usgs.gov"
66 #define SRTM_HTTP_URI "/srtm/version2_1/SRTM3/OLD/"
68 #ifdef VIK_CONFIG_DEM24K
69 #define DEM24K_DOWNLOAD_SCRIPT "dem24k.pl"
73 static void dem_layer_marshall( VikDEMLayer
*vdl
, guint8
**data
, gint
*len
);
74 static VikDEMLayer
*dem_layer_unmarshall( guint8
*data
, gint len
, VikViewport
*vvp
);
75 static gboolean
dem_layer_set_param ( VikDEMLayer
*vdl
, guint16 id
, VikLayerParamData data
, VikViewport
*vp
);
76 static VikLayerParamData
dem_layer_get_param ( VikDEMLayer
*vdl
, guint16 id
);
77 static void dem_layer_update_gc ( VikDEMLayer
*vdl
, VikViewport
*vp
, const gchar
*color
);
78 static void dem_layer_post_read ( VikLayer
*vl
, VikViewport
*vp
, gboolean from_file
);
79 static void srtm_draw_existence ( VikViewport
*vp
);
81 #ifdef VIK_CONFIG_DEM24K
82 static void dem24k_draw_existence ( VikViewport
*vp
);
85 static VikLayerParamScale param_scales
[] = {
91 static gchar
*params_source
[] = {
92 "SRTM Global 90m (3 arcsec)",
93 #ifdef VIK_CONFIG_DEM24K
100 static gchar
*params_type
[] = {
101 N_("Absolute height"),
102 N_("Height gradient"),
106 enum { DEM_SOURCE_SRTM
,
107 #ifdef VIK_CONFIG_DEM24K
113 enum { DEM_TYPE_HEIGHT
= 0,
118 static VikLayerParam dem_layer_params
[] = {
119 { "files", VIK_LAYER_PARAM_STRING_LIST
, VIK_LAYER_GROUP_NONE
, N_("DEM Files:"), VIK_LAYER_WIDGET_FILELIST
},
120 { "source", VIK_LAYER_PARAM_UINT
, VIK_LAYER_GROUP_NONE
, N_("Download Source:"), VIK_LAYER_WIDGET_RADIOGROUP_STATIC
, params_source
, NULL
},
121 { "color", VIK_LAYER_PARAM_STRING
, VIK_LAYER_GROUP_NONE
, N_("Color:"), VIK_LAYER_WIDGET_ENTRY
},
122 { "type", VIK_LAYER_PARAM_UINT
, VIK_LAYER_GROUP_NONE
, N_("Type:"), VIK_LAYER_WIDGET_RADIOGROUP_STATIC
, params_type
, NULL
},
123 { "min_elev", VIK_LAYER_PARAM_DOUBLE
, VIK_LAYER_GROUP_NONE
, N_("Min Elev:"), VIK_LAYER_WIDGET_SPINBUTTON
, param_scales
+ 0 },
124 { "max_elev", VIK_LAYER_PARAM_DOUBLE
, VIK_LAYER_GROUP_NONE
, N_("Max Elev:"), VIK_LAYER_WIDGET_SPINBUTTON
, param_scales
+ 0 },
125 { "line_thickness", VIK_LAYER_PARAM_UINT
, VIK_LAYER_GROUP_NONE
, N_("Line Thickness:"), VIK_LAYER_WIDGET_SPINBUTTON
, param_scales
+ 1 },
129 enum { PARAM_FILES
=0, PARAM_SOURCE
, PARAM_COLOR
, PARAM_TYPE
, PARAM_MIN_ELEV
, PARAM_MAX_ELEV
, PARAM_LINE_THICKNESS
, NUM_PARAMS
};
131 static gpointer
dem_layer_download_create ( VikWindow
*vw
, VikViewport
*vvp
);
132 static gboolean
dem_layer_download_release ( VikDEMLayer
*vdl
, GdkEventButton
*event
, VikViewport
*vvp
);
133 static gboolean
dem_layer_download_click ( VikDEMLayer
*vdl
, GdkEventButton
*event
, VikViewport
*vvp
);
135 static VikToolInterface dem_tools
[] = {
136 { N_("DEM Download/Import"), (VikToolConstructorFunc
) dem_layer_download_create
, NULL
, NULL
, NULL
,
137 (VikToolMouseFunc
) dem_layer_download_click
, NULL
, (VikToolMouseFunc
) dem_layer_download_release
,
138 (VikToolKeyFunc
) NULL
, GDK_CURSOR_IS_PIXMAP
, &cursor_demdl_pixbuf
},
145 static gchar
*dem_height_colors
[] = {
147 "#9b793c", "#9c7d40", "#9d8144", "#9e8549", "#9f894d", "#a08d51", "#a29156", "#a3955a", "#a4995e", "#a69d63",
148 "#a89f65", "#aaa267", "#ada569", "#afa76b", "#b1aa6d", "#b4ad6f", "#b6b071", "#b9b373", "#bcb676", "#beb978",
149 "#c0bc7a", "#c2c07d", "#c4c37f", "#c6c681", "#c8ca84", "#cacd86", "#ccd188", "#cfd58b", "#c2ce84", "#b5c87e",
150 "#a9c278", "#9cbb71", "#8fb56b", "#83af65", "#76a95e", "#6aa358", "#5e9d52", "#63a055", "#69a458", "#6fa85c",
151 "#74ac5f", "#7ab063", "#80b467", "#86b86a", "#8cbc6e", "#92c072", "#94c175", "#97c278", "#9ac47c", "#9cc57f",
152 "#9fc682", "#a2c886", "#a4c989", "#a7cb8d", "#aacd91", "#afce99", "#b5d0a1", "#bbd2aa", "#c0d3b2", "#c6d5ba",
153 "#ccd7c3", "#d1d9cb", "#d7dbd4", "#DDDDDD", "#e0e0e0", "#e4e4e4", "#e8e8e8", "#ebebeb", "#efefef", "#f3f3f3",
154 "#f7f7f7", "#fbfbfb", "#ffffff"
157 static const guint DEM_N_HEIGHT_COLORS
= sizeof(dem_height_colors
)/sizeof(dem_height_colors
[0]);
160 "#9b793c", "#9e8549", "#a29156", "#a69d63", "#ada569", "#b4ad6f", "#bcb676", "#c2c07d", "#c8ca84", "#cfd58b",
161 "#a9c278", "#83af65", "#5e9d52", "#6fa85c", "#80b467", "#92c072", "#9ac47c", "#a2c886", "#aacd91", "#bbd2aa",
162 "#ccd7c3", "#DDDDDD", "#e8e8e8", "#f3f3f3", "#FFFFFF"
166 static gchar
*dem_gradient_colors
[] = {
168 "#000000", "#000011", "#000022", "#000033", "#000044", "#00004c", "#000055", "#00005d", "#000066", "#00006e",
169 "#000077", "#00007f", "#000088", "#000090", "#000099", "#0000a1", "#0000aa", "#0000b2", "#0000bb", "#0000c3",
170 "#0000cc", "#0000d4", "#0000dd", "#0000e5", "#0000ee", "#0000f6", "#0000ff", "#0008f7", "#0011ee", "#0019e6",
171 "#0022dd", "#002ad5", "#0033cc", "#003bc4", "#0044bb", "#004cb3", "#0055aa", "#005da2", "#006699", "#006e91",
172 "#007788", "#007f80", "#008877", "#00906f", "#009966", "#00a15e", "#00aa55", "#00b24d", "#00bb44", "#00c33c",
173 "#00cc33", "#00d42b", "#00dd22", "#00e51a", "#00ee11", "#00f609", "#00ff00", "#08f700", "#11ee00", "#19e600",
174 "#22dd00", "#2ad500", "#33cc00", "#3bc400", "#44bb00", "#4cb300", "#55aa00", "#5da200", "#669900", "#6e9100",
175 "#778800", "#7f8000", "#887700", "#906f00", "#996600", "#a15e00", "#aa5500", "#b24d00", "#bb4400", "#c33c00",
176 "#cc3300", "#d42b00", "#dd2200", "#e51a00", "#ee1100", "#f60900", "#ff0000",
180 static const guint DEM_N_GRADIENT_COLORS
= sizeof(dem_gradient_colors
)/sizeof(dem_gradient_colors
[0]);
183 VikLayerInterface vik_dem_layer_interface
= {
188 sizeof(dem_tools
) / sizeof(dem_tools
[0]),
197 (VikLayerFuncCreate
) vik_dem_layer_create
,
198 (VikLayerFuncRealize
) NULL
,
199 (VikLayerFuncPostRead
) dem_layer_post_read
,
200 (VikLayerFuncFree
) vik_dem_layer_free
,
202 (VikLayerFuncProperties
) NULL
,
203 (VikLayerFuncDraw
) vik_dem_layer_draw
,
204 (VikLayerFuncChangeCoordMode
) NULL
,
206 (VikLayerFuncSetMenuItemsSelection
) NULL
,
207 (VikLayerFuncGetMenuItemsSelection
) NULL
,
209 (VikLayerFuncAddMenuItems
) NULL
,
210 (VikLayerFuncSublayerAddMenuItems
) NULL
,
212 (VikLayerFuncSublayerRenameRequest
) NULL
,
213 (VikLayerFuncSublayerToggleVisible
) NULL
,
215 (VikLayerFuncMarshall
) dem_layer_marshall
,
216 (VikLayerFuncUnmarshall
) dem_layer_unmarshall
,
218 (VikLayerFuncSetParam
) dem_layer_set_param
,
219 (VikLayerFuncGetParam
) dem_layer_get_param
,
221 (VikLayerFuncReadFileData
) NULL
,
222 (VikLayerFuncWriteFileData
) NULL
,
224 (VikLayerFuncDeleteItem
) NULL
,
225 (VikLayerFuncCopyItem
) NULL
,
226 (VikLayerFuncPasteItem
) NULL
,
227 (VikLayerFuncFreeCopiedItem
) NULL
,
228 (VikLayerFuncDragDropRequest
) NULL
,
231 struct _VikDEMLayer
{
239 guint8 line_thickness
;
245 GType
vik_dem_layer_get_type ()
247 static GType vdl_type
= 0;
251 static const GTypeInfo vdl_info
=
253 sizeof (VikDEMLayerClass
),
254 NULL
, /* base_init */
255 NULL
, /* base_finalize */
256 NULL
, /* class init */
257 NULL
, /* class_finalize */
258 NULL
, /* class_data */
259 sizeof (VikDEMLayer
),
261 NULL
/* instance init */
263 vdl_type
= g_type_register_static ( VIK_LAYER_TYPE
, "VikDEMLayer", &vdl_info
, 0 );
269 static void dem_layer_marshall( VikDEMLayer
*vdl
, guint8
**data
, gint
*len
)
271 vik_layer_marshall_params ( VIK_LAYER(vdl
), data
, len
);
274 static VikDEMLayer
*dem_layer_unmarshall( guint8
*data
, gint len
, VikViewport
*vvp
)
276 VikDEMLayer
*rv
= vik_dem_layer_new ();
279 /* TODO: share GCS between layers */
280 for ( i
= 0; i
< DEM_N_HEIGHT_COLORS
; i
++ )
281 rv
->gcs
[i
] = vik_viewport_new_gc ( vvp
, dem_height_colors
[i
], rv
->line_thickness
);
283 for ( i
= 0; i
< DEM_N_GRADIENT_COLORS
; i
++ )
284 rv
->gcsgradient
[i
] = vik_viewport_new_gc ( vvp
, dem_gradient_colors
[i
], rv
->line_thickness
);
286 vik_layer_unmarshall_params ( VIK_LAYER(rv
), data
, len
, vvp
);
290 gboolean
dem_layer_set_param ( VikDEMLayer
*vdl
, guint16 id
, VikLayerParamData data
, VikViewport
*vp
)
294 case PARAM_COLOR
: if ( vdl
->color
) g_free ( vdl
->color
); vdl
->color
= g_strdup ( data
.s
); break;
295 case PARAM_SOURCE
: vdl
->source
= data
.u
; break;
296 case PARAM_TYPE
: vdl
->type
= data
.u
; break;
297 case PARAM_MIN_ELEV
: vdl
->min_elev
= data
.d
; break;
298 case PARAM_MAX_ELEV
: vdl
->max_elev
= data
.d
; break;
299 case PARAM_LINE_THICKNESS
: if ( data
.u
>= 1 && data
.u
<= 15 ) vdl
->line_thickness
= data
.u
; break;
300 case PARAM_FILES
: a_dems_load_list ( &(data
.sl
) ); a_dems_list_free ( vdl
->files
); vdl
->files
= data
.sl
; break;
305 static VikLayerParamData
dem_layer_get_param ( VikDEMLayer
*vdl
, guint16 id
)
307 VikLayerParamData rv
;
310 case PARAM_FILES
: rv
.sl
= vdl
->files
; break;
311 case PARAM_SOURCE
: rv
.u
= vdl
->source
; break;
312 case PARAM_TYPE
: rv
.u
= vdl
->type
; break;
313 case PARAM_COLOR
: rv
.s
= vdl
->color
? vdl
->color
: ""; break;
314 case PARAM_MIN_ELEV
: rv
.d
= vdl
->min_elev
; break;
315 case PARAM_MAX_ELEV
: rv
.d
= vdl
->max_elev
; break;
316 case PARAM_LINE_THICKNESS
: rv
.i
= vdl
->line_thickness
; break;
321 static void dem_layer_post_read ( VikLayer
*vl
, VikViewport
*vp
, gboolean from_file
)
323 VikDEMLayer
*vdl
= VIK_DEM_LAYER(vl
);
325 g_object_unref ( G_OBJECT(vdl
->gc
) );
327 vdl
->gc
= vik_viewport_new_gc ( vp
, vdl
->color
, vdl
->line_thickness
);
330 VikDEMLayer
*vik_dem_layer_new ( )
332 VikDEMLayer
*vdl
= VIK_DEM_LAYER ( g_object_new ( VIK_DEM_LAYER_TYPE
, NULL
) );
334 vik_layer_init ( VIK_LAYER(vdl
), VIK_LAYER_DEM
);
341 vdl
->gcs
= g_malloc(sizeof(GdkGC
*)*DEM_N_HEIGHT_COLORS
);
342 vdl
->gcsgradient
= g_malloc(sizeof(GdkGC
*)*DEM_N_GRADIENT_COLORS
);
343 /* make new gcs only if we need it (copy layer -> use old) */
346 vdl
->max_elev
= 1000.0;
347 vdl
->source
= DEM_SOURCE_SRTM
;
348 vdl
->type
= DEM_TYPE_HEIGHT
;
349 vdl
->line_thickness
= 3;
356 static void vik_dem_layer_draw_dem ( VikDEMLayer
*vdl
, VikViewport
*vp
, VikDEM
*dem
)
358 VikDEMColumn
*column
;
359 VikDEMColumn
*nextcolumn
;
361 struct LatLon dem_northeast
, dem_southwest
;
362 gdouble max_lat
, max_lon
, min_lat
, min_lon
;
364 /**** Check if viewport and DEM data overlap ****/
366 /* get min, max lat/lon of viewport */
367 vik_viewport_get_min_max_lat_lon ( vp
, &min_lat
, &max_lat
, &min_lon
, &max_lon
);
369 /* get min, max lat/lon of DEM data */
370 if ( dem
->horiz_units
== VIK_DEM_HORIZ_LL_ARCSECONDS
) {
371 dem_northeast
.lat
= dem
->max_north
/ 3600.0;
372 dem_northeast
.lon
= dem
->max_east
/ 3600.0;
373 dem_southwest
.lat
= dem
->min_north
/ 3600.0;
374 dem_southwest
.lon
= dem
->min_east
/ 3600.0;
375 } else if ( dem
->horiz_units
== VIK_DEM_HORIZ_UTM_METERS
) {
376 struct UTM dem_northeast_utm
, dem_southwest_utm
;
377 dem_northeast_utm
.northing
= dem
->max_north
;
378 dem_northeast_utm
.easting
= dem
->max_east
;
379 dem_southwest_utm
.northing
= dem
->min_north
;
380 dem_southwest_utm
.easting
= dem
->min_east
;
381 dem_northeast_utm
.zone
= dem_southwest_utm
.zone
= dem
->utm_zone
;
382 dem_northeast_utm
.letter
= dem_southwest_utm
.letter
= dem
->utm_letter
;
384 a_coords_utm_to_latlon(&dem_northeast_utm
, &dem_northeast
);
385 a_coords_utm_to_latlon(&dem_southwest_utm
, &dem_southwest
);
388 if ( (max_lat
> dem_northeast
.lat
&& min_lat
> dem_northeast
.lat
) ||
389 (max_lat
< dem_southwest
.lat
&& min_lat
< dem_southwest
.lat
) )
391 else if ( (max_lon
> dem_northeast
.lon
&& min_lon
> dem_northeast
.lon
) ||
392 (max_lon
< dem_southwest
.lon
&& min_lon
< dem_southwest
.lon
) )
394 /* else they overlap */
396 /**** End Overlap Check ****/
397 /* boxes to show where we have DEM instead of actually drawing the DEM.
398 * useful if we want to see what areas we have coverage for (if we want
399 * to get elevation data for a track) but don't want to cover the map.
403 /* draw a box if a DEM is loaded. in future I'd like to add an option for this
404 * this is useful if we want to see what areas we have dem for but don't want to
405 * cover the map (or maybe we just need translucent DEM?) */
407 VikCoord demne
, demsw
;
409 vik_coord_load_from_latlon(&demne
, vik_viewport_get_coord_mode(vp
), &dem_northeast
);
410 vik_coord_load_from_latlon(&demsw
, vik_viewport_get_coord_mode(vp
), &dem_southwest
);
412 vik_viewport_coord_to_screen ( vp
, &demne
, &x1
, &y1
);
413 vik_viewport_coord_to_screen ( vp
, &demsw
, &x2
, &y2
);
415 if ( x1
> vik_viewport_get_width(vp
) ) x1
=vik_viewport_get_width(vp
);
416 if ( y2
> vik_viewport_get_height(vp
) ) y2
=vik_viewport_get_height(vp
);
417 if ( x2
< 0 ) x2
= 0;
418 if ( y1
< 0 ) y1
= 0;
419 vik_viewport_draw_rectangle ( vp
, GTK_WIDGET(vp
)->style
->black_gc
,
420 FALSE
, x2
, y1
, x1
-x2
, y2
-y1
);
425 if ( dem
->horiz_units
== VIK_DEM_HORIZ_LL_ARCSECONDS
) {
426 VikCoord tmp
; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
428 gdouble max_lat_as
, max_lon_as
, min_lat_as
, min_lon_as
;
429 gdouble start_lat_as
, end_lat_as
, start_lon_as
, end_lon_as
;
431 gdouble start_lat
, end_lat
, start_lon
, end_lon
;
433 struct LatLon counter
;
435 guint x
, y
, start_x
, start_y
;
439 guint skip_factor
= ceil ( vik_viewport_get_xmpp(vp
) / 40 ); /* todo: smarter calculation. */
441 gdouble nscale_deg
= dem
->north_scale
/ ((gdouble
) 3600);
442 gdouble escale_deg
= dem
->east_scale
/ ((gdouble
) 3600);
444 max_lat_as
= max_lat
* 3600;
445 min_lat_as
= min_lat
* 3600;
446 max_lon_as
= max_lon
* 3600;
447 min_lon_as
= min_lon
* 3600;
449 start_lat_as
= MAX(min_lat_as
, dem
->min_north
);
450 end_lat_as
= MIN(max_lat_as
, dem
->max_north
);
451 start_lon_as
= MAX(min_lon_as
, dem
->min_east
);
452 end_lon_as
= MIN(max_lon_as
, dem
->max_east
);
454 start_lat
= floor(start_lat_as
/ dem
->north_scale
) * nscale_deg
;
455 end_lat
= ceil (end_lat_as
/ dem
->north_scale
) * nscale_deg
;
456 start_lon
= floor(start_lon_as
/ dem
->east_scale
) * escale_deg
;
457 end_lon
= ceil (end_lon_as
/ dem
->east_scale
) * escale_deg
;
459 vik_dem_east_north_to_xy ( dem
, start_lon_as
, start_lat_as
, &start_x
, &start_y
);
461 /* verify sane elev interval */
462 if ( vdl
->max_elev
<= vdl
->min_elev
)
463 vdl
->max_elev
= vdl
->min_elev
+ 1;
465 for ( x
=start_x
, counter
.lon
= start_lon
; counter
.lon
<= end_lon
; counter
.lon
+= escale_deg
* skip_factor
, x
+= skip_factor
) {
466 if ( x
> 0 && x
< dem
->n_columns
) {
467 column
= g_ptr_array_index ( dem
->columns
, x
);
468 if(x
+1 == dem
->n_columns
) {
469 nextcolumn
= g_ptr_array_index ( dem
->columns
, x
-1);
471 nextcolumn
= g_ptr_array_index ( dem
->columns
, x
+1);
474 for ( y
=start_y
, counter
.lat
= start_lat
; counter
.lat
<= end_lat
; counter
.lat
+= nscale_deg
* skip_factor
, y
+= skip_factor
) {
475 if ( y
> column
->n_points
)
477 elev
= column
->points
[y
];
479 if(vdl
->type
== DEM_TYPE_HEIGHT
) {
480 if ( elev
!= VIK_DEM_INVALID_ELEVATION
&& elev
< vdl
->min_elev
)
482 if ( elev
!= VIK_DEM_INVALID_ELEVATION
&& elev
> vdl
->max_elev
)
489 vik_coord_load_from_latlon(&tmp
, vik_viewport_get_coord_mode(vp
), &counter
);
490 vik_viewport_coord_to_screen(vp
, &tmp
, &a
, &b
);
491 if(vdl
->type
== DEM_TYPE_GRADIENT
) {
492 if( elev
== VIK_DEM_INVALID_ELEVATION
) {
495 // calculate gradient, but only in two orthogonal directions.
500 if(y
+1 == column
->n_points
)
501 newelev
= column
->points
[y
-1];
503 newelev
= column
->points
[y
+1];
504 if(newelev
!= VIK_DEM_INVALID_ELEVATION
)
505 change
+= abs(newelev
- elev
);
508 if(y
+1 == nextcolumn
->n_points
)
509 newelev
= nextcolumn
->points
[y
-1];
511 newelev
= nextcolumn
->points
[y
+1];
512 if(newelev
!= VIK_DEM_INVALID_ELEVATION
)
513 change
+= abs(newelev
- elev
);
516 newelev
= nextcolumn
->points
[y
];
517 if(newelev
!= VIK_DEM_INVALID_ELEVATION
)
518 change
+= abs(newelev
- elev
);
522 newelev
= nextcolumn
->points
[y
+1];
524 newelev
= nextcolumn
->points
[y
-1];
525 if(newelev
!= VIK_DEM_INVALID_ELEVATION
)
526 change
+= abs(newelev
- elev
);
528 change
= log(change
) * log(change
) * log(change
);
530 if(change
< vdl
->min_elev
)
531 change
= vdl
->min_elev
;
533 if(change
> vdl
->max_elev
)
534 change
= vdl
->max_elev
;
536 // void vik_viewport_draw_rectangle ( VikViewport *vvp, GdkGC *gc, gboolean filled, gint x1, gint y1, gint x2, gint y2 );
537 vik_viewport_draw_rectangle(vp
, vdl
->gcsgradient
[(gint
)floor((change
- vdl
->min_elev
)/(vdl
->max_elev
- vdl
->min_elev
)*(DEM_N_GRADIENT_COLORS
-2))+1], TRUE
, a
-2, b
-2, 4, 4 );
540 if(vdl
->type
== DEM_TYPE_HEIGHT
) {
541 if ( elev
== VIK_DEM_INVALID_ELEVATION
)
542 ; /* don't draw it */
543 else if ( elev
<= 0 )
544 vik_viewport_draw_rectangle(vp
, vdl
->gcs
[0], TRUE
, a
-2, b
-2, 4, 4 );
546 vik_viewport_draw_rectangle(vp
, vdl
->gcs
[(gint
)floor((elev
- vdl
->min_elev
)/(vdl
->max_elev
- vdl
->min_elev
)*(DEM_N_HEIGHT_COLORS
-2))+1], TRUE
, a
-2, b
-2, 4, 4 );
554 } else if ( dem
->horiz_units
== VIK_DEM_HORIZ_UTM_METERS
) {
555 gdouble max_nor
, max_eas
, min_nor
, min_eas
;
556 gdouble start_nor
, start_eas
, end_nor
, end_eas
;
560 guint x
, y
, start_x
, start_y
;
562 VikCoord tmp
; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
565 guint skip_factor
= ceil ( vik_viewport_get_xmpp(vp
) / 10 ); /* todo: smarter calculation. */
567 VikCoord tleft
, tright
, bleft
, bright
;
569 vik_viewport_screen_to_coord ( vp
, 0, 0, &tleft
);
570 vik_viewport_screen_to_coord ( vp
, vik_viewport_get_width(vp
), 0, &tright
);
571 vik_viewport_screen_to_coord ( vp
, 0, vik_viewport_get_height(vp
), &bleft
);
572 vik_viewport_screen_to_coord ( vp
, vik_viewport_get_width(vp
), vik_viewport_get_height(vp
), &bright
);
575 vik_coord_convert(&tleft
, VIK_COORD_UTM
);
576 vik_coord_convert(&tright
, VIK_COORD_UTM
);
577 vik_coord_convert(&bleft
, VIK_COORD_UTM
);
578 vik_coord_convert(&bright
, VIK_COORD_UTM
);
580 max_nor
= MAX(tleft
.north_south
, tright
.north_south
);
581 min_nor
= MIN(bleft
.north_south
, bright
.north_south
);
582 max_eas
= MAX(bright
.east_west
, tright
.east_west
);
583 min_eas
= MIN(bleft
.east_west
, tleft
.east_west
);
585 start_nor
= MAX(min_nor
, dem
->min_north
);
586 end_nor
= MIN(max_nor
, dem
->max_north
);
587 if ( tleft
.utm_zone
== dem
->utm_zone
&& bleft
.utm_zone
== dem
->utm_zone
588 && (tleft
.utm_letter
>= 'N') == (dem
->utm_letter
>= 'N')
589 && (bleft
.utm_letter
>= 'N') == (dem
->utm_letter
>= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
590 start_eas
= MAX(min_eas
, dem
->min_east
);
592 start_eas
= dem
->min_east
;
593 if ( tright
.utm_zone
== dem
->utm_zone
&& bright
.utm_zone
== dem
->utm_zone
594 && (tright
.utm_letter
>= 'N') == (dem
->utm_letter
>= 'N')
595 && (bright
.utm_letter
>= 'N') == (dem
->utm_letter
>= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
596 end_eas
= MIN(max_eas
, dem
->max_east
);
598 end_eas
= dem
->max_east
;
600 start_nor
= floor(start_nor
/ dem
->north_scale
) * dem
->north_scale
;
601 end_nor
= ceil (end_nor
/ dem
->north_scale
) * dem
->north_scale
;
602 start_eas
= floor(start_eas
/ dem
->east_scale
) * dem
->east_scale
;
603 end_eas
= ceil (end_eas
/ dem
->east_scale
) * dem
->east_scale
;
605 vik_dem_east_north_to_xy ( dem
, start_eas
, start_nor
, &start_x
, &start_y
);
607 /* TODO: why start_x and start_y are -1 -- rounding error from above? */
609 counter
.zone
= dem
->utm_zone
;
610 counter
.letter
= dem
->utm_letter
;
612 for ( x
=start_x
, counter
.easting
= start_eas
; counter
.easting
<= end_eas
; counter
.easting
+= dem
->east_scale
* skip_factor
, x
+= skip_factor
) {
613 if ( x
> 0 && x
< dem
->n_columns
) {
614 column
= g_ptr_array_index ( dem
->columns
, x
);
615 for ( y
=start_y
, counter
.northing
= start_nor
; counter
.northing
<= end_nor
; counter
.northing
+= dem
->north_scale
* skip_factor
, y
+= skip_factor
) {
616 if ( y
> column
->n_points
)
618 elev
= column
->points
[y
];
619 if ( elev
!= VIK_DEM_INVALID_ELEVATION
&& elev
< vdl
->min_elev
)
621 if ( elev
!= VIK_DEM_INVALID_ELEVATION
&& elev
> vdl
->max_elev
)
626 vik_coord_load_from_utm(&tmp
, vik_viewport_get_coord_mode(vp
), &counter
);
627 vik_viewport_coord_to_screen(vp
, &tmp
, &a
, &b
);
628 if ( elev
== VIK_DEM_INVALID_ELEVATION
)
629 ; /* don't draw it */
630 else if ( elev
<= 0 )
631 vik_viewport_draw_rectangle(vp
, vdl
->gcs
[0], TRUE
, a
-2, b
-2, 4, 4 );
633 vik_viewport_draw_rectangle(vp
, vdl
->gcs
[(gint
)floor((elev
- vdl
->min_elev
)/(vdl
->max_elev
- vdl
->min_elev
)*(DEM_N_HEIGHT_COLORS
-2))+1], TRUE
, a
-2, b
-2, 4, 4 );
641 /* return the continent for the specified lat, lon */
643 static const gchar
*srtm_continent_dir ( gint lat
, gint lon
)
645 extern const char *_srtm_continent_data
[];
646 static GHashTable
*srtm_continent
= NULL
;
647 const gchar
*continent
;
650 if (!srtm_continent
) {
653 srtm_continent
= g_hash_table_new(g_str_hash
, g_str_equal
);
654 s
= _srtm_continent_data
;
655 while (*s
!= (gchar
*)-1) {
658 g_hash_table_insert(srtm_continent
, (gpointer
) *s
, (gpointer
) continent
);
664 g_snprintf(name
, sizeof(name
), "%c%02d%c%03d",
665 (lat
>= 0) ? 'N' : 'S', ABS(lat
),
666 (lon
>= 0) ? 'E' : 'W', ABS(lon
));
668 return(g_hash_table_lookup(srtm_continent
, name
));
671 void vik_dem_layer_draw ( VikDEMLayer
*vdl
, gpointer data
)
673 VikViewport
*vp
= (VikViewport
*) data
;
674 GList
*dems_iter
= vdl
->files
;
678 /* search for SRTM3 90m */
680 if ( vdl
->source
== DEM_SOURCE_SRTM
)
681 srtm_draw_existence ( vp
);
682 #ifdef VIK_CONFIG_DEM24K
683 else if ( vdl
->source
== DEM_SOURCE_DEM24K
)
684 dem24k_draw_existence ( vp
);
687 while ( dems_iter
) {
688 dem
= a_dems_get ( (const char *) (dems_iter
->data
) );
690 vik_dem_layer_draw_dem ( vdl
, vp
, dem
);
691 dems_iter
= dems_iter
->next
;
695 void vik_dem_layer_free ( VikDEMLayer
*vdl
)
698 if ( vdl
->gc
!= NULL
)
699 g_object_unref ( G_OBJECT(vdl
->gc
) );
701 if ( vdl
->color
!= NULL
)
702 g_free ( vdl
->color
);
705 for ( i
= 0; i
< DEM_N_HEIGHT_COLORS
; i
++ )
706 g_object_unref ( vdl
->gcs
[i
] );
709 if ( vdl
->gcsgradient
)
710 for ( i
= 0; i
< DEM_N_GRADIENT_COLORS
; i
++ )
711 g_object_unref ( vdl
->gcsgradient
[i
] );
712 g_free ( vdl
->gcsgradient
);
714 a_dems_list_free ( vdl
->files
);
717 static void dem_layer_update_gc ( VikDEMLayer
*vdl
, VikViewport
*vp
, const gchar
*color
)
720 g_free ( vdl
->color
);
722 vdl
->color
= g_strdup ( color
);
725 g_object_unref ( G_OBJECT(vdl
->gc
) );
727 vdl
->gc
= vik_viewport_new_gc ( vp
, vdl
->color
, vdl
->line_thickness
);
730 VikDEMLayer
*vik_dem_layer_create ( VikViewport
*vp
)
732 VikDEMLayer
*vdl
= vik_dem_layer_new ();
735 /* TODO: share GCS between layers */
736 for ( i
= 0; i
< DEM_N_HEIGHT_COLORS
; i
++ )
737 vdl
->gcs
[i
] = vik_viewport_new_gc ( vp
, dem_height_colors
[i
], vdl
->line_thickness
);
739 for ( i
= 0; i
< DEM_N_GRADIENT_COLORS
; i
++ )
740 vdl
->gcsgradient
[i
] = vik_viewport_new_gc ( vp
, dem_gradient_colors
[i
], vdl
->line_thickness
);
742 dem_layer_update_gc ( vdl
, vp
, "red" );
745 /**************************************************************
746 **** SOURCES & DOWNLOADING
747 **************************************************************/
753 VikDEMLayer
*vdl
; /* NULL if not alive */
759 /**************************************************
761 **************************************************/
763 static void srtm_dem_download_thread ( DEMDownloadParams
*p
, gpointer threaddata
)
766 const gchar
*continent_dir
;
768 intlat
= (int)floor(p
->lat
);
769 intlon
= (int)floor(p
->lon
);
770 continent_dir
= srtm_continent_dir(intlat
, intlon
);
772 if (!continent_dir
) {
773 g_warning(N_("No SRTM data available for %f, %f"), p
->lat
, p
->lon
);
777 gchar
*src_fn
= g_strdup_printf("%s%s/%c%02d%c%03d.hgt.zip",
780 (intlat
>= 0) ? 'N' : 'S',
782 (intlon
>= 0) ? 'E' : 'W',
785 static DownloadOptions options
= { 0, NULL
, 0, a_check_map_file
};
786 a_http_download_get_url ( SRTM_HTTP_SITE
, src_fn
, p
->dest
, &options
);
790 static gchar
*srtm_lat_lon_to_dest_fn ( gdouble lat
, gdouble lon
)
793 const gchar
*continent_dir
;
795 intlat
= (int)floor(lat
);
796 intlon
= (int)floor(lon
);
797 continent_dir
= srtm_continent_dir(intlat
, intlon
);
800 continent_dir
= "nowhere";
802 return g_strdup_printf("srtm3-%s%s%c%02d%c%03d.hgt.zip",
805 (intlat
>= 0) ? 'N' : 'S',
807 (intlon
>= 0) ? 'E' : 'W',
812 /* TODO: generalize */
813 static void srtm_draw_existence ( VikViewport
*vp
)
815 gdouble max_lat
, max_lon
, min_lat
, min_lon
;
816 gchar buf
[strlen(MAPS_CACHE_DIR
)+strlen(SRTM_CACHE_TEMPLATE
)+30];
819 vik_viewport_get_min_max_lat_lon ( vp
, &min_lat
, &max_lat
, &min_lon
, &max_lon
);
821 for (i
= floor(min_lat
); i
<= floor(max_lat
); i
++) {
822 for (j
= floor(min_lon
); j
<= floor(max_lon
); j
++) {
823 const gchar
*continent_dir
;
824 if ((continent_dir
= srtm_continent_dir(i
, j
)) == NULL
)
826 g_snprintf(buf
, sizeof(buf
), SRTM_CACHE_TEMPLATE
,
830 (i
>= 0) ? 'N' : 'S',
832 (j
>= 0) ? 'E' : 'W',
834 if ( g_file_test(buf
, G_FILE_TEST_EXISTS
) == TRUE
) {
839 sw
.mode
= VIK_COORD_LATLON
;
840 ne
.north_south
= i
+1;
842 ne
.mode
= VIK_COORD_LATLON
;
843 vik_viewport_coord_to_screen ( vp
, &sw
, &x1
, &y1
);
844 vik_viewport_coord_to_screen ( vp
, &ne
, &x2
, &y2
);
845 if ( x1
< 0 ) x1
= 0;
846 if ( y2
< 0 ) y2
= 0;
847 vik_viewport_draw_rectangle ( vp
, GTK_WIDGET(vp
)->style
->black_gc
,
848 FALSE
, x1
, y2
, x2
-x1
, y1
-y2
);
855 /**************************************************
857 **************************************************/
859 #ifdef VIK_CONFIG_DEM24K
861 static void dem24k_dem_download_thread ( DEMDownloadParams
*p
, gpointer threaddata
)
864 gchar
*cmdline
= g_strdup_printf("%s %.03f %.03f",
865 DEM24K_DOWNLOAD_SCRIPT
,
868 /* FIX: don't use system, use execv or something. check for existence */
872 static gchar
*dem24k_lat_lon_to_dest_fn ( gdouble lat
, gdouble lon
)
874 return g_strdup_printf("dem24k/%d/%d/%.03f,%.03f.dem",
881 /* TODO: generalize */
882 static void dem24k_draw_existence ( VikViewport
*vp
)
884 gdouble max_lat
, max_lon
, min_lat
, min_lon
;
885 gchar buf
[strlen(MAPS_CACHE_DIR
)+40];
888 vik_viewport_get_min_max_lat_lon ( vp
, &min_lat
, &max_lat
, &min_lon
, &max_lon
);
890 for (i
= floor(min_lat
*8)/8; i
<= floor(max_lat
*8)/8; i
+=0.125) {
891 /* check lat dir first -- faster */
892 g_snprintf(buf
, sizeof(buf
), "%sdem24k/%d/",
895 if ( g_file_test(buf
, G_FILE_TEST_EXISTS
) == FALSE
)
897 for (j
= floor(min_lon
*8)/8; j
<= floor(max_lon
*8)/8; j
+=0.125) {
898 /* check lon dir first -- faster */
899 g_snprintf(buf
, sizeof(buf
), "%sdem24k/%d/%d/",
903 if ( g_file_test(buf
, G_FILE_TEST_EXISTS
) == FALSE
)
905 g_snprintf(buf
, sizeof(buf
), "%sdem24k/%d/%d/%.03f,%.03f.dem",
911 if ( g_file_test(buf
, G_FILE_TEST_EXISTS
) == TRUE
) {
915 sw
.east_west
= j
-0.125;
916 sw
.mode
= VIK_COORD_LATLON
;
917 ne
.north_south
= i
+0.125;
919 ne
.mode
= VIK_COORD_LATLON
;
920 vik_viewport_coord_to_screen ( vp
, &sw
, &x1
, &y1
);
921 vik_viewport_coord_to_screen ( vp
, &ne
, &x2
, &y2
);
922 if ( x1
< 0 ) x1
= 0;
923 if ( y2
< 0 ) y2
= 0;
924 vik_viewport_draw_rectangle ( vp
, GTK_WIDGET(vp
)->style
->black_gc
,
925 FALSE
, x1
, y2
, x2
-x1
, y1
-y2
);
932 /**************************************************
933 * SOURCES -- DOWNLOADING & IMPORTING TOOL *
934 **************************************************
937 static void weak_ref_cb ( gpointer ptr
, GObject
* dead_vdl
)
939 DEMDownloadParams
*p
= ptr
;
940 g_mutex_lock ( p
->mutex
);
942 g_mutex_unlock ( p
->mutex
);
945 /* Try to add file full_path.
946 * full_path will be copied.
947 * returns FALSE if file does not exists, TRUE otherwise.
949 static gboolean
dem_layer_add_file ( VikDEMLayer
*vdl
, const gchar
*full_path
)
951 if ( g_file_test(full_path
, G_FILE_TEST_EXISTS
) == TRUE
) {
952 /* only load if file size is not 0 (not in progress) */
954 stat (full_path
, &sb
);
956 gchar
*duped_path
= g_strdup(full_path
);
957 vdl
->files
= g_list_prepend ( vdl
->files
, duped_path
);
958 a_dems_load ( duped_path
);
959 g_debug("%s: %s", __FUNCTION__
, duped_path
);
960 vik_layer_emit_update ( VIK_LAYER(vdl
) );
967 static void dem_download_thread ( DEMDownloadParams
*p
, gpointer threaddata
)
969 if ( p
->source
== DEM_SOURCE_SRTM
)
970 srtm_dem_download_thread ( p
, threaddata
);
971 #ifdef VIK_CONFIG_DEM24K
972 else if ( p
->source
== DEM_SOURCE_DEM24K
)
973 dem24k_dem_download_thread ( p
, threaddata
);
977 g_mutex_lock ( p
->mutex
);
979 g_object_weak_unref ( G_OBJECT(p
->vdl
), weak_ref_cb
, p
);
981 if ( dem_layer_add_file ( p
->vdl
, p
->dest
) )
982 vik_layer_emit_update ( VIK_LAYER(p
->vdl
) );
984 g_mutex_unlock ( p
->mutex
);
989 static void free_dem_download_params ( DEMDownloadParams
*p
)
991 g_mutex_free ( p
->mutex
);
996 static gpointer
dem_layer_download_create ( VikWindow
*vw
, VikViewport
*vvp
)
1002 static gboolean
dem_layer_download_release ( VikDEMLayer
*vdl
, GdkEventButton
*event
, VikViewport
*vvp
)
1008 gchar
*dem_file
= NULL
;
1010 if ( vdl
->source
== DEM_SOURCE_NONE
)
1011 a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vdl
), _("No download source selected. Edit layer properties.") );
1013 vik_viewport_screen_to_coord ( vvp
, event
->x
, event
->y
, &coord
);
1014 vik_coord_to_latlon ( &coord
, &ll
);
1017 if ( vdl
->source
== DEM_SOURCE_SRTM
)
1018 dem_file
= srtm_lat_lon_to_dest_fn ( ll
.lat
, ll
.lon
);
1019 #ifdef VIK_CONFIG_DEM24K
1020 else if ( vdl
->source
== DEM_SOURCE_DEM24K
)
1021 dem_file
= dem24k_lat_lon_to_dest_fn ( ll
.lat
, ll
.lon
);
1027 full_path
= g_strdup_printf("%s%s", MAPS_CACHE_DIR
, dem_file
);
1029 g_debug("%s: %s", __FUNCTION__
, full_path
);
1031 // TODO: check if already in filelist
1033 if ( ! dem_layer_add_file(vdl
, full_path
) ) {
1034 gchar
*tmp
= g_strdup_printf ( _("Downloading DEM %s"), dem_file
);
1035 DEMDownloadParams
*p
= g_malloc(sizeof(DEMDownloadParams
));
1036 p
->dest
= g_strdup(full_path
);
1040 p
->mutex
= g_mutex_new();
1041 p
->source
= vdl
->source
;
1042 g_object_weak_ref(G_OBJECT(p
->vdl
), weak_ref_cb
, p
);
1044 a_background_thread ( VIK_GTK_WINDOW_FROM_LAYER(vdl
), tmp
,
1045 (vik_thr_func
) dem_download_thread
, p
,
1046 (vik_thr_free_func
) free_dem_download_params
, NULL
, 1 );
1049 g_free ( dem_file
);
1050 g_free ( full_path
);
1055 static gboolean
dem_layer_download_click ( VikDEMLayer
*vdl
, GdkEventButton
*event
, VikViewport
*vvp
)
1057 /* choose & keep track of cache dir
1058 * download in background thread
1059 * download over area */