static gboolean
gimp_hue_saturation_config_copy (GimpConfig *src,
GimpConfig *dest,
GParamFlags flags)
{
GimpHueSaturationConfig *src_config = GIMP_HUE_SATURATION_CONFIG (src);
GimpHueSaturationConfig *dest_config = GIMP_HUE_SATURATION_CONFIG (dest);
GimpHueRange range;
for (range = GIMP_HUE_RANGE_ALL; range <= GIMP_HUE_RANGE_MAGENTA; range++)
{
dest_config->hue[range] = src_config->hue[range];
dest_config->saturation[range] = src_config->saturation[range];
dest_config->lightness[range] = src_config->lightness[range];
}
g_object_notify (G_OBJECT (dest), "hue");
g_object_notify (G_OBJECT (dest), "saturation");
g_object_notify (G_OBJECT (dest), "lightness");
dest_config->range = src_config->range;
dest_config->overlap = src_config->overlap;
g_object_notify (G_OBJECT (dest), "range");
g_object_notify (G_OBJECT (dest), "overlap");
return TRUE;
}
static void
gimp_hue_saturation_config_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpHueSaturationConfig *self = GIMP_HUE_SATURATION_CONFIG (object);
switch (property_id)
{
case PROP_RANGE:
g_value_set_enum (value, self->range);
break;
case PROP_HUE:
g_value_set_double (value, self->hue[self->range]);
break;
case PROP_SATURATION:
g_value_set_double (value, self->saturation[self->range]);
break;
case PROP_LIGHTNESS:
g_value_set_double (value, self->lightness[self->range]);
break;
case PROP_OVERLAP:
g_value_set_double (value, self->overlap);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gboolean
gimp_hue_saturation_config_equal (GimpConfig *a,
GimpConfig *b)
{
GimpHueSaturationConfig *config_a = GIMP_HUE_SATURATION_CONFIG (a);
GimpHueSaturationConfig *config_b = GIMP_HUE_SATURATION_CONFIG (b);
GimpHueRange range;
for (range = GIMP_HUE_RANGE_ALL; range <= GIMP_HUE_RANGE_MAGENTA; range++)
{
if (config_a->hue[range] != config_b->hue[range] ||
config_a->saturation[range] != config_b->saturation[range] ||
config_a->lightness[range] != config_b->lightness[range])
return FALSE;
}
/* don't compare "range" */
if (config_a->overlap != config_b->overlap)
return FALSE;
return TRUE;
}
static void
gimp_hue_saturation_config_reset (GimpConfig *config)
{
GimpHueSaturationConfig *hs_config = GIMP_HUE_SATURATION_CONFIG (config);
GimpHueRange range;
for (range = GIMP_HUE_RANGE_ALL; range <= GIMP_HUE_RANGE_MAGENTA; range++)
{
hs_config->range = range;
gimp_hue_saturation_config_reset_range (hs_config);
}
gimp_config_reset_property (G_OBJECT (config), "range");
gimp_config_reset_property (G_OBJECT (config), "overlap");
}
static gboolean
gimp_hue_saturation_config_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
GimpHueSaturationConfig *hs_config = GIMP_HUE_SATURATION_CONFIG (config);
GimpHueRange old_range;
gboolean success = TRUE;
old_range = hs_config->range;
success = gimp_config_deserialize_properties (config, scanner, nest_level);
g_object_set (config, "range", old_range, NULL);
return success;
}
static gboolean
gimp_hue_saturation_config_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data)
{
GimpHueSaturationConfig *hs_config = GIMP_HUE_SATURATION_CONFIG (config);
GimpHueRange range;
GimpHueRange old_range;
gboolean success = TRUE;
if (! gimp_config_serialize_property_by_name (config, "time", writer))
return FALSE;
old_range = hs_config->range;
for (range = GIMP_HUE_RANGE_ALL; range <= GIMP_HUE_RANGE_MAGENTA; range++)
{
hs_config->range = range;
success = (gimp_config_serialize_property_by_name (config, "range",
writer) &&
gimp_config_serialize_property_by_name (config, "hue",
writer) &&
gimp_config_serialize_property_by_name (config, "saturation",
writer) &&
gimp_config_serialize_property_by_name (config, "lightness",
writer));
if (! success)
break;
}
if (success)
success = gimp_config_serialize_property_by_name (config, "overlap",
writer);
hs_config->range = old_range;
return success;
}
static void
hue_saturation_config_notify (GObject *object,
GParamSpec *pspec,
GimpHueSaturationTool *hs_tool)
{
GimpHueSaturationConfig *config = GIMP_HUE_SATURATION_CONFIG (object);
if (! hs_tool->hue_data)
return;
if (! strcmp (pspec->name, "range"))
{
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (hs_tool->range_radio),
config->range);
}
else if (! strcmp (pspec->name, "hue"))
{
gtk_adjustment_set_value (hs_tool->hue_data,
config->hue[config->range] * 180.0);
}
else if (! strcmp (pspec->name, "lightness"))
{
gtk_adjustment_set_value (hs_tool->lightness_data,
config->lightness[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "saturation"))
{
gtk_adjustment_set_value (hs_tool->saturation_data,
config->saturation[config->range] * 100.0);
}
else if (! strcmp (pspec->name, "overlap"))
{
gtk_adjustment_set_value (hs_tool->overlap_data,
config->overlap * 100.0);
}
hue_saturation_update_color_areas (hs_tool);
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (hs_tool));
}
static gboolean
gimp_operation_hue_saturation_process (GeglOperation *operation,
void *in_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi)
{
GimpOperationPointFilter *point = GIMP_OPERATION_POINT_FILTER (operation);
GimpHueSaturationConfig *config = GIMP_HUE_SATURATION_CONFIG (point->config);
gfloat *src = in_buf;
gfloat *dest = out_buf;
gfloat overlap;
if (! config)
return FALSE;
overlap = config->overlap / 2.0;
while (samples--)
{
GimpRGB rgb;
GimpHSL hsl;
gdouble h;
gint hue_counter;
gint hue = 0;
gint secondary_hue = 0;
gboolean use_secondary_hue = FALSE;
gfloat primary_intensity = 0.0;
gfloat secondary_intensity = 0.0;
rgb.r = src[RED];
rgb.g = src[GREEN];
rgb.b = src[BLUE];
gimp_rgb_to_hsl (&rgb, &hsl);
h = hsl.h * 6.0;
for (hue_counter = 0; hue_counter < 7; hue_counter++)
{
gdouble hue_threshold = (gdouble) hue_counter + 0.5;
if (h < ((gdouble) hue_threshold + overlap))
{
hue = hue_counter;
if (overlap > 0.0 && h > ((gdouble) hue_threshold - overlap))
{
use_secondary_hue = TRUE;
secondary_hue = hue_counter + 1;
secondary_intensity =
(h - (gdouble) hue_threshold + overlap) / (2.0 * overlap);
primary_intensity = 1.0 - secondary_intensity;
}
else
{
use_secondary_hue = FALSE;
}
break;
}
}
if (hue >= 6)
{
hue = 0;
use_secondary_hue = FALSE;
}
if (secondary_hue >= 6)
{
secondary_hue = 0;
}
/* transform into GimpHueRange values */
hue++;
secondary_hue++;
if (use_secondary_hue)
{
gdouble mapped_primary_hue;
gdouble mapped_secondary_hue;
gdouble diff;
mapped_primary_hue = map_hue (config, hue, hsl.h);
mapped_secondary_hue = map_hue (config, secondary_hue, hsl.h);
/* Find nearest hue on the circle between primary and
* secondary hue
*/
diff = mapped_primary_hue - mapped_secondary_hue;
if (diff < -0.5)
{
mapped_secondary_hue -= 1.0;
}
else if (diff >= 0.5)
{
mapped_secondary_hue += 1.0;
}
hsl.h = (mapped_primary_hue * primary_intensity +
mapped_secondary_hue * secondary_intensity);
hsl.s = (map_saturation (config, hue, hsl.s) * primary_intensity +
map_saturation (config, secondary_hue, hsl.s) * secondary_intensity);
hsl.l = (map_lightness (config, hue, hsl.l) * primary_intensity +
map_lightness (config, secondary_hue, hsl.l) * secondary_intensity);
}
else
{
hsl.h = map_hue (config, hue, hsl.h);
hsl.s = map_saturation (config, hue, hsl.s);
hsl.l = map_lightness (config, hue, hsl.l);
}
gimp_hsl_to_rgb (&hsl, &rgb);
dest[RED] = rgb.r;
dest[GREEN] = rgb.g;
dest[BLUE] = rgb.b;
dest[ALPHA] = src[ALPHA];
src += 4;
dest += 4;
}
return TRUE;
}
