+#define IMAGER_NO_CONTEXT
#include "imager.h"
#include "imageri.h"
+#include <assert.h>
/*
=head1 NAME
fill = i_new_fill_hatchf(&fc1, &fc2, combine, hatch, cust_hash, dx, dy);
fill = i_new_fill_hatch(&c1, &c2, combine, hatch, cust_hash, dx, dy);
fill = i_new_fill_image(im, matrix, xoff, yoff, combine);
+ fill = i_new_fill_opacity(fill, alpha_mult);
i_fill_destroy(fill);
=head1 DESCRIPTION
i_fcolor fc;
} i_fill_solid_t;
-static void fill_solid(i_fill_t *, int x, int y, int width, int channels,
- i_color *);
-static void fill_solidf(i_fill_t *, int x, int y, int width, int channels,
- i_fcolor *);
+static void fill_solid(i_fill_t *, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_color *);
+static void fill_solidf(i_fill_t *, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_fcolor *);
static i_fill_solid_t base_solid_fill =
{
/*
=item i_fill_destroy(fill)
-
+=order 90
=category Fills
=synopsis i_fill_destroy(fill);
i_color fg, bg;
i_fcolor ffg, fbg;
unsigned char hatch[8];
- int dx, dy;
+ i_img_dim dx, dy;
} i_fill_hatch_t;
-static void fill_hatch(i_fill_t *fill, int x, int y, int width, int channels,
- i_color *data);
-static void fill_hatchf(i_fill_t *fill, int x, int y, int width, int channels,
- i_fcolor *data);
+static void fill_hatch(i_fill_t *fill, i_img_dim x, i_img_dim y,
+ i_img_dim width, int channels, i_color *data);
+static void fill_hatchf(i_fill_t *fill, i_img_dim x, i_img_dim y,
+ i_img_dim width, int channels, i_fcolor *data);
static
i_fill_t *
i_new_hatch_low(const i_color *fg, const i_color *bg, const i_fcolor *ffg, const i_fcolor *fbg,
int combine, int hatch, const unsigned char *cust_hatch,
- int dx, int dy);
+ i_img_dim dx, i_img_dim dy);
/*
-=item i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch, dx, dy)
+=item i_new_fill_hatch(C<fg>, C<bg>, C<combine>, C<hatch>, C<cust_hatch>, C<dx>, C<dy>)
=category Fills
=synopsis i_fill_t *fill = i_new_fill_hatch(&fg_color, &bg_color, combine, hatch, custom_hatch, dx, dy);
-Creates a new hatched fill with the fg color used for the 1 bits in
-the hatch and bg for the 0 bits. If combine is non-zero alpha values
-will be combined.
+Creates a new hatched fill with the C<fg> color used for the 1 bits in
+the hatch and C<bg> for the 0 bits. If C<combine> is non-zero alpha
+values will be combined.
-If cust_hatch is non-NULL it should be a pointer to 8 bytes of the
+If C<cust_hatch> is non-NULL it should be a pointer to 8 bytes of the
hash definition, with the high-bits to the left.
-If cust_hatch is NULL then one of the standard hatches is used.
+If C<cust_hatch> is NULL then one of the standard hatches is used.
-(dx, dy) are an offset into the hatch which can be used to unalign adjoining areas, or to align the origin of a hatch with the the side of a filled area.
+(C<dx>, C<dy>) are an offset into the hatch which can be used to hatch
+adjoining areas out of alignment, or to align the origin of a hatch
+with the side of a filled area.
=cut
*/
i_fill_t *
i_new_fill_hatch(const i_color *fg, const i_color *bg, int combine, int hatch,
- const unsigned char *cust_hatch, int dx, int dy) {
+ const unsigned char *cust_hatch, i_img_dim dx, i_img_dim dy) {
+ assert(fg);
+ assert(bg);
return i_new_hatch_low(fg, bg, NULL, NULL, combine, hatch, cust_hatch,
dx, dy);
}
/*
-=item i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch, dx, dy)
+=item i_new_fill_hatchf(C<fg>, C<bg>, C<combine>, C<hatch>, C<cust_hatch>, C<dx>, C<dy>)
=category Fills
=synopsis i_fill_t *fill = i_new_fill_hatchf(&fg_fcolor, &bg_fcolor, combine, hatch, custom_hatch, dx, dy);
-Creates a new hatched fill with the fg color used for the 1 bits in
-the hatch and bg for the 0 bits. If combine is non-zero alpha values
-will be combined.
+Creates a new hatched fill with the C<fg> color used for the 1 bits in
+the hatch and C<bg> for the 0 bits. If C<combine> is non-zero alpha
+values will be combined.
-If cust_hatch is non-NULL it should be a pointer to 8 bytes of the
+If C<cust_hatch> is non-NULL it should be a pointer to 8 bytes of the
hash definition, with the high-bits to the left.
-If cust_hatch is NULL then one of the standard hatches is used.
+If C<cust_hatch> is NULL then one of the standard hatches is used.
-(dx, dy) are an offset into the hatch which can be used to unalign adjoining areas, or to align the origin of a hatch with the the side of a filled area.
+(C<dx>, C<dy>) are an offset into the hatch which can be used to hatch
+adjoining areas out of alignment, or to align the origin of a hatch
+with the side of a filled area.
=cut
*/
i_fill_t *
i_new_fill_hatchf(const i_fcolor *fg, const i_fcolor *bg, int combine, int hatch,
- const unsigned char *cust_hatch, int dx, int dy) {
+ const unsigned char *cust_hatch, i_img_dim dx, i_img_dim dy) {
+ assert(fg);
+ assert(bg);
return i_new_hatch_low(NULL, NULL, fg, bg, combine, hatch, cust_hatch,
dx, dy);
}
-static void fill_image(i_fill_t *fill, int x, int y, int width, int channels,
- i_color *data);
-static void fill_imagef(i_fill_t *fill, int x, int y, int width, int channels,
- i_fcolor *data);
+static void fill_image(i_fill_t *fill, i_img_dim x, i_img_dim y,
+ i_img_dim width, int channels, i_color *data);
+static void fill_imagef(i_fill_t *fill, i_img_dim x, i_img_dim y,
+ i_img_dim width, int channels, i_fcolor *data);
struct i_fill_image_t {
i_fill_t base;
i_img *src;
- int xoff, yoff;
+ i_img_dim xoff, yoff;
int has_matrix;
double matrix[9];
};
};
/*
-=item i_new_fill_image(im, matrix, xoff, yoff, combine)
+=item i_new_fill_image(C<im>, C<matrix>, C<xoff>, C<yoff>, C<combine>)
=category Fills
=synopsis i_fill_t *fill = i_new_fill_image(src_img, matrix, x_offset, y_offset, combine);
matrix is an array of 9 doubles representing a transformation matrix.
-xoff and yoff are the offset into the image to start filling from.
+C<xoff> and C<yoff> are the offset into the image to start filling from.
=cut
*/
i_fill_t *
-i_new_fill_image(i_img *im, const double *matrix, int xoff, int yoff, int combine) {
+i_new_fill_image(i_img *im, const double *matrix, i_img_dim xoff, i_img_dim yoff, int combine) {
struct i_fill_image_t *fill = mymalloc(sizeof(*fill)); /* checked 14jul05 tonyc */
*fill = image_fill_proto;
return &fill->base;
}
+static void fill_opacity(i_fill_t *fill, i_img_dim x, i_img_dim y,
+ i_img_dim width, int channels, i_color *data);
+static void fill_opacityf(i_fill_t *fill, i_img_dim x, i_img_dim y,
+ i_img_dim width, int channels, i_fcolor *data);
+
+struct i_fill_opacity_t {
+ i_fill_t base;
+ i_fill_t *other_fill;
+ double alpha_mult;
+};
+
+static struct i_fill_opacity_t
+opacity_fill_proto =
+ {
+ {
+ fill_opacity,
+ fill_opacityf,
+ NULL
+ }
+ };
+
+i_fill_t *
+i_new_fill_opacity(i_fill_t *base_fill, double alpha_mult) {
+ struct i_fill_opacity_t *fill = mymalloc(sizeof(*fill));
+ *fill = opacity_fill_proto;
+
+ fill->base.combine = base_fill->combine;
+ fill->base.combinef = base_fill->combinef;
+
+ fill->other_fill = base_fill;
+ fill->alpha_mult = alpha_mult;
+
+ if (!base_fill->f_fill_with_color) {
+ /* base fill only does floating, so we only do that too */
+ fill->base.f_fill_with_color = NULL;
+ }
+
+ return &fill->base;
+}
#define T_SOLID_FILL(fill) ((i_fill_solid_t *)(fill))
=cut
*/
static void
-fill_solid(i_fill_t *fill, int x, int y, int width, int channels,
- i_color *data) {
+fill_solid(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_color *data) {
i_color c = T_SOLID_FILL(fill)->c;
i_adapt_colors(channels > 2 ? 4 : 2, 4, &c, 1);
while (width-- > 0) {
=cut
*/
static void
-fill_solidf(i_fill_t *fill, int x, int y, int width, int channels,
- i_fcolor *data) {
+fill_solidf(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_fcolor *data) {
i_fcolor c = T_SOLID_FILL(fill)->fc;
i_adapt_fcolors(channels > 2 ? 4 : 2, 4, &c, 1);
while (width-- > 0) {
i_new_hatch_low(const i_color *fg, const i_color *bg,
const i_fcolor *ffg, const i_fcolor *fbg,
int combine, int hatch, const unsigned char *cust_hatch,
- int dx, int dy) {
+ i_img_dim dx, i_img_dim dy) {
i_fill_hatch_t *fill = mymalloc(sizeof(i_fill_hatch_t)); /* checked 14jul05 tonyc */
*fill = hatch_fill_proto;
- /* Some Sun C didn't like the condition expressions that were here.
- See https://rt.cpan.org/Ticket/Display.html?id=21944
- */
- if (fg)
+ if (fg && bg) {
fill->fg = *fg;
- else
- fill->fg = fcolor_to_color(ffg);
- if (bg)
fill->bg = *bg;
- else
+ fill->ffg = color_to_fcolor(fg);
+ fill->fbg = color_to_fcolor(bg);
+ }
+ else if (ffg && fbg) {
+ fill->fg = fcolor_to_color(ffg);
fill->bg = fcolor_to_color(fbg);
- if (ffg)
fill->ffg = *ffg;
- else
- fill->ffg = color_to_fcolor(fg);
- if (fbg)
fill->fbg = *fbg;
- else
- fill->fbg = color_to_fcolor(bg);
+ }
+ else {
+ assert(0);
+ /* NOTREACHED */
+ }
+
if (combine) {
i_get_combine(combine, &fill->base.combine, &fill->base.combinef);
}
memcpy(fill->hatch, cust_hatch, 8);
}
else {
- if (hatch > sizeof(builtin_hatches)/sizeof(*builtin_hatches))
+ if (hatch >= sizeof(builtin_hatches)/sizeof(*builtin_hatches)
+ || hatch < 0) {
hatch = 0;
+ }
memcpy(fill->hatch, builtin_hatches[hatch], 8);
}
fill->dx = dx & 7;
=cut
*/
-static void fill_hatch(i_fill_t *fill, int x, int y, int width, int channels,
- i_color *data) {
+static void
+fill_hatch(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_color *data) {
i_fill_hatch_t *f = (i_fill_hatch_t *)fill;
int byte = f->hatch[(y + f->dy) & 7];
int xpos = (x + f->dx) & 7;
int mask = 128 >> xpos;
+ i_color fg = f->fg;
+ i_color bg = f->bg;
+
+ if (channels < 3) {
+ i_adapt_colors(2, 4, &fg, 1);
+ i_adapt_colors(2, 4, &bg, 1);
+ }
while (width-- > 0) {
if (byte & mask)
- *data++ = f->fg;
+ *data++ = fg;
else
- *data++ = f->bg;
+ *data++ = bg;
if ((mask >>= 1) == 0)
mask = 128;
The floating sample fill function for hatched fills.
-=back
+=cut
*/
-static void fill_hatchf(i_fill_t *fill, int x, int y, int width, int channels,
- i_fcolor *data) {
+static void
+fill_hatchf(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_fcolor *data) {
i_fill_hatch_t *f = (i_fill_hatch_t *)fill;
int byte = f->hatch[(y + f->dy) & 7];
int xpos = (x + f->dx) & 7;
int mask = 128 >> xpos;
+ i_fcolor fg = f->ffg;
+ i_fcolor bg = f->fbg;
+
+ if (channels < 3) {
+ i_adapt_fcolors(2, 4, &fg, 1);
+ i_adapt_fcolors(2, 4, &bg, 1);
+ }
while (width-- > 0) {
if (byte & mask)
- *data++ = f->ffg;
+ *data++ = fg;
else
- *data++ = f->fbg;
+ *data++ = bg;
if ((mask >>= 1) == 0)
mask = 128;
pos -= floor(pos);
for (ch = 0; ch < channels; ++ch)
out.channel[ch] = (1-pos) * before.channel[ch] + pos * after.channel[ch];
- if (channels > 3 && out.channel[3])
- for (ch = 0; ch < channels; ++ch)
+ if (channels > 3 && out.channel[3]) {
+ for (ch = 0; ch < channels; ++ch) {
if (ch != 3) {
int temp = out.channel[ch] * 255 / out.channel[3];
if (temp > 255)
temp = 255;
out.channel[ch] = temp;
}
+ }
+ }
return out;
}
pos -= floor(pos);
for (ch = 0; ch < channels; ++ch)
out.channel[ch] = (1-pos) * before.channel[ch] + pos * after.channel[ch];
- if (out.channel[3])
- for (ch = 0; ch < channels; ++ch)
+ if (out.channel[3]) {
+ for (ch = 0; ch < channels; ++ch) {
if (ch != 3) {
int temp = out.channel[ch] / out.channel[3];
if (temp > 1.0)
temp = 1.0;
out.channel[ch] = temp;
}
+ }
+ }
return out;
}
=cut
*/
-static void fill_image(i_fill_t *fill, int x, int y, int width, int channels,
- i_color *data) {
+static void
+fill_image(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_color *data) {
struct i_fill_image_t *f = (struct i_fill_image_t *)fill;
- int i = 0;
+ i_img_dim i = 0;
i_color *out = data;
+ int want_channels = channels > 2 ? 4 : 2;
if (f->has_matrix) {
/* the hard way */
double iy = floor(ry / f->src->ysize);
i_color c[2][2];
i_color c2[2];
- int dy;
+ i_img_dim dy;
if (f->xoff) {
rx += iy * f->xoff;
ry -= iy * f->src->ysize;
for (dy = 0; dy < 2; ++dy) {
- if ((int)rx == f->src->xsize-1) {
- i_gpix(f->src, f->src->xsize-1, ((int)ry+dy) % f->src->ysize, &c[dy][0]);
- i_gpix(f->src, 0, ((int)ry+dy) % f->src->xsize, &c[dy][1]);
+ if ((i_img_dim)rx == f->src->xsize-1) {
+ i_gpix(f->src, f->src->xsize-1, ((i_img_dim)ry+dy) % f->src->ysize, &c[dy][0]);
+ i_gpix(f->src, 0, ((i_img_dim)ry+dy) % f->src->xsize, &c[dy][1]);
}
else {
- i_glin(f->src, (int)rx, (int)rx+2, ((int)ry+dy) % f->src->ysize,
+ i_glin(f->src, (i_img_dim)rx, (i_img_dim)rx+2, ((i_img_dim)ry+dy) % f->src->ysize,
c[dy]);
}
c2[dy] = interp_i_color(c[dy][0], c[dy][1], rx, f->src->channels);
/* the easy way */
/* this should be possible to optimize to use i_glin() */
while (i < width) {
- int rx = x+i;
- int ry = y;
- int ix = rx / f->src->xsize;
- int iy = ry / f->src->ysize;
+ i_img_dim rx = x+i;
+ i_img_dim ry = y;
+ i_img_dim ix = rx / f->src->xsize;
+ i_img_dim iy = ry / f->src->ysize;
if (f->xoff) {
rx += iy * f->xoff;
}
else if (f->yoff) {
ry += ix * f->yoff;
- iy = ry / f->src->xsize;
+ iy = ry / f->src->ysize;
}
rx -= ix * f->src->xsize;
ry -= iy * f->src->ysize;
++i;
}
}
- if (f->src->channels == 3) {
- /* just set the alpha */
- for (i = 0; i < width; ++i) {
- data->channel[3] = 255;
- data++;
- }
- }
- else if (f->src->channels == 2) {
- /* copy the alpha to channel 3, duplicate the grey value */
- for (i = 0; i < width; ++i) {
- data->channel[3] = data->channel[1];
- data->channel[1] = data->channel[2] = data->channel[0];
- data++;
- }
- }
- else if (f->src->channels == 1) {
- /* set the alpha, duplicate grey */
- for (i = 0; i < width; ++i) {
- data->channel[3] = 255;
- data->channel[1] = data->channel[2] = data->channel[0];
- data++;
- }
- }
+ if (f->src->channels != want_channels)
+ i_adapt_colors(want_channels, f->src->channels, data, width);
}
/*
-=item fill_image(fill, x, y, width, channels, data, work)
+=item fill_imagef(fill, x, y, width, channels, data, work)
=cut
*/
-static void fill_imagef(i_fill_t *fill, int x, int y, int width, int channels,
- i_fcolor *data) {
+static void
+fill_imagef(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_fcolor *data) {
struct i_fill_image_t *f = (struct i_fill_image_t *)fill;
- int i = 0;
+ i_img_dim i = 0;
+ int want_channels = channels > 2 ? 4 : 2;
if (f->has_matrix) {
+ i_fcolor *work_data = data;
/* the hard way */
while (i < width) {
double rx = f->matrix[0] * (x+i) + f->matrix[1] * y + f->matrix[2];
double iy = floor(ry / f->src->ysize);
i_fcolor c[2][2];
i_fcolor c2[2];
- int dy;
+ i_img_dim dy;
if (f->xoff) {
rx += iy * f->xoff;
ry -= iy * f->src->ysize;
for (dy = 0; dy < 2; ++dy) {
- if ((int)rx == f->src->xsize-1) {
- i_gpixf(f->src, f->src->xsize-1, ((int)ry+dy) % f->src->ysize, &c[dy][0]);
- i_gpixf(f->src, 0, ((int)ry+dy) % f->src->xsize, &c[dy][1]);
+ if ((i_img_dim)rx == f->src->xsize-1) {
+ i_gpixf(f->src, f->src->xsize-1, ((i_img_dim)ry+dy) % f->src->ysize, &c[dy][0]);
+ i_gpixf(f->src, 0, ((i_img_dim)ry+dy) % f->src->xsize, &c[dy][1]);
}
else {
- i_glinf(f->src, (int)rx, (int)rx+2, ((int)ry+dy) % f->src->ysize,
+ i_glinf(f->src, (i_img_dim)rx, (i_img_dim)rx+2, ((i_img_dim)ry+dy) % f->src->ysize,
c[dy]);
}
c2[dy] = interp_i_fcolor(c[dy][0], c[dy][1], rx, f->src->channels);
}
- *data++ = interp_i_fcolor(c2[0], c2[1], ry, f->src->channels);
+ *work_data++ = interp_i_fcolor(c2[0], c2[1], ry, f->src->channels);
++i;
}
}
else {
+ i_fcolor *work_data = data;
/* the easy way */
/* this should be possible to optimize to use i_glin() */
while (i < width) {
- int rx = x+i;
- int ry = y;
- int ix = rx / f->src->xsize;
- int iy = ry / f->src->ysize;
+ i_img_dim rx = x+i;
+ i_img_dim ry = y;
+ i_img_dim ix = rx / f->src->xsize;
+ i_img_dim iy = ry / f->src->ysize;
if (f->xoff) {
rx += iy * f->xoff;
}
rx -= ix * f->src->xsize;
ry -= iy * f->src->ysize;
- i_gpixf(f->src, rx, ry, data);
- ++data;
+ i_gpixf(f->src, rx, ry, work_data);
+ ++work_data;
++i;
}
}
- if (f->src->channels == 3) {
- /* just set the alpha */
- for (i = 0; i < width; ++i) {
- data->channel[3] = 1.0;
- data++;
- }
- }
- else if (f->src->channels == 2) {
- /* copy the alpha to channel 3, duplicate the grey value */
- for (i = 0; i < width; ++i) {
- data->channel[3] = data->channel[1];
- data->channel[1] = data->channel[2] = data->channel[0];
- data++;
- }
+ if (f->src->channels != want_channels)
+ i_adapt_fcolors(want_channels, f->src->channels, data, width);
+}
+
+static void
+fill_opacity(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_color *data) {
+ struct i_fill_opacity_t *f = (struct i_fill_opacity_t *)fill;
+ int alpha_chan = channels > 2 ? 3 : 1;
+ i_color *datap = data;
+
+ (f->other_fill->f_fill_with_color)(f->other_fill, x, y, width, channels, data);
+ while (width--) {
+ double new_alpha = datap->channel[alpha_chan] * f->alpha_mult;
+ if (new_alpha < 0)
+ datap->channel[alpha_chan] = 0;
+ else if (new_alpha > 255)
+ datap->channel[alpha_chan] = 255;
+ else datap->channel[alpha_chan] = (int)(new_alpha + 0.5);
+
+ ++datap;
}
- else if (f->src->channels == 1) {
- /* set the alpha, duplicate grey */
- for (i = 0; i < width; ++i) {
- data->channel[3] = 1.0;
- data->channel[1] = data->channel[2] = data->channel[0];
- data++;
- }
+}
+static void
+fill_opacityf(i_fill_t *fill, i_img_dim x, i_img_dim y, i_img_dim width,
+ int channels, i_fcolor *data) {
+ struct i_fill_opacity_t *f = (struct i_fill_opacity_t *)fill;
+ int alpha_chan = channels > 2 ? 3 : 1;
+ i_fcolor *datap = data;
+
+ (f->other_fill->f_fill_with_fcolor)(f->other_fill, x, y, width, channels, data);
+
+ while (width--) {
+ double new_alpha = datap->channel[alpha_chan] * f->alpha_mult;
+ if (new_alpha < 0)
+ datap->channel[alpha_chan] = 0;
+ else if (new_alpha > 1.0)
+ datap->channel[alpha_chan] = 1.0;
+ else datap->channel[alpha_chan] = new_alpha;
+
+ ++datap;
}
}
-
/*
=back
projects / imager.git / blobdiff