dymokomi/luce-svg
Source of release 0.9.1
0.9.1 / src / svg / convert_primitive.lucb
#==============================================================================================
#
# svg/convert_primitive - Filter elements and their primitives
#
# DESCRIPTION:
# A filter element's region (filterUnits, -10%/120% by default) and its
# primitives, from the first filter in its `href` chain that has any. Each
# primitive's subregion defaults to the filter region (feFlood and feImage in
# bounding-box units default to the box); its inputs resolve by result name to an
# earlier primitive, an unknown name to the one just before, a missing `in` too,
# and the first primitive's to the source graphic. Numbers follow usvg's
# defaults and limits, scaled by the box with primitiveUnits objectBoundingBox.
#
#==============================================================================================
## A primitive's result name and its index within its filter.
struct ResultName:
var name: str = ""
var index: usize = 0
extend Converter:
## Add the filter element `node` for an element with `object_box`; false when it is
## not a usable filter.
func filter_element(node: u32, state: const State*, object_box: Rect?) -> bool!:
if self.tree.tag(node) != Tag.filter:
return false
let units_source = self.filter_source(node, Attr.filter_units)
let bbox_units = strings.trim(self.attribute(units_source, Attr.filter_units) else "") != "userSpaceOnUse"
let primitive_source = self.filter_source(node, Attr.primitive_units)
let primitive_bbox = strings.trim(self.attribute(primitive_source, Attr.primitive_units) else "") == "objectBoundingBox"
var rect = Rect(x = self.length(self.filter_source(node, Attr.x), Attr.x, bbox_units, state, Length(number = -10.0, unit = Unit.percent)),
y = self.length(self.filter_source(node, Attr.y), Attr.y, bbox_units, state, Length(number = -10.0, unit = Unit.percent)),
w = self.length(self.filter_source(node, Attr.width), Attr.width, bbox_units, state, Length(number = 120.0, unit = Unit.percent)),
h = self.length(self.filter_source(node, Attr.height), Attr.height, bbox_units, state, Length(number = 120.0, unit = Unit.percent)))
if not (rect.w > 0.0) or not (rect.h > 0.0):
return false
if bbox_units:
let box = object_box else return false
rect = rect_in_bbox(rect, box)
let holder = self.filter_holder(node) else return false
let start = self.picture.primitives.used
try self.active.push(node)
defer self.active.used -= 1
try self.primitives(holder, primitive_bbox, state, object_box, rect)
let count = self.picture.primitives.used - start
if count == 0:
return false
try self.picture.filters.push(FilterServer(rect = rect, primitive_start = start, primitive_count = count))
return true
## The filter in `node`'s href chain that sets `name`, else `node`.
func filter_source(node: u32, name: Attr) -> u32:
var at = node
for _ in 0..<64:
if self.has(at, name):
return at
let next = self.tree.linked(at, Attr.href) else return node
if next == at or next == node or self.tree.tag(next) != Tag.filter:
return node
at = next
return node
## The first filter in `node`'s href chain with children, or none.
func filter_holder(node: u32) -> u32?:
var at = node
for _ in 0..<64:
if self.tree.tag(at) != Tag.filter:
return none
if self.tree.first_element_child(at) != 0:
return at
let next = self.tree.linked(at, Attr.href) else return none
if next == at or next == node:
return none
at = next
return none
## Convert the primitives of filter `holder` into the picture.
func primitives(holder: u32, bbox_units: bool, state: const State*, object_box: Rect?, region: Rect) -> !:
var names = List[ResultName]()
defer names.release()
var sx = 1.0
var sy = 1.0
if bbox_units:
let box = object_box else return
sx = box.w
sy = box.h
let start = self.picture.primitives.used
var child = self.tree.first_child(holder)
while child != 0:
let fe = child
child = self.tree.next_sibling(child)
if not self.tree.is_element(fe):
continue
let tag = self.tree.tag(fe)
let subregion = self.subregion(fe, tag, bbox_units, state, object_box, region) else break
let index = self.picture.primitives.used - start
var primitive = Primitive(rect = subregion)
let interpolation = strings.trim(self.find(fe, Attr.color_interpolation_filters) else "linearRGB")
primitive.linear = interpolation != "sRGB"
primitive.input1 = self.filter_input(fe, Attr.input, names.view(), index)
primitive.input2 = self.filter_input(fe, Attr.in2, names.view(), index)
if not try self.primitive_kind(fe, tag, sx, sy, state, names.view(), index, &primitive):
continue
try self.picture.primitives.push(primitive)
if let name = self.attribute(fe, Attr.result):
try names.push(ResultName(name = name, index = index))
## A primitive's subregion in user space, or none when it is empty.
func subregion(fe: u32, tag: Tag, bbox_units: bool, state: const State*, object_box: Rect?, region: Rect) -> Rect?:
let x = self.optional_length(fe, Attr.x, bbox_units, state)
let y = self.optional_length(fe, Attr.y, bbox_units, state)
let w = self.optional_length(fe, Attr.width, bbox_units, state)
let h = self.optional_length(fe, Attr.height, bbox_units, state)
var base = region
if (tag == Tag.fe_flood or tag == Tag.fe_image) and bbox_units:
let box = object_box else return none
let r = Rect(x = x else 0.0, y = y else 0.0, w = w else 1.0, h = h else 1.0)
if not (r.w > 0.0) or not (r.h > 0.0):
return none
return rect_in_bbox(r, box)
if bbox_units:
let r = Rect(x = x else 0.0, y = y else 0.0, w = w else 1.0, h = h else 1.0)
if not (r.w > 0.0) or not (r.h > 0.0):
return none
# As usvg computes it: the region placed by the subregion's fractions.
return rect_in_bbox(base, r)
let result = Rect(x = x else base.x, y = y else base.y, w = w else base.w, h = h else base.h)
if not (result.w > 0.0) or not (result.h > 0.0):
return none
return result
## A length attribute when it is set and readable.
func optional_length(node: u32, name: Attr, bbox_units: bool, state: const State*) -> f64?:
let text = self.attribute(node, name) else return none
let value = parse_length(text) else return none
return self.resolve_length(node, name, value, bbox_units, state)
## The input `in` or `in2` names: a source, an earlier result, else the previous
## primitive's result (the source graphic for the first).
func filter_input(fe: u32, name: Attr, names: const ResultName[], index: usize) -> FilterInput:
let previous = FilterInput(source = 2, result = index - 1) if index > 0 else FilterInput()
let text = strings.trim(self.attribute(fe, name) else return previous)
if text == "SourceGraphic" or text == "BackgroundImage" or text == "BackgroundAlpha" or text == "FillPaint" or text == "StrokePaint":
return FilterInput()
if text == "SourceAlpha":
return FilterInput(source = 1)
var at = names.length
while at > 0:
at -= 1
if names[at].name == text:
return FilterInput(source = 2, result = names[at].index)
return previous
## A number attribute of a primitive, else `default`.
func fe_number(fe: u32, name: Attr, default: f64) -> f64:
return parse_number(self.attribute(fe, name) else "") else default
## Up to `most` numbers of a list attribute into `out`; how many, or none when the
## attribute is absent or unreadable.
func number_list(fe: u32, name: Attr, out: f64[], most: usize) -> usize?:
let text = self.attribute(fe, name) else return none
var scanner = Scanner(data = text.bytes)
var count: usize = 0
while true:
scanner.skip_spaces()
if scanner.at_end():
break
let value = scanner.list_number() else return none
if count < most:
out[count] = value
count += 1
return count
## Push a list attribute's numbers to the picture's filter values: (start, count),
## or none when it is unreadable.
func value_list(fe: u32, name: Attr) -> (usize, usize)?!:
let text = self.attribute(fe, name) else return none
let start = self.picture.filter_values.used
var scanner = Scanner(data = text.bytes)
while true:
scanner.skip_spaces()
if scanner.at_end():
break
if let value = scanner.list_number():
try self.picture.filter_values.push(value)
else:
self.picture.filter_values.truncate(start)
return none
return (start, self.picture.filter_values.used - start)