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