dymokomi/luce-svg
Source of release 0.9.2
0.9.2 / src / svg / convert_fe.lucb
#==============================================================================================
#
# svg/convert_fe - Each filter primitive's parameters
#
# DESCRIPTION:
# Reads the attributes of every primitive resvg renders — feBlend, feColorMatrix,
# feComponentTransfer, feComposite, feConvolveMatrix, feDisplacementMap,
# feDropShadow, feFlood, feGaussianBlur, feImage, feMerge, feMorphology, feOffset,
# feTile, feTurbulence and the two lighting primitives with their light sources —
# with usvg's defaults, clamps and fallbacks (an invalid convolution or lighting
# primitive becomes a transparent flood).
#
#==============================================================================================
extend Converter:
## Fill in `primitive` for element `fe` (`tag`); false when it is not a primitive.
func primitive_kind(fe: u32, tag: Tag, sx: f64, sy: f64, state: const State*, names: const ResultName[], index: usize,
primitive: Primitive*) -> bool!:
match tag:
.fe_blend:
primitive.kind = FilterKind.blend
primitive.blend = blend_mode(self.attribute(fe, Attr.mode) else "normal")
.fe_flood:
primitive.kind = FilterKind.flood
primitive.color = self.flood_color(fe)
.fe_offset:
primitive.kind = FilterKind.offset
primitive.values[0] = self.fe_number(fe, Attr.dx, 0.0) * sx
primitive.values[1] = self.fe_number(fe, Attr.dy, 0.0) * sy
.fe_gaussian_blur, .fe_drop_shadow:
let default = "2 2" if tag == Tag.fe_drop_shadow else "0 0"
var deviation: f64[3] = [0.0, 0.0, 0.0]
var count: usize = 0
if self.has(fe, Attr.std_deviation):
count = self.number_list(fe, Attr.std_deviation, deviation, 3) else 0
else:
var scanner = Scanner(data = default.bytes)
deviation[0] = scanner.list_number() else 0.0
deviation[1] = scanner.list_number() else 0.0
count = 2
var x = 0.0
var y = 0.0
if count == 1:
x = deviation[0]
y = deviation[0]
elif count == 2:
x = deviation[0]
y = deviation[1]
if tag == Tag.fe_gaussian_blur:
primitive.kind = FilterKind.blur
primitive.values[0] = math.max(0.0, x * sx)
primitive.values[1] = math.max(0.0, y * sy)
else:
primitive.kind = FilterKind.drop_shadow
primitive.values[0] = self.fe_number(fe, Attr.dx, 2.0) * sx
primitive.values[1] = self.fe_number(fe, Attr.dy, 2.0) * sy
primitive.values[2] = math.max(0.0, x * sx)
primitive.values[3] = math.max(0.0, y * sy)
primitive.color = self.flood_color(fe)
.fe_composite:
primitive.kind = FilterKind.composite
let operator = strings.trim(self.attribute(fe, Attr.operator) else "over")
let operators: str[5] = ["in", "out", "atop", "xor", "arithmetic"]
for at in 0..<operators.length:
if operator == operators[at]:
primitive.values[0] = (f64)(at + 1)
primitive.values[1] = self.fe_number(fe, Attr.k1, 0.0)
primitive.values[2] = self.fe_number(fe, Attr.k2, 0.0)
primitive.values[3] = self.fe_number(fe, Attr.k3, 0.0)
primitive.values[4] = self.fe_number(fe, Attr.k4, 0.0)
.fe_merge:
primitive.kind = FilterKind.merge
primitive.start = self.picture.filter_inputs.used
var node = self.tree.first_child(fe)
while node != 0:
if self.tree.is_element(node):
try self.picture.filter_inputs.push(self.filter_input(node, Attr.input, names, index))
node = self.tree.next_sibling(node)
primitive.count = self.picture.filter_inputs.used - primitive.start
.fe_tile:
primitive.kind = FilterKind.tile
.fe_color_matrix:
try self.color_matrix(fe, primitive)
.fe_component_transfer:
primitive.kind = FilterKind.component_transfer
var node = self.tree.first_child(fe)
while node != 0:
if self.tree.is_element(node):
let channel_tag = self.tree.tag(node)
var channel: usize = 4
if channel_tag == Tag.fe_func_r:
channel = 0
elif channel_tag == Tag.fe_func_g:
channel = 1
elif channel_tag == Tag.fe_func_b:
channel = 2
elif channel_tag == Tag.fe_func_a:
channel = 3
if channel < 4:
if let function = try self.transfer_function(node):
primitive.functions[channel] = function
node = self.tree.next_sibling(node)
.fe_morphology:
primitive.kind = FilterKind.morphology
primitive.values[0] = 1.0 if strings.trim(self.attribute(fe, Attr.operator) else "") == "dilate" else 0.0
primitive.values[1] = sx
primitive.values[2] = sy
var radius: f64[2] = [0.0, 0.0]
if let count = self.number_list(fe, Attr.radius, radius, 2):
var rx = 0.0
var ry = 0.0
if count == 2:
rx = radius[0]
ry = radius[1]
elif count == 1:
rx = radius[0]
ry = radius[0]
if rx == 0.0 and ry == 0.0:
rx = 1.0
ry = 1.0
if rx == 0.0:
rx = 1.0
if ry == 0.0:
ry = 1.0
if rx > 0.0 and ry > 0.0:
primitive.values[1] = rx * sx
primitive.values[2] = ry * sy
.fe_displacement_map:
primitive.kind = FilterKind.displacement
primitive.values[0] = self.fe_number(fe, Attr.scale, 0.0) * (sx + sy) * 0.5
primitive.values[1] = channel_of(self.attribute(fe, Attr.x_channel_selector) else "A")
primitive.values[2] = channel_of(self.attribute(fe, Attr.y_channel_selector) else "A")
.fe_turbulence:
primitive.kind = FilterKind.turbulence
var frequency: f64[2] = [0.0, 0.0]
if let count = self.number_list(fe, Attr.base_frequency, frequency, 2):
var x = 0.0
var y = 0.0
if count == 2:
x = frequency[0]
y = frequency[1]
elif count == 1:
x = frequency[0]
y = frequency[0]
if x >= 0.0 and y >= 0.0:
primitive.values[0] = x
primitive.values[1] = y
primitive.values[2] = math.round(math.max(0.0, self.fe_number(fe, Attr.num_octaves, 1.0)))
primitive.values[3] = math.trunc(self.fe_number(fe, Attr.seed, 0.0))
primitive.values[4] = 1.0 if strings.trim(self.attribute(fe, Attr.stitch_tiles) else "") == "stitch" else 0.0
primitive.values[5] = 1.0 if strings.trim(self.attribute(fe, Attr.kind) else "") == "fractalNoise" else 0.0
.fe_convolve_matrix:
if not try self.convolve(fe, primitive):
transparent_flood(primitive)
.fe_diffuse_lighting, .fe_specular_lighting:
if not self.lighting(fe, tag, primitive):
transparent_flood(primitive)
.fe_image:
try self.fe_image(fe, state, primitive)
_:
return false
return true
## flood-color with flood-opacity (black and 1 by default).
func flood_color(fe: u32) -> Rgba:
var color = Rgba()
if let text = self.attribute(fe, Attr.flood_color):
if strings.trim(text) == "currentColor":
color = parse_rgba(self.find(fe, Attr.color) else "black") else Rgba()
else:
color = parse_rgba(text) else Rgba()
color.a *= self.opacity(fe, Attr.flood_opacity, 1.0)
return color
func color_matrix(fe: u32, primitive: Primitive*) -> !:
primitive.kind = FilterKind.color_matrix
let kind = strings.trim(self.attribute(fe, Attr.kind) else "matrix")
var first: f64[1] = [0.0]
let count = self.number_list(fe, Attr.values, first, 1)
if kind == "saturate":
if let n = count:
primitive.values[0] = 1.0
primitive.values[1] = math.clamp(first[0], 0.0, 1.0) if n > 0 else 1.0
return
elif kind == "hueRotate":
if let n = count:
primitive.values[0] = 2.0
primitive.values[1] = first[0] if n > 0 else 0.0
return
elif kind == "luminanceToAlpha":
primitive.values[0] = 3.0
return
else:
if let found_list = try self.value_list(fe, Attr.values):
let start = found_list.0
let length = found_list.1
if length == 20:
primitive.start = start
primitive.count = 20
return
self.picture.filter_values.truncate(start)
# Anything else is the identity matrix.
let start = self.picture.filter_values.used
let unit_matrix: f64[20] = [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0]
for value in unit_matrix:
try self.picture.filter_values.push(value)
primitive.values[0] = 0.0
primitive.start = start
primitive.count = 20
## A feFuncX element's function, or none for an unknown type.
func transfer_function(node: u32) -> TransferFn?!:
let kind = strings.trim(self.attribute(node, Attr.kind) else return none)
if kind == "identity":
return TransferFn()
if kind == "table" or kind == "discrete":
var function = TransferFn(kind = 1 if kind == "table" else 2)
if let found_list = try self.value_list(node, Attr.table_values):
let start = found_list.0
let count = found_list.1
function.start = start
function.count = count
return function
if kind == "linear":
return TransferFn(kind = 3, a = self.fe_number(node, Attr.slope, 1.0), b = self.fe_number(node, Attr.intercept, 0.0))
if kind == "gamma":
return TransferFn(kind = 4, a = self.fe_number(node, Attr.amplitude, 1.0), b = self.fe_number(node, Attr.exponent, 1.0),
c = self.fe_number(node, Attr.offset, 0.0))
return none
## feConvolveMatrix's kernel and options; false when they are invalid.
func convolve(fe: u32, primitive: Primitive*) -> bool!:
primitive.kind = FilterKind.convolve
var columns = 3.0
var rows = 3.0
var order: f64[2] = [0.0, 0.0]
if let count = self.number_list(fe, Attr.order, order, 2):
let x = math.trunc(order[0]) if count >= 1 else 3.0
let y = math.trunc(order[1]) if count >= 2 else x
if x > 0.0 and y > 0.0:
columns = x
rows = y
var sum = 0.0
primitive.start = self.picture.filter_values.used
primitive.count = 0
if let found_list = try self.value_list(fe, Attr.kernel_matrix):
let start = found_list.0
let count = found_list.1
if (f64)count == columns * rows:
primitive.start = start
primitive.count = count
for at in start..<start + count:
sum += self.picture.filter_values.items[at]
else:
self.picture.filter_values.truncate(start)
if primitive.count == 0:
return false
sum = math.round(sum * 1000000.0) / 1000000.0
if sum == 0.0:
sum = 1.0
let divisor = self.fe_number(fe, Attr.divisor, sum)
if divisor == 0.0:
return false
let target_x = math.trunc(self.fe_number(fe, Attr.target_x, math.floor(columns / 2.0)))
let target_y = math.trunc(self.fe_number(fe, Attr.target_y, math.floor(rows / 2.0)))
if target_x < 0.0 or target_x >= columns or target_y < 0.0 or target_y >= rows:
return false
let edge = strings.trim(self.attribute(fe, Attr.edge_mode) else "duplicate")
primitive.values = [columns, rows, target_x, target_y, divisor, self.fe_number(fe, Attr.bias, 0.0),
1.0 if edge == "wrap" else (2.0 if edge == "none" else 0.0),
1.0 if strings.trim(self.attribute(fe, Attr.preserve_alpha) else "false") == "true" else 0.0]
return true
## A lighting primitive's parameters and light; false when it has none or an
## out-of-range exponent.
func lighting(fe: u32, tag: Tag, primitive: Primitive*) -> bool:
var light_node: u32 = 0
var child = self.tree.first_child(fe)
while child != 0:
if self.tree.is_element(child):
let child_tag = self.tree.tag(child)
if child_tag == Tag.fe_distant_light or child_tag == Tag.fe_point_light or child_tag == Tag.fe_spot_light:
light_node = child
break
child = self.tree.next_sibling(child)
if light_node == 0:
return false
let light_tag = self.tree.tag(light_node)
var light = Light()
if light_tag == Tag.fe_distant_light:
light.values[0] = self.fe_number(light_node, Attr.azimuth, 0.0)
light.values[1] = self.fe_number(light_node, Attr.elevation, 0.0)
else:
light.kind = 1 if light_tag == Tag.fe_point_light else 2
light.values[0] = self.fe_number(light_node, Attr.x, 0.0)
light.values[1] = self.fe_number(light_node, Attr.y, 0.0)
light.values[2] = self.fe_number(light_node, Attr.z, 0.0)
if light.kind == 2:
light.values[3] = self.fe_number(light_node, Attr.points_at_x, 0.0)
light.values[4] = self.fe_number(light_node, Attr.points_at_y, 0.0)
light.values[5] = self.fe_number(light_node, Attr.points_at_z, 0.0)
let exponent = self.fe_number(light_node, Attr.specular_exponent, 1.0)
light.values[6] = exponent if exponent > 0.0 else 1.0
if let cone = parse_number(self.attribute(light_node, Attr.limiting_cone_angle) else ""):
light.values[7] = cone
light.cone = true
primitive.light = light
primitive.values[0] = self.fe_number(fe, Attr.surface_scale, 1.0)
primitive.color = self.lighting_color(fe)
if tag == Tag.fe_diffuse_lighting:
primitive.kind = FilterKind.diffuse
primitive.values[1] = self.fe_number(fe, Attr.diffuse_constant, 1.0)
else:
primitive.kind = FilterKind.specular
primitive.values[1] = self.fe_number(fe, Attr.specular_constant, 1.0)
let exponent = self.fe_number(fe, Attr.specular_exponent, 1.0)
if exponent < 1.0 or exponent > 128.0:
return false
primitive.values[2] = exponent
return true
## lighting-color: white by default, its own opacity dropped.
func lighting_color(fe: u32) -> Rgba:
let text = strings.trim(self.attribute(fe, Attr.lighting_color) else return Rgba(r = 1.0, g = 1.0, b = 1.0))
if text == "currentColor":
var color = parse_rgba(self.find(fe, Attr.color) else "black") else Rgba()
color.a = 1.0
return color
var color = parse_rgba(text) else Rgba(r = 1.0, g = 1.0, b = 1.0)
color.a = 1.0
return color
extend Converter:
## feImage: an element of the document, or an image fitted into the subregion; its
## content is drawn at the subregion's corner.
func fe_image(fe: u32, state: const State*, primitive: Primitive*) -> !:
primitive.kind = FilterKind.image
let root = try self.picture.add_item(Item())
primitive.root = root
let href = strings.trim(self.attribute(fe, Attr.href) else "")
if let id = iri(href):
if let link = self.tree.element_by_id(id):
try self.element(link, state, root)
return
let loaded = (try self.load_image(fe)) else return
try self.fit_image(fe, loaded.0, loaded.1, Rect(w = primitive.rect.w, h = primitive.rect.h), root)
## Make `primitive` a transparent flood, what an invalid primitive draws.
func transparent_flood(primitive: Primitive*):
primitive.kind = FilterKind.flood
primitive.color = Rgba(a = 0.0)
## A channel selector: R 0, G 1, B 2, anything else A 3.
func channel_of(text: str) -> f64:
let value = strings.trim(text)
if value == "R": return 0.0
if value == "G": return 1.0
if value == "B": return 2.0
return 3.0