void process(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *ivoid, void *ovoid,
const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
dt_iop_colisa_data_t *data = (dt_iop_colisa_data_t *)piece->data;
float *in = (float *)ivoid;
float *out = (float *)ovoid;
const int width = roi_in->width;
const int height = roi_in->height;
const int ch = piece->colors;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(in, out, data) schedule(static)
#endif
for(size_t k = 0; k < (size_t)width * height; k++)
{
float L = (in[k * ch + 0] < 100.0f)
? data->ctable[CLAMP((int)(in[k * ch + 0] / 100.0f * 0x10000ul), 0, 0xffff)]
: dt_iop_eval_exp(data->cunbounded_coeffs, in[k * ch + 0] / 100.0f);
out[k * ch + 0] = (L < 100.0f) ? data->ltable[CLAMP((int)(L / 100.0f * 0x10000ul), 0, 0xffff)]
: dt_iop_eval_exp(data->lunbounded_coeffs, L / 100.0f);
out[k * ch + 1] = in[k * ch + 1] * data->saturation;
out[k * ch + 2] = in[k * ch + 2] * data->saturation;
out[k * ch + 3] = in[k * ch + 3];
}
}
static void process_fastpath_apply_tonecurves(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece,
const void *const ivoid, void *const ovoid,
const dt_iop_roi_t *const roi_in,
const dt_iop_roi_t *const roi_out)
{
const dt_iop_colorout_data_t *const d = (dt_iop_colorout_data_t *)piece->data;
const int ch = piece->colors;
if(!isnan(d->cmatrix[0]))
{
// out is already converted to RGB from Lab.
// do we have any lut to apply, or is this a linear profile?
if((d->lut[0][0] >= 0.0f) && (d->lut[1][0] >= 0.0f) && (d->lut[2][0] >= 0.0f))
{ // apply profile
float *const out = (float *const)ovoid;
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none)
#endif
for(size_t k = 0; k < (size_t)ch * roi_out->width * roi_out->height; k += ch)
{
for(int c = 0; c < 3; c++)
{
out[k + c] = (out[k + c] < 1.0f) ? lerp_lut(d->lut[c], out[k + c])
: dt_iop_eval_exp(d->unbounded_coeffs[c], out[k + c]);
}
}
}
else if((d->lut[0][0] >= 0.0f) || (d->lut[1][0] >= 0.0f) || (d->lut[2][0] >= 0.0f))
{ // apply profile
float *const out = (float *const)ovoid;
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none)
#endif
for(size_t k = 0; k < (size_t)ch * roi_out->width * roi_out->height; k += ch)
{
for(int c = 0; c < 3; c++)
{
if(d->lut[c][0] >= 0.0f)
{
out[k + c] = (out[k + c] < 1.0f) ? lerp_lut(d->lut[c], out[k + c])
: dt_iop_eval_exp(d->unbounded_coeffs[c], out[k + c]);
}
}
}
}
}
}
void process(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *i, void *o,
const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
float *in = (float *)i;
float *out = (float *)o;
const int ch = piece->colors;
dt_iop_basecurve_data_t *d = (dt_iop_basecurve_data_t *)(piece->data);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, out, d, in) schedule(static)
#endif
for(size_t k = 0; k < (size_t)roi_out->width * roi_out->height; k++)
{
float *inp = in + ch * k;
float *outp = out + ch * k;
for(int i = 0; i < 3; i++)
{
// use base curve for values < 1, else use extrapolation.
if(inp[i] < 1.0f)
outp[i] = d->table[CLAMP((int)(inp[i] * 0x10000ul), 0, 0xffff)];
else
outp[i] = dt_iop_eval_exp(d->unbounded_coeffs, inp[i]);
}
outp[3] = inp[3];
}
}
void process (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *i, void *o, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
const int ch = piece->colors;
dt_iop_tonecurve_data_t *d = (dt_iop_tonecurve_data_t *)(piece->data);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, i, o, d) schedule(static)
#endif
for(int k=0; k<roi_out->height; k++)
{
float *in = ((float *)i) + k*ch*roi_out->width;
float *out = ((float *)o) + k*ch*roi_out->width;
const float low_approximation = d->table[(int)(0.01f * 0xfffful)];
for (int j=0; j<roi_out->width; j++,in+=ch,out+=ch)
{
// in Lab: correct compressed Luminance for saturation:
const float L_in = in[0]/100.0f;
if(in[0] > 1.0f)
{
out[0] = (L_in < 1.0f) ? d->table[CLAMP((int)(L_in*0xfffful), 0, 0xffff)] :
dt_iop_eval_exp(d->unbounded_coeffs, L_in);
out[1] = in[1] * out[0]/in[0];
out[2] = in[2] * out[0]/in[0];
}
else
{
out[0] = in[0] * low_approximation;
out[1] = in[1] * low_approximation;
out[2] = in[2] * low_approximation;
}
}
}
}
void process(dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *ivoid, void *ovoid,
const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
dt_iop_profilegamma_data_t *data = (dt_iop_profilegamma_data_t *)piece->data;
const int ch = piece->colors;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, data) schedule(static)
#endif
for(int k = 0; k < roi_out->height; k++)
{
const float *in = ((float *)ivoid) + (size_t)ch * k * roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch * k * roi_out->width;
for(int j = 0; j < roi_out->width; j++, in += ch, out += ch)
{
for(int i = 0; i < 3; i++)
{
// use base curve for values < 1, else use extrapolation.
if(in[i] < 1.0f)
out[i] = data->table[CLAMP((int)(in[i] * 0x10000ul), 0, 0xffff)];
else
out[i] = dt_iop_eval_exp(data->unbounded_coeffs, in[i]);
}
}
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
void process (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *ivoid, void *ovoid, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
dt_iop_lowpass_data_t *data = (dt_iop_lowpass_data_t *)piece->data;
float *in = (float *)ivoid;
float *out = (float *)ovoid;
const int width = roi_in->width;
const int height = roi_in->height;
const int ch = piece->colors;
const int use_bilateral = data->radius < 0 ? 1 : 0;
const float radius = fmax(0.1f, fabs(data->radius));
const float sigma = radius * roi_in->scale / piece ->iscale;
const int order = data->order;
const float Labmax[] = { 100.0f, 128.0f, 128.0f, 1.0f };
const float Labmin[] = { 0.0f, -128.0f, -128.0f, 0.0f };
if(!use_bilateral)
{
dt_gaussian_t *g = dt_gaussian_init(width, height, ch, Labmax, Labmin, sigma, order);
if(!g) return;
dt_gaussian_blur_4c(g, in, out);
dt_gaussian_free(g);
}
else
{
const float sigma_r = 100.0f;// d->sigma_r; // does not depend on scale
const float sigma_s = sigma;
const float detail = -1.0f; // we want the bilateral base layer
dt_bilateral_t *b = dt_bilateral_init(width, height, sigma_s, sigma_r);
if(!b) return;
dt_bilateral_splat(b, in);
dt_bilateral_blur(b);
dt_bilateral_slice(b, in, out, detail);
dt_bilateral_free(b);
}
// some aliased pointers for compilers that don't yet understand operators on __m128
const float *const Labminf = (float *)&Labmin;
const float *const Labmaxf = (float *)&Labmax;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(in,out,data,roi_out) schedule(static)
#endif
for(int k=0; k<roi_out->width*roi_out->height; k++)
{
out[k*ch+0] = (out[k*ch+0] < 100.0f) ? data->table[CLAMP((int)(out[k*ch+0]/100.0f*0x10000ul), 0, 0xffff)] :
dt_iop_eval_exp(data->unbounded_coeffs, out[k*ch+0]/100.0f);
out[k*ch+1] = CLAMPF(out[k*ch+1]*data->saturation, Labminf[1], Labmaxf[1]);
out[k*ch+2] = CLAMPF(out[k*ch+2]*data->saturation, Labminf[2], Labmaxf[2]);
out[k*ch+3] = in[k*ch+3];
}
}
void
process (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *ivoid, void *ovoid, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
const dt_iop_colorout_data_t *const d = (dt_iop_colorout_data_t *)piece->data;
const int ch = piece->colors;
const int gamutcheck = (d->softproof_enabled == DT_SOFTPROOF_GAMUTCHECK);
if(!isnan(d->cmatrix[0]))
{
//fprintf(stderr,"Using cmatrix codepath\n");
// convert to rgb using matrix
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(roi_in,roi_out, ivoid, ovoid)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *in = (float*)ivoid + ch*roi_in->width *j;
float *out = (float*)ovoid + ch*roi_out->width*j;
const __m128 m0 = _mm_set_ps(0.0f,d->cmatrix[6],d->cmatrix[3],d->cmatrix[0]);
const __m128 m1 = _mm_set_ps(0.0f,d->cmatrix[7],d->cmatrix[4],d->cmatrix[1]);
const __m128 m2 = _mm_set_ps(0.0f,d->cmatrix[8],d->cmatrix[5],d->cmatrix[2]);
for(int i=0; i<roi_out->width; i++, in+=ch, out+=ch )
{
const __m128 xyz = dt_Lab_to_XYZ_SSE(_mm_load_ps(in));
const __m128 t = _mm_add_ps(_mm_mul_ps(m0,_mm_shuffle_ps(xyz,xyz,_MM_SHUFFLE(0,0,0,0))),_mm_add_ps(_mm_mul_ps(m1,_mm_shuffle_ps(xyz,xyz,_MM_SHUFFLE(1,1,1,1))),_mm_mul_ps(m2,_mm_shuffle_ps(xyz,xyz,_MM_SHUFFLE(2,2,2,2)))));
_mm_stream_ps(out,t);
}
}
_mm_sfence();
// apply profile
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(roi_in,roi_out, ivoid, ovoid)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *in = (float*)ivoid + ch*roi_in->width *j;
float *out = (float*)ovoid + ch*roi_out->width*j;
for(int i=0; i<roi_out->width; i++, in+=ch, out+=ch )
{
for(int i=0; i<3; i++)
if (d->lut[i][0] >= 0.0f)
{
out[i] = (out[i] < 1.0f) ? lerp_lut(d->lut[i], out[i]) : dt_iop_eval_exp(d->unbounded_coeffs[i], out[i]);
}
}
}
}
else
{
float *in = (float*)ivoid;
float *out = (float*)ovoid;
const int rowsize=roi_out->width * 3;
//fprintf(stderr,"Using xform codepath\n");
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(out, roi_out, in)
#endif
for (int k=0; k<roi_out->height; k++)
{
float Lab[rowsize];
float rgb[rowsize];
const int m=(k*(roi_out->width*ch));
for (int l=0; l<roi_out->width; l++)
{
int li=3*l,ii=ch*l;
Lab[li+0] = in[m+ii+0];
Lab[li+1] = in[m+ii+1];
Lab[li+2] = in[m+ii+2];
}
cmsDoTransform (d->xform, Lab, rgb, roi_out->width);
for (int l=0; l<roi_out->width; l++)
{
int oi=ch*l, ri=3*l;
if(gamutcheck && (rgb[ri+0] < 0.0f || rgb[ri+1] < 0.0f || rgb[ri+2] < 0.0f))
{
out[m+oi+0] = 0.0f;
out[m+oi+1] = 1.0f;
out[m+oi+2] = 1.0f;
}
else
{
out[m+oi+0] = rgb[ri+0];
out[m+oi+1] = rgb[ri+1];
out[m+oi+2] = rgb[ri+2];
}
}
}
}
if(piece->pipe->mask_display)
dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
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;
dt_develop_t *dev = darktable.develop;
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);
if(dev->histogram_type == DT_DEV_HISTOGRAM_WAVEFORM)
dt_draw_waveform_lines(cr, 0, 0, width, height);
else
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 histogram in background
// only if module is enabled
if (self->enabled)
{
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 = self->histogram;
hist_max = dev->histogram_type == DT_DEV_HISTOGRAM_LINEAR?self->histogram_max[ch]:logf(1.0 + self->histogram_max[ch]);
if(hist && hist_max > 0)
{
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, ch, dev->histogram_type == DT_DEV_HISTOGRAM_WAVEFORM?DT_DEV_HISTOGRAM_LOGARITHMIC:dev->histogram_type); // TODO: make draw handle waveform histograms
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;
}
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;
}
void process(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *i, void *o,
const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
const int ch = piece->colors;
dt_iop_tonecurve_data_t *d = (dt_iop_tonecurve_data_t *)(piece->data);
const float xm_L = 1.0f / d->unbounded_coeffs_L[0];
const float xm_ar = 1.0f / d->unbounded_coeffs_ab[0];
const float xm_al = 1.0f - 1.0f / d->unbounded_coeffs_ab[3];
const float xm_br = 1.0f / d->unbounded_coeffs_ab[6];
const float xm_bl = 1.0f - 1.0f / d->unbounded_coeffs_ab[9];
const float low_approximation = d->table[0][(int)(0.01f * 0xfffful)];
const int width = roi_out->width;
const int height = roi_out->height;
const int autoscale_ab = d->autoscale_ab;
const int unbound_ab = d->unbound_ab;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(i, o, d) schedule(static)
#endif
for(int k = 0; k < height; k++)
{
float *in = ((float *)i) + (size_t)k * ch * width;
float *out = ((float *)o) + (size_t)k * ch * width;
for(int j = 0; j < width; j++, in += ch, out += ch)
{
const float L_in = in[0] / 100.0f;
out[0] = (L_in < xm_L) ? d->table[ch_L][CLAMP((int)(L_in * 0xfffful), 0, 0xffff)]
: dt_iop_eval_exp(d->unbounded_coeffs_L, L_in);
if(autoscale_ab == 0)
{
const float a_in = (in[1] + 128.0f) / 256.0f;
const float b_in = (in[2] + 128.0f) / 256.0f;
if(unbound_ab == 0)
{
// old style handling of a/b curves: only lut lookup with clamping
out[1] = d->table[ch_a][CLAMP((int)(a_in * 0xfffful), 0, 0xffff)];
out[2] = d->table[ch_b][CLAMP((int)(b_in * 0xfffful), 0, 0xffff)];
}
else
{
// new style handling of a/b curves: lut lookup with two-sided extrapolation;
// mind the x-axis reversal for the left-handed side
out[1] = (a_in > xm_ar)
? dt_iop_eval_exp(d->unbounded_coeffs_ab, a_in)
: ((a_in < xm_al) ? dt_iop_eval_exp(d->unbounded_coeffs_ab + 3, 1.0f - a_in)
: d->table[ch_a][CLAMP((int)(a_in * 0xfffful), 0, 0xffff)]);
out[2] = (b_in > xm_br)
? dt_iop_eval_exp(d->unbounded_coeffs_ab + 6, b_in)
: ((b_in < xm_bl) ? dt_iop_eval_exp(d->unbounded_coeffs_ab + 9, 1.0f - b_in)
: d->table[ch_b][CLAMP((int)(b_in * 0xfffful), 0, 0xffff)]);
}
}
else
{
// in Lab: correct compressed Luminance for saturation:
if(L_in > 0.01f)
{
out[1] = in[1] * out[0] / in[0];
out[2] = in[2] * out[0] / in[0];
}
else
{
out[1] = in[1] * low_approximation;
out[2] = in[2] * low_approximation;
}
}
out[3] = in[3];
}
}
}
void process(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *ivoid, void *ovoid,
const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
const dt_iop_colorout_data_t *const d = (dt_iop_colorout_data_t *)piece->data;
const int ch = piece->colors;
const int gamutcheck = (d->mode == DT_PROFILE_GAMUTCHECK);
if(!isnan(d->cmatrix[0]))
{
// fprintf(stderr,"Using cmatrix codepath\n");
// convert to rgb using matrix
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(roi_in, roi_out, ivoid, ovoid)
#endif
for(int j = 0; j < roi_out->height; j++)
{
float *in = (float *)ivoid + (size_t)ch * roi_in->width * j;
float *out = (float *)ovoid + (size_t)ch * roi_out->width * j;
const __m128 m0 = _mm_set_ps(0.0f, d->cmatrix[6], d->cmatrix[3], d->cmatrix[0]);
const __m128 m1 = _mm_set_ps(0.0f, d->cmatrix[7], d->cmatrix[4], d->cmatrix[1]);
const __m128 m2 = _mm_set_ps(0.0f, d->cmatrix[8], d->cmatrix[5], d->cmatrix[2]);
for(int i = 0; i < roi_out->width; i++, in += ch, out += ch)
{
const __m128 xyz = dt_Lab_to_XYZ_SSE(_mm_load_ps(in));
const __m128 t
= _mm_add_ps(_mm_mul_ps(m0, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(0, 0, 0, 0))),
_mm_add_ps(_mm_mul_ps(m1, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(1, 1, 1, 1))),
_mm_mul_ps(m2, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(2, 2, 2, 2)))));
_mm_stream_ps(out, t);
}
}
_mm_sfence();
// apply profile
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(roi_in, roi_out, ivoid, ovoid)
#endif
for(int j = 0; j < roi_out->height; j++)
{
float *in = (float *)ivoid + (size_t)ch * roi_in->width * j;
float *out = (float *)ovoid + (size_t)ch * roi_out->width * j;
for(int i = 0; i < roi_out->width; i++, in += ch, out += ch)
{
for(int i = 0; i < 3; i++)
if(d->lut[i][0] >= 0.0f)
{
out[i] = (out[i] < 1.0f) ? lerp_lut(d->lut[i], out[i])
: dt_iop_eval_exp(d->unbounded_coeffs[i], out[i]);
}
}
}
}
else
{
// fprintf(stderr,"Using xform codepath\n");
const __m128 outofgamutpixel = _mm_set_ps(0.0f, 1.0f, 1.0f, 0.0f);
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(ivoid, ovoid, roi_out)
#endif
for(int k = 0; k < roi_out->height; k++)
{
const float *in = ((float *)ivoid) + (size_t)ch * k * roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch * k * roi_out->width;
if(!gamutcheck)
{
cmsDoTransform(d->xform, in, out, roi_out->width);
}
else
{
void *rgb = dt_alloc_align(16, 4 * sizeof(float) * roi_out->width);
cmsDoTransform(d->xform, in, rgb, roi_out->width);
float *rgbptr = (float *)rgb;
for(int j = 0; j < roi_out->width; j++, rgbptr += 4, out += 4)
{
const __m128 pixel = _mm_load_ps(rgbptr);
__m128 ingamut = _mm_cmplt_ps(pixel, _mm_set_ps(-FLT_MAX, 0.0f, 0.0f, 0.0f));
ingamut = _mm_or_ps(_mm_unpacklo_ps(ingamut, ingamut), _mm_unpackhi_ps(ingamut, ingamut));
ingamut = _mm_or_ps(_mm_unpacklo_ps(ingamut, ingamut), _mm_unpackhi_ps(ingamut, ingamut));
const __m128 result
= _mm_or_ps(_mm_and_ps(ingamut, outofgamutpixel), _mm_andnot_ps(ingamut, pixel));
_mm_stream_ps(out, result);
}
dt_free_align(rgb);
}
}
_mm_sfence();
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
