dymokomi/luce-svg
Source of release 0.9.1
0.9.1 / src / svg / convert.lucb
#==============================================================================================
#
# svg/convert - Converting the document tree into a picture
#
# DESCRIPTION:
# Walks the SVG tree and builds the render tree (scene.lucb), as resvg's usvg does:
# elements that are not displayed, fail their conditions or have a singular
# transform are skipped; each container or shape becomes a group only when it
# needs one (a transform, opacity, blend mode, isolation, clip path, mask or
# filter, or being a `g` or `use`), else its content joins its parent; shapes
# become paths with their paints resolved (convert_paint.lucb); `use`, `symbol`,
# nested `svg` and `switch` are expanded (convert_use.lucb). Lengths resolve here
# against the nearest viewport, the font size and the DPI.
#
#==============================================================================================
## How a document is read and converted.
pub struct Options:
## Pixels per inch, for in, cm, mm, pt and pc.
pub var dpi: f64 = 96.0
## The font size em and ex resolve against where no element sets one.
pub var font_size: f64 = 12.0
## The size of a document whose width or height is a percentage with no viewBox.
pub var default_width: f64 = 100.0
pub var default_height: f64 = 100.0
## The user's languages for `systemLanguage`, comma separated.
pub var languages: str = "en"
## The directory relative image references resolve against; "" loads no files.
pub var resources: str = ""
## Where `<text>` gets its glyphs. Without a source, text is set in the system's fonts
## (FontFiles.system(), made once, on the first text that needs it), or not drawn when
## `system_fonts` is false.
pub var glyphs: GlyphSource? = none
## Whether text without a GlyphSource is set in the system's fonts.
pub var system_fonts: bool = true
## What the conversion of one element knows about where it stands.
struct State:
## Inside a clip path's content: no strokes, opacity, masks or filters.
var clip_child: bool = false
## The nearest viewport, for percentages.
var view_box: Rect = Rect(w = 100.0, h = 100.0)
## The width and height a `use` gives the `svg` it references, if any.
var use_width: f64? = none
var use_height: f64? = none
## What context-fill and context-stroke paint with, inside a marker or a `use`.
var context_fill: Brush? = none
var context_stroke: Brush? = none
## The state of one conversion.
struct Converter:
var tree: const Tree*
var picture: Picture*
var options: Options
## Per tree node: the paint server converted from it, as kind (1 gradient, 2
## pattern, 3 a plain color) and index; 0 when not converted yet.
var servers: u32[]
var server_colors: List[Rgba] = List[Rgba]()
## Elements being converted as clip paths, masks or patterns, so references back to
## one of them are refused rather than followed for ever.
var active: List[u32] = List[u32]()
## Whether this conversion holds the system fonts (system_glyphs).
var system_fonts_held: bool = false
func release():
if self.servers.length > 0:
free(self.servers) in memory.heap
self.server_colors.release()
self.active.release()
if self.system_fonts_held:
system_fonts_lock.unlock()
self.system_fonts_held = false
## Where text gets its glyphs: the caller's source, else the system's fonts, which the
## conversion holds (one at a time) until it is released.
func glyph_source() -> GlyphSource?:
if let source = self.options.glyphs:
return source
if not self.options.system_fonts:
return none
if not self.system_fonts_held:
system_fonts_lock.lock()
self.system_fonts_held = true
let system = system_glyphs() else return none
return system
func entered(node: u32) -> bool:
for at in self.active.view():
if at == node:
return true
return false
# mark: Attributes ==========================================================================
func attribute(node: u32, name: Attr) -> str?:
return self.tree.attribute(node, name)
func has(node: u32, name: Attr) -> bool:
return self.tree.has(node, name)
## A length attribute in user units (`bbox_units`: as a fraction of a box); `default`
## when absent or unreadable.
func length(node: u32, name: Attr, bbox_units: bool, state: const State*, default: Length) -> f64:
var value = default
if let text = self.attribute(node, name):
value = parse_length(text) else default
return self.resolve_length(node, name, value, bbox_units, state)
func user_length(node: u32, name: Attr, state: const State*, default: Length) -> f64:
return self.length(node, name, false, state, default)
## `value`, set on `node` for `name`, in user units.
func resolve_length(node: u32, name: Attr, value: Length, bbox_units: bool, state: const State*) -> f64:
let n = value.number
match value.unit:
.plain, .px:
return n
.em:
return n * self.font_size(node)
.ex:
return n * self.font_size(node) * 0.5
.inch:
return n * self.options.dpi
.cm:
return n * self.options.dpi / 2.54
.mm:
return n * self.options.dpi / 25.4
.pt:
return n * self.options.dpi / 72.0
.pc:
return n * self.options.dpi / 6.0
.percent:
if bbox_units:
return n / 100.0
let box = state.view_box
if is_horizontal(name):
return box.w * n / 100.0
if is_vertical(name):
return box.h * n / 100.0
return math.sqrt((box.w * box.w + box.h * box.h) * 0.5) * n / 100.0
## The font size in effect at `node`, in pixels.
func font_size(node: u32) -> f64:
let parent = self.tree.nodes.items[node].parent
let inherited = self.options.font_size if parent == 0 else self.font_size(parent)
if self.tree.nodes.items[node].kind != Kind.element:
return inherited
let text = self.attribute(node, Attr.font_size) else return inherited
if let size = parse_length(text):
let n = size.number
match size.unit:
.plain, .px:
return n
.em:
return n * inherited
.ex:
return n * inherited * 0.5
.inch:
return n * self.options.dpi
.cm:
return n * self.options.dpi / 2.54
.mm:
return n * self.options.dpi / 25.4
.pt:
return n * self.options.dpi / 72.0
.pc:
return n * self.options.dpi / 6.0
.percent:
return n * inherited * 0.01
let names: str[9] = ["xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large", "smaller", "larger"]
let steps: f64[9] = [-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, -1.0, 1.0]
for index in 0..<names.length:
if text == names[index]:
return inherited * math.pow(1.2, steps[index])
return inherited
## A number attribute, else `default`.
func number(node: u32, name: Attr, default: f64) -> f64:
let text = self.attribute(node, name) else return default
return parse_number(text) else default
## An opacity: a number or a percentage, clamped to 0..1, else `default`.
func opacity(node: u32, name: Attr, default: f64) -> f64:
let text = self.attribute(node, name) else return default
let value = parse_length(text) else return default
if value.unit == Unit.percent:
return math.clamp(value.number / 100.0, 0.0, 1.0)
if value.unit == Unit.plain:
return math.clamp(value.number, 0.0, 1.0)
return default
## The applicable value of an inherited (or parent-inherited) property.
func find(node: u32, name: Attr) -> str?:
return self.tree.find(node, name)
## An element's transform with its transform-origin, identity when absent or invalid.
func transform_of(node: u32, name: Attr, state: const State*) -> Matrix:
let text = self.attribute(node, name) else return Matrix()
var transform = parse_transform_list(text) else return Matrix()
# A singular transform reads as none (elements with one are not drawn at all).
if not invertible(transform):
return Matrix()
if let origin = self.attribute(node, Attr.transform_origin):
let (ox, oy) = self.transform_origin(node, origin, state)
transform = multiply(multiply(Matrix(e = ox, f = oy), transform), Matrix(e = -ox, f = -oy))
return transform
## The point a transform-origin value names, as svgtypes reads one: one or two
## positions (lengths, or left, center, right, top and bottom in either order) and
## an optional z length; anything else is the origin.
func transform_origin(node: u32, text: str, state: const State*) -> (f64, f64):
var scanner = Scanner(data = text.bytes)
var parts: Length[2] = [Length(), Length()]
var kinds: u8[2] = [0, 0]
var count: usize = 0
while count < 3:
scanner.skip_spaces()
if scanner.at_end():
break
if count == 2:
let z = scanner.length() else return (0.0, 0.0)
if z.unit == Unit.percent:
return (0.0, 0.0)
count += 1
scanner.skip_separator()
continue
# kind: 1 horizontal keyword, 2 vertical keyword, 3 center or a length.
if is_alpha(scanner.peek()):
let word = scanner.identifier()
let percent = Unit.percent
if word == "left":
parts[count] = Length(number = 0.0, unit = percent)
kinds[count] = 1
elif word == "right":
parts[count] = Length(number = 100.0, unit = percent)
kinds[count] = 1
elif word == "top":
parts[count] = Length(number = 0.0, unit = percent)
kinds[count] = 2
elif word == "bottom":
parts[count] = Length(number = 100.0, unit = percent)
kinds[count] = 2
elif word == "center":
parts[count] = Length(number = 50.0, unit = percent)
kinds[count] = 3
else:
return (0.0, 0.0)
else:
parts[count] = scanner.length() else return (0.0, 0.0)
kinds[count] = 3
count += 1
scanner.skip_separator()
scanner.skip_spaces()
if count == 0 or not scanner.at_end():
return (0.0, 0.0)
let center = Length(number = 50.0, unit = Unit.percent)
var x = parts[0]
var y = center
if count == 1:
if kinds[0] == 2:
x = center
y = parts[0]
elif kinds[0] == 3 and kinds[1] == 3:
y = parts[1]
elif kinds[0] != 2 and kinds[1] != 1:
y = parts[1]
elif kinds[0] != 1 and kinds[1] != 2:
x = parts[1]
y = parts[0]
else:
return (0.0, 0.0)
return (self.resolve_length(node, Attr.width, x, false, state), self.resolve_length(node, Attr.height, y, false, state))
## Whether a transform attribute, when set, parses to an invertible transform.
func transform_valid(node: u32) -> bool:
let text = self.attribute(node, Attr.transform) else return true
let transform = parse_transform_list(text) else return true
return invertible(transform)
## Whether an element is displayed: not `display: none`, a valid transform and its
## conditional attributes passed.
func visible_element(node: u32) -> bool:
if let display = self.attribute(node, Attr.display):
if strings.trim(display) == "none":
return false
return self.transform_valid(node) and self.condition_passed(node)
# mark: Small helpers =========================================================================
## Attributes whose percentages are of the viewport's width.
func is_horizontal(name: Attr) -> bool:
return name == Attr.cx or name == Attr.dx or name == Attr.fx or name == Attr.marker_width or name == Attr.ref_x or name == Attr.rx or name == Attr.width or name == Attr.x or name == Attr.x1 or name == Attr.x2
## Attributes whose percentages are of the viewport's height.
func is_vertical(name: Attr) -> bool:
return name == Attr.cy or name == Attr.dy or name == Attr.fy or name == Attr.height or name == Attr.marker_height or name == Attr.ref_y or name == Attr.ry or name == Attr.y or name == Attr.y1 or name == Attr.y2
func invertible(m: Matrix) -> bool:
let det = m.a * m.d - m.b * m.c
return math.is_finite(det) and math.abs(det) > 1e-12 and math.is_finite(m.e) and math.is_finite(m.f)
func is_identity(m: Matrix) -> bool:
return m.a == 1.0 and m.b == 0.0 and m.c == 0.0 and m.d == 1.0 and m.e == 0.0 and m.f == 0.0
## `rect` mapped through `m`: the box round its four corners.
func transform_rect(rect: Rect, m: Matrix) -> Rect:
var box = Box()
box.add(apply(m, rect.x, rect.y))
box.add(apply(m, rect.x + rect.w, rect.y))
box.add(apply(m, rect.x, rect.y + rect.h))
box.add(apply(m, rect.x + rect.w, rect.y + rect.h))
return box.rect() else rect
## The transform taking the unit square onto `box`.
func bbox_matrix(box: Rect) -> Matrix:
return Matrix(a = box.w, d = box.h, e = box.x, f = box.y)
## A box given in fractions of `box`, in `box`'s space.
func rect_in_bbox(rect: Rect, box: Rect) -> Rect:
return Rect(x = box.x + rect.x * box.w, y = box.y + rect.y * box.h, w = rect.w * box.w, h = rect.h * box.h)
# mark: Conversion ============================================================================
## Convert `tree` into a picture with `options`.
## Convert SVG `source`, an image inside a document, into `picture` as a detached group;
## answer it with the image's size, or none when it does not parse or show.
func convert_nested(source: str, options: Options, picture: Picture*) -> (u32, Rect)?!:
var tree = Tree()
defer tree.release()
build_tree(source, &tree) catch _:
return none
let servers = try new u32[tree.nodes.used] in memory.heap
var converter = Converter(tree = &tree, picture = picture, options = options, servers = servers)
defer converter.release()
let (size, view) = converter.document_size(tree.root_element())
let group = (try converter.document_group(size, view)) else return none
return (group, size)
func convert_tree(tree: const Tree*, options: Options, picture: Picture*) -> !:
let servers = try new u32[tree.nodes.used] in memory.heap
var converter = Converter(tree = tree, picture = picture, options = options, servers = servers)
defer converter.release()
try converter.document()
extend Converter:
## The root `svg`: its size, its viewBox, and its content under the root group.
func document() -> !:
let svg = self.tree.root_element()
try self.picture.items.push(Item())
let (size, view) = self.document_size(svg)
self.picture.width = size.w
self.picture.height = size.h
if let group = try self.document_group(size, view):
self.picture.attach(0, group)
## The root `svg` drawn at `size` with `view`: a detached group, or none when it is
## not displayed.
func document_group(size: Rect, view: Rect) -> u32?!:
let svg = self.tree.root_element()
if not self.visible_element(svg):
return none
var aspect = AspectRatio()
if let text = self.attribute(svg, Attr.preserve_aspect_ratio):
aspect = parse_aspect_ratio(text) else AspectRatio()
let root_transform = view_box_transform(view, aspect, size.w, size.h)
let state = State(view_box = view)
let group = try self.picture.add_item(Item(transform = root_transform))
# resvg's non-standard background-color on the root fills the viewBox first.
if let text = self.attribute(svg, Attr.background_color):
if let color = parse_rgba(text):
var background = Path()
errdefer background.release()
try background.rect(view.x, view.y, view.w, view.h)
let index = self.picture.paths.used
try self.picture.paths.push(background)
let fill = FillPaint(brush = Brush(color = color.rgb(), opacity = color.a))
_ = try self.picture.append(group, Item(kind = ItemKind.shape, path = index, fill = fill))
try self.element(svg, &state, group)
return group
## The document's size and viewBox: width and height (100% of the viewBox, or of the
## default size without one), the missing one following the viewBox's aspect.
func document_size(svg: u32) -> (Rect, Rect):
let full = Length(number = 100.0, unit = Unit.percent)
let view = parse_view_box(self.attribute(svg, Attr.view_box) else "")
var width_length = full
var height_length = full
var has_width = false
var has_height = false
if let text = self.attribute(svg, Attr.width):
if let value = parse_length(text):
width_length = value
has_width = true
if let text = self.attribute(svg, Attr.height):
if let value = parse_length(text):
height_length = value
has_height = true
if let box = view:
let state = State(view_box = box)
let w = box.w * width_length.number / 100.0 if width_length.unit == Unit.percent else self.resolve_length(svg, Attr.width, width_length, false, &state)
let h = box.h * height_length.number / 100.0 if height_length.unit == Unit.percent else self.resolve_length(svg, Attr.height, height_length, false, &state)
var size = Rect(w = w, h = h)
if has_width and not has_height:
size = Rect(w = w, h = box.h * w / box.w)
elif has_height and not has_width:
size = Rect(w = box.w * h / box.h, h = h)
return (size, box)
let state = State(view_box = Rect(w = 100.0, h = 100.0))
var w = self.options.default_width * width_length.number / 100.0 if width_length.unit == Unit.percent else self.resolve_length(svg, Attr.width, width_length, false, &state)
var h = self.options.default_height * height_length.number / 100.0 if height_length.unit == Unit.percent else self.resolve_length(svg, Attr.height, height_length, false, &state)
if not (w > 0.0):
w = self.options.default_width
if not (h > 0.0):
h = self.options.default_height
return (Rect(w = w, h = h), Rect(w = w, h = h))
## Convert the element children of `node` into group `parent`.
func children(node: u32, state: const State*, parent: u32) -> !:
var child = self.tree.first_child(node)
while child != 0:
try self.element(child, state, parent)
child = self.tree.next_sibling(child)
## Convert one element into group `parent`.
func element(node: u32, state: const State*, parent: u32) -> !:
if not self.tree.is_element(node):
return
let tag = self.tree.tag(node)
if not (is_graphic(tag) or tag == Tag.g or tag == Tag.switch or tag == Tag.svg):
return
if not self.visible_element(node):
return
if tag == Tag.use:
try self.use_element(node, state, parent)
return
if tag == Tag.switch:
try self.switch_element(node, state, parent)
return
if tag == Tag.svg and self.tree.parent_element(node) != none:
try self.nested_svg(node, state, parent)
return
let group = try self.open_group(node, state, parent)
try self.content(node, tag, state, group)
try self.close_group(node, state, parent, group, false)
## The content of `node` itself, into `group`.
func content(node: u32, tag: Tag, state: const State*, group: u32) -> !:
if is_shape_tag(tag):
if let path = try self.shape_path(node, tag, state):
try self.shape(node, path, state, group)
elif tag == Tag.image:
try self.image_element(node, state, group)
elif tag == Tag.text:
try self.text_element(node, state, group)
elif tag == Tag.g or tag == Tag.svg:
if state.clip_child:
try self.clip_children(node, state, group)
else:
try self.children(node, state, group)
# mark: Groups ==============================================================================
## Start the group `node` would make, detached until close_group decides its fate.
func open_group(node: u32, state: const State*, parent: u32) -> u32!:
var item = Item(transform = self.transform_of(node, Attr.transform, state))
if not state.clip_child:
item.opacity = self.opacity(node, Attr.opacity, 1.0)
item.blend = blend_mode(self.attribute(node, Attr.mix_blend_mode) else "normal")
item.isolate = (self.attribute(node, Attr.isolation) else "") == "isolate"
let group = try self.picture.add_item(item)
self.picture.items.items[group].parent = parent
return group
## Finish group `group` of `node`: give it the clip path, mask and filters its
## element asks for (which may hide it), then attach it to `parent` when it needs to
## be a group, else hand its children to `parent`. `force` keeps it a group.
func close_group(node: u32, state: const State*, parent: u32, group: u32, force: bool) -> !:
let object_box = self.object_bounds(group)
let tag = self.tree.tag(node)
var clip: usize = 0
if let link = self.link_attribute(node, Attr.clip_path):
if not self.entered(link):
clip = try self.clip_path(link, state, object_box)
if clip == 0:
return
var mask: usize = 0
if not state.clip_child:
if let link = self.link_attribute(node, Attr.mask):
if not self.entered(link):
mask = try self.mask_element(link, state, object_box)
if mask == 0:
return
var filter_ok = true
if not state.clip_child:
filter_ok = try self.filters(node, state, object_box, group)
if not filter_ok:
return
let item = self.picture.items.items[group]
let required = item.opacity != 1.0 or clip != 0 or mask != 0 or item.filter_count > 0 or not is_identity(item.transform) or item.blend != Blend.normal or item.isolate or tag == Tag.g or tag == Tag.use or force
if not required:
self.picture.adopt_children(group, parent)
return
self.picture.items.items[group].clip = clip
self.picture.items.items[group].mask = mask
self.picture.attach(parent, group)
## The element a clip-path, mask or filter attribute links to, if it links to one.
func link_attribute(node: u32, name: Attr) -> u32?:
let text = self.attribute(node, name) else return none
if strings.trim(text) == "none":
return none
let id = func_iri(text) else return none
return self.tree.element_by_id(id)
## The union of the children's bounding boxes, in the group's own space.
func object_bounds(group: u32) -> Rect?:
# A text's group carries its text box (advances by face heights).
if let known = self.picture.items.items[group].box:
return known
var box = Box()
var child = self.picture.items.items[group].first
while child != 0:
if let r = self.item_bounds(child):
box.add_rect(r)
child = self.picture.items.items[child].next
return box.rect()
## An item's bounding box in its parent's space.
func item_bounds(index: u32) -> Rect?:
let item = self.picture.items.items[index]
match item.kind:
.shape:
return self.picture.paths.items[item.path].bounds()
.image:
return item.view
.group:
var inner = item.box
if inner == none:
inner = self.object_bounds(index)
let found = inner else return none
return transform_rect(found, item.transform)
## Whether a tag is drawn by itself (or, for `use`, by what it references).
func is_graphic(tag: Tag) -> bool:
return is_shape_tag(tag) or tag == Tag.image or tag == Tag.text or tag == Tag.use
func is_shape_tag(tag: Tag) -> bool:
return tag == Tag.rect or tag == Tag.circle or tag == Tag.ellipse or tag == Tag.line or tag == Tag.polyline or tag == Tag.polygon or tag == Tag.path
## A mix-blend-mode value.
func blend_mode(text: str) -> Blend:
let names: str[16] = ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn",
"hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity"]
let modes: Blend[16] = [Blend.normal, Blend.multiply, Blend.screen, Blend.overlay, Blend.darken, Blend.lighten,
Blend.color_dodge, Blend.color_burn, Blend.hard_light, Blend.soft_light, Blend.difference,
Blend.exclusion, Blend.hue, Blend.saturation, Blend.color, Blend.luminosity]
let value = strings.trim(text)
for index in 0..<names.length:
if value == names[index]:
return modes[index]
return Blend.normal