gimp/plug-ins/common/tiler.c

237 lines
5.5 KiB
C

/* Tiler v0.31
* 22 May 1997
* Tim Rowley <tor@cs.brown.edu>
*/
/* TODO:
* + better basis function
* + optimize
*/
/* History:
* v0.1: initial version
* v0.2: fix edge conditions
* v0.3: port to 0.99 API
* v0.31: small bugfix
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libgimp/gimp.h"
/* Declare local functions.
*/
static void query(void);
static void run(char *name, int nparams, GParam *param, int *nreturn_vals,
GParam **return_vals);
static void tile(GDrawable *drawable);
static int scale(int width, int height, int x, int y, int data);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
MAIN ()
static void
query ()
{
static GParamDef args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (unused)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" },
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof (args) / sizeof (args[0]);
static int nreturn_vals = 0;
gimp_install_procedure ("plug_in_make_seamless",
"Seamless tile creation",
"This plugin creates a seamless tileable from the input image",
"Tim Rowley",
"Tim Rowley",
"1997",
"<Image>/Filters/Map/Make Seamless",
"RGB*, GRAY*",
PROC_PLUG_IN,
nargs, nreturn_vals,
args, return_vals);
}
static void
run (char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals)
{
static GParam values[1];
GDrawable *drawable;
GRunModeType run_mode;
GStatusType status = STATUS_SUCCESS;
run_mode = param[0].data.d_int32;
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_color (drawable->id) || gimp_drawable_gray (drawable->id))
{
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
tile(drawable);
if (run_mode != RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else
{
/* gimp_message ("laplace: cannot operate on indexed color images"); */
status = STATUS_EXECUTION_ERROR;
}
*nreturn_vals = 1;
*return_vals = values;
values[0].type = PARAM_STATUS;
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static int scale(int width, int height, int x, int y, int data)
{
int A = width/2-1;
int B = height/2-1;
int a, b;
if (x<width/2)
a = width/2-x-1;
else if ((x==width/2) && (width&1))
return data;
else
a = x-width/2-(width&1);
if (y<height/2)
b = height/2-y-1;
else if ((y==height/2) && (height&1))
return data;
else
b = y-height/2-(height&1);
if ((B*a<A*b) || ((B*a==A*b) && (a&1))) {
a = A-a;
b = B-b;
if (a==A)
return data;
else
return data-((data*(A*B-a*B))/(A*b+A*B-a*B));
}
else {
if (a==A)
return 0;
else
return (data*(A*B-a*B))/(A*b+A*B-a*B);
}
}
static void
tile(GDrawable *drawable)
{
long width, height;
long bytes;
long val;
int wodd, hodd;
GPixelRgn srcPR, destPR;
gint x1, y1, x2, y2;
gint row, col, x, y, c;
guchar *cur_row, *dest_cur, *dest_top, *dest_bot;
/* Get the input */
gimp_drawable_mask_bounds(drawable->id, &x1, &y1, &x2, &y2);
gimp_progress_init("Tiler");
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
/* allocate row buffers */
cur_row = (guchar *) malloc ((x2 - x1) * bytes);
dest_cur = (guchar *) malloc ((x2 - x1) * bytes);
dest_top = (guchar *) malloc ((x2 - x1) * bytes);
dest_bot = (guchar *) malloc ((x2 - x1) * bytes);
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, 0, 0, width, height, TRUE, TRUE);
y = y2-y1;
x = x2-x1;
wodd = x&1;
hodd = y&1;
for (row = 0; row <y; row++)
{
gimp_pixel_rgn_get_row(&destPR, dest_cur, x1, y1+row, (x2-x1));
memset(dest_cur, 0, x*bytes);
gimp_pixel_rgn_set_row(&destPR, dest_cur, x1, y1+row, (x2-x1));
}
for (row = 0; row < y; row++)
{
gimp_pixel_rgn_get_row(&srcPR, cur_row, x1, y1+row, (x2-x1));
gimp_pixel_rgn_get_row(&destPR, dest_cur, x1, y1+row, (x2-x1));
if (row>=y/2+hodd)
gimp_pixel_rgn_get_row(&destPR, dest_top, x1, y1+(row-y/2-hodd), (x2-x1));
if (row<y/2)
gimp_pixel_rgn_get_row(&destPR, dest_bot, x1, y1+(row+y/2+hodd), (x2-x1));
for (col = 0; col < x; col++)
{
for (c=0; c<bytes; c++) {
val = scale(x, y, col, row, cur_row[col*bytes+c]);
/* Main image */
dest_cur[col*bytes+c] += val;
/* top left */
if ((col>=x/2+wodd) && (row>=y/2+hodd))
dest_top[(col-x/2-wodd)*bytes+c] += val;
/* top right */
if ((col<x/2) && (row>=y/2+hodd))
dest_top[(x/2+col+wodd)*bytes+c] += val;
/* bottom left */
if ((col>=x/2+wodd) && (row<y/2))
dest_bot[(col-x/2-wodd)*bytes+c] += val;
/* bottom right */
if ((col<x/2) && (row<y/2))
dest_bot[(col+x/2+wodd)*bytes+c] += val;
}
}
gimp_pixel_rgn_set_row(&destPR, dest_cur, x1, y1+row, (x2-x1));
if (row>=y/2+hodd)
gimp_pixel_rgn_set_row(&destPR, dest_top, x1, y1+(row-y/2-hodd), (x2-x1));
if (row<y/2)
gimp_pixel_rgn_set_row(&destPR, dest_bot, x1, y1+(row+y/2+hodd), (x2-x1));
if ((row % 5) == 0)
gimp_progress_update((double)row/(double)(y2-y1));
}
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(drawable->id, TRUE);
gimp_drawable_update(drawable->id, x1, y1, (x2-x1), (y2-y1));
}