/************************************************** * file: nlfilt/nlfilt.c * * Copyright (c) 1997 Eric L. Hernes (erich@rrnet.com) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. The name of the author may not be used to endorse or promote products * derived from this software withough specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * Algorithm fixes, V2.0 compatibility by David Hodson hodsond@ozemail.com.au */ #include "config.h" #include #include #include #include "libgimp/stdplugins-intl.h" #define PLUG_IN_PROC "plug-in-nlfilt" #define PLUG_IN_BINARY "nl-filter" #define PLUG_IN_ROLE "gimp-nl-filter" typedef struct { gdouble alpha; gdouble radius; gint filter; } NLFilterValues; typedef enum { filter_alpha_trim, filter_opt_est, filter_edge_enhance } FilterType; static NLFilterValues nlfvals = { 0.3, 0.3, 0 }; /* function protos */ static void query (void); static void run (const gchar *name, gint nparam, const GimpParam *param, gint *nretvals, GimpParam **retvals); static void nlfilter (GimpDrawable *drawable, GimpPreview *preview); static gboolean nlfilter_dialog (GimpDrawable *drawable); static gint nlfiltInit (gdouble alpha, gdouble radius, FilterType filter); static void nlfiltRow (guchar *srclast, guchar *srcthis, guchar *srcnext, guchar *dst, gint width, gint bpp, gint filtno); const GimpPlugInInfo PLUG_IN_INFO = { NULL, /* init_proc */ NULL, /* quit_proc */ query, /* query_proc */ run, /* run_proc */ }; MAIN () static void query (void) { static const GimpParamDef args[] = { { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, { GIMP_PDB_IMAGE, "img", "The Image to Filter" }, { GIMP_PDB_DRAWABLE, "drw", "The Drawable" }, { GIMP_PDB_FLOAT, "alpha", "The amount of the filter to apply" }, { GIMP_PDB_FLOAT, "radius", "The filter radius" }, { GIMP_PDB_INT32, "filter", "The Filter to Run, " "0 - alpha trimmed mean; " "1 - optimal estimation (alpha controls noise variance); " "2 - edge enhancement" } }; gimp_install_procedure (PLUG_IN_PROC, N_("Nonlinear swiss army knife filter"), "This is the pnmnlfilt, in gimp's clothing. " "See the pnmnlfilt manpage for details.", "Graeme W. Gill, gimp 0.99 plugin by Eric L. Hernes", "Graeme W. Gill, Eric L. Hernes", "1997", N_("_NL Filter..."), "RGB,GRAY", GIMP_PLUGIN, G_N_ELEMENTS (args), 0, args, NULL); gimp_plugin_menu_register (PLUG_IN_PROC, "/Filters/Enhance"); } static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; INIT_I18N (); drawable = gimp_drawable_get (param[2].data.d_drawable); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; switch (run_mode) { case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC, &nlfvals); if (! nlfilter_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: if (nparams != 6) { status = GIMP_PDB_CALLING_ERROR; } else { nlfvals.alpha = param[3].data.d_float; nlfvals.radius = param[4].data.d_float; nlfvals.filter = param[5].data.d_int32; } break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC, &nlfvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { nlfilter (drawable, NULL); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &nlfvals, sizeof (NLFilterValues)); } values[0].data.d_status = status; gimp_drawable_detach (drawable); } /* pnmnlfilt.c - 4 in 1 (2 non-linear) filter ** - smooth an anyimage ** - do alpha trimmed mean filtering on an anyimage ** - do optimal estimation smoothing on an anyimage ** - do edge enhancement on an anyimage ** ** Version 1.0 ** ** The implementation of an alpha-trimmed mean filter ** is based on the description in IEEE CG&A May 1990 ** Page 23 by Mark E. Lee and Richard A. Redner. ** ** The paper recommends using a hexagon sampling region around each ** pixel being processed, allowing an effective sub pixel radius to be ** specified. The hexagon values are sythesised by area sampling the ** rectangular pixels with a hexagon grid. The seven hexagon values ** obtained from the 3x3 pixel grid are used to compute the alpha ** trimmed mean. Note that an alpha value of 0.0 gives a conventional ** mean filter (where the radius controls the contribution of ** surrounding pixels), while a value of 0.5 gives a median filter. ** Although there are only seven values to trim from before finding ** the mean, the algorithm has been extended from that described in ** CG&A by using interpolation, to allow a continuous selection of ** alpha value between and including 0.0 to 0.5 The useful values ** for radius are between 0.3333333 (where the filter will have no ** effect because only one pixel is sampled), to 1.0, where all ** pixels in the 3x3 grid are sampled. ** ** The optimal estimation filter is taken from an article "Converting Dithered ** Images Back to Gray Scale" by Allen Stenger, Dr Dobb's Journal, November ** 1992, and this article references "Digital Image Enhancement andNoise Filtering by ** Use of Local Statistics", Jong-Sen Lee, IEEE Transactions on Pattern Analysis and ** Machine Intelligence, March 1980. ** ** Also borrow the technique used in pgmenhance(1) to allow edge ** enhancement if the alpha value is negative. ** ** Author: ** Graeme W. Gill, 30th Jan 1993 ** graeme@labtam.oz.au ** ** Permission is hereby granted, to use, copy, modify, distribute, ** and sell this software and its associated documentation files ** (the "Software") for any purpose without fee, provided ** that: ** ** 1) The above copyright notices and this permission notice ** accompany all source code copies of the Software and ** related documentation. ** and ** ** 2) If executable code based on the Software only is distributed, ** then the accompanying documentation must acknowledge that ** "this software is based in part on the work of Graeme W. Gill". ** and ** ** 3) It is accepted that Graeme W. Gill (the "Author") accepts ** NO LIABILITY for damages of any kind. The Software is ** provided without fee by the Author "AS-IS" and without ** warranty of any kind, express, implied or otherwise, ** including without limitation, any warranty of merchantability ** or fitness for a particular purpose. ** and ** ** 4) These conditions apply to any software derived from or based ** on the Software, not just to the unmodified library. ** */ /* ************************************************** */ /* Hexagon intersecting square area functions */ /* Compute the area of the intersection of a triangle */ /* and a rectangle */ static gdouble triang_area(gdouble, gdouble, gdouble, gdouble, gdouble, gdouble, gdouble, gdouble, gint); static gdouble rectang_area(gdouble, gdouble, gdouble, gdouble, gdouble, gdouble, gdouble, gdouble); static gdouble hex_area(gdouble, gdouble, gdouble, gdouble, gdouble); static gint atfilt0 (gint *p); static gint atfilt1 (gint *p); static gint atfilt2 (gint *p); static gint atfilt3 (gint *p); static gint atfilt4 (gint *p); static gint atfilt5 (gint *p); gint (*atfuncs[6])(gint *) = { atfilt0, atfilt1, atfilt2, atfilt3, atfilt4, atfilt5 }; static gint noisevariance; #define MXIVAL 255 /* maximum input value */ #define NOIVAL (MXIVAL + 1) /* number of possible input values */ #define SCALEB 8 /* scale bits */ #define SCALE (1 << SCALEB) /* scale factor */ #define CSCALEB 2 /* coarse scale bits */ #define CSCALE (1 << CSCALEB) /* coarse scale factor */ #define MXCSVAL (MXIVAL * CSCALE) /* maximum coarse scaled values */ #define NOCSVAL (MXCSVAL + 1) /* number of coarse scaled values */ #define SCTOCSC(x) ((x) >> (SCALEB - CSCALEB)) /* convert from scaled to coarse scaled */ #define CSCTOSC(x) ((x) << (SCALEB - CSCALEB)) /* convert from course scaled to scaled */ /* round and scale floating point to scaled integer */ #define SROUND(x) ((gint)(((x) * (gdouble)SCALE) + 0.5)) /* round and un-scale scaled integer value */ #define RUNSCALE(x) (((x) + (1 << (SCALEB-1))) >> SCALEB) /* rounded un-scale */ #define UNSCALE(x) ((x) >> SCALEB) /* Note: modified by David Hodson, nlfiltRow now accesses * srclast, srcthis, and srcnext from [-bpp] to [width*bpp-1]. * Beware if you use this code anywhere else! */ static void nlfiltRow (guchar *srclast, guchar *srcthis, guchar *srcnext, guchar *dst, gint width, gint bpp, gint filtno) { gint pf[9]; guchar *ip0, *ip1, *ip2, *or, *orend; orend = dst + width * bpp; ip0 = srclast; ip1 = srcthis; ip2 = srcnext; for (or = dst; or < orend; ip0++, ip1++, ip2++, or++) { pf[0] = *ip1; pf[1] = *(ip1 - bpp); pf[2] = *(ip2 - bpp); pf[3] = *(ip2); pf[4] = *(ip2 + bpp); pf[5] = *(ip1 + bpp); pf[6] = *(ip0 + bpp); pf[7] = *(ip0); pf[8] = *(ip0 - bpp); *or=(atfuncs[filtno])(pf); } } /* We restrict radius to the values: 0.333333 <= radius <= 1.0 */ /* so that no fewer and no more than a 3x3 grid of pixels around */ /* the pixel in question needs to be read. Given this, we only */ /* need 3 or 4 weightings per hexagon, as follows: */ /* _ _ */ /* Virtical hex: |_|_| 1 2 */ /* |X|_| 0 3 */ /* _ */ /* _ _|_| 1 */ /* Middle hex: |_| 1 Horizontal hex: |X|_| 0 2 */ /* |X| 0 |_| 3 */ /* |_| 2 */ /* all filters */ gint V0[NOIVAL],V1[NOIVAL],V2[NOIVAL],V3[NOIVAL]; /* vertical hex */ gint M0[NOIVAL],M1[NOIVAL],M2[NOIVAL]; /* middle hex */ gint H0[NOIVAL],H1[NOIVAL],H2[NOIVAL],H3[NOIVAL]; /* horizontal hex */ /* alpha trimmed and edge enhancement only */ gint ALFRAC[NOIVAL * 8]; /* fractional alpha divider table */ /* optimal estimation only */ gint AVEDIV[7 * NOCSVAL]; /* divide by 7 to give average value */ gint SQUARE[2 * NOCSVAL]; /* scaled square lookup table */ /* Table initialisation function - return alpha range */ static gint nlfiltInit (gdouble alpha, gdouble radius, FilterType filter) { gint alpharange; /* alpha range value 0 - 3 */ gdouble meanscale; /* scale for finding mean */ gdouble mmeanscale; /* scale for finding mean - midle hex */ gdouble alphafraction; /* fraction of next largest/smallest * to subtract from sum */ switch (filter) { case filter_alpha_trim: { gdouble noinmean; /* alpha only makes sense in range 0.0 - 0.5 */ alpha /= 2.0; /* number of elements (out of a possible 7) used in the mean */ noinmean = ((0.5 - alpha) * 12.0) + 1.0; mmeanscale = meanscale = 1.0/noinmean; if (alpha == 0.0) { /* mean filter */ alpharange = 0; alphafraction = 0.0; /* not used */ } else if (alpha < (1.0/6.0)) { /* mean of 5 to 7 middle values */ alpharange = 1; alphafraction = (7.0 - noinmean)/2.0; } else if (alpha < (1.0/3.0)) { /* mean of 3 to 5 middle values */ alpharange = 2; alphafraction = (5.0 - noinmean)/2.0; } else { /* mean of 1 to 3 middle values */ /* alpha==0.5 => median filter */ alpharange = 3; alphafraction = (3.0 - noinmean)/2.0; } } break; case filter_opt_est: { gint i; gdouble noinmean = 7.0; /* edge enhancement function */ alpharange = 5; /* compute scaled hex values */ mmeanscale=meanscale=1.0; /* Set up 1:1 division lookup - not used */ alphafraction=1.0/noinmean; /* estimate of noise variance */ noisevariance = alpha * (gdouble)255; noisevariance = noisevariance * noisevariance / 8.0; /* set yp optimal estimation specific stuff */ for (i=0;i<(7*NOCSVAL);i++) { /* divide scaled value by 7 lookup */ AVEDIV[i] = CSCTOSC(i)/7; /* scaled divide by 7 */ } /* compute square and rescale by * (val >> (2 * SCALEB + 2)) table */ for (i=0;i<(2*NOCSVAL);i++) { gint val; /* NOCSVAL offset to cope with -ve input values */ val = CSCTOSC(i - NOCSVAL); SQUARE[i] = (val * val) >> (2 * SCALEB + 2); } } break; case filter_edge_enhance: { if (alpha == 1.0) alpha = 0.99; alpharange = 4; /* mean of 7 and scaled by -alpha/(1-alpha) */ meanscale = 1.0 * (-alpha/((1.0 - alpha) * 7.0)); /* middle pixel has 1/(1-alpha) as well */ mmeanscale = 1.0 * (1.0/(1.0 - alpha) + meanscale); alphafraction = 0.0; /* not used */ } break; default: g_printerr ("unknown filter %d\n", filter); return -1; } /* * Setup pixel weighting tables - * note we pre-compute mean division here too. */ { gint i; gdouble hexhoff,hexvoff; gdouble tabscale,mtabscale; gdouble v0,v1,v2,v3,m0,m1,m2,h0,h1,h2,h3; /* horizontal offset of virtical hex centers */ hexhoff = radius/2; /* vertical offset of virtical hex centers */ hexvoff = 3.0 * radius/sqrt(12.0); /* * scale tables to normalise by hexagon * area, and number of hexes used in mean */ tabscale = meanscale / (radius * hexvoff); mtabscale = mmeanscale / (radius * hexvoff); v0 = hex_area(0.0,0.0,hexhoff,hexvoff,radius) * tabscale; v1 = hex_area(0.0,1.0,hexhoff,hexvoff,radius) * tabscale; v2 = hex_area(1.0,1.0,hexhoff,hexvoff,radius) * tabscale; v3 = hex_area(1.0,0.0,hexhoff,hexvoff,radius) * tabscale; m0 = hex_area(0.0,0.0,0.0,0.0,radius) * mtabscale; m1 = hex_area(0.0,1.0,0.0,0.0,radius) * mtabscale; m2 = hex_area(0.0,-1.0,0.0,0.0,radius) * mtabscale; h0 = hex_area(0.0,0.0,radius,0.0,radius) * tabscale; h1 = hex_area(1.0,1.0,radius,0.0,radius) * tabscale; h2 = hex_area(1.0,0.0,radius,0.0,radius) * tabscale; h3 = hex_area(1.0,-1.0,radius,0.0,radius) * tabscale; for (i=0; i <= MXIVAL; i++) { gdouble fi; fi = (gdouble)i; V0[i] = SROUND(fi * v0); V1[i] = SROUND(fi * v1); V2[i] = SROUND(fi * v2); V3[i] = SROUND(fi * v3); M0[i] = SROUND(fi * m0); M1[i] = SROUND(fi * m1); M2[i] = SROUND(fi * m2); H0[i] = SROUND(fi * h0); H1[i] = SROUND(fi * h1); H2[i] = SROUND(fi * h2); H3[i] = SROUND(fi * h3); } /* set up alpha fraction lookup table used on big/small */ for (i=0; i < (NOIVAL * 8); i++) { ALFRAC[i] = SROUND((gdouble)i * alphafraction); } } return alpharange; } /* Core pixel processing function - hand it 3x3 pixels and return result. */ /* Mean filter */ static gint atfilt0(gint32 *p) { gint retv; /* map to scaled hexagon values */ retv = M0[p[0]] + M1[p[3]] + M2[p[7]]; retv += H0[p[0]] + H1[p[2]] + H2[p[1]] + H3[p[8]]; retv += V0[p[0]] + V1[p[3]] + V2[p[2]] + V3[p[1]]; retv += V0[p[0]] + V1[p[3]] + V2[p[4]] + V3[p[5]]; retv += H0[p[0]] + H1[p[4]] + H2[p[5]] + H3[p[6]]; retv += V0[p[0]] + V1[p[7]] + V2[p[6]] + V3[p[5]]; retv += V0[p[0]] + V1[p[7]] + V2[p[8]] + V3[p[1]]; return UNSCALE(retv); } /* Mean of 5 - 7 middle values */ static gint atfilt1 (gint32 *p) { gint h0,h1,h2,h3,h4,h5,h6; /* hexagon values 2 3 */ /* 1 0 4 */ /* 6 5 */ gint big,small; /* map to scaled hexagon values */ h0 = M0[p[0]] + M1[p[3]] + M2[p[7]]; h1 = H0[p[0]] + H1[p[2]] + H2[p[1]] + H3[p[8]]; h2 = V0[p[0]] + V1[p[3]] + V2[p[2]] + V3[p[1]]; h3 = V0[p[0]] + V1[p[3]] + V2[p[4]] + V3[p[5]]; h4 = H0[p[0]] + H1[p[4]] + H2[p[5]] + H3[p[6]]; h5 = V0[p[0]] + V1[p[7]] + V2[p[6]] + V3[p[5]]; h6 = V0[p[0]] + V1[p[7]] + V2[p[8]] + V3[p[1]]; /* sum values and also discover the largest and smallest */ big = small = h0; #define CHECK(xx) \ h0 += xx; \ if (xx > big) \ big = xx; \ else if (xx < small) \ small = xx; CHECK(h1) CHECK(h2) CHECK(h3) CHECK(h4) CHECK(h5) CHECK(h6) #undef CHECK /* Compute mean of middle 5-7 values */ return UNSCALE(h0 -ALFRAC[(big + small)>>SCALEB]); } /* Mean of 3 - 5 middle values */ static gint atfilt2 (gint32 *p) { gint h0,h1,h2,h3,h4,h5,h6; /* hexagon values 2 3 */ /* 1 0 4 */ /* 6 5 */ gint big0,big1,small0,small1; /* map to scaled hexagon values */ h0 = M0[p[0]] + M1[p[3]] + M2[p[7]]; h1 = H0[p[0]] + H1[p[2]] + H2[p[1]] + H3[p[8]]; h2 = V0[p[0]] + V1[p[3]] + V2[p[2]] + V3[p[1]]; h3 = V0[p[0]] + V1[p[3]] + V2[p[4]] + V3[p[5]]; h4 = H0[p[0]] + H1[p[4]] + H2[p[5]] + H3[p[6]]; h5 = V0[p[0]] + V1[p[7]] + V2[p[6]] + V3[p[5]]; h6 = V0[p[0]] + V1[p[7]] + V2[p[8]] + V3[p[1]]; /* sum values and also discover the 2 largest and 2 smallest */ big0 = small0 = h0; small1 = G_MAXINT; big1 = 0; #define CHECK(xx) \ h0 += xx; \ if (xx > big1) \ { \ if (xx > big0) \ { \ big1 = big0; \ big0 = xx; \ } \ else \ big1 = xx; \ } \ if (xx < small1) \ { \ if (xx < small0) \ { \ small1 = small0; \ small0 = xx; \ } \ else \ small1 = xx; \ } CHECK(h1) CHECK(h2) CHECK(h3) CHECK(h4) CHECK(h5) CHECK(h6) #undef CHECK /* Compute mean of middle 3-5 values */ return UNSCALE(h0 -big0 -small0 -ALFRAC[(big1 + small1)>>SCALEB]); } /* * Mean of 1 - 3 middle values. * If only 1 value, then this is a median filter. */ static gint32 atfilt3(gint32 *p) { gint h0,h1,h2,h3,h4,h5,h6; /* hexagon values 2 3 */ /* 1 0 4 */ /* 6 5 */ gint big0,big1,big2,small0,small1,small2; /* map to scaled hexagon values */ h0 = M0[p[0]] + M1[p[3]] + M2[p[7]]; h1 = H0[p[0]] + H1[p[2]] + H2[p[1]] + H3[p[8]]; h2 = V0[p[0]] + V1[p[3]] + V2[p[2]] + V3[p[1]]; h3 = V0[p[0]] + V1[p[3]] + V2[p[4]] + V3[p[5]]; h4 = H0[p[0]] + H1[p[4]] + H2[p[5]] + H3[p[6]]; h5 = V0[p[0]] + V1[p[7]] + V2[p[6]] + V3[p[5]]; h6 = V0[p[0]] + V1[p[7]] + V2[p[8]] + V3[p[1]]; /* sum values and also discover the 3 largest and 3 smallest */ big0 = small0 = h0; small1 = small2 = G_MAXINT; big1 = big2 = 0; #define CHECK(xx) \ h0 += xx; \ if (xx > big2) \ { \ if (xx > big1) \ { \ if (xx > big0) \ { \ big2 = big1; \ big1 = big0; \ big0 = xx; \ } \ else \ { \ big2 = big1; \ big1 = xx; \ } \ } \ else \ big2 = xx; \ } \ if (xx < small2) \ { \ if (xx < small1) \ { \ if (xx < small0) \ { \ small2 = small1; \ small1 = small0; \ small0 = xx; \ } \ else \ { \ small2 = small1; \ small1 = xx; \ } \ } \ else \ small2 = xx; \ } CHECK(h1) CHECK(h2) CHECK(h3) CHECK(h4) CHECK(h5) CHECK(h6) #undef CHECK /* Compute mean of middle 1-3 values */ return UNSCALE(h0-big0-big1-small0-small1-ALFRAC[(big2+small2)>>SCALEB]); } /* Edge enhancement */ static gint atfilt4 (gint *p) { gint hav; /* map to scaled hexagon values and compute enhance value */ hav = M0[p[0]] + M1[p[3]] + M2[p[7]]; hav += H0[p[0]] + H1[p[2]] + H2[p[1]] + H3[p[8]]; hav += V0[p[0]] + V1[p[3]] + V2[p[2]] + V3[p[1]]; hav += V0[p[0]] + V1[p[3]] + V2[p[4]] + V3[p[5]]; hav += H0[p[0]] + H1[p[4]] + H2[p[5]] + H3[p[6]]; hav += V0[p[0]] + V1[p[7]] + V2[p[6]] + V3[p[5]]; hav += V0[p[0]] + V1[p[7]] + V2[p[8]] + V3[p[1]]; if (hav < 0) hav = 0; hav = UNSCALE(hav); if (hav > (gdouble)255) hav = (gdouble)255; return hav; } /* Optimal estimation - do smoothing in inverse proportion */ /* to the local variance. */ /* notice we use the globals noisevariance */ gint atfilt5(gint *p) { gint mean,variance,temp; gint h0,h1,h2,h3,h4,h5,h6; /* hexagon values 2 3 */ /* 1 0 4 */ /* 6 5 */ /* map to scaled hexagon values */ h0 = M0[p[0]] + M1[p[3]] + M2[p[7]]; h1 = H0[p[0]] + H1[p[2]] + H2[p[1]] + H3[p[8]]; h2 = V0[p[0]] + V1[p[3]] + V2[p[2]] + V3[p[1]]; h3 = V0[p[0]] + V1[p[3]] + V2[p[4]] + V3[p[5]]; h4 = H0[p[0]] + H1[p[4]] + H2[p[5]] + H3[p[6]]; h5 = V0[p[0]] + V1[p[7]] + V2[p[6]] + V3[p[5]]; h6 = V0[p[0]] + V1[p[7]] + V2[p[8]] + V3[p[1]]; mean = h0 + h1 + h2 + h3 + h4 + h5 + h6; /* compute scaled mean by dividing by 7 */ mean = AVEDIV[SCTOCSC(mean)]; /* compute scaled variance */ temp = (h1 - mean); variance = SQUARE[NOCSVAL + SCTOCSC(temp)]; /* and rescale to keep */ temp = (h2 - mean); variance += SQUARE[NOCSVAL + SCTOCSC(temp)]; /* within 32 bit limits */ temp = (h3 - mean); variance += SQUARE[NOCSVAL + SCTOCSC(temp)]; temp = (h4 - mean); variance += SQUARE[NOCSVAL + SCTOCSC(temp)]; temp = (h5 - mean); variance += SQUARE[NOCSVAL + SCTOCSC(temp)]; temp = (h6 - mean); variance += SQUARE[NOCSVAL + SCTOCSC(temp)]; /* (temp = h0 - mean) */ temp = (h0 - mean); variance += SQUARE[NOCSVAL + SCTOCSC(temp)]; if (variance != 0) /* avoid possible divide by 0 */ /* optimal estimate */ temp = mean + (variance * temp) / (variance + noisevariance); else temp = h0; if (temp < 0) temp = 0; temp = RUNSCALE(temp); if (temp > (gdouble)255) temp = (gdouble)255; return temp; } /* Triangle orientation is per geometric axes (not graphical axies) */ #define NW 0 /* North west triangle /| */ #define NE 1 /* North east triangle |\ */ #define SW 2 /* South west triangle \| */ #define SE 3 /* South east triangle |/ */ #define STH 2 #define EST 1 #define SWAPI(a,b) (t = a, a = -b, b = -t) /* compute the area of overlap of a hexagon diameter d, */ /* centered at hx,hy, with a unit square of center sx,sy. */ static gdouble hex_area (gdouble sx, gdouble sy, gdouble hx, gdouble hy, gdouble d) { gdouble hx0,hx1,hx2,hy0,hy1,hy2,hy3; gdouble sx0,sx1,sy0,sy1; /* compute square co-ordinates */ sx0 = sx - 0.5; sy0 = sy - 0.5; sx1 = sx + 0.5; sy1 = sy + 0.5; /* compute hexagon co-ordinates */ hx0 = hx - d/2.0; hx1 = hx; hx2 = hx + d/2.0; hy0 = hy - 0.5773502692 * d; /* d / sqrt(3) */ hy1 = hy - 0.2886751346 * d; /* d / sqrt(12) */ hy2 = hy + 0.2886751346 * d; /* d / sqrt(12) */ hy3 = hy + 0.5773502692 * d; /* d / sqrt(3) */ return triang_area(sx0,sy0,sx1,sy1,hx0,hy2,hx1,hy3,NW) + triang_area(sx0,sy0,sx1,sy1,hx1,hy2,hx2,hy3,NE) + rectang_area(sx0,sy0,sx1,sy1,hx0,hy1,hx2,hy2) + triang_area(sx0,sy0,sx1,sy1,hx0,hy0,hx1,hy1,SW) + triang_area(sx0,sy0,sx1,sy1,hx1,hy0,hx2,hy1,SE); } static gdouble triang_area (gdouble rx0, gdouble ry0, gdouble rx1, gdouble ry1, gdouble tx0, gdouble ty0, gdouble tx1, gdouble ty1, gint tt) { gdouble a,b,c,d; gdouble lx0,ly0,lx1,ly1; /* Convert everything to a NW triangle */ if (tt & STH) { gdouble t; SWAPI(ry0,ry1); SWAPI(ty0,ty1); } if (tt & EST) { gdouble t; SWAPI(rx0,rx1); SWAPI(tx0,tx1); } /* Compute overlapping box */ if (tx0 > rx0) rx0 = tx0; if (ty0 > ry0) ry0 = ty0; if (tx1 < rx1) rx1 = tx1; if (ty1 < ry1) ry1 = ty1; if (rx1 <= rx0 || ry1 <= ry0) return 0.0; /* Need to compute diagonal line intersection with the box */ /* First compute co-efficients to formulas x = a + by and y = c + dx */ b = (tx1 - tx0)/(ty1 - ty0); a = tx0 - b * ty0; d = (ty1 - ty0)/(tx1 - tx0); c = ty0 - d * tx0; /* compute top or right intersection */ tt = 0; ly1 = ry1; lx1 = a + b * ly1; if (lx1 <= rx0) return (rx1 - rx0) * (ry1 - ry0); else if (lx1 > rx1) { /* could be right hand side */ lx1 = rx1; ly1 = c + d * lx1; if (ly1 <= ry0) return (rx1 - rx0) * (ry1 - ry0); tt = 1; /* right hand side intersection */ } /* compute left or bottom intersection */ lx0 = rx0; ly0 = c + d * lx0; if (ly0 >= ry1) return (rx1 - rx0) * (ry1 - ry0); else if (ly0 < ry0) { /* could be right hand side */ ly0 = ry0; lx0 = a + b * ly0; if (lx0 >= rx1) return (rx1 - rx0) * (ry1 - ry0); tt |= 2; /* bottom intersection */ } if (tt == 0) { /* top and left intersection */ /* rectangle minus triangle */ return ((rx1 - rx0) * (ry1 - ry0)) - (0.5 * (lx1 - rx0) * (ry1 - ly0)); } else if (tt == 1) { /* right and left intersection */ return ((rx1 - rx0) * (ly0 - ry0)) + (0.5 * (rx1 - rx0) * (ly1 - ly0)); } else if (tt == 2) { /* top and bottom intersection */ return ((rx1 - lx1) * (ry1 - ry0)) + (0.5 * (lx1 - lx0) * (ry1 - ry0)); } else { /* tt == 3 */ /* right and bottom intersection */ /* triangle */ return (0.5 * (rx1 - lx0) * (ly1 - ry0)); } } /* Compute rectangle area */ static gdouble rectang_area (gdouble rx0, gdouble ry0, gdouble rx1, gdouble ry1, gdouble tx0, gdouble ty0, gdouble tx1, gdouble ty1) { /* Compute overlapping box */ if (tx0 > rx0) rx0 = tx0; if (ty0 > ry0) ry0 = ty0; if (tx1 < rx1) rx1 = tx1; if (ty1 < ry1) ry1 = ty1; if (rx1 <= rx0 || ry1 <= ry0) return 0.0; return (rx1 - rx0) * (ry1 - ry0); } static void nlfilter (GimpDrawable *drawable, GimpPreview *preview) { GimpPixelRgn srcPr, dstPr; guchar *srcbuf, *dstbuf; guchar *lastrow, *thisrow, *nextrow, *temprow; gint x1, x2, y1, y2; gint width, height, bpp; gint filtno, y, rowsize, exrowsize, p_update; if (preview) { gimp_preview_get_position (preview, &x1, &y1); gimp_preview_get_size (preview, &width, &height); x2 = x1 + width; y2 = y1 + height; } else { gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); width = x2 - x1; height = y2 - y1; } bpp = drawable->bpp; rowsize = width * bpp; exrowsize = (width + 2) * bpp; p_update = width / 20 + 1; gimp_tile_cache_ntiles (2 * (width / gimp_tile_width () + 1)); gimp_pixel_rgn_init (&srcPr, drawable, x1, y1, width, height, FALSE, FALSE); gimp_pixel_rgn_init (&dstPr, drawable, x1, y1, width, height, preview == NULL, TRUE); /* source buffer gives one pixel margin all around destination buffer */ srcbuf = g_new0 (guchar, exrowsize * 3); dstbuf = g_new0 (guchar, rowsize); /* pointers to second pixel in each source row */ lastrow = srcbuf + bpp; thisrow = lastrow + exrowsize; nextrow = thisrow + exrowsize; filtno = nlfiltInit (nlfvals.alpha, nlfvals.radius, nlfvals.filter); if (!preview) gimp_progress_init (_("NL Filter")); /* first row */ gimp_pixel_rgn_get_row (&srcPr, thisrow, x1, y1, width); /* copy thisrow[0] to thisrow[-1], thisrow[width-1] to thisrow[width] */ memcpy (thisrow - bpp, thisrow, bpp); memcpy (thisrow + rowsize, thisrow + rowsize - bpp, bpp); /* copy whole thisrow to lastrow */ memcpy (lastrow - bpp, thisrow - bpp, exrowsize); for (y = y1; y < y2 - 1; y++) { if (((y % p_update) == 0) && !preview) gimp_progress_update ((gdouble) y / (gdouble) height); gimp_pixel_rgn_get_row (&srcPr, nextrow, x1, y + 1, width); memcpy (nextrow - bpp, nextrow, bpp); memcpy (nextrow + rowsize, nextrow + rowsize - bpp, bpp); nlfiltRow (lastrow, thisrow, nextrow, dstbuf, width, bpp, filtno); gimp_pixel_rgn_set_row (&dstPr, dstbuf, x1, y, width); /* rotate row buffers */ temprow = lastrow; lastrow = thisrow; thisrow = nextrow; nextrow = temprow; } /* last row */ memcpy (nextrow - bpp, thisrow - bpp, exrowsize); nlfiltRow (lastrow, thisrow, nextrow, dstbuf, width, bpp, filtno); gimp_pixel_rgn_set_row (&dstPr, dstbuf, x1, y2 - 1, width); g_free (srcbuf); g_free (dstbuf); if (preview) { gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview), &dstPr); } else { gimp_progress_update (1.0); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, width, height); gimp_displays_flush (); } } static gboolean nlfilter_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *frame; GtkWidget *alpha_trim; GtkWidget *opt_est; GtkWidget *edge_enhance; GtkWidget *table; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("NL Filter"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (nlfilter), drawable); frame = gimp_int_radio_group_new (TRUE, _("Filter"), G_CALLBACK (gimp_radio_button_update), &nlfvals.filter, nlfvals.filter, _("_Alpha trimmed mean"), filter_alpha_trim, &alpha_trim, _("Op_timal estimation"), filter_opt_est, &opt_est, _("_Edge enhancement"), filter_edge_enhance, &edge_enhance, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); g_signal_connect_swapped (alpha_trim, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); g_signal_connect_swapped (opt_est, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); g_signal_connect_swapped (edge_enhance, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("A_lpha:"), 0, 0, nlfvals.alpha, 0.0, 1.0, 0.05, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &nlfvals.alpha); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Radius:"), 0, 0, nlfvals.radius, 1.0 / 3.0, 1.0, 0.05, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &nlfvals.radius); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }