src/iop/bilateral.cc
Rama master · réplica de lectura del repositorio original.
/*
This file is part of darktable,
Copyright (C) 2010-2025 darktable developers.
darktable 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 3 of the License, or
(at your option) any later version.
darktable 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 darktable. If not, see <http://www.gnu.org/licenses/>.
*/
#define __STDC_FORMAT_MACROS
#include "bauhaus/bauhaus.h"
#include "common/imagebuf.h"
#include "control/control.h"
#include "develop/develop.h"
#include "develop/imageop.h"
#include "develop/imageop_math.h"
#include "develop/imageop_gui.h"
#include "develop/tiling.h"
#include "gui/accelerators.h"
#include "gui/gtk.h"
#include "iop/iop_api.h"
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "iop/Permutohedral.h"
#include <gtk/gtk.h>
#include <inttypes.h>
G_BEGIN_DECLS
/**
* implementation of the 5d-color bilateral filter using andrew adams
* et al.'s permutohedral lattice, which they kindly provided online
* as c++ code, under new bsd license.
*/
#define MAX_DIRECT_STAMP_RADIUS 6
DT_MODULE_INTROSPECTION(1, dt_iop_bilateral_params_t)
typedef struct dt_iop_bilateral_params_t
{
// standard deviations of the gauss to use for blurring in the dimensions x,y,r,g,b (or L*,a*,b*)
float radius; // $MIN: 1.0 $MAX: 50.0 $DEFAULT: 15.0
float reserved; // $DEFAULT: 15.0
float red, green, blue; // $MIN: 0.0001 $MAX: 1.0 $DEFAULT: 0.005
} dt_iop_bilateral_params_t;
typedef struct dt_iop_bilateral_gui_data_t
{
GtkWidget *radius, *red, *green, *blue;
} dt_iop_bilateral_gui_data_t;
typedef struct dt_iop_bilateral_data_t
{
float sigma[5];
} dt_iop_bilateral_data_t;
typedef struct dt_iop_bilateral_global_data_t
{
int kernel_insert;
int kernel_splat;
int kernel_blur;
int kernel_slice;
int kernel_direct;
} dt_iop_bilateral_global_data_t;
const char *name()
{
return _("surface blur");
}
const char *aliases()
{
return _("denoise (bilateral filter)");
}
int default_group()
{
return IOP_GROUP_CORRECT | IOP_GROUP_TECHNICAL;
}
int flags()
{
return IOP_FLAGS_ALLOW_TILING | IOP_FLAGS_SUPPORTS_BLENDING;
}
dt_iop_colorspace_type_t default_colorspace(dt_iop_module_t *self,
dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
return IOP_CS_RGB;
}
const char **description(dt_iop_module_t *self)
{
return dt_iop_set_description
(self,
_("apply edge-aware surface blur\n"
"to denoise or smoothen textures"),
_("corrective and creative"),
_("linear, RGB, scene-referred"),
_("linear, RGB"),
_("linear, RGB, scene-referred"));
}
static void _compute_sigmas(float sigma[5],
dt_iop_bilateral_data_t *data,
float scale,
float iscale)
{
sigma[0] = data->sigma[0] * scale / iscale;
sigma[1] = data->sigma[1] * scale / iscale;
sigma[2] = data->sigma[2];
sigma[3] = data->sigma[3];
sigma[4] = data->sigma[4];
}
void process(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)
{
if(!dt_iop_have_required_input_format(4 /*we need full-color pixels*/,
self, piece->colors,
ivoid, ovoid, roi_in, roi_out))
return;
assert(roi_in->width == roi_out->width);
assert(roi_in->height == roi_out->height);
const size_t width = roi_out->width;
const size_t height = roi_out->height;
const size_t npixels = width * height;
if (npixels > INT_MAX)
{
dt_iop_set_module_trouble_message(self, _("image too large"),
_("this module is unable to process\n"
"images with more than 2 gigapixels.\n"
"processing has been skipped."),
"image too large, processing skipped");
dt_iop_image_copy_by_size((float*)ovoid, (float*)ivoid,
roi_out->width, roi_out->height, 4);
return;
}
else
{
dt_iop_clear_module_trouble_message(self);
}
dt_iop_bilateral_data_t *data = (dt_iop_bilateral_data_t *)piece->data;
float sigma[5];
_compute_sigmas(sigma, data, roi_in->scale, piece->iscale);
if(fmaxf(sigma[0], sigma[1]) < 0.1f)
{
dt_iop_image_copy_by_size((float*)ovoid, (float*)ivoid,
roi_out->width, roi_out->height, 4);
return;
}
// if rad <= 6 use naive version!
const int prad = (int)(3.0f * fmaxf(sigma[0], sigma[1]) + 1.0f);
const int rad = MIN(prad, MIN(roi_out->width, roi_out->height) - 2 * prad);
const gboolean thumb = dt_pipe_is_thumb(piece->pipe);
if(rad < 1 || (rad <= MAX_DIRECT_STAMP_RADIUS && thumb))
{
// no use denoising the thumbnail. takes ages without permutohedral
dt_iop_image_copy_by_size((float*)ovoid, (float*)ivoid, roi_out->width, roi_out->height, 4);
}
else if(rad <= MAX_DIRECT_STAMP_RADIUS)
{
static const size_t weights_size = 2 * (6 + 1) * 2 * (6 + 1);
float mat[weights_size];
const int wd = 2 * rad + 1;
float *m = mat + rad * wd + rad;
float weight = 0.0f;
const dt_aligned_pixel_t isig2col = {1.0f / (2.0f * sigma[2] * sigma[2]),
1.0f / (2.0f * sigma[3] * sigma[3]),
1.0f / (2.0f * sigma[4] * sigma[4]),
0.0f };
// init gaussian kernel
for(int l = -rad; l <= rad; l++)
for(int k = -rad; k <= rad; k++)
weight += m[l * wd + k] = expf(-(l * l + k * k) / (2.f * sigma[0] * sigma[0]));
for(int l = -rad; l <= rad; l++)
for(int k = -rad; k <= rad; k++)
m[l * wd + k] /= weight;
DT_OMP_FOR()
for(size_t j = 0; j < height; j++)
{
const float *in = ((float *)ivoid) + 4 * (j * width);
float *out = ((float *)ovoid) + 4 * (j * width);
if(j < (unsigned)rad || j >= height - rad)
{
// copy the unprocessed top/bottom border rows
for(size_t i = 0; i < width; i++)
copy_pixel_nontemporal(out + 4*i, in + 4*i);
continue;
}
for(size_t i = 0; i < (size_t)rad; i++, in += 4)
{
// copy the unprocessed left border pixels
copy_pixel_nontemporal(out + 4*i, in);
}
// apply blur to main body of image
for(size_t i = rad; i < width - rad; i++, in += 4)
{
float sumw = 0.0f;
dt_aligned_pixel_t res = { 0.0f, 0.0f, 0.0f, 0.0f };
dt_aligned_pixel_t pixel;
copy_pixel(pixel, in);
for(ssize_t l = -rad; l <= rad; l++)
{
for(ssize_t k = -rad; k <= rad; k++)
{
const float *inp = in + 4 * (l * width + k);
dt_aligned_pixel_t chandiff;
for_each_channel(c)
chandiff[c] = (pixel[c] - inp[c]) * (pixel[c] - inp[c]) * isig2col[c];
const float diff = chandiff[0] + chandiff[1] + chandiff[2];
const float pix_weight = m[l * wd + k] * expf(-diff);
for_each_channel(c)
res[c] += inp[c] * pix_weight;
sumw += pix_weight;
}
}
for_each_channel(c)
res[c] /= sumw;
copy_pixel_nontemporal(out + 4*i, res);
}
for(size_t i = width - rad; i < width; i++, in += 4)
{
// copy the unprocessed right border pixels
copy_pixel_nontemporal(out + 4*i, in);
}
}
dt_omploop_sfence();
}
else
{
for(int k = 0; k < 5; k++) sigma[k] = 1.0f / sigma[k];
const size_t grid_points =
(height*sigma[0]) * (width*sigma[1]) * sigma[2] * sigma[3] * sigma[4];
PermutohedralLattice<5, 4> lattice(width * height, dt_get_num_threads(), grid_points);
// splat into the lattice
DT_OMP_FOR(shared(lattice))
for(size_t j = 0; j < height; j++)
{
const float *in = (const float *)ivoid + j * width * 4;
const int thread = dt_get_thread_num();
const size_t index = j * width;
for(size_t i = 0; i < width; i++)
{
// image coordinates rather than roi ones: the lattice is not
// translation invariant, so tiles and zoomed views would otherwise
// each get a different blur
float pos[5] = { (float)(roi_in->x + (int)i) * sigma[0],
(float)(roi_in->y + (int)j) * sigma[1],
in[0] * sigma[2],
in[1] * sigma[3],
in[2] * sigma[4] };
dt_aligned_pixel_t val = { in[0], in[1], in[2], 1.0f };
lattice.splat(pos, val, index + i, thread);
in += 4;
}
}
lattice.merge_splat_threads();
// blur the lattice
lattice.blur();
// slice from the lattice
float *const out = (float*)ovoid;
DT_OMP_FOR(shared(lattice))
for(size_t index = 0; index < npixels; index++)
{
dt_aligned_pixel_t val;
lattice.slice(val, index);
for_each_channel(k)
val[k] /= val[3];
copy_pixel_nontemporal(out + 4*index, val);
}
dt_omploop_sfence();
}
}
#ifdef HAVE_OPENCL
// the lattice on the device, see data/kernels/permutohedral.cl. sigma holds
// the inverted sigmas, as process() has them for the lattice.
static cl_int _lattice_cl(const dt_iop_bilateral_global_data_t *gd,
const int devid,
cl_mem dev_in,
cl_mem dev_out,
const int width,
const int height,
const int x0,
const int y0,
const float sigma[5])
{
const size_t npixels = (size_t)width * height;
const size_t grid_points =
(height*sigma[0]) * (width*sigma[1]) * sigma[2] * sigma[3] * sigma[4];
// the scale factors of the PermutohedralLattice constructor, computed the
// same way so the vertices match the CPU's
float prm[12];
for(int i = 0; i < 5; i++)
{
prm[i] = sigma[i];
prm[5 + i] = 1.0f / (sqrtf((float)(i + 1) * (i + 2)));
prm[5 + i] *= (5 + 1) * sqrtf(2.0 / 3);
}
// the roi origin, for the image coordinates process() uses
prm[10] = x0;
prm[11] = y0;
// the CPU's estimate of the vertex count, which it uses to size its
// tables. A run that needs more entries starts again with the count it
// found.
size_t max_entries = PermutohedralLattice<5, 4>::estimatedHashEntries(grid_points, npixels);
const int row_width = 4096;
cl_int err = DT_OPENCL_DEFAULT_ERROR;
for(int attempt = 0; attempt < 3; attempt++)
{
const size_t capacity = 2 * max_entries;
if(capacity > UINT32_MAX || max_entries == 0) return DT_OPENCL_PROCESS_CL;
const uint32_t cap = capacity;
const uint32_t max_e = max_entries;
cl_mem slots = (cl_mem)dt_opencl_alloc_device_buffer(devid, 2 * sizeof(uint32_t) * capacity);
cl_mem keys = (cl_mem)dt_opencl_alloc_device_buffer(devid, 3 * sizeof(uint32_t) * max_entries);
cl_mem counters = (cl_mem)dt_opencl_alloc_device_buffer(devid, 4 * sizeof(uint32_t));
cl_mem params = (cl_mem)dt_opencl_copy_host_to_device_constant(devid, sizeof(prm), prm);
cl_mem values[2] = { NULL, NULL };
gboolean overflow = FALSE;
uint32_t cnt[4] = { 0 };
err = DT_OPENCL_DEFAULT_ERROR;
if(!slots || !keys || !counters || !params) goto cleanup;
err = dt_opencl_fill_buffer(devid, slots, 2 * capacity, 1, 0.0f);
if(err == CL_SUCCESS)
err = dt_opencl_write_buffer_to_device(devid, cnt, counters, 0, sizeof(cnt), TRUE);
// more rounds only for vertices that lost their slot to another vertex
// with the same fingerprint
for(uint32_t round = 1; err == CL_SUCCESS && round < 8; round++)
{
err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_insert, width, height,
CLARG(dev_in), CLARG(slots), CLARG(keys), CLARG(counters), CLARG(params),
CLARG(width), CLARG(height), CLARG(cap), CLARG(max_e), CLARG(round));
if(err == CL_SUCCESS)
err = dt_opencl_read_buffer_from_device(devid, cnt, counters, 0, sizeof(cnt), TRUE);
if(err != CL_SUCCESS) break;
if(cnt[1])
{
// too many vertices for the estimate: size the next attempt by the count
overflow = TRUE;
max_entries = (size_t)cnt[0] + cnt[0] / 8 + 1024;
break;
}
const uint32_t entries = cnt[0];
for(int k = 0; k < 2; k++)
{
dt_opencl_release_mem_object(values[k]);
values[k] = (cl_mem)dt_opencl_alloc_device_buffer(devid, 4 * sizeof(float) * entries);
}
err = DT_OPENCL_DEFAULT_ERROR;
if(!values[0] || !values[1]) break;
err = dt_opencl_fill_buffer(devid, values[0], entries, 4, 0.0f);
if(err == CL_SUCCESS)
err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_splat, width, height,
CLARG(dev_in), CLARG(slots), CLARG(keys), CLARG(counters), CLARG(values[0]),
CLARG(params), CLARG(width), CLARG(height), CLARG(cap), CLARG(entries));
const int rows = (entries + row_width - 1) / row_width;
int src = 0;
for(int j = 0; err == CL_SUCCESS && j <= 5; j++)
{
err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_blur, row_width, rows,
CLARG(slots), CLARG(keys), CLARG(values[src]), CLARG(values[1 - src]),
CLARG(cap), CLARG(entries), CLARG(row_width), CLARG(j));
src = 1 - src;
}
if(err == CL_SUCCESS)
err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_slice, width, height,
CLARG(dev_in), CLARG(dev_out), CLARG(slots), CLARG(keys), CLARG(values[src]),
CLARG(params), CLARG(width), CLARG(height), CLARG(cap), CLARG(entries));
if(err == CL_SUCCESS)
err = dt_opencl_read_buffer_from_device(devid, cnt, counters, 0, sizeof(cnt), TRUE);
if(err != CL_SUCCESS || cnt[2] == 0) break;
dt_print(DT_DEBUG_OPENCL, "[bilateral] %u vertices lost their slot, inserting again", cnt[2]);
// the next round starts with no missing vertices
cnt[2] = 0;
err = dt_opencl_write_buffer_to_device(devid, cnt, counters, 0, sizeof(cnt), TRUE);
if(round == 7) err = DT_OPENCL_PROCESS_CL;
}
cleanup:
dt_opencl_release_mem_object(values[0]);
dt_opencl_release_mem_object(values[1]);
dt_opencl_release_mem_object(params);
dt_opencl_release_mem_object(counters);
dt_opencl_release_mem_object(keys);
dt_opencl_release_mem_object(slots);
if(!overflow) break;
dt_print(DT_DEBUG_OPENCL, "[bilateral] lattice outgrew its estimate, retrying with %zu entries",
max_entries);
err = DT_OPENCL_PROCESS_CL;
}
return err;
}
int process_cl(dt_iop_module_t *self,
dt_dev_pixelpipe_iop_t *piece,
cl_mem dev_in,
cl_mem dev_out,
const dt_iop_roi_t *const roi_in,
const dt_iop_roi_t *const roi_out)
{
const dt_iop_bilateral_global_data_t *gd = (dt_iop_bilateral_global_data_t *)self->global_data;
if(piece->colors != 4) return DT_OPENCL_PROCESS_CL;
if(roi_in->width != roi_out->width || roi_in->height != roi_out->height) return DT_OPENCL_PROCESS_CL;
const int devid = piece->pipe->devid;
const int width = roi_out->width;
const int height = roi_out->height;
if((size_t)width * height > INT_MAX) return DT_OPENCL_PROCESS_CL;
dt_iop_bilateral_data_t *data = (dt_iop_bilateral_data_t *)piece->data;
float sigma[5];
_compute_sigmas(sigma, data, roi_in->scale, piece->iscale);
// the branches of process()
size_t origin[] = { 0, 0, 0 };
size_t region[] = { (size_t)width, (size_t)height, 1 };
if(fmaxf(sigma[0], sigma[1]) < 0.1f)
return dt_opencl_enqueue_copy_image(devid, dev_in, dev_out, origin, origin, region);
const int prad = (int)(3.0f * fmaxf(sigma[0], sigma[1]) + 1.0f);
const int rad = MIN(prad, MIN(roi_out->width, roi_out->height) - 2 * prad);
const gboolean thumb = dt_pipe_is_thumb(piece->pipe);
if(rad < 1 || (rad <= MAX_DIRECT_STAMP_RADIUS && thumb))
return dt_opencl_enqueue_copy_image(devid, dev_in, dev_out, origin, origin, region);
if(rad <= MAX_DIRECT_STAMP_RADIUS)
{
const int wd = 2 * rad + 1;
float mat[(2 * MAX_DIRECT_STAMP_RADIUS + 1) * (2 * MAX_DIRECT_STAMP_RADIUS + 1)];
float *m = mat + rad * wd + rad;
float weight = 0.0f;
for(int l = -rad; l <= rad; l++)
for(int k = -rad; k <= rad; k++)
weight += m[l * wd + k] = expf(-(l * l + k * k) / (2.f * sigma[0] * sigma[0]));
for(int l = -rad; l <= rad; l++)
for(int k = -rad; k <= rad; k++)
m[l * wd + k] /= weight;
const dt_aligned_pixel_t isig2col = { 1.0f / (2.0f * sigma[2] * sigma[2]),
1.0f / (2.0f * sigma[3] * sigma[3]),
1.0f / (2.0f * sigma[4] * sigma[4]),
0.0f };
cl_mem dev_m = (cl_mem)dt_opencl_copy_host_to_device_constant(devid, sizeof(float) * wd * wd, mat);
cl_int err = DT_OPENCL_DEFAULT_ERROR;
if(dev_m)
err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_direct, width, height,
CLARG(dev_in), CLARG(dev_out), CLARG(dev_m), CLARG(width), CLARG(height),
CLARG(rad), CLARG(isig2col));
dt_opencl_release_mem_object(dev_m);
return err;
}
for(int k = 0; k < 5; k++) sigma[k] = 1.0f / sigma[k];
return _lattice_cl(gd, devid, dev_in, dev_out, width, height, roi_in->x, roi_in->y, sigma);
}
#endif
void commit_params(dt_iop_module_t *self,
dt_iop_params_t *p1,
dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
dt_iop_bilateral_params_t *p = (dt_iop_bilateral_params_t *)p1;
dt_iop_bilateral_data_t *d = (dt_iop_bilateral_data_t *)piece->data;
d->sigma[0] = p->radius;
d->sigma[1] = p->radius;
d->sigma[2] = p->red;
d->sigma[3] = p->green;
d->sigma[4] = p->blue;
}
void init_pipe(dt_iop_module_t *self,
dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
piece->data = malloc(sizeof(dt_iop_bilateral_data_t));
}
void cleanup_pipe(dt_iop_module_t *self,
dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
free(piece->data);
piece->data = NULL;
}
void tiling_callback(dt_iop_module_t *self,
dt_dev_pixelpipe_iop_t *piece,
const dt_iop_roi_t *roi_in,
const dt_iop_roi_t *roi_out,
dt_develop_tiling_t *tiling)
{
dt_iop_bilateral_data_t *data = (dt_iop_bilateral_data_t *)piece->data;
float sigma[5];
_compute_sigmas(sigma, data, roi_in->scale, piece->iscale);
const int prad = (int)(3.0f * fmaxf(sigma[0], sigma[1]) + 1.0f);
const int rad = MIN(prad, MIN(roi_out->width, roi_out->height) - 2 * prad);
if(rad <= MAX_DIRECT_STAMP_RADIUS)
tiling->factor = 2.0f; // direct stamp, no intermediate buffers used
else
{
// permutohedral needs LOTS of memory
// start with the fixed memory requirements
tiling->factor = 2.0f /*input+output*/ + 52.0f/16.0f /*52 bytes per pixel for
ReplayEntry array*/;
// now try to estimate the variable needs for the hashtable based
// on the current parameters
size_t npixels = (size_t)roi_out->height * roi_out->width;
size_t grid_points = (roi_out->height/sigma[0]) * (roi_out->width/sigma[1]) / sigma[2] / sigma[3] / sigma[4];
size_t hash_bytes = PermutohedralLattice<5, 4>::estimatedBytes(grid_points, npixels);
tiling->factor += (hash_bytes / (16.0f*npixels));
// the OpenCL lattice: two slot words per estimated entry and twice as
// many slots, three key words and two float4 values per entry
const size_t entries = PermutohedralLattice<5, 4>::estimatedHashEntries(grid_points, npixels);
tiling->factor_cl = 2.0f + (entries * (2 * 8 + 12 + 32)) / (16.0f * npixels);
dt_print(DT_DEBUG_MEMORY,
"[bilateral tiling requirements] "
"tiling factor=%f, npixels=%lu, estimated hashbytes=%lu",
tiling->factor, npixels, hash_bytes);
}
tiling->overhead = 0;
tiling->overlap = rad;
tiling->align = 1;
tiling->maxbuf = 1.0f;
}
void init_global(dt_iop_module_so_t *self)
{
const int program = 50; // permutohedral.cl, from programs.conf
dt_iop_bilateral_global_data_t *gd =
(dt_iop_bilateral_global_data_t *)malloc(sizeof(dt_iop_bilateral_global_data_t));
self->data = gd;
gd->kernel_insert = dt_opencl_create_kernel(program, "permutohedral_insert");
gd->kernel_splat = dt_opencl_create_kernel(program, "permutohedral_splat");
gd->kernel_blur = dt_opencl_create_kernel(program, "permutohedral_blur");
gd->kernel_slice = dt_opencl_create_kernel(program, "permutohedral_slice");
gd->kernel_direct = dt_opencl_create_kernel(program, "bilateral_direct");
}
void cleanup_global(dt_iop_module_so_t *self)
{
dt_iop_bilateral_global_data_t *gd = (dt_iop_bilateral_global_data_t *)self->data;
dt_opencl_free_kernel(gd->kernel_insert);
dt_opencl_free_kernel(gd->kernel_splat);
dt_opencl_free_kernel(gd->kernel_blur);
dt_opencl_free_kernel(gd->kernel_slice);
dt_opencl_free_kernel(gd->kernel_direct);
free(self->data);
self->data = NULL;
}
void gui_init(dt_iop_module_t *self)
{
dt_iop_bilateral_gui_data_t *g = IOP_GUI_ALLOC(bilateral);
g->radius = dt_bauhaus_slider_from_params(self, N_("radius"));
gtk_widget_set_tooltip_text(g->radius, _("spatial extent of the gaussian"));
dt_bauhaus_slider_set_soft_range(g->radius, 1.0, 30.0);
g->red = dt_bauhaus_slider_from_params(self, N_("red"));
gtk_widget_set_tooltip_text(g->red, _("how much to blur red"));
dt_bauhaus_slider_set_soft_max(g->red, 0.1);
dt_bauhaus_slider_set_digits(g->red, 4);
g->green = dt_bauhaus_slider_from_params(self, N_("green"));
gtk_widget_set_tooltip_text(g->green, _("how much to blur green"));
dt_bauhaus_slider_set_soft_max(g->green, 0.1);
dt_bauhaus_slider_set_digits(g->green, 4);
g->blue = dt_bauhaus_slider_from_params(self, N_("blue"));
gtk_widget_set_tooltip_text(g->blue, _("how much to blur blue"));
dt_bauhaus_slider_set_soft_max(g->blue, 0.1);
dt_bauhaus_slider_set_digits(g->blue, 4);
}
G_END_DECLS
// clang-format off
// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on