static void
apply_whirl_pinch (gdouble whirl, gdouble pinch, gdouble radius,
gdouble cen_x, gdouble cen_y,
Babl *format,
GeglBuffer *src,
GeglRectangle *in_boundary,
GeglBuffer *dst,
GeglRectangle *boundary,
const GeglRectangle *roi)
{
gfloat *dst_buf;
gint row, col;
gdouble scale_x, scale_y;
gdouble cx, cy;
/* Get buffer in which to place dst pixels. */
dst_buf = g_new0 (gfloat, roi->width * roi->height * 4);
whirl = whirl * G_PI / 180;
scale_x = 1.0;
scale_y = roi->width / (gdouble) roi->height;
for (row = 0; row < roi->height; row++) {
for (col = 0; col < roi->width; col++) {
calc_undistorted_coords (roi->x + col, roi->y + row,
cen_x, cen_y,
scale_x, scale_y,
whirl, pinch, radius,
&cx, &cy);
gegl_buffer_sample (src, cx, cy, 1.0, &dst_buf[(row * roi->width + col) * 4], format, GEGL_INTERPOLATION_LINEAR);
} /* for */
} /* for */
gegl_buffer_sample_cleanup (src);
/* Store dst pixels. */
gegl_buffer_set (dst, roi, format, dst_buf, GEGL_AUTO_ROWSTRIDE);
gegl_buffer_flush(dst);
g_free (dst_buf);
}
static void
polarize_func (gint x,
gint y,
guchar *dest,
gint bpp,
gpointer data)
{
double cx, cy;
if (calc_undistorted_coords (x, y, &cx, &cy))
{
guchar pixel1[4], pixel2[4], pixel3[4], pixel4[4];
guchar *values[4];
GimpPixelFetcher *pft = (GimpPixelFetcher*) data;
values[0] = pixel1;
values[1] = pixel2;
values[2] = pixel3;
values[3] = pixel4;
gimp_pixel_fetcher_get_pixel (pft, cx, cy, pixel1);
gimp_pixel_fetcher_get_pixel (pft, cx + 1, cy, pixel2);
gimp_pixel_fetcher_get_pixel (pft, cx, cy + 1, pixel3);
gimp_pixel_fetcher_get_pixel (pft, cx + 1, cy + 1, pixel4);
gimp_bilinear_pixels_8 (dest, cx, cy, bpp, img_has_alpha, values);
}
else
{
gint b;
for (b = 0; b < bpp; b++)
{
dest[b] = back_color[b];
}
}
}
static void
dialog_update_preview (GimpDrawable *drawable,
GimpPreview *preview)
{
gdouble cx, cy;
gint x, y;
gint sx, sy;
gint width, height;
guchar *pixel;
guchar outside[4];
GimpRGB background;
guchar *dest;
gint j;
gint bpp;
GimpPixelFetcher *pft;
guchar in_pixels[4][4];
guchar *in_values[4];
for (j = 0; j < 4; j++)
in_values[j] = in_pixels[j];
pft = gimp_pixel_fetcher_new (drawable, FALSE);
gimp_context_get_background (&background);
gimp_rgb_set_alpha (&background, 0.0);
gimp_drawable_get_color_uchar (drawable->drawable_id, &background, outside);
gimp_pixel_fetcher_set_bg_color (pft, &background);
gimp_pixel_fetcher_set_edge_mode (pft, GIMP_PIXEL_FETCHER_EDGE_SMEAR);
dest = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
&width, &height, &bpp);
pixel = dest;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
gimp_preview_untransform (preview, x, y, &sx, &sy);
if (calc_undistorted_coords ((gdouble)sx, (gdouble)sy,
&cx, &cy))
{
gimp_pixel_fetcher_get_pixel (pft, cx, cy, in_pixels[0]);
gimp_pixel_fetcher_get_pixel (pft, cx + 1, cy, in_pixels[1]);
gimp_pixel_fetcher_get_pixel (pft, cx, cy + 1, in_pixels[2]);
gimp_pixel_fetcher_get_pixel (pft, cx + 1, cy + 1, in_pixels[3]);
gimp_bilinear_pixels_8 (pixel, cx, cy, bpp,
img_has_alpha, in_values);
}
else
{
for (j = 0; j < bpp; j++)
pixel[j] = outside[j];
}
pixel += bpp;
}
}
gimp_pixel_fetcher_destroy (pft);
gimp_preview_draw_buffer (preview, dest, width * bpp);
g_free (dest);
}
static void
apply_mirror (double mirror_angle,
double result_angle,
int nsegs,
double cen_x,
double cen_y,
double off_x,
double off_y,
double input_scale,
gboolean clip,
gboolean warp,
const Babl *format,
GeglBuffer *src,
GeglRectangle *in_boundary,
GeglBuffer *dst,
GeglRectangle *boundary,
const GeglRectangle *roi,
gint level)
{
gfloat *dst_buf;
GeglSampler *sampler;
gint row, col;
gdouble cx, cy;
/* Get src pixels. */
#ifdef TRACE
g_warning ("> mirror marker1, boundary x:%d, y:%d, w:%d, h:%d, center: (%f, %f) offset: (%f, %f)", boundary->x, boundary->y, boundary->width, boundary->height, cen_x, cen_y, off_x,off_y );
#endif
#ifdef DO_NOT_USE_BUFFER_SAMPLE
src_buf = g_new0 (gfloat, boundary->width * boundary->height * 4);
gegl_buffer_get (src, 1.0, boundary, format, src_buf, GEGL_AUTO_ROWSTRIDE);
#else
sampler = gegl_buffer_sampler_new_at_level (src, format, GEGL_SAMPLER_LINEAR, level);
#endif
/* Get buffer in which to place dst pixels. */
dst_buf = g_new0 (gfloat, roi->width * roi->height * 4);
mirror_angle = mirror_angle * G_PI / 180;
result_angle = result_angle * G_PI / 180;
for (row = 0; row < roi->height; row++) {
for (col = 0; col < roi->width; col++) {
calc_undistorted_coords(roi->x + col + 0.01, roi->y + row - 0.01, mirror_angle, result_angle,
nsegs,
cen_x, cen_y,
off_x * input_scale, off_y * input_scale,
&cx, &cy);
/* apply scale*/
cx = in_boundary->x + (cx - in_boundary->x) / input_scale;
cy = in_boundary->y + (cy - in_boundary->y) / input_scale;
/*Warping*/
if (warp)
{
double dx = cx - in_boundary->x;
double dy = cy - in_boundary->y;
double width_overrun = ceil ((dx) / (in_boundary->width)) ;
double height_overrun = ceil ((dy) / (in_boundary->height));
if (cx <= (in_boundary->x))
{
if ( fabs (fmod (width_overrun, 2)) < 1.0)
cx = in_boundary->x - fmod (dx, in_boundary->width);
else
cx = in_boundary->x + in_boundary->width + fmod (dx, in_boundary->width);
}
if (cy <= (in_boundary->y))
{
if ( fabs (fmod (height_overrun, 2)) < 1.0)
cy = in_boundary->y + fmod (dy, in_boundary->height);
else
cy = in_boundary->y + in_boundary->height - fmod (dy, in_boundary->height);
}
if (cx >= (in_boundary->x + in_boundary->width))
{
if ( fabs (fmod (width_overrun, 2)) < 1.0)
cx = in_boundary->x + in_boundary->width - fmod (dx, in_boundary->width);
else
cx = in_boundary->x + fmod (dx, in_boundary->width);
}
if (cy >= (in_boundary->y + in_boundary->height))
{
if ( fabs (fmod (height_overrun, 2)) < 1.0)
cy = in_boundary->y + in_boundary->height - fmod (dy, in_boundary->height);
else
cy = in_boundary->y + fmod (dy, in_boundary->height);
}
}
else /* cliping */
{
if (cx < boundary->x)
cx = 0;
if (cy < boundary->x)
cy = 0;
if (cx >= boundary->width)
cx = boundary->width - 1;
if (cy >= boundary->height)
cy = boundary->height -1;
}
/* Top */
#ifdef DO_NOT_USE_BUFFER_SAMPLE
if (cx >= 0.0)
ix = (int) cx;
else
ix = -((int) -cx + 1);
if (cy >= 0.0)
iy = (int) cy;
else
iy = -((int) -cy + 1);
spx_pos = (iy * boundary->width + ix) * 4;
#endif
#ifndef DO_NOT_USE_BUFFER_SAMPLE
gegl_sampler_get (sampler, cx, cy, NULL, &dst_buf[(row * roi->width + col) * 4], GEGL_ABYSS_NONE);
#endif
#ifdef DO_NOT_USE_BUFFER_SAMPLE
dst_buf[dpx_pos] = src_buf[spx_pos];
dst_buf[dpx_pos + 1] = src_buf[spx_pos + 1];
dst_buf[dpx_pos + 2] = src_buf[spx_pos + 2];
dst_buf[dpx_pos + 3] = src_buf[spx_pos + 3];
#endif
} /* for */
} /* for */
/* Store dst pixels. */
gegl_buffer_set (dst, roi, 0, format, dst_buf, GEGL_AUTO_ROWSTRIDE);
/* Free acquired storage. */
#ifdef DO_NOT_USE_BUFFER_SAMPLE
g_free (src_buf);
#else
g_object_unref (sampler);
#endif
g_free (dst_buf);
}