PIKApp/plug-ins/map-object/map-object-image.c

355 lines
8.1 KiB
C
Raw Normal View History

2023-09-26 00:35:21 +02:00
/*********************************************************/
/* Image manipulation routines. Calls mapobject_shade.c */
/* functions to compute the shading of the image at each */
/* pixel. These routines are used by the functions in */
/* mapobject_preview.c and mapobject_apply.c */
/*********************************************************/
#include "config.h"
#include <string.h>
#include <sys/types.h>
#include <gtk/gtk.h>
#include <libpika/pika.h>
#include <libpika/pikaui.h>
#include "map-object-main.h"
#include "map-object-preview.h"
#include "map-object-shade.h"
#include "map-object-ui.h"
#include "map-object-image.h"
PikaImage *image;
PikaDrawable *input_drawable;
PikaDrawable *output_drawable;
GeglBuffer *source_buffer;
GeglBuffer *dest_buffer;
PikaDrawable *box_drawables[6];
GeglBuffer *box_buffers[6];
PikaDrawable *cylinder_drawables[2];
GeglBuffer *cylinder_buffers[2];
guchar *preview_rgb_data = NULL;
gint preview_rgb_stride;
cairo_surface_t *preview_surface = NULL;
glong maxcounter, old_depth, max_depth;
gint width, height;
PikaRGB background;
gint border_x, border_y, border_w, border_h;
/******************/
/* Implementation */
/******************/
PikaRGB
peek (gint x,
gint y)
{
PikaRGB color;
gegl_buffer_sample (source_buffer, x, y, NULL,
&color, babl_format ("R'G'B'A double"),
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
if (! babl_format_has_alpha (gegl_buffer_get_format (source_buffer)))
color.a = 1.0;
return color;
}
static PikaRGB
peek_box_image (gint image,
gint x,
gint y)
{
PikaRGB color;
gegl_buffer_sample (box_buffers[image], x, y, NULL,
&color, babl_format ("R'G'B'A double"),
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
if (! babl_format_has_alpha (gegl_buffer_get_format (box_buffers[image])))
color.a = 1.0;
return color;
}
static PikaRGB
peek_cylinder_image (gint image,
gint x,
gint y)
{
PikaRGB color;
gegl_buffer_sample (cylinder_buffers[image], x, y, NULL,
&color, babl_format ("R'G'B'A double"),
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
if (! babl_format_has_alpha (gegl_buffer_get_format (cylinder_buffers[image])))
color.a = 1.0;
return color;
}
void
poke (gint x,
gint y,
PikaRGB *color,
gpointer user_data)
{
gegl_buffer_set (dest_buffer, GEGL_RECTANGLE (x, y, 1, 1), 0,
babl_format ("R'G'B'A double"), color,
GEGL_AUTO_ROWSTRIDE);
}
gint
checkbounds (gint x,
gint y)
{
if (x < border_x ||
y < border_y ||
x >= border_x + border_w ||
y >= border_y + border_h)
return FALSE;
else
return TRUE;
}
static gint
checkbounds_box_image (gint image,
gint x,
gint y)
{
gint w, h;
w = gegl_buffer_get_width (box_buffers[image]);
h = gegl_buffer_get_height (box_buffers[image]);
if (x < 0 || y < 0 || x >= w || y >= h)
return FALSE ;
else
return TRUE ;
}
static gint
checkbounds_cylinder_image (gint image,
gint x,
gint y)
{
gint w, h;
w = gegl_buffer_get_width (cylinder_buffers[image]);
h = gegl_buffer_get_height (cylinder_buffers[image]);
if (x < 0 || y < 0 || x >= w || y >= h)
return FALSE;
else
return TRUE;
}
PikaVector3
int_to_pos (gint x,
gint y)
{
PikaVector3 pos;
pos.x = (gdouble) x / (gdouble) width;
pos.y = (gdouble) y / (gdouble) height;
pos.z = 0.0;
return pos;
}
void
pos_to_int (gdouble x,
gdouble y,
gint *scr_x,
gint *scr_y)
{
*scr_x = (gint) ((x * (gdouble) width));
*scr_y = (gint) ((y * (gdouble) height));
}
/**********************************************/
/* Compute the image color at pos (u,v) using */
/* Quartics bilinear interpolation stuff. */
/**********************************************/
PikaRGB
get_image_color (gdouble u,
gdouble v,
gint *inside)
{
gint x1, y1, x2, y2;
PikaRGB p[4];
pos_to_int (u, v, &x1, &y1);
if (mapvals.tiled == TRUE)
{
*inside = TRUE;
if (x1 < 0) x1 = (width-1) - (-x1 % width);
else x1 = x1 % width;
if (y1 < 0) y1 = (height-1) - (-y1 % height);
else y1 = y1 % height;
x2 = (x1 + 1) % width;
y2 = (y1 + 1) % height;
p[0] = peek (x1, y1);
p[1] = peek (x2, y1);
p[2] = peek (x1, y2);
p[3] = peek (x2, y2);
return pika_bilinear_rgba (u * width, v * height, p);
}
if (checkbounds (x1, y1) == FALSE)
{
*inside =FALSE;
return background;
}
x2 = (x1 + 1);
y2 = (y1 + 1);
if (checkbounds (x2, y2) == FALSE)
{
*inside = TRUE;
return peek (x1, y1);
}
*inside=TRUE;
p[0] = peek (x1, y1);
p[1] = peek (x2, y1);
p[2] = peek (x1, y2);
p[3] = peek (x2, y2);
return pika_bilinear_rgba (u * width, v * height, p);
}
PikaRGB
get_box_image_color (gint image,
gdouble u,
gdouble v)
{
gint w, h;
gint x1, y1, x2, y2;
PikaRGB p[4];
w = gegl_buffer_get_width (box_buffers[image]);
h = gegl_buffer_get_height (box_buffers[image]);
x1 = (gint) ((u * (gdouble) w));
y1 = (gint) ((v * (gdouble) h));
if (checkbounds_box_image (image, x1, y1) == FALSE)
return background;
x2 = (x1 + 1);
y2 = (y1 + 1);
if (checkbounds_box_image (image, x2, y2) == FALSE)
return peek_box_image (image, x1,y1);
p[0] = peek_box_image (image, x1, y1);
p[1] = peek_box_image (image, x2, y1);
p[2] = peek_box_image (image, x1, y2);
p[3] = peek_box_image (image, x2, y2);
return pika_bilinear_rgba (u * w, v * h, p);
}
PikaRGB
get_cylinder_image_color (gint image,
gdouble u,
gdouble v)
{
gint w, h;
gint x1, y1, x2, y2;
PikaRGB p[4];
w = gegl_buffer_get_width (cylinder_buffers[image]);
h = gegl_buffer_get_height (cylinder_buffers[image]);
x1 = (gint) ((u * (gdouble) w));
y1 = (gint) ((v * (gdouble) h));
if (checkbounds_cylinder_image (image, x1, y1) == FALSE)
return background;
x2 = (x1 + 1);
y2 = (y1 + 1);
if (checkbounds_cylinder_image (image, x2, y2) == FALSE)
return peek_cylinder_image (image, x1,y1);
p[0] = peek_cylinder_image (image, x1, y1);
p[1] = peek_cylinder_image (image, x2, y1);
p[2] = peek_cylinder_image (image, x1, y2);
p[3] = peek_cylinder_image (image, x2, y2);
return pika_bilinear_rgba (u * w, v * h, p);
}
/****************************************/
/* Allocate memory for temporary images */
/****************************************/
gint
image_setup (PikaDrawable *drawable,
gint interactive)
{
input_drawable = drawable;
output_drawable = drawable;
if (! pika_drawable_mask_intersect (drawable, &border_x, &border_y,
&border_w, &border_h))
return FALSE;
width = pika_drawable_get_width (input_drawable);
height = pika_drawable_get_height (input_drawable);
source_buffer = pika_drawable_get_buffer (input_drawable);
maxcounter = (glong) width * (glong) height;
if (mapvals.transparent_background == TRUE)
{
pika_rgba_set (&background, 0.0, 0.0, 0.0, 0.0);
}
else
{
pika_context_get_background (&background);
pika_rgb_set_alpha (&background, 1.0);
}
if (interactive == TRUE)
{
preview_rgb_stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24,
PREVIEW_WIDTH);
preview_rgb_data = g_new0 (guchar, preview_rgb_stride * PREVIEW_HEIGHT);
preview_surface = cairo_image_surface_create_for_data (preview_rgb_data,
CAIRO_FORMAT_RGB24,
PREVIEW_WIDTH,
PREVIEW_HEIGHT,
preview_rgb_stride);
}
return TRUE;
}