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 );
}
static void clip_add_wp(VikLayersPanel *vlp, struct LatLon *coord)
{
VikCoord vc;
VikLayer *sel = vik_layers_panel_get_selected ( vlp );
vik_coord_load_from_latlon ( &vc, VIK_COORD_LATLON, coord );
if (sel && sel->type == VIK_LAYER_TRW) {
vik_trw_layer_new_waypoint ( VIK_TRW_LAYER(sel), VIK_GTK_WINDOW_FROM_LAYER(sel), &vc );
} else {
a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_WIDGET(GTK_WIDGET(vlp)), _("In order to paste a waypoint, please select an appropriate layer to paste into."), NULL);
}
}
void a_geonames_wikipedia_box(VikWindow *vw, VikTrwLayer *vtl, VikLayersPanel *vlp, struct LatLon maxmin[2])
{
gchar *uri;
gchar *tmpname;
GList *wiki_places;
GList *selected;
GList *wp_runner;
VikWaypoint *wiki_wp;
found_geoname *wiki_geoname;
/* encode doubles in a C locale */
gchar *north = a_coords_dtostr(maxmin[0].lat);
gchar *south = a_coords_dtostr(maxmin[1].lat);
gchar *east = a_coords_dtostr(maxmin[0].lon);
gchar *west = a_coords_dtostr(maxmin[1].lon);
uri = g_strdup_printf(GEONAMES_WIKIPEDIA_URL_FMT, north, south, east, west);
g_free(north); north = NULL;
g_free(south); south = NULL;
g_free(east); east = NULL;
g_free(west); west = NULL;
tmpname = download_url(uri);
if (!tmpname) {
none_found(vw);
return;
}
wiki_places = get_entries_from_file(tmpname);
if (g_list_length(wiki_places) == 0) {
none_found(vw);
return;
}
selected = a_select_geoname_from_list(VIK_GTK_WINDOW_FROM_WIDGET(vw), wiki_places, TRUE, "Select articles", "Select the articles you want to add.");
wp_runner = selected;
while (wp_runner) {
wiki_geoname = (found_geoname *)wp_runner->data;
wiki_wp = vik_waypoint_new();
wiki_wp->visible = TRUE;
vik_coord_load_from_latlon(&(wiki_wp->coord), vik_trw_layer_get_coord_mode ( vtl ), &(wiki_geoname->ll));
vik_waypoint_set_comment(wiki_wp, wiki_geoname->desc);
vik_trw_layer_filein_add_waypoint ( vtl, wiki_geoname->name, wiki_wp );
wp_runner = g_list_next(wp_runner);
}
free_geoname_list(wiki_places);
free_geoname_list(selected);
g_free(uri);
if (tmpname) {
g_free(tmpname);
}
vik_layers_panel_emit_update(vlp);
}
static void tpwin_sync_ll_to_tp ( VikTrwLayerTpwin *tpwin )
{
if ( tpwin->cur_tp && (!tpwin->sync_to_tp_block) )
{
struct LatLon ll;
VikCoord coord;
ll.lat = gtk_spin_button_get_value ( tpwin->lat );
ll.lon = gtk_spin_button_get_value ( tpwin->lon );
vik_coord_load_from_latlon ( &coord, tpwin->cur_tp->coord.mode, &ll );
/* don't redraw unless we really have to */
if ( vik_coord_diff(&(tpwin->cur_tp->coord), &coord) > 0.05 ) /* may not be exact due to rounding */
{
tpwin->cur_tp->coord = coord;
gtk_dialog_response ( GTK_DIALOG(tpwin), VIK_TRW_LAYER_TPWIN_DATA_CHANGED );
}
}
}
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;
}
static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr)
{
static const gchar *tmp;
g_string_append_c ( xpath, '/' );
g_string_append ( xpath, el );
current_tag = get_tag ( xpath->str );
switch ( current_tag ) {
case tt_gpx:
c_md = vik_trw_metadata_new();
break;
case tt_wpt:
if ( set_c_ll( attr ) ) {
c_wp = vik_waypoint_new ();
c_wp->visible = TRUE;
if ( get_attr ( attr, "hidden" ) )
c_wp->visible = FALSE;
vik_coord_load_from_latlon ( &(c_wp->coord), vik_trw_layer_get_coord_mode ( vtl ), &c_ll );
}
break;
case tt_trk:
case tt_rte:
c_tr = vik_track_new ();
vik_track_set_defaults ( c_tr );
c_tr->is_route = (current_tag == tt_rte) ? TRUE : FALSE;
c_tr->visible = TRUE;
if ( get_attr ( attr, "hidden" ) )
c_tr->visible = FALSE;
break;
case tt_trk_trkseg:
f_tr_newseg = TRUE;
break;
case tt_trk_trkseg_trkpt:
if ( set_c_ll( attr ) ) {
c_tp = vik_trackpoint_new ();
vik_coord_load_from_latlon ( &(c_tp->coord), vik_trw_layer_get_coord_mode ( vtl ), &c_ll );
if ( f_tr_newseg ) {
c_tp->newsegment = TRUE;
f_tr_newseg = FALSE;
}
c_tr->trackpoints = g_list_append ( c_tr->trackpoints, c_tp );
}
break;
case tt_gpx_name:
case tt_gpx_author:
case tt_gpx_desc:
case tt_gpx_keywords:
case tt_gpx_time:
case tt_trk_trkseg_trkpt_name:
case tt_trk_trkseg_trkpt_ele:
case tt_trk_trkseg_trkpt_time:
case tt_wpt_cmt:
case tt_wpt_desc:
case tt_wpt_name:
case tt_wpt_ele:
case tt_wpt_time:
case tt_wpt_url:
case tt_wpt_link:
case tt_trk_cmt:
case tt_trk_desc:
case tt_trk_name:
g_string_erase ( c_cdata, 0, -1 ); /* clear the cdata buffer */
break;
case tt_waypoint:
c_wp = vik_waypoint_new ();
c_wp->visible = TRUE;
break;
case tt_waypoint_coord:
if ( set_c_ll( attr ) )
vik_coord_load_from_latlon ( &(c_wp->coord), vik_trw_layer_get_coord_mode ( vtl ), &c_ll );
break;
case tt_waypoint_name:
if ( ( tmp = get_attr(attr, "id") ) ) {
if ( c_wp_name )
g_free ( c_wp_name );
c_wp_name = g_strdup ( tmp );
}
g_string_erase ( c_cdata, 0, -1 ); /* clear the cdata buffer for description */
break;
default: break;
}
}
/**
* Correlate the image against the specified track
*/
static void trw_layer_geotag_track ( const gchar *name, VikTrack *track, geotag_options_t *options )
{
// If already found match then don't need to check this track
if ( options->found_match )
return;
VikTrackpoint *trkpt;
VikTrackpoint *trkpt_next;
GList *mytrkpt = track->trackpoints;
for ( mytrkpt = mytrkpt; mytrkpt; mytrkpt = mytrkpt->next ) {
// Do something for this trackpoint...
trkpt = VIK_TRACKPOINT(mytrkpt->data);
// is it exactly this point?
if ( options->PhotoTime == trkpt->timestamp ) {
options->coord = trkpt->coord;
options->altitude = trkpt->altitude;
options->found_match = TRUE;
break;
}
// Now need two trackpoints, hence check next is available
if ( !mytrkpt->next ) break;
trkpt_next = VIK_TRACKPOINT(mytrkpt->next->data);
// TODO need to use 'has_timestamp' property
if ( trkpt->timestamp == trkpt_next->timestamp ) continue;
if ( trkpt->timestamp > trkpt_next->timestamp ) continue;
// When interpolating between segments, no need for any special segment handling
if ( !options->ov.interpolate_segments )
// Don't check between segments
if ( trkpt_next->newsegment )
// Simply move on to consider next point
continue;
// Too far
if ( trkpt->timestamp > options->PhotoTime ) break;
// Is is between this and the next point?
if ( (options->PhotoTime > trkpt->timestamp) && (options->PhotoTime < trkpt_next->timestamp) ) {
options->found_match = TRUE;
// Interpolate
/* Calculate the "scale": a decimal giving the relative distance
* in time between the two points. Ie, a number between 0 and 1 -
* 0 is the first point, 1 is the next point, and 0.5 would be
* half way. */
gdouble scale = (gdouble)trkpt_next->timestamp - (gdouble)trkpt->timestamp;
scale = ((gdouble)options->PhotoTime - (gdouble)trkpt->timestamp) / scale;
struct LatLon ll_result, ll1, ll2;
vik_coord_to_latlon ( &(trkpt->coord), &ll1 );
vik_coord_to_latlon ( &(trkpt_next->coord), &ll2 );
ll_result.lat = ll1.lat + ((ll2.lat - ll1.lat) * scale);
// NB This won't cope with going over the 180 degrees longitude boundary
ll_result.lon = ll1.lon + ((ll2.lon - ll1.lon) * scale);
// set coord
vik_coord_load_from_latlon ( &(options->coord), VIK_COORD_LATLON, &ll_result );
// Interpolate elevation
options->altitude = trkpt->altitude + ((trkpt_next->altitude - trkpt->altitude) * scale);
break;
}
}
}
/* todo: less on this side, like add track */
gchar *a_dialog_waypoint ( GtkWindow *parent, gchar *default_name, VikTrwLayer *vtl, VikWaypoint *wp, VikCoordMode coord_mode, gboolean is_new, gboolean *updated )
{
GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Waypoint Properties"),
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
struct LatLon ll;
GtkWidget *latlabel, *lonlabel, *namelabel, *latentry, *lonentry, *altentry, *altlabel, *nameentry=NULL;
GtkWidget *commentlabel, *commententry, *descriptionlabel, *descriptionentry, *imagelabel, *imageentry, *symbollabel, *symbolentry;
GtkWidget *sourcelabel = NULL, *sourceentry = NULL;
GtkWidget *typelabel = NULL, *typeentry = NULL;
GtkWidget *timelabel = NULL;
GtkWidget *timevaluebutton = NULL;
GtkWidget *hasGeotagCB = NULL;
GtkWidget *consistentGeotagCB = NULL;
GtkWidget *direction_sb = NULL;
GtkWidget *direction_hb = NULL;
GtkListStore *store;
gchar *lat, *lon, *alt;
vik_coord_to_latlon ( &(wp->coord), &ll );
lat = g_strdup_printf ( "%f", ll.lat );
lon = g_strdup_printf ( "%f", ll.lon );
vik_units_height_t height_units = a_vik_get_units_height ();
switch (height_units) {
case VIK_UNITS_HEIGHT_METRES:
alt = g_strdup_printf ( "%f", wp->altitude );
break;
case VIK_UNITS_HEIGHT_FEET:
alt = g_strdup_printf ( "%f", VIK_METERS_TO_FEET(wp->altitude) );
break;
default:
alt = g_strdup_printf ( "%f", wp->altitude );
g_critical("Houston, we've had a problem. height=%d", height_units);
}
*updated = FALSE;
namelabel = gtk_label_new (_("Name:"));
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), namelabel, FALSE, FALSE, 0);
// Name is now always changeable
nameentry = gtk_entry_new ();
if ( default_name )
gtk_entry_set_text( GTK_ENTRY(nameentry), default_name );
g_signal_connect_swapped ( nameentry, "activate", G_CALLBACK(a_dialog_response_accept), GTK_DIALOG(dialog) );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), nameentry, FALSE, FALSE, 0);
latlabel = gtk_label_new (_("Latitude:"));
latentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(latentry), lat );
g_free ( lat );
lonlabel = gtk_label_new (_("Longitude:"));
lonentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(lonentry), lon );
g_free ( lon );
altlabel = gtk_label_new (_("Altitude:"));
altentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(altentry), alt );
g_free ( alt );
if ( wp->comment && !strncmp(wp->comment, "http", 4) )
commentlabel = gtk_link_button_new_with_label (wp->comment, _("Comment:") );
else
commentlabel = gtk_label_new (_("Comment:"));
commententry = gtk_entry_new ();
gchar *cmt = NULL;
// Auto put in some kind of 'name' as a comment if one previously 'goto'ed this exact location
cmt = a_vik_goto_get_search_string_for_this_place(VIK_WINDOW(parent));
if (cmt)
gtk_entry_set_text(GTK_ENTRY(commententry), cmt);
if ( wp->description && !strncmp(wp->description, "http", 4) )
descriptionlabel = gtk_link_button_new_with_label (wp->description, _("Description:") );
else
descriptionlabel = gtk_label_new (_("Description:"));
descriptionentry = gtk_entry_new ();
sourcelabel = gtk_label_new (_("Source:"));
if ( wp->source ) {
sourceentry = gtk_entry_new ();
gtk_entry_set_text(GTK_ENTRY(sourceentry), wp->source);
}
typelabel = gtk_label_new (_("Type:"));
if ( wp->type ) {
typeentry = gtk_entry_new ();
gtk_entry_set_text(GTK_ENTRY(typeentry), wp->type);
}
imagelabel = gtk_label_new (_("Image:"));
imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, VF_FILTER_IMAGE, NULL, NULL);
{
GtkCellRenderer *r;
symbollabel = gtk_label_new (_("Symbol:"));
GtkTreeIter iter;
store = gtk_list_store_new(3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING);
symbolentry = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(symbolentry), 6);
g_signal_connect(symbolentry, "changed", G_CALLBACK(symbol_entry_changed_cb), store);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, NULL, 1, NULL, 2, _("(none)"), -1);
a_populate_sym_list(store);
r = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (symbolentry), r, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (symbolentry), r, "pixbuf", 1, NULL);
r = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (symbolentry), r, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (symbolentry), r, "text", 2, NULL);
if ( !is_new && wp->symbol ) {
gboolean ok;
gchar *sym;
for (ok = gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(store), &iter ); ok; ok = gtk_tree_model_iter_next ( GTK_TREE_MODEL(store), &iter)) {
gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, 0, (void *)&sym, -1 );
if (sym && !strcmp(sym, wp->symbol)) {
g_free(sym);
break;
} else {
g_free(sym);
}
}
// Ensure is it a valid symbol in the given symbol set (large vs small)
// Not all symbols are available in both
// The check prevents a Gtk Critical message
if ( iter.stamp )
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(symbolentry), &iter);
}
}
if ( !is_new && wp->comment )
gtk_entry_set_text ( GTK_ENTRY(commententry), wp->comment );
if ( !is_new && wp->description )
gtk_entry_set_text ( GTK_ENTRY(descriptionentry), wp->description );
if ( !edit_wp )
edit_wp = vik_waypoint_new ();
edit_wp = vik_waypoint_copy ( wp );
if ( !is_new && wp->image ) {
vik_file_entry_set_filename ( VIK_FILE_ENTRY(imageentry), wp->image );
#ifdef VIK_CONFIG_GEOTAG
// Geotag Info [readonly]
hasGeotagCB = gtk_check_button_new_with_label ( _("Has Geotag") );
gtk_widget_set_sensitive ( hasGeotagCB, FALSE );
gboolean hasGeotag;
gchar *ignore = a_geotag_get_exif_date_from_file ( wp->image, &hasGeotag );
g_free ( ignore );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(hasGeotagCB), hasGeotag );
consistentGeotagCB = gtk_check_button_new_with_label ( _("Consistent Position") );
gtk_widget_set_sensitive ( consistentGeotagCB, FALSE );
if ( hasGeotag ) {
struct LatLon ll = a_geotag_get_position ( wp->image );
VikCoord coord;
vik_coord_load_from_latlon ( &coord, coord_mode, &ll );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(consistentGeotagCB), vik_coord_equalish(&coord, &wp->coord) );
}
// ATM the direction value box is always shown, even when there is no information.
// It would be nice to be able to hide it until the 'Add' has been performed,
// however I've not been able to achieve this.
// Thus simply sensistizing it instead.
GtkWidget *direction_label = gtk_label_new ( _("Image Direction:") );
direction_hb = gtk_hbox_new ( FALSE, 0 );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_label, FALSE, FALSE, 0);
direction_sb = gtk_spin_button_new ( (GtkAdjustment*)gtk_adjustment_new (0, 0.0, 359.9, 5.0, 1, 0 ), 1, 1 );
if ( !is_new && !isnan(wp->image_direction) ) {
GtkWidget *direction_ref = gtk_label_new ( NULL );
if ( wp->image_direction_ref == WP_IMAGE_DIRECTION_REF_MAGNETIC )
gtk_label_set_label ( GTK_LABEL(direction_ref), _("Magnetic") );
else
gtk_label_set_label ( GTK_LABEL(direction_ref), _("True") );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_ref, TRUE, FALSE, 0);
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(direction_sb), wp->image_direction );
}
else {
GtkWidget *direction_ref_button = gtk_button_new ();
gtk_button_set_relief ( GTK_BUTTON(direction_ref_button), GTK_RELIEF_NONE );
GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU );
gtk_button_set_image ( GTK_BUTTON(direction_ref_button), img );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_ref_button, TRUE, FALSE, 0);
gtk_widget_set_sensitive ( direction_sb, FALSE );
direction_signal_id = g_signal_connect ( G_OBJECT(direction_ref_button), "button-release-event", G_CALLBACK(direction_add_click), direction_sb );
}
#endif
}
timelabel = gtk_label_new ( _("Time:") );
timevaluebutton = gtk_button_new();
gtk_button_set_relief ( GTK_BUTTON(timevaluebutton), GTK_RELIEF_NONE );
// TODO: Consider if there should be a remove time button...
if ( !is_new && wp->has_timestamp ) {
update_time ( timevaluebutton, wp );
}
else {
GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU );
gtk_button_set_image ( GTK_BUTTON(timevaluebutton), img );
// Initially use current time or otherwise whatever the last value used was
if ( edit_wp->timestamp == 0 ) {
time ( &edit_wp->timestamp );
}
}
g_signal_connect ( G_OBJECT(timevaluebutton), "button-release-event", G_CALLBACK(time_edit_click), edit_wp );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), latlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), latentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), lonlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), lonentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), timelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), timevaluebutton, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), altlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), altentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), commentlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), commententry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), descriptionlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), descriptionentry, FALSE, FALSE, 0);
if ( wp->source ) {
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), sourcelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), sourceentry, FALSE, FALSE, 0);
}
if ( wp->type ) {
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), typelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), typeentry, FALSE, FALSE, 0);
}
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), imagelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), imageentry, FALSE, FALSE, 0);
if ( hasGeotagCB ) {
GtkWidget *hbox = gtk_hbox_new ( FALSE, 0 );
gtk_box_pack_start (GTK_BOX(hbox), hasGeotagCB, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox), consistentGeotagCB, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox, FALSE, FALSE, 0);
}
if ( direction_hb )
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), direction_hb, FALSE, FALSE, 0);
if ( direction_sb )
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), direction_sb, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), symbollabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), GTK_WIDGET(symbolentry), FALSE, FALSE, 0);
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
gtk_widget_show_all ( gtk_dialog_get_content_area(GTK_DIALOG(dialog)) );
if ( !is_new ) {
// Shift left<->right to try not to obscure the waypoint.
trw_layer_dialog_shift ( vtl, GTK_WINDOW(dialog), &(wp->coord), FALSE );
}
while ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
if ( strlen((gchar*)gtk_entry_get_text ( GTK_ENTRY(nameentry) )) == 0 ) /* TODO: other checks (isalpha or whatever ) */
a_dialog_info_msg ( parent, _("Please enter a name for the waypoint.") );
else {
// NB: No check for unique names - this allows generation of same named entries.
gchar *entered_name = g_strdup ( (gchar*)gtk_entry_get_text ( GTK_ENTRY(nameentry) ) );
/* Do It */
ll.lat = convert_dms_to_dec ( gtk_entry_get_text ( GTK_ENTRY(latentry) ) );
ll.lon = convert_dms_to_dec ( gtk_entry_get_text ( GTK_ENTRY(lonentry) ) );
vik_coord_load_from_latlon ( &(wp->coord), coord_mode, &ll );
// Always store in metres
switch (height_units) {
case VIK_UNITS_HEIGHT_METRES:
wp->altitude = atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) );
break;
case VIK_UNITS_HEIGHT_FEET:
wp->altitude = VIK_FEET_TO_METERS(atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) ));
break;
default:
wp->altitude = atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) );
g_critical("Houston, we've had a problem. height=%d", height_units);
}
if ( g_strcmp0 ( wp->comment, gtk_entry_get_text ( GTK_ENTRY(commententry) ) ) )
vik_waypoint_set_comment ( wp, gtk_entry_get_text ( GTK_ENTRY(commententry) ) );
if ( g_strcmp0 ( wp->description, gtk_entry_get_text ( GTK_ENTRY(descriptionentry) ) ) )
vik_waypoint_set_description ( wp, gtk_entry_get_text ( GTK_ENTRY(descriptionentry) ) );
if ( g_strcmp0 ( wp->image, vik_file_entry_get_filename ( VIK_FILE_ENTRY(imageentry) ) ) )
vik_waypoint_set_image ( wp, vik_file_entry_get_filename ( VIK_FILE_ENTRY(imageentry) ) );
if ( sourceentry && g_strcmp0 ( wp->source, gtk_entry_get_text ( GTK_ENTRY(sourceentry) ) ) )
vik_waypoint_set_source ( wp, gtk_entry_get_text ( GTK_ENTRY(sourceentry) ) );
if ( typeentry && g_strcmp0 ( wp->type, gtk_entry_get_text ( GTK_ENTRY(typeentry) ) ) )
vik_waypoint_set_type ( wp, gtk_entry_get_text ( GTK_ENTRY(typeentry) ) );
if ( wp->image && *(wp->image) && (!a_thumbnails_exists(wp->image)) )
a_thumbnails_create ( wp->image );
if ( edit_wp->timestamp ) {
wp->timestamp = edit_wp->timestamp;
wp->has_timestamp = TRUE;
}
if ( direction_sb ) {
if ( gtk_widget_get_sensitive (direction_sb) ) {
wp->image_direction = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(direction_sb) );
if ( wp->image_direction != edit_wp->image_direction )
a_geotag_write_exif_gps ( wp->image, wp->coord, wp->altitude, wp->image_direction, wp->image_direction_ref, TRUE );
}
}
GtkTreeIter iter, first;
gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(store), &first );
if ( !gtk_combo_box_get_active_iter ( GTK_COMBO_BOX(symbolentry), &iter ) || !memcmp(&iter, &first, sizeof(GtkTreeIter)) ) {
vik_waypoint_set_symbol ( wp, NULL );
} else {
gchar *sym;
gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, 0, (void *)&sym, -1 );
vik_waypoint_set_symbol ( wp, sym );
g_free(sym);
}
gtk_widget_destroy ( dialog );
if ( is_new )
return entered_name;
else {
*updated = TRUE;
// See if name has been changed
if ( g_strcmp0 (default_name, entered_name ) )
return entered_name;
else
return NULL;
}
}
}
gtk_widget_destroy ( dialog );
return NULL;
}
/**
* a_geotag_create_waypoint_from_file:
* @filename: The image file to process
* @vcmode: The current location mode to use in the positioning of Waypoint
* @name: Returns a name for the Waypoint (can be NULL)
*
* Returns: An allocated Waypoint or NULL if Waypoint could not be generated (e.g. no EXIF info)
*
*/
VikWaypoint* a_geotag_create_waypoint_from_file ( const gchar *filename, VikCoordMode vcmode, gchar **name )
{
// Default return values (for failures)
*name = NULL;
VikWaypoint *wp = NULL;
// TODO use log?
//ExifLog *log = NULL;
// open image with libexif
ExifData *ed = exif_data_new_from_file ( filename );
// Detect EXIF load failure
if ( !ed )
// return with no Waypoint
return wp;
struct LatLon ll;
gchar str[128];
ExifEntry *ee;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_VERSION_ID);
// Confirm this has a GPS Id - normally "2.0.0.0" or "2.2.0.0"
if ( ! ( ee && ee->components == 4 ) )
goto MyReturn;
// Could test for these versions explicitly but may have byte order issues...
//if ( ! ( ee->data[0] == 2 && ee->data[2] == 0 && ee->data[3] == 0 ) )
// goto MyReturn;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_MAP_DATUM);
if ( ! ( ee && ee->components > 0 && ee->format == EXIF_FORMAT_ASCII ) )
goto MyReturn;
// If map datum specified - only deal in WGS-84 - the defacto standard
if ( ee && ee->components > 0 ) {
exif_entry_get_value ( ee, str, 128 );
if ( strncmp (str, "WGS-84", 6) )
goto MyReturn;
}
//
// Lat & Long is necessary to form a waypoint.
//
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LATITUDE);
if ( ! ( ee && ee->components == 3 && ee->format == EXIF_FORMAT_RATIONAL ) )
goto MyReturn;
ll.lat = Rational2Double ( ee->data,
exif_format_get_size(ee->format),
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LATITUDE_REF);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
if ( str[0] == 'S' )
ll.lat = -ll.lat;
}
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LONGITUDE);
if ( ! ( ee && ee->components == 3 && ee->format == EXIF_FORMAT_RATIONAL ) )
goto MyReturn;
ll.lon = Rational2Double ( ee->data,
exif_format_get_size(ee->format),
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LONGITUDE_REF);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
if ( str[0] == 'W' )
ll.lon = -ll.lon;
}
//
// Not worried if none of the other fields exist, as can default the values to something
//
gdouble alt = VIK_DEFAULT_ALTITUDE;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_ALTITUDE);
if ( ee && ee->components == 1 && ee->format == EXIF_FORMAT_RATIONAL ) {
alt = Rational2Double ( ee->data,
0,
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_ALTITUDE_REF);
if ( ee && ee->components == 1 && ee->format == EXIF_FORMAT_BYTE && ee->data[0] == 1 )
alt = -alt;
}
// Name
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_TITLE);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
*name = g_strdup ( str );
}
//
// Now create Waypoint with acquired information
//
wp = vik_waypoint_new();
wp->visible = TRUE;
// Set info from exif values
// Location
vik_coord_load_from_latlon ( &(wp->coord), vcmode, &ll );
// Altitude
wp->altitude = alt;
wp->comment = geotag_get_exif_comment ( ed );
vik_waypoint_set_image ( wp, filename );
MyReturn:
// Finished with EXIF
exif_data_free ( ed );
return wp;
}
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= */
}
}
void a_gpspoint_read_file(VikTrwLayer *trw, FILE *f ) {
VikCoordMode coord_mode = vik_trw_layer_get_coord_mode ( trw );
gchar *tag_start, *tag_end;
g_assert ( f != NULL && trw != NULL );
line_type = 0;
line_timestamp = 0;
line_newsegment = FALSE;
line_image = NULL;
line_symbol = NULL;
current_track = NULL;
while (fgets(line_buffer, 2048, f))
{
gboolean inside_quote = 0;
gboolean backslash = 0;
line_buffer[strlen(line_buffer)-1] = '\0'; /* chop off newline */
/* for gpspoint files wrapped inside */
if ( strlen(line_buffer) >= 13 && strncmp ( line_buffer, "~EndLayerData", 13 ) == 0 )
break;
/* each line: nullify stuff, make thing if nes, free name if ness */
tag_start = line_buffer;
for (;;)
{
/* my addition: find first non-whitespace character. if the null, skip line. */
while (*tag_start != '\0' && isspace(*tag_start))
tag_start++;
if (tag_start == '\0')
break;
if (*tag_start == '#')
break;
tag_end = tag_start;
if (*tag_end == '"')
inside_quote = !inside_quote;
while (*tag_end != '\0' && (!isspace(*tag_end) || inside_quote)) {
tag_end++;
if (*tag_end == '\\' && !backslash)
backslash = TRUE;
else if (backslash)
backslash = FALSE;
else if (*tag_end == '"')
inside_quote = !inside_quote;
}
gpspoint_process_tag ( tag_start, tag_end - tag_start );
if (*tag_end == '\0' )
break;
else
tag_start = tag_end+1;
}
if (line_type == GPSPOINT_TYPE_WAYPOINT && line_name)
{
VikWaypoint *wp = vik_waypoint_new();
wp->visible = line_visible;
wp->altitude = line_altitude;
vik_coord_load_from_latlon ( &(wp->coord), coord_mode, &line_latlon );
vik_trw_layer_filein_add_waypoint ( trw, line_name, wp );
g_free ( line_name );
line_name = NULL;
if ( line_comment )
{
vik_waypoint_set_comment ( wp, line_comment );
line_comment = NULL;
}
if ( line_image )
{
vik_waypoint_set_image ( wp, line_image );
line_image = NULL;
}
if ( line_symbol )
{
vik_waypoint_set_symbol ( wp, line_symbol );
line_symbol = NULL;
}
}
else if (line_type == GPSPOINT_TYPE_TRACK && line_name)
{
VikTrack *pl = vik_track_new();
/* Thanks to Peter Jones for this Fix */
if (!line_name) line_name = g_strdup("UNK");
pl->visible = line_visible;
if ( line_comment )
{
vik_track_set_comment ( pl, line_comment );
line_comment = NULL;
}
pl->trackpoints = NULL;
vik_trw_layer_filein_add_track ( trw, line_name, pl );
g_free ( line_name );
line_name = NULL;
current_track = pl;
}
else if (line_type == GPSPOINT_TYPE_TRACKPOINT && current_track)
{
VikTrackpoint *tp = vik_trackpoint_new();
vik_coord_load_from_latlon ( &(tp->coord), coord_mode, &line_latlon );
tp->newsegment = line_newsegment;
tp->has_timestamp = line_has_timestamp;
tp->timestamp = line_timestamp;
tp->altitude = line_altitude;
if (line_extended) {
tp->extended = TRUE;
tp->speed = line_speed;
tp->course = line_course;
tp->nsats = line_sat;
tp->fix_mode = line_fix;
}
else {
tp->extended = FALSE;
}
current_track->trackpoints = g_list_append ( current_track->trackpoints, tp );
}
if (line_name)
g_free ( line_name );
line_name = NULL;
if (line_comment)
g_free ( line_comment );
if (line_image)
g_free ( line_image );
if (line_symbol)
g_free ( line_symbol );
line_comment = NULL;
line_image = NULL;
line_symbol = NULL;
line_type = GPSPOINT_TYPE_NONE;
line_newsegment = FALSE;
line_has_timestamp = FALSE;
line_timestamp = 0;
line_altitude = VIK_DEFAULT_ALTITUDE;
line_visible = TRUE;
line_symbol = NULL;
line_extended = FALSE;
line_speed = NAN;
line_course = NAN;
line_sat = 0;
line_fix = 0;
}
}
void vik_viewport_set_center_latlon ( VikViewport *vvp, const struct LatLon *ll )
{
vik_coord_load_from_latlon ( &(vvp->center), vvp->coord_mode, ll );
if ( vvp->coord_mode == VIK_COORD_UTM )
viewport_utm_zone_check ( vvp );
}
/*
* Returns whether file read was a success
* No obvious way to test for a 'gpspoint' file,
* thus set a flag if any actual tag found during processing of the file
*/
gboolean a_gpspoint_read_file(VikTrwLayer *trw, FILE *f, const gchar *dirpath ) {
VikCoordMode coord_mode = vik_trw_layer_get_coord_mode ( trw );
gchar *tag_start, *tag_end;
g_assert ( f != NULL && trw != NULL );
line_type = 0;
line_timestamp = 0;
line_newsegment = FALSE;
line_image = NULL;
line_symbol = NULL;
current_track = NULL;
gboolean have_read_something = FALSE;
while (fgets(line_buffer, VIKING_LINE_SIZE, f))
{
gboolean inside_quote = 0;
gboolean backslash = 0;
line_buffer[strlen(line_buffer)-1] = '\0'; /* chop off newline */
/* for gpspoint files wrapped inside */
if ( strlen(line_buffer) >= 13 && strncmp ( line_buffer, "~EndLayerData", 13 ) == 0 ) {
// Even just a blank TRW is ok when in a .vik file
have_read_something = TRUE;
break;
}
/* each line: nullify stuff, make thing if nes, free name if ness */
tag_start = line_buffer;
for (;;)
{
/* my addition: find first non-whitespace character. if the null, skip line. */
while (*tag_start != '\0' && isspace(*tag_start))
tag_start++;
if (*tag_start == '\0')
break;
if (*tag_start == '#')
break;
tag_end = tag_start;
if (*tag_end == '"')
inside_quote = !inside_quote;
while (*tag_end != '\0' && (!isspace(*tag_end) || inside_quote)) {
tag_end++;
if (*tag_end == '\\' && !backslash)
backslash = TRUE;
else if (backslash)
backslash = FALSE;
else if (*tag_end == '"')
inside_quote = !inside_quote;
}
// Won't have super massively long strings, so potential truncation in cast is acceptable.
guint len = (guint)(tag_end - tag_start);
gpspoint_process_tag ( tag_start, len );
if (*tag_end == '\0' )
break;
else
tag_start = tag_end+1;
}
if (line_type == GPSPOINT_TYPE_WAYPOINT && line_name)
{
have_read_something = TRUE;
VikWaypoint *wp = vik_waypoint_new();
wp->visible = line_visible;
wp->altitude = line_altitude;
wp->has_timestamp = line_has_timestamp;
wp->timestamp = line_timestamp;
vik_coord_load_from_latlon ( &(wp->coord), coord_mode, &line_latlon );
vik_trw_layer_filein_add_waypoint ( trw, line_name, wp );
g_free ( line_name );
line_name = NULL;
if ( line_comment )
vik_waypoint_set_comment ( wp, line_comment );
if ( line_description )
vik_waypoint_set_description ( wp, line_description );
if ( line_source )
vik_waypoint_set_source ( wp, line_source );
if ( line_xtype )
vik_waypoint_set_type ( wp, line_xtype );
if ( line_image ) {
// Ensure the filename is absolute
if ( g_path_is_absolute ( line_image ) )
vik_waypoint_set_image ( wp, line_image );
else {
// Otherwise create the absolute filename from the directory of the .vik file & and the relative filename
gchar *full = g_strconcat(dirpath, G_DIR_SEPARATOR_S, line_image, NULL);
gchar *absolute = file_realpath_dup ( full ); // resolved into the canonical name
vik_waypoint_set_image ( wp, absolute );
g_free ( absolute );
g_free ( full );
}
}
if ( line_symbol )
vik_waypoint_set_symbol ( wp, line_symbol );
}
else if ((line_type == GPSPOINT_TYPE_TRACK || line_type == GPSPOINT_TYPE_ROUTE) && line_name)
{
have_read_something = TRUE;
VikTrack *pl = vik_track_new();
// NB don't set defaults here as all properties are stored in the GPS_POINT format
//vik_track_set_defaults ( pl );
/* Thanks to Peter Jones for this Fix */
if (!line_name) line_name = g_strdup("UNK");
pl->visible = line_visible;
pl->is_route = (line_type == GPSPOINT_TYPE_ROUTE);
if ( line_comment )
vik_track_set_comment ( pl, line_comment );
if ( line_description )
vik_track_set_description ( pl, line_description );
if ( line_source )
vik_track_set_source ( pl, line_source );
if ( line_xtype )
vik_track_set_type ( pl, line_xtype );
if ( line_color )
{
if ( gdk_color_parse ( line_color, &(pl->color) ) )
pl->has_color = TRUE;
}
pl->draw_name_mode = line_name_label;
pl->max_number_dist_labels = line_dist_label;
pl->trackpoints = NULL;
vik_trw_layer_filein_add_track ( trw, line_name, pl );
g_free ( line_name );
line_name = NULL;
current_track = pl;
}
else if ((line_type == GPSPOINT_TYPE_TRACKPOINT || line_type == GPSPOINT_TYPE_ROUTEPOINT) && current_track)
{
have_read_something = TRUE;
VikTrackpoint *tp = vik_trackpoint_new();
vik_coord_load_from_latlon ( &(tp->coord), coord_mode, &line_latlon );
tp->newsegment = line_newsegment;
tp->has_timestamp = line_has_timestamp;
tp->timestamp = line_timestamp;
tp->altitude = line_altitude;
vik_trackpoint_set_name ( tp, line_name );
if (line_extended) {
tp->speed = line_speed;
tp->course = line_course;
tp->nsats = line_sat;
tp->fix_mode = line_fix;
tp->hdop = line_hdop;
tp->vdop = line_vdop;
tp->pdop = line_pdop;
}
current_track->trackpoints = g_list_append ( current_track->trackpoints, tp );
}
if (line_name)
g_free ( line_name );
line_name = NULL;
if (line_comment)
g_free ( line_comment );
if (line_description)
g_free ( line_description );
if (line_source)
g_free ( line_source );
if (line_xtype)
g_free ( line_xtype );
if (line_color)
g_free ( line_color );
if (line_image)
g_free ( line_image );
if (line_symbol)
g_free ( line_symbol );
line_comment = NULL;
line_description = NULL;
line_source = NULL;
line_xtype = NULL;
line_color = NULL;
line_image = NULL;
line_symbol = NULL;
line_type = GPSPOINT_TYPE_NONE;
line_newsegment = FALSE;
line_has_timestamp = FALSE;
line_timestamp = 0;
line_altitude = VIK_DEFAULT_ALTITUDE;
line_visible = TRUE;
line_symbol = NULL;
line_extended = FALSE;
line_speed = NAN;
line_course = NAN;
line_sat = 0;
line_fix = 0;
line_hdop = VIK_DEFAULT_DOP;
line_vdop = VIK_DEFAULT_DOP;
line_pdop = VIK_DEFAULT_DOP;
line_name_label = 0;
line_dist_label = 0;
}
return have_read_something;
}
/**
* a_geotag_create_waypoint_from_file:
* @filename: The image file to process
* @vcmode: The current location mode to use in the positioning of Waypoint
* @name: Returns a name for the Waypoint (can be NULL)
*
* Returns: An allocated Waypoint or NULL if Waypoint could not be generated (e.g. no EXIF info)
*
*/
VikWaypoint* a_geotag_create_waypoint_from_file ( const gchar *filename, VikCoordMode vcmode, gchar **name )
{
// Default return values (for failures)
*name = NULL;
VikWaypoint *wp = NULL;
#ifdef HAVE_LIBGEXIV2
GExiv2Metadata *gemd = gexiv2_metadata_new ();
if ( gexiv2_metadata_open_path ( gemd, filename, NULL ) ) {
gdouble lat;
gdouble lon;
gdouble alt;
if ( gexiv2_metadata_get_gps_info ( gemd, &lon, &lat, &alt ) ) {
struct LatLon ll;
ll.lat = lat;
ll.lon = lon;
//
// Now create Waypoint with acquired information
//
wp = vik_waypoint_new();
wp->visible = TRUE;
// Set info from exif values
// Location
vik_coord_load_from_latlon ( &(wp->coord), vcmode, &ll );
// Altitude
wp->altitude = alt;
if ( gexiv2_metadata_has_tag ( gemd, "Exif.Image.XPTitle" ) )
*name = g_strdup ( gexiv2_metadata_get_tag_interpreted_string ( gemd, "Exif.Image.XPTitle" ) );
wp->comment = geotag_get_exif_comment ( gemd );
// Direction
VikWaypointImageDirectionRef ref = WP_IMAGE_DIRECTION_REF_TRUE;
if ( gexiv2_metadata_has_tag ( gemd, EXIF_GPS_IMGDIR_REF ) ) {
gchar* ref_str = gexiv2_metadata_get_tag_interpreted_string(gemd, EXIF_GPS_IMGDIR_REF);
if ( ref_str && g_ascii_strncasecmp ("M", ref_str, 1) == 0 )
ref = WP_IMAGE_DIRECTION_REF_MAGNETIC;
g_free ( ref_str );
}
if ( gexiv2_metadata_has_tag ( gemd, EXIF_GPS_IMGDIR ) ) {
gint nom;
gint den;
gdouble direction = NAN;
if ( gexiv2_metadata_get_exif_tag_rational (gemd, EXIF_GPS_IMGDIR, &nom, &den) )
if ( den != 0 )
direction = (gdouble)nom/(gdouble)den;
if ( !isnan(direction) )
vik_waypoint_set_image_direction_info ( wp, direction, ref );
}
vik_waypoint_set_image ( wp, filename );
}
}
metadata_free ( gemd );
#else
#ifdef HAVE_LIBEXIF
// TODO use log?
//ExifLog *log = NULL;
// open image with libexif
ExifData *ed = exif_data_new_from_file ( filename );
// Detect EXIF load failure
if ( !ed )
// return with no Waypoint
return wp;
struct LatLon ll;
gchar str[128];
ExifEntry *ee;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_VERSION_ID);
// Confirm this has a GPS Id - normally "2.0.0.0" or "2.2.0.0"
if ( ! ( ee && ee->components == 4 ) )
goto MyReturn;
// Could test for these versions explicitly but may have byte order issues...
//if ( ! ( ee->data[0] == 2 && ee->data[2] == 0 && ee->data[3] == 0 ) )
// goto MyReturn;
ll = get_latlon ( ed );
// Hopefully won't have valid images at 0,0!
if ( ll.lat == 0.0 && ll.lon == 0.0 )
goto MyReturn;
//
// Not worried if none of the other fields exist, as can default the values to something
//
gdouble alt = VIK_DEFAULT_ALTITUDE;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_ALTITUDE);
if ( ee && ee->components == 1 && ee->format == EXIF_FORMAT_RATIONAL ) {
alt = Rational2Double ( ee->data,
0,
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_ALTITUDE_REF);
if ( ee && ee->components == 1 && ee->format == EXIF_FORMAT_BYTE && ee->data[0] == 1 )
alt = -alt;
}
// Name
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_TITLE);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
*name = g_strdup ( str );
}
//
// Now create Waypoint with acquired information
//
wp = vik_waypoint_new();
wp->visible = TRUE;
// Set info from exif values
// Location
vik_coord_load_from_latlon ( &(wp->coord), vcmode, &ll );
// Altitude
wp->altitude = alt;
wp->comment = geotag_get_exif_comment ( ed );
vik_waypoint_set_image ( wp, filename );
MyReturn:
// Finished with EXIF
exif_data_free ( ed );
#endif
#endif
return wp;
}
