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