dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

*** empty log message ***

This commit is contained in:
Vidar Madsen/gimpressionist 1999-08-29 21:06:26 +00:00
parent fdab10caa8
commit febc3daa0c
13 changed files with 441 additions and 564 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
plug-ins/gimpressionist/brush.c
View File

@ -53,6 +53,7 @@ void brushdmenuselect(gint32 id, gpointer data)
gint x1, y1, x2, y2;
gint row, col;
GDrawable *drawable;
int rowstride;
if(brushfile == 2) return; /* Not finished GUI-building yet */
@ -77,6 +78,8 @@ void brushdmenuselect(gint32 id, gpointer data)
newppm(&brushppm, x2-x1, y2-y1);
p = &brushppm;
rowstride = p->width * 3;
src_row = (guchar *)safemalloc((x2 - x1) * bpp);
gimp_pixel_rgn_init (&src_rgn, drawable, 0, 0, x2-x1, y2-y1, FALSE, FALSE);
@ -85,42 +88,44 @@ void brushdmenuselect(gint32 id, gpointer data)
int bpr = (x2-x1) * 3;
for(row = 0, y = y1; y < y2; row++, y++) {
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
memcpy(p->col[row], src_row, bpr);
memcpy(p->col + row*rowstride, src_row, bpr);
}
} else if(bpp > 3) { /* RGBA */
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
guchar *tmprow = p->col + row * rowstride;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
src = src_row;
for (col = 0, x = x1; x < x2; col++, x++) {
tmprow[col].r = src[0];
tmprow[col].g = src[1];
tmprow[col].b = src[2];
int k = col * 3;
tmprow[k+0] = src[0];
tmprow[k+1] = src[1];
tmprow[k+2] = src[2];
src += src_rgn.bpp;
}
}
} else if(bpp == 2) { /* GrayA */
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
guchar *tmprow = p->col + row * rowstride;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
src = src_row;
for (col = 0, x = x1; x < x2; col++, x++) {
tmprow[col].r = src[0];
tmprow[col].g = src[0];
tmprow[col].b = src[0];
int k = col * 3;
tmprow[k+0] = src[0];
tmprow[k+1] = src[0];
tmprow[k+2] = src[0];
src += src_rgn.bpp;
}
}
} else { /* Gray */
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
guchar *tmprow = p->col + row * rowstride;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
src = src_row;
for (col = 0, x = x1; x < x2; col++, x++) {
tmprow[col].r = src[0];
tmprow[col].g = src[0];
tmprow[col].b = src[0];
int k = col * 3;
tmprow[k+0] = src[0];
tmprow[k+1] = src[0];
tmprow[k+2] = src[0];
src += src_rgn.bpp;
}
}
@ -220,12 +225,12 @@ void reloadbrush(char *fn, struct ppm *p)
void padbrush(struct ppm *p, int width, int height)
{
struct rgbcolor black = {0,0,0};
guchar black[3] = {0,0,0};
int left = (width - p->width) / 2;
int right = (width - p->width) - left;
int top = (height - p->height) / 2;
int bottom = (height - p->height) - top;
pad(p, left, right, top, bottom, &black);
pad(p, left, right, top, bottom, black);
}
void updatebrushprev(char *fn)
@ -244,7 +249,7 @@ void updatebrushprev(char *fn)
} else {
double sc;
struct ppm p = {0,0,NULL};
unsigned char gammatable[256];
guchar gammatable[256];
int newheight;
if(brushfile)
@ -268,10 +273,11 @@ void updatebrushprev(char *fn)
resize_fast(&p, p.width*sc,newheight*sc);
padbrush(&p,100,100);
for(i = 0; i < 100; i++) {
int k = i * p.width * 3;
memset(buf,0,100);
if(i < p.height)
for(j = 0; j < p.width; j++)
buf[j] = gammatable[p.col[i][j].r];
buf[j] = gammatable[p.col[k + j * 3]];
gtk_preview_draw_row (GTK_PREVIEW (brushprev), buf, 0, i, 100);
}
killppm(&p);

71
plug-ins/gimpressionist/gimp.c
View File

@ -48,7 +48,7 @@ gimpressionist_vals_t defaultpcvals = {
{0,0,0},
1,
0,
{ { 0.5, 0.5, 0.0, 0.0, 1.0, 0 } },
{ { 0.5, 0.5, 0.0, 0.0, 1.0, 1.0, 0 } },
1,
0,
0.0,
@ -184,6 +184,7 @@ void grabarea(void)
struct ppm *p;
gint x1, y1, x2, y2;
gint row, col;
int rowstride;
if(standalone) {
loadppm(standalone, &infile);
@ -202,6 +203,8 @@ void grabarea(void)
newppm(&inalpha, x2-x1, y2-y1);
}
rowstride = p->width * 3;
src_row = (guchar *)safemalloc((x2 - x1) * bpp);
gimp_pixel_rgn_init (&src_rgn, drawable, 0, 0, x2-x1, y2-y1, FALSE, FALSE);
@ -210,45 +213,48 @@ void grabarea(void)
int bpr = (x2-x1) * 3;
for(row = 0, y = y1; y < y2; row++, y++) {
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
memcpy(p->col[row], src_row, bpr);
memcpy(p->col + row * rowstride, src_row, bpr);
}
} else if(bpp > 3) { /* RGBA */
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
struct rgbcolor *tmparow = inalpha.col[row];
guchar *tmprow = p->col + row * rowstride;
guchar *tmparow = inalpha.col + row * rowstride;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
src = src_row;
for (col = 0, x = x1; x < x2; col++, x++) {
tmprow[col].r = src[0];
tmprow[col].g = src[1];
tmprow[col].b = src[2];
tmparow[col].r = 255 - src[3];
int k = col * 3;
tmprow[k+0] = src[0];
tmprow[k+1] = src[1];
tmprow[k+2] = src[2];
tmparow[k] = 255 - src[3];
src += src_rgn.bpp;
}
}
} else if(bpp == 2) { /* GrayA */
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
struct rgbcolor *tmparow = inalpha.col[row];
guchar *tmprow = p->col + row * rowstride;
guchar *tmparow = inalpha.col + row * rowstride;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
src = src_row;
for (col = 0, x = x1; x < x2; col++, x++) {
tmprow[col].r = src[0];
tmprow[col].g = src[0];
tmprow[col].b = src[0];
tmparow[col].r = 255 - src[1];
int k = col * 3;
tmprow[k+0] = src[0];
tmprow[k+1] = src[0];
tmprow[k+2] = src[0];
tmparow[k] = 255 - src[1];
src += src_rgn.bpp;
}
}
} else { /* Gray */
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
guchar *tmprow = p->col + row * rowstride;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
src = src_row;
for (col = 0, x = x1; x < x2; col++, x++) {
tmprow[col].r = src[0];
tmprow[col].g = src[0];
tmprow[col].b = src[0];
int k = col * 3;
tmprow[k+0] = src[0];
tmprow[k+1] = src[0];
tmprow[k+2] = src[0];
src += src_rgn.bpp;
}
}
@ -266,6 +272,7 @@ void gimpressionist_main(void)
struct ppm *p;
gint x1, y1, x2, y2;
gint row, col;
int rowstride;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
@ -290,6 +297,8 @@ void gimpressionist_main(void)
p = &infile;
rowstride = p->width * 3;
if(bpp == 3) {
int bpr = (x2 - x1) * 3;
@ -297,22 +306,23 @@ void gimpressionist_main(void)
for(row = 0, y = y1; y < y2; row++, y++) {
if(row % 10 == 0)
gimp_progress_update(0.8 + 0.2*((double)row / (y2-y1)));
memcpy(dest_row, p->col[row], bpr);
memcpy(dest_row, p->col + row * rowstride, bpr);
gimp_pixel_rgn_set_row (&dest_rgn, dest_row, x1, y, (x2 - x1));
}
} else if(bpp == 4) {
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
guchar *tmprow = p->col + row * rowstride;
if(row % 10 == 0)
gimp_progress_update(0.8 + 0.2*((double)row / (y2-y1)));
dest = dest_row;
for(col = 0, x = x1; x < x2; col++, x++) {
dest[0] = tmprow[col].r;
dest[1] = tmprow[col].g;
dest[2] = tmprow[col].b;
dest[3] = 255 - inalpha.col[row][col].r;
int k = col * 3;
dest[0] = tmprow[k+0];
dest[1] = tmprow[k+1];
dest[2] = tmprow[k+2];
dest[3] = 255 - inalpha.col[row * rowstride + k];
dest += dest_rgn.bpp;
}
gimp_pixel_rgn_set_row (&dest_rgn, dest_row, x1, y, (x2 - x1));
@ -321,13 +331,14 @@ void gimpressionist_main(void)
} else if(bpp == 2) {
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
guchar *tmprow = p->col + row * rowstride;
if(row % 10 == 0)
gimp_progress_update(0.8 + 0.2*((double)row / (y2-y1)));
dest = dest_row;
for(col = 0, x = x1; x < x2; col++, x++) {
dest[0] = (tmprow[col].r + tmprow[col].g + tmprow[col].b) / 3;
dest[1] = 255 - inalpha.col[row][col].r;
int k = col * 3;
dest[0] = (tmprow[k] + tmprow[k+1] + tmprow[k+2]) / 3;
dest[1] = 255 - inalpha.col[row*rowstride + k];
dest += dest_rgn.bpp;
}
gimp_pixel_rgn_set_row (&dest_rgn, dest_row, x1, y, (x2 - x1));
@ -335,13 +346,15 @@ void gimpressionist_main(void)
} else {
for(row = 0, y = y1; y < y2; row++, y++) {
struct rgbcolor *tmprow = p->col[row];
guchar *tmprow = p->col + row * rowstride;
if(row % 10 == 0)
gimp_progress_update(0.8 + 0.2*((double)row / (y2-y1)));
dest = dest_row;
for(col = 0, x = x1; x < x2; col++, x++) {
dest[0] = (tmprow[col].r + tmprow[col].g + tmprow[col].b) / 3;
int k = col * 3;
dest[0] = (tmprow[k] + tmprow[k+1] + tmprow[k+2]) / 3;
dest += dest_rgn.bpp;
}
gimp_pixel_rgn_set_row (&dest_rgn, dest_row, x1, y, (x2 - x1));

14
plug-ins/gimpressionist/gimpressionist.c
View File

@ -60,10 +60,6 @@ GList *parsepath(void)
gimpdatasubdir = strchr (defaultpath, ':') + 1;
#endif
#ifdef DEBUG
fprintf(stderr, "gimp_gimprc_query: ");
#endif
if(standalone)
tmps = g_strdup(defaultpath);
else {
@ -89,9 +85,6 @@ GList *parsepath(void)
tmps = g_strdup(defaultpath);
} else {
tmps = g_strdup(return_vals[1].data.d_string);
#ifdef DEBUG
fprintf(stderr, "Got \"%s\"\n", tmps);
#endif
}
gimp_destroy_params (return_vals, nreturn_vals);
}
@ -125,10 +118,6 @@ char *findfile(char *fn)
static char file[200];
struct stat st;
#ifdef DEBUG
fprintf(stderr, "findfile(%s)\n", fn);
#endif
if(!rcpath) rcpath = parsepath();
thispath = rcpath;
@ -137,9 +126,6 @@ char *findfile(char *fn)
if(!stat(file, &st)) return file;
thispath = thispath->next;
}
#ifdef DEBUG
fprintf(stderr, "findfile(%s) returned NULL\n", fn);
#endif
return NULL;
}

5
plug-ins/gimpressionist/gimpressionist.h
View File

@ -1,7 +1,7 @@
#include <gtk/gtk.h>
#define PLUG_IN_NAME "plug_in_gimpressionist"
#define PLUG_IN_VERSION "v0.99.5, August 1999"
#define PLUG_IN_VERSION "v0.99.6, August 1999"
#ifndef DEFAULTPATH
#define DEFAULTPATH "~/.gimp/gimpressionist:/usr/local/share/gimp/gimpressionist"
@ -80,6 +80,8 @@ typedef struct {
int generalshadowdepth;
int generalshadowblur;
int coloracc;
} gimpressionist_vals_t;
/* Globals */
@ -135,6 +137,7 @@ extern GtkObject *generalshadowadjust;
extern GtkObject *generalshadowdepth;
extern GtkObject *generalshadowblur;
extern GtkObject *devthreshadjust;
extern GtkObject *coloraccadjust;
extern GtkWidget *placecenter;

102
plug-ins/gimpressionist/orientmap.c
View File

@ -149,27 +149,26 @@ void updateompreviewprev(void)
{
int x, y;
static struct ppm nbuffer = {0,0,NULL};
struct rgbcolor black = {0,0,0};
struct rgbcolor gray = {120,120,120};
struct rgbcolor white = {255,255,255};
guchar black[3] = {0,0,0};
guchar gray[3] = {120,120,120};
guchar white[3] = {255,255,255};
if(!nbuffer.col) {
newppm(&nbuffer,OMWIDTH,OMHEIGHT);
}
fill(&nbuffer, &black);
fill(&nbuffer, black);
for(y = 6; y < OMHEIGHT-4; y += 10)
for(x = 6; x < OMWIDTH-4; x += 10) {
double dir = degtorad(getdir(x/(double)OMWIDTH,y/(double)OMHEIGHT,0));
double xo = sin(dir)*4.0;
double yo = cos(dir)*4.0;
drawline(&nbuffer, x-xo, y-yo, x+xo, y+yo, &gray);
putrgb(&nbuffer, x-xo, y-yo, &white);
drawline(&nbuffer, x-xo, y-yo, x+xo, y+yo, gray);
putrgb(&nbuffer, x-xo, y-yo, white);
}
for(y = 0; y < OMHEIGHT; y++)
gtk_preview_draw_row(GTK_PREVIEW(ompreviewprev), (guchar *)nbuffer.col[y],
0, y, OMWIDTH);
gtk_preview_draw_row(GTK_PREVIEW(ompreviewprev), (guchar *)nbuffer.col + y * OMWIDTH * 3, 0, y, OMWIDTH);
gtk_widget_draw(ompreviewprev,NULL);
}
@ -184,9 +183,9 @@ void updatevectorprev(void)
double dir, xo, yo;
double val;
static double lastval = 0.0;
struct rgbcolor gray = {120,120,120};
struct rgbcolor red = {255,0,0};
struct rgbcolor white = {255,255,255};
guchar gray[3] = {120,120,120};
guchar red[3] = {255,0,0};
guchar white[3] = {255,255,255};
if(vectprevbrightadjust) val = 1.0 - GTK_ADJUSTMENT(vectprevbrightadjust)->value / 100.0;
else val = 0.5;
@ -211,14 +210,14 @@ void updatevectorprev(void)
xo = sin(dir)*(6.0+100*s);
yo = cos(dir)*(6.0+100*s);
if(i == selectedvector)
drawline(&buffer, x-xo, y-yo, x+xo, y+yo, &red);
drawline(&buffer, x-xo, y-yo, x+xo, y+yo, red);
else
drawline(&buffer, x-xo, y-yo, x+xo, y+yo, &gray);
putrgb(&buffer, x-xo, y-yo, &white);
drawline(&buffer, x-xo, y-yo, x+xo, y+yo, gray);
putrgb(&buffer, x-xo, y-yo, white);
}
for(y = 0; y < OMHEIGHT; y++)
gtk_preview_draw_row(GTK_PREVIEW(vectorprev), (guchar *)buffer.col[y], 0, y, OMWIDTH);
gtk_preview_draw_row(GTK_PREVIEW(vectorprev), (guchar *)buffer.col + y * OMWIDTH * 3, 0, y, OMWIDTH);
gtk_widget_draw(vectorprev,NULL);
}
@ -368,46 +367,6 @@ void vectypeclick(GtkWidget *w, gpointer data)
updateompreviewprev();
}
#ifdef DEBUG
void loadclick(void)
{
readdata(MAPFILE);
selectedvector = 0;
updatevectorprev();
updateompreviewprev();
}
void saveclick(void)
{
FILE *f = fopen(MAPFILE, "wt");
int i;
for(i = 0; i < numvect; i++) {
fprintf(f, "%.3f\t%.3f\t%5.1f\t%5.1f\n",
vector[i].x, vector[i].y, vector[i].dir, vector[i].str);
}
fclose(f);
}
void showpixclick(void)
{
int x, y;
for(y = 0; y < OMHEIGHT; y++) {
char buf[OMWIDTH*3];
for(x = 0; x < OMWIDTH; x++) {
int c = pixval(getdir(x/(double)OMWIDTH, y/(double)OMHEIGHT,0));
buf[x*3] = c;
buf[x*3+1] = c;
buf[x*3+2] = c;
}
gtk_preview_draw_row(GTK_PREVIEW(ompreviewprev), buf, 0, y, OMWIDTH);
}
gtk_widget_draw(ompreviewprev,NULL);
}
#endif
void hidewin(GtkWidget *w, GtkWidget **win)
{
gtk_widget_hide(*win);
@ -726,39 +685,6 @@ void create_orientmap_dialog(void)
(GtkSignalFunc)angoffadjmove, NULL);
gtk_tooltips_set_tip(GTK_TOOLTIPS(tooltips), tmpw, "Voronoi-mode makes only the vector closest to the given point have any influence", NULL);
#ifdef DEBUG
tmpw = hbox = gtk_hbox_new(TRUE,0);
gtk_table_attach_defaults(GTK_TABLE(table1), tmpw, 1,2,3,4);
gtk_container_border_width (GTK_CONTAINER (tmpw), 2);
gtk_widget_show(tmpw);
tmpw = gtk_button_new_with_label("Save");
gtk_box_pack_start(GTK_BOX(hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show(tmpw);
gtk_signal_connect (GTK_OBJECT(tmpw), "clicked",
GTK_SIGNAL_FUNC(saveclick), NULL);
tmpw = gtk_button_new_with_label("Load");
gtk_box_pack_start(GTK_BOX(hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show(tmpw);
gtk_signal_connect (GTK_OBJECT(tmpw), "clicked",
GTK_SIGNAL_FUNC(loadclick), NULL);
tmpw = gtk_button_new_with_label("Show pix");
gtk_box_pack_start(GTK_BOX(hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show(tmpw);
gtk_signal_connect (GTK_OBJECT(tmpw), "clicked",
GTK_SIGNAL_FUNC(showpixclick), NULL);
tmpw = gtk_button_new_with_label("dumpvect");
gtk_box_pack_start(GTK_BOX(hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show(tmpw);
gtk_signal_connect (GTK_OBJECT(tmpw), "clicked",
GTK_SIGNAL_FUNC(dumpvect), NULL);
#endif
gtk_widget_show(omwindow);
updatevectorprev();

3
plug-ins/gimpressionist/paper.c
View File

@ -41,10 +41,11 @@ void updatepaperprev(char *fn)
sc = 100.0 / sc;
resize(&p, p.width*sc,p.height*sc);
for(i = 0; i < 100; i++) {
int k = i * p.width * 3;
memset(buf,0,100);
if(i < p.height) {
for(j = 0; j < p.width; j++)
buf[j] = p.col[i][j].r;
buf[j] = p.col[k + j * 3];
if(GTK_TOGGLE_BUTTON(paperinvert)->active)
for(j = 0; j < p.width; j++)
buf[j] = 255 - buf[j];

49
plug-ins/gimpressionist/plasma.c
View File

@ -10,8 +10,12 @@ int pfix(int n)
return n;
}
#define PIXEL(y,x,z) p->col[(y)*rowstride+(x)*3+z]
void mkplasma_sub(struct ppm *p, int x1, int x2, int y1, int y2, float turb)
{
int rowstride = p->width * 3;
int r=0;
int xr, yr, nx, ny;
xr = abs(x1-x2);
yr = abs(y1-y2);
@ -20,22 +24,22 @@ void mkplasma_sub(struct ppm *p, int x1, int x2, int y1, int y2, float turb)
nx = (x1+x2)/2;
ny = (y1+y2)/2;
if(!p->col[y1][nx].r)
p->col[y1][nx].r = pfix((p->col[y1][x1].r+p->col[y1][x2].r)/2.0+
if(!PIXEL(y1,nx,r))
PIXEL(y1,nx,r) = pfix((PIXEL(y1,x1,r)+PIXEL(y1,x2,r))/2.0+
turb*(rand()%xr-xr/2.0));
if(!p->col[y2][nx].r)
p->col[y2][nx].r = pfix((p->col[y2][x1].r+p->col[y2][x2].r)/2.0+
if(!PIXEL(y2,nx,r))
PIXEL(y2,nx,r) = pfix((PIXEL(y2,x1,r)+PIXEL(y2,x2,r))/2.0+
turb*(rand()%xr-xr/2.0));
if(!p->col[ny][x1].r)
p->col[ny][x1].r = pfix((p->col[y1][x1].r+p->col[y2][x1].r)/2.0+
if(!PIXEL(ny,x1,r))
PIXEL(ny,x1,r) = pfix((PIXEL(y1,x1,r)+PIXEL(y2,x1,r))/2.0+
turb*(rand()%yr-yr/2.0));
if(!p->col[ny][x2].r)
p->col[ny][x2].r = pfix((p->col[y1][x2].r+p->col[y2][x2].r)/2.0+
if(!PIXEL(ny,x2,r))
PIXEL(ny,x2,r) = pfix((PIXEL(y1,x2,r)+PIXEL(y2,x2,r))/2.0+
turb*(rand()%yr-yr/2.0));
if(!p->col[ny][nx].r)
p->col[ny][nx].r =
pfix((p->col[y1][x1].r+p->col[y1][x2].r+p->col[y2][x1].r+
p->col[y2][x2].r)/4.0+turb*(rand()%(xr+yr)/2.0-(xr+yr)/4.0));
if(!PIXEL(ny,nx,r))
PIXEL(ny,nx,r) =
pfix((PIXEL(y1,x1,r)+PIXEL(y1,x2,r)+PIXEL(y2,x1,r)+
PIXEL(y2,x2,r))/4.0+turb*(rand()%(xr+yr)/2.0-(xr+yr)/4.0));
if(xr>1) {
mkplasma_sub(p,x1,nx,y1,ny, turb);
@ -50,26 +54,25 @@ void mkplasma_sub(struct ppm *p, int x1, int x2, int y1, int y2, float turb)
void mkplasma_red(struct ppm *p, float turb)
{
int x=0, y=0;
int rowstride = p->width * 3;
for(x = 0; x < p->width; x++)
for(y = 0; y < p->height; y++)
p->col[y][x].r = 0;
PIXEL(y,x,0) = 0;
x--; y--;
p->col[0][0].r = 1+rand()%255;
p->col[y][0].r = 1+rand()%255;
p->col[0][x].r = 1+rand()%255;
p->col[y][x].r = 1+rand()%255;
PIXEL(0,0,0) = 1+rand()%255;
PIXEL(y,0,0) = 1+rand()%255;
PIXEL(0,x,0) = 1+rand()%255;
PIXEL(y,x,0) = 1+rand()%255;
mkplasma_sub(p, 0, x, 0, y, turb);
}
void mkgrayplasma(struct ppm *p, float turb)
{
int x,y;
int y,l;
mkplasma_red(p, turb);
for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y];
for(x = 0; x < p->width; x++)
row[x].g = row[x].b = row[x].r;
}
l = p->width * 3 * p->height;
for(y = 0; y < l; y += 3)
p->col[y+1] = p->col[y+2] = p->col[y];
}

370
plug-ins/gimpressionist/ppmtool.c
View File

@ -45,10 +45,6 @@ void *safemalloc(int len)
void killppm(struct ppm *p)
{
int y;
for(y = 0; y < p->height; y++) {
free(p->col[y]);
}
free(p->col);
p->col = NULL;
p->height = p->width = 0;
@ -57,14 +53,8 @@ void killppm(struct ppm *p)
void newppm(struct ppm *p, int xs, int ys)
{
int x,y;
struct rgbcolor bgcol = {0,0,0};
#ifdef DEBUG
if((xs < 1) || (ys < 1)) {
fprintf(stderr, "Illegal size (%dx%d) specified!%c\n",xs, ys, 7);
}
#endif
int x;
guchar bgcol[3] = {0,0,0};
if(xs < 1)
xs = 1;
@ -73,24 +63,22 @@ void newppm(struct ppm *p, int xs, int ys)
p->width = xs;
p->height = ys;
p->col = (struct rgbcolor **)safemalloc(p->height * sizeof(struct rgbcolor *));
for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y] = (struct rgbcolor *)safemalloc(p->width * sizeof(struct rgbcolor));
for(x = 0; x < p->width; x++) {
row[x].r = bgcol.r;
row[x].g = bgcol.g;
row[x].b = bgcol.b;
}
p->col = safemalloc(xs * 3 * ys);
for(x = 0; x < xs * 3 * ys; x += 3) {
p->col[x+0] = bgcol[0];
p->col[x+1] = bgcol[1];
p->col[x+2] = bgcol[2];
}
}
void getrgb(struct ppm *s, float xo, float yo, struct rgbcolor *d)
void getrgb(struct ppm *s, float xo, float yo, guchar *d)
{
float ix, iy;
int x1, x2, y1, y2;
float x1y1, x2y1, x1y2, x2y2;
float r, g, b;
int bail = 0;
int rowstride = s->width * 3;
if(xo < 0.0) bail=1;
else if(xo >= s->width-1) { xo = s->width-1; } /* bail=1; */
@ -98,7 +86,7 @@ void getrgb(struct ppm *s, float xo, float yo, struct rgbcolor *d)
else if(yo >= s->height-1) { yo= s->height-1; } /* bail=1; */
if(bail) {
d->r = d->g = d->b = 0;
d[0] = d[1] = d[2] = 0;
return;
}
@ -121,34 +109,25 @@ void getrgb(struct ppm *s, float xo, float yo, struct rgbcolor *d)
x1y2 = (1.0-xo+ix)*(yo-iy);
x2y2 = (xo-ix)*(yo-iy);
r = s->col[y1][x1].r * x1y1;
if(x2y1 > 0.0)
r += s->col[y1][x2].r * x2y1;
if(x1y2 > 0.0)
r += s->col[y2][x1].r * x1y2;
if(x2y2 > 0.0)
r += s->col[y2][x2].r * x2y2;
r = s->col[y1*rowstride + x1*3 + 0] * x1y1;
g = s->col[y1*rowstride + x1*3 + 1] * x1y1;
b = s->col[y1*rowstride + x1*3 + 2] * x1y1;
g = s->col[y1][x1].g * x1y1;
if(x2y1 > 0.0)
g += s->col[y1][x2].g * x2y1;
if(x1y2 > 0.0)
g += s->col[y2][x1].g * x1y2;
if(x2y2 > 0.0)
g += s->col[y2][x2].g * x2y2;
if(x2y1 > 0.0) r += s->col[y1*rowstride + x2*3 + 0] * x2y1;
if(x2y1 > 0.0) g += s->col[y1*rowstride + x2*3 + 1] * x2y1;
if(x2y1 > 0.0) b += s->col[y1*rowstride + x2*3 + 2] * x2y1;
b = s->col[y1][x1].b * x1y1;
if(x2y1 > 0.0)
b += s->col[y1][x2].b * x2y1;
if(x1y2 > 0.0)
b += s->col[y2][x1].b * x1y2;
if(x2y2 > 0.0)
b += s->col[y2][x2].b * x2y2;
if(x1y2 > 0.0) r += s->col[y2*rowstride + x1*3 + 0] * x1y2;
if(x1y2 > 0.0) g += s->col[y2*rowstride + x1*3 + 1] * x1y2;
if(x1y2 > 0.0) b += s->col[y2*rowstride + x1*3 + 2] * x1y2;
d->r = r;
d->g = g;
d->b = b;
if(x2y2 > 0.0) r += s->col[y2*rowstride + x2*3 + 0] * x2y2;
if(x2y2 > 0.0) g += s->col[y2*rowstride + x2*3 + 1] * x2y2;
if(x2y2 > 0.0) b += s->col[y2*rowstride + x2*3 + 2] * x2y2;
d[0] = r;
d[1] = g;
d[2] = b;
}
@ -161,8 +140,9 @@ void resize(struct ppm *p, int nx, int ny)
newppm(&tmp, nx, ny);
for(y = 0; y < ny; y++) {
guchar *row = tmp.col + y * tmp.width * 3;
for(x = 0; x < nx; x++) {
getrgb(p, x*xs, y*ys, &tmp.col[y][x]);
getrgb(p, x*xs, y*ys, &row[x*3]);
}
}
killppm(p);
@ -187,7 +167,7 @@ void resize_fast(struct ppm *p, int nx, int ny)
for(y = 0; y < ny; y++) {
for(x = 0; x < nx; x++) {
int rx = x*xs, ry = y*ys;
memcpy(&tmp.col[y][x], &p->col[ry][rx], 3);
memcpy(&tmp.col[y*tmp.width*3+x*3], &p->col[ry*p->width*3+rx*3], 3);
}
}
killppm(p);
@ -210,7 +190,7 @@ struct _BrushHeader
void msb2lsb(unsigned int *i)
{
unsigned char *p = (unsigned char *)i, c;
guchar *p = (guchar *)i, c;
c = p[1]; p[1] = p[2]; p[2] = c;
c = p[0]; p[0] = p[3]; p[3] = c;
}
@ -219,7 +199,7 @@ void loadgbr(char *fn, struct ppm *p)
{
FILE *f;
struct _BrushHeader hdr;
unsigned char *ptr;
guchar *ptr;
int x, y;
f = fopen(fn, "rb");
@ -248,7 +228,8 @@ void loadgbr(char *fn, struct ppm *p)
for(y = 0; y < p->height; y++) {
fread(ptr, p->width, 1, f);
for(x = 0; x < p->width; x++) {
p->col[y][x].r = p->col[y][x].g = p->col[y][x].b = ptr[x];
int k = y*p->width*3 + x*3;
p->col[k+0] = p->col[k+1] = p->col[k+2] = ptr[x];
}
}
fclose(f);
@ -258,7 +239,7 @@ void loadgbr(char *fn, struct ppm *p)
void loadppm(char *fn, struct ppm *p)
{
char line[200];
int x,y, pgm = 0, c;
int y, pgm = 0;
FILE *f;
if(!strcmp(&fn[strlen(fn)-4], ".gbr")) {
@ -299,41 +280,37 @@ void loadppm(char *fn, struct ppm *p)
return;
/* fatal("Aborting!"); */
}
p->col = (struct rgbcolor **)safemalloc(p->height * sizeof(struct rgbcolor *));
p->col = safemalloc(p->height * p->width * 3);
if(!pgm)
for(y = 0; y < p->height; y++) {
p->col[y] = (struct rgbcolor *)safemalloc(p->width * sizeof(struct rgbcolor));
fread(p->col[y], p->width * sizeof(struct rgbcolor), 1, f);
} else /* if pgm */ {
for(y = 0; y < p->height; y++) {
p->col[y] = (struct rgbcolor *)safemalloc(p->width * sizeof(struct rgbcolor));
fread(p->col[y], p->width, 1, f);
for(x = p->width-1; x>=0; x--) {
c = *((unsigned char *)(p->col[y])+x);
p->col[y][x].r = p->col[y][x].g = p->col[y][x].b = c;
}
if(!pgm) {
fread(p->col, p->height * 3 * p->width, 1, f);
} else {
guchar *tmpcol = safemalloc(p->width * p->height);
fread(tmpcol, p->height * p->width, 1, f);
for(y = 0; y < p->width * p->height * 3; y++) {
p->col[y] = tmpcol[y/3];
}
}
fclose(f);
}
void fill(struct ppm *p, struct rgbcolor *c)
void fill(struct ppm *p, guchar *c)
{
int x, y;
if((c->r == c->g) && (c->r == c->b)) {
unsigned char col = c->r;
if((c[0] == c[1]) && (c[0] == c[2])) {
guchar col = c[0];
for(y = 0; y < p->height; y++) {
memset(p->col[y], col, p->width*3);
memset(p->col + y*p->width*3, col, p->width*3);
}
} else {
for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y];
guchar *row = p->col + y * p->width * 3;
for(x = 0; x < p->width; x++) {
row[x].r = c->r;
row[x].g = c->g;
row[x].b = c->b;
int k = x * 3;
row[k+0] = c[0];
row[k+1] = c[1];
row[k+2] = c[2];
}
}
}
@ -341,16 +318,12 @@ void fill(struct ppm *p, struct rgbcolor *c)
void copyppm(struct ppm *s, struct ppm *p)
{
int y;
if(p->col)
killppm(p);
p->width = s->width;
p->height = s->height;
p->col = (struct rgbcolor **)safemalloc(p->height * sizeof(struct rgbcolor *));
for(y = 0; y < p->height; y++) {
p->col[y] = (struct rgbcolor *)safemalloc(p->width * sizeof(struct rgbcolor));
memcpy(p->col[y], s->col[y], p->width * sizeof(struct rgbcolor));
}
p->col = safemalloc(p->width * 3 * p->height);
memcpy(p->col, s->col, p->width * 3 * p->height);
}
void freerotate(struct ppm *p, double amount)
@ -360,6 +333,7 @@ void freerotate(struct ppm *p, double amount)
double R, a;
struct ppm tmp = {0,0,NULL};
double f = amount*M_PI*2/360.0;
int rowstride = p->width * 3;
a = p->width/(float)p->height;
R = p->width<p->height?p->width/2:p->height/2;
@ -376,7 +350,7 @@ void freerotate(struct ppm *p, double amount)
nx = (p->width/2.0 + cos(d-f) * r);
ny = (p->height/2.0 + sin(d-f) * r);
getrgb(p, nx, ny, &tmp.col[y][x]);
getrgb(p, nx, ny, tmp.col + y*rowstride+x*3);
}
}
killppm(p);
@ -389,11 +363,15 @@ void crop(struct ppm *p, int lx, int ly, int hx, int hy)
{
struct ppm tmp = {0,0,NULL};
int x, y;
int srowstride = p->width * 3;
int drowstride;
newppm(&tmp, hx-lx, hy-ly);
drowstride = tmp.width * 3;
for(y = ly; y < hy; y++)
for(x = lx; x < hx; x++)
memcpy(&tmp.col[y-ly][x-lx], &p->col[y][x], sizeof(struct rgbcolor));
memcpy(&tmp.col[(y-ly)*drowstride+(x-lx)*3],
&p->col[y*srowstride+x*3], 3);
killppm(p);
p->col = tmp.col;
p->width = tmp.width;
@ -404,15 +382,17 @@ void autocrop(struct ppm *p, int room)
{
int lx = 0, hx = p->width, ly = 0, hy = p->height;
int x, y, n = 0;
struct rgbcolor tc;
guchar tc[3];
struct ppm tmp = {0,0,NULL};
int rowstride = p->width * 3;
int drowstride;
/* upper */
memcpy(&tc, &p->col[0][0], sizeof(struct rgbcolor));
memcpy(&tc, p->col, 3);
for(y = 0; y < p->height; y++) {
n = 0;
for(x = 0; x < p->width; x++) {
if(memcmp(&tc, &p->col[y][x], sizeof(struct rgbcolor))) { n++; break; }
if(memcmp(&tc, &p->col[y*rowstride+x*3], 3)) { n++; break; }
}
if(n) break;
}
@ -420,11 +400,11 @@ void autocrop(struct ppm *p, int room)
/* printf("ly = %d\n", ly); */
/* lower */
memcpy(&tc, &p->col[p->height-1][0], sizeof(struct rgbcolor));
memcpy(&tc, &p->col[(p->height-1)*rowstride], 3);
for(y = p->height-1; y >= 0; y--) {
n = 0;
for(x = 0; x < p->width; x++) {
if(memcmp(&tc, &p->col[y][x], sizeof(struct rgbcolor))) { n++; break; }
if(memcmp(&tc, &p->col[y*rowstride+x*3], 3)) { n++; break; }
}
if(n) break;
}
@ -433,11 +413,11 @@ void autocrop(struct ppm *p, int room)
/* printf("hy = %d\n", hy); */
/* left */
memcpy(&tc, &p->col[ly][0], sizeof(struct rgbcolor));
memcpy(&tc, &p->col[ly*rowstride], 3);
for(x = 0; x < p->width; x++) {
n = 0;
for(y = ly; y <= hy && y < p->height; y++) {
if(memcmp(&tc, &p->col[y][x], sizeof(struct rgbcolor))) { n++; break; }
if(memcmp(&tc, &p->col[y*rowstride+x*3], 3)) { n++; break; }
}
if(n) break;
}
@ -445,11 +425,11 @@ void autocrop(struct ppm *p, int room)
/* printf("lx = %d\n", lx); */
/* right */
memcpy(&tc, &p->col[ly][p->width-1], sizeof(struct rgbcolor));
memcpy(&tc, &p->col[ly*rowstride + (p->width-1)*3], 3);
for(x = p->width-1; x >= 0; x--) {
n = 0;
for(y = ly; y <= hy; y++) {
if(memcmp(&tc, &p->col[y][x], sizeof(struct rgbcolor))) { n++; break; }
if(memcmp(&tc, &p->col[y*rowstride+x*3], 3)) { n++; break; }
}
if(n) break;
}
@ -462,47 +442,53 @@ void autocrop(struct ppm *p, int room)
hy += room; if(hy>=p->height) hy = p->height-1;
newppm(&tmp, hx-lx, hy-ly);
drowstride = tmp.width * 3;
for(y = ly; y < hy; y++)
for(x = lx; x < hx; x++)
memcpy(&tmp.col[y-ly][x-lx], &p->col[y][x], sizeof(struct rgbcolor));
memcpy(&tmp.col[(y-ly)*drowstride+(x-lx)*3],
&p->col[y*rowstride+x*3], 3);
killppm(p);
p->col = tmp.col;
p->width = tmp.width;
p->height = tmp.height;
}
void pad(struct ppm *p, int left,int right, int top, int bottom, struct rgbcolor *bg)
void pad(struct ppm *p, int left,int right, int top, int bottom, guchar *bg)
{
int x, y;
struct ppm tmp = {0,0,NULL};
newppm(&tmp, p->width+left+right, p->height+top+bottom);
for(y = 0; y < tmp.height; y++) {
struct rgbcolor *row, *srcrow;
row = tmp.col[y];
guchar *row, *srcrow;
row = tmp.col + y * tmp.width * 3;
if((y < top) || (y >= tmp.height-bottom)) {
for(x = 0; x < tmp.width; x++) {
row[x].r = bg->r;
row[x].g = bg->g;
row[x].b = bg->b;
int k = x * 3;
row[k+0] = bg[0];
row[k+1] = bg[1];
row[k+2] = bg[2];
}
continue;
}
srcrow = p->col[y-top];
srcrow = p->col + (y-top) * p->width * 3;
for(x = 0; x < left; x++) {
row[x].r = bg->r;
row[x].g = bg->g;
row[x].b = bg->b;
int k = x * 3;
row[k+0] = bg[0];
row[k+1] = bg[1];
row[k+2] = bg[2];
}
for(; x < tmp.width-right; x++) {
tmp.col[y][x].r = srcrow[x-left].r;
tmp.col[y][x].g = srcrow[x-left].g;
tmp.col[y][x].b = srcrow[x-left].b;
int k = y * tmp.width * 3 + x * 3;
tmp.col[k+0] = srcrow[(x-left)*3+0];
tmp.col[k+1] = srcrow[(x-left)*3+1];
tmp.col[k+2] = srcrow[(x-left)*3+2];
}
for(; x < tmp.width; x++) {
row[x].r = bg->r;
row[x].g = bg->g;
row[x].b = bg->b;
int k = x * 3;
row[k+0] = bg[0];
row[k+1] = bg[1];
row[k+2] = bg[2];
}
}
killppm(p);
@ -513,11 +499,9 @@ void pad(struct ppm *p, int left,int right, int top, int bottom, struct rgbcolor
void saveppm(struct ppm *p, char *fn)
{
int y;
FILE *f = fopen(fn, "wb");
fprintf(f, "P6\n%d %d\n255\n", p->width, p->height);
for(y = 0; y < p->height; y++)
fwrite(p->col[y], p->width, 3, f);
fwrite(p->col, p->width * 3 * p->height, 1, f);
fclose(f);
}
@ -525,33 +509,36 @@ void edgepad(struct ppm *p, int left,int right, int top, int bottom)
{
int x,y;
struct ppm tmp = {0,0,NULL};
struct rgbcolor testcol = {0,255,0};
guchar testcol[3] = {0,255,0};
int srowstride, drowstride;
newppm(&tmp, p->width+left+right, p->height+top+bottom);
fill(&tmp, &testcol);
fill(&tmp, testcol);
srowstride = p->width * 3;
drowstride = tmp.width * 3;
for(y = 0; y < top; y++) {
memcpy(&tmp.col[y][left], &p->col[0][0], p->width * sizeof(struct rgbcolor));
memcpy(&tmp.col[y*drowstride+left*3], p->col, srowstride);
}
for(; y-top < p->height; y++) {
memcpy(&tmp.col[y][left], &p->col[y-top][0], p->width * sizeof(struct rgbcolor));
memcpy(&tmp.col[y*drowstride+left*3], p->col + (y-top)*srowstride, srowstride);
}
for(; y < tmp.height; y++) {
memcpy(&tmp.col[y][left], &p->col[p->height-1][0], p->width * sizeof(struct rgbcolor));
memcpy(&tmp.col[y*drowstride+left*3], p->col + (p->height-1)*srowstride, srowstride);
}
for(y = 0; y < tmp.height; y++) {
struct rgbcolor *col;
struct rgbcolor *tmprow;
guchar *col, *tmprow;
tmprow = tmp.col[y];
tmprow = tmp.col + y*drowstride;
col = tmp.col + y*drowstride + left*3;
col = &tmp.col[y][left];
for(x = 0; x < left; x++) {
memcpy(&tmprow[x], col, sizeof(struct rgbcolor));
memcpy(&tmprow[x*3], col, 3);
}
col = &tmp.col[y][tmp.width-right-1];
col = tmp.col + y*drowstride + (tmp.width-right-1)*3;
for(x = 0; x < right; x++) {
memcpy(&tmprow[x+tmp.width-right-1], col, sizeof(struct rgbcolor));
memcpy(&tmprow[(x+tmp.width-right-1)*3], col, 3);
}
}
killppm(p);
@ -562,69 +549,42 @@ void edgepad(struct ppm *p, int left,int right, int top, int bottom)
void ppmgamma(struct ppm *p, float e, int r, int g, int b)
{
int x, y;
unsigned char xlat[256];
int x, l = p->width * 3 * p->height;
guchar xlat[256], *pix;
if(e > 0.0) for(x = 0; x < 256; x++) {
xlat[x] = pow((x/255.0),(1.0/e))*255.0;
} else if(e < 0.0) for(x = 0; x < 256; x++) {
xlat[255-x] = pow((x/255.0),(-1.0/e))*255.0;
} else for(x = 0; x < 256; x++) { xlat[x] = 0; }
if(r) for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y];
for(x = 0; x < p->width; x++) {
row[x].r = xlat[row[x].r];
}
}
if(g) for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y];
for(x = 0; x < p->width; x++) {
row[x].g = xlat[row[x].g];
}
}
if(b) for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y];
for(x = 0; x < p->width; x++) {
row[x].b = xlat[row[x].b];
}
}
pix = p->col;
if(r) for(x = 0; x < l; x += 3) pix[x] = xlat[pix[x]];
if(g) for(x = 1; x < l; x += 3) pix[x] = xlat[pix[x]];
if(b) for(x = 2; x < l; x += 3) pix[x] = xlat[pix[x]];
}
void ppmbrightness(struct ppm *p, float e, int r, int g, int b)
{
int x, y;
unsigned char xlat[256];
int x, l = p->width * 3 * p->height;
guchar xlat[256], *pix;
for(x = 0; x < 256; x++) {
xlat[x] = x*e;
}
if(r) for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y];
for(x = 0; x < p->width; x++) {
row[x].r = xlat[row[x].r];
}
}
if(g) for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y];
for(x = 0; x < p->width; x++) {
row[x].g = xlat[row[x].g];
}
}
if(b) for(y = 0; y < p->height; y++) {
struct rgbcolor *row = p->col[y];
for(x = 0; x < p->width; x++) {
row[x].b = xlat[row[x].b];
}
}
pix = p->col;
if(r) for(x = 0; x < l; x += 3) pix[x] = xlat[pix[x]];
if(g) for(x = 1; x < l; x += 3) pix[x] = xlat[pix[x]];
if(b) for(x = 2; x < l; x += 3) pix[x] = xlat[pix[x]];
}
void blur(struct ppm *p, int xrad, int yrad)
{
int x, y;
int x, y, k;
int tx, ty;
struct ppm tmp = {0,0,NULL};
int r, g, b, n;
int rowstride = p->width * 3;
newppm(&tmp, p->width, p->height);
for(y = 0; y < p->height; y++) {
@ -636,15 +596,17 @@ void blur(struct ppm *p, int xrad, int yrad)
if(ty>=p->height) continue;
if(tx<0) continue;
if(tx>=p->width) continue;
r += p->col[ty][tx].r;
g += p->col[ty][tx].g;
b += p->col[ty][tx].b;
k = ty*rowstride + tx*3;
r += p->col[k+0];
g += p->col[k+1];
b += p->col[k+2];
n++;
}
}
tmp.col[y][x].r = r / n;
tmp.col[y][x].g = g / n;
tmp.col[y][x].b = b / n;
k = y*rowstride + x*3;
tmp.col[k+0] = r / n;
tmp.col[k+1] = g / n;
tmp.col[k+2] = b / n;
}
}
killppm(p);
@ -653,18 +615,20 @@ void blur(struct ppm *p, int xrad, int yrad)
p->col = tmp.col;
}
void putrgb_fast(struct ppm *s, float xo, float yo, struct rgbcolor *d)
void putrgb_fast(struct ppm *s, float xo, float yo, guchar *d)
{
struct rgbcolor *tp = &s->col[(int)(yo+0.5)][(int)(xo+0.5)];
tp->r = d->r;
tp->g = d->g;
tp->b = d->b;
guchar *tp;
tp = s->col + s->width * 3 * (int)(yo+0.5) + 3 * (int)(xo+0.5);
tp[0] = d[0];
tp[1] = d[1];
tp[2] = d[2];
}
void putrgb(struct ppm *s, float xo, float yo, struct rgbcolor *d)
void putrgb(struct ppm *s, float xo, float yo, guchar *d)
{
int x, y;
float aa, ab, ba, bb;
int k, rowstride = s->width * 3;
x = xo;
y = yo;
@ -680,34 +644,38 @@ void putrgb(struct ppm *s, float xo, float yo, struct rgbcolor *d)
ba = (1.0-xo)*yo;
bb = xo*yo;
s->col[y][x].r *= (1.0-aa);
s->col[y][x].g *= (1.0-aa);
s->col[y][x].b *= (1.0-aa);
s->col[y][x+1].r *= (1.0-ab);
s->col[y][x+1].g *= (1.0-ab);
s->col[y][x+1].b *= (1.0-ab);
s->col[y+1][x].r *= (1.0-ba);
s->col[y+1][x].g *= (1.0-ba);
s->col[y+1][x].b *= (1.0-ba);
s->col[y+1][x+1].r *= (1.0-bb);
s->col[y+1][x+1].g *= (1.0-bb);
s->col[y+1][x+1].b *= (1.0-bb);
k = y*rowstride + x*3;
s->col[k+0] *= (1.0-aa);
s->col[k+1] *= (1.0-aa);
s->col[k+2] *= (1.0-aa);
s->col[y][x].r += aa * d->r;
s->col[y][x].g += aa * d->g;
s->col[y][x].b += aa * d->b;
s->col[y][x+1].r += ab * d->r;
s->col[y][x+1].g += ab * d->g;
s->col[y][x+1].b += ab * d->b;
s->col[y+1][x].r += ba * d->r;
s->col[y+1][x].g += ba * d->g;
s->col[y+1][x].b += ba * d->b;
s->col[y+1][x+1].r += bb * d->r;
s->col[y+1][x+1].g += bb * d->g;
s->col[y+1][x+1].b += bb * d->b;
s->col[k+3] *= (1.0-ab);
s->col[k+4] *= (1.0-ab);
s->col[k+5] *= (1.0-ab);
s->col[k+rowstride+0] *= (1.0-ba);
s->col[k+rowstride+1] *= (1.0-ba);
s->col[k+rowstride+2] *= (1.0-ba);
s->col[k+rowstride+3] *= (1.0-bb);
s->col[k+rowstride+4] *= (1.0-bb);
s->col[k+rowstride+5] *= (1.0-bb);
s->col[k+0] += aa * d[0];
s->col[k+1] += aa * d[1];
s->col[k+2] += aa * d[2];
s->col[k+3] += ab * d[0];
s->col[k+4] += ab * d[1];
s->col[k+5] += ab * d[2];
s->col[k+rowstride+0] += ba * d[0];
s->col[k+rowstride+1] += ba * d[1];
s->col[k+rowstride+2] += ba * d[2];
s->col[k+rowstride+3] += bb * d[0];
s->col[k+rowstride+4] += bb * d[1];
s->col[k+rowstride+5] += bb * d[2];
}
void drawline(struct ppm *p, float fx, float fy, float tx, float ty, struct rgbcolor *col)
void drawline(struct ppm *p, float fx, float fy, float tx, float ty, guchar *col)
{
float i;
float d, x, y;

18
plug-ins/gimpressionist/ppmtool.h
View File

@ -1,35 +1,33 @@
struct rgbcolor {
unsigned char r, g, b;
};
#include <glib.h>
struct ppm {
int width;
int height;
struct rgbcolor **col;
unsigned char *col;
};
void fatal(char *s);
void *safemalloc(int len);
void killppm(struct ppm *p);
void newppm(struct ppm *p, int xs, int ys);
void getrgb(struct ppm *s, float xo, float yo, struct rgbcolor *d);
void getrgb(struct ppm *s, float xo, float yo, unsigned char *d);
void resize(struct ppm *p, int nx, int ny);
void rescale(struct ppm *p, double scale);
void resize_fast(struct ppm *p, int nx, int ny);
void loadppm(char *fn, struct ppm *p);
void saveppm(struct ppm *p, char *fn);
void copyppm(struct ppm *s, struct ppm *p);
void fill(struct ppm *p, struct rgbcolor *c);
void fill(struct ppm *p, guchar *c);
void freerotate(struct ppm *p, double amount);
void pad(struct ppm *p, int left,int right, int top, int bottom, struct rgbcolor *bg);
void pad(struct ppm *p, int left,int right, int top, int bottom, guchar *);
void edgepad(struct ppm *p, int left,int right, int top, int bottom);
void autocrop(struct ppm *p, int room);
void crop(struct ppm *p, int lx, int ly, int hx, int hy);
void ppmgamma(struct ppm *p, float e, int r, int g, int b);
void ppmbrightness(struct ppm *p, float e, int r, int g, int b);
void putrgb_fast(struct ppm *s, float xo, float yo, struct rgbcolor *d);
void putrgb(struct ppm *s, float xo, float yo, struct rgbcolor *d);
void drawline(struct ppm *p, float fx, float fy, float tx, float ty, struct rgbcolor *col);
void putrgb_fast(struct ppm *s, float xo, float yo, guchar *d);
void putrgb(struct ppm *s, float xo, float yo, guchar *d);
void drawline(struct ppm *p, float fx, float fy, float tx, float ty, guchar *col);
void repaint(struct ppm *p, struct ppm *a);

2
plug-ins/gimpressionist/presets.c
View File

@ -323,7 +323,7 @@ void savepreset(GtkWidget *wg, GtkWidget *p);
void presetdesccallback(GtkWidget *widget, gpointer data)
{
unsigned char *s;
guchar *s;
char *d, *str;
str = gtk_editable_get_chars(GTK_EDITABLE (widget),0,-1);
s = str;

25
plug-ins/gimpressionist/preview.c
View File

@ -21,19 +21,21 @@ void drawalpha(struct ppm *p, struct ppm *a)
int x, y, g;
double v;
int gridsize = 16;
int rowstride = p->width * 3;
for(y = 0; y < p->height; y++) {
for(x = 0; x < p->width; x++) {
if(!a->col[y][x].r) continue;
v = 1.0 - a->col[y][x].r / 255.0;
int k = y*rowstride + x*3;
if(!a->col[k]) continue;
v = 1.0 - a->col[k] / 255.0;
g = ((x/gridsize+y/gridsize)%2)*60+100;
p->col[y][x].r *= v;
p->col[y][x].g *= v;
p->col[y][x].b *= v;
p->col[k+0] *= v;
p->col[k+1] *= v;
p->col[k+2] *= v;
v = 1.0-v;
p->col[y][x].r += g*v;
p->col[y][x].g += g*v;
p->col[y][x].b += g*v;
p->col[k+0] += g*v;
p->col[k+1] += g*v;
p->col[k+2] += g*v;
}
}
@ -42,7 +44,7 @@ void drawalpha(struct ppm *p, struct ppm *a)
void updatepreviewprev(GtkWidget *wg, void *d)
{
int i, j;
int i;
char buf[PREVIEWSIZE*3];
static struct ppm p = {0,0,NULL};
static struct ppm a = {0,0,NULL};
@ -83,9 +85,8 @@ void updatepreviewprev(GtkWidget *wg, void *d)
for(i = 0; i < PREVIEWSIZE; i++) {
memset(buf,0,PREVIEWSIZE*3);
for(j = 0; j < p.width; j++)
gtk_preview_draw_row(GTK_PREVIEW(previewprev), (guchar *)p.col[i],
0, i, PREVIEWSIZE);
//for(j = 0; j < p.width; j++)
gtk_preview_draw_row(GTK_PREVIEW(previewprev), (guchar *)&p.col[i*PREVIEWSIZE*3], 0, i, PREVIEWSIZE);
}
killppm(&p);
if(img_has_alpha)

236
plug-ins/gimpressionist/repaint.c
View File

@ -22,51 +22,50 @@ gimpressionist_vals_t runningvals;
void prepbrush(struct ppm *p)
{
int x, y;
int rowstride = p->width * 3;
for(y = 0; y< p->height; y++) {
for(x = 0; x < p->width; x++) {
p->col[y][x].g = 0;
p->col[y*rowstride+x*3+1] = 0;
}
}
for(y = 1; y< p->height; y++) {
for(x = 1; x < p->width; x++) {
int v = p->col[y][x].r - p->col[y-1][x-1].r;
int v = p->col[y*rowstride+x*3] - p->col[(y-1)*rowstride+(x-1)*3];
if(v < 0) v = 0;
p->col[y][x].g = v;
p->col[y*rowstride+x*3+1] = v;
}
}
}
double sumbrush(struct ppm *p)
{
int x, y;
double sum = 0;
for(y = 0; y< p->height; y++) {
for(x = 0; x < p->width; x++) {
sum += p->col[y][x].r;
}
}
int i;
for(i = 0; i < p->width*3*p->height; i += 3)
sum += p->col[i];
return sum;
}
int gethue(struct rgbcolor *rgb)
int gethue(guchar *rgb)
{
double h, v, temp, diff;
if((rgb->r == rgb->g) && (rgb->r == rgb->b)) /* Gray */
if((rgb[0] == rgb[1]) && (rgb[0] == rgb[2])) /* Gray */
return 0;
v = (rgb->r > rgb->g ? rgb->r : rgb->g); /* v = st<F8>rste verdi */
if(rgb->b > v) v = rgb->b;
temp = (rgb->r > rgb->g ? rgb->g : rgb->r ); /* temp = minste */
if(rgb->b < temp) temp = rgb->b;
v = (rgb[0] > rgb[1] ? rgb[0] : rgb[1]); /* v = st<F8>rste verdi */
if(rgb[2] > v) v = rgb[2];
temp = (rgb[0] > rgb[1] ? rgb[1] : rgb[0] ); /* temp = minste */
if(rgb[2] < temp) temp = rgb[2];
diff = v - temp;
if(v == rgb->r)
h = ((double)rgb->g - rgb->b) / diff;
else if(v == rgb->g)
h = ((double)rgb->b - rgb->r) / diff + 2;
else /* v == rgb->b */
h = ((double)rgb->r - rgb->g) / diff + 4;
if(v == rgb[0])
h = ((double)rgb[1] - rgb[2]) / diff;
else if(v == rgb[1])
h = ((double)rgb[2] - rgb[0]) / diff + 2;
else /* v == rgb[2] */
h = ((double)rgb[0] - rgb[1]) / diff + 4;
if(h < 0) h += 6;
return h * 255.0 / 6.0;
}
@ -90,15 +89,16 @@ int bestbrush(struct ppm *p, struct ppm *a, int tx, int ty,
r = g = b = 0.0;
for(y = 0; y < brush->height; y++) {
struct rgbcolor *row = p->col[ty+y];
guchar *row = p->col + (ty+y)*p->width*3;
for(x = 0; x < brush->width; x++) {
int k = (tx+x)*3;
double v;
if((h = brush->col[y][x].r)) {
if((h = brush->col[(y*brush->width*3)+x*3])) {
/* thissum += h; */
v = h / 255.0;
r += row[tx+x].r * v;
g += row[tx+x].g * v;
b += row[tx+x].b * v;
r += row[k+0] * v;
g += row[k+1] * v;
b += row[k+2] * v;
}
}
}
@ -108,16 +108,17 @@ int bestbrush(struct ppm *p, struct ppm *a, int tx, int ty,
dev = 0.0;
for(y = 0; y < brush->height; y++) {
struct rgbcolor *row = p->col[ty+y];
guchar *row = p->col + (ty+y)*p->width*3;
for(x = 0; x < brush->width; x++) {
int k = (tx+x)*3;
double v;
if((h = brush->col[y][x].r)) {
if((h = brush->col[(y*brush->width*3)+x*3])) {
v = h / 255.0;
dev += abs(row[tx+x].r - r) * v;
dev += abs(row[tx+x].g - g) * v;
dev += abs(row[tx+x].b - b) * v;
dev += abs(row[k+0] - r) * v;
dev += abs(row[k+1] - g) * v;
dev += abs(row[k+2] - b) * v;
if(img_has_alpha)
dev += a->col[ty+y][tx+x].r * v;
dev += a->col[(ty+y)*a->width*3+(tx+x)*3] * v;
}
}
}
@ -177,63 +178,66 @@ void applybrush(struct ppm *brush,
int sx = tx + shadowdepth - shadowblur*2;
int sy = ty + shadowdepth - shadowblur*2;
for(y = 0; y < shadow->height; y++) {
struct rgbcolor *row, *arow = NULL;
guchar *row, *arow = NULL;
if((sy + y) < 0) continue;
if((sy + y) >= tmp.height) break;
row = tmp.col[sy+y];
if(img_has_alpha) arow = atmp.col[sy+y];
row = tmp.col + (sy+y) * tmp.width * 3;
if(img_has_alpha) arow = atmp.col + (sy+y) * atmp.width * 3;
for(x = 0; x < shadow->width; x++) {
int k = (sx + x) * 3;
if((sx + x) < 0) continue;
if((sx + x) >= tmp.width) break;
h = shadow->col[y][x].b;
h = shadow->col[y*shadow->width*3+x*3+2];
if(!h) continue;
v = 1.0 - (h / 255.0 * runningvals.generalshadowdarkness / 100.0);
row[sx+x].r *= v;
row[sx+x].g *= v;
row[sx+x].b *= v;
if(img_has_alpha) arow[sx+x].r *= v;
row[k+0] *= v;
row[k+1] *= v;
row[k+2] *= v;
if(img_has_alpha) arow[k] *= v;
}
}
}
for(y = 0; y < brush->height; y++) {
struct rgbcolor *row = tmp.col[ty+y];
struct rgbcolor *arow = NULL;
if(img_has_alpha) arow = atmp.col[ty+y];
guchar *row = tmp.col + (ty+y)*tmp.width*3;
guchar *arow = NULL;
if(img_has_alpha) arow = atmp.col + (ty+y)*atmp.width*3;
for(x = 0; x < brush->width; x++) {
h = brush->col[y][x].r;
int k = (tx + x) * 3;
h = brush->col[y*brush->width*3+x*3];
if(!h) continue;
if(runningvals.colorbrushes) {
v = 1.0 - brush->col[y][x].b / 255.0;
row[tx+x].r *= v;
row[tx+x].g *= v;
row[tx+x].b *= v;
if(img_has_alpha) arow[tx+x].r *= v;
v = 1.0 - brush->col[y*brush->width*3+x*3+2] / 255.0;
row[k+0] *= v;
row[k+1] *= v;
row[k+2] *= v;
if(img_has_alpha) arow[(tx+x)*3] *= v;
}
v = (1.0 - h / 255.0) * edgedarken;
row[tx+x].r *= v;
row[tx+x].g *= v;
row[tx+x].b *= v;
if(img_has_alpha) arow[tx+x].r *= v;
row[k+0] *= v;
row[k+1] *= v;
row[k+2] *= v;
if(img_has_alpha) arow[k] *= v;
v = h / 255.0;
row[tx+x].r += r * v;
row[tx+x].g += g * v;
row[tx+x].b += b * v;
row[k+0] += r * v;
row[k+1] += g * v;
row[k+2] += b * v;
}
}
if(relief > 0.001) {
for(y = 1; y < brush->height; y++) {
struct rgbcolor *row = tmp.col[ty+y];
guchar *row = tmp.col + (ty+y)*tmp.width*3;
for(x = 1; x < brush->width; x++) {
h = brush->col[y][x].g * relief;
int k = (tx + x) * 3;
h = brush->col[y*brush->width*3+x*3+1] * relief;
if(h < 0.001) continue;
if(h > 255) h = 255;
row[tx+x].r = (row[tx+x].r * (255-h) + 255 * h) / 255;
row[tx+x].g = (row[tx+x].g * (255-h) + 255 * h) / 255;
row[tx+x].b = (row[tx+x].b * (255-h) + 255 * h) / 255;
row[k+0] = (row[k+0] * (255-h) + 255 * h) / 255;
row[k+1] = (row[k+1] * (255-h) + 255 * h) / 255;
row[k+2] = (row[k+2] * (255-h) + 255 * h) / 255;
}
}
}
@ -247,7 +251,7 @@ void repaint(struct ppm *p, struct ppm *a)
struct ppm atmp = {0,0,NULL};
int r, g, b, n, h, i, j, on, sn;
int numbrush, maxbrushwidth, maxbrushheight;
struct rgbcolor back = {0,0,0};
guchar back[3] = {0,0,0};
struct ppm *brushes, *shadows;
struct ppm *brush, *shadow = NULL;
double *brushsum;
@ -315,7 +319,7 @@ void repaint(struct ppm *p, struct ppm *a)
i = 1 + sqrt(brushes[0].width * brushes[0].width +
brushes[0].height * brushes[0].height);
pad(&brushes[0], i-brushes[0].width, i-brushes[0].width,
i-brushes[0].height, i-brushes[0].height, &back);
i-brushes[0].height, i-brushes[0].height, back);
for(i = 1; i < numbrush; i++) {
brushes[i].col = NULL;
@ -362,12 +366,12 @@ void repaint(struct ppm *p, struct ppm *a)
for(i = 0; i < numbrush; i++) {
int xp, yp;
struct rgbcolor blk = {0,0,0};
guchar blk[3] = {0,0,0};
xp = maxbrushwidth - brushes[i].width;
yp = maxbrushheight - brushes[i].height;
if(xp || yp)
pad(&brushes[i], xp/2, xp-xp/2, yp/2, yp-yp/2, &blk);
pad(&brushes[i], xp/2, xp-xp/2, yp/2, yp-yp/2, blk);
}
if(dropshadow) {
@ -376,7 +380,7 @@ void repaint(struct ppm *p, struct ppm *a)
copyppm(&brushes[i], &shadows[i]);
ppmgamma(&shadows[i], 0, 1,1,0);
pad(&shadows[i], shadowblur*2, shadowblur*2,
shadowblur*2, shadowblur*2, &back);
shadowblur*2, shadowblur*2, back);
for(j = 0; j < shadowblur; j++)
blur(&shadows[i], 2, 2);
/* autocrop(&shadows[i],1); */
@ -403,19 +407,19 @@ void repaint(struct ppm *p, struct ppm *a)
if(img_has_alpha) {
/* Initially fully transparent */
if(runningvals.generalbgtype == 3) {
struct rgbcolor tmpcol = {255,255,255};
guchar tmpcol[3] = {255,255,255};
newppm(&atmp, a->width, a->height);
fill(&atmp, &tmpcol);
fill(&atmp, tmpcol);
} else {
copyppm(a, &atmp);
}
}
if(runningvals.generalbgtype == 0) {
struct rgbcolor tmpcol;
guchar tmpcol[3];
newppm(&tmp, p->width, p->height);
memcpy(&tmpcol, runningvals.color, 3);
fill(&tmp, &tmpcol);
fill(&tmp, tmpcol);
} else if(runningvals.generalbgtype == 1) {
copyppm(p, &tmp);
} else {
@ -429,7 +433,7 @@ void repaint(struct ppm *p, struct ppm *a)
int rx = x % paperppm.width;
for(y = 0; y < tmp.height; y++) {
int ry = y % paperppm.height;
memcpy(&tmp.col[y][x], &paperppm.col[ry][rx], 3);
memcpy(&tmp.col[y*tmp.width*3+x*3], &paperppm.col[ry*paperppm.width*3+rx*3], 3);
}
}
}
@ -441,27 +445,27 @@ void repaint(struct ppm *p, struct ppm *a)
if(runningvals.orienttype == 0) { /* Value */
newppm(&dirmap, p->width, p->height);
for(y = 0; y < dirmap.height; y++) {
struct rgbcolor *dstrow = dirmap.col[y];
struct rgbcolor *srcrow = p->col[y];
guchar *dstrow = &dirmap.col[y*dirmap.width*3];
guchar *srcrow = &p->col[y*p->width*3];
for(x = 0; x < dirmap.width; x++) {
dstrow[x].r = (srcrow[x].r + srcrow[x].g + srcrow[x].b) / 3;
dstrow[x*3] = (srcrow[x*3] + srcrow[x*3+1] + srcrow[x*3+2]) / 3;
}
}
} else if(runningvals.orienttype == 1) { /* Radius */
newppm(&dirmap, p->width, p->height);
for(y = 0; y < dirmap.height; y++) {
struct rgbcolor *dstrow = dirmap.col[y];
guchar *dstrow = &dirmap.col[y*dirmap.width*3];
double ysqr = (cy-y)*(cy-y);
for(x = 0; x < dirmap.width; x++) {
dstrow[x].r = sqrt((cx-x)*(cx-x)+ysqr) * 255 / maxdist;
dstrow[x*3] = sqrt((cx-x)*(cx-x)+ysqr) * 255 / maxdist;
}
}
} else if(runningvals.orienttype == 3) { /* Radial */
newppm(&dirmap, p->width, p->height);
for(y = 0; y < dirmap.height; y++) {
struct rgbcolor *dstrow = dirmap.col[y];
guchar *dstrow = &dirmap.col[y*dirmap.width*3];
for(x = 0; x < dirmap.width; x++) {
dstrow[x].r = (M_PI + atan2(cy-y, cx-x)) * 255.0 / (M_PI*2);
dstrow[x*3] = (M_PI + atan2(cy-y, cx-x)) * 255.0 / (M_PI*2);
}
}
} else if(runningvals.orienttype == 4) { /* Flowing */
@ -476,24 +480,24 @@ void repaint(struct ppm *p, struct ppm *a)
} else if(runningvals.orienttype == 5) { /* Hue */
newppm(&dirmap, p->width, p->height);
for(y = 0; y < dirmap.height; y++) {
struct rgbcolor *dstrow = dirmap.col[y];
struct rgbcolor *srcrow = p->col[y];
guchar *dstrow = &dirmap.col[y*dirmap.width*3];
guchar *srcrow = &p->col[y*p->width*3];
for(x = 0; x < dirmap.width; x++) {
dstrow[x].r = gethue(&srcrow[x]);
dstrow[x*3] = gethue(&srcrow[x*3]);
}
}
} else if(runningvals.orienttype == 6) {
struct rgbcolor tmpcol = {0,0,0};
guchar tmpcol[3] = {0,0,0};
newppm(&dirmap, p->width, p->height);
fill(&dirmap, &tmpcol);
fill(&dirmap, tmpcol);
} else if(runningvals.orienttype == 7) { /* Manual */
newppm(&dirmap, p->width-maxbrushwidth*2, p->height-maxbrushheight*2);
for(y = 0; y < dirmap.height; y++) {
struct rgbcolor *dstrow = dirmap.col[y];
guchar *dstrow = &dirmap.col[y*dirmap.width*3];
double tmpy = y / (double)dirmap.height;
for(x = 0; x < dirmap.width; x++) {
dstrow[x].r = pixval(90-getdir(x / (double)dirmap.width, tmpy, 1));
dstrow[x*3] = pixval(90-getdir(x / (double)dirmap.width, tmpy, 1));
}
}
edgepad(&dirmap, maxbrushwidth, maxbrushwidth, maxbrushheight, maxbrushheight);
@ -502,27 +506,27 @@ void repaint(struct ppm *p, struct ppm *a)
if(runningvals.sizetype == 0) { /* Value */
newppm(&sizmap, p->width, p->height);
for(y = 0; y < sizmap.height; y++) {
struct rgbcolor *dstrow = sizmap.col[y];
struct rgbcolor *srcrow = p->col[y];
guchar *dstrow = &sizmap.col[y*sizmap.width*3];
guchar *srcrow = &p->col[y*p->width*3];
for(x = 0; x < sizmap.width; x++) {
dstrow[x].r = (srcrow[x].r + srcrow[x].g + srcrow[x].b) / 3;
dstrow[x*3] = (srcrow[x*3] + srcrow[x*3+1] + srcrow[x*3+2]) / 3;
}
}
} else if(runningvals.sizetype == 1) { /* Radius */
newppm(&sizmap, p->width, p->height);
for(y = 0; y < sizmap.height; y++) {
struct rgbcolor *dstrow = sizmap.col[y];
guchar *dstrow = &sizmap.col[y*sizmap.width*3];
double ysqr = (cy-y)*(cy-y);
for(x = 0; x < sizmap.width; x++) {
dstrow[x].r = sqrt((cx-x)*(cx-x)+ysqr) * 255 / maxdist;
dstrow[x*3] = sqrt((cx-x)*(cx-x)+ysqr) * 255 / maxdist;
}
}
} else if(runningvals.sizetype == 3) { /* Radial */
newppm(&sizmap, p->width, p->height);
for(y = 0; y < sizmap.height; y++) {
struct rgbcolor *dstrow = sizmap.col[y];
guchar *dstrow = &sizmap.col[y*sizmap.width*3];
for(x = 0; x < sizmap.width; x++) {
dstrow[x].r = (M_PI + atan2(cy-y, cx-x)) * 255.0 / (M_PI*2);
dstrow[x*3] = (M_PI + atan2(cy-y, cx-x)) * 255.0 / (M_PI*2);
}
}
} else if(runningvals.sizetype == 4) { /* Flowing */
@ -537,24 +541,24 @@ void repaint(struct ppm *p, struct ppm *a)
} else if(runningvals.sizetype == 5) { /* Hue */
newppm(&sizmap, p->width, p->height);
for(y = 0; y < sizmap.height; y++) {
struct rgbcolor *dstrow = sizmap.col[y];
struct rgbcolor *srcrow = p->col[y];
guchar *dstrow = &sizmap.col[y*sizmap.width*3];
guchar *srcrow = &p->col[y*p->width*3];
for(x = 0; x < sizmap.width; x++) {
dstrow[x].r = gethue(&srcrow[x]);
dstrow[x*3] = gethue(&srcrow[x*3]);
}
}
} else if(runningvals.sizetype == 6) {
struct rgbcolor tmpcol = {0,0,0};
guchar tmpcol[3] = {0,0,0};
newppm(&sizmap, p->width, p->height);
fill(&sizmap, &tmpcol);
fill(&sizmap, tmpcol);
} else if(runningvals.sizetype == 7) { /* Manual */
newppm(&sizmap, p->width-maxbrushwidth*2, p->height-maxbrushheight*2);
for(y = 0; y < sizmap.height; y++) {
struct rgbcolor *dstrow = sizmap.col[y];
guchar *dstrow = &sizmap.col[y*sizmap.width*3];
double tmpy = y / (double)sizmap.height;
for(x = 0; x < sizmap.width; x++) {
dstrow[x].r = 255 * (1.0 - getsiz(x / (double)sizmap.width, tmpy, 1));
dstrow[x*3] = 255 * (1.0 - getsiz(x / (double)sizmap.width, tmpy, 1));
}
}
edgepad(&sizmap, maxbrushwidth, maxbrushwidth, maxbrushheight, maxbrushheight);
@ -639,7 +643,7 @@ void repaint(struct ppm *p, struct ppm *a)
}
if(img_has_alpha) {
if(a->col[ty][tx].r > 128)
if(a->col[ty*a->width*3+tx*3] > 128)
continue;
}
@ -655,7 +659,7 @@ void repaint(struct ppm *p, struct ppm *a)
case 4: /* Flowing */
case 5: /* Hue */
case 7: /* Manual */
on = runningvals.orientnum * dirmap.col[ty][tx].r / 255;
on = runningvals.orientnum * dirmap.col[ty*dirmap.width*3+tx*3] / 255;
break;
case 6: /* Adaptive */
break; /* Handled below */
@ -675,7 +679,7 @@ void repaint(struct ppm *p, struct ppm *a)
case 4: /* Flowing */
case 5: /* Hue */
case 7: /* Manual */
sn = runningvals.sizenum * sizmap.col[ty][tx].r / 255;
sn = runningvals.sizenum * sizmap.col[ty*sizmap.width*3+tx*3] / 255;
break;
case 6: /* Adaptive */
break; /* Handled below */
@ -715,14 +719,15 @@ void repaint(struct ppm *p, struct ppm *a)
/* Calculate color - avg. of in-brush pixels */
r = g = b = 0;
for(y = 0; y < brush->height; y++) {
struct rgbcolor *row = p->col[ty+y];
guchar *row = &p->col[(ty+y)*p->width*3];
for(x = 0; x < brush->width; x++) {
int k = (tx+x) * 3;
double v;
if((h = brush->col[y][x].r)) {
if((h = brush->col[y*brush->width*3+x*3])) {
v = h / 255.0;
r += row[tx+x].r * v;
g += row[tx+x].g * v;
b += row[tx+x].b * v;
r += row[k+0] * v;
g += row[k+1] * v;
b += row[k+2] * v;
}
}
}
@ -808,23 +813,24 @@ void repaint(struct ppm *p, struct ppm *a)
double h, v;
int px = x % tmp.width, py;
for(y = 0; y < p->height; y++) {
int k = y * tmp.width * 3 + x * 3;
py = y % tmp.height;
if(runningvals.paperoverlay)
h = (tmp.col[py][px].r-128) * relief;
h = (tmp.col[py*tmp.width*3+px*3]-128) * relief;
else
h = (tmp.col[py][px].r - (int)tmp.col[(py+1)%tmp.height][(px+1)%tmp.width].r) / -2.0 * relief;
h = (tmp.col[py*tmp.width*3+px*3] - (int)tmp.col[((py+1)%tmp.height)*tmp.width*3+((px+1)%tmp.width)*3]) / -2.0 * relief;
if(h <= 0.0) {
v = 1.0 + h/128.0;
if(v < 0.0) v = 0.0; else if(v > 1.0) v = 1.0;
p->col[y][x].r *= v;
p->col[y][x].g *= v;
p->col[y][x].b *= v;
p->col[k+0] *= v;
p->col[k+1] *= v;
p->col[k+2] *= v;
} else {
v = h/128.0;
if(v < 0.0) v = 0.0; else if(v > 1.0) v = 1.0;
p->col[y][x].r = p->col[y][x].r * (1.0-v) + 255 * v;
p->col[y][x].g = p->col[y][x].g * (1.0-v) + 255 * v;
p->col[y][x].b = p->col[y][x].b * (1.0-v) + 255 * v;
p->col[k+0] = p->col[k+0] * (1.0-v) + 255 * v;
p->col[k+1] = p->col[k+1] * (1.0-v) + 255 * v;
p->col[k+2] = p->col[k+2] * (1.0-v) + 255 * v;
}
}
}

68
plug-ins/gimpressionist/sizemap.c
View File

@ -92,26 +92,25 @@ void updatesmpreviewprev(void)
{
int x, y;
static struct ppm nsbuffer = {0,0,NULL};
struct rgbcolor black = {0,0,0};
struct rgbcolor gray = {120,120,120};
guchar black[3] = {0,0,0};
guchar gray[3] = {120,120,120};
if(!nsbuffer.col) {
newppm(&nsbuffer,OMWIDTH,OMHEIGHT);
}
fill(&nsbuffer, &black);
fill(&nsbuffer, black);
for(y = 6; y < OMHEIGHT-4; y += 10)
for(x = 6; x < OMWIDTH-4; x += 10) {
double siz = 5 * getsiz(x/(double)OMWIDTH,y/(double)OMHEIGHT,0);
drawline(&nsbuffer, x-siz, y-siz, x+siz, y-siz, &gray);
drawline(&nsbuffer, x+siz, y-siz, x+siz, y+siz, &gray);
drawline(&nsbuffer, x+siz, y+siz, x-siz, y+siz, &gray);
drawline(&nsbuffer, x-siz, y+siz, x-siz, y-siz, &gray);
drawline(&nsbuffer, x-siz, y-siz, x+siz, y-siz, gray);
drawline(&nsbuffer, x+siz, y-siz, x+siz, y+siz, gray);
drawline(&nsbuffer, x+siz, y+siz, x-siz, y+siz, gray);
drawline(&nsbuffer, x-siz, y+siz, x-siz, y-siz, gray);
}
for(y = 0; y < OMHEIGHT; y++)
gtk_preview_draw_row(GTK_PREVIEW(smpreviewprev), (guchar *)nsbuffer.col[y],
0, y, OMWIDTH);
gtk_preview_draw_row(GTK_PREVIEW(smpreviewprev), &nsbuffer.col[y*nsbuffer.width*3], 0, y, OMWIDTH);
gtk_widget_draw(smpreviewprev,NULL);
}
@ -125,9 +124,9 @@ void updatesmvectorprev(void)
int i, x, y;
double val;
static double lastval = 0.0;
struct rgbcolor gray = {120,120,120};
struct rgbcolor red = {255,0,0};
struct rgbcolor white = {255,255,255};
guchar gray[3] = {120,120,120};
guchar red[3] = {255,0,0};
guchar white[3] = {255,255,255};
if(smvectprevbrightadjust) val = 1.0 - GTK_ADJUSTMENT(smvectprevbrightadjust)->value / 100.0;
else val = 0.5;
@ -147,17 +146,17 @@ void updatesmvectorprev(void)
x = smvector[i].x * OMWIDTH;
y = smvector[i].y * OMHEIGHT;
if(i == selectedsmvector) {
drawline(&sbuffer, x-5, y, x+5, y, &red);
drawline(&sbuffer, x, y-5, x, y+5, &red);
drawline(&sbuffer, x-5, y, x+5, y, red);
drawline(&sbuffer, x, y-5, x, y+5, red);
} else {
drawline(&sbuffer, x-5, y, x+5, y, &gray);
drawline(&sbuffer, x, y-5, x, y+5, &gray);
drawline(&sbuffer, x-5, y, x+5, y, gray);
drawline(&sbuffer, x, y-5, x, y+5, gray);
}
putrgb(&sbuffer, x, y, &white);
putrgb(&sbuffer, x, y, white);
}
for(y = 0; y < OMHEIGHT; y++)
gtk_preview_draw_row(GTK_PREVIEW(smvectorprev), (guchar *)sbuffer.col[y], 0, y, OMWIDTH);
gtk_preview_draw_row(GTK_PREVIEW(smvectorprev), &sbuffer.col[y*sbuffer.width*3], 0, y, OMWIDTH);
gtk_widget_draw(smvectorprev,NULL);
}
@ -533,39 +532,6 @@ void create_sizemap_dialog(void)
(GtkSignalFunc)smstrexpsmadjmove, NULL);
gtk_tooltips_set_tip(GTK_TOOLTIPS(tooltips), tmpw, "Voronoi-mode makes only the smvector closest to the given point have any influence", NULL);
#ifdef DEBUG
tmpw = hbox = gtk_hbox_new(TRUE,0);
gtk_table_attach_defaults(GTK_TABLE(table1), tmpw, 1,2,3,4);
gtk_container_border_width (GTK_CONTAINER (tmpw), 2);
gtk_widget_show(tmpw);
tmpw = gtk_button_new_with_label("Save");
gtk_box_pack_start(GTK_BOX(hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show(tmpw);
gtk_signal_connect (GTK_OBJECT(tmpw), "clicked",
GTK_SIGNAL_FUNC(saveclick), NULL);
tmpw = gtk_button_new_with_label("Load");
gtk_box_pack_start(GTK_BOX(hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show(tmpw);
gtk_signal_connect (GTK_OBJECT(tmpw), "clicked",
GTK_SIGNAL_FUNC(loadclick), NULL);
tmpw = gtk_button_new_with_label("Show pix");
gtk_box_pack_start(GTK_BOX(hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show(tmpw);
gtk_signal_connect (GTK_OBJECT(tmpw), "clicked",
GTK_SIGNAL_FUNC(showpixclick), NULL);
tmpw = gtk_button_new_with_label("dumpvect");
gtk_box_pack_start(GTK_BOX(hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show(tmpw);
gtk_signal_connect (GTK_OBJECT(tmpw), "clicked",
GTK_SIGNAL_FUNC(dumpvect), NULL);
#endif
gtk_widget_show(smwindow);
updatesmvectorprev();