waveform scope: add option for luma display

In waveform scope can now either show RGB channels or luma. When luma
option is on, make the RGB channel buttons insensitive.

Note that this is luma (Y') not relative luminance (Y). Until add an
option to display linearized RGB data, it doesn't make sense to show
linearized Y, not least as the jump from seeing non-linear RGB
channels to linearized relative luminance is disconcerting.

Calculate either RGB channels or luma waveform, not both. This makes
sure that RGB waveform calc is as fast as it was before luminance
calculation added. Luma calculation is ~15% faster than RGB
calculation. This does require reprocessing the pixelpipe when turn
on/off the luma option.

Future improvements could be:

- Add option to show linearized waveform (and rgb parade) data
- When linearized option is on, show luminance rather than luma
- Add option to show luma/luminance in addition to RGB channels in RGB
  parade mode
- Show luma/luminance in histogram

Also:

- Rename vs_prof parameter to profile in non-vectorscope _process()
  functions. The vs_prof name was a result of copying the name from
  vectorscope process.
- Update some comments and general tidying.

Author: dtorop

data/darktableconfig.xml.in

@@ -3362,6 +3362,13 @@
     <shortdescription/>
     <longdescription/>
   </dtconfig>
+  <dtconfig>
+    <name>plugins/darkroom/histogram/show_luma</name>
+    <type>bool</type>
+    <default>false</default>
+    <shortdescription/>
+    <longdescription/>
+  </dtconfig>
   <dtconfig>
     <name>plugins/darkroom/histogram/vectorscope/harmony_type</name>
     <type>

data/themes/darktable.css

@@ -745,6 +745,11 @@ dialog .sidebar row:selected:hover label,
   background-color: alpha(@graph_blue, 0.2);
 }
 
+#luma-channel-button
+{
+  background-color: alpha(white, 0.2);
+}
+
 /* set now them active state */
 #red-channel-button:checked
 {
@@ -761,6 +766,11 @@ dialog .sidebar row:selected:hover label,
   background-color: alpha(@graph_blue, 0.66);
 }
 
+#luma-channel-button:checked
+{
+  background-color: alpha(white, 0.66);
+}
+
 /* set now hover state */
 #red-channel-button:hover
 {
@@ -777,6 +787,27 @@ dialog .sidebar row:selected:hover label,
   background-color: alpha(@graph_blue, 0.5);
 }
 
+#luma-channel-button:hover
+{
+  background-color: alpha(white, 0.5);
+}
+
+/* inactive state */
+#red-channel-button:disabled
+{
+  background-color: alpha(@graph_red, 0.1);
+}
+
+#green-channel-button:disabled
+{
+  background-color: alpha(@graph_green, 0.1);
+}
+
+#blue-channel-button:disabled
+{
+  background-color: alpha(@graph_blue, 0.1);
+}
+
 /*------------------
   - Dialog windows -
   ------------------*/

src/libs/histogram.c

@@ -41,10 +41,11 @@ static void _lib_histogram_get_sector_angles(dt_lib_module_t *self,
                                              float *angles,
                                              int *n);
 
-static const gchar *rgb_names[DT_SCOPES_RGB_N] =
+static const gchar *channel_names[DT_SCOPES_CHANNEL_N] =
   { N_("red"),
     N_("green"),
-    N_("blue")
+    N_("blue"),
+    N_("luma")
   };
 
 const char *name(dt_lib_module_t *self)
@@ -442,7 +443,7 @@ static void _mode_toggle(GtkWidget *button, dt_scopes_t *s)
   lib_histogram_update_tooltip(s);
 
   dt_scopes_call(prior_mode, mode_leave);
-  gtk_widget_set_visible(s->button_box_rgb,
+  gtk_widget_set_visible(s->button_box_channels,
                          dt_scopes_func_exists(s->cur_mode, draw_scope_channels));
   dt_scopes_call(s->cur_mode, update_buttons);
   dt_scopes_call(s->cur_mode, mode_enter);
@@ -457,16 +458,23 @@ static void _mode_toggle(GtkWidget *button, dt_scopes_t *s)
 
 static void _channel_toggle(GtkWidget *button, dt_scopes_t *s)
 {
-  for(int i = 0; i < DT_SCOPES_RGB_N; i++)
-    if(s->channel_buttons[i] == button)
+  for(int i = 0; i < DT_SCOPES_CHANNEL_N; i++)
+    if(s->channel_btns[i] == button)
     {
       char conf[48];
       g_snprintf(conf, sizeof(conf),
-                 "plugins/darkroom/histogram/show_%s", rgb_names[i]);
+                 "plugins/darkroom/histogram/show_%s", channel_names[i]);
       s->channels[i]
         = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
       dt_conf_set_bool(conf, s->channels[i]);
-      dt_scopes_refresh(s);
+      if(i == DT_SCOPES_CHANNEL_LUMA)
+      {
+        for(int ch = 0; ch <= DT_SCOPES_CHANNEL_BLUE; ch++)
+          gtk_widget_set_sensitive(s->channel_btns[ch], !s->channels[i]);
+        dt_scopes_reprocess();
+      }
+      else
+        dt_scopes_refresh(s);
     }
 }
 
@@ -537,7 +545,7 @@ static void _eventbox_enter_notify_callback(GtkEventControllerMotion *controller
     if(s->cur_mode != &s->modes[i])
       dt_scopes_call(&s->modes[i], mode_leave);
   dt_scopes_call(s->cur_mode, mode_enter);
-  gtk_widget_set_visible(s->button_box_rgb,
+  gtk_widget_set_visible(s->button_box_channels,
                          dt_scopes_func_exists(s->cur_mode, draw_scope_channels));
   gtk_widget_show(s->button_box_left);
   gtk_widget_show(s->button_box_right);
@@ -675,12 +683,14 @@ void gui_init(dt_lib_module_t *self)
 
   dt_pthread_mutex_init(&s->lock, NULL);
 
-  s->channels[DT_SCOPES_RGB_RED]
+  s->channels[DT_SCOPES_CHANNEL_RED]
     = dt_conf_get_bool("plugins/darkroom/histogram/show_red");
-  s->channels[DT_SCOPES_RGB_GREEN]
+  s->channels[DT_SCOPES_CHANNEL_GREEN]
     = dt_conf_get_bool("plugins/darkroom/histogram/show_green");
-  s->channels[DT_SCOPES_RGB_BLUE]
+  s->channels[DT_SCOPES_CHANNEL_BLUE]
     = dt_conf_get_bool("plugins/darkroom/histogram/show_blue");
+  s->channels[DT_SCOPES_CHANNEL_LUMA]
+    = dt_conf_get_bool("plugins/darkroom/histogram/show_luma");
 
   // proxy functions and data so that pixelpipe or tether can
   // provide data for a histogram
@@ -804,28 +814,35 @@ void gui_init(dt_lib_module_t *self)
                        GDK_KEY_H, GDK_CONTROL_MASK | GDK_SHIFT_MASK);
 
   // RGB channel buttons
-  s->button_box_rgb = dt_gui_hbox();
-  gtk_widget_set_valign(s->button_box_rgb, GTK_ALIGN_CENTER);
-  gtk_widget_set_halign(s->button_box_rgb, GTK_ALIGN_CENTER);
-  // red/green/blue channel on/off
-  for(int i=DT_SCOPES_RGB_RED; i < DT_SCOPES_RGB_N; i++)
+  s->button_box_channels = dt_gui_hbox();
+  gtk_widget_set_valign(s->button_box_channels, GTK_ALIGN_CENTER);
+  gtk_widget_set_halign(s->button_box_channels, GTK_ALIGN_CENTER);
+  // red/green/blue/luma on/off
+  for(int i=DT_SCOPES_CHANNEL_RED; i < DT_SCOPES_CHANNEL_N; i++)
   {
-    g_autofree char *name = g_strdup_printf("%s-channel-button", rgb_names[i]);
-    g_autofree char *tip = g_strdup_printf(_("toggle %s channel"), _(rgb_names[i]));
+    g_autofree char *name = g_strdup_printf("%s-channel-button", channel_names[i]);
+    g_autofree char *tip = g_strdup_printf(_("toggle %s channel"), _(channel_names[i]));
     GtkWidget *btn = dtgtk_togglebutton_new(dtgtk_cairo_paint_color,
                                             CPF_NONE, NULL);
     dt_gui_add_class(btn, "rgb_toggle");
     gtk_widget_set_name(btn, name);
     gtk_widget_set_tooltip_text(btn, tip);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn),
                                  s->channels[i]);
-    dt_action_define(dark, N_("toggle colors"), rgb_names[i], btn, &dt_action_def_toggle);
-    dt_gui_box_add(s->button_box_rgb, btn);
+    if(i <= DT_SCOPES_CHANNEL_BLUE)
+      gtk_widget_set_sensitive(btn, !s->channels[DT_SCOPES_CHANNEL_LUMA]);
+    dt_action_define(dark, N_("toggle colors"), channel_names[i], btn, &dt_action_def_toggle);
     g_signal_connect(G_OBJECT(btn), "toggled", G_CALLBACK(_channel_toggle), s);
-    s->channel_buttons[i] = btn;
+    s->channel_btns[i] = btn;
   }
-  // RGB channels are always rightmost
-  dt_gui_box_add(s->button_box_right, s->button_box_rgb);
+  // luma is always leftmost
+  dt_gui_box_add(s->button_box_channels,
+                 s->channel_btns[DT_SCOPES_CHANNEL_LUMA],
+                 s->channel_btns[DT_SCOPES_CHANNEL_RED],
+                 s->channel_btns[DT_SCOPES_CHANNEL_GREEN],
+                 s->channel_btns[DT_SCOPES_CHANNEL_BLUE]);
+  // channels are always rightmost
+  dt_gui_box_add(s->button_box_right, s->button_box_channels);
 
   for(dt_scopes_mode_type_t i = 0; i < DT_SCOPES_MODE_N; i++)
   {

src/libs/scopes.h

@@ -43,15 +43,16 @@ typedef enum dt_scopes_highlight_t
   DT_SCOPES_HIGHLIGHT_EXPOSURE
 } dt_scopes_highlight_t;
 
-typedef enum dt_scopes_rgb_t
+typedef enum dt_scopes_channels_t
 {
-  DT_SCOPES_RGB_RED = 0,
-  DT_SCOPES_RGB_GREEN,
-  DT_SCOPES_RGB_BLUE,
-  DT_SCOPES_RGB_N // needs to be the last one
-} dt_scopes_rgb_t;
+  DT_SCOPES_CHANNEL_RED = 0,
+  DT_SCOPES_CHANNEL_GREEN,
+  DT_SCOPES_CHANNEL_BLUE,
+  DT_SCOPES_CHANNEL_LUMA,
+  DT_SCOPES_CHANNEL_N // needs to be the last one
+} dt_scopes_channels_t;
 
-typedef gboolean scopes_channels_t[DT_SCOPES_RGB_N];
+typedef gboolean dt_scopes_channels_list_t[DT_SCOPES_CHANNEL_N];
 
 struct dt_scopes_t;
 struct dt_scopes_mode_t;
@@ -66,7 +67,7 @@ typedef struct dt_scopes_functions_t
                   const float *const input,
                   // FIXME: should ROI by dt_histogram_roi_t or another type?
                   dt_histogram_roi_t *const roi,
-                  const dt_iop_order_iccprofile_info_t *vs_prof);
+                  const dt_iop_order_iccprofile_info_t *profile);
   // FIXME: do want a proper clear function or just tag as not up to date?
   void (*clear)(struct dt_scopes_mode_t *const self);
   void (*draw_bkgd)(const struct dt_scopes_mode_t *const self,
@@ -90,7 +91,7 @@ typedef struct dt_scopes_functions_t
                               cairo_t *cr,
                               const int width,
                               const int height,
-                              const scopes_channels_t channels);
+                              const dt_scopes_channels_list_t channels);
   // FIXME: rename to something more sensible
   dt_scopes_highlight_t (*get_highlight)(const struct dt_scopes_mode_t *const self,
                                          const double posx,
@@ -140,16 +141,16 @@ typedef struct dt_scopes_t
   dt_scopes_mode_t modes[DT_SCOPES_MODE_N];     // all available modes
   int update_counter;                           // most recent pixelpipe vs mode data
   dt_scopes_highlight_t highlight;              // depends on mouse position
-  scopes_channels_t channels;                   // display state chosen by RGB buttons
+  dt_scopes_channels_list_t channels;           // RGB & luma display state
   gboolean dragging;                            // to block motion handling during drag
   gdouble last_offset_x, last_offset_y;         // for drag handling
   // UI elements
   GtkWidget *overlay;                           // GtkOverlay -- scope and buttons
   GtkWidget *button_box_left;                   // GtkBox -- scope mode buttons
   GtkWidget *button_box_split;                  // GtkBox -- option buttons for left scope
   GtkWidget *button_box_right;                  // GtkBox -- option buttons for main scope
-  GtkWidget *button_box_rgb;                    // GtkBox -- RGB channels buttons
-  GtkWidget *channel_buttons[DT_SCOPES_RGB_N];  // Array of GtkToggleButton -- RGB channels
+  GtkWidget *button_box_channels;               // GtkBox -- RGB & luma buttons
+  GtkWidget *channel_btns[DT_SCOPES_CHANNEL_N]; // Array of GtkToggleButton -- channels
   GtkWidget *scope_draw;                        // GtkDrawingArea -- scope & resize
   // for access to data during process/draw
   dt_pthread_mutex_t lock;

src/libs/scopes/histogram.c

@@ -53,7 +53,7 @@ const char* _hist_name(const dt_scopes_mode_t *const self)
 static void _hist_process(dt_scopes_mode_t *const self,
                           const float *const input,
                           dt_histogram_roi_t *const roi,
-                          const dt_iop_order_iccprofile_info_t *vs_prof)
+                          const dt_iop_order_iccprofile_info_t *profile)
 {
   dt_scopes_hist_t *const d = self->data;
   dt_dev_histogram_collection_params_t histogram_params = { 0 };
@@ -126,7 +126,7 @@ static void _hist_draw(const dt_scopes_mode_t *const self,
                        cairo_t *cr,
                        const int width,
                        const int height,
-                       const scopes_channels_t channels)
+                       const dt_scopes_channels_list_t channels)
 {
   const dt_scopes_hist_t *const d = self->data;
 
@@ -146,7 +146,7 @@ static void _hist_draw(const dt_scopes_mode_t *const self,
   cairo_scale(cr, width / 255.0, -(height - 10) / hist_max);
   cairo_set_operator(cr, CAIRO_OPERATOR_ADD);
   cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.));
-  for(int k = 0; k < DT_SCOPES_RGB_N; k++)
+  for(int k = 0; k <= DT_SCOPES_CHANNEL_BLUE; k++)
     if(channels[k])
     {
       // FIXME: this is the last place in dt these are used -- if can

src/libs/scopes/split.c

@@ -33,11 +33,11 @@ const char* _split_name(const dt_scopes_mode_t *const self)
 static void _split_process(dt_scopes_mode_t *const self,
                           const float *const input,
                           dt_histogram_roi_t *const roi,
-                          const dt_iop_order_iccprofile_info_t *vs_prof)
+                          const dt_iop_order_iccprofile_info_t *profile)
 {
   dt_scopes_split_t *const d = self->data;
-  dt_scopes_call(d->left, process, input, roi, vs_prof);
-  dt_scopes_call(d->right, process, input, roi, vs_prof);
+  dt_scopes_call(d->left, process, input, roi, profile);
+  dt_scopes_call(d->right, process, input, roi, profile);
   self->update_counter = self->scopes->update_counter;
 }
 
@@ -90,7 +90,7 @@ static void _split_draw(const dt_scopes_mode_t *const self,
                         cairo_t *cr,
                         const int width,
                         const int height,
-                        const scopes_channels_t channels)
+                        const dt_scopes_channels_list_t channels)
 {
   const dt_scopes_split_t *const d = self->data;
   const int half_width = width / 2;
@@ -225,7 +225,7 @@ static void _responsive_buttons(dt_scopes_t *const s)
 
     const int mode_btns_hori = DT_SCOPES_MODE_N;
     const int opt_btns_wave = 1;  // FIXME: change this if there are more
-    const int opt_btns_hori = DT_SCOPES_RGB_N + opt_btns_wave;
+    const int opt_btns_hori = DT_SCOPES_CHANNEL_N + opt_btns_wave;
     const int opt_btns_vert = 1 + opt_btns_wave;
     const int estd_margin = 6;  // for both boxes and buttons
     const double estd_btn_width = min_w + estd_margin;
@@ -247,7 +247,7 @@ static void _responsive_buttons(dt_scopes_t *const s)
   // compact layout should show all buttons without overlap on the
   // smallest panel width and scope height
   gtk_orientable_set_orientation(GTK_ORIENTABLE(s->button_box_left), orient_btn_left);
-  gtk_orientable_set_orientation(GTK_ORIENTABLE(s->button_box_rgb), orient_btn_rgb);
+  gtk_orientable_set_orientation(GTK_ORIENTABLE(s->button_box_channels), orient_btn_rgb);
 }
 
 static void _reparent(GtkWidget *src, GtkWidget *dest, GtkWidget *child)
@@ -279,7 +279,7 @@ static void _split_mode_enter(dt_scopes_mode_t *const self)
             d->left->options_box);
   if(d->left->functions->draw_scope_channels)
     _reparent(self->scopes->button_box_right, self->scopes->button_box_split,
-              self->scopes->button_box_rgb);
+              self->scopes->button_box_channels);
   gtk_widget_show_all(self->scopes->button_box_split);
 }
 
@@ -293,11 +293,11 @@ static void _split_mode_leave(const dt_scopes_mode_t *const self)
             d->left->options_box);
   if(d->left->functions->draw_scope_channels)
     _reparent(self->scopes->button_box_split, self->scopes->button_box_right,
-              self->scopes->button_box_rgb);
+              self->scopes->button_box_channels);
   gtk_widget_hide(self->scopes->button_box_split);
   gtk_orientable_set_orientation(GTK_ORIENTABLE(self->scopes->button_box_left),
                                  GTK_ORIENTATION_HORIZONTAL);
-  gtk_orientable_set_orientation(GTK_ORIENTABLE(self->scopes->button_box_rgb),
+  gtk_orientable_set_orientation(GTK_ORIENTABLE(self->scopes->button_box_channels),
                                  GTK_ORIENTATION_HORIZONTAL);
 }