the code for the transform2() uminus operator was missing a break.
[imager.git] / regmach.c
1 #include "regmach.h"
2 #include <float.h>
3
4 /*#define DEBUG*/
5 #ifdef DEBUG
6 #define DBG(x) printf x
7 #else
8 #define DBG(x) 
9 #endif
10
11 static float MAX_EXP_ARG; /* = log(DBL_MAX); */
12
13
14 /* these functions currently assume RGB images - there seems to be some 
15    support for other color spaces, but I can't tell how you find what 
16    space an image is using.
17
18    HSV conversions from pages 401-403 "Procedural Elements for Computer 
19    Graphics", 1985, ISBN 0-07-053534-5.  The algorithm presents to produce
20    an HSV color calculates all components at once - I don't, so I've 
21    simiplified the algorithm to avoid unnecessary calculation (any errors 
22    (of which I had a few ;) are mine).
23 */
24
25 /* returns the value (brightness) of color from 0 to 1 */
26 static double hsv_value(i_color color) {
27   return i_max(i_max(color.rgb.r, color.rgb.g), color.rgb.b) / 255.0;
28 }
29
30 /* returns the hue (color) of color from 0 to 360 */
31 static double hsv_hue(i_color color) {
32   int val;
33   int temp;
34   temp = i_min(i_min(color.rgb.r, color.rgb.g), color.rgb.b);
35   val = i_max(color.rgb.r, i_max(color.rgb.g, color.rgb.b));
36   if (val == 0 || val==temp) {
37     return 0;
38   }
39   else {
40     double cr = (val - color.rgb.r) / (double)(val - temp);
41     double cg = (val - color.rgb.g) / (double)(val - temp);
42     double cb = (val - color.rgb.b) / (double)(val - temp);
43     double hue;
44     if (color.rgb.r == val) {
45       hue = cb-cg;
46     }
47     else if (color.rgb.g == val) {
48       hue = 2.0 + cr-cb;
49     }
50     else { /* if (blue == val) */
51       hue = 4.0 + cg - cr;
52     }
53     hue *= 60.0; /* to degrees */
54     if (hue < 0) 
55       hue += 360;
56
57     return hue;
58   }
59 }
60
61 /* return the saturation of color from 0 to 1 */
62 static double hsv_sat(i_color color) {
63   int value = i_max(i_max(color.rgb.r, color.rgb.g), color.rgb.b);
64   if (value == 0) {
65     return 0;
66   }
67   else {
68     int temp = i_min(i_max(color.rgb.r, color.rgb.g), color.rgb.b);
69     return (value - temp) / (double)value;
70   }
71 }
72
73 static i_color make_hsv(double hue, double sat, double val, int alpha) {
74   int i;
75   i_color c;
76   for( i=0; i< MAXCHANNELS; i++) c.channel[i]=0;
77   DBG(("hsv=%f %f %f\n", hue, sat, val));
78   if (sat <= 0) { /* handle -ve in case someone supplies a bad value */
79     /* should this be * 256? */
80     c.rgb.r = c.rgb.g = c.rgb.b = 255 * val;
81   }
82   else {
83     int i, m, n, k, v;
84     double f;
85     
86     if (val < 0) val = 0;
87     if (val > 1) val = 1;
88     if (sat > 1) sat = 1;
89
90     /* I want to handle -360 <= hue < 720 so that the caller can
91        fiddle with colour 
92     */
93     if (hue >= 360)
94       hue -= 360;
95     else if (hue < 0) 
96       hue += 360;
97     hue /= 60;
98     i = hue; /* floor */
99     f = hue - i;
100     val *= 255; 
101     m = val * (1.0 - sat);
102     n = val * (1.0 - sat * f);
103     k = val * (1.0 - sat * (1 - f));
104     v = val;
105     switch (i) {
106     case 0:
107       c.rgb.r = v; c.rgb.g = k; c.rgb.b = m;
108       break;
109     case 1:
110       c.rgb.r = n; c.rgb.g = v; c.rgb.b = m;
111       break;
112     case 2:
113       c.rgb.r = m; c.rgb.g = v; c.rgb.b = k;
114       break;
115     case 3:
116       c.rgb.r = m; c.rgb.g = n; c.rgb.b = v;
117       break;
118     case 4:
119       c.rgb.r = k; c.rgb.g = m; c.rgb.b = v;
120       break;
121     case 5:
122       c.rgb.r = v; c.rgb.g = m; c.rgb.b = n;
123       break;
124     }
125   }
126   c.rgba.a = alpha;
127
128   return c;
129 }
130
131 static i_color make_rgb(int r, int g, int b, int a) {
132   i_color c;
133   if (r < 0)
134     r = 0;
135   if (r > 255)
136     r = 255;
137   c.rgb.r = r;
138   if (g < 0)
139     g = 0;
140   if (g > 255)
141     g = 255;
142   c.rgb.g = g;
143   if (b < 0)
144     b = 0;
145   if (b > 255)
146     b = 255;
147   c.rgb.b = b;
148
149   c.rgba.a = a;
150
151   return c;
152 }
153
154 /* greatly simplifies the code */
155 #define nout n_regs[codes->rout]
156 #define na n_regs[codes->ra]
157 #define nb n_regs[codes->rb]
158 #define nc n_regs[codes->rc]
159 #define nd n_regs[codes->rd]
160 #define cout c_regs[codes->rout]
161 #define ca c_regs[codes->ra]
162 #define cb c_regs[codes->rb]
163 #define cc c_regs[codes->rc]
164 #define cd c_regs[codes->rd]
165
166 /* this is a pretty poor epsilon used for loosening up equality comparisons
167    It isn't currently used for inequalities 
168 */
169
170 #define n_epsilon(x, y) (abs(x)+abs(y))*0.001
171 static i_color bcol = {{ 0 }};
172
173 i_color i_rm_run(struct rm_op codes[], size_t code_count, 
174                double n_regs[],  size_t n_regs_count,
175                i_color c_regs[], size_t c_regs_count,
176                i_img *images[],  size_t image_count) {
177   double dx, dy;
178   struct rm_op *codes_base = codes;
179   size_t count_base = code_count;
180
181   DBG(("rm_run(%p, %d)\n", codes, code_count));
182   while (code_count) {
183     DBG((" rm_code %d\n", codes->code));
184     switch (codes->code) {
185     case rbc_add:
186       nout = na + nb;
187       break;
188       
189     case rbc_subtract:
190       nout = na - nb;
191       break;
192       
193     case rbc_mult:
194       nout = na * nb;
195       break;
196       
197     case rbc_div:
198       if (abs(nb) < 1e-10)
199         nout = 1e10;
200       else
201         nout = na / nb;
202       break;
203       
204     case rbc_mod:
205       if (abs(nb) > 1e-10) {
206         nout = fmod(na, nb);
207       }
208       else {
209         nout = 0; /* close enough ;) */
210       }
211       break;
212
213     case rbc_pow:
214       nout = pow(na, nb);
215       break;
216
217     case rbc_uminus:
218       nout = -na;
219       break;
220
221     case rbc_multp:
222       cout = make_rgb(ca.rgb.r * nb, ca.rgb.g * nb, ca.rgb.b * nb, 255);
223       break;
224
225     case rbc_addp:
226       cout = make_rgb(ca.rgb.r + cb.rgb.r, ca.rgb.g + cb.rgb.g, 
227                       ca.rgb.b + cb.rgb.b, 255);
228       break;
229
230     case rbc_subtractp:
231       cout = make_rgb(ca.rgb.r - cb.rgb.r, ca.rgb.g - cb.rgb.g, 
232                       ca.rgb.b - cb.rgb.b, 255);
233       break;
234
235     case rbc_sin:
236       nout = sin(na);
237       break;
238
239     case rbc_cos:
240       nout = cos(na);
241       break;
242
243     case rbc_atan2:
244       nout = atan2(na, nb);
245       break;
246
247     case rbc_sqrt:
248       nout = sqrt(na);
249       break;
250
251     case rbc_distance:
252       dx = na-nc;
253       dy = nb-nd;
254       nout = sqrt(dx*dx+dy*dy);
255       break;
256
257     case rbc_getp1:
258       i_gpix(images[0], na, nb, c_regs+codes->rout);
259       if (images[0]->channels < 4) cout.rgba.a = 255;
260       break;
261
262     case rbc_getp2:
263       i_gpix(images[1], na, nb, c_regs+codes->rout);
264       if (images[1]->channels < 4) cout.rgba.a = 255;
265       break;
266
267     case rbc_getp3:
268       i_gpix(images[2], na, nb, c_regs+codes->rout);
269       if (images[2]->channels < 4) cout.rgba.a = 255;
270       break;
271
272     case rbc_value:
273       nout = hsv_value(ca);
274       break;
275
276     case rbc_hue:
277       nout = hsv_hue(ca);
278       break;
279
280     case rbc_sat:
281       nout = hsv_sat(ca);
282       break;
283       
284     case rbc_hsv:
285       cout = make_hsv(na, nb, nc, 255);
286       break;
287
288     case rbc_hsva:
289       cout = make_hsv(na, nb, nc, nd);
290       break;
291
292     case rbc_red:
293       nout = ca.rgb.r;
294       break;
295
296     case rbc_green:
297       nout = ca.rgb.g;
298       break;
299
300     case rbc_blue:
301       nout = ca.rgb.b;
302       break;
303
304     case rbc_alpha:
305       nout = ca.rgba.a;
306       break;
307
308     case rbc_rgb:
309       cout = make_rgb(na, nb, nc, 255);
310       break;
311
312     case rbc_rgba:
313       cout = make_rgb(na, nb, nc, nd);
314       break;
315
316     case rbc_int:
317       nout = (int)(na);
318       break;
319
320     case rbc_if:
321       nout = na ? nb : nc;
322       break;
323
324     case rbc_ifp:
325       cout = na ? cb : cc;
326       break;
327
328     case rbc_le:
329       nout = na <= nb + n_epsilon(na,nb);
330       break;
331
332     case rbc_lt:
333       nout = na < nb;
334       break;
335
336     case rbc_ge:
337       nout = na >= nb - n_epsilon(na,nb);
338       break;
339
340     case rbc_gt:
341       nout = na > nb;
342       break;
343
344     case rbc_eq:
345       nout = abs(na-nb) <= n_epsilon(na,nb);
346       break;
347
348     case rbc_ne:
349       nout = abs(na-nb) > n_epsilon(na,nb);
350       break;
351
352     case rbc_and:
353       nout = na && nb;
354       break;
355  
356     case rbc_or:
357       nout = na || nb;
358       break;
359
360     case rbc_not:
361       nout = !na;
362       break;
363
364     case rbc_abs:
365       nout = abs(na);
366       break;
367
368     case rbc_ret:
369       return ca;
370       break;
371
372     case rbc_jump:
373       /* yes, order is important here */
374       code_count = count_base - codes->ra;
375       codes = codes_base + codes->ra;
376       continue;
377     
378     case rbc_jumpz:
379       if (!na) {        
380         /* yes, order is important here */
381         code_count = count_base - codes->rb;
382         codes = codes_base + codes->rb;
383         continue;
384       }
385       break;
386
387     case rbc_jumpnz:
388       if (na) {
389         /* yes, order is important here */
390         code_count = count_base - codes->rb;
391         codes = codes_base + codes->rb;
392         continue;
393       }
394       break;
395
396     case rbc_set:
397       nout = na;
398       break;
399
400     case rbc_setp:
401       cout = ca;
402       break;
403
404     case rbc_log:
405       if (na > 0) {
406         nout = log(na);
407       }
408       else {
409         nout = DBL_MAX;
410       }
411       break;
412
413     case rbc_exp:
414       if (!MAX_EXP_ARG) MAX_EXP_ARG = log(DBL_MAX);
415       if (na <= MAX_EXP_ARG) {
416         nout = exp(na);
417       }
418       else {
419         nout = DBL_MAX;
420       }
421       break;
422
423     case rbc_print:
424       printf("r%d is %g\n", codes->ra, na);
425       break;
426
427     default:
428       /*croak("bad opcode"); */
429       printf("bad op %d\n", codes->code);
430       return bcol;
431     }
432     --code_count;
433     ++codes;
434   }
435   return bcol;
436   /* croak("no return opcode"); */
437 }