fills.c

   1 #define IMAGER_NO_CONTEXT
   2 #include "imager.h"
   3 #include "imageri.h"
   4
   5 /*
   6 =head1 NAME
   7
   8 fills.c - implements the basic general fills
   9
  10 =head1 SYNOPSIS
  11
  12   i_fill_t *fill;
  13   i_color c1, c2;
  14   i_fcolor fc1, fc2;
  15   int combine;
  16   fill = i_new_fill_solidf(&fc1, combine);
  17   fill = i_new_fill_solid(&c1, combine);
  18   fill = i_new_fill_hatchf(&fc1, &fc2, combine, hatch, cust_hash, dx, dy);
  19   fill = i_new_fill_hatch(&c1, &c2, combine, hatch, cust_hash, dx, dy);
  20   fill = i_new_fill_image(im, matrix, xoff, yoff, combine);
  21   fill = i_new_fill_opacity(fill, alpha_mult);
  22   i_fill_destroy(fill);
  23
  24 =head1 DESCRIPTION
  25
  26 Implements the basic general fills, which can be used for filling some
  27 shapes and for flood fills.
  28
  29 Each fill can implement up to 3 functions:
  30
  31 =over
  32
  33 =item fill_with_color
  34
  35 called for fills on 8-bit images.  This can be NULL in which case the
  36 fill_with_colorf function is called.
  37
  38 =item fill_with_fcolor
  39
  40 called for fills on non-8-bit images or when fill_with_color is NULL.
  41
  42 =item destroy
  43
  44 called by i_fill_destroy() if non-NULL, to release any extra resources
  45 that the fill may need.
  46
  47 =back
  48
  49 fill_with_color and fill_with_fcolor are basically the same function
  50 except that the first works with lines of i_color and the second with
  51 lines of i_fcolor.
  52
  53 If the combines member if non-zero the line data is populated from the
  54 target image before calling fill_with_*color.
  55
  56 fill_with_color needs to fill the I<data> parameter with the fill
  57 pixels.  If combines is non-zero it the fill pixels should be combined
  58 with the existing data.
  59
  60 The current fills are:
  61
  62 =over
  63
  64 =item *
  65
  66 solid fill
  67
  68 =item *
  69
  70 hatched fill
  71
  72 =item *
  73
  74 fountain fill
  75
  76 =back
  77
  78 Fountain fill is implemented by L<filters.c>.
  79
  80 Other fills that could be implemented include:
  81
  82 =over
  83
  84 =item *
  85
  86 image - an image tiled over the fill area, with an offset either
  87 horizontally or vertically.
  88
  89 =item *
  90
  91 checkerboard - combine 2 fills in a checkerboard
  92
  93 =item *
  94
  95 combine - combine the levels of 2 other fills based in the levels of
  96 an image
  97
  98 =item *
  99
 100 regmach - use the register machine to generate colors
 101
 102 =back
 103
 104 =over
 105
 106 =cut
 107 */
 108
 109 static i_color fcolor_to_color(const i_fcolor *c) {
 110   int ch;
 111   i_color out;
 112
 113   for (ch = 0; ch < MAXCHANNELS; ++ch)
 114     out.channel[ch] = SampleFTo8(c->channel[ch]);
 115
 116   return out;
 117 }
 118
 119 static i_fcolor color_to_fcolor(const i_color *c) {
 120   int ch;
 121   i_fcolor out;
 122
 123   for (ch = 0; ch < MAXCHANNELS; ++ch)
 124     out.channel[ch] = Sample8ToF(c->channel[ch]);
 125
 126   return out;
 127 }
 128
 129 /* alpha combine in with out */
 130 #define COMBINE(out, in, channels) \
 131   { \
 132     int ch; \
 133     for (ch = 0; ch < (channels); ++ch) { \
 134       (out).channel[ch] = ((out).channel[ch] * (255 - (in).channel[3]) \
 135         + (in).channel[ch] * (in).channel[3]) / 255; \
 136     } \
 137   }
 138
 139 /* alpha combine in with out, in this case in is a simple array of
 140    samples, potentially not integers - the mult combiner uses doubles
 141    for accuracy */
 142 #define COMBINEA(out, in, channels) \
 143   { \
 144     int ch; \
 145     for (ch = 0; ch < (channels); ++ch) { \
 146       (out).channel[ch] = ((out).channel[ch] * (255 - (in)[3]) \
 147         + (in)[ch] * (in)[3]) / 255; \
 148     } \
 149   }
 150
 151 #define COMBINEF(out, in, channels) \
 152   { \
 153     int ch; \
 154     for (ch = 0; ch < (channels); ++ch) { \
 155       (out).channel[ch] = (out).channel[ch] * (1.0 - (in).channel[3]) \
 156         + (in).channel[ch] * (in).channel[3]; \
 157     } \
 158   }
 159
 160 typedef struct
 161 {
 162   i_fill_t base;
 163   i_color c;
 164   i_fcolor fc;
 165 } i_fill_solid_t;
 166
 167 static void fill_solid(i_fill_t *, i_img_dim x, i_img_dim y, i_img_dim width,
 168                        int channels, i_color *);
 169 static void fill_solidf(i_fill_t *, i_img_dim x, i_img_dim y, i_img_dim width,
 170                         int channels, i_fcolor *);
 171
 172 static i_fill_solid_t base_solid_fill =
 173 {
 174   {
 175     fill_solid,
 176     fill_solidf,
 177     NULL,
 178     NULL,
 179     NULL,
 180   },
 181 };
 182
 183 /*
 184 =item i_fill_destroy(fill)
 185 =order 90
 186 =category Fills
 187 =synopsis i_fill_destroy(fill);
 188
 189 Call to destroy any fill object.
 190
 191 =cut
 192 */
 193
 194 void
 195 i_fill_destroy(i_fill_t *fill) {
 196   if (fill->destroy)
 197     (fill->destroy)(fill);
 198   myfree(fill);
 199 }
 200
 201 /*
 202 =item i_new_fill_solidf(color, combine)
 203
 204 =category Fills
 205 =synopsis i_fill_t *fill = i_new_fill_solidf(&fcolor, combine);
 206
 207 Create a solid fill based on a float color.
 208
 209 If combine is non-zero then alpha values will be combined.
 210
 211 =cut
 212 */
 213
 214 i_fill_t *
 215 i_new_fill_solidf(const i_fcolor *c, int combine) {
 216   int ch;
 217   i_fill_solid_t *fill = mymalloc(sizeof(i_fill_solid_t)); /* checked 14jul05 tonyc */
 218
 219   *fill = base_solid_fill;
 220   if (combine) {
 221     i_get_combine(combine, &fill->base.combine, &fill->base.combinef);
 222   }
 223
 224   fill->fc = *c;
 225   for (ch = 0; ch < MAXCHANNELS; ++ch) {
 226     fill->c.channel[ch] = SampleFTo8(c->channel[ch]);
 227   }
 228
 229   return &fill->base;
 230 }
 231
 232 /*
 233 =item i_new_fill_solid(color, combine)
 234
 235 =category Fills
 236 =synopsis i_fill_t *fill = i_new_fill_solid(&color, combine);
 237
 238 Create a solid fill based on an 8-bit color.
 239
 240 If combine is non-zero then alpha values will be combined.
 241
 242 =cut
 243 */
 244
 245 i_fill_t *
 246 i_new_fill_solid(const i_color *c, int combine) {
 247   int ch;
 248   i_fill_solid_t *fill = mymalloc(sizeof(i_fill_solid_t)); /* checked 14jul05 tonyc */
 249
 250   *fill = base_solid_fill;
 251   if (combine) {
 252     i_get_combine(combine, &fill->base.combine, &fill->base.combinef);
 253   }
 254
 255   fill->c = *c;
 256   for (ch = 0; ch < MAXCHANNELS; ++ch) {
 257     fill->fc.channel[ch] = Sample8ToF(c->channel[ch]);
 258   }
 259
 260   return &fill->base;
 261 }
 262
 263 static unsigned char
 264 builtin_hatches[][8] =
 265 {
 266   {
 267     /* 1x1 checkerboard */
 268     0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55,
 269   },
 270   {
 271     /* 2x2 checkerboard */
 272     0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33,
 273   },
 274   {
 275     /* 4 x 4 checkerboard */
 276     0xF0, 0xF0, 0xF0, 0xF0, 0x0F, 0x0F, 0x0F, 0x0F,
 277   },
 278   {
 279     /* single vertical lines */
 280     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 281   },
 282   {
 283     /* double vertical lines */
 284     0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
 285   },
 286   {
 287     /* quad vertical lines */
 288     0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
 289   },
 290   {
 291     /* single hlines */
 292     0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 293   },
 294   {
 295     /* double hlines */
 296     0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
 297   },
 298   {
 299     /* quad hlines */
 300     0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
 301   },
 302   {
 303     /* single / */
 304     0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
 305   },
 306   {
 307     /* single \ */
 308     0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,
 309   },
 310   {
 311     /* double / */
 312     0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88,
 313   },
 314   {
 315     /* double \ */
 316     0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11,
 317   },
 318   {
 319     /* single grid */
 320     0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
 321   },
 322   {
 323     /* double grid */
 324     0xFF, 0x88, 0x88, 0x88, 0xFF, 0x88, 0x88, 0x88,
 325   },
 326   {
 327     /* quad grid */
 328     0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA,
 329   },
 330   {
 331     /* single dots */
 332     0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 333   },
 334   {
 335     /* 4 dots */
 336     0x88, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00,
 337   },
 338   {
 339     /* 16 dots */
 340     0xAA, 0x00, 0xAA, 0x00, 0xAA, 0x00, 0xAA, 0x00,
 341   },
 342   {
 343     /* simple stipple */
 344     0x48, 0x84, 0x00, 0x00, 0x84, 0x48, 0x00, 0x00,
 345   },
 346   {
 347     /* weave */
 348     0x55, 0xFD, 0x05, 0xFD, 0x55, 0xDF, 0x50, 0xDF,
 349   },
 350   {
 351     /* single cross hatch */
 352     0x82, 0x44, 0x28, 0x10, 0x28, 0x44, 0x82, 0x01,
 353   },
 354   {
 355     /* double cross hatch */
 356     0xAA, 0x44, 0xAA, 0x11, 0xAA, 0x44, 0xAA, 0x11,
 357   },
 358   {
 359     /* vertical lozenge */
 360     0x11, 0x11, 0x11, 0xAA, 0x44, 0x44, 0x44, 0xAA,
 361   },
 362   {
 363     /* horizontal lozenge */
 364     0x88, 0x70, 0x88, 0x07, 0x88, 0x70, 0x88, 0x07,
 365   },
 366   {
 367     /* scales overlapping downwards */
 368     0x80, 0x80, 0x41, 0x3E, 0x08, 0x08, 0x14, 0xE3,
 369   },
 370   {
 371     /* scales overlapping upwards */
 372     0xC7, 0x28, 0x10, 0x10, 0x7C, 0x82, 0x01, 0x01,
 373   },
 374   {
 375     /* scales overlapping leftwards */
 376     0x83, 0x84, 0x88, 0x48, 0x38, 0x48, 0x88, 0x84,
 377   },
 378   {
 379     /* scales overlapping rightwards */
 380     0x21, 0x11, 0x12, 0x1C, 0x12, 0x11, 0x21, 0xC1,
 381   },
 382   {
 383     /* denser stipple */
 384     0x44, 0x88, 0x22, 0x11, 0x44, 0x88, 0x22, 0x11,
 385   },
 386   {
 387     /* L-shaped tiles */
 388     0xFF, 0x84, 0x84, 0x9C, 0x94, 0x9C, 0x90, 0x90,
 389   },
 390   {
 391     /* wider stipple */
 392     0x80, 0x40, 0x20, 0x00, 0x02, 0x04, 0x08, 0x00,
 393   },
 394 };
 395
 396 typedef struct
 397 {
 398   i_fill_t base;
 399   i_color fg, bg;
 400   i_fcolor ffg, fbg;
 401   unsigned char hatch[8];
 402   i_img_dim dx, dy;
 403 } i_fill_hatch_t;
 404
 405 static void fill_hatch(i_fill_t *fill, i_img_dim x, i_img_dim y,
 406                        i_img_dim width, int channels, i_color *data);
 407 static void fill_hatchf(i_fill_t *fill, i_img_dim x, i_img_dim y,
 408                         i_img_dim width, int channels, i_fcolor *data);
 409 static
 410 i_fill_t *
 411 i_new_hatch_low(const i_color *fg, const i_color *bg, const i_fcolor *ffg, const i_fcolor *fbg,
 412                 int combine, int hatch, const unsigned char *cust_hatch,
 413                 i_img_dim dx, i_img_dim dy);
 414
 415 /*
 416 =item i_new_fill_hatch(C<fg>, C<bg>, C<combine>, C<hatch>, C<cust_hatch>, C<dx>, C<dy>)
 417
 418 =category Fills
 419 =synopsis i_fill_t *fill = i_new_fill_hatch(&fg_color, &bg_color, combine, hatch, custom_hatch, dx, dy);
 420
 421 Creates a new hatched fill with the C<fg> color used for the 1 bits in
 422 the hatch and C<bg> for the 0 bits.  If C<combine> is non-zero alpha
 423 values will be combined.
 424
 425 If C<cust_hatch> is non-NULL it should be a pointer to 8 bytes of the
 426 hash definition, with the high-bits to the left.
 427
 428 If C<cust_hatch> is NULL then one of the standard hatches is used.
 429
 430 (C<dx>, C<dy>) are an offset into the hatch which can be used to hatch
 431 adjoining areas out of alignment, or to align the origin of a hatch
 432 with the side of a filled area.
 433
 434 =cut
 435 */
 436 i_fill_t *
 437 i_new_fill_hatch(const i_color *fg, const i_color *bg, int combine, int hatch,
 438             const unsigned char *cust_hatch, i_img_dim dx, i_img_dim dy) {
 439   return i_new_hatch_low(fg, bg, NULL, NULL, combine, hatch, cust_hatch,
 440                          dx, dy);
 441 }
 442
 443 /*
 444 =item i_new_fill_hatchf(C<fg>, C<bg>, C<combine>, C<hatch>, C<cust_hatch>, C<dx>, C<dy>)
 445
 446 =category Fills
 447 =synopsis i_fill_t *fill = i_new_fill_hatchf(&fg_fcolor, &bg_fcolor, combine, hatch, custom_hatch, dx, dy);
 448
 449 Creates a new hatched fill with the C<fg> color used for the 1 bits in
 450 the hatch and C<bg> for the 0 bits.  If C<combine> is non-zero alpha
 451 values will be combined.
 452
 453 If C<cust_hatch> is non-NULL it should be a pointer to 8 bytes of the
 454 hash definition, with the high-bits to the left.
 455
 456 If C<cust_hatch> is NULL then one of the standard hatches is used.
 457
 458 (C<dx>, C<dy>) are an offset into the hatch which can be used to hatch
 459 adjoining areas out of alignment, or to align the origin of a hatch
 460 with the side of a filled area.
 461
 462 =cut
 463 */
 464 i_fill_t *
 465 i_new_fill_hatchf(const i_fcolor *fg, const i_fcolor *bg, int combine, int hatch,
 466                   const unsigned char *cust_hatch, i_img_dim dx, i_img_dim dy) {
 467   return i_new_hatch_low(NULL, NULL, fg, bg, combine, hatch, cust_hatch,
 468                          dx, dy);
 469 }
 470
 471 static void fill_image(i_fill_t *fill, i_img_dim x, i_img_dim y,
 472                        i_img_dim width, int channels, i_color *data);
 473 static void fill_imagef(i_fill_t *fill, i_img_dim x, i_img_dim y,
 474                         i_img_dim width, int channels, i_fcolor *data);
 475 struct i_fill_image_t {
 476   i_fill_t base;
 477   i_img *src;
 478   i_img_dim xoff, yoff;
 479   int has_matrix;
 480   double matrix[9];
 481 };
 482
 483 static struct i_fill_image_t
 484 image_fill_proto =
 485   {
 486     {
 487       fill_image,
 488       fill_imagef,
 489       NULL
 490     }
 491   };
 492
 493 /*
 494 =item i_new_fill_image(C<im>, C<matrix>, C<xoff>, C<yoff>, C<combine>)
 495
 496 =category Fills
 497 =synopsis i_fill_t *fill = i_new_fill_image(src_img, matrix, x_offset, y_offset, combine);
 498
 499 Create an image based fill.
 500
 501 matrix is an array of 9 doubles representing a transformation matrix.
 502
 503 C<xoff> and C<yoff> are the offset into the image to start filling from.
 504
 505 =cut
 506 */
 507 i_fill_t *
 508 i_new_fill_image(i_img *im, const double *matrix, i_img_dim xoff, i_img_dim yoff, int combine) {
 509   struct i_fill_image_t *fill = mymalloc(sizeof(*fill)); /* checked 14jul05 tonyc */
 510
 511   *fill = image_fill_proto;
 512
 513   if (combine) {
 514     i_get_combine(combine, &fill->base.combine, &fill->base.combinef);
 515   }
 516   else {
 517     fill->base.combine = NULL;
 518     fill->base.combinef = NULL;
 519   }
 520   fill->src = im;
 521   if (xoff < 0)
 522     xoff += im->xsize;
 523   fill->xoff = xoff;
 524   if (yoff < 0)
 525     yoff += im->ysize;
 526   fill->yoff = yoff;
 527   if (matrix) {
 528     fill->has_matrix = 1;
 529     memcpy(fill->matrix, matrix, sizeof(fill->matrix));
 530   }
 531   else
 532     fill->has_matrix = 0;
 533
 534   return &fill->base;
 535 }
 536
 537 static void fill_opacity(i_fill_t *fill, i_img_dim x, i_img_dim y,
 538                          i_img_dim width, int channels, i_color *data);
 539 static void fill_opacityf(i_fill_t *fill, i_img_dim x, i_img_dim y,
 540                           i_img_dim width, int channels, i_fcolor *data);
 541
 542 struct i_fill_opacity_t {
 543   i_fill_t base;
 544   i_fill_t *other_fill;
 545   double alpha_mult;
 546 };
 547
 548 static struct i_fill_opacity_t
 549 opacity_fill_proto =
 550   {
 551     {
 552       fill_opacity,
 553       fill_opacityf,
 554       NULL
 555     }
 556   };
 557
 558 i_fill_t *
 559 i_new_fill_opacity(i_fill_t *base_fill, double alpha_mult) {
 560   struct i_fill_opacity_t *fill = mymalloc(sizeof(*fill));
 561   *fill = opacity_fill_proto;
 562
 563   fill->base.combine = base_fill->combine;
 564   fill->base.combinef = base_fill->combinef;
 565
 566   fill->other_fill = base_fill;
 567   fill->alpha_mult = alpha_mult;
 568
 569   if (!base_fill->f_fill_with_color) {
 570     /* base fill only does floating, so we only do that too */
 571     fill->base.f_fill_with_color = NULL;
 572   }
 573
 574   return &fill->base;
 575 }
 576
 577 #define T_SOLID_FILL(fill) ((i_fill_solid_t *)(fill))
 578
 579 /*
 580 =back
 581
 582 =head1 INTERNAL FUNCTIONS
 583
 584 =over
 585
 586 =item fill_solid(fill, x, y, width, channels, data)
 587
 588 The 8-bit sample fill function for non-combining solid fills.
 589
 590 =cut
 591 */
 592 static void
 593 fill_solid(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
 594            int channels, i_color *data) {
 595   i_color c = T_SOLID_FILL(fill)->c;
 596   i_adapt_colors(channels > 2 ? 4 : 2, 4, &c, 1);
 597   while (width-- > 0) {
 598     *data++ = c;
 599   }
 600 }
 601
 602 /*
 603 =item fill_solid(fill, x, y, width, channels, data)
 604
 605 The floating sample fill function for non-combining solid fills.
 606
 607 =cut
 608 */
 609 static void
 610 fill_solidf(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
 611             int channels, i_fcolor *data) {
 612   i_fcolor c = T_SOLID_FILL(fill)->fc;
 613   i_adapt_fcolors(channels > 2 ? 4 : 2, 4, &c, 1);
 614   while (width-- > 0) {
 615     *data++ = c;
 616   }
 617 }
 618
 619 static i_fill_hatch_t
 620 hatch_fill_proto =
 621   {
 622     {
 623       fill_hatch,
 624       fill_hatchf,
 625       NULL
 626     }
 627   };
 628
 629 /*
 630 =item i_new_hatch_low(fg, bg, ffg, fbg, combine, hatch, cust_hatch, dx, dy)
 631
 632 Implements creation of hatch fill objects.
 633
 634 =cut
 635 */
 636 static
 637 i_fill_t *
 638 i_new_hatch_low(const i_color *fg, const i_color *bg,
 639                 const i_fcolor *ffg, const i_fcolor *fbg,
 640                 int combine, int hatch, const unsigned char *cust_hatch,
 641                 i_img_dim dx, i_img_dim dy) {
 642   i_fill_hatch_t *fill = mymalloc(sizeof(i_fill_hatch_t)); /* checked 14jul05 tonyc */
 643
 644   *fill = hatch_fill_proto;
 645   /* Some Sun C didn't like the condition expressions that were here.
 646      See https://rt.cpan.org/Ticket/Display.html?id=21944
 647    */
 648   if (fg)
 649     fill->fg = *fg;
 650   else
 651     fill->fg = fcolor_to_color(ffg);
 652   if (bg)
 653     fill->bg = *bg;
 654   else
 655     fill->bg = fcolor_to_color(fbg);
 656   if (ffg)
 657     fill->ffg = *ffg;
 658   else
 659     fill->ffg = color_to_fcolor(fg);
 660   if (fbg)
 661     fill->fbg = *fbg;
 662   else
 663     fill->fbg = color_to_fcolor(bg);
 664   if (combine) {
 665     i_get_combine(combine, &fill->base.combine, &fill->base.combinef);
 666   }
 667   else {
 668     fill->base.combine = NULL;
 669     fill->base.combinef = NULL;
 670   }
 671   if (cust_hatch) {
 672     memcpy(fill->hatch, cust_hatch, 8);
 673   }
 674   else {
 675     if (hatch >= sizeof(builtin_hatches)/sizeof(*builtin_hatches)
 676         || hatch < 0) {
 677       hatch = 0;
 678     }
 679     memcpy(fill->hatch, builtin_hatches[hatch], 8);
 680   }
 681   fill->dx = dx & 7;
 682   fill->dy = dy & 7;
 683
 684   return &fill->base;
 685 }
 686
 687 /*
 688 =item fill_hatch(fill, x, y, width, channels, data)
 689
 690 The 8-bit sample fill function for hatched fills.
 691
 692 =cut
 693 */
 694 static void
 695 fill_hatch(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
 696            int channels, i_color *data) {
 697   i_fill_hatch_t *f = (i_fill_hatch_t *)fill;
 698   int byte = f->hatch[(y + f->dy) & 7];
 699   int xpos = (x + f->dx) & 7;
 700   int mask = 128 >> xpos;
 701   i_color fg = f->fg;
 702   i_color bg = f->bg;
 703
 704   if (channels < 3) {
 705     i_adapt_colors(2, 4, &fg, 1);
 706     i_adapt_colors(2, 4, &bg, 1);
 707   }
 708
 709   while (width-- > 0) {
 710     if (byte & mask)
 711       *data++ = fg;
 712     else
 713       *data++ = bg;
 714
 715     if ((mask >>= 1) == 0)
 716       mask = 128;
 717   }
 718 }
 719
 720 /*
 721 =item fill_hatchf(fill, x, y, width, channels, data)
 722
 723 The floating sample fill function for hatched fills.
 724
 725 =cut
 726 */
 727 static void
 728 fill_hatchf(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
 729             int channels, i_fcolor *data) {
 730   i_fill_hatch_t *f = (i_fill_hatch_t *)fill;
 731   int byte = f->hatch[(y + f->dy) & 7];
 732   int xpos = (x + f->dx) & 7;
 733   int mask = 128 >> xpos;
 734   i_fcolor fg = f->ffg;
 735   i_fcolor bg = f->fbg;
 736
 737   if (channels < 3) {
 738     i_adapt_fcolors(2, 4, &fg, 1);
 739     i_adapt_fcolors(2, 4, &bg, 1);
 740   }
 741
 742   while (width-- > 0) {
 743     if (byte & mask)
 744       *data++ = fg;
 745     else
 746       *data++ = bg;
 747
 748     if ((mask >>= 1) == 0)
 749       mask = 128;
 750   }
 751 }
 752
 753 /* hopefully this will be inlined  (it is with -O3 with gcc 2.95.4) */
 754 /* linear interpolation */
 755 static i_color interp_i_color(i_color before, i_color after, double pos,
 756                               int channels) {
 757   i_color out;
 758   int ch;
 759
 760   pos -= floor(pos);
 761   for (ch = 0; ch < channels; ++ch)
 762     out.channel[ch] = (1-pos) * before.channel[ch] + pos * after.channel[ch];
 763   if (channels > 3 && out.channel[3]) {
 764     for (ch = 0; ch < channels; ++ch) {
 765       if (ch != 3) {
 766         int temp = out.channel[ch] * 255 / out.channel[3];
 767         if (temp > 255)
 768           temp = 255;
 769         out.channel[ch] = temp;
 770       }
 771     }
 772   }
 773
 774   return out;
 775 }
 776
 777 /* hopefully this will be inlined  (it is with -O3 with gcc 2.95.4) */
 778 /* linear interpolation */
 779 static i_fcolor interp_i_fcolor(i_fcolor before, i_fcolor after, double pos,
 780                                 int channels) {
 781   i_fcolor out;
 782   int ch;
 783
 784   pos -= floor(pos);
 785   for (ch = 0; ch < channels; ++ch)
 786     out.channel[ch] = (1-pos) * before.channel[ch] + pos * after.channel[ch];
 787   if (out.channel[3]) {
 788     for (ch = 0; ch < channels; ++ch) {
 789       if (ch != 3) {
 790         int temp = out.channel[ch] / out.channel[3];
 791         if (temp > 1.0)
 792           temp = 1.0;
 793         out.channel[ch] = temp;
 794       }
 795     }
 796   }
 797
 798   return out;
 799 }
 800
 801 /*
 802 =item fill_image(fill, x, y, width, channels, data, work)
 803
 804 =cut
 805 */
 806 static void
 807 fill_image(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
 808            int channels, i_color *data) {
 809   struct i_fill_image_t *f = (struct i_fill_image_t *)fill;
 810   i_img_dim i = 0;
 811   i_color *out = data;
 812   int want_channels = channels > 2 ? 4 : 2;
 813
 814   if (f->has_matrix) {
 815     /* the hard way */
 816     while (i < width) {
 817       double rx = f->matrix[0] * (x+i) + f->matrix[1] * y + f->matrix[2];
 818       double ry = f->matrix[3] * (x+i) + f->matrix[4] * y + f->matrix[5];
 819       double ix = floor(rx / f->src->xsize);
 820       double iy = floor(ry / f->src->ysize);
 821       i_color c[2][2];
 822       i_color c2[2];
 823       i_img_dim dy;
 824
 825       if (f->xoff) {
 826         rx += iy * f->xoff;
 827         ix = floor(rx / f->src->xsize);
 828       }
 829       else if (f->yoff) {
 830         ry += ix * f->yoff;
 831         iy = floor(ry / f->src->ysize);
 832       }
 833       rx -= ix * f->src->xsize;
 834       ry -= iy * f->src->ysize;
 835
 836       for (dy = 0; dy < 2; ++dy) {
 837         if ((i_img_dim)rx == f->src->xsize-1) {
 838           i_gpix(f->src, f->src->xsize-1, ((i_img_dim)ry+dy) % f->src->ysize, &c[dy][0]);
 839           i_gpix(f->src, 0, ((i_img_dim)ry+dy) % f->src->xsize, &c[dy][1]);
 840         }
 841         else {
 842           i_glin(f->src, (i_img_dim)rx, (i_img_dim)rx+2, ((i_img_dim)ry+dy) % f->src->ysize,
 843                  c[dy]);
 844         }
 845         c2[dy] = interp_i_color(c[dy][0], c[dy][1], rx, f->src->channels);
 846       }
 847       *out++ = interp_i_color(c2[0], c2[1], ry, f->src->channels);
 848       ++i;
 849     }
 850   }
 851   else {
 852     /* the easy way */
 853     /* this should be possible to optimize to use i_glin() */
 854     while (i < width) {
 855       i_img_dim rx = x+i;
 856       i_img_dim ry = y;
 857       i_img_dim ix = rx / f->src->xsize;
 858       i_img_dim iy = ry / f->src->ysize;
 859
 860       if (f->xoff) {
 861         rx += iy * f->xoff;
 862         ix = rx / f->src->xsize;
 863       }
 864       else if (f->yoff) {
 865         ry += ix * f->yoff;
 866         iy = ry / f->src->ysize;
 867       }
 868       rx -= ix * f->src->xsize;
 869       ry -= iy * f->src->ysize;
 870       i_gpix(f->src, rx, ry, out);
 871       ++out;
 872       ++i;
 873     }
 874   }
 875   if (f->src->channels != want_channels)
 876     i_adapt_colors(want_channels, f->src->channels, data, width);
 877 }
 878
 879 /*
 880 =item fill_imagef(fill, x, y, width, channels, data, work)
 881
 882 =cut
 883 */
 884 static void
 885 fill_imagef(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
 886             int channels, i_fcolor *data) {
 887   struct i_fill_image_t *f = (struct i_fill_image_t *)fill;
 888   i_img_dim i = 0;
 889   int want_channels = channels > 2 ? 4 : 2;
 890
 891   if (f->has_matrix) {
 892     i_fcolor *work_data = data;
 893     /* the hard way */
 894     while (i < width) {
 895       double rx = f->matrix[0] * (x+i) + f->matrix[1] * y + f->matrix[2];
 896       double ry = f->matrix[3] * (x+i) + f->matrix[4] * y + f->matrix[5];
 897       double ix = floor(rx / f->src->xsize);
 898       double iy = floor(ry / f->src->ysize);
 899       i_fcolor c[2][2];
 900       i_fcolor c2[2];
 901       i_img_dim dy;
 902
 903       if (f->xoff) {
 904         rx += iy * f->xoff;
 905         ix = floor(rx / f->src->xsize);
 906       }
 907       else if (f->yoff) {
 908         ry += ix * f->yoff;
 909         iy = floor(ry / f->src->ysize);
 910       }
 911       rx -= ix * f->src->xsize;
 912       ry -= iy * f->src->ysize;
 913
 914       for (dy = 0; dy < 2; ++dy) {
 915         if ((i_img_dim)rx == f->src->xsize-1) {
 916           i_gpixf(f->src, f->src->xsize-1, ((i_img_dim)ry+dy) % f->src->ysize, &c[dy][0]);
 917           i_gpixf(f->src, 0, ((i_img_dim)ry+dy) % f->src->xsize, &c[dy][1]);
 918         }
 919         else {
 920           i_glinf(f->src, (i_img_dim)rx, (i_img_dim)rx+2, ((i_img_dim)ry+dy) % f->src->ysize,
 921                  c[dy]);
 922         }
 923         c2[dy] = interp_i_fcolor(c[dy][0], c[dy][1], rx, f->src->channels);
 924       }
 925       *work_data++ = interp_i_fcolor(c2[0], c2[1], ry, f->src->channels);
 926       ++i;
 927     }
 928   }
 929   else {
 930     i_fcolor *work_data = data;
 931     /* the easy way */
 932     /* this should be possible to optimize to use i_glin() */
 933     while (i < width) {
 934       i_img_dim rx = x+i;
 935       i_img_dim ry = y;
 936       i_img_dim ix = rx / f->src->xsize;
 937       i_img_dim iy = ry / f->src->ysize;
 938
 939       if (f->xoff) {
 940         rx += iy * f->xoff;
 941         ix = rx / f->src->xsize;
 942       }
 943       else if (f->yoff) {
 944         ry += ix * f->yoff;
 945         iy = ry / f->src->xsize;
 946       }
 947       rx -= ix * f->src->xsize;
 948       ry -= iy * f->src->ysize;
 949       i_gpixf(f->src, rx, ry, work_data);
 950       ++work_data;
 951       ++i;
 952     }
 953   }
 954   if (f->src->channels != want_channels)
 955     i_adapt_fcolors(want_channels, f->src->channels, data, width);
 956 }
 957
 958 static void
 959 fill_opacity(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
 960              int channels, i_color *data) {
 961   struct i_fill_opacity_t *f = (struct i_fill_opacity_t *)fill;
 962   int alpha_chan = channels > 2 ? 3 : 1;
 963   i_color *datap = data;
 964
 965   (f->other_fill->f_fill_with_color)(f->other_fill, x, y, width, channels, data);
 966   while (width--) {
 967     double new_alpha = datap->channel[alpha_chan] * f->alpha_mult;
 968     if (new_alpha < 0)
 969       datap->channel[alpha_chan] = 0;
 970     else if (new_alpha > 255)
 971       datap->channel[alpha_chan] = 255;
 972     else datap->channel[alpha_chan] = (int)(new_alpha + 0.5);
 973
 974     ++datap;
 975   }
 976 }
 977 static void
 978 fill_opacityf(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
 979               int channels, i_fcolor *data) {
 980   struct i_fill_opacity_t *f = (struct i_fill_opacity_t *)fill;
 981   int alpha_chan = channels > 2 ? 3 : 1;
 982   i_fcolor *datap = data;
 983
 984   (f->other_fill->f_fill_with_fcolor)(f->other_fill, x, y, width, channels, data);
 985
 986   while (width--) {
 987     double new_alpha = datap->channel[alpha_chan] * f->alpha_mult;
 988     if (new_alpha < 0)
 989       datap->channel[alpha_chan] = 0;
 990     else if (new_alpha > 1.0)
 991       datap->channel[alpha_chan] = 1.0;
 992     else datap->channel[alpha_chan] = new_alpha;
 993
 994     ++datap;
 995   }
 996 }
 997
 998 /*
 999 =back
1000
1001 =head1 AUTHOR
1002
1003 Tony Cook <tony@develop-help.com>
1004
1005 =head1 SEE ALSO
1006
1007 Imager(3)
1008
1009 =cut
1010 */