diff options
author | Robin Watts <robin.watts@artifex.com> | 2013-05-09 20:07:42 +0100 |
---|---|---|
committer | Robin Watts <robin.watts@artifex.com> | 2013-05-14 15:08:26 +0100 |
commit | d80869b6422fc0d3541b8f2750e2f8deaaf38f4e (patch) | |
tree | f7b71b39e434fbcc52a4915e4ae068ec8ee12c7d /fitz | |
parent | 13577a1ec82a9443ddb1943582a4d387ba15a99f (diff) | |
download | mupdf-d80869b6422fc0d3541b8f2750e2f8deaaf38f4e.tar.xz |
svgwrite: First attempt at an SVG output device.
No font support (just font names are sent through).
No group support.
No shading support.
No image mask support.
Line art, text position/size, bitmaps, clipping all seem to work
though.
Diffstat (limited to 'fitz')
-rw-r--r-- | fitz/dev_svg.c | 620 | ||||
-rw-r--r-- | fitz/fitz.h | 2 |
2 files changed, 622 insertions, 0 deletions
diff --git a/fitz/dev_svg.c b/fitz/dev_svg.c new file mode 100644 index 00000000..1b71e576 --- /dev/null +++ b/fitz/dev_svg.c @@ -0,0 +1,620 @@ +#include "mupdf-internal.h" + +typedef struct svg_device_s svg_device; + +typedef struct tile_s tile; + +struct tile_s +{ + int pattern; + fz_matrix ctm; + fz_rect view; + fz_rect area; + fz_point step; +}; + +struct svg_device_s +{ + fz_context *ctx; + fz_output *out; + + int id; + + int num_tiles; + int max_tiles; + tile *tiles; +}; + +/* Helper functions */ + +static void +svg_dev_path(svg_device *sdev, fz_path *path) +{ + fz_output *out = sdev->out; + float x, y; + int i = 0; + fz_printf(out, " d=\""); + while (i < path->len) + { + switch (path->items[i++].k) + { + case FZ_MOVETO: + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "M %g %g ", x, y); + break; + case FZ_LINETO: + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "L %g %g ", x, y); + break; + case FZ_CURVETO: + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "C %g %g ", x, y); + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "%g %g ", x, y); + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "%g %g ", x, y); + break; + case FZ_CLOSE_PATH: + fz_printf(out, "Z "); + break; + } + } + fz_printf(out, "\""); +} + +static void +svg_dev_ctm(svg_device *sdev, const fz_matrix *ctm) +{ + fz_output *out = sdev->out; + + if (ctm->a != 1.0 || ctm->b != 0 || ctm->c != 0 || ctm->d != 1.0 || ctm->e != 0 || ctm->f != 0) + { + fz_printf(out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"", + ctm->a, ctm->b, ctm->c, ctm->d, ctm->e, ctm->f); + } +} + +static void +svg_dev_stroke_state(svg_device *sdev, fz_stroke_state *stroke_state) +{ + fz_output *out = sdev->out; + + fz_printf(out, " stroke-width=\"%g\"", stroke_state->linewidth); + fz_printf(out, " stroke-linecap=\"%s\"", + (stroke_state->start_cap == FZ_LINECAP_SQUARE ? "square" : + (stroke_state->start_cap == FZ_LINECAP_ROUND ? "round" : "butt"))); + if (stroke_state->dash_len != 0) + { + int i; + fz_printf(out, " stroke-dasharray="); + for (i = 0; i < stroke_state->dash_len; i++) + fz_printf(out, "%c%g", (i == 0 ? '\"' : ','), stroke_state->dash_list[i]); + fz_printf(out, "\""); + if (stroke_state->dash_phase != 0) + fz_printf(out, " stroke-dashoffset=\"%g\"", stroke_state->dash_phase); + } + if (stroke_state->linejoin == FZ_LINEJOIN_MITER || stroke_state->linejoin == FZ_LINEJOIN_MITER_XPS) + fz_printf(out, " stroke-miterlimit=\"%g\"", stroke_state->miterlimit); + fz_printf(out, " stroke-linejoin=\"%s\"", + (stroke_state->linejoin == FZ_LINEJOIN_BEVEL ? "bevel" : + (stroke_state->linejoin == FZ_LINEJOIN_ROUND ? "round" : "miter"))); +} + +static void +svg_dev_fill_color(svg_device *sdev, fz_colorspace *colorspace, float *color, float alpha) +{ + fz_context *ctx = sdev->ctx; + fz_output *out = sdev->out; + float rgb[FZ_MAX_COLORS]; + + if (colorspace != fz_device_rgb) + { + /* If it's not rgb, make it rgb */ + colorspace->to_rgb(ctx, colorspace, color, rgb); + color = rgb; + } + + if (color[0] == 0 && color[1] == 0 && color[2] == 0) + { + /* don't send a fill, as it will be assumed to be black */ + } + else + fz_printf(out, " fill=\"rgb(%d,%d,%d)\"", (int)(255*color[0] + 0.5), (int)(255*color[1] + 0.5), (int)(255*color[2]+0.5)); + if (alpha != 1) + fz_printf(out, " fill-opacity=\"%g\"", alpha); +} + +static void +svg_dev_stroke_color(svg_device *sdev, fz_colorspace *colorspace, float *color, float alpha) +{ + fz_context *ctx = sdev->ctx; + fz_output *out = sdev->out; + float rgb[FZ_MAX_COLORS]; + + if (colorspace != fz_device_rgb) + { + /* If it's not rgb, make it rgb */ + colorspace->to_rgb(ctx, colorspace, color, rgb); + color = rgb; + } + + fz_printf(out, " fill=\"none\" stroke=\"rgb(%d,%d,%d)\"", (int)(255*color[0] + 0.5), (int)(255*color[1] + 0.5), (int)(255*color[2]+0.5)); + if (alpha != 1) + fz_printf(out, " stroke-opacity=\"%g\"", alpha); +} + +static void +svg_dev_text(svg_device *sdev, const fz_matrix *ctm, fz_text *text) +{ + fz_output *out = sdev->out; + int i; + fz_matrix inverse; + fz_matrix local_trm; + float size; + + /* Rely on the fact that trm.{e,f} == 0 */ + size = fz_matrix_expansion(&text->trm); + local_trm.a = text->trm.a / size; + local_trm.b = text->trm.b / size; + local_trm.c = -text->trm.c / size; + local_trm.d = -text->trm.d / size; + local_trm.e = 0; + local_trm.f = 0; + fz_invert_matrix(&inverse, &local_trm); + fz_concat(&local_trm, &local_trm, ctm); + + fz_printf(out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"", + local_trm.a, local_trm.b, local_trm.c, local_trm.d, local_trm.e, local_trm.f); + fz_printf(out, " font-size=\"%g\"", size); + fz_printf(out, " font-family=\"%s\"", text->font->name); + + fz_printf(out, " x="); + for (i=0; i < text->len; i++) + { + fz_text_item *it = &text->items[i]; + fz_point p; + p.x = it->x; + p.y = it->y; + fz_transform_point(&p, &inverse); + fz_printf(out, "%c%g", i == 0 ? '\"' : ' ', p.x); + } + fz_printf(out, "\" y="); + for (i=0; i < text->len; i++) + { + fz_text_item *it = &text->items[i]; + fz_point p; + p.x = it->x; + p.y = it->y; + fz_transform_point(&p, &inverse); + fz_printf(out, "%c%g", i == 0 ? '\"' : ' ', p.y); + } + fz_printf(out, "\">\n"); + for (i=0; i < text->len; i++) + { + fz_text_item *it = &text->items[i]; + int c = it->ucs; + if (c >= 32 && c <= 127 && c != '<' && c != '&') + fz_printf(out, "%c", c); + else + fz_printf(out, "&#x%04x;", c); + } + fz_printf(out, "\n</text>\n"); +} + + +/* Entry points */ + +static void +svg_dev_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, + fz_colorspace *colorspace, float *color, float alpha) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "<path"); + svg_dev_ctm(sdev, ctm); + svg_dev_path(sdev, path); + svg_dev_fill_color(sdev, colorspace, color, alpha); + if (even_odd) + fz_printf(out, " fill-rule=\"evenodd\" "); + fz_printf(out, "/>\n"); +} + +static void +svg_dev_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, + fz_colorspace *colorspace, float *color, float alpha) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "<path"); + svg_dev_ctm(sdev, ctm); + svg_dev_stroke_state(sdev, stroke); + svg_dev_stroke_color(sdev, colorspace, color, alpha); + svg_dev_path(sdev, path); + fz_printf(out, "/>\n"); +} + +static void +svg_dev_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + int num = sdev->id++; + + fz_printf(out, "<clipPath id=\"cp%d\">\n", num); + fz_printf(out, "<path"); + svg_dev_ctm(sdev, ctm); + svg_dev_path(sdev, path); + if (even_odd) + fz_printf(out, " fill-rule=\"evenodd\" "); + fz_printf(out, "/>\n</clipPath>\n<g clip-path=\"url(#cp%d)\">\n", num); +} + +static void +svg_dev_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + fz_context *ctx = dev->ctx; + fz_rect bounds; + int num = sdev->id++; + float white[3] = { 255, 255, 255 }; + + fz_bound_path(ctx, path, stroke, ctm, &bounds); + + fz_printf(out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\" >\n", + num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); + fz_printf(out, "<path"); + svg_dev_ctm(sdev, ctm); + svg_dev_stroke_state(sdev, stroke); + svg_dev_stroke_color(sdev, fz_device_rgb, white, 1); + svg_dev_path(sdev, path); + fz_printf(out, "/>\n</mask>\n<g mask=\"url(#ma%d)\">\n", num); +} + +static void +svg_dev_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, + fz_colorspace *colorspace, float *color, float alpha) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "<text"); + svg_dev_fill_color(sdev, colorspace, color, alpha); + svg_dev_text(sdev, ctm, text); +} + +static void +svg_dev_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, + fz_colorspace *colorspace, float *color, float alpha) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "<text"); + svg_dev_ctm(sdev, ctm); + svg_dev_stroke_state(sdev, stroke); + svg_dev_stroke_color(sdev, colorspace, color, alpha); + svg_dev_text(sdev, ctm, text); +} + +static void +svg_dev_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + fz_context *ctx = dev->ctx; + fz_rect bounds; + int num = sdev->id++; + float white[3] = { 255, 255, 255 }; + + fz_bound_text(ctx, text, NULL, ctm, &bounds); + + fz_printf(out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\" >\n", + num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); + fz_printf(out, "<text"); + svg_dev_fill_color(sdev, fz_device_rgb, white, 1.0f); + svg_dev_text(sdev, ctm, text); + fz_printf(out, "</mask>\n<g mask=\"url(#ma%d)\">\n", num); +} + +static void +svg_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + fz_context *ctx = dev->ctx; + fz_rect bounds; + int num = sdev->id++; + float white[3] = { 255, 255, 255 }; + + fz_bound_text(ctx, text, NULL, ctm, &bounds); + + fz_printf(out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\" >\n", + num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); + fz_printf(out, "<text"); + svg_dev_stroke_state(sdev, stroke); + svg_dev_stroke_color(sdev, fz_device_rgb, white, 1.0f); + svg_dev_text(sdev, ctm, text); + fz_printf(out, "</mask>\n<g mask=\"url(#ma%d)\">\n", num); +} + +static void +svg_dev_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +{ +} + +static void +send_data_base64(fz_output *out, fz_buffer *buffer) +{ + int i, len; + static const char set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + len = buffer->len/3; + for (i = 0; i < len; i++) + { + int c = buffer->data[3*i]; + int d = buffer->data[3*i+1]; + int e = buffer->data[3*i+2]; + if ((i & 15) == 0) + fz_printf(out, "\n"); + fz_printf(out, "%c%c%c%c", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)|(e>>6)], set[e & 63]); + } + i *= 3; + switch (buffer->len-i) + { + case 2: + { + int c = buffer->data[i]; + int d = buffer->data[i+1]; + fz_printf(out, "%c%c%c=", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)]); + break; + } + case 1: + { + int c = buffer->data[i]; + fz_printf(out, "%c%c==", set[c>>2], set[(c&3)<<4]); + break; + } + default: + case 0: + break; + } +} + +static void +svg_dev_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +{ + svg_device *sdev = (svg_device *)dev->user; + fz_context *ctx = dev->ctx; + fz_output *out = sdev->out; + fz_matrix local_ctm = *ctm; + fz_matrix scale = { 1.0f/image->w, 0, 0, 1.0f/image->h, 0, 0}; + + fz_concat(&local_ctm, &scale, ctm); + fz_printf(out, "<image"); + svg_dev_ctm(sdev, &local_ctm); + fz_printf(out, "width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:", image->w, image->h); + switch (image->buffer == NULL ? FZ_IMAGE_JPX : image->buffer->params.type) + { + case FZ_IMAGE_JPEG: + fz_printf(out, "image/jpeg;base64,"); + send_data_base64(out, image->buffer->buffer); + break; + case FZ_IMAGE_PNG: + fz_printf(out, "image/png;base64,"); + send_data_base64(out, image->buffer->buffer); + break; + default: + { + fz_buffer *buf = fz_image_as_png(ctx, image, image->w, image->h); + fz_printf(out, "image/png;base64,"); + send_data_base64(out, buf); + fz_drop_buffer(ctx, buf); + break; + } + } + fz_printf(out, "\"/>\n"); +} + +static void +svg_dev_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +{ +} + +static void +svg_dev_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +fz_colorspace *colorspace, float *color, float alpha) +{ +} + +static void +svg_dev_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "<g>\n"); +} + +static void +svg_dev_pop_clip(fz_device *dev) +{ + svg_device *sdev = (svg_device *)dev->user; + fz_output *out = sdev->out; + + /* FIXME */ + fz_printf(out, "</g>\n"); +} + +static void +svg_dev_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) +{ +} + +static void +svg_dev_end_mask(fz_device *dev) +{ + +} + +static void +svg_dev_begin_group(fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) +{ + +} + +static void +svg_dev_end_group(fz_device *dev) +{ + +} + +static int +svg_dev_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +{ + svg_device *sdev = (svg_device *)dev->user; + fz_output *out = sdev->out; + fz_context *ctx = dev->ctx; + fz_matrix inverse; + int num; + tile *t; + + if (sdev->num_tiles == sdev->max_tiles) + { + int n = (sdev->num_tiles == 0 ? 4 : sdev->num_tiles * 2); + + sdev->tiles = fz_resize_array(ctx, sdev->tiles, n, sizeof(tile)); + sdev->max_tiles = n; + } + num = sdev->num_tiles++; + t = &sdev->tiles[num]; + t->area = *area; + t->view = *view; + t->ctm = *ctm; + t->pattern = sdev->id++; + t->step.x = xstep; + t->step.y = ystep; + + /* view = area of our reference tile in pattern space. + * area = area to tile into in pattern space. + * xstep/ystep = pattern repeat step in pattern space. + * All of these need to be transformed by ctm to get to device space. + * SVG only allows us to specify pattern tiles as axis aligned + * rectangles, so we send these through as is, and ensure that the + * correct matrix is used on the fill. + */ + + /* In svg, the reference tile is taken from (x,y) to (x+width,y+height) + * and is repeated at (x+n*width,y+m*height) for all integer n and m. + * This means that width and height correspond to xstep and ystep. */ + fz_printf(out, "<pattern id=\"pa%d\" patternUnits=\"userSpaceOnUse\" patternContentUnits=\"userSpaceOnUse\"", + t->pattern); + fz_printf(out, " x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\">\n", + view->x0, view->y0, xstep, ystep); + /* All the pattern contents will have their own ctm applied. Let's + * undo the current one to allow for this */ + fz_invert_matrix(&inverse, ctm); + fz_printf(out, "<g"); + svg_dev_ctm(sdev, &inverse); + fz_printf(out, ">\n"); + + return 0; +} + +static void +svg_dev_end_tile(fz_device *dev) +{ + svg_device *sdev = (svg_device *)dev->user; + fz_output *out = sdev->out; + int num; + tile *t; + + if (sdev->num_tiles == 0) + return; + num = --sdev->num_tiles; + t = &sdev->tiles[num]; + + fz_printf(out, "</g>\n</pattern>\n"); + fz_printf(out, "<rect"); + svg_dev_ctm(sdev, &t->ctm); + fz_printf(out, " fill=\"url(#pa%d)\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\"/>\n", + t->pattern, t->area.x0, t->area.y0, t->area.x1 - t->area.x0, t->area.y1 - t->area.y0); +} + +static void +svg_dev_free_user(fz_device *dev) +{ + svg_device *sdev = dev->user; + fz_context *ctx = sdev->ctx; + fz_output *out = sdev->out; + + fz_free(ctx, sdev->tiles); + + fz_printf(out, "</svg>\n"); + + fz_free(ctx, sdev); +} + +fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, float page_height) +{ + svg_device *sdev = fz_malloc_struct(ctx, svg_device); + fz_device *dev; + + fz_try(ctx) + { + sdev->ctx = ctx; + sdev->out = out; + sdev->id = 0; + + dev = fz_new_device(ctx, sdev); + } + fz_catch(ctx) + { + fz_free(ctx, sdev); + fz_rethrow(ctx); + } + + dev->free_user = svg_dev_free_user; + + dev->fill_path = svg_dev_fill_path; + dev->stroke_path = svg_dev_stroke_path; + dev->clip_path = svg_dev_clip_path; + dev->clip_stroke_path = svg_dev_clip_stroke_path; + + dev->fill_text = svg_dev_fill_text; + dev->stroke_text = svg_dev_stroke_text; + dev->clip_text = svg_dev_clip_text; + dev->clip_stroke_text = svg_dev_clip_stroke_text; + dev->ignore_text = svg_dev_ignore_text; + + dev->fill_shade = svg_dev_fill_shade; + dev->fill_image = svg_dev_fill_image; + dev->fill_image_mask = svg_dev_fill_image_mask; + dev->clip_image_mask = svg_dev_clip_image_mask; + + dev->pop_clip = svg_dev_pop_clip; + + dev->begin_mask = svg_dev_begin_mask; + dev->end_mask = svg_dev_end_mask; + dev->begin_group = svg_dev_begin_group; + dev->end_group = svg_dev_end_group; + + dev->begin_tile = svg_dev_begin_tile; + dev->end_tile = svg_dev_end_tile; + + fz_printf(out, "<?xml version=\"1.0\" standalone=\"no\"?>\n"); + fz_printf(out, "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n"); + fz_printf(out, "<svg xmlns=\"http://www.w3.org/2000/svg\" " + "xmlns:xlink=\"http://www.w3.org/1999/xlink\" version=\"1.1\" " + "width=\"%gcm\" height=\"%gcm\" viewBox=\"0 0 %g %g\">\n", + page_width*2.54/72, page_height*2.54/72, page_width, page_height); + + return dev; +} diff --git a/fitz/fitz.h b/fitz/fitz.h index 2cea5424..5eb570d0 100644 --- a/fitz/fitz.h +++ b/fitz/fitz.h @@ -1901,6 +1901,8 @@ fz_device *fz_new_draw_device(fz_context *ctx, fz_pixmap *dest); */ fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, const fz_irect *clip); +fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, float page_height); + /* fz_enable_device_hints : Enable hints in a device. |