diff options
author | Tor Andersson <tor.andersson@artifex.com> | 2013-06-19 15:29:44 +0200 |
---|---|---|
committer | Tor Andersson <tor.andersson@artifex.com> | 2013-06-20 16:45:35 +0200 |
commit | 0a927854a10e1e6b9770a81e2e1d9f3093631757 (patch) | |
tree | 3d65d820d9fdba2d0d394d99c36290c851b78ca0 /source/xps/xps-gradient.c | |
parent | 1ae8f19179c5f0f8c6352b3c7855465325d5449a (diff) | |
download | mupdf-0a927854a10e1e6b9770a81e2e1d9f3093631757.tar.xz |
Rearrange source files.
Diffstat (limited to 'source/xps/xps-gradient.c')
-rw-r--r-- | source/xps/xps-gradient.c | 525 |
1 files changed, 525 insertions, 0 deletions
diff --git a/source/xps/xps-gradient.c b/source/xps/xps-gradient.c new file mode 100644 index 00000000..88ed470b --- /dev/null +++ b/source/xps/xps-gradient.c @@ -0,0 +1,525 @@ +#include "mupdf/xps.h" + +#define MAX_STOPS 256 + +enum { SPREAD_PAD, SPREAD_REPEAT, SPREAD_REFLECT }; + +/* + * Parse a list of GradientStop elements. + * Fill the offset and color arrays, and + * return the number of stops parsed. + */ + +struct stop +{ + float offset; + float r, g, b, a; +}; + +static int cmp_stop(const void *a, const void *b) +{ + const struct stop *astop = a; + const struct stop *bstop = b; + float diff = astop->offset - bstop->offset; + if (diff < 0) + return -1; + if (diff > 0) + return 1; + return 0; +} + +static inline float lerp(float a, float b, float x) +{ + return a + (b - a) * x; +} + +static int +xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, + struct stop *stops, int maxcount) +{ + fz_colorspace *colorspace; + float sample[8]; + float rgb[3]; + int before, after; + int count; + int i; + + /* We may have to insert 2 extra stops when postprocessing */ + maxcount -= 2; + + count = 0; + while (node && count < maxcount) + { + if (!strcmp(fz_xml_tag(node), "GradientStop")) + { + char *offset = fz_xml_att(node, "Offset"); + char *color = fz_xml_att(node, "Color"); + if (offset && color) + { + stops[count].offset = fz_atof(offset); + + xps_parse_color(doc, base_uri, color, &colorspace, sample); + + fz_convert_color(doc->ctx, fz_device_rgb(doc->ctx), rgb, colorspace, sample + 1); + + stops[count].r = rgb[0]; + stops[count].g = rgb[1]; + stops[count].b = rgb[2]; + stops[count].a = sample[0]; + + count ++; + } + } + node = fz_xml_next(node); + } + + if (count == 0) + { + fz_warn(doc->ctx, "gradient brush has no gradient stops"); + stops[0].offset = 0; + stops[0].r = 0; + stops[0].g = 0; + stops[0].b = 0; + stops[0].a = 1; + stops[1].offset = 1; + stops[1].r = 1; + stops[1].g = 1; + stops[1].b = 1; + stops[1].a = 1; + return 2; + } + + if (count == maxcount) + fz_warn(doc->ctx, "gradient brush exceeded maximum number of gradient stops"); + + /* Postprocess to make sure the range of offsets is 0.0 to 1.0 */ + + qsort(stops, count, sizeof(struct stop), cmp_stop); + + before = -1; + after = -1; + + for (i = 0; i < count; i++) + { + if (stops[i].offset < 0) + before = i; + if (stops[i].offset > 1) + { + after = i; + break; + } + } + + /* Remove all stops < 0 except the largest one */ + if (before > 0) + { + memmove(stops, stops + before, (count - before) * sizeof(struct stop)); + count -= before; + } + + /* Remove all stops > 1 except the smallest one */ + if (after >= 0) + count = after + 1; + + /* Expand single stop to 0 .. 1 */ + if (count == 1) + { + stops[1] = stops[0]; + stops[0].offset = 0; + stops[1].offset = 1; + return 2; + } + + /* First stop < 0 -- interpolate value to 0 */ + if (stops[0].offset < 0) + { + float d = -stops[0].offset / (stops[1].offset - stops[0].offset); + stops[0].offset = 0; + stops[0].r = lerp(stops[0].r, stops[1].r, d); + stops[0].g = lerp(stops[0].g, stops[1].g, d); + stops[0].b = lerp(stops[0].b, stops[1].b, d); + stops[0].a = lerp(stops[0].a, stops[1].a, d); + } + + /* Last stop > 1 -- interpolate value to 1 */ + if (stops[count-1].offset > 1) + { + float d = (1 - stops[count-2].offset) / (stops[count-1].offset - stops[count-2].offset); + stops[count-1].offset = 1; + stops[count-1].r = lerp(stops[count-2].r, stops[count-1].r, d); + stops[count-1].g = lerp(stops[count-2].g, stops[count-1].g, d); + stops[count-1].b = lerp(stops[count-2].b, stops[count-1].b, d); + stops[count-1].a = lerp(stops[count-2].a, stops[count-1].a, d); + } + + /* First stop > 0 -- insert a duplicate at 0 */ + if (stops[0].offset > 0) + { + memmove(stops + 1, stops, count * sizeof(struct stop)); + stops[0] = stops[1]; + stops[0].offset = 0; + count++; + } + + /* Last stop < 1 -- insert a duplicate at 1 */ + if (stops[count-1].offset < 1) + { + stops[count] = stops[count-1]; + stops[count].offset = 1; + count++; + } + + return count; +} + +static void +xps_sample_gradient_stops(fz_shade *shade, struct stop *stops, int count) +{ + float offset, d; + int i, k; + + k = 0; + for (i = 0; i < 256; i++) + { + offset = i / 255.0f; + while (k + 1 < count && offset > stops[k+1].offset) + k++; + + d = (offset - stops[k].offset) / (stops[k+1].offset - stops[k].offset); + + shade->function[i][0] = lerp(stops[k].r, stops[k+1].r, d); + shade->function[i][1] = lerp(stops[k].g, stops[k+1].g, d); + shade->function[i][2] = lerp(stops[k].b, stops[k+1].b, d); + shade->function[i][3] = lerp(stops[k].a, stops[k+1].a, d); + } +} + +/* + * Radial gradients map more or less to Radial shadings. + * The inner circle is always a point. + * The outer circle is actually an ellipse, + * mess with the transform to squash the circle into the right aspect. + */ + +static void +xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, + struct stop *stops, int count, + int extend, + float x0, float y0, float r0, + float x1, float y1, float r1) +{ + fz_shade *shade; + + /* TODO: this (and the stuff in pdf_shade) should move to res_shade.c */ + shade = fz_malloc_struct(doc->ctx, fz_shade); + FZ_INIT_STORABLE(shade, 1, fz_free_shade_imp); + shade->colorspace = fz_device_rgb(doc->ctx); + shade->bbox = fz_infinite_rect; + shade->matrix = fz_identity; + shade->use_background = 0; + shade->use_function = 1; + shade->type = FZ_RADIAL; + shade->u.l_or_r.extend[0] = extend; + shade->u.l_or_r.extend[1] = extend; + + xps_sample_gradient_stops(shade, stops, count); + + shade->u.l_or_r.coords[0][0] = x0; + shade->u.l_or_r.coords[0][1] = y0; + shade->u.l_or_r.coords[0][2] = r0; + shade->u.l_or_r.coords[1][0] = x1; + shade->u.l_or_r.coords[1][1] = y1; + shade->u.l_or_r.coords[1][2] = r1; + + fz_fill_shade(doc->dev, shade, ctm, 1); + + fz_drop_shade(doc->ctx, shade); +} + +/* + * Linear gradients. + */ + +static void +xps_draw_one_linear_gradient(xps_document *doc, const fz_matrix *ctm, + struct stop *stops, int count, + int extend, + float x0, float y0, float x1, float y1) +{ + fz_shade *shade; + + /* TODO: this (and the stuff in pdf_shade) should move to res_shade.c */ + shade = fz_malloc_struct(doc->ctx, fz_shade); + FZ_INIT_STORABLE(shade, 1, fz_free_shade_imp); + shade->colorspace = fz_device_rgb(doc->ctx); + shade->bbox = fz_infinite_rect; + shade->matrix = fz_identity; + shade->use_background = 0; + shade->use_function = 1; + shade->type = FZ_LINEAR; + shade->u.l_or_r.extend[0] = extend; + shade->u.l_or_r.extend[1] = extend; + + xps_sample_gradient_stops(shade, stops, count); + + shade->u.l_or_r.coords[0][0] = x0; + shade->u.l_or_r.coords[0][1] = y0; + shade->u.l_or_r.coords[0][2] = 0; + shade->u.l_or_r.coords[1][0] = x1; + shade->u.l_or_r.coords[1][1] = y1; + shade->u.l_or_r.coords[1][2] = 0; + + fz_fill_shade(doc->dev, shade, ctm, doc->opacity[doc->opacity_top]); + + fz_drop_shade(doc->ctx, shade); +} + +/* + * We need to loop and create many shading objects to account + * for the Repeat and Reflect SpreadMethods. + * I'm not smart enough to calculate this analytically + * so we iterate and check each object until we + * reach a reasonable limit for infinite cases. + */ + +static inline float point_inside_circle(float px, float py, float x, float y, float r) +{ + float dx = px - x; + float dy = py - y; + return dx * dx + dy * dy <= r * r; +} + +static void +xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, + struct stop *stops, int count, + fz_xml *root, int spread) +{ + float x0, y0, r0; + float x1, y1, r1; + float xrad = 1; + float yrad = 1; + float invscale; + int i, ma = 1; + fz_matrix local_ctm = *ctm; + fz_matrix inv; + fz_rect local_area = *area; + + char *center_att = fz_xml_att(root, "Center"); + char *origin_att = fz_xml_att(root, "GradientOrigin"); + char *radius_x_att = fz_xml_att(root, "RadiusX"); + char *radius_y_att = fz_xml_att(root, "RadiusY"); + + x0 = y0 = 0.0; + x1 = y1 = 1.0; + xrad = 1.0; + yrad = 1.0; + + if (origin_att) + xps_parse_point(origin_att, &x0, &y0); + if (center_att) + xps_parse_point(center_att, &x1, &y1); + if (radius_x_att) + xrad = fz_atof(radius_x_att); + if (radius_y_att) + yrad = fz_atof(radius_y_att); + + xrad = fz_max(0.01f, xrad); + yrad = fz_max(0.01f, yrad); + + /* scale the ctm to make ellipses */ + if (fz_abs(xrad) > FLT_EPSILON) + { + fz_pre_scale(&local_ctm, 1, yrad/xrad); + } + + if (yrad != 0.0) + { + invscale = xrad / yrad; + y0 = y0 * invscale; + y1 = y1 * invscale; + } + + r0 = 0; + r1 = xrad; + + fz_transform_rect(&local_area, fz_invert_matrix(&inv, &local_ctm)); + ma = fz_maxi(ma, ceilf(hypotf(local_area.x0 - x0, local_area.y0 - y0) / xrad)); + ma = fz_maxi(ma, ceilf(hypotf(local_area.x1 - x0, local_area.y0 - y0) / xrad)); + ma = fz_maxi(ma, ceilf(hypotf(local_area.x0 - x0, local_area.y1 - y0) / xrad)); + ma = fz_maxi(ma, ceilf(hypotf(local_area.x1 - x0, local_area.y1 - y0) / xrad)); + + if (spread == SPREAD_REPEAT) + { + for (i = ma - 1; i >= 0; i--) + xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); + } + else if (spread == SPREAD_REFLECT) + { + if ((ma % 2) != 0) + ma++; + for (i = ma - 2; i >= 0; i -= 2) + { + xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); + xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad); + } + } + else + { + xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 1, x0, y0, r0, x1, y1, r1); + } +} + +/* + * Calculate how many iterations are needed to cover + * the bounding box. + */ + +static void +xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, + struct stop *stops, int count, + fz_xml *root, int spread) +{ + float x0, y0, x1, y1; + int i, mi, ma; + float dx, dy, x, y, k; + fz_point p1, p2; + fz_matrix inv; + fz_rect local_area = *area; + + char *start_point_att = fz_xml_att(root, "StartPoint"); + char *end_point_att = fz_xml_att(root, "EndPoint"); + + x0 = y0 = 0; + x1 = y1 = 1; + + if (start_point_att) + xps_parse_point(start_point_att, &x0, &y0); + if (end_point_att) + xps_parse_point(end_point_att, &x1, &y1); + + p1.x = x0; p1.y = y0; p2.x = x1; p2.y = y1; + fz_transform_rect(&local_area, fz_invert_matrix(&inv, ctm)); + x = p2.x - p1.x; y = p2.y - p1.y; + k = ((local_area.x0 - p1.x) * x + (local_area.y0 - p1.y) * y) / (x * x + y * y); + mi = floorf(k); ma = ceilf(k); + k = ((local_area.x1 - p1.x) * x + (local_area.y0 - p1.y) * y) / (x * x + y * y); + mi = fz_mini(mi, floorf(k)); ma = fz_maxi(ma, ceilf(k)); + k = ((local_area.x0 - p1.x) * x + (local_area.y1 - p1.y) * y) / (x * x + y * y); + mi = fz_mini(mi, floorf(k)); ma = fz_maxi(ma, ceilf(k)); + k = ((local_area.x1 - p1.x) * x + (local_area.y1 - p1.y) * y) / (x * x + y * y); + mi = fz_mini(mi, floorf(k)); ma = fz_maxi(ma, ceilf(k)); + dx = x1 - x0; dy = y1 - y0; + + if (spread == SPREAD_REPEAT) + { + for (i = mi; i < ma; i++) + xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); + } + else if (spread == SPREAD_REFLECT) + { + if ((mi % 2) != 0) + mi--; + for (i = mi; i < ma; i += 2) + { + xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); + xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + (i + 2) * dx, y0 + (i + 2) * dy, x1 + i * dx, y1 + i * dy); + } + } + else + { + xps_draw_one_linear_gradient(doc, ctm, stops, count, 1, x0, y0, x1, y1); + } +} + +/* + * Parse XML tag and attributes for a gradient brush, create color/opacity + * function objects and call gradient drawing primitives. + */ + +static void +xps_parse_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, + char *base_uri, xps_resource *dict, fz_xml *root, + void (*draw)(xps_document *, const fz_matrix*, const fz_rect *, struct stop *, int, fz_xml *, int)) +{ + fz_xml *node; + + char *opacity_att; + char *spread_att; + char *transform_att; + + fz_xml *transform_tag = NULL; + fz_xml *stop_tag = NULL; + + struct stop stop_list[MAX_STOPS]; + int stop_count; + fz_matrix transform; + int spread_method; + + opacity_att = fz_xml_att(root, "Opacity"); + spread_att = fz_xml_att(root, "SpreadMethod"); + transform_att = fz_xml_att(root, "Transform"); + + for (node = fz_xml_down(root); node; node = fz_xml_next(node)) + { + if (!strcmp(fz_xml_tag(node), "LinearGradientBrush.Transform")) + transform_tag = fz_xml_down(node); + if (!strcmp(fz_xml_tag(node), "RadialGradientBrush.Transform")) + transform_tag = fz_xml_down(node); + if (!strcmp(fz_xml_tag(node), "LinearGradientBrush.GradientStops")) + stop_tag = fz_xml_down(node); + if (!strcmp(fz_xml_tag(node), "RadialGradientBrush.GradientStops")) + stop_tag = fz_xml_down(node); + } + + xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); + + spread_method = SPREAD_PAD; + if (spread_att) + { + if (!strcmp(spread_att, "Pad")) + spread_method = SPREAD_PAD; + if (!strcmp(spread_att, "Reflect")) + spread_method = SPREAD_REFLECT; + if (!strcmp(spread_att, "Repeat")) + spread_method = SPREAD_REPEAT; + } + + transform = fz_identity; + if (transform_att) + xps_parse_render_transform(doc, transform_att, &transform); + if (transform_tag) + xps_parse_matrix_transform(doc, transform_tag, &transform); + fz_concat(&transform, &transform, ctm); + + if (!stop_tag) { + fz_warn(doc->ctx, "missing gradient stops tag"); + return; + } + + stop_count = xps_parse_gradient_stops(doc, base_uri, stop_tag, stop_list, MAX_STOPS); + if (stop_count == 0) + { + fz_warn(doc->ctx, "no gradient stops found"); + return; + } + + xps_begin_opacity(doc, &transform, area, base_uri, dict, opacity_att, NULL); + + draw(doc, &transform, area, stop_list, stop_count, root, spread_method); + + xps_end_opacity(doc, base_uri, dict, opacity_att, NULL); +} + +void +xps_parse_linear_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, + char *base_uri, xps_resource *dict, fz_xml *root) +{ + xps_parse_gradient_brush(doc, ctm, area, base_uri, dict, root, xps_draw_linear_gradient); +} + +void +xps_parse_radial_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, + char *base_uri, xps_resource *dict, fz_xml *root) +{ + xps_parse_gradient_brush(doc, ctm, area, base_uri, dict, root, xps_draw_radial_gradient); +} |