src/iop/rasterfile.c
Rama master · réplica de lectura del repositorio original.
/*
This file is part of darktable,
Copyright (C) 2025-2026 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/>.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <math.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "bauhaus/bauhaus.h"
#include "develop/tiling.h"
#include "develop/develop.h"
#include "develop/imageop.h"
#include "develop/imageop_gui.h"
#include "develop/imageop_math.h"
#include "common/interpolation.h"
#include "common/fast_guided_filter.h"
#include "common/dtdata.h"
#include "common/pfm.h"
#include "common/ras2vect.h"
#include "common/utility.h"
#include "imageio/imageio_png.h"
#include "gui/accelerators.h"
#include "gui/gtk.h"
#ifdef _OPENMP
#include <omp.h>
#endif
#define SET_THRESHOLD 0.6f
DT_MODULE_INTROSPECTION(2, dt_iop_rasterfile_params_t)
typedef enum dt_iop_rasterfile_mode_t
{
DT_RASTERFILE_MODE_ALL = 7, // $DESCRIPTION: "all RGB channels"
DT_RASTERFILE_MODE_RED = 1, // $DESCRIPTION: "only red"
DT_RASTERFILE_MODE_GREEN = 2, // $DESCRIPTION: "only green"
DT_RASTERFILE_MODE_BLUE = 4, // $DESCRIPTION: "only blue"
DT_RASTERFILE_MODE_REDGREEN = DT_RASTERFILE_MODE_RED | DT_RASTERFILE_MODE_GREEN, // $DESCRIPTION: "red and green"
DT_RASTERFILE_MODE_REDBLUE = DT_RASTERFILE_MODE_RED | DT_RASTERFILE_MODE_BLUE, // $DESCRIPTION: "red and blue"
DT_RASTERFILE_MODE_GREENBLUE = DT_RASTERFILE_MODE_GREEN | DT_RASTERFILE_MODE_BLUE, // $DESCRIPTION: "green and blue"
} dt_iop_rasterfile_mode_t;
#define RASTERFILE_MAXFILE 2048
typedef struct dt_iop_rasterfile_params_t
{
dt_iop_rasterfile_mode_t mode; // $DEFAULT: DT_RASTERFILE_MODE_ALL $DESCRIPTION: "mode"
// v1: a file in the raster mask root folder. still honored when set and
// no sidecar entry is referenced
char path[RASTERFILE_MAXFILE];
char file[RASTERFILE_MAXFILE];
// v2: an entry in the image's .dtdata sidecar, the fields of
// dt_dtdata_ref_t laid out inline so introspection can see them
char entry[DT_DTDATA_ENTRY_LEN];
int entry_kind;
int entry_origin;
int entry_width;
int entry_height;
int entry_bpc;
char entry_producer[DT_DTDATA_PRODUCER_LEN];
} dt_iop_rasterfile_params_t;
typedef struct dt_iop_rasterfile_data_t
{
dt_iop_rasterfile_mode_t mode;
char filepath[PATH_MAX];
dt_dtdata_ref_t ref;
} dt_iop_rasterfile_data_t;
typedef struct dt_rasterfile_cache_t
{
dt_pthread_mutex_t lock; // all access to cache data MUST be done in mutex locked state !
volatile dt_hash_t hash; // as the hash is shared between threads make sure it's actually read from mem
int width, height;
float *volatile mask;
} dt_rasterfile_cache_t;
const char *name()
{
return _("external raster masks");
}
const char *aliases()
{
return _("raster|mask");
}
const char **description(dt_iop_module_t *self)
{
return dt_iop_set_description(self,
_("read PFM/PNG files recorded for use as raster masks"),
_("corrective or creative"),
_("linear, raw, scene-referred"),
_("linear, raw"),
_("linear, raw, scene-referred"));
}
int default_group()
{
return IOP_GROUP_BASIC | IOP_GROUP_TECHNICAL;
}
int flags()
{
return IOP_FLAGS_WRITE_RASTER;
}
dt_iop_colorspace_type_t default_colorspace(dt_iop_module_t *self,
dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
return (pipe && !dt_image_is_raw(&pipe->image)) ? IOP_CS_RGB : IOP_CS_RAW;
}
typedef struct dt_iop_rasterfile_gui_data_t
{
GtkWidget *mode;
GtkWidget *import;
GtkWidget *info;
GtkWidget *vectorize;
} dt_iop_rasterfile_gui_data_t;
int legacy_params(dt_iop_module_t *self,
const void *const old_params,
const int old_version,
void **new_params,
int32_t *new_params_size,
int *new_version)
{
typedef struct dt_iop_rasterfile_params_v2_t
{
dt_iop_rasterfile_mode_t mode;
char path[RASTERFILE_MAXFILE];
char file[RASTERFILE_MAXFILE];
char entry[DT_DTDATA_ENTRY_LEN];
int entry_kind;
int entry_origin;
int entry_width;
int entry_height;
int entry_bpc;
char entry_producer[DT_DTDATA_PRODUCER_LEN];
} dt_iop_rasterfile_params_v2_t;
if(old_version == 1)
{
typedef struct dt_iop_rasterfile_params_v1_t
{
dt_iop_rasterfile_mode_t mode;
char path[RASTERFILE_MAXFILE];
char file[RASTERFILE_MAXFILE];
} dt_iop_rasterfile_params_v1_t;
const dt_iop_rasterfile_params_v1_t *o = old_params;
dt_iop_rasterfile_params_v2_t *n = calloc(1, sizeof(dt_iop_rasterfile_params_v2_t));
memcpy(n, o, sizeof(dt_iop_rasterfile_params_v1_t));
*new_params = n;
*new_params_size = sizeof(dt_iop_rasterfile_params_v2_t);
*new_version = 2;
return 0;
}
return 1;
}
static gboolean _has_source(const dt_iop_rasterfile_params_t *p)
{
return p->entry[0] || (p->path[0] && p->file[0]);
}
static void _params_from_ref(dt_iop_rasterfile_params_t *p, const dt_dtdata_ref_t *ref)
{
g_strlcpy(p->entry, ref->entry, sizeof(p->entry));
p->entry_kind = ref->kind;
p->entry_origin = ref->origin;
p->entry_width = ref->width;
p->entry_height = ref->height;
p->entry_bpc = ref->bpc;
g_strlcpy(p->entry_producer, ref->producer, sizeof(p->entry_producer));
// a sidecar entry replaces a folder file
memset(p->path, 0, sizeof(p->path));
memset(p->file, 0, sizeof(p->file));
}
static void _ref_from_params(const dt_iop_rasterfile_params_t *p, dt_dtdata_ref_t *ref)
{
memset(ref, 0, sizeof(*ref));
g_strlcpy(ref->entry, p->entry, sizeof(ref->entry));
ref->kind = p->entry_kind;
ref->origin = p->entry_origin;
ref->width = p->entry_width;
ref->height = p->entry_height;
ref->bpc = p->entry_bpc;
g_strlcpy(ref->producer, p->entry_producer, sizeof(ref->producer));
}
void modify_roi_in(dt_iop_module_t *self,
dt_dev_pixelpipe_iop_t *piece,
const dt_iop_roi_t *const roi_out,
dt_iop_roi_t *roi_in)
{
*roi_in = *roi_out;
roi_in->scale = 1.0f;
roi_in->x = 0;
roi_in->y = 0;
roi_in->width = piece->buf_in.width;
roi_in->height = piece->buf_in.height;
}
static void _vectorize_button_clicked(GtkWidget *widget,
dt_iop_module_t *self)
{
dt_develop_t *dev = darktable.develop;
dt_rasterfile_cache_t *cd = self->data;
dt_pthread_mutex_lock(&cd->lock);
const dt_image_t *const image = &(self->dev->image_storage);
GList *forms = ras2forms(cd->mask, cd->width, cd->height, image,
SET_THRESHOLD, 0, 0.0, NULL);
dt_pthread_mutex_unlock(&cd->lock);
const int nbform = g_list_length(forms);
if(nbform == 0)
{
dt_control_log(_("no mask extracted from the raster file\n"
"make sure the masks have proper contrast"));
}
else
{
dt_control_log(ngettext("%d mask extracted from the raster file",
"%d masks extracted from the raster file", nbform), nbform);
// add all forms into the mask manager
dt_masks_register_forms(dev, self, forms);
}
}
// sbpc, when given, is the depth worth storing: 16 for a 16-bit PNG or a
// float PFM, 8 otherwise
static float *_read_rasterfile(char *filename,
const dt_iop_rasterfile_mode_t mode,
int *swidth,
int *sheight,
int *sbpc)
{
*swidth = 0;
*sheight = 0;
if(sbpc) *sbpc = 8;
if(!filename || filename[0] == 0) return NULL;
const char *extension = g_strrstr(filename, ".");
const gboolean is_png = extension && !g_ascii_strcasecmp(extension, ".png");
if(is_png)
{
dt_imageio_png_t png;
if(!dt_imageio_png_read_header(filename, &png))
{
dt_print(DT_DEBUG_ALWAYS, "failed to read PNG header from '%s'", filename ? filename : "???");
dt_control_log(_("can't read raster mask file '%s'"), filename ? filename : "???");
return NULL;
}
const size_t rowbytes = png_get_rowbytes(png.png_ptr, png.info_ptr);
uint8_t *buf = dt_alloc_aligned((size_t)png.height * rowbytes);
if(!buf)
{
fclose(png.f);
png_destroy_read_struct(&png.png_ptr, &png.info_ptr, NULL);
dt_print(DT_DEBUG_ALWAYS, "can't read raster mask file '%s'", filename ? filename : "???");
dt_control_log(_("can't read raster mask file '%s'"), filename ? filename : "???");
return NULL;
}
if(!dt_imageio_png_read_image(&png, buf))
{
dt_free_align(buf);
dt_print(DT_DEBUG_ALWAYS, "can't read raster mask file '%s'", filename ? filename : "???");
dt_control_log(_("can't read raster mask file '%s'"), filename ? filename : "???");
return NULL;
}
const int width = png.width;
const int height = png.height;
float *mask = dt_iop_image_alloc(width, height, 1);
if(!mask)
{
dt_free_align(buf);
dt_print(DT_DEBUG_ALWAYS, "can't read raster mask file '%s'", filename ? filename : "???");
dt_control_log(_("can't read raster mask file '%s'"), filename ? filename : "???");
return NULL;
}
if(png.bit_depth < 16)
{
const float normalizer = 1.0f / 255.0f;
DT_OMP_FOR()
for(size_t k = 0; k < (size_t)width * height; k++)
{
const size_t base = 3 * k;
float val = 0.0f;
if(mode & DT_RASTERFILE_MODE_RED) val = MAX(val, buf[base] * normalizer);
if(mode & DT_RASTERFILE_MODE_GREEN) val = MAX(val, buf[base + 1] * normalizer);
if(mode & DT_RASTERFILE_MODE_BLUE) val = MAX(val, buf[base + 2] * normalizer);
mask[k] = CLIP(val);
}
}
else
{
const float normalizer = 1.0f / 65535.0f;
DT_OMP_FOR()
for(size_t k = 0; k < (size_t)width * height; k++)
{
const size_t base = 6 * k;
const float red = (buf[base] * 256.0f + buf[base + 1]) * normalizer;
const float green = (buf[base + 2] * 256.0f + buf[base + 3]) * normalizer;
const float blue = (buf[base + 4] * 256.0f + buf[base + 5]) * normalizer;
float val = 0.0f;
if(mode & DT_RASTERFILE_MODE_RED) val = MAX(val, red);
if(mode & DT_RASTERFILE_MODE_GREEN) val = MAX(val, green);
if(mode & DT_RASTERFILE_MODE_BLUE) val = MAX(val, blue);
mask[k] = CLIP(val);
}
}
dt_free_align(buf);
*swidth = width;
*sheight = height;
if(sbpc) *sbpc = png.bit_depth == 16 ? 16 : 8;
return mask;
}
int width, height, channels, error = 0;
float *image = dt_read_pfm(filename, &error, &width, &height, &channels, 3);
float *mask = dt_iop_image_alloc(width, height, 1);
if(!image || !mask)
{
dt_print(DT_DEBUG_ALWAYS,
"can't read raster mask file '%s'", filename ? filename : "???");
dt_control_log(_("can't read raster mask file '%s'"), filename ? filename : "???");
dt_free_align(image);
dt_free_align(mask);
return NULL;
}
DT_OMP_FOR()
for(size_t k = 0; k < (size_t)width * height; k++)
{
float val = 0.0f;
if(mode & DT_RASTERFILE_MODE_RED) val = MAX(val, image[k*3]);
if(mode & DT_RASTERFILE_MODE_GREEN) val = MAX(val, image[k*3+1]);
if(mode & DT_RASTERFILE_MODE_BLUE) val = MAX(val, image[k*3+2]);
mask[k] = CLIP(val);
}
*swidth = width;
*sheight = height;
if(sbpc) *sbpc = 16;
dt_free_align(image);
return mask;
}
// what this instance references: its sidecar entry, the folder file of a
// v1 edit, or nothing
static void _update_info(dt_iop_module_t *self)
{
dt_iop_rasterfile_gui_data_t *g = self->gui_data;
dt_iop_rasterfile_params_t *p = self->params;
gchar *text = NULL;
if(p->entry[0])
{
const char *dash = strchr(p->entry, '-');
GList *entries = self->dev ? dt_dtdata_list_entries(self->dev->image_storage.id) : NULL;
const gboolean present = g_list_find_custom(entries, p->entry, (GCompareFunc)g_strcmp0) != NULL;
g_list_free_full(entries, g_free);
if(p->entry_width > 0 && p->entry_height > 0)
text = g_strdup_printf(_("mask %.8s, %d x %d"), dash ? dash + 1 : p->entry,
p->entry_width, p->entry_height);
else
text = g_strdup_printf(_("mask %.8s"), dash ? dash + 1 : p->entry);
if(!present)
{
gchar *full = g_strdup_printf("%s (%s)", text, _("missing from sidecar"));
g_free(text);
text = full;
}
}
else if(p->path[0] && p->file[0])
text = g_strdup_printf(_("folder: %s"), p->file);
else
text = g_strdup(_("no mask imported"));
gtk_label_set_text(GTK_LABEL(g->info), text);
g_free(text);
gtk_widget_set_sensitive(g->vectorize, _has_source(p));
}
static GtkFileChooserNative *_mask_file_chooser(const char *folder)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkFileChooserNative *filechooser = gtk_file_chooser_native_new(
_("select raster mask file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN,
_("_select"), _("_cancel"));
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), FALSE);
if(folder && *folder && g_file_test(folder, G_FILE_TEST_IS_DIR))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), folder);
GtkFileFilter *filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*.pfm");
gtk_file_filter_add_pattern(filter, "*.PFM");
gtk_file_filter_add_pattern(filter, "*.png");
gtk_file_filter_add_pattern(filter, "*.PNG");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(filechooser), filter);
return filechooser;
}
// sidecars off: the previous behavior, a file inside the raster mask root
// folder referenced by its path
static void _select_folder_file(dt_iop_module_t *self)
{
dt_iop_rasterfile_params_t *p = self->params;
gchar *mfolder = dt_conf_get_string("plugins/darkroom/segments/def_path");
if(!mfolder || !*mfolder)
{
dt_control_log(_("raster mask files root folder not defined"));
g_free(mfolder);
return;
}
GtkFileChooserNative *filechooser = _mask_file_chooser(mfolder);
if(gtk_native_dialog_run(GTK_NATIVE_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
gchar *filepath = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
const gboolean within = (strlen(filepath) > strlen(mfolder))
&& (memcmp(filepath, mfolder, strlen(mfolder)) == 0);
if(within)
{
char *relativepath = g_path_get_dirname(filepath);
dt_strlcpy_to_fixed(p->path, relativepath, sizeof(p->path));
g_free(relativepath);
char *bname = g_path_get_basename(filepath);
dt_strlcpy_to_fixed(p->file, bname, sizeof(p->file));
g_free(bname);
memset(p->entry, 0, sizeof(p->entry));
_update_info(self);
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
else
dt_control_log(_("selected file not within raster masks root folder"));
g_free(filepath);
}
g_free(mfolder);
g_object_unref(filechooser);
}
// sidecars on: read any PNG or PFM, reduce it to gray with the channel
// mode, and store it as an entry of the image's sidecar
static void _import_file(dt_iop_module_t *self)
{
dt_iop_rasterfile_params_t *p = self->params;
const dt_imgid_t imgid = self->dev->image_storage.id;
if(!dt_is_valid_imgid(imgid)) return;
gchar *mfolder = dt_conf_get_string("plugins/darkroom/segments/def_path");
GtkFileChooserNative *filechooser = _mask_file_chooser(mfolder);
g_free(mfolder);
if(gtk_native_dialog_run(GTK_NATIVE_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
gchar *filepath = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
int width = 0, height = 0, bpc = 8;
float *mask = _read_rasterfile(filepath, p->mode, &width, &height, &bpc);
if(mask)
{
dt_dtdata_ref_t ref;
if(dt_dtdata_write_gray(imgid, DT_DTDATA_KIND_MASK, DT_DTDATA_ORIGIN_AUTHORITATIVE,
"rasterfile import", mask, width, height, bpc, &ref))
{
_params_from_ref(p, &ref);
_update_info(self);
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
else
dt_control_log(_("cannot write the raster mask sidecar for this image"));
dt_free_align(mask);
}
g_free(filepath);
}
g_object_unref(filechooser);
}
static void _import_clicked(GtkWidget *widget, dt_iop_module_t *self)
{
if(dt_dtdata_enabled())
_import_file(self);
else
_select_folder_file(self);
}
// the button does two different things depending on the sidecar setting,
// so say which before it is clicked
static void _update_import_tooltip(dt_iop_module_t *self)
{
dt_iop_rasterfile_gui_data_t *g = self->gui_data;
gtk_widget_set_tooltip_text
(g->import,
dt_dtdata_enabled()
? _("import a PNG or PFM file as a raster mask\n"
"it is stored in the image's .dtdata sidecar and travels with the image")
: _("select a PNG or PFM file from the raster mask root folder\n"
"sidecar files are disabled in preferences, so the mask is referenced by its path"));
}
static void _clear_cache(dt_rasterfile_cache_t *cache)
{
dt_free_align(cache->mask);
cache->mask = NULL;
cache->width = cache->height = 0;
cache->hash = DT_INVALID_HASH;
}
static inline dt_hash_t _get_cache_hash(dt_iop_module_t *self)
{
dt_hash_t hash = dt_hash(DT_INITHASH, self->params, self->params_size);
// not technically required but possibly reduces mem footprint
hash = dt_hash(hash,
&self->dev->image_storage.id,
sizeof(self->dev->image_storage.id));
return hash;
}
static float *_get_rasterfile_mask(dt_dev_pixelpipe_iop_t *piece,
const dt_iop_roi_t *const roi,
const dt_iop_roi_t *const roo)
{
dt_iop_module_t *self = piece->module;
dt_iop_rasterfile_data_t *d = piece->data;
dt_rasterfile_cache_t *cd = self->data;
float *res = NULL;
dt_pthread_mutex_lock(&cd->lock);
const dt_hash_t hash = _get_cache_hash(self);
if(hash != cd->hash)
{
_clear_cache(cd);
if(d->ref.entry[0])
{
dt_print(DT_DEBUG_PIPE, "read sidecar raster entry `%s'", d->ref.entry);
cd->mask = dt_dtdata_read_gray(self->dev->image_storage.id, &d->ref,
&cd->width, &cd->height);
}
else
{
dt_print(DT_DEBUG_PIPE,
"read image raster file `%s'", d->filepath);
cd->mask = _read_rasterfile(d->filepath, d->mode, &cd->width, &cd->height, NULL);
}
cd->hash = cd->mask ? hash : DT_INVALID_HASH;
dt_print(DT_DEBUG_PIPE,
"got raster mask data %p %dx%d", cd->mask, cd->width, cd->height);
}
if(cd->mask)
{
const gboolean scale = cd->width != roi->width || cd->height != roi->height;
float *tmp = scale ? dt_iop_image_alloc(roi->width, roi->height, 1) : cd->mask;
if(tmp)
{
if(scale)
interpolate_bilinear(cd->mask, cd->width, cd->height, tmp,
roi->width, roi->height, 1);
res = dt_iop_image_alloc(roo->width, roo->height, 1);
if(res)
self->distort_mask(self, piece, tmp, res, roi, roo);
if(scale)
dt_free_align(tmp);
}
}
dt_pthread_mutex_unlock(&cd->lock);
return res;
}
#ifdef HAVE_OPENCL
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)
{
dt_dev_pixelpipe_t *pipe = piece->pipe;
const ssize_t ch = pipe->dsc.filters ? 1 : 4;
const gboolean fullpipe = dt_pipe_is_full(pipe);
const gboolean visual = fullpipe && dt_iop_has_focus(self);
const int devid = pipe->devid;
cl_int err = DT_OPENCL_PROCESS_CL;
if(visual) return err;
if(roi_out->scale != roi_in->scale && ch == 4)
err = dt_iop_clip_and_zoom_cl(devid, dev_out, dev_in, roi_out, roi_in);
else
{
const size_t iorigin[2] = { roi_out->x, roi_out->y };
const size_t region[2] = { roi_out->width, roi_out->height };
err = dt_opencl_enqueue_copy_image(devid, dev_in, dev_out, iorigin, CLIMG_ORIGIN, region);
}
if(dt_iop_is_raster_mask_used(piece->module, BLEND_RASTER_ID)
&& (err == CL_SUCCESS))
{
float *mask = _get_rasterfile_mask(piece, roi_in, roi_out);
if(mask)
dt_iop_piece_set_raster(piece, mask, roi_in, roi_out);
else
dt_iop_piece_clear_raster(piece, NULL);
}
else
dt_iop_piece_clear_raster(piece, NULL);
return err;
}
#endif // OpenCL
void init_pipe(dt_iop_module_t *self,
dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
piece->data = calloc(1, sizeof(dt_iop_rasterfile_data_t));
}
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)
{
const float *const in = (float *)ivoid;
float *const out = (float *)ovoid;
dt_dev_pixelpipe_t *pipe = piece->pipe;
const uint32_t filters = pipe->dsc.filters;
const ssize_t ch = filters ? 1 : 4;
if(roi_out->scale != roi_in->scale && ch == 4)
{
const dt_interpolation_t *itor = dt_interpolation_new(DT_INTERPOLATION_USERPREF_WARP);
dt_interpolation_resample(itor, out, roi_out, in, roi_in);
}
else
dt_iop_copy_image_roi(out, in, ch, roi_in, roi_out);
const gboolean fullpipe = dt_pipe_is_full(pipe);
const gboolean request = dt_iop_is_raster_mask_used(piece->module, BLEND_RASTER_ID);
const gboolean visual = fullpipe && dt_iop_has_focus(self);
float *mask = visual || request ? _get_rasterfile_mask(piece, roi_in, roi_out) : NULL;
if(visual)
{
pipe->mask_display = DT_DEV_PIXELPIPE_DISPLAY_PASSTHRU;
if(ch == 1)
{
// simple blur to remove CFA colors:
dt_box_mean(out, roi_out->height, roi_out->width, 1, 3, 2);
DT_OMP_FOR()
for(size_t k = 0; k < (size_t)roi_out->width * roi_out->height; k++)
out[k] =
0.2f
* CLAMPF(sqrtf(out[k]), 0.0f, 0.5f)
+ (mask ? mask[k] : 0.0f);
}
else
{
DT_OMP_FOR()
for(size_t k = 0; k < (size_t)roi_out->width * roi_out->height; k++)
{
const float val =
0.2f
* CLAMPF(sqrtf(0.33f * (out[4*k] + out[4*k+1]+ out[4*k+2])), 0.0f, 0.5f)
+ (mask ? mask[k] : 0.0f);
for_three_channels(m) out[4*k+m] = val;
}
}
}
if(request && mask)
dt_iop_piece_set_raster(piece, mask, roi_in, roi_out);
else
{
dt_iop_piece_clear_raster(piece, NULL);
dt_free_align(mask);
}
}
// lets the sidecar sweep see which entry a stored params blob references
static int _scan_params(const void *params,
const size_t size,
const int version,
char *entry,
const size_t len)
{
if(version == 1) return 0; // a folder file, nothing in the sidecar
if(version != 2 || size != sizeof(dt_iop_rasterfile_params_t)) return -1;
const dt_iop_rasterfile_params_t *p = params;
if(!p->entry[0]) return 0;
g_strlcpy(entry, p->entry, len);
return 1;
}
void init_global(dt_iop_module_so_t *self)
{
dt_dtdata_register_scanner(self->op, 1u << DT_DTDATA_KIND_MASK, _scan_params);
}
void commit_params(dt_iop_module_t *self,
dt_iop_params_t *p1,
dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
const dt_iop_rasterfile_params_t *p = (dt_iop_rasterfile_params_t *)p1;
dt_iop_rasterfile_data_t *d = piece->data;
d->mode = p->mode;
// stored params need not terminate the path or file name
gchar *path = g_strndup(p->path, sizeof(p->path));
gchar *file = g_strndup(p->file, sizeof(p->file));
gchar *fullpath = g_build_filename(path, file, NULL);
dt_strlcpy_to_fixed(d->filepath, fullpath, sizeof(d->filepath));
g_free(fullpath);
g_free(file);
g_free(path);
_ref_from_params(p, &d->ref);
}
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)
{
tiling->maxbuf = 1.0f;
tiling->align = 1;
tiling->overhead = 0;
tiling->factor = 2.0f;
}
void reload_defaults(dt_iop_module_t *self)
{
// we might be called from presets update infrastructure => there is
// no image
if(!self->dev || !dt_is_valid_imgid(self->dev->image_storage.id))
return;
self->default_enabled = FALSE;
dt_iop_rasterfile_params_t *dp = self->default_params;
memset(dp->path, 0, sizeof(dp->path));
memset(dp->file, 0, sizeof(dp->file));
}
void distort_mask(dt_iop_module_t *self,
dt_dev_pixelpipe_iop_t *piece,
const float *const in,
float *const out,
const dt_iop_roi_t *const roi_in,
const dt_iop_roi_t *const roi_out)
{
if(roi_out->scale != roi_in->scale)
{
const dt_interpolation_t *itor = dt_interpolation_new(DT_INTERPOLATION_USERPREF_WARP);
dt_interpolation_resample_mask(itor, out, roi_out, in, roi_in);
}
else
dt_iop_copy_image_roi(out, in, 1, roi_in, roi_out);
}
void gui_changed(dt_iop_module_t *self,
GtkWidget *w,
void *previous)
{
dt_iop_rasterfile_gui_data_t *g = self->gui_data;
dt_iop_rasterfile_params_t *p = self->params;
if(!w)
{
_update_info(self);
_update_import_tooltip(self);
}
if(!w)
{
dt_rasterfile_cache_t *cd = self->data;
dt_pthread_mutex_lock(&cd->lock);
const dt_hash_t hash = _get_cache_hash(self);
const gboolean other = hash != cd->hash;
if(other) _clear_cache(cd);
dt_pthread_mutex_unlock(&cd->lock);
if(other)
dt_dev_reprocess_center(self->dev, self->iop_order);
}
gtk_widget_set_sensitive(g->vectorize, _has_source(p));
}
void gui_update(dt_iop_module_t *self)
{
dt_iop_rasterfile_params_t *p = self->params;
// the GUI handlers read the stored path and file name as C strings
p->path[sizeof(p->path) - 1] = '\0';
p->file[sizeof(p->file) - 1] = '\0';
gui_changed(self, NULL, NULL);
}
void init(dt_iop_module_t *self)
{
dt_iop_default_init(self);
dt_iop_rasterfile_params_t *d = self->default_params;
memset(d->path, 0, sizeof(d->path));
memset(d->file, 0, sizeof(d->file));
/*
Implementation note and reminder:
Here we allocate per-module-instance memory shared by all pipes.
To be sure data are valid and access is safe we
a) ensure validity via a hash. Here it's just based on the
parameters of the module's instance in other situations we
might have to use the piece hash
b) **always** access any module->data within a mutex-locked state.
In this module the data do **not** depend on the using pipe. In
other cases, the pipe changing data according to a diffenrent hash
must make sure the other pipes get restarted afterwards.
*/
dt_rasterfile_cache_t *cd = calloc(1, sizeof(dt_rasterfile_cache_t));
cd->hash = DT_INVALID_HASH;
dt_pthread_mutex_init(&cd->lock);
cd->mask = NULL;
cd->width = cd->height = 0;
self->data = cd;
}
void cleanup(dt_iop_module_t *self)
{
dt_iop_default_cleanup(self);
dt_rasterfile_cache_t *cd = self->data;
_clear_cache(cd);
dt_pthread_mutex_destroy(&cd->lock);
free(cd);
self->data = NULL;
}
void gui_focus(dt_iop_module_t *self, gboolean in)
{
dt_dev_reprocess_center(self->dev, self->iop_order);
}
void gui_init(dt_iop_module_t *self)
{
dt_iop_rasterfile_gui_data_t *g = IOP_GUI_ALLOC(rasterfile);
g->mode = dt_bauhaus_combobox_from_params(self, "mode");
gtk_widget_set_tooltip_text
(g->mode,
_("select the RGB channels taken into account when a color file is imported"));
g->import = dtgtk_button_new_full(dtgtk_cairo_paint_directory, CPF_NONE, NULL,
&(dtgtk_button_config_t){
.clicked_cb = G_CALLBACK(_import_clicked),
.clicked_data = self,
});
gtk_widget_set_name(g->import, "non-flat");
g->info = dt_ui_label_new("");
gtk_label_set_ellipsize(GTK_LABEL(g->info), PANGO_ELLIPSIZE_MIDDLE);
gtk_widget_set_tooltip_text
(g->info,
_("the raster mask this instance uses\n"
"importing another file replaces it; masks no longer used by any\n"
"history item are removed from the sidecar when leaving the darkroom"));
// Vectorize button
g->vectorize = gtk_button_new_with_label(_("vectorize"));
gtk_widget_set_tooltip_text
(g->vectorize,
_("vectorize the current bitmap and create corresponding"
" path masks in the mask manager"));
g_signal_connect(g->vectorize, "clicked",
G_CALLBACK(_vectorize_button_clicked), self);
dt_gui_box_add(self->widget,
dt_gui_hbox(g->import, dt_gui_expand(g->info)),
g->vectorize);
}
#undef RASTERFILE_MAXFILE
// 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