- start of external Imager API access:
[imager.git] / draw.c
CommitLineData
92bda632 1#include "imager.h"
02d1d628
AMH
2#include "draw.h"
3#include "log.h"
92bda632 4#include "imageri.h"
02d1d628 5
6af18d2b
AMH
6#include <limits.h>
7
02d1d628
AMH
8void
9i_mmarray_cr(i_mmarray *ar,int l) {
10 int i;
f0960b14 11 int alloc_size;
02d1d628
AMH
12
13 ar->lines=l;
f0960b14
TC
14 alloc_size = sizeof(minmax) * l;
15 /* check for overflow */
16 if (alloc_size / l != sizeof(minmax)) {
17 fprintf(stderr, "overflow calculating memory allocation");
18 exit(3);
19 }
20 ar->data=mymalloc(alloc_size); /* checked 5jul05 tonyc */
02d1d628
AMH
21 for(i=0;i<l;i++) { ar->data[i].max=-1; ar->data[i].min=MAXINT; }
22}
23
24void
25i_mmarray_dst(i_mmarray *ar) {
26 ar->lines=0;
27 if (ar->data != NULL) { myfree(ar->data); ar->data=NULL; }
28}
29
30void
31i_mmarray_add(i_mmarray *ar,int x,int y) {
32 if (y>-1 && y<ar->lines)
33 {
34 if (x<ar->data[y].min) ar->data[y].min=x;
35 if (x>ar->data[y].max) ar->data[y].max=x;
36 }
37}
38
39int
40i_mmarray_gmin(i_mmarray *ar,int y) {
41 if (y>-1 && y<ar->lines) return ar->data[y].min;
42 else return -1;
43}
44
45int
46i_mmarray_getm(i_mmarray *ar,int y) {
47 if (y>-1 && y<ar->lines) return ar->data[y].max;
48 else return MAXINT;
49}
50
51void
52i_mmarray_render(i_img *im,i_mmarray *ar,i_color *val) {
53 int i,x;
54 for(i=0;i<ar->lines;i++) if (ar->data[i].max!=-1) for(x=ar->data[i].min;x<ar->data[i].max;x++) i_ppix(im,x,i,val);
55}
56
f1ac5027
TC
57void
58i_mmarray_render_fill(i_img *im,i_mmarray *ar,i_fill_t *fill) {
59 int x, w, y;
60 if (im->bits == i_8_bits && fill->fill_with_color) {
f0960b14 61 i_color *line = mymalloc(sizeof(i_color) * im->xsize); /* checked 5jul05 tonyc */
efdc2568
TC
62 i_color *work = NULL;
63 if (fill->combine)
f0960b14 64 work = mymalloc(sizeof(i_color) * im->xsize); /* checked 5jul05 tonyc */
f1ac5027
TC
65 for(y=0;y<ar->lines;y++) {
66 if (ar->data[y].max!=-1) {
67 x = ar->data[y].min;
68 w = ar->data[y].max-ar->data[y].min;
69
43c5dacb 70 if (fill->combine) {
f1ac5027 71 i_glin(im, x, x+w, y, line);
43c5dacb
TC
72 (fill->fill_with_color)(fill, x, y, w, im->channels, work);
73 (fill->combine)(line, work, im->channels, w);
74 }
75 else {
76 (fill->fill_with_color)(fill, x, y, w, im->channels, line);
77 }
f1ac5027
TC
78 i_plin(im, x, x+w, y, line);
79 }
80 }
81
82 myfree(line);
efdc2568
TC
83 if (work)
84 myfree(work);
f1ac5027
TC
85 }
86 else {
f0960b14 87 i_fcolor *line = mymalloc(sizeof(i_fcolor) * im->xsize); /* checked 5jul05 tonyc */
efdc2568
TC
88 i_fcolor *work = NULL;
89 if (fill->combinef)
f0960b14 90 work = mymalloc(sizeof(i_fcolor) * im->xsize); /* checked 5jul05 tonyc */
f1ac5027
TC
91 for(y=0;y<ar->lines;y++) {
92 if (ar->data[y].max!=-1) {
93 x = ar->data[y].min;
94 w = ar->data[y].max-ar->data[y].min;
95
43c5dacb 96 if (fill->combinef) {
f1ac5027 97 i_glinf(im, x, x+w, y, line);
43c5dacb
TC
98 (fill->fill_with_fcolor)(fill, x, y, w, im->channels, work);
99 (fill->combinef)(line, work, im->channels, w);
100 }
101 else {
102 (fill->fill_with_fcolor)(fill, x, y, w, im->channels, line);
103 }
f1ac5027
TC
104 i_plinf(im, x, x+w, y, line);
105 }
106 }
107
108 myfree(line);
efdc2568
TC
109 if (work)
110 myfree(work);
f1ac5027
TC
111 }
112}
113
02d1d628
AMH
114
115static
116void
117i_arcdraw(int x1, int y1, int x2, int y2, i_mmarray *ar) {
118 double alpha;
119 double dsec;
120 int temp;
121 alpha=(double)(y2-y1)/(double)(x2-x1);
b254292b 122 if (fabs(alpha) <= 1)
02d1d628
AMH
123 {
124 if (x2<x1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
125 dsec=y1;
b254292b 126 while(x1<=x2)
02d1d628 127 {
02d1d628 128 i_mmarray_add(ar,x1,(int)(dsec+0.5));
b254292b 129 dsec+=alpha;
02d1d628
AMH
130 x1++;
131 }
132 }
133 else
134 {
135 alpha=1/alpha;
136 if (y2<y1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
137 dsec=x1;
b254292b 138 while(y1<=y2)
02d1d628 139 {
02d1d628 140 i_mmarray_add(ar,(int)(dsec+0.5),y1);
b254292b 141 dsec+=alpha;
02d1d628
AMH
142 y1++;
143 }
144 }
145}
146
147void
148i_mmarray_info(i_mmarray *ar) {
149 int i;
150 for(i=0;i<ar->lines;i++)
151 if (ar->data[i].max!=-1) printf("line %d: min=%d, max=%d.\n",i,ar->data[i].min,ar->data[i].max);
152}
153
a8652edf
TC
154static void
155i_arc_minmax(i_int_hlines *hlines,int x,int y,float rad,float d1,float d2) {
02d1d628
AMH
156 i_mmarray dot;
157 float f,fx,fy;
158 int x1,y1;
159
a8652edf 160 /*mm_log((1,"i_arc(im* 0x%x,x %d,y %d,rad %.2f,d1 %.2f,d2 %.2f,val 0x%x)\n",im,x,y,rad,d1,d2,val));*/
02d1d628 161
a8652edf 162 i_mmarray_cr(&dot, hlines->limit_y);
02d1d628
AMH
163
164 x1=(int)(x+0.5+rad*cos(d1*PI/180.0));
165 y1=(int)(y+0.5+rad*sin(d1*PI/180.0));
166 fx=(float)x1; fy=(float)y1;
167
168 /* printf("x1: %d.\ny1: %d.\n",x1,y1); */
169 i_arcdraw(x, y, x1, y1, &dot);
170
171 x1=(int)(x+0.5+rad*cos(d2*PI/180.0));
172 y1=(int)(y+0.5+rad*sin(d2*PI/180.0));
173
174 for(f=d1;f<=d2;f+=0.01) i_mmarray_add(&dot,(int)(x+0.5+rad*cos(f*PI/180.0)),(int)(y+0.5+rad*sin(f*PI/180.0)));
6af18d2b 175
02d1d628
AMH
176 /* printf("x1: %d.\ny1: %d.\n",x1,y1); */
177 i_arcdraw(x, y, x1, y1, &dot);
178
a8652edf
TC
179 /* render the minmax values onto the hlines */
180 for (y = 0; y < dot.lines; y++) {
181 if (dot.data[y].max!=-1) {
182 int minx, width;
183 minx = dot.data[y].min;
184 width = dot.data[y].max - dot.data[y].min + 1;
185 i_int_hlines_add(hlines, y, minx, width);
186 }
187 }
188
02d1d628 189 /* dot.info(); */
7f882a01 190 i_mmarray_dst(&dot);
02d1d628
AMH
191}
192
a8652edf
TC
193static void
194i_arc_hlines(i_int_hlines *hlines,int x,int y,float rad,float d1,float d2) {
195 if (d1 <= d2) {
196 i_arc_minmax(hlines, x, y, rad, d1, d2);
197 }
198 else {
199 i_arc_minmax(hlines, x, y, rad, d1, 360);
200 i_arc_minmax(hlines, x, y, rad, 0, d2);
201 }
202}
203
92bda632
TC
204/*
205=item i_arc(im, x, y, rad, d1, d2, color)
206
207=category Drawing
208=synopsis i_arc(im, 50, 50, 20, 45, 135, &color);
209
210Fills an arc centered at (x,y) with radius I<rad> covering the range
211of angles in degrees from d1 to d2, with the color.
212
213=cut
214*/
215
a8652edf
TC
216void
217i_arc(i_img *im,int x,int y,float rad,float d1,float d2,i_color *val) {
218 i_int_hlines hlines;
219
220 i_int_init_hlines_img(&hlines, im);
221
222 i_arc_hlines(&hlines, x, y, rad, d1, d2);
223
224 i_int_hlines_fill_color(im, &hlines, val);
225
226 i_int_hlines_destroy(&hlines);
227}
228
92bda632
TC
229/*
230=item i_arc_cfill(im, x, y, rad, d1, d2, fill)
231
232=category Drawing
233=synopsis i_arc_cfill(im, 50, 50, 35, 90, 135, fill);
234
235Fills an arc centered at (x,y) with radius I<rad> covering the range
236of angles in degrees from d1 to d2, with the fill object.
237
238=cut
239*/
240
a8652edf
TC
241#define MIN_CIRCLE_STEPS 8
242#define MAX_CIRCLE_STEPS 360
243
f1ac5027
TC
244void
245i_arc_cfill(i_img *im,int x,int y,float rad,float d1,float d2,i_fill_t *fill) {
a8652edf 246 i_int_hlines hlines;
f1ac5027 247
a8652edf 248 i_int_init_hlines_img(&hlines, im);
f1ac5027 249
a8652edf 250 i_arc_hlines(&hlines, x, y, rad, d1, d2);
f1ac5027 251
a8652edf 252 i_int_hlines_fill_fill(im, &hlines, fill);
f1ac5027 253
a8652edf
TC
254 i_int_hlines_destroy(&hlines);
255}
f1ac5027 256
a8652edf
TC
257static void
258arc_poly(int *count, double **xvals, double **yvals,
259 double x, double y, double rad, double d1, double d2) {
260 double d1_rad, d2_rad;
261 double circum;
262 int steps, point_count;
263 double angle_inc;
264
265 /* normalize the angles */
266 d1 = fmod(d1, 360);
267 if (d1 == 0) {
268 if (d2 >= 360) { /* default is 361 */
269 d2 = 360;
270 }
271 else {
272 d2 = fmod(d2, 360);
273 if (d2 < d1)
274 d2 += 360;
275 }
276 }
277 else {
278 d2 = fmod(d2, 360);
279 if (d2 < d1)
280 d2 += 360;
281 }
282 d1_rad = d1 * PI / 180;
283 d2_rad = d2 * PI / 180;
284
285 /* how many segments for the curved part?
286 we do a maximum of one per degree, with a minimum of 8/circle
287 we try to aim at having about one segment per 2 pixels
288 Work it out per circle to get a step size.
289
290 I was originally making steps = circum/2 but that looked horrible.
291
292 I think there might be an issue in the polygon filler.
293 */
294 circum = 2 * PI * rad;
295 steps = circum;
296 if (steps > MAX_CIRCLE_STEPS)
297 steps = MAX_CIRCLE_STEPS;
298 else if (steps < MIN_CIRCLE_STEPS)
299 steps = MIN_CIRCLE_STEPS;
300
301 angle_inc = 2 * PI / steps;
302
303 point_count = steps + 5; /* rough */
304 *xvals = mymalloc(point_count * sizeof(double));
305 *yvals = mymalloc(point_count * sizeof(double));
306
307 /* from centre to edge at d1 */
308 (*xvals)[0] = x;
309 (*yvals)[0] = y;
310 (*xvals)[1] = x + rad * cos(d1_rad);
311 (*yvals)[1] = y + rad * sin(d1_rad);
312 *count = 2;
313
314 /* step around the curve */
315 while (d1_rad < d2_rad) {
316 (*xvals)[*count] = x + rad * cos(d1_rad);
317 (*yvals)[*count] = y + rad * sin(d1_rad);
318 ++*count;
319 d1_rad += angle_inc;
320 }
f1ac5027 321
a8652edf
TC
322 /* finish off the curve */
323 (*xvals)[*count] = x + rad * cos(d2_rad);
324 (*yvals)[*count] = y + rad * sin(d2_rad);
325 ++*count;
326}
f1ac5027 327
92bda632
TC
328/*
329=item i_arc_aa(im, x, y, rad, d1, d2, color)
330
331=category Drawing
332=synopsis i_arc_aa(im, 50, 50, 35, 90, 135, &color);
333
334Antialias fills an arc centered at (x,y) with radius I<rad> covering
335the range of angles in degrees from d1 to d2, with the color.
336
337=cut
338*/
339
a8652edf
TC
340void
341i_arc_aa(i_img *im, double x, double y, double rad, double d1, double d2,
342 i_color *val) {
343 double *xvals, *yvals;
344 int count;
345
346 arc_poly(&count, &xvals, &yvals, x, y, rad, d1, d2);
347
348 i_poly_aa(im, count, xvals, yvals, val);
349
350 myfree(xvals);
351 myfree(yvals);
f1ac5027
TC
352}
353
92bda632
TC
354/*
355=item i_arc_aa_cfill(im, x, y, rad, d1, d2, fill)
356
357=category Drawing
358=synopsis i_arc_aa_cfill(im, 50, 50, 35, 90, 135, fill);
359
360Antialias fills an arc centered at (x,y) with radius I<rad> covering
361the range of angles in degrees from d1 to d2, with the fill object.
362
363=cut
364*/
365
a8652edf
TC
366void
367i_arc_aa_cfill(i_img *im, double x, double y, double rad, double d1, double d2,
368 i_fill_t *fill) {
369 double *xvals, *yvals;
370 int count;
371
372 arc_poly(&count, &xvals, &yvals, x, y, rad, d1, d2);
373
374 i_poly_aa_cfill(im, count, xvals, yvals, fill);
6af18d2b 375
a8652edf
TC
376 myfree(xvals);
377 myfree(yvals);
378}
6af18d2b
AMH
379
380/* Temporary AA HACK */
381
382
383typedef int frac;
384static frac float_to_frac(float x) { return (frac)(0.5+x*16.0); }
385static int frac_sub (frac x) { return (x%16); }
386static int frac_int (frac x) { return (x/16); }
387static float frac_to_float(float x) { return (float)x/16.0; }
388
389static
390void
391polar_to_plane(float cx, float cy, float angle, float radius, frac *x, frac *y) {
392 *x = float_to_frac(cx+radius*cos(angle));
393 *y = float_to_frac(cy+radius*sin(angle));
394}
395
396static
397void
398order_pair(frac *x, frac *y) {
399 frac t = *x;
400 if (t>*y) {
401 *x = *y;
402 *y = t;
403 }
404}
405
406
407
408
409static
410void
411make_minmax_list(i_mmarray *dot, float x, float y, float radius) {
412 float angle = 0.0;
413 float astep = radius>0.1 ? .5/radius : 10;
414 frac cx, cy, lx, ly, sx, sy;
415
416 mm_log((1, "make_minmax_list(dot %p, x %.2f, y %.2f, radius %.2f)\n", dot, x, y, radius));
417
418 polar_to_plane(x, y, angle, radius, &sx, &sy);
419
420 for(angle = 0.0; angle<361; angle +=astep) {
6af18d2b
AMH
421 lx = sx; ly = sy;
422 polar_to_plane(x, y, angle, radius, &cx, &cy);
423 sx = cx; sy = cy;
424
425 if (fabs(cx-lx) > fabs(cy-ly)) {
426 int ccx, ccy;
427 if (lx>cx) {
428 ccx = lx; lx = cx; cx = ccx;
429 ccy = ly; ly = cy; cy = ccy;
430 }
431
432 for(ccx=lx; ccx<=cx; ccx++) {
433 ccy = ly + ((cy-ly)*(ccx-lx))/(cx-lx);
434 i_mmarray_add(dot, ccx, ccy);
435 }
436 } else {
437 int ccx, ccy;
438
439 if (ly>cy) {
440 ccy = ly; ly = cy; cy = ccy;
441 ccx = lx; lx = cx; cx = ccx;
442 }
443
444 for(ccy=ly; ccy<=cy; ccy++) {
445 if (cy-ly) ccx = lx + ((cx-lx)*(ccy-ly))/(cy-ly); else ccx = lx;
446 i_mmarray_add(dot, ccx, ccy);
447 }
448 }
449 }
450}
451
452/* Get the number of subpixels covered */
453
454static
455int
456i_pixel_coverage(i_mmarray *dot, int x, int y) {
457 frac minx = x*16;
458 frac maxx = minx+15;
459 frac cy;
460 int cnt = 0;
461
462 for(cy=y*16; cy<(y+1)*16; cy++) {
463 frac tmin = dot->data[cy].min;
464 frac tmax = dot->data[cy].max;
465
466 if (tmax == -1 || tmin > maxx || tmax < minx) continue;
467
468 if (tmin < minx) tmin = minx;
469 if (tmax > maxx) tmax = maxx;
470
471 cnt+=1+tmax-tmin;
472 }
473 return cnt;
474}
475
92bda632
TC
476/*
477=item i_circle_aa(im, x, y, rad, color)
478
479=category Drawing
480=synopsis i_circle_aa(im, 50, 50, 45, &color);
481
482Antialias fills a circle centered at (x,y) for radius I<rad> with
483color.
484
485=cut
486*/
6af18d2b
AMH
487void
488i_circle_aa(i_img *im, float x, float y, float rad, i_color *val) {
489 i_mmarray dot;
490 i_color temp;
491 int ly;
492
493 mm_log((1, "i_circle_aa(im %p, x %d, y %d, rad %.2f, val %p)\n", im, x, y, rad, val));
494
495 i_mmarray_cr(&dot,16*im->ysize);
496 make_minmax_list(&dot, x, y, rad);
497
498 for(ly = 0; ly<im->ysize; ly++) {
a659442a 499 int ix, cy, minx = INT_MAX, maxx = INT_MIN;
6af18d2b
AMH
500
501 /* Find the left/rightmost set subpixels */
502 for(cy = 0; cy<16; cy++) {
503 frac tmin = dot.data[ly*16+cy].min;
504 frac tmax = dot.data[ly*16+cy].max;
505 if (tmax == -1) continue;
506
507 if (minx > tmin) minx = tmin;
508 if (maxx < tmax) maxx = tmax;
509 }
510
511 if (maxx == INT_MIN) continue; /* no work to be done for this row of pixels */
512
513 minx /= 16;
514 maxx /= 16;
515 for(ix=minx; ix<=maxx; ix++) {
516 int cnt = i_pixel_coverage(&dot, ix, ly);
517 if (cnt>255) cnt = 255;
518 if (cnt) { /* should never be true */
519 int ch;
520 float ratio = (float)cnt/255.0;
521 i_gpix(im, ix, ly, &temp);
522 for(ch=0;ch<im->channels; ch++) temp.channel[ch] = (unsigned char)((float)val->channel[ch]*ratio + (float)temp.channel[ch]*(1.0-ratio));
523 i_ppix(im, ix, ly, &temp);
524 }
525 }
526 }
4b19f77a 527 i_mmarray_dst(&dot);
6af18d2b
AMH
528}
529
92bda632
TC
530/*
531=item i_box(im, x1, y1, x2, y2, color)
6af18d2b 532
92bda632
TC
533=category Drawing
534=synopsis i_box(im, 0, 0, im->xsize-1, im->ysize-1, &color).
6af18d2b 535
92bda632 536Outlines the box from (x1,y1) to (x2,y2) inclusive with I<color>.
6af18d2b 537
92bda632
TC
538=cut
539*/
6af18d2b 540
02d1d628
AMH
541void
542i_box(i_img *im,int x1,int y1,int x2,int y2,i_color *val) {
543 int x,y;
544 mm_log((1,"i_box(im* 0x%x,x1 %d,y1 %d,x2 %d,y2 %d,val 0x%x)\n",im,x1,y1,x2,y2,val));
545 for(x=x1;x<x2+1;x++) {
546 i_ppix(im,x,y1,val);
547 i_ppix(im,x,y2,val);
548 }
549 for(y=y1;y<y2+1;y++) {
550 i_ppix(im,x1,y,val);
551 i_ppix(im,x2,y,val);
552 }
553}
554
92bda632
TC
555/*
556=item i_box_filled(im, x1, y1, x2, y2, color)
557
558=category Drawing
559=synopsis i_box_filled(im, 0, 0, im->xsize-1, im->ysize-1, &color);
560
561Fills the box from (x1,y1) to (x2,y2) inclusive with color.
562
563=cut
564*/
565
02d1d628
AMH
566void
567i_box_filled(i_img *im,int x1,int y1,int x2,int y2,i_color *val) {
568 int x,y;
569 mm_log((1,"i_box_filled(im* 0x%x,x1 %d,y1 %d,x2 %d,y2 %d,val 0x%x)\n",im,x1,y1,x2,y2,val));
570 for(x=x1;x<x2+1;x++) for (y=y1;y<y2+1;y++) i_ppix(im,x,y,val);
571}
572
92bda632
TC
573/*
574=item i_box_cfill(im, x1, y1, x2, y2, fill)
575
576=category Drawing
577=synopsis i_box_cfill(im, 0, 0, im->xsize-1, im->ysize-1, fill);
578
579Fills the box from (x1,y1) to (x2,y2) inclusive with fill.
580
581=cut
582*/
583
f1ac5027
TC
584void
585i_box_cfill(i_img *im,int x1,int y1,int x2,int y2,i_fill_t *fill) {
586 mm_log((1,"i_box_cfill(im* 0x%x,x1 %d,y1 %d,x2 %d,y2 %d,fill 0x%x)\n",im,x1,y1,x2,y2,fill));
587
588 ++x2;
f0960b14
TC
589 if (x1 < 0)
590 x1 = 0;
591 if (y1 < 0)
592 y1 = 0;
593 if (x2 > im->xsize)
594 x2 = im->xsize;
595 if (y2 >= im->ysize)
596 y2 = im->ysize-1;
597 if (x1 >= x2 || y1 > y2)
598 return;
f1ac5027 599 if (im->bits == i_8_bits && fill->fill_with_color) {
f0960b14 600 i_color *line = mymalloc(sizeof(i_color) * (x2 - x1)); /* checked 5jul05 tonyc */
efdc2568
TC
601 i_color *work = NULL;
602 if (fill->combine)
f0960b14 603 work = mymalloc(sizeof(i_color) * (x2-x1)); /* checked 5jul05 tonyc */
f1ac5027 604 while (y1 <= y2) {
43c5dacb 605 if (fill->combine) {
f1ac5027 606 i_glin(im, x1, x2, y1, line);
43c5dacb
TC
607 (fill->fill_with_color)(fill, x1, y1, x2-x1, im->channels, work);
608 (fill->combine)(line, work, im->channels, x2-x1);
609 }
610 else {
611 (fill->fill_with_color)(fill, x1, y1, x2-x1, im->channels, line);
612 }
f1ac5027
TC
613 i_plin(im, x1, x2, y1, line);
614 ++y1;
615 }
616 myfree(line);
efdc2568
TC
617 if (work)
618 myfree(work);
f1ac5027
TC
619 }
620 else {
f0960b14 621 i_fcolor *line = mymalloc(sizeof(i_fcolor) * (x2 - x1)); /* checked 5jul05 tonyc */
efdc2568 622 i_fcolor *work;
f0960b14 623 work = mymalloc(sizeof(i_fcolor) * (x2 - x1)); /* checked 5jul05 tonyc */
efdc2568 624
f1ac5027 625 while (y1 <= y2) {
43c5dacb 626 if (fill->combine) {
f1ac5027 627 i_glinf(im, x1, x2, y1, line);
43c5dacb
TC
628 (fill->fill_with_fcolor)(fill, x1, y1, x2-x1, im->channels, work);
629 (fill->combinef)(line, work, im->channels, x2-x1);
630 }
631 else {
632 (fill->fill_with_fcolor)(fill, x1, y1, x2-x1, im->channels, line);
633 }
f1ac5027 634 i_plinf(im, x1, x2, y1, line);
2de568dc 635 ++y1;
f1ac5027
TC
636 }
637 myfree(line);
efdc2568
TC
638 if (work)
639 myfree(work);
f1ac5027
TC
640 }
641}
02d1d628 642
aa833c97
AMH
643
644/*
645=item i_line(im, x1, y1, x2, y2, val, endp)
646
92bda632
TC
647=category Drawing
648
aa833c97
AMH
649Draw a line to image using bresenhams linedrawing algorithm
650
651 im - image to draw to
652 x1 - starting x coordinate
653 y1 - starting x coordinate
654 x2 - starting x coordinate
655 y2 - starting x coordinate
656 val - color to write to image
657 endp - endpoint flag (boolean)
658
659=cut
660*/
661
02d1d628 662void
aa833c97
AMH
663i_line(i_img *im, int x1, int y1, int x2, int y2, i_color *val, int endp) {
664 int x, y;
665 int dx, dy;
666 int p;
02d1d628 667
aa833c97
AMH
668 dx = x2 - x1;
669 dy = y2 - y1;
02d1d628 670
aa833c97
AMH
671
672 /* choose variable to iterate on */
673 if (abs(dx)>abs(dy)) {
674 int dx2, dy2, cpy;
675
676 /* sort by x */
677 if (x1 > x2) {
678 int t;
679 t = x1; x1 = x2; x2 = t;
680 t = y1; y1 = y2; y2 = t;
02d1d628 681 }
aa833c97
AMH
682
683 dx = abs(dx);
684 dx2 = dx*2;
685 dy = y2 - y1;
686
687 if (dy<0) {
688 dy = -dy;
689 cpy = -1;
690 } else {
691 cpy = 1;
692 }
693 dy2 = dy*2;
694 p = dy2 - dx;
695
696
697 y = y1;
698 for(x=x1; x<x2-1; x++) {
699 if (p<0) {
700 p += dy2;
701 } else {
702 y += cpy;
703 p += dy2-dx2;
704 }
705 i_ppix(im, x+1, y, val);
02d1d628 706 }
aa833c97
AMH
707 } else {
708 int dy2, dx2, cpx;
709
710 /* sort bx y */
711 if (y1 > y2) {
712 int t;
713 t = x1; x1 = x2; x2 = t;
714 t = y1; y1 = y2; y2 = t;
715 }
716
717 dy = abs(dy);
718 dx = x2 - x1;
719 dy2 = dy*2;
720
721 if (dx<0) {
722 dx = -dx;
723 cpx = -1;
724 } else {
725 cpx = 1;
726 }
727 dx2 = dx*2;
728 p = dx2 - dy;
729
730 x = x1;
731
732 for(y=y1; y<y2-1; y++) {
733 if (p<0) {
734 p += dx2;
735 } else {
736 x += cpx;
737 p += dx2-dy2;
738 }
739 i_ppix(im, x, y+1, val);
740 }
741 }
742 if (endp) {
743 i_ppix(im, x1, y1, val);
744 i_ppix(im, x2, y2, val);
745 } else {
746 if (x1 != x2 || y1 != y2)
747 i_ppix(im, x1, y1, val);
748 }
02d1d628
AMH
749}
750
aa833c97 751
02d1d628 752void
b437ce0a
AMH
753i_line_dda(i_img *im, int x1, int y1, int x2, int y2, i_color *val) {
754
755 float dy;
756 int x;
757
758 for(x=x1; x<=x2; x++) {
759 dy = y1+ (x-x1)/(float)(x2-x1)*(y2-y1);
135fb460 760 i_ppix(im, x, (int)(dy+0.5), val);
b437ce0a
AMH
761 }
762}
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790void
791i_line_aa3(i_img *im,int x1,int y1,int x2,int y2,i_color *val) {
02d1d628
AMH
792 i_color tval;
793 float alpha;
794 float dsec,dfrac;
795 int temp,dx,dy,isec,ch;
796
b437ce0a 797 mm_log((1,"i_line_aa(im* 0x%x,x1 %d,y1 %d,x2 %d,y2 %d,val 0x%x)\n",im,x1,y1,x2,y2,val));
02d1d628
AMH
798
799 dy=y2-y1;
800 dx=x2-x1;
801
802 if (abs(dx)>abs(dy)) { /* alpha < 1 */
803 if (x2<x1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
804 alpha=(float)(y2-y1)/(float)(x2-x1);
805
806 dsec=y1;
807 while(x1<=x2) {
808 isec=(int)dsec;
809 dfrac=dsec-isec;
810 /* dfrac=1-(1-dfrac)*(1-dfrac); */
811 /* This is something we can play with to try to get better looking lines */
812
813 i_gpix(im,x1,isec,&tval);
814 for(ch=0;ch<im->channels;ch++) tval.channel[ch]=(unsigned char)(dfrac*(float)tval.channel[ch]+(1-dfrac)*(float)val->channel[ch]);
815 i_ppix(im,x1,isec,&tval);
816
817 i_gpix(im,x1,isec+1,&tval);
818 for(ch=0;ch<im->channels;ch++) tval.channel[ch]=(unsigned char)((1-dfrac)*(float)tval.channel[ch]+dfrac*(float)val->channel[ch]);
819 i_ppix(im,x1,isec+1,&tval);
820
821 dsec+=alpha;
822 x1++;
823 }
824 } else {
825 if (y2<y1) { temp=y1; y1=y2; y2=temp; temp=x1; x1=x2; x2=temp; }
826 alpha=(float)(x2-x1)/(float)(y2-y1);
827 dsec=x1;
828 while(y1<=y2) {
829 isec=(int)dsec;
830 dfrac=dsec-isec;
831 /* dfrac=sqrt(dfrac); */
832 /* This is something we can play with */
833 i_gpix(im,isec,y1,&tval);
834 for(ch=0;ch<im->channels;ch++) tval.channel[ch]=(unsigned char)(dfrac*(float)tval.channel[ch]+(1-dfrac)*(float)val->channel[ch]);
835 i_ppix(im,isec,y1,&tval);
836
837 i_gpix(im,isec+1,y1,&tval);
838 for(ch=0;ch<im->channels;ch++) tval.channel[ch]=(unsigned char)((1-dfrac)*(float)tval.channel[ch]+dfrac*(float)val->channel[ch]);
839 i_ppix(im,isec+1,y1,&tval);
840
841 dsec+=alpha;
842 y1++;
843 }
844 }
845}
846
b437ce0a 847
92bda632
TC
848/*
849=item i_line_aa(im, x1, x2, y1, y2, color, endp)
850
851=category Drawing
852
853Antialias draws a line from (x1,y1) to (x2, y2) in color.
b437ce0a 854
92bda632
TC
855The point (x2, y2) is drawn only if endp is set.
856
857=cut
858*/
b437ce0a
AMH
859
860void
861i_line_aa(i_img *im, int x1, int y1, int x2, int y2, i_color *val, int endp) {
862 int x, y;
863 int dx, dy;
864 int p;
b437ce0a
AMH
865
866 dx = x2 - x1;
867 dy = y2 - y1;
868
869 /* choose variable to iterate on */
870 if (abs(dx)>abs(dy)) {
871 int dx2, dy2, cpy;
872
873 /* sort by x */
874 if (x1 > x2) {
875 int t;
876 t = x1; x1 = x2; x2 = t;
877 t = y1; y1 = y2; y2 = t;
878 }
879
880 dx = abs(dx);
881 dx2 = dx*2;
882 dy = y2 - y1;
883
884 if (dy<0) {
885 dy = -dy;
886 cpy = -1;
887 } else {
888 cpy = 1;
889 }
890 dy2 = dy*2;
891 p = dy2 - dx2; /* this has to be like this for AA */
892
893 y = y1;
894
895 for(x=x1; x<x2-1; x++) {
896 int ch;
897 i_color tval;
898 float t = (dy) ? -(float)(p)/(float)(dx2) : 1;
899 float t1, t2;
900
901 if (t<0) t = 0;
902 t1 = 1-t;
903 t2 = t;
904
905 i_gpix(im,x+1,y,&tval);
906 for(ch=0;ch<im->channels;ch++)
907 tval.channel[ch]=(unsigned char)(t1*(float)tval.channel[ch]+t2*(float)val->channel[ch]);
908 i_ppix(im,x+1,y,&tval);
909
910 i_gpix(im,x+1,y+cpy,&tval);
911 for(ch=0;ch<im->channels;ch++)
912 tval.channel[ch]=(unsigned char)(t2*(float)tval.channel[ch]+t1*(float)val->channel[ch]);
913 i_ppix(im,x+1,y+cpy,&tval);
914
915 if (p<0) {
916 p += dy2;
917 } else {
918 y += cpy;
919 p += dy2-dx2;
920 }
921 }
922 } else {
923 int dy2, dx2, cpx;
924
925 /* sort bx y */
926 if (y1 > y2) {
927 int t;
928 t = x1; x1 = x2; x2 = t;
929 t = y1; y1 = y2; y2 = t;
930 }
931
932 dy = abs(dy);
933 dx = x2 - x1;
934 dy2 = dy*2;
935
936 if (dx<0) {
937 dx = -dx;
938 cpx = -1;
939 } else {
940 cpx = 1;
941 }
942 dx2 = dx*2;
943 p = dx2 - dy2; /* this has to be like this for AA */
944
945 x = x1;
946
947 for(y=y1; y<y2-1; y++) {
948 int ch;
949 i_color tval;
950 float t = (dx) ? -(float)(p)/(float)(dy2) : 1;
951 float t1, t2;
952
953 if (t<0) t = 0;
954 t1 = 1-t;
955 t2 = t;
956
957 i_gpix(im,x,y+1,&tval);
958 for(ch=0;ch<im->channels;ch++)
959 tval.channel[ch]=(unsigned char)(t1*(float)tval.channel[ch]+t2*(float)val->channel[ch]);
960 i_ppix(im,x,y+1,&tval);
961
962 i_gpix(im,x+cpx,y+1,&tval);
963 for(ch=0;ch<im->channels;ch++)
964 tval.channel[ch]=(unsigned char)(t2*(float)tval.channel[ch]+t1*(float)val->channel[ch]);
965 i_ppix(im,x+cpx,y+1,&tval);
966
967 if (p<0) {
968 p += dx2;
969 } else {
970 x += cpx;
971 p += dx2-dy2;
972 }
973 }
974 }
975
976
977 if (endp) {
978 i_ppix(im, x1, y1, val);
979 i_ppix(im, x2, y2, val);
980 } else {
981 if (x1 != x2 || y1 != y2)
982 i_ppix(im, x1, y1, val);
983 }
984}
985
986
987
b33c08f8 988static double
02d1d628
AMH
989perm(int n,int k) {
990 double r;
991 int i;
992 r=1;
993 for(i=k+1;i<=n;i++) r*=i;
994 for(i=1;i<=(n-k);i++) r/=i;
995 return r;
996}
997
998
999/* Note in calculating t^k*(1-t)^(n-k)
1000 we can start by using t^0=1 so this simplifies to
1001 t^0*(1-t)^n - we want to multiply that with t/(1-t) each iteration
1002 to get a new level - this may lead to errors who knows lets test it */
1003
1004void
1005i_bezier_multi(i_img *im,int l,double *x,double *y,i_color *val) {
1006 double *bzcoef;
1007 double t,cx,cy;
1008 int k,i;
1009 int lx = 0,ly = 0;
1010 int n=l-1;
1011 double itr,ccoef;
1012
f0960b14
TC
1013 /* this is the same size as the x and y arrays, so shouldn't overflow */
1014 bzcoef=mymalloc(sizeof(double)*l); /* checked 5jul05 tonyc */
02d1d628
AMH
1015 for(k=0;k<l;k++) bzcoef[k]=perm(n,k);
1016 ICL_info(val);
1017
1018
1019 /* for(k=0;k<l;k++) printf("bzcoef: %d -> %f\n",k,bzcoef[k]); */
1020 i=0;
1021 for(t=0;t<=1;t+=0.005) {
1022 cx=cy=0;
1023 itr=t/(1-t);
1024 ccoef=pow(1-t,n);
1025 for(k=0;k<l;k++) {
1026 /* cx+=bzcoef[k]*x[k]*pow(t,k)*pow(1-t,n-k);
1027 cy+=bzcoef[k]*y[k]*pow(t,k)*pow(1-t,n-k);*/
1028
1029 cx+=bzcoef[k]*x[k]*ccoef;
1030 cy+=bzcoef[k]*y[k]*ccoef;
1031 ccoef*=itr;
1032 }
1033 /* printf("%f -> (%d,%d)\n",t,(int)(0.5+cx),(int)(0.5+cy)); */
1034 if (i++) {
b437ce0a 1035 i_line_aa(im,lx,ly,(int)(0.5+cx),(int)(0.5+cy),val, 1);
02d1d628
AMH
1036 }
1037 /* i_ppix(im,(int)(0.5+cx),(int)(0.5+cy),val); */
1038 lx=(int)(0.5+cx);
1039 ly=(int)(0.5+cy);
1040 }
1041 ICL_info(val);
1042 myfree(bzcoef);
1043}
1044
02d1d628
AMH
1045/* Flood fill
1046
1047 REF: Graphics Gems I. page 282+
1048
1049*/
1050
02d1d628
AMH
1051/* This should be moved into a seperate file? */
1052
1053/* This is the truncation used:
1054
1055 a double is multiplied by 16 and then truncated.
1056 This means that 0 -> 0
1057 So a triangle of (0,0) (10,10) (10,0) Will look like it's
1058 not filling the (10,10) point nor the (10,0)-(10,10) line segment
1059
1060*/
1061
1062
02d1d628
AMH
1063/* Flood fill algorithm - based on the Ken Fishkins (pixar) gem in
1064 graphics gems I */
1065
1066/*
1067struct stc {
1068 int mylx,myrx;
1069 int dadlx,dadrx;
1070 int myy;
1071 int mydirection;
1072};
1073
1074Not used code???
1075*/
1076
1077
1078struct stack_element {
1079 int myLx,myRx;
1080 int dadLx,dadRx;
1081 int myY;
1082 int myDirection;
1083};
1084
1085
1086/* create the link data to put push onto the stack */
1087
1088static
1089struct stack_element*
1090crdata(int left,int right,int dadl,int dadr,int y, int dir) {
1091 struct stack_element *ste;
f0960b14 1092 ste = mymalloc(sizeof(struct stack_element)); /* checked 5jul05 tonyc */
a73aeb5f
AMH
1093 ste->myLx = left;
1094 ste->myRx = right;
1095 ste->dadLx = dadl;
1096 ste->dadRx = dadr;
1097 ste->myY = y;
1098 ste->myDirection = dir;
02d1d628
AMH
1099 return ste;
1100}
1101
1102/* i_ccomp compares two colors and gives true if they are the same */
1103
1104static int
1105i_ccomp(i_color *val1,i_color *val2,int ch) {
1106 int i;
1107 for(i=0;i<ch;i++) if (val1->channel[i] !=val2->channel[i]) return 0;
1108 return 1;
1109}
1110
1111
1112static int
e25e59b1 1113i_lspan(i_img *im, int seedx, int seedy, i_color *val) {
02d1d628
AMH
1114 i_color cval;
1115 while(1) {
1116 if (seedx-1 < 0) break;
1117 i_gpix(im,seedx-1,seedy,&cval);
1118 if (!i_ccomp(val,&cval,im->channels)) break;
1119 seedx--;
1120 }
1121 return seedx;
1122}
1123
1124static int
e25e59b1 1125i_rspan(i_img *im, int seedx, int seedy, i_color *val) {
02d1d628
AMH
1126 i_color cval;
1127 while(1) {
1128 if (seedx+1 > im->xsize-1) break;
1129 i_gpix(im,seedx+1,seedy,&cval);
1130 if (!i_ccomp(val,&cval,im->channels)) break;
1131 seedx++;
1132 }
1133 return seedx;
1134}
1135
1136/* Macro to create a link and push on to the list */
1137
e25e59b1
AMH
1138#define ST_PUSH(left,right,dadl,dadr,y,dir) do { \
1139 struct stack_element *s = crdata(left,right,dadl,dadr,y,dir); \
1140 llist_push(st,&s); \
1141} while (0)
02d1d628
AMH
1142
1143/* pops the shadow on TOS into local variables lx,rx,y,direction,dadLx and dadRx */
1144/* No overflow check! */
1145
e25e59b1
AMH
1146#define ST_POP() do { \
1147 struct stack_element *s; \
1148 llist_pop(st,&s); \
1149 lx = s->myLx; \
1150 rx = s->myRx; \
1151 dadLx = s->dadLx; \
1152 dadRx = s->dadRx; \
1153 y = s->myY; \
1154 direction = s->myDirection; \
1155 myfree(s); \
1156} while (0)
1157
1158#define ST_STACK(dir,dadLx,dadRx,lx,rx,y) do { \
1159 int pushrx = rx+1; \
1160 int pushlx = lx-1; \
1161 ST_PUSH(lx,rx,pushlx,pushrx,y+dir,dir); \
1162 if (rx > dadRx) \
1163 ST_PUSH(dadRx+1,rx,pushlx,pushrx,y-dir,-dir); \
1164 if (lx < dadLx) ST_PUSH(lx,dadLx-1,pushlx,pushrx,y-dir,-dir); \
1165} while (0)
1166
1167#define SET(x,y) btm_set(btm,x,y)
02d1d628 1168
86d20cb9 1169/* INSIDE returns true if pixel is correct color and we haven't set it before. */
02d1d628
AMH
1170#define INSIDE(x,y) ((!btm_test(btm,x,y) && ( i_gpix(im,x,y,&cval),i_ccomp(&val,&cval,channels) ) ))
1171
02d1d628 1172
02d1d628 1173
aa833c97
AMH
1174/* The function that does all the real work */
1175
1176static struct i_bitmap *
1177i_flood_fill_low(i_img *im,int seedx,int seedy,
1178 int *bxminp, int *bxmaxp, int *byminp, int *bymaxp) {
02d1d628 1179
aa833c97
AMH
1180 /*
1181 int lx,rx;
1182 int y;
1183 int direction;
1184 int dadLx,dadRx;
1185 int wasIn=0;
1186 */
1187 int ltx, rtx;
1188 int tx = 0;
02d1d628 1189
e25e59b1
AMH
1190 int bxmin = seedx;
1191 int bxmax = seedx;
1192 int bymin = seedy;
1193 int bymax = seedy;
02d1d628
AMH
1194
1195 struct llist *st;
1196 struct i_bitmap *btm;
1197
1198 int channels,xsize,ysize;
aa833c97 1199 i_color cval,val;
02d1d628 1200
a73aeb5f
AMH
1201 channels = im->channels;
1202 xsize = im->xsize;
1203 ysize = im->ysize;
02d1d628 1204
86d20cb9
AMH
1205 btm = btm_new(xsize, ysize);
1206 st = llist_new(100, sizeof(struct stack_element*));
02d1d628
AMH
1207
1208 /* Get the reference color */
86d20cb9 1209 i_gpix(im, seedx, seedy, &val);
02d1d628
AMH
1210
1211 /* Find the starting span and fill it */
aa833c97
AMH
1212 ltx = i_lspan(im, seedx, seedy, &val);
1213 rtx = i_rspan(im, seedx, seedy, &val);
1214 for(tx=ltx; tx<=rtx; tx++) SET(tx, seedy);
02d1d628 1215
aa833c97
AMH
1216 ST_PUSH(ltx, rtx, ltx, rtx, seedy+1, 1);
1217 ST_PUSH(ltx, rtx, ltx, rtx, seedy-1, -1);
02d1d628
AMH
1218
1219 while(st->count) {
aa833c97
AMH
1220 /* Stack variables */
1221 int lx,rx;
1222 int dadLx,dadRx;
1223 int y;
1224 int direction;
e25e59b1 1225
aa833c97
AMH
1226 int x;
1227 int wasIn=0;
02d1d628 1228
aa833c97
AMH
1229 ST_POP(); /* sets lx, rx, dadLx, dadRx, y, direction */
1230
1231
1232 if (y<0 || y>ysize-1) continue;
02d1d628
AMH
1233 if (bymin > y) bymin=y; /* in the worst case an extra line */
1234 if (bymax < y) bymax=y;
1235
e25e59b1
AMH
1236
1237 x = lx+1;
aa833c97
AMH
1238 if ( lx >= 0 && (wasIn = INSIDE(lx, y)) ) {
1239 SET(lx, y);
02d1d628 1240 lx--;
aa833c97 1241 while(INSIDE(lx, y) && lx > 0) {
02d1d628
AMH
1242 SET(lx,y);
1243 lx--;
1244 }
1245 }
1246
86d20cb9 1247 if (bxmin > lx) bxmin = lx;
02d1d628
AMH
1248 while(x <= xsize-1) {
1249 /* printf("x=%d\n",x); */
1250 if (wasIn) {
1251
aa833c97 1252 if (INSIDE(x, y)) {
02d1d628
AMH
1253 /* case 1: was inside, am still inside */
1254 SET(x,y);
1255 } else {
1256 /* case 2: was inside, am no longer inside: just found the
1257 right edge of a span */
aa833c97 1258 ST_STACK(direction, dadLx, dadRx, lx, (x-1), y);
02d1d628 1259
aa833c97 1260 if (bxmax < x) bxmax = x;
02d1d628
AMH
1261 wasIn=0;
1262 }
1263 } else {
aa833c97
AMH
1264 if (x > rx) goto EXT;
1265 if (INSIDE(x, y)) {
1266 SET(x, y);
02d1d628 1267 /* case 3: Wasn't inside, am now: just found the start of a new run */
aa833c97
AMH
1268 wasIn = 1;
1269 lx = x;
02d1d628
AMH
1270 } else {
1271 /* case 4: Wasn't inside, still isn't */
1272 }
1273 }
1274 x++;
1275 }
1276 EXT: /* out of loop */
1277 if (wasIn) {
1278 /* hit an edge of the frame buffer while inside a run */
aa833c97
AMH
1279 ST_STACK(direction, dadLx, dadRx, lx, (x-1), y);
1280 if (bxmax < x) bxmax = x;
02d1d628
AMH
1281 }
1282 }
02d1d628 1283
02d1d628 1284 llist_destroy(st);
cc6483e0 1285
aa833c97
AMH
1286 *bxminp = bxmin;
1287 *bxmaxp = bxmax;
1288 *byminp = bymin;
1289 *bymaxp = bymax;
cc6483e0 1290
aa833c97
AMH
1291 return btm;
1292}
cc6483e0 1293
92bda632
TC
1294/*
1295=item i_flood_fill(im, seedx, seedy, color)
1296
1297=category Drawing
1298=synopsis i_flood_fill(im, 50, 50, &color);
cc6483e0 1299
92bda632
TC
1300Flood fills the 4-connected region starting from the point (seedx,
1301seedy) with I<color>.
cc6483e0 1302
92bda632
TC
1303Returns false if (seedx, seedy) are outside the image.
1304
1305=cut
1306*/
cc6483e0 1307
aa833c97
AMH
1308undef_int
1309i_flood_fill(i_img *im, int seedx, int seedy, i_color *dcol) {
1310 int bxmin, bxmax, bymin, bymax;
1311 struct i_bitmap *btm;
1312 int x, y;
cc6483e0 1313
aa833c97
AMH
1314 i_clear_error();
1315 if (seedx < 0 || seedx >= im->xsize ||
1316 seedy < 0 || seedy >= im->ysize) {
1317 i_push_error(0, "i_flood_cfill: Seed pixel outside of image");
1318 return 0;
cc6483e0 1319 }
cc6483e0 1320
aa833c97 1321 btm = i_flood_fill_low(im, seedx, seedy, &bxmin, &bxmax, &bymin, &bymax);
cc6483e0 1322
aa833c97
AMH
1323 for(y=bymin;y<=bymax;y++)
1324 for(x=bxmin;x<=bxmax;x++)
1325 if (btm_test(btm,x,y))
1326 i_ppix(im,x,y,dcol);
1327 btm_destroy(btm);
1328 return 1;
cc6483e0
TC
1329}
1330
92bda632
TC
1331/*
1332=item i_flood_cfill(im, seedx, seedy, fill)
1333
1334=category Drawing
1335=synopsis i_flood_cfill(im, 50, 50, fill);
aa833c97 1336
92bda632
TC
1337Flood fills the 4-connected region starting from the point (seedx,
1338seedy) with I<fill>.
1339
1340Returns false if (seedx, seedy) are outside the image.
1341
1342=cut
1343*/
aa833c97 1344
a321d497 1345undef_int
cc6483e0
TC
1346i_flood_cfill(i_img *im, int seedx, int seedy, i_fill_t *fill) {
1347 int bxmin, bxmax, bymin, bymax;
1348 struct i_bitmap *btm;
1349 int x, y;
1350 int start;
1351
aa833c97 1352 i_clear_error();
a321d497
AMH
1353
1354 if (seedx < 0 || seedx >= im->xsize ||
1355 seedy < 0 || seedy >= im->ysize) {
3e1e2ed3 1356 i_push_error(0, "i_flood_cfill: Seed pixel outside of image");
a321d497
AMH
1357 return 0;
1358 }
1359
cc6483e0
TC
1360 btm = i_flood_fill_low(im, seedx, seedy, &bxmin, &bxmax, &bymin, &bymax);
1361
1362 if (im->bits == i_8_bits && fill->fill_with_color) {
f0960b14
TC
1363 /* bxmax/bxmin are inside the image, hence this won't overflow */
1364 i_color *line = mymalloc(sizeof(i_color) * (bxmax - bxmin)); /* checked 5jul05 tonyc */
efdc2568
TC
1365 i_color *work = NULL;
1366 if (fill->combine)
f0960b14 1367 work = mymalloc(sizeof(i_color) * (bxmax - bxmin)); /* checked 5jul05 tonyc */
cc6483e0 1368
aa833c97 1369 for(y=bymin; y<=bymax; y++) {
cc6483e0
TC
1370 x = bxmin;
1371 while (x < bxmax) {
1372 while (x < bxmax && !btm_test(btm, x, y)) {
1373 ++x;
1374 }
1375 if (btm_test(btm, x, y)) {
1376 start = x;
1377 while (x < bxmax && btm_test(btm, x, y)) {
1378 ++x;
1379 }
43c5dacb 1380 if (fill->combine) {
cc6483e0 1381 i_glin(im, start, x, y, line);
43c5dacb
TC
1382 (fill->fill_with_color)(fill, start, y, x-start, im->channels,
1383 work);
1384 (fill->combine)(line, work, im->channels, x-start);
1385 }
1386 else {
1387 (fill->fill_with_color)(fill, start, y, x-start, im->channels,
1388 line);
1389 }
cc6483e0
TC
1390 i_plin(im, start, x, y, line);
1391 }
1392 }
1393 }
1394 myfree(line);
efdc2568
TC
1395 if (work)
1396 myfree(work);
cc6483e0
TC
1397 }
1398 else {
f0960b14
TC
1399 /* bxmax/bxmin are inside the image, hence this won't overflow */
1400 i_fcolor *line = mymalloc(sizeof(i_fcolor) * (bxmax - bxmin)); /* checked 5jul05 tonyc */
efdc2568
TC
1401 i_fcolor *work = NULL;
1402 if (fill->combinef)
f0960b14 1403 work = mymalloc(sizeof(i_fcolor) * (bxmax - bxmin)); /* checked 5jul05 tonyc */
cc6483e0
TC
1404
1405 for(y=bymin;y<=bymax;y++) {
1406 x = bxmin;
1407 while (x < bxmax) {
1408 while (x < bxmax && !btm_test(btm, x, y)) {
1409 ++x;
1410 }
1411 if (btm_test(btm, x, y)) {
1412 start = x;
1413 while (x < bxmax && btm_test(btm, x, y)) {
1414 ++x;
1415 }
43c5dacb 1416 if (fill->combinef) {
cc6483e0 1417 i_glinf(im, start, x, y, line);
43c5dacb
TC
1418 (fill->fill_with_fcolor)(fill, start, y, x-start, im->channels,
1419 work);
1420 (fill->combinef)(line, work, im->channels, x-start);
1421 }
1422 else {
1423 (fill->fill_with_fcolor)(fill, start, y, x-start, im->channels,
1424 line);
1425 }
cc6483e0
TC
1426 i_plinf(im, start, x, y, line);
1427 }
1428 }
1429 }
1430 myfree(line);
efdc2568
TC
1431 if (work)
1432 myfree(work);
cc6483e0
TC
1433 }
1434
1435 btm_destroy(btm);
a321d497 1436 return 1;
cc6483e0 1437}