diff options
Diffstat (limited to 'src/xsane-gamma.c')
| -rw-r--r-- | src/xsane-gamma.c | 2504 |
1 files changed, 2504 insertions, 0 deletions
diff --git a/src/xsane-gamma.c b/src/xsane-gamma.c new file mode 100644 index 0000000..d47f6b7 --- /dev/null +++ b/src/xsane-gamma.c @@ -0,0 +1,2504 @@ +/* xsane -- a graphical (X11, gtk) scanner-oriented SANE frontend + + xsane-gamma.c + + Oliver Rauch <Oliver.Rauch@rauch-domain.de> + Copyright (C) 1998-2002 Oliver Rauch + This file is part of the XSANE package. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +#include "xsane.h" +#include "xsane-back-gtk.h" +#include "xsane-front-gtk.h" +#include "xsane-preferences.h" +#include "xsane-preview.h" +#include "xsane-save.h" + +#ifdef HAVE_LIBPNG +#ifdef HAVE_LIBZ +#include <png.h> +#include <zlib.h> +#endif +#endif + + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +/* forward declarations: */ + +void xsane_clear_histogram(XsanePixmap *hist); +static void xsane_draw_histogram_with_points(XsanePixmap *hist, + SANE_Int *count, SANE_Int *count_red, SANE_Int *count_green, SANE_Int *count_blue, + int show_red, int show_green, int show_blue, int show_inten, double scale); +static void xsane_draw_histogram_with_lines(XsanePixmap *hist, + SANE_Int *count, SANE_Int *count_red, SANE_Int *count_green, SANE_Int *count_blue, + int show_red, int show_green, int show_blue, int show_inten, double scale); +void xsane_draw_slider_level(XsaneSlider *slider); +static void xsane_set_slider(XsaneSlider *slider, double min, double mid, double max); +void xsane_update_slider(XsaneSlider *slider); +void xsane_update_sliders(void); +static gint xsane_slider_callback(GtkWidget *widget, GdkEvent *event, XsaneSlider *slider); +void xsane_create_slider(XsaneSlider *slider); +void xsane_create_histogram(GtkWidget *parent, const char *title, int width, int height, XsanePixmap *hist); +void xsane_get_free_gamma_curve(gfloat *free_color_gamma_data, SANE_Int *gammadata, + int negative, double gamma, double brightness, double contrast, + int len, int maxout); +static void xsane_calculate_auto_enhancement(SANE_Int *count_raw, + SANE_Int *count_raw_red, SANE_Int *count_raw_green, SANE_Int *count_raw_blue); +void xsane_calculate_raw_histogram(void); +void xsane_calculate_enh_histogram(void); +void xsane_update_histogram(int update_raw); +void xsane_histogram_toggle_button_callback(GtkWidget *widget, gpointer data); +void xsane_create_preview_threshold_curve(u_char *gammadata, double threshold, int numbers); +void xsane_create_preview_gamma_curve(u_char *gammadata, int negative, double gamma, + double brightness, double contrast, + double medium_shadow, double medium_highlight, double medium_gamma, + int numbers); +void xsane_create_gamma_curve(SANE_Int *gammadata, + int negative, double gamma, double brightness, double contrast, + double medium_shadow, double medium_highlight, double medium_gamma, + int numbers, int maxout); +void xsane_update_gamma_curve(int update_raw); +static void xsane_enhancement_update(void); +static void xsane_gamma_to_histogram(double *min, double *mid, double *max, + double contrast, double brightness, double gamma); +void xsane_enhancement_by_gamma(void); +void xsane_enhancement_restore_default(void); +void xsane_enhancement_restore(void); +void xsane_enhancement_store(void); +static int xsane_histogram_to_gamma(XsaneSlider *slider, double *contrast, double contrast_offset, double *brightness, double brightness_offset, double *gamma, double gamma_multiplier); +void xsane_enhancement_by_histogram(int update_gamma); +static gint xsane_histogram_win_delete(GtkWidget *widget, gpointer data); +void xsane_create_histogram_dialog(const char *devicetext); +#ifdef HAVE_WORKING_GTK_GAMMACURVE +static gint xsane_gamma_win_delete(GtkWidget *widget, gpointer data); +#endif +void xsane_create_gamma_dialog(const char *devicetext); +void xsane_update_gamma_dialog(void); +void xsane_set_auto_enhancement(void); + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_clear_histogram(XsanePixmap *hist) +{ + GdkRectangle rect; + + DBG(DBG_proc, "xsane_clear_histogram\n"); + + if(hist->pixmap) + { + rect.x=0; + rect.y=0; + rect.width = HIST_WIDTH; + rect.height = HIST_HEIGHT; + + gdk_draw_rectangle(hist->pixmap, xsane.gc_backg, TRUE, 0, 0, HIST_WIDTH, HIST_HEIGHT); + gtk_widget_draw(hist->pixmapwid, &rect); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void xsane_draw_histogram_with_points(XsanePixmap *hist, + SANE_Int *count, SANE_Int *count_red, SANE_Int *count_green, SANE_Int *count_blue, + int show_red, int show_green, int show_blue, int show_inten, double scale) +{ + GdkRectangle rect; + int i; + int inten, red, green, blue; + + DBG(DBG_proc, "xsane_draw_histogram_with_points\n"); + +#define XD 1 +#define YD 2 + + if(hist->pixmap) + { + rect.x=0; + rect.y=0; + rect.width = HIST_WIDTH; + rect.height = HIST_HEIGHT; + + gdk_draw_rectangle(hist->pixmap, xsane.gc_backg, TRUE, 0, 0, HIST_WIDTH, HIST_HEIGHT); + + red = 0; + green = 0; + blue = 0; + + for (i=0; i < HIST_WIDTH; i++) + { + inten = show_inten * count[i] * scale; + + if (xsane.xsane_colors > 1) + { + red = show_red * count_red[i] * scale; + green = show_green * count_green[i] * scale; + blue = show_blue * count_blue[i] * scale; + } + + if (inten > HIST_HEIGHT) + inten = HIST_HEIGHT; + + if (red > HIST_HEIGHT) + red = HIST_HEIGHT; + + if (green > HIST_HEIGHT) + green = HIST_HEIGHT; + + if (blue > HIST_HEIGHT) + blue = HIST_HEIGHT; + + + gdk_draw_rectangle(hist->pixmap, xsane.gc_red, TRUE, i, HIST_HEIGHT - red, XD, YD); + gdk_draw_rectangle(hist->pixmap, xsane.gc_green, TRUE, i, HIST_HEIGHT - green, XD, YD); + gdk_draw_rectangle(hist->pixmap, xsane.gc_blue, TRUE, i, HIST_HEIGHT - blue, XD, YD); + gdk_draw_rectangle(hist->pixmap, xsane.gc_black, TRUE, i, HIST_HEIGHT - inten, XD, YD); + } + + gtk_widget_draw(hist->pixmapwid, &rect); + } +} +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void xsane_draw_histogram_with_lines(XsanePixmap *hist, + SANE_Int *count, SANE_Int *count_red, SANE_Int *count_green, SANE_Int *count_blue, + int show_red, int show_green, int show_blue, int show_inten, double scale) +{ + GdkRectangle rect; + int i, j, k; + int inten, red, green, blue; + int inten0=0, red0=0, green0=0, blue0=0; + int val[4]; + int val2[4]; + int color[4]; + int val_swap; + int color_swap; + + DBG(DBG_proc, "xsane_draw_histogram_with_lines\n"); + + if (hist->pixmap) + { + rect.x=0; + rect.y=0; + rect.width = HIST_WIDTH; + rect.height = HIST_HEIGHT; + + gdk_draw_rectangle(hist->pixmap, xsane.gc_backg, TRUE, 0, 0, HIST_WIDTH, HIST_HEIGHT); + + red = 0; + green = 0; + blue = 0; + + for (i=0; i < HIST_WIDTH; i++) + { + inten = show_inten * count[i] * scale; + + if (xsane.xsane_colors > 1) + { + red = show_red * count_red[i] * scale; + green = show_green * count_green[i] * scale; + blue = show_blue * count_blue[i] * scale; + } + + if (inten > HIST_HEIGHT) + { + inten = HIST_HEIGHT; + } + + if (red > HIST_HEIGHT) + { + red = HIST_HEIGHT; + } + + if (green > HIST_HEIGHT) + { + green = HIST_HEIGHT; + } + + if (blue > HIST_HEIGHT) + { + blue = HIST_HEIGHT; + } + + val[0] = red; color[0] = 0; + val[1] = green; color[1] = 1; + val[2] = blue; color[2] = 2; + val[3] = inten; color[3] = 3; + + for (j = 0; j < 3; j++) + { + for (k = j + 1; k < 4; k++) + { + if (val[j] < val[k]) + { + val_swap = val[j]; + color_swap = color[j]; + val[j] = val[k]; + color[j] = color[k]; + val[k] = val_swap; + color[k] = color_swap; + } + } + } + val2[0] = val[1] + 1; + val2[1] = val[2] + 1; + val2[2] = val[3] + 1; + val2[3] = 0; + + for (j = 0; j < 4; j++) + { + switch(color[j]) + { + case 0: red0 = val2[j]; + break; + case 1: green0 = val2[j]; + break; + case 2: blue0 = val2[j]; + break; + case 3: inten0 = val2[j]; + break; + } + } + + + gdk_draw_line(hist->pixmap, xsane.gc_red, i, HIST_HEIGHT - red, i, HIST_HEIGHT - red0); + gdk_draw_line(hist->pixmap, xsane.gc_green, i, HIST_HEIGHT - green, i, HIST_HEIGHT - green0); + gdk_draw_line(hist->pixmap, xsane.gc_blue, i, HIST_HEIGHT - blue, i, HIST_HEIGHT - blue0); + gdk_draw_line(hist->pixmap, xsane.gc_black, i, HIST_HEIGHT - inten, i, HIST_HEIGHT - inten0); + } + + gtk_widget_draw(hist->pixmapwid, &rect); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_establish_slider(XsaneSlider *slider) +{ + int x, y, pos, len; + guchar buf[XSANE_SLIDER_WIDTH*3]; + GdkRectangle rect; + + DBG(DBG_proc, "xsane_establish_slider\n"); + + buf[0] = buf[1] = buf[2] = 0; + buf[3+0] = buf[3+1] = buf[3+2]= 0; + + for (x = 0; x < 256; x++) + { + buf[3*x+0+6] = x * slider->r; + buf[3*x+1+6] = x * slider->g; + buf[3*x+2+6] = x * slider->b; + } + + buf[258*3+0] = 255 * slider->r; + buf[258*3+1] = 255 * slider->g; + buf[258*3+2] = 255 * slider->b; + + buf[259*3+0] = 255 * slider->r; + buf[259*3+1] = 255 * slider->g; + buf[259*3+2] = 255 * slider->b; + + for (y = 0; y < XSANE_SLIDER_HEIGHT; y++) + { + pos = slider->position[0]-y/2; + len = y; + if (pos<-2) + { + len = len + pos + 2; + pos = -2; + } + pos = pos * 3 + 6; + + for (x = 0; x <= len; x++) + { + if ((x == 0) || (x == len) || (y == XSANE_SLIDER_HEIGHT-1)) + { + buf[pos++] = 255; + buf[pos++] = 255; + buf[pos++] = 255; + } + else + { + buf[pos++] = 0; + buf[pos++] = 0; + buf[pos++] = 0; + } + } + + + pos = slider->position[1]-y/2; + len = y; + pos = pos * 3 + 6; + + for (x = 0; x <= len; x++) + { + if ((x == 0) || (x == len) || (y == XSANE_SLIDER_HEIGHT-1)) + { + buf[pos++] = 255; + buf[pos++] = 255; + buf[pos++] = 255; + } + else + { + buf[pos++] = 128; + buf[pos++] = 128; + buf[pos++] = 128; + } + } + + + pos = slider->position[2]-y/2; + len = y; + if (pos+len>257) + { + len = 257 - pos; + } + pos = pos * 3 + 6; + + for (x=0; x<=len; x++) + { + if ((x == 0) || (x == len) || (y == XSANE_SLIDER_HEIGHT-1)) + { + buf[pos++] = 0; + buf[pos++] = 0; + buf[pos++] = 0; + } + else + { + buf[pos++] = 255; + buf[pos++] = 255; + buf[pos++] = 255; + } + } + + gtk_preview_draw_row(GTK_PREVIEW(slider->preview),buf, 0, y, XSANE_SLIDER_WIDTH); + } + + rect.x=0; + rect.y=0; + rect.width = XSANE_SLIDER_WIDTH; + rect.height = XSANE_SLIDER_HEIGHT; + + gtk_widget_draw(slider->preview, &rect); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_draw_slider_level(XsaneSlider *slider) +{ + int i; + guchar buf[XSANE_SLIDER_WIDTH*3]; + GdkRectangle rect; + + DBG(DBG_proc, "xsane_draw_slider_level\n"); + + buf[0] = buf[1] = buf[2] = 0; + buf[3+0] = buf[3+1] = buf[3+2]= 0; + + for (i=0; i<256; i++) + { + buf[3*i+0+6] = i * slider->r; + buf[3*i+1+6] = i * slider->g; + buf[3*i+2+6] = i * slider->b; + } + + buf[258*3+0] = 255 * slider->r; + buf[258*3+1] = 255 * slider->g; + buf[258*3+2] = 255 * slider->b; + + buf[259*3+0] = 255 * slider->r; + buf[259*3+1] = 255 * slider->g; + buf[259*3+2] = 255 * slider->b; + + for (i=0; i<XSANE_SLIDER_HEIGHT; i++) + { + gtk_preview_draw_row(GTK_PREVIEW(slider->preview),buf, 0, i, XSANE_SLIDER_WIDTH); + } + + rect.x=0; + rect.y=0; + rect.width = XSANE_SLIDER_WIDTH; + rect.height = XSANE_SLIDER_HEIGHT; + + gtk_widget_draw(slider->preview, &rect); +} +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void xsane_set_slider(XsaneSlider *slider, double min, double mid, double max) +{ + DBG(DBG_proc, "xsane_set_slider\n"); + + slider->value[0] = min; + slider->value[1] = mid; + slider->value[2] = max; + + slider->position[0] = min * 2.55; + slider->position[1] = mid * 2.55; + slider->position[2] = max * 2.55; + + xsane_establish_slider(slider); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_update_slider(XsaneSlider *slider) +{ + DBG(DBG_proc, "xsane_update_slider\n"); + + slider->position[0] = 2.55 * slider->value[0]; + slider->position[1] = 2.55 * slider->value[1]; + slider->position[2] = 2.55 * slider->value[2]; + + xsane_establish_slider(slider); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_update_sliders() +{ + DBG(DBG_proc, "xsane_update_sliders\n"); + + xsane_update_slider(&xsane.slider_gray); + + if ( (xsane.xsane_colors > 1) && (!xsane.enhancement_rgb_default) ) + { + xsane_update_slider(&xsane.slider_red); + xsane_update_slider(&xsane.slider_green); + xsane_update_slider(&xsane.slider_blue); + + xsane.slider_gray.active &= ~XSANE_SLIDER_INACTIVE; /* mark slider active */ + xsane.slider_red.active &= ~XSANE_SLIDER_INACTIVE; /* mark slider active */ + xsane.slider_green.active &= ~XSANE_SLIDER_INACTIVE; /* mark slider active */ + xsane.slider_blue.active &= ~XSANE_SLIDER_INACTIVE; /* mark slider active */ + } + else + { + xsane_draw_slider_level(&xsane.slider_red); /* remove slider */ + xsane_draw_slider_level(&xsane.slider_green); /* remove slider */ + xsane_draw_slider_level(&xsane.slider_blue); /* remove slider */ + + xsane.slider_red.active = XSANE_SLIDER_INACTIVE; /* mark slider inactive */ + xsane.slider_green.active = XSANE_SLIDER_INACTIVE; /* mark slider inactive */ + xsane.slider_blue.active = XSANE_SLIDER_INACTIVE; /* mark slider inactive */ + + if (xsane.param.depth == 1) + { + xsane_draw_slider_level(&xsane.slider_gray); /* remove slider */ + xsane.slider_gray.active = XSANE_SLIDER_INACTIVE; /* mark slider inactive */ + } + else + { + xsane.slider_gray.active &= ~XSANE_SLIDER_INACTIVE; /* mark slider active */ + } + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint xsane_slider_hold_event() +{ + DBG(DBG_proc, "xsane_slider_hold_event\n"); + + xsane_enhancement_by_histogram(TRUE); + + gtk_timeout_remove(xsane.slider_timer); + xsane.slider_timer = 0; + + if (xsane.slider_timer_restart) + { + xsane.slider_timer = gtk_timeout_add(XSANE_CONTINUOUS_HOLD_TIME, xsane_slider_hold_event, 0); + xsane.slider_timer_restart = FALSE; + } + + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint xsane_slider_callback(GtkWidget *widget, GdkEvent *event, XsaneSlider *slider) +{ + GdkEventButton *button_event; + GdkEventMotion *motion_event; + int distance; + int i = 0; + static int update = FALSE; + static int x; + + DBG(DBG_proc, "xsane_slider_callback\n"); + + if (slider->active == XSANE_SLIDER_INACTIVE) + { + return 0; + } + + switch(event->type) + { + case GDK_BUTTON_PRESS: + gtk_grab_add(widget); + button_event = (GdkEventButton *) event; + + distance = G_MAXINT; + for (i=0; i<3; i++) + { + if (fabs(button_event->x - slider->position[i]) < distance) + { + slider->active = i + 1; + distance = fabs(button_event->x - slider->position[i]); + } + } + if (distance<10) + { + x = button_event->x; + update = TRUE; + } + else + { + slider->active = XSANE_SLIDER_ACTIVE; + } + break; + + case GDK_BUTTON_RELEASE: + gtk_grab_remove(widget); + xsane_enhancement_by_histogram(TRUE); /* slider->active must be unchanged !!! */ + slider->active = XSANE_SLIDER_ACTIVE; /* ok, now we can reset it */ + break; + + case GDK_MOTION_NOTIFY: + + motion_event = (GdkEventMotion *) event; + gdk_window_get_pointer(widget->window, &x, 0, 0); + update = TRUE; + break; + + default: + break; + } + + if (update) + { + update = FALSE; + switch(slider->active) + { + case 1: + slider->value[0] = (x-XSANE_SLIDER_OFFSET) / 2.55; + xsane_bound_double(&slider->value[0], 0.0, slider->value[1] - 1); + break; + + case 2: + slider->value[1] = (x-XSANE_SLIDER_OFFSET) / 2.55; + xsane_bound_double(&slider->value[1], slider->value[0] + 1, slider->value[2] - 1); + break; + + case 3: + slider->value[2] = (x-XSANE_SLIDER_OFFSET) / 2.55; + xsane_bound_double(&slider->value[2], slider->value[1] + 1, 100.0); + break; + + default: + break; + } + xsane_set_slider(slider, slider->value[0], slider->value[1], slider->value[2]); + + if (preferences.gtk_update_policy == GTK_UPDATE_CONTINUOUS) + { + /* call xsane_enhancement_by_histogram by event handler */ + if (!xsane.slider_timer) + { + xsane.slider_timer = gtk_timeout_add(XSANE_CONTINUOUS_HOLD_TIME, xsane_slider_hold_event, 0); + } + else + { + xsane.slider_timer_restart = TRUE; + } + } + else if (preferences.gtk_update_policy == GTK_UPDATE_DELAYED) + { + if (xsane.slider_timer) /* hold timer active? then remove it, we had a motion */ + { + gtk_timeout_remove(xsane.slider_timer); + } + /* call xsane_slider_hold_event if mouse is not moved for ??? ms */ + xsane.slider_timer = gtk_timeout_add(XSANE_HOLD_TIME, xsane_slider_hold_event, 0); + } + } + + return 0; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_create_slider(XsaneSlider *slider) +{ + DBG(DBG_proc, "xsane_create_slider\n"); + + slider->preview = gtk_preview_new(GTK_PREVIEW_COLOR); + gtk_preview_size(GTK_PREVIEW(slider->preview), XSANE_SLIDER_WIDTH, XSANE_SLIDER_HEIGHT); + gtk_widget_set_events(slider->preview, XSANE_SLIDER_EVENTS); + gtk_signal_connect(GTK_OBJECT(slider->preview), "event", GTK_SIGNAL_FUNC(xsane_slider_callback), slider); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_create_histogram(GtkWidget *parent, const char *title, int width, int height, XsanePixmap *hist) +{ + GdkBitmap *mask=NULL; + + DBG(DBG_proc, "xsane_create_histogram\n"); + + hist->frame = gtk_frame_new(title); + hist->pixmap = gdk_pixmap_new(xsane.histogram_dialog->window, width, height, -1); + hist->pixmapwid = gtk_pixmap_new(hist->pixmap, mask); + gtk_container_add(GTK_CONTAINER(hist->frame), hist->pixmapwid); + gdk_draw_rectangle(hist->pixmap, xsane.gc_backg, TRUE, 0, 0, width, height); + + gtk_box_pack_start(GTK_BOX(parent), hist->frame, FALSE, FALSE, 2); + gtk_widget_show(hist->pixmapwid); + gtk_widget_show(hist->frame); + } + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void xsane_calculate_auto_enhancement(SANE_Int *count_raw, + SANE_Int *count_raw_red, SANE_Int *count_raw_green, SANE_Int *count_raw_blue) +{ /* calculate white, medium and black values for auto enhancement */ + int limit, limit_mid; + int points, points_mix, points_red, points_green, points_blue; + int min, mid, max; + int min_red, mid_red, max_red; + int min_green, mid_green, max_green; + int min_blue, mid_blue, max_blue; + int val; + int i; + + DBG(DBG_proc, "xsane_calculate_auto_enhancement\n"); + + if (xsane.preview) + { + points = 0; + points_mix = 0; + points_red = 0; + points_green = 0; + points_blue = 0; + + for (i=0; i<256; i++) + { + points += count_raw[i]; + points_mix += 10 * log(1 + count_raw[i] + count_raw_red[i] + count_raw_green[i] + count_raw_blue[i]); + points_red += 10 * log(1 + count_raw_red[i]); + points_green += 10 * log(1 + count_raw_green[i]); + points_blue += 10 * log(1 + count_raw_blue[i]); + } + + limit = 1 + points / 5000; + + /* ----- gray ----- */ + + min = -1; + val = 0; + while ( (val/4 < limit) && (min < 253) ) + { + min++; + val += count_raw[min] + count_raw_red[min] + count_raw_green[min] + count_raw_blue[min]; + } + + max = HIST_WIDTH; + val = 0; + while ( (val/4 < limit) && (max > min + 1) ) + { + max--; + val += count_raw[max] + count_raw_red[max] + count_raw_green[max] + count_raw_blue[max]; + } + + limit_mid = points_mix / 2.0; + + mid = 0; + val = 0; + while ( (val < limit_mid) && (mid < max - 1) ) + { + mid++; + val += 10 * log(1 + count_raw[mid] + count_raw_red[mid] + count_raw_green[mid] + count_raw_blue[mid]); + } + + xsane_bound_int(&mid, min, max); + + /* ----- red ----- */ + + min_red = -1; + val = 0; + while ( (val < limit) && (min_red < 253) ) + { + min_red++; + val += count_raw_red[min_red]; + } + + max_red = HIST_WIDTH; + val = 0; + while ( (val < limit) && (max_red > min_red + 1) ) + { + max_red--; + val += count_raw_red[max_red]; + } + + limit_mid = points_red / 2.0; + + mid_red = 0; + val = 0; + while ( (val < limit_mid) && (mid_red < max_red - 1) ) + { + mid_red++; + val += 10 * log(1 + count_raw_red[mid_red]); + } + + xsane_bound_int(&mid_red, min_red, max_red); + + /* ----- green ----- */ + + min_green = -1; + val = 0; + while ( (val < limit) && (min_green < 253) ) + { + min_green++; + val += count_raw_green[min_green]; + } + + max_green = HIST_WIDTH; + val = 0; + while ( (val < limit) && (max_green > min_green + 1) ) + { + max_green--; + val += count_raw_green[max_green]; + } + + limit_mid = points_green / 2.0; + + mid_green = 0; + val = 0; + while ( (val < limit_mid) && (mid_green < max_green - 1) ) + { + mid_green++; + val += 10 * log(1 + count_raw_green[mid_green]); + } + + xsane_bound_int(&mid_green, min_green, max_green); + + /* ----- blue ----- */ + + min_blue = -1; + val = 0; + while ( (val < limit) && (min_blue < 253) ) + { + min_blue++; + val += count_raw_blue[min_blue]; + } + + max_blue = HIST_WIDTH; + val = 0; + while ( (val < limit) && (max_blue > min_blue + 1) ) + { + max_blue--; + val += count_raw_blue[max_blue]; + } + + limit_mid = points_blue / 2.0; + + mid_blue = 0; + val = 0; + while ( (val < limit_mid) && (mid_blue < max_blue - 1) ) + { + mid_blue++; + val += 10 * log(1 + count_raw_blue[mid_blue]); + } + + xsane_bound_int(&mid_blue, min_blue, max_blue); + + xsane.auto_white = max/2.55; + xsane.auto_gray = mid/2.55; + xsane.auto_black = min/2.55; + + xsane.auto_white_red = max_red/2.55; + xsane.auto_gray_red = mid_red/2.55; + xsane.auto_black_red = min_red/2.55; + + xsane.auto_white_green = max_green/2.55; + xsane.auto_gray_green = mid_green/2.55; + xsane.auto_black_green = min_green/2.55; + + xsane.auto_white_blue = max_blue/2.55; + xsane.auto_gray_blue = mid_blue/2.55; + xsane.auto_black_blue = min_blue/2.55; + } + + DBG(DBG_proc, "xsane.auto_white = %f\n", xsane.auto_white); + DBG(DBG_proc, "xsane.auto_gray = %f\n", xsane.auto_gray); + DBG(DBG_proc, "xsane.auto_black = %f\n", xsane.auto_black); + DBG(DBG_proc, "xsane.auto_white_red = %f\n", xsane.auto_white_red); + DBG(DBG_proc, "xsane.auto_gray_red = %f\n", xsane.auto_gray_red); + DBG(DBG_proc, "xsane.auto_black_red = %f\n", xsane.auto_black_red); + DBG(DBG_proc, "xsane.auto_white_green = %f\n", xsane.auto_white_green); + DBG(DBG_proc, "xsane.auto_gray_green = %f\n", xsane.auto_gray_green); + DBG(DBG_proc, "xsane.auto_black_green = %f\n", xsane.auto_black_green); + DBG(DBG_proc, "xsane.auto_white_blue = %f\n", xsane.auto_white_blue); + DBG(DBG_proc, "xsane.auto_gray_blue = %f\n", xsane.auto_gray_blue); + DBG(DBG_proc, "xsane.auto_black_blue = %f\n", xsane.auto_black_blue); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_calculate_raw_histogram(void) +{ + SANE_Int *count_raw; + SANE_Int *count_raw_red; + SANE_Int *count_raw_green; + SANE_Int *count_raw_blue; + int i; + int maxval_raw; + double scale_raw; + + DBG(DBG_proc, "xsane_calculate_raw_histogram\n"); + + /* at first reset auto enhancement values */ + + xsane.auto_black = 0.0; + xsane.auto_gray = 50.0; + xsane.auto_white = 100.0; + + xsane.auto_black_red = 0.0; + xsane.auto_gray_red = 50.0; + xsane.auto_white_red = 100.0; + + xsane.auto_black_green = 0.0; + xsane.auto_gray_green = 50.0; + xsane.auto_white_green = 100.0; + + xsane.auto_black_blue = 0.0; + xsane.auto_gray_blue = 50.0; + xsane.auto_white_blue = 100.0; + + if (xsane.preview) /* preview window exists? */ + { + count_raw = calloc(256, sizeof(SANE_Int)); + count_raw_red = calloc(256, sizeof(SANE_Int)); + count_raw_green = calloc(256, sizeof(SANE_Int)); + count_raw_blue = calloc(256, sizeof(SANE_Int)); + + preview_calculate_raw_histogram(xsane.preview, count_raw, count_raw_red, count_raw_green, count_raw_blue); + + if (xsane.param.depth > 1) + { + xsane_calculate_auto_enhancement(count_raw, count_raw_red, count_raw_green, count_raw_blue); + } + + if (xsane.histogram_log) /* logarithmical display */ + { + for (i=0; i<=255; i++) + { + count_raw[i] = (int) (50*log(1.0 + count_raw[i])); + count_raw_red[i] = (int) (50*log(1.0 + count_raw_red[i])); + count_raw_green[i] = (int) (50*log(1.0 + count_raw_green[i])); + count_raw_blue[i] = (int) (50*log(1.0 + count_raw_blue[i])); + } + } + + maxval_raw = 1; /* we do not use 0 here because we divide through this varaible later */ + + /* first and last 10 values are not used for calculating maximum value */ + for (i = 10 ; i < HIST_WIDTH - 10; i++) + { + if (count_raw[i] > maxval_raw) { maxval_raw = count_raw[i]; } + if (count_raw_red[i] > maxval_raw) { maxval_raw = count_raw_red[i]; } + if (count_raw_green[i] > maxval_raw) { maxval_raw = count_raw_green[i]; } + if (count_raw_blue[i] > maxval_raw) { maxval_raw = count_raw_blue[i]; } + } + scale_raw = 100.0/maxval_raw; + + if (xsane.histogram_lines) + { + xsane_draw_histogram_with_lines(&xsane.histogram_raw, + count_raw, count_raw_red, count_raw_green, count_raw_blue, + xsane.histogram_red, xsane.histogram_green, xsane.histogram_blue, + xsane.histogram_int, scale_raw); + } + else + { + xsane_draw_histogram_with_points(&xsane.histogram_raw, + count_raw, count_raw_red, count_raw_green, count_raw_blue, + xsane.histogram_red, xsane.histogram_green, xsane.histogram_blue, + xsane.histogram_int, scale_raw); + } + + free(count_raw_blue); + free(count_raw_green); + free(count_raw_red); + free(count_raw); + } + else + { + xsane_clear_histogram(&xsane.histogram_raw); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_calculate_enh_histogram(void) +{ + SANE_Int *count_enh; + SANE_Int *count_enh_red; + SANE_Int *count_enh_green; + SANE_Int *count_enh_blue; + int i; + int maxval_enh; + double scale_enh; + + DBG(DBG_proc, "xsane_calculate_enh_histogram\n"); + + if (xsane.preview) /* preview window exists? */ + { + count_enh = calloc(256, sizeof(SANE_Int)); + count_enh_red = calloc(256, sizeof(SANE_Int)); + count_enh_green = calloc(256, sizeof(SANE_Int)); + count_enh_blue = calloc(256, sizeof(SANE_Int)); + + preview_calculate_enh_histogram(xsane.preview, count_enh, count_enh_red, count_enh_green, count_enh_blue); + + if (xsane.histogram_log) /* logarithmical display */ + { + for (i=0; i<=255; i++) + { + count_enh[i] = (int) (50*log(1.0 + count_enh[i])); + count_enh_red[i] = (int) (50*log(1.0 + count_enh_red[i])); + count_enh_green[i] = (int) (50*log(1.0 + count_enh_green[i])); + count_enh_blue[i] = (int) (50*log(1.0 + count_enh_blue[i])); + } + } + + maxval_enh = 1; + + /* first and last 10 values are not used for calculating maximum value */ + for (i = 10 ; i < HIST_WIDTH - 10; i++) + { + if (count_enh[i] > maxval_enh) { maxval_enh = count_enh[i]; } + if (count_enh_red[i] > maxval_enh) { maxval_enh = count_enh_red[i]; } + if (count_enh_green[i] > maxval_enh) { maxval_enh = count_enh_green[i]; } + if (count_enh_blue[i] > maxval_enh) { maxval_enh = count_enh_blue[i]; } + } + scale_enh = 100.0/maxval_enh; + + if (xsane.histogram_lines) + { + xsane_draw_histogram_with_lines(&xsane.histogram_enh, + count_enh, count_enh_red, count_enh_green, count_enh_blue, + xsane.histogram_red, xsane.histogram_green, xsane.histogram_blue, xsane.histogram_int, scale_enh); + } + else + { + xsane_draw_histogram_with_points(&xsane.histogram_enh, + count_enh, count_enh_red, count_enh_green, count_enh_blue, + xsane.histogram_red, xsane.histogram_green, xsane.histogram_blue, xsane.histogram_int, scale_enh); + } + + free(count_enh_blue); + free(count_enh_green); + free(count_enh_red); + free(count_enh); + } + else + { + xsane_clear_histogram(&xsane.histogram_enh); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_update_histogram(int update_raw) +{ + DBG(DBG_proc, "xsane_update_histogram\n"); + + if (preferences.show_histogram) + { + if (update_raw) + { + xsane_calculate_raw_histogram(); + } + xsane_calculate_enh_histogram(); + + gtk_widget_show(xsane.histogram_dialog); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_histogram_toggle_button_callback(GtkWidget *widget, gpointer data) +{ + int *valuep = data; + + DBG(DBG_proc, "xsane_histogram_toggle_button_callback\n"); + + *valuep = (GTK_TOGGLE_BUTTON(widget)->active != 0); + xsane_update_histogram(TRUE); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_create_preview_threshold_curve(u_char *gammadata, double threshold, int numbers) +{ + int i; + int maxin = numbers-1; + int threshold_level; + + DBG(DBG_proc, "xsane_create_preview_threshold_curve\n"); + + xsane_bound_double(&threshold, 0.0, 100.0); + threshold_level = maxin * threshold / 100.0; + + for (i=0; i < threshold_level; i++) + { + gammadata[i] = 0; + } + + for (i=threshold_level; i <= maxin; i++) + { + gammadata[i] = 255; + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_create_preview_gamma_curve(u_char *gammadata, int negative, double gamma, + double brightness, double contrast, + double medium_shadow, double medium_highlight, double medium_gamma, + int numbers) +{ + int i; + double midin; + double val; + double m; + double b; + int maxin = numbers-1; + double medium_m; + double medium_mid; + + medium_m = 100.0/(medium_highlight - medium_shadow); + medium_mid = (medium_shadow + medium_highlight)/200.0 * maxin; + + DBG(DBG_proc, "xsane_create_preview_gamma_curve(neg=%d, gam=%3.2f, bri=%3.2f, ctr=%3.2f, nrs=%d)\n", + negative, gamma, brightness, contrast, numbers); + + if (contrast < -100.0) + { + contrast = -100.0; + } + + midin = (int)(numbers / 2.0); + + m = 1.0 + contrast/100.0; + b = (1.0 + brightness/100.0) * midin; + + if (negative) + { + for (i=0; i <= maxin; i++) + { + val = ((double) i); + + /* medium correction */ + val = (val - medium_mid) * medium_m + midin; + xsane_bound_double(&val, 0.0, maxin); + val = maxin - val; /* invert */ + val = maxin * pow( val/maxin, (1.0/medium_gamma) ); + + val = val - midin; + + /* user correction */ + val = val * m + b; + xsane_bound_double(&val, 0.0, maxin); + + gammadata[i] = (u_char) (255 * pow( val/maxin, (1.0/gamma) )); + } + } + else /* positive */ + { + for (i=0; i <= maxin; i++) + { + val = ((double) i); + + /* medium correction */ + val = (val - medium_mid) * medium_m + midin; + xsane_bound_double(&val, 0.0, maxin); + val = maxin * pow( val/maxin, (1.0/medium_gamma) ); + + val = val - midin; + + /* user correction */ + val = val * m + b; + xsane_bound_double(&val, 0.0, maxin); + + gammadata[i] = (u_char) (255 * pow( val/maxin, (1.0/gamma) )); + } + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_create_gamma_curve(SANE_Int *gammadata, + int negative, double gamma, double brightness, double contrast, + double medium_shadow, double medium_highlight, double medium_gamma, + int numbers, int maxout) +{ + int i; + double midin; + double val; + double m; + double b; + double medium_m; + double medium_mid; + int maxin = numbers-1; + + DBG(DBG_proc, "xsane_create_gamma_curve(neg=%d, gam=%3.2f, bri=%3.2f, ctr=%3.2f, " + "mshd=%3.2f, mhig=%3.2f, mgam=%3.2f, " + "nrs=%d, max=%d)\n", + negative, gamma, brightness, contrast, + medium_shadow, medium_highlight, medium_gamma, + numbers, maxout); + + midin = (int)(numbers / 2.0); + + if (contrast < -100.0) + { + contrast = -100.0; + } + + medium_m = 100.0/(medium_highlight - medium_shadow); + medium_mid = (medium_shadow + medium_highlight)/200.0 * maxin; + + m = 1.0 + contrast/100.0; + b = (1.0 + brightness/100.0) * midin; + + if (negative) + { + for (i=0; i <= maxin; i++) + { + val = ((double) i); + + /* medium correction */ + val = (val - medium_mid) * medium_m + midin; + xsane_bound_double(&val, 0.0, maxin); + val = maxin - val; /* invert */ + val = maxin * pow( val/maxin, (1.0/medium_gamma) ); + + val = val - midin; + + /* user correction */ + val = val * m + b; + xsane_bound_double(&val, 0.0, maxin); + gammadata[i] = maxout * pow( val/maxin, (1.0/gamma) ); + } + } + else /* positive */ + { + for (i=0; i <= maxin; i++) + { + val = ((double) i); + + /* medium correction */ + val = (val - medium_mid) * medium_m + midin; + xsane_bound_double(&val, 0.0, maxin); + val = maxin * pow( val/maxin, (1.0/medium_gamma) ); + + val = val - midin; + + /* user correction */ + val = val * m + b; + xsane_bound_double(&val, 0.0, maxin); + gammadata[i] = maxout * pow( val/maxin, (1.0/gamma) ); + } + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_update_gamma_curve(int update_raw) +{ + DBG(DBG_proc, "xsane_update_gamma_curve\n"); + + if (xsane.preview) + { + if (!xsane.preview_gamma_data_red) + { + xsane.preview_gamma_size = pow(2, preferences.preview_gamma_input_bits); + + xsane.preview_gamma_data_red = malloc(xsane.preview_gamma_size); + xsane.preview_gamma_data_green = malloc(xsane.preview_gamma_size); + xsane.preview_gamma_data_blue = malloc(xsane.preview_gamma_size); + + xsane.histogram_gamma_data_red = malloc(xsane.preview_gamma_size); + xsane.histogram_gamma_data_green = malloc(xsane.preview_gamma_size); + xsane.histogram_gamma_data_blue = malloc(xsane.preview_gamma_size); + + xsane.histogram_medium_gamma_data_red = malloc(xsane.preview_gamma_size); + xsane.histogram_medium_gamma_data_green = malloc(xsane.preview_gamma_size); + xsane.histogram_medium_gamma_data_blue = malloc(xsane.preview_gamma_size); + } + + if (xsane.preview->calibration) + { + double pgamma_red; + double pgamma_green; + double pgamma_blue; + + pgamma_red = preferences.preview_gamma * preferences.preview_gamma_red; + pgamma_green = preferences.preview_gamma * preferences.preview_gamma_green; + pgamma_blue = preferences.preview_gamma * preferences.preview_gamma_blue; + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_red, 0, pgamma_red, + 0.0, 0.0, 0.0, 100.0, 1.0, xsane.preview_gamma_size); + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_green, 0, pgamma_green, + 0.0, 0.0, 0.0, 100.0, 1.0, xsane.preview_gamma_size); + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_blue, 0, pgamma_blue, + 0.0, 0.0, 0.0, 100.0, 1.0, xsane.preview_gamma_size); + } + else if (xsane.param.depth == 1) /* for lineart mode with grayscale preview scan */ + { + xsane_create_preview_threshold_curve(xsane.preview_gamma_data_red, xsane.threshold, xsane.preview_gamma_size); + xsane_create_preview_threshold_curve(xsane.preview_gamma_data_green, xsane.threshold, xsane.preview_gamma_size); + xsane_create_preview_threshold_curve(xsane.preview_gamma_data_blue, xsane.threshold, xsane.preview_gamma_size); + + xsane_create_preview_threshold_curve(xsane.histogram_gamma_data_red, xsane.threshold, xsane.preview_gamma_size); + xsane_create_preview_threshold_curve(xsane.histogram_gamma_data_green, xsane.threshold, xsane.preview_gamma_size); + xsane_create_preview_threshold_curve(xsane.histogram_gamma_data_blue, xsane.threshold, xsane.preview_gamma_size); + } + else /* multi bit mode */ + { + double pgamma_red = 1.0; + double pgamma_green = 1.0; + double pgamma_blue = 1.0; + + if ((xsane.mode != XSANE_GIMP_EXTENSION) || (!preferences.disable_gimp_preview_gamma)) + { + pgamma_red = preferences.preview_gamma * preferences.preview_gamma_red; + pgamma_green = preferences.preview_gamma * preferences.preview_gamma_green; + pgamma_blue = preferences.preview_gamma * preferences.preview_gamma_blue; + } + + +#ifdef HAVE_WORKING_GTK_GAMMACURVE +#if 1 + gtk_curve_get_vector(GTK_CURVE(GTK_GAMMA_CURVE(xsane.gamma_curve_gray)->curve), 65536, xsane.free_gamma_data); +#if 1 +{ + int i; + for (i=0; i<100; i++) + { + printf("%1.6f ", xsane.free_gamma_data[i]); + if (i / 10.0 == i / 10) + { + printf("\n"); + } + } + printf("\n"); + for (i=65435; i<65536; i++) + { + printf("%1.6f ", xsane.free_gamma_data[i]); + if (i / 10.0 == i / 10) + { + printf("\n"); + } + } + printf("\n"); + printf("\n"); +} +#endif + gtk_curve_get_vector(GTK_CURVE(GTK_GAMMA_CURVE(xsane.gamma_curve_red)->curve), 65536, xsane.free_gamma_data_red); + gtk_curve_get_vector(GTK_CURVE(GTK_GAMMA_CURVE(xsane.gamma_curve_green)->curve), 65536, xsane.free_gamma_data_green); + gtk_curve_get_vector(GTK_CURVE(GTK_GAMMA_CURVE(xsane.gamma_curve_blue)->curve), 65536, xsane.free_gamma_data_blue); +#endif + + xsane_get_free_gamma_curve(xsane.free_gamma_data_red, xsane.preview_gamma_data_red, xsane.negative, + xsane.gamma * xsane.gamma_red * pgamma_red, + xsane.brightness + xsane.brightness_red, + xsane.contrast + xsane.contrast_red, xsane.preview_gamma_size, 255); + + xsane_get_free_gamma_curve(xsane.free_gamma_data_green, xsane.preview_gamma_data_green, xsane.negative, + xsane.gamma * xsane.gamma_green * pgamma_green, + xsane.brightness + xsane.brightness_green, + xsane.contrast + xsane.contrast_green, xsane.preview_gamma_size, 255); + + xsane_get_free_gamma_curve(xsane.free_gamma_data_blue, xsane.preview_gamma_data_blue, xsane.negative, + xsane.gamma * xsane.gamma_blue * pgamma_blue, + xsane.brightness + xsane.brightness_blue, + xsane.contrast + xsane.contrast_blue , xsane.preview_gamma_size, 255); + + + xsane_get_free_gamma_curve(xsane.free_gamma_data_red, xsane.histogram_gamma_data_red, xsane.negative, + xsane.gamma * xsane.gamma_red, + xsane.brightness + xsane.brightness_red, + xsane.contrast + xsane.contrast_red, xsane.preview_gamma_size, 255); + + xsane_get_free_gamma_curve(xsane.free_gamma_data_green, xsane.histogram_gamma_data_green, xsane.negative, + xsane.gamma * xsane.gamma_green, + xsane.brightness + xsane.brightness_green, + xsane.contrast + xsane.contrast_green, xsane.preview_gamma_size, 255); + + xsane_get_free_gamma_curve(xsane.free_gamma_data_blue, xsane.histogram_gamma_data_blue, xsane.negative, + xsane.gamma * xsane.gamma_blue, + xsane.brightness + xsane.brightness_blue, + xsane.contrast + xsane.contrast_blue , xsane.preview_gamma_size, 255); +#else + if ( ( ( (xsane.xsane_colors > 1) && xsane.scanner_gamma_color ) || /* color scan and gamma table for red, green and blue available */ + xsane.scanner_gamma_gray ) && /* grayscale scan and gamma table for gray available */ + (!xsane.no_preview_medium_gamma) ) /* do not use gamma table when disabled */ + { + DBG(DBG_info, "creating preview gamma tables without medium correction\n"); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_red, xsane.negative, + xsane.gamma * xsane.gamma_red * pgamma_red, + xsane.brightness + xsane.brightness_red, + xsane.contrast + xsane.contrast_red, + 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_green, xsane.negative, + xsane.gamma * xsane.gamma_green * pgamma_green, + xsane.brightness + xsane.brightness_green, + xsane.contrast + xsane.contrast_green, + 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_blue, xsane.negative, + xsane.gamma * xsane.gamma_blue * pgamma_blue, + xsane.brightness + xsane.brightness_blue, + xsane.contrast + xsane.contrast_blue, + 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_red, xsane.negative, + xsane.gamma * xsane.gamma_red, + xsane.brightness + xsane.brightness_red, + xsane.contrast + xsane.contrast_red, + 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_green, xsane.negative, + xsane.gamma * xsane.gamma_green, + xsane.brightness + xsane.brightness_green, + xsane.contrast + xsane.contrast_green, + 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_blue, xsane.negative, + xsane.gamma * xsane.gamma_blue, + xsane.brightness + xsane.brightness_blue, + xsane.contrast + xsane.contrast_blue, + 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + + if (update_raw) /* to speed up things here */ + { + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_red, xsane.negative, + 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_green, xsane.negative, + 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_blue, xsane.negative, + 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, + xsane.preview_gamma_size); + } + } + else if (xsane.xsane_colors > 1) /* color scan, no color scanner gamma tables available */ + { + DBG(DBG_info, "creating preview gamma tables with medium correction\n"); + + xsane.medium_changed = FALSE; + + preview_display_valid(xsane.preview); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_red, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_red * pgamma_red, + xsane.brightness + xsane.brightness_red, + xsane.contrast + xsane.contrast_red, + xsane.medium_shadow_red, xsane.medium_highlight_red, xsane.medium_gamma_red, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_green, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_green * pgamma_green, + xsane.brightness + xsane.brightness_green, + xsane.contrast + xsane.contrast_green, + xsane.medium_shadow_green, xsane.medium_highlight_green, xsane.medium_gamma_green, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_blue, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_blue * pgamma_blue, + xsane.brightness + xsane.brightness_blue, + xsane.contrast + xsane.contrast_blue, + xsane.medium_shadow_blue, xsane.medium_highlight_blue, xsane.medium_gamma_blue, + xsane.preview_gamma_size); + + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_red, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_red, + xsane.brightness + xsane.brightness_red, + xsane.contrast + xsane.contrast_red, + xsane.medium_shadow_red, xsane.medium_highlight_red, xsane.medium_gamma_red, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_green, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_green, + xsane.brightness + xsane.brightness_green, + xsane.contrast + xsane.contrast_green, + xsane.medium_shadow_green, xsane.medium_highlight_green, xsane.medium_gamma_green, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_blue, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_blue, + xsane.brightness + xsane.brightness_blue, + xsane.contrast + xsane.contrast_blue, + xsane.medium_shadow_blue, xsane.medium_highlight_blue, xsane.medium_gamma_blue, + xsane.preview_gamma_size); + + + if (update_raw) /* to speed up things here */ + { + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_red, xsane.negative != xsane.medium_negative, + 1.0, 0.0, 0.0, + xsane.medium_shadow_red, xsane.medium_highlight_red, xsane.medium_gamma_red, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_green, xsane.negative != xsane.medium_negative, + 1.0, 0.0, 0.0, + xsane.medium_shadow_green, xsane.medium_highlight_green, xsane.medium_gamma_green, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_blue, xsane.negative != xsane.medium_negative, + 1.0, 0.0, 0.0, + xsane.medium_shadow_blue, xsane.medium_highlight_blue, xsane.medium_gamma_blue, + xsane.preview_gamma_size); + } + } + else /* grayscale scan, no gray scanner gamma table available */ + { + DBG(DBG_info, "creating preview gamma tables with medium correction\n"); + + xsane.medium_changed = FALSE; + + preview_display_valid(xsane.preview); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_red, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_red * pgamma_red, + xsane.brightness + xsane.brightness_red, + xsane.contrast + xsane.contrast_red, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_green, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_green * pgamma_green, + xsane.brightness + xsane.brightness_green, + xsane.contrast + xsane.contrast_green, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.preview_gamma_data_blue, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_blue * pgamma_blue, + xsane.brightness + xsane.brightness_blue, + xsane.contrast + xsane.contrast_blue, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_red, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_red, + xsane.brightness + xsane.brightness_red, + xsane.contrast + xsane.contrast_red, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_green, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_green, + xsane.brightness + xsane.brightness_green, + xsane.contrast + xsane.contrast_green, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_gamma_data_blue, xsane.negative != xsane.medium_negative, + xsane.gamma * xsane.gamma_blue, + xsane.brightness + xsane.brightness_blue, + xsane.contrast + xsane.contrast_blue, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + + + if (update_raw) /* to speed up things here */ + { + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_red, xsane.negative != xsane.medium_negative, + 1.0, 0.0, 0.0, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_green, xsane.negative != xsane.medium_negative, + 1.0, 0.0, 0.0, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + + xsane_create_preview_gamma_curve(xsane.histogram_medium_gamma_data_blue, xsane.negative != xsane.medium_negative, + 1.0, 0.0, 0.0, + xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, + xsane.preview_gamma_size); + } + } +#endif + } + + preview_gamma_correction(xsane.preview, preferences.preview_gamma_input_bits, + xsane.preview_gamma_data_red, xsane.preview_gamma_data_green, xsane.preview_gamma_data_blue, + xsane.histogram_gamma_data_red, xsane.histogram_gamma_data_green, xsane.histogram_gamma_data_blue, + xsane.histogram_medium_gamma_data_red, xsane.histogram_medium_gamma_data_green, xsane.histogram_medium_gamma_data_blue); + + xsane_update_histogram(update_raw); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void xsane_enhancement_update(void) +{ + guint sig_changed=0; + + DBG(DBG_proc, "xsane_enhancement_update\n"); + + if (xsane.param.depth == 1) /* lineart? no gamma */ + { + return; + } + + sig_changed = gtk_signal_lookup("changed", GTK_OBJECT_TYPE(xsane.gamma_widget)); + + GTK_ADJUSTMENT(xsane.gamma_widget)->value = xsane.gamma; + GTK_ADJUSTMENT(xsane.brightness_widget)->value = xsane.brightness; + GTK_ADJUSTMENT(xsane.contrast_widget)->value = xsane.contrast; + + if ( (xsane.xsane_colors > 1) && (!xsane.enhancement_rgb_default) ) + { + GTK_ADJUSTMENT(xsane.gamma_red_widget)->value = xsane.gamma_red; + GTK_ADJUSTMENT(xsane.gamma_green_widget)->value = xsane.gamma_green; + GTK_ADJUSTMENT(xsane.gamma_blue_widget)->value = xsane.gamma_blue; + + GTK_ADJUSTMENT(xsane.brightness_red_widget)->value = xsane.brightness_red; + GTK_ADJUSTMENT(xsane.brightness_green_widget)->value = xsane.brightness_green; + GTK_ADJUSTMENT(xsane.brightness_blue_widget)->value = xsane.brightness_blue; + + GTK_ADJUSTMENT(xsane.contrast_red_widget)->value = xsane.contrast_red; + GTK_ADJUSTMENT(xsane.contrast_green_widget)->value = xsane.contrast_green; + GTK_ADJUSTMENT(xsane.contrast_blue_widget)->value = xsane.contrast_blue; + + gtk_signal_emit(xsane.gamma_red_widget, sig_changed); + gtk_signal_emit(xsane.gamma_green_widget, sig_changed); + gtk_signal_emit(xsane.gamma_blue_widget, sig_changed); + + gtk_signal_emit(xsane.brightness_red_widget, sig_changed); + gtk_signal_emit(xsane.brightness_green_widget, sig_changed); + gtk_signal_emit(xsane.brightness_blue_widget, sig_changed); + + gtk_signal_emit(xsane.contrast_red_widget, sig_changed); + gtk_signal_emit(xsane.contrast_green_widget, sig_changed); + gtk_signal_emit(xsane.contrast_blue_widget, sig_changed); + + } + + gtk_signal_emit(xsane.gamma_widget, sig_changed); + gtk_signal_emit(xsane.brightness_widget, sig_changed); + gtk_signal_emit(xsane.contrast_widget, sig_changed); + + xsane_update_sliders(); /* update histogram slider */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void xsane_gamma_to_histogram(double *min, double *mid, double *max, + double contrast, double brightness, double gamma) +{ + double m; + double b; + + DBG(DBG_proc, "xsane_gamma_to_histogram\n"); + + m = 1.0 + contrast/100.0; + b = (1.0 + brightness/100.0) * 50.0; + + if (m > 0) + { + *min = 50.0 - b/m; + *mid = (100.0 * pow(0.5, gamma)-b) / m + 50.0; + *max = (100.0-b)/m + 50.0; + } + else + { + *min = 0.0; + *mid = 50.0; + *max = 100.0; + } + + xsane_bound_double(min, 0.0, 98.0); + xsane_bound_double(max, *min+1, 100.0); + xsane_bound_double(mid, *min+1, *max-1); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_enhancement_by_gamma(void) +{ + double min, mid, max; + double contrast, brightness, gamma; + + DBG(DBG_proc, "xsane_enhancement_by_gamma\n"); + + xsane_gamma_to_histogram(&min, &mid, &max, xsane.contrast, xsane.brightness, xsane.gamma); + + xsane.slider_gray.value[0] = min; + xsane.slider_gray.value[1] = mid; + xsane.slider_gray.value[2] = max; + + + /* red */ + contrast = xsane.contrast + xsane.contrast_red; + brightness = xsane.brightness + xsane.brightness_red; + gamma = xsane.gamma * xsane.gamma_red; + + if (contrast < -100) + { + contrast = -100; + } + + xsane_gamma_to_histogram(&min, &mid, &max, contrast, brightness, gamma); + + + xsane.slider_red.value[0] = min; + xsane.slider_red.value[1] = mid; + xsane.slider_red.value[2] = max; + + + /* green */ + contrast = xsane.contrast + xsane.contrast_green; + brightness = xsane.brightness + xsane.brightness_green; + gamma = xsane.gamma * xsane.gamma_green; + + if (contrast < -100) + { + contrast = -100; + } + + xsane_gamma_to_histogram(&min, &mid, &max, contrast, brightness, gamma); + + xsane.slider_green.value[0] = min; + xsane.slider_green.value[1] = mid; + xsane.slider_green.value[2] = max; + + + /* blue */ + contrast = xsane.contrast + xsane.contrast_blue; + brightness = xsane.brightness + xsane.brightness_blue; + gamma = xsane.gamma * xsane.gamma_blue; + + if (contrast < -100) + { + contrast = -100; + } + + xsane_gamma_to_histogram(&min, &mid, &max, contrast, brightness, gamma); + + xsane.slider_blue.value[0] = min; + xsane.slider_blue.value[1] = mid; + xsane.slider_blue.value[2] = max; + + + xsane_enhancement_update(); + xsane_update_gamma_curve(FALSE); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_enhancement_restore_default() +{ + DBG(DBG_proc, "xsane_enhancement_restore_default\n"); + + xsane.gamma = 1.0; + xsane.gamma_red = 1.0; + xsane.gamma_green = 1.0; + xsane.gamma_blue = 1.0; + + xsane.brightness = 0.0; + xsane.brightness_red = 0.0; + xsane.brightness_green = 0.0; + xsane.brightness_blue = 0.0; + + xsane.contrast = 0.0; + xsane.contrast_red = 0.0; + xsane.contrast_green = 0.0; + xsane.contrast_blue = 0.0; + + xsane_enhancement_by_gamma(); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_enhancement_restore() +{ + DBG(DBG_proc, "xsane_enhancement_restore\n"); + + xsane.gamma = preferences.xsane_gamma; + xsane.gamma_red = preferences.xsane_gamma_red; + xsane.gamma_green = preferences.xsane_gamma_green; + xsane.gamma_blue = preferences.xsane_gamma_blue; + + xsane.brightness = preferences.xsane_brightness; + xsane.brightness_red = preferences.xsane_brightness_red; + xsane.brightness_green = preferences.xsane_brightness_green; + xsane.brightness_blue = preferences.xsane_brightness_blue; + + xsane.contrast = preferences.xsane_contrast; + xsane.contrast_red = preferences.xsane_contrast_red; + xsane.contrast_green = preferences.xsane_contrast_green; + xsane.contrast_blue = preferences.xsane_contrast_blue; + + xsane.enhancement_rgb_default = preferences.xsane_rgb_default; + xsane.negative = preferences.xsane_negative; + + xsane_refresh_dialog(); + xsane_enhancement_by_gamma(); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_enhancement_store() +{ + DBG(DBG_proc, "xsane_enhancement_store\n"); + + preferences.xsane_gamma = xsane.gamma; + preferences.xsane_gamma_red = xsane.gamma_red; + preferences.xsane_gamma_green = xsane.gamma_green; + preferences.xsane_gamma_blue = xsane.gamma_blue; + + preferences.xsane_brightness = xsane.brightness; + preferences.xsane_brightness_red = xsane.brightness_red; + preferences.xsane_brightness_green = xsane.brightness_green; + preferences.xsane_brightness_blue = xsane.brightness_blue; + + preferences.xsane_contrast = xsane.contrast; + preferences.xsane_contrast_red = xsane.contrast_red; + preferences.xsane_contrast_green = xsane.contrast_green; + preferences.xsane_contrast_blue = xsane.contrast_blue; + + preferences.xsane_rgb_default = xsane.enhancement_rgb_default; + preferences.xsane_negative = xsane.negative; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static int xsane_histogram_to_gamma(XsaneSlider *slider, + double *contrast, double contrast_offset, + double *brightness, double brightness_offset, + double *gamma, double gamma_multiplier) +{ + double mid; + double range; + int correct_bound = ((slider->active == XSANE_SLIDER_ACTIVE) || (slider->active == XSANE_SLIDER_INACTIVE)); /* slider not moved */ + + DBG(DBG_proc, "xsane_histogram_to_gamma(correct_bound = %d)\n", correct_bound); + + *contrast = (10000.0 / (slider->value[2] - slider->value[0]) - 100.0); + if (correct_bound) + { + xsane_bound_double(contrast, -100.0 + contrast_offset, xsane.contrast_max + contrast_offset); + } + + *brightness = - (slider->value[0] - 50.0) * (*contrast + 100.0)/50.0 - 100.0; + if (correct_bound) + { + xsane_bound_double(brightness, xsane.brightness_min + brightness_offset, xsane.brightness_max + brightness_offset); + } + + mid = slider->value[1] - slider->value[0]; + range = slider->value[2] - slider->value[0]; + + *gamma = log(mid/range) / log(0.5); + if (correct_bound) + { + xsane_bound_double(gamma, XSANE_GAMMA_MIN * gamma_multiplier, XSANE_GAMMA_MAX * gamma_multiplier); + return 1; /* in bound */ + } + else if (xsane_check_bound_double(*contrast, -100.0 + contrast_offset, xsane.contrast_max + contrast_offset) && + xsane_check_bound_double(*brightness, XSANE_BRIGHTNESS_MIN + brightness_offset, xsane.brightness_max + brightness_offset) && + xsane_check_bound_double(*gamma, XSANE_GAMMA_MIN * gamma_multiplier, XSANE_GAMMA_MAX * gamma_multiplier)) + { + return 1; /* in bound */ + } + return 0; /* out of bound */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_enhancement_by_histogram(int update_gamma) +{ + double gray_brightness; + double gray_contrast; + double gray_gamma; + double brightness; + double contrast; + double gamma; + + DBG(DBG_proc, "xsane_enhancement_by_histogram\n"); + + if (xsane_histogram_to_gamma(&xsane.slider_gray, &gray_contrast, 0, &gray_brightness, 0, &gray_gamma, 1.0)) + { + if (update_gamma) + { + xsane.gamma = gray_gamma; + } + + xsane.brightness = gray_brightness; + xsane.contrast = gray_contrast; + } + + if ( (xsane.xsane_colors > 1) && (!xsane.enhancement_rgb_default) ) /* rgb sliders active */ + { + if ((xsane.slider_gray.active == XSANE_SLIDER_ACTIVE) || + (xsane.slider_gray.active == XSANE_SLIDER_INACTIVE)) /* gray slider not moved */ + { + /* red */ + if (xsane_histogram_to_gamma(&xsane.slider_red, &contrast, gray_contrast, &brightness, gray_brightness, &gamma, gray_gamma)) + { + if (update_gamma) + { + xsane.gamma_red = gamma / gray_gamma; + } + xsane.brightness_red = brightness - gray_brightness; + xsane.contrast_red = contrast - gray_contrast; + } + + /* green */ + if (xsane_histogram_to_gamma(&xsane.slider_green, &contrast, gray_contrast, &brightness, gray_brightness, &gamma, gray_gamma)) + { + if (update_gamma) + { + xsane.gamma_green = gamma / gray_gamma; + } + xsane.brightness_green = brightness - gray_brightness; + xsane.contrast_green = contrast - gray_contrast; + } + + /* blue */ + if (xsane_histogram_to_gamma(&xsane.slider_blue, &contrast, gray_contrast, &brightness, gray_brightness, &gamma, gray_gamma)) + { + if (update_gamma) + { + xsane.gamma_blue = gamma / gray_gamma; + } + xsane.brightness_blue = brightness - gray_brightness; + xsane.contrast_blue = contrast - gray_contrast; + } + + } + } + + xsane_enhancement_by_gamma(); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint xsane_histogram_win_delete(GtkWidget *widget, gpointer data) +{ + DBG(DBG_proc, "xsane_histogram_win_delete\n"); + + gtk_widget_hide(widget); + preferences.show_histogram = FALSE; + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(xsane.show_histogram_widget), preferences.show_histogram); + return TRUE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_create_histogram_dialog(const char *devicetext) +{ + char windowname[255]; + GtkWidget *xsane_color_hbox; + GtkWidget *xsane_histogram_vbox; + GtkWidget *button; + GdkColor color_black; + GdkColor color_red; + GdkColor color_green; + GdkColor color_blue; + GdkColor color_backg; + GdkColormap *colormap; + GtkStyle *style; + + DBG(DBG_proc, "xsane_create_histogram_dialog\n"); + + xsane.histogram_dialog = gtk_window_new(GTK_WINDOW_DIALOG); + gtk_window_set_policy(GTK_WINDOW(xsane.histogram_dialog), FALSE, FALSE, FALSE); + gtk_widget_set_uposition(xsane.histogram_dialog, XSANE_HISTOGRAM_POS_X, XSANE_HISTOGRAM_POS_Y); + gtk_signal_connect(GTK_OBJECT(xsane.histogram_dialog), "delete_event", GTK_SIGNAL_FUNC(xsane_histogram_win_delete), NULL); + sprintf(windowname, "%s %s", WINDOW_HISTOGRAM, devicetext); + gtk_window_set_title(GTK_WINDOW(xsane.histogram_dialog), windowname); + xsane_set_window_icon(xsane.histogram_dialog, 0); + gtk_accel_group_attach(xsane.accelerator_group, GTK_OBJECT(xsane.histogram_dialog)); + + xsane_histogram_vbox = gtk_vbox_new(FALSE, 0); + gtk_container_set_border_width(GTK_CONTAINER(xsane_histogram_vbox), 5); + gtk_container_add(GTK_CONTAINER(xsane.histogram_dialog), xsane_histogram_vbox); + gtk_widget_show(xsane_histogram_vbox); + + + /* set gc for histogram drawing */ + gtk_widget_realize(xsane.histogram_dialog); /* realize dialog to get colors and style */ + + style = gtk_widget_get_style(xsane.histogram_dialog); +/* + style = gtk_rc_get_style(xsane.histogram_dialog); + style = gtk_widget_get_default_style(); +*/ + + xsane.gc_trans = style->bg_gc[GTK_STATE_NORMAL]; + xsane.bg_trans = &style->bg[GTK_STATE_NORMAL]; + + colormap = gdk_window_get_colormap(xsane.histogram_dialog->window); + + xsane.gc_black = gdk_gc_new(xsane.histogram_dialog->window); + color_black.red = 0; + color_black.green = 0; + color_black.blue = 0; + gdk_color_alloc(colormap, &color_black); + gdk_gc_set_foreground(xsane.gc_black, &color_black); + + xsane.gc_red = gdk_gc_new(xsane.histogram_dialog->window); + color_red.red = 40000; + color_red.green = 10000; + color_red.blue = 10000; + gdk_color_alloc(colormap, &color_red); + gdk_gc_set_foreground(xsane.gc_red, &color_red); + + xsane.gc_green = gdk_gc_new(xsane.histogram_dialog->window); + color_green.red = 10000; + color_green.green = 40000; + color_green.blue = 10000; + gdk_color_alloc(colormap, &color_green); + gdk_gc_set_foreground(xsane.gc_green, &color_green); + + xsane.gc_blue = gdk_gc_new(xsane.histogram_dialog->window); + color_blue.red = 10000; + color_blue.green = 10000; + color_blue.blue = 40000; + gdk_color_alloc(colormap, &color_blue); + gdk_gc_set_foreground(xsane.gc_blue, &color_blue); + + xsane.gc_backg = gdk_gc_new(xsane.histogram_dialog->window); + color_backg.red = 50000; + color_backg.green = 50000; + color_backg.blue = 50000; + gdk_color_alloc(colormap, &color_backg); + gdk_gc_set_foreground(xsane.gc_backg, &color_backg); + + + /* add histogram images and sliders */ + + xsane_create_histogram(xsane_histogram_vbox, FRAME_RAW_IMAGE, 256, 100, &(xsane.histogram_raw)); + + xsane_separator_new(xsane_histogram_vbox, 0); + + xsane.slider_gray.r = 1; + xsane.slider_gray.g = 1; + xsane.slider_gray.b = 1; + xsane.slider_gray.active = XSANE_SLIDER_ACTIVE; + xsane_create_slider(&xsane.slider_gray); + gtk_box_pack_start(GTK_BOX(xsane_histogram_vbox), xsane.slider_gray.preview, FALSE, FALSE, 0); + gtk_widget_show(xsane.slider_gray.preview); + gtk_widget_realize(xsane.slider_gray.preview); + + xsane_separator_new(xsane_histogram_vbox, 0); + + xsane.slider_red.r = 1; + xsane.slider_red.g = 0; + xsane.slider_red.b = 0; + xsane.slider_red.active = XSANE_SLIDER_ACTIVE; + xsane_create_slider(&xsane.slider_red); + gtk_box_pack_start(GTK_BOX(xsane_histogram_vbox), xsane.slider_red.preview, FALSE, FALSE, 0); + gtk_widget_show(xsane.slider_red.preview); + gtk_widget_realize(xsane.slider_red.preview); + + xsane_separator_new(xsane_histogram_vbox, 0); + + xsane.slider_green.r = 0; + xsane.slider_green.g = 1; + xsane.slider_green.b = 0; + xsane.slider_green.active = XSANE_SLIDER_ACTIVE; + xsane_create_slider(&xsane.slider_green); + gtk_box_pack_start(GTK_BOX(xsane_histogram_vbox), xsane.slider_green.preview, FALSE, FALSE, 0); + gtk_widget_show(xsane.slider_green.preview); + gtk_widget_realize(xsane.slider_green.preview); + + xsane_separator_new(xsane_histogram_vbox, 0); + + xsane.slider_blue.r = 0; + xsane.slider_blue.g = 0; + xsane.slider_blue.b = 1; + xsane.slider_blue.active = XSANE_SLIDER_ACTIVE; + xsane_create_slider(&xsane.slider_blue); + gtk_box_pack_start(GTK_BOX(xsane_histogram_vbox), xsane.slider_blue.preview, FALSE, FALSE, 0); + gtk_widget_show(xsane.slider_blue.preview); + gtk_widget_realize(xsane.slider_blue.preview); + + xsane_draw_slider_level(&xsane.slider_gray); + xsane_draw_slider_level(&xsane.slider_red); + xsane_draw_slider_level(&xsane.slider_green); + xsane_draw_slider_level(&xsane.slider_blue); + + xsane_separator_new(xsane_histogram_vbox, 0); + + xsane_create_histogram(xsane_histogram_vbox, FRAME_ENHANCED_IMAGE, 256, 100, &(xsane.histogram_enh)); + + xsane_color_hbox = gtk_hbox_new(TRUE, 5); + gtk_container_set_border_width(GTK_CONTAINER(xsane_color_hbox), 5); + gtk_container_add(GTK_CONTAINER(xsane_histogram_vbox), xsane_color_hbox); + gtk_widget_show(xsane_color_hbox); + + button = xsane_toggle_button_new_with_pixmap(xsane.histogram_dialog->window, xsane_color_hbox, intensity_xpm, DESC_HIST_INTENSITY, + &xsane.histogram_int, xsane_histogram_toggle_button_callback); + gtk_widget_add_accelerator(button, "clicked", xsane.accelerator_group, GDK_I, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); + + button = xsane_toggle_button_new_with_pixmap(xsane.histogram_dialog->window, xsane_color_hbox, red_xpm, DESC_HIST_RED, + &xsane.histogram_red, xsane_histogram_toggle_button_callback); + gtk_widget_add_accelerator(button, "clicked", xsane.accelerator_group, GDK_R, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); + + button = xsane_toggle_button_new_with_pixmap(xsane.histogram_dialog->window, xsane_color_hbox, green_xpm, DESC_HIST_GREEN, + &xsane.histogram_green, xsane_histogram_toggle_button_callback); + gtk_widget_add_accelerator(button, "clicked", xsane.accelerator_group, GDK_G, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); + + button = xsane_toggle_button_new_with_pixmap(xsane.histogram_dialog->window, xsane_color_hbox, blue_xpm, DESC_HIST_BLUE, + &xsane.histogram_blue, xsane_histogram_toggle_button_callback); + gtk_widget_add_accelerator(button, "clicked", xsane.accelerator_group, GDK_B, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); + + button = xsane_toggle_button_new_with_pixmap(xsane.histogram_dialog->window, xsane_color_hbox, pixel_xpm, DESC_HIST_PIXEL, + &xsane.histogram_lines, xsane_histogram_toggle_button_callback); + gtk_widget_add_accelerator(button, "clicked", xsane.accelerator_group, GDK_M, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); + + button = xsane_toggle_button_new_with_pixmap(xsane.histogram_dialog->window, xsane_color_hbox, log_xpm, DESC_HIST_LOG, + &xsane.histogram_log, xsane_histogram_toggle_button_callback); + gtk_widget_add_accelerator(button, "clicked", xsane.accelerator_group, GDK_L, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); + + gtk_widget_show(xsane_color_hbox); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ +#ifdef HAVE_WORKING_GTK_GAMMACURVE +/* xsane_get_free_gamma_curve transforms gamma table with 65536 entries and value range 0.0-1.0 to requested gamma table */ +/* it combines the color gamma table given by gamma_widget and the gray gamma table (xsane.gamma_curve_gray) */ +void xsane_get_free_gamma_curve(gfloat *free_color_gamma_data, SANE_Int *gammadata, + int negative, double gamma, double brightness, double contrast, + int len, int maxout) +{ + int i; + gfloat factor; + double midin; + double val; + double m; + double b; + int maxin = len-1; + + DBG(DBG_proc, "xsane_get_free_gamma_curve\n"); + DBG(DBG_proc, "xsane_get_free_gamma_curve(neg=%d, gam=%3.2f, bri=%3.2f, ctr=%3.2f, nrs=%d, max=%d\n", + negative, gamma, brightness, contrast, len, maxout); + + if (contrast < -100.0) + { + contrast = -100.0; + } + + midin = (int)(len / 2.0); + + m = 1.0 + contrast/100.0; + b = (1.0 + brightness/100.0) * midin; + + factor = 65536.0 / len; + + if (1) /* xxxxxxxxxxxx colors available */ + { + if (negative) + { + DBG(DBG_proc, "xsane_get_free_gamma_curve: color transformation, negative\n"); + + for (i=0; i <= maxin; i++) + { + val = ((double) (maxin - i)) - midin; + val = val * m + b; + xsane_bound_double(&val, 0.0, maxin); + + val = maxout * xsane.free_gamma_data[(int) (65535 * free_color_gamma_data[(int) (val * factor)])]; + val = 0.5 + maxout * pow( val/maxin, (1.0/gamma) ); + gammadata[i] = val; + } + } + else /* positive */ + { + DBG(DBG_proc, "xsane_get_free_gamma_curve: color transformation, positive\n"); + + for (i=0; i <= maxin; i++) + { + val = ((double) i) - midin; + val = val * m + b; + xsane_bound_double(&val, 0.0, maxin); + + val = maxout * xsane.free_gamma_data[(int) (65535 * free_color_gamma_data[(int) (val * factor)])]; + val = 0.5 + maxout * pow( val/maxin, (1.0/gamma) ); + gammadata[i] = val; + } + } + } + else + { + if (negative) + { + DBG(DBG_proc, "xsane_get_free_gamma_curve: gray transformation, negative\n"); + + for (i=0; i <= maxin; i++) + { + val = ((double) (maxin - i)) - midin; + val = val * m + b; + xsane_bound_double(&val, 0.0, maxin); + + val = maxout * xsane.free_gamma_data[(int) (val * factor)]; + val = 0.5 + maxout * pow( val/maxin, (1.0/gamma) ); + gammadata[i] = val; + } + } + else /* positive */ + { + DBG(DBG_proc, "xsane_get_free_gamma_curve: gray transformation, positive\n"); + + for (i=0; i <= maxin; i++) + { + val = ((double) i) - midin; + val = val * m + b; + xsane_bound_double(&val, 0.0, maxin); + + val = maxout * xsane.free_gamma_data[(int) (val * factor)]; + val = 0.5 + maxout * pow( val/maxin, (1.0/gamma) ); + gammadata[i] = val; + } + } + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint xsane_gamma_win_delete(GtkWidget *widget, gpointer data) +{ + DBG(DBG_proc, "xsane_gamma_win_delete\n"); + + gtk_widget_hide(widget); + preferences.show_gamma = FALSE; + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(xsane.show_gamma_widget), preferences.show_gamma); + return TRUE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ +/* xsane_gamma_curve_notebook_page_new creates a notebook page with a gamma curve + of 65536 entries and a value range from 0.0-1.0 */ + +GtkWidget* xsane_gamma_curve_notebook_page_new(GtkWidget *notebook, char *title) +{ + gfloat fmin, fmax, *vector; + GtkWidget *curve, *gamma, *vbox, *label; + int optlen; + + DBG(DBG_proc, "xsane_back_gtk_curve_new\n"); + + optlen = 65536; + fmin = 0.0; + fmax = 1.0; + + label = gtk_label_new((char *) title); + vbox = gtk_vbox_new(/* homogeneous */ FALSE, 0); + gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label); + gtk_widget_show(vbox); + gtk_widget_show(label); + + gamma = gtk_gamma_curve_new(); + gtk_widget_set_usize(gamma, 0, 256); + curve = GTK_GAMMA_CURVE(gamma)->curve; + + vector = alloca(optlen * sizeof(vector[0])); + + gtk_curve_set_range(GTK_CURVE(curve), 0, optlen - 1, fmin, fmax); +#if 1 + gtk_curve_maintain_accuracy(GTK_CURVE(curve), 1.0); +#endif + + gtk_container_set_border_width(GTK_CONTAINER(gamma), 4); + gtk_box_pack_start(GTK_BOX(vbox), gamma, TRUE, TRUE, 0); + gtk_widget_show(gamma); + + return gamma; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_create_gamma_dialog(const char *devicetext) +{ + char windowname[255]; + GtkWidget *xsane_vbox_gamma, *notebook; + + DBG(DBG_proc, "xsane_create_free_gamma_dialog\n"); + + xsane.free_gamma_data = calloc(65536, sizeof(xsane.free_gamma_data[0])); + xsane.free_gamma_data_red = calloc(65536, sizeof(xsane.free_gamma_data_red[0])); + xsane.free_gamma_data_green = calloc(65536, sizeof(xsane.free_gamma_data_green[0])); + xsane.free_gamma_data_blue = calloc(65536, sizeof(xsane.free_gamma_data_green[0])); + + xsane.gamma_dialog = gtk_window_new(GTK_WINDOW_DIALOG); + gtk_window_set_policy(GTK_WINDOW(xsane.gamma_dialog), FALSE, FALSE, FALSE); + gtk_widget_set_uposition(xsane.gamma_dialog, XSANE_GAMMA_POS_X, XSANE_GAMMA_POS_Y); + gtk_signal_connect(GTK_OBJECT(xsane.gamma_dialog), "delete_event", GTK_SIGNAL_FUNC(xsane_gamma_win_delete), NULL); + sprintf(windowname, "%s %s", WINDOW_GAMMA, devicetext); + gtk_window_set_title(GTK_WINDOW(xsane.gamma_dialog), windowname); + xsane_set_window_icon(xsane.gamma_dialog, 0); + gtk_accel_group_attach(xsane.accelerator_group, GTK_OBJECT(xsane.gamma_dialog)); + + xsane_vbox_gamma = gtk_vbox_new(TRUE, 5); + gtk_container_set_border_width(GTK_CONTAINER(xsane_vbox_gamma), 5); + gtk_container_add(GTK_CONTAINER(xsane.gamma_dialog), xsane_vbox_gamma); + gtk_widget_show(xsane_vbox_gamma); + + notebook = gtk_notebook_new(); + gtk_container_set_border_width(GTK_CONTAINER(notebook), 4); + gtk_box_pack_start(GTK_BOX(xsane_vbox_gamma), notebook, TRUE, TRUE, 0); + gtk_widget_show(notebook); + + xsane.gamma_curve_gray = xsane_gamma_curve_notebook_page_new(notebook, "Gamma gray"); + xsane.gamma_curve_red = xsane_gamma_curve_notebook_page_new(notebook, "Gamma red"); + xsane.gamma_curve_green = xsane_gamma_curve_notebook_page_new(notebook, "Gamma green"); + xsane.gamma_curve_blue = xsane_gamma_curve_notebook_page_new(notebook, "Gamma blue"); + + gtk_curve_get_vector(GTK_CURVE(GTK_GAMMA_CURVE(xsane.gamma_curve_gray)->curve), 65536, xsane.free_gamma_data); + gtk_curve_get_vector(GTK_CURVE(GTK_GAMMA_CURVE(xsane.gamma_curve_red)->curve), 65536, xsane.free_gamma_data_red); + gtk_curve_get_vector(GTK_CURVE(GTK_GAMMA_CURVE(xsane.gamma_curve_green)->curve), 65536, xsane.free_gamma_data_green); + gtk_curve_get_vector(GTK_CURVE(GTK_GAMMA_CURVE(xsane.gamma_curve_blue)->curve), 65536, xsane.free_gamma_data_blue); + +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_update_gamma_dialog() +{ + DBG(DBG_proc, "xsane_update_gamma_dialog\n"); + + if (preferences.show_gamma) + { + gtk_widget_show(xsane.gamma_dialog); + } +} +#endif + + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void xsane_set_auto_enhancement() +{ + DBG(DBG_proc, "xsane_set_auto_enhancement\n"); + xsane.slider_gray.value[0] = xsane.auto_black; + xsane.slider_gray.value[1] = xsane.auto_gray; + xsane.slider_gray.value[2] = xsane.auto_white; + + if (xsane.enhancement_rgb_default) /* set same values for color components */ + { + xsane.slider_red.value[0] = xsane.auto_black; + xsane.slider_red.value[1] = xsane.auto_gray; + xsane.slider_red.value[2] = xsane.auto_white; + + xsane.slider_green.value[0] = xsane.auto_black; + xsane.slider_green.value[1] = xsane.auto_gray; + xsane.slider_green.value[2] = xsane.auto_white; + + xsane.slider_blue.value[0] = xsane.auto_black; + xsane.slider_blue.value[1] = xsane.auto_gray; + xsane.slider_blue.value[2] = xsane.auto_white; + } + else /* set different values for each color component */ + { + xsane.slider_red.value[0] = xsane.auto_black_red; + xsane.slider_red.value[1] = xsane.auto_gray_red; + xsane.slider_red.value[2] = xsane.auto_white_red; + + xsane.slider_green.value[0] = xsane.auto_black_green; + xsane.slider_green.value[1] = xsane.auto_gray_green; + xsane.slider_green.value[2] = xsane.auto_white_green; + + xsane.slider_blue.value[0] = xsane.auto_black_blue; + xsane.slider_blue.value[1] = xsane.auto_gray_blue; + xsane.slider_blue.value[2] = xsane.auto_white_blue; + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ +void xsane_set_medium(Preferences_medium_t *medium) +{ + const SANE_Option_Descriptor *opt; + int shadow_gray, shadow_red, shadow_green, shadow_blue; + int highlight_gray, highlight_red, highlight_green, highlight_blue; + + + if (!medium) + { + DBG(DBG_proc, "xsane_set_medium: no medium given, using default values\n"); + + xsane.medium_gamma_gray = 1.0; + xsane.medium_gamma_red = 1.0; + xsane.medium_gamma_green = 1.0; + xsane.medium_gamma_blue = 1.0; + + xsane.medium_shadow_gray = 0.0; + xsane.medium_shadow_red = 0.0; + xsane.medium_shadow_green = 0.0; + xsane.medium_shadow_blue = 0.0; + + xsane.medium_highlight_gray = 100.0; + xsane.medium_highlight_red = 100.0; + xsane.medium_highlight_green = 100.0; + xsane.medium_highlight_blue = 100.0; + + xsane.medium_negative = 0; + + return; + } + + DBG(DBG_proc, "xsane_set_medium: setting values for %s\n", medium->name); + + xsane.medium_gamma_red = medium->gamma_red; + xsane.medium_gamma_green = medium->gamma_green; + xsane.medium_gamma_blue = medium->gamma_blue; + + xsane.medium_shadow_red = medium->shadow_red; + xsane.medium_shadow_green = medium->shadow_green; + xsane.medium_shadow_blue = medium->shadow_blue; + + xsane.medium_highlight_red = medium->highlight_red; + xsane.medium_highlight_green = medium->highlight_green; + xsane.medium_highlight_blue = medium->highlight_blue; + + xsane.medium_gamma_gray = medium->gamma_gray; + xsane.medium_shadow_gray = medium->shadow_gray; + xsane.medium_highlight_gray = medium->highlight_gray; + + xsane.medium_negative = medium->negative; + +#if 1 +return; +#endif + + opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.shadow); + if (!opt) + { + opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.shadow_r); + } + else if (!opt) + { + opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.highlight); + } + else if (!opt) + { + opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.highlight_r); + } + else if (!opt) + { + DBG(DBG_info, "xsane_set_medium_callback: no shadow/highlight values available\n"); + return; + } + + if (opt->type == SANE_TYPE_FIXED) + { + shadow_gray = SANE_FIX(medium->shadow_gray); + shadow_red = SANE_FIX(medium->shadow_red); + shadow_green = SANE_FIX(medium->shadow_green); + shadow_blue = SANE_FIX(medium->shadow_blue); + highlight_gray = SANE_FIX(medium->highlight_gray); + highlight_red = SANE_FIX(medium->highlight_red); + highlight_green = SANE_FIX(medium->highlight_green); + highlight_blue = SANE_FIX(medium->highlight_blue); + } + else if (opt->type == SANE_TYPE_INT) + { + shadow_gray = (int) medium->shadow_gray; + shadow_red = (int) medium->shadow_red; + shadow_green = (int) medium->shadow_green; + shadow_blue = (int) medium->shadow_blue; + highlight_gray = (int) medium->highlight_gray; + highlight_red = (int) medium->highlight_red; + highlight_green = (int) medium->highlight_green; + highlight_blue = (int) medium->highlight_blue; + } + else + { + DBG(DBG_info, "xsane_set_medium_callback: unknown type of shadow/highlight: %d\n", opt->type); + return; + } + + /* shadow values */ + if (!xsane_control_option(xsane.dev, xsane.well_known.shadow, SANE_ACTION_SET_VALUE, &shadow_gray, 0)) + { + xsane.medium_shadow_gray = 0.0; /* we are using hardware shadow */ + } + + if (!xsane_control_option(xsane.dev, xsane.well_known.shadow_r, SANE_ACTION_SET_VALUE, &shadow_red, 0)) + { + xsane.medium_shadow_red = 0.0; /* we are using hardware shadow */ + } + + if (!xsane_control_option(xsane.dev, xsane.well_known.shadow_g, SANE_ACTION_SET_VALUE, &shadow_green, 0)) + { + xsane.medium_shadow_green = 0.0; /* we are using hardware shadow */ + } + + if (!xsane_control_option(xsane.dev, xsane.well_known.shadow_b, SANE_ACTION_SET_VALUE, &shadow_blue, 0)) + { + xsane.medium_shadow_blue = 0.0; /* we are using hardware shadow */ + } + + /* highlight values */ + if (!xsane_control_option(xsane.dev, xsane.well_known.highlight, SANE_ACTION_SET_VALUE, &highlight_gray, 0)) + { + xsane.medium_highlight_gray = 100.0; /* we are using hardware highlight */ + } + + if (!xsane_control_option(xsane.dev, xsane.well_known.highlight_r, SANE_ACTION_SET_VALUE, &highlight_red, 0)) + { + xsane.medium_highlight_red = 100.0; /* we are using hardware highlight */ + } + + if (!xsane_control_option(xsane.dev, xsane.well_known.highlight_g, SANE_ACTION_SET_VALUE, &highlight_green, 0)) + { + xsane.medium_highlight_green = 100.0; /* we are using hardware highlight */ + } + + if (!xsane_control_option(xsane.dev, xsane.well_known.highlight_b, SANE_ACTION_SET_VALUE, &highlight_blue, 0)) + { + xsane.medium_highlight_blue = 100.0; /* we are using hardware highlight */ + } + + xsane_back_gtk_refresh_dialog(); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ |