void gui_update(dt_iop_module_t *self)
{
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
gtk_widget_set_visible(GTK_WIDGET(g->pickerbuttons), TRUE);
dtgtk_reset_label_set_text(g->label, _("color of film material"));
gui_update_from_coeffs(self);
}
static void
apply_preset(dt_iop_module_t *self)
{
self->request_color_pick = 0;
if(self->dt->gui->reset) return;
dt_iop_temperature_gui_data_t *g = (dt_iop_temperature_gui_data_t *)self->gui_data;
dt_iop_temperature_params_t *p = (dt_iop_temperature_params_t *)self->params;
dt_iop_temperature_params_t *fp = (dt_iop_temperature_params_t *)self->default_params;
const int tune = dt_bauhaus_slider_get(g->finetune);
const int pos = dt_bauhaus_combobox_get(g->presets);
switch(pos)
{
case -1: // just un-setting.
return;
case 0: // camera wb
for(int k=0; k<3; k++) p->coeffs[k] = fp->coeffs[k];
break;
case 1: // spot wb, exposure callback will set p->coeffs.
for(int k=0; k<3; k++) p->coeffs[k] = fp->coeffs[k];
dt_iop_request_focus(self);
self->request_color_pick = 1;
/* set the area sample size*/
if (self->request_color_pick)
dt_lib_colorpicker_set_area(darktable.lib, 0.99);
break;
case 2: // passthrough mode, raw data
for(int k=0; k<3; k++) p->coeffs[k] = 1.0;
break;
default:
for(int i=g->preset_num[pos]; i<wb_preset_count; i++)
{
char makermodel[1024];
char *model = makermodel;
dt_colorspaces_get_makermodel_split(makermodel, 1024, &model, self->dev->image_storage.exif_maker, self->dev->image_storage.exif_model);
if(!strcmp(wb_preset[i].make, makermodel) &&
!strcmp(wb_preset[i].model, model) && wb_preset[i].tuning == tune)
{
for(int k=0; k<3; k++) p->coeffs[k] = wb_preset[i].channel[k];
break;
}
}
break;
}
if(self->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->off), 1);
gui_update_from_coeffs(self);
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
static void
rgb_callback (GtkWidget *slider, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(self->dt->gui->reset) return;
dt_iop_temperature_gui_data_t *g = (dt_iop_temperature_gui_data_t *)self->gui_data;
dt_iop_temperature_params_t *p = (dt_iop_temperature_params_t *)self->params;
const float value = dt_bauhaus_slider_get( slider );
if (slider == g->scale_r) p->coeffs[0] = value;
else if(slider == g->scale_g) p->coeffs[1] = value;
else if(slider == g->scale_b) p->coeffs[2] = value;
gui_update_from_coeffs(self);
dt_dev_add_history_item(darktable.develop, self, TRUE);
dt_bauhaus_combobox_set(g->presets, -1);
}
static gboolean
expose (GtkWidget *widget, GdkEventExpose *event, dt_iop_module_t *self)
{
// capture gui color picked event.
if(darktable.gui->reset) return FALSE;
if(self->picked_color_max[0] < self->picked_color_min[0]) return FALSE;
if(!self->request_color_pick) return FALSE;
static float old[3] = {0, 0, 0};
const float *grayrgb = self->picked_color;
if(grayrgb[0] == old[0] && grayrgb[1] == old[1] && grayrgb[2] == old[2]) return FALSE;
for(int k=0; k<3; k++) old[k] = grayrgb[k];
dt_iop_temperature_params_t *p = (dt_iop_temperature_params_t *)self->params;
for(int k=0; k<3; k++) p->coeffs[k] = (grayrgb[k] > 0.001f) ? 1.0f/grayrgb[k] : 1.0f;
// normalize green:
p->coeffs[0] /= p->coeffs[1];
p->coeffs[2] /= p->coeffs[1];
p->coeffs[1] = 1.0;
for(int k=0; k<3; k++) p->coeffs[k] = fmaxf(0.0f, fminf(8.0f, p->coeffs[k]));
gui_update_from_coeffs(self);
dt_dev_add_history_item(darktable.develop, self, TRUE);
return FALSE;
}
static void gui_update_from_coeffs(dt_iop_module_t *self)
{
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
const dt_image_t *img = &self->dev->image_storage;
if(img->flags & DT_IMAGE_4BAYER)
{
float rgb[4];
for(int k = 0; k < 4; k++) rgb[k] = p->color[k];
dt_colorspaces_cygm_to_rgb(rgb, 1, g->CAM_to_RGB);
color.red = rgb[0];
color.green = rgb[1];
color.blue = rgb[2];
}
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->colorpicker), &color);
}
static gboolean draw(GtkWidget *widget, cairo_t *cr, dt_iop_module_t *self)
{
if(darktable.gui->reset) return FALSE;
if(self->picked_color_max[0] < 0.0f) return FALSE;
if(self->request_color_pick == DT_REQUEST_COLORPICK_OFF) return FALSE;
static float old[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
const float *grayrgb = self->picked_color;
if(grayrgb[0] == old[0] && grayrgb[1] == old[1] && grayrgb[2] == old[2] && grayrgb[3] == old[3]) return FALSE;
for(int k = 0; k < 4; k++) old[k] = grayrgb[k];
dt_iop_invert_params_t *p = self->params;
for(int k = 0; k < 4; k++) p->color[k] = grayrgb[k];
darktable.gui->reset = 1;
gui_update_from_coeffs(self);
darktable.gui->reset = 0;
dt_dev_add_history_item(darktable.develop, self, TRUE);
return FALSE;
}
static void colorpicker_callback(GtkColorButton *widget, dt_iop_module_t *self)
{
if(self->dt->gui->reset) return;
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
// turn off the other color picker so that this tool actually works ...
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->picker), FALSE);
GdkRGBA c;
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &c);
p->color[0] = c.red;
p->color[1] = c.green;
p->color[2] = c.blue;
const dt_image_t *img = &self->dev->image_storage;
if(img->flags & DT_IMAGE_4BAYER)
{
dt_colorspaces_rgb_to_cygm(p->color, 1, g->RGB_to_CAM);
}
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
void process(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_invert_data_t *const d = (dt_iop_invert_data_t *)piece->data;
const float *const m = piece->pipe->dsc.processed_maximum;
const float film_rgb_f[4]
= { d->color[0] * m[0], d->color[1] * m[1], d->color[2] * m[2], d->color[3] * m[3] };
// FIXME: it could be wise to make this a NOP when picking colors. not sure about that though.
// if(self->request_color_pick){
// do nothing
// }
const uint32_t filters = piece->pipe->dsc.filters;
const uint8_t(*const xtrans)[6] = (const uint8_t(*const)[6])piece->pipe->dsc.xtrans;
const float *const in = (const float *const)ivoid;
float *const out = (float *const)ovoid;
if(filters == 9u)
{ // xtrans float mosaiced
#ifdef _OPENMP
#pragma omp parallel for SIMD() default(none) schedule(static) collapse(2)
#endif
for(int j = 0; j < roi_out->height; j++)
{
for(int i = 0; i < roi_out->width; i++)
{
const size_t p = (size_t)j * roi_out->width + i;
out[p] = CLAMP(film_rgb_f[FCxtrans(j, i, roi_out, xtrans)] - in[p], 0.0f, 1.0f);
}
}
for(int k = 0; k < 4; k++) piece->pipe->dsc.processed_maximum[k] = 1.0f;
}
else if(filters)
{ // bayer float mosaiced
#ifdef _OPENMP
#pragma omp parallel for SIMD() default(none) schedule(static) collapse(2)
#endif
for(int j = 0; j < roi_out->height; j++)
{
for(int i = 0; i < roi_out->width; i++)
{
const size_t p = (size_t)j * roi_out->width + i;
out[p] = CLAMP(film_rgb_f[FC(j + roi_out->y, i + roi_out->x, filters)] - in[p], 0.0f, 1.0f);
}
}
for(int k = 0; k < 4; k++) piece->pipe->dsc.processed_maximum[k] = 1.0f;
}
else
{ // non-mosaiced
const int ch = piece->colors;
#ifdef _OPENMP
#pragma omp parallel for SIMD() default(none) schedule(static) collapse(2)
#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++)
{
const size_t p = (size_t)k + c;
out[p] = d->color[c] - in[p];
}
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
}
#if defined(__SSE__)
void process_sse2(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)
{
dt_iop_invert_data_t *d = (dt_iop_invert_data_t *)piece->data;
const float *const m = piece->pipe->dsc.processed_maximum;
const float film_rgb_f[4]
= { d->color[0] * m[0], d->color[1] * m[1], d->color[2] * m[2], d->color[3] * m[3] };
// FIXME: it could be wise to make this a NOP when picking colors. not sure about that though.
// if(self->request_color_pick){
// do nothing
// }
const uint32_t filters = piece->pipe->dsc.filters;
const uint8_t(*const xtrans)[6] = (const uint8_t(*const)[6])piece->pipe->dsc.xtrans;
if(filters == 9u)
{ // xtrans float mosaiced
const __m128 val_min = _mm_setzero_ps();
const __m128 val_max = _mm_set1_ps(1.0f);
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static)
#endif
for(int j = 0; j < roi_out->height; j++)
{
const float *in = ((float *)ivoid) + (size_t)j * roi_out->width;
float *out = ((float *)ovoid) + (size_t)j * roi_out->width;
int i = 0;
int alignment = ((4 - (j * roi_out->width & (4 - 1))) & (4 - 1));
// process unaligned pixels
for(; i < alignment && i < roi_out->width; i++, out++, in++)
*out = CLAMP(film_rgb_f[FCxtrans(j, i, roi_out, xtrans)] - *in, 0.0f, 1.0f);
const __m128 film[3] = { _mm_set_ps(film_rgb_f[FCxtrans(j, i + 3, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 2, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 1, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 0, roi_out, xtrans)]),
_mm_set_ps(film_rgb_f[FCxtrans(j, i + 7, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 6, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 5, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 4, roi_out, xtrans)]),
_mm_set_ps(film_rgb_f[FCxtrans(j, i + 11, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 10, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 9, roi_out, xtrans)],
film_rgb_f[FCxtrans(j, i + 8, roi_out, xtrans)]) };
// process aligned pixels with SSE
for(int c = 0; c < 3 && i < roi_out->width - (4 - 1); c++, i += 4, in += 4, out += 4)
{
__m128 v;
v = _mm_load_ps(in);
v = _mm_sub_ps(film[c], v);
v = _mm_min_ps(v, val_max);
v = _mm_max_ps(v, val_min);
_mm_stream_ps(out, v);
}
// process the rest
for(; i < roi_out->width; i++, out++, in++)
*out = CLAMP(film_rgb_f[FCxtrans(j, i, roi_out, xtrans)] - *in, 0.0f, 1.0f);
}
_mm_sfence();
for(int k = 0; k < 4; k++) piece->pipe->dsc.processed_maximum[k] = 1.0f;
}
else if(filters)
{ // bayer float mosaiced
const __m128 val_min = _mm_setzero_ps();
const __m128 val_max = _mm_set1_ps(1.0f);
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static)
#endif
for(int j = 0; j < roi_out->height; j++)
{
const float *in = ((float *)ivoid) + (size_t)j * roi_out->width;
float *out = ((float *)ovoid) + (size_t)j * roi_out->width;
int i = 0;
int alignment = ((4 - (j * roi_out->width & (4 - 1))) & (4 - 1));
// process unaligned pixels
for(; i < alignment && i < roi_out->width; i++, out++, in++)
*out = CLAMP(film_rgb_f[FC(j + roi_out->y, i + roi_out->x, filters)] - *in, 0.0f, 1.0f);
const __m128 film = _mm_set_ps(film_rgb_f[FC(j + roi_out->y, roi_out->x + i + 3, filters)],
film_rgb_f[FC(j + roi_out->y, roi_out->x + i + 2, filters)],
film_rgb_f[FC(j + roi_out->y, roi_out->x + i + 1, filters)],
film_rgb_f[FC(j + roi_out->y, roi_out->x + i, filters)]);
// process aligned pixels with SSE
for(; i < roi_out->width - (4 - 1); i += 4, in += 4, out += 4)
{
const __m128 input = _mm_load_ps(in);
const __m128 subtracted = _mm_sub_ps(film, input);
_mm_stream_ps(out, _mm_max_ps(_mm_min_ps(subtracted, val_max), val_min));
}
// process the rest
for(; i < roi_out->width; i++, out++, in++)
*out = CLAMP(film_rgb_f[FC(j + roi_out->y, i + roi_out->x, filters)] - *in, 0.0f, 1.0f);
}
_mm_sfence();
for(int k = 0; k < 4; k++) piece->pipe->dsc.processed_maximum[k] = 1.0f;
}
else
{ // non-mosaiced
const int ch = piece->colors;
const __m128 film = _mm_set_ps(1.0f, d->color[2], d->color[1], d->color[0]);
#ifdef _OPENMP
#pragma omp parallel for default(none) 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)
{
const __m128 input = _mm_load_ps(in);
const __m128 subtracted = _mm_sub_ps(film, input);
_mm_stream_ps(out, subtracted);
}
}
_mm_sfence();
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
}
