#define SRTM_CACHE_TEMPLATE "%ssrtm3-%s%s%c%02d%c%03d.hgt.zip"
#define SRTM_HTTP_SITE "dds.cr.usgs.gov"
-#define SRTM_HTTP_URI "/srtm/version2_1/SRTM3/OLD/"
+#define SRTM_HTTP_URI "/srtm/version2_1/SRTM3/"
#ifdef VIK_CONFIG_DEM24K
#define DEM24K_DOWNLOAD_SCRIPT "dem24k.pl"
#endif
+#define UNUSED_LINE_THICKNESS 3
+static const gchar* dem_layer_tooltip( VikDEMLayer *vdl );
static void dem_layer_marshall( VikDEMLayer *vdl, guint8 **data, gint *len );
static VikDEMLayer *dem_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp );
-static gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp );
-static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id );
-static void dem_layer_update_gc ( VikDEMLayer *vdl, VikViewport *vp, const gchar *color );
+static gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation );
+static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id, gboolean is_file_operation );
static void dem_layer_post_read ( VikLayer *vl, VikViewport *vp, gboolean from_file );
static void srtm_draw_existence ( VikViewport *vp );
static void dem24k_draw_existence ( VikViewport *vp );
#endif
+/* Upped upper limit incase units are feet */
static VikLayerParamScale param_scales[] = {
- { 1, 10000, 10, 1 },
- { 1, 10000, 10, 1 },
- { 1, 10, 1, 0 },
+ { 0, 30000, 10, 1 },
+ { 1, 30000, 10, 1 },
};
static gchar *params_source[] = {
#ifdef VIK_CONFIG_DEM24K
"USA 10m (USGS 24k)",
#endif
- "None",
NULL
};
+static gchar *params_type[] = {
+ N_("Absolute height"),
+ N_("Height gradient"),
+ NULL
+};
+
enum { DEM_SOURCE_SRTM,
#ifdef VIK_CONFIG_DEM24K
DEM_SOURCE_DEM24K,
#endif
- DEM_SOURCE_NONE,
};
+enum { DEM_TYPE_HEIGHT = 0,
+ DEM_TYPE_GRADIENT,
+ DEM_TYPE_NONE,
+};
+
static VikLayerParam dem_layer_params[] = {
{ "files", VIK_LAYER_PARAM_STRING_LIST, VIK_LAYER_GROUP_NONE, N_("DEM Files:"), VIK_LAYER_WIDGET_FILELIST },
{ "source", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, N_("Download Source:"), VIK_LAYER_WIDGET_RADIOGROUP_STATIC, params_source, NULL },
- { "color", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("Color:"), VIK_LAYER_WIDGET_ENTRY },
+ { "color", VIK_LAYER_PARAM_COLOR, VIK_LAYER_GROUP_NONE, N_("Min Elev Color:"), VIK_LAYER_WIDGET_COLOR, 0 },
+ { "type", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, N_("Type:"), VIK_LAYER_WIDGET_RADIOGROUP_STATIC, params_type, NULL },
{ "min_elev", VIK_LAYER_PARAM_DOUBLE, VIK_LAYER_GROUP_NONE, N_("Min Elev:"), VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 0 },
{ "max_elev", VIK_LAYER_PARAM_DOUBLE, VIK_LAYER_GROUP_NONE, N_("Max Elev:"), VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 0 },
- { "line_thickness", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, N_("Line Thickness:"), VIK_LAYER_WIDGET_SPINBUTTON, param_scales + 1 },
};
-enum { PARAM_FILES=0, PARAM_SOURCE, PARAM_COLOR, PARAM_MIN_ELEV, PARAM_MAX_ELEV, PARAM_LINE_THICKNESS, NUM_PARAMS };
+enum { PARAM_FILES=0, PARAM_SOURCE, PARAM_COLOR, PARAM_TYPE, PARAM_MIN_ELEV, PARAM_MAX_ELEV, NUM_PARAMS };
static gpointer dem_layer_download_create ( VikWindow *vw, VikViewport *vvp);
static gboolean dem_layer_download_release ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp );
static gboolean dem_layer_download_click ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp );
static VikToolInterface dem_tools[] = {
- { N_("DEM Download/Import"), (VikToolConstructorFunc) dem_layer_download_create, NULL, NULL, NULL,
+ { { "DEMDownload", "vik-icon-DEM Download", N_("_DEM Download"), NULL, N_("DEM Download"), 0 },
+ (VikToolConstructorFunc) dem_layer_download_create, NULL, NULL, NULL,
(VikToolMouseFunc) dem_layer_download_click, NULL, (VikToolMouseFunc) dem_layer_download_release,
- (VikToolKeyFunc) NULL, GDK_CURSOR_IS_PIXMAP, &cursor_demdl_pixbuf },
+ (VikToolKeyFunc) NULL,
+ FALSE,
+ GDK_CURSOR_IS_PIXMAP, &cursor_demdl_pixbuf },
};
-/*
+/* HEIGHT COLORS
+ The first entry is blue for a default 'sea' colour,
+ however the value used by the corresponding gc can be configured as part of the DEM layer properties.
+ The other colours, shaded from brown to white are used to give an indication of height.
*/
-
-static gchar *dem_colors[] = {
+static gchar *dem_height_colors[] = {
"#0000FF",
-"#9b793c",
-"#9c7d40",
-"#9d8144",
-"#9e8549",
-"#9f894d",
-"#a08d51",
-"#a29156",
-"#a3955a",
-"#a4995e",
-"#a69d63",
-"#a89f65",
-"#aaa267",
-"#ada569",
-"#afa76b",
-"#b1aa6d",
-"#b4ad6f",
-"#b6b071",
-"#b9b373",
-"#bcb676",
-"#beb978",
-"#c0bc7a",
-"#c2c07d",
-"#c4c37f",
-"#c6c681",
-"#c8ca84",
-"#cacd86",
-"#ccd188",
-"#cfd58b",
-"#c2ce84",
-"#b5c87e",
-"#a9c278",
-"#9cbb71",
-"#8fb56b",
-"#83af65",
-"#76a95e",
-"#6aa358",
-"#5e9d52",
-"#63a055",
-"#69a458",
-"#6fa85c",
-"#74ac5f",
-"#7ab063",
-"#80b467",
-"#86b86a",
-"#8cbc6e",
-"#92c072",
-"#94c175",
-"#97c278",
-"#9ac47c",
-"#9cc57f",
-"#9fc682",
-"#a2c886",
-"#a4c989",
-"#a7cb8d",
-"#aacd91",
-"#afce99",
-"#b5d0a1",
-"#bbd2aa",
-"#c0d3b2",
-"#c6d5ba",
-"#ccd7c3",
-"#d1d9cb",
-"#d7dbd4",
-"#DDDDDD",
-"#e0e0e0",
-"#e4e4e4",
-"#e8e8e8",
-"#ebebeb",
-"#efefef",
-"#f3f3f3",
-"#f7f7f7",
-"#fbfbfb",
-"#ffffff"
+"#9b793c", "#9c7d40", "#9d8144", "#9e8549", "#9f894d", "#a08d51", "#a29156", "#a3955a", "#a4995e", "#a69d63",
+"#a89f65", "#aaa267", "#ada569", "#afa76b", "#b1aa6d", "#b4ad6f", "#b6b071", "#b9b373", "#bcb676", "#beb978",
+"#c0bc7a", "#c2c07d", "#c4c37f", "#c6c681", "#c8ca84", "#cacd86", "#ccd188", "#cfd58b", "#c2ce84", "#b5c87e",
+"#a9c278", "#9cbb71", "#8fb56b", "#83af65", "#76a95e", "#6aa358", "#5e9d52", "#63a055", "#69a458", "#6fa85c",
+"#74ac5f", "#7ab063", "#80b467", "#86b86a", "#8cbc6e", "#92c072", "#94c175", "#97c278", "#9ac47c", "#9cc57f",
+"#9fc682", "#a2c886", "#a4c989", "#a7cb8d", "#aacd91", "#afce99", "#b5d0a1", "#bbd2aa", "#c0d3b2", "#c6d5ba",
+"#ccd7c3", "#d1d9cb", "#d7dbd4", "#DDDDDD", "#e0e0e0", "#e4e4e4", "#e8e8e8", "#ebebeb", "#efefef", "#f3f3f3",
+"#f7f7f7", "#fbfbfb", "#ffffff"
};
+static const guint DEM_N_HEIGHT_COLORS = sizeof(dem_height_colors)/sizeof(dem_height_colors[0]);
+
/*
-"#9b793c",
-"#9e8549",
-"#a29156",
-"#a69d63",
-"#ada569",
-"#b4ad6f",
-"#bcb676",
-"#c2c07d",
-"#c8ca84",
-"#cfd58b",
-"#a9c278",
-"#83af65",
-"#5e9d52",
-"#6fa85c",
-"#80b467",
-"#92c072",
-"#9ac47c",
-"#a2c886",
-"#aacd91",
-"#bbd2aa",
-"#ccd7c3",
-"#DDDDDD",
-"#e8e8e8",
-"#f3f3f3",
-"#FFFFFF"
+"#9b793c", "#9e8549", "#a29156", "#a69d63", "#ada569", "#b4ad6f", "#bcb676", "#c2c07d", "#c8ca84", "#cfd58b",
+"#a9c278", "#83af65", "#5e9d52", "#6fa85c", "#80b467", "#92c072", "#9ac47c", "#a2c886", "#aacd91", "#bbd2aa",
+"#ccd7c3", "#DDDDDD", "#e8e8e8", "#f3f3f3", "#FFFFFF"
};
*/
-static const guint DEM_N_COLORS = sizeof(dem_colors)/sizeof(dem_colors[0]);
+static gchar *dem_gradient_colors[] = {
+"#AAAAAA",
+"#000000", "#000011", "#000022", "#000033", "#000044", "#00004c", "#000055", "#00005d", "#000066", "#00006e",
+"#000077", "#00007f", "#000088", "#000090", "#000099", "#0000a1", "#0000aa", "#0000b2", "#0000bb", "#0000c3",
+"#0000cc", "#0000d4", "#0000dd", "#0000e5", "#0000ee", "#0000f6", "#0000ff", "#0008f7", "#0011ee", "#0019e6",
+"#0022dd", "#002ad5", "#0033cc", "#003bc4", "#0044bb", "#004cb3", "#0055aa", "#005da2", "#006699", "#006e91",
+"#007788", "#007f80", "#008877", "#00906f", "#009966", "#00a15e", "#00aa55", "#00b24d", "#00bb44", "#00c33c",
+"#00cc33", "#00d42b", "#00dd22", "#00e51a", "#00ee11", "#00f609", "#00ff00", "#08f700", "#11ee00", "#19e600",
+"#22dd00", "#2ad500", "#33cc00", "#3bc400", "#44bb00", "#4cb300", "#55aa00", "#5da200", "#669900", "#6e9100",
+"#778800", "#7f8000", "#887700", "#906f00", "#996600", "#a15e00", "#aa5500", "#b24d00", "#bb4400", "#c33c00",
+"#cc3300", "#d42b00", "#dd2200", "#e51a00", "#ee1100", "#f60900", "#ff0000",
+"#FFFFFF"
+};
+
+static const guint DEM_N_GRADIENT_COLORS = sizeof(dem_gradient_colors)/sizeof(dem_gradient_colors[0]);
VikLayerInterface vik_dem_layer_interface = {
- "DEM",
+ N_("DEM"),
+ "<control><shift>D",
&vikdemlayer_pixbuf,
dem_tools,
(VikLayerFuncSublayerRenameRequest) NULL,
(VikLayerFuncSublayerToggleVisible) NULL,
+ (VikLayerFuncSublayerTooltip) NULL,
+ (VikLayerFuncLayerTooltip) dem_layer_tooltip,
+ (VikLayerFuncLayerSelected) NULL,
(VikLayerFuncMarshall) dem_layer_marshall,
(VikLayerFuncUnmarshall) dem_layer_unmarshall,
(VikLayerFuncWriteFileData) NULL,
(VikLayerFuncDeleteItem) NULL,
+ (VikLayerFuncCutItem) NULL,
(VikLayerFuncCopyItem) NULL,
(VikLayerFuncPasteItem) NULL,
(VikLayerFuncFreeCopiedItem) NULL,
(VikLayerFuncDragDropRequest) NULL,
+
+ (VikLayerFuncSelectClick) NULL,
+ (VikLayerFuncSelectMove) NULL,
+ (VikLayerFuncSelectRelease) NULL,
+ (VikLayerFuncSelectedViewportMenu) NULL,
};
struct _VikDEMLayer {
VikLayer vl;
- GdkGC *gc;
GdkGC **gcs;
+ GdkGC **gcsgradient;
GList *files;
gdouble min_elev;
gdouble max_elev;
- guint8 line_thickness;
- gchar *color;
+ GdkGC *color;
guint source;
+ guint type;
};
GType vik_dem_layer_get_type ()
return vdl_type;
}
+static const gchar* dem_layer_tooltip( VikDEMLayer *vdl )
+{
+ static gchar tmp_buf[100];
+ g_snprintf (tmp_buf, sizeof(tmp_buf), _("Number of files: %d"), g_list_length (vdl->files));
+ return tmp_buf;
+}
+
static void dem_layer_marshall( VikDEMLayer *vdl, guint8 **data, gint *len )
{
vik_layer_marshall_params ( VIK_LAYER(vdl), data, len );
gint i;
/* TODO: share GCS between layers */
- for ( i = 0; i < DEM_N_COLORS; i++ )
- rv->gcs[i] = vik_viewport_new_gc ( vvp, dem_colors[i], rv->line_thickness );
+ for ( i = 0; i < DEM_N_HEIGHT_COLORS; i++ )
+ rv->gcs[i] = vik_viewport_new_gc ( vvp, dem_height_colors[i], UNUSED_LINE_THICKNESS );
+
+ for ( i = 0; i < DEM_N_GRADIENT_COLORS; i++ )
+ rv->gcsgradient[i] = vik_viewport_new_gc ( vvp, dem_gradient_colors[i], UNUSED_LINE_THICKNESS );
vik_layer_unmarshall_params ( VIK_LAYER(rv), data, len, vvp );
return rv;
}
-gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp )
+/* Structure for DEM data used in background thread */
+typedef struct {
+ VikDEMLayer *vdl;
+} dem_load_thread_data;
+
+/*
+ * Function for starting the DEM file loading as a background thread
+ */
+static int dem_layer_load_list_thread ( dem_load_thread_data *dltd, gpointer threaddata )
+{
+ int result = 0; // Default to good
+ // Actual Load
+ if ( a_dems_load_list ( &(dltd->vdl->files), threaddata ) ) {
+ // Thread cancelled
+ result = -1;
+ }
+
+ // ATM as each file is processed the screen is not updated (no mechanism exposed to a_dems_load_list)
+ // Thus force draw only at the end, as loading is complete/aborted
+ //gdk_threads_enter();
+ // Test is helpful to prevent Gtk-CRITICAL warnings if the program is exitted whilst loading
+ if ( IS_VIK_LAYER(dltd->vdl) )
+ vik_layer_emit_update ( VIK_LAYER(dltd->vdl), TRUE ); // Yes update from background thread
+ //gdk_threads_leave();
+
+ return result;
+}
+
+static void dem_layer_thread_data_free ( dem_load_thread_data *data )
+{
+ // Simple release
+ g_free ( data );
+}
+
+static void dem_layer_thread_cancel ( dem_load_thread_data *data )
+{
+ // Abort loading
+ // Instead of freeing the list, leave it as partially processed
+ // Thus we can see/use what was done
+}
+
+gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation )
{
switch ( id )
{
- case PARAM_COLOR: if ( vdl->color ) g_free ( vdl->color ); vdl->color = g_strdup ( data.s ); break;
+ case PARAM_COLOR: gdk_gc_set_rgb_fg_color ( vdl->gcs[0], &(data.c) ); break;
case PARAM_SOURCE: vdl->source = data.u; break;
- case PARAM_MIN_ELEV: vdl->min_elev = data.d; break;
- case PARAM_MAX_ELEV: vdl->max_elev = data.d; break;
- case PARAM_LINE_THICKNESS: if ( data.u >= 1 && data.u <= 15 ) vdl->line_thickness = data.u; break;
- case PARAM_FILES: a_dems_load_list ( &(data.sl) ); a_dems_list_free ( vdl->files ); vdl->files = data.sl; break;
+ case PARAM_TYPE: vdl->type = data.u; break;
+ case PARAM_MIN_ELEV:
+ /* Convert to store internally
+ NB file operation always in internal units (metres) */
+ if (!is_file_operation && a_vik_get_units_height () == VIK_UNITS_HEIGHT_FEET )
+ vdl->min_elev = VIK_FEET_TO_METERS(data.d);
+ else
+ vdl->min_elev = data.d;
+ break;
+ case PARAM_MAX_ELEV:
+ /* Convert to store internally
+ NB file operation always in internal units (metres) */
+ if (!is_file_operation && a_vik_get_units_height () == VIK_UNITS_HEIGHT_FEET )
+ vdl->max_elev = VIK_FEET_TO_METERS(data.d);
+ else
+ vdl->max_elev = data.d;
+ break;
+ case PARAM_FILES:
+ {
+ // Clear out old settings - if any commonalities with new settings they will have to be read again
+ a_dems_list_free ( vdl->files );
+ // Set file list so any other intermediate screen drawing updates will show currently loaded DEMs by the working thread
+ vdl->files = data.sl;
+ // Thread Load
+ dem_load_thread_data *dltd = g_malloc ( sizeof(dem_load_thread_data) );
+ dltd->vdl = vdl;
+ dltd->vdl->files = data.sl;
+
+ a_background_thread ( VIK_GTK_WINDOW_FROM_WIDGET(vp),
+ _("DEM Loading"),
+ (vik_thr_func) dem_layer_load_list_thread,
+ dltd,
+ (vik_thr_free_func) dem_layer_thread_data_free,
+ (vik_thr_free_func) dem_layer_thread_cancel,
+ g_list_length ( data.sl ) ); // Number of DEM files
+ break;
+ }
}
return TRUE;
}
-static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id )
+static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id, gboolean is_file_operation )
{
VikLayerParamData rv;
switch ( id )
{
case PARAM_FILES: rv.sl = vdl->files; break;
case PARAM_SOURCE: rv.u = vdl->source; break;
- case PARAM_COLOR: rv.s = vdl->color ? vdl->color : ""; break;
- case PARAM_MIN_ELEV: rv.d = vdl->min_elev; break;
- case PARAM_MAX_ELEV: rv.d = vdl->max_elev; break;
- case PARAM_LINE_THICKNESS: rv.i = vdl->line_thickness; break;
+ case PARAM_TYPE: rv.u = vdl->type; break;
+ case PARAM_COLOR: vik_gc_get_fg_color ( vdl->gcs[0], &(rv.c) ); break;
+ case PARAM_MIN_ELEV:
+ /* Convert for display in desired units
+ NB file operation always in internal units (metres) */
+ if (!is_file_operation && a_vik_get_units_height () == VIK_UNITS_HEIGHT_FEET )
+ rv.d = VIK_METERS_TO_FEET(vdl->min_elev);
+ else
+ rv.d = vdl->min_elev;
+ break;
+ case PARAM_MAX_ELEV:
+ /* Convert for display in desired units
+ NB file operation always in internal units (metres) */
+ if (!is_file_operation && a_vik_get_units_height () == VIK_UNITS_HEIGHT_FEET )
+ rv.d = VIK_METERS_TO_FEET(vdl->max_elev);
+ else
+ rv.d = vdl->max_elev;
+ break;
}
return rv;
}
static void dem_layer_post_read ( VikLayer *vl, VikViewport *vp, gboolean from_file )
{
- VikDEMLayer *vdl = VIK_DEM_LAYER(vl);
- if ( vdl->gc )
- g_object_unref ( G_OBJECT(vdl->gc) );
-
- vdl->gc = vik_viewport_new_gc ( vp, vdl->color, vdl->line_thickness );
+ /* nothing ATM, but keep in case it's needed the future */
}
VikDEMLayer *vik_dem_layer_new ( )
vdl->files = NULL;
-
- vdl->gc = NULL;
-
- vdl->gcs = g_malloc(sizeof(GdkGC *)*DEM_N_COLORS);
+ vdl->gcs = g_malloc(sizeof(GdkGC *)*DEM_N_HEIGHT_COLORS);
+ vdl->gcsgradient = g_malloc(sizeof(GdkGC *)*DEM_N_GRADIENT_COLORS);
/* make new gcs only if we need it (copy layer -> use old) */
vdl->min_elev = 0.0;
vdl->max_elev = 1000.0;
vdl->source = DEM_SOURCE_SRTM;
- vdl->line_thickness = 3;
- vdl->color = NULL;
+ vdl->type = DEM_TYPE_HEIGHT;
return vdl;
}
+static inline guint16 get_height_difference(gint16 elev, gint16 new_elev)
+{
+ if(new_elev == VIK_DEM_INVALID_ELEVATION)
+ return 0;
+ else
+ return abs(new_elev - elev);
+}
+
static void vik_dem_layer_draw_dem ( VikDEMLayer *vdl, VikViewport *vp, VikDEM *dem )
{
- VikDEMColumn *column;
+ VikDEMColumn *column, *prevcolumn, *nextcolumn;
struct LatLon dem_northeast, dem_southwest;
- gdouble max_lat, max_lon, min_lat, min_lon;
+ gdouble max_lat, max_lon, min_lat, min_lon;
/**** Check if viewport and DEM data overlap ****/
gint16 elev;
- guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 40 ); /* todo: smarter calculation. */
+ guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 80 ); /* todo: smarter calculation. */
gdouble nscale_deg = dem->north_scale / ((gdouble) 3600);
gdouble escale_deg = dem->east_scale / ((gdouble) 3600);
end_lon = ceil (end_lon_as / dem->east_scale) * escale_deg;
vik_dem_east_north_to_xy ( dem, start_lon_as, start_lat_as, &start_x, &start_y );
+ guint gradient_skip_factor = 1;
+ if(vdl->type == DEM_TYPE_GRADIENT)
+ gradient_skip_factor = skip_factor;
/* verify sane elev interval */
if ( vdl->max_elev <= vdl->min_elev )
vdl->max_elev = vdl->min_elev + 1;
- for ( x=start_x, counter.lon = start_lon; counter.lon <= end_lon; counter.lon += escale_deg * skip_factor, x += skip_factor ) {
- if ( x > 0 && x < dem->n_columns ) {
+ for ( x=start_x, counter.lon = start_lon; counter.lon <= end_lon+escale_deg*skip_factor; counter.lon += escale_deg * skip_factor, x += skip_factor ) {
+ // NOTE: ( counter.lon <= end_lon + ESCALE_DEG*SKIP_FACTOR ) is neccessary so in high zoom modes,
+ // the leftmost column does also get drawn, if the center point is out of viewport.
+ if ( x >= 0 && x < dem->n_columns ) {
column = g_ptr_array_index ( dem->columns, x );
+ // get previous and next column. catch out-of-bound.
+ gint32 new_x = x;
+ new_x -= gradient_skip_factor;
+ if(new_x < 1)
+ prevcolumn = g_ptr_array_index ( dem->columns, x+1);
+ else
+ prevcolumn = g_ptr_array_index ( dem->columns, new_x);
+ new_x = x;
+ new_x += gradient_skip_factor;
+ if(new_x >= dem->n_columns)
+ nextcolumn = g_ptr_array_index ( dem->columns, x-1);
+ else
+ nextcolumn = g_ptr_array_index ( dem->columns, new_x);
+
for ( y=start_y, counter.lat = start_lat; counter.lat <= end_lat; counter.lat += nscale_deg * skip_factor, y += skip_factor ) {
if ( y > column->n_points )
break;
- elev = column->points[y];
- if ( elev != VIK_DEM_INVALID_ELEVATION && elev < vdl->min_elev )
- elev=vdl->min_elev;
- if ( elev != VIK_DEM_INVALID_ELEVATION && elev > vdl->max_elev )
- elev=vdl->max_elev;
+ elev = column->points[y];
+ // calculate bounding box for drawing
+ gint box_x, box_y, box_width, box_height;
+ struct LatLon box_c;
+ box_c = counter;
+ box_c.lat += (nscale_deg * skip_factor)/2;
+ box_c.lon -= (escale_deg * skip_factor)/2;
+ vik_coord_load_from_latlon(&tmp, vik_viewport_get_coord_mode(vp), &box_c);
+ vik_viewport_coord_to_screen(vp, &tmp, &box_x, &box_y);
+ // catch box at borders
+ if(box_x < 0)
+ box_x = 0;
+ if(box_y < 0)
+ box_y = 0;
+ box_c.lat -= nscale_deg * skip_factor;
+ box_c.lon += escale_deg * skip_factor;
+ vik_coord_load_from_latlon(&tmp, vik_viewport_get_coord_mode(vp), &box_c);
+ vik_viewport_coord_to_screen(vp, &tmp, &box_width, &box_height);
+ box_width -= box_x;
+ box_height -= box_y;
+ // catch box at borders
+ if(box_width < 0 || box_height < 0)
+ continue; // skip this. this is out of our viewport anyway. FIXME: why?
+
+ gboolean below_minimum = FALSE;
+ if(vdl->type == DEM_TYPE_HEIGHT) {
+ if ( elev != VIK_DEM_INVALID_ELEVATION && elev < vdl->min_elev ) {
+ // Prevent 'elev - vdl->min_elev' from being negative so can safely use as array index
+ elev = ceil ( vdl->min_elev );
+ below_minimum = TRUE;
+ }
+ if ( elev != VIK_DEM_INVALID_ELEVATION && elev > vdl->max_elev )
+ elev = vdl->max_elev;
+ }
{
- gint a, b;
-
- vik_coord_load_from_latlon(&tmp, vik_viewport_get_coord_mode(vp), &counter);
- vik_viewport_coord_to_screen(vp, &tmp, &a, &b);
- if ( elev == VIK_DEM_INVALID_ELEVATION )
- ; /* don't draw it */
- else if ( elev <= 0 )
- vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-2, b-2, 4, 4 );
- else
- 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 );
+ if(box_width < 0 || box_height < 0) // FIXME: why does this happen?
+ continue;
+
+ if(vdl->type == DEM_TYPE_GRADIENT) {
+ if( elev == VIK_DEM_INVALID_ELEVATION ) {
+ /* don't draw it */
+ } else {
+ // calculate and sum gradient in all directions
+ gint16 change = 0;
+ gint32 new_y;
+
+ // calculate gradient from height points all around the current one
+ new_y = y - gradient_skip_factor;
+ if(new_y < 0)
+ new_y = y;
+ change += get_height_difference(elev, prevcolumn->points[new_y]);
+ change += get_height_difference(elev, column->points[new_y]);
+ change += get_height_difference(elev, nextcolumn->points[new_y]);
+
+ change += get_height_difference(elev, prevcolumn->points[y]);
+ change += get_height_difference(elev, nextcolumn->points[y]);
+
+ new_y = y + gradient_skip_factor;
+ if(new_y >= column->n_points)
+ new_y = y;
+ change += get_height_difference(elev, prevcolumn->points[new_y]);
+ change += get_height_difference(elev, column->points[new_y]);
+ change += get_height_difference(elev, nextcolumn->points[new_y]);
+
+ change = change / ((skip_factor > 1) ? log(skip_factor) : 0.55); // FIXME: better calc.
+
+ if(change < vdl->min_elev)
+ // Prevent 'change - vdl->min_elev' from being negative so can safely use as array index
+ change = ceil ( vdl->min_elev );
+
+ if(change > vdl->max_elev)
+ change = vdl->max_elev;
+
+ // void vik_viewport_draw_rectangle ( VikViewport *vvp, GdkGC *gc, gboolean filled, gint x1, gint y1, gint x2, gint y2 );
+ vik_viewport_draw_rectangle(vp, vdl->gcsgradient[(gint)floor(((change - vdl->min_elev)/(vdl->max_elev - vdl->min_elev))*(DEM_N_GRADIENT_COLORS-2))+1], TRUE, box_x, box_y, box_width, box_height);
+ }
+ } else {
+ if(vdl->type == DEM_TYPE_HEIGHT) {
+ if ( elev == VIK_DEM_INVALID_ELEVATION )
+ ; /* don't draw it */
+ else if ( elev <= 0 || below_minimum )
+ /* If 'sea' colour or below the defined mininum draw in the configurable colour */
+ vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, box_x, box_y, box_width, box_height);
+ else
+ vik_viewport_draw_rectangle(vp, vdl->gcs[(gint)floor(((elev - vdl->min_elev)/(vdl->max_elev - vdl->min_elev))*(DEM_N_HEIGHT_COLORS-2))+1], TRUE, box_x, box_y, box_width, box_height);
+ }
+ }
}
} /* for y= */
}
if ( elev == VIK_DEM_INVALID_ELEVATION )
; /* don't draw it */
else if ( elev <= 0 )
- vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-2, b-2, 4, 4 );
+ vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-1, b-1, 2, 2 );
else
- 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 );
+ vik_viewport_draw_rectangle(vp, vdl->gcs[(gint)floor((elev - vdl->min_elev)/(vdl->max_elev - vdl->min_elev)*(DEM_N_HEIGHT_COLORS-2))+1], TRUE, a-1, b-1, 2, 2 );
}
} /* for y= */
}
void vik_dem_layer_free ( VikDEMLayer *vdl )
{
gint i;
- if ( vdl->gc != NULL )
- g_object_unref ( G_OBJECT(vdl->gc) );
-
if ( vdl->color != NULL )
- g_free ( vdl->color );
+ g_object_unref ( vdl->color );
if ( vdl->gcs )
- for ( i = 0; i < DEM_N_COLORS; i++ )
+ for ( i = 0; i < DEM_N_HEIGHT_COLORS; i++ )
g_object_unref ( vdl->gcs[i] );
g_free ( vdl->gcs );
- a_dems_list_free ( vdl->files );
-}
+ if ( vdl->gcsgradient )
+ for ( i = 0; i < DEM_N_GRADIENT_COLORS; i++ )
+ g_object_unref ( vdl->gcsgradient[i] );
+ g_free ( vdl->gcsgradient );
-static void dem_layer_update_gc ( VikDEMLayer *vdl, VikViewport *vp, const gchar *color )
-{
- if ( vdl->color )
- g_free ( vdl->color );
-
- vdl->color = g_strdup ( color );
-
- if ( vdl->gc )
- g_object_unref ( G_OBJECT(vdl->gc) );
-
- vdl->gc = vik_viewport_new_gc ( vp, vdl->color, vdl->line_thickness );
+ a_dems_list_free ( vdl->files );
}
VikDEMLayer *vik_dem_layer_create ( VikViewport *vp )
gint i;
/* TODO: share GCS between layers */
- for ( i = 0; i < DEM_N_COLORS; i++ )
- vdl->gcs[i] = vik_viewport_new_gc ( vp, dem_colors[i], vdl->line_thickness );
+ for ( i = 0; i < DEM_N_HEIGHT_COLORS; i++ )
+ vdl->gcs[i] = vik_viewport_new_gc ( vp, dem_height_colors[i], UNUSED_LINE_THICKNESS );
+
+ for ( i = 0; i < DEM_N_GRADIENT_COLORS; i++ )
+ vdl->gcsgradient[i] = vik_viewport_new_gc ( vp, dem_gradient_colors[i], UNUSED_LINE_THICKNESS );
- dem_layer_update_gc ( vdl, vp, "red" );
return vdl;
}
/**************************************************************
(intlon >= 0) ? 'E' : 'W',
ABS(intlon) );
- static DownloadOptions options = { NULL, 0, a_check_map_file };
- a_http_download_get_url ( SRTM_HTTP_SITE, src_fn, p->dest, &options );
+ static DownloadMapOptions options = { FALSE, FALSE, NULL, 0, a_check_map_file };
+ a_http_download_get_url ( SRTM_HTTP_SITE, src_fn, p->dest, &options, NULL );
g_free ( src_fn );
}
ceil(p->lon*8)/8 );
/* FIX: don't use system, use execv or something. check for existence */
system(cmdline);
+ g_free ( cmdline );
}
static gchar *dem24k_lat_lon_to_dest_fn ( gdouble lat, gdouble lon )
vdl->files = g_list_prepend ( vdl->files, duped_path );
a_dems_load ( duped_path );
g_debug("%s: %s", __FUNCTION__, duped_path);
- vik_layer_emit_update ( VIK_LAYER(vdl) );
}
return TRUE;
} else
else if ( p->source == DEM_SOURCE_DEM24K )
dem24k_dem_download_thread ( p, threaddata );
#endif
+ else
+ return;
- gdk_threads_enter();
+ //gdk_threads_enter();
g_mutex_lock ( p->mutex );
if ( p->vdl ) {
g_object_weak_unref ( G_OBJECT(p->vdl), weak_ref_cb, p );
if ( dem_layer_add_file ( p->vdl, p->dest ) )
- vik_layer_emit_update ( VIK_LAYER(p->vdl) );
+ vik_layer_emit_update ( VIK_LAYER(p->vdl), TRUE ); // Yes update from background thread
}
g_mutex_unlock ( p->mutex );
- gdk_threads_leave();
+ //gdk_threads_leave();
}
gchar *full_path;
gchar *dem_file = NULL;
- if ( vdl->source == DEM_SOURCE_NONE )
- a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vdl), _("No download source selected. Edit layer properties.") );
-
vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord );
vik_coord_to_latlon ( &coord, &ll );
a_background_thread ( VIK_GTK_WINDOW_FROM_LAYER(vdl), tmp,
(vik_thr_func) dem_download_thread, p,
(vik_thr_free_func) free_dem_download_params, NULL, 1 );
+
+ g_free ( tmp );
}
+ else
+ vik_layer_emit_update ( VIK_LAYER(vdl), FALSE );
g_free ( dem_file );
g_free ( full_path );
projects / andy / viking.git / blobdiff