static VikGeorefLayer *georef_layer_new ( VikViewport *vvp ) { VikGeorefLayer *vgl = VIK_GEOREF_LAYER ( g_object_new ( VIK_GEOREF_LAYER_TYPE, NULL ) ); vik_layer_set_type ( VIK_LAYER(vgl), VIK_LAYER_GEOREF ); // Since GeoRef layer doesn't use uibuilder // initializing this way won't do anything yet.. vik_layer_set_defaults ( VIK_LAYER(vgl), vvp ); // Make these defaults based on the current view vgl->mpp_northing = vik_viewport_get_ympp ( vvp ); vgl->mpp_easting = vik_viewport_get_xmpp ( vvp ); vik_coord_to_utm ( vik_viewport_get_center ( vvp ), &(vgl->corner) ); vgl->image = NULL; vgl->pixbuf = NULL; vgl->click_x = -1; vgl->click_y = -1; vgl->scaled = NULL; vgl->scaled_width = 0; vgl->scaled_height = 0; vgl->ll_br.lat = 0.0; vgl->ll_br.lon = 0.0; vgl->alpha = 255; return vgl; }
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. */ } } }
void a_print(VikWindow *vw, VikViewport *vvp) { /* TODO: make print_settings non-static when saving_settings_to_file is * implemented. Keep it static for now to retain settings for each * viking session */ static GtkPrintSettings *print_settings = NULL; GtkPrintOperation *print_oper; GtkPrintOperationResult res; PrintData data; print_oper = gtk_print_operation_new (); data.num_pages = 1; data.vw = vw; data.vvp = vvp; data.offset_x = 0; data.offset_y = 0; data.center = VIK_PRINT_CENTER_BOTH; data.use_full_page = FALSE; data.operation = print_oper; data.xmpp = vik_viewport_get_xmpp(vvp); data.ympp = vik_viewport_get_ympp(vvp); data.width = vik_viewport_get_width(vvp); data.height = vik_viewport_get_height(vvp); data.xres = data.yres = 230; /* FIXME */ if (print_settings != NULL) gtk_print_operation_set_print_settings (print_oper, print_settings); g_signal_connect (print_oper, "begin_print", G_CALLBACK (begin_print), &data); g_signal_connect (print_oper, "draw_page", G_CALLBACK (draw_page), &data); g_signal_connect (print_oper, "end-print", G_CALLBACK (end_print), &data); g_signal_connect (print_oper, "create-custom-widget", G_CALLBACK (create_custom_widget_cb), &data); gtk_print_operation_set_custom_tab_label (print_oper, _("Image Settings")); res = gtk_print_operation_run (print_oper, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (vw), NULL); if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { if (print_settings != NULL) g_object_unref (print_settings); print_settings = g_object_ref (gtk_print_operation_get_print_settings (print_oper)); } g_object_unref (print_oper); }
static gboolean georef_layer_move_release ( VikGeorefLayer *vgl, GdkEventButton *event, VikViewport *vvp ) { if (!vgl || vgl->vl.type != VIK_LAYER_GEOREF) return FALSE; if ( vgl->click_x != -1 ) { vgl->corner.easting += (event->x - vgl->click_x) * vik_viewport_get_xmpp (vvp); vgl->corner.northing -= (event->y - vgl->click_y) * vik_viewport_get_ympp (vvp); vik_layer_emit_update ( VIK_LAYER(vgl) ); return TRUE; } return FALSE; /* I didn't move anything on this layer! */ }
static void file_write ( VikAggregateLayer *top, FILE *f, gpointer vp ) { Stack *stack = NULL; VikLayer *current_layer; struct LatLon ll; VikViewportDrawMode mode; gchar *modestring = NULL; push(&stack); stack->data = (gpointer) vik_aggregate_layer_get_children(VIK_AGGREGATE_LAYER(top)); stack->under = NULL; /* crazhy CRAZHY */ vik_coord_to_latlon ( vik_viewport_get_center ( VIK_VIEWPORT(vp) ), &ll ); mode = vik_viewport_get_drawmode ( VIK_VIEWPORT(vp) ); switch ( mode ) { case VIK_VIEWPORT_DRAWMODE_UTM: modestring = "utm"; break; case VIK_VIEWPORT_DRAWMODE_EXPEDIA: modestring = "expedia"; break; case VIK_VIEWPORT_DRAWMODE_MERCATOR: modestring = "mercator"; break; case VIK_VIEWPORT_DRAWMODE_LATLON: modestring = "latlon"; break; default: g_critical("Houston, we've had a problem. mode=%d", mode); } fprintf ( f, "#VIKING GPS Data file " VIKING_URL "\n" ); fprintf ( f, "FILE_VERSION=%d\n", VIKING_FILE_VERSION ); fprintf ( f, "\nxmpp=%f\nympp=%f\nlat=%f\nlon=%f\nmode=%s\ncolor=%s\nhighlightcolor=%s\ndrawscale=%s\ndrawcentermark=%s\ndrawhighlight=%s\n", vik_viewport_get_xmpp ( VIK_VIEWPORT(vp) ), vik_viewport_get_ympp ( VIK_VIEWPORT(vp) ), ll.lat, ll.lon, modestring, vik_viewport_get_background_color(VIK_VIEWPORT(vp)), vik_viewport_get_highlight_color(VIK_VIEWPORT(vp)), vik_viewport_get_draw_scale(VIK_VIEWPORT(vp)) ? "t" : "f", vik_viewport_get_draw_centermark(VIK_VIEWPORT(vp)) ? "t" : "f", vik_viewport_get_draw_highlight(VIK_VIEWPORT(vp)) ? "t" : "f" ); if ( ! VIK_LAYER(top)->visible ) fprintf ( f, "visible=f\n" ); while (stack && stack->data) { current_layer = VIK_LAYER(((GList *)stack->data)->data); fprintf ( f, "\n~Layer %s\n", vik_layer_get_interface(current_layer->type)->fixed_layer_name ); write_layer_params_and_data ( current_layer, f ); if ( current_layer->type == VIK_LAYER_AGGREGATE && !vik_aggregate_layer_is_empty(VIK_AGGREGATE_LAYER(current_layer)) ) { push(&stack); stack->data = (gpointer) vik_aggregate_layer_get_children(VIK_AGGREGATE_LAYER(current_layer)); } else if ( current_layer->type == VIK_LAYER_GPS && !vik_gps_layer_is_empty(VIK_GPS_LAYER(current_layer)) ) { push(&stack); stack->data = (gpointer) vik_gps_layer_get_children(VIK_GPS_LAYER(current_layer)); } else { stack->data = (gpointer) ((GList *)stack->data)->next; fprintf ( f, "~EndLayer\n\n" ); while ( stack && (!stack->data) ) { pop(&stack); if ( stack ) { stack->data = (gpointer) ((GList *)stack->data)->next; fprintf ( f, "~EndLayer\n\n" ); } } } } /* get vikaggregatelayer's children (?) foreach write ALL params, then layer data (IF function exists) then endlayer impl: stack of layers (LIST) we are working on when layer->next == NULL ... we move on. */ }
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= */ } }
/* 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; }