/** * Process selected files and try to generate waypoints storing them in the given vtl */ static gboolean datasource_geotag_process ( VikTrwLayer *vtl, ProcessOptions *po, BabelStatusFunc status_cb, acq_dialog_widgets_t *adw, gpointer not_used ) { datasource_geotag_user_data_t *user_data = (datasource_geotag_user_data_t *)adw->user_data; // Process selected files // In prinicple this loading should be quite fast and so don't need to have any progress monitoring GSList *cur_file = user_data->filelist; while ( cur_file ) { gchar *filename = cur_file->data; gchar *name; VikWaypoint *wp = a_geotag_create_waypoint_from_file ( filename, vik_viewport_get_coord_mode ( adw->vvp ), &name ); if ( wp ) { // Create name if geotag method didn't return one if ( !name ) name = g_strdup ( a_file_basename ( filename ) ); vik_trw_layer_filein_add_waypoint ( vtl, name, wp ); g_free ( name ); } else { gchar* msg = g_strdup_printf ( _("Unable to create waypoint from %s"), filename ); vik_window_statusbar_update ( adw->vw, msg, VIK_STATUSBAR_INFO ); g_free (msg); } g_free ( filename ); cur_file = g_slist_next ( cur_file ); } /* Free memory */ g_slist_free ( user_data->filelist ); // No failure return TRUE; }
VikGeorefLayer *vik_georef_layer_create ( VikViewport *vp, VikLayersPanel *vlp, const gchar *name, GdkPixbuf *pixbuf, VikCoord *coord_tl, VikCoord *coord_br ) { VikGeorefLayer *vgl = georef_layer_new ( vp ); vik_layer_rename ( VIK_LAYER(vgl), name ); vgl->pixbuf = pixbuf; vik_coord_to_utm ( coord_tl, &(vgl->corner) ); vik_coord_to_latlon ( coord_br, &(vgl->ll_br) ); if ( vgl->pixbuf ) { vgl->width = gdk_pixbuf_get_width ( vgl->pixbuf ); vgl->height = gdk_pixbuf_get_height ( vgl->pixbuf ); if ( vgl->width > 0 && vgl->height > 0 ) { struct LatLon ll_tl; vik_coord_to_latlon ( coord_tl, &ll_tl); struct LatLon ll_br; vik_coord_to_latlon ( coord_br, &ll_br); VikCoordMode mode = vik_viewport_get_coord_mode (vp); gdouble xmpp, ympp; georef_layer_mpp_from_coords ( mode, ll_tl, ll_br, vgl->width, vgl->height, &xmpp, &ympp ); vgl->mpp_easting = xmpp; vgl->mpp_northing = ympp; goto_center_ll ( vp, ll_tl, ll_br); // Set best zoom level struct LatLon maxmin[2] = { ll_tl, ll_br }; vu_zoom_to_show_latlons ( vik_viewport_get_coord_mode(vp), vp, maxmin ); return vgl; } } // Bad image georef_layer_free ( vgl ); return NULL; }
static void georef_layer_draw ( VikGeorefLayer *vgl, VikViewport *vp ) { if ( vik_viewport_get_drawmode(vp) != VIK_VIEWPORT_DRAWMODE_UTM ) return; if ( vgl->pixbuf ) { struct UTM utm_middle; gdouble xmpp = vik_viewport_get_xmpp(vp), ympp = vik_viewport_get_ympp(vp); GdkPixbuf *pixbuf = vgl->pixbuf; guint layer_width = vgl->width; guint layer_height = vgl->height; vik_coord_to_utm ( vik_viewport_get_center ( vp ), &utm_middle ); /* scale the pixbuf if it doesn't match our dimensions */ if ( xmpp != vgl->mpp_easting || ympp != vgl->mpp_northing ) { layer_width = round(vgl->width * vgl->mpp_easting / xmpp); layer_height = round(vgl->height * vgl->mpp_northing / ympp); /* rescale if necessary */ if (layer_width == vgl->scaled_width && layer_height == vgl->scaled_height && vgl->scaled != NULL) pixbuf = vgl->scaled; else { pixbuf = gdk_pixbuf_scale_simple( vgl->pixbuf, layer_width, layer_height, GDK_INTERP_BILINEAR ); if (vgl->scaled != NULL) g_object_unref(vgl->scaled); vgl->scaled = pixbuf; vgl->scaled_width = layer_width; vgl->scaled_height = layer_height; } } guint width = vik_viewport_get_width(vp), height = vik_viewport_get_height(vp); gint32 x, y; vgl->corner.zone = utm_middle.zone; vgl->corner.letter = utm_middle.letter; VikCoord corner_coord; vik_coord_load_from_utm ( &corner_coord, vik_viewport_get_coord_mode(vp), &(vgl->corner) ); vik_viewport_coord_to_screen ( vp, &corner_coord, &x, &y ); if ( (x < 0 || x < width) && (y < 0 || y < height) && x+layer_width > 0 && y+layer_height > 0 ) vik_viewport_draw_pixbuf ( vp, pixbuf, 0, 0, x, y, layer_width, layer_height ); /* todo: draw only what we need to. */ } }
static void georef_layer_draw ( VikGeorefLayer *vgl, VikViewport *vp ) { if ( vgl->pixbuf ) { gdouble xmpp = vik_viewport_get_xmpp(vp), ympp = vik_viewport_get_ympp(vp); GdkPixbuf *pixbuf = vgl->pixbuf; guint layer_width = vgl->width; guint layer_height = vgl->height; guint width = vik_viewport_get_width(vp), height = vik_viewport_get_height(vp); gint32 x, y; VikCoord corner_coord; vik_coord_load_from_utm ( &corner_coord, vik_viewport_get_coord_mode(vp), &(vgl->corner) ); vik_viewport_coord_to_screen ( vp, &corner_coord, &x, &y ); /* mark to scale the pixbuf if it doesn't match our dimensions */ gboolean scale = FALSE; if ( xmpp != vgl->mpp_easting || ympp != vgl->mpp_northing ) { scale = TRUE; layer_width = round(vgl->width * vgl->mpp_easting / xmpp); layer_height = round(vgl->height * vgl->mpp_northing / ympp); } // If image not in viewport bounds - no need to draw it (or bother with any scaling) if ( (x < 0 || x < width) && (y < 0 || y < height) && x+layer_width > 0 && y+layer_height > 0 ) { if ( scale ) { /* rescale if necessary */ if (layer_width == vgl->scaled_width && layer_height == vgl->scaled_height && vgl->scaled != NULL) pixbuf = vgl->scaled; else { pixbuf = gdk_pixbuf_scale_simple( vgl->pixbuf, layer_width, layer_height, GDK_INTERP_BILINEAR ); if (vgl->scaled != NULL) g_object_unref(vgl->scaled); vgl->scaled = pixbuf; vgl->scaled_width = layer_width; vgl->scaled_height = layer_height; } } vik_viewport_draw_pixbuf ( vp, pixbuf, 0, 0, x, y, layer_width, layer_height ); /* todo: draw only what we need to. */ } } }
static void goto_center_ll ( VikViewport *vp, struct LatLon ll_tl, struct LatLon ll_br ) { VikCoord vc_center; struct LatLon ll_center; ll_center.lat = (ll_tl.lat + ll_br.lat) / 2.0; ll_center.lon = (ll_tl.lon + ll_br.lon) / 2.0; vik_coord_load_from_latlon ( &vc_center, vik_viewport_get_coord_mode (vp), &ll_center ); vik_viewport_set_center_coord ( vp, &vc_center, TRUE ); }
static void datasource_gc_draw_circle ( datasource_gc_widgets_t *widgets ) { gdouble lat, lon; if ( widgets->circle_onscreen ) { vik_viewport_draw_arc ( widgets->vvp, widgets->circle_gc, FALSE, widgets->circle_x - widgets->circle_width/2, widgets->circle_y - widgets->circle_width/2, widgets->circle_width, widgets->circle_width, 0, 360*64 ); } /* calculate widgets circle_x and circle_y */ /* split up lat,lon into lat and lon */ if ( 2 == sscanf ( gtk_entry_get_text ( GTK_ENTRY(widgets->center_entry) ), "%lf,%lf", &lat, &lon ) ) { struct LatLon ll; VikCoord c; gint x, y; ll.lat = lat; ll.lon = lon; vik_coord_load_from_latlon ( &c, vik_viewport_get_coord_mode ( widgets->vvp ), &ll ); vik_viewport_coord_to_screen ( widgets->vvp, &c, &x, &y ); /* TODO: real calculation */ if ( x > -1000 && y > -1000 && x < (vik_viewport_get_width(widgets->vvp) + 1000) && y < (vik_viewport_get_width(widgets->vvp) + 1000) ) { VikCoord c1, c2; gdouble pixels_per_meter; widgets->circle_x = x; widgets->circle_y = y; /* determine miles per pixel */ vik_viewport_screen_to_coord ( widgets->vvp, 0, vik_viewport_get_height(widgets->vvp)/2, &c1 ); vik_viewport_screen_to_coord ( widgets->vvp, vik_viewport_get_width(widgets->vvp), vik_viewport_get_height(widgets->vvp)/2, &c2 ); pixels_per_meter = ((gdouble)vik_viewport_get_width(widgets->vvp)) / vik_coord_diff(&c1, &c2); /* this is approximate */ widgets->circle_width = gtk_spin_button_get_value_as_float ( GTK_SPIN_BUTTON(widgets->miles_radius_spin) ) * METERSPERMILE * pixels_per_meter * 2; vik_viewport_draw_arc ( widgets->vvp, widgets->circle_gc, FALSE, widgets->circle_x - widgets->circle_width/2, widgets->circle_y - widgets->circle_width/2, widgets->circle_width, widgets->circle_width, 0, 360*64 ); widgets->circle_onscreen = TRUE; } else widgets->circle_onscreen = FALSE; } /* see if onscreen */ /* okay */ vik_viewport_sync ( widgets->vvp ); }
/** * vik_layers_panel_add_layer: * @l: existing layer * * Add an existing layer to panel. */ void vik_layers_panel_add_layer ( VikLayersPanel *vlp, VikLayer *l ) { GtkTreeIter iter; GtkTreeIter *replace_iter = NULL; /* could be something different so we have to do this */ vik_layer_change_coord_mode ( l, vik_viewport_get_coord_mode(vlp->vvp) ); if ( ! vik_treeview_get_selected_iter ( vlp->vt, &iter ) ) vik_aggregate_layer_add_layer ( vlp->toplayer, l ); else { VikAggregateLayer *addtoagg; if (vik_treeview_item_get_type ( vlp->vt, &iter ) == VIK_TREEVIEW_TYPE_LAYER ) { if ( IS_VIK_AGGREGATE_LAYER(vik_treeview_item_get_pointer ( vlp->vt, &iter )) ) addtoagg = VIK_AGGREGATE_LAYER(vik_treeview_item_get_pointer ( vlp->vt, &iter )); else { VikLayer *vl = VIK_LAYER(vik_treeview_item_get_parent ( vlp->vt, &iter )); while ( ! IS_VIK_AGGREGATE_LAYER(vl) ) { iter = vl->iter; vl = VIK_LAYER(vik_treeview_item_get_parent ( vlp->vt, &vl->iter )); g_assert ( vl->realized ); } addtoagg = VIK_AGGREGATE_LAYER(vl); replace_iter = &iter; } } else { /* a sublayer is selected, first get its parent (layer), then find the layer's parent (aggr. layer) */ VikLayer *vl = VIK_LAYER(vik_treeview_item_get_parent ( vlp->vt, &iter )); replace_iter = &(vl->iter); g_assert ( vl->realized ); VikLayer *grandpa = (vik_treeview_item_get_parent ( vlp->vt, &(vl->iter) ) ); if (IS_VIK_AGGREGATE_LAYER(grandpa)) addtoagg = VIK_AGGREGATE_LAYER(grandpa); else { addtoagg = vlp->toplayer; replace_iter = &grandpa->iter; } } if ( replace_iter ) vik_aggregate_layer_insert_layer ( addtoagg, l, replace_iter ); else vik_aggregate_layer_add_layer ( addtoagg, l ); } vik_layers_panel_emit_update ( vlp ); }
/** * Load a single JPG into a Trackwaypoint Layer as a waypoint * * @top: The Aggregate layer that a new TRW layer may be created in * @filename: The JPG filename * @vvp: The viewport * * Returns: Whether the loading was a success or not * * If the JPG has geotag information then the waypoint will be created with the appropriate position. * Otherwise the waypoint will be positioned at the current screen center. * If a TRW layer is already selected the waypoint will be created in that layer. */ gboolean a_jpg_load_file ( VikAggregateLayer *top, const gchar *filename, VikViewport *vvp ) { gboolean auto_zoom = TRUE; VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(top))); VikLayersPanel *vlp = vik_window_layers_panel ( vw ); // Auto load into TrackWaypoint layer if one is selected VikLayer *vtl = vik_layers_panel_get_selected ( vlp ); gboolean create_layer = FALSE; if ( vtl == NULL || vtl->type != VIK_LAYER_TRW ) { // Create layer if necessary vtl = vik_layer_create ( VIK_LAYER_TRW, vvp, FALSE ); vik_layer_rename ( vtl, a_file_basename ( filename ) ); create_layer = TRUE; } gchar *name = NULL; VikWaypoint *wp = NULL; #ifdef VIK_CONFIG_GEOTAG wp = a_geotag_create_waypoint_from_file ( filename, vik_viewport_get_coord_mode (vvp), &name ); #endif if ( wp ) { // Create name if geotag method didn't return one if ( !name ) name = g_strdup ( a_file_basename ( filename ) ); vik_trw_layer_filein_add_waypoint ( VIK_TRW_LAYER(vtl), name, wp ); g_free ( name ); } else { wp = vik_waypoint_new (); wp->visible = TRUE; vik_trw_layer_filein_add_waypoint ( VIK_TRW_LAYER(vtl), (gchar*) a_file_basename(filename), wp ); vik_waypoint_set_image ( wp, filename ); // Simply set position to the current center wp->coord = *( vik_viewport_get_center ( vvp ) ); auto_zoom = FALSE; } // Complete the setup vik_layer_post_read ( vtl, vvp, TRUE ); if ( create_layer ) vik_aggregate_layer_add_layer ( top, vtl, FALSE ); if ( auto_zoom ) vik_trw_layer_auto_set_view ( VIK_TRW_LAYER(vtl), vvp ); // ATM This routine can't fail return TRUE; }
static void georef_layer_goto_center ( gpointer vgl_vlp[2] ) { VikGeorefLayer *vgl = VIK_GEOREF_LAYER ( vgl_vlp[0] ); VikViewport *vp = vik_layers_panel_get_viewport(VIK_LAYERS_PANEL(vgl_vlp[1])); struct UTM utm; VikCoord coord; vik_coord_to_utm ( vik_viewport_get_center ( vp ), &utm ); utm.easting = vgl->corner.easting + (vgl->width * vgl->mpp_easting / 2); /* only an approximation */ utm.northing = vgl->corner.northing - (vgl->height * vgl->mpp_northing / 2); vik_coord_load_from_utm ( &coord, vik_viewport_get_coord_mode ( vp ), &utm ); vik_viewport_set_center_coord ( vp, &coord ); vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vgl_vlp[1]) ); }
static int geonames_search_get_coord(VikWindow *vw, VikViewport *vvp, gchar *srch_str, VikCoord *coord) { gchar *uri; gchar *escaped_srch_str; int ret = 1; /* OK */ struct LatLon ll; gchar *tmpname; g_debug("%s: raw search: %s", __FUNCTION__, srch_str); escaped_srch_str = uri_escape(srch_str); g_debug("%s: escaped search: %s", __FUNCTION__, escaped_srch_str); //uri = g_strdup_printf(GEONAMES_SEARCH_URL_FMT, srch_str); uri = g_strdup_printf(GEONAMES_SEARCH_URL_FMT, escaped_srch_str); tmpname = download_url(uri); if (!tmpname) { ret = -1; goto done; } ret = parse_file_for_latlon(vw, tmpname, &ll); if (ret == 3) { goto done; } vik_coord_load_from_latlon ( coord, vik_viewport_get_coord_mode(vvp), &ll ); if (last_coord) g_free(last_coord); last_coord = g_malloc(sizeof(VikCoord)); *last_coord = *coord; if (last_successful_search_str) g_free(last_successful_search_str); last_successful_search_str = g_strdup(last_search_str); done: g_free(escaped_srch_str); g_free(uri); if (tmpname) { g_remove(tmpname); g_free(tmpname); } return ret; }
void vik_coord_layer_draw ( VikCoordLayer *vcl, gpointer data ) { VikViewport *vp = (VikViewport *) data; if ( !vcl->gc ) { return; } if ( vik_viewport_get_coord_mode(vp) != VIK_COORD_UTM ) { VikCoord left, right, left2, right2; gdouble l, r, i, j; gint x1, y1, x2, y2, smod = 1, mmod = 1; gboolean mins = FALSE, secs = FALSE; GdkGC *dgc = vik_viewport_new_gc_from_color(vp, vcl->color, vcl->line_thickness); GdkGC *mgc = vik_viewport_new_gc_from_color(vp, vcl->color, MAX(vcl->line_thickness/2, 1)); GdkGC *sgc = vik_viewport_new_gc_from_color(vp, vcl->color, MAX(vcl->line_thickness/5, 1)); vik_viewport_screen_to_coord ( vp, 0, 0, &left ); vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), 0, &right ); vik_viewport_screen_to_coord ( vp, 0, vik_viewport_get_height(vp), &left2 ); vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), vik_viewport_get_height(vp), &right2 ); #define CLINE(gc, c1, c2) { \ vik_viewport_coord_to_screen(vp, (c1), &x1, &y1); \ vik_viewport_coord_to_screen(vp, (c2), &x2, &y2); \ vik_viewport_draw_line (vp, (gc), x1, y1, x2, y2); \ } l = left.east_west; r = right.east_west; if (60*fabs(l-r) < 4) { secs = TRUE; smod = MIN(6, (int)ceil(3600*fabs(l-r)/30.0)); } if (fabs(l-r) < 4) { mins = TRUE; mmod = MIN(6, (int)ceil(60*fabs(l-r)/30.0)); } for (i=floor(l*60); i<ceil(r*60); i+=1.0) { if (secs) { for (j=i*60+1; j<(i+1)*60; j+=1.0) { left.east_west = j/3600.0; left2.east_west = j/3600.0; if ((int)j % smod == 0) CLINE(sgc, &left, &left2); } } if (mins) { left.east_west = i/60.0; left2.east_west = i/60.0; if ((int)i % mmod == 0) CLINE(mgc, &left, &left2); } if ((int)i % 60 == 0) { left.east_west = i/60.0; left2.east_west = i/60.0; CLINE(dgc, &left, &left2); } } vik_viewport_screen_to_coord ( vp, 0, 0, &left ); l = left2.north_south; r = left.north_south; for (i=floor(l*60); i<ceil(r*60); i+=1.0) { if (secs) { for (j=i*60+1; j<(i+1)*60; j+=1.0) { left.north_south = j/3600.0; right.north_south = j/3600.0; if ((int)j % smod == 0) CLINE(sgc, &left, &right); } } if (mins) { left.north_south = i/60.0; right.north_south = i/60.0; if ((int)i % mmod == 0) CLINE(mgc, &left, &right); } if ((int)i % 60 == 0) { left.north_south = i/60.0; right.north_south = i/60.0; CLINE(dgc, &left, &right); } } #undef CLINE g_object_unref(dgc); g_object_unref(sgc); g_object_unref(mgc); return; } if ( vik_viewport_get_coord_mode(vp) == VIK_COORD_UTM ) { const struct UTM *center = (const struct UTM *)vik_viewport_get_center ( vp ); gdouble xmpp = vik_viewport_get_xmpp ( vp ), ympp = vik_viewport_get_ympp ( vp ); guint16 width = vik_viewport_get_width ( vp ), height = vik_viewport_get_height ( vp ); struct LatLon ll, ll2, min, max; double lon; int x1, x2; struct UTM utm; utm = *center; utm.northing = center->northing - ( ympp * height / 2 ); a_coords_utm_to_latlon ( &utm, &ll ); utm.northing = center->northing + ( ympp * height / 2 ); a_coords_utm_to_latlon ( &utm, &ll2 ); { /* find corner coords in lat/lon. start at whichever is less: top or bottom left lon. goto whichever more: top or bottom right lon */ struct LatLon topleft, topright, bottomleft, bottomright; struct UTM temp_utm; temp_utm = *center; temp_utm.easting -= (width/2)*xmpp; temp_utm.northing += (height/2)*ympp; a_coords_utm_to_latlon ( &temp_utm, &topleft ); temp_utm.easting += (width*xmpp); a_coords_utm_to_latlon ( &temp_utm, &topright ); temp_utm.northing -= (height*ympp); a_coords_utm_to_latlon ( &temp_utm, &bottomright ); temp_utm.easting -= (width*xmpp); a_coords_utm_to_latlon ( &temp_utm, &bottomleft ); min.lon = (topleft.lon < bottomleft.lon) ? topleft.lon : bottomleft.lon; max.lon = (topright.lon > bottomright.lon) ? topright.lon : bottomright.lon; min.lat = (bottomleft.lat < bottomright.lat) ? bottomleft.lat : bottomright.lat; max.lat = (topleft.lat > topright.lat) ? topleft.lat : topright.lat; } lon = ((double) ((long) ((min.lon)/ vcl->deg_inc))) * vcl->deg_inc; ll.lon = ll2.lon = lon; for (; ll.lon <= max.lon; ll.lon+=vcl->deg_inc, ll2.lon+=vcl->deg_inc ) { a_coords_latlon_to_utm ( &ll, &utm ); x1 = ( (utm.easting - center->easting) / xmpp ) + (width / 2); a_coords_latlon_to_utm ( &ll2, &utm ); x2 = ( (utm.easting - center->easting) / xmpp ) + (width / 2); vik_viewport_draw_line (vp, vcl->gc, x1, height, x2, 0); } utm = *center; utm.easting = center->easting - ( xmpp * width / 2 ); a_coords_utm_to_latlon ( &utm, &ll ); utm.easting = center->easting + ( xmpp * width / 2 ); a_coords_utm_to_latlon ( &utm, &ll2 ); /* really lat, just reusing a variable */ lon = ((double) ((long) ((min.lat)/ vcl->deg_inc))) * vcl->deg_inc; ll.lat = ll2.lat = lon; for (; ll.lat <= max.lat ; ll.lat+=vcl->deg_inc, ll2.lat+=vcl->deg_inc ) { a_coords_latlon_to_utm ( &ll, &utm ); x1 = (height / 2) - ( (utm.northing - center->northing) / ympp ); a_coords_latlon_to_utm ( &ll2, &utm ); x2 = (height / 2) - ( (utm.northing - center->northing) / ympp ); vik_viewport_draw_line (vp, vcl->gc, width, x2, 0, x1); } } }
static void vik_dem_layer_draw_dem ( VikDEMLayer *vdl, VikViewport *vp, VikDEM *dem ) { VikDEMColumn *column, *prevcolumn, *nextcolumn; struct LatLon dem_northeast, dem_southwest; gdouble max_lat, max_lon, min_lat, min_lon; /**** Check if viewport and DEM data overlap ****/ /* get min, max lat/lon of viewport */ vik_viewport_get_min_max_lat_lon ( vp, &min_lat, &max_lat, &min_lon, &max_lon ); /* get min, max lat/lon of DEM data */ if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) { dem_northeast.lat = dem->max_north / 3600.0; dem_northeast.lon = dem->max_east / 3600.0; dem_southwest.lat = dem->min_north / 3600.0; dem_southwest.lon = dem->min_east / 3600.0; } else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) { struct UTM dem_northeast_utm, dem_southwest_utm; dem_northeast_utm.northing = dem->max_north; dem_northeast_utm.easting = dem->max_east; dem_southwest_utm.northing = dem->min_north; dem_southwest_utm.easting = dem->min_east; dem_northeast_utm.zone = dem_southwest_utm.zone = dem->utm_zone; dem_northeast_utm.letter = dem_southwest_utm.letter = dem->utm_letter; a_coords_utm_to_latlon(&dem_northeast_utm, &dem_northeast); a_coords_utm_to_latlon(&dem_southwest_utm, &dem_southwest); } if ( (max_lat > dem_northeast.lat && min_lat > dem_northeast.lat) || (max_lat < dem_southwest.lat && min_lat < dem_southwest.lat) ) return; else if ( (max_lon > dem_northeast.lon && min_lon > dem_northeast.lon) || (max_lon < dem_southwest.lon && min_lon < dem_southwest.lon) ) return; /* else they overlap */ /**** End Overlap Check ****/ /* boxes to show where we have DEM instead of actually drawing the DEM. * useful if we want to see what areas we have coverage for (if we want * to get elevation data for a track) but don't want to cover the map. */ #if 0 /* draw a box if a DEM is loaded. in future I'd like to add an option for this * this is useful if we want to see what areas we have dem for but don't want to * cover the map (or maybe we just need translucent DEM?) */ { VikCoord demne, demsw; gint x1, y1, x2, y2; vik_coord_load_from_latlon(&demne, vik_viewport_get_coord_mode(vp), &dem_northeast); vik_coord_load_from_latlon(&demsw, vik_viewport_get_coord_mode(vp), &dem_southwest); vik_viewport_coord_to_screen ( vp, &demne, &x1, &y1 ); vik_viewport_coord_to_screen ( vp, &demsw, &x2, &y2 ); if ( x1 > vik_viewport_get_width(vp) ) x1=vik_viewport_get_width(vp); if ( y2 > vik_viewport_get_height(vp) ) y2=vik_viewport_get_height(vp); if ( x2 < 0 ) x2 = 0; if ( y1 < 0 ) y1 = 0; vik_viewport_draw_rectangle ( vp, gtk_widget_get_style(GTK_WIDGET(vp))->black_gc, FALSE, x2, y1, x1-x2, y2-y1 ); return; } #endif if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) { VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */ gdouble max_lat_as, max_lon_as, min_lat_as, min_lon_as; gdouble start_lat_as, end_lat_as, start_lon_as, end_lon_as; gdouble start_lat, end_lat, start_lon, end_lon; struct LatLon counter; guint x, y, start_x, start_y; gint16 elev; 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); max_lat_as = max_lat * 3600; min_lat_as = min_lat * 3600; max_lon_as = max_lon * 3600; min_lon_as = min_lon * 3600; start_lat_as = MAX(min_lat_as, dem->min_north); end_lat_as = MIN(max_lat_as, dem->max_north); start_lon_as = MAX(min_lon_as, dem->min_east); end_lon_as = MIN(max_lon_as, dem->max_east); start_lat = floor(start_lat_as / dem->north_scale) * nscale_deg; end_lat = ceil (end_lat_as / dem->north_scale) * nscale_deg; start_lon = floor(start_lon_as / dem->east_scale) * escale_deg; 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+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 < 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]; // 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; } { 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= */ } } /* for x= */ } else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) { gdouble max_nor, max_eas, min_nor, min_eas; gdouble start_nor, start_eas, end_nor, end_eas; gint16 elev; guint x, y, start_x, start_y; VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */ struct UTM counter; guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 10 ); /* todo: smarter calculation. */ VikCoord tleft, tright, bleft, bright; vik_viewport_screen_to_coord ( vp, 0, 0, &tleft ); vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), 0, &tright ); vik_viewport_screen_to_coord ( vp, 0, vik_viewport_get_height(vp), &bleft ); vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), vik_viewport_get_height(vp), &bright ); vik_coord_convert(&tleft, VIK_COORD_UTM); vik_coord_convert(&tright, VIK_COORD_UTM); vik_coord_convert(&bleft, VIK_COORD_UTM); vik_coord_convert(&bright, VIK_COORD_UTM); max_nor = MAX(tleft.north_south, tright.north_south); min_nor = MIN(bleft.north_south, bright.north_south); max_eas = MAX(bright.east_west, tright.east_west); min_eas = MIN(bleft.east_west, tleft.east_west); start_nor = MAX(min_nor, dem->min_north); end_nor = MIN(max_nor, dem->max_north); if ( tleft.utm_zone == dem->utm_zone && bleft.utm_zone == dem->utm_zone && (tleft.utm_letter >= 'N') == (dem->utm_letter >= 'N') && (bleft.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */ start_eas = MAX(min_eas, dem->min_east); else start_eas = dem->min_east; if ( tright.utm_zone == dem->utm_zone && bright.utm_zone == dem->utm_zone && (tright.utm_letter >= 'N') == (dem->utm_letter >= 'N') && (bright.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */ end_eas = MIN(max_eas, dem->max_east); else end_eas = dem->max_east; start_nor = floor(start_nor / dem->north_scale) * dem->north_scale; end_nor = ceil (end_nor / dem->north_scale) * dem->north_scale; start_eas = floor(start_eas / dem->east_scale) * dem->east_scale; end_eas = ceil (end_eas / dem->east_scale) * dem->east_scale; vik_dem_east_north_to_xy ( dem, start_eas, start_nor, &start_x, &start_y ); /* TODO: why start_x and start_y are -1 -- rounding error from above? */ counter.zone = dem->utm_zone; counter.letter = dem->utm_letter; for ( x=start_x, counter.easting = start_eas; counter.easting <= end_eas; counter.easting += dem->east_scale * skip_factor, x += skip_factor ) { if ( x > 0 && x < dem->n_columns ) { column = g_ptr_array_index ( dem->columns, x ); for ( y=start_y, counter.northing = start_nor; counter.northing <= end_nor; counter.northing += dem->north_scale * skip_factor, y += skip_factor ) { if ( y > column->n_points ) continue; 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; { gint a, b; vik_coord_load_from_utm(&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-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_HEIGHT_COLORS-2))+1], TRUE, a-1, b-1, 2, 2 ); } } /* for y= */ } } /* for x= */ } }