callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f7513e5a80f7b70d8eaa3eb11b51b9fb4bcd5dbc
gimp/plug-ins/common/lens.c
Sven Neumann 1fcac72b1a applied patch from Aurimas Juška which, among other changes, ports the 
2006-09-17  Sven Neumann  <sven@gimp.org>

	* plug-ins/common/lens.c: applied patch from Aurimas Juška
which,
	among other changes, ports the plug-in to GimpZoomPreview
	(bug #324849).
2006-09-17 13:38:41 +00:00

1030 lines
30 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* Lens plug-in - adjust for lens distortion
* Copyright (C) 2001-2005 David Hodson hodsond@acm.org
* Many thanks for Lars Clausen for the original inspiration,
* useful discussion, optimisation and improvements.
* Framework borrowed from many similar plugins...
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <string.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
/* non-zero value compiles with statistics gathering */
#define GATHERING_STATS 0
#define PLUG_IN_PROC "plug-in-lens-distortion"
#define PLUG_IN_BINARY "lens"
#define RESPONSE_RESET 1
#define LENS_PIXEL_ACCESS_REGIONS 20
#define LENS_PIXEL_ACCESS_WIDTH 40
#define LENS_PIXEL_ACCESS_HEIGHT 20
#define LENS_PIXEL_ACCESS_XOFFSET 3
#define LENS_PIXEL_ACCESS_YOFFSET 3
#define LENS_MAX_PIXEL_DEPTH 4
typedef struct
{
guchar *src_buffer; /* preview pixels */
GimpPixelRgn src_rgn; /* image pixels */
guchar *buffer[LENS_PIXEL_ACCESS_REGIONS];
gint width;
gint height;
gint depth;
gint image_width;
gint image_height;
gint tile_xmin[LENS_PIXEL_ACCESS_REGIONS];
gint tile_xmax[LENS_PIXEL_ACCESS_REGIONS];
gint tile_ymin[LENS_PIXEL_ACCESS_REGIONS];
gint tile_ymax[LENS_PIXEL_ACCESS_REGIONS];
#if GATHERING_STATS
gint pixels_found;
gint pixels_found_in_buffer[LENS_PIXEL_ACCESS_REGIONS];
gint pixels_loaded_from_image;
#endif
} LensPixelAccess;
typedef struct
{
gdouble centre_x;
gdouble centre_y;
gdouble square_a;
gdouble quad_a;
gdouble scale_a;
gdouble brighten;
} LensValues;
typedef struct
{
gdouble normallise_radius_sq;
gdouble centre_x;
gdouble centre_y;
gdouble mult_sq;
gdouble mult_qd;
gdouble rescale;
gdouble brighten;
} LensCalcValues;
/* Declare local functions. */
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
static void lens_correction (GimpDrawable *drawable);
static gboolean lens_dialog (GimpDrawable *drawable);
static LensValues vals = { 0.0, 0.0, 0.0, 0.0 };
static LensCalcValues calc_vals;
const 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", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "offset-x", "Effect centre offset in X" },
{ GIMP_PDB_FLOAT, "offset-y", "Effect centre offset in Y" },
{ GIMP_PDB_FLOAT, "main-adjust",
"Amount of second-order distortion" },
{ GIMP_PDB_FLOAT, "edge-adjust",
"Amount of fourth-order distortion" },
{ GIMP_PDB_FLOAT, "rescale", "Rescale overall image size" },
{ GIMP_PDB_FLOAT, "brighten", "Adjust brightness in corners" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Corrects lens distortion"),
"Corrects barrel or pincushion lens distortion.",
"David Hodson, ported by Aurimas Juska",
"David Hodson",
"Version 1.0.10",
N_("Lens Distortion..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Distorts");
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
gint32 image_ID;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
run_mode = param[0].data.d_int32;
image_ID = param[1].data.d_int32;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
INIT_I18N ();
drawable = gimp_drawable_get (param[2].data.d_drawable);
*nreturn_vals = 1;
*return_vals = values;
switch (run_mode) {
case GIMP_RUN_INTERACTIVE:
gimp_get_data (PLUG_IN_PROC, &vals);
if (! lens_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 9)
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
{
vals.centre_x = param[3].data.d_float;
vals.centre_y = param[4].data.d_float;
vals.square_a = param[5].data.d_float;
vals.quad_a = param[6].data.d_float;
vals.scale_a = param[7].data.d_float;
vals.brighten = param[8].data.d_float;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &vals);
break;
default:
break;
}
if ( status == GIMP_PDB_SUCCESS )
{
lens_correction (drawable);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &vals, sizeof (LensValues));
gimp_drawable_detach (drawable);
}
values[0].data.d_status = status;
}
static void
lens_get_source_coords (gdouble i,
gdouble j,
gdouble *x,
gdouble *y,
gdouble *mag)
{
gdouble radius_sq;
gdouble off_x;
gdouble off_y;
gdouble radius_mult;
off_x = i - calc_vals.centre_x;
off_y = j - calc_vals.centre_y;
radius_sq = (off_x * off_x) + (off_y * off_y);
radius_sq *= calc_vals.normallise_radius_sq;
radius_mult = radius_sq * calc_vals.mult_sq + radius_sq * radius_sq *
calc_vals.mult_qd;
*mag = radius_mult;
radius_mult = calc_vals.rescale * (1.0 + radius_mult);
*x = calc_vals.centre_x + radius_mult * off_x;
*y = calc_vals.centre_y + radius_mult * off_y;
}
static void
lens_setup_calc (gint width, gint height)
{
calc_vals.normallise_radius_sq =
4.0 / (width * width + height * height);
calc_vals.centre_x = width * (100.0 + vals.centre_x) / 200.0;
calc_vals.centre_y = height * (100.0 + vals.centre_y) / 200.0;
calc_vals.mult_sq = vals.square_a / 200.0;
calc_vals.mult_qd = vals.quad_a / 200.0;
calc_vals.rescale = pow(2.0, - vals.scale_a / 100.0);
calc_vals.brighten = - vals.brighten / 10.0;
}
/*
* Catmull-Rom cubic interpolation
*
* equally spaced points p0, p1, p2, p3
* interpolate 0 <= u < 1 between p1 and p2
*
* (1 u u^2 u^3) ( 0.0 1.0 0.0 0.0 ) (p0)
* ( -0.5 0.0 0.5 0.0 ) (p1)
* ( 1.0 -2.5 2.0 -0.5 ) (p2)
* ( -0.5 1.5 -1.5 0.5 ) (p3)
*
*/
static void
lens_cubic_interpolate (const guchar *src,
gint row_stride,
gint src_depth,
guchar *dst,
gint dst_depth,
gdouble dx,
gdouble dy,
gdouble brighten)
{
gfloat um1, u, up1, up2;
gfloat vm1, v, vp1, vp2;
gint c;
gfloat verts[4 * LENS_MAX_PIXEL_DEPTH];
um1 = ((-0.5 * dx + 1.0) * dx - 0.5) * dx;
u = (1.5 * dx - 2.5) * dx * dx + 1.0;
up1 = ((-1.5 * dx + 2.0) * dx + 0.5) * dx;
up2 = (0.5 * dx - 0.5) * dx * dx;
vm1 = ((-0.5 * dy + 1.0) * dy - 0.5) * dy;
v = (1.5 * dy - 2.5) * dy * dy + 1.0;
vp1 = ((-1.5 * dy + 2.0) * dy + 0.5) * dy;
vp2 = (0.5 * dy - 0.5) * dy * dy;
/* Note: if dst_depth < src_depth, we calculate unneeded pixels here */
/* later - select or create index array */
for (c = 0; c < 4 * src_depth; ++c)
{
verts[c] = vm1 * src[c] + v * src[c+row_stride] +
vp1 * src[c+row_stride*2] + vp2 * src[c+row_stride*3];
}
for (c = 0; c < dst_depth; ++c)
{
gfloat result;
result = um1 * verts[c] + u * verts[c+src_depth] +
up1 * verts[c+src_depth*2] + up2 * verts[c+src_depth*3];
result *= brighten;
if (result < 0.0)
{
dst[c] = 0;
}
else if (result > 255.0)
{
dst[c] = 255;
}
else
{
dst[c] = result;
}
}
}
/* Solving the eternal problem: random, cubic-interpolated,
* sub-pixel coordinate access to a tiled image.
* Assuming that accesses are at least slightly coherent,
* LensPixelAccess keeps LENS_PIXEL_ACCESS_REGIONS buffers, each containing a
* LENS_PIXEL_ACCESS_WIDTH x LENS_PIXEL_ACCESS_HEIGHT region of pixels.
* Buffer[0] is always checked first, so move the last accessed
* region into that position.
* When a request arrives which is outside all the regions,
* get a new region (using GimpPixelRgn - good idea? bad idea?).
* The new region is placed so that the requested pixel is positioned
* at [LENS_PIXEL_ACCESS_XOFFSET, LENS_PIXEL_ACCESS_YOFFSET] in the region.
*/
#if GATHERING_STATS
static void
lens_pixel_access_dump_region (LensPixelAccess* pa,
gint n)
{
g_print ("Region %d: buffer %p\n", n, pa->buffer[n]);
g_print (" X min %d max %d, Y min %d max %d\n",
pa->tile_xmin[n], pa->tile_xmax[n],
pa->tile_ymin[n], pa->tile_ymax[n]);
}
static void
lens_pixel_access_dump_stats (LensPixelAccess* pa)
{
g_print ("Pixels found %d\n", pa->pixels_found);
if (pa->pixels_found)
{
gint i;
for (i = 0; i < LENS_PIXEL_ACCESS_REGIONS; ++i)
{
g_print (" In buffer[%d]: %d ratio %f\n", i,
pa->pixels_found_in_buffer[i],
(gfloat) pa->pixels_found_in_buffer[i] /
(gfloat) pa->pixels_found );
pa->pixels_found_in_buffer[i] = 0;
}
g_print (" Loaded: %d ratio %f\n", pa->pixels_loaded_from_image,
(gfloat) pa->pixels_loaded_from_image /
(gfloat) pa->pixels_found );
pa->pixels_loaded_from_image = 0;
}
pa->pixels_found = 0;
}
#endif
/* get rect of pixels from preview data */
static void
lens_pixel_access_get_rect (LensPixelAccess *pa,
guchar *buffer,
gint x,
gint y,
gint width,
gint height)
{
gint i, j;
guchar *row;
gint rowstride;
gint rowbytes;
g_assert (pa->src_buffer);
g_assert (x + width <= pa->image_width);
g_assert (y + height <= pa->image_height);
rowstride = pa->image_width * pa->depth;
rowbytes = width * pa->depth;
row = pa->src_buffer + (rowstride * y + x * pa->depth);
for ( i = 0; i < height; i++ )
{
for ( j = 0; j < width; j++ )
{
memcpy (buffer, row, rowbytes);
}
buffer += rowbytes;
row += rowstride;
}
}
static LensPixelAccess *
lens_pixel_access_new (GimpDrawable *drawable)
{
LensPixelAccess *pa = g_new (LensPixelAccess, 1);
gint i;
gint buffer_size;
pa->src_buffer = NULL;
pa->width = LENS_PIXEL_ACCESS_WIDTH;
pa->height = LENS_PIXEL_ACCESS_HEIGHT;
pa->depth = drawable->bpp;
pa->image_width = drawable->width;
pa->image_height = drawable->height;
gimp_pixel_rgn_init (&pa->src_rgn, drawable, 0, 0, drawable->width,
drawable->height, FALSE, FALSE);
buffer_size = pa->height * pa->width * pa->depth;
pa->buffer[0] = (guchar*) g_malloc (buffer_size);
/* better: lens_pixel_access_reposition(), pixelAccessSelect()! */
gimp_pixel_rgn_get_rect (&pa->src_rgn, pa->buffer[0], 0, 0,
pa->width, pa->height);
pa->tile_xmin[0] = 1;
pa->tile_xmax[0] = pa->width - 2;
pa->tile_ymin[0] = 1;
pa->tile_ymax[0] = pa->height - 2;
for (i = 1; i < LENS_PIXEL_ACCESS_REGIONS; ++i)
{
pa->buffer[i] = (guchar*) g_malloc (buffer_size);
memcpy (pa->buffer[i], pa->buffer[0], buffer_size);
pa->tile_xmin[i] = 1;
pa->tile_xmax[i] = pa->width - 2;
pa->tile_ymin[i] = 1;
pa->tile_ymax[i] = pa->height - 2;
}
#if GATHERING_STATS
for ( i = 0; i < LENS_PIXEL_ACCESS_REGIONS; i++ )
pa->pixels_found_in_buffer[i] = 0;
pa->pixels_found = 0;
pa->pixels_loaded_from_image = 0;
#endif
return pa;
}
static LensPixelAccess *
lens_pixel_access_new_for_preview (guchar *buffer,
gint width,
gint height,
gint depth)
{
LensPixelAccess *pa = g_new (LensPixelAccess, 1);
gint i;
gint buffer_size;
pa->src_buffer = buffer;
pa->width = LENS_PIXEL_ACCESS_WIDTH;
pa->height = LENS_PIXEL_ACCESS_HEIGHT;
pa->depth = depth;
pa->image_width = width;
pa->image_height = height;
buffer_size = pa->height * pa->width * pa->depth;
pa->buffer[0] = (guchar*) g_malloc (buffer_size);
lens_pixel_access_get_rect (pa, pa->buffer[0], 0, 0, pa->width, pa->height);
pa->tile_xmin[0] = 1;
pa->tile_xmax[0] = pa->width - 2;
pa->tile_ymin[0] = 1;
pa->tile_ymax[0] = pa->height - 2;
for (i = 1; i < LENS_PIXEL_ACCESS_REGIONS; ++i)
{
pa->buffer[i] = (guchar*) g_malloc (buffer_size);
memcpy (pa->buffer[i], pa->buffer[0], buffer_size);
pa->tile_xmin[i] = 1;
pa->tile_xmax[i] = pa->width - 2;
pa->tile_ymin[i] = 1;
pa->tile_ymax[i] = pa->height - 2;
}
#if GATHERING_STATS
for ( i = 0; i < LENS_PIXEL_ACCESS_REGIONS; i++ )
pa->pixels_found_in_buffer[i] = 0;
pa->pixels_found = 0;
pa->pixels_loaded_from_image = 0;
#endif
return pa;
}
static void
lens_pixel_access_delete (LensPixelAccess *pa)
{
gint i;
for (i = 0; i < LENS_PIXEL_ACCESS_REGIONS; ++i)
g_free (pa->buffer[i]);
g_free (pa);
}
static guchar *
lens_pixel_access_address (LensPixelAccess *pa,
gint i,
gint j)
{
return pa->buffer[0] + pa->depth *
(pa->width * (j + 1 - pa->tile_ymin[0]) + (i + 1 - pa->tile_xmin[0]));
}
/* swap region[n] with region[0] */
static void
lens_pixel_access_select_region (LensPixelAccess *pa,
gint n)
{
guchar *temp;
gint a, b, c, d;
gint i;
temp = pa->buffer[n];
a = pa->tile_xmin[n];
b = pa->tile_xmax[n];
c = pa->tile_ymin[n];
d = pa->tile_ymax[n];
for (i = n; i > 0; --i)
{
pa->buffer[i] = pa->buffer[i-1];
pa->tile_xmin[i] = pa->tile_xmin[i-1];
pa->tile_xmax[i] = pa->tile_xmax[i-1];
pa->tile_ymin[i] = pa->tile_ymin[i-1];
pa->tile_ymax[i] = pa->tile_ymax[i-1];
}
pa->buffer[0] = temp;
pa->tile_xmin[0] = a;
pa->tile_xmax[0] = b;
pa->tile_ymin[0] = c;
pa->tile_ymax[0] = d;
}
/* buffer[0] is cleared, should start at [i, j],
* fill rows that overlap image */
static void
lens_pixel_access_do_edge (LensPixelAccess *pa,
gint i,
gint j)
{
guchar *line;
gint y;
gint line_start, line_end;
gint row_start, row_end;
gint line_width;
line_start = MAX (i, 0);
line_end = MIN (i + pa->width, pa->image_width);
line_width = line_end - line_start;
if (line_start >= line_end)
return;
row_start = MAX (j, 0);
row_end = MIN (j + pa->height, pa->image_height);
for (y = row_start; y < row_end; ++y)
{
line = lens_pixel_access_address (pa, line_start, y);
#if GATHERING_STATS
pa->pixels_loaded_from_image += line_width;
#endif
if (pa->src_buffer)
lens_pixel_access_get_rect (pa, line, line_start, y, line_width, 1);
else
gimp_pixel_rgn_get_row (&pa->src_rgn, line, line_start, y, line_width);
}
}
/* moves buffer[0] so that [x, y] is inside it */
static void
lens_pixel_access_reposition (LensPixelAccess *pa,
gint x_int,
gint y_int)
{
gint new_xstart, new_ystart;
/* experiment! */
/* could look at current position of region, for example... */
/* this assumes random direction */
/*
* new_xstart = x_int - pa->width / 2;
* new_ystart = y_int - pa->height / 2;
*/
/* this assumes mostly stepping min->max in x and y */
new_xstart = x_int - LENS_PIXEL_ACCESS_XOFFSET;
new_ystart = y_int - LENS_PIXEL_ACCESS_YOFFSET;
pa->tile_xmin[0] = new_xstart + 1;
pa->tile_xmax[0] = new_xstart + pa->width - 2;
pa->tile_ymin[0] = new_ystart + 1;
pa->tile_ymax[0] = new_ystart + pa->height - 2;
if ( (new_xstart < 0) || ((new_xstart + pa->width) >= pa->image_width) ||
(new_ystart < 0) || ((new_ystart + pa->height) >= pa->image_height) )
{
/* some data is off edge of image */
memset (pa->buffer[0], 0, pa->width * pa->height * pa->depth);
if ( ((new_xstart + pa->width) < 0) || (new_xstart >= pa->image_width) ||
((new_ystart + pa->height) < 0) || (new_ystart >= pa->image_height))
{
/* totally outside, just leave it */
}
else
{
lens_pixel_access_do_edge (pa, new_xstart, new_ystart);
}
}
else
{
#if GATHERING_STATS
pa->pixels_loaded_from_image += pa->width * pa->height;
#endif
if ( pa->src_buffer )
lens_pixel_access_get_rect (pa, pa->buffer[0],
new_xstart, new_ystart,
pa->width, pa->height);
else
gimp_pixel_rgn_get_rect (&pa->src_rgn, pa->buffer[0],
new_xstart, new_ystart,
pa->width, pa->height);
}
}
static void
lens_pixel_access_get_cubic (LensPixelAccess *pa,
gdouble src_x,
gdouble src_y,
gdouble brighten,
guchar *dst,
gint dst_depth)
{
guchar *corner;
gdouble dx, dy;
gint i;
gint x_int, y_int;
x_int = floor (src_x);
dx = src_x - x_int;
y_int = floor (src_y);
dy = src_y - y_int;
#if GATHERING_STATS
++pa->pixels_found;
#endif
/* we need 4x4 pixels, x_int-1 to x_int+2 horz, y_int-1 to y_int+2 vert */
/* they're probably in the last place we looked... */
if ((x_int >= pa->tile_xmin[0]) && (x_int < pa->tile_xmax[0]) &&
(y_int >= pa->tile_ymin[0]) && (y_int < pa->tile_ymax[0]) )
{
#if GATHERING_STATS
++pa->pixels_found_in_buffer[0];
#endif
corner = lens_pixel_access_address (pa, x_int - 1, y_int - 1);
lens_cubic_interpolate (corner, pa->depth * pa->width, pa->depth, dst,
dst_depth, dx, dy, brighten);
return;
}
/* or maybe it was a while back... */
for (i = 1; i < LENS_PIXEL_ACCESS_REGIONS; ++i)
{
if ((x_int >= pa->tile_xmin[i]) && (x_int < pa->tile_xmax[i]) &&
(y_int >= pa->tile_ymin[i]) && (y_int < pa->tile_ymax[i]) )
{
#if GATHERING_STATS
++pa->pixels_found_in_buffer[i];
#endif
/* check here first next time */
lens_pixel_access_select_region (pa, i);
corner = lens_pixel_access_address (pa, x_int - 1, y_int - 1);
lens_cubic_interpolate (corner, pa->depth * pa->width, pa->depth,
dst, dst_depth, dx, dy, brighten);
return;
}
}
/* nope, recycle an old region */
lens_pixel_access_select_region (pa, LENS_PIXEL_ACCESS_REGIONS - 1);
lens_pixel_access_reposition (pa, x_int, y_int);
corner = lens_pixel_access_address (pa, x_int - 1, y_int - 1);
lens_cubic_interpolate (corner, pa->depth * pa->width, pa->depth, dst,
dst_depth, dx, dy, brighten);
}
/*
* start at image (i, j), increment by (step, step)
* output goes to dst, which is w x h x d in size
* NB: d <= image.bpp
*/
static void
lens_calc_rect (LensPixelAccess *pa,
guchar *dst,
gint x,
gint y,
gint width,
gint height,
gint depth,
gint rowstride,
gint step)
{
gdouble src_x, src_y, mag, brighten;
gint i, j;
gint xlimit, ylimit;
gint rowpad;
xlimit = x + width * step;
ylimit = y + height * step;
rowpad = rowstride - width * depth;
for (i = y; i < ylimit; i += step)
{
for ( j = x; j < xlimit; j += step)
{
lens_get_source_coords (j, i, &src_x, &src_y, &mag);
brighten = 1.0 + mag * calc_vals.brighten;
lens_pixel_access_get_cubic (pa, src_x, src_y, brighten,
dst, depth);
dst += depth;
}
dst += rowpad;
}
}
static void
lens_correction (GimpDrawable *drawable)
{
GimpPixelRgn dest_rgn;
gpointer pr;
guchar *dest;
gint x1, y1, x2, y2;
gint width, height;
gint progress, progress_max;
LensPixelAccess *pa;
lens_setup_calc (drawable->width, drawable->height);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = x2 - x1;
height = y2 - y1;
gimp_progress_init (_("Lens distortion"));
progress_max = ((width - 1) / gimp_tile_width() + 1) *
((height - 1) / gimp_tile_height() + 1);
dest = g_malloc (gimp_tile_width() * gimp_tile_height() * drawable->bpp);
pa = lens_pixel_access_new (drawable);
#if GATHERING_STATS
lens_pixel_access_dump_stats (pa);
#endif
gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1,
width, height, TRUE, TRUE);
pr = gimp_pixel_rgns_register (1, &dest_rgn);
progress = 0;
for ( ; pr; pr = gimp_pixel_rgns_process (pr))
{
lens_calc_rect (pa, dest_rgn.data, dest_rgn.x, dest_rgn.y,
dest_rgn.w, dest_rgn.h, dest_rgn.bpp,
dest_rgn.rowstride, 1);
gimp_progress_update ((gfloat) progress / (gfloat) progress_max);
++progress;
}
g_free(dest);
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);
#if GATHERING_STATS
lens_pixel_access_dump_stats (pa);
#endif
lens_pixel_access_delete (pa);
}
static void
lens_correction_preview (GimpDrawable *drawable,
GimpPreview *preview)
{
guchar *src, *dest;
gint width, height;
gint bpp;
LensPixelAccess *pa;
src = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
&width, &height, &bpp);
lens_setup_calc (width, height);
dest = g_new (guchar, width * height * bpp);
pa = lens_pixel_access_new_for_preview (src, width, height, bpp);
lens_calc_rect (pa, dest, 0, 0, width, height, bpp, width*bpp, 1);
gimp_preview_draw_buffer (preview, dest, width * bpp);
lens_pixel_access_delete (pa);
g_free (dest);
g_free (src);
}
/* UI callback functions */
static GSList *adjustments = NULL;
static void
lens_dialog_reset (void)
{
GSList *list;
for (list = adjustments; list; list = list->next)
gtk_adjustment_set_value (GTK_ADJUSTMENT (list->data), 0.0);
}
static void
lens_response (GtkWidget *widget,
gint response_id,
gboolean *run)
{
switch (response_id)
{
case RESPONSE_RESET:
lens_dialog_reset ();
break;
case GTK_RESPONSE_OK:
*run = TRUE;
/* fallthrough */
default:
gtk_widget_destroy (GTK_WIDGET (widget));
break;
}
}
static gboolean
lens_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *table;
GtkWidget *preview;
GtkObject *adj;
gint row = 0;
gboolean run = FALSE;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Lens Distortion"), PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
gtk_widget_show (main_vbox);
preview = gimp_zoom_preview_new (drawable);
gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview);
gtk_widget_show (preview);
g_signal_connect_swapped (preview, "invalidated",
G_CALLBACK (lens_correction_preview),
drawable);
table = gtk_table_new (6, 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, row++,
_("_Main:"), 120, 6,
vals.square_a, -100.0, 100.0, 0.1, 1.0, 3,
TRUE, 0, 0,
NULL, NULL);
adjustments = g_slist_append (adjustments, adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vals.square_a);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
_("_Edge:"), 120, 6,
vals.quad_a, -100.0, 100.0, 0.1, 1.0, 3,
TRUE, 0, 0,
NULL, NULL);
adjustments = g_slist_append (adjustments, adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vals.quad_a);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
_("_Zoom:"), 120, 6,
vals.scale_a, -100.0, 100.0, 0.1, 1.0, 3,
TRUE, 0, 0,
NULL, NULL);
adjustments = g_slist_append (adjustments, adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vals.scale_a);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
_("_Brighten:"), 120, 6,
vals.brighten, -100.0, 100.0, 0.1, 1.0, 3,
TRUE, 0, 0,
NULL, NULL);
adjustments = g_slist_append (adjustments, adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vals.brighten);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
_("_X shift:"), 120, 6,
vals.centre_x, -100.0, 100.0, 0.1, 1.0, 3,
TRUE, 0, 0,
NULL, NULL);
adjustments = g_slist_append (adjustments, adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vals.centre_x);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, row++,
_("_Y shift:"), 120, 6,
vals.centre_y, -100.0, 100.0, 0.1, 1.0, 3,
TRUE, 0, 0,
NULL, NULL);
adjustments = g_slist_append (adjustments, adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vals.centre_y);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
g_signal_connect (dialog, "response",
G_CALLBACK (lens_response),
&run);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_widget_show (dialog);
gtk_main ();
g_slist_free (adjustments);
adjustments = NULL;
return run;
}
Reference in New Issue View Git Blame Copy Permalink