(Hopefully) last fix for flood fill crash.
[imager.git] / draw.c
1 #include "image.h"
2 #include "draw.h"
3 #include "log.h"
4
5 #include <limits.h>
6
7 void
8 i_mmarray_cr(i_mmarray *ar,int l) {
9   int i;
10
11   ar->lines=l;
12   ar->data=mymalloc(sizeof(minmax)*l);
13   for(i=0;i<l;i++) { ar->data[i].max=-1; ar->data[i].min=MAXINT; }
14 }
15
16 void
17 i_mmarray_dst(i_mmarray *ar) {
18   ar->lines=0;
19   if (ar->data != NULL) { myfree(ar->data); ar->data=NULL; }
20 }
21
22 void
23 i_mmarray_add(i_mmarray *ar,int x,int y) {
24   if (y>-1 && y<ar->lines)
25     {
26       if (x<ar->data[y].min) ar->data[y].min=x;
27       if (x>ar->data[y].max) ar->data[y].max=x;
28     }
29 }
30
31 int
32 i_mmarray_gmin(i_mmarray *ar,int y) {
33   if (y>-1 && y<ar->lines) return ar->data[y].min;
34   else return -1;
35 }
36
37 int
38 i_mmarray_getm(i_mmarray *ar,int y) {
39   if (y>-1 && y<ar->lines) return ar->data[y].max;
40   else return MAXINT;
41 }
42
43 void
44 i_mmarray_render(i_img *im,i_mmarray *ar,i_color *val) {
45   int i,x;
46   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);
47 }
48
49 void
50 i_mmarray_render_fill(i_img *im,i_mmarray *ar,i_fill_t *fill) {
51   int x, w, y;
52   if (im->bits == i_8_bits && fill->fill_with_color) {
53     i_color *line = mymalloc(sizeof(i_color) * im->xsize);
54     i_color *work = NULL;
55     if (fill->combine)
56       work = mymalloc(sizeof(i_color) * im->xsize);
57     for(y=0;y<ar->lines;y++) {
58       if (ar->data[y].max!=-1) {
59         x = ar->data[y].min;
60         w = ar->data[y].max-ar->data[y].min;
61
62         if (fill->combine) {
63           i_glin(im, x, x+w, y, line);
64           (fill->fill_with_color)(fill, x, y, w, im->channels, work);
65           (fill->combine)(line, work, im->channels, w);
66         }
67         else {
68           (fill->fill_with_color)(fill, x, y, w, im->channels, line);
69         }
70         i_plin(im, x, x+w, y, line);
71       }
72     }
73   
74     myfree(line);
75     if (work)
76       myfree(work);
77   }
78   else {
79     i_fcolor *line = mymalloc(sizeof(i_fcolor) * im->xsize);
80     i_fcolor *work = NULL;
81     if (fill->combinef)
82       work = mymalloc(sizeof(i_fcolor) * im->xsize);
83     for(y=0;y<ar->lines;y++) {
84       if (ar->data[y].max!=-1) {
85         x = ar->data[y].min;
86         w = ar->data[y].max-ar->data[y].min;
87
88         if (fill->combinef) {
89           i_glinf(im, x, x+w, y, line);
90           (fill->fill_with_fcolor)(fill, x, y, w, im->channels, work);
91           (fill->combinef)(line, work, im->channels, w);
92         }
93         else {
94           (fill->fill_with_fcolor)(fill, x, y, w, im->channels, line);
95         }
96         i_plinf(im, x, x+w, y, line);
97       }
98     }
99   
100     myfree(line);
101     if (work)
102       myfree(work);
103   }
104 }
105
106
107 static
108 void
109 i_arcdraw(int x1, int y1, int x2, int y2, i_mmarray *ar) {
110   double alpha;
111   double dsec;
112   int temp;
113   alpha=(double)(y2-y1)/(double)(x2-x1);
114   if (fabs(alpha)<1) 
115     {
116       if (x2<x1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
117       dsec=y1;
118       while(x1<x2)
119         {
120           dsec+=alpha;
121           i_mmarray_add(ar,x1,(int)(dsec+0.5));
122           x1++;
123         }
124     }
125   else
126     {
127       alpha=1/alpha;
128       if (y2<y1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
129       dsec=x1;
130       while(y1<y2)
131         {
132           dsec+=alpha;
133           i_mmarray_add(ar,(int)(dsec+0.5),y1);
134           y1++;
135         }
136     }
137 }
138
139 void
140 i_mmarray_info(i_mmarray *ar) {
141   int i;
142   for(i=0;i<ar->lines;i++)
143   if (ar->data[i].max!=-1) printf("line %d: min=%d, max=%d.\n",i,ar->data[i].min,ar->data[i].max);
144 }
145
146
147 void
148 i_arc(i_img *im,int x,int y,float rad,float d1,float d2,i_color *val) {
149   i_mmarray dot;
150   float f,fx,fy;
151   int x1,y1;
152
153   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));
154
155   i_mmarray_cr(&dot,im->ysize);
156
157   x1=(int)(x+0.5+rad*cos(d1*PI/180.0));
158   y1=(int)(y+0.5+rad*sin(d1*PI/180.0));
159   fx=(float)x1; fy=(float)y1;
160
161   /*  printf("x1: %d.\ny1: %d.\n",x1,y1); */
162   i_arcdraw(x, y, x1, y1, &dot);
163
164   x1=(int)(x+0.5+rad*cos(d2*PI/180.0));
165   y1=(int)(y+0.5+rad*sin(d2*PI/180.0));
166
167   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)));
168   
169   /*  printf("x1: %d.\ny1: %d.\n",x1,y1); */
170   i_arcdraw(x, y, x1, y1, &dot);
171
172   /*  dot.info(); */
173   i_mmarray_render(im,&dot,val);
174   i_mmarray_dst(&dot);
175 }
176
177 void
178 i_arc_cfill(i_img *im,int x,int y,float rad,float d1,float d2,i_fill_t *fill) {
179   i_mmarray dot;
180   float f,fx,fy;
181   int x1,y1;
182
183   mm_log((1,"i_arc_cfill(im* 0x%x,x %d,y %d,rad %.2f,d1 %.2f,d2 %.2f,fill 0x%x)\n",im,x,y,rad,d1,d2,fill));
184
185   i_mmarray_cr(&dot,im->ysize);
186
187   x1=(int)(x+0.5+rad*cos(d1*PI/180.0));
188   y1=(int)(y+0.5+rad*sin(d1*PI/180.0));
189   fx=(float)x1; fy=(float)y1;
190
191   /*  printf("x1: %d.\ny1: %d.\n",x1,y1); */
192   i_arcdraw(x, y, x1, y1, &dot);
193
194   x1=(int)(x+0.5+rad*cos(d2*PI/180.0));
195   y1=(int)(y+0.5+rad*sin(d2*PI/180.0));
196
197   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)));
198   
199   /*  printf("x1: %d.\ny1: %d.\n",x1,y1); */
200   i_arcdraw(x, y, x1, y1, &dot);
201
202   /*  dot.info(); */
203   i_mmarray_render_fill(im,&dot,fill);
204   i_mmarray_dst(&dot);
205 }
206
207
208
209 /* Temporary AA HACK */
210
211
212 typedef int frac;
213 static  frac float_to_frac(float x) { return (frac)(0.5+x*16.0); }
214 static   int frac_sub     (frac x)  { return (x%16); }
215 static   int frac_int     (frac x)  { return (x/16); }
216 static float frac_to_float(float x) { return (float)x/16.0; }
217
218 static 
219 void
220 polar_to_plane(float cx, float cy, float angle, float radius, frac *x, frac *y) {
221   *x = float_to_frac(cx+radius*cos(angle));
222   *y = float_to_frac(cy+radius*sin(angle));
223 }
224
225 static
226 void
227 order_pair(frac *x, frac *y) {
228   frac t = *x;
229   if (t>*y) {
230     *x = *y;
231     *y = t;
232   }
233 }
234
235
236
237
238 static
239 void
240 make_minmax_list(i_mmarray *dot, float x, float y, float radius) {
241   float angle = 0.0;
242   float astep = radius>0.1 ? .5/radius : 10;
243   frac cx, cy, lx, ly, sx, sy;
244
245   mm_log((1, "make_minmax_list(dot %p, x %.2f, y %.2f, radius %.2f)\n", dot, x, y, radius));
246
247   polar_to_plane(x, y, angle, radius, &sx, &sy);
248   
249   for(angle = 0.0; angle<361; angle +=astep) {
250     float alpha;
251     lx = sx; ly = sy;
252     polar_to_plane(x, y, angle, radius, &cx, &cy);
253     sx = cx; sy = cy;
254
255     if (fabs(cx-lx) > fabs(cy-ly)) {
256       int ccx, ccy;
257       if (lx>cx) { 
258         ccx = lx; lx = cx; cx = ccx; 
259         ccy = ly; ly = cy; cy = ccy; 
260       }
261
262       for(ccx=lx; ccx<=cx; ccx++) {
263         ccy = ly + ((cy-ly)*(ccx-lx))/(cx-lx);
264         i_mmarray_add(dot, ccx, ccy);
265       }
266     } else {
267       int ccx, ccy;
268
269       if (ly>cy) { 
270         ccy = ly; ly = cy; cy = ccy; 
271         ccx = lx; lx = cx; cx = ccx; 
272       }
273       
274       for(ccy=ly; ccy<=cy; ccy++) {
275         if (cy-ly) ccx = lx + ((cx-lx)*(ccy-ly))/(cy-ly); else ccx = lx;
276         i_mmarray_add(dot, ccx, ccy);
277       }
278     }
279   }
280 }
281
282 /* Get the number of subpixels covered */
283
284 static
285 int
286 i_pixel_coverage(i_mmarray *dot, int x, int y) {
287   frac minx = x*16;
288   frac maxx = minx+15;
289   frac cy;
290   int cnt = 0;
291   
292   for(cy=y*16; cy<(y+1)*16; cy++) {
293     frac tmin = dot->data[cy].min;
294     frac tmax = dot->data[cy].max;
295
296     if (tmax == -1 || tmin > maxx || tmax < minx) continue;
297     
298     if (tmin < minx) tmin = minx;
299     if (tmax > maxx) tmax = maxx;
300     
301     cnt+=1+tmax-tmin;
302   }
303   return cnt;
304 }
305
306 void
307 i_circle_aa(i_img *im, float x, float y, float rad, i_color *val) {
308   i_mmarray dot;
309   i_color temp;
310   int ly;
311
312   mm_log((1, "i_circle_aa(im %p, x %d, y %d, rad %.2f, val %p)\n", im, x, y, rad, val));
313
314   i_mmarray_cr(&dot,16*im->ysize);
315   make_minmax_list(&dot, x, y, rad);
316
317   for(ly = 0; ly<im->ysize; ly++) {
318     int ix, cy, cnt = 0, minx = INT_MAX, maxx = INT_MIN;
319
320     /* Find the left/rightmost set subpixels */
321     for(cy = 0; cy<16; cy++) {
322       frac tmin = dot.data[ly*16+cy].min;
323       frac tmax = dot.data[ly*16+cy].max;
324       if (tmax == -1) continue;
325
326       if (minx > tmin) minx = tmin;
327       if (maxx < tmax) maxx = tmax;
328     }
329
330     if (maxx == INT_MIN) continue; /* no work to be done for this row of pixels */
331
332     minx /= 16;
333     maxx /= 16;
334     for(ix=minx; ix<=maxx; ix++) {
335       int cnt = i_pixel_coverage(&dot, ix, ly);
336       if (cnt>255) cnt = 255;
337       if (cnt) { /* should never be true */
338         int ch;
339         float ratio = (float)cnt/255.0;
340         i_gpix(im, ix, ly, &temp);
341         for(ch=0;ch<im->channels; ch++) temp.channel[ch] = (unsigned char)((float)val->channel[ch]*ratio + (float)temp.channel[ch]*(1.0-ratio));
342         i_ppix(im, ix, ly, &temp);
343       }
344     }
345   }
346   i_mmarray_dst(&dot);
347 }
348
349
350
351
352
353
354 void
355 i_box(i_img *im,int x1,int y1,int x2,int y2,i_color *val) {
356   int x,y;
357   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));
358   for(x=x1;x<x2+1;x++) {
359     i_ppix(im,x,y1,val);
360     i_ppix(im,x,y2,val);
361   }
362   for(y=y1;y<y2+1;y++) {
363     i_ppix(im,x1,y,val);
364     i_ppix(im,x2,y,val);
365   }
366 }
367
368 void
369 i_box_filled(i_img *im,int x1,int y1,int x2,int y2,i_color *val) {
370   int x,y;
371   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));
372   for(x=x1;x<x2+1;x++) for (y=y1;y<y2+1;y++) i_ppix(im,x,y,val);
373 }
374
375 void
376 i_box_cfill(i_img *im,int x1,int y1,int x2,int y2,i_fill_t *fill) {
377   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));
378
379   ++x2;
380   if (im->bits == i_8_bits && fill->fill_with_color) {
381     i_color *line = mymalloc(sizeof(i_color) * (x2 - x1));
382     i_color *work = NULL;
383     if (fill->combine)
384       work = mymalloc(sizeof(i_color) * (x2-x1));
385     while (y1 <= y2) {
386       if (fill->combine) {
387         i_glin(im, x1, x2, y1, line);
388         (fill->fill_with_color)(fill, x1, y1, x2-x1, im->channels, work);
389         (fill->combine)(line, work, im->channels, x2-x1);
390       }
391       else {
392         (fill->fill_with_color)(fill, x1, y1, x2-x1, im->channels, line);
393       }
394       i_plin(im, x1, x2, y1, line);
395       ++y1;
396     }
397     myfree(line);
398     if (work)
399       myfree(work);
400   }
401   else {
402     i_fcolor *line = mymalloc(sizeof(i_fcolor) * (x2 - x1));
403     i_fcolor *work;
404     work = mymalloc(sizeof(i_fcolor) * (x2 - x1));
405
406     while (y1 <= y2) {
407       if (fill->combine) {
408         i_glinf(im, x1, x2, y1, line);
409         (fill->fill_with_fcolor)(fill, x1, y1, x2-x1, im->channels, work);
410         (fill->combinef)(line, work, im->channels, x2-x1);
411       }
412       else {
413         (fill->fill_with_fcolor)(fill, x1, y1, x2-x1, im->channels, line);
414       }
415       i_plinf(im, x1, x2, y1, line);
416       ++y1;
417     }
418     myfree(line);
419     if (work)
420       myfree(work);
421   }
422 }
423
424 void
425 i_draw(i_img *im,int x1,int y1,int x2,int y2,i_color *val) {
426   double alpha;
427   double dsec;
428   int temp;
429
430   mm_log((1,"i_draw(im* 0x%x,x1 %d,y1 %d,x2 %d,y2 %d,val 0x%x)\n",im,x1,y1,x2,y2,val));
431
432   alpha=(double)(y2-y1)/(double)(x2-x1);
433   if (fabs(alpha)<1) 
434     {
435       if (x2<x1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
436       dsec=y1;
437       while(x1<x2)
438         {
439           dsec+=alpha;
440           i_ppix(im,x1,(int)(dsec+0.5),val);
441           x1++;
442         }
443     }
444   else
445     {
446       alpha=1/alpha;
447       if (y2<y1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
448       dsec=x1;
449       while(y1<y2)
450         {
451           dsec+=alpha;
452           i_ppix(im,(int)(dsec+0.5),y1,val);
453           y1++;
454         }
455     }
456   mm_log((1,"i_draw: alpha=%f.\n",alpha));
457 }
458
459 void
460 i_line_aa(i_img *im,int x1,int y1,int x2,int y2,i_color *val) {
461   i_color tval;
462   float alpha;
463   float dsec,dfrac;
464   int temp,dx,dy,isec,ch;
465
466   mm_log((1,"i_draw(im* 0x%x,x1 %d,y1 %d,x2 %d,y2 %d,val 0x%x)\n",im,x1,y1,x2,y2,val));
467
468   dy=y2-y1;
469   dx=x2-x1;
470
471   if (abs(dx)>abs(dy)) { /* alpha < 1 */
472     if (x2<x1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
473     alpha=(float)(y2-y1)/(float)(x2-x1);
474
475     dsec=y1;
476     while(x1<=x2) {
477       isec=(int)dsec;
478       dfrac=dsec-isec;
479       /*      dfrac=1-(1-dfrac)*(1-dfrac); */
480       /* This is something we can play with to try to get better looking lines */
481
482       i_gpix(im,x1,isec,&tval);
483       for(ch=0;ch<im->channels;ch++) tval.channel[ch]=(unsigned char)(dfrac*(float)tval.channel[ch]+(1-dfrac)*(float)val->channel[ch]);
484       i_ppix(im,x1,isec,&tval);
485       
486       i_gpix(im,x1,isec+1,&tval);
487       for(ch=0;ch<im->channels;ch++) tval.channel[ch]=(unsigned char)((1-dfrac)*(float)tval.channel[ch]+dfrac*(float)val->channel[ch]);
488       i_ppix(im,x1,isec+1,&tval);
489       
490       dsec+=alpha;
491       x1++;
492     }
493   } else {
494     if (y2<y1) { temp=y1; y1=y2; y2=temp; temp=x1; x1=x2; x2=temp; }
495     alpha=(float)(x2-x1)/(float)(y2-y1);
496     dsec=x1;
497     while(y1<=y2) {
498       isec=(int)dsec;
499       dfrac=dsec-isec;
500       /*      dfrac=sqrt(dfrac); */
501       /* This is something we can play with */
502       i_gpix(im,isec,y1,&tval);
503       for(ch=0;ch<im->channels;ch++) tval.channel[ch]=(unsigned char)(dfrac*(float)tval.channel[ch]+(1-dfrac)*(float)val->channel[ch]);
504       i_ppix(im,isec,y1,&tval);
505
506       i_gpix(im,isec+1,y1,&tval);
507       for(ch=0;ch<im->channels;ch++) tval.channel[ch]=(unsigned char)((1-dfrac)*(float)tval.channel[ch]+dfrac*(float)val->channel[ch]);
508       i_ppix(im,isec+1,y1,&tval);
509
510       dsec+=alpha;
511       y1++;
512     }
513   }
514 }
515
516 static double
517 perm(int n,int k) {
518   double r;
519   int i;
520   r=1;
521   for(i=k+1;i<=n;i++) r*=i;
522   for(i=1;i<=(n-k);i++) r/=i;
523   return r;
524 }
525
526
527 /* Note in calculating t^k*(1-t)^(n-k) 
528    we can start by using t^0=1 so this simplifies to
529    t^0*(1-t)^n - we want to multiply that with t/(1-t) each iteration
530    to get a new level - this may lead to errors who knows lets test it */
531
532 void
533 i_bezier_multi(i_img *im,int l,double *x,double *y,i_color *val) {
534   double *bzcoef;
535   double t,cx,cy;
536   int k,i;
537   int lx = 0,ly = 0;
538   int n=l-1;
539   double itr,ccoef;
540
541
542   bzcoef=mymalloc(sizeof(double)*l);
543   for(k=0;k<l;k++) bzcoef[k]=perm(n,k);
544   ICL_info(val);
545
546
547   /*  for(k=0;k<l;k++) printf("bzcoef: %d -> %f\n",k,bzcoef[k]); */
548   i=0;
549   for(t=0;t<=1;t+=0.005) {
550     cx=cy=0;
551     itr=t/(1-t);
552     ccoef=pow(1-t,n);
553     for(k=0;k<l;k++) {
554       /*      cx+=bzcoef[k]*x[k]*pow(t,k)*pow(1-t,n-k); 
555               cy+=bzcoef[k]*y[k]*pow(t,k)*pow(1-t,n-k);*/
556
557       cx+=bzcoef[k]*x[k]*ccoef;
558       cy+=bzcoef[k]*y[k]*ccoef;
559       ccoef*=itr;
560     }
561     /*    printf("%f -> (%d,%d)\n",t,(int)(0.5+cx),(int)(0.5+cy)); */
562     if (i++) { 
563       i_line_aa(im,lx,ly,(int)(0.5+cx),(int)(0.5+cy),val);
564     }
565       /*     i_ppix(im,(int)(0.5+cx),(int)(0.5+cy),val); */
566     lx=(int)(0.5+cx);
567     ly=(int)(0.5+cy);
568   }
569   ICL_info(val);
570   myfree(bzcoef);
571 }
572
573
574
575
576
577
578
579
580
581
582
583 /* Flood fill 
584
585    REF: Graphics Gems I. page 282+
586
587 */
588
589 /* This should be moved into a seperate file? */
590
591 /* This is the truncation used:
592    
593    a double is multiplied by 16 and then truncated.
594    This means that 0 -> 0
595    So a triangle of (0,0) (10,10) (10,0) Will look like it's
596    not filling the (10,10) point nor the (10,0)-(10,10)  line segment
597
598 */
599
600
601 /* Flood fill algorithm - based on the Ken Fishkins (pixar) gem in 
602    graphics gems I */
603
604 /*
605 struct stc {
606   int mylx,myrx; 
607   int dadlx,dadrx;
608   int myy;
609   int mydirection;
610 };
611
612 Not used code???
613 */
614
615
616 struct stack_element {
617   int myLx,myRx;
618   int dadLx,dadRx;
619   int myY;
620   int myDirection;
621 };
622
623
624 /* create the link data to put push onto the stack */
625
626 static
627 struct stack_element*
628 crdata(int left,int right,int dadl,int dadr,int y, int dir) {
629   struct stack_element *ste;
630   ste              = mymalloc(sizeof(struct stack_element));
631   ste->myLx        = left;
632   ste->myRx        = right;
633   ste->dadLx       = dadl;
634   ste->dadRx       = dadr;
635   ste->myY         = y;
636   ste->myDirection = dir;
637   return ste;
638 }
639
640 /* i_ccomp compares two colors and gives true if they are the same */
641
642 static int
643 i_ccomp(i_color *val1,i_color *val2,int ch) {
644   int i;
645   for(i=0;i<ch;i++) if (val1->channel[i] !=val2->channel[i]) return 0;
646   return 1;
647 }
648
649
650 static int
651 i_lspan(i_img *im, int seedx, int seedy, i_color *val) {
652   i_color cval;
653   while(1) {
654     if (seedx-1 < 0) break;
655     i_gpix(im,seedx-1,seedy,&cval);
656     if (!i_ccomp(val,&cval,im->channels)) break;
657     seedx--;
658   }
659   return seedx;
660 }
661
662 static int
663 i_rspan(i_img *im, int seedx, int seedy, i_color *val) {
664   i_color cval;
665   while(1) {
666     if (seedx+1 > im->xsize-1) break;
667     i_gpix(im,seedx+1,seedy,&cval);
668     if (!i_ccomp(val,&cval,im->channels)) break;
669     seedx++;
670   }
671   return seedx;
672 }
673
674 /* Macro to create a link and push on to the list */
675
676 #define ST_PUSH(left,right,dadl,dadr,y,dir) do {                 \
677   struct stack_element *s = crdata(left,right,dadl,dadr,y,dir);  \
678   llist_push(st,&s);                                             \
679 } while (0)
680
681 /* pops the shadow on TOS into local variables lx,rx,y,direction,dadLx and dadRx */
682 /* No overflow check! */
683  
684 #define ST_POP() do {         \
685   struct stack_element *s;    \
686   llist_pop(st,&s);           \
687   lx        = s->myLx;        \
688   rx        = s->myRx;        \
689   dadLx     = s->dadLx;       \
690   dadRx     = s->dadRx;       \
691   y         = s->myY;         \
692   direction = s->myDirection; \
693   myfree(s);                  \
694 } while (0)
695
696 #define ST_STACK(dir,dadLx,dadRx,lx,rx,y) do {                    \
697   int pushrx = rx+1;                                              \
698   int pushlx = lx-1;                                              \
699   ST_PUSH(lx,rx,pushlx,pushrx,y+dir,dir);                         \
700   if (rx > dadRx)                                                 \
701     ST_PUSH(dadRx+1,rx,pushlx,pushrx,y-dir,-dir);                 \
702   if (lx < dadLx) ST_PUSH(lx,dadLx-1,pushlx,pushrx,y-dir,-dir);   \
703 } while (0)
704
705 #define SET(x,y) btm_set(btm,x,y)
706
707 /* INSIDE returns true if pixel is correct color and we haven't set it before. */
708 #define INSIDE(x,y) ((!btm_test(btm,x,y) && ( i_gpix(im,x,y,&cval),i_ccomp(&val,&cval,channels)  ) ))
709
710 undef_int
711 i_flood_fill(i_img *im, int seedx, int seedy, i_color *dcol) {
712
713   int lx,rx;
714   int y;
715   int direction;
716   int dadLx,dadRx;
717
718   int wasIn=0;
719   int x=0;
720
721   /*  int tx,ty; */
722
723   int bxmin = seedx;
724   int bxmax = seedx;
725   int bymin = seedy;
726   int bymax = seedy;
727
728   struct llist *st;
729   struct i_bitmap *btm;
730
731   int channels,xsize,ysize;
732   i_color cval, val;
733
734   channels = im->channels;
735   xsize    = im->xsize;
736   ysize    = im->ysize;
737
738   if (seedx < 0 || seedx >= xsize ||
739       seedy < 0 || seedy >= ysize) {
740     i_push_error(0, "i_flood_fill: Seed pixel outside of image");
741     return 0;
742   }
743
744   btm = btm_new(xsize, ysize);
745   st  = llist_new(100, sizeof(struct stack_element*));
746
747   /* Get the reference color */
748   i_gpix(im, seedx, seedy, &val);
749
750   /* Find the starting span and fill it */
751   lx = i_lspan(im, seedx, seedy, &val);
752   rx = i_rspan(im, seedx, seedy, &val);
753   
754   printf("span: %d %d \n",lx,rx);
755
756   for(x=lx; x<=rx; x++) SET(x,seedy);
757
758   ST_PUSH(lx, rx, lx, rx, seedy+1, 1);
759   ST_PUSH(lx, rx, lx, rx, seedy-1,-1);
760
761   while(st->count) {
762     ST_POP();
763     
764     if (y<0 || y>ysize-1) continue;
765
766
767     if (bymin > y) bymin=y; /* in the worst case an extra line */
768     if (bymax < y) bymax=y; 
769
770     /*
771       {
772       int tx, ty;
773       printf("start of scan - on stack : %d \n",st->count); 
774       printf("lx=%d rx=%d dadLx=%d dadRx=%d y=%d direction=%d\n",lx,rx,dadLx,dadRx,y,direction); 
775       
776       
777       printf(" ");
778       for(tx=0;tx<xsize;tx++) printf("%d",tx%10);
779       printf("\n");
780       for(ty=0;ty<ysize;ty++) {
781       printf("%d",ty%10);
782       for(tx=0;tx<xsize;tx++) printf("%d",!!btm_test(btm,tx,ty));
783       printf("\n");
784       }
785       printf("y=%d\n",y);
786       }
787     */
788
789
790     x = lx+1;
791     if ( lx>=0 && (wasIn = INSIDE(lx,y)) ) {
792       SET(lx,y);
793       lx--;
794       while(lx>0 && INSIDE(lx,y)) {
795         SET(lx,y);
796         lx--;
797       }
798     }
799
800     if (bxmin > lx) bxmin = lx;
801     
802     while(x <= xsize-1) {
803       /*  printf("x=%d\n",x); */
804       if (wasIn) {
805         
806         if (INSIDE(x,y)) {
807           /* case 1: was inside, am still inside */
808           SET(x,y);
809         } else {
810           /* case 2: was inside, am no longer inside: just found the
811              right edge of a span */
812           ST_STACK(direction,dadLx,dadRx,lx,(x-1),y);
813
814           if (bxmax < x) bxmax=x;
815
816           wasIn=0;
817         }
818       } else {
819         if (x>rx) goto EXT;
820         if (INSIDE(x,y)) {
821           SET(x,y);
822           /* case 3: Wasn't inside, am now: just found the start of a new run */
823           wasIn=1;
824           lx=x;
825         } else {
826           /* case 4: Wasn't inside, still isn't */
827         }
828       }
829       x++;
830     }
831   EXT: /* out of loop */
832     if (wasIn) {
833       /* hit an edge of the frame buffer while inside a run */
834       ST_STACK(direction,dadLx,dadRx,lx,(x-1),y);
835       if (bxmax < x) bxmax=x;
836     }
837   }
838   
839   /*   printf("lx=%d rx=%d dadLx=%d dadRx=%d y=%d direction=%d\n",lx,rx,dadLx,dadRx,y,direction); 
840        printf("bounding box: [%d,%d] - [%d,%d]\n",bxmin,bymin,bxmax,bymax); */
841
842   for(y=bymin;y<=bymax;y++) for(x=bxmin;x<=bxmax;x++) if (btm_test(btm,x,y)) i_ppix(im,x,y,dcol);
843
844   btm_destroy(btm);
845   mm_log((1, "DESTROY\n"));
846   llist_destroy(st);
847   return 1;
848 }
849
850 static struct i_bitmap *
851 i_flood_fill_low(i_img *im,int seedx,int seedy,
852                  int *bxminp, int *bxmaxp, int *byminp, int *bymaxp) {
853   int lx,rx;
854   int y;
855   int direction;
856   int dadLx,dadRx;
857
858   int wasIn=0;
859   int x=0;
860
861   /*  int tx,ty; */
862
863   int bxmin=seedx,bxmax=seedx,bymin=seedy,bymax=seedy;
864
865   struct llist *st;
866   struct i_bitmap *btm;
867
868   int channels,xsize,ysize;
869   i_color cval,val;
870
871   channels=im->channels;
872   xsize=im->xsize;
873   ysize=im->ysize;
874
875   btm=btm_new(xsize,ysize);
876   st=llist_new(100,sizeof(struct stack_element*));
877
878   /* Get the reference color */
879   i_gpix(im,seedx,seedy,&val);
880
881   /* Find the starting span and fill it */
882   lx = i_lspan(im, seedx, seedy, &val);
883   rx = i_rspan(im, seedx, seedy, &val);
884   
885   /* printf("span: %d %d \n",lx,rx); */
886
887   for(x=lx; x<=rx; x++) SET(x, seedy);
888
889   ST_PUSH(lx, rx, lx, rx, seedy+1,  1);
890   ST_PUSH(lx, rx, lx, rx, seedy-1, -1);
891
892   while(st->count) {
893     ST_POP();
894     
895     if (y<0 || y>ysize-1) continue;
896
897     if (bymin > y) bymin=y; /* in the worst case an extra line */
898     if (bymax < y) bymax=y; 
899
900     /*     printf("start of scan - on stack : %d \n",st->count); */
901
902     
903     /*     printf("lx=%d rx=%d dadLx=%d dadRx=%d y=%d direction=%d\n",lx,rx,dadLx,dadRx,y,direction); */
904     
905     /*
906     printf(" ");
907     for(tx=0;tx<xsize;tx++) printf("%d",tx%10);
908     printf("\n");
909     for(ty=0;ty<ysize;ty++) {
910       printf("%d",ty%10);
911       for(tx=0;tx<xsize;tx++) printf("%d",!!btm_test(btm,tx,ty));
912       printf("\n");
913     }
914
915     printf("y=%d\n",y);
916     */
917
918
919     x=lx+1;
920     if ( (wasIn = INSIDE(lx,y)) ) {
921       SET(lx,y);
922       lx--;
923       while(INSIDE(lx,y) && lx > 0) {
924         SET(lx,y);
925         lx--;
926       }
927     }
928
929     if (bxmin > lx) bxmin=lx;
930     
931     while(x <= xsize-1) {
932       /*  printf("x=%d\n",x); */
933       if (wasIn) {
934         
935         if (INSIDE(x,y)) {
936           /* case 1: was inside, am still inside */
937           SET(x,y);
938         } else {
939           /* case 2: was inside, am no longer inside: just found the
940              right edge of a span */
941           ST_STACK(direction,dadLx,dadRx,lx,(x-1),y);
942
943           if (bxmax < x) bxmax=x;
944
945           wasIn=0;
946         }
947       } else {
948         if (x>rx) goto EXT;
949         if (INSIDE(x,y)) {
950           SET(x,y);
951           /* case 3: Wasn't inside, am now: just found the start of a new run */
952           wasIn=1;
953             lx=x;
954         } else {
955           /* case 4: Wasn't inside, still isn't */
956         }
957       }
958       x++;
959     }
960   EXT: /* out of loop */
961     if (wasIn) {
962       /* hit an edge of the frame buffer while inside a run */
963       ST_STACK(direction,dadLx,dadRx,lx,(x-1),y);
964       if (bxmax < x) bxmax=x;
965     }
966   }
967   
968   /*   printf("lx=%d rx=%d dadLx=%d dadRx=%d y=%d direction=%d\n",lx,rx,dadLx,dadRx,y,direction); 
969        printf("bounding box: [%d,%d] - [%d,%d]\n",bxmin,bymin,bxmax,bymax); */
970
971   llist_destroy(st);
972
973   *bxminp = bxmin;
974   *bxmaxp = bxmax;
975   *byminp = bymin;
976   *bymaxp = bymax;
977
978   return btm;
979 }
980
981 undef_int
982 i_flood_cfill(i_img *im, int seedx, int seedy, i_fill_t *fill) {
983   int bxmin, bxmax, bymin, bymax;
984   struct i_bitmap *btm;
985   int x, y;
986   int start;
987
988   
989   if (seedx < 0 || seedx >= im->xsize ||
990       seedy < 0 || seedy >= im->ysize) {
991     i_push_error(0, "i_flood_cfill: Seed pixel outside of image");
992     return 0;
993   }
994
995
996   btm = i_flood_fill_low(im, seedx, seedy, &bxmin, &bxmax, &bymin, &bymax);
997
998   if (im->bits == i_8_bits && fill->fill_with_color) {
999     i_color *line = mymalloc(sizeof(i_color) * (bxmax - bxmin));
1000     i_color *work = NULL;
1001     if (fill->combine)
1002       work = mymalloc(sizeof(i_color) * (bxmax - bxmin));
1003
1004     for(y=bymin;y<=bymax;y++) {
1005       x = bxmin;
1006       while (x < bxmax) {
1007         while (x < bxmax && !btm_test(btm, x, y)) {
1008           ++x;
1009         }
1010         if (btm_test(btm, x, y)) {
1011           start = x;
1012           while (x < bxmax && btm_test(btm, x, y)) {
1013             ++x;
1014           }
1015           if (fill->combine) {
1016             i_glin(im, start, x, y, line);
1017             (fill->fill_with_color)(fill, start, y, x-start, im->channels, 
1018                                     work);
1019             (fill->combine)(line, work, im->channels, x-start);
1020           }
1021           else {
1022             (fill->fill_with_color)(fill, start, y, x-start, im->channels, 
1023                                     line);
1024           }
1025           i_plin(im, start, x, y, line);
1026         }
1027       }
1028     }
1029     myfree(line);
1030     if (work)
1031       myfree(work);
1032   }
1033   else {
1034     i_fcolor *line = mymalloc(sizeof(i_fcolor) * (bxmax - bxmin));
1035     i_fcolor *work = NULL;
1036     if (fill->combinef)
1037       work = mymalloc(sizeof(i_fcolor) * (bxmax - bxmin));
1038     
1039     for(y=bymin;y<=bymax;y++) {
1040       x = bxmin;
1041       while (x < bxmax) {
1042         while (x < bxmax && !btm_test(btm, x, y)) {
1043           ++x;
1044         }
1045         if (btm_test(btm, x, y)) {
1046           start = x;
1047           while (x < bxmax && btm_test(btm, x, y)) {
1048             ++x;
1049           }
1050           if (fill->combinef) {
1051             i_glinf(im, start, x, y, line);
1052             (fill->fill_with_fcolor)(fill, start, y, x-start, im->channels, 
1053                                     work);
1054             (fill->combinef)(line, work, im->channels, x-start);
1055           }
1056           else {
1057             (fill->fill_with_fcolor)(fill, start, y, x-start, im->channels, 
1058                                     line);
1059           }
1060           i_plinf(im, start, x, y, line);
1061         }
1062       }
1063     }
1064     myfree(line);
1065     if (work)
1066       myfree(work);
1067   }
1068
1069   btm_destroy(btm);
1070   return 1;
1071 }