static gboolean dt_iop_basecurve_draw(GtkWidget *widget, cairo_t *crf, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_basecurve_gui_data_t *c = (dt_iop_basecurve_gui_data_t *)self->gui_data;
dt_iop_basecurve_params_t *p = (dt_iop_basecurve_params_t *)self->params;
int nodes = p->basecurve_nodes[0];
dt_iop_basecurve_node_t *basecurve = p->basecurve[0];
if(c->minmax_curve_type != p->basecurve_type[0] || c->minmax_curve_nodes != p->basecurve_nodes[0])
{
dt_draw_curve_destroy(c->minmax_curve);
c->minmax_curve = dt_draw_curve_new(0.0, 1.0, p->basecurve_type[0]);
c->minmax_curve_nodes = p->basecurve_nodes[0];
c->minmax_curve_type = p->basecurve_type[0];
for(int k = 0; k < p->basecurve_nodes[0]; k++)
(void)dt_draw_curve_add_point(c->minmax_curve, p->basecurve[0][k].x, p->basecurve[0][k].y);
}
else
{
for(int k = 0; k < p->basecurve_nodes[0]; k++)
dt_draw_curve_set_point(c->minmax_curve, k, p->basecurve[0][k].x, p->basecurve[0][k].y);
}
dt_draw_curve_t *minmax_curve = c->minmax_curve;
dt_draw_curve_calc_values(minmax_curve, 0.0, 1.0, DT_IOP_TONECURVE_RES, c->draw_xs, c->draw_ys);
const float xm = basecurve[nodes - 1].x;
const float x[4] = { 0.7f * xm, 0.8f * xm, 0.9f * xm, 1.0f * xm };
const float y[4] = { c->draw_ys[CLAMP((int)(x[0] * DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES - 1)],
c->draw_ys[CLAMP((int)(x[1] * DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES - 1)],
c->draw_ys[CLAMP((int)(x[2] * DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES - 1)],
c->draw_ys[CLAMP((int)(x[3] * DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES - 1)] };
float unbounded_coeffs[3];
dt_iop_estimate_exp(x, y, 4, unbounded_coeffs);
const int inset = DT_GUI_CURVE_EDITOR_INSET;
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
int width = allocation.width, height = allocation.height;
cairo_surface_t *cst = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
cairo_t *cr = cairo_create(cst);
// clear bg
cairo_set_source_rgb(cr, .2, .2, .2);
cairo_paint(cr);
cairo_translate(cr, inset, inset);
width -= 2 * inset;
height -= 2 * inset;
#if 0
// draw shadow around
float alpha = 1.0f;
for(int k=0; k<inset; k++)
{
cairo_rectangle(cr, -k, -k, width + 2*k, height + 2*k);
cairo_set_source_rgba(cr, 0, 0, 0, alpha);
alpha *= 0.6f;
cairo_fill(cr);
}
#else
cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.0));
cairo_set_source_rgb(cr, .1, .1, .1);
cairo_rectangle(cr, 0, 0, width, height);
cairo_stroke(cr);
#endif
cairo_set_source_rgb(cr, .3, .3, .3);
cairo_rectangle(cr, 0, 0, width, height);
cairo_fill(cr);
cairo_translate(cr, 0, height);
cairo_scale(cr, 1.0f, -1.0f);
// draw grid
cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(.4));
cairo_set_source_rgb(cr, .1, .1, .1);
if(c->loglogscale)
dt_draw_loglog_grid(cr, 4, 0, 0, width, height, c->loglogscale);
else
dt_draw_grid(cr, 4, 0, 0, width, height);
// draw nodes positions
cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.));
cairo_set_source_rgb(cr, 0.6, 0.6, 0.6);
for(int k = 0; k < nodes; k++)
{
const float x = to_log(basecurve[k].x, c->loglogscale), y = to_log(basecurve[k].y, c->loglogscale);
cairo_arc(cr, x * width, y * height, DT_PIXEL_APPLY_DPI(3), 0, 2. * M_PI);
cairo_stroke(cr);
}
// draw selected cursor
cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.));
if(c->selected >= 0)
{
cairo_set_source_rgb(cr, .9, .9, .9);
const float x = to_log(basecurve[c->selected].x, c->loglogscale),
y = to_log(basecurve[c->selected].y, c->loglogscale);
cairo_arc(cr, x * width, y * height, DT_PIXEL_APPLY_DPI(4), 0, 2. * M_PI);
cairo_stroke(cr);
}
// draw curve
cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(2.));
cairo_set_source_rgb(cr, .9, .9, .9);
// cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_move_to(cr, 0, height * to_log(c->draw_ys[0], c->loglogscale));
for(int k = 1; k < DT_IOP_TONECURVE_RES; k++)
{
const float xx = k / (DT_IOP_TONECURVE_RES - 1.0);
if(xx > xm)
{
const float yy = dt_iop_eval_exp(unbounded_coeffs, xx);
const float x = to_log(xx, c->loglogscale), y = to_log(yy, c->loglogscale);
cairo_line_to(cr, x * width, height * y);
}
else
{
const float yy = c->draw_ys[k];
const float x = to_log(xx, c->loglogscale), y = to_log(yy, c->loglogscale);
cairo_line_to(cr, x * width, height * y);
}
}
cairo_stroke(cr);
cairo_destroy(cr);
cairo_set_source_surface(crf, cst, 0, 0);
cairo_paint(crf);
cairo_surface_destroy(cst);
return TRUE;
}
static gboolean dt_iop_tonecurve_expose(GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_tonecurve_gui_data_t *c = (dt_iop_tonecurve_gui_data_t *)self->gui_data;
dt_iop_tonecurve_params_t *p = (dt_iop_tonecurve_params_t *)self->params;
const float color_labels_left[3][3] = { { 0.3f, 0.3f, 0.3f },
{ 0.0f, 0.34f, 0.27f },
{ 0.0f, 0.27f, 0.58f }
};
const float color_labels_right[3][3] = {{ 0.3f, 0.3f, 0.3f },
{ 0.53f, 0.08f, 0.28f},
{ 0.81f, 0.66f, 0.0f }
};
int ch = c->channel;
int nodes = p->tonecurve_nodes[ch];
dt_iop_tonecurve_node_t *tonecurve = p->tonecurve[ch];
int autoscale_ab = p->tonecurve_autoscale_ab;
if(c->minmax_curve_type[ch] != p->tonecurve_type[ch] || c->minmax_curve_nodes[ch] != p->tonecurve_nodes[ch])
{
dt_draw_curve_destroy(c->minmax_curve[ch]);
c->minmax_curve[ch] = dt_draw_curve_new(0.0, 1.0, p->tonecurve_type[ch]);
c->minmax_curve_nodes[ch] = p->tonecurve_nodes[ch];
c->minmax_curve_type[ch] = p->tonecurve_type[ch];
for(int k=0; k<p->tonecurve_nodes[ch]; k++)
(void)dt_draw_curve_add_point(c->minmax_curve[ch], p->tonecurve[ch][k].x, p->tonecurve[ch][k].y);
}
else
{
for(int k=0; k<p->tonecurve_nodes[ch]; k++)
dt_draw_curve_set_point(c->minmax_curve[ch], k, p->tonecurve[ch][k].x, p->tonecurve[ch][k].y);
}
dt_draw_curve_t *minmax_curve = c->minmax_curve[ch];
dt_draw_curve_calc_values(minmax_curve, 0.0, 1.0, DT_IOP_TONECURVE_RES, c->draw_xs, c->draw_ys);
const float xm = tonecurve[nodes-1].x;
const float x[4] = {0.7f*xm, 0.8f*xm, 0.9f*xm, 1.0f*xm};
const float y[4] = {c->draw_ys[CLAMP((int)(x[0]*DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES-1)],
c->draw_ys[CLAMP((int)(x[1]*DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES-1)],
c->draw_ys[CLAMP((int)(x[2]*DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES-1)],
c->draw_ys[CLAMP((int)(x[3]*DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES-1)]
};
float unbounded_coeffs[3];
dt_iop_estimate_exp(x, y, 4, unbounded_coeffs);
const int inset = DT_GUI_CURVE_EDITOR_INSET;
int width = widget->allocation.width, height = widget->allocation.height;
cairo_surface_t *cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
cairo_t *cr = cairo_create(cst);
// clear bg
cairo_set_source_rgb (cr, .2, .2, .2);
cairo_paint(cr);
cairo_translate(cr, inset, inset);
width -= 2*inset;
height -= 2*inset;
#if 0
// draw shadow around
float alpha = 1.0f;
for(int k=0; k<inset; k++)
{
cairo_rectangle(cr, -k, -k, width + 2*k, height + 2*k);
cairo_set_source_rgba(cr, 0, 0, 0, alpha);
alpha *= 0.6f;
cairo_fill(cr);
}
#else
cairo_set_line_width(cr, 1.0);
cairo_set_source_rgb (cr, .1, .1, .1);
cairo_rectangle(cr, 0, 0, width, height);
cairo_stroke(cr);
#endif
cairo_set_source_rgb (cr, .3, .3, .3);
cairo_rectangle(cr, 0, 0, width, height);
cairo_fill(cr);
// draw color labels
const int cells = 8;
for(int j=0; j<cells; j++)
{
for(int i=0; i<cells; i++)
{
const float f = (cells-1-j+i)/(2.0f*cells-2.0f);
cairo_set_source_rgba (cr,
(1.0f-f)*color_labels_left[ch][0] + f*color_labels_right[ch][0],
(1.0f-f)*color_labels_left[ch][1] + f*color_labels_right[ch][1],
(1.0f-f)*color_labels_left[ch][2] + f*color_labels_right[ch][2],
.5f); // blend over to make colors darker, so the overlay is more visible
cairo_rectangle(cr, width*i/(float)cells, height*j/(float)cells, width/(float)cells, height/(float)cells);
cairo_fill(cr);
}
}
// draw grid
cairo_set_line_width(cr, .4);
cairo_set_source_rgb (cr, .1, .1, .1);
dt_draw_grid(cr, 4, 0, 0, width, height);
// if autoscale_ab is on: do not display a and b curves
if (autoscale_ab && ch != ch_L) goto finally;
// draw nodes positions
cairo_set_line_width(cr, 1.);
cairo_set_source_rgb(cr, 0.6, 0.6, 0.6);
cairo_translate(cr, 0, height);
for(int k=0; k<nodes; k++)
{
cairo_arc(cr, tonecurve[k].x*width, -tonecurve[k].y*height, 3, 0, 2.*M_PI);
cairo_stroke(cr);
}
// draw selected cursor
cairo_set_line_width(cr, 1.);
// draw lum h istogram in background
// only if module is enabled
if (self->enabled)
{
dt_develop_t *dev = darktable.develop;
float *hist, hist_max;
float *raw_mean, *raw_min, *raw_max;
float *raw_mean_output;
float picker_mean[3], picker_min[3], picker_max[3];
char text[256];
raw_mean = self->picked_color;
raw_min = self->picked_color_min;
raw_max = self->picked_color_max;
raw_mean_output = self->picked_output_color;
hist = dev->histogram_pre_tonecurve;
hist_max = dev->histogram_linear?dev->histogram_pre_tonecurve_max:logf(1.0 + dev->histogram_pre_tonecurve_max);
if(hist_max > 0 && ch == ch_L)
{
cairo_save(cr);
cairo_scale(cr, width/63.0, -(height-5)/(float)hist_max);
cairo_set_source_rgba(cr, .2, .2, .2, 0.5);
dt_draw_histogram_8(cr, hist, 3);
cairo_restore(cr);
}
if(self->request_color_pick)
{
// the global live samples ...
GSList *samples = darktable.lib->proxy.colorpicker.live_samples;
dt_colorpicker_sample_t *sample = NULL;
while(samples)
{
sample = samples->data;
picker_scale(sample->picked_color_lab_mean, picker_mean);
picker_scale(sample->picked_color_lab_min, picker_min);
picker_scale(sample->picked_color_lab_max, picker_max);
cairo_set_source_rgba(cr, 0.5, 0.7, 0.5, 0.15);
cairo_rectangle(cr, width*picker_min[ch], 0, width*fmax(picker_max[ch]-picker_min[ch], 0.0f), -height);
cairo_fill(cr);
cairo_set_source_rgba(cr, 0.5, 0.7, 0.5, 0.5);
cairo_move_to(cr, width*picker_mean[ch], 0);
cairo_line_to(cr, width*picker_mean[ch], -height);
cairo_stroke(cr);
samples = g_slist_next(samples);
}
// ... and the local sample
picker_scale(raw_mean, picker_mean);
picker_scale(raw_min, picker_min);
picker_scale(raw_max, picker_max);
cairo_set_source_rgba(cr, 0.7, 0.5, 0.5, 0.33);
cairo_rectangle(cr, width*picker_min[ch], 0, width*fmax(picker_max[ch]-picker_min[ch], 0.0f), -height);
cairo_fill(cr);
cairo_set_source_rgba(cr, 0.9, 0.7, 0.7, 0.5);
cairo_move_to(cr, width*picker_mean[ch], 0);
cairo_line_to(cr, width*picker_mean[ch], -height);
cairo_stroke(cr);
snprintf(text, 256, "%.1f → %.1f", raw_mean[ch], raw_mean_output[ch]);
cairo_set_source_rgb(cr, 0.1, 0.1, 0.1);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, 0.06*height);
cairo_move_to (cr, 0.02f*width, -0.94*height);
cairo_show_text(cr, text);
cairo_stroke(cr);
}
}
if(c->selected >= 0)
{
cairo_set_source_rgb(cr, .9, .9, .9);
cairo_arc(cr, tonecurve[c->selected].x*width, -tonecurve[c->selected].y*height, 4, 0, 2.*M_PI);
cairo_stroke(cr);
}
// draw curve
cairo_set_line_width(cr, 2.);
cairo_set_source_rgb(cr, .9, .9, .9);
// cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_move_to(cr, 0, -height*c->draw_ys[0]);
for(int k=1; k<DT_IOP_TONECURVE_RES; k++)
{
const float xx = k/(DT_IOP_TONECURVE_RES-1.0);
if(xx > xm)
{
const float yy = dt_iop_eval_exp(unbounded_coeffs, xx);
cairo_line_to(cr, xx*width, - height*yy);
}
else
{
cairo_line_to(cr, xx*width, - height*c->draw_ys[k]);
}
}
cairo_stroke(cr);
finally:
cairo_destroy(cr);
cairo_t *cr_pixmap = gdk_cairo_create(gtk_widget_get_window(widget));
cairo_set_source_surface (cr_pixmap, cst, 0, 0);
cairo_paint(cr_pixmap);
cairo_destroy(cr_pixmap);
cairo_surface_destroy(cst);
return TRUE;
}
