Commit b5629497 authored by Robert Sasu's avatar Robert Sasu Committed by Mukund Sivaraman

emboss: Add the emboss op from soc-2011-ops branch

parent 10d40786
/* 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 1997 Eric L. Hernes (erich@rrnet.com)
* Copyright 2011 Robert Sasu (sasu.robert@gmail.com)
*/
#include "config.h"
#include <glib/gi18n-lib.h>
#ifdef GEGL_CHANT_PROPERTIES
gegl_chant_double (azimuth, _("Azimuth"), 0.0, 360.0, 30.0,
_("The value of azimuth"))
gegl_chant_double (elevation, _("Elevation"), 0.0, 180.0, 45.0,
_("The value of elevation"))
gegl_chant_int (depth, _("Depth"), 1, 100, 20,
_("Pixel depth"))
gegl_chant_string (filter, _("Filter"), "emboss",
_("Optional parameter to override automatic selection "
"of emboss filter. Choices are emboss, blur-map"))
#else
#define GEGL_CHANT_TYPE_AREA_FILTER
#define GEGL_CHANT_C_FILE "emboss.c"
#include "gegl-chant.h"
#include <math.h>
#include <stdio.h>
#define DEG_TO_RAD(d) (((d) * G_PI) / 180.0)
/*
* ANSI C code from the article
* "Fast Embossing Effects on Raster Image Data"
* by John Schlag, jfs@kerner.com
* in "Graphics Gems IV", Academic Press, 1994
*
* Emboss - shade 24-bit pixels using a single distant light source.
* Normals are obtained by differentiating a monochrome 'bump' image.
* The unary case ('texture' == NULL) uses the shading result as output.
* The binary case multiples the optional 'texture' image by the shade.
* Images are in row major order with interleaved color components
* (rgbrgb...). E.g., component c of pixel x,y of 'dst' is
* dst[3*(y*width + x) + c].
*/
static void
emboss (gfloat *src_buf,
const GeglRectangle *src_rect,
gfloat *dst_buf,
const GeglRectangle *dst_rect,
gint x,
gchar *text,
gint floats_per_pixel,
gint alpha,
gdouble azimuth,
gdouble elevation,
gint width45)
{
gint y;
gint offset, verify;
gint bytes;
gdouble Lx, Ly, Lz;
gdouble Nz, Nz2, NzLz;
Lx = cos (azimuth) * cos (elevation);
Ly = sin (azimuth) * cos (elevation);
Lz = sin (elevation);
Nz = 1.0 / width45;
Nz2 = Nz * Nz;
NzLz = Nz * Lz;
bytes = (alpha) ? floats_per_pixel - 1 : floats_per_pixel;
verify = src_rect->width * src_rect->height * floats_per_pixel;
offset = x * dst_rect->width * floats_per_pixel;
for (y = 0; y < dst_rect->width; y++)
{
gint i, j, b, count;
gfloat Nx, Ny, NdotL;
gfloat shade;
gfloat M[3][3];
gfloat a;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
M[i][j] = 0.0;
for (b = 0; b < bytes; b++)
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
{
count = ((x+i-1)*src_rect->width + (y+j-1))*floats_per_pixel + bytes;
/*verify each time that we are in the source image*/
if (alpha && count >= 0 && count < verify)
a = src_buf[count];
else
a = 1.0;
/*calculate recalculate the sorrounding pixels by multiplication*/
/*after we have that we can calculate new value of the pixel*/
if ((count - bytes + b) >= 0 && (count - bytes + b) < verify)
M[i][j] += a * src_buf[count - bytes + b];
}
Nx = M[0][0] + M[1][0] + M[2][0] - M[0][2] - M[1][2] - M[2][2];
Ny = M[2][0] + M[2][1] + M[2][2] - M[0][0] - M[0][1] - M[0][2];
/*calculating the shading result (same as in gimp)*/
if ( Nx == 0 && Ny == 0 )
shade = Lz;
else if ( (NdotL = Nx * Lx + Ny * Ly + NzLz) < 0 )
shade = 0;
else
shade = NdotL / sqrt(Nx*Nx + Ny*Ny + Nz2);
count = (x*src_rect->width + y)*floats_per_pixel;
/*setting the value of the destination buffer*/
if (bytes == 1)
dst_buf[offset++] = shade;
else
{
/*recalculating every byte of a pixel*/
/*by multiplying with the shading result*/
for (b = 0; b < bytes; b++)
if ((count + b) >= 0 && (count + b) < verify)
dst_buf[offset++] = (src_buf[count+b] * shade) ;
else
dst_buf[offset++] = 1.0;
/*preserving alpha*/
if (alpha && (count + bytes) >= 0 && (count + bytes) < verify)
dst_buf[offset++] = src_buf[count + bytes];
else
dst_buf[offset++] = 1.0 ;
}
}
}
static void
prepare (GeglOperation *operation)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
op_area->left = op_area->right = op_area->top = op_area->bottom = 3;
if (o->filter && !strcmp(o->filter, "blur-map"))
gegl_operation_set_format (operation, "output",
babl_format ("RGBA float"));
else
gegl_operation_set_format (operation, "output",
babl_format ("Y float"));
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglRectangle rect;
gfloat *src_buf;
gfloat *dst_buf;
gchar *type;
gint alpha;
gint x;
gint floats_per_pixel;
/*blur-map or emboss*/
if (o->filter && !strcmp (o->filter, "blur-map"))
{
type = "RGBA float";
floats_per_pixel = 4;
alpha = 1;
}
else
{
type = "Y float";
floats_per_pixel = 1;
alpha = 0;
}
rect.x = result->x - op_area->left;
rect.width = result->width + op_area->left + op_area->right;
rect.y = result->y - op_area->top;
rect.height = result->height + op_area->top + op_area->bottom;
src_buf = g_new0 (gfloat, rect.width * rect.height * floats_per_pixel);
dst_buf = g_new0 (gfloat, rect.width * rect.height * floats_per_pixel);
gegl_buffer_get (input, 1.0, &rect, babl_format (type),
src_buf, GEGL_AUTO_ROWSTRIDE);
/*do for every row*/
for (x = 0; x < rect.height; x++)
emboss (src_buf, &rect, dst_buf, &rect, x, type, floats_per_pixel, alpha,
DEG_TO_RAD (o->azimuth), DEG_TO_RAD (o->elevation), o->depth);
gegl_buffer_set (output, &rect, babl_format (type),
dst_buf, GEGL_AUTO_ROWSTRIDE);
g_free (src_buf);
g_free (dst_buf);
return TRUE;
}
static void
gegl_chant_class_init (GeglChantClass *klass)
{
GeglOperationClass *operation_class;
GeglOperationFilterClass *filter_class;
operation_class = GEGL_OPERATION_CLASS (klass);
filter_class = GEGL_OPERATION_FILTER_CLASS (klass);
filter_class->process = process;
operation_class->prepare = prepare;
operation_class->categories = "distort";
operation_class->name = "gegl:emboss";
operation_class->description =
_("Simulates an image created by embossing.");
}
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment