Add reading pfm files as rastermasks to segment maps

jenshannoschwalm · jenshannoschwalm · commit 8087365e848d · 2025-04-25T19:10:22.000+02:00
Had been requested a few times, one was #12551 1. In preferences we have a root folder containing such mask pfm files. 2. The segment map module gets a "mask from file" mode. There we have a button to select the file and besides that a menu offering the files found there (we have the same in luts). Just *.pfm files are supported, depending on being gray or rgb we offer one or three segment maps afterwards.
diff --git a/data/darktableconfig.xml.in b/data/darktableconfig.xml.in
@@ -3500,6 +3500,13 @@
     <shortdescription>LUT 3D root folder</shortdescription>
     <longdescription>this folder (and sub-folders) contains LUT files used by LUT 3D module. (restart required)</longdescription>
   </dtconfig>
+  <dtconfig prefs="processing" section="general" restart="true">
+    <name>plugins/darkroom/segments/def_path</name>
+    <type>dir</type>
+    <default>$(home)</default>
+    <shortdescription>image masks root folder</shortdescription>
+    <longdescription>this folder (and sub-folders) contains mask pfm files used by segment maps module. (restart required)</longdescription>
+  </dtconfig>
   <dtconfig prefs="processing" section="general">
     <name>plugins/darkroom/workflow</name>
     <type>
diff --git a/src/iop/rastermapping/filemap.c b/src/iop/rastermapping/filemap.c
@@ -0,0 +1,257 @@
+/*
+    This file is part of darktable,
+    Copyright (C) 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/>.
+*/
+
+static void _filemap_segment(dt_segmentation_t *seg, char *filename)
+{
+  /* basically copy&paste from imageio_pfm.c
+     inspect that code for details
+  */
+  float *readbuf = NULL;
+  if(!filename || filename[0] == 0) return;
+  FILE *f = g_fopen(filename, "r");
+  if(f == NULL) goto error;
+
+  seg->threshold = 32;
+  int ret = 0;
+  float scale_factor;
+  char head[2] = { 'X', 'X' };
+
+  ret = fscanf(f, "%c%c\n", head, head + 1);
+  if(ret != 2 || head[0] != 'P') goto error;
+
+  if(head[1] == 'F')        seg->segments = 3;
+  else if(head[1] == 'f')   seg->segments = 1;
+  else goto error;
+
+  int read_byte;
+  gboolean made_by_photoshop = TRUE;
+  for(;;)
+  {
+    read_byte = fgetc(f);
+    if((read_byte == '\n') || (read_byte == EOF))
+      break;
+    if(read_byte < '0')          // easy way to match all whitespaces
+    {
+      made_by_photoshop = FALSE; // if present, the file is not saved by Photoshop
+      break;
+    }
+  }
+  fseek(f, 3, SEEK_SET);
+
+  char width_string[10] = { 0 };
+  char height_string[10] = { 0 };
+  char scale_factor_string[64] = { 0 };
+  ret = fscanf(f, "%9s %9s %63s%*[^\n]", width_string, height_string, scale_factor_string);
+  if(ret != 3) goto error;
+
+  seg->width = strtol(width_string, NULL, 0);
+  seg->height = strtol(height_string, NULL, 0);
+  scale_factor = g_ascii_strtod(scale_factor_string, NULL);
+
+  if(seg->width <= 0 || seg->height <= 0) goto error;
+
+  ret = fread(&ret, sizeof(char), 1, f);
+  if(ret != 1) goto error;
+
+  int swap_byte_order = (scale_factor >= 0.0) ^ (G_BYTE_ORDER == G_BIG_ENDIAN);
+  const size_t npixels = (size_t)seg->width * seg->height;
+
+  readbuf = dt_alloc_align_float(npixels * 4);
+  if(!readbuf) goto error;
+  for(int i = 0; i < seg->segments; i++)
+    seg->map[i] = dt_calloc_align_type(uint8_t, (size_t)seg->width * seg->height);
+
+  union { float as_float; guint32 as_int; } value;
+
+  if(seg->segments == 3)
+  {
+    ret = fread(readbuf, 3 * sizeof(float), npixels, f);
+    size_t target_row = 0;
+
+    DT_OMP_FOR(collapse(2))
+    for(size_t row = 0; row < seg->height; row++)
+    {
+      for(size_t column = 0; column < seg->width; column++)
+      {
+        if(made_by_photoshop) target_row = row;
+        else target_row = seg->height - 1 - row;
+
+        for_three_channels(c)
+        {
+          value.as_float = readbuf[3 * (target_row * seg->width + column) + c];
+          if(swap_byte_order) value.as_int = GUINT32_SWAP_LE_BE(value.as_int);
+
+          if(seg->map[c])
+            seg->map[c][row*seg->width + column] = CLIP(value.as_float) * 255.0f;
+        }
+      }
+    }
+  }
+  else
+  {
+    ret = fread(readbuf, sizeof(float), npixels, f);
+    size_t target_row = 0;
+
+    DT_OMP_FOR(collapse(2))
+    for(size_t row = 0; row < seg->height; row++)
+    {
+      for(size_t column = 0; column < seg->width; column++)
+      {
+        if(made_by_photoshop) target_row = row;
+        else target_row = seg->height - 1 - row;
+        value.as_float = readbuf[target_row * seg->width + column];
+        if(swap_byte_order) value.as_int = GUINT32_SWAP_LE_BE(value.as_int);
+
+        if(seg->map[0])
+            seg->map[0][row*seg->width + column] = CLIP(value.as_float) * 255.0f;
+      }
+    }
+  }
+
+  fclose(f);
+  dt_free_align(readbuf);
+
+  dt_print(DT_DEBUG_PIPE, "file='%s' %d map segments %dx%d provided hash=%"PRIx64,
+   filename, seg->segments, seg->width, seg->height, seg->hash);
+  dt_control_log(_("%d filemap segments %dx%d provided"), seg->segments, seg->width, seg->height);
+  return;
+
+error:
+  dt_print(DT_DEBUG_ALWAYS, "can't read image map file '%s'", filename ? filename : "???");
+  dt_control_log(_("can't read image map file '%s'"), filename ? filename : "???");
+  if(f) fclose(f);
+
+  dt_free_align(readbuf);
+  for(int i = 0; i < seg->segments; i++) dt_free_align(seg->map[i]);
+  seg->width = seg->height = seg->segments = 0;
+}
+
+static int _check_extension(const struct dirent *namestruct)
+{
+  const char *filename = namestruct->d_name;
+  int res = 0;
+  if(!filename || !filename[0]) return res;
+  char *p = g_strrstr(filename,".");
+  if(!p) return res;
+  char *fext = g_ascii_strdown(g_strdup(p), -1);
+  if(!g_strcmp0(fext, ".pfm")) res = 1;
+  g_free(fext);
+  return res;
+}
+
+static void _update_filepath(dt_iop_module_t *self)
+{
+  dt_iop_segmap_gui_data_t *g = self->gui_data;
+  dt_iop_segmap_params_t *p = self->params;
+  if(!p->path[0] || !p->file[0])
+  {
+    dt_bauhaus_combobox_clear(g->file);
+    return;
+  }
+
+  if(!dt_bauhaus_combobox_set_from_text(g->file, p->file))
+  {
+    struct dirent **entries;
+    const int numentries = scandir(p->path, &entries, _check_extension, alphasort);
+    dt_bauhaus_combobox_clear(g->file);
+
+    for(int i = 0; i < numentries; i++)
+    {
+      const char *file = entries[i]->d_name;
+      dt_bauhaus_combobox_add_aligned(g->file, file, DT_BAUHAUS_COMBOBOX_ALIGN_LEFT);
+      free(entries[i]);
+    }
+    if(numentries != -1) free(entries);
+
+    if(!dt_bauhaus_combobox_set_from_text(g->file, p->file))
+    { // file may have disappeared - show it
+      char *invalidfilepath = g_strconcat(" ??? ", p->file, NULL);
+      dt_bauhaus_combobox_add_aligned(g->file, invalidfilepath, DT_BAUHAUS_COMBOBOX_ALIGN_LEFT);
+      dt_bauhaus_combobox_set_from_text(g->file, invalidfilepath);
+      g_free(invalidfilepath);
+    }
+  }
+}
+
+static void _fbutton_clicked(GtkWidget *widget, dt_iop_module_t *self)
+{
+  dt_iop_segmap_gui_data_t *g = self->gui_data;
+  dt_iop_segmap_params_t *p = self->params;
+
+  gchar *mfolder = dt_conf_get_string("plugins/darkroom/segments/def_path");
+  if(strlen(mfolder) == 0)
+  {
+    dt_print(DT_DEBUG_ALWAYS, "segment masks root folder not defined");
+    dt_control_log(_("segment masks root folder not defined"));
+    g_free(mfolder);
+    return;
+  }
+
+  GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
+  GtkFileChooserNative *filechooser = gtk_file_chooser_native_new(
+        _("select segment mask file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN,
+        _("_select"), _("_cancel"));
+  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), FALSE);
+  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), mfolder);
+  GtkFileFilter *filter = GTK_FILE_FILTER(gtk_file_filter_new());
+  // only pfm files yet supported
+  gtk_file_filter_add_pattern(filter, "*.pfm");
+  gtk_file_filter_add_pattern(filter, "*.PFM");
+  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
+  gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(filechooser), filter);
+
+  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);
+      const int rplen = strlen(relativepath);
+      memcpy(p->path, relativepath, rplen);
+      p->path[rplen] = '\0';
+      g_free(relativepath);
+
+      const int flen = strlen(filepath) - rplen - 1;
+      memcpy(p->file, filepath + rplen + 1, flen);
+      p->file[flen] = '\0';
+
+      _update_filepath(self);
+      dt_dev_add_history_item(darktable.develop, self, FALSE);
+    }
+    else
+    {
+      dt_print(DT_DEBUG_ALWAYS, "selected file not within masks root folder");
+      dt_control_log(_("selected file not within masks root folder"));
+    }
+    g_free(filepath);
+    gtk_widget_set_sensitive(g->file, p->path[0] && p->file[0]);
+  }
+  g_free(mfolder);
+  g_object_unref(filechooser);
+}
+
+static void _file_callback(GtkWidget *widget, dt_iop_module_t *self)
+{
+  dt_iop_segmap_params_t *p = self->params;
+  const gchar *select = dt_bauhaus_combobox_get_text(widget);
+  g_strlcpy(p->file, select, sizeof(p->file));
+  dt_dev_add_history_item(darktable.develop, self, FALSE);
+}
+
diff --git a/src/iop/rastermapping/variance.c b/src/iop/rastermapping/variance.c
@@ -0,0 +1,97 @@
+/*
+    This file is part of darktable,
+    Copyright (C) 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/>.
+*/
+
+static void _variance_segment(float *in,
+                              dt_segmentation_t *seg,
+                              const int depth,
+                              const int level,
+                              const dt_iop_roi_t *roi)
+{
+  /*  For many algorithms we might want to scale down for performance reasons, in addition
+      to that we might require some blurring or other preprocessing.
+      As the stored uint8_t maps are later bilinear interpolated when inserted into the pipe
+      we can effectively choose any size/ratio for the maps.
+  */
+  const int width = roi->width / 2;
+  const int height = roi->height / 2;
+  float *rgb = dt_iop_image_alloc(width, height, 4);
+  if(!rgb)
+  {
+    dt_print(DT_DEBUG_ALWAYS, "can't provide variance segments because of low memory");
+    dt_control_log(_("can't provide variance segments because of low memory"));
+    return;
+  }
+
+  interpolate_bilinear(in, roi->width, roi->height, rgb, width, height, 4);
+  seg->postprocess = NULL;
+  seg->width = width;
+  seg->height = height;
+  seg->segments = 3;  // for many algorithms the number of presented segments will depend on depth
+  seg->threshold = 4;
+  for(int i = 0; i < seg->segments; i++)
+    seg->map[i] = dt_calloc_align_type(uint8_t, (size_t)width * height);
+
+  const int r = depth+1;
+  const int limit = r * r + 1;
+  const float power = 0.4f + 0.025f * level;
+
+  DT_OMP_FOR(collapse(2))
+  for(ssize_t row = 0; row < height; row++)
+  {
+    for(ssize_t col = 0; col < width; col++)
+    {
+      float pix = 0.0f; // count the pixels inside the circle
+      dt_aligned_pixel_t av = { 0.0f, 0.0f, 0.0f, 0.0f };
+      for(int y = MAX(0, row-r); y < MIN(height, row+r+1); y++)
+      {
+        for(int x = MAX(0, col-r); x < MIN(width, col+r+1); x++)
+        {
+          const int dx = x - col;
+          const int dy = y - row;
+          if((dx*dx + dy*dy) <= limit)
+          {
+            for_each_channel(c) av[c] += rgb[(size_t)4*(y*width + x) + c];
+            pix += 1.0f;
+          }
+        }
+      }
+      for_each_channel(c) av[c] /= pix;
+
+      dt_aligned_pixel_t sv = { 0.0f, 0.0f, 0.0f, 0.0f };
+      for(int y = MAX(0, row-r); y < MIN(height, row+r+1); y++)
+      {
+        for(int x = MAX(0, col-r); x < MIN(width, col+r+1); x++)
+        {
+          const int dx = x - col;
+          const int dy = y - row;
+          if((dx*dx + dy*dy) <= limit)
+          {
+            for_each_channel(c) sv[c] += sqrf(rgb[(size_t)4*(y*width + x) + c] - av[c]);
+          }
+        }
+      }
+      for_each_channel(c) sv[c] /= (pix - 1.0f);
+
+      for_three_channels(c)
+        if(seg->map[c]) seg->map[c][row*width + col] = CLIP(3.0f * powf(sv[c], power)) * 255.0f;
+    }
+  }
+  dt_print(DT_DEBUG_PIPE, "%d variance segments %dx%d provided hash=%"PRIx64, seg->segments, seg->width, seg->height, seg->hash);
+  dt_control_log(_("%d variance segments %dx%d provided"), seg->segments, seg->width, seg->height);
+  dt_free_align(rgb);
+}
diff --git a/src/iop/rastermaps.c b/src/iop/rastermaps.c
