regmach.c

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