diff options
Diffstat (limited to 'src/dw-hdfsee.c')
| -rw-r--r-- | src/dw-hdfsee.c | 1573 |
1 files changed, 1573 insertions, 0 deletions
diff --git a/src/dw-hdfsee.c b/src/dw-hdfsee.c new file mode 100644 index 00000000..9c42bf5b --- /dev/null +++ b/src/dw-hdfsee.c @@ -0,0 +1,1573 @@ +/* + * dw-hdfsee.c + * + * Quick yet non-crappy HDF viewer + * + * (c) 2006-2010 Thomas White <taw@physics.org> + * + * Part of CrystFEL - crystallography with a FEL + * + */ + + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gtk/gtk.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <cairo.h> +#include <gdk-pixbuf/gdk-pixbuf.h> + +#include "dw-hdfsee.h" +#include "render.h" +#include "hdf5-file.h" +#include "hdfsee.h" +#include "utils.h" +#include "detector.h" + + +static void displaywindow_error(DisplayWindow *dw, const char *message) +{ + GtkWidget *window; + + window = gtk_message_dialog_new(GTK_WINDOW(dw->window), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_CLOSE, message); + gtk_window_set_title(GTK_WINDOW(window), "Error"); + + g_signal_connect_swapped(window, "response", + G_CALLBACK(gtk_widget_destroy), window); + gtk_widget_show(window); +} + + +static void displaywindow_update(DisplayWindow *dw) +{ + gint width; + GdkGeometry geom; + + if ( dw->image == NULL ) { + dw->width = 320; + dw->height = 320; + } else { + + double min_x, min_y, max_x, max_y; + + get_pixel_extents(dw->image->det, + &min_x, &min_y, &max_x, &max_y); + + if ( min_x > 0.0 ) min_x = 0.0; + if ( max_x < 0.0 ) max_x = 0.0; + if ( min_y > 0.0 ) min_y = 0.0; + if ( max_y < 0.0 ) max_y = 0.0; + dw->min_x = min_x; + dw->max_x = max_x; + dw->min_y = min_y; + dw->max_y = max_y; + + dw->width = (max_x - min_x) / dw->binning; + dw->height = (max_y - min_y) / dw->binning; + + /* Add a thin border */ + dw->width += 2.0; + dw->height += 2.0; + } + + width = dw->width; + if ( dw->show_col_scale ) width += 20; + + gtk_widget_set_size_request(GTK_WIDGET(dw->drawingarea), width, + dw->height); + geom.min_width = -1; + geom.min_height = -1; + geom.max_width = -1; + geom.max_height = -1; + gtk_window_set_geometry_hints(GTK_WINDOW(dw->window), + GTK_WIDGET(dw->drawingarea), &geom, + GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE); + + /* Free old pixbufs */ + if ( dw->pixbufs != NULL ) { + int i; + for ( i=0; i<dw->n_pixbufs; i++ ) { + gdk_pixbuf_unref(dw->pixbufs[i]); + } + free(dw->pixbufs); + } + if ( dw->col_scale != NULL ) { + gdk_pixbuf_unref(dw->col_scale); + } + + if ( dw->image != NULL ) { + dw->pixbufs = render_panels(dw->image, dw->binning, + dw->scale, dw->boostint, + &dw->n_pixbufs); + } else { + dw->pixbufs = NULL; + } + + dw->col_scale = render_get_colour_scale(20, dw->height, dw->scale); + + /* Schedule redraw */ + gdk_window_invalidate_rect(dw->drawingarea->window, NULL, FALSE); +} + + +/* Window closed - clean up */ +static gint displaywindow_closed(GtkWidget *window, DisplayWindow *dw) +{ + if ( dw->hdfile != NULL ) { + hdfile_close(dw->hdfile); + } + + /* Notify 'main', so it can update the master list */ + hdfsee_window_closed(dw); + + return 0; +} + + +static double ring_radius(struct image *image, double d) +{ + double theta, r, r_px; + + theta = asin(image->lambda / (2.0*d)); + r = image->det->panels[0].clen * tan(2.0*theta); + r_px = r * image->det->panels[0].res; + + return r_px; +} + + +static void show_ring(cairo_t *cr, DisplayWindow *dw, + double d, const char *label) +{ + cairo_identity_matrix(cr); + cairo_translate(cr, -dw->min_x/dw->binning, dw->max_y/dw->binning); + cairo_arc(cr, 0.0, 0.0, ring_radius(dw->image, d)/dw->binning, + 0.0, 2.0*M_PI); + cairo_set_source_rgb(cr, 1.0, 0.0, 0.0); + cairo_set_line_width(cr, 1.0); + cairo_stroke(cr); + cairo_rotate(cr, -M_PI/4.0); + cairo_translate(cr, 0.0, + ring_radius(dw->image, d)/dw->binning-5.0); + cairo_set_font_size(cr, 20.0); + cairo_show_text(cr, label); + cairo_fill(cr); +} + + +static int draw_stuff(cairo_surface_t *surf, DisplayWindow *dw) +{ + cairo_t *cr; + int i; + cairo_matrix_t basic_m; + cairo_matrix_t m; + + cr = cairo_create(surf); + + /* Blank white background */ + cairo_rectangle(cr, 0.0, 0.0, dw->width, dw->height); + cairo_set_source_rgb(cr, 0.5, 0.5, 0.5); + cairo_fill(cr); + + if ( dw->image == NULL ) return 0; + + /* Set up basic coordinate system + * - origin in the centre, y upwards. */ + cairo_identity_matrix(cr); + cairo_matrix_init(&m, 1.0, 0.0, 0.0, -1.0, 0.0, 0.0); + cairo_translate(cr, -dw->min_x/dw->binning, dw->max_y/dw->binning); + cairo_transform(cr, &m); + cairo_get_matrix(cr, &basic_m); + + if ( dw->pixbufs != NULL ) { + + int i; + + for ( i=0; i<dw->image->det->n_panels; i++ ) { + + struct panel p = dw->image->det->panels[i]; + int w = gdk_pixbuf_get_width(dw->pixbufs[i]); + int h = gdk_pixbuf_get_height(dw->pixbufs[i]); + cairo_matrix_t m; + + /* Start with the basic coordinate system */ + cairo_set_matrix(cr, &basic_m); + + /* Move to the right location */ + cairo_translate(cr, p.cnx/dw->binning, + p.cny/dw->binning); + + /* Twiddle directions according to matrix */ + cairo_matrix_init(&m, p.fsx, p.fsy, p.ssx, p.ssy, + 0.0, 0.0); + cairo_transform(cr, &m); + + gdk_cairo_set_source_pixbuf(cr, dw->pixbufs[i], + 0.0, 0.0); + cairo_rectangle(cr, 0.0, 0.0, w, h); + cairo_fill(cr); + + } + + } + + if ( (dw->show_col_scale) && (dw->col_scale != NULL) ) { + cairo_identity_matrix(cr); + cairo_translate(cr, dw->width, 0.0); + cairo_rectangle(cr, 0.0, 0.0, 20.0, dw->height); + gdk_cairo_set_source_pixbuf(cr, dw->col_scale, 0.0, 0.0); + cairo_fill(cr); + } + + if ( dw->show_rings ) { + + /* Mark the beam */ + cairo_set_matrix(cr, &basic_m); + cairo_arc(cr, 0.0, 0.0, 5.0/dw->binning, 0.0, 2.0*M_PI); + cairo_set_source_rgb(cr, 1.0, 0.0, 0.0); + cairo_fill(cr); + + /* Draw resolution circles */ + show_ring(cr, dw, 10.0e-10, "10A"); + show_ring(cr, dw, 8.0e-10, "8A"); + show_ring(cr, dw, 5.0e-10, "5A"); + show_ring(cr, dw, 4.0e-10, "4A"); + show_ring(cr, dw, 3.0e-10, "3A"); + show_ring(cr, dw, 2.0e-10, "2A"); + show_ring(cr, dw, 1.0e-10, "1A"); + + } + + if ( dw->image->features == NULL ) { + cairo_destroy(cr); + return 0; + } + + /* Ensure a clean Cairo context, since the rings often cause + * matrix trouble */ + cairo_destroy(cr); + cr = cairo_create(surf); + + cairo_set_matrix(cr, &basic_m); + for ( i=0; i<image_feature_count(dw->image->features); i++ ) { + + double fs, ss; + double x, y, xs, ys; + struct imagefeature *f; + struct panel *p; + + f = image_get_feature(dw->image->features, i); + if ( f == NULL ) continue; + + fs = f->x; + ss = f->y; + + p = find_panel(dw->image->det, fs, ss); + if ( p == NULL ) continue; + + xs = (fs-p->min_fs)*p->fsx + (ss-p->min_ss)*p->ssx; + ys = (fs-p->min_fs)*p->fsy + (ss-p->min_ss)*p->ssy; + x = xs + p->cnx; + y = ys + p->cny; + + cairo_arc(cr, x/dw->binning, y/dw->binning, + 7.0/dw->binning, 0.0, 2.0*M_PI); + switch ( dw->scale ) { + + case SCALE_COLOUR : + cairo_set_source_rgb(cr, 1.0, 1.0, 0.0); + break; + + case SCALE_MONO : + cairo_set_source_rgb(cr, 1.0, 1.0, 1.0); + break; + + case SCALE_INVMONO: + cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); + break; + + } + + cairo_set_line_width(cr, 0.75); + cairo_stroke(cr); + + } + + cairo_destroy(cr); + + return 0; +} + + +static gboolean displaywindow_expose(GtkWidget *da, GdkEventExpose *event, + DisplayWindow *dw) +{ + cairo_t *cr; + cairo_surface_t *surf; + + cr = gdk_cairo_create(da->window); + surf = cairo_get_target(cr); + draw_stuff(surf, dw); + cairo_destroy(cr); + + return FALSE; +} + + +static int write_png(const char *filename, DisplayWindow *dw) +{ + cairo_status_t r; + cairo_t *cr; + cairo_surface_t *surf; + + surf = gdk_window_create_similar_surface(dw->drawingarea->window, + CAIRO_CONTENT_COLOR, + dw->width, dw->height); + + draw_stuff(surf, dw); + + r = cairo_surface_write_to_png(surf, filename); + if ( r != CAIRO_STATUS_SUCCESS ) return 1; + + cairo_destroy(cr); + cairo_surface_destroy(surf); + + return 0; +} + + +static gint displaywindow_close(GtkWidget *widget, DisplayWindow *dw) +{ + gtk_widget_destroy(dw->window); + return 0; +} + + +static gint displaywindow_set_binning_response(GtkWidget *widget, gint response, + DisplayWindow *dw) +{ + int done = 1; + + if ( response == GTK_RESPONSE_OK ) { + + const char *sbinning; + unsigned int binning; + int scanval; + + sbinning = gtk_entry_get_text( + GTK_ENTRY(dw->binning_dialog->entry)); + scanval = sscanf(sbinning, "%u", &binning); + if ( (scanval != 1) || (binning <= 0) ) { + displaywindow_error(dw, + "Please enter a positive integer for the " + "binning factor."); + done = 0; + } else { + if ((binning < dw->image->width/10) + && (binning < dw->image->height/10)) { + dw->binning = binning; + displaywindow_update(dw); + } else { + displaywindow_error(dw, + "Please enter a sensible value for " + "the binning factor."); + done = 0; + } + } + } + + if ( done ) { + gtk_widget_destroy(dw->binning_dialog->window); + } + + return 0; + +} + + +static gint displaywindow_set_binning_destroy(GtkWidget *widget, + DisplayWindow *dw) +{ + free(dw->binning_dialog); + dw->binning_dialog = NULL; + return 0; +} + + +static gint displaywindow_set_binning_response_ac(GtkWidget *widget, + DisplayWindow *dw) +{ + return displaywindow_set_binning_response(widget, GTK_RESPONSE_OK, dw); +} + + +/* Create a window to ask the user for a new binning factor */ +static gint displaywindow_set_binning(GtkWidget *widget, DisplayWindow *dw) +{ + BinningDialog *bd; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *table; + GtkWidget *label; + char tmp[64]; + + if ( dw->binning_dialog != NULL ) { + return 0; + } + + if ( dw->hdfile == NULL ) { + return 0; + } + + bd = malloc(sizeof(BinningDialog)); + if ( bd == NULL ) return 0; + dw->binning_dialog = bd; + + bd->window = gtk_dialog_new_with_buttons("Set Binning", + GTK_WINDOW(dw->window), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_STOCK_CANCEL, GTK_RESPONSE_CLOSE, + GTK_STOCK_OK, GTK_RESPONSE_OK, + NULL); + + vbox = gtk_vbox_new(FALSE, 0); + hbox = gtk_hbox_new(TRUE, 0); + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(bd->window)->vbox), + GTK_WIDGET(hbox), FALSE, FALSE, 7); + gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), FALSE, FALSE, 5); + + table = gtk_table_new(3, 2, FALSE); + gtk_table_set_row_spacings(GTK_TABLE(table), 5); + gtk_table_set_col_spacings(GTK_TABLE(table), 5); + gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, FALSE, 0); + + label = gtk_label_new("Smaller numbers mean larger images on screen"); + gtk_label_set_markup(GTK_LABEL(label), + "<span style=\"italic\" weight=\"light\">" + "Smaller numbers mean larger images on screen</span>"); + gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label), + 1, 3, 1, 2); + + snprintf(tmp, 63, "Raw image size: %i by %i pixels", + dw->image->width, dw->image->height); + label = gtk_label_new(tmp); + gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label), + 1, 3, 2, 3); + + label = gtk_label_new("Binning Factor:"); + gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5); + gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label), + 1, 2, 3, 4); + + bd->entry = gtk_entry_new(); + snprintf(tmp, 63, "%i", dw->binning); + gtk_entry_set_text(GTK_ENTRY(bd->entry), tmp); + gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(bd->entry), + 2, 3, 3, 4); + + g_signal_connect(G_OBJECT(bd->entry), "activate", + G_CALLBACK(displaywindow_set_binning_response_ac), dw); + g_signal_connect(G_OBJECT(bd->window), "response", + G_CALLBACK(displaywindow_set_binning_response), dw); + g_signal_connect(G_OBJECT(bd->window), "destroy", + G_CALLBACK(displaywindow_set_binning_destroy), dw); + gtk_window_set_resizable(GTK_WINDOW(bd->window), FALSE); + gtk_widget_show_all(bd->window); + gtk_widget_grab_focus(GTK_WIDGET(bd->entry)); + + return 0; +} + + +static gint displaywindow_set_boostint_response(GtkWidget *widget, + gint response, + DisplayWindow *dw) +{ + int done = 1; + + if ( response == GTK_RESPONSE_OK ) { + + const char *sboostint; + float boostint; + int scanval; + + sboostint = gtk_entry_get_text( + GTK_ENTRY(dw->boostint_dialog->entry)); + scanval = sscanf(sboostint, "%f", &boostint); + if ( (scanval != 1) || (boostint <= 0) ) { + displaywindow_error(dw, "Please enter a positive " + "number for the intensity boost " + "factor."); + done = 0; + } else { + dw->boostint = boostint; + displaywindow_update(dw); + } + } + + if ( done ) { + gtk_widget_destroy(dw->boostint_dialog->window); + } + + return 0; +} + + +static gint displaywindow_set_boostint_destroy(GtkWidget *widget, + DisplayWindow *dw) +{ + free(dw->boostint_dialog); + dw->boostint_dialog = NULL; + return 0; +} + + +static gint displaywindow_set_boostint_response_ac(GtkWidget *widget, + DisplayWindow *dw) +{ + return displaywindow_set_boostint_response(widget, GTK_RESPONSE_OK, dw); +} + + +/* Create a window to ask the user for a new intensity boost factor */ +static gint displaywindow_set_boostint(GtkWidget *widget, DisplayWindow *dw) +{ + BoostIntDialog *bd; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *table; + GtkWidget *label; + char tmp[64]; + + if ( dw->boostint_dialog != NULL ) { + return 0; + } + + if ( dw->hdfile == NULL ) { + return 0; + } + + bd = malloc(sizeof(BoostIntDialog)); + if ( bd == NULL ) return 0; + dw->boostint_dialog = bd; + + bd->window = gtk_dialog_new_with_buttons("Intensity Boost", + GTK_WINDOW(dw->window), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_STOCK_CANCEL, GTK_RESPONSE_CLOSE, + GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); + + vbox = gtk_vbox_new(FALSE, 0); + hbox = gtk_hbox_new(TRUE, 0); + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(bd->window)->vbox), + GTK_WIDGET(hbox), FALSE, FALSE, 7); + gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), FALSE, FALSE, 5); + + table = gtk_table_new(3, 2, FALSE); + gtk_table_set_row_spacings(GTK_TABLE(table), 5); + gtk_table_set_col_spacings(GTK_TABLE(table), 5); + gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, FALSE, 0); + + label = gtk_label_new("Boost Factor:"); + gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5); + gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label), + 1, 2, 3, 4); + + bd->entry = gtk_entry_new(); + snprintf(tmp, 63, "%.2f", dw->boostint); + gtk_entry_set_text(GTK_ENTRY(bd->entry), tmp); + gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(bd->entry), + 2, 3, 3, 4); + + g_signal_connect(G_OBJECT(bd->entry), "activate", + G_CALLBACK(displaywindow_set_boostint_response_ac), + dw); + g_signal_connect(G_OBJECT(bd->window), "response", + G_CALLBACK(displaywindow_set_boostint_response), dw); + g_signal_connect(G_OBJECT(bd->window), "destroy", + G_CALLBACK(displaywindow_set_boostint_destroy), dw); + gtk_window_set_resizable(GTK_WINDOW(bd->window), FALSE); + gtk_widget_show_all(bd->window); + gtk_widget_grab_focus(GTK_WIDGET(bd->entry)); + + return 0; +} + + +static void load_features_from_file(struct image *image, const char *filename) +{ + FILE *fh; + char *rval; + + fh = fopen(filename, "r"); + if ( fh == NULL ) return; + + if ( image->features != NULL ) { + image_feature_list_free(image->features); + } + image->features = image_feature_list_new(); + + do { + char line[1024]; + float x, y, df; + int r; + signed int h, k, l; + + rval = fgets(line, 1023, fh); + if ( rval == NULL ) continue; + chomp(line); + + /* Try long format (output of pattern_sim --near-bragg) */ + r = sscanf(line, "%i %i %i %f (at %f,%f)", + &h, &k, &l, &df, &x, &y); + if ( r == 6 ) { + char name[32]; + snprintf(name, 31, "%i %i %i", h, k, l); + image_add_feature(image->features, x, y, image, 1.0, + strdup(name)); + continue; + } + + r = sscanf(line, "%f %f", &x, &y); + if ( r != 2 ) continue; + + image_add_feature(image->features, x, y, image, 1.0, NULL); + + } while ( rval != NULL ); +} + + +static gint displaywindow_peaklist_response(GtkWidget *d, gint response, + DisplayWindow *dw) +{ + if ( response == GTK_RESPONSE_ACCEPT ) { + + char *filename; + + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(d)); + + load_features_from_file(dw->image, filename); + displaywindow_update(dw); + + g_free(filename); + + } + + gtk_widget_destroy(d); + + return 0; +} + + +static gint displaywindow_about(GtkWidget *widget, DisplayWindow *dw) +{ + GtkWidget *window; + + const gchar *authors[] = { + "Thomas White <taw@physics.org>", + NULL + }; + + window = gtk_about_dialog_new(); + gtk_window_set_transient_for(GTK_WINDOW(window), + GTK_WINDOW(dw->window)); + + gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(window), "hdfsee"); + gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(window), PACKAGE_VERSION); + gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(window), + "(c) 2006-2011 Thomas White <taw@physics.org> and others"); + gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(window), + "Quick viewer for HDF files"); + gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(window), + "(c) 2006-2011 Thomas White <taw@physics.org>\n"); + gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(window), + "http://www.bitwiz.org.uk/"); + gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(window), authors); + + g_signal_connect(window, "response", G_CALLBACK(gtk_widget_destroy), + NULL); + + gtk_widget_show_all(window); + + return 0; +} + + +static int load_geometry_file(DisplayWindow *dw, struct image *image, + const char *filename) +{ + struct detector *geom; + GtkWidget *w; + + geom = get_detector_geometry(filename); + if ( geom == NULL ) { + displaywindow_error(dw, "Failed to load geometry file"); + return -1; + } + fill_in_values(geom, dw->hdfile); + + if ( (1+geom->max_fs != dw->image->width) + || (1+geom->max_ss != dw->image->height) ) { + + displaywindow_error(dw, "Geometry doesn't match image."); + return -1; + + } + + if ( dw->loaded_geom != NULL ) free_detector_geometry(dw->loaded_geom); + dw->loaded_geom = geom; + + w = gtk_ui_manager_get_widget(dw->ui, + "/ui/displaywindow/view/usegeom"); + gtk_widget_set_sensitive(GTK_WIDGET(w), TRUE); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), TRUE); + dw->use_geom = 1; + + return 0; +} + + +static gint displaywindow_loadgeom_response(GtkWidget *d, gint response, + DisplayWindow *dw) +{ + if ( response == GTK_RESPONSE_ACCEPT ) { + + char *filename; + + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(d)); + + if ( load_geometry_file(dw, dw->image, filename) == 0 ) { + displaywindow_update(dw); + } + + g_free(filename); + + } + + gtk_widget_destroy(d); + + return 0; +} + + +static gint displaywindow_load_geom(GtkWidget *widget, DisplayWindow *dw) +{ + GtkWidget *d; + + d = gtk_file_chooser_dialog_new("Load Geometry File", + GTK_WINDOW(dw->window), + GTK_FILE_CHOOSER_ACTION_OPEN, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, + NULL); + + g_signal_connect(G_OBJECT(d), "response", + G_CALLBACK(displaywindow_loadgeom_response), dw); + + gtk_widget_show_all(d); + + return 0; +} + + +static gint displaywindow_peak_overlay(GtkWidget *widget, DisplayWindow *dw) +{ + GtkWidget *d; + + d = gtk_file_chooser_dialog_new("Choose Peak List", + GTK_WINDOW(dw->window), + GTK_FILE_CHOOSER_ACTION_OPEN, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, + NULL); + + g_signal_connect(G_OBJECT(d), "response", + G_CALLBACK(displaywindow_peaklist_response), dw); + + gtk_widget_show_all(d); + + return 0; +} + + +static gint displaywindow_set_usegeom(GtkWidget *d, DisplayWindow *dw) +{ + GtkWidget *w; + + /* Get new value */ + w = gtk_ui_manager_get_widget(dw->ui, + "/ui/displaywindow/view/usegeom"); + dw->use_geom = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w)); + + if ( dw->use_geom ) { + dw->image->det = dw->loaded_geom; + } else { + dw->image->det = dw->simple_geom; + } + + displaywindow_update(dw); + + return 0; +} + + +static gint displaywindow_set_rings(GtkWidget *d, DisplayWindow *dw) +{ + GtkWidget *w; + + /* Get new value */ + w = gtk_ui_manager_get_widget(dw->ui, + "/ui/displaywindow/view/rings"); + dw->show_rings = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w)); + + gdk_window_invalidate_rect(dw->drawingarea->window, NULL, FALSE); + + return 0; +} + + +struct savedialog { + DisplayWindow *dw; + GtkWidget *cb; +}; + + +static gint displaywindow_save_response(GtkWidget *d, gint response, + struct savedialog *cd) +{ + DisplayWindow *dw = cd->dw; + int r; + + if ( response == GTK_RESPONSE_ACCEPT ) { + + char *file; + int type; + + file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(d)); + + type = gtk_combo_box_get_active(GTK_COMBO_BOX(cd->cb)); + + if ( type == 0 ) { + r = write_png(file, dw); + } else if ( type == 1 ) { + r = render_tiff_fp(dw->image, file); + } else if ( type == 2 ) { + r = render_tiff_int16(dw->image, file, dw->boostint); + } else { + r = -1; + } + + if ( r != 0 ) { + displaywindow_error(dw, "Unable to save the image."); + } + + g_free(file); + + } + + gtk_widget_destroy(d); + free(cd); + + return 0; +} + + +static gint displaywindow_save(GtkWidget *widget, DisplayWindow *dw) +{ + GtkWidget *d, *hbox, *l, *cb; + struct savedialog *cd; + + d = gtk_file_chooser_dialog_new("Save Image", + GTK_WINDOW(dw->window), + GTK_FILE_CHOOSER_ACTION_SAVE, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, + NULL); + + gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(d), + TRUE); + + hbox = gtk_hbox_new(FALSE, 0); + gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(d), hbox); + cb = gtk_combo_box_new_text(); + gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(cb), TRUE, TRUE, 5); + l = gtk_label_new("Save as type:"); + gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(l), FALSE, FALSE, 5); + + gtk_combo_box_append_text(GTK_COMBO_BOX(cb), + "PNG - 8 bit RGB (colour, binned, filtered, boosted)"); + gtk_combo_box_append_text(GTK_COMBO_BOX(cb), + "TIFF - Floating point (mono, unbinned, filtered, not boosted)"); + gtk_combo_box_append_text(GTK_COMBO_BOX(cb), + "TIFF - 16 bit signed integer " + "(mono, unbinned, filtered, boosted)"); + gtk_combo_box_set_active(GTK_COMBO_BOX(cb), 0); + + cd = malloc(sizeof(*cd)); + cd->dw = dw; + cd->cb = cb; + + g_signal_connect(G_OBJECT(d), "response", + G_CALLBACK(displaywindow_save_response), cd); + + gtk_widget_show_all(d); + + return 0; +} + + +static gint displaywindow_set_colscale(GtkWidget *widget, DisplayWindow *dw) +{ + dw->show_col_scale = 1 - dw->show_col_scale; + displaywindow_update(dw); + return 0; +} + + +static gint displaywindow_numbers_response(GtkWidget *widget, + gint response, DisplayWindow *dw) +{ + gtk_widget_destroy(dw->numbers_window->window); + return 0; +} + + +static gint displaywindow_numbers_destroy(GtkWidget *widget, DisplayWindow *dw) +{ + free(dw->numbers_window); + dw->numbers_window = NULL; + return 0; +} + + +static gint displaywindow_show_numbers(GtkWidget *widget, DisplayWindow *dw) +{ + struct numberswindow *nw; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *hbox2; + GtkWidget *table; + GtkWidget *label; + unsigned int x, y; + + if ( dw->numbers_window != NULL ) { + return 0; + } + + if ( dw->hdfile == NULL ) { + return 0; + } + + nw = malloc(sizeof(struct numberswindow)); + if ( nw == NULL ) return 0; + dw->numbers_window = nw; + + nw->window = gtk_dialog_new_with_buttons("Numbers", + GTK_WINDOW(dw->window), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, + NULL); + + vbox = gtk_vbox_new(FALSE, 0); + hbox = gtk_hbox_new(TRUE, 0); + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(nw->window)->vbox), + GTK_WIDGET(hbox), FALSE, FALSE, 7); + gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), FALSE, FALSE, 5); + + table = gtk_table_new(17, 17, FALSE); + gtk_table_set_row_spacings(GTK_TABLE(table), 5); + gtk_table_set_col_spacings(GTK_TABLE(table), 5); + gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, FALSE, 0); + + for ( x=0; x<17; x++ ) { + for ( y=0; y<17; y++ ) { + + GtkWidget *label; + + label = gtk_label_new("--"); + gtk_widget_set_size_request(GTK_WIDGET(label), 40, -1); + + gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label), + x, x+1, y, y+1); + + nw->labels[x+17*y] = label; + + } + } + + hbox2 = gtk_hbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox2), FALSE, FALSE, 5); + label = gtk_label_new("Feature:"); + gtk_box_pack_start(GTK_BOX(hbox2), GTK_WIDGET(label), FALSE, FALSE, 5); + nw->feat = gtk_label_new("-"); + gtk_box_pack_start(GTK_BOX(hbox2), GTK_WIDGET(nw->feat), FALSE, FALSE, 5); + + g_signal_connect(G_OBJECT(nw->window), "response", + G_CALLBACK(displaywindow_numbers_response), dw); + g_signal_connect(G_OBJECT(nw->window), "destroy", + G_CALLBACK(displaywindow_numbers_destroy), dw); + gtk_window_set_resizable(GTK_WINDOW(nw->window), FALSE); + + gtk_widget_show_all(nw->window); + + return 0; +} + + +static void numbers_update(DisplayWindow *dw) +{ + int px, py; + int imin; + double dmin; + struct imagefeature *f; + + for ( px=0; px<17; px++ ) { + for ( py=0; py<17; py++ ) { + + char s[32]; + float val; + GtkWidget *l; + int x, y; + int invalid; + double dfs, dss; + int fs, ss; + + x = dw->binning * dw->numbers_window->cx + (px-8); + y = dw->binning * dw->numbers_window->cy + (17-py-8); + x += dw->min_x; + y += dw->min_y; + + /* Map from unbinned mapped pixel coordinates to a panel */ + invalid = reverse_2d_mapping(x, y, &dfs, &dss, dw->image->det); + fs = dfs; ss = dss; + if ( !invalid ) { + val = dw->image->data[fs+ss*dw->image->width]; + } + + if ( !invalid ) { + if ( val > 0.0 ) { + if ( log(val)/log(10.0) < 5 ) { + snprintf(s, 31, "%.0f", val); + } else { + snprintf(s, 31, "HUGE"); + } + } else { + if ( log(-val)/log(10) < 4 ) { + snprintf(s, 31, "%.0f", val); + } else { + snprintf(s, 31, "-HUGE"); + } + } + } else { + strcpy(s, "-"); + } + l = dw->numbers_window->labels[px+17*py]; + gtk_label_set_text(GTK_LABEL(l), s); + + } + } + + if ( dw->image->features == NULL ) return; + + f = image_feature_closest(dw->image->features, + dw->binning * dw->numbers_window->cx, + dw->binning * dw->numbers_window->cy, + &dmin, &imin); + if ( dmin < 20.0 ) { + gtk_label_set_text(GTK_LABEL(dw->numbers_window->feat), + f->name); + } else { + gtk_label_set_text(GTK_LABEL(dw->numbers_window->feat), + "-"); + } +} + + +static void displaywindow_addui_callback(GtkUIManager *ui, GtkWidget *widget, + GtkContainer *container) +{ + gtk_box_pack_start(GTK_BOX(container), widget, FALSE, FALSE, 0); + + /* Enable overflow menu if this is a toolbar */ + if ( GTK_IS_TOOLBAR(widget) ) { + gtk_toolbar_set_show_arrow(GTK_TOOLBAR(widget), TRUE); + } +} + + +static gint displaywindow_setscale(GtkWidget *widget, GtkRadioAction *action, + DisplayWindow *dw) +{ + switch ( gtk_radio_action_get_current_value(action) ) + { + case 0 : dw->scale = SCALE_COLOUR; break; + case 1 : dw->scale = SCALE_MONO; break; + case 2 : dw->scale = SCALE_INVMONO; break; + } + displaywindow_update(dw); + + return 0; +} + + +static void displaywindow_addmenubar(DisplayWindow *dw, GtkWidget *vbox, + int colscale) +{ + GError *error = NULL; + GtkActionEntry entries[] = { + + { "FileAction", NULL, "_File", NULL, NULL, NULL }, + { "SaveAction", GTK_STOCK_SAVE, "Save Image...", NULL, NULL, + G_CALLBACK(displaywindow_save) }, + { "CloseAction", GTK_STOCK_CLOSE, "_Close", NULL, NULL, + G_CALLBACK(displaywindow_close) }, + + { "ViewAction", NULL, "_View", NULL, NULL, NULL }, + { "ImagesAction", NULL, "Images", NULL, NULL, NULL }, + { "BinningAction", NULL, "Set Binning...", "F3", NULL, + G_CALLBACK(displaywindow_set_binning) }, + { "BoostIntAction", NULL, "Boost Intensity...", "F5", NULL, + G_CALLBACK(displaywindow_set_boostint) }, + + { "ToolsAction", NULL, "_Tools", NULL, NULL, NULL }, + { "NumbersAction", NULL, "View Numbers...", "F2", NULL, + G_CALLBACK(displaywindow_show_numbers) }, + { "PeaksAction", NULL, "Peak Position Overlay...", NULL, NULL, + G_CALLBACK(displaywindow_peak_overlay) }, + { "LoadGeomAction", NULL, "Load Geometry File...", NULL, NULL, + G_CALLBACK(displaywindow_load_geom) }, + + { "HelpAction", NULL, "_Help", NULL, NULL, NULL }, + { "AboutAction", GTK_STOCK_ABOUT, "_About hdfsee...", + NULL, NULL, + G_CALLBACK(displaywindow_about) }, + + }; + guint n_entries = G_N_ELEMENTS(entries); + + GtkToggleActionEntry toggles[] = { + { "ColScaleAction", NULL, "Show Colour Scale", NULL, NULL, + G_CALLBACK(displaywindow_set_colscale), FALSE }, + { "GeometryAction", NULL, "Use Detector Geometry", NULL, NULL, + G_CALLBACK(displaywindow_set_usegeom), FALSE }, + { "RingsAction", NULL, "Show Resolution Rings", NULL, NULL, + G_CALLBACK(displaywindow_set_rings), dw->show_rings }, + }; + guint n_toggles = G_N_ELEMENTS(toggles); + GtkRadioActionEntry radios[] = { + { "ColAction", NULL, "Colour", NULL, NULL, + SCALE_COLOUR }, + { "MonoAction", NULL, "Monochrome", NULL, NULL, + SCALE_MONO }, + { "InvMonoAction", NULL, "Inverse Monochrome", NULL, NULL, + SCALE_INVMONO }, + }; + guint n_radios = G_N_ELEMENTS(radios); + + dw->action_group = gtk_action_group_new("hdfseedisplaywindow"); + gtk_action_group_add_actions(dw->action_group, entries, n_entries, dw); + gtk_action_group_add_toggle_actions(dw->action_group, toggles, + n_toggles, dw); + gtk_action_group_add_radio_actions(dw->action_group, radios, n_radios, + colscale, + G_CALLBACK(displaywindow_setscale), + dw); + + dw->ui = gtk_ui_manager_new(); + gtk_ui_manager_insert_action_group(dw->ui, dw->action_group, 0); + g_signal_connect(dw->ui, "add_widget", + G_CALLBACK(displaywindow_addui_callback), vbox); + if ( gtk_ui_manager_add_ui_from_file(dw->ui, + DATADIR"/crystfel/hdfsee.ui", &error) == 0 ) { + fprintf(stderr, "Error loading message window menu bar: %s\n", + error->message); + return; + } + + gtk_window_add_accel_group(GTK_WINDOW(dw->window), + gtk_ui_manager_get_accel_group(dw->ui)); + gtk_ui_manager_ensure_update(dw->ui); +} + + + +static int geometry_fits(struct image *image, struct detector *geom) +{ + if ( (1+geom->max_fs != image->width) + || (1+geom->max_ss != image->height) ) return 0; + + return 1; +} + + +struct newhdf { + DisplayWindow *dw; + char name[1024]; +}; + +static gint displaywindow_newhdf(GtkMenuItem *item, struct newhdf *nh) +{ + if ( nh->dw->not_ready_yet ) return 0; + + hdfile_set_image(nh->dw->hdfile, nh->name); + hdf5_read(nh->dw->hdfile, nh->dw->image, 0, 0.0); + + /* Check that the geometry still fits */ + if ( !geometry_fits(nh->dw->image, nh->dw->simple_geom) ) { + int using = 0; + if ( nh->dw->simple_geom == nh->dw->image->det ) { + using = 1; + } + free_detector_geometry(nh->dw->simple_geom); + nh->dw->simple_geom = simple_geometry(nh->dw->image); + if ( using ) { + nh->dw->image->det = nh->dw->simple_geom; + } + } + + if ( (nh->dw->loaded_geom != NULL ) + && (!geometry_fits(nh->dw->image, nh->dw->loaded_geom)) ) { + + GtkWidget *w; + + free_detector_geometry(nh->dw->loaded_geom); + nh->dw->loaded_geom = NULL; + + /* Force out of "use geometry" mode */ + w = gtk_ui_manager_get_widget(nh->dw->ui, + "/ui/displaywindow/view/usegeom"); + gtk_widget_set_sensitive(GTK_WIDGET(w), FALSE); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), FALSE); + nh->dw->use_geom = 0; + nh->dw->image->det = nh->dw->simple_geom; + + } + + if ( nh->dw->use_geom ) { + nh->dw->image->det = nh->dw->loaded_geom; + } else { + nh->dw->image->det = nh->dw->simple_geom; + } + + displaywindow_update(nh->dw); + return 0; +} + + +static GtkWidget *displaywindow_addhdfgroup(struct hdfile *hdfile, + const char *group, + DisplayWindow *dw, GSList **rgp, + const char *selectme) +{ + char **names; + int *is_group; + int *is_image; + GtkWidget *ms; + int n, i; + + if ( hdfile == NULL ) return NULL; + + names = hdfile_read_group(hdfile, &n, group, &is_group, &is_image); + if ( n == 0 ) return NULL; + + ms = gtk_menu_new(); + + for ( i=0; i<n; i++ ) { + + GtkWidget *item; + GtkWidget *sub; + + if ( names[i] == NULL ) return NULL; + + if ( is_group[i] ) { + + item = gtk_menu_item_new_with_label(names[i]); + + sub = displaywindow_addhdfgroup(hdfile, names[i], + dw, rgp, selectme); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), sub); + + } else if ( is_image[i] ) { + + struct newhdf *nh; + + item = gtk_radio_menu_item_new_with_label(*rgp, + names[i]); + + nh = malloc(sizeof(struct newhdf)); + if ( nh != NULL ) { + strncpy(nh->name, names[i], 1023); + nh->dw = dw; + g_signal_connect(G_OBJECT(item), "activate", + G_CALLBACK(displaywindow_newhdf), nh); + } + + if ( (selectme != NULL) + && (strcmp(names[i], selectme) == 0) ) { + gtk_check_menu_item_set_active( + GTK_CHECK_MENU_ITEM(item), TRUE); + } else { + gtk_check_menu_item_set_active( + GTK_CHECK_MENU_ITEM(item), FALSE); + } + + *rgp = gtk_radio_menu_item_get_group( + GTK_RADIO_MENU_ITEM(item)); + + } else { + + char *tmp; + + item = gtk_menu_item_new_with_label(names[i]); + + tmp = hdfile_get_string_value(hdfile, names[i]); + if ( tmp != NULL ) { + + GtkWidget *ss; + GtkWidget *mss; + + mss = gtk_menu_new(); + ss = gtk_menu_item_new_with_label(tmp); + gtk_widget_set_sensitive(ss, FALSE); + gtk_menu_shell_append(GTK_MENU_SHELL(mss), ss); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), + mss); + + } + + + } + + gtk_menu_shell_append(GTK_MENU_SHELL(ms), item); + + free(names[i]); + + + } + + free(is_group); + free(is_image); + + return ms; +} + + +static GtkWidget *displaywindow_createhdfmenus(struct hdfile *hdfile, + DisplayWindow *dw, + const char *selectme) +{ + GSList *rg = NULL; + + return displaywindow_addhdfgroup(hdfile, "/", dw, &rg, selectme); +} + + +static int displaywindow_update_menus(DisplayWindow *dw, const char *selectme) +{ + GtkWidget *ms; + GtkWidget *w; + + ms = displaywindow_createhdfmenus(dw->hdfile, dw, selectme); + + if ( ms == NULL ) return 1; + + /* Make new menu be the submenu for File->Images */ + w = gtk_ui_manager_get_widget(dw->ui, "/ui/displaywindow/view/images"); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(w), ms); + + gtk_widget_show_all(ms); + + return 0; +} + + +static gint displaywindow_release(GtkWidget *widget, GdkEventButton *event, + DisplayWindow *dw) +{ + if ( (event->type == GDK_BUTTON_RELEASE) && (event->button == 1) ) { + + g_signal_handler_disconnect(GTK_OBJECT(dw->drawingarea), + dw->motion_callback); + dw->motion_callback = 0; + + } + + return 0; +} + + +static gint displaywindow_motion(GtkWidget *widget, GdkEventMotion *event, + DisplayWindow *dw) +{ + if ( dw->numbers_window == NULL ) return 0; + + dw->numbers_window->cx = event->x; + dw->numbers_window->cy = dw->height - 1 - event->y; + + /* Schedule redraw */ + gtk_widget_queue_draw_area(dw->drawingarea, 0, 0, + dw->width, dw->height); + + /* Update numbers window */ + numbers_update(dw); + + return 0; + +} + + +static gint displaywindow_press(GtkWidget *widget, GdkEventButton *event, + DisplayWindow *dw) +{ + if ( dw->motion_callback != 0 ) { + return 0; + } + + if ( (event->type == GDK_BUTTON_PRESS) && (event->button == 1) ) { + + dw->motion_callback = g_signal_connect( + GTK_OBJECT(dw->drawingarea), + "motion-notify-event", + G_CALLBACK(displaywindow_motion), + dw); + + if ( dw->numbers_window != NULL ) { + dw->numbers_window->cx = event->x; + dw->numbers_window->cy = dw->height - 1 - event->y; + numbers_update(dw); + } + + } + + return 0; + +} + + +DisplayWindow *displaywindow_open(const char *filename, const char *peaks, + int boost, int binning, int cmfilter, + int noisefilter, int colscale, + const char *element, const char *geometry, + int show_rings) +{ + DisplayWindow *dw; + char *title; + GtkWidget *vbox; + GtkWidget *w; + + dw = calloc(1, sizeof(DisplayWindow)); + if ( dw == NULL ) return NULL; + dw->pixbufs = NULL; + dw->binning_dialog = NULL; + dw->show_col_scale = 0; + dw->col_scale = NULL; + dw->boostint_dialog = NULL; + dw->boostint = 1; + dw->motion_callback = 0; + dw->numbers_window = NULL; + dw->image = NULL; + dw->use_geom = 0; + dw->show_rings = show_rings; + dw->scale = colscale; + dw->binning = binning; + dw->boostint = boost; + dw->cmfilter = cmfilter; + dw->noisefilter = noisefilter; + dw->not_ready_yet = 1; + + /* Open the file, if any */ + if ( filename != NULL ) { + + dw->hdfile = hdfile_open(filename); + if ( dw->hdfile == NULL ) { + ERROR("Couldn't open file '%s'\n", filename); + free(dw); + return NULL; + } else { + int fail = -1; + + if ( element == NULL ) { + fail = hdfile_set_first_image(dw->hdfile, "/"); + } else { + fail = hdfile_set_image(dw->hdfile, element); + } + + if ( !fail ) { + dw->image = calloc(1, sizeof(struct image)); + hdf5_read(dw->hdfile, dw->image, 0, 0.0); + } else { + ERROR("Couldn't select path\n"); + free(dw); + return NULL; + } + } + + } else { + free(dw); + return NULL; + } + + dw->loaded_geom = NULL; + dw->simple_geom = simple_geometry(dw->image); + dw->image->det = dw->simple_geom; + + /* Peak list provided at startup? */ + if ( peaks != NULL ) { + load_features_from_file(dw->image, peaks); + } + + dw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + char *bn = safe_basename(filename); + title = malloc(strlen(bn)+14); + sprintf(title, "%s - hdfsee", bn); + free(bn); + gtk_window_set_title(GTK_WINDOW(dw->window), title); + free(title); + + g_signal_connect(G_OBJECT(dw->window), "destroy", + G_CALLBACK(displaywindow_closed), dw); + + vbox = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(dw->window), vbox); + displaywindow_addmenubar(dw, vbox, colscale); + + dw->drawingarea = gtk_drawing_area_new(); + gtk_box_pack_start(GTK_BOX(vbox), dw->drawingarea, TRUE, TRUE, 0); + + g_signal_connect(GTK_OBJECT(dw->drawingarea), "expose-event", + G_CALLBACK(displaywindow_expose), dw); + + gtk_window_set_resizable(GTK_WINDOW(dw->window), FALSE); + gtk_widget_show_all(dw->window); + + w = gtk_ui_manager_get_widget(dw->ui, "/ui/displaywindow/view/usegeom"); + gtk_widget_set_sensitive(GTK_WIDGET(w), FALSE); + if ( geometry != NULL ) { + load_geometry_file(dw, dw->image, geometry); + } + + displaywindow_update(dw); + + gtk_widget_add_events(GTK_WIDGET(dw->drawingarea), + GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK + | GDK_BUTTON1_MOTION_MASK); + g_object_set(G_OBJECT(dw->drawingarea), "can-focus", TRUE, NULL); + + g_signal_connect(GTK_OBJECT(dw->drawingarea), "button-press-event", + G_CALLBACK(displaywindow_press), dw); + g_signal_connect(GTK_OBJECT(dw->drawingarea), "button-release-event", + G_CALLBACK(displaywindow_release), dw); + + displaywindow_update_menus(dw, element); + dw->not_ready_yet = 0; + + return dw; +} |