static void color_picker_helper_xtrans_seq(const dt_iop_buffer_dsc_t *const dsc, const float *const pixel,
const dt_iop_roi_t *const roi, const int *const box,
float *const picked_color, float *const picked_color_min,
float *const picked_color_max)
{
const int width = roi->width;
const uint8_t(*const xtrans)[6] = (const uint8_t(*const)[6])dsc->xtrans;
uint32_t weights[3] = { 0u, 0u, 0u };
// code path for small region, especially for color picker point mode
for(size_t j = box[1]; j < box[3]; j++)
{
for(size_t i = box[0]; i < box[2]; i++)
{
const int c = FCxtrans(j, i, roi, xtrans);
const size_t k = width * j + i;
const float v = pixel[k];
picked_color[c] += v;
picked_color_min[c] = fminf(picked_color_min[c], v);
picked_color_max[c] = fmaxf(picked_color_max[c], v);
weights[c]++;
}
}
// and finally normalize data.
// X-Trans RGB weighting averages to 2:5:2 for each 3x3 cell
for(int c = 0; c < 3; c++)
{
picked_color[c] /= (float)weights[c];
}
}
static void process_lch_xtrans(
const void *const ivoid,
void *const ovoid,
const int width,
const int height,
const float clip,
const dt_iop_roi_t *const roi_in,
const uint8_t (*const xtrans)[6])
{
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none)
#endif
for(int j = 0; j < height; j++)
{
float *out = (float *)ovoid + (size_t)width * j;
float *in = (float *)ivoid + (size_t)width * j;
for(int i = 0; i < width; i++)
{
if(i < 3 || i > width - 3 || j < 3 || j > height - 3)
{
// fast path for border
out[0] = MIN(clip, in[0]);
}
else
{
const float near_clip = 0.96f * clip;
const float post_clip = 1.10f * clip;
float blend[3] = {0.0f};
float mean[3] = {0.0f};
int cnt[3] = {0};
for(int jj = -1; jj <= 1; jj++)
{
for(int ii = -1; ii <= 1; ii++)
{
const float val = in[(size_t)jj * width + ii];
const int c = FCxtrans(j+jj, i+ii, roi_in, xtrans);
mean[c] += val;
cnt[c]++;
blend[c] = fmaxf(blend[c], (fminf(post_clip, val) - near_clip) / (post_clip - near_clip));
}
}
if(blend[0] + blend[1] + blend[2] > 0)
{ // recover:
// options: use max colour and mean blend weight.
// const float m = fmaxf(mean[0]/cnt[0], fmaxf(mean[1]/cnt[1], mean[2]/cnt[2]));
// const float b = (blend[0] + blend[1] + blend[2])/3.0f;
const float m = (mean[0]/cnt[0] + mean[1]/cnt[1] + mean[2]/cnt[2])/3.0f;
const float b = fmaxf(fmaxf(blend[0], blend[1]), blend[2]);
out[0] = b * m + (1.0f-b) * in[0];
}
else
out[0] = in[0];
}
out++;
in++;
}
}
}
static int process_xtrans(const void *const i, void *o, const dt_iop_roi_t *const roi_in, const int width,
const int height, const uint8_t (*const xtrans)[6], const float threshold,
const float multiplier, const gboolean markfixed, const int min_neighbours)
{
// for each cell of sensor array, a list of the x/y offsets of the
// four radially nearest pixels of the same color
int offsets[6][6][4][2];
const int search[20][2] = { { -1, 0 },
{ 1, 0 },
{ 0, -1 },
{ 0, 1 },
{ -1, -1 },
{ -1, 1 },
{ 1, -1 },
{ 1, 1 },
{ -2, 0 },
{ 2, 0 },
{ 0, -2 },
{ 0, 2 },
{ -2, -1 },
{ -2, 1 },
{ 2, -1 },
{ 2, 1 },
{ -1, -2 },
{ 1, -2 },
{ -1, 2 },
{ 1, 2 } };
for(int j = 0; j < 6; ++j)
for(int i = 0; i < 6; ++i)
{
const uint8_t c = FCxtrans(j, i, roi_in, xtrans);
for(int s = 0, found = 0; s < 20 && found < 4; ++s)
{
if(c == FCxtrans(j + search[s][1], i + search[s][0], roi_in, xtrans))
{
offsets[i][j][found][0] = search[s][0];
offsets[i][j][found][1] = search[s][1];
++found;
}
}
}
int fixed = 0;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(o, offsets) reduction(+ : fixed) schedule(static)
#endif
for(int row = 1; row < height - 1; row++)
{
const float *in = (float *)i + (size_t)width * row + 2;
float *out = (float *)o + (size_t)width * row + 2;
for(int col = 1; col < width - 1; col++, in++, out++)
{
float mid = *in * multiplier;
if(*in > threshold)
{
int count = 0;
float maxin = 0.0;
for(int n = 0; n < 4; ++n)
{
int xx = offsets[col % 6][row % 6][n][0];
int yy = offsets[col % 6][row % 6][n][1];
if((xx < -col) || (xx >= (width - col)) || (yy < -row) || (yy >= (height - row))) break;
float other = *(in + xx + yy * width);
if(mid > other)
{
count++;
if(other > maxin) maxin = other;
}
}
// NOTE: it seems that detecting by 2 neighbors would help for extreme cases
if(count >= min_neighbours)
{
*out = maxin;
fixed++;
if(markfixed)
{
// cheat and mark all colors of pixels
// FIXME: use offsets
for(int i = -2; i >= -10 && i >= -col; --i) out[i] = *in;
for(int i = 2; i <= 10 && i < width - col; ++i) out[i] = *in;
}
}
}
}
}
return fixed;
}
static void process_lch_xtrans(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 float clip)
{
const uint8_t(*const xtrans)[6] = (const uint8_t(*const)[6])piece->pipe->dsc.xtrans;
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none)
#endif
for(int j = 0; j < roi_out->height; j++)
{
float *out = (float *)ovoid + (size_t)roi_out->width * j;
float *in = (float *)ivoid + (size_t)roi_in->width * j;
// bit vector used as ring buffer to remember clipping of current
// and last two columns, checking current pixel and its vertical
// neighbors
int cl = 0;
for(int i = 0; i < roi_out->width; i++)
{
// update clipping ring buffer
cl = (cl << 1) & 6;
if(j >= 2 && j <= roi_out->height - 3)
{
cl |= (in[-roi_in->width] > clip) | (in[0] > clip) | (in[roi_in->width] > clip);
}
if(i < 2 || i > roi_out->width - 3 || j < 2 || j > roi_out->height - 3)
{
// fast path for border
out[0] = MIN(clip, in[0]);
}
else
{
// if current pixel is clipped, always reconstruct
int clipped = (in[0] > clip);
if(!clipped)
{
clipped = cl;
if(clipped)
{
// If the ring buffer can't show we are in an obviously
// unclipped region, this is the slow case: check if there
// is any 3x3 block touching the current pixel which has
// no clipping, as then don't need to reconstruct the
// current pixel. This avoids zippering in edge
// transitions from clipped to unclipped areas. The
// X-Trans sensor seems prone to this, unlike Bayer, due
// to its irregular pattern.
for(int offset_j = -2; offset_j <= 0; offset_j++)
{
for(int offset_i = -2; offset_i <= 0; offset_i++)
{
if(clipped)
{
clipped = 0;
for(int jj = offset_j; jj <= offset_j + 2; jj++)
{
for(int ii = offset_i; ii <= offset_i + 2; ii++)
{
const float val = in[(ssize_t)jj * roi_in->width + ii];
clipped = (clipped || (val > clip));
}
}
}
}
}
}
}
if(clipped)
{
float mean[3] = { 0.0f, 0.0f, 0.0f };
int cnt[3] = { 0, 0, 0 };
float RGBmax[3] = { -FLT_MAX, -FLT_MAX, -FLT_MAX };
for(int jj = -1; jj <= 1; jj++)
{
for(int ii = -1; ii <= 1; ii++)
{
const float val = in[(ssize_t)jj * roi_in->width + ii];
const int c = FCxtrans(j+jj, i+ii, roi_in, xtrans);
mean[c] += val;
cnt[c]++;
RGBmax[c] = MAX(RGBmax[c], val);
}
}
const float Ro = MIN(mean[0]/cnt[0], clip);
const float Go = MIN(mean[1]/cnt[1], clip);
const float Bo = MIN(mean[2]/cnt[2], clip);
const float R = RGBmax[0];
const float G = RGBmax[1];
const float B = RGBmax[2];
const float L = (R + G + B) / 3.0f;
float C = SQRT3 * (R - G);
float H = 2.0f * B - G - R;
const float Co = SQRT3 * (Ro - Go);
const float Ho = 2.0f * Bo - Go - Ro;
if(R != G && G != B)
{
const float ratio = sqrtf((Co * Co + Ho * Ho) / (C * C + H * H));
C *= ratio;
H *= ratio;
}
float RGB[3] = { 0.0f, 0.0f, 0.0f };
RGB[0] = L - H / 6.0f + C / SQRT12;
RGB[1] = L - H / 6.0f - C / SQRT12;
RGB[2] = L + H / 3.0f;
out[0] = RGB[FCxtrans(j, i, roi_out, xtrans)];
}
else
out[0] = in[0];
}
out++;
in++;
}
}
}
static inline void interpolate_color_xtrans(const void *const ivoid, void *const ovoid,
const dt_iop_roi_t *const roi_in,
const dt_iop_roi_t *const roi_out,
int dim, int dir, int other,
const float *const clip,
const uint8_t (*const xtrans)[6],
const int pass)
{
// In Bayer each row/col has only green/red or green/blue
// transitions, hence can reconstruct color by single ratio per
// row. In x-trans there can be transitions between arbitrary colors
// in a row/col (and 2x2 green blocks which provide no color
// transition information). Hence calculate multiple color ratios
// for each row/col.
// Lookup for color ratios, e.g. red -> blue is roff[0][2] and blue
// -> red is roff[2][0]. Returned value is an index into ratios. If
// negative, then need to invert the ratio. Identity color
// transitions aren't used.
const int roff[3][3] = {{ 0, -1, -2},
{ 1, 0, -3},
{ 2, 3, 0}};
// record ratios of color transitions 0:unused, 1:RG, 2:RB, and 3:GB
float ratios[4] = {1.0f, 1.0f, 1.0f, 1.0f};
// passes are 0:+x, 1:-x, 2:+y, 3:-y
// dims are 0:traverse a row, 1:traverse a column
// dir is 1:left to right, -1: right to left
int i = (dim == 0) ? 0 : other;
int j = (dim == 0) ? other : 0;
const ssize_t offs = (dim ? roi_out->width : 1) * ((dir < 0) ? -1 : 1);
const ssize_t offl = offs - (dim ? 1 : roi_out->width);
const ssize_t offr = offs + (dim ? 1 : roi_out->width);
int beg, end;
if(dir == 1)
{
beg = 0;
end = (dim == 0) ? roi_out->width : roi_out->height;
}
else
{
beg = ((dim == 0) ? roi_out->width : roi_out->height) - 1;
end = -1;
}
float *in, *out;
if(dim == 1)
{
out = (float *)ovoid + (size_t)i + (size_t)beg * roi_out->width;
in = (float *)ivoid + (size_t)i + (size_t)beg * roi_in->width;
}
else
{
out = (float *)ovoid + (size_t)beg + (size_t)j * roi_out->width;
in = (float *)ivoid + (size_t)beg + (size_t)j * roi_in->width;
}
for(int k = beg; k != end; k += dir)
{
if(dim == 1)
j = k;
else
i = k;
const uint8_t f0 = FCxtrans(j, i, roi_in, xtrans);
const uint8_t f1 = FCxtrans(dim ? (j + dir) : j, dim ? i : (i + dir), roi_in, xtrans);
const uint8_t fl = FCxtrans(dim ? (j + dir) : (j - 1), dim ? (i - 1) : (i + dir), roi_in, xtrans);
const uint8_t fr = FCxtrans(dim ? (j + dir) : (j + 1), dim ? (i + 1) : (i + dir), roi_in, xtrans);
const float clip0 = clip[f0];
const float clip1 = clip[f1];
const float clipl = clip[fl];
const float clipr = clip[fr];
const float clip_max = fmaxf(fmaxf(clip[0], clip[1]), clip[2]);
if(i == 0 || i == roi_out->width - 1 || j == 0 || j == roi_out->height - 1)
{
if(pass == 3) out[0] = fminf(clip_max, in[0]);
}
else
{
// ratio to next pixel if this & next are unclamped and not in
// 2x2 green block
if ((f0 != f1) &&
(in[0] < clip0 && in[0] > 1e-5f) &&
(in[offs] < clip1 && in[offs] > 1e-5f))
{
const int r = roff[f0][f1];
assert(r != 0);
if (r > 0)
ratios[r] = (3.f * ratios[r] + (in[offs] / in[0])) / 4.f;
else
ratios[-r] = (3.f * ratios[-r] + (in[0] / in[offs])) / 4.f;
}
if(in[0] >= clip0 - 1e-5f)
{
// interplate color for clipped pixel
float add;
if(f0 != f1)
// next pixel is different color
add =
interp_pix_xtrans(roff[f0][f1], offs, clip0, clip1, in, ratios);
else
// at start of 2x2 green block, look diagonally
add = (fl != f0) ?
interp_pix_xtrans(roff[f0][fl], offl, clip0, clipl, in, ratios) :
interp_pix_xtrans(roff[f0][fr], offr, clip0, clipr, in, ratios);
if(pass == 0)
out[0] = add;
else if(pass == 3)
out[0] = fminf(clip_max, (out[0] + add) / 4.0f);
else
out[0] += add;
}
else
{
// pixel is not clipped
if(pass == 3) out[0] = in[0];
}
}
out += offs;
in += offs;
}
}
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 int filters = dt_image_filter(&piece->pipe->image);
uint8_t (*const xtrans)[6] = self->dev->image_storage.xtrans;
dt_iop_temperature_data_t *d = (dt_iop_temperature_data_t *)piece->data;
if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters == 9u)
{ // xtrans float mosaiced
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, d) 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;
for(int i=0; i<roi_out->width; i++,out++,in++)
*out = *in * d->coeffs[FCxtrans(j,i,roi_out,xtrans)];
}
}
else if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters)
{ // bayer float mosaiced
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, d) 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++, out++, in++)
*out = *in * d->coeffs[FC(j+roi_out->y, i+roi_out->x, filters)];
const __m128 coeffs = _mm_set_ps(d->coeffs[FC(j+roi_out->y, roi_out->x+i+3, filters)],
d->coeffs[FC(j+roi_out->y, roi_out->x+i+2, filters)],
d->coeffs[FC(j+roi_out->y, roi_out->x+i+1, filters)],
d->coeffs[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 multiplied = _mm_mul_ps(input, coeffs);
_mm_stream_ps(out, multiplied);
}
// process the rest
for( ; i<roi_out->width; i++,out++,in++)
*out = *in * d->coeffs[FC(j+roi_out->y, i+roi_out->x, filters)];
}
_mm_sfence();
}
else
{ // non-mosaiced
const int ch = piece->colors;
const __m128 coeffs = _mm_set_ps(1.0f,
d->coeffs[2],
d->coeffs[1],
d->coeffs[0]);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, d) 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 multiplied = _mm_mul_ps(input, coeffs);
_mm_stream_ps(out, multiplied);
}
}
_mm_sfence();
if(piece->pipe->mask_display)
dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
for(int k=0; k<3; k++)
piece->pipe->processed_maximum[k] = d->coeffs[k] * piece->pipe->processed_maximum[k];
}
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;
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;
if(fabsf(p->color[0] - self->picked_color[0]) < 0.0001f
&& fabsf(p->color[1] - self->picked_color[1]) < 0.0001f
&& fabsf(p->color[2] - self->picked_color[2]) < 0.0001f)
{
// interrupt infinite loops
return FALSE;
}
p->color[0] = self->picked_color[0];
p->color[1] = self->picked_color[1];
p->color[2] = self->picked_color[2];
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->colorpicker), &color);
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;
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
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_invert_data_t *d = (dt_iop_invert_data_t *)piece->data;
const float *const m = piece->pipe->processed_maximum;
float film_rgb[4] = { d->color[0], d->color[1], d->color[2], 0.0f };
// Convert the RGB color to CYGM only if we're not in the preview pipe (which is already RGB)
if((self->dev->image_storage.flags & DT_IMAGE_4BAYER) && !dt_dev_pixelpipe_uses_downsampled_input(piece->pipe))
dt_colorspaces_rgb_to_cygm(film_rgb, 1, d->RGB_to_CAM);
const float film_rgb_f[4] = { film_rgb[0] * m[0], film_rgb[1] * m[1], film_rgb[2] * m[2], film_rgb[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 int filters = dt_image_filter(&piece->pipe->image);
const uint8_t (*const xtrans)[6] = (const uint8_t (*const)[6]) self->dev->image_storage.xtrans;
if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && (filters == 9u))
{ // xtrans float mosaiced
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid) 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;
for(int i = 0; i < roi_out->width; i++, out++, in++)
*out = CLAMP(film_rgb_f[FCxtrans(j, i, roi_out, xtrans)] - *in, 0.0f, 1.0f);
}
for(int k = 0; k < 4; k++) piece->pipe->processed_maximum[k] = 1.0f;
}
else if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && 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) shared(roi_out, ivoid, ovoid) 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++, 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->processed_maximum[k] = 1.0f;
}
else
{ // non-mosaiced
const int ch = piece->colors;
const __m128 film = _mm_set_ps(1.0f, film_rgb[2], film_rgb[1], film_rgb[0]);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid) 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);
}
}
/* X-Trans sensor equivalent of process_bayer(). */
static int process_xtrans(const dt_iop_hotpixels_data_t *data,
const void *const ivoid, void *const ovoid,
const dt_iop_roi_t *const roi_out, const uint8_t (*const xtrans)[6])
{
// for each cell of sensor array, pre-calculate, a list of the x/y
// offsets of the four radially nearest pixels of the same color
int offsets[6][6][4][2];
// increasing offsets from pixel to find nearest like-colored pixels
const int search[20][2] = { { -1, 0 },
{ 1, 0 },
{ 0, -1 },
{ 0, 1 },
{ -1, -1 },
{ -1, 1 },
{ 1, -1 },
{ 1, 1 },
{ -2, 0 },
{ 2, 0 },
{ 0, -2 },
{ 0, 2 },
{ -2, -1 },
{ -2, 1 },
{ 2, -1 },
{ 2, 1 },
{ -1, -2 },
{ 1, -2 },
{ -1, 2 },
{ 1, 2 } };
for(int j = 0; j < 6; ++j)
{
for(int i = 0; i < 6; ++i)
{
const uint8_t c = FCxtrans(j, i, roi_out, xtrans);
for(int s = 0, found = 0; s < 20 && found < 4; ++s)
{
if(c == FCxtrans(j + search[s][1], i + search[s][0], roi_out, xtrans))
{
offsets[j][i][found][0] = search[s][0];
offsets[j][i][found][1] = search[s][1];
++found;
}
}
}
}
const float threshold = data->threshold;
const float multiplier = data->multiplier;
const gboolean markfixed = data->markfixed;
const int min_neighbours = data->permissive ? 3 : 4;
const int width = roi_out->width;
int fixed = 0;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(offsets) reduction(+ : fixed) schedule(static)
#endif
for(int row = 2; row < roi_out->height - 2; row++)
{
const float *in = (float *)ivoid + (size_t)width * row + 2;
float *out = (float *)ovoid + (size_t)width * row + 2;
for(int col = 2; col < width - 2; col++, in++, out++)
{
float mid = *in * multiplier;
if(*in > threshold)
{
int count = 0;
float maxin = 0.0;
for(int n = 0; n < 4; ++n)
{
int xx = offsets[row % 6][col % 6][n][0];
int yy = offsets[row % 6][col % 6][n][1];
float other = *(in + xx + yy * (size_t)width);
if(mid > other)
{
count++;
if(other > maxin) maxin = other;
}
}
// NOTE: it seems that detecting by 2 neighbors would help for extreme cases
if(count >= min_neighbours)
{
*out = maxin;
fixed++;
if(markfixed)
{
const uint8_t c = FCxtrans(row, col, roi_out, xtrans);
for(int i = -2; i >= -10 && i >= -col; --i)
{
if(c == FCxtrans(row, col+i, roi_out, xtrans))
{
out[i] = *in;
}
}
for(int i = 2; i <= 10 && i < width - col; ++i)
{
if(c == FCxtrans(row, col+i, roi_out, xtrans))
{
out[i] = *in;
}
}
}
}
}
}
}
return fixed;
}
static inline void _interpolate_color_xtrans(void *ivoid, void *ovoid, const dt_iop_roi_t *const roi_in,
const dt_iop_roi_t *const roi_out, int dim, int dir, int other,
const float *clip, const uint8_t (*const xtrans)[6],
const int pass)
{
// similar to Bayer version, but in Bayer each row/column has only
// green/red or green/blue transitions, in x-trans there can be
// red/green, red/blue, and green/blue
float ratios[2][3] = { { 1.0f, 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f } };
float *in, *out;
int i = 0, j = 0;
if(dim == 0)
j = other;
else
i = other;
ssize_t offs = dim ? roi_out->width : 1;
if(dir < 0) offs = -offs;
int beg, end;
if(dim == 0 && dir == 1)
{
beg = 0;
end = roi_out->width;
}
else if(dim == 0 && dir == -1)
{
beg = roi_out->width - 1;
end = -1;
}
else if(dim == 1 && dir == 1)
{
beg = 0;
end = roi_out->height;
}
else if(dim == 1 && dir == -1)
{
beg = roi_out->height - 1;
end = -1;
}
else
return;
if(dim == 1)
{
out = (float *)ovoid + i + (size_t)beg * roi_out->width;
in = (float *)ivoid + i + (size_t)beg * roi_out->width;
}
else
{
out = (float *)ovoid + beg + (size_t)j * roi_out->width;
in = (float *)ivoid + beg + (size_t)j * roi_out->width;
}
for(int k = beg; k != end; k += dir)
{
if(dim == 1)
j = k;
else
i = k;
if(i < 2 || i > roi_out->width - 3 || j < 2 || j > roi_out->height - 3)
{
if(pass == 3) out[0] = in[0];
}
else
{
const uint8_t f0 = FCxtrans(j, i, roi_in, xtrans);
const uint8_t f1 = FCxtrans(dim ? (j + dir) : j, dim ? i : (i + dir), roi_in, xtrans);
const uint8_t f2 = FCxtrans(dim ? (j + dir * 2) : j, dim ? i : (i + dir * 2), roi_in, xtrans);
const float clip0 = clip[f0];
const float clip1 = clip[f1];
const float clip2 = clip[f2];
// record ratio to next different-colored pixel if this & next unclamped
if(in[0] < clip0 && in[0] > 1e-5f)
{
if(in[offs] < clip1 && in[offs] > 1e-5f)
{
if(f0 != f1)
{ // not first of gg block
if(f0 < f1)
ratios[f0][f1] = (3.0f * ratios[f0][f1] + in[0] / in[offs]) / 4.0f;
else
ratios[f1][f0] = (3.0f * ratios[f1][f0] + in[offs] / in[0]) / 4.0f;
}
else
{
if(in[offs * 2] < clip2 && in[offs * 2] > 1e-5f)
{
if(f0 < f2)
ratios[f0][f2] = (3.0f * ratios[f0][f2] + in[0] / in[offs * 2]) / 4.0f;
else
ratios[f2][f0] = (3.0f * ratios[f2][f0] + in[offs * 2] / in[0]) / 4.0f;
}
}
}
}
if(in[0] >= clip0 - 1e-5f)
{
float add = 0.0f;
if(f0 != f1) // not double green block
{
if(in[offs] >= clip1 - 1e-5f)
{
add = fmaxf(clip0, clip1);
}
else
{
if(f0 < f1)
add = in[offs] * ratios[f0][f1];
else
add = in[offs] / ratios[f1][f0];
}
}
else
{
if(1 && in[offs] < clip1 - 1e-5f) // adjacent green isn't clipped
{
add = in[offs];
}
else if(in[offs * 2] >= clip2 - 1e-5f)
{
add = fmaxf(clip0, clip2);
}
else
{
if(f0 < f2)
add = in[offs * 2] * ratios[f0][f2];
else
add = in[offs * 2] / ratios[f2][f0];
}
}
if(pass == 0)
out[0] = add;
else if(pass == 3)
out[0] = (out[0] + add) / 4.0f;
else
out[0] += add;
}
else
{
if(pass == 3) out[0] = in[0];
}
}
out += offs;
in += offs;
}
}
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);
}
}
static void color_picker_helper_xtrans_parallel(const dt_iop_buffer_dsc_t *const dsc, const float *const pixel,
const dt_iop_roi_t *const roi, const int *const box,
float *const picked_color, float *const picked_color_min,
float *const picked_color_max)
{
const int width = roi->width;
const uint8_t(*const xtrans)[6] = (const uint8_t(*const)[6])dsc->xtrans;
uint32_t weights[3] = { 0u, 0u, 0u };
const int numthreads = dt_get_num_threads();
float *const msum = malloc((size_t)3 * numthreads * sizeof(float));
float *const mmin = malloc((size_t)3 * numthreads * sizeof(float));
float *const mmax = malloc((size_t)3 * numthreads * sizeof(float));
uint32_t *const cnt = malloc((size_t)3 * numthreads * sizeof(uint32_t));
for(int n = 0; n < 3 * numthreads; n++)
{
msum[n] = 0.0f;
mmin[n] = INFINITY;
mmax[n] = -INFINITY;
cnt[n] = 0u;
}
#ifdef _OPENMP
#pragma omp parallel default(none)
#endif
{
const int tnum = dt_get_thread_num();
float *const tsum = msum + 3 * tnum;
float *const tmmin = mmin + 3 * tnum;
float *const tmmax = mmax + 3 * tnum;
uint32_t *const tcnt = cnt + 3 * tnum;
#ifdef _OPENMP
#pragma omp for schedule(static) collapse(2)
#endif
for(size_t j = box[1]; j < box[3]; j++)
{
for(size_t i = box[0]; i < box[2]; i++)
{
const int c = FCxtrans(j, i, roi, xtrans);
const size_t k = width * j + i;
const float v = pixel[k];
tsum[c] += v;
tmmin[c] = fminf(tmmin[c], v);
tmmax[c] = fmaxf(tmmax[c], v);
tcnt[c]++;
}
}
}
for(int n = 0; n < numthreads; n++)
{
for(int c = 0; c < 3; c++)
{
picked_color[c] += msum[3 * n + c];
picked_color_min[c] = fminf(picked_color_min[c], mmin[3 * n + c]);
picked_color_max[c] = fmaxf(picked_color_max[c], mmax[3 * n + c]);
weights[c] += cnt[3 * n + c];
}
}
free(cnt);
free(mmax);
free(mmin);
free(msum);
// and finally normalize data.
// X-Trans RGB weighting averages to 2:5:2 for each 3x3 cell
for(int c = 0; c < 3; c++)
{
picked_color[c] /= (float)weights[c];
}
}
