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_viewport_compute_bearing:
* @vp: self object
* @x1: screen coord
* @y1: screen coord
* @x2: screen coord
* @y2: screen coord
* @angle: bearing in Radian (output)
* @baseangle: UTM base angle in Radian (output)
*
* Compute bearing.
*/
void vik_viewport_compute_bearing ( VikViewport *vp, gint x1, gint y1, gint x2, gint y2, gdouble *angle, gdouble *baseangle )
{
gdouble len = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
gdouble dx = (x2-x1)/len*10;
gdouble dy = (y2-y1)/len*10;
*angle = atan2(dy, dx) + M_PI_2;
if ( vik_viewport_get_drawmode ( vp ) == VIK_VIEWPORT_DRAWMODE_UTM) {
VikCoord test;
struct LatLon ll;
struct UTM u;
gint tx, ty;
vik_viewport_screen_to_coord ( vp, x1, y1, &test );
vik_coord_to_latlon ( &test, &ll );
ll.lat += vik_viewport_get_ympp ( vp ) * vik_viewport_get_height ( vp ) / 11000.0; // about 11km per degree latitude
a_coords_latlon_to_utm ( &ll, &u );
vik_coord_load_from_utm ( &test, VIK_VIEWPORT_DRAWMODE_UTM, &u );
vik_viewport_coord_to_screen ( vp, &test, &tx, &ty );
*baseangle = M_PI - atan2(tx-x1, ty-y1);
*angle -= *baseangle;
}
if (*angle < 0)
*angle += 2*M_PI;
if (*angle > 2*M_PI)
*angle -= 2*M_PI;
}
gchar vik_viewport_rightmost_zone ( VikViewport *vvp )
{
if ( vvp->coord_mode == VIK_COORD_UTM ) {
VikCoord coord;
g_assert ( vvp != NULL );
vik_viewport_screen_to_coord ( vvp, vvp->width, 0, &coord );
return coord.utm_zone;
}
return '\0';
}
void vik_viewport_get_min_max_lat_lon ( VikViewport *vp, gdouble *min_lat, gdouble *max_lat, gdouble *min_lon, gdouble *max_lon )
{
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, vp->width, vp->height, &bright );
vik_coord_convert(&tleft, VIK_COORD_LATLON);
vik_coord_convert(&tright, VIK_COORD_LATLON);
vik_coord_convert(&bleft, VIK_COORD_LATLON);
vik_coord_convert(&bright, VIK_COORD_LATLON);
*max_lat = MAX(tleft.north_south, tright.north_south);
*min_lat = MIN(bleft.north_south, bright.north_south);
*max_lon = MAX(tright.east_west, bright.east_west);
*min_lon = MIN(tleft.east_west, bleft.east_west);
}
void vik_viewport_set_center_screen ( VikViewport *vvp, int x, int y )
{
g_return_if_fail ( vvp != NULL );
if ( vvp->coord_mode == VIK_COORD_UTM ) {
/* slightly optimized */
vvp->center.east_west += vvp->xmpp * (x - (vvp->width/2));
vvp->center.north_south += vvp->ympp * ((vvp->height/2) - y);
viewport_utm_zone_check ( vvp );
} else {
VikCoord tmp;
vik_viewport_screen_to_coord ( vvp, x, y, &tmp );
vik_viewport_set_center_coord ( vvp, &tmp );
}
}
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= */
}
}
static gboolean dem_layer_download_release ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp )
{
VikCoord coord;
static struct LatLon ll;
gchar *full_path;
gchar *dem_file = NULL;
vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord );
vik_coord_to_latlon ( &coord, &ll );
if ( vdl->source == DEM_SOURCE_SRTM )
dem_file = srtm_lat_lon_to_dest_fn ( ll.lat, ll.lon );
#ifdef VIK_CONFIG_DEM24K
else if ( vdl->source == DEM_SOURCE_DEM24K )
dem_file = dem24k_lat_lon_to_dest_fn ( ll.lat, ll.lon );
#endif
if ( ! dem_file )
return TRUE;
full_path = g_strdup_printf("%s%s", MAPS_CACHE_DIR, dem_file );
g_debug("%s: %s", __FUNCTION__, full_path);
if ( event->button == 1 ) {
// TODO: check if already in filelist
if ( ! dem_layer_add_file(vdl, full_path) ) {
gchar *tmp = g_strdup_printf ( _("Downloading DEM %s"), dem_file );
DEMDownloadParams *p = g_malloc(sizeof(DEMDownloadParams));
p->dest = g_strdup(full_path);
p->lat = ll.lat;
p->lon = ll.lon;
p->vdl = vdl;
p->mutex = g_mutex_new();
p->source = vdl->source;
g_object_weak_ref(G_OBJECT(p->vdl), weak_ref_cb, p );
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) );
}
else {
if ( !vdl->right_click_menu ) {
GtkWidget *item;
vdl->right_click_menu = GTK_MENU ( gtk_menu_new () );
item = gtk_image_menu_item_new_with_mnemonic ( _("_Show DEM File Information") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU) );
g_signal_connect ( G_OBJECT(item), "activate", G_CALLBACK(dem_layer_file_info), &ll );
gtk_menu_shell_append (GTK_MENU_SHELL(vdl->right_click_menu), item);
}
gtk_menu_popup ( vdl->right_click_menu, NULL, NULL, NULL, NULL, event->button, event->time );
gtk_widget_show_all ( GTK_WIDGET(vdl->right_click_menu) );
}
g_free ( dem_file );
g_free ( full_path );
return TRUE;
}
void vik_viewport_draw_scale ( VikViewport *vvp )
{
g_return_if_fail ( vvp != NULL );
if ( vvp->draw_scale ) {
VikCoord left, right;
gdouble unit, base, diff, old_unit, old_diff, ratio;
gint odd, len, SCSIZE = 5, HEIGHT=10;
PangoLayout *pl;
gchar s[128];
vik_viewport_screen_to_coord ( vvp, 0, vvp->height, &left );
vik_viewport_screen_to_coord ( vvp, vvp->width/SCSIZE, vvp->height, &right );
vik_units_distance_t dist_units = a_vik_get_units_distance ();
switch (dist_units) {
case VIK_UNITS_DISTANCE_KILOMETRES:
base = vik_coord_diff ( &left, &right ); // in meters
break;
case VIK_UNITS_DISTANCE_MILES:
// in 0.1 miles (copes better when zoomed in as 1 mile can be too big)
base = VIK_METERS_TO_MILES(vik_coord_diff ( &left, &right )) * 10.0;
break;
default:
base = 1; // Keep the compiler happy
g_critical("Houston, we've had a problem. distance=%d", dist_units);
}
ratio = (vvp->width/SCSIZE)/base;
unit = 1;
diff = fabs(base-unit);
old_unit = unit;
old_diff = diff;
odd = 1;
while (diff <= old_diff) {
old_unit = unit;
old_diff = diff;
unit = unit * (odd%2 ? 5 : 2);
diff = fabs(base-unit);
odd++;
}
unit = old_unit;
len = unit * ratio;
/* white background */
vik_viewport_draw_line(vvp, vvp->scale_bg_gc,
PAD, vvp->height-PAD, PAD + len, vvp->height-PAD);
vik_viewport_draw_line(vvp, vvp->scale_bg_gc,
PAD, vvp->height-PAD, PAD, vvp->height-PAD-HEIGHT);
vik_viewport_draw_line(vvp, vvp->scale_bg_gc,
PAD + len, vvp->height-PAD, PAD + len, vvp->height-PAD-HEIGHT);
/* black scale */
vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc,
PAD, vvp->height-PAD, PAD + len, vvp->height-PAD);
vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc,
PAD, vvp->height-PAD, PAD, vvp->height-PAD-HEIGHT);
vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc,
PAD + len, vvp->height-PAD, PAD + len, vvp->height-PAD-HEIGHT);
if (odd%2) {
int i;
for (i=1; i<5; i++) {
vik_viewport_draw_line(vvp, vvp->scale_bg_gc,
PAD+i*len/5, vvp->height-PAD, PAD+i*len/5, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2)));
vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc,
PAD+i*len/5, vvp->height-PAD, PAD+i*len/5, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2)));
}
} else {
int i;
for (i=1; i<10; i++) {
vik_viewport_draw_line(vvp, vvp->scale_bg_gc,
PAD+i*len/10, vvp->height-PAD, PAD+i*len/10, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2)));
vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc,
PAD+i*len/10, vvp->height-PAD, PAD+i*len/10, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2)));
}
}
pl = gtk_widget_create_pango_layout (GTK_WIDGET(&vvp->drawing_area), NULL);
pango_layout_set_font_description (pl, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->font_desc);
switch (dist_units) {
case VIK_UNITS_DISTANCE_KILOMETRES:
if (unit >= 1000) {
sprintf(s, "%d km", (int)unit/1000);
} else {
sprintf(s, "%d m", (int)unit);
}
break;
case VIK_UNITS_DISTANCE_MILES:
// Handle units in 0.1 miles
if (unit < 10.0) {
sprintf(s, "%0.1f miles", unit/10.0);
}
else if ((int)unit == 10.0) {
sprintf(s, "1 mile");
}
else {
sprintf(s, "%d miles", (int)(unit/10.0));
}
break;
default:
g_critical("Houston, we've had a problem. distance=%d", dist_units);
}
pango_layout_set_text(pl, s, -1);
vik_viewport_draw_layout(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc,
PAD + len + PAD, vvp->height - PAD - 10, pl);
g_object_unref(pl);
pl = NULL;
}
}
/* returns TRUE if OK was pressed. */
static gboolean georef_layer_dialog ( VikGeorefLayer **vgl, gpointer vp, GtkWindow *w )
{
GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Layer Properties"),
w,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL );
/* Default to reject as user really needs to specify map file first */
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
#endif
GtkWidget *table, *wfp_hbox, *wfp_label, *wfp_button, *ce_label, *ce_spin, *cn_label, *cn_spin, *xlabel, *xspin, *ylabel, *yspin, *imagelabel, *imageentry;
GtkWidget *pass_along[4];
table = gtk_table_new ( 6, 2, FALSE );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0 );
wfp_hbox = gtk_hbox_new ( FALSE, 0 );
wfp_label = gtk_label_new ( _("World File Parameters:") );
wfp_button = gtk_button_new_with_label ( _("Load From File...") );
gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_label, TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_button, FALSE, FALSE, 3 );
ce_label = gtk_label_new ( _("Corner pixel easting:") );
ce_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, 0.0, 1500000.0, 1, 5, 0 ), 1, 4 );
gtk_widget_set_tooltip_text ( GTK_WIDGET(ce_spin), _("the UTM \"easting\" value of the upper-left corner pixel of the map") );
cn_label = gtk_label_new ( _("Corner pixel northing:") );
cn_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, 0.0, 9000000.0, 1, 5, 0 ), 1, 4 );
gtk_widget_set_tooltip_text ( GTK_WIDGET(cn_spin), _("the UTM \"northing\" value of the upper-left corner pixel of the map") );
xlabel = gtk_label_new ( _("X (easting) scale (mpp): "));
ylabel = gtk_label_new ( _("Y (northing) scale (mpp): "));
xspin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 );
gtk_widget_set_tooltip_text ( GTK_WIDGET(xspin), _("the scale of the map in the X direction (meters per pixel)") );
yspin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 );
gtk_widget_set_tooltip_text ( GTK_WIDGET(yspin), _("the scale of the map in the Y direction (meters per pixel)") );
imagelabel = gtk_label_new ( _("Map Image:") );
imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN);
if (*vgl)
{
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(ce_spin), (*vgl)->corner.easting );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cn_spin), (*vgl)->corner.northing );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(xspin), (*vgl)->mpp_easting );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(yspin), (*vgl)->mpp_northing );
if ( (*vgl)->image )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(imageentry), (*vgl)->image );
}
else
{
VikCoord corner_coord;
struct UTM utm;
vik_viewport_screen_to_coord ( VIK_VIEWPORT(vp), 0, 0, &corner_coord );
vik_coord_to_utm ( &corner_coord, &utm );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(ce_spin), utm.easting );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cn_spin), utm.northing );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(xspin), vik_viewport_get_xmpp ( VIK_VIEWPORT(vp) ) );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(yspin), vik_viewport_get_ympp ( VIK_VIEWPORT(vp) ) );
}
gtk_table_attach_defaults ( GTK_TABLE(table), imagelabel, 0, 1, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table), imageentry, 1, 2, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table), wfp_hbox, 0, 2, 1, 2 );
gtk_table_attach_defaults ( GTK_TABLE(table), xlabel, 0, 1, 2, 3 );
gtk_table_attach_defaults ( GTK_TABLE(table), xspin, 1, 2, 2, 3 );
gtk_table_attach_defaults ( GTK_TABLE(table), ylabel, 0, 1, 3, 4 );
gtk_table_attach_defaults ( GTK_TABLE(table), yspin, 1, 2, 3, 4 );
gtk_table_attach_defaults ( GTK_TABLE(table), ce_label, 0, 1, 4, 5 );
gtk_table_attach_defaults ( GTK_TABLE(table), ce_spin, 1, 2, 4, 5 );
gtk_table_attach_defaults ( GTK_TABLE(table), cn_label, 0, 1, 5, 6 );
gtk_table_attach_defaults ( GTK_TABLE(table), cn_spin, 1, 2, 5, 6 );
pass_along[0] = xspin;
pass_along[1] = yspin;
pass_along[2] = ce_spin;
pass_along[3] = cn_spin;
g_signal_connect_swapped ( G_OBJECT(wfp_button), "clicked", G_CALLBACK(georef_layer_dialog_load), pass_along );
if ( response_w )
gtk_widget_grab_focus ( response_w );
gtk_widget_show_all ( table );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
if (! *vgl)
{
*vgl = georef_layer_new ( VIK_VIEWPORT(vp) );
vik_layer_rename ( VIK_LAYER(*vgl), vik_georef_layer_interface.name );
}
(*vgl)->corner.easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(ce_spin) );
(*vgl)->corner.northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cn_spin) );
(*vgl)->mpp_easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(xspin) );
(*vgl)->mpp_northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(yspin) );
if ( (!(*vgl)->image) || strcmp( (*vgl)->image, vik_file_entry_get_filename(VIK_FILE_ENTRY(imageentry)) ) != 0 )
{
georef_layer_set_image ( *vgl, vik_file_entry_get_filename(VIK_FILE_ENTRY(imageentry)) );
georef_layer_load_image ( *vgl, VIK_VIEWPORT(vp), FALSE );
}
gtk_widget_destroy ( GTK_WIDGET(dialog) );
return TRUE;
}
gtk_widget_destroy ( GTK_WIDGET(dialog) );
return FALSE;
}
