AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/app/operations/pikaoperationgradient.c

1288 lines
43 KiB
C
Raw Permalink Normal View History

Initial checkin of Pika from heckimp
2023-09-26 00:35:21 +02:00
/* PIKA - Photo and Image Kooker Application
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
*
* Original copyright, applying to most contents (license remains unchanged):
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* Largely based on pikadrawable-gradient.c
*
* pikaoperationgradient.c
* Copyright (C) 2014 Michael Henning <drawoc@darkrefraction.com>
*
* This program 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.
*
* This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <cairo.h>
#include <gegl.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include "libpikacolor/pikacolor.h"
#include "libpikamath/pikamath.h"
#include "operations-types.h"
#include "core/pikagradient.h"
#include "pikaoperationgradient.h"
#define GRADIENT_CACHE_N_SUPERSAMPLES 4
#define GRADIENT_CACHE_MAX_SIZE ((1 << 20) / sizeof (PikaRGB))
enum
{
PROP_0,
PROP_CONTEXT,
PROP_GRADIENT,
PROP_START_X,
PROP_START_Y,
PROP_END_X,
PROP_END_Y,
PROP_GRADIENT_TYPE,
PROP_GRADIENT_REPEAT,
PROP_OFFSET,
PROP_GRADIENT_REVERSE,
PROP_GRADIENT_BLEND_COLOR_SPACE,
PROP_SUPERSAMPLE,
PROP_SUPERSAMPLE_DEPTH,
PROP_SUPERSAMPLE_THRESHOLD,
PROP_DITHER
};
typedef struct
{
PikaGradient *gradient;
gboolean reverse;
PikaGradientBlendColorSpace blend_color_space;
PikaRGB *gradient_cache;
gint gradient_cache_size;
PikaGradientSegment *last_seg;
gdouble offset;
gdouble sx, sy;
PikaGradientType gradient_type;
gdouble dist;
gdouble vec[2];
PikaRepeatMode repeat;
GeglSampler *dist_sampler;
} RenderBlendData;
typedef struct
{
gfloat *data;
GeglRectangle roi;
GRand *dither_rand;
} PutPixelData;
/* local function prototypes */
static void pika_operation_gradient_dispose (GObject *gobject);
static void pika_operation_gradient_finalize (GObject *gobject);
static void pika_operation_gradient_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void pika_operation_gradient_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void pika_operation_gradient_prepare (GeglOperation *operation);
static GeglRectangle pika_operation_gradient_get_bounding_box (GeglOperation *operation);
static gdouble gradient_calc_conical_sym_factor (gdouble dist,
gdouble *axis,
gdouble offset,
gdouble x,
gdouble y);
static gdouble gradient_calc_conical_asym_factor (gdouble dist,
gdouble *axis,
gdouble offset,
gdouble x,
gdouble y);
static gdouble gradient_calc_square_factor (gdouble dist,
gdouble offset,
gdouble x,
gdouble y);
static gdouble gradient_calc_radial_factor (gdouble dist,
gdouble offset,
gdouble x,
gdouble y);
static gdouble gradient_calc_linear_factor (gdouble dist,
gdouble *vec,
gdouble offset,
gdouble x,
gdouble y);
static gdouble gradient_calc_bilinear_factor (gdouble dist,
gdouble *vec,
gdouble offset,
gdouble x,
gdouble y);
static gdouble gradient_calc_spiral_factor (gdouble dist,
gdouble *axis,
gdouble offset,
gdouble x,
gdouble y,
gboolean clockwise);
static gdouble gradient_calc_shapeburst_angular_factor (GeglSampler *dist_sampler,
gdouble offset,
gdouble x,
gdouble y);
static gdouble gradient_calc_shapeburst_spherical_factor (GeglSampler *dist_sampler,
gdouble offset,
gdouble x,
gdouble y);
static gdouble gradient_calc_shapeburst_dimpled_factor (GeglSampler *dist_sampler,
gdouble offset,
gdouble x,
gdouble y);
static void gradient_render_pixel (gdouble x,
gdouble y,
PikaRGB *color,
gpointer render_data);
static void gradient_put_pixel (gint x,
gint y,
PikaRGB *color,
gpointer put_pixel_data);
static void gradient_dither_pixel (PikaRGB *color,
GRand *dither_rand,
gfloat *dest);
static gboolean pika_operation_gradient_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level);
static void pika_operation_gradient_invalidate_cache (PikaOperationGradient *self);
static void pika_operation_gradient_validate_cache (PikaOperationGradient *self);
G_DEFINE_TYPE (PikaOperationGradient, pika_operation_gradient,
GEGL_TYPE_OPERATION_FILTER)
#define parent_class pika_operation_gradient_parent_class
static void
pika_operation_gradient_class_init (PikaOperationGradientClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationFilterClass *filter_class = GEGL_OPERATION_FILTER_CLASS (klass);
object_class->dispose = pika_operation_gradient_dispose;
object_class->finalize = pika_operation_gradient_finalize;
object_class->set_property = pika_operation_gradient_set_property;
object_class->get_property = pika_operation_gradient_get_property;
operation_class->prepare = pika_operation_gradient_prepare;
operation_class->get_bounding_box = pika_operation_gradient_get_bounding_box;
filter_class->process = pika_operation_gradient_process;
gegl_operation_class_set_keys (operation_class,
"name", "pika:gradient",
"categories", "pika",
"description", "PIKA Gradient operation",
NULL);
g_object_class_install_property (object_class, PROP_CONTEXT,
g_param_spec_object ("context",
"Context",
"A PikaContext",
PIKA_TYPE_OBJECT,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_GRADIENT,
g_param_spec_object ("gradient",
"Gradient",
"A PikaGradient to render",
PIKA_TYPE_OBJECT,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_START_X,
g_param_spec_double ("start-x",
"Start X",
"X coordinate of the first point",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_START_Y,
g_param_spec_double ("start-y",
"Start Y",
"Y coordinate of the first point",
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_END_X,
g_param_spec_double ("end-x",
"End X",
"X coordinate of the second point",
-G_MAXDOUBLE, G_MAXDOUBLE, 200,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_END_Y,
g_param_spec_double ("end-y",
"End Y",
"Y coordinate of the second point",
-G_MAXDOUBLE, G_MAXDOUBLE, 200,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_GRADIENT_TYPE,
g_param_spec_enum ("gradient-type",
"Gradient Type",
"The type of gradient to render",
PIKA_TYPE_GRADIENT_TYPE,
PIKA_GRADIENT_LINEAR,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_GRADIENT_REPEAT,
g_param_spec_enum ("gradient-repeat",
"Repeat mode",
"Repeat mode",
PIKA_TYPE_REPEAT_MODE,
PIKA_REPEAT_NONE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_OFFSET,
g_param_spec_double ("offset",
"Offset",
"Offset relates to the starting and ending coordinates "
"specified for the blend. This parameter is mode dependent.",
0, G_MAXDOUBLE, 0,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_GRADIENT_REVERSE,
g_param_spec_boolean ("gradient-reverse",
"Reverse",
"Reverse the gradient",
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_GRADIENT_BLEND_COLOR_SPACE,
g_param_spec_enum ("gradient-blend-color-space",
"Blend Color Space",
"Which color space to use when blending RGB gradient segments",
PIKA_TYPE_GRADIENT_BLEND_COLOR_SPACE,
PIKA_GRADIENT_BLEND_RGB_PERCEPTUAL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_SUPERSAMPLE,
g_param_spec_boolean ("supersample",
"Supersample",
"Do adaptive supersampling",
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_SUPERSAMPLE_DEPTH,
g_param_spec_int ("supersample-depth",
"Max depth",
"Maximum recursion levels for supersampling",
1, 9, 3,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_SUPERSAMPLE_THRESHOLD,
g_param_spec_double ("supersample-threshold",
"Threshold",
"Supersampling threshold",
0, 4, 0.20,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_DITHER,
g_param_spec_boolean ("dither",
"Dither",
"Use dithering to reduce banding",
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
}
static void
pika_operation_gradient_init (PikaOperationGradient *self)
{
g_mutex_init (&self->gradient_cache_mutex);
}
static void
pika_operation_gradient_dispose (GObject *object)
{
PikaOperationGradient *self = PIKA_OPERATION_GRADIENT (object);
pika_operation_gradient_invalidate_cache (self);
g_clear_object (&self->gradient);
g_clear_object (&self->context);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
pika_operation_gradient_finalize (GObject *object)
{
PikaOperationGradient *self = PIKA_OPERATION_GRADIENT (object);
g_mutex_clear (&self->gradient_cache_mutex);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
pika_operation_gradient_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
PikaOperationGradient *self = PIKA_OPERATION_GRADIENT (object);
switch (property_id)
{
case PROP_CONTEXT:
g_value_set_object (value, self->context);
break;
case PROP_GRADIENT:
g_value_set_object (value, self->gradient);
break;
case PROP_START_X:
g_value_set_double (value, self->start_x);
break;
case PROP_START_Y:
g_value_set_double (value, self->start_y);
break;
case PROP_END_X:
g_value_set_double (value, self->end_x);
break;
case PROP_END_Y:
g_value_set_double (value, self->end_y);
break;
case PROP_GRADIENT_TYPE:
g_value_set_enum (value, self->gradient_type);
break;
case PROP_GRADIENT_REPEAT:
g_value_set_enum (value, self->gradient_repeat);
break;
case PROP_OFFSET:
g_value_set_double (value, self->offset);
break;
case PROP_GRADIENT_REVERSE:
g_value_set_boolean (value, self->gradient_reverse);
break;
case PROP_GRADIENT_BLEND_COLOR_SPACE:
g_value_set_enum (value, self->gradient_blend_color_space);
break;
case PROP_SUPERSAMPLE:
g_value_set_boolean (value, self->supersample);
break;
case PROP_SUPERSAMPLE_DEPTH:
g_value_set_int (value, self->supersample_depth);
break;
case PROP_SUPERSAMPLE_THRESHOLD:
g_value_set_double (value, self->supersample_threshold);
break;
case PROP_DITHER:
g_value_set_boolean (value, self->dither);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
pika_operation_gradient_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
PikaOperationGradient *self = PIKA_OPERATION_GRADIENT (object);
switch (property_id)
{
case PROP_CONTEXT:
if (self->context)
g_object_unref (self->context);
self->context = g_value_dup_object (value);
break;
case PROP_GRADIENT:
{
PikaGradient *gradient = g_value_get_object (value);
g_clear_object (&self->gradient);
if (gradient)
{
if (pika_gradient_has_fg_bg_segments (gradient))
self->gradient = pika_gradient_flatten (gradient, self->context);
else
self->gradient = g_object_ref (gradient);
}
pika_operation_gradient_invalidate_cache (self);
}
break;
case PROP_START_X:
self->start_x = g_value_get_double (value);
pika_operation_gradient_invalidate_cache (self);
break;
case PROP_START_Y:
self->start_y = g_value_get_double (value);
pika_operation_gradient_invalidate_cache (self);
break;
case PROP_END_X:
self->end_x = g_value_get_double (value);
pika_operation_gradient_invalidate_cache (self);
break;
case PROP_END_Y:
self->end_y = g_value_get_double (value);
pika_operation_gradient_invalidate_cache (self);
break;
case PROP_GRADIENT_TYPE:
self->gradient_type = g_value_get_enum (value);
break;
case PROP_GRADIENT_REPEAT:
self->gradient_repeat = g_value_get_enum (value);
break;
case PROP_OFFSET:
self->offset = g_value_get_double (value);
break;
case PROP_GRADIENT_REVERSE:
self->gradient_reverse = g_value_get_boolean (value);
pika_operation_gradient_invalidate_cache (self);
break;
case PROP_GRADIENT_BLEND_COLOR_SPACE:
self->gradient_blend_color_space = g_value_get_enum (value);
pika_operation_gradient_invalidate_cache (self);
break;
case PROP_SUPERSAMPLE:
self->supersample = g_value_get_boolean (value);
break;
case PROP_SUPERSAMPLE_DEPTH:
self->supersample_depth = g_value_get_int (value);
break;
case PROP_SUPERSAMPLE_THRESHOLD:
self->supersample_threshold = g_value_get_double (value);
break;
case PROP_DITHER:
self->dither = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
pika_operation_gradient_prepare (GeglOperation *operation)
{
gegl_operation_set_format (operation, "output", babl_format ("R'G'B'A float"));
}
static GeglRectangle
pika_operation_gradient_get_bounding_box (GeglOperation *operation)
{
return gegl_rectangle_infinite_plane ();
}
static gdouble
gradient_calc_conical_sym_factor (gdouble dist,
gdouble *axis,
gdouble offset,
gdouble x,
gdouble y)
{
if (dist == 0.0)
{
return 0.0;
}
else if ((x != 0) || (y != 0))
{
gdouble vec[2];
gdouble r;
gdouble rat;
/* Calculate offset from the start in pixels */
r = sqrt (SQR (x) + SQR (y));
vec[0] = x / r;
vec[1] = y / r;
rat = axis[0] * vec[0] + axis[1] * vec[1]; /* Dot product */
if (rat > 1.0)
rat = 1.0;
else if (rat < -1.0)
rat = -1.0;
/* This cool idea is courtesy Josh MacDonald,
* Ali Rahimi --- two more XCF losers. */
rat = acos (rat) / G_PI;
rat = pow (rat, (offset / 10.0) + 1.0);
return CLAMP (rat, 0.0, 1.0);
}
else
{
return 0.5;
}
}
static gdouble
gradient_calc_conical_asym_factor (gdouble dist,
gdouble *axis,
gdouble offset,
gdouble x,
gdouble y)
{
if (dist == 0.0)
{
return 0.0;
}
else if (x != 0 || y != 0)
{
gdouble ang0, ang1;
gdouble ang;
gdouble rat;
ang0 = atan2 (axis[0], axis[1]) + G_PI;
ang1 = atan2 (x, y) + G_PI;
ang = ang1 - ang0;
if (ang < 0.0)
ang += (2.0 * G_PI);
rat = ang / (2.0 * G_PI);
rat = pow (rat, (offset / 10.0) + 1.0);
return CLAMP (rat, 0.0, 1.0);
}
else
{
return 0.5; /* We are on middle point */
}
}
static gdouble
gradient_calc_square_factor (gdouble dist,
gdouble offset,
gdouble x,
gdouble y)
{
if (dist == 0.0)
{
return 0.0;
}
else
{
gdouble r;
gdouble rat;
/* Calculate offset from start as a value in [0, 1] */
offset = offset / 100.0;
r = MAX (fabs (x), fabs (y));
rat = r / dist;
if (rat < offset)
return 0.0;
else if (offset == 1.0)
return (rat >= 1.0) ? 1.0 : 0.0;
else
return (rat - offset) / (1.0 - offset);
}
}
static gdouble
gradient_calc_radial_factor (gdouble dist,
gdouble offset,
gdouble x,
gdouble y)
{
if (dist == 0.0)
{
return 0.0;
}
else
{
gdouble r;
gdouble rat;
/* Calculate radial offset from start as a value in [0, 1] */
offset = offset / 100.0;
r = sqrt (SQR (x) + SQR (y));
rat = r / dist;
if (rat < offset)
return 0.0;
else if (offset == 1.0)
return (rat >= 1.0) ? 1.0 : 0.0;
else
return (rat - offset) / (1.0 - offset);
}
}
static gdouble
gradient_calc_linear_factor (gdouble dist,
gdouble *vec,
gdouble offset,
gdouble x,
gdouble y)
{
if (dist == 0.0)
{
return 0.0;
}
else
{
gdouble r;
gdouble rat;
offset = offset / 100.0;
r = vec[0] * x + vec[1] * y;
rat = r / dist;
if (rat >= 0.0 && rat < offset)
return 0.0;
else if (offset == 1.0)
return (rat >= 1.0) ? 1.0 : 0.0;
else if (rat < 0.0)
return rat / (1.0 - offset);
else
return (rat - offset) / (1.0 - offset);
}
}
static gdouble
gradient_calc_bilinear_factor (gdouble dist,
gdouble *vec,
gdouble offset,
gdouble x,
gdouble y)
{
if (dist == 0.0)
{
return 0.0;
}
else
{
gdouble r;
gdouble rat;
/* Calculate linear offset from the start line outward */
offset = offset / 100.0;
r = vec[0] * x + vec[1] * y;
rat = r / dist;
if (fabs (rat) < offset)
return 0.0;
else if (offset == 1.0)
return (rat == 1.0) ? 1.0 : 0.0;
else
return (fabs (rat) - offset) / (1.0 - offset);
}
}
static gdouble
gradient_calc_spiral_factor (gdouble dist,
gdouble *axis,
gdouble offset,
gdouble x,
gdouble y,
gboolean clockwise)
{
if (dist == 0.0)
{
return 0.0;
}
else if (x != 0.0 || y != 0.0)
{
gdouble ang0, ang1;
gdouble ang;
double r;
offset = offset / 100.0;
ang0 = atan2 (axis[0], axis[1]) + G_PI;
ang1 = atan2 (x, y) + G_PI;
if (clockwise)
ang = ang1 - ang0;
else
ang = ang0 - ang1;
if (ang < 0.0)
ang += (2.0 * G_PI);
r = sqrt (SQR (x) + SQR (y)) / dist;
return fmod (ang / (2.0 * G_PI) + r + offset, 1.0);
}
else
{
return 0.5 ; /* We are on the middle point */
}
}
static gdouble
gradient_calc_shapeburst_angular_factor (GeglSampler *dist_sampler,
gdouble offset,
gdouble x,
gdouble y)
{
gfloat value;
offset = offset / 100.0;
gegl_sampler_get (dist_sampler, x, y, NULL, &value, GEGL_ABYSS_NONE);
value = 1.0 - value;
if (value < offset)
value = 0.0;
else if (offset == 1.0)
value = (value >= 1.0) ? 1.0 : 0.0;
else
value = (value - offset) / (1.0 - offset);
return value;
}
static gdouble
gradient_calc_shapeburst_spherical_factor (GeglSampler *dist_sampler,
gdouble offset,
gdouble x,
gdouble y)
{
gfloat value;
offset = 1.0 - offset / 100.0;
gegl_sampler_get (dist_sampler, x, y, NULL, &value, GEGL_ABYSS_NONE);
if (value > offset)
value = 1.0;
else if (offset == 0.0)
value = (value <= 0.0) ? 0.0 : 1.0;
else
value = value / offset;
value = 1.0 - sin (0.5 * G_PI * value);
return value;
}
static gdouble
gradient_calc_shapeburst_dimpled_factor (GeglSampler *dist_sampler,
gdouble offset,
gdouble x,
gdouble y)
{
gfloat value;
offset = 1.0 - offset / 100.0;
gegl_sampler_get (dist_sampler, x, y, NULL, &value, GEGL_ABYSS_NONE);
if (value > offset)
value = 1.0;
else if (offset == 0.0)
value = (value <= 0.0) ? 0.0 : 1.0;
else
value = value / offset;
value = cos (0.5 * G_PI * value);
return value;
}
static void
gradient_render_pixel (gdouble x,
gdouble y,
PikaRGB *color,
gpointer render_data)
{
RenderBlendData *rbd = render_data;
gdouble factor;
/* we want to calculate the color at the pixel's center */
x += 0.5;
y += 0.5;
/* Calculate blending factor */
switch (rbd->gradient_type)
{
case PIKA_GRADIENT_LINEAR:
factor = gradient_calc_linear_factor (rbd->dist,
rbd->vec, rbd->offset,
x - rbd->sx, y - rbd->sy);
break;
case PIKA_GRADIENT_BILINEAR:
factor = gradient_calc_bilinear_factor (rbd->dist,
rbd->vec, rbd->offset,
x - rbd->sx, y - rbd->sy);
break;
case PIKA_GRADIENT_RADIAL:
factor = gradient_calc_radial_factor (rbd->dist,
rbd->offset,
x - rbd->sx, y - rbd->sy);
break;
case PIKA_GRADIENT_SQUARE:
factor = gradient_calc_square_factor (rbd->dist, rbd->offset,
x - rbd->sx, y - rbd->sy);
break;
case PIKA_GRADIENT_CONICAL_SYMMETRIC:
factor = gradient_calc_conical_sym_factor (rbd->dist,
rbd->vec, rbd->offset,
x - rbd->sx, y - rbd->sy);
break;
case PIKA_GRADIENT_CONICAL_ASYMMETRIC:
factor = gradient_calc_conical_asym_factor (rbd->dist,
rbd->vec, rbd->offset,
x - rbd->sx, y - rbd->sy);
break;
case PIKA_GRADIENT_SHAPEBURST_ANGULAR:
factor = gradient_calc_shapeburst_angular_factor (rbd->dist_sampler,
rbd->offset,
x, y);
break;
case PIKA_GRADIENT_SHAPEBURST_SPHERICAL:
factor = gradient_calc_shapeburst_spherical_factor (rbd->dist_sampler,
rbd->offset,
x, y);
break;
case PIKA_GRADIENT_SHAPEBURST_DIMPLED:
factor = gradient_calc_shapeburst_dimpled_factor (rbd->dist_sampler,
rbd->offset,
x, y);
break;
case PIKA_GRADIENT_SPIRAL_CLOCKWISE:
factor = gradient_calc_spiral_factor (rbd->dist,
rbd->vec, rbd->offset,
x - rbd->sx, y - rbd->sy, TRUE);
break;
case PIKA_GRADIENT_SPIRAL_ANTICLOCKWISE:
factor = gradient_calc_spiral_factor (rbd->dist,
rbd->vec, rbd->offset,
x - rbd->sx, y - rbd->sy, FALSE);
break;
default:
g_return_if_reached ();
break;
}
/* Adjust for repeat */
switch (rbd->repeat)
{
case PIKA_REPEAT_NONE:
break;
case PIKA_REPEAT_SAWTOOTH:
factor = factor - floor (factor);
break;
case PIKA_REPEAT_TRIANGULAR:
{
guint ifactor;
if (factor < 0.0)
factor = -factor;
ifactor = (guint) factor;
factor = factor - floor (factor);
if (ifactor & 1)
factor = 1.0 - factor;
}
break;
case PIKA_REPEAT_TRUNCATE:
if (factor < 0.0 || factor > 1.0)
{
pika_rgba_set (color, 0.0, 0.0, 0.0, 0.0);
return;
}
break;
}
/* Blend the colors */
if (rbd->gradient_cache)
{
factor = CLAMP (factor, 0.0, 1.0);
*color =
rbd->gradient_cache[ROUND (factor * (rbd->gradient_cache_size - 1))];
}
else
{
rbd->last_seg = pika_gradient_get_color_at (rbd->gradient, NULL,
rbd->last_seg, factor,
rbd->reverse,
rbd->blend_color_space,
color);
}
}
static void
gradient_put_pixel (gint x,
gint y,
PikaRGB *color,
gpointer put_pixel_data)
{
PutPixelData *ppd = put_pixel_data;
const gint index = (y - ppd->roi.y) * ppd->roi.width + (x - ppd->roi.x);
gfloat *dest = ppd->data + 4 * index;
if (ppd->dither_rand)
{
gradient_dither_pixel (color, ppd->dither_rand, dest);
dest += 4;
}
else
{
*dest++ = color->r;
*dest++ = color->g;
*dest++ = color->b;
*dest++ = color->a;
}
}
static void
gradient_dither_pixel (PikaRGB *color,
GRand *dither_rand,
gfloat *dest)
{
gfloat r, g, b, a;
guint i;
i = g_rand_int (dither_rand);
r = color->r + (gdouble) (i & 0xff) / 256.0 / 256.0 - 0.5 / 256.0; i >>= 8;
g = color->g + (gdouble) (i & 0xff) / 256.0 / 256.0 - 0.5 / 256.0; i >>= 8;
b = color->b + (gdouble) (i & 0xff) / 256.0 / 256.0 - 0.5 / 256.0; i >>= 8;
if (color->a > 0.0 && color->a < 1.0)
a = color->a + (gdouble) (i & 0xff) / 256.0 / 256.0 - 0.5 / 256.0;
else
a = color->a;
*dest++ = CLAMP (r, 0.0, 1.0);
*dest++ = CLAMP (g, 0.0, 1.0);
*dest++ = CLAMP (b, 0.0, 1.0);
*dest++ = CLAMP (a, 0.0, 1.0);
}
static gboolean
pika_operation_gradient_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
PikaOperationGradient *self = PIKA_OPERATION_GRADIENT (operation);
const gdouble sx = self->start_x;
const gdouble sy = self->start_y;
const gdouble ex = self->end_x;
const gdouble ey = self->end_y;
RenderBlendData rbd = { 0, };
GeglBufferIterator *iter;
GeglRectangle *roi;
GRand *dither_rand = NULL;
if (! self->gradient)
return TRUE;
pika_operation_gradient_validate_cache (self);
rbd.gradient = self->gradient;
rbd.reverse = self->gradient_reverse;
rbd.blend_color_space = self->gradient_blend_color_space;
rbd.gradient_cache = self->gradient_cache;
rbd.gradient_cache_size = self->gradient_cache_size;
/* Calculate type-specific parameters */
switch (self->gradient_type)
{
case PIKA_GRADIENT_RADIAL:
rbd.dist = sqrt (SQR (ex - sx) + SQR (ey - sy));
break;
case PIKA_GRADIENT_SQUARE:
rbd.dist = MAX (fabs (ex - sx), fabs (ey - sy));
break;
case PIKA_GRADIENT_CONICAL_SYMMETRIC:
case PIKA_GRADIENT_CONICAL_ASYMMETRIC:
case PIKA_GRADIENT_SPIRAL_CLOCKWISE:
case PIKA_GRADIENT_SPIRAL_ANTICLOCKWISE:
case PIKA_GRADIENT_LINEAR:
case PIKA_GRADIENT_BILINEAR:
rbd.dist = sqrt (SQR (ex - sx) + SQR (ey - sy));
if (rbd.dist > 0.0)
{
rbd.vec[0] = (ex - sx) / rbd.dist;
rbd.vec[1] = (ey - sy) / rbd.dist;
}
break;
case PIKA_GRADIENT_SHAPEBURST_ANGULAR:
case PIKA_GRADIENT_SHAPEBURST_SPHERICAL:
case PIKA_GRADIENT_SHAPEBURST_DIMPLED:
rbd.dist = sqrt (SQR (ex - sx) + SQR (ey - sy));
rbd.dist_sampler = gegl_buffer_sampler_new_at_level (
input, babl_format ("Y float"), GEGL_SAMPLER_NEAREST, level);
break;
default:
g_return_val_if_reached (FALSE);
break;
}
/* Initialize render data */
rbd.offset = self->offset;
rbd.sx = self->start_x;
rbd.sy = self->start_y;
rbd.gradient_type = self->gradient_type;
rbd.repeat = self->gradient_repeat;
/* Render the gradient! */
iter = gegl_buffer_iterator_new (output, result, 0,
babl_format ("R'G'B'A float"),
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1);
roi = &iter->items[0].roi;
if (self->dither)
dither_rand = g_rand_new ();
if (self->supersample)
{
PutPixelData ppd;
ppd.dither_rand = dither_rand;
while (gegl_buffer_iterator_next (iter))
{
ppd.data = iter->items[0].data;
ppd.roi = *roi;
pika_adaptive_supersample_area (roi->x, roi->y,
roi->x + roi->width - 1,
roi->y + roi->height - 1,
self->supersample_depth,
self->supersample_threshold,
gradient_render_pixel, &rbd,
gradient_put_pixel, &ppd,
NULL,
NULL);
}
}
else
{
while (gegl_buffer_iterator_next (iter))
{
gfloat *dest = iter->items[0].data;
gint endx = roi->x + roi->width;
gint endy = roi->y + roi->height;
gint x, y;
if (dither_rand)
{
for (y = roi->y; y < endy; y++)
for (x = roi->x; x < endx; x++)
{
PikaRGB color = { 0.0, 0.0, 0.0, 1.0 };
gradient_render_pixel (x, y, &color, &rbd);
gradient_dither_pixel (&color, dither_rand, dest);
dest += 4;
}
}
else
{
for (y = roi->y; y < endy; y++)
for (x = roi->x; x < endx; x++)
{
PikaRGB color = { 0.0, 0.0, 0.0, 1.0 };
gradient_render_pixel (x, y, &color, &rbd);
*dest++ = color.r;
*dest++ = color.g;
*dest++ = color.b;
*dest++ = color.a;
}
}
}
}
if (self->dither)
g_rand_free (dither_rand);
g_clear_object (&rbd.dist_sampler);
return TRUE;
}
static void
pika_operation_gradient_invalidate_cache (PikaOperationGradient *self)
{
g_clear_pointer (&self->gradient_cache, g_free);
}
static void
pika_operation_gradient_validate_cache (PikaOperationGradient *self)
{
PikaGradientSegment *last_seg = NULL;
gint cache_size;
gint i;
if (! self->gradient)
return;
g_mutex_lock (&self->gradient_cache_mutex);
if (self->gradient_cache)
{
g_mutex_unlock (&self->gradient_cache_mutex);
return;
}
cache_size = ceil (hypot (self->start_x - self->end_x,
self->start_y - self->end_y)) *
GRADIENT_CACHE_N_SUPERSAMPLES;
/* have at least two values in the cache */
cache_size = MAX (cache_size, 2);
/* don't use a cache if its necessary size is too big */
if (cache_size > GRADIENT_CACHE_MAX_SIZE)
{
g_mutex_unlock (&self->gradient_cache_mutex);
return;
}
self->gradient_cache = g_new0 (PikaRGB, cache_size);
self->gradient_cache_size = cache_size;
for (i = 0; i < self->gradient_cache_size; i++)
{
gdouble factor = (gdouble) i / (gdouble) (self->gradient_cache_size - 1);
last_seg = pika_gradient_get_color_at (self->gradient, NULL, last_seg,
factor,
self->gradient_reverse,
self->gradient_blend_color_space,
self->gradient_cache + i);
}
g_mutex_unlock (&self->gradient_cache_mutex);
}