/* This file is an image processing operation for GEGL
*
* GEGL is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* GEGL 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with GEGL; if not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2007 Mukund Sivaraman <muks@mukund.org>
*/
/* XXX
* This plug-in isn't really useful apart for compatibility with GIMP
* scripts, operating with HSV as a color model for filters isn't really
* useful.
*/
/*
* The plug-in only does v = 1.0 - v; for each pixel in the image, or
* each entry in the colormap depending upon the type of image, where 'v'
* is the value in HSV color model.
*
* The plug-in code is optimized towards this, in that it is not a full
* RGB->HSV->RGB transform, but shortcuts many of the calculations to
* effectively only do v = 1.0 - v. In fact, hue is never calculated. The
* shortcuts can be derived from running a set of r, g, b values through the
* RGB->HSV transform and then from HSV->RGB and solving out the redundant
* portions.
*
*/
#include "config.h"
#include <glib/gi18n-lib.h>
#ifdef GEGL_CHANT_PROPERTIES
/* no properties */
#else
#define GEGL_CHANT_TYPE_POINT_FILTER
#define GEGL_CHANT_C_FILE "value-invert.c"
#include "gegl-chant.h"
static void
prepare (GeglOperation *operation)
{
gegl_operation_set_format (operation, "input", babl_format ("R'G'B'A float"));
gegl_operation_set_format (operation, "output", babl_format ("R'G'B'A float"));
}
static gboolean
process (GeglOperation *op,
void *in_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi,
gint level)
{
glong j;
gfloat *src = in_buf;
gfloat *dest = out_buf;
gfloat r, g, b;
gfloat value, min;
gfloat delta;
for (j = 0; j < samples; j++)
{
r = *src++;
g = *src++;
b = *src++;
if (r > g)
{
value = MAX (r, b);
min = MIN (g, b);
}
else
{
value = MAX (g, b);
min = MIN (r, b);
}
delta = value - min;
if ((value == 0) || (delta == 0))
{
r = 1.0 - value;
g = 1.0 - value;
b = 1.0 - value;
}
else
{
if (r == value)
{
r = 1.0 - r;
b = r * b / value;
g = r * g / value;
}
else if (g == value)
{
g = 1.0 - g;
r = g * r / value;
b = g * b / value;
}
else
{
b = 1.0 - b;
g = b * g / value;
r = b * r / value;
}
}
*dest++ = r;
*dest++ = g;
*dest++ = b;
*dest++ = *src++;
}
return TRUE;
}
#include "opencl/gegl-cl.h"
static const char* kernel_source =
"__kernel void kernel_vinv(__global const float4 *in, \n"
" __global float4 *out) \n"
"{ \n"
" int gid = get_global_id(0); \n"
" float4 in_v = in[gid]; \n"
" float4 out_v; \n"
" \n"
" float value = fmax (in_v.x, fmax (in_v.y, in_v.z)); \n"
" float minv = fmin (in_v.x, fmin (in_v.y, in_v.z)); \n"
" float delta = value - minv; \n"
" \n"
" if (value == 0.0f || delta == 0.0f) \n"
" { \n"
" out_v.xyz = (float3) (1.0f - value); \n"
" } \n"
" else \n"
" { \n"
" if (in_v.x == value) \n"
" { \n"
" out_v.xzy = (float3) ((1.0f - in_v.x), \n"
" (1.0f - in_v.x) * in_v.z / value, \n"
" (1.0f - in_v.x) * in_v.y / value); \n"
" } \n"
" else if (in_v.y == value) \n"
" { \n"
" out_v.yxz = (float3) ((1.0f - in_v.y), \n"
" (1.0f - in_v.y) * in_v.x / value, \n"
" (1.0f - in_v.y) * in_v.z / value); \n"
" } \n"
" else \n"
" { \n"
" out_v.zyx = (float3) ((1.0f - in_v.z), \n"
" (1.0f - in_v.z) * in_v.y / value, \n"
" (1.0f - in_v.z) * in_v.x / value); \n"
" } \n"
" } \n"
" \n"
" out_v.w = in_v.w; \n"
" out[gid] = out_v; \n"
"} \n";
static gegl_cl_run_data *cl_data = NULL;
/* OpenCL processing function */
static cl_int
cl_process (GeglOperation *op,
cl_mem in_tex,
cl_mem out_tex,
size_t global_worksize,
const GeglRectangle *roi,
int level)
{
cl_int cl_err = 0;
if (!cl_data)
{
const char *kernel_name[] = {"kernel_vinv", NULL};
cl_data = gegl_cl_compile_and_build (kernel_source, kernel_name);
}
if (!cl_data) return 1;
cl_err |= gegl_clSetKernelArg(cl_data->kernel[0], 0, sizeof(cl_mem), (void*)&in_tex);
cl_err |= gegl_clSetKernelArg(cl_data->kernel[0], 1, sizeof(cl_mem), (void*)&out_tex);
if (cl_err != CL_SUCCESS) return cl_err;
cl_err = gegl_clEnqueueNDRangeKernel(gegl_cl_get_command_queue (),
cl_data->kernel[0], 1,
NULL, &global_worksize, NULL,
0, NULL, NULL);
if (cl_err != CL_SUCCESS) return cl_err;
return cl_err;
}
static void
gegl_chant_class_init (GeglChantClass *klass)
{
GeglOperationClass *operation_class;
GeglOperationPointFilterClass *point_filter_class;
operation_class = GEGL_OPERATION_CLASS (klass);
point_filter_class = GEGL_OPERATION_POINT_FILTER_CLASS (klass);
point_filter_class->process = process;
operation_class->prepare = prepare;
point_filter_class->cl_process = cl_process;
operation_class->opencl_support = TRUE;
gegl_operation_class_set_keys (operation_class,
"name" , "gegl:value-invert",
"categories" , "color",
"description",
_("Inverts just the value component, the result is the corresponding "
"`inverted' image."),
NULL);
}
#endif