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