Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-svg

Source of release 0.9.2

0.9.2 / src / svg / convert_filter.lucb

#==============================================================================================
#
#   svg/convert_filter - Filters: the `filter` property and filter elements
#
#   DESCRIPTION:
#       `filter` is a list of filter functions (blur, drop-shadow, brightness, contrast,
#       grayscale, hue-rotate, invert, opacity, saturate, sepia), each one primitive over
#       a region round the element's box, and `url(#id)` references to filter
#       elements. A filter element (its attributes and primitives possibly inherited
#       through `href`) has a region in its filterUnits and primitives whose subregions
#       and lengths are in its primitiveUnits; each primitive reads its inputs by
#       result name. An unreadable list means no filter; a list of only broken
#       references hides the element. As resvg's usvg converts them.
#
#==============================================================================================

extend Converter:
    ## Give `group` the filters `node` asks for; false when they hide it.
    func filters(node: u32, state: const State*, object_box: Rect?, group: u32) -> bool!:
        let text = self.attribute(node, Attr.filter) else return true
        if strings.trim(text) == "none":
            return true
        let start = self.picture.filters.used
        var broken_link = false
        var scanner = Scanner(data = text.bytes)
        while true:
            scanner.skip_spaces()
            if scanner.at_end():
                break
            let name = scanner.identifier()
            scanner.skip_spaces()
            if scanner.peek() != '(':
                self.picture.filters.truncate(start)
                return true
            scanner.pos += 1
            scanner.skip_spaces()
            if name == "url":
                if scanner.peek() != '#':
                    self.picture.filters.truncate(start)
                    return true
                scanner.pos += 1
                let id_start = scanner.pos
                while not scanner.at_end() and scanner.peek() != ' ' and scanner.peek() != ')':
                    scanner.pos += 1
                let id = (str)scanner.data[id_start..<scanner.pos]
                scanner.skip_spaces()
                if scanner.peek() != ')' or id.length == 0:
                    self.picture.filters.truncate(start)
                    return true
                scanner.pos += 1
                if let link = self.tree.element_by_id(id):
                    # A filter whose feImage draws this element again is ignored.
                    if not self.entered(link):
                        if not try self.filter_element(link, state, object_box):
                            broken_link = true
                else:
                    broken_link = true
                continue
            let ok = try self.filter_function(node, name, &scanner, state, object_box)
            if not ok:
                self.picture.filters.truncate(start)
                return true
        let count = self.picture.filters.used - start
        if count == 0 and broken_link:
            return false
        self.picture.items.items[group].filter_start = start
        self.picture.items.items[group].filter_count = count
        return true

    ## Read one filter function after its `(` and add it as a filter; false when it does
    ## not parse (the whole list is then ignored).
    func filter_function(node: u32, name: str, scanner: Scanner*, state: const State*, object_box: Rect?) -> bool!:
        var primitive = Primitive(linear = false)
        var region = Rect(x = -0.1, y = -0.1, w = 1.2, h = 1.2)
        if name == "blur" or name == "drop-shadow":
            region = Rect(x = -0.5, y = -0.5, w = 2.0, h = 2.0)
        if name == "blur":
            primitive.kind = FilterKind.blur
            var deviation = 0.0
            if scanner.peek() != ')':
                let value = scanner.length() else return false
                if value.number < 0.0 or value.unit == Unit.percent:
                    return false
                deviation = self.resolve_length(node, Attr.dx, value, false, state)
            primitive.values[0] = math.max(0.0, deviation)
            primitive.values[1] = math.max(0.0, deviation)
        elif name == "drop-shadow":
            if scanner.peek() == ')':
                return false
            primitive.kind = FilterKind.drop_shadow
            var color: Rgba? = try_color(scanner)
            var current = false
            if color == none and scanner.starts_with("currentColor"):
                scanner.pos += 12
                current = true
            scanner.skip_spaces()
            let dx = scanner.length() else return false
            scanner.skip_spaces()
            let dy = scanner.length() else return false
            if dx.unit == Unit.percent or dy.unit == Unit.percent:
                return false
            scanner.skip_spaces()
            var deviation = 0.0
            let before = scanner.pos
            if let value = scanner.length():
                if value.number >= 0.0 and value.unit != Unit.percent:
                    deviation = self.resolve_length(node, Attr.dx, value, false, state)
                else:
                    scanner.pos = before
            scanner.skip_spaces()
            if color == none and not current:
                color = try_color(scanner)
                if color == none and scanner.starts_with("currentColor"):
                    scanner.pos += 12
            let found = color else parse_rgba(self.find(node, Attr.color) else "black") else Rgba()
            primitive.color = found
            primitive.values = [self.resolve_length(node, Attr.dx, dx, false, state), self.resolve_length(node, Attr.dy, dy, false, state),
                                deviation, deviation, 0.0, 0.0, 0.0, 0.0]
        elif name == "hue-rotate":
            primitive.kind = FilterKind.color_matrix
            primitive.values[0] = 2.0
            if scanner.peek() != ')':
                let value = scanner.number() else return false
                var degrees = value
                if scanner.starts_with("deg"):
                    scanner.pos += 3
                elif scanner.starts_with("grad"):
                    scanner.pos += 4
                    degrees = value * 0.9
                elif scanner.starts_with("rad"):
                    scanner.pos += 3
                    degrees = value * 180.0 / math.pi
                elif scanner.starts_with("turn"):
                    scanner.pos += 4
                    degrees = value * 360.0
                elif value != 0.0:
                    return false
                primitive.values[1] = degrees
        else:
            var amount = 1.0
            if scanner.peek() != ')':
                let value = scanner.number() else return false
                amount = value
                if scanner.peek() == '%':
                    scanner.pos += 1
                    amount = value / 100.0
                if amount < 0.0:
                    return false
            if not try self.color_function(name, amount, &primitive):
                return false
        scanner.skip_spaces()
        if scanner.peek() != ')':
            return false
        scanner.pos += 1
        let box = object_box else return true
        let rect = rect_in_bbox(region, box)
        primitive.rect = rect
        let at = self.picture.primitives.used
        try self.picture.primitives.push(primitive)
        try self.picture.filters.push(FilterServer(rect = rect, primitive_start = at, primitive_count = 1))
        return true

    ## brightness, contrast, grayscale, invert, opacity, saturate and sepia as
    ## primitives; false for an unknown name.
    func color_function(name: str, amount: f64, primitive: Primitive*) -> bool!:
        let a = math.min(amount, 1.0)
        if name == "brightness" or name == "contrast":
            primitive.kind = FilterKind.component_transfer
            let intercept = 0.0 if name == "brightness" else 0.5 - 0.5 * amount
            for channel in 0..<(usize)3:
                primitive.functions[channel] = TransferFn(kind = 3, a = amount, b = intercept)
        elif name == "invert" or name == "opacity":
            primitive.kind = FilterKind.component_transfer
            let start = self.picture.filter_values.used
            if name == "invert":
                try self.picture.filter_values.push(a)
                try self.picture.filter_values.push(1.0 - a)
                for channel in 0..<(usize)3:
                    primitive.functions[channel] = TransferFn(kind = 1, start = start, count = 2)
            else:
                try self.picture.filter_values.push(0.0)
                try self.picture.filter_values.push(a)
                primitive.functions[3] = TransferFn(kind = 1, start = start, count = 2)
        elif name == "saturate":
            primitive.kind = FilterKind.color_matrix
            primitive.values[0] = 1.0
            primitive.values[1] = math.max(0.0, amount)
        elif name == "grayscale" or name == "sepia":
            primitive.kind = FilterKind.color_matrix
            let start = self.picture.filter_values.used
            let k = 1.0 - a
            var m: f64[20] = [0.2126 + 0.7874 * k, 0.7152 - 0.7152 * k, 0.0722 - 0.0722 * k, 0.0, 0.0,
                              0.2126 - 0.2126 * k, 0.7152 + 0.2848 * k, 0.0722 - 0.0722 * k, 0.0, 0.0,
                              0.2126 - 0.2126 * k, 0.7152 - 0.7152 * k, 0.0722 + 0.9278 * k, 0.0, 0.0,
                              0.0, 0.0, 0.0, 1.0, 0.0]
            if name == "sepia":
                m = [0.393 + 0.607 * k, 0.769 - 0.769 * k, 0.189 - 0.189 * k, 0.0, 0.0,
                     0.349 - 0.349 * k, 0.686 + 0.314 * k, 0.168 - 0.168 * k, 0.0, 0.0,
                     0.272 - 0.272 * k, 0.534 - 0.534 * k, 0.131 + 0.869 * k, 0.0, 0.0,
                     0.0, 0.0, 0.0, 1.0, 0.0]
            for value in m:
                try self.picture.filter_values.push(value)
            primitive.start = start
            primitive.count = 20
        else:
            return false
        return true

## A color at the scanner, which moves past it only when one is there.
func try_color(scanner: Scanner*) -> Rgba?:
    let saved = scanner.pos
    if let color = scan_color(scanner):
        return color
    scanner.pos = saved
    return none