mirror of https://github.com/GNOME/gimp.git
327 lines
10 KiB
C
327 lines
10 KiB
C
/* GIMP - The GNU Image Manipulation Program
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
*
|
|
* Auntie Alias 0.92 --- image filter plug-in
|
|
*
|
|
* Copyright (C) 2005 Adam D. Moss (adam@gimp.org)
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this plug-in (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use, copy, modify,
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
|
* and to permit persons to whom the Software is furnished to do so, subject
|
|
* to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
/* This plugin performs a pseudo-antialiasing effect on hard-edged source
|
|
* material. It does this by performing a 'clever' edge extrapolation for
|
|
* each pixel which is then resampled back to a single pixel for output.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <libgimp/gimp.h>
|
|
#include <libgimp/gimpui.h>
|
|
|
|
#include "libgimp/stdplugins-intl.h"
|
|
|
|
|
|
/* Constants */
|
|
|
|
#define PLUG_IN_PROC "plug-in-antialias"
|
|
|
|
|
|
/* Local function prototypes */
|
|
|
|
static void query (void);
|
|
static void run (const gchar *name,
|
|
gint nparams,
|
|
const GimpParam *param,
|
|
gint *nreturn_vals,
|
|
GimpParam **return_vals);
|
|
static void render (GimpDrawable *drawable);
|
|
|
|
|
|
/* Local variables */
|
|
|
|
GimpPlugInInfo PLUG_IN_INFO =
|
|
{
|
|
NULL, /* init_proc */
|
|
NULL, /* quit_proc */
|
|
query, /* query_proc */
|
|
run, /* run_proc */
|
|
};
|
|
|
|
|
|
MAIN ()
|
|
|
|
|
|
static void
|
|
query (void)
|
|
{
|
|
static GimpParamDef args[] =
|
|
{
|
|
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
|
|
{ GIMP_PDB_IMAGE, "image", "Input image" },
|
|
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
|
|
};
|
|
|
|
gimp_install_procedure (PLUG_IN_PROC,
|
|
N_("Antialias using the Scale3X edge-extrapolation "
|
|
"algorithm"),
|
|
"Help - write me",
|
|
"Adam D. Moss <adam@gimp.org>",
|
|
"Adam D. Moss <adam@gimp.org>",
|
|
"2005",
|
|
N_("_Antialias"),
|
|
"RGB*, GRAY*",
|
|
GIMP_PLUGIN,
|
|
G_N_ELEMENTS (args), 0,
|
|
args, NULL);
|
|
|
|
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Enhance");
|
|
}
|
|
|
|
static void
|
|
run (const gchar *name,
|
|
gint n_params,
|
|
const GimpParam *param,
|
|
gint *nreturn_vals,
|
|
GimpParam **return_vals)
|
|
{
|
|
static GimpParam values[1];
|
|
GimpRunMode run_mode;
|
|
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
|
|
|
|
INIT_I18N ();
|
|
|
|
*nreturn_vals = 1;
|
|
*return_vals = values;
|
|
|
|
run_mode = param[0].data.d_int32;
|
|
|
|
if (strcmp (name, PLUG_IN_PROC) == 0)
|
|
{
|
|
switch (run_mode)
|
|
{
|
|
case GIMP_RUN_NONINTERACTIVE:
|
|
if (n_params != 3)
|
|
status = GIMP_PDB_CALLING_ERROR;
|
|
break;
|
|
|
|
case GIMP_RUN_INTERACTIVE:
|
|
break;
|
|
|
|
case GIMP_RUN_WITH_LAST_VALS:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = GIMP_PDB_CALLING_ERROR;
|
|
}
|
|
|
|
if (status == GIMP_PDB_SUCCESS)
|
|
{
|
|
GimpDrawable *drawable;
|
|
gint32 image_ID;
|
|
|
|
image_ID = param[1].data.d_int32;
|
|
drawable = gimp_drawable_get (param[2].data.d_drawable);
|
|
|
|
gimp_progress_init (_("Antialiasing..."));
|
|
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
|
|
|
|
render (drawable);
|
|
|
|
if (run_mode != GIMP_RUN_NONINTERACTIVE)
|
|
gimp_displays_flush ();
|
|
|
|
gimp_drawable_detach (drawable);
|
|
}
|
|
|
|
values[0].type = GIMP_PDB_STATUS;
|
|
values[0].data.d_status = status;
|
|
}
|
|
|
|
static int
|
|
extrapolate9 (const int bytes,
|
|
unsigned char *E0, unsigned char *E1, unsigned char *E2,
|
|
unsigned char *E3, unsigned char *E4, unsigned char *E5,
|
|
unsigned char *E6, unsigned char *E7, unsigned char *E8,
|
|
unsigned char *A, unsigned char *B, unsigned char *C,
|
|
unsigned char *D, unsigned char *E, unsigned char *F,
|
|
unsigned char *G, unsigned char *H, unsigned char *I)
|
|
{
|
|
#define PEQ(X,Y) (0==memcmp(X,Y,bytes))
|
|
#define PCPY(DST,SRC) do{memcpy(DST,SRC,bytes);}while(0)
|
|
|
|
/* an implementation of the Scale3X edge-extrapolation algorithm */
|
|
if ( (!PEQ(B,H)) && (!PEQ(D,F)) )
|
|
{
|
|
if (PEQ(D,B)) PCPY(E0,D); else PCPY(E0,E);
|
|
if ((PEQ(D,B) && !PEQ(E,C)) || (PEQ(B,F) && !PEQ(E,A)))
|
|
PCPY(E1,B); else PCPY(E1,E);
|
|
if (PEQ(B,F)) PCPY(E2,F); else PCPY(E2,E);
|
|
if ((PEQ(D,B) && !PEQ(E,G)) || (PEQ(D,H) && !PEQ(E,A)))
|
|
PCPY(E3,D); else PCPY(E3,E);
|
|
PCPY(E4,E);
|
|
if ((PEQ(B,F) && !PEQ(E,I)) || (PEQ(H,F) && !PEQ(E,C)))
|
|
PCPY(E5,F); else PCPY(E5,E);
|
|
if (PEQ(D,H)) PCPY(E6,D); else PCPY(E6,E);
|
|
if ((PEQ(D,H) && !PEQ(E,I)) || (PEQ(H,F) && !PEQ(E,G)))
|
|
PCPY(E7,H); else PCPY(E7,E);
|
|
if (PEQ(H,F)) PCPY(E8,F); else PCPY(E8,E);
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#undef PEQ
|
|
#undef PCPY
|
|
}
|
|
|
|
static void
|
|
render (GimpDrawable *drawable)
|
|
{
|
|
gint width, height, bytes;
|
|
gint x, y, w, h;
|
|
gint row, col, b;
|
|
GimpPixelRgn srcPR, destPR;
|
|
guchar *rowbefore;
|
|
guchar *rowthis;
|
|
guchar *rowafter;
|
|
guchar *dest;
|
|
guchar *ninepix;
|
|
gboolean has_alpha;
|
|
guint alpha;
|
|
|
|
/* get bounds of working area */
|
|
if (! gimp_drawable_mask_intersect (drawable->drawable_id, &x, &y, &w, &h))
|
|
return;
|
|
|
|
width = drawable->width;
|
|
height = drawable->height;
|
|
bytes = drawable->bpp;
|
|
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
|
|
alpha = bytes - 1;
|
|
|
|
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height, FALSE, FALSE);
|
|
gimp_pixel_rgn_init (&destPR, drawable, 0, 0, width, height, TRUE, TRUE);
|
|
|
|
rowbefore = g_new (guchar, (width + 2) * bytes);
|
|
rowthis = g_new (guchar, (width + 2) * bytes);
|
|
rowafter = g_new (guchar, (width + 2) * bytes);
|
|
dest = g_new (guchar, (width + 2) * bytes);
|
|
ninepix = g_new (guchar, 9 * bytes);
|
|
|
|
gimp_pixel_rgn_get_row (&srcPR, &rowthis[bytes], 0, y, width);
|
|
memcpy (&rowthis[0], &rowthis[bytes], bytes);
|
|
memcpy (&rowthis[(width+1)*bytes], &rowthis[(width)*bytes], bytes);
|
|
memcpy (rowbefore, rowthis, (width+2)*bytes);
|
|
memcpy (rowafter, rowthis, (width+2)*bytes);
|
|
|
|
for (row = y; row < (y + h); ++row)
|
|
{
|
|
guchar *tmp;
|
|
gint srcrowafter = row + 1;
|
|
|
|
if (srcrowafter >= (y + h - 1))
|
|
srcrowafter = y + h - 1;
|
|
|
|
/* rotate pointers */
|
|
tmp = rowbefore;
|
|
rowbefore = rowthis;
|
|
rowthis = rowafter;
|
|
rowafter = tmp;
|
|
|
|
/* populate new after-row */
|
|
gimp_pixel_rgn_get_row (&srcPR, &rowafter[bytes], 0, srcrowafter, width);
|
|
memcpy (&rowafter[0], &rowafter[bytes], bytes);
|
|
memcpy (&rowafter[(width + 1) * bytes], &rowafter[width * bytes], bytes);
|
|
|
|
/* this macro returns the current pixel if it has some opacity. Otherwise
|
|
* it returns the center pixel of the current 3x3 area. */
|
|
#define USE_IF_ALPHA(p) (((!has_alpha) || *((p)+alpha)) ? (p) : &rowthis[(col+1)*bytes])
|
|
|
|
for (col = x; col < (x + w); ++col)
|
|
{
|
|
/* do 9x extrapolation pass */
|
|
if (((!has_alpha) || (rowthis[(col+1)*bytes+alpha])) &&
|
|
extrapolate9 (bytes,
|
|
&ninepix[0*bytes],
|
|
&ninepix[1*bytes],
|
|
&ninepix[2*bytes],
|
|
&ninepix[3*bytes],
|
|
&ninepix[4*bytes],
|
|
&ninepix[5*bytes],
|
|
&ninepix[6*bytes],
|
|
&ninepix[7*bytes],
|
|
&ninepix[8*bytes],
|
|
USE_IF_ALPHA (&rowbefore[(col+0)*bytes]),
|
|
USE_IF_ALPHA (&rowbefore[(col+1)*bytes]),
|
|
USE_IF_ALPHA (&rowbefore[(col+2)*bytes]),
|
|
USE_IF_ALPHA (&rowthis [(col+0)*bytes]),
|
|
&rowthis [(col+1)*bytes],
|
|
USE_IF_ALPHA (&rowthis [(col+2)*bytes]),
|
|
USE_IF_ALPHA (&rowafter [(col+0)*bytes]),
|
|
USE_IF_ALPHA (&rowafter [(col+1)*bytes]),
|
|
USE_IF_ALPHA (&rowafter [(col+2)*bytes])
|
|
))
|
|
{
|
|
/* subsample results and put into dest */
|
|
for (b = 0; b < bytes; ++b)
|
|
{
|
|
dest[(col * bytes) + b] =
|
|
(3*ninepix[0*bytes+b]+5*ninepix[1*bytes+b]+3*ninepix[2*bytes+b]+
|
|
5*ninepix[3*bytes+b]+6*ninepix[4*bytes+b]+5*ninepix[5*bytes+b]+
|
|
3*ninepix[6*bytes+b]+5*ninepix[7*bytes+b]+3*ninepix[8*bytes+b]+
|
|
19) / 38;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memcpy (&dest[col * bytes], &rowthis[(col + 1) * bytes], bytes);
|
|
}
|
|
}
|
|
|
|
#undef USE_IF_ALPHA
|
|
|
|
/* write result row to dest */
|
|
gimp_pixel_rgn_set_row (&destPR, &dest[x * bytes],
|
|
x, row, w);
|
|
if ((row & 31) == 0)
|
|
gimp_progress_update ((gdouble) row / (gdouble) h);
|
|
}
|
|
|
|
gimp_progress_update ((gdouble) 100);
|
|
gimp_drawable_flush (drawable);
|
|
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
|
|
gimp_drawable_update (drawable->drawable_id, x, y, w, h);
|
|
|
|
g_free (rowbefore);
|
|
g_free (rowthis);
|
|
g_free (rowafter);
|
|
g_free (dest);
|
|
g_free (ninepix);
|
|
}
|