Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 1987 lines (1576 sloc) 45.476 kb
92bda63 - start of external Imager API access:
Tony Cook authored
1 #include "imager.h"
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
2 #include "draw.h"
3 #include "log.h"
92bda63 - start of external Imager API access:
Tony Cook authored
4 #include "imageri.h"
9b1ec2b commit changes from draw branch
Tony Cook authored
5 #include "imrender.h"
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
6 #include <limits.h>
7
40068b3 merge circle outline branch
Tony Cook authored
8 int
9 i_ppix_norm(i_img *im, i_img_dim x, i_img_dim y, i_color const *col) {
10 i_color src;
11 i_color work;
12 int dest_alpha;
13 int remains;
14
15 if (!col->channel[3])
16 return 0;
17
18 switch (im->channels) {
19 case 1:
20 work = *col;
21 i_adapt_colors(2, 4, &work, 1);
22 i_gpix(im, x, y, &src);
23 remains = 255 - work.channel[1];
24 src.channel[0] = (src.channel[0] * remains
25 + work.channel[0] * work.channel[1]) / 255;
26 return i_ppix(im, x, y, &src);
27
28 case 2:
29 work = *col;
30 i_adapt_colors(2, 4, &work, 1);
31 i_gpix(im, x, y, &src);
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
32 remains = 255 - work.channel[1];
40068b3 merge circle outline branch
Tony Cook authored
33 dest_alpha = work.channel[1] + remains * src.channel[1] / 255;
34 if (work.channel[1] == 255) {
35 return i_ppix(im, x, y, &work);
36 }
37 else {
38 src.channel[0] = (work.channel[1] * work.channel[0]
39 + remains * src.channel[0] * src.channel[1] / 255) / dest_alpha;
40 src.channel[1] = dest_alpha;
41 return i_ppix(im, x, y, &src);
42 }
43
44 case 3:
45 work = *col;
46 i_gpix(im, x, y, &src);
47 remains = 255 - work.channel[3];
48 src.channel[0] = (src.channel[0] * remains
49 + work.channel[0] * work.channel[3]) / 255;
50 src.channel[1] = (src.channel[1] * remains
51 + work.channel[1] * work.channel[3]) / 255;
52 src.channel[2] = (src.channel[2] * remains
53 + work.channel[2] * work.channel[3]) / 255;
54 return i_ppix(im, x, y, &src);
55
56 case 4:
57 work = *col;
58 i_gpix(im, x, y, &src);
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
59 remains = 255 - work.channel[3];
40068b3 merge circle outline branch
Tony Cook authored
60 dest_alpha = work.channel[3] + remains * src.channel[3] / 255;
61 if (work.channel[3] == 255) {
62 return i_ppix(im, x, y, &work);
63 }
64 else {
65 src.channel[0] = (work.channel[3] * work.channel[0]
66 + remains * src.channel[0] * src.channel[3] / 255) / dest_alpha;
67 src.channel[1] = (work.channel[3] * work.channel[1]
68 + remains * src.channel[1] * src.channel[3] / 255) / dest_alpha;
69 src.channel[2] = (work.channel[3] * work.channel[2]
70 + remains * src.channel[2] * src.channel[3] / 255) / dest_alpha;
71 src.channel[3] = dest_alpha;
72 return i_ppix(im, x, y, &src);
73 }
74 }
75 return 0;
76 }
77
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
78 static void
79 cfill_from_btm(i_img *im, i_fill_t *fill, struct i_bitmap *btm,
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
80 i_img_dim bxmin, i_img_dim bxmax, i_img_dim bymin, i_img_dim bymax);
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
81
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
82 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
83 i_mmarray_cr(i_mmarray *ar,i_img_dim l) {
84 i_img_dim i;
85 size_t alloc_size;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
86
87 ar->lines=l;
f0960b1 - added integer overflow checks to many memory allocation calls
Tony Cook authored
88 alloc_size = sizeof(minmax) * l;
89 /* check for overflow */
90 if (alloc_size / l != sizeof(minmax)) {
91 fprintf(stderr, "overflow calculating memory allocation");
92 exit(3);
93 }
94 ar->data=mymalloc(alloc_size); /* checked 5jul05 tonyc */
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
95 for(i=0;i<l;i++) { ar->data[i].max=-1; ar->data[i].min=MAXINT; }
96 }
97
98 void
99 i_mmarray_dst(i_mmarray *ar) {
100 ar->lines=0;
101 if (ar->data != NULL) { myfree(ar->data); ar->data=NULL; }
102 }
103
104 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
105 i_mmarray_add(i_mmarray *ar,i_img_dim x,i_img_dim y) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
106 if (y>-1 && y<ar->lines)
107 {
108 if (x<ar->data[y].min) ar->data[y].min=x;
109 if (x>ar->data[y].max) ar->data[y].max=x;
110 }
111 }
112
113 int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
114 i_mmarray_gmin(i_mmarray *ar,i_img_dim y) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
115 if (y>-1 && y<ar->lines) return ar->data[y].min;
116 else return -1;
117 }
118
119 int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
120 i_mmarray_getm(i_mmarray *ar,i_img_dim y) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
121 if (y>-1 && y<ar->lines) return ar->data[y].max;
122 else return MAXINT;
123 }
124
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
125 #if 0
126 /* unused? */
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
127 void
128 i_mmarray_render(i_img *im,i_mmarray *ar,i_color *val) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
129 i_img_dim i,x;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
130 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);
131 }
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
132 #endif
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
133
134 static
135 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
136 i_arcdraw(i_img_dim x1, i_img_dim y1, i_img_dim x2, i_img_dim y2, i_mmarray *ar) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
137 double alpha;
138 double dsec;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
139 i_img_dim temp;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
140 alpha=(double)(y2-y1)/(double)(x2-x1);
b254292 - the straight edges of filled arcs weren't being drawn correctly,
Tony Cook authored
141 if (fabs(alpha) <= 1)
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
142 {
143 if (x2<x1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
144 dsec=y1;
b254292 - the straight edges of filled arcs weren't being drawn correctly,
Tony Cook authored
145 while(x1<=x2)
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
146 {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
147 i_mmarray_add(ar,x1,(i_img_dim)(dsec+0.5));
b254292 - the straight edges of filled arcs weren't being drawn correctly,
Tony Cook authored
148 dsec+=alpha;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
149 x1++;
150 }
151 }
152 else
153 {
154 alpha=1/alpha;
155 if (y2<y1) { temp=x1; x1=x2; x2=temp; temp=y1; y1=y2; y2=temp; }
156 dsec=x1;
b254292 - the straight edges of filled arcs weren't being drawn correctly,
Tony Cook authored
157 while(y1<=y2)
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
158 {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
159 i_mmarray_add(ar,(i_img_dim)(dsec+0.5),y1);
b254292 - the straight edges of filled arcs weren't being drawn correctly,
Tony Cook authored
160 dsec+=alpha;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
161 y1++;
162 }
163 }
164 }
165
166 void
167 i_mmarray_info(i_mmarray *ar) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
168 i_img_dim i;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
169 for(i=0;i<ar->lines;i++)
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
170 if (ar->data[i].max!=-1)
171 printf("line %"i_DF ": min=%" i_DF ", max=%" i_DF ".\n",
172 i_DFc(i), i_DFc(ar->data[i].min), i_DFc(ar->data[i].max));
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
173 }
174
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
175 static void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
176 i_arc_minmax(i_int_hlines *hlines,i_img_dim x,i_img_dim y, double rad,float d1,float d2) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
177 i_mmarray dot;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
178 double f,fx,fy;
179 i_img_dim x1,y1;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
180
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
181 i_mmarray_cr(&dot, hlines->limit_y);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
182
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
183 x1=(i_img_dim)(x+0.5+rad*cos(d1*PI/180.0));
184 y1=(i_img_dim)(y+0.5+rad*sin(d1*PI/180.0));
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
185 fx=(float)x1; fy=(float)y1;
186
187 /* printf("x1: %d.\ny1: %d.\n",x1,y1); */
188 i_arcdraw(x, y, x1, y1, &dot);
189
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
190 x1=(i_img_dim)(x+0.5+rad*cos(d2*PI/180.0));
191 y1=(i_img_dim)(y+0.5+rad*sin(d2*PI/180.0));
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
192
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
193 for(f=d1;f<=d2;f+=0.01)
194 i_mmarray_add(&dot,(i_img_dim)(x+0.5+rad*cos(f*PI/180.0)),(i_img_dim)(y+0.5+rad*sin(f*PI/180.0)));
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
195
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
196 /* printf("x1: %d.\ny1: %d.\n",x1,y1); */
197 i_arcdraw(x, y, x1, y1, &dot);
198
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
199 /* render the minmax values onto the hlines */
200 for (y = 0; y < dot.lines; y++) {
201 if (dot.data[y].max!=-1) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
202 i_img_dim minx, width;
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
203 minx = dot.data[y].min;
204 width = dot.data[y].max - dot.data[y].min + 1;
205 i_int_hlines_add(hlines, y, minx, width);
206 }
207 }
208
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
209 /* dot.info(); */
7f882a0 Added an Imager::log_entry() function and some extra logging
Arnar Mar Hrafnkelsson authored
210 i_mmarray_dst(&dot);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
211 }
212
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
213 static void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
214 i_arc_hlines(i_int_hlines *hlines,i_img_dim x,i_img_dim y,double rad,float d1,float d2) {
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
215 if (d1 <= d2) {
216 i_arc_minmax(hlines, x, y, rad, d1, d2);
217 }
218 else {
219 i_arc_minmax(hlines, x, y, rad, d1, 360);
220 i_arc_minmax(hlines, x, y, rad, 0, d2);
221 }
222 }
223
92bda63 - start of external Imager API access:
Tony Cook authored
224 /*
225 =item i_arc(im, x, y, rad, d1, d2, color)
226
227 =category Drawing
228 =synopsis i_arc(im, 50, 50, 20, 45, 135, &color);
229
230 Fills an arc centered at (x,y) with radius I<rad> covering the range
231 of angles in degrees from d1 to d2, with the color.
232
233 =cut
234 */
235
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
236 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
237 i_arc(i_img *im, i_img_dim x, i_img_dim y,double rad,double d1,double d2,const i_color *val) {
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
238 i_int_hlines hlines;
239
240 i_int_init_hlines_img(&hlines, im);
241
242 i_arc_hlines(&hlines, x, y, rad, d1, d2);
243
244 i_int_hlines_fill_color(im, &hlines, val);
245
246 i_int_hlines_destroy(&hlines);
247 }
248
92bda63 - start of external Imager API access:
Tony Cook authored
249 /*
250 =item i_arc_cfill(im, x, y, rad, d1, d2, fill)
251
252 =category Drawing
253 =synopsis i_arc_cfill(im, 50, 50, 35, 90, 135, fill);
254
255 Fills an arc centered at (x,y) with radius I<rad> covering the range
256 of angles in degrees from d1 to d2, with the fill object.
257
258 =cut
259 */
260
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
261 #define MIN_CIRCLE_STEPS 8
262 #define MAX_CIRCLE_STEPS 360
263
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
264 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
265 i_arc_cfill(i_img *im, i_img_dim x, i_img_dim y,double rad,double d1,double d2,i_fill_t *fill) {
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
266 i_int_hlines hlines;
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
267
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
268 i_int_init_hlines_img(&hlines, im);
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
269
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
270 i_arc_hlines(&hlines, x, y, rad, d1, d2);
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
271
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
272 i_int_hlines_fill_fill(im, &hlines, fill);
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
273
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
274 i_int_hlines_destroy(&hlines);
275 }
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
276
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
277 static void
278 arc_poly(int *count, double **xvals, double **yvals,
279 double x, double y, double rad, double d1, double d2) {
280 double d1_rad, d2_rad;
281 double circum;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
282 i_img_dim steps, point_count;
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
283 double angle_inc;
284
285 /* normalize the angles */
286 d1 = fmod(d1, 360);
287 if (d1 == 0) {
288 if (d2 >= 360) { /* default is 361 */
289 d2 = 360;
290 }
291 else {
292 d2 = fmod(d2, 360);
293 if (d2 < d1)
294 d2 += 360;
295 }
296 }
297 else {
298 d2 = fmod(d2, 360);
299 if (d2 < d1)
300 d2 += 360;
301 }
302 d1_rad = d1 * PI / 180;
303 d2_rad = d2 * PI / 180;
304
305 /* how many segments for the curved part?
306 we do a maximum of one per degree, with a minimum of 8/circle
307 we try to aim at having about one segment per 2 pixels
308 Work it out per circle to get a step size.
309
310 I was originally making steps = circum/2 but that looked horrible.
311
312 I think there might be an issue in the polygon filler.
313 */
314 circum = 2 * PI * rad;
315 steps = circum;
316 if (steps > MAX_CIRCLE_STEPS)
317 steps = MAX_CIRCLE_STEPS;
318 else if (steps < MIN_CIRCLE_STEPS)
319 steps = MIN_CIRCLE_STEPS;
320
321 angle_inc = 2 * PI / steps;
322
323 point_count = steps + 5; /* rough */
e310e5f - more memory allocation integer overflow auditing
Tony Cook authored
324 /* point_count is always relatively small, so allocation won't overflow */
325 *xvals = mymalloc(point_count * sizeof(double)); /* checked 17feb2005 tonyc */
326 *yvals = mymalloc(point_count * sizeof(double)); /* checked 17feb2005 tonyc */
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
327
328 /* from centre to edge at d1 */
329 (*xvals)[0] = x;
330 (*yvals)[0] = y;
331 (*xvals)[1] = x + rad * cos(d1_rad);
332 (*yvals)[1] = y + rad * sin(d1_rad);
333 *count = 2;
334
335 /* step around the curve */
336 while (d1_rad < d2_rad) {
337 (*xvals)[*count] = x + rad * cos(d1_rad);
338 (*yvals)[*count] = y + rad * sin(d1_rad);
339 ++*count;
340 d1_rad += angle_inc;
341 }
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
342
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
343 /* finish off the curve */
344 (*xvals)[*count] = x + rad * cos(d2_rad);
345 (*yvals)[*count] = y + rad * sin(d2_rad);
346 ++*count;
347 }
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
348
92bda63 - start of external Imager API access:
Tony Cook authored
349 /*
350 =item i_arc_aa(im, x, y, rad, d1, d2, color)
351
352 =category Drawing
353 =synopsis i_arc_aa(im, 50, 50, 35, 90, 135, &color);
354
5715f7c huge spelling update and spell checking patch
Tony Cook authored
355 Anti-alias fills an arc centered at (x,y) with radius I<rad> covering
92bda63 - start of external Imager API access:
Tony Cook authored
356 the range of angles in degrees from d1 to d2, with the color.
357
358 =cut
359 */
360
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
361 void
362 i_arc_aa(i_img *im, double x, double y, double rad, double d1, double d2,
97ac0a9 - constify the Imager API
Tony Cook authored
363 const i_color *val) {
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
364 double *xvals, *yvals;
365 int count;
366
6b8fe08 revert the offset for AA filled arcs
Tony Cook authored
367 arc_poly(&count, &xvals, &yvals, x, y, rad, d1, d2);
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
368
369 i_poly_aa(im, count, xvals, yvals, val);
370
371 myfree(xvals);
372 myfree(yvals);
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
373 }
374
92bda63 - start of external Imager API access:
Tony Cook authored
375 /*
376 =item i_arc_aa_cfill(im, x, y, rad, d1, d2, fill)
377
378 =category Drawing
379 =synopsis i_arc_aa_cfill(im, 50, 50, 35, 90, 135, fill);
380
5715f7c huge spelling update and spell checking patch
Tony Cook authored
381 Anti-alias fills an arc centered at (x,y) with radius I<rad> covering
92bda63 - start of external Imager API access:
Tony Cook authored
382 the range of angles in degrees from d1 to d2, with the fill object.
383
384 =cut
385 */
386
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
387 void
388 i_arc_aa_cfill(i_img *im, double x, double y, double rad, double d1, double d2,
389 i_fill_t *fill) {
390 double *xvals, *yvals;
391 int count;
392
393 arc_poly(&count, &xvals, &yvals, x, y, rad, d1, d2);
394
395 i_poly_aa_cfill(im, count, xvals, yvals, fill);
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
396
a8652ed - arc(..., fill=> ...) wasn't handling concave areas correctly
Tony Cook authored
397 myfree(xvals);
398 myfree(yvals);
399 }
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
400
401 /* Temporary AA HACK */
402
403
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
404 typedef i_img_dim frac;
405 static frac float_to_frac(double x) { return (frac)(0.5+x*16.0); }
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
406
407 static
408 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
409 polar_to_plane(double cx, double cy, float angle, double radius, frac *x, frac *y) {
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
410 *x = float_to_frac(cx+radius*cos(angle));
411 *y = float_to_frac(cy+radius*sin(angle));
412 }
413
414 static
415 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
416 make_minmax_list(i_mmarray *dot, double x, double y, double radius) {
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
417 float angle = 0.0;
418 float astep = radius>0.1 ? .5/radius : 10;
419 frac cx, cy, lx, ly, sx, sy;
420
421 mm_log((1, "make_minmax_list(dot %p, x %.2f, y %.2f, radius %.2f)\n", dot, x, y, radius));
422
423 polar_to_plane(x, y, angle, radius, &sx, &sy);
424
425 for(angle = 0.0; angle<361; angle +=astep) {
426 lx = sx; ly = sy;
427 polar_to_plane(x, y, angle, radius, &cx, &cy);
428 sx = cx; sy = cy;
429
430 if (fabs(cx-lx) > fabs(cy-ly)) {
431 int ccx, ccy;
432 if (lx>cx) {
433 ccx = lx; lx = cx; cx = ccx;
434 ccy = ly; ly = cy; cy = ccy;
435 }
436
437 for(ccx=lx; ccx<=cx; ccx++) {
438 ccy = ly + ((cy-ly)*(ccx-lx))/(cx-lx);
439 i_mmarray_add(dot, ccx, ccy);
440 }
441 } else {
442 int ccx, ccy;
443
444 if (ly>cy) {
445 ccy = ly; ly = cy; cy = ccy;
446 ccx = lx; lx = cx; cx = ccx;
447 }
448
449 for(ccy=ly; ccy<=cy; ccy++) {
450 if (cy-ly) ccx = lx + ((cx-lx)*(ccy-ly))/(cy-ly); else ccx = lx;
451 i_mmarray_add(dot, ccx, ccy);
452 }
453 }
454 }
455 }
456
457 /* Get the number of subpixels covered */
458
459 static
460 int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
461 i_pixel_coverage(i_mmarray *dot, i_img_dim x, i_img_dim y) {
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
462 frac minx = x*16;
463 frac maxx = minx+15;
464 frac cy;
465 int cnt = 0;
466
467 for(cy=y*16; cy<(y+1)*16; cy++) {
468 frac tmin = dot->data[cy].min;
469 frac tmax = dot->data[cy].max;
470
471 if (tmax == -1 || tmin > maxx || tmax < minx) continue;
472
473 if (tmin < minx) tmin = minx;
474 if (tmax > maxx) tmax = maxx;
475
476 cnt+=1+tmax-tmin;
477 }
478 return cnt;
479 }
480
92bda63 - start of external Imager API access:
Tony Cook authored
481 /*
482 =item i_circle_aa(im, x, y, rad, color)
483
484 =category Drawing
485 =synopsis i_circle_aa(im, 50, 50, 45, &color);
486
5715f7c huge spelling update and spell checking patch
Tony Cook authored
487 Anti-alias fills a circle centered at (x,y) for radius I<rad> with
92bda63 - start of external Imager API access:
Tony Cook authored
488 color.
489
490 =cut
491 */
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
492 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
493 i_circle_aa(i_img *im, double x, double y, double rad, const i_color *val) {
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
494 i_mmarray dot;
495 i_color temp;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
496 i_img_dim ly;
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
497
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
498 mm_log((1, "i_circle_aa(im %p, centre(" i_DFp "), rad %.2f, val %p)\n",
499 im, i_DFcp(x, y), rad, val));
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
500
501 i_mmarray_cr(&dot,16*im->ysize);
502 make_minmax_list(&dot, x, y, rad);
503
504 for(ly = 0; ly<im->ysize; ly++) {
a659442 - eliminate unused variables and static functions
Tony Cook authored
505 int ix, cy, minx = INT_MAX, maxx = INT_MIN;
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
506
507 /* Find the left/rightmost set subpixels */
508 for(cy = 0; cy<16; cy++) {
509 frac tmin = dot.data[ly*16+cy].min;
510 frac tmax = dot.data[ly*16+cy].max;
511 if (tmax == -1) continue;
512
513 if (minx > tmin) minx = tmin;
514 if (maxx < tmax) maxx = tmax;
515 }
516
517 if (maxx == INT_MIN) continue; /* no work to be done for this row of pixels */
518
519 minx /= 16;
520 maxx /= 16;
521 for(ix=minx; ix<=maxx; ix++) {
522 int cnt = i_pixel_coverage(&dot, ix, ly);
523 if (cnt>255) cnt = 255;
524 if (cnt) { /* should never be true */
525 int ch;
526 float ratio = (float)cnt/255.0;
527 i_gpix(im, ix, ly, &temp);
528 for(ch=0;ch<im->channels; ch++) temp.channel[ch] = (unsigned char)((float)val->channel[ch]*ratio + (float)temp.channel[ch]*(1.0-ratio));
529 i_ppix(im, ix, ly, &temp);
530 }
531 }
532 }
4b19f77 Added Destroy method for Imager::Font::TT and moved to that package name
Arnar Mar Hrafnkelsson authored
533 i_mmarray_dst(&dot);
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
534 }
535
92bda63 - start of external Imager API access:
Tony Cook authored
536 /*
40068b3 merge circle outline branch
Tony Cook authored
537 =item i_circle_out(im, x, y, r, col)
538
539 =category Drawing
540 =synopsis i_circle_out(im, 50, 50, 45, &color);
541
542 Draw a circle outline centered at (x,y) with radius r,
543 non-anti-aliased.
544
545 Parameters:
546
547 =over
548
549 =item *
550
551 (x, y) - the center of the circle
552
553 =item *
554
555 r - the radius of the circle in pixels, must be non-negative
556
557 =back
558
559 Returns non-zero on success.
560
561 Implementation:
562
563 =cut
564 */
565
566 int
567 i_circle_out(i_img *im, i_img_dim xc, i_img_dim yc, i_img_dim r,
568 const i_color *col) {
569 i_img_dim x, y;
570 i_img_dim dx, dy;
571 int error;
572
573 i_clear_error();
574
575 if (r < 0) {
576 i_push_error(0, "circle: radius must be non-negative");
577 return 0;
578 }
579
580 i_ppix(im, xc+r, yc, col);
581 i_ppix(im, xc-r, yc, col);
582 i_ppix(im, xc, yc+r, col);
583 i_ppix(im, xc, yc-r, col);
584
585 x = 0;
586 y = r;
587 dx = 1;
588 dy = -2 * r;
589 error = 1 - r;
590 while (x < y) {
591 if (error >= 0) {
592 --y;
593 dy += 2;
594 error += dy;
595 }
596 ++x;
597 dx += 2;
598 error += dx;
599
600 i_ppix(im, xc + x, yc + y, col);
601 i_ppix(im, xc + x, yc - y, col);
602 i_ppix(im, xc - x, yc + y, col);
603 i_ppix(im, xc - x, yc - y, col);
604 if (x != y) {
605 i_ppix(im, xc + y, yc + x, col);
606 i_ppix(im, xc + y, yc - x, col);
607 i_ppix(im, xc - y, yc + x, col);
608 i_ppix(im, xc - y, yc - x, col);
609 }
610 }
611
612 return 1;
613 }
614
615 /*
616 =item arc_seg(angle)
617
618 Convert an angle in degrees into an angle measure we can generate
619 simply from the numbers we have when drawing the circle.
620
621 =back
622 */
623
624 static i_img_dim
625 arc_seg(double angle, int scale) {
626 i_img_dim seg = (angle + 45) / 90;
627 double remains = angle - seg * 90; /* should be in the range [-45,45] */
628
629 while (seg > 4)
630 seg -= 4;
631 if (seg == 4 && remains > 0)
632 seg = 0;
633
634 return scale * (seg * 2 + sin(remains * PI/180));
635 }
636
637 /*
638 =item i_arc_out(im, x, y, r, d1, d2, col)
639
640 =category Drawing
641 =synopsis i_arc_out(im, 50, 50, 45, 45, 135, &color);
642
643 Draw an arc outline centered at (x,y) with radius r, non-anti-aliased
644 over the angle range d1 through d2 degrees.
645
646 Parameters:
647
648 =over
649
650 =item *
651
652 (x, y) - the center of the circle
653
654 =item *
655
656 r - the radius of the circle in pixels, must be non-negative
657
658 =item *
659
660 d1, d2 - the range of angles to draw the arc over, in degrees.
661
662 =back
663
664 Returns non-zero on success.
665
666 Implementation:
667
668 =cut
669 */
670
671 int
672 i_arc_out(i_img *im, i_img_dim xc, i_img_dim yc, i_img_dim r,
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
673 double d1, double d2, const i_color *col) {
40068b3 merge circle outline branch
Tony Cook authored
674 i_img_dim x, y;
675 i_img_dim dx, dy;
676 int error;
677 i_img_dim segs[2][2];
678 int seg_count;
679 i_img_dim sin_th;
680 i_img_dim seg_d1, seg_d2;
681 int seg_num;
682 i_img_dim scale = r + 1;
683 i_img_dim seg1 = scale * 2;
684 i_img_dim seg2 = scale * 4;
685 i_img_dim seg3 = scale * 6;
686 i_img_dim seg4 = scale * 8;
687
688 i_clear_error();
689
690 if (r <= 0) {
691 i_push_error(0, "arc: radius must be non-negative");
692 return 0;
693 }
694 if (d1 + 360 <= d2)
695 return i_circle_out(im, xc, yc, r, col);
696
697 if (d1 < 0)
698 d1 += 360 * floor((-d1 + 359) / 360);
699 if (d2 < 0)
700 d2 += 360 * floor((-d2 + 359) / 360);
701 d1 = fmod(d1, 360);
702 d2 = fmod(d2, 360);
703 seg_d1 = arc_seg(d1, scale);
704 seg_d2 = arc_seg(d2, scale);
705 if (seg_d2 < seg_d1) {
706 /* split into two segments */
707 segs[0][0] = 0;
708 segs[0][1] = seg_d2;
709 segs[1][0] = seg_d1;
710 segs[1][1] = seg4;
711 seg_count = 2;
712 }
713 else {
714 segs[0][0] = seg_d1;
715 segs[0][1] = seg_d2;
716 seg_count = 1;
717 }
718
719 for (seg_num = 0; seg_num < seg_count; ++seg_num) {
720 i_img_dim seg_start = segs[seg_num][0];
721 i_img_dim seg_end = segs[seg_num][1];
722 if (seg_start == 0)
723 i_ppix(im, xc+r, yc, col);
724 if (seg_start <= seg1 && seg_end >= seg1)
725 i_ppix(im, xc, yc+r, col);
726 if (seg_start <= seg2 && seg_end >= seg2)
727 i_ppix(im, xc-r, yc, col);
728 if (seg_start <= seg3 && seg_end >= seg3)
729 i_ppix(im, xc, yc-r, col);
730
731 y = 0;
732 x = r;
733 dy = 1;
734 dx = -2 * r;
735 error = 1 - r;
736 while (y < x) {
737 if (error >= 0) {
738 --x;
739 dx += 2;
740 error += dx;
741 }
742 ++y;
743 dy += 2;
744 error += dy;
745
746 sin_th = y;
747 if (seg_start <= sin_th && seg_end >= sin_th)
748 i_ppix(im, xc + x, yc + y, col);
749 if (seg_start <= seg1 - sin_th && seg_end >= seg1 - sin_th)
750 i_ppix(im, xc + y, yc + x, col);
751
752 if (seg_start <= seg1 + sin_th && seg_end >= seg1 + sin_th)
753 i_ppix(im, xc - y, yc + x, col);
754 if (seg_start <= seg2 - sin_th && seg_end >= seg2 - sin_th)
755 i_ppix(im, xc - x, yc + y, col);
756
757 if (seg_start <= seg2 + sin_th && seg_end >= seg2 + sin_th)
758 i_ppix(im, xc - x, yc - y, col);
759 if (seg_start <= seg3 - sin_th && seg_end >= seg3 - sin_th)
760 i_ppix(im, xc - y, yc - x, col);
761
762 if (seg_start <= seg3 + sin_th && seg_end >= seg3 + sin_th)
763 i_ppix(im, xc + y, yc - x, col);
764 if (seg_start <= seg4 - sin_th && seg_end >= seg4 - sin_th)
765 i_ppix(im, xc + x, yc - y, col);
766 }
767 }
768
769 return 1;
770 }
771
772 static double
773 cover(i_img_dim r, i_img_dim j) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
774 double rjsqrt = sqrt(r*r - j*j);
40068b3 merge circle outline branch
Tony Cook authored
775
776 return ceil(rjsqrt) - rjsqrt;
777 }
778
779 /*
780 =item i_circle_out_aa(im, xc, yc, r, col)
781
782 =synopsis i_circle_out_aa(im, 50, 50, 45, &color);
783
784 Draw a circle outline centered at (x,y) with radius r, anti-aliased.
785
786 Parameters:
787
788 =over
789
790 =item *
791
792 (xc, yc) - the center of the circle
793
794 =item *
795
796 r - the radius of the circle in pixels, must be non-negative
797
798 =item *
799
800 col - an i_color for the color to draw in.
801
802 =back
803
804 Returns non-zero on success.
805
806 =cut
807
808 Based on "Fast Anti-Aliased Circle Generation", Xiaolin Wu, Graphics
809 Gems.
810
811 I use floating point for I<D> since for large circles the precision of
812 a [0,255] value isn't sufficient when approaching the end of the
813 octant.
814
815 */
816
817 int
818 i_circle_out_aa(i_img *im, i_img_dim xc, i_img_dim yc, i_img_dim r, const i_color *col) {
819 i_img_dim i, j;
820 double t;
821 i_color workc = *col;
822 int orig_alpha = col->channel[3];
823
824 i_clear_error();
825 if (r <= 0) {
826 i_push_error(0, "arc: radius must be non-negative");
827 return 0;
828 }
829 i = r;
830 j = 0;
831 t = 0;
832 i_ppix_norm(im, xc+i, yc+j, col);
833 i_ppix_norm(im, xc-i, yc+j, col);
834 i_ppix_norm(im, xc+j, yc+i, col);
835 i_ppix_norm(im, xc+j, yc-i, col);
836
837 while (i > j+1) {
838 double d;
839 int cv, inv_cv;
840 j++;
841 d = cover(r, j);
842 cv = (int)(d * 255 + 0.5);
843 inv_cv = 255-cv;
844 if (d < t) {
845 --i;
846 }
847 if (inv_cv) {
848 workc.channel[3] = orig_alpha * inv_cv / 255;
849 i_ppix_norm(im, xc+i, yc+j, &workc);
850 i_ppix_norm(im, xc-i, yc+j, &workc);
851 i_ppix_norm(im, xc+i, yc-j, &workc);
852 i_ppix_norm(im, xc-i, yc-j, &workc);
853
854 if (i != j) {
855 i_ppix_norm(im, xc+j, yc+i, &workc);
856 i_ppix_norm(im, xc-j, yc+i, &workc);
857 i_ppix_norm(im, xc+j, yc-i, &workc);
858 i_ppix_norm(im, xc-j, yc-i, &workc);
859 }
860 }
861 if (cv && i > j) {
862 workc.channel[3] = orig_alpha * cv / 255;
863 i_ppix_norm(im, xc+i-1, yc+j, &workc);
864 i_ppix_norm(im, xc-i+1, yc+j, &workc);
865 i_ppix_norm(im, xc+i-1, yc-j, &workc);
866 i_ppix_norm(im, xc-i+1, yc-j, &workc);
867
868 if (j != i-1) {
869 i_ppix_norm(im, xc+j, yc+i-1, &workc);
870 i_ppix_norm(im, xc-j, yc+i-1, &workc);
871 i_ppix_norm(im, xc+j, yc-i+1, &workc);
872 i_ppix_norm(im, xc-j, yc-i+1, &workc);
873 }
874 }
875 t = d;
876 }
877
878 return 1;
879 }
880
881 /*
882 =item i_arc_out_aa(im, xc, yc, r, d1, d2, col)
883
884 =synopsis i_arc_out_aa(im, 50, 50, 45, 45, 125, &color);
885
886 Draw a circle arc outline centered at (x,y) with radius r, from angle
887 d1 degrees through angle d2 degrees, anti-aliased.
888
889 Parameters:
890
891 =over
892
893 =item *
894
895 (xc, yc) - the center of the circle
896
897 =item *
898
899 r - the radius of the circle in pixels, must be non-negative
900
901 =item *
902
903 d1, d2 - the range of angle in degrees to draw the arc through. If
904 d2-d1 >= 360 a full circle is drawn.
905
906 =back
907
908 Returns non-zero on success.
909
910 =cut
911
912 Based on "Fast Anti-Aliased Circle Generation", Xiaolin Wu, Graphics
913 Gems.
914
915 */
916
917 int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
918 i_arc_out_aa(i_img *im, i_img_dim xc, i_img_dim yc, i_img_dim r, double d1, double d2, const i_color *col) {
40068b3 merge circle outline branch
Tony Cook authored
919 i_img_dim i, j;
920 double t;
921 i_color workc = *col;
922 i_img_dim segs[2][2];
923 int seg_count;
924 i_img_dim sin_th;
925 i_img_dim seg_d1, seg_d2;
926 int seg_num;
927 int orig_alpha = col->channel[3];
928 i_img_dim scale = r + 1;
929 i_img_dim seg1 = scale * 2;
930 i_img_dim seg2 = scale * 4;
931 i_img_dim seg3 = scale * 6;
932 i_img_dim seg4 = scale * 8;
933
934 i_clear_error();
935 if (r <= 0) {
936 i_push_error(0, "arc: radius must be non-negative");
937 return 0;
938 }
939 if (d1 + 360 <= d2)
940 return i_circle_out_aa(im, xc, yc, r, col);
941
942 if (d1 < 0)
943 d1 += 360 * floor((-d1 + 359) / 360);
944 if (d2 < 0)
945 d2 += 360 * floor((-d2 + 359) / 360);
946 d1 = fmod(d1, 360);
947 d2 = fmod(d2, 360);
948 seg_d1 = arc_seg(d1, scale);
949 seg_d2 = arc_seg(d2, scale);
950 if (seg_d2 < seg_d1) {
951 /* split into two segments */
952 segs[0][0] = 0;
953 segs[0][1] = seg_d2;
954 segs[1][0] = seg_d1;
955 segs[1][1] = seg4;
956 seg_count = 2;
957 }
958 else {
959 segs[0][0] = seg_d1;
960 segs[0][1] = seg_d2;
961 seg_count = 1;
962 }
963
964 for (seg_num = 0; seg_num < seg_count; ++seg_num) {
965 i_img_dim seg_start = segs[seg_num][0];
966 i_img_dim seg_end = segs[seg_num][1];
967
968 i = r;
969 j = 0;
970 t = 0;
971
972 if (seg_start == 0)
973 i_ppix_norm(im, xc+i, yc+j, col);
974 if (seg_start <= seg1 && seg_end >= seg1)
975 i_ppix_norm(im, xc+j, yc+i, col);
976 if (seg_start <= seg2 && seg_end >= seg2)
977 i_ppix_norm(im, xc-i, yc+j, col);
978 if (seg_start <= seg3 && seg_end >= seg3)
979 i_ppix_norm(im, xc+j, yc-i, col);
980
981 while (i > j+1) {
982 int cv, inv_cv;
983 double d;
984 j++;
985 d = cover(r, j);
986 cv = (int)(d * 255 + 0.5);
987 inv_cv = 255-cv;
988 if (d < t) {
989 --i;
990 }
991 sin_th = j;
992 if (inv_cv) {
993 workc.channel[3] = orig_alpha * inv_cv / 255;
994
995 if (seg_start <= sin_th && seg_end >= sin_th)
996 i_ppix_norm(im, xc+i, yc+j, &workc);
997 if (seg_start <= seg2 - sin_th && seg_end >= seg2 - sin_th)
998 i_ppix_norm(im, xc-i, yc+j, &workc);
999 if (seg_start <= seg4 - sin_th && seg_end >= seg4 - sin_th)
1000 i_ppix_norm(im, xc+i, yc-j, &workc);
1001 if (seg_start <= seg2 + sin_th && seg_end >= seg2 + sin_th)
1002 i_ppix_norm(im, xc-i, yc-j, &workc);
1003
1004 if (i != j) {
1005 if (seg_start <= seg1 - sin_th && seg_end >= seg1 - sin_th)
1006 i_ppix_norm(im, xc+j, yc+i, &workc);
1007 if (seg_start <= seg1 + sin_th && seg_end >= seg1 + sin_th)
1008 i_ppix_norm(im, xc-j, yc+i, &workc);
1009 if (seg_start <= seg3 + sin_th && seg_end >= seg3 + sin_th)
1010 i_ppix_norm(im, xc+j, yc-i, &workc);
1011 if (seg_start <= seg3 - sin_th && seg_end >= seg3 - sin_th)
1012 i_ppix_norm(im, xc-j, yc-i, &workc);
1013 }
1014 }
1015 if (cv && i > j) {
1016 workc.channel[3] = orig_alpha * cv / 255;
1017 if (seg_start <= sin_th && seg_end >= sin_th)
1018 i_ppix_norm(im, xc+i-1, yc+j, &workc);
1019 if (seg_start <= seg2 - sin_th && seg_end >= seg2 - sin_th)
1020 i_ppix_norm(im, xc-i+1, yc+j, &workc);
1021 if (seg_start <= seg4 - sin_th && seg_end >= seg4 - sin_th)
1022 i_ppix_norm(im, xc+i-1, yc-j, &workc);
1023 if (seg_start <= seg2 + sin_th && seg_end >= seg2 + sin_th)
1024 i_ppix_norm(im, xc-i+1, yc-j, &workc);
1025
1026 if (seg_start <= seg1 - sin_th && seg_end >= seg1 - sin_th)
1027 i_ppix_norm(im, xc+j, yc+i-1, &workc);
1028 if (seg_start <= seg1 + sin_th && seg_end >= seg1 + sin_th)
1029 i_ppix_norm(im, xc-j, yc+i-1, &workc);
1030 if (seg_start <= seg3 + sin_th && seg_end >= seg3 + sin_th)
1031 i_ppix_norm(im, xc+j, yc-i+1, &workc);
1032 if (seg_start <= seg3 - sin_th && seg_end >= seg3 - sin_th)
1033 i_ppix_norm(im, xc-j, yc-i+1, &workc);
1034 }
1035 t = d;
1036 }
1037 }
1038
1039 return 1;
1040 }
1041
1042 /*
92bda63 - start of external Imager API access:
Tony Cook authored
1043 =item i_box(im, x1, y1, x2, y2, color)
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
1044
92bda63 - start of external Imager API access:
Tony Cook authored
1045 =category Drawing
1046 =synopsis i_box(im, 0, 0, im->xsize-1, im->ysize-1, &color).
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
1047
92bda63 - start of external Imager API access:
Tony Cook authored
1048 Outlines the box from (x1,y1) to (x2,y2) inclusive with I<color>.
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
1049
92bda63 - start of external Imager API access:
Tony Cook authored
1050 =cut
1051 */
6af18d2 Added a temporary circle antialiasing routine.
Arnar Mar Hrafnkelsson authored
1052
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1053 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1054 i_box(i_img *im,i_img_dim x1,i_img_dim y1,i_img_dim x2,i_img_dim y2,const i_color *val) {
1055 i_img_dim x,y;
1056 mm_log((1,"i_box(im* %p, p1(" i_DFp "), p2(" i_DFp "),val %p)\n",
1057 im, i_DFcp(x1,y1), i_DFcp(x2,y2), val));
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1058 for(x=x1;x<x2+1;x++) {
1059 i_ppix(im,x,y1,val);
1060 i_ppix(im,x,y2,val);
1061 }
1062 for(y=y1;y<y2+1;y++) {
1063 i_ppix(im,x1,y,val);
1064 i_ppix(im,x2,y,val);
1065 }
1066 }
1067
92bda63 - start of external Imager API access:
Tony Cook authored
1068 /*
1069 =item i_box_filled(im, x1, y1, x2, y2, color)
1070
1071 =category Drawing
1072 =synopsis i_box_filled(im, 0, 0, im->xsize-1, im->ysize-1, &color);
1073
1074 Fills the box from (x1,y1) to (x2,y2) inclusive with color.
1075
1076 =cut
1077 */
1078
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1079 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1080 i_box_filled(i_img *im,i_img_dim x1,i_img_dim y1,i_img_dim x2,i_img_dim y2, const i_color *val) {
3b00058 optimize filled box drawing
Tony Cook authored
1081 i_img_dim x, y, width;
1082 i_palidx index;
1083
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1084 mm_log((1,"i_box_filled(im* %p, p1(" i_DFp "), p2(" i_DFp "),val %p)\n",
1085 im, i_DFcp(x1, y1), i_DFcp(x2,y2) ,val));
3b00058 optimize filled box drawing
Tony Cook authored
1086
1087 if (x1 > x2 || y1 > y2
1088 || x2 < 0 || y2 < 0
1089 || x1 >= im->xsize || y1 > im->ysize)
1090 return;
1091
1092 if (x1 < 0)
1093 x1 = 0;
1094 if (x2 >= im->xsize)
1095 x2 = im->xsize - 1;
1096 if (y1 < 0)
1097 y1 = 0;
1098 if (y2 >= im->ysize)
1099 y2 = im->ysize - 1;
1100
1101 width = x2 - x1 + 1;
1102
1103 if (im->type == i_palette_type
1104 && i_findcolor(im, val, &index)) {
1105 i_palidx *line = mymalloc(sizeof(i_palidx) * width);
1106
1107 for (x = 0; x < width; ++x)
1108 line[x] = index;
1109
1110 for (y = y1; y <= y2; ++y)
1111 i_ppal(im, x1, x2+1, y, line);
1112
1113 myfree(line);
1114 }
1115 else {
1116 i_color *line = mymalloc(sizeof(i_color) * width);
1117
1118 for (x = 0; x < width; ++x)
1119 line[x] = *val;
1120
1121 for (y = y1; y <= y2; ++y)
1122 i_plin(im, x1, x2+1, y, line);
1123
1124 myfree(line);
1125 }
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1126 }
1127
92bda63 - start of external Imager API access:
Tony Cook authored
1128 /*
7477ff1 @tonycoz allow box() to accept floating colors for filling areas
authored
1129 =item i_box_filledf(im, x1, y1, x2, y2, color)
1130
1131 =category Drawing
1132 =synopsis i_box_filledf(im, 0, 0, im->xsize-1, im->ysize-1, &fcolor);
1133
1134 Fills the box from (x1,y1) to (x2,y2) inclusive with a floating point
1135 color.
1136
1137 =cut
1138 */
1139
1140 int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1141 i_box_filledf(i_img *im,i_img_dim x1,i_img_dim y1,i_img_dim x2,i_img_dim y2, const i_fcolor *val) {
7477ff1 @tonycoz allow box() to accept floating colors for filling areas
authored
1142 i_img_dim x, y, width;
1143
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1144 mm_log((1,"i_box_filledf(im* %p, p1(" i_DFp "), p2(" i_DFp "),val %p)\n",
1145 im, i_DFcp(x1, y1), i_DFcp(x2, y2), val));
7477ff1 @tonycoz allow box() to accept floating colors for filling areas
authored
1146
1147 if (x1 > x2 || y1 > y2
1148 || x2 < 0 || y2 < 0
1149 || x1 >= im->xsize || y1 > im->ysize)
1150 return 0;
1151
1152 if (x1 < 0)
1153 x1 = 0;
1154 if (x2 >= im->xsize)
1155 x2 = im->xsize - 1;
1156 if (y1 < 0)
1157 y1 = 0;
1158 if (y2 >= im->ysize)
1159 y2 = im->ysize - 1;
1160
1161 width = x2 - x1 + 1;
1162
1163 if (im->bits <= 8) {
1164 i_color c;
1165 c.rgba.r = SampleFTo8(val->rgba.r);
1166 c.rgba.g = SampleFTo8(val->rgba.g);
1167 c.rgba.b = SampleFTo8(val->rgba.b);
1168 c.rgba.a = SampleFTo8(val->rgba.a);
1169
1170 i_box_filled(im, x1, y1, x2, y2, &c);
1171 }
1172 else {
1173 i_fcolor *line = mymalloc(sizeof(i_fcolor) * width);
1174
1175 for (x = 0; x < width; ++x)
1176 line[x] = *val;
1177
1178 for (y = y1; y <= y2; ++y)
1179 i_plinf(im, x1, x2+1, y, line);
1180
1181 myfree(line);
1182 }
1183
1184 return 1;
1185 }
1186
1187 /*
92bda63 - start of external Imager API access:
Tony Cook authored
1188 =item i_box_cfill(im, x1, y1, x2, y2, fill)
1189
1190 =category Drawing
1191 =synopsis i_box_cfill(im, 0, 0, im->xsize-1, im->ysize-1, fill);
1192
1193 Fills the box from (x1,y1) to (x2,y2) inclusive with fill.
1194
1195 =cut
1196 */
1197
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
1198 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1199 i_box_cfill(i_img *im,i_img_dim x1,i_img_dim y1,i_img_dim x2,i_img_dim y2,i_fill_t *fill) {
9b1ec2b commit changes from draw branch
Tony Cook authored
1200 i_render r;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1201
1202 mm_log((1,"i_box_cfill(im* %p, p1(" i_DFp "), p2(" i_DFp "), fill %p)\n",
1203 im, i_DFcp(x1, y1), i_DFcp(x2,y2), fill));
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
1204
1205 ++x2;
f0960b1 - added integer overflow checks to many memory allocation calls
Tony Cook authored
1206 if (x1 < 0)
1207 x1 = 0;
1208 if (y1 < 0)
1209 y1 = 0;
1210 if (x2 > im->xsize)
1211 x2 = im->xsize;
1212 if (y2 >= im->ysize)
1213 y2 = im->ysize-1;
1214 if (x1 >= x2 || y1 > y2)
1215 return;
9b1ec2b commit changes from draw branch
Tony Cook authored
1216
1217 i_render_init(&r, im, x2-x1);
1218 while (y1 <= y2) {
1219 i_render_fill(&r, x1, y1, x2-x1, NULL, fill);
1220 ++y1;
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
1221 }
9b1ec2b commit changes from draw branch
Tony Cook authored
1222 i_render_done(&r);
f1ac502 support for generic fills for box and arc, with solid, hatched
Tony Cook authored
1223 }
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1224
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1225 /*
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1226 =item i_line(C<im>, C<x1>, C<y1>, C<x2>, C<y2>, C<color>, C<endp>)
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1227
92bda63 - start of external Imager API access:
Tony Cook authored
1228 =category Drawing
1229
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1230 =for stopwords Bresenham's
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1231
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1232 Draw a line to image using Bresenham's line drawing algorithm
1233
1234 im - image to draw to
1235 x1 - starting x coordinate
1236 y1 - starting x coordinate
1237 x2 - starting x coordinate
1238 y2 - starting x coordinate
1239 color - color to write to image
1240 endp - endpoint flag (boolean)
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1241
1242 =cut
1243 */
1244
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1245 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1246 i_line(i_img *im, i_img_dim x1, i_img_dim y1, i_img_dim x2, i_img_dim y2, const i_color *val, int endp) {
1247 i_img_dim x, y;
1248 i_img_dim dx, dy;
1249 i_img_dim p;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1250
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1251 dx = x2 - x1;
1252 dy = y2 - y1;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1253
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1254
1255 /* choose variable to iterate on */
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1256 if (i_abs(dx) > i_abs(dy)) {
1257 i_img_dim dx2, dy2, cpy;
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1258
1259 /* sort by x */
1260 if (x1 > x2) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1261 i_img_dim t;
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1262 t = x1; x1 = x2; x2 = t;
1263 t = y1; y1 = y2; y2 = t;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1264 }
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1265
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1266 dx = i_abs(dx);
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1267 dx2 = dx*2;
1268 dy = y2 - y1;
1269
1270 if (dy<0) {
1271 dy = -dy;
1272 cpy = -1;
1273 } else {
1274 cpy = 1;
1275 }
1276 dy2 = dy*2;
1277 p = dy2 - dx;
1278
1279
1280 y = y1;
1281 for(x=x1; x<x2-1; x++) {
1282 if (p<0) {
1283 p += dy2;
1284 } else {
1285 y += cpy;
1286 p += dy2-dx2;
1287 }
1288 i_ppix(im, x+1, y, val);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1289 }
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1290 } else {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1291 i_img_dim dy2, dx2, cpx;
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1292
1293 /* sort bx y */
1294 if (y1 > y2) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1295 i_img_dim t;
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1296 t = x1; x1 = x2; x2 = t;
1297 t = y1; y1 = y2; y2 = t;
1298 }
1299
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1300 dy = i_abs(dy);
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1301 dx = x2 - x1;
1302 dy2 = dy*2;
1303
1304 if (dx<0) {
1305 dx = -dx;
1306 cpx = -1;
1307 } else {
1308 cpx = 1;
1309 }
1310 dx2 = dx*2;
1311 p = dx2 - dy;
1312
1313 x = x1;
1314
1315 for(y=y1; y<y2-1; y++) {
1316 if (p<0) {
1317 p += dx2;
1318 } else {
1319 x += cpx;
1320 p += dx2-dy2;
1321 }
1322 i_ppix(im, x, y+1, val);
1323 }
1324 }
1325 if (endp) {
1326 i_ppix(im, x1, y1, val);
1327 i_ppix(im, x2, y2, val);
1328 } else {
1329 if (x1 != x2 || y1 != y2)
1330 i_ppix(im, x1, y1, val);
1331 }
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1332 }
1333
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1334
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1335 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1336 i_line_dda(i_img *im, i_img_dim x1, i_img_dim y1, i_img_dim x2, i_img_dim y2, i_color *val) {
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1337
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1338 double dy;
1339 i_img_dim x;
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1340
1341 for(x=x1; x<=x2; x++) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1342 dy = y1+ (x-x1)/(double)(x2-x1)*(y2-y1);
1343 i_ppix(im, x, (i_img_dim)(dy+0.5), val);
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1344 }
1345 }
1346
92bda63 - start of external Imager API access:
Tony Cook authored
1347 /*
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1348 =item i_line_aa(C<im>, C<x1>, C<x2>, C<y1>, C<y2>, C<color>, C<endp>)
92bda63 - start of external Imager API access:
Tony Cook authored
1349
1350 =category Drawing
1351
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1352 Anti-alias draws a line from (x1,y1) to (x2, y2) in color.
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1353
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1354 The point (x2, y2) is drawn only if C<endp> is set.
92bda63 - start of external Imager API access:
Tony Cook authored
1355
1356 =cut
1357 */
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1358
1359 void
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1360 i_line_aa(i_img *im, i_img_dim x1, i_img_dim y1, i_img_dim x2, i_img_dim y2, const i_color *val, int endp) {
1361 i_img_dim x, y;
1362 i_img_dim dx, dy;
1363 i_img_dim p;
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1364
1365 dx = x2 - x1;
1366 dy = y2 - y1;
1367
1368 /* choose variable to iterate on */
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1369 if (i_abs(dx) > i_abs(dy)) {
1370 i_img_dim dx2, dy2, cpy;
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1371
1372 /* sort by x */
1373 if (x1 > x2) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1374 i_img_dim t;
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1375 t = x1; x1 = x2; x2 = t;
1376 t = y1; y1 = y2; y2 = t;
1377 }
1378
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1379 dx = i_abs(dx);
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1380 dx2 = dx*2;
1381 dy = y2 - y1;
1382
1383 if (dy<0) {
1384 dy = -dy;
1385 cpy = -1;
1386 } else {
1387 cpy = 1;
1388 }
1389 dy2 = dy*2;
1390 p = dy2 - dx2; /* this has to be like this for AA */
1391
1392 y = y1;
1393
1394 for(x=x1; x<x2-1; x++) {
1395 int ch;
1396 i_color tval;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1397 double t = (dy) ? -(float)(p)/(float)(dx2) : 1;
1398 double t1, t2;
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1399
1400 if (t<0) t = 0;
1401 t1 = 1-t;
1402 t2 = t;
1403
1404 i_gpix(im,x+1,y,&tval);
1405 for(ch=0;ch<im->channels;ch++)
1406 tval.channel[ch]=(unsigned char)(t1*(float)tval.channel[ch]+t2*(float)val->channel[ch]);
1407 i_ppix(im,x+1,y,&tval);
1408
1409 i_gpix(im,x+1,y+cpy,&tval);
1410 for(ch=0;ch<im->channels;ch++)
1411 tval.channel[ch]=(unsigned char)(t2*(float)tval.channel[ch]+t1*(float)val->channel[ch]);
1412 i_ppix(im,x+1,y+cpy,&tval);
1413
1414 if (p<0) {
1415 p += dy2;
1416 } else {
1417 y += cpy;
1418 p += dy2-dx2;
1419 }
1420 }
1421 } else {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1422 i_img_dim dy2, dx2, cpx;
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1423
1424 /* sort bx y */
1425 if (y1 > y2) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1426 i_img_dim t;
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1427 t = x1; x1 = x2; x2 = t;
1428 t = y1; y1 = y2; y2 = t;
1429 }
1430
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1431 dy = i_abs(dy);
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1432 dx = x2 - x1;
1433 dy2 = dy*2;
1434
1435 if (dx<0) {
1436 dx = -dx;
1437 cpx = -1;
1438 } else {
1439 cpx = 1;
1440 }
1441 dx2 = dx*2;
1442 p = dx2 - dy2; /* this has to be like this for AA */
1443
1444 x = x1;
1445
1446 for(y=y1; y<y2-1; y++) {
1447 int ch;
1448 i_color tval;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1449 double t = (dx) ? -(double)(p)/(double)(dy2) : 1;
1450 double t1, t2;
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1451
1452 if (t<0) t = 0;
1453 t1 = 1-t;
1454 t2 = t;
1455
1456 i_gpix(im,x,y+1,&tval);
1457 for(ch=0;ch<im->channels;ch++)
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1458 tval.channel[ch]=(unsigned char)(t1*(double)tval.channel[ch]+t2*(double)val->channel[ch]);
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1459 i_ppix(im,x,y+1,&tval);
1460
1461 i_gpix(im,x+cpx,y+1,&tval);
1462 for(ch=0;ch<im->channels;ch++)
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1463 tval.channel[ch]=(unsigned char)(t2*(double)tval.channel[ch]+t1*(double)val->channel[ch]);
b437ce0 Modified i_line_aa to use a modified bresenham algorithm. This method
Arnar Mar Hrafnkelsson authored
1464 i_ppix(im,x+cpx,y+1,&tval);
1465
1466 if (p<0) {
1467 p += dx2;
1468 } else {
1469 x += cpx;
1470 p += dx2-dy2;
1471 }
1472 }
1473 }
1474
1475
1476 if (endp) {
1477 i_ppix(im, x1, y1, val);
1478 i_ppix(im, x2, y2, val);
1479 } else {
1480 if (x1 != x2 || y1 != y2)
1481 i_ppix(im, x1, y1, val);
1482 }
1483 }
1484
1485
1486
b33c08f hide or rename any symbols that are likely to conflict with other
Tony Cook authored
1487 static double
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1488 perm(i_img_dim n,i_img_dim k) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1489 double r;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1490 i_img_dim i;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1491 r=1;
1492 for(i=k+1;i<=n;i++) r*=i;
1493 for(i=1;i<=(n-k);i++) r/=i;
1494 return r;
1495 }
1496
1497
1498 /* Note in calculating t^k*(1-t)^(n-k)
1499 we can start by using t^0=1 so this simplifies to
1500 t^0*(1-t)^n - we want to multiply that with t/(1-t) each iteration
1501 to get a new level - this may lead to errors who knows lets test it */
1502
1503 void
97ac0a9 - constify the Imager API
Tony Cook authored
1504 i_bezier_multi(i_img *im,int l,const double *x,const double *y, const i_color *val) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1505 double *bzcoef;
1506 double t,cx,cy;
1507 int k,i;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1508 i_img_dim lx = 0,ly = 0;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1509 int n=l-1;
1510 double itr,ccoef;
1511
f0960b1 - added integer overflow checks to many memory allocation calls
Tony Cook authored
1512 /* this is the same size as the x and y arrays, so shouldn't overflow */
1513 bzcoef=mymalloc(sizeof(double)*l); /* checked 5jul05 tonyc */
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1514 for(k=0;k<l;k++) bzcoef[k]=perm(n,k);
1515 ICL_info(val);
1516
1517
1518 /* for(k=0;k<l;k++) printf("bzcoef: %d -> %f\n",k,bzcoef[k]); */
1519 i=0;
1520 for(t=0;t<=1;t+=0.005) {
1521 cx=cy=0;
1522 itr=t/(1-t);
1523 ccoef=pow(1-t,n);
1524 for(k=0;k<l;k++) {
1525 /* cx+=bzcoef[k]*x[k]*pow(t,k)*pow(1-t,n-k);
1526 cy+=bzcoef[k]*y[k]*pow(t,k)*pow(1-t,n-k);*/
1527
1528 cx+=bzcoef[k]*x[k]*ccoef;
1529 cy+=bzcoef[k]*y[k]*ccoef;
1530 ccoef*=itr;
1531 }
1532 /* printf("%f -> (%d,%d)\n",t,(int)(0.5+cx),(int)(0.5+cy)); */
1533 if (i++) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1534 i_line_aa(im,lx,ly,(i_img_dim)(0.5+cx),(i_img_dim)(0.5+cy),val, 1);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1535 }
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1536 /* i_ppix(im,(i_img_dim)(0.5+cx),(i_img_dim)(0.5+cy),val); */
1537 lx=(i_img_dim)(0.5+cx);
1538 ly=(i_img_dim)(0.5+cy);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1539 }
1540 ICL_info(val);
1541 myfree(bzcoef);
1542 }
1543
1544 /* Flood fill
1545
1546 REF: Graphics Gems I. page 282+
1547
1548 */
1549
1550 /* This should be moved into a seperate file? */
1551
1552 /* This is the truncation used:
1553
1554 a double is multiplied by 16 and then truncated.
1555 This means that 0 -> 0
1556 So a triangle of (0,0) (10,10) (10,0) Will look like it's
1557 not filling the (10,10) point nor the (10,0)-(10,10) line segment
1558
1559 */
1560
1561
1562 /* Flood fill algorithm - based on the Ken Fishkins (pixar) gem in
1563 graphics gems I */
1564
1565 /*
1566 struct stc {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1567 i_img_dim mylx,myrx;
1568 i_img_dim dadlx,dadrx;
1569 i_img_dim myy;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1570 int mydirection;
1571 };
1572
1573 Not used code???
1574 */
1575
1576
1577 struct stack_element {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1578 i_img_dim myLx,myRx;
1579 i_img_dim dadLx,dadRx;
1580 i_img_dim myY;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1581 int myDirection;
1582 };
1583
1584
1585 /* create the link data to put push onto the stack */
1586
1587 static
1588 struct stack_element*
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1589 crdata(i_img_dim left,i_img_dim right,i_img_dim dadl,i_img_dim dadr,i_img_dim y, int dir) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1590 struct stack_element *ste;
f0960b1 - added integer overflow checks to many memory allocation calls
Tony Cook authored
1591 ste = mymalloc(sizeof(struct stack_element)); /* checked 5jul05 tonyc */
a73aeb5 Fixed most outstanding memory leaks that are revealed in the test cases.
Arnar Mar Hrafnkelsson authored
1592 ste->myLx = left;
1593 ste->myRx = right;
1594 ste->dadLx = dadl;
1595 ste->dadRx = dadr;
1596 ste->myY = y;
1597 ste->myDirection = dir;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1598 return ste;
1599 }
1600
1601 /* i_ccomp compares two colors and gives true if they are the same */
1602
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1603 typedef int (*ff_cmpfunc)(i_color const *c1, i_color const *c2, int channels);
1604
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1605 static int
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1606 i_ccomp_normal(i_color const *val1, i_color const *val2, int ch) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1607 int i;
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1608 for(i = 0; i < ch; i++)
1609 if (val1->channel[i] !=val2->channel[i])
1610 return 0;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1611 return 1;
1612 }
1613
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1614 static int
1615 i_ccomp_border(i_color const *val1, i_color const *val2, int ch) {
1616 int i;
1617 for(i = 0; i < ch; i++)
1618 if (val1->channel[i] !=val2->channel[i])
1619 return 1;
1620 return 0;
1621 }
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1622
1623 static int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1624 i_lspan(i_img *im, i_img_dim seedx, i_img_dim seedy, i_color const *val, ff_cmpfunc cmpfunc) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1625 i_color cval;
1626 while(1) {
1627 if (seedx-1 < 0) break;
1628 i_gpix(im,seedx-1,seedy,&cval);
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1629 if (!cmpfunc(val,&cval,im->channels))
1630 break;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1631 seedx--;
1632 }
1633 return seedx;
1634 }
1635
1636 static int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1637 i_rspan(i_img *im, i_img_dim seedx, i_img_dim seedy, i_color const *val, ff_cmpfunc cmpfunc) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1638 i_color cval;
1639 while(1) {
1640 if (seedx+1 > im->xsize-1) break;
1641 i_gpix(im,seedx+1,seedy,&cval);
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1642 if (!cmpfunc(val,&cval,im->channels)) break;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1643 seedx++;
1644 }
1645 return seedx;
1646 }
1647
1648 /* Macro to create a link and push on to the list */
1649
e25e59b Second attempt at flood fix.
Arnar Mar Hrafnkelsson authored
1650 #define ST_PUSH(left,right,dadl,dadr,y,dir) do { \
1651 struct stack_element *s = crdata(left,right,dadl,dadr,y,dir); \
1652 llist_push(st,&s); \
1653 } while (0)
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1654
1655 /* pops the shadow on TOS into local variables lx,rx,y,direction,dadLx and dadRx */
1656 /* No overflow check! */
1657
e25e59b Second attempt at flood fix.
Arnar Mar Hrafnkelsson authored
1658 #define ST_POP() do { \
1659 struct stack_element *s; \
1660 llist_pop(st,&s); \
1661 lx = s->myLx; \
1662 rx = s->myRx; \
1663 dadLx = s->dadLx; \
1664 dadRx = s->dadRx; \
1665 y = s->myY; \
1666 direction = s->myDirection; \
1667 myfree(s); \
1668 } while (0)
1669
1670 #define ST_STACK(dir,dadLx,dadRx,lx,rx,y) do { \
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1671 i_img_dim pushrx = rx+1; \
1672 i_img_dim pushlx = lx-1; \
e25e59b Second attempt at flood fix.
Arnar Mar Hrafnkelsson authored
1673 ST_PUSH(lx,rx,pushlx,pushrx,y+dir,dir); \
1674 if (rx > dadRx) \
1675 ST_PUSH(dadRx+1,rx,pushlx,pushrx,y-dir,-dir); \
1676 if (lx < dadLx) ST_PUSH(lx,dadLx-1,pushlx,pushrx,y-dir,-dir); \
1677 } while (0)
1678
1679 #define SET(x,y) btm_set(btm,x,y)
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1680
86d20cb (Hopefully) last fix for flood fill crash.
Arnar Mar Hrafnkelsson authored
1681 /* INSIDE returns true if pixel is correct color and we haven't set it before. */
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1682 #define INSIDE(x,y, seed) ((!btm_test(btm,x,y) && ( i_gpix(im,x,y,&cval),cmpfunc(seed,&cval,channels) ) ))
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1683
1684
1685
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1686 /* The function that does all the real work */
1687
1688 static struct i_bitmap *
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1689 i_flood_fill_low(i_img *im,i_img_dim seedx,i_img_dim seedy,
1690 i_img_dim *bxminp, i_img_dim *bxmaxp, i_img_dim *byminp, i_img_dim *bymaxp,
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1691 i_color const *seed, ff_cmpfunc cmpfunc) {
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1692 i_img_dim ltx, rtx;
1693 i_img_dim tx = 0;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1694
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1695 i_img_dim bxmin = seedx;
1696 i_img_dim bxmax = seedx;
1697 i_img_dim bymin = seedy;
1698 i_img_dim bymax = seedy;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1699
1700 struct llist *st;
1701 struct i_bitmap *btm;
1702
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1703 int channels;
1704 i_img_dim xsize,ysize;
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1705 i_color cval;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1706
a73aeb5 Fixed most outstanding memory leaks that are revealed in the test cases.
Arnar Mar Hrafnkelsson authored
1707 channels = im->channels;
1708 xsize = im->xsize;
1709 ysize = im->ysize;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1710
86d20cb (Hopefully) last fix for flood fill crash.
Arnar Mar Hrafnkelsson authored
1711 btm = btm_new(xsize, ysize);
1712 st = llist_new(100, sizeof(struct stack_element*));
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1713
1714 /* Find the starting span and fill it */
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1715 ltx = i_lspan(im, seedx, seedy, seed, cmpfunc);
1716 rtx = i_rspan(im, seedx, seedy, seed, cmpfunc);
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1717 for(tx=ltx; tx<=rtx; tx++) SET(tx, seedy);
353eb6e flood_fill() wouldn't fill the right side of a single scan-line fill …
Tony Cook authored
1718 bxmin = ltx;
1719 bxmax = rtx;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1720
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1721 ST_PUSH(ltx, rtx, ltx, rtx, seedy+1, 1);
1722 ST_PUSH(ltx, rtx, ltx, rtx, seedy-1, -1);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1723
1724 while(st->count) {
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1725 /* Stack variables */
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1726 i_img_dim lx,rx;
1727 i_img_dim dadLx,dadRx;
1728 i_img_dim y;
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1729 int direction;
e25e59b Second attempt at flood fix.
Arnar Mar Hrafnkelsson authored
1730
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1731 i_img_dim x;
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1732 int wasIn=0;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1733
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1734 ST_POP(); /* sets lx, rx, dadLx, dadRx, y, direction */
1735
1736
1737 if (y<0 || y>ysize-1) continue;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1738 if (bymin > y) bymin=y; /* in the worst case an extra line */
1739 if (bymax < y) bymax=y;
1740
e25e59b Second attempt at flood fix.
Arnar Mar Hrafnkelsson authored
1741
1742 x = lx+1;
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1743 if ( lx >= 0 && (wasIn = INSIDE(lx, y, seed)) ) {
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1744 SET(lx, y);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1745 lx--;
95b9922 fix flood_fill some more
Tony Cook authored
1746 while(lx >= 0 && INSIDE(lx, y, seed)) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1747 SET(lx,y);
1748 lx--;
1749 }
1750 }
1751
86d20cb (Hopefully) last fix for flood fill crash.
Arnar Mar Hrafnkelsson authored
1752 if (bxmin > lx) bxmin = lx;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1753 while(x <= xsize-1) {
1754 /* printf("x=%d\n",x); */
1755 if (wasIn) {
1756
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1757 if (INSIDE(x, y, seed)) {
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1758 /* case 1: was inside, am still inside */
1759 SET(x,y);
1760 } else {
1761 /* case 2: was inside, am no longer inside: just found the
1762 right edge of a span */
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1763 ST_STACK(direction, dadLx, dadRx, lx, (x-1), y);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1764
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1765 if (bxmax < x) bxmax = x;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1766 wasIn=0;
1767 }
1768 } else {
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1769 if (x > rx) goto EXT;
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1770 if (INSIDE(x, y, seed)) {
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1771 SET(x, y);
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1772 /* case 3: Wasn't inside, am now: just found the start of a new run */
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1773 wasIn = 1;
1774 lx = x;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1775 } else {
1776 /* case 4: Wasn't inside, still isn't */
1777 }
1778 }
1779 x++;
1780 }
1781 EXT: /* out of loop */
1782 if (wasIn) {
1783 /* hit an edge of the frame buffer while inside a run */
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1784 ST_STACK(direction, dadLx, dadRx, lx, (x-1), y);
1785 if (bxmax < x) bxmax = x;
02d1d62 Initial revision
Arnar Mar Hrafnkelsson authored
1786 }
1787 }
1788
1789 llist_destroy(st);
cc6483e an extra stipple
Tony Cook authored
1790
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1791 *bxminp = bxmin;
1792 *bxmaxp = bxmax;
1793 *byminp = bymin;
1794 *bymaxp = bymax;
cc6483e an extra stipple
Tony Cook authored
1795
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1796 return btm;
1797 }
cc6483e an extra stipple
Tony Cook authored
1798
92bda63 - start of external Imager API access:
Tony Cook authored
1799 /*
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1800 =item i_flood_fill(C<im>, C<seedx>, C<seedy>, C<color>)
92bda63 - start of external Imager API access:
Tony Cook authored
1801
1802 =category Drawing
1803 =synopsis i_flood_fill(im, 50, 50, &color);
cc6483e an extra stipple
Tony Cook authored
1804
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1805 Flood fills the 4-connected region starting from the point (C<seedx>,
1806 C<seedy>) with I<color>.
cc6483e an extra stipple
Tony Cook authored
1807
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1808 Returns false if (C<seedx>, C<seedy>) are outside the image.
92bda63 - start of external Imager API access:
Tony Cook authored
1809
1810 =cut
1811 */
cc6483e an extra stipple
Tony Cook authored
1812
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1813 undef_int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1814 i_flood_fill(i_img *im, i_img_dim seedx, i_img_dim seedy, const i_color *dcol) {
1815 i_img_dim bxmin, bxmax, bymin, bymax;
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1816 struct i_bitmap *btm;
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1817 i_img_dim x, y;
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1818 i_color val;
cc6483e an extra stipple
Tony Cook authored
1819
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1820 i_clear_error();
1821 if (seedx < 0 || seedx >= im->xsize ||
1822 seedy < 0 || seedy >= im->ysize) {
1823 i_push_error(0, "i_flood_cfill: Seed pixel outside of image");
1824 return 0;
cc6483e an extra stipple
Tony Cook authored
1825 }
1826
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1827 /* Get the reference color */
1828 i_gpix(im, seedx, seedy, &val);
1829
1830 btm = i_flood_fill_low(im, seedx, seedy, &bxmin, &bxmax, &bymin, &bymax,
1831 &val, i_ccomp_normal);
cc6483e an extra stipple
Tony Cook authored
1832
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1833 for(y=bymin;y<=bymax;y++)
1834 for(x=bxmin;x<=bxmax;x++)
1835 if (btm_test(btm,x,y))
1836 i_ppix(im,x,y,dcol);
1837 btm_destroy(btm);
1838 return 1;
cc6483e an extra stipple
Tony Cook authored
1839 }
1840
92bda63 - start of external Imager API access:
Tony Cook authored
1841 /*
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1842 =item i_flood_cfill(C<im>, C<seedx>, C<seedy>, C<fill>)
92bda63 - start of external Imager API access:
Tony Cook authored
1843
1844 =category Drawing
1845 =synopsis i_flood_cfill(im, 50, 50, fill);
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1846
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1847 Flood fills the 4-connected region starting from the point (C<seedx>,
1848 C<seedy>) with C<fill>.
92bda63 - start of external Imager API access:
Tony Cook authored
1849
5715f7c huge spelling update and spell checking patch
Tony Cook authored
1850 Returns false if (C<seedx>, C<seedy>) are outside the image.
92bda63 - start of external Imager API access:
Tony Cook authored
1851
1852 =cut
1853 */
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1854
a321d49 Added checks to flood fill functions for seed pixel being outside of
Arnar Mar Hrafnkelsson authored
1855 undef_int
8d14daa @tonycoz switch to using size_t and i_img_dim strictly
authored
1856 i_flood_cfill(i_img *im, i_img_dim seedx, i_img_dim seedy, i_fill_t *fill) {
1857 i_img_dim bxmin, bxmax, bymin, bymax;
cc6483e an extra stipple
Tony Cook authored
1858 struct i_bitmap *btm;
3efb091 implement a flood_fill that stops at a given color rather than filling
Tony Cook authored
1859 i_color val;
cc6483e an extra stipple
Tony Cook authored
1860
aa833c9 Switched i_draw to i_line, added endpoint boolean condition,
Arnar Mar Hrafnkelsson authored
1861 i_clear_error();
a321d49 Added checks to flood fill functions for seed pixel being outside of
Arnar Mar Hrafnkelsson authored
1862
1863 if (seedx < 0 || seedx >= im->xsize ||
1864 seedy < 0 || seedy >= im->ysize) {
3e1e2ed Fixed missing check that cause out of bounds access on bitmaps for fl…
Arnar Mar Hrafnkelsson authored
1865 i_push_error(0, "i_flood_cfill: Seed pixel outside of image");
a321d49 Added checks to flood fill functions for seed pixel being outside of
Arnar Mar Hrafnkelsson authored
1866 return 0;